1 /* readelf.c -- display contents of an ELF format file
2 Copyright (C) 1998-2020 Free Software Foundation, Inc.
4 Originally developed by Eric Youngdale <eric@andante.jic.com>
5 Modifications by Nick Clifton <nickc@redhat.com>
7 This file is part of GNU Binutils.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
24 /* The difference between readelf and objdump:
26 Both programs are capable of displaying the contents of ELF format files,
27 so why does the binutils project have two file dumpers ?
29 The reason is that objdump sees an ELF file through a BFD filter of the
30 world; if BFD has a bug where, say, it disagrees about a machine constant
31 in e_flags, then the odds are good that it will remain internally
32 consistent. The linker sees it the BFD way, objdump sees it the BFD way,
33 GAS sees it the BFD way. There was need for a tool to go find out what
34 the file actually says.
36 This is why the readelf program does not link against the BFD library - it
37 exists as an independent program to help verify the correct working of BFD.
39 There is also the case that readelf can provide more information about an
40 ELF file than is provided by objdump. In particular it can display DWARF
41 debugging information which (at the moment) objdump cannot. */
52 /* Define BFD64 here, even if our default architecture is 32 bit ELF
53 as this will allow us to read in and parse 64bit and 32bit ELF files.
54 Only do this if we believe that the compiler can support a 64 bit
55 data type. For now we only rely on GCC being able to do this. */
66 #include "elf/common.h"
67 #include "elf/external.h"
68 #include "elf/internal.h"
71 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
72 we can obtain the H8 reloc numbers. We need these for the
73 get_reloc_size() function. We include h8.h again after defining
74 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
79 /* Undo the effects of #including reloc-macros.h. */
81 #undef START_RELOC_NUMBERS
85 #undef END_RELOC_NUMBERS
86 #undef _RELOC_MACROS_H
88 /* The following headers use the elf/reloc-macros.h file to
89 automatically generate relocation recognition functions
90 such as elf_mips_reloc_type() */
92 #define RELOC_MACROS_GEN_FUNC
94 #include "elf/aarch64.h"
95 #include "elf/alpha.h"
100 #include "elf/cr16.h"
101 #include "elf/cris.h"
103 #include "elf/csky.h"
104 #include "elf/d10v.h"
105 #include "elf/d30v.h"
108 #include "elf/epiphany.h"
109 #include "elf/fr30.h"
111 #include "elf/ft32.h"
113 #include "elf/hppa.h"
114 #include "elf/i386.h"
115 #include "elf/i370.h"
116 #include "elf/i860.h"
117 #include "elf/i960.h"
118 #include "elf/ia64.h"
119 #include "elf/ip2k.h"
120 #include "elf/lm32.h"
121 #include "elf/iq2000.h"
122 #include "elf/m32c.h"
123 #include "elf/m32r.h"
124 #include "elf/m68k.h"
125 #include "elf/m68hc11.h"
126 #include "elf/s12z.h"
127 #include "elf/mcore.h"
129 #include "elf/metag.h"
130 #include "elf/microblaze.h"
131 #include "elf/mips.h"
132 #include "elf/mmix.h"
133 #include "elf/mn10200.h"
134 #include "elf/mn10300.h"
135 #include "elf/moxie.h"
137 #include "elf/msp430.h"
138 #include "elf/nds32.h"
140 #include "elf/nios2.h"
141 #include "elf/or1k.h"
144 #include "elf/ppc64.h"
146 #include "elf/riscv.h"
147 #include "elf/rl78.h"
149 #include "elf/s390.h"
150 #include "elf/score.h"
152 #include "elf/sparc.h"
154 #include "elf/tic6x.h"
155 #include "elf/tilegx.h"
156 #include "elf/tilepro.h"
157 #include "elf/v850.h"
159 #include "elf/visium.h"
160 #include "elf/wasm32.h"
161 #include "elf/x86-64.h"
162 #include "elf/xc16x.h"
163 #include "elf/xgate.h"
164 #include "elf/xstormy16.h"
165 #include "elf/xtensa.h"
169 #include "libiberty.h"
170 #include "safe-ctype.h"
171 #include "filenames.h"
174 #define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
177 typedef struct elf_section_list
179 Elf_Internal_Shdr
* hdr
;
180 struct elf_section_list
* next
;
183 /* Flag bits indicating particular types of dump. */
184 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
185 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
186 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
187 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
188 #define RELOC_DUMP (1 << 4) /* The -R command line switch. */
189 #define CTF_DUMP (1 << 5) /* The --ctf command line switch. */
191 typedef unsigned char dump_type
;
193 /* A linked list of the section names for which dumps were requested. */
194 struct dump_list_entry
198 struct dump_list_entry
* next
;
201 /* A dynamic array of flags indicating for which sections a dump
202 has been requested via command line switches. */
205 dump_type
* dump_sects
;
206 unsigned int num_dump_sects
;
209 static struct dump_data cmdline
;
211 static struct dump_list_entry
* dump_sects_byname
;
213 char * program_name
= "readelf";
215 static bfd_boolean show_name
= FALSE
;
216 static bfd_boolean do_dynamic
= FALSE
;
217 static bfd_boolean do_syms
= FALSE
;
218 static bfd_boolean do_dyn_syms
= FALSE
;
219 static bfd_boolean do_lto_syms
= FALSE
;
220 static bfd_boolean do_reloc
= FALSE
;
221 static bfd_boolean do_sections
= FALSE
;
222 static bfd_boolean do_section_groups
= FALSE
;
223 static bfd_boolean do_section_details
= FALSE
;
224 static bfd_boolean do_segments
= FALSE
;
225 static bfd_boolean do_unwind
= FALSE
;
226 static bfd_boolean do_using_dynamic
= FALSE
;
227 static bfd_boolean do_header
= FALSE
;
228 static bfd_boolean do_dump
= FALSE
;
229 static bfd_boolean do_version
= FALSE
;
230 static bfd_boolean do_histogram
= FALSE
;
231 static bfd_boolean do_debugging
= FALSE
;
232 static bfd_boolean do_ctf
= FALSE
;
233 static bfd_boolean do_arch
= FALSE
;
234 static bfd_boolean do_notes
= FALSE
;
235 static bfd_boolean do_archive_index
= FALSE
;
236 static bfd_boolean check_all
= FALSE
;
237 static bfd_boolean is_32bit_elf
= FALSE
;
238 static bfd_boolean decompress_dumps
= FALSE
;
239 static bfd_boolean do_not_show_symbol_truncation
= FALSE
;
240 static bfd_boolean do_demangle
= FALSE
; /* Pretty print C++ symbol names. */
241 static int demangle_flags
= DMGL_ANSI
| DMGL_PARAMS
;
243 static char *dump_ctf_parent_name
;
244 static char *dump_ctf_symtab_name
;
245 static char *dump_ctf_strtab_name
;
249 struct group_list
* next
;
250 unsigned int section_index
;
255 struct group_list
* root
;
256 unsigned int group_index
;
259 typedef struct filedata
261 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
[PATH_MAX
];
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
*, bfd_boolean
, 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 bfd_boolean extra_padding
= FALSE
;
561 bfd_boolean 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 128
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
822 static inline bfd_boolean
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
);
1195 static inline bfd_boolean
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
,
1218 bfd_boolean is_dynsym
)
1221 Elf_Internal_Rela
* rels
;
1222 bfd_boolean res
= TRUE
;
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";
2237 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
2239 const char * result
;
2241 switch (filedata
->file_header
.e_machine
)
2244 result
= get_aarch64_dynamic_type (type
);
2247 case EM_MIPS_RS3_LE
:
2248 result
= get_mips_dynamic_type (type
);
2251 result
= get_sparc64_dynamic_type (type
);
2254 result
= get_ppc_dynamic_type (type
);
2257 result
= get_ppc64_dynamic_type (type
);
2260 result
= get_ia64_dynamic_type (type
);
2263 result
= get_alpha_dynamic_type (type
);
2266 result
= get_score_dynamic_type (type
);
2269 result
= get_tic6x_dynamic_type (type
);
2271 case EM_ALTERA_NIOS2
:
2272 result
= get_nios2_dynamic_type (type
);
2275 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2276 result
= get_solaris_dynamic_type (type
);
2285 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
2287 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
2288 || (filedata
->file_header
.e_machine
== EM_PARISC
2289 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
2291 const char * result
;
2293 switch (filedata
->file_header
.e_machine
)
2296 result
= get_parisc_dynamic_type (type
);
2299 result
= get_ia64_dynamic_type (type
);
2302 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2303 result
= get_solaris_dynamic_type (type
);
2312 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
2316 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
2323 get_file_type (unsigned e_type
)
2325 static char buff
[64];
2329 case ET_NONE
: return _("NONE (None)");
2330 case ET_REL
: return _("REL (Relocatable file)");
2331 case ET_EXEC
: return _("EXEC (Executable file)");
2332 case ET_DYN
: return _("DYN (Shared object file)");
2333 case ET_CORE
: return _("CORE (Core file)");
2336 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
2337 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
2338 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
2339 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
2341 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
2347 get_machine_name (unsigned e_machine
)
2349 static char buff
[64]; /* XXX */
2353 /* Please keep this switch table sorted by increasing EM_ value. */
2355 case EM_NONE
: return _("None");
2356 case EM_M32
: return "WE32100";
2357 case EM_SPARC
: return "Sparc";
2358 case EM_386
: return "Intel 80386";
2359 case EM_68K
: return "MC68000";
2360 case EM_88K
: return "MC88000";
2361 case EM_IAMCU
: return "Intel MCU";
2362 case EM_860
: return "Intel 80860";
2363 case EM_MIPS
: return "MIPS R3000";
2364 case EM_S370
: return "IBM System/370";
2366 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
2367 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
2368 case EM_PARISC
: return "HPPA";
2369 case EM_VPP550
: return "Fujitsu VPP500";
2370 case EM_SPARC32PLUS
: return "Sparc v8+" ;
2371 case EM_960
: return "Intel 80960";
2372 case EM_PPC
: return "PowerPC";
2374 case EM_PPC64
: return "PowerPC64";
2376 case EM_S390
: return "IBM S/390";
2377 case EM_SPU
: return "SPU";
2379 case EM_V800
: return "Renesas V850 (using RH850 ABI)";
2380 case EM_FR20
: return "Fujitsu FR20";
2381 case EM_RH32
: return "TRW RH32";
2382 case EM_MCORE
: return "MCORE";
2384 case EM_ARM
: return "ARM";
2385 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
2386 case EM_SH
: return "Renesas / SuperH SH";
2387 case EM_SPARCV9
: return "Sparc v9";
2388 case EM_TRICORE
: return "Siemens Tricore";
2389 case EM_ARC
: return "ARC";
2390 case EM_H8_300
: return "Renesas H8/300";
2391 case EM_H8_300H
: return "Renesas H8/300H";
2392 case EM_H8S
: return "Renesas H8S";
2393 case EM_H8_500
: return "Renesas H8/500";
2395 case EM_IA_64
: return "Intel IA-64";
2396 case EM_MIPS_X
: return "Stanford MIPS-X";
2397 case EM_COLDFIRE
: return "Motorola Coldfire";
2398 case EM_68HC12
: return "Motorola MC68HC12 Microcontroller";
2399 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
2400 case EM_PCP
: return "Siemens PCP";
2401 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
2402 case EM_NDR1
: return "Denso NDR1 microprocesspr";
2403 case EM_STARCORE
: return "Motorola Star*Core processor";
2404 case EM_ME16
: return "Toyota ME16 processor";
2406 case EM_ST100
: return "STMicroelectronics ST100 processor";
2407 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
2408 case EM_X86_64
: return "Advanced Micro Devices X86-64";
2409 case EM_PDSP
: return "Sony DSP processor";
2410 case EM_PDP10
: return "Digital Equipment Corp. PDP-10";
2411 case EM_PDP11
: return "Digital Equipment Corp. PDP-11";
2412 case EM_FX66
: return "Siemens FX66 microcontroller";
2413 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2414 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
2415 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
2417 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
2418 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
2419 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
2420 case EM_SVX
: return "Silicon Graphics SVx";
2421 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
2422 case EM_VAX
: return "Digital VAX";
2423 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
2424 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
2425 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
2426 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
2428 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
2429 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
2430 case EM_PRISM
: return "Vitesse Prism";
2432 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
2433 case EM_CYGNUS_FR30
:
2434 case EM_FR30
: return "Fujitsu FR30";
2435 case EM_CYGNUS_D10V
:
2436 case EM_D10V
: return "d10v";
2437 case EM_CYGNUS_D30V
:
2438 case EM_D30V
: return "d30v";
2439 case EM_CYGNUS_V850
:
2440 case EM_V850
: return "Renesas V850";
2441 case EM_CYGNUS_M32R
:
2442 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
2443 case EM_CYGNUS_MN10300
:
2444 case EM_MN10300
: return "mn10300";
2446 case EM_CYGNUS_MN10200
:
2447 case EM_MN10200
: return "mn10200";
2448 case EM_PJ
: return "picoJava";
2449 case EM_OR1K
: return "OpenRISC 1000";
2450 case EM_ARC_COMPACT
: return "ARCompact";
2452 case EM_XTENSA
: return "Tensilica Xtensa Processor";
2453 case EM_VIDEOCORE
: return "Alphamosaic VideoCore processor";
2454 case EM_TMM_GPP
: return "Thompson Multimedia General Purpose Processor";
2455 case EM_NS32K
: return "National Semiconductor 32000 series";
2456 case EM_TPC
: return "Tenor Network TPC processor";
2457 case EM_SNP1K
: return "Trebia SNP 1000 processor";
2459 case EM_ST200
: return "STMicroelectronics ST200 microcontroller";
2461 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
2462 case EM_MAX
: return "MAX Processor";
2463 case EM_CR
: return "National Semiconductor CompactRISC";
2464 case EM_F2MC16
: return "Fujitsu F2MC16";
2465 case EM_MSP430
: return "Texas Instruments msp430 microcontroller";
2466 case EM_BLACKFIN
: return "Analog Devices Blackfin";
2467 case EM_SE_C33
: return "S1C33 Family of Seiko Epson processors";
2468 case EM_SEP
: return "Sharp embedded microprocessor";
2469 case EM_ARCA
: return "Arca RISC microprocessor";
2471 case EM_UNICORE
: return "Unicore";
2472 case EM_EXCESS
: return "eXcess 16/32/64-bit configurable embedded CPU";
2473 case EM_DXP
: return "Icera Semiconductor Inc. Deep Execution Processor";
2474 case EM_ALTERA_NIOS2
: return "Altera Nios II";
2475 case EM_CRX
: return "National Semiconductor CRX microprocessor";
2476 case EM_XGATE
: return "Motorola XGATE embedded processor";
2478 case EM_XC16X
: return "Infineon Technologies xc16x";
2479 case EM_M16C
: return "Renesas M16C series microprocessors";
2480 case EM_DSPIC30F
: return "Microchip Technology dsPIC30F Digital Signal Controller";
2481 case EM_CE
: return "Freescale Communication Engine RISC core";
2483 case EM_M32C
: return "Renesas M32c";
2485 case EM_TSK3000
: return "Altium TSK3000 core";
2486 case EM_RS08
: return "Freescale RS08 embedded processor";
2487 case EM_ECOG2
: return "Cyan Technology eCOG2 microprocessor";
2488 case EM_SCORE
: return "SUNPLUS S+Core";
2489 case EM_DSP24
: return "New Japan Radio (NJR) 24-bit DSP Processor";
2490 case EM_VIDEOCORE3
: return "Broadcom VideoCore III processor";
2491 case EM_LATTICEMICO32
: return "Lattice Mico32";
2492 case EM_SE_C17
: return "Seiko Epson C17 family";
2494 case EM_TI_C6000
: return "Texas Instruments TMS320C6000 DSP family";
2495 case EM_TI_C2000
: return "Texas Instruments TMS320C2000 DSP family";
2496 case EM_TI_C5500
: return "Texas Instruments TMS320C55x DSP family";
2497 case EM_TI_PRU
: return "TI PRU I/O processor";
2499 case EM_MMDSP_PLUS
: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2500 case EM_CYPRESS_M8C
: return "Cypress M8C microprocessor";
2501 case EM_R32C
: return "Renesas R32C series microprocessors";
2502 case EM_TRIMEDIA
: return "NXP Semiconductors TriMedia architecture family";
2503 case EM_QDSP6
: return "QUALCOMM DSP6 Processor";
2504 case EM_8051
: return "Intel 8051 and variants";
2505 case EM_STXP7X
: return "STMicroelectronics STxP7x family";
2506 case EM_NDS32
: return "Andes Technology compact code size embedded RISC processor family";
2507 case EM_ECOG1X
: return "Cyan Technology eCOG1X family";
2508 case EM_MAXQ30
: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2510 case EM_XIMO16
: return "New Japan Radio (NJR) 16-bit DSP Processor";
2511 case EM_MANIK
: return "M2000 Reconfigurable RISC Microprocessor";
2512 case EM_CRAYNV2
: return "Cray Inc. NV2 vector architecture";
2513 case EM_RX
: return "Renesas RX";
2514 case EM_METAG
: return "Imagination Technologies Meta processor architecture";
2515 case EM_MCST_ELBRUS
: return "MCST Elbrus general purpose hardware architecture";
2516 case EM_ECOG16
: return "Cyan Technology eCOG16 family";
2519 case EM_MICROBLAZE_OLD
: return "Xilinx MicroBlaze";
2520 case EM_ETPU
: return "Freescale Extended Time Processing Unit";
2521 case EM_SLE9X
: return "Infineon Technologies SLE9X core";
2523 case EM_L1OM
: return "Intel L1OM";
2524 case EM_K1OM
: return "Intel K1OM";
2525 case EM_INTEL182
: return "Intel (reserved)";
2526 case EM_AARCH64
: return "AArch64";
2527 case EM_ARM184
: return "ARM (reserved)";
2528 case EM_AVR32
: return "Atmel Corporation 32-bit microprocessor";
2529 case EM_STM8
: return "STMicroeletronics STM8 8-bit microcontroller";
2530 case EM_TILE64
: return "Tilera TILE64 multicore architecture family";
2531 case EM_TILEPRO
: return "Tilera TILEPro multicore architecture family";
2533 case EM_CUDA
: return "NVIDIA CUDA architecture";
2534 case EM_TILEGX
: return "Tilera TILE-Gx multicore architecture family";
2535 case EM_CLOUDSHIELD
: return "CloudShield architecture family";
2536 case EM_COREA_1ST
: return "KIPO-KAIST Core-A 1st generation processor family";
2537 case EM_COREA_2ND
: return "KIPO-KAIST Core-A 2nd generation processor family";
2538 case EM_ARC_COMPACT2
: return "ARCv2";
2539 case EM_OPEN8
: return "Open8 8-bit RISC soft processor core";
2540 case EM_RL78
: return "Renesas RL78";
2541 case EM_VIDEOCORE5
: return "Broadcom VideoCore V processor";
2542 case EM_78K0R
: return "Renesas 78K0R";
2544 case EM_56800EX
: return "Freescale 56800EX Digital Signal Controller (DSC)";
2545 case EM_BA1
: return "Beyond BA1 CPU architecture";
2546 case EM_BA2
: return "Beyond BA2 CPU architecture";
2547 case EM_XCORE
: return "XMOS xCORE processor family";
2548 case EM_MCHP_PIC
: return "Microchip 8-bit PIC(r) family";
2550 case EM_KM32
: return "KM211 KM32 32-bit processor";
2551 case EM_KMX32
: return "KM211 KMX32 32-bit processor";
2552 case EM_KMX16
: return "KM211 KMX16 16-bit processor";
2553 case EM_KMX8
: return "KM211 KMX8 8-bit processor";
2554 case EM_KVARC
: return "KM211 KVARC processor";
2555 case EM_CDP
: return "Paneve CDP architecture family";
2556 case EM_COGE
: return "Cognitive Smart Memory Processor";
2557 case EM_COOL
: return "Bluechip Systems CoolEngine";
2558 case EM_NORC
: return "Nanoradio Optimized RISC";
2559 case EM_CSR_KALIMBA
: return "CSR Kalimba architecture family";
2561 case EM_Z80
: return "Zilog Z80";
2562 case EM_VISIUM
: return "CDS VISIUMcore processor";
2563 case EM_FT32
: return "FTDI Chip FT32";
2564 case EM_MOXIE
: return "Moxie";
2565 case EM_AMDGPU
: return "AMD GPU";
2566 /* 230 (all reserved) */
2568 case EM_RISCV
: return "RISC-V";
2569 case EM_LANAI
: return "Lanai 32-bit processor";
2570 case EM_CEVA
: return "CEVA Processor Architecture Family";
2571 case EM_CEVA_X2
: return "CEVA X2 Processor Family";
2572 case EM_BPF
: return "Linux BPF";
2573 case EM_GRAPHCORE_IPU
: return "Graphcore Intelligent Processing Unit";
2574 case EM_IMG1
: return "Imagination Technologies";
2576 case EM_NFP
: return "Netronome Flow Processor";
2577 case EM_VE
: return "NEC Vector Engine";
2578 case EM_CSKY
: return "C-SKY";
2579 case EM_ARC_COMPACT3_64
: return "Synopsys ARCv2.3 64-bit";
2580 case EM_MCS6502
: return "MOS Technology MCS 6502 processor";
2581 case EM_ARC_COMPACT3
: return "Synopsys ARCv2.3 32-bit";
2582 case EM_KVX
: return "Kalray VLIW core of the MPPA processor family";
2583 case EM_65816
: return "WDC 65816/65C816";
2584 case EM_LOONGARCH
: return "Loongson Loongarch";
2585 case EM_KF32
: return "ChipON KungFu32";
2587 /* Large numbers... */
2588 case EM_MT
: return "Morpho Techologies MT processor";
2589 case EM_ALPHA
: return "Alpha";
2590 case EM_WEBASSEMBLY
: return "Web Assembly";
2591 case EM_DLX
: return "OpenDLX";
2592 case EM_XSTORMY16
: return "Sanyo XStormy16 CPU core";
2593 case EM_IQ2000
: return "Vitesse IQ2000";
2595 case EM_NIOS32
: return "Altera Nios";
2596 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
2597 case EM_ADAPTEVA_EPIPHANY
: return "Adapteva EPIPHANY";
2598 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
2599 case EM_S12Z
: return "Freescale S12Z";
2602 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
2608 decode_ARC_machine_flags (unsigned e_flags
, unsigned e_machine
, char buf
[])
2610 /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2. Some
2611 other compilers don't a specific architecture type in the e_flags, and
2612 instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
2613 architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
2616 Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
2617 but also sets a specific architecture type in the e_flags field.
2619 However, when decoding the flags we don't worry if we see an
2620 unexpected pairing, for example EM_ARC_COMPACT machine type, with
2621 ARCEM architecture type. */
2623 switch (e_flags
& EF_ARC_MACH_MSK
)
2625 /* We only expect these to occur for EM_ARC_COMPACT2. */
2626 case EF_ARC_CPU_ARCV2EM
:
2627 strcat (buf
, ", ARC EM");
2629 case EF_ARC_CPU_ARCV2HS
:
2630 strcat (buf
, ", ARC HS");
2633 /* We only expect these to occur for EM_ARC_COMPACT. */
2634 case E_ARC_MACH_ARC600
:
2635 strcat (buf
, ", ARC600");
2637 case E_ARC_MACH_ARC601
:
2638 strcat (buf
, ", ARC601");
2640 case E_ARC_MACH_ARC700
:
2641 strcat (buf
, ", ARC700");
2644 /* The only times we should end up here are (a) A corrupt ELF, (b) A
2645 new ELF with new architecture being read by an old version of
2646 readelf, or (c) An ELF built with non-GNU compiler that does not
2647 set the architecture in the e_flags. */
2649 if (e_machine
== EM_ARC_COMPACT
)
2650 strcat (buf
, ", Unknown ARCompact");
2652 strcat (buf
, ", Unknown ARC");
2656 switch (e_flags
& EF_ARC_OSABI_MSK
)
2658 case E_ARC_OSABI_ORIG
:
2659 strcat (buf
, ", (ABI:legacy)");
2661 case E_ARC_OSABI_V2
:
2662 strcat (buf
, ", (ABI:v2)");
2664 /* Only upstream 3.9+ kernels will support ARCv2 ISA. */
2665 case E_ARC_OSABI_V3
:
2666 strcat (buf
, ", v3 no-legacy-syscalls ABI");
2668 case E_ARC_OSABI_V4
:
2669 strcat (buf
, ", v4 ABI");
2672 strcat (buf
, ", unrecognised ARC OSABI flag");
2678 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
2681 bfd_boolean unknown
= FALSE
;
2683 eabi
= EF_ARM_EABI_VERSION (e_flags
);
2684 e_flags
&= ~ EF_ARM_EABIMASK
;
2686 /* Handle "generic" ARM flags. */
2687 if (e_flags
& EF_ARM_RELEXEC
)
2689 strcat (buf
, ", relocatable executable");
2690 e_flags
&= ~ EF_ARM_RELEXEC
;
2693 if (e_flags
& EF_ARM_PIC
)
2695 strcat (buf
, ", position independent");
2696 e_flags
&= ~ EF_ARM_PIC
;
2699 /* Now handle EABI specific flags. */
2703 strcat (buf
, ", <unrecognized EABI>");
2708 case EF_ARM_EABI_VER1
:
2709 strcat (buf
, ", Version1 EABI");
2714 /* Process flags one bit at a time. */
2715 flag
= e_flags
& - e_flags
;
2720 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2721 strcat (buf
, ", sorted symbol tables");
2731 case EF_ARM_EABI_VER2
:
2732 strcat (buf
, ", Version2 EABI");
2737 /* Process flags one bit at a time. */
2738 flag
= e_flags
& - e_flags
;
2743 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2744 strcat (buf
, ", sorted symbol tables");
2747 case EF_ARM_DYNSYMSUSESEGIDX
:
2748 strcat (buf
, ", dynamic symbols use segment index");
2751 case EF_ARM_MAPSYMSFIRST
:
2752 strcat (buf
, ", mapping symbols precede others");
2762 case EF_ARM_EABI_VER3
:
2763 strcat (buf
, ", Version3 EABI");
2766 case EF_ARM_EABI_VER4
:
2767 strcat (buf
, ", Version4 EABI");
2772 /* Process flags one bit at a time. */
2773 flag
= e_flags
& - e_flags
;
2779 strcat (buf
, ", BE8");
2783 strcat (buf
, ", LE8");
2793 case EF_ARM_EABI_VER5
:
2794 strcat (buf
, ", Version5 EABI");
2799 /* Process flags one bit at a time. */
2800 flag
= e_flags
& - e_flags
;
2806 strcat (buf
, ", BE8");
2810 strcat (buf
, ", LE8");
2813 case EF_ARM_ABI_FLOAT_SOFT
: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2814 strcat (buf
, ", soft-float ABI");
2817 case EF_ARM_ABI_FLOAT_HARD
: /* Conflicts with EF_ARM_VFP_FLOAT. */
2818 strcat (buf
, ", hard-float ABI");
2828 case EF_ARM_EABI_UNKNOWN
:
2829 strcat (buf
, ", GNU EABI");
2834 /* Process flags one bit at a time. */
2835 flag
= e_flags
& - e_flags
;
2840 case EF_ARM_INTERWORK
:
2841 strcat (buf
, ", interworking enabled");
2844 case EF_ARM_APCS_26
:
2845 strcat (buf
, ", uses APCS/26");
2848 case EF_ARM_APCS_FLOAT
:
2849 strcat (buf
, ", uses APCS/float");
2853 strcat (buf
, ", position independent");
2857 strcat (buf
, ", 8 bit structure alignment");
2860 case EF_ARM_NEW_ABI
:
2861 strcat (buf
, ", uses new ABI");
2864 case EF_ARM_OLD_ABI
:
2865 strcat (buf
, ", uses old ABI");
2868 case EF_ARM_SOFT_FLOAT
:
2869 strcat (buf
, ", software FP");
2872 case EF_ARM_VFP_FLOAT
:
2873 strcat (buf
, ", VFP");
2876 case EF_ARM_MAVERICK_FLOAT
:
2877 strcat (buf
, ", Maverick FP");
2888 strcat (buf
,_(", <unknown>"));
2892 decode_AVR_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2894 --size
; /* Leave space for null terminator. */
2896 switch (e_flags
& EF_AVR_MACH
)
2898 case E_AVR_MACH_AVR1
:
2899 strncat (buf
, ", avr:1", size
);
2901 case E_AVR_MACH_AVR2
:
2902 strncat (buf
, ", avr:2", size
);
2904 case E_AVR_MACH_AVR25
:
2905 strncat (buf
, ", avr:25", size
);
2907 case E_AVR_MACH_AVR3
:
2908 strncat (buf
, ", avr:3", size
);
2910 case E_AVR_MACH_AVR31
:
2911 strncat (buf
, ", avr:31", size
);
2913 case E_AVR_MACH_AVR35
:
2914 strncat (buf
, ", avr:35", size
);
2916 case E_AVR_MACH_AVR4
:
2917 strncat (buf
, ", avr:4", size
);
2919 case E_AVR_MACH_AVR5
:
2920 strncat (buf
, ", avr:5", size
);
2922 case E_AVR_MACH_AVR51
:
2923 strncat (buf
, ", avr:51", size
);
2925 case E_AVR_MACH_AVR6
:
2926 strncat (buf
, ", avr:6", size
);
2928 case E_AVR_MACH_AVRTINY
:
2929 strncat (buf
, ", avr:100", size
);
2931 case E_AVR_MACH_XMEGA1
:
2932 strncat (buf
, ", avr:101", size
);
2934 case E_AVR_MACH_XMEGA2
:
2935 strncat (buf
, ", avr:102", size
);
2937 case E_AVR_MACH_XMEGA3
:
2938 strncat (buf
, ", avr:103", size
);
2940 case E_AVR_MACH_XMEGA4
:
2941 strncat (buf
, ", avr:104", size
);
2943 case E_AVR_MACH_XMEGA5
:
2944 strncat (buf
, ", avr:105", size
);
2946 case E_AVR_MACH_XMEGA6
:
2947 strncat (buf
, ", avr:106", size
);
2949 case E_AVR_MACH_XMEGA7
:
2950 strncat (buf
, ", avr:107", size
);
2953 strncat (buf
, ", avr:<unknown>", size
);
2957 size
-= strlen (buf
);
2958 if (e_flags
& EF_AVR_LINKRELAX_PREPARED
)
2959 strncat (buf
, ", link-relax", size
);
2963 decode_NDS32_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2969 bfd_boolean has_fpu
= FALSE
;
2972 static const char *ABI_STRINGS
[] =
2974 "ABI v0", /* use r5 as return register; only used in N1213HC */
2975 "ABI v1", /* use r0 as return register */
2976 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2977 "ABI v2fp", /* for FPU */
2981 static const char *VER_STRINGS
[] =
2983 "Andes ELF V1.3 or older",
2987 static const char *ARCH_STRINGS
[] =
2996 abi
= EF_NDS_ABI
& e_flags
;
2997 arch
= EF_NDS_ARCH
& e_flags
;
2998 config
= EF_NDS_INST
& e_flags
;
2999 version
= EF_NDS32_ELF_VERSION
& e_flags
;
3001 memset (buf
, 0, size
);
3008 case E_NDS_ABI_V2FP
:
3009 case E_NDS_ABI_AABI
:
3010 case E_NDS_ABI_V2FP_PLUS
:
3011 /* In case there are holes in the array. */
3012 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ABI_STRINGS
[abi
>> EF_NDS_ABI_SHIFT
]);
3016 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ABI>");
3022 case E_NDS32_ELF_VER_1_2
:
3023 case E_NDS32_ELF_VER_1_3
:
3024 case E_NDS32_ELF_VER_1_4
:
3025 r
+= snprintf (buf
+ r
, size
- r
, ", %s", VER_STRINGS
[version
>> EF_NDS32_ELF_VERSION_SHIFT
]);
3029 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ELF version number>");
3033 if (E_NDS_ABI_V0
== abi
)
3035 /* OLD ABI; only used in N1213HC, has performance extension 1. */
3036 r
+= snprintf (buf
+ r
, size
- r
, ", Andes Star v1.0, N1213HC, MAC, PERF1");
3037 if (arch
== E_NDS_ARCH_STAR_V1_0
)
3038 r
+= snprintf (buf
+ r
, size
-r
, ", 16b"); /* has 16-bit instructions */
3044 case E_NDS_ARCH_STAR_V1_0
:
3045 case E_NDS_ARCH_STAR_V2_0
:
3046 case E_NDS_ARCH_STAR_V3_0
:
3047 case E_NDS_ARCH_STAR_V3_M
:
3048 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ARCH_STRINGS
[arch
>> EF_NDS_ARCH_SHIFT
]);
3052 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized architecture>");
3053 /* ARCH version determines how the e_flags are interpreted.
3054 If it is unknown, we cannot proceed. */
3058 /* Newer ABI; Now handle architecture specific flags. */
3059 if (arch
== E_NDS_ARCH_STAR_V1_0
)
3061 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
3062 r
+= snprintf (buf
+ r
, size
-r
, ", MFUSR_PC");
3064 if (!(config
& E_NDS32_HAS_NO_MAC_INST
))
3065 r
+= snprintf (buf
+ r
, size
-r
, ", MAC");
3067 if (config
& E_NDS32_HAS_DIV_INST
)
3068 r
+= snprintf (buf
+ r
, size
-r
, ", DIV");
3070 if (config
& E_NDS32_HAS_16BIT_INST
)
3071 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
3075 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
3077 if (version
<= E_NDS32_ELF_VER_1_3
)
3078 r
+= snprintf (buf
+ r
, size
-r
, ", [B8]");
3080 r
+= snprintf (buf
+ r
, size
-r
, ", EX9");
3083 if (config
& E_NDS32_HAS_MAC_DX_INST
)
3084 r
+= snprintf (buf
+ r
, size
-r
, ", MAC_DX");
3086 if (config
& E_NDS32_HAS_DIV_DX_INST
)
3087 r
+= snprintf (buf
+ r
, size
-r
, ", DIV_DX");
3089 if (config
& E_NDS32_HAS_16BIT_INST
)
3091 if (version
<= E_NDS32_ELF_VER_1_3
)
3092 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
3094 r
+= snprintf (buf
+ r
, size
-r
, ", IFC");
3098 if (config
& E_NDS32_HAS_EXT_INST
)
3099 r
+= snprintf (buf
+ r
, size
-r
, ", PERF1");
3101 if (config
& E_NDS32_HAS_EXT2_INST
)
3102 r
+= snprintf (buf
+ r
, size
-r
, ", PERF2");
3104 if (config
& E_NDS32_HAS_FPU_INST
)
3107 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_SP");
3110 if (config
& E_NDS32_HAS_FPU_DP_INST
)
3113 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_DP");
3116 if (config
& E_NDS32_HAS_FPU_MAC_INST
)
3119 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_MAC");
3124 switch ((config
& E_NDS32_FPU_REG_CONF
) >> E_NDS32_FPU_REG_CONF_SHIFT
)
3126 case E_NDS32_FPU_REG_8SP_4DP
:
3127 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:8/4");
3129 case E_NDS32_FPU_REG_16SP_8DP
:
3130 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:16/8");
3132 case E_NDS32_FPU_REG_32SP_16DP
:
3133 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/16");
3135 case E_NDS32_FPU_REG_32SP_32DP
:
3136 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/32");
3141 if (config
& E_NDS32_HAS_AUDIO_INST
)
3142 r
+= snprintf (buf
+ r
, size
-r
, ", AUDIO");
3144 if (config
& E_NDS32_HAS_STRING_INST
)
3145 r
+= snprintf (buf
+ r
, size
-r
, ", STR");
3147 if (config
& E_NDS32_HAS_REDUCED_REGS
)
3148 r
+= snprintf (buf
+ r
, size
-r
, ", 16REG");
3150 if (config
& E_NDS32_HAS_VIDEO_INST
)
3152 if (version
<= E_NDS32_ELF_VER_1_3
)
3153 r
+= snprintf (buf
+ r
, size
-r
, ", VIDEO");
3155 r
+= snprintf (buf
+ r
, size
-r
, ", SATURATION");
3158 if (config
& E_NDS32_HAS_ENCRIPT_INST
)
3159 r
+= snprintf (buf
+ r
, size
-r
, ", ENCRP");
3161 if (config
& E_NDS32_HAS_L2C_INST
)
3162 r
+= snprintf (buf
+ r
, size
-r
, ", L2C");
3166 get_machine_flags (Filedata
* filedata
, unsigned e_flags
, unsigned e_machine
)
3168 static char buf
[1024];
3179 case EM_ARC_COMPACT2
:
3180 case EM_ARC_COMPACT
:
3181 decode_ARC_machine_flags (e_flags
, e_machine
, buf
);
3185 decode_ARM_machine_flags (e_flags
, buf
);
3189 decode_AVR_machine_flags (e_flags
, buf
, sizeof buf
);
3193 if (e_flags
& EF_BFIN_PIC
)
3194 strcat (buf
, ", PIC");
3196 if (e_flags
& EF_BFIN_FDPIC
)
3197 strcat (buf
, ", FDPIC");
3199 if (e_flags
& EF_BFIN_CODE_IN_L1
)
3200 strcat (buf
, ", code in L1");
3202 if (e_flags
& EF_BFIN_DATA_IN_L1
)
3203 strcat (buf
, ", data in L1");
3208 switch (e_flags
& EF_FRV_CPU_MASK
)
3210 case EF_FRV_CPU_GENERIC
:
3214 strcat (buf
, ", fr???");
3217 case EF_FRV_CPU_FR300
:
3218 strcat (buf
, ", fr300");
3221 case EF_FRV_CPU_FR400
:
3222 strcat (buf
, ", fr400");
3224 case EF_FRV_CPU_FR405
:
3225 strcat (buf
, ", fr405");
3228 case EF_FRV_CPU_FR450
:
3229 strcat (buf
, ", fr450");
3232 case EF_FRV_CPU_FR500
:
3233 strcat (buf
, ", fr500");
3235 case EF_FRV_CPU_FR550
:
3236 strcat (buf
, ", fr550");
3239 case EF_FRV_CPU_SIMPLE
:
3240 strcat (buf
, ", simple");
3242 case EF_FRV_CPU_TOMCAT
:
3243 strcat (buf
, ", tomcat");
3249 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
3250 strcat (buf
, ", m68000");
3251 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
3252 strcat (buf
, ", cpu32");
3253 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
3254 strcat (buf
, ", fido_a");
3257 char const * isa
= _("unknown");
3258 char const * mac
= _("unknown mac");
3259 char const * additional
= NULL
;
3261 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
3263 case EF_M68K_CF_ISA_A_NODIV
:
3265 additional
= ", nodiv";
3267 case EF_M68K_CF_ISA_A
:
3270 case EF_M68K_CF_ISA_A_PLUS
:
3273 case EF_M68K_CF_ISA_B_NOUSP
:
3275 additional
= ", nousp";
3277 case EF_M68K_CF_ISA_B
:
3280 case EF_M68K_CF_ISA_C
:
3283 case EF_M68K_CF_ISA_C_NODIV
:
3285 additional
= ", nodiv";
3288 strcat (buf
, ", cf, isa ");
3291 strcat (buf
, additional
);
3292 if (e_flags
& EF_M68K_CF_FLOAT
)
3293 strcat (buf
, ", float");
3294 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
3299 case EF_M68K_CF_MAC
:
3302 case EF_M68K_CF_EMAC
:
3305 case EF_M68K_CF_EMAC_B
:
3318 switch (e_flags
& EF_MEP_CPU_MASK
)
3320 case EF_MEP_CPU_MEP
: strcat (buf
, ", generic MeP"); break;
3321 case EF_MEP_CPU_C2
: strcat (buf
, ", MeP C2"); break;
3322 case EF_MEP_CPU_C3
: strcat (buf
, ", MeP C3"); break;
3323 case EF_MEP_CPU_C4
: strcat (buf
, ", MeP C4"); break;
3324 case EF_MEP_CPU_C5
: strcat (buf
, ", MeP C5"); break;
3325 case EF_MEP_CPU_H1
: strcat (buf
, ", MeP H1"); break;
3326 default: strcat (buf
, _(", <unknown MeP cpu type>")); break;
3329 switch (e_flags
& EF_MEP_COP_MASK
)
3331 case EF_MEP_COP_NONE
: break;
3332 case EF_MEP_COP_AVC
: strcat (buf
, ", AVC coprocessor"); break;
3333 case EF_MEP_COP_AVC2
: strcat (buf
, ", AVC2 coprocessor"); break;
3334 case EF_MEP_COP_FMAX
: strcat (buf
, ", FMAX coprocessor"); break;
3335 case EF_MEP_COP_IVC2
: strcat (buf
, ", IVC2 coprocessor"); break;
3336 default: strcat (buf
, _("<unknown MeP copro type>")); break;
3339 if (e_flags
& EF_MEP_LIBRARY
)
3340 strcat (buf
, ", Built for Library");
3342 if (e_flags
& EF_MEP_INDEX_MASK
)
3343 sprintf (buf
+ strlen (buf
), ", Configuration Index: %#x",
3344 e_flags
& EF_MEP_INDEX_MASK
);
3346 if (e_flags
& ~ EF_MEP_ALL_FLAGS
)
3347 sprintf (buf
+ strlen (buf
), _(", unknown flags bits: %#x"),
3348 e_flags
& ~ EF_MEP_ALL_FLAGS
);
3352 if (e_flags
& EF_PPC_EMB
)
3353 strcat (buf
, ", emb");
3355 if (e_flags
& EF_PPC_RELOCATABLE
)
3356 strcat (buf
, _(", relocatable"));
3358 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
3359 strcat (buf
, _(", relocatable-lib"));
3363 if (e_flags
& EF_PPC64_ABI
)
3365 char abi
[] = ", abiv0";
3367 abi
[6] += e_flags
& EF_PPC64_ABI
;
3373 if ((e_flags
& EF_RH850_ABI
) == EF_RH850_ABI
)
3374 strcat (buf
, ", RH850 ABI");
3376 if (e_flags
& EF_V800_850E3
)
3377 strcat (buf
, ", V3 architecture");
3379 if ((e_flags
& (EF_RH850_FPU_DOUBLE
| EF_RH850_FPU_SINGLE
)) == 0)
3380 strcat (buf
, ", FPU not used");
3382 if ((e_flags
& (EF_RH850_REGMODE22
| EF_RH850_REGMODE32
)) == 0)
3383 strcat (buf
, ", regmode: COMMON");
3385 if ((e_flags
& (EF_RH850_GP_FIX
| EF_RH850_GP_NOFIX
)) == 0)
3386 strcat (buf
, ", r4 not used");
3388 if ((e_flags
& (EF_RH850_EP_FIX
| EF_RH850_EP_NOFIX
)) == 0)
3389 strcat (buf
, ", r30 not used");
3391 if ((e_flags
& (EF_RH850_TP_FIX
| EF_RH850_TP_NOFIX
)) == 0)
3392 strcat (buf
, ", r5 not used");
3394 if ((e_flags
& (EF_RH850_REG2_RESERVE
| EF_RH850_REG2_NORESERVE
)) == 0)
3395 strcat (buf
, ", r2 not used");
3397 for (e_flags
&= 0xFFFF; e_flags
; e_flags
&= ~ (e_flags
& - e_flags
))
3399 switch (e_flags
& - e_flags
)
3401 case EF_RH850_FPU_DOUBLE
: strcat (buf
, ", double precision FPU"); break;
3402 case EF_RH850_FPU_SINGLE
: strcat (buf
, ", single precision FPU"); break;
3403 case EF_RH850_REGMODE22
: strcat (buf
, ", regmode:22"); break;
3404 case EF_RH850_REGMODE32
: strcat (buf
, ", regmode:23"); break;
3405 case EF_RH850_GP_FIX
: strcat (buf
, ", r4 fixed"); break;
3406 case EF_RH850_GP_NOFIX
: strcat (buf
, ", r4 free"); break;
3407 case EF_RH850_EP_FIX
: strcat (buf
, ", r30 fixed"); break;
3408 case EF_RH850_EP_NOFIX
: strcat (buf
, ", r30 free"); break;
3409 case EF_RH850_TP_FIX
: strcat (buf
, ", r5 fixed"); break;
3410 case EF_RH850_TP_NOFIX
: strcat (buf
, ", r5 free"); break;
3411 case EF_RH850_REG2_RESERVE
: strcat (buf
, ", r2 fixed"); break;
3412 case EF_RH850_REG2_NORESERVE
: strcat (buf
, ", r2 free"); break;
3419 case EM_CYGNUS_V850
:
3420 switch (e_flags
& EF_V850_ARCH
)
3422 case E_V850E3V5_ARCH
:
3423 strcat (buf
, ", v850e3v5");
3425 case E_V850E2V3_ARCH
:
3426 strcat (buf
, ", v850e2v3");
3429 strcat (buf
, ", v850e2");
3432 strcat (buf
, ", v850e1");
3435 strcat (buf
, ", v850e");
3438 strcat (buf
, ", v850");
3441 strcat (buf
, _(", unknown v850 architecture variant"));
3447 case EM_CYGNUS_M32R
:
3448 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
3449 strcat (buf
, ", m32r");
3453 case EM_MIPS_RS3_LE
:
3454 if (e_flags
& EF_MIPS_NOREORDER
)
3455 strcat (buf
, ", noreorder");
3457 if (e_flags
& EF_MIPS_PIC
)
3458 strcat (buf
, ", pic");
3460 if (e_flags
& EF_MIPS_CPIC
)
3461 strcat (buf
, ", cpic");
3463 if (e_flags
& EF_MIPS_UCODE
)
3464 strcat (buf
, ", ugen_reserved");
3466 if (e_flags
& EF_MIPS_ABI2
)
3467 strcat (buf
, ", abi2");
3469 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
3470 strcat (buf
, ", odk first");
3472 if (e_flags
& EF_MIPS_32BITMODE
)
3473 strcat (buf
, ", 32bitmode");
3475 if (e_flags
& EF_MIPS_NAN2008
)
3476 strcat (buf
, ", nan2008");
3478 if (e_flags
& EF_MIPS_FP64
)
3479 strcat (buf
, ", fp64");
3481 switch ((e_flags
& EF_MIPS_MACH
))
3483 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
3484 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
3485 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
3486 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
3487 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
3488 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
3489 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
3490 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
3491 case E_MIPS_MACH_5900
: strcat (buf
, ", 5900"); break;
3492 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
3493 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
3494 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
3495 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
3496 case E_MIPS_MACH_GS464
: strcat (buf
, ", gs464"); break;
3497 case E_MIPS_MACH_GS464E
: strcat (buf
, ", gs464e"); break;
3498 case E_MIPS_MACH_GS264E
: strcat (buf
, ", gs264e"); break;
3499 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
3500 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
3501 case E_MIPS_MACH_OCTEON3
: strcat (buf
, ", octeon3"); break;
3502 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
3503 case E_MIPS_MACH_IAMR2
: strcat (buf
, ", interaptiv-mr2"); break;
3505 /* We simply ignore the field in this case to avoid confusion:
3506 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3509 default: strcat (buf
, _(", unknown CPU")); break;
3512 switch ((e_flags
& EF_MIPS_ABI
))
3514 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
3515 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
3516 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
3517 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
3519 /* We simply ignore the field in this case to avoid confusion:
3520 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3521 This means it is likely to be an o32 file, but not for
3524 default: strcat (buf
, _(", unknown ABI")); break;
3527 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
3528 strcat (buf
, ", mdmx");
3530 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
3531 strcat (buf
, ", mips16");
3533 if (e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
3534 strcat (buf
, ", micromips");
3536 switch ((e_flags
& EF_MIPS_ARCH
))
3538 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
3539 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
3540 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
3541 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
3542 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
3543 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
3544 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
3545 case E_MIPS_ARCH_32R6
: strcat (buf
, ", mips32r6"); break;
3546 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
3547 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
3548 case E_MIPS_ARCH_64R6
: strcat (buf
, ", mips64r6"); break;
3549 default: strcat (buf
, _(", unknown ISA")); break;
3554 decode_NDS32_machine_flags (e_flags
, buf
, sizeof buf
);
3558 switch (EF_NFP_MACH (e_flags
))
3560 case E_NFP_MACH_3200
:
3561 strcat (buf
, ", NFP-32xx");
3563 case E_NFP_MACH_6000
:
3564 strcat (buf
, ", NFP-6xxx");
3570 if (e_flags
& EF_RISCV_RVC
)
3571 strcat (buf
, ", RVC");
3573 if (e_flags
& EF_RISCV_RVE
)
3574 strcat (buf
, ", RVE");
3576 switch (e_flags
& EF_RISCV_FLOAT_ABI
)
3578 case EF_RISCV_FLOAT_ABI_SOFT
:
3579 strcat (buf
, ", soft-float ABI");
3582 case EF_RISCV_FLOAT_ABI_SINGLE
:
3583 strcat (buf
, ", single-float ABI");
3586 case EF_RISCV_FLOAT_ABI_DOUBLE
:
3587 strcat (buf
, ", double-float ABI");
3590 case EF_RISCV_FLOAT_ABI_QUAD
:
3591 strcat (buf
, ", quad-float ABI");
3597 switch ((e_flags
& EF_SH_MACH_MASK
))
3599 case EF_SH1
: strcat (buf
, ", sh1"); break;
3600 case EF_SH2
: strcat (buf
, ", sh2"); break;
3601 case EF_SH3
: strcat (buf
, ", sh3"); break;
3602 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
3603 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
3604 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
3605 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
3606 case EF_SH4
: strcat (buf
, ", sh4"); break;
3607 case EF_SH5
: strcat (buf
, ", sh5"); break;
3608 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
3609 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
3610 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
3611 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
3612 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
3613 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
3614 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
3615 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
3616 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3617 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
3618 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
3619 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
3620 default: strcat (buf
, _(", unknown ISA")); break;
3623 if (e_flags
& EF_SH_PIC
)
3624 strcat (buf
, ", pic");
3626 if (e_flags
& EF_SH_FDPIC
)
3627 strcat (buf
, ", fdpic");
3631 if (e_flags
& EF_OR1K_NODELAY
)
3632 strcat (buf
, ", no delay");
3636 if (e_flags
& EF_SPARC_32PLUS
)
3637 strcat (buf
, ", v8+");
3639 if (e_flags
& EF_SPARC_SUN_US1
)
3640 strcat (buf
, ", ultrasparcI");
3642 if (e_flags
& EF_SPARC_SUN_US3
)
3643 strcat (buf
, ", ultrasparcIII");
3645 if (e_flags
& EF_SPARC_HAL_R1
)
3646 strcat (buf
, ", halr1");
3648 if (e_flags
& EF_SPARC_LEDATA
)
3649 strcat (buf
, ", ledata");
3651 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
3652 strcat (buf
, ", tso");
3654 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
3655 strcat (buf
, ", pso");
3657 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
3658 strcat (buf
, ", rmo");
3662 switch (e_flags
& EF_PARISC_ARCH
)
3664 case EFA_PARISC_1_0
:
3665 strcpy (buf
, ", PA-RISC 1.0");
3667 case EFA_PARISC_1_1
:
3668 strcpy (buf
, ", PA-RISC 1.1");
3670 case EFA_PARISC_2_0
:
3671 strcpy (buf
, ", PA-RISC 2.0");
3676 if (e_flags
& EF_PARISC_TRAPNIL
)
3677 strcat (buf
, ", trapnil");
3678 if (e_flags
& EF_PARISC_EXT
)
3679 strcat (buf
, ", ext");
3680 if (e_flags
& EF_PARISC_LSB
)
3681 strcat (buf
, ", lsb");
3682 if (e_flags
& EF_PARISC_WIDE
)
3683 strcat (buf
, ", wide");
3684 if (e_flags
& EF_PARISC_NO_KABP
)
3685 strcat (buf
, ", no kabp");
3686 if (e_flags
& EF_PARISC_LAZYSWAP
)
3687 strcat (buf
, ", lazyswap");
3692 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
3693 strcat (buf
, ", new calling convention");
3695 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
3696 strcat (buf
, ", gnu calling convention");
3700 if ((e_flags
& EF_IA_64_ABI64
))
3701 strcat (buf
, ", 64-bit");
3703 strcat (buf
, ", 32-bit");
3704 if ((e_flags
& EF_IA_64_REDUCEDFP
))
3705 strcat (buf
, ", reduced fp model");
3706 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
3707 strcat (buf
, ", no function descriptors, constant gp");
3708 else if ((e_flags
& EF_IA_64_CONS_GP
))
3709 strcat (buf
, ", constant gp");
3710 if ((e_flags
& EF_IA_64_ABSOLUTE
))
3711 strcat (buf
, ", absolute");
3712 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
3714 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
3715 strcat (buf
, ", vms_linkages");
3716 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
3718 case EF_IA_64_VMS_COMCOD_SUCCESS
:
3720 case EF_IA_64_VMS_COMCOD_WARNING
:
3721 strcat (buf
, ", warning");
3723 case EF_IA_64_VMS_COMCOD_ERROR
:
3724 strcat (buf
, ", error");
3726 case EF_IA_64_VMS_COMCOD_ABORT
:
3727 strcat (buf
, ", abort");
3730 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3731 e_flags
& EF_IA_64_VMS_COMCOD
);
3732 strcat (buf
, ", <unknown>");
3738 if ((e_flags
& EF_VAX_NONPIC
))
3739 strcat (buf
, ", non-PIC");
3740 if ((e_flags
& EF_VAX_DFLOAT
))
3741 strcat (buf
, ", D-Float");
3742 if ((e_flags
& EF_VAX_GFLOAT
))
3743 strcat (buf
, ", G-Float");
3747 if (e_flags
& EF_VISIUM_ARCH_MCM
)
3748 strcat (buf
, ", mcm");
3749 else if (e_flags
& EF_VISIUM_ARCH_MCM24
)
3750 strcat (buf
, ", mcm24");
3751 if (e_flags
& EF_VISIUM_ARCH_GR6
)
3752 strcat (buf
, ", gr6");
3756 switch (e_flags
& E_FLAG_RL78_CPU_MASK
)
3758 case E_FLAG_RL78_ANY_CPU
: break;
3759 case E_FLAG_RL78_G10
: strcat (buf
, ", G10"); break;
3760 case E_FLAG_RL78_G13
: strcat (buf
, ", G13"); break;
3761 case E_FLAG_RL78_G14
: strcat (buf
, ", G14"); break;
3763 if (e_flags
& E_FLAG_RL78_64BIT_DOUBLES
)
3764 strcat (buf
, ", 64-bit doubles");
3768 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
3769 strcat (buf
, ", 64-bit doubles");
3770 if (e_flags
& E_FLAG_RX_DSP
)
3771 strcat (buf
, ", dsp");
3772 if (e_flags
& E_FLAG_RX_PID
)
3773 strcat (buf
, ", pid");
3774 if (e_flags
& E_FLAG_RX_ABI
)
3775 strcat (buf
, ", RX ABI");
3776 if (e_flags
& E_FLAG_RX_SINSNS_SET
)
3777 strcat (buf
, e_flags
& E_FLAG_RX_SINSNS_YES
3778 ? ", uses String instructions" : ", bans String instructions");
3779 if (e_flags
& E_FLAG_RX_V2
)
3780 strcat (buf
, ", V2");
3781 if (e_flags
& E_FLAG_RX_V3
)
3782 strcat (buf
, ", V3");
3786 if (e_flags
& EF_S390_HIGH_GPRS
)
3787 strcat (buf
, ", highgprs");
3791 if ((e_flags
& EF_C6000_REL
))
3792 strcat (buf
, ", relocatable module");
3796 strcat (buf
, _(": architecture variant: "));
3797 switch (e_flags
& EF_MSP430_MACH
)
3799 case E_MSP430_MACH_MSP430x11
: strcat (buf
, "MSP430x11"); break;
3800 case E_MSP430_MACH_MSP430x11x1
: strcat (buf
, "MSP430x11x1 "); break;
3801 case E_MSP430_MACH_MSP430x12
: strcat (buf
, "MSP430x12"); break;
3802 case E_MSP430_MACH_MSP430x13
: strcat (buf
, "MSP430x13"); break;
3803 case E_MSP430_MACH_MSP430x14
: strcat (buf
, "MSP430x14"); break;
3804 case E_MSP430_MACH_MSP430x15
: strcat (buf
, "MSP430x15"); break;
3805 case E_MSP430_MACH_MSP430x16
: strcat (buf
, "MSP430x16"); break;
3806 case E_MSP430_MACH_MSP430x31
: strcat (buf
, "MSP430x31"); break;
3807 case E_MSP430_MACH_MSP430x32
: strcat (buf
, "MSP430x32"); break;
3808 case E_MSP430_MACH_MSP430x33
: strcat (buf
, "MSP430x33"); break;
3809 case E_MSP430_MACH_MSP430x41
: strcat (buf
, "MSP430x41"); break;
3810 case E_MSP430_MACH_MSP430x42
: strcat (buf
, "MSP430x42"); break;
3811 case E_MSP430_MACH_MSP430x43
: strcat (buf
, "MSP430x43"); break;
3812 case E_MSP430_MACH_MSP430x44
: strcat (buf
, "MSP430x44"); break;
3813 case E_MSP430_MACH_MSP430X
: strcat (buf
, "MSP430X"); break;
3815 strcat (buf
, _(": unknown")); break;
3818 if (e_flags
& ~ EF_MSP430_MACH
)
3819 strcat (buf
, _(": unknown extra flag bits also present"));
3823 switch (e_flags
& EF_Z80_MACH_MSK
)
3825 case EF_Z80_MACH_Z80
: strcat (buf
, ", Z80"); break;
3826 case EF_Z80_MACH_Z180
: strcat (buf
, ", Z180"); break;
3827 case EF_Z80_MACH_R800
: strcat (buf
, ", R800"); break;
3828 case EF_Z80_MACH_EZ80_Z80
: strcat (buf
, ", EZ80"); break;
3829 case EF_Z80_MACH_EZ80_ADL
: strcat (buf
, ", EZ80, ADL"); break;
3830 case EF_Z80_MACH_GBZ80
: strcat (buf
, ", GBZ80"); break;
3831 case EF_Z80_MACH_Z80N
: strcat (buf
, ", Z80N"); break;
3833 strcat (buf
, _(", unknown")); break;
3843 get_osabi_name (Filedata
* filedata
, unsigned int osabi
)
3845 static char buff
[32];
3849 case ELFOSABI_NONE
: return "UNIX - System V";
3850 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
3851 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
3852 case ELFOSABI_GNU
: return "UNIX - GNU";
3853 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
3854 case ELFOSABI_AIX
: return "UNIX - AIX";
3855 case ELFOSABI_IRIX
: return "UNIX - IRIX";
3856 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
3857 case ELFOSABI_TRU64
: return "UNIX - TRU64";
3858 case ELFOSABI_MODESTO
: return "Novell - Modesto";
3859 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
3860 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
3861 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
3862 case ELFOSABI_AROS
: return "AROS";
3863 case ELFOSABI_FENIXOS
: return "FenixOS";
3864 case ELFOSABI_CLOUDABI
: return "Nuxi CloudABI";
3865 case ELFOSABI_OPENVOS
: return "Stratus Technologies OpenVOS";
3868 switch (filedata
->file_header
.e_machine
)
3873 case ELFOSABI_ARM
: return "ARM";
3874 case ELFOSABI_ARM_FDPIC
: return "ARM FDPIC";
3885 case ELFOSABI_STANDALONE
: return _("Standalone App");
3894 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
3895 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
3904 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
3910 get_aarch64_segment_type (unsigned long type
)
3914 case PT_AARCH64_ARCHEXT
: return "AARCH64_ARCHEXT";
3915 default: return NULL
;
3920 get_arm_segment_type (unsigned long type
)
3924 case PT_ARM_EXIDX
: return "EXIDX";
3925 default: return NULL
;
3930 get_s390_segment_type (unsigned long type
)
3934 case PT_S390_PGSTE
: return "S390_PGSTE";
3935 default: return NULL
;
3940 get_mips_segment_type (unsigned long type
)
3944 case PT_MIPS_REGINFO
: return "REGINFO";
3945 case PT_MIPS_RTPROC
: return "RTPROC";
3946 case PT_MIPS_OPTIONS
: return "OPTIONS";
3947 case PT_MIPS_ABIFLAGS
: return "ABIFLAGS";
3948 default: return NULL
;
3953 get_parisc_segment_type (unsigned long type
)
3957 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
3958 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
3959 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
3960 default: return NULL
;
3965 get_ia64_segment_type (unsigned long type
)
3969 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
3970 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
3971 default: return NULL
;
3976 get_tic6x_segment_type (unsigned long type
)
3980 case PT_C6000_PHATTR
: return "C6000_PHATTR";
3981 default: return NULL
;
3986 get_hpux_segment_type (unsigned long type
, unsigned e_machine
)
3988 if (e_machine
== EM_PARISC
)
3991 case PT_HP_TLS
: return "HP_TLS";
3992 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
3993 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
3994 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
3995 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
3996 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
3997 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
3998 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
3999 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
4000 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
4001 case PT_HP_PARALLEL
: return "HP_PARALLEL";
4002 case PT_HP_FASTBIND
: return "HP_FASTBIND";
4003 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
4004 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
4005 case PT_HP_STACK
: return "HP_STACK";
4006 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
4007 default: return NULL
;
4010 if (e_machine
== EM_IA_64
)
4013 case PT_HP_TLS
: return "HP_TLS";
4014 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
4015 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
4016 case PT_IA_64_HP_STACK
: return "HP_STACK";
4017 default: return NULL
;
4024 get_solaris_segment_type (unsigned long type
)
4028 case 0x6464e550: return "PT_SUNW_UNWIND";
4029 case 0x6474e550: return "PT_SUNW_EH_FRAME";
4030 case 0x6ffffff7: return "PT_LOSUNW";
4031 case 0x6ffffffa: return "PT_SUNWBSS";
4032 case 0x6ffffffb: return "PT_SUNWSTACK";
4033 case 0x6ffffffc: return "PT_SUNWDTRACE";
4034 case 0x6ffffffd: return "PT_SUNWCAP";
4035 case 0x6fffffff: return "PT_HISUNW";
4036 default: return NULL
;
4041 get_segment_type (Filedata
* filedata
, unsigned long p_type
)
4043 static char buff
[32];
4047 case PT_NULL
: return "NULL";
4048 case PT_LOAD
: return "LOAD";
4049 case PT_DYNAMIC
: return "DYNAMIC";
4050 case PT_INTERP
: return "INTERP";
4051 case PT_NOTE
: return "NOTE";
4052 case PT_SHLIB
: return "SHLIB";
4053 case PT_PHDR
: return "PHDR";
4054 case PT_TLS
: return "TLS";
4055 case PT_GNU_EH_FRAME
: return "GNU_EH_FRAME";
4056 case PT_GNU_STACK
: return "GNU_STACK";
4057 case PT_GNU_RELRO
: return "GNU_RELRO";
4058 case PT_GNU_PROPERTY
: return "GNU_PROPERTY";
4060 case PT_OPENBSD_RANDOMIZE
: return "OPENBSD_RANDOMIZE";
4061 case PT_OPENBSD_WXNEEDED
: return "OPENBSD_WXNEEDED";
4062 case PT_OPENBSD_BOOTDATA
: return "OPENBSD_BOOTDATA";
4065 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
4067 const char * result
;
4069 switch (filedata
->file_header
.e_machine
)
4072 result
= get_aarch64_segment_type (p_type
);
4075 result
= get_arm_segment_type (p_type
);
4078 case EM_MIPS_RS3_LE
:
4079 result
= get_mips_segment_type (p_type
);
4082 result
= get_parisc_segment_type (p_type
);
4085 result
= get_ia64_segment_type (p_type
);
4088 result
= get_tic6x_segment_type (p_type
);
4092 result
= get_s390_segment_type (p_type
);
4102 sprintf (buff
, "LOPROC+%#lx", p_type
- PT_LOPROC
);
4104 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
4106 const char * result
= NULL
;
4108 switch (filedata
->file_header
.e_ident
[EI_OSABI
])
4111 case ELFOSABI_FREEBSD
:
4112 if (p_type
>= PT_GNU_MBIND_LO
&& p_type
<= PT_GNU_MBIND_HI
)
4114 sprintf (buff
, "GNU_MBIND+%#lx", p_type
- PT_GNU_MBIND_LO
);
4119 result
= get_hpux_segment_type (p_type
,
4120 filedata
->file_header
.e_machine
);
4122 case ELFOSABI_SOLARIS
:
4123 result
= get_solaris_segment_type (p_type
);
4131 sprintf (buff
, "LOOS+%#lx", p_type
- PT_LOOS
);
4134 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
4141 get_arc_section_type_name (unsigned int sh_type
)
4145 case SHT_ARC_ATTRIBUTES
: return "ARC_ATTRIBUTES";
4153 get_mips_section_type_name (unsigned int sh_type
)
4157 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
4158 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
4159 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
4160 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
4161 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
4162 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
4163 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
4164 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
4165 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
4166 case SHT_MIPS_RELD
: return "MIPS_RELD";
4167 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
4168 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
4169 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
4170 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
4171 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
4172 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
4173 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
4174 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
4175 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
4176 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
4177 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
4178 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
4179 case SHT_MIPS_LINE
: return "MIPS_LINE";
4180 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
4181 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
4182 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
4183 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
4184 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
4185 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
4186 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
4187 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
4188 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
4189 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
4190 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
4191 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
4192 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
4193 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
4194 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
4195 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
4196 case SHT_MIPS_ABIFLAGS
: return "MIPS_ABIFLAGS";
4197 case SHT_MIPS_XHASH
: return "MIPS_XHASH";
4205 get_parisc_section_type_name (unsigned int sh_type
)
4209 case SHT_PARISC_EXT
: return "PARISC_EXT";
4210 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
4211 case SHT_PARISC_DOC
: return "PARISC_DOC";
4212 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
4213 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
4214 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
4215 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
4216 default: return NULL
;
4221 get_ia64_section_type_name (Filedata
* filedata
, unsigned int sh_type
)
4223 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
4224 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
4225 return get_osabi_name (filedata
, (sh_type
& 0x00FF0000) >> 16);
4229 case SHT_IA_64_EXT
: return "IA_64_EXT";
4230 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
4231 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
4232 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
4233 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
4234 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
4235 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
4236 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
4237 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
4238 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
4246 get_x86_64_section_type_name (unsigned int sh_type
)
4250 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
4251 default: return NULL
;
4256 get_aarch64_section_type_name (unsigned int sh_type
)
4260 case SHT_AARCH64_ATTRIBUTES
: return "AARCH64_ATTRIBUTES";
4261 default: return NULL
;
4266 get_arm_section_type_name (unsigned int sh_type
)
4270 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
4271 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
4272 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
4273 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
4274 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
4275 default: return NULL
;
4280 get_tic6x_section_type_name (unsigned int sh_type
)
4284 case SHT_C6000_UNWIND
: return "C6000_UNWIND";
4285 case SHT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
4286 case SHT_C6000_ATTRIBUTES
: return "C6000_ATTRIBUTES";
4287 case SHT_TI_ICODE
: return "TI_ICODE";
4288 case SHT_TI_XREF
: return "TI_XREF";
4289 case SHT_TI_HANDLER
: return "TI_HANDLER";
4290 case SHT_TI_INITINFO
: return "TI_INITINFO";
4291 case SHT_TI_PHATTRS
: return "TI_PHATTRS";
4292 default: return NULL
;
4297 get_msp430_section_type_name (unsigned int sh_type
)
4301 case SHT_MSP430_SEC_FLAGS
: return "MSP430_SEC_FLAGS";
4302 case SHT_MSP430_SYM_ALIASES
: return "MSP430_SYM_ALIASES";
4303 case SHT_MSP430_ATTRIBUTES
: return "MSP430_ATTRIBUTES";
4304 default: return NULL
;
4309 get_nfp_section_type_name (unsigned int sh_type
)
4313 case SHT_NFP_MECONFIG
: return "NFP_MECONFIG";
4314 case SHT_NFP_INITREG
: return "NFP_INITREG";
4315 case SHT_NFP_UDEBUG
: return "NFP_UDEBUG";
4316 default: return NULL
;
4321 get_v850_section_type_name (unsigned int sh_type
)
4325 case SHT_V850_SCOMMON
: return "V850 Small Common";
4326 case SHT_V850_TCOMMON
: return "V850 Tiny Common";
4327 case SHT_V850_ZCOMMON
: return "V850 Zero Common";
4328 case SHT_RENESAS_IOP
: return "RENESAS IOP";
4329 case SHT_RENESAS_INFO
: return "RENESAS INFO";
4330 default: return NULL
;
4335 get_riscv_section_type_name (unsigned int sh_type
)
4339 case SHT_RISCV_ATTRIBUTES
: return "RISCV_ATTRIBUTES";
4340 default: return NULL
;
4345 get_csky_section_type_name (unsigned int sh_type
)
4349 case SHT_CSKY_ATTRIBUTES
: return "CSKY_ATTRIBUTES";
4350 default: return NULL
;
4355 get_section_type_name (Filedata
* filedata
, unsigned int sh_type
)
4357 static char buff
[32];
4358 const char * result
;
4362 case SHT_NULL
: return "NULL";
4363 case SHT_PROGBITS
: return "PROGBITS";
4364 case SHT_SYMTAB
: return "SYMTAB";
4365 case SHT_STRTAB
: return "STRTAB";
4366 case SHT_RELA
: return "RELA";
4367 case SHT_HASH
: return "HASH";
4368 case SHT_DYNAMIC
: return "DYNAMIC";
4369 case SHT_NOTE
: return "NOTE";
4370 case SHT_NOBITS
: return "NOBITS";
4371 case SHT_REL
: return "REL";
4372 case SHT_SHLIB
: return "SHLIB";
4373 case SHT_DYNSYM
: return "DYNSYM";
4374 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
4375 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
4376 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
4377 case SHT_GNU_HASH
: return "GNU_HASH";
4378 case SHT_GROUP
: return "GROUP";
4379 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICES";
4380 case SHT_GNU_verdef
: return "VERDEF";
4381 case SHT_GNU_verneed
: return "VERNEED";
4382 case SHT_GNU_versym
: return "VERSYM";
4383 case 0x6ffffff0: return "VERSYM";
4384 case 0x6ffffffc: return "VERDEF";
4385 case 0x7ffffffd: return "AUXILIARY";
4386 case 0x7fffffff: return "FILTER";
4387 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
4390 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
4392 switch (filedata
->file_header
.e_machine
)
4395 case EM_ARC_COMPACT
:
4396 case EM_ARC_COMPACT2
:
4397 result
= get_arc_section_type_name (sh_type
);
4400 case EM_MIPS_RS3_LE
:
4401 result
= get_mips_section_type_name (sh_type
);
4404 result
= get_parisc_section_type_name (sh_type
);
4407 result
= get_ia64_section_type_name (filedata
, sh_type
);
4412 result
= get_x86_64_section_type_name (sh_type
);
4415 result
= get_aarch64_section_type_name (sh_type
);
4418 result
= get_arm_section_type_name (sh_type
);
4421 result
= get_tic6x_section_type_name (sh_type
);
4424 result
= get_msp430_section_type_name (sh_type
);
4427 result
= get_nfp_section_type_name (sh_type
);
4431 case EM_CYGNUS_V850
:
4432 result
= get_v850_section_type_name (sh_type
);
4435 result
= get_riscv_section_type_name (sh_type
);
4438 result
= get_csky_section_type_name (sh_type
);
4448 sprintf (buff
, "LOPROC+%#x", sh_type
- SHT_LOPROC
);
4450 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
4452 switch (filedata
->file_header
.e_machine
)
4455 result
= get_ia64_section_type_name (filedata
, sh_type
);
4458 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
4459 result
= get_solaris_section_type (sh_type
);
4464 case SHT_GNU_INCREMENTAL_INPUTS
: result
= "GNU_INCREMENTAL_INPUTS"; break;
4465 case SHT_GNU_ATTRIBUTES
: result
= "GNU_ATTRIBUTES"; break;
4466 case SHT_GNU_HASH
: result
= "GNU_HASH"; break;
4467 case SHT_GNU_LIBLIST
: result
= "GNU_LIBLIST"; break;
4479 sprintf (buff
, "LOOS+%#x", sh_type
- SHT_LOOS
);
4481 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
4483 switch (filedata
->file_header
.e_machine
)
4487 case EM_CYGNUS_V850
:
4488 result
= get_v850_section_type_name (sh_type
);
4498 sprintf (buff
, "LOUSER+%#x", sh_type
- SHT_LOUSER
);
4501 /* This message is probably going to be displayed in a 15
4502 character wide field, so put the hex value first. */
4503 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
4509 enum long_option_values
4511 OPTION_DEBUG_DUMP
= 512,
4521 OPTION_WITH_SYMBOL_VERSIONS
,
4522 OPTION_RECURSE_LIMIT
,
4523 OPTION_NO_RECURSE_LIMIT
,
4524 OPTION_NO_DEMANGLING
4527 static struct option options
[] =
4529 /* Note - This table is alpha-sorted on the 'val'
4530 field in order to make adding new options easier. */
4531 {"arch-specific", no_argument
, 0, 'A'},
4532 {"all", no_argument
, 0, 'a'},
4533 {"demangle", optional_argument
, 0, 'C'},
4534 {"archive-index", no_argument
, 0, 'c'},
4535 {"use-dynamic", no_argument
, 0, 'D'},
4536 {"dynamic", no_argument
, 0, 'd'},
4537 {"headers", no_argument
, 0, 'e'},
4538 {"section-groups", no_argument
, 0, 'g'},
4539 {"help", no_argument
, 0, 'H'},
4540 {"file-header", no_argument
, 0, 'h'},
4541 {"histogram", no_argument
, 0, 'I'},
4542 {"lint", no_argument
, 0, 'L'},
4543 {"enable-checks", no_argument
, 0, 'L'},
4544 {"program-headers", no_argument
, 0, 'l'},
4545 {"segments", no_argument
, 0, 'l'},
4546 {"full-section-name",no_argument
, 0, 'N'},
4547 {"notes", no_argument
, 0, 'n'},
4548 {"string-dump", required_argument
, 0, 'p'},
4549 {"relocated-dump", required_argument
, 0, 'R'},
4550 {"relocs", no_argument
, 0, 'r'},
4551 {"section-headers", no_argument
, 0, 'S'},
4552 {"sections", no_argument
, 0, 'S'},
4553 {"symbols", no_argument
, 0, 's'},
4554 {"syms", no_argument
, 0, 's'},
4555 {"silent-truncation",no_argument
, 0, 'T'},
4556 {"section-details", no_argument
, 0, 't'},
4557 {"unwind", no_argument
, 0, 'u'},
4558 {"version-info", no_argument
, 0, 'V'},
4559 {"version", no_argument
, 0, 'v'},
4560 {"wide", no_argument
, 0, 'W'},
4561 {"hex-dump", required_argument
, 0, 'x'},
4562 {"decompress", no_argument
, 0, 'z'},
4564 {"no-demangle", no_argument
, 0, OPTION_NO_DEMANGLING
},
4565 {"recurse-limit", no_argument
, NULL
, OPTION_RECURSE_LIMIT
},
4566 {"no-recurse-limit", no_argument
, NULL
, OPTION_NO_RECURSE_LIMIT
},
4567 {"no-recursion-limit", no_argument
, NULL
, OPTION_NO_RECURSE_LIMIT
},
4568 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
4569 {"lto-syms", no_argument
, 0, OPTION_LTO_SYMS
},
4570 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
4571 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
4572 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
4573 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
4574 #ifdef ENABLE_LIBCTF
4575 {"ctf", required_argument
, 0, OPTION_CTF_DUMP
},
4576 {"ctf-symbols", required_argument
, 0, OPTION_CTF_SYMBOLS
},
4577 {"ctf-strings", required_argument
, 0, OPTION_CTF_STRINGS
},
4578 {"ctf-parent", required_argument
, 0, OPTION_CTF_PARENT
},
4581 {0, no_argument
, 0, 0}
4585 usage (FILE * stream
)
4587 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
4588 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
4589 fprintf (stream
, _(" Options are:\n\
4590 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4591 -h --file-header Display the ELF file header\n\
4592 -l --program-headers Display the program headers\n\
4593 --segments An alias for --program-headers\n\
4594 -S --section-headers Display the sections' header\n\
4595 --sections An alias for --section-headers\n\
4596 -g --section-groups Display the section groups\n\
4597 -t --section-details Display the section details\n\
4598 -e --headers Equivalent to: -h -l -S\n\
4599 -s --syms Display the symbol table\n\
4600 --symbols An alias for --syms\n\
4601 --dyn-syms Display the dynamic symbol table\n\
4602 --lto-syms Display LTO symbol tables\n\
4603 -C --demangle[=STYLE] Decode low-level symbol names into user-level names\n\
4604 The STYLE, if specified, can be `auto' (the default),\n\
4605 `gnu', `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
4607 --no-demangle Do not demangle low-level symbol names. (This is the default)\n\
4608 --recurse-limit Enable a demangling recursion limit. (This is the default)\n\
4609 --no-recurse-limit Disable a demangling recursion limit\n\
4610 -n --notes Display the core notes (if present)\n\
4611 -r --relocs Display the relocations (if present)\n\
4612 -u --unwind Display the unwind info (if present)\n\
4613 -d --dynamic Display the dynamic section (if present)\n\
4614 -V --version-info Display the version sections (if present)\n\
4615 -A --arch-specific Display architecture specific information (if any)\n\
4616 -c --archive-index Display the symbol/file index in an archive\n\
4617 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
4618 -L --lint|--enable-checks Display warning messages for possible problems\n\
4619 -x --hex-dump=<number|name>\n\
4620 Dump the contents of section <number|name> as bytes\n\
4621 -p --string-dump=<number|name>\n\
4622 Dump the contents of section <number|name> as strings\n\
4623 -R --relocated-dump=<number|name>\n\
4624 Dump the contents of section <number|name> as relocated bytes\n\
4625 -z --decompress Decompress section before dumping it\n\
4626 -w[lLiaprmfFsoORtUuTgAckK] or\n\
4627 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4628 =frames-interp,=str,=str-offsets,=loc,=Ranges,=pubtypes,\n\
4629 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4630 =addr,=cu_index,=links,=follow-links]\n\
4631 Display the contents of DWARF debug sections\n"));
4632 fprintf (stream
, _("\
4633 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4634 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4636 #ifdef ENABLE_LIBCTF
4637 fprintf (stream
, _("\
4638 --ctf=<number|name> Display CTF info from section <number|name>\n\
4639 --ctf-parent=<number|name>\n\
4640 Use section <number|name> as the CTF parent\n\n\
4641 --ctf-symbols=<number|name>\n\
4642 Use section <number|name> as the CTF external symtab\n\n\
4643 --ctf-strings=<number|name>\n\
4644 Use section <number|name> as the CTF external strtab\n\n"));
4647 #ifdef SUPPORT_DISASSEMBLY
4648 fprintf (stream
, _("\
4649 -i --instruction-dump=<number|name>\n\
4650 Disassemble the contents of section <number|name>\n"));
4652 fprintf (stream
, _("\
4653 -I --histogram Display histogram of bucket list lengths\n\
4654 -W --wide Allow output width to exceed 80 characters\n\
4655 -T --silent-truncation If a symbol name is truncated, do not add a suffix [...]\n\
4656 @<file> Read options from <file>\n\
4657 -H --help Display this information\n\
4658 -v --version Display the version number of readelf\n"));
4660 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
4661 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
4663 exit (stream
== stdout
? 0 : 1);
4666 /* Record the fact that the user wants the contents of section number
4667 SECTION to be displayed using the method(s) encoded as flags bits
4668 in TYPE. Note, TYPE can be zero if we are creating the array for
4672 request_dump_bynumber (struct dump_data
*dumpdata
,
4673 unsigned int section
, dump_type type
)
4675 if (section
>= dumpdata
->num_dump_sects
)
4677 dump_type
* new_dump_sects
;
4679 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
4680 sizeof (* new_dump_sects
));
4682 if (new_dump_sects
== NULL
)
4683 error (_("Out of memory allocating dump request table.\n"));
4686 if (dumpdata
->dump_sects
)
4688 /* Copy current flag settings. */
4689 memcpy (new_dump_sects
, dumpdata
->dump_sects
,
4690 dumpdata
->num_dump_sects
* sizeof (* new_dump_sects
));
4692 free (dumpdata
->dump_sects
);
4695 dumpdata
->dump_sects
= new_dump_sects
;
4696 dumpdata
->num_dump_sects
= section
+ 1;
4700 if (dumpdata
->dump_sects
)
4701 dumpdata
->dump_sects
[section
] |= type
;
4704 /* Request a dump by section name. */
4707 request_dump_byname (const char * section
, dump_type type
)
4709 struct dump_list_entry
* new_request
;
4711 new_request
= (struct dump_list_entry
*)
4712 malloc (sizeof (struct dump_list_entry
));
4714 error (_("Out of memory allocating dump request table.\n"));
4716 new_request
->name
= strdup (section
);
4717 if (!new_request
->name
)
4718 error (_("Out of memory allocating dump request table.\n"));
4720 new_request
->type
= type
;
4722 new_request
->next
= dump_sects_byname
;
4723 dump_sects_byname
= new_request
;
4727 request_dump (struct dump_data
*dumpdata
, dump_type type
)
4733 section
= strtoul (optarg
, & cp
, 0);
4735 if (! *cp
&& section
>= 0)
4736 request_dump_bynumber (dumpdata
, section
, type
);
4738 request_dump_byname (optarg
, type
);
4742 parse_args (struct dump_data
*dumpdata
, int argc
, char ** argv
)
4749 while ((c
= getopt_long
4750 (argc
, argv
, "ACDHILNR:STVWacdeghi:lnp:rstuvw::x:z", options
, NULL
)) != EOF
)
4768 do_section_groups
= TRUE
;
4771 do_histogram
= TRUE
;
4777 do_section_groups
= TRUE
;
4782 do_section_details
= TRUE
;
4793 do_using_dynamic
= TRUE
;
4817 do_histogram
= TRUE
;
4823 do_archive_index
= TRUE
;
4829 request_dump (dumpdata
, HEX_DUMP
);
4832 request_dump (dumpdata
, STRING_DUMP
);
4835 request_dump (dumpdata
, RELOC_DUMP
);
4838 decompress_dumps
= TRUE
;
4844 do_debugging
= TRUE
;
4845 dwarf_select_sections_all ();
4849 do_debugging
= FALSE
;
4850 dwarf_select_sections_by_letters (optarg
);
4853 case OPTION_DEBUG_DUMP
:
4856 do_debugging
= TRUE
;
4859 do_debugging
= FALSE
;
4860 dwarf_select_sections_by_names (optarg
);
4863 case OPTION_DWARF_DEPTH
:
4867 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
4870 case OPTION_DWARF_START
:
4874 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
4877 case OPTION_DWARF_CHECK
:
4880 case OPTION_CTF_DUMP
:
4882 request_dump (dumpdata
, CTF_DUMP
);
4884 case OPTION_CTF_SYMBOLS
:
4885 free (dump_ctf_symtab_name
);
4886 dump_ctf_symtab_name
= strdup (optarg
);
4888 case OPTION_CTF_STRINGS
:
4889 free (dump_ctf_strtab_name
);
4890 dump_ctf_strtab_name
= strdup (optarg
);
4892 case OPTION_CTF_PARENT
:
4893 free (dump_ctf_parent_name
);
4894 dump_ctf_parent_name
= strdup (optarg
);
4896 case OPTION_DYN_SYMS
:
4899 case OPTION_LTO_SYMS
:
4902 #ifdef SUPPORT_DISASSEMBLY
4904 request_dump (dumpdata
, DISASS_DUMP
);
4908 print_version (program_name
);
4917 do_not_show_symbol_truncation
= TRUE
;
4923 enum demangling_styles style
;
4925 style
= cplus_demangle_name_to_style (optarg
);
4926 if (style
== unknown_demangling
)
4927 error (_("unknown demangling style `%s'"), optarg
);
4929 cplus_demangle_set_style (style
);
4932 case OPTION_NO_DEMANGLING
:
4933 do_demangle
= FALSE
;
4935 case OPTION_RECURSE_LIMIT
:
4936 demangle_flags
&= ~ DMGL_NO_RECURSE_LIMIT
;
4938 case OPTION_NO_RECURSE_LIMIT
:
4939 demangle_flags
|= DMGL_NO_RECURSE_LIMIT
;
4941 case OPTION_WITH_SYMBOL_VERSIONS
:
4942 /* Ignored for backward compatibility. */
4946 /* xgettext:c-format */
4947 error (_("Invalid option '-%c'\n"), c
);
4954 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
4955 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
4956 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
4957 && !do_section_groups
&& !do_archive_index
4958 && !do_dyn_syms
&& !do_lto_syms
)
4963 do_dynamic
= do_syms
= do_reloc
= do_unwind
= do_sections
= TRUE
;
4964 do_segments
= do_header
= do_dump
= do_version
= TRUE
;
4965 do_histogram
= do_debugging
= do_arch
= do_notes
= TRUE
;
4966 do_section_groups
= do_archive_index
= do_dyn_syms
= TRUE
;
4975 get_elf_class (unsigned int elf_class
)
4977 static char buff
[32];
4981 case ELFCLASSNONE
: return _("none");
4982 case ELFCLASS32
: return "ELF32";
4983 case ELFCLASS64
: return "ELF64";
4985 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
4991 get_data_encoding (unsigned int encoding
)
4993 static char buff
[32];
4997 case ELFDATANONE
: return _("none");
4998 case ELFDATA2LSB
: return _("2's complement, little endian");
4999 case ELFDATA2MSB
: return _("2's complement, big endian");
5001 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
5006 /* Decode the data held in 'filedata->file_header'. */
5009 process_file_header (Filedata
* filedata
)
5011 Elf_Internal_Ehdr
* header
= & filedata
->file_header
;
5013 if ( header
->e_ident
[EI_MAG0
] != ELFMAG0
5014 || header
->e_ident
[EI_MAG1
] != ELFMAG1
5015 || header
->e_ident
[EI_MAG2
] != ELFMAG2
5016 || header
->e_ident
[EI_MAG3
] != ELFMAG3
)
5019 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
5023 init_dwarf_regnames_by_elf_machine_code (header
->e_machine
);
5029 printf (_("ELF Header:\n"));
5030 printf (_(" Magic: "));
5031 for (i
= 0; i
< EI_NIDENT
; i
++)
5032 printf ("%2.2x ", header
->e_ident
[i
]);
5034 printf (_(" Class: %s\n"),
5035 get_elf_class (header
->e_ident
[EI_CLASS
]));
5036 printf (_(" Data: %s\n"),
5037 get_data_encoding (header
->e_ident
[EI_DATA
]));
5038 printf (_(" Version: %d%s\n"),
5039 header
->e_ident
[EI_VERSION
],
5040 (header
->e_ident
[EI_VERSION
] == EV_CURRENT
5042 : (header
->e_ident
[EI_VERSION
] != EV_NONE
5045 printf (_(" OS/ABI: %s\n"),
5046 get_osabi_name (filedata
, header
->e_ident
[EI_OSABI
]));
5047 printf (_(" ABI Version: %d\n"),
5048 header
->e_ident
[EI_ABIVERSION
]);
5049 printf (_(" Type: %s\n"),
5050 get_file_type (header
->e_type
));
5051 printf (_(" Machine: %s\n"),
5052 get_machine_name (header
->e_machine
));
5053 printf (_(" Version: 0x%lx\n"),
5056 printf (_(" Entry point address: "));
5057 print_vma (header
->e_entry
, PREFIX_HEX
);
5058 printf (_("\n Start of program headers: "));
5059 print_vma (header
->e_phoff
, DEC
);
5060 printf (_(" (bytes into file)\n Start of section headers: "));
5061 print_vma (header
->e_shoff
, DEC
);
5062 printf (_(" (bytes into file)\n"));
5064 printf (_(" Flags: 0x%lx%s\n"),
5066 get_machine_flags (filedata
, header
->e_flags
, header
->e_machine
));
5067 printf (_(" Size of this header: %u (bytes)\n"),
5069 printf (_(" Size of program headers: %u (bytes)\n"),
5070 header
->e_phentsize
);
5071 printf (_(" Number of program headers: %u"),
5073 if (filedata
->section_headers
!= NULL
5074 && header
->e_phnum
== PN_XNUM
5075 && filedata
->section_headers
[0].sh_info
!= 0)
5077 header
->e_phnum
= filedata
->section_headers
[0].sh_info
;
5078 printf (" (%u)", header
->e_phnum
);
5080 putc ('\n', stdout
);
5081 printf (_(" Size of section headers: %u (bytes)\n"),
5082 header
->e_shentsize
);
5083 printf (_(" Number of section headers: %u"),
5085 if (filedata
->section_headers
!= NULL
&& header
->e_shnum
== SHN_UNDEF
)
5087 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
5088 printf (" (%u)", header
->e_shnum
);
5090 putc ('\n', stdout
);
5091 printf (_(" Section header string table index: %u"),
5092 header
->e_shstrndx
);
5093 if (filedata
->section_headers
!= NULL
5094 && header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
5096 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
5097 printf (" (%u)", header
->e_shstrndx
);
5099 if (header
->e_shstrndx
!= SHN_UNDEF
5100 && header
->e_shstrndx
>= header
->e_shnum
)
5102 header
->e_shstrndx
= SHN_UNDEF
;
5103 printf (_(" <corrupt: out of range>"));
5105 putc ('\n', stdout
);
5108 if (filedata
->section_headers
!= NULL
)
5110 if (header
->e_phnum
== PN_XNUM
5111 && filedata
->section_headers
[0].sh_info
!= 0)
5112 header
->e_phnum
= filedata
->section_headers
[0].sh_info
;
5113 if (header
->e_shnum
== SHN_UNDEF
)
5114 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
5115 if (header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
5116 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
5117 if (header
->e_shstrndx
>= header
->e_shnum
)
5118 header
->e_shstrndx
= SHN_UNDEF
;
5119 free (filedata
->section_headers
);
5120 filedata
->section_headers
= NULL
;
5126 /* Read in the program headers from FILEDATA and store them in PHEADERS.
5127 Returns TRUE upon success, FALSE otherwise. Loads 32-bit headers. */
5130 get_32bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
5132 Elf32_External_Phdr
* phdrs
;
5133 Elf32_External_Phdr
* external
;
5134 Elf_Internal_Phdr
* internal
;
5136 unsigned int size
= filedata
->file_header
.e_phentsize
;
5137 unsigned int num
= filedata
->file_header
.e_phnum
;
5139 /* PR binutils/17531: Cope with unexpected section header sizes. */
5140 if (size
== 0 || num
== 0)
5142 if (size
< sizeof * phdrs
)
5144 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
5147 if (size
> sizeof * phdrs
)
5148 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
5150 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
5151 size
, num
, _("program headers"));
5155 for (i
= 0, internal
= pheaders
, external
= phdrs
;
5156 i
< filedata
->file_header
.e_phnum
;
5157 i
++, internal
++, external
++)
5159 internal
->p_type
= BYTE_GET (external
->p_type
);
5160 internal
->p_offset
= BYTE_GET (external
->p_offset
);
5161 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
5162 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
5163 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
5164 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
5165 internal
->p_flags
= BYTE_GET (external
->p_flags
);
5166 internal
->p_align
= BYTE_GET (external
->p_align
);
5173 /* Read in the program headers from FILEDATA and store them in PHEADERS.
5174 Returns TRUE upon success, FALSE otherwise. Loads 64-bit headers. */
5177 get_64bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
5179 Elf64_External_Phdr
* phdrs
;
5180 Elf64_External_Phdr
* external
;
5181 Elf_Internal_Phdr
* internal
;
5183 unsigned int size
= filedata
->file_header
.e_phentsize
;
5184 unsigned int num
= filedata
->file_header
.e_phnum
;
5186 /* PR binutils/17531: Cope with unexpected section header sizes. */
5187 if (size
== 0 || num
== 0)
5189 if (size
< sizeof * phdrs
)
5191 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
5194 if (size
> sizeof * phdrs
)
5195 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
5197 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
5198 size
, num
, _("program headers"));
5202 for (i
= 0, internal
= pheaders
, external
= phdrs
;
5203 i
< filedata
->file_header
.e_phnum
;
5204 i
++, internal
++, external
++)
5206 internal
->p_type
= BYTE_GET (external
->p_type
);
5207 internal
->p_flags
= BYTE_GET (external
->p_flags
);
5208 internal
->p_offset
= BYTE_GET (external
->p_offset
);
5209 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
5210 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
5211 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
5212 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
5213 internal
->p_align
= BYTE_GET (external
->p_align
);
5220 /* Returns TRUE if the program headers were read into `program_headers'. */
5223 get_program_headers (Filedata
* filedata
)
5225 Elf_Internal_Phdr
* phdrs
;
5227 /* Check cache of prior read. */
5228 if (filedata
->program_headers
!= NULL
)
5231 /* Be kind to memory checkers by looking for
5232 e_phnum values which we know must be invalid. */
5233 if (filedata
->file_header
.e_phnum
5234 * (is_32bit_elf
? sizeof (Elf32_External_Phdr
) : sizeof (Elf64_External_Phdr
))
5235 >= filedata
->file_size
)
5237 error (_("Too many program headers - %#x - the file is not that big\n"),
5238 filedata
->file_header
.e_phnum
);
5242 phdrs
= (Elf_Internal_Phdr
*) cmalloc (filedata
->file_header
.e_phnum
,
5243 sizeof (Elf_Internal_Phdr
));
5246 error (_("Out of memory reading %u program headers\n"),
5247 filedata
->file_header
.e_phnum
);
5252 ? get_32bit_program_headers (filedata
, phdrs
)
5253 : get_64bit_program_headers (filedata
, phdrs
))
5255 filedata
->program_headers
= phdrs
;
5263 /* Returns TRUE if the program headers were loaded. */
5266 process_program_headers (Filedata
* filedata
)
5268 Elf_Internal_Phdr
* segment
;
5270 Elf_Internal_Phdr
* previous_load
= NULL
;
5272 filedata
->dynamic_addr
= 0;
5273 filedata
->dynamic_size
= 0;
5275 if (filedata
->file_header
.e_phnum
== 0)
5277 /* PR binutils/12467. */
5278 if (filedata
->file_header
.e_phoff
!= 0)
5280 warn (_("possibly corrupt ELF header - it has a non-zero program"
5281 " header offset, but no program headers\n"));
5284 else if (do_segments
)
5285 printf (_("\nThere are no program headers in this file.\n"));
5289 if (do_segments
&& !do_header
)
5291 printf (_("\nElf file type is %s\n"), get_file_type (filedata
->file_header
.e_type
));
5292 printf (_("Entry point 0x%s\n"), bfd_vmatoa ("x", filedata
->file_header
.e_entry
));
5293 printf (ngettext ("There is %d program header, starting at offset %s\n",
5294 "There are %d program headers, starting at offset %s\n",
5295 filedata
->file_header
.e_phnum
),
5296 filedata
->file_header
.e_phnum
,
5297 bfd_vmatoa ("u", filedata
->file_header
.e_phoff
));
5300 if (! get_program_headers (filedata
))
5305 if (filedata
->file_header
.e_phnum
> 1)
5306 printf (_("\nProgram Headers:\n"));
5308 printf (_("\nProgram Headers:\n"));
5312 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5315 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5319 (_(" Type Offset VirtAddr PhysAddr\n"));
5321 (_(" FileSiz MemSiz Flags Align\n"));
5325 for (i
= 0, segment
= filedata
->program_headers
;
5326 i
< filedata
->file_header
.e_phnum
;
5331 printf (" %-14.14s ", get_segment_type (filedata
, segment
->p_type
));
5335 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
5336 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
5337 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
5338 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
5339 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
5341 (segment
->p_flags
& PF_R
? 'R' : ' '),
5342 (segment
->p_flags
& PF_W
? 'W' : ' '),
5343 (segment
->p_flags
& PF_X
? 'E' : ' '));
5344 printf ("%#lx", (unsigned long) segment
->p_align
);
5348 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
5349 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
5352 print_vma (segment
->p_offset
, FULL_HEX
);
5356 print_vma (segment
->p_vaddr
, FULL_HEX
);
5358 print_vma (segment
->p_paddr
, FULL_HEX
);
5361 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
5362 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
5365 print_vma (segment
->p_filesz
, FULL_HEX
);
5369 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
5370 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
5373 print_vma (segment
->p_memsz
, FULL_HEX
);
5377 (segment
->p_flags
& PF_R
? 'R' : ' '),
5378 (segment
->p_flags
& PF_W
? 'W' : ' '),
5379 (segment
->p_flags
& PF_X
? 'E' : ' '));
5381 if ((unsigned long) segment
->p_align
== segment
->p_align
)
5382 printf ("%#lx", (unsigned long) segment
->p_align
);
5385 print_vma (segment
->p_align
, PREFIX_HEX
);
5390 print_vma (segment
->p_offset
, FULL_HEX
);
5392 print_vma (segment
->p_vaddr
, FULL_HEX
);
5394 print_vma (segment
->p_paddr
, FULL_HEX
);
5396 print_vma (segment
->p_filesz
, FULL_HEX
);
5398 print_vma (segment
->p_memsz
, FULL_HEX
);
5400 (segment
->p_flags
& PF_R
? 'R' : ' '),
5401 (segment
->p_flags
& PF_W
? 'W' : ' '),
5402 (segment
->p_flags
& PF_X
? 'E' : ' '));
5403 print_vma (segment
->p_align
, PREFIX_HEX
);
5406 putc ('\n', stdout
);
5409 switch (segment
->p_type
)
5412 #if 0 /* Do not warn about out of order PT_LOAD segments. Although officially
5413 required by the ELF standard, several programs, including the Linux
5414 kernel, make use of non-ordered segments. */
5416 && previous_load
->p_vaddr
> segment
->p_vaddr
)
5417 error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
5419 if (segment
->p_memsz
< segment
->p_filesz
)
5420 error (_("the segment's file size is larger than its memory size\n"));
5421 previous_load
= segment
;
5425 /* PR 20815 - Verify that the program header is loaded into memory. */
5426 if (i
> 0 && previous_load
!= NULL
)
5427 error (_("the PHDR segment must occur before any LOAD segment\n"));
5428 if (filedata
->file_header
.e_machine
!= EM_PARISC
)
5432 for (j
= 1; j
< filedata
->file_header
.e_phnum
; j
++)
5434 Elf_Internal_Phdr
*load
= filedata
->program_headers
+ j
;
5435 if (load
->p_type
== PT_LOAD
5436 && load
->p_offset
<= segment
->p_offset
5437 && (load
->p_offset
+ load
->p_filesz
5438 >= segment
->p_offset
+ segment
->p_filesz
)
5439 && load
->p_vaddr
<= segment
->p_vaddr
5440 && (load
->p_vaddr
+ load
->p_filesz
5441 >= segment
->p_vaddr
+ segment
->p_filesz
))
5444 if (j
== filedata
->file_header
.e_phnum
)
5445 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5450 if (filedata
->dynamic_addr
)
5451 error (_("more than one dynamic segment\n"));
5453 /* By default, assume that the .dynamic section is the first
5454 section in the DYNAMIC segment. */
5455 filedata
->dynamic_addr
= segment
->p_offset
;
5456 filedata
->dynamic_size
= segment
->p_filesz
;
5458 /* Try to locate the .dynamic section. If there is
5459 a section header table, we can easily locate it. */
5460 if (filedata
->section_headers
!= NULL
)
5462 Elf_Internal_Shdr
* sec
;
5464 sec
= find_section (filedata
, ".dynamic");
5465 if (sec
== NULL
|| sec
->sh_size
== 0)
5467 /* A corresponding .dynamic section is expected, but on
5468 IA-64/OpenVMS it is OK for it to be missing. */
5469 if (!is_ia64_vms (filedata
))
5470 error (_("no .dynamic section in the dynamic segment\n"));
5474 if (sec
->sh_type
== SHT_NOBITS
)
5476 filedata
->dynamic_size
= 0;
5480 filedata
->dynamic_addr
= sec
->sh_offset
;
5481 filedata
->dynamic_size
= sec
->sh_size
;
5483 /* The PT_DYNAMIC segment, which is used by the run-time
5484 loader, should exactly match the .dynamic section. */
5486 && (filedata
->dynamic_addr
!= segment
->p_offset
5487 || filedata
->dynamic_size
!= segment
->p_filesz
))
5489 the .dynamic section is not the same as the dynamic segment\n"));
5492 /* PR binutils/17512: Avoid corrupt dynamic section info in the
5493 segment. Check this after matching against the section headers
5494 so we don't warn on debuginfo file (which have NOBITS .dynamic
5496 if (filedata
->dynamic_addr
> filedata
->file_size
5497 || (filedata
->dynamic_size
5498 > filedata
->file_size
- filedata
->dynamic_addr
))
5500 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5501 filedata
->dynamic_addr
= filedata
->dynamic_size
= 0;
5506 if (fseek (filedata
->handle
,
5507 filedata
->archive_file_offset
+ (long) segment
->p_offset
,
5509 error (_("Unable to find program interpreter name\n"));
5513 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
- 1);
5515 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
5516 error (_("Internal error: failed to create format string to display program interpreter\n"));
5518 filedata
->program_interpreter
[0] = 0;
5519 if (fscanf (filedata
->handle
, fmt
,
5520 filedata
->program_interpreter
) <= 0)
5521 error (_("Unable to read program interpreter name\n"));
5524 printf (_(" [Requesting program interpreter: %s]\n"),
5525 filedata
->program_interpreter
);
5532 && filedata
->section_headers
!= NULL
5533 && filedata
->string_table
!= NULL
)
5535 printf (_("\n Section to Segment mapping:\n"));
5536 printf (_(" Segment Sections...\n"));
5538 for (i
= 0; i
< filedata
->file_header
.e_phnum
; i
++)
5541 Elf_Internal_Shdr
* section
;
5543 segment
= filedata
->program_headers
+ i
;
5544 section
= filedata
->section_headers
+ 1;
5546 printf (" %2.2d ", i
);
5548 for (j
= 1; j
< filedata
->file_header
.e_shnum
; j
++, section
++)
5550 if (!ELF_TBSS_SPECIAL (section
, segment
)
5551 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
5552 printf ("%s ", printable_section_name (filedata
, section
));
5563 /* Find the file offset corresponding to VMA by using the program headers. */
5566 offset_from_vma (Filedata
* filedata
, bfd_vma vma
, bfd_size_type size
)
5568 Elf_Internal_Phdr
* seg
;
5570 if (! get_program_headers (filedata
))
5572 warn (_("Cannot interpret virtual addresses without program headers.\n"));
5576 for (seg
= filedata
->program_headers
;
5577 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
5580 if (seg
->p_type
!= PT_LOAD
)
5583 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
5584 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
5585 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
5588 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5589 (unsigned long) vma
);
5594 /* Allocate memory and load the sections headers into FILEDATA->filedata->section_headers.
5595 If PROBE is true, this is just a probe and we do not generate any error
5596 messages if the load fails. */
5599 get_32bit_section_headers (Filedata
* filedata
, bfd_boolean probe
)
5601 Elf32_External_Shdr
* shdrs
;
5602 Elf_Internal_Shdr
* internal
;
5604 unsigned int size
= filedata
->file_header
.e_shentsize
;
5605 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
5607 /* PR binutils/17531: Cope with unexpected section header sizes. */
5608 if (size
== 0 || num
== 0)
5610 if (size
< sizeof * shdrs
)
5613 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5616 if (!probe
&& size
> sizeof * shdrs
)
5617 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5619 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_shoff
,
5621 probe
? NULL
: _("section headers"));
5625 free (filedata
->section_headers
);
5626 filedata
->section_headers
= (Elf_Internal_Shdr
*)
5627 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
5628 if (filedata
->section_headers
== NULL
)
5631 error (_("Out of memory reading %u section headers\n"), num
);
5636 for (i
= 0, internal
= filedata
->section_headers
;
5640 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5641 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5642 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5643 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5644 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5645 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5646 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5647 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5648 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5649 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5650 if (!probe
&& internal
->sh_link
> num
)
5651 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5652 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5653 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5660 /* Like get_32bit_section_headers, except that it fetches 64-bit headers. */
5663 get_64bit_section_headers (Filedata
* filedata
, bfd_boolean probe
)
5665 Elf64_External_Shdr
* shdrs
;
5666 Elf_Internal_Shdr
* internal
;
5668 unsigned int size
= filedata
->file_header
.e_shentsize
;
5669 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
5671 /* PR binutils/17531: Cope with unexpected section header sizes. */
5672 if (size
== 0 || num
== 0)
5675 if (size
< sizeof * shdrs
)
5678 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5682 if (! probe
&& size
> sizeof * shdrs
)
5683 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5685 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, filedata
,
5686 filedata
->file_header
.e_shoff
,
5688 probe
? NULL
: _("section headers"));
5692 free (filedata
->section_headers
);
5693 filedata
->section_headers
= (Elf_Internal_Shdr
*)
5694 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
5695 if (filedata
->section_headers
== NULL
)
5698 error (_("Out of memory reading %u section headers\n"), num
);
5703 for (i
= 0, internal
= filedata
->section_headers
;
5707 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5708 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5709 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5710 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5711 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5712 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5713 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5714 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5715 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5716 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5717 if (!probe
&& internal
->sh_link
> num
)
5718 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5719 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5720 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5727 static Elf_Internal_Sym
*
5728 get_32bit_elf_symbols (Filedata
* filedata
,
5729 Elf_Internal_Shdr
* section
,
5730 unsigned long * num_syms_return
)
5732 unsigned long number
= 0;
5733 Elf32_External_Sym
* esyms
= NULL
;
5734 Elf_External_Sym_Shndx
* shndx
= NULL
;
5735 Elf_Internal_Sym
* isyms
= NULL
;
5736 Elf_Internal_Sym
* psym
;
5738 elf_section_list
* entry
;
5740 if (section
->sh_size
== 0)
5742 if (num_syms_return
!= NULL
)
5743 * num_syms_return
= 0;
5747 /* Run some sanity checks first. */
5748 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5750 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5751 printable_section_name (filedata
, section
),
5752 (unsigned long) section
->sh_entsize
);
5756 if (section
->sh_size
> filedata
->file_size
)
5758 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5759 printable_section_name (filedata
, section
),
5760 (unsigned long) section
->sh_size
);
5764 number
= section
->sh_size
/ section
->sh_entsize
;
5766 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
5768 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5769 (unsigned long) section
->sh_size
,
5770 printable_section_name (filedata
, section
),
5771 (unsigned long) section
->sh_entsize
);
5775 esyms
= (Elf32_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
5776 section
->sh_size
, _("symbols"));
5781 for (entry
= filedata
->symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5783 if (entry
->hdr
->sh_link
!= (unsigned long) (section
- filedata
->section_headers
))
5788 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5792 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
5793 entry
->hdr
->sh_offset
,
5794 1, entry
->hdr
->sh_size
,
5795 _("symbol table section indices"));
5799 /* PR17531: file: heap-buffer-overflow */
5800 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5802 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5803 printable_section_name (filedata
, entry
->hdr
),
5804 (unsigned long) entry
->hdr
->sh_size
,
5805 (unsigned long) section
->sh_size
);
5810 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5814 error (_("Out of memory reading %lu symbols\n"),
5815 (unsigned long) number
);
5819 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5821 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5822 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5823 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5824 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5825 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5827 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5828 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5829 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5830 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5831 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5838 if (num_syms_return
!= NULL
)
5839 * num_syms_return
= isyms
== NULL
? 0 : number
;
5844 static Elf_Internal_Sym
*
5845 get_64bit_elf_symbols (Filedata
* filedata
,
5846 Elf_Internal_Shdr
* section
,
5847 unsigned long * num_syms_return
)
5849 unsigned long number
= 0;
5850 Elf64_External_Sym
* esyms
= NULL
;
5851 Elf_External_Sym_Shndx
* shndx
= NULL
;
5852 Elf_Internal_Sym
* isyms
= NULL
;
5853 Elf_Internal_Sym
* psym
;
5855 elf_section_list
* entry
;
5857 if (section
->sh_size
== 0)
5859 if (num_syms_return
!= NULL
)
5860 * num_syms_return
= 0;
5864 /* Run some sanity checks first. */
5865 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5867 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5868 printable_section_name (filedata
, section
),
5869 (unsigned long) section
->sh_entsize
);
5873 if (section
->sh_size
> filedata
->file_size
)
5875 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5876 printable_section_name (filedata
, section
),
5877 (unsigned long) section
->sh_size
);
5881 number
= section
->sh_size
/ section
->sh_entsize
;
5883 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
5885 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5886 (unsigned long) section
->sh_size
,
5887 printable_section_name (filedata
, section
),
5888 (unsigned long) section
->sh_entsize
);
5892 esyms
= (Elf64_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
5893 section
->sh_size
, _("symbols"));
5898 for (entry
= filedata
->symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5900 if (entry
->hdr
->sh_link
!= (unsigned long) (section
- filedata
->section_headers
))
5905 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5909 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
5910 entry
->hdr
->sh_offset
,
5911 1, entry
->hdr
->sh_size
,
5912 _("symbol table section indices"));
5916 /* PR17531: file: heap-buffer-overflow */
5917 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5919 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5920 printable_section_name (filedata
, entry
->hdr
),
5921 (unsigned long) entry
->hdr
->sh_size
,
5922 (unsigned long) section
->sh_size
);
5927 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5931 error (_("Out of memory reading %lu symbols\n"),
5932 (unsigned long) number
);
5936 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5938 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5939 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5940 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5941 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5943 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5945 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5946 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5947 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5949 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5950 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5957 if (num_syms_return
!= NULL
)
5958 * num_syms_return
= isyms
== NULL
? 0 : number
;
5964 get_elf_section_flags (Filedata
* filedata
, bfd_vma sh_flags
)
5966 static char buff
[1024];
5968 unsigned int field_size
= is_32bit_elf
? 8 : 16;
5970 unsigned int size
= sizeof (buff
) - (field_size
+ 4 + 1);
5971 bfd_vma os_flags
= 0;
5972 bfd_vma proc_flags
= 0;
5973 bfd_vma unknown_flags
= 0;
5981 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5982 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5983 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5984 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5985 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5986 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5987 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5988 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5989 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5990 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5991 /* IA-64 specific. */
5992 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5993 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5994 /* IA-64 OpenVMS specific. */
5995 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5996 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5997 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5998 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5999 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
6000 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
6002 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
6003 /* SPARC specific. */
6004 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
6005 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
6007 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
6008 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
6009 /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
6011 /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
6013 /* 25 */ { STRING_COMMA_LEN ("VLE") },
6015 /* 26 */ { STRING_COMMA_LEN ("GNU_RETAIN") },
6018 if (do_section_details
)
6020 sprintf (buff
, "[%*.*lx]: ",
6021 field_size
, field_size
, (unsigned long) sh_flags
);
6022 p
+= field_size
+ 4;
6029 flag
= sh_flags
& - sh_flags
;
6032 if (do_section_details
)
6036 case SHF_WRITE
: sindex
= 0; break;
6037 case SHF_ALLOC
: sindex
= 1; break;
6038 case SHF_EXECINSTR
: sindex
= 2; break;
6039 case SHF_MERGE
: sindex
= 3; break;
6040 case SHF_STRINGS
: sindex
= 4; break;
6041 case SHF_INFO_LINK
: sindex
= 5; break;
6042 case SHF_LINK_ORDER
: sindex
= 6; break;
6043 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
6044 case SHF_GROUP
: sindex
= 8; break;
6045 case SHF_TLS
: sindex
= 9; break;
6046 case SHF_EXCLUDE
: sindex
= 18; break;
6047 case SHF_COMPRESSED
: sindex
= 20; break;
6051 switch (filedata
->file_header
.e_machine
)
6054 if (flag
== SHF_IA_64_SHORT
)
6056 else if (flag
== SHF_IA_64_NORECOV
)
6059 else if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
6062 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
6063 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
6064 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
6065 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
6066 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
6067 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
6078 case EM_OLD_SPARCV9
:
6079 case EM_SPARC32PLUS
:
6082 if (flag
== SHF_ORDERED
)
6089 case SHF_ENTRYSECT
: sindex
= 21; break;
6090 case SHF_ARM_PURECODE
: sindex
= 22; break;
6091 case SHF_COMDEF
: sindex
= 23; break;
6096 if (flag
== SHF_PPC_VLE
)
6103 switch (filedata
->file_header
.e_ident
[EI_OSABI
])
6106 case ELFOSABI_FREEBSD
:
6107 if (flag
== SHF_GNU_RETAIN
)
6111 if (flag
== SHF_GNU_MBIND
)
6112 /* We should not recognize SHF_GNU_MBIND for
6113 ELFOSABI_NONE, but binutils as of 2019-07-23 did
6114 not set the EI_OSABI header byte. */
6125 if (p
!= buff
+ field_size
+ 4)
6127 if (size
< (10 + 2))
6129 warn (_("Internal error: not enough buffer room for section flag info"));
6130 return _("<unknown>");
6137 size
-= flags
[sindex
].len
;
6138 p
= stpcpy (p
, flags
[sindex
].str
);
6140 else if (flag
& SHF_MASKOS
)
6142 else if (flag
& SHF_MASKPROC
)
6145 unknown_flags
|= flag
;
6151 case SHF_WRITE
: *p
= 'W'; break;
6152 case SHF_ALLOC
: *p
= 'A'; break;
6153 case SHF_EXECINSTR
: *p
= 'X'; break;
6154 case SHF_MERGE
: *p
= 'M'; break;
6155 case SHF_STRINGS
: *p
= 'S'; break;
6156 case SHF_INFO_LINK
: *p
= 'I'; break;
6157 case SHF_LINK_ORDER
: *p
= 'L'; break;
6158 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
6159 case SHF_GROUP
: *p
= 'G'; break;
6160 case SHF_TLS
: *p
= 'T'; break;
6161 case SHF_EXCLUDE
: *p
= 'E'; break;
6162 case SHF_COMPRESSED
: *p
= 'C'; break;
6165 if ((filedata
->file_header
.e_machine
== EM_X86_64
6166 || filedata
->file_header
.e_machine
== EM_L1OM
6167 || filedata
->file_header
.e_machine
== EM_K1OM
)
6168 && flag
== SHF_X86_64_LARGE
)
6170 else if (filedata
->file_header
.e_machine
== EM_ARM
6171 && flag
== SHF_ARM_PURECODE
)
6173 else if (filedata
->file_header
.e_machine
== EM_PPC
6174 && flag
== SHF_PPC_VLE
)
6176 else if (flag
& SHF_MASKOS
)
6178 switch (filedata
->file_header
.e_ident
[EI_OSABI
])
6181 case ELFOSABI_FREEBSD
:
6182 if (flag
== SHF_GNU_RETAIN
)
6189 if (flag
== SHF_GNU_MBIND
)
6191 /* We should not recognize SHF_GNU_MBIND for
6192 ELFOSABI_NONE, but binutils as of 2019-07-23 did
6193 not set the EI_OSABI header byte. */
6200 sh_flags
&= ~SHF_MASKOS
;
6204 else if (flag
& SHF_MASKPROC
)
6207 sh_flags
&= ~ SHF_MASKPROC
;
6217 if (do_section_details
)
6221 size
-= 5 + field_size
;
6222 if (p
!= buff
+ field_size
+ 4)
6226 warn (_("Internal error: not enough buffer room for section flag info"));
6227 return _("<unknown>");
6233 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
6234 (unsigned long) os_flags
);
6235 p
+= 5 + field_size
;
6239 size
-= 7 + field_size
;
6240 if (p
!= buff
+ field_size
+ 4)
6244 warn (_("Internal error: not enough buffer room for section flag info"));
6245 return _("<unknown>");
6251 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
6252 (unsigned long) proc_flags
);
6253 p
+= 7 + field_size
;
6257 size
-= 10 + field_size
;
6258 if (p
!= buff
+ field_size
+ 4)
6262 warn (_("Internal error: not enough buffer room for section flag info"));
6263 return _("<unknown>");
6269 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
6270 (unsigned long) unknown_flags
);
6271 p
+= 10 + field_size
;
6279 static unsigned int ATTRIBUTE_WARN_UNUSED_RESULT
6280 get_compression_header (Elf_Internal_Chdr
*chdr
, unsigned char *buf
, bfd_size_type size
)
6284 Elf32_External_Chdr
*echdr
= (Elf32_External_Chdr
*) buf
;
6286 if (size
< sizeof (* echdr
))
6288 error (_("Compressed section is too small even for a compression header\n"));
6292 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
6293 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
6294 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
6295 return sizeof (*echdr
);
6299 Elf64_External_Chdr
*echdr
= (Elf64_External_Chdr
*) buf
;
6301 if (size
< sizeof (* echdr
))
6303 error (_("Compressed section is too small even for a compression header\n"));
6307 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
6308 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
6309 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
6310 return sizeof (*echdr
);
6315 process_section_headers (Filedata
* filedata
)
6317 Elf_Internal_Shdr
* section
;
6320 free (filedata
->section_headers
);
6321 filedata
->section_headers
= NULL
;
6322 free (filedata
->dynamic_symbols
);
6323 filedata
->dynamic_symbols
= NULL
;
6324 filedata
->num_dynamic_syms
= 0;
6325 free (filedata
->dynamic_strings
);
6326 filedata
->dynamic_strings
= NULL
;
6327 filedata
->dynamic_strings_length
= 0;
6328 free (filedata
->dynamic_syminfo
);
6329 filedata
->dynamic_syminfo
= NULL
;
6330 while (filedata
->symtab_shndx_list
!= NULL
)
6332 elf_section_list
*next
= filedata
->symtab_shndx_list
->next
;
6333 free (filedata
->symtab_shndx_list
);
6334 filedata
->symtab_shndx_list
= next
;
6337 if (filedata
->file_header
.e_shnum
== 0)
6339 /* PR binutils/12467. */
6340 if (filedata
->file_header
.e_shoff
!= 0)
6342 warn (_("possibly corrupt ELF file header - it has a non-zero"
6343 " section header offset, but no section headers\n"));
6346 else if (do_sections
)
6347 printf (_("\nThere are no sections in this file.\n"));
6352 if (do_sections
&& !do_header
)
6353 printf (ngettext ("There is %d section header, "
6354 "starting at offset 0x%lx:\n",
6355 "There are %d section headers, "
6356 "starting at offset 0x%lx:\n",
6357 filedata
->file_header
.e_shnum
),
6358 filedata
->file_header
.e_shnum
,
6359 (unsigned long) filedata
->file_header
.e_shoff
);
6363 if (! get_32bit_section_headers (filedata
, FALSE
))
6368 if (! get_64bit_section_headers (filedata
, FALSE
))
6372 /* Read in the string table, so that we have names to display. */
6373 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
6374 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
6376 section
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
6378 if (section
->sh_size
!= 0)
6380 filedata
->string_table
= (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6381 1, section
->sh_size
,
6384 filedata
->string_table_length
= filedata
->string_table
!= NULL
? section
->sh_size
: 0;
6388 /* Scan the sections for the dynamic symbol table
6389 and dynamic string table and debug sections. */
6390 eh_addr_size
= is_32bit_elf
? 4 : 8;
6391 switch (filedata
->file_header
.e_machine
)
6394 case EM_MIPS_RS3_LE
:
6395 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
6396 FDE addresses. However, the ABI also has a semi-official ILP32
6397 variant for which the normal FDE address size rules apply.
6399 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
6400 section, where XX is the size of longs in bits. Unfortunately,
6401 earlier compilers provided no way of distinguishing ILP32 objects
6402 from LP64 objects, so if there's any doubt, we should assume that
6403 the official LP64 form is being used. */
6404 if ((filedata
->file_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
6405 && find_section (filedata
, ".gcc_compiled_long32") == NULL
)
6411 switch (filedata
->file_header
.e_flags
& EF_H8_MACH
)
6413 case E_H8_MACH_H8300
:
6414 case E_H8_MACH_H8300HN
:
6415 case E_H8_MACH_H8300SN
:
6416 case E_H8_MACH_H8300SXN
:
6419 case E_H8_MACH_H8300H
:
6420 case E_H8_MACH_H8300S
:
6421 case E_H8_MACH_H8300SX
:
6429 switch (filedata
->file_header
.e_flags
& EF_M32C_CPU_MASK
)
6431 case EF_M32C_CPU_M16C
:
6438 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
6441 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
6442 if (section->sh_entsize != expected_entsize) \
6445 sprintf_vma (buf, section->sh_entsize); \
6446 /* Note: coded this way so that there is a single string for \
6448 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
6449 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
6450 (unsigned) expected_entsize); \
6451 section->sh_entsize = expected_entsize; \
6456 #define CHECK_ENTSIZE(section, i, type) \
6457 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
6458 sizeof (Elf64_External_##type))
6460 for (i
= 0, section
= filedata
->section_headers
;
6461 i
< filedata
->file_header
.e_shnum
;
6464 char * name
= SECTION_NAME_PRINT (section
);
6466 /* Run some sanity checks on the headers and
6467 possibly fill in some file data as well. */
6468 switch (section
->sh_type
)
6471 if (filedata
->dynamic_symbols
!= NULL
)
6473 error (_("File contains multiple dynamic symbol tables\n"));
6477 CHECK_ENTSIZE (section
, i
, Sym
);
6478 filedata
->dynamic_symbols
6479 = GET_ELF_SYMBOLS (filedata
, section
, &filedata
->num_dynamic_syms
);
6480 filedata
->dynamic_symtab_section
= section
;
6484 if (streq (name
, ".dynstr"))
6486 if (filedata
->dynamic_strings
!= NULL
)
6488 error (_("File contains multiple dynamic string tables\n"));
6492 filedata
->dynamic_strings
6493 = (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6494 1, section
->sh_size
, _("dynamic strings"));
6495 filedata
->dynamic_strings_length
6496 = filedata
->dynamic_strings
== NULL
? 0 : section
->sh_size
;
6497 filedata
->dynamic_strtab_section
= section
;
6501 case SHT_SYMTAB_SHNDX
:
6503 elf_section_list
* entry
= xmalloc (sizeof * entry
);
6505 entry
->hdr
= section
;
6506 entry
->next
= filedata
->symtab_shndx_list
;
6507 filedata
->symtab_shndx_list
= entry
;
6512 CHECK_ENTSIZE (section
, i
, Sym
);
6516 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
6520 CHECK_ENTSIZE (section
, i
, Rel
);
6521 if (do_checks
&& section
->sh_size
== 0)
6522 warn (_("Section '%s': zero-sized relocation section\n"), name
);
6526 CHECK_ENTSIZE (section
, i
, Rela
);
6527 if (do_checks
&& section
->sh_size
== 0)
6528 warn (_("Section '%s': zero-sized relocation section\n"), name
);
6533 /* Having a zero sized section is not illegal according to the
6534 ELF standard, but it might be an indication that something
6535 is wrong. So issue a warning if we are running in lint mode. */
6536 if (do_checks
&& section
->sh_size
== 0)
6537 warn (_("Section '%s': has a size of zero - is this intended ?\n"), name
);
6544 if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
6545 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
6546 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
6547 || do_debug_str
|| do_debug_str_offsets
|| do_debug_loc
|| do_debug_ranges
6548 || do_debug_addr
|| do_debug_cu_index
|| do_debug_links
)
6549 && (const_strneq (name
, ".debug_")
6550 || const_strneq (name
, ".zdebug_")))
6553 name
+= sizeof (".zdebug_") - 1;
6555 name
+= sizeof (".debug_") - 1;
6558 || (do_debug_info
&& const_strneq (name
, "info"))
6559 || (do_debug_info
&& const_strneq (name
, "types"))
6560 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
6561 || (do_debug_lines
&& strcmp (name
, "line") == 0)
6562 || (do_debug_lines
&& const_strneq (name
, "line."))
6563 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
6564 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
6565 || (do_debug_pubnames
&& const_strneq (name
, "gnu_pubnames"))
6566 || (do_debug_pubtypes
&& const_strneq (name
, "gnu_pubtypes"))
6567 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
6568 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
6569 || (do_debug_ranges
&& const_strneq (name
, "rnglists"))
6570 || (do_debug_frames
&& const_strneq (name
, "frame"))
6571 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
6572 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
6573 || (do_debug_str
&& const_strneq (name
, "str"))
6574 || (do_debug_str_offsets
&& const_strneq (name
, "str_offsets"))
6575 || (do_debug_loc
&& const_strneq (name
, "loc"))
6576 || (do_debug_loc
&& const_strneq (name
, "loclists"))
6577 || (do_debug_addr
&& const_strneq (name
, "addr"))
6578 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
6579 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
6581 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6583 /* Linkonce section to be combined with .debug_info at link time. */
6584 else if ((do_debugging
|| do_debug_info
)
6585 && const_strneq (name
, ".gnu.linkonce.wi."))
6586 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6587 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
6588 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6589 else if (do_gdb_index
&& (streq (name
, ".gdb_index")
6590 || streq (name
, ".debug_names")))
6591 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6592 /* Trace sections for Itanium VMS. */
6593 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
6594 || do_trace_aranges
)
6595 && const_strneq (name
, ".trace_"))
6597 name
+= sizeof (".trace_") - 1;
6600 || (do_trace_info
&& streq (name
, "info"))
6601 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
6602 || (do_trace_aranges
&& streq (name
, "aranges"))
6604 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6606 else if ((do_debugging
|| do_debug_links
)
6607 && (const_strneq (name
, ".gnu_debuglink")
6608 || const_strneq (name
, ".gnu_debugaltlink")))
6609 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6615 if (filedata
->file_header
.e_shnum
> 1)
6616 printf (_("\nSection Headers:\n"));
6618 printf (_("\nSection Header:\n"));
6622 if (do_section_details
)
6624 printf (_(" [Nr] Name\n"));
6625 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
6629 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
6633 if (do_section_details
)
6635 printf (_(" [Nr] Name\n"));
6636 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
6640 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
6644 if (do_section_details
)
6646 printf (_(" [Nr] Name\n"));
6647 printf (_(" Type Address Offset Link\n"));
6648 printf (_(" Size EntSize Info Align\n"));
6652 printf (_(" [Nr] Name Type Address Offset\n"));
6653 printf (_(" Size EntSize Flags Link Info Align\n"));
6657 if (do_section_details
)
6658 printf (_(" Flags\n"));
6660 for (i
= 0, section
= filedata
->section_headers
;
6661 i
< filedata
->file_header
.e_shnum
;
6664 /* Run some sanity checks on the section header. */
6666 /* Check the sh_link field. */
6667 switch (section
->sh_type
)
6671 if (section
->sh_link
== 0
6672 && (filedata
->file_header
.e_type
== ET_EXEC
6673 || filedata
->file_header
.e_type
== ET_DYN
))
6674 /* A dynamic relocation section where all entries use a
6675 zero symbol index need not specify a symtab section. */
6678 case SHT_SYMTAB_SHNDX
:
6682 case SHT_GNU_versym
:
6683 if (section
->sh_link
== 0
6684 || section
->sh_link
>= filedata
->file_header
.e_shnum
6685 || (filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_SYMTAB
6686 && filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_DYNSYM
))
6687 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6688 i
, section
->sh_link
);
6694 case SHT_GNU_verneed
:
6695 case SHT_GNU_verdef
:
6696 case SHT_GNU_LIBLIST
:
6697 if (section
->sh_link
== 0
6698 || section
->sh_link
>= filedata
->file_header
.e_shnum
6699 || filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_STRTAB
)
6700 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6701 i
, section
->sh_link
);
6704 case SHT_INIT_ARRAY
:
6705 case SHT_FINI_ARRAY
:
6706 case SHT_PREINIT_ARRAY
:
6707 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6708 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6709 i
, section
->sh_link
);
6713 /* FIXME: Add support for target specific section types. */
6714 #if 0 /* Currently we do not check other section types as there are too
6715 many special cases. Stab sections for example have a type
6716 of SHT_PROGBITS but an sh_link field that links to the .stabstr
6718 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6719 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6720 i
, section
->sh_link
);
6725 /* Check the sh_info field. */
6726 switch (section
->sh_type
)
6730 if (section
->sh_info
== 0
6731 && (filedata
->file_header
.e_type
== ET_EXEC
6732 || filedata
->file_header
.e_type
== ET_DYN
))
6733 /* Dynamic relocations apply to segments, so they do not
6734 need to specify the section they relocate. */
6736 if (section
->sh_info
== 0
6737 || section
->sh_info
>= filedata
->file_header
.e_shnum
6738 || (filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PROGBITS
6739 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOBITS
6740 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOTE
6741 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_INIT_ARRAY
6742 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_FINI_ARRAY
6743 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PREINIT_ARRAY
6744 /* FIXME: Are other section types valid ? */
6745 && filedata
->section_headers
[section
->sh_info
].sh_type
< SHT_LOOS
))
6746 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6747 i
, section
->sh_info
);
6752 case SHT_SYMTAB_SHNDX
:
6753 case SHT_INIT_ARRAY
:
6754 case SHT_FINI_ARRAY
:
6755 case SHT_PREINIT_ARRAY
:
6756 if (section
->sh_info
!= 0)
6757 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6758 i
, section
->sh_info
);
6764 /* A symbol index - we assume that it is valid. */
6768 /* FIXME: Add support for target specific section types. */
6769 if (section
->sh_type
== SHT_NOBITS
)
6770 /* NOBITS section headers with non-zero sh_info fields can be
6771 created when a binary is stripped of everything but its debug
6772 information. The stripped sections have their headers
6773 preserved but their types set to SHT_NOBITS. So do not check
6774 this type of section. */
6776 else if (section
->sh_flags
& SHF_INFO_LINK
)
6778 if (section
->sh_info
< 1 || section
->sh_info
>= filedata
->file_header
.e_shnum
)
6779 warn (_("[%2u]: Expected link to another section in info field"), i
);
6781 else if (section
->sh_type
< SHT_LOOS
6782 && (section
->sh_flags
& SHF_GNU_MBIND
) == 0
6783 && section
->sh_info
!= 0)
6784 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6785 i
, section
->sh_info
);
6789 /* Check the sh_size field. */
6790 if (section
->sh_size
> filedata
->file_size
6791 && section
->sh_type
!= SHT_NOBITS
6792 && section
->sh_type
!= SHT_NULL
6793 && section
->sh_type
< SHT_LOOS
)
6794 warn (_("Size of section %u is larger than the entire file!\n"), i
);
6796 printf (" [%2u] ", i
);
6797 if (do_section_details
)
6798 printf ("%s\n ", printable_section_name (filedata
, section
));
6800 print_symbol (-17, SECTION_NAME_PRINT (section
));
6802 printf (do_wide
? " %-15s " : " %-15.15s ",
6803 get_section_type_name (filedata
, section
->sh_type
));
6807 const char * link_too_big
= NULL
;
6809 print_vma (section
->sh_addr
, LONG_HEX
);
6811 printf ( " %6.6lx %6.6lx %2.2lx",
6812 (unsigned long) section
->sh_offset
,
6813 (unsigned long) section
->sh_size
,
6814 (unsigned long) section
->sh_entsize
);
6816 if (do_section_details
)
6817 fputs (" ", stdout
);
6819 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6821 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
6824 /* The sh_link value is out of range. Normally this indicates
6825 an error but it can have special values in Solaris binaries. */
6826 switch (filedata
->file_header
.e_machine
)
6833 case EM_OLD_SPARCV9
:
6834 case EM_SPARC32PLUS
:
6837 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
6838 link_too_big
= "BEFORE";
6839 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
6840 link_too_big
= "AFTER";
6847 if (do_section_details
)
6849 if (link_too_big
!= NULL
&& * link_too_big
)
6850 printf ("<%s> ", link_too_big
);
6852 printf ("%2u ", section
->sh_link
);
6853 printf ("%3u %2lu\n", section
->sh_info
,
6854 (unsigned long) section
->sh_addralign
);
6857 printf ("%2u %3u %2lu\n",
6860 (unsigned long) section
->sh_addralign
);
6862 if (link_too_big
&& ! * link_too_big
)
6863 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6864 i
, section
->sh_link
);
6868 print_vma (section
->sh_addr
, LONG_HEX
);
6870 if ((long) section
->sh_offset
== section
->sh_offset
)
6871 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
6875 print_vma (section
->sh_offset
, LONG_HEX
);
6878 if ((unsigned long) section
->sh_size
== section
->sh_size
)
6879 printf (" %6.6lx", (unsigned long) section
->sh_size
);
6883 print_vma (section
->sh_size
, LONG_HEX
);
6886 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
6887 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
6891 print_vma (section
->sh_entsize
, LONG_HEX
);
6894 if (do_section_details
)
6895 fputs (" ", stdout
);
6897 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6899 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
6901 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
6902 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
6905 print_vma (section
->sh_addralign
, DEC
);
6909 else if (do_section_details
)
6912 print_vma (section
->sh_addr
, LONG_HEX
);
6913 if ((long) section
->sh_offset
== section
->sh_offset
)
6914 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
6918 print_vma (section
->sh_offset
, LONG_HEX
);
6920 printf (" %u\n ", section
->sh_link
);
6921 print_vma (section
->sh_size
, LONG_HEX
);
6923 print_vma (section
->sh_entsize
, LONG_HEX
);
6925 printf (" %-16u %lu\n",
6927 (unsigned long) section
->sh_addralign
);
6932 print_vma (section
->sh_addr
, LONG_HEX
);
6933 if ((long) section
->sh_offset
== section
->sh_offset
)
6934 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
6938 print_vma (section
->sh_offset
, LONG_HEX
);
6941 print_vma (section
->sh_size
, LONG_HEX
);
6943 print_vma (section
->sh_entsize
, LONG_HEX
);
6945 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6947 printf (" %2u %3u %lu\n",
6950 (unsigned long) section
->sh_addralign
);
6953 if (do_section_details
)
6955 printf (" %s\n", get_elf_section_flags (filedata
, section
->sh_flags
));
6956 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
6958 /* Minimum section size is 12 bytes for 32-bit compression
6959 header + 12 bytes for compressed data header. */
6960 unsigned char buf
[24];
6962 assert (sizeof (buf
) >= sizeof (Elf64_External_Chdr
));
6963 if (get_data (&buf
, filedata
, section
->sh_offset
, 1,
6964 sizeof (buf
), _("compression header")))
6966 Elf_Internal_Chdr chdr
;
6968 if (get_compression_header (&chdr
, buf
, sizeof (buf
)) == 0)
6969 printf (_(" [<corrupt>]\n"));
6972 if (chdr
.ch_type
== ELFCOMPRESS_ZLIB
)
6975 printf (_(" [<unknown>: 0x%x], "),
6977 print_vma (chdr
.ch_size
, LONG_HEX
);
6978 printf (", %lu\n", (unsigned long) chdr
.ch_addralign
);
6985 if (!do_section_details
)
6987 /* The ordering of the letters shown here matches the ordering of the
6988 corresponding SHF_xxx values, and hence the order in which these
6989 letters will be displayed to the user. */
6990 printf (_("Key to Flags:\n\
6991 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6992 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6993 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
6994 if (filedata
->file_header
.e_machine
== EM_X86_64
6995 || filedata
->file_header
.e_machine
== EM_L1OM
6996 || filedata
->file_header
.e_machine
== EM_K1OM
)
6997 printf (_("l (large), "));
6998 else if (filedata
->file_header
.e_machine
== EM_ARM
)
6999 printf (_("y (purecode), "));
7000 else if (filedata
->file_header
.e_machine
== EM_PPC
)
7001 printf (_("v (VLE), "));
7002 printf ("p (processor specific)\n");
7009 get_symtab (Filedata
*filedata
, Elf_Internal_Shdr
*symsec
,
7010 Elf_Internal_Sym
**symtab
, unsigned long *nsyms
,
7011 char **strtab
, unsigned long *strtablen
)
7015 *symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, nsyms
);
7017 if (*symtab
== NULL
)
7020 if (symsec
->sh_link
!= 0)
7022 Elf_Internal_Shdr
*strsec
;
7024 if (symsec
->sh_link
>= filedata
->file_header
.e_shnum
)
7026 error (_("Bad sh_link in symbol table section\n"));
7033 strsec
= filedata
->section_headers
+ symsec
->sh_link
;
7035 *strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
7036 1, strsec
->sh_size
, _("string table"));
7037 if (*strtab
== NULL
)
7044 *strtablen
= strsec
->sh_size
;
7050 get_group_flags (unsigned int flags
)
7052 static char buff
[128];
7056 else if (flags
== GRP_COMDAT
)
7059 snprintf (buff
, sizeof buff
, "[0x%x: %s%s%s]",
7061 flags
& GRP_MASKOS
? _("<OS specific>") : "",
7062 flags
& GRP_MASKPROC
? _("<PROC specific>") : "",
7063 (flags
& ~(GRP_COMDAT
| GRP_MASKOS
| GRP_MASKPROC
)
7064 ? _("<unknown>") : ""));
7070 process_section_groups (Filedata
* filedata
)
7072 Elf_Internal_Shdr
* section
;
7074 struct group
* group
;
7075 Elf_Internal_Shdr
* symtab_sec
;
7076 Elf_Internal_Shdr
* strtab_sec
;
7077 Elf_Internal_Sym
* symtab
;
7078 unsigned long num_syms
;
7082 /* Don't process section groups unless needed. */
7083 if (!do_unwind
&& !do_section_groups
)
7086 if (filedata
->file_header
.e_shnum
== 0)
7088 if (do_section_groups
)
7089 printf (_("\nThere are no sections to group in this file.\n"));
7094 if (filedata
->section_headers
== NULL
)
7096 error (_("Section headers are not available!\n"));
7097 /* PR 13622: This can happen with a corrupt ELF header. */
7101 filedata
->section_headers_groups
7102 = (struct group
**) calloc (filedata
->file_header
.e_shnum
,
7103 sizeof (struct group
*));
7105 if (filedata
->section_headers_groups
== NULL
)
7107 error (_("Out of memory reading %u section group headers\n"),
7108 filedata
->file_header
.e_shnum
);
7112 /* Scan the sections for the group section. */
7113 filedata
->group_count
= 0;
7114 for (i
= 0, section
= filedata
->section_headers
;
7115 i
< filedata
->file_header
.e_shnum
;
7117 if (section
->sh_type
== SHT_GROUP
)
7118 filedata
->group_count
++;
7120 if (filedata
->group_count
== 0)
7122 if (do_section_groups
)
7123 printf (_("\nThere are no section groups in this file.\n"));
7128 filedata
->section_groups
= (struct group
*) calloc (filedata
->group_count
,
7129 sizeof (struct group
));
7131 if (filedata
->section_groups
== NULL
)
7133 error (_("Out of memory reading %lu groups\n"),
7134 (unsigned long) filedata
->group_count
);
7144 for (i
= 0, section
= filedata
->section_headers
, group
= filedata
->section_groups
;
7145 i
< filedata
->file_header
.e_shnum
;
7148 if (section
->sh_type
== SHT_GROUP
)
7150 const char * name
= printable_section_name (filedata
, section
);
7151 const char * group_name
;
7152 unsigned char * start
;
7153 unsigned char * indices
;
7154 unsigned int entry
, j
, size
;
7155 Elf_Internal_Shdr
* sec
;
7156 Elf_Internal_Sym
* sym
;
7158 /* Get the symbol table. */
7159 if (section
->sh_link
>= filedata
->file_header
.e_shnum
7160 || ((sec
= filedata
->section_headers
+ section
->sh_link
)->sh_type
7163 error (_("Bad sh_link in group section `%s'\n"), name
);
7167 if (symtab_sec
!= sec
)
7171 symtab
= GET_ELF_SYMBOLS (filedata
, symtab_sec
, & num_syms
);
7176 error (_("Corrupt header in group section `%s'\n"), name
);
7180 if (section
->sh_info
>= num_syms
)
7182 error (_("Bad sh_info in group section `%s'\n"), name
);
7186 sym
= symtab
+ section
->sh_info
;
7188 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
7190 if (sym
->st_shndx
== 0
7191 || sym
->st_shndx
>= filedata
->file_header
.e_shnum
)
7193 error (_("Bad sh_info in group section `%s'\n"), name
);
7197 group_name
= SECTION_NAME_PRINT (filedata
->section_headers
7206 /* Get the string table. */
7207 if (symtab_sec
->sh_link
>= filedata
->file_header
.e_shnum
)
7215 != (sec
= filedata
->section_headers
+ symtab_sec
->sh_link
))
7220 strtab
= (char *) get_data (NULL
, filedata
, strtab_sec
->sh_offset
,
7221 1, strtab_sec
->sh_size
,
7223 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
7225 group_name
= sym
->st_name
< strtab_size
7226 ? strtab
+ sym
->st_name
: _("<corrupt>");
7229 /* PR 17531: file: loop. */
7230 if (section
->sh_entsize
> section
->sh_size
)
7232 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
7233 printable_section_name (filedata
, section
),
7234 (unsigned long) section
->sh_entsize
,
7235 (unsigned long) section
->sh_size
);
7239 start
= (unsigned char *) get_data (NULL
, filedata
, section
->sh_offset
,
7240 1, section
->sh_size
,
7246 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
7247 entry
= byte_get (indices
, 4);
7250 if (do_section_groups
)
7252 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
7253 get_group_flags (entry
), i
, name
, group_name
, size
);
7255 printf (_(" [Index] Name\n"));
7258 group
->group_index
= i
;
7260 for (j
= 0; j
< size
; j
++)
7262 struct group_list
* g
;
7264 entry
= byte_get (indices
, 4);
7267 if (entry
>= filedata
->file_header
.e_shnum
)
7269 static unsigned num_group_errors
= 0;
7271 if (num_group_errors
++ < 10)
7273 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
7274 entry
, i
, filedata
->file_header
.e_shnum
- 1);
7275 if (num_group_errors
== 10)
7276 warn (_("Further error messages about overlarge group section indices suppressed\n"));
7281 if (filedata
->section_headers_groups
[entry
] != NULL
)
7285 static unsigned num_errs
= 0;
7287 if (num_errs
++ < 10)
7289 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
7291 filedata
->section_headers_groups
[entry
]->group_index
);
7293 warn (_("Further error messages about already contained group sections suppressed\n"));
7299 /* Intel C/C++ compiler may put section 0 in a
7300 section group. We just warn it the first time
7301 and ignore it afterwards. */
7302 static bfd_boolean warned
= FALSE
;
7305 error (_("section 0 in group section [%5u]\n"),
7306 filedata
->section_headers_groups
[entry
]->group_index
);
7312 filedata
->section_headers_groups
[entry
] = group
;
7314 if (do_section_groups
)
7316 sec
= filedata
->section_headers
+ entry
;
7317 printf (" [%5u] %s\n", entry
, printable_section_name (filedata
, sec
));
7320 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
7321 g
->section_index
= entry
;
7322 g
->next
= group
->root
;
7337 /* Data used to display dynamic fixups. */
7339 struct ia64_vms_dynfixup
7341 bfd_vma needed_ident
; /* Library ident number. */
7342 bfd_vma needed
; /* Index in the dstrtab of the library name. */
7343 bfd_vma fixup_needed
; /* Index of the library. */
7344 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
7345 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
7348 /* Data used to display dynamic relocations. */
7350 struct ia64_vms_dynimgrela
7352 bfd_vma img_rela_cnt
; /* Number of relocations. */
7353 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
7356 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
7360 dump_ia64_vms_dynamic_fixups (Filedata
* filedata
,
7361 struct ia64_vms_dynfixup
* fixup
,
7362 const char * strtab
,
7363 unsigned int strtab_sz
)
7365 Elf64_External_VMS_IMAGE_FIXUP
* imfs
;
7367 const char * lib_name
;
7369 imfs
= get_data (NULL
, filedata
,
7370 filedata
->dynamic_addr
+ fixup
->fixup_rela_off
,
7371 sizeof (*imfs
), fixup
->fixup_rela_cnt
,
7372 _("dynamic section image fixups"));
7376 if (fixup
->needed
< strtab_sz
)
7377 lib_name
= strtab
+ fixup
->needed
;
7380 warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
7381 (unsigned long) fixup
->needed
);
7385 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
7386 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
7388 (_("Seg Offset Type SymVec DataType\n"));
7390 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
7395 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
7396 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
7397 type
= BYTE_GET (imfs
[i
].type
);
7398 rtype
= elf_ia64_reloc_type (type
);
7400 printf (" 0x%08x ", type
);
7402 printf (" %-32s ", rtype
);
7403 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
7404 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
7411 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
7414 dump_ia64_vms_dynamic_relocs (Filedata
* filedata
, struct ia64_vms_dynimgrela
*imgrela
)
7416 Elf64_External_VMS_IMAGE_RELA
*imrs
;
7419 imrs
= get_data (NULL
, filedata
,
7420 filedata
->dynamic_addr
+ imgrela
->img_rela_off
,
7421 sizeof (*imrs
), imgrela
->img_rela_cnt
,
7422 _("dynamic section image relocations"));
7426 printf (_("\nImage relocs\n"));
7428 (_("Seg Offset Type Addend Seg Sym Off\n"));
7430 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
7435 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
7436 printf ("%08" BFD_VMA_FMT
"x ",
7437 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
7438 type
= BYTE_GET (imrs
[i
].type
);
7439 rtype
= elf_ia64_reloc_type (type
);
7441 printf ("0x%08x ", type
);
7443 printf ("%-31s ", rtype
);
7444 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
7445 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
7446 printf ("%08" BFD_VMA_FMT
"x\n",
7447 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
7454 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
7457 process_ia64_vms_dynamic_relocs (Filedata
* filedata
)
7459 struct ia64_vms_dynfixup fixup
;
7460 struct ia64_vms_dynimgrela imgrela
;
7461 Elf_Internal_Dyn
*entry
;
7462 bfd_vma strtab_off
= 0;
7463 bfd_vma strtab_sz
= 0;
7464 char *strtab
= NULL
;
7465 bfd_boolean res
= TRUE
;
7467 memset (&fixup
, 0, sizeof (fixup
));
7468 memset (&imgrela
, 0, sizeof (imgrela
));
7470 /* Note: the order of the entries is specified by the OpenVMS specs. */
7471 for (entry
= filedata
->dynamic_section
;
7472 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
7475 switch (entry
->d_tag
)
7477 case DT_IA_64_VMS_STRTAB_OFFSET
:
7478 strtab_off
= entry
->d_un
.d_val
;
7481 strtab_sz
= entry
->d_un
.d_val
;
7483 strtab
= get_data (NULL
, filedata
,
7484 filedata
->dynamic_addr
+ strtab_off
,
7485 1, strtab_sz
, _("dynamic string section"));
7490 case DT_IA_64_VMS_NEEDED_IDENT
:
7491 fixup
.needed_ident
= entry
->d_un
.d_val
;
7494 fixup
.needed
= entry
->d_un
.d_val
;
7496 case DT_IA_64_VMS_FIXUP_NEEDED
:
7497 fixup
.fixup_needed
= entry
->d_un
.d_val
;
7499 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
7500 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
7502 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
7503 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
7504 if (! dump_ia64_vms_dynamic_fixups (filedata
, &fixup
, strtab
, strtab_sz
))
7507 case DT_IA_64_VMS_IMG_RELA_CNT
:
7508 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
7510 case DT_IA_64_VMS_IMG_RELA_OFF
:
7511 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
7512 if (! dump_ia64_vms_dynamic_relocs (filedata
, &imgrela
))
7533 dynamic_relocations
[] =
7535 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
7536 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
7537 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
7540 /* Process the reloc section. */
7543 process_relocs (Filedata
* filedata
)
7545 unsigned long rel_size
;
7546 unsigned long rel_offset
;
7551 if (do_using_dynamic
)
7555 bfd_boolean has_dynamic_reloc
;
7558 has_dynamic_reloc
= FALSE
;
7560 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7562 is_rela
= dynamic_relocations
[i
].rela
;
7563 name
= dynamic_relocations
[i
].name
;
7564 rel_size
= filedata
->dynamic_info
[dynamic_relocations
[i
].size
];
7565 rel_offset
= filedata
->dynamic_info
[dynamic_relocations
[i
].reloc
];
7568 has_dynamic_reloc
= TRUE
;
7570 if (is_rela
== UNKNOWN
)
7572 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
7573 switch (filedata
->dynamic_info
[DT_PLTREL
])
7587 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7588 name
, rel_offset
, rel_size
);
7590 dump_relocations (filedata
,
7591 offset_from_vma (filedata
, rel_offset
, rel_size
),
7593 filedata
->dynamic_symbols
,
7594 filedata
->num_dynamic_syms
,
7595 filedata
->dynamic_strings
,
7596 filedata
->dynamic_strings_length
,
7597 is_rela
, TRUE
/* is_dynamic */);
7601 if (is_ia64_vms (filedata
))
7602 if (process_ia64_vms_dynamic_relocs (filedata
))
7603 has_dynamic_reloc
= TRUE
;
7605 if (! has_dynamic_reloc
)
7606 printf (_("\nThere are no dynamic relocations in this file.\n"));
7610 Elf_Internal_Shdr
* section
;
7612 bfd_boolean found
= FALSE
;
7614 for (i
= 0, section
= filedata
->section_headers
;
7615 i
< filedata
->file_header
.e_shnum
;
7618 if ( section
->sh_type
!= SHT_RELA
7619 && section
->sh_type
!= SHT_REL
)
7622 rel_offset
= section
->sh_offset
;
7623 rel_size
= section
->sh_size
;
7628 unsigned long num_rela
;
7630 printf (_("\nRelocation section "));
7632 if (filedata
->string_table
== NULL
)
7633 printf ("%d", section
->sh_name
);
7635 printf ("'%s'", printable_section_name (filedata
, section
));
7637 num_rela
= rel_size
/ section
->sh_entsize
;
7638 printf (ngettext (" at offset 0x%lx contains %lu entry:\n",
7639 " at offset 0x%lx contains %lu entries:\n",
7641 rel_offset
, num_rela
);
7643 is_rela
= section
->sh_type
== SHT_RELA
;
7645 if (section
->sh_link
!= 0
7646 && section
->sh_link
< filedata
->file_header
.e_shnum
)
7648 Elf_Internal_Shdr
* symsec
;
7649 Elf_Internal_Sym
* symtab
;
7650 unsigned long nsyms
;
7651 unsigned long strtablen
= 0;
7652 char * strtab
= NULL
;
7654 symsec
= filedata
->section_headers
+ section
->sh_link
;
7655 if (symsec
->sh_type
!= SHT_SYMTAB
7656 && symsec
->sh_type
!= SHT_DYNSYM
)
7659 if (!get_symtab (filedata
, symsec
,
7660 &symtab
, &nsyms
, &strtab
, &strtablen
))
7663 dump_relocations (filedata
, rel_offset
, rel_size
,
7664 symtab
, nsyms
, strtab
, strtablen
,
7666 symsec
->sh_type
== SHT_DYNSYM
);
7671 dump_relocations (filedata
, rel_offset
, rel_size
,
7672 NULL
, 0, NULL
, 0, is_rela
,
7673 FALSE
/* is_dynamic */);
7681 /* Users sometimes forget the -D option, so try to be helpful. */
7682 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7684 if (filedata
->dynamic_info
[dynamic_relocations
[i
].size
])
7686 printf (_("\nThere are no static relocations in this file."));
7687 printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
7692 if (i
== ARRAY_SIZE (dynamic_relocations
))
7693 printf (_("\nThere are no relocations in this file.\n"));
7700 /* An absolute address consists of a section and an offset. If the
7701 section is NULL, the offset itself is the address, otherwise, the
7702 address equals to LOAD_ADDRESS(section) + offset. */
7706 unsigned short section
;
7710 /* Find the nearest symbol at or below ADDR. Returns the symbol
7711 name, if found, and the offset from the symbol to ADDR. */
7714 find_symbol_for_address (Filedata
* filedata
,
7715 Elf_Internal_Sym
* symtab
,
7716 unsigned long nsyms
,
7717 const char * strtab
,
7718 unsigned long strtab_size
,
7719 struct absaddr addr
,
7720 const char ** symname
,
7723 bfd_vma dist
= 0x100000;
7724 Elf_Internal_Sym
* sym
;
7725 Elf_Internal_Sym
* beg
;
7726 Elf_Internal_Sym
* end
;
7727 Elf_Internal_Sym
* best
= NULL
;
7729 REMOVE_ARCH_BITS (addr
.offset
);
7731 end
= symtab
+ nsyms
;
7737 sym
= beg
+ (end
- beg
) / 2;
7739 value
= sym
->st_value
;
7740 REMOVE_ARCH_BITS (value
);
7742 if (sym
->st_name
!= 0
7743 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
7744 && addr
.offset
>= value
7745 && addr
.offset
- value
< dist
)
7748 dist
= addr
.offset
- value
;
7753 if (addr
.offset
< value
)
7761 *symname
= (best
->st_name
>= strtab_size
7762 ? _("<corrupt>") : strtab
+ best
->st_name
);
7768 *offset
= addr
.offset
;
7771 static /* signed */ int
7772 symcmp (const void *p
, const void *q
)
7774 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
7775 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
7777 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
7780 /* Process the unwind section. */
7782 #include "unwind-ia64.h"
7784 struct ia64_unw_table_entry
7786 struct absaddr start
;
7788 struct absaddr info
;
7791 struct ia64_unw_aux_info
7793 struct ia64_unw_table_entry
* table
; /* Unwind table. */
7794 unsigned long table_len
; /* Length of unwind table. */
7795 unsigned char * info
; /* Unwind info. */
7796 unsigned long info_size
; /* Size of unwind info. */
7797 bfd_vma info_addr
; /* Starting address of unwind info. */
7798 bfd_vma seg_base
; /* Starting address of segment. */
7799 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7800 unsigned long nsyms
; /* Number of symbols. */
7801 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7802 unsigned long nfuns
; /* Number of entries in funtab. */
7803 char * strtab
; /* The string table. */
7804 unsigned long strtab_size
; /* Size of string table. */
7808 dump_ia64_unwind (Filedata
* filedata
, struct ia64_unw_aux_info
* aux
)
7810 struct ia64_unw_table_entry
* tp
;
7811 unsigned long j
, nfuns
;
7813 bfd_boolean res
= TRUE
;
7815 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7816 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7817 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7818 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7820 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7822 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7826 const unsigned char * dp
;
7827 const unsigned char * head
;
7828 const unsigned char * end
;
7829 const char * procname
;
7831 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7832 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
7834 fputs ("\n<", stdout
);
7838 fputs (procname
, stdout
);
7841 printf ("+%lx", (unsigned long) offset
);
7844 fputs (">: [", stdout
);
7845 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7846 fputc ('-', stdout
);
7847 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7848 printf ("], info at +0x%lx\n",
7849 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
7851 /* PR 17531: file: 86232b32. */
7852 if (aux
->info
== NULL
)
7855 offset
= tp
->info
.offset
;
7856 if (tp
->info
.section
)
7858 if (tp
->info
.section
>= filedata
->file_header
.e_shnum
)
7860 warn (_("Invalid section %u in table entry %ld\n"),
7861 tp
->info
.section
, (long) (tp
- aux
->table
));
7865 offset
+= filedata
->section_headers
[tp
->info
.section
].sh_addr
;
7867 offset
-= aux
->info_addr
;
7868 /* PR 17531: file: 0997b4d1. */
7869 if (offset
>= aux
->info_size
7870 || aux
->info_size
- offset
< 8)
7872 warn (_("Invalid offset %lx in table entry %ld\n"),
7873 (long) tp
->info
.offset
, (long) (tp
- aux
->table
));
7878 head
= aux
->info
+ offset
;
7879 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
7881 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7882 (unsigned) UNW_VER (stamp
),
7883 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
7884 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
7885 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
7886 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
7888 if (UNW_VER (stamp
) != 1)
7890 printf (_("\tUnknown version.\n"));
7895 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
7896 /* PR 17531: file: 16ceda89. */
7897 if (end
> aux
->info
+ aux
->info_size
)
7898 end
= aux
->info
+ aux
->info_size
;
7899 for (dp
= head
+ 8; dp
< end
;)
7900 dp
= unw_decode (dp
, in_body
, & in_body
, end
);
7909 slurp_ia64_unwind_table (Filedata
* filedata
,
7910 struct ia64_unw_aux_info
* aux
,
7911 Elf_Internal_Shdr
* sec
)
7913 unsigned long size
, nrelas
, i
;
7914 Elf_Internal_Phdr
* seg
;
7915 struct ia64_unw_table_entry
* tep
;
7916 Elf_Internal_Shdr
* relsec
;
7917 Elf_Internal_Rela
* rela
;
7918 Elf_Internal_Rela
* rp
;
7919 unsigned char * table
;
7921 Elf_Internal_Sym
* sym
;
7922 const char * relname
;
7926 /* First, find the starting address of the segment that includes
7929 if (filedata
->file_header
.e_phnum
)
7931 if (! get_program_headers (filedata
))
7934 for (seg
= filedata
->program_headers
;
7935 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
7938 if (seg
->p_type
!= PT_LOAD
)
7941 if (sec
->sh_addr
>= seg
->p_vaddr
7942 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7944 aux
->seg_base
= seg
->p_vaddr
;
7950 /* Second, build the unwind table from the contents of the unwind section: */
7951 size
= sec
->sh_size
;
7952 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
7957 aux
->table_len
= size
/ (3 * eh_addr_size
);
7958 aux
->table
= (struct ia64_unw_table_entry
*)
7959 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
7962 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
7964 tep
->start
.section
= SHN_UNDEF
;
7965 tep
->end
.section
= SHN_UNDEF
;
7966 tep
->info
.section
= SHN_UNDEF
;
7967 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7968 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7969 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7970 tep
->start
.offset
+= aux
->seg_base
;
7971 tep
->end
.offset
+= aux
->seg_base
;
7972 tep
->info
.offset
+= aux
->seg_base
;
7976 /* Third, apply any relocations to the unwind table: */
7977 for (relsec
= filedata
->section_headers
;
7978 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
7981 if (relsec
->sh_type
!= SHT_RELA
7982 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
7983 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
7986 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
7995 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7997 unsigned int sym_ndx
;
7998 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
7999 relname
= elf_ia64_reloc_type (r_type
);
8001 /* PR 17531: file: 9fa67536. */
8002 if (relname
== NULL
)
8004 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
8008 if (! const_strneq (relname
, "R_IA64_SEGREL"))
8010 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
8014 i
= rp
->r_offset
/ (3 * eh_addr_size
);
8016 /* PR 17531: file: 5bc8d9bf. */
8017 if (i
>= aux
->table_len
)
8019 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
8023 sym_ndx
= get_reloc_symindex (rp
->r_info
);
8024 if (sym_ndx
>= aux
->nsyms
)
8026 warn (_("Skipping reloc with invalid symbol index: %u\n"),
8030 sym
= aux
->symtab
+ sym_ndx
;
8032 switch (rp
->r_offset
/ eh_addr_size
% 3)
8035 aux
->table
[i
].start
.section
= sym
->st_shndx
;
8036 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
8039 aux
->table
[i
].end
.section
= sym
->st_shndx
;
8040 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
8043 aux
->table
[i
].info
.section
= sym
->st_shndx
;
8044 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
8058 ia64_process_unwind (Filedata
* filedata
)
8060 Elf_Internal_Shdr
* sec
;
8061 Elf_Internal_Shdr
* unwsec
= NULL
;
8062 unsigned long i
, unwcount
= 0, unwstart
= 0;
8063 struct ia64_unw_aux_info aux
;
8064 bfd_boolean res
= TRUE
;
8066 memset (& aux
, 0, sizeof (aux
));
8068 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8070 if (sec
->sh_type
== SHT_SYMTAB
)
8074 error (_("Multiple symbol tables encountered\n"));
8080 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
8081 &aux
.strtab
, &aux
.strtab_size
))
8084 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
8089 printf (_("\nThere are no unwind sections in this file.\n"));
8091 while (unwcount
-- > 0)
8096 for (i
= unwstart
, sec
= filedata
->section_headers
+ unwstart
, unwsec
= NULL
;
8097 i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8098 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
8103 /* We have already counted the number of SHT_IA64_UNWIND
8104 sections so the loop above should never fail. */
8105 assert (unwsec
!= NULL
);
8108 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
8110 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
8112 /* We need to find which section group it is in. */
8113 struct group_list
* g
;
8115 if (filedata
->section_headers_groups
== NULL
8116 || filedata
->section_headers_groups
[i
] == NULL
)
8117 i
= filedata
->file_header
.e_shnum
;
8120 g
= filedata
->section_headers_groups
[i
]->root
;
8122 for (; g
!= NULL
; g
= g
->next
)
8124 sec
= filedata
->section_headers
+ g
->section_index
;
8126 if (SECTION_NAME_VALID (sec
)
8127 && streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
8132 i
= filedata
->file_header
.e_shnum
;
8135 else if (SECTION_NAME_VALID (unwsec
)
8136 && strneq (SECTION_NAME (unwsec
),
8137 ELF_STRING_ia64_unwind_once
, len
))
8139 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
8140 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
8141 suffix
= SECTION_NAME (unwsec
) + len
;
8142 for (i
= 0, sec
= filedata
->section_headers
;
8143 i
< filedata
->file_header
.e_shnum
;
8145 if (SECTION_NAME_VALID (sec
)
8146 && strneq (SECTION_NAME (sec
),
8147 ELF_STRING_ia64_unwind_info_once
, len2
)
8148 && streq (SECTION_NAME (sec
) + len2
, suffix
))
8153 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
8154 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
8155 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
8156 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
8158 if (SECTION_NAME_VALID (unwsec
)
8159 && strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
8160 suffix
= SECTION_NAME (unwsec
) + len
;
8161 for (i
= 0, sec
= filedata
->section_headers
;
8162 i
< filedata
->file_header
.e_shnum
;
8164 if (SECTION_NAME_VALID (sec
)
8165 && strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
8166 && streq (SECTION_NAME (sec
) + len2
, suffix
))
8170 if (i
== filedata
->file_header
.e_shnum
)
8172 printf (_("\nCould not find unwind info section for "));
8174 if (filedata
->string_table
== NULL
)
8175 printf ("%d", unwsec
->sh_name
);
8177 printf ("'%s'", printable_section_name (filedata
, unwsec
));
8181 aux
.info_addr
= sec
->sh_addr
;
8182 aux
.info
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1,
8185 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
8187 printf (_("\nUnwind section "));
8189 if (filedata
->string_table
== NULL
)
8190 printf ("%d", unwsec
->sh_name
);
8192 printf ("'%s'", printable_section_name (filedata
, unwsec
));
8194 printf (_(" at offset 0x%lx contains %lu entries:\n"),
8195 (unsigned long) unwsec
->sh_offset
,
8196 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
8198 if (slurp_ia64_unwind_table (filedata
, & aux
, unwsec
)
8199 && aux
.table_len
> 0)
8200 dump_ia64_unwind (filedata
, & aux
);
8202 free ((char *) aux
.table
);
8203 free ((char *) aux
.info
);
8210 free ((char *) aux
.strtab
);
8215 struct hppa_unw_table_entry
8217 struct absaddr start
;
8219 unsigned int Cannot_unwind
:1; /* 0 */
8220 unsigned int Millicode
:1; /* 1 */
8221 unsigned int Millicode_save_sr0
:1; /* 2 */
8222 unsigned int Region_description
:2; /* 3..4 */
8223 unsigned int reserved1
:1; /* 5 */
8224 unsigned int Entry_SR
:1; /* 6 */
8225 unsigned int Entry_FR
:4; /* Number saved 7..10 */
8226 unsigned int Entry_GR
:5; /* Number saved 11..15 */
8227 unsigned int Args_stored
:1; /* 16 */
8228 unsigned int Variable_Frame
:1; /* 17 */
8229 unsigned int Separate_Package_Body
:1; /* 18 */
8230 unsigned int Frame_Extension_Millicode
:1; /* 19 */
8231 unsigned int Stack_Overflow_Check
:1; /* 20 */
8232 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
8233 unsigned int Ada_Region
:1; /* 22 */
8234 unsigned int cxx_info
:1; /* 23 */
8235 unsigned int cxx_try_catch
:1; /* 24 */
8236 unsigned int sched_entry_seq
:1; /* 25 */
8237 unsigned int reserved2
:1; /* 26 */
8238 unsigned int Save_SP
:1; /* 27 */
8239 unsigned int Save_RP
:1; /* 28 */
8240 unsigned int Save_MRP_in_frame
:1; /* 29 */
8241 unsigned int extn_ptr_defined
:1; /* 30 */
8242 unsigned int Cleanup_defined
:1; /* 31 */
8244 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
8245 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
8246 unsigned int Large_frame
:1; /* 2 */
8247 unsigned int Pseudo_SP_Set
:1; /* 3 */
8248 unsigned int reserved4
:1; /* 4 */
8249 unsigned int Total_frame_size
:27; /* 5..31 */
8252 struct hppa_unw_aux_info
8254 struct hppa_unw_table_entry
* table
; /* Unwind table. */
8255 unsigned long table_len
; /* Length of unwind table. */
8256 bfd_vma seg_base
; /* Starting address of segment. */
8257 Elf_Internal_Sym
* symtab
; /* The symbol table. */
8258 unsigned long nsyms
; /* Number of symbols. */
8259 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8260 unsigned long nfuns
; /* Number of entries in funtab. */
8261 char * strtab
; /* The string table. */
8262 unsigned long strtab_size
; /* Size of string table. */
8266 dump_hppa_unwind (Filedata
* filedata
, struct hppa_unw_aux_info
* aux
)
8268 struct hppa_unw_table_entry
* tp
;
8269 unsigned long j
, nfuns
;
8270 bfd_boolean res
= TRUE
;
8272 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
8273 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
8274 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
8275 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
8277 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
8279 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
8282 const char * procname
;
8284 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8285 aux
->strtab_size
, tp
->start
, &procname
,
8288 fputs ("\n<", stdout
);
8292 fputs (procname
, stdout
);
8295 printf ("+%lx", (unsigned long) offset
);
8298 fputs (">: [", stdout
);
8299 print_vma (tp
->start
.offset
, PREFIX_HEX
);
8300 fputc ('-', stdout
);
8301 print_vma (tp
->end
.offset
, PREFIX_HEX
);
8304 #define PF(_m) if (tp->_m) printf (#_m " ");
8305 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
8308 PF(Millicode_save_sr0
);
8309 /* PV(Region_description); */
8315 PF(Separate_Package_Body
);
8316 PF(Frame_Extension_Millicode
);
8317 PF(Stack_Overflow_Check
);
8318 PF(Two_Instruction_SP_Increment
);
8322 PF(sched_entry_seq
);
8325 PF(Save_MRP_in_frame
);
8326 PF(extn_ptr_defined
);
8327 PF(Cleanup_defined
);
8328 PF(MPE_XL_interrupt_marker
);
8329 PF(HP_UX_interrupt_marker
);
8332 PV(Total_frame_size
);
8345 slurp_hppa_unwind_table (Filedata
* filedata
,
8346 struct hppa_unw_aux_info
* aux
,
8347 Elf_Internal_Shdr
* sec
)
8349 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
8350 Elf_Internal_Phdr
* seg
;
8351 struct hppa_unw_table_entry
* tep
;
8352 Elf_Internal_Shdr
* relsec
;
8353 Elf_Internal_Rela
* rela
;
8354 Elf_Internal_Rela
* rp
;
8355 unsigned char * table
;
8357 Elf_Internal_Sym
* sym
;
8358 const char * relname
;
8360 /* First, find the starting address of the segment that includes
8362 if (filedata
->file_header
.e_phnum
)
8364 if (! get_program_headers (filedata
))
8367 for (seg
= filedata
->program_headers
;
8368 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
8371 if (seg
->p_type
!= PT_LOAD
)
8374 if (sec
->sh_addr
>= seg
->p_vaddr
8375 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
8377 aux
->seg_base
= seg
->p_vaddr
;
8383 /* Second, build the unwind table from the contents of the unwind
8385 size
= sec
->sh_size
;
8386 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
8392 nentries
= size
/ unw_ent_size
;
8393 size
= unw_ent_size
* nentries
;
8395 aux
->table_len
= nentries
;
8396 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
8397 xcmalloc (nentries
, sizeof (aux
->table
[0]));
8399 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
8401 unsigned int tmp1
, tmp2
;
8403 tep
->start
.section
= SHN_UNDEF
;
8404 tep
->end
.section
= SHN_UNDEF
;
8406 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
8407 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
8408 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
8409 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
8411 tep
->start
.offset
+= aux
->seg_base
;
8412 tep
->end
.offset
+= aux
->seg_base
;
8414 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
8415 tep
->Millicode
= (tmp1
>> 30) & 0x1;
8416 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
8417 tep
->Region_description
= (tmp1
>> 27) & 0x3;
8418 tep
->reserved1
= (tmp1
>> 26) & 0x1;
8419 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
8420 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
8421 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
8422 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
8423 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
8424 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
8425 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
8426 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
8427 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
8428 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
8429 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
8430 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
8431 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
8432 tep
->reserved2
= (tmp1
>> 5) & 0x1;
8433 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
8434 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
8435 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
8436 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
8437 tep
->Cleanup_defined
= tmp1
& 0x1;
8439 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
8440 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
8441 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
8442 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
8443 tep
->reserved4
= (tmp2
>> 27) & 0x1;
8444 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
8448 /* Third, apply any relocations to the unwind table. */
8449 for (relsec
= filedata
->section_headers
;
8450 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8453 if (relsec
->sh_type
!= SHT_RELA
8454 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
8455 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
8458 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
8462 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
8464 unsigned int sym_ndx
;
8465 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
8466 relname
= elf_hppa_reloc_type (r_type
);
8468 if (relname
== NULL
)
8470 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
8474 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
8475 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
8477 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
8481 i
= rp
->r_offset
/ unw_ent_size
;
8482 if (i
>= aux
->table_len
)
8484 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
8488 sym_ndx
= get_reloc_symindex (rp
->r_info
);
8489 if (sym_ndx
>= aux
->nsyms
)
8491 warn (_("Skipping reloc with invalid symbol index: %u\n"),
8495 sym
= aux
->symtab
+ sym_ndx
;
8497 switch ((rp
->r_offset
% unw_ent_size
) / 4)
8500 aux
->table
[i
].start
.section
= sym
->st_shndx
;
8501 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
8504 aux
->table
[i
].end
.section
= sym
->st_shndx
;
8505 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
8519 hppa_process_unwind (Filedata
* filedata
)
8521 struct hppa_unw_aux_info aux
;
8522 Elf_Internal_Shdr
* unwsec
= NULL
;
8523 Elf_Internal_Shdr
* sec
;
8525 bfd_boolean res
= TRUE
;
8527 if (filedata
->string_table
== NULL
)
8530 memset (& aux
, 0, sizeof (aux
));
8532 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8534 if (sec
->sh_type
== SHT_SYMTAB
)
8538 error (_("Multiple symbol tables encountered\n"));
8544 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
8545 &aux
.strtab
, &aux
.strtab_size
))
8548 else if (SECTION_NAME_VALID (sec
)
8549 && streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8554 printf (_("\nThere are no unwind sections in this file.\n"));
8556 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8558 if (SECTION_NAME_VALID (sec
)
8559 && streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8561 unsigned long num_unwind
= sec
->sh_size
/ 16;
8563 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
8564 "contains %lu entry:\n",
8565 "\nUnwind section '%s' at offset 0x%lx "
8566 "contains %lu entries:\n",
8568 printable_section_name (filedata
, sec
),
8569 (unsigned long) sec
->sh_offset
,
8572 if (! slurp_hppa_unwind_table (filedata
, &aux
, sec
))
8575 if (res
&& aux
.table_len
> 0)
8577 if (! dump_hppa_unwind (filedata
, &aux
))
8581 free ((char *) aux
.table
);
8587 free ((char *) aux
.strtab
);
8594 unsigned char * data
; /* The unwind data. */
8595 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
8596 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
8597 unsigned long nrelas
; /* The number of relocations. */
8598 unsigned int rel_type
; /* REL or RELA ? */
8599 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
8602 struct arm_unw_aux_info
8604 Filedata
* filedata
; /* The file containing the unwind sections. */
8605 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
8606 unsigned long nsyms
; /* Number of symbols. */
8607 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8608 unsigned long nfuns
; /* Number of these symbols. */
8609 char * strtab
; /* The file's string table. */
8610 unsigned long strtab_size
; /* Size of string table. */
8614 arm_print_vma_and_name (Filedata
* filedata
,
8615 struct arm_unw_aux_info
* aux
,
8617 struct absaddr addr
)
8619 const char *procname
;
8622 if (addr
.section
== SHN_UNDEF
)
8625 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8626 aux
->strtab_size
, addr
, &procname
,
8629 print_vma (fn
, PREFIX_HEX
);
8633 fputs (" <", stdout
);
8634 fputs (procname
, stdout
);
8637 printf ("+0x%lx", (unsigned long) sym_offset
);
8638 fputc ('>', stdout
);
8645 arm_free_section (struct arm_section
*arm_sec
)
8647 free (arm_sec
->data
);
8648 free (arm_sec
->rela
);
8651 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8652 cached section and install SEC instead.
8653 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8654 and return its valued in * WORDP, relocating if necessary.
8655 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8656 relocation's offset in ADDR.
8657 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8658 into the string table of the symbol associated with the reloc. If no
8659 reloc was applied store -1 there.
8660 5) Return TRUE upon success, FALSE otherwise. */
8663 get_unwind_section_word (Filedata
* filedata
,
8664 struct arm_unw_aux_info
* aux
,
8665 struct arm_section
* arm_sec
,
8666 Elf_Internal_Shdr
* sec
,
8667 bfd_vma word_offset
,
8668 unsigned int * wordp
,
8669 struct absaddr
* addr
,
8672 Elf_Internal_Rela
*rp
;
8673 Elf_Internal_Sym
*sym
;
8674 const char * relname
;
8676 bfd_boolean wrapped
;
8678 if (sec
== NULL
|| arm_sec
== NULL
)
8681 addr
->section
= SHN_UNDEF
;
8684 if (sym_name
!= NULL
)
8685 *sym_name
= (bfd_vma
) -1;
8687 /* If necessary, update the section cache. */
8688 if (sec
!= arm_sec
->sec
)
8690 Elf_Internal_Shdr
*relsec
;
8692 arm_free_section (arm_sec
);
8695 arm_sec
->data
= get_data (NULL
, aux
->filedata
, sec
->sh_offset
, 1,
8696 sec
->sh_size
, _("unwind data"));
8697 arm_sec
->rela
= NULL
;
8698 arm_sec
->nrelas
= 0;
8700 for (relsec
= filedata
->section_headers
;
8701 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8704 if (relsec
->sh_info
>= filedata
->file_header
.e_shnum
8705 || filedata
->section_headers
+ relsec
->sh_info
!= sec
8706 /* PR 15745: Check the section type as well. */
8707 || (relsec
->sh_type
!= SHT_REL
8708 && relsec
->sh_type
!= SHT_RELA
))
8711 arm_sec
->rel_type
= relsec
->sh_type
;
8712 if (relsec
->sh_type
== SHT_REL
)
8714 if (!slurp_rel_relocs (aux
->filedata
, relsec
->sh_offset
,
8716 & arm_sec
->rela
, & arm_sec
->nrelas
))
8719 else /* relsec->sh_type == SHT_RELA */
8721 if (!slurp_rela_relocs (aux
->filedata
, relsec
->sh_offset
,
8723 & arm_sec
->rela
, & arm_sec
->nrelas
))
8729 arm_sec
->next_rela
= arm_sec
->rela
;
8732 /* If there is no unwind data we can do nothing. */
8733 if (arm_sec
->data
== NULL
)
8736 /* If the offset is invalid then fail. */
8737 if (/* PR 21343 *//* PR 18879 */
8739 || word_offset
> (sec
->sh_size
- 4)
8740 || ((bfd_signed_vma
) word_offset
) < 0)
8743 /* Get the word at the required offset. */
8744 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
8746 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
8747 if (arm_sec
->rela
== NULL
)
8753 /* Look through the relocs to find the one that applies to the provided offset. */
8755 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
8757 bfd_vma prelval
, offset
;
8759 if (rp
->r_offset
> word_offset
&& !wrapped
)
8764 if (rp
->r_offset
> word_offset
)
8767 if (rp
->r_offset
& 3)
8769 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8770 (unsigned long) rp
->r_offset
);
8774 if (rp
->r_offset
< word_offset
)
8777 /* PR 17531: file: 027-161405-0.004 */
8778 if (aux
->symtab
== NULL
)
8781 if (arm_sec
->rel_type
== SHT_REL
)
8783 offset
= word
& 0x7fffffff;
8784 if (offset
& 0x40000000)
8785 offset
|= ~ (bfd_vma
) 0x7fffffff;
8787 else if (arm_sec
->rel_type
== SHT_RELA
)
8788 offset
= rp
->r_addend
;
8791 error (_("Unknown section relocation type %d encountered\n"),
8796 /* PR 17531 file: 027-1241568-0.004. */
8797 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
8799 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8800 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
8804 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
8805 offset
+= sym
->st_value
;
8806 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
8808 /* Check that we are processing the expected reloc type. */
8809 if (filedata
->file_header
.e_machine
== EM_ARM
)
8811 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8812 if (relname
== NULL
)
8814 warn (_("Skipping unknown ARM relocation type: %d\n"),
8815 (int) ELF32_R_TYPE (rp
->r_info
));
8819 if (streq (relname
, "R_ARM_NONE"))
8822 if (! streq (relname
, "R_ARM_PREL31"))
8824 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
8828 else if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
8830 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8831 if (relname
== NULL
)
8833 warn (_("Skipping unknown C6000 relocation type: %d\n"),
8834 (int) ELF32_R_TYPE (rp
->r_info
));
8838 if (streq (relname
, "R_C6000_NONE"))
8841 if (! streq (relname
, "R_C6000_PREL31"))
8843 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
8851 /* This function currently only supports ARM and TI unwinders. */
8852 warn (_("Only TI and ARM unwinders are currently supported\n"));
8856 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
8857 addr
->section
= sym
->st_shndx
;
8858 addr
->offset
= offset
;
8861 * sym_name
= sym
->st_name
;
8866 arm_sec
->next_rela
= rp
;
8871 static const char *tic6x_unwind_regnames
[16] =
8873 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8874 "A14", "A13", "A12", "A11", "A10",
8875 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8879 decode_tic6x_unwind_regmask (unsigned int mask
)
8883 for (i
= 12; mask
; mask
>>= 1, i
--)
8887 fputs (tic6x_unwind_regnames
[i
], stdout
);
8889 fputs (", ", stdout
);
8895 if (remaining == 0 && more_words) \
8898 if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, \
8899 data_offset, & word, & addr, NULL)) \
8905 #define GET_OP(OP) \
8910 (OP) = word >> 24; \
8915 printf (_("[Truncated opcode]\n")); \
8918 printf ("0x%02x ", OP)
8921 decode_arm_unwind_bytecode (Filedata
* filedata
,
8922 struct arm_unw_aux_info
* aux
,
8924 unsigned int remaining
,
8925 unsigned int more_words
,
8926 bfd_vma data_offset
,
8927 Elf_Internal_Shdr
* data_sec
,
8928 struct arm_section
* data_arm_sec
)
8930 struct absaddr addr
;
8931 bfd_boolean res
= TRUE
;
8933 /* Decode the unwinding instructions. */
8936 unsigned int op
, op2
;
8945 printf (" 0x%02x ", op
);
8947 if ((op
& 0xc0) == 0x00)
8949 int offset
= ((op
& 0x3f) << 2) + 4;
8951 printf (" vsp = vsp + %d", offset
);
8953 else if ((op
& 0xc0) == 0x40)
8955 int offset
= ((op
& 0x3f) << 2) + 4;
8957 printf (" vsp = vsp - %d", offset
);
8959 else if ((op
& 0xf0) == 0x80)
8962 if (op
== 0x80 && op2
== 0)
8963 printf (_("Refuse to unwind"));
8966 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
8967 bfd_boolean first
= TRUE
;
8971 for (i
= 0; i
< 12; i
++)
8972 if (mask
& (1 << i
))
8978 printf ("r%d", 4 + i
);
8983 else if ((op
& 0xf0) == 0x90)
8985 if (op
== 0x9d || op
== 0x9f)
8986 printf (_(" [Reserved]"));
8988 printf (" vsp = r%d", op
& 0x0f);
8990 else if ((op
& 0xf0) == 0xa0)
8992 int end
= 4 + (op
& 0x07);
8993 bfd_boolean first
= TRUE
;
8997 for (i
= 4; i
<= end
; i
++)
9013 else if (op
== 0xb0)
9014 printf (_(" finish"));
9015 else if (op
== 0xb1)
9018 if (op2
== 0 || (op2
& 0xf0) != 0)
9019 printf (_("[Spare]"));
9022 unsigned int mask
= op2
& 0x0f;
9023 bfd_boolean first
= TRUE
;
9027 for (i
= 0; i
< 12; i
++)
9028 if (mask
& (1 << i
))
9039 else if (op
== 0xb2)
9041 unsigned char buf
[9];
9042 unsigned int i
, len
;
9043 unsigned long offset
;
9045 for (i
= 0; i
< sizeof (buf
); i
++)
9048 if ((buf
[i
] & 0x80) == 0)
9051 if (i
== sizeof (buf
))
9053 error (_("corrupt change to vsp\n"));
9058 offset
= read_leb128 (buf
, buf
+ i
+ 1, FALSE
, &len
, NULL
);
9059 assert (len
== i
+ 1);
9060 offset
= offset
* 4 + 0x204;
9061 printf ("vsp = vsp + %ld", offset
);
9064 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
9066 unsigned int first
, last
;
9073 printf ("pop {D%d", first
);
9075 printf ("-D%d", first
+ last
);
9078 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
9080 unsigned int count
= op
& 0x07;
9084 printf ("-D%d", 8 + count
);
9087 else if (op
>= 0xc0 && op
<= 0xc5)
9089 unsigned int count
= op
& 0x07;
9091 printf (" pop {wR10");
9093 printf ("-wR%d", 10 + count
);
9096 else if (op
== 0xc6)
9098 unsigned int first
, last
;
9103 printf ("pop {wR%d", first
);
9105 printf ("-wR%d", first
+ last
);
9108 else if (op
== 0xc7)
9111 if (op2
== 0 || (op2
& 0xf0) != 0)
9112 printf (_("[Spare]"));
9115 unsigned int mask
= op2
& 0x0f;
9116 bfd_boolean first
= TRUE
;
9120 for (i
= 0; i
< 4; i
++)
9121 if (mask
& (1 << i
))
9127 printf ("wCGR%d", i
);
9134 printf (_(" [unsupported opcode]"));
9145 decode_tic6x_unwind_bytecode (Filedata
* filedata
,
9146 struct arm_unw_aux_info
* aux
,
9148 unsigned int remaining
,
9149 unsigned int more_words
,
9150 bfd_vma data_offset
,
9151 Elf_Internal_Shdr
* data_sec
,
9152 struct arm_section
* data_arm_sec
)
9154 struct absaddr addr
;
9156 /* Decode the unwinding instructions. */
9159 unsigned int op
, op2
;
9168 printf (" 0x%02x ", op
);
9170 if ((op
& 0xc0) == 0x00)
9172 int offset
= ((op
& 0x3f) << 3) + 8;
9173 printf (" sp = sp + %d", offset
);
9175 else if ((op
& 0xc0) == 0x80)
9178 if (op
== 0x80 && op2
== 0)
9179 printf (_("Refuse to unwind"));
9182 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
9184 printf ("pop compact {");
9188 decode_tic6x_unwind_regmask (mask
);
9192 else if ((op
& 0xf0) == 0xc0)
9200 unsigned int offset
;
9204 /* Scan entire instruction first so that GET_OP output is not
9205 interleaved with disassembly. */
9207 for (i
= 0; nregs
< (op
& 0xf); i
++)
9213 regpos
[nregs
].offset
= i
* 2;
9214 regpos
[nregs
].reg
= reg
;
9221 regpos
[nregs
].offset
= i
* 2 + 1;
9222 regpos
[nregs
].reg
= reg
;
9227 printf (_("pop frame {"));
9230 printf (_("*corrupt* - no registers specified"));
9235 for (i
= i
* 2; i
> 0; i
--)
9237 if (regpos
[reg
].offset
== i
- 1)
9239 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
9246 fputs (name
, stdout
);
9254 else if (op
== 0xd0)
9255 printf (" MOV FP, SP");
9256 else if (op
== 0xd1)
9257 printf (" __c6xabi_pop_rts");
9258 else if (op
== 0xd2)
9260 unsigned char buf
[9];
9261 unsigned int i
, len
;
9262 unsigned long offset
;
9264 for (i
= 0; i
< sizeof (buf
); i
++)
9267 if ((buf
[i
] & 0x80) == 0)
9270 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
9271 if (i
== sizeof (buf
))
9273 warn (_("Corrupt stack pointer adjustment detected\n"));
9277 offset
= read_leb128 (buf
, buf
+ i
+ 1, FALSE
, &len
, NULL
);
9278 assert (len
== i
+ 1);
9279 offset
= offset
* 8 + 0x408;
9280 printf (_("sp = sp + %ld"), offset
);
9282 else if ((op
& 0xf0) == 0xe0)
9284 if ((op
& 0x0f) == 7)
9287 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
9291 printf (_(" [unsupported opcode]"));
9300 arm_expand_prel31 (Filedata
* filedata
, bfd_vma word
, bfd_vma where
)
9304 offset
= word
& 0x7fffffff;
9305 if (offset
& 0x40000000)
9306 offset
|= ~ (bfd_vma
) 0x7fffffff;
9308 if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
9311 return offset
+ where
;
9315 decode_arm_unwind (Filedata
* filedata
,
9316 struct arm_unw_aux_info
* aux
,
9318 unsigned int remaining
,
9319 bfd_vma data_offset
,
9320 Elf_Internal_Shdr
* data_sec
,
9321 struct arm_section
* data_arm_sec
)
9324 unsigned int more_words
= 0;
9325 struct absaddr addr
;
9326 bfd_vma sym_name
= (bfd_vma
) -1;
9327 bfd_boolean res
= TRUE
;
9331 /* Fetch the first word.
9332 Note - when decoding an object file the address extracted
9333 here will always be 0. So we also pass in the sym_name
9334 parameter so that we can find the symbol associated with
9335 the personality routine. */
9336 if (! get_unwind_section_word (filedata
, aux
, data_arm_sec
, data_sec
, data_offset
,
9337 & word
, & addr
, & sym_name
))
9344 addr
.section
= SHN_UNDEF
;
9348 if ((word
& 0x80000000) == 0)
9350 /* Expand prel31 for personality routine. */
9352 const char *procname
;
9354 fn
= arm_expand_prel31 (filedata
, word
, data_sec
->sh_addr
+ data_offset
);
9355 printf (_(" Personality routine: "));
9357 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
9358 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
9360 procname
= aux
->strtab
+ sym_name
;
9361 print_vma (fn
, PREFIX_HEX
);
9364 fputs (" <", stdout
);
9365 fputs (procname
, stdout
);
9366 fputc ('>', stdout
);
9370 procname
= arm_print_vma_and_name (filedata
, aux
, fn
, addr
);
9371 fputc ('\n', stdout
);
9373 /* The GCC personality routines use the standard compact
9374 encoding, starting with one byte giving the number of
9376 if (procname
!= NULL
9377 && (const_strneq (procname
, "__gcc_personality_v0")
9378 || const_strneq (procname
, "__gxx_personality_v0")
9379 || const_strneq (procname
, "__gcj_personality_v0")
9380 || const_strneq (procname
, "__gnu_objc_personality_v0")))
9387 printf (_(" [Truncated data]\n"));
9390 more_words
= word
>> 24;
9400 /* ARM EHABI Section 6.3:
9402 An exception-handling table entry for the compact model looks like:
9406 1 0 index Data for personalityRoutine[index] */
9408 if (filedata
->file_header
.e_machine
== EM_ARM
9409 && (word
& 0x70000000))
9411 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
9415 per_index
= (word
>> 24) & 0x7f;
9416 printf (_(" Compact model index: %d\n"), per_index
);
9423 else if (per_index
< 3)
9425 more_words
= (word
>> 16) & 0xff;
9431 switch (filedata
->file_header
.e_machine
)
9436 if (! decode_arm_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
9437 data_offset
, data_sec
, data_arm_sec
))
9442 warn (_("Unknown ARM compact model index encountered\n"));
9443 printf (_(" [reserved]\n"));
9451 if (! decode_tic6x_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
9452 data_offset
, data_sec
, data_arm_sec
))
9455 else if (per_index
< 5)
9457 if (((word
>> 17) & 0x7f) == 0x7f)
9458 printf (_(" Restore stack from frame pointer\n"));
9460 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
9461 printf (_(" Registers restored: "));
9463 printf (" (compact) ");
9464 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
9466 printf (_(" Return register: %s\n"),
9467 tic6x_unwind_regnames
[word
& 0xf]);
9470 printf (_(" [reserved (%d)]\n"), per_index
);
9474 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
9475 filedata
->file_header
.e_machine
);
9479 /* Decode the descriptors. Not implemented. */
9485 dump_arm_unwind (Filedata
* filedata
,
9486 struct arm_unw_aux_info
* aux
,
9487 Elf_Internal_Shdr
* exidx_sec
)
9489 struct arm_section exidx_arm_sec
, extab_arm_sec
;
9490 unsigned int i
, exidx_len
;
9491 unsigned long j
, nfuns
;
9492 bfd_boolean res
= TRUE
;
9494 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
9495 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
9496 exidx_len
= exidx_sec
->sh_size
/ 8;
9498 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
9499 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
9500 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
9501 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
9503 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
9505 for (i
= 0; i
< exidx_len
; i
++)
9507 unsigned int exidx_fn
, exidx_entry
;
9508 struct absaddr fn_addr
, entry_addr
;
9511 fputc ('\n', stdout
);
9513 if (! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9514 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
9515 || ! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9516 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
9519 arm_free_section (& exidx_arm_sec
);
9520 arm_free_section (& extab_arm_sec
);
9524 /* ARM EHABI, Section 5:
9525 An index table entry consists of 2 words.
9526 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
9527 if (exidx_fn
& 0x80000000)
9529 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
9533 fn
= arm_expand_prel31 (filedata
, exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
9535 arm_print_vma_and_name (filedata
, aux
, fn
, fn_addr
);
9536 fputs (": ", stdout
);
9538 if (exidx_entry
== 1)
9540 print_vma (exidx_entry
, PREFIX_HEX
);
9541 fputs (" [cantunwind]\n", stdout
);
9543 else if (exidx_entry
& 0x80000000)
9545 print_vma (exidx_entry
, PREFIX_HEX
);
9546 fputc ('\n', stdout
);
9547 decode_arm_unwind (filedata
, aux
, exidx_entry
, 4, 0, NULL
, NULL
);
9551 bfd_vma table
, table_offset
= 0;
9552 Elf_Internal_Shdr
*table_sec
;
9554 fputs ("@", stdout
);
9555 table
= arm_expand_prel31 (filedata
, exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
9556 print_vma (table
, PREFIX_HEX
);
9559 /* Locate the matching .ARM.extab. */
9560 if (entry_addr
.section
!= SHN_UNDEF
9561 && entry_addr
.section
< filedata
->file_header
.e_shnum
)
9563 table_sec
= filedata
->section_headers
+ entry_addr
.section
;
9564 table_offset
= entry_addr
.offset
;
9566 if (table_offset
> table_sec
->sh_size
9567 || ((bfd_signed_vma
) table_offset
) < 0)
9569 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
9570 (unsigned long) table_offset
,
9571 printable_section_name (filedata
, table_sec
));
9578 table_sec
= find_section_by_address (filedata
, table
);
9579 if (table_sec
!= NULL
)
9580 table_offset
= table
- table_sec
->sh_addr
;
9583 if (table_sec
== NULL
)
9585 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
9586 (unsigned long) table
);
9591 if (! decode_arm_unwind (filedata
, aux
, 0, 0, table_offset
, table_sec
,
9600 arm_free_section (&exidx_arm_sec
);
9601 arm_free_section (&extab_arm_sec
);
9606 /* Used for both ARM and C6X unwinding tables. */
9609 arm_process_unwind (Filedata
* filedata
)
9611 struct arm_unw_aux_info aux
;
9612 Elf_Internal_Shdr
*unwsec
= NULL
;
9613 Elf_Internal_Shdr
*sec
;
9615 unsigned int sec_type
;
9616 bfd_boolean res
= TRUE
;
9618 switch (filedata
->file_header
.e_machine
)
9621 sec_type
= SHT_ARM_EXIDX
;
9625 sec_type
= SHT_C6000_UNWIND
;
9629 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9630 filedata
->file_header
.e_machine
);
9634 if (filedata
->string_table
== NULL
)
9637 memset (& aux
, 0, sizeof (aux
));
9638 aux
.filedata
= filedata
;
9640 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9642 if (sec
->sh_type
== SHT_SYMTAB
)
9646 error (_("Multiple symbol tables encountered\n"));
9652 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
9653 &aux
.strtab
, &aux
.strtab_size
))
9656 else if (sec
->sh_type
== sec_type
)
9661 printf (_("\nThere are no unwind sections in this file.\n"));
9663 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9665 if (sec
->sh_type
== sec_type
)
9667 unsigned long num_unwind
= sec
->sh_size
/ (2 * eh_addr_size
);
9668 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
9669 "contains %lu entry:\n",
9670 "\nUnwind section '%s' at offset 0x%lx "
9671 "contains %lu entries:\n",
9673 printable_section_name (filedata
, sec
),
9674 (unsigned long) sec
->sh_offset
,
9677 if (! dump_arm_unwind (filedata
, &aux
, sec
))
9683 free ((char *) aux
.strtab
);
9689 process_unwind (Filedata
* filedata
)
9691 struct unwind_handler
9693 unsigned int machtype
;
9694 bfd_boolean (* handler
)(Filedata
*);
9697 { EM_ARM
, arm_process_unwind
},
9698 { EM_IA_64
, ia64_process_unwind
},
9699 { EM_PARISC
, hppa_process_unwind
},
9700 { EM_TI_C6000
, arm_process_unwind
},
9708 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
9709 if (filedata
->file_header
.e_machine
== handlers
[i
].machtype
)
9710 return handlers
[i
].handler (filedata
);
9712 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9713 get_machine_name (filedata
->file_header
.e_machine
));
9718 dynamic_section_aarch64_val (Elf_Internal_Dyn
* entry
)
9720 switch (entry
->d_tag
)
9722 case DT_AARCH64_BTI_PLT
:
9723 case DT_AARCH64_PAC_PLT
:
9726 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9733 dynamic_section_mips_val (Filedata
* filedata
, Elf_Internal_Dyn
* entry
)
9735 switch (entry
->d_tag
)
9738 if (entry
->d_un
.d_val
== 0)
9742 static const char * opts
[] =
9744 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9745 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9746 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9747 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9751 bfd_boolean first
= TRUE
;
9753 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
9754 if (entry
->d_un
.d_val
& (1 << cnt
))
9756 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
9762 case DT_MIPS_IVERSION
:
9763 if (VALID_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
))
9764 printf (_("Interface Version: %s"),
9765 GET_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
));
9769 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
9770 /* Note: coded this way so that there is a single string for translation. */
9771 printf (_("<corrupt: %s>"), buf
);
9775 case DT_MIPS_TIME_STAMP
:
9779 time_t atime
= entry
->d_un
.d_val
;
9781 tmp
= gmtime (&atime
);
9782 /* PR 17531: file: 6accc532. */
9784 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
9786 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
9787 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9788 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9789 printf (_("Time Stamp: %s"), timebuf
);
9793 case DT_MIPS_RLD_VERSION
:
9794 case DT_MIPS_LOCAL_GOTNO
:
9795 case DT_MIPS_CONFLICTNO
:
9796 case DT_MIPS_LIBLISTNO
:
9797 case DT_MIPS_SYMTABNO
:
9798 case DT_MIPS_UNREFEXTNO
:
9799 case DT_MIPS_HIPAGENO
:
9800 case DT_MIPS_DELTA_CLASS_NO
:
9801 case DT_MIPS_DELTA_INSTANCE_NO
:
9802 case DT_MIPS_DELTA_RELOC_NO
:
9803 case DT_MIPS_DELTA_SYM_NO
:
9804 case DT_MIPS_DELTA_CLASSSYM_NO
:
9805 case DT_MIPS_COMPACT_SIZE
:
9806 print_vma (entry
->d_un
.d_val
, DEC
);
9810 filedata
->dynamic_info_DT_MIPS_XHASH
= entry
->d_un
.d_val
;
9811 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
9812 /* Falls through. */
9815 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9821 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
9823 switch (entry
->d_tag
)
9825 case DT_HP_DLD_FLAGS
:
9834 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
9835 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
9836 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
9837 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
9838 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
9839 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
9840 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
9841 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
9842 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
9843 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
9844 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
9845 { DT_HP_GST
, "HP_GST" },
9846 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
9847 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
9848 { DT_HP_NODELETE
, "HP_NODELETE" },
9849 { DT_HP_GROUP
, "HP_GROUP" },
9850 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
9852 bfd_boolean first
= TRUE
;
9854 bfd_vma val
= entry
->d_un
.d_val
;
9856 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
9857 if (val
& flags
[cnt
].bit
)
9861 fputs (flags
[cnt
].str
, stdout
);
9863 val
^= flags
[cnt
].bit
;
9866 if (val
!= 0 || first
)
9870 print_vma (val
, HEX
);
9876 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9884 /* VMS vs Unix time offset and factor. */
9886 #define VMS_EPOCH_OFFSET 35067168000000000LL
9887 #define VMS_GRANULARITY_FACTOR 10000000
9889 /* Display a VMS time in a human readable format. */
9892 print_vms_time (bfd_int64_t vmstime
)
9897 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
9898 tm
= gmtime (&unxtime
);
9899 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9900 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
9901 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
9906 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
9908 switch (entry
->d_tag
)
9910 case DT_IA_64_PLT_RESERVE
:
9911 /* First 3 slots reserved. */
9912 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9914 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
9917 case DT_IA_64_VMS_LINKTIME
:
9919 print_vms_time (entry
->d_un
.d_val
);
9923 case DT_IA_64_VMS_LNKFLAGS
:
9924 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9925 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
9926 printf (" CALL_DEBUG");
9927 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
9928 printf (" NOP0BUFS");
9929 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
9930 printf (" P0IMAGE");
9931 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
9932 printf (" MKTHREADS");
9933 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
9934 printf (" UPCALLS");
9935 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
9937 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
9938 printf (" INITIALIZE");
9939 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
9941 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
9942 printf (" EXE_INIT");
9943 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
9944 printf (" TBK_IN_IMG");
9945 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
9946 printf (" DBG_IN_IMG");
9947 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
9948 printf (" TBK_IN_DSF");
9949 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
9950 printf (" DBG_IN_DSF");
9951 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
9952 printf (" SIGNATURES");
9953 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
9954 printf (" REL_SEG_OFF");
9958 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9965 get_32bit_dynamic_section (Filedata
* filedata
)
9967 Elf32_External_Dyn
* edyn
;
9968 Elf32_External_Dyn
* ext
;
9969 Elf_Internal_Dyn
* entry
;
9971 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, filedata
,
9972 filedata
->dynamic_addr
, 1,
9973 filedata
->dynamic_size
,
9974 _("dynamic section"));
9978 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9979 might not have the luxury of section headers. Look for the DT_NULL
9980 terminator to determine the number of entries. */
9981 for (ext
= edyn
, filedata
->dynamic_nent
= 0;
9982 (char *) (ext
+ 1) <= (char *) edyn
+ filedata
->dynamic_size
;
9985 filedata
->dynamic_nent
++;
9986 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9990 filedata
->dynamic_section
9991 = (Elf_Internal_Dyn
*) cmalloc (filedata
->dynamic_nent
, sizeof (* entry
));
9992 if (filedata
->dynamic_section
== NULL
)
9994 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9995 (unsigned long) filedata
->dynamic_nent
);
10000 for (ext
= edyn
, entry
= filedata
->dynamic_section
;
10001 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10004 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
10005 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
10014 get_64bit_dynamic_section (Filedata
* filedata
)
10016 Elf64_External_Dyn
* edyn
;
10017 Elf64_External_Dyn
* ext
;
10018 Elf_Internal_Dyn
* entry
;
10020 /* Read in the data. */
10021 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, filedata
,
10022 filedata
->dynamic_addr
, 1,
10023 filedata
->dynamic_size
,
10024 _("dynamic section"));
10028 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
10029 might not have the luxury of section headers. Look for the DT_NULL
10030 terminator to determine the number of entries. */
10031 for (ext
= edyn
, filedata
->dynamic_nent
= 0;
10032 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
10033 (char *) (ext
+ 1) <= (char *) edyn
+ filedata
->dynamic_size
;
10036 filedata
->dynamic_nent
++;
10037 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
10041 filedata
->dynamic_section
10042 = (Elf_Internal_Dyn
*) cmalloc (filedata
->dynamic_nent
, sizeof (* entry
));
10043 if (filedata
->dynamic_section
== NULL
)
10045 error (_("Out of memory allocating space for %lu dynamic entries\n"),
10046 (unsigned long) filedata
->dynamic_nent
);
10051 /* Convert from external to internal formats. */
10052 for (ext
= edyn
, entry
= filedata
->dynamic_section
;
10053 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10056 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
10057 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
10066 print_dynamic_flags (bfd_vma flags
)
10068 bfd_boolean first
= TRUE
;
10074 flag
= flags
& - flags
;
10080 putc (' ', stdout
);
10084 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
10085 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
10086 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
10087 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
10088 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
10089 default: fputs (_("unknown"), stdout
); break;
10096 get_dynamic_data (Filedata
* filedata
, bfd_size_type number
, unsigned int ent_size
)
10098 unsigned char * e_data
;
10101 /* If the size_t type is smaller than the bfd_size_type, eg because
10102 you are building a 32-bit tool on a 64-bit host, then make sure
10103 that when (number) is cast to (size_t) no information is lost. */
10104 if (sizeof (size_t) < sizeof (bfd_size_type
)
10105 && (bfd_size_type
) ((size_t) number
) != number
)
10107 error (_("Size truncation prevents reading %s elements of size %u\n"),
10108 bfd_vmatoa ("u", number
), ent_size
);
10112 /* Be kind to memory checkers (eg valgrind, address sanitizer) by not
10113 attempting to allocate memory when the read is bound to fail. */
10114 if (ent_size
* number
> filedata
->file_size
)
10116 error (_("Invalid number of dynamic entries: %s\n"),
10117 bfd_vmatoa ("u", number
));
10121 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
10122 if (e_data
== NULL
)
10124 error (_("Out of memory reading %s dynamic entries\n"),
10125 bfd_vmatoa ("u", number
));
10129 if (fread (e_data
, ent_size
, (size_t) number
, filedata
->handle
) != number
)
10131 error (_("Unable to read in %s bytes of dynamic data\n"),
10132 bfd_vmatoa ("u", number
* ent_size
));
10137 i_data
= (bfd_vma
*) cmalloc ((size_t) number
, sizeof (*i_data
));
10138 if (i_data
== NULL
)
10140 error (_("Out of memory allocating space for %s dynamic entries\n"),
10141 bfd_vmatoa ("u", number
));
10147 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
10154 static unsigned long
10155 get_num_dynamic_syms (Filedata
* filedata
)
10157 unsigned long num_of_syms
= 0;
10159 if (!do_histogram
&& (!do_using_dynamic
|| do_dyn_syms
))
10160 return num_of_syms
;
10162 if (filedata
->dynamic_info
[DT_HASH
])
10164 unsigned char nb
[8];
10165 unsigned char nc
[8];
10166 unsigned int hash_ent_size
= 4;
10168 if ((filedata
->file_header
.e_machine
== EM_ALPHA
10169 || filedata
->file_header
.e_machine
== EM_S390
10170 || filedata
->file_header
.e_machine
== EM_S390_OLD
)
10171 && filedata
->file_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
10174 if (fseek (filedata
->handle
,
10175 (filedata
->archive_file_offset
10176 + offset_from_vma (filedata
, filedata
->dynamic_info
[DT_HASH
],
10177 sizeof nb
+ sizeof nc
)),
10180 error (_("Unable to seek to start of dynamic information\n"));
10184 if (fread (nb
, hash_ent_size
, 1, filedata
->handle
) != 1)
10186 error (_("Failed to read in number of buckets\n"));
10190 if (fread (nc
, hash_ent_size
, 1, filedata
->handle
) != 1)
10192 error (_("Failed to read in number of chains\n"));
10196 filedata
->nbuckets
= byte_get (nb
, hash_ent_size
);
10197 filedata
->nchains
= byte_get (nc
, hash_ent_size
);
10199 if (filedata
->nbuckets
!= 0 && filedata
->nchains
!= 0)
10201 filedata
->buckets
= get_dynamic_data (filedata
, filedata
->nbuckets
,
10203 filedata
->chains
= get_dynamic_data (filedata
, filedata
->nchains
,
10206 if (filedata
->buckets
!= NULL
&& filedata
->chains
!= NULL
)
10207 num_of_syms
= filedata
->nchains
;
10210 if (num_of_syms
== 0)
10212 free (filedata
->buckets
);
10213 filedata
->buckets
= NULL
;
10214 free (filedata
->chains
);
10215 filedata
->chains
= NULL
;
10216 filedata
->nbuckets
= 0;
10220 if (filedata
->dynamic_info_DT_GNU_HASH
)
10222 unsigned char nb
[16];
10223 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
10224 bfd_vma buckets_vma
;
10227 if (fseek (filedata
->handle
,
10228 (filedata
->archive_file_offset
10229 + offset_from_vma (filedata
,
10230 filedata
->dynamic_info_DT_GNU_HASH
,
10234 error (_("Unable to seek to start of dynamic information\n"));
10238 if (fread (nb
, 16, 1, filedata
->handle
) != 1)
10240 error (_("Failed to read in number of buckets\n"));
10244 filedata
->ngnubuckets
= byte_get (nb
, 4);
10245 filedata
->gnusymidx
= byte_get (nb
+ 4, 4);
10246 bitmaskwords
= byte_get (nb
+ 8, 4);
10247 buckets_vma
= filedata
->dynamic_info_DT_GNU_HASH
+ 16;
10249 buckets_vma
+= bitmaskwords
* 4;
10251 buckets_vma
+= bitmaskwords
* 8;
10253 if (fseek (filedata
->handle
,
10254 (filedata
->archive_file_offset
10255 + offset_from_vma (filedata
, buckets_vma
, 4)),
10258 error (_("Unable to seek to start of dynamic information\n"));
10262 filedata
->gnubuckets
10263 = get_dynamic_data (filedata
, filedata
->ngnubuckets
, 4);
10265 if (filedata
->gnubuckets
== NULL
)
10268 for (i
= 0; i
< filedata
->ngnubuckets
; i
++)
10269 if (filedata
->gnubuckets
[i
] != 0)
10271 if (filedata
->gnubuckets
[i
] < filedata
->gnusymidx
)
10274 if (maxchain
== 0xffffffff || filedata
->gnubuckets
[i
] > maxchain
)
10275 maxchain
= filedata
->gnubuckets
[i
];
10278 if (maxchain
== 0xffffffff)
10281 maxchain
-= filedata
->gnusymidx
;
10283 if (fseek (filedata
->handle
,
10284 (filedata
->archive_file_offset
10285 + offset_from_vma (filedata
,
10286 buckets_vma
+ 4 * (filedata
->ngnubuckets
10291 error (_("Unable to seek to start of dynamic information\n"));
10297 if (fread (nb
, 4, 1, filedata
->handle
) != 1)
10299 error (_("Failed to determine last chain length\n"));
10303 if (maxchain
+ 1 == 0)
10308 while ((byte_get (nb
, 4) & 1) == 0);
10310 if (fseek (filedata
->handle
,
10311 (filedata
->archive_file_offset
10312 + offset_from_vma (filedata
, (buckets_vma
10313 + 4 * filedata
->ngnubuckets
),
10317 error (_("Unable to seek to start of dynamic information\n"));
10321 filedata
->gnuchains
= get_dynamic_data (filedata
, maxchain
, 4);
10322 filedata
->ngnuchains
= maxchain
;
10324 if (filedata
->gnuchains
== NULL
)
10327 if (filedata
->dynamic_info_DT_MIPS_XHASH
)
10329 if (fseek (filedata
->handle
,
10330 (filedata
->archive_file_offset
10331 + offset_from_vma (filedata
, (buckets_vma
10332 + 4 * (filedata
->ngnubuckets
10336 error (_("Unable to seek to start of dynamic information\n"));
10340 filedata
->mipsxlat
= get_dynamic_data (filedata
, maxchain
, 4);
10341 if (filedata
->mipsxlat
== NULL
)
10345 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
10346 if (filedata
->gnubuckets
[hn
] != 0)
10348 bfd_vma si
= filedata
->gnubuckets
[hn
];
10349 bfd_vma off
= si
- filedata
->gnusymidx
;
10353 if (filedata
->dynamic_info_DT_MIPS_XHASH
)
10355 if (off
< filedata
->ngnuchains
10356 && filedata
->mipsxlat
[off
] >= num_of_syms
)
10357 num_of_syms
= filedata
->mipsxlat
[off
] + 1;
10361 if (si
>= num_of_syms
)
10362 num_of_syms
= si
+ 1;
10366 while (off
< filedata
->ngnuchains
10367 && (filedata
->gnuchains
[off
++] & 1) == 0);
10370 if (num_of_syms
== 0)
10373 free (filedata
->mipsxlat
);
10374 filedata
->mipsxlat
= NULL
;
10375 free (filedata
->gnuchains
);
10376 filedata
->gnuchains
= NULL
;
10377 free (filedata
->gnubuckets
);
10378 filedata
->gnubuckets
= NULL
;
10379 filedata
->ngnubuckets
= 0;
10380 filedata
->ngnuchains
= 0;
10384 return num_of_syms
;
10387 /* Parse and display the contents of the dynamic section. */
10390 process_dynamic_section (Filedata
* filedata
)
10392 Elf_Internal_Dyn
* entry
;
10394 if (filedata
->dynamic_size
== 0)
10397 printf (_("\nThere is no dynamic section in this file.\n"));
10404 if (! get_32bit_dynamic_section (filedata
))
10409 if (! get_64bit_dynamic_section (filedata
))
10413 /* Find the appropriate symbol table. */
10414 if (filedata
->dynamic_symbols
== NULL
|| do_histogram
)
10416 unsigned long num_of_syms
;
10418 for (entry
= filedata
->dynamic_section
;
10419 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10421 if (entry
->d_tag
== DT_SYMTAB
)
10422 filedata
->dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
10423 else if (entry
->d_tag
== DT_SYMENT
)
10424 filedata
->dynamic_info
[DT_SYMENT
] = entry
->d_un
.d_val
;
10425 else if (entry
->d_tag
== DT_HASH
)
10426 filedata
->dynamic_info
[DT_HASH
] = entry
->d_un
.d_val
;
10427 else if (entry
->d_tag
== DT_GNU_HASH
)
10428 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10429 else if ((filedata
->file_header
.e_machine
== EM_MIPS
10430 || filedata
->file_header
.e_machine
== EM_MIPS_RS3_LE
)
10431 && entry
->d_tag
== DT_MIPS_XHASH
)
10433 filedata
->dynamic_info_DT_MIPS_XHASH
= entry
->d_un
.d_val
;
10434 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10437 num_of_syms
= get_num_dynamic_syms (filedata
);
10439 if (num_of_syms
!= 0
10440 && filedata
->dynamic_symbols
== NULL
10441 && filedata
->dynamic_info
[DT_SYMTAB
]
10442 && filedata
->dynamic_info
[DT_SYMENT
])
10444 Elf_Internal_Phdr
*seg
;
10445 bfd_vma vma
= filedata
->dynamic_info
[DT_SYMTAB
];
10447 if (! get_program_headers (filedata
))
10449 error (_("Cannot interpret virtual addresses "
10450 "without program headers.\n"));
10454 for (seg
= filedata
->program_headers
;
10455 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
10458 if (seg
->p_type
!= PT_LOAD
)
10461 if (seg
->p_offset
+ seg
->p_filesz
> filedata
->file_size
)
10463 /* See PR 21379 for a reproducer. */
10464 error (_("Invalid PT_LOAD entry\n"));
10468 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
10469 && vma
< seg
->p_vaddr
+ seg
->p_filesz
)
10471 /* Since we do not know how big the symbol table is,
10472 we default to reading in up to the end of PT_LOAD
10473 segment and processing that. This is overkill, I
10474 know, but it should work. */
10475 Elf_Internal_Shdr section
;
10476 section
.sh_offset
= (vma
- seg
->p_vaddr
10478 section
.sh_size
= (num_of_syms
10479 * filedata
->dynamic_info
[DT_SYMENT
]);
10480 section
.sh_entsize
= filedata
->dynamic_info
[DT_SYMENT
];
10483 && filedata
->dynamic_symtab_section
!= NULL
10484 && ((filedata
->dynamic_symtab_section
->sh_offset
10485 != section
.sh_offset
)
10486 || (filedata
->dynamic_symtab_section
->sh_size
10487 != section
.sh_size
)
10488 || (filedata
->dynamic_symtab_section
->sh_entsize
10489 != section
.sh_entsize
)))
10491 the .dynsym section doesn't match the DT_SYMTAB and DT_SYMENT tags\n"));
10493 section
.sh_name
= filedata
->string_table_length
;
10494 filedata
->dynamic_symbols
10495 = GET_ELF_SYMBOLS (filedata
, §ion
,
10496 &filedata
->num_dynamic_syms
);
10497 if (filedata
->dynamic_symbols
== NULL
10498 || filedata
->num_dynamic_syms
!= num_of_syms
)
10500 error (_("Corrupt DT_SYMTAB dynamic entry\n"));
10509 /* Similarly find a string table. */
10510 if (filedata
->dynamic_strings
== NULL
)
10511 for (entry
= filedata
->dynamic_section
;
10512 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10515 if (entry
->d_tag
== DT_STRTAB
)
10516 filedata
->dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
10518 if (entry
->d_tag
== DT_STRSZ
)
10519 filedata
->dynamic_info
[DT_STRSZ
] = entry
->d_un
.d_val
;
10521 if (filedata
->dynamic_info
[DT_STRTAB
]
10522 && filedata
->dynamic_info
[DT_STRSZ
])
10524 unsigned long offset
;
10525 bfd_size_type str_tab_len
= filedata
->dynamic_info
[DT_STRSZ
];
10527 offset
= offset_from_vma (filedata
,
10528 filedata
->dynamic_info
[DT_STRTAB
],
10531 && filedata
->dynamic_strtab_section
10532 && ((filedata
->dynamic_strtab_section
->sh_offset
10533 != (file_ptr
) offset
)
10534 || (filedata
->dynamic_strtab_section
->sh_size
10537 the .dynstr section doesn't match the DT_STRTAB and DT_STRSZ tags\n"));
10539 filedata
->dynamic_strings
10540 = (char *) get_data (NULL
, filedata
, offset
, 1, str_tab_len
,
10541 _("dynamic string table"));
10542 if (filedata
->dynamic_strings
== NULL
)
10544 error (_("Corrupt DT_STRTAB dynamic entry\n"));
10548 filedata
->dynamic_strings_length
= str_tab_len
;
10553 /* And find the syminfo section if available. */
10554 if (filedata
->dynamic_syminfo
== NULL
)
10556 unsigned long syminsz
= 0;
10558 for (entry
= filedata
->dynamic_section
;
10559 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10562 if (entry
->d_tag
== DT_SYMINENT
)
10564 /* Note: these braces are necessary to avoid a syntax
10565 error from the SunOS4 C compiler. */
10566 /* PR binutils/17531: A corrupt file can trigger this test.
10567 So do not use an assert, instead generate an error message. */
10568 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
10569 error (_("Bad value (%d) for SYMINENT entry\n"),
10570 (int) entry
->d_un
.d_val
);
10572 else if (entry
->d_tag
== DT_SYMINSZ
)
10573 syminsz
= entry
->d_un
.d_val
;
10574 else if (entry
->d_tag
== DT_SYMINFO
)
10575 filedata
->dynamic_syminfo_offset
10576 = offset_from_vma (filedata
, entry
->d_un
.d_val
, syminsz
);
10579 if (filedata
->dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
10581 Elf_External_Syminfo
* extsyminfo
;
10582 Elf_External_Syminfo
* extsym
;
10583 Elf_Internal_Syminfo
* syminfo
;
10585 /* There is a syminfo section. Read the data. */
10586 extsyminfo
= (Elf_External_Syminfo
*)
10587 get_data (NULL
, filedata
, filedata
->dynamic_syminfo_offset
,
10588 1, syminsz
, _("symbol information"));
10592 if (filedata
->dynamic_syminfo
!= NULL
)
10594 error (_("Multiple dynamic symbol information sections found\n"));
10595 free (filedata
->dynamic_syminfo
);
10597 filedata
->dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
10598 if (filedata
->dynamic_syminfo
== NULL
)
10600 error (_("Out of memory allocating %lu bytes "
10601 "for dynamic symbol info\n"),
10602 (unsigned long) syminsz
);
10606 filedata
->dynamic_syminfo_nent
10607 = syminsz
/ sizeof (Elf_External_Syminfo
);
10608 for (syminfo
= filedata
->dynamic_syminfo
, extsym
= extsyminfo
;
10609 syminfo
< (filedata
->dynamic_syminfo
10610 + filedata
->dynamic_syminfo_nent
);
10611 ++syminfo
, ++extsym
)
10613 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
10614 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
10621 if (do_dynamic
&& filedata
->dynamic_addr
)
10622 printf (ngettext ("\nDynamic section at offset 0x%lx "
10623 "contains %lu entry:\n",
10624 "\nDynamic section at offset 0x%lx "
10625 "contains %lu entries:\n",
10626 filedata
->dynamic_nent
),
10627 filedata
->dynamic_addr
, (unsigned long) filedata
->dynamic_nent
);
10629 printf (_(" Tag Type Name/Value\n"));
10631 for (entry
= filedata
->dynamic_section
;
10632 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10637 const char * dtype
;
10640 print_vma (entry
->d_tag
, FULL_HEX
);
10641 dtype
= get_dynamic_type (filedata
, entry
->d_tag
);
10642 printf (" (%s)%*s", dtype
,
10643 ((is_32bit_elf
? 27 : 19) - (int) strlen (dtype
)), " ");
10646 switch (entry
->d_tag
)
10650 print_dynamic_flags (entry
->d_un
.d_val
);
10660 switch (entry
->d_tag
)
10663 printf (_("Auxiliary library"));
10667 printf (_("Filter library"));
10671 printf (_("Configuration file"));
10675 printf (_("Dependency audit library"));
10679 printf (_("Audit library"));
10683 if (VALID_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
))
10684 printf (": [%s]\n",
10685 GET_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
));
10689 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10698 printf (_("Flags:"));
10700 if (entry
->d_un
.d_val
== 0)
10701 printf (_(" None\n"));
10704 unsigned long int val
= entry
->d_un
.d_val
;
10706 if (val
& DTF_1_PARINIT
)
10708 printf (" PARINIT");
10709 val
^= DTF_1_PARINIT
;
10711 if (val
& DTF_1_CONFEXP
)
10713 printf (" CONFEXP");
10714 val
^= DTF_1_CONFEXP
;
10717 printf (" %lx", val
);
10726 printf (_("Flags:"));
10728 if (entry
->d_un
.d_val
== 0)
10729 printf (_(" None\n"));
10732 unsigned long int val
= entry
->d_un
.d_val
;
10734 if (val
& DF_P1_LAZYLOAD
)
10736 printf (" LAZYLOAD");
10737 val
^= DF_P1_LAZYLOAD
;
10739 if (val
& DF_P1_GROUPPERM
)
10741 printf (" GROUPPERM");
10742 val
^= DF_P1_GROUPPERM
;
10745 printf (" %lx", val
);
10754 printf (_("Flags:"));
10755 if (entry
->d_un
.d_val
== 0)
10756 printf (_(" None\n"));
10759 unsigned long int val
= entry
->d_un
.d_val
;
10761 if (val
& DF_1_NOW
)
10766 if (val
& DF_1_GLOBAL
)
10768 printf (" GLOBAL");
10769 val
^= DF_1_GLOBAL
;
10771 if (val
& DF_1_GROUP
)
10776 if (val
& DF_1_NODELETE
)
10778 printf (" NODELETE");
10779 val
^= DF_1_NODELETE
;
10781 if (val
& DF_1_LOADFLTR
)
10783 printf (" LOADFLTR");
10784 val
^= DF_1_LOADFLTR
;
10786 if (val
& DF_1_INITFIRST
)
10788 printf (" INITFIRST");
10789 val
^= DF_1_INITFIRST
;
10791 if (val
& DF_1_NOOPEN
)
10793 printf (" NOOPEN");
10794 val
^= DF_1_NOOPEN
;
10796 if (val
& DF_1_ORIGIN
)
10798 printf (" ORIGIN");
10799 val
^= DF_1_ORIGIN
;
10801 if (val
& DF_1_DIRECT
)
10803 printf (" DIRECT");
10804 val
^= DF_1_DIRECT
;
10806 if (val
& DF_1_TRANS
)
10811 if (val
& DF_1_INTERPOSE
)
10813 printf (" INTERPOSE");
10814 val
^= DF_1_INTERPOSE
;
10816 if (val
& DF_1_NODEFLIB
)
10818 printf (" NODEFLIB");
10819 val
^= DF_1_NODEFLIB
;
10821 if (val
& DF_1_NODUMP
)
10823 printf (" NODUMP");
10824 val
^= DF_1_NODUMP
;
10826 if (val
& DF_1_CONFALT
)
10828 printf (" CONFALT");
10829 val
^= DF_1_CONFALT
;
10831 if (val
& DF_1_ENDFILTEE
)
10833 printf (" ENDFILTEE");
10834 val
^= DF_1_ENDFILTEE
;
10836 if (val
& DF_1_DISPRELDNE
)
10838 printf (" DISPRELDNE");
10839 val
^= DF_1_DISPRELDNE
;
10841 if (val
& DF_1_DISPRELPND
)
10843 printf (" DISPRELPND");
10844 val
^= DF_1_DISPRELPND
;
10846 if (val
& DF_1_NODIRECT
)
10848 printf (" NODIRECT");
10849 val
^= DF_1_NODIRECT
;
10851 if (val
& DF_1_IGNMULDEF
)
10853 printf (" IGNMULDEF");
10854 val
^= DF_1_IGNMULDEF
;
10856 if (val
& DF_1_NOKSYMS
)
10858 printf (" NOKSYMS");
10859 val
^= DF_1_NOKSYMS
;
10861 if (val
& DF_1_NOHDR
)
10866 if (val
& DF_1_EDITED
)
10868 printf (" EDITED");
10869 val
^= DF_1_EDITED
;
10871 if (val
& DF_1_NORELOC
)
10873 printf (" NORELOC");
10874 val
^= DF_1_NORELOC
;
10876 if (val
& DF_1_SYMINTPOSE
)
10878 printf (" SYMINTPOSE");
10879 val
^= DF_1_SYMINTPOSE
;
10881 if (val
& DF_1_GLOBAUDIT
)
10883 printf (" GLOBAUDIT");
10884 val
^= DF_1_GLOBAUDIT
;
10886 if (val
& DF_1_SINGLETON
)
10888 printf (" SINGLETON");
10889 val
^= DF_1_SINGLETON
;
10891 if (val
& DF_1_STUB
)
10896 if (val
& DF_1_PIE
)
10901 if (val
& DF_1_KMOD
)
10906 if (val
& DF_1_WEAKFILTER
)
10908 printf (" WEAKFILTER");
10909 val
^= DF_1_WEAKFILTER
;
10911 if (val
& DF_1_NOCOMMON
)
10913 printf (" NOCOMMON");
10914 val
^= DF_1_NOCOMMON
;
10917 printf (" %lx", val
);
10924 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10926 puts (get_dynamic_type (filedata
, entry
->d_un
.d_val
));
10946 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10952 if (VALID_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
))
10953 name
= GET_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
);
10959 switch (entry
->d_tag
)
10962 printf (_("Shared library: [%s]"), name
);
10964 if (streq (name
, filedata
->program_interpreter
))
10965 printf (_(" program interpreter"));
10969 printf (_("Library soname: [%s]"), name
);
10973 printf (_("Library rpath: [%s]"), name
);
10977 printf (_("Library runpath: [%s]"), name
);
10981 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10986 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10999 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
11000 /* Fall through. */
11004 case DT_INIT_ARRAYSZ
:
11005 case DT_FINI_ARRAYSZ
:
11006 case DT_GNU_CONFLICTSZ
:
11007 case DT_GNU_LIBLISTSZ
:
11010 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
11011 printf (_(" (bytes)\n"));
11016 case DT_VERNEEDNUM
:
11021 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
11030 case DT_INIT_ARRAY
:
11031 case DT_FINI_ARRAY
:
11034 if (entry
->d_tag
== DT_USED
11035 && VALID_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
))
11037 char * name
= GET_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
);
11041 printf (_("Not needed object: [%s]\n"), name
);
11046 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
11052 /* The value of this entry is ignored. */
11057 case DT_GNU_PRELINKED
:
11061 time_t atime
= entry
->d_un
.d_val
;
11063 tmp
= gmtime (&atime
);
11064 /* PR 17533 file: 041-1244816-0.004. */
11066 printf (_("<corrupt time val: %lx"),
11067 (unsigned long) atime
);
11069 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
11070 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
11071 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
11077 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
11080 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
11086 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
11087 filedata
->version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)]
11088 = entry
->d_un
.d_val
;
11092 switch (filedata
->file_header
.e_machine
)
11095 dynamic_section_aarch64_val (entry
);
11098 case EM_MIPS_RS3_LE
:
11099 dynamic_section_mips_val (filedata
, entry
);
11102 dynamic_section_parisc_val (entry
);
11105 dynamic_section_ia64_val (entry
);
11108 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
11120 get_ver_flags (unsigned int flags
)
11122 static char buff
[128];
11129 if (flags
& VER_FLG_BASE
)
11130 strcat (buff
, "BASE");
11132 if (flags
& VER_FLG_WEAK
)
11134 if (flags
& VER_FLG_BASE
)
11135 strcat (buff
, " | ");
11137 strcat (buff
, "WEAK");
11140 if (flags
& VER_FLG_INFO
)
11142 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
11143 strcat (buff
, " | ");
11145 strcat (buff
, "INFO");
11148 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
11150 if (flags
& (VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
11151 strcat (buff
, " | ");
11153 strcat (buff
, _("<unknown>"));
11159 /* Display the contents of the version sections. */
11162 process_version_sections (Filedata
* filedata
)
11164 Elf_Internal_Shdr
* section
;
11166 bfd_boolean found
= FALSE
;
11171 for (i
= 0, section
= filedata
->section_headers
;
11172 i
< filedata
->file_header
.e_shnum
;
11175 switch (section
->sh_type
)
11177 case SHT_GNU_verdef
:
11179 Elf_External_Verdef
* edefs
;
11186 printf (ngettext ("\nVersion definition section '%s' "
11187 "contains %u entry:\n",
11188 "\nVersion definition section '%s' "
11189 "contains %u entries:\n",
11191 printable_section_name (filedata
, section
),
11194 printf (_(" Addr: 0x"));
11195 printf_vma (section
->sh_addr
);
11196 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
11197 (unsigned long) section
->sh_offset
, section
->sh_link
,
11198 printable_section_name_from_index (filedata
, section
->sh_link
));
11200 edefs
= (Elf_External_Verdef
*)
11201 get_data (NULL
, filedata
, section
->sh_offset
, 1,section
->sh_size
,
11202 _("version definition section"));
11205 endbuf
= (char *) edefs
+ section
->sh_size
;
11207 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
11210 Elf_External_Verdef
* edef
;
11211 Elf_Internal_Verdef ent
;
11212 Elf_External_Verdaux
* eaux
;
11213 Elf_Internal_Verdaux aux
;
11214 unsigned long isum
;
11217 vstart
= ((char *) edefs
) + idx
;
11218 if (vstart
+ sizeof (*edef
) > endbuf
)
11221 edef
= (Elf_External_Verdef
*) vstart
;
11223 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
11224 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
11225 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
11226 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
11227 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
11228 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
11229 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
11231 printf (_(" %#06lx: Rev: %d Flags: %s"),
11232 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
11234 printf (_(" Index: %d Cnt: %d "),
11235 ent
.vd_ndx
, ent
.vd_cnt
);
11237 /* Check for overflow. */
11238 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
11241 vstart
+= ent
.vd_aux
;
11243 if (vstart
+ sizeof (*eaux
) > endbuf
)
11245 eaux
= (Elf_External_Verdaux
*) vstart
;
11247 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
11248 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
11250 if (VALID_DYNAMIC_NAME (filedata
, aux
.vda_name
))
11251 printf (_("Name: %s\n"),
11252 GET_DYNAMIC_NAME (filedata
, aux
.vda_name
));
11254 printf (_("Name index: %ld\n"), aux
.vda_name
);
11256 isum
= idx
+ ent
.vd_aux
;
11258 for (j
= 1; j
< ent
.vd_cnt
; j
++)
11260 if (aux
.vda_next
< sizeof (*eaux
)
11261 && !(j
== ent
.vd_cnt
- 1 && aux
.vda_next
== 0))
11263 warn (_("Invalid vda_next field of %lx\n"),
11268 /* Check for overflow. */
11269 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
11272 isum
+= aux
.vda_next
;
11273 vstart
+= aux
.vda_next
;
11275 if (vstart
+ sizeof (*eaux
) > endbuf
)
11277 eaux
= (Elf_External_Verdaux
*) vstart
;
11279 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
11280 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
11282 if (VALID_DYNAMIC_NAME (filedata
, aux
.vda_name
))
11283 printf (_(" %#06lx: Parent %d: %s\n"),
11285 GET_DYNAMIC_NAME (filedata
, aux
.vda_name
));
11287 printf (_(" %#06lx: Parent %d, name index: %ld\n"),
11288 isum
, j
, aux
.vda_name
);
11291 if (j
< ent
.vd_cnt
)
11292 printf (_(" Version def aux past end of section\n"));
11295 file: id:000001,src:000172+005151,op:splice,rep:2. */
11296 if (ent
.vd_next
< sizeof (*edef
)
11297 && !(cnt
== section
->sh_info
- 1 && ent
.vd_next
== 0))
11299 warn (_("Invalid vd_next field of %lx\n"), ent
.vd_next
);
11300 cnt
= section
->sh_info
;
11303 if (ent
.vd_next
> (size_t) (endbuf
- ((char *) edefs
+ idx
)))
11306 idx
+= ent
.vd_next
;
11309 if (cnt
< section
->sh_info
)
11310 printf (_(" Version definition past end of section\n"));
11316 case SHT_GNU_verneed
:
11318 Elf_External_Verneed
* eneed
;
11325 printf (ngettext ("\nVersion needs section '%s' "
11326 "contains %u entry:\n",
11327 "\nVersion needs section '%s' "
11328 "contains %u entries:\n",
11330 printable_section_name (filedata
, section
), section
->sh_info
);
11332 printf (_(" Addr: 0x"));
11333 printf_vma (section
->sh_addr
);
11334 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
11335 (unsigned long) section
->sh_offset
, section
->sh_link
,
11336 printable_section_name_from_index (filedata
, section
->sh_link
));
11338 eneed
= (Elf_External_Verneed
*) get_data (NULL
, filedata
,
11339 section
->sh_offset
, 1,
11341 _("Version Needs section"));
11344 endbuf
= (char *) eneed
+ section
->sh_size
;
11346 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
11348 Elf_External_Verneed
* entry
;
11349 Elf_Internal_Verneed ent
;
11350 unsigned long isum
;
11354 vstart
= ((char *) eneed
) + idx
;
11355 if (vstart
+ sizeof (*entry
) > endbuf
)
11358 entry
= (Elf_External_Verneed
*) vstart
;
11360 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
11361 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
11362 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
11363 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
11364 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
11366 printf (_(" %#06lx: Version: %d"), idx
, ent
.vn_version
);
11368 if (VALID_DYNAMIC_NAME (filedata
, ent
.vn_file
))
11369 printf (_(" File: %s"),
11370 GET_DYNAMIC_NAME (filedata
, ent
.vn_file
));
11372 printf (_(" File: %lx"), ent
.vn_file
);
11374 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
11376 /* Check for overflow. */
11377 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
11379 vstart
+= ent
.vn_aux
;
11381 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
11383 Elf_External_Vernaux
* eaux
;
11384 Elf_Internal_Vernaux aux
;
11386 if (vstart
+ sizeof (*eaux
) > endbuf
)
11388 eaux
= (Elf_External_Vernaux
*) vstart
;
11390 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
11391 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
11392 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
11393 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
11394 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
11396 if (VALID_DYNAMIC_NAME (filedata
, aux
.vna_name
))
11397 printf (_(" %#06lx: Name: %s"),
11398 isum
, GET_DYNAMIC_NAME (filedata
, aux
.vna_name
));
11400 printf (_(" %#06lx: Name index: %lx"),
11401 isum
, aux
.vna_name
);
11403 printf (_(" Flags: %s Version: %d\n"),
11404 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
11406 if (aux
.vna_next
< sizeof (*eaux
)
11407 && !(j
== ent
.vn_cnt
- 1 && aux
.vna_next
== 0))
11409 warn (_("Invalid vna_next field of %lx\n"),
11414 /* Check for overflow. */
11415 if (aux
.vna_next
> (size_t) (endbuf
- vstart
))
11417 isum
+= aux
.vna_next
;
11418 vstart
+= aux
.vna_next
;
11421 if (j
< ent
.vn_cnt
)
11422 warn (_("Missing Version Needs auxillary information\n"));
11424 if (ent
.vn_next
< sizeof (*entry
)
11425 && !(cnt
== section
->sh_info
- 1 && ent
.vn_next
== 0))
11427 warn (_("Invalid vn_next field of %lx\n"), ent
.vn_next
);
11428 cnt
= section
->sh_info
;
11431 if (ent
.vn_next
> (size_t) (endbuf
- ((char *) eneed
+ idx
)))
11433 idx
+= ent
.vn_next
;
11436 if (cnt
< section
->sh_info
)
11437 warn (_("Missing Version Needs information\n"));
11443 case SHT_GNU_versym
:
11445 Elf_Internal_Shdr
* link_section
;
11448 unsigned char * edata
;
11449 unsigned short * data
;
11451 Elf_Internal_Sym
* symbols
;
11452 Elf_Internal_Shdr
* string_sec
;
11453 unsigned long num_syms
;
11456 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
11459 link_section
= filedata
->section_headers
+ section
->sh_link
;
11460 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
11462 if (link_section
->sh_link
>= filedata
->file_header
.e_shnum
)
11467 symbols
= GET_ELF_SYMBOLS (filedata
, link_section
, & num_syms
);
11468 if (symbols
== NULL
)
11471 string_sec
= filedata
->section_headers
+ link_section
->sh_link
;
11473 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
11474 string_sec
->sh_size
,
11475 _("version string table"));
11482 printf (ngettext ("\nVersion symbols section '%s' "
11483 "contains %lu entry:\n",
11484 "\nVersion symbols section '%s' "
11485 "contains %lu entries:\n",
11487 printable_section_name (filedata
, section
), (unsigned long) total
);
11489 printf (_(" Addr: 0x"));
11490 printf_vma (section
->sh_addr
);
11491 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
11492 (unsigned long) section
->sh_offset
, section
->sh_link
,
11493 printable_section_name (filedata
, link_section
));
11495 off
= offset_from_vma (filedata
,
11496 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
11497 total
* sizeof (short));
11498 edata
= (unsigned char *) get_data (NULL
, filedata
, off
,
11499 sizeof (short), total
,
11500 _("version symbol data"));
11508 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
11510 for (cnt
= total
; cnt
--;)
11511 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
11516 for (cnt
= 0; cnt
< total
; cnt
+= 4)
11520 char *invalid
= _("*invalid*");
11522 printf (" %03x:", cnt
);
11524 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
11525 switch (data
[cnt
+ j
])
11528 fputs (_(" 0 (*local*) "), stdout
);
11532 fputs (_(" 1 (*global*) "), stdout
);
11536 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
11537 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
11539 /* If this index value is greater than the size of the symbols
11540 array, break to avoid an out-of-bounds read. */
11541 if ((unsigned long)(cnt
+ j
) >= num_syms
)
11543 warn (_("invalid index into symbol array\n"));
11548 if (filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
11550 Elf_Internal_Verneed ivn
;
11551 unsigned long offset
;
11553 offset
= offset_from_vma
11555 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
11556 sizeof (Elf_External_Verneed
));
11560 Elf_Internal_Vernaux ivna
;
11561 Elf_External_Verneed evn
;
11562 Elf_External_Vernaux evna
;
11563 unsigned long a_off
;
11565 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
11566 _("version need")) == NULL
)
11569 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
11570 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
11572 a_off
= offset
+ ivn
.vn_aux
;
11576 if (get_data (&evna
, filedata
, a_off
, sizeof (evna
),
11577 1, _("version need aux (2)")) == NULL
)
11580 ivna
.vna_other
= 0;
11584 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
11585 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
11588 a_off
+= ivna
.vna_next
;
11590 while (ivna
.vna_other
!= data
[cnt
+ j
]
11591 && ivna
.vna_next
!= 0);
11593 if (ivna
.vna_other
== data
[cnt
+ j
])
11595 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
11597 if (ivna
.vna_name
>= string_sec
->sh_size
)
11600 name
= strtab
+ ivna
.vna_name
;
11604 offset
+= ivn
.vn_next
;
11606 while (ivn
.vn_next
);
11609 if (data
[cnt
+ j
] != 0x8001
11610 && filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
11612 Elf_Internal_Verdef ivd
;
11613 Elf_External_Verdef evd
;
11614 unsigned long offset
;
11616 offset
= offset_from_vma
11618 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
11623 if (get_data (&evd
, filedata
, offset
, sizeof (evd
), 1,
11624 _("version def")) == NULL
)
11627 /* PR 17531: file: 046-1082287-0.004. */
11628 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
11633 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
11634 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
11637 offset
+= ivd
.vd_next
;
11639 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
11640 && ivd
.vd_next
!= 0);
11642 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
11644 Elf_External_Verdaux evda
;
11645 Elf_Internal_Verdaux ivda
;
11647 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
11649 if (get_data (&evda
, filedata
,
11650 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
11652 _("version def aux")) == NULL
)
11655 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
11657 if (ivda
.vda_name
>= string_sec
->sh_size
)
11659 else if (name
!= NULL
&& name
!= invalid
)
11660 name
= _("*both*");
11662 name
= strtab
+ ivda
.vda_name
;
11666 nn
+= printf ("(%s%-*s",
11668 12 - (int) strlen (name
),
11672 printf ("%*c", 18 - nn
, ' ');
11690 printf (_("\nNo version information found in this file.\n"));
11695 static const char *
11696 get_symbol_binding (Filedata
* filedata
, unsigned int binding
)
11698 static char buff
[64];
11702 case STB_LOCAL
: return "LOCAL";
11703 case STB_GLOBAL
: return "GLOBAL";
11704 case STB_WEAK
: return "WEAK";
11706 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
11707 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
11709 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
11711 if (binding
== STB_GNU_UNIQUE
11712 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
)
11714 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
11717 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
11722 static const char *
11723 get_symbol_type (Filedata
* filedata
, unsigned int type
)
11725 static char buff
[64];
11729 case STT_NOTYPE
: return "NOTYPE";
11730 case STT_OBJECT
: return "OBJECT";
11731 case STT_FUNC
: return "FUNC";
11732 case STT_SECTION
: return "SECTION";
11733 case STT_FILE
: return "FILE";
11734 case STT_COMMON
: return "COMMON";
11735 case STT_TLS
: return "TLS";
11736 case STT_RELC
: return "RELC";
11737 case STT_SRELC
: return "SRELC";
11739 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
11741 if (filedata
->file_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
11742 return "THUMB_FUNC";
11744 if (filedata
->file_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
11747 if (filedata
->file_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
11748 return "PARISC_MILLI";
11750 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
11752 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
11754 if (filedata
->file_header
.e_machine
== EM_PARISC
)
11756 if (type
== STT_HP_OPAQUE
)
11757 return "HP_OPAQUE";
11758 if (type
== STT_HP_STUB
)
11762 if (type
== STT_GNU_IFUNC
11763 && (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
11764 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
))
11767 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
11770 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
11775 static const char *
11776 get_symbol_visibility (unsigned int visibility
)
11778 switch (visibility
)
11780 case STV_DEFAULT
: return "DEFAULT";
11781 case STV_INTERNAL
: return "INTERNAL";
11782 case STV_HIDDEN
: return "HIDDEN";
11783 case STV_PROTECTED
: return "PROTECTED";
11785 error (_("Unrecognized visibility value: %u\n"), visibility
);
11786 return _("<unknown>");
11790 static const char *
11791 get_alpha_symbol_other (unsigned int other
)
11795 case STO_ALPHA_NOPV
: return "NOPV";
11796 case STO_ALPHA_STD_GPLOAD
: return "STD GPLOAD";
11798 error (_("Unrecognized alpha specific other value: %u\n"), other
);
11799 return _("<unknown>");
11803 static const char *
11804 get_solaris_symbol_visibility (unsigned int visibility
)
11806 switch (visibility
)
11808 case 4: return "EXPORTED";
11809 case 5: return "SINGLETON";
11810 case 6: return "ELIMINATE";
11811 default: return get_symbol_visibility (visibility
);
11815 static const char *
11816 get_aarch64_symbol_other (unsigned int other
)
11818 static char buf
[32];
11820 if (other
& STO_AARCH64_VARIANT_PCS
)
11822 other
&= ~STO_AARCH64_VARIANT_PCS
;
11824 return "VARIANT_PCS";
11825 snprintf (buf
, sizeof buf
, "VARIANT_PCS | %x", other
);
11831 static const char *
11832 get_mips_symbol_other (unsigned int other
)
11836 case STO_OPTIONAL
: return "OPTIONAL";
11837 case STO_MIPS_PLT
: return "MIPS PLT";
11838 case STO_MIPS_PIC
: return "MIPS PIC";
11839 case STO_MICROMIPS
: return "MICROMIPS";
11840 case STO_MICROMIPS
| STO_MIPS_PIC
: return "MICROMIPS, MIPS PIC";
11841 case STO_MIPS16
: return "MIPS16";
11842 default: return NULL
;
11846 static const char *
11847 get_ia64_symbol_other (Filedata
* filedata
, unsigned int other
)
11849 if (is_ia64_vms (filedata
))
11851 static char res
[32];
11855 /* Function types is for images and .STB files only. */
11856 switch (filedata
->file_header
.e_type
)
11860 switch (VMS_ST_FUNC_TYPE (other
))
11862 case VMS_SFT_CODE_ADDR
:
11863 strcat (res
, " CA");
11865 case VMS_SFT_SYMV_IDX
:
11866 strcat (res
, " VEC");
11869 strcat (res
, " FD");
11871 case VMS_SFT_RESERVE
:
11872 strcat (res
, " RSV");
11875 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
11876 VMS_ST_FUNC_TYPE (other
));
11877 strcat (res
, " <unknown>");
11884 switch (VMS_ST_LINKAGE (other
))
11886 case VMS_STL_IGNORE
:
11887 strcat (res
, " IGN");
11889 case VMS_STL_RESERVE
:
11890 strcat (res
, " RSV");
11893 strcat (res
, " STD");
11896 strcat (res
, " LNK");
11899 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
11900 VMS_ST_LINKAGE (other
));
11901 strcat (res
, " <unknown>");
11913 static const char *
11914 get_ppc64_symbol_other (unsigned int other
)
11916 if ((other
& ~STO_PPC64_LOCAL_MASK
) != 0)
11919 other
>>= STO_PPC64_LOCAL_BIT
;
11922 static char buf
[64];
11924 other
= ppc64_decode_local_entry (other
);
11925 snprintf (buf
, sizeof buf
, _("<localentry>: %d"), other
);
11931 static const char *
11932 get_symbol_other (Filedata
* filedata
, unsigned int other
)
11934 const char * result
= NULL
;
11935 static char buff
[64];
11940 switch (filedata
->file_header
.e_machine
)
11943 result
= get_alpha_symbol_other (other
);
11946 result
= get_aarch64_symbol_other (other
);
11949 result
= get_mips_symbol_other (other
);
11952 result
= get_ia64_symbol_other (filedata
, other
);
11955 result
= get_ppc64_symbol_other (other
);
11965 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
11969 static const char *
11970 get_symbol_index_type (Filedata
* filedata
, unsigned int type
)
11972 static char buff
[32];
11976 case SHN_UNDEF
: return "UND";
11977 case SHN_ABS
: return "ABS";
11978 case SHN_COMMON
: return "COM";
11980 if (type
== SHN_IA_64_ANSI_COMMON
11981 && filedata
->file_header
.e_machine
== EM_IA_64
11982 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
11984 else if ((filedata
->file_header
.e_machine
== EM_X86_64
11985 || filedata
->file_header
.e_machine
== EM_L1OM
11986 || filedata
->file_header
.e_machine
== EM_K1OM
)
11987 && type
== SHN_X86_64_LCOMMON
)
11988 return "LARGE_COM";
11989 else if ((type
== SHN_MIPS_SCOMMON
11990 && filedata
->file_header
.e_machine
== EM_MIPS
)
11991 || (type
== SHN_TIC6X_SCOMMON
11992 && filedata
->file_header
.e_machine
== EM_TI_C6000
))
11994 else if (type
== SHN_MIPS_SUNDEFINED
11995 && filedata
->file_header
.e_machine
== EM_MIPS
)
11997 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
11998 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
11999 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
12000 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
12001 else if (type
>= SHN_LORESERVE
)
12002 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
12003 else if (filedata
->file_header
.e_shnum
!= 0
12004 && type
>= filedata
->file_header
.e_shnum
)
12005 sprintf (buff
, _("bad section index[%3d]"), type
);
12007 sprintf (buff
, "%3d", type
);
12014 static const char *
12015 get_symbol_version_string (Filedata
* filedata
,
12016 bfd_boolean is_dynsym
,
12017 const char * strtab
,
12018 unsigned long int strtab_size
,
12020 Elf_Internal_Sym
* psym
,
12021 enum versioned_symbol_info
* sym_info
,
12022 unsigned short * vna_other
)
12024 unsigned char data
[2];
12025 unsigned short vers_data
;
12026 unsigned long offset
;
12027 unsigned short max_vd_ndx
;
12030 || filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
12033 offset
= offset_from_vma (filedata
,
12034 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
12035 sizeof data
+ si
* sizeof (vers_data
));
12037 if (get_data (&data
, filedata
, offset
+ si
* sizeof (vers_data
),
12038 sizeof (data
), 1, _("version data")) == NULL
)
12041 vers_data
= byte_get (data
, 2);
12043 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
== 0)
12046 *sym_info
= (vers_data
& VERSYM_HIDDEN
) != 0 ? symbol_hidden
: symbol_public
;
12049 /* Usually we'd only see verdef for defined symbols, and verneed for
12050 undefined symbols. However, symbols defined by the linker in
12051 .dynbss for variables copied from a shared library in order to
12052 avoid text relocations are defined yet have verneed. We could
12053 use a heuristic to detect the special case, for example, check
12054 for verneed first on symbols defined in SHT_NOBITS sections, but
12055 it is simpler and more reliable to just look for both verdef and
12056 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
12058 if (psym
->st_shndx
!= SHN_UNDEF
12059 && vers_data
!= 0x8001
12060 && filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
12062 Elf_Internal_Verdef ivd
;
12063 Elf_Internal_Verdaux ivda
;
12064 Elf_External_Verdaux evda
;
12067 off
= offset_from_vma (filedata
,
12068 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
12069 sizeof (Elf_External_Verdef
));
12073 Elf_External_Verdef evd
;
12075 if (get_data (&evd
, filedata
, off
, sizeof (evd
), 1,
12076 _("version def")) == NULL
)
12085 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
12086 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
12087 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
12088 ivd
.vd_flags
= BYTE_GET (evd
.vd_flags
);
12091 if ((ivd
.vd_ndx
& VERSYM_VERSION
) > max_vd_ndx
)
12092 max_vd_ndx
= ivd
.vd_ndx
& VERSYM_VERSION
;
12094 off
+= ivd
.vd_next
;
12096 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
12098 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
12100 if (ivd
.vd_ndx
== 1 && ivd
.vd_flags
== VER_FLG_BASE
)
12103 off
-= ivd
.vd_next
;
12106 if (get_data (&evda
, filedata
, off
, sizeof (evda
), 1,
12107 _("version def aux")) != NULL
)
12109 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
12111 if (psym
->st_name
!= ivda
.vda_name
)
12112 return (ivda
.vda_name
< strtab_size
12113 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
12118 if (filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
12120 Elf_External_Verneed evn
;
12121 Elf_Internal_Verneed ivn
;
12122 Elf_Internal_Vernaux ivna
;
12124 offset
= offset_from_vma (filedata
,
12125 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
12129 unsigned long vna_off
;
12131 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
12132 _("version need")) == NULL
)
12135 ivna
.vna_other
= 0;
12140 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
12141 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
12143 vna_off
= offset
+ ivn
.vn_aux
;
12147 Elf_External_Vernaux evna
;
12149 if (get_data (&evna
, filedata
, vna_off
, sizeof (evna
), 1,
12150 _("version need aux (3)")) == NULL
)
12153 ivna
.vna_other
= 0;
12158 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
12159 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
12160 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
12163 vna_off
+= ivna
.vna_next
;
12165 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
12167 if (ivna
.vna_other
== vers_data
)
12170 offset
+= ivn
.vn_next
;
12172 while (ivn
.vn_next
!= 0);
12174 if (ivna
.vna_other
== vers_data
)
12176 *sym_info
= symbol_undefined
;
12177 *vna_other
= ivna
.vna_other
;
12178 return (ivna
.vna_name
< strtab_size
12179 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
12181 else if ((max_vd_ndx
|| (vers_data
& VERSYM_VERSION
) != 1)
12182 && (vers_data
& VERSYM_VERSION
) > max_vd_ndx
)
12183 return _("<corrupt>");
12189 print_dynamic_symbol (Filedata
*filedata
, unsigned long si
,
12190 Elf_Internal_Sym
*symtab
,
12191 Elf_Internal_Shdr
*section
,
12192 char *strtab
, size_t strtab_size
)
12194 const char *version_string
;
12195 enum versioned_symbol_info sym_info
;
12196 unsigned short vna_other
;
12197 Elf_Internal_Sym
*psym
= symtab
+ si
;
12199 printf ("%6ld: ", si
);
12200 print_vma (psym
->st_value
, LONG_HEX
);
12202 print_vma (psym
->st_size
, DEC_5
);
12203 printf (" %-7s", get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)));
12204 printf (" %-6s", get_symbol_binding (filedata
, ELF_ST_BIND (psym
->st_info
)));
12205 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
12206 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
12209 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
12211 printf (" %-7s", get_symbol_visibility (vis
));
12212 /* Check to see if any other bits in the st_other field are set.
12213 Note - displaying this information disrupts the layout of the
12214 table being generated, but for the moment this case is very rare. */
12215 if (psym
->st_other
^ vis
)
12216 printf (" [%s] ", get_symbol_other (filedata
, psym
->st_other
^ vis
));
12218 printf (" %4s ", get_symbol_index_type (filedata
, psym
->st_shndx
));
12220 bfd_boolean is_valid
= VALID_SYMBOL_NAME (strtab
, strtab_size
,
12222 const char * sstr
= is_valid
? strtab
+ psym
->st_name
: _("<corrupt>");
12225 = get_symbol_version_string (filedata
,
12227 || section
->sh_type
== SHT_DYNSYM
),
12228 strtab
, strtab_size
, si
,
12229 psym
, &sym_info
, &vna_other
);
12231 int len_avail
= 21;
12232 if (! do_wide
&& version_string
!= NULL
)
12236 len_avail
-= 1 + strlen (version_string
);
12238 if (sym_info
== symbol_undefined
)
12239 len_avail
-= sprintf (buffer
," (%d)", vna_other
);
12240 else if (sym_info
!= symbol_hidden
)
12244 print_symbol (len_avail
, sstr
);
12246 if (version_string
)
12248 if (sym_info
== symbol_undefined
)
12249 printf ("@%s (%d)", version_string
, vna_other
);
12251 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
12257 if (ELF_ST_BIND (psym
->st_info
) == STB_LOCAL
12259 && si
>= section
->sh_info
12260 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
12261 && filedata
->file_header
.e_machine
!= EM_MIPS
12262 /* Solaris binaries have been found to violate this requirement as
12263 well. Not sure if this is a bug or an ABI requirement. */
12264 && filedata
->file_header
.e_ident
[EI_OSABI
] != ELFOSABI_SOLARIS
)
12265 warn (_("local symbol %lu found at index >= %s's sh_info value of %u\n"),
12266 si
, printable_section_name (filedata
, section
), section
->sh_info
);
12269 static const char *
12270 get_lto_kind (unsigned int kind
)
12274 case 0: return "DEF";
12275 case 1: return "WEAKDEF";
12276 case 2: return "UNDEF";
12277 case 3: return "WEAKUNDEF";
12278 case 4: return "COMMON";
12283 static char buffer
[30];
12284 error (_("Unknown LTO symbol definition encountered: %u\n"), kind
);
12285 sprintf (buffer
, "<unknown: %u>", kind
);
12289 static const char *
12290 get_lto_visibility (unsigned int visibility
)
12292 switch (visibility
)
12294 case 0: return "DEFAULT";
12295 case 1: return "PROTECTED";
12296 case 2: return "INTERNAL";
12297 case 3: return "HIDDEN";
12302 static char buffer
[30];
12303 error (_("Unknown LTO symbol visibility encountered: %u\n"), visibility
);
12304 sprintf (buffer
, "<unknown: %u>", visibility
);
12308 static const char *
12309 get_lto_sym_type (unsigned int sym_type
)
12313 case 0: return "UNKNOWN";
12314 case 1: return "FUNCTION";
12315 case 2: return "VARIABLE";
12320 static char buffer
[30];
12321 error (_("Unknown LTO symbol type encountered: %u\n"), sym_type
);
12322 sprintf (buffer
, "<unknown: %u>", sym_type
);
12326 /* Display an LTO format symbol table.
12327 FIXME: The format of LTO symbol tables is not formalized.
12328 So this code could need changing in the future. */
12331 display_lto_symtab (Filedata
* filedata
,
12332 Elf_Internal_Shdr
* section
)
12334 if (section
->sh_size
== 0)
12336 printf (_("\nLTO Symbol table '%s' is empty!\n"),
12337 printable_section_name (filedata
, section
));
12341 if (section
->sh_size
> filedata
->file_size
)
12343 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
12344 printable_section_name (filedata
, section
),
12345 (unsigned long) section
->sh_size
);
12349 void * alloced_data
= get_data (NULL
, filedata
, section
->sh_offset
,
12350 section
->sh_size
, 1, _("LTO symbols"));
12351 if (alloced_data
== NULL
)
12354 /* Look for extended data for the symbol table. */
12355 Elf_Internal_Shdr
* ext
;
12356 void * ext_data_orig
= NULL
;
12357 char * ext_data
= NULL
;
12358 char * ext_data_end
= NULL
;
12359 char * ext_name
= NULL
;
12361 if (asprintf (& ext_name
, ".gnu.lto_.ext_symtab.%s",
12362 SECTION_NAME (section
) + sizeof (".gnu.lto_.symtab.") - 1) > 0
12363 && ext_name
!= NULL
/* Paranoia. */
12364 && (ext
= find_section (filedata
, ext_name
)) != NULL
)
12366 if (ext
->sh_size
< 3)
12367 error (_("LTO Symbol extension table '%s' is empty!\n"),
12368 printable_section_name (filedata
, ext
));
12371 ext_data_orig
= ext_data
= get_data (NULL
, filedata
, ext
->sh_offset
,
12373 _("LTO ext symbol data"));
12374 if (ext_data
!= NULL
)
12376 ext_data_end
= ext_data
+ ext
->sh_size
;
12377 if (* ext_data
++ != 1)
12378 error (_("Unexpected version number in symbol extension table\n"));
12383 const unsigned char * data
= (const unsigned char *) alloced_data
;
12384 const unsigned char * end
= data
+ section
->sh_size
;
12386 if (ext_data_orig
!= NULL
)
12389 printf (_("\nLTO Symbol table '%s' and extension table '%s' contain:\n"),
12390 printable_section_name (filedata
, section
),
12391 printable_section_name (filedata
, ext
));
12394 printf (_("\nLTO Symbol table '%s'\n"),
12395 printable_section_name (filedata
, section
));
12396 printf (_(" and extension table '%s' contain:\n"),
12397 printable_section_name (filedata
, ext
));
12401 printf (_("\nLTO Symbol table '%s' contains:\n"),
12402 printable_section_name (filedata
, section
));
12405 /* FIXME: Add a wide version. */
12406 if (ext_data_orig
!= NULL
)
12407 printf (_(" Comdat_Key Kind Visibility Size Slot Type Section Name\n"));
12409 printf (_(" Comdat_Key Kind Visibility Size Slot Name\n"));
12411 /* FIXME: We do not handle style prefixes. */
12415 const unsigned char * sym_name
= data
;
12416 data
+= strnlen ((const char *) sym_name
, end
- data
) + 1;
12420 const unsigned char * comdat_key
= data
;
12421 data
+= strnlen ((const char *) comdat_key
, end
- data
) + 1;
12425 if (data
+ 2 + 8 + 4 > end
)
12428 unsigned int kind
= *data
++;
12429 unsigned int visibility
= *data
++;
12431 elf_vma size
= byte_get (data
, 8);
12434 elf_vma slot
= byte_get (data
, 4);
12437 if (ext_data
!= NULL
)
12439 if (ext_data
< (ext_data_end
- 1))
12441 unsigned int sym_type
= * ext_data
++;
12442 unsigned int sec_kind
= * ext_data
++;
12444 printf (" %10s %10s %11s %08lx %08lx %9s %08lx _",
12445 * comdat_key
== 0 ? "-" : (char *) comdat_key
,
12446 get_lto_kind (kind
),
12447 get_lto_visibility (visibility
),
12450 get_lto_sym_type (sym_type
),
12452 print_symbol (6, (const char *) sym_name
);
12456 error (_("Ran out of LTO symbol extension data\n"));
12458 /* FIXME: return FAIL result ? */
12463 printf (" %10s %10s %11s %08lx %08lx _",
12464 * comdat_key
== 0 ? "-" : (char *) comdat_key
,
12465 get_lto_kind (kind
),
12466 get_lto_visibility (visibility
),
12469 print_symbol (21, (const char *) sym_name
);
12474 if (ext_data
!= NULL
&& ext_data
< ext_data_end
)
12476 error (_("Data remains in the LTO symbol extension table\n"));
12480 free (alloced_data
);
12481 free (ext_data_orig
);
12486 error (_("Buffer overrun encountered whilst decoding LTO symbol table\n"));
12487 free (alloced_data
);
12488 free (ext_data_orig
);
12493 /* Display LTO symbol tables. */
12496 process_lto_symbol_tables (Filedata
* filedata
)
12498 Elf_Internal_Shdr
* section
;
12500 bfd_boolean res
= TRUE
;
12505 if (filedata
->section_headers
== NULL
)
12508 for (i
= 0, section
= filedata
->section_headers
;
12509 i
< filedata
->file_header
.e_shnum
;
12511 if (SECTION_NAME_VALID (section
)
12512 && CONST_STRNEQ (SECTION_NAME (section
), ".gnu.lto_.symtab."))
12513 res
&= display_lto_symtab (filedata
, section
);
12518 /* Dump the symbol table. */
12521 process_symbol_table (Filedata
* filedata
)
12523 Elf_Internal_Shdr
* section
;
12525 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
12528 if ((filedata
->dynamic_info
[DT_HASH
] || filedata
->dynamic_info_DT_GNU_HASH
)
12530 && do_using_dynamic
12531 && filedata
->dynamic_strings
!= NULL
12532 && filedata
->dynamic_symbols
!= NULL
)
12536 printf (ngettext ("\nSymbol table for image contains %lu entry:\n",
12537 "\nSymbol table for image contains %lu entries:\n",
12538 filedata
->num_dynamic_syms
),
12539 filedata
->num_dynamic_syms
);
12541 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12543 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12545 for (si
= 0; si
< filedata
->num_dynamic_syms
; si
++)
12546 print_dynamic_symbol (filedata
, si
, filedata
->dynamic_symbols
, NULL
,
12547 filedata
->dynamic_strings
,
12548 filedata
->dynamic_strings_length
);
12550 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
12551 && filedata
->section_headers
!= NULL
)
12555 for (i
= 0, section
= filedata
->section_headers
;
12556 i
< filedata
->file_header
.e_shnum
;
12559 char * strtab
= NULL
;
12560 unsigned long int strtab_size
= 0;
12561 Elf_Internal_Sym
* symtab
;
12562 unsigned long si
, num_syms
;
12564 if ((section
->sh_type
!= SHT_SYMTAB
12565 && section
->sh_type
!= SHT_DYNSYM
)
12567 && section
->sh_type
== SHT_SYMTAB
))
12570 if (section
->sh_entsize
== 0)
12572 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
12573 printable_section_name (filedata
, section
));
12577 num_syms
= section
->sh_size
/ section
->sh_entsize
;
12578 printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
12579 "\nSymbol table '%s' contains %lu entries:\n",
12581 printable_section_name (filedata
, section
),
12585 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12587 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12589 symtab
= GET_ELF_SYMBOLS (filedata
, section
, & num_syms
);
12590 if (symtab
== NULL
)
12593 if (section
->sh_link
== filedata
->file_header
.e_shstrndx
)
12595 strtab
= filedata
->string_table
;
12596 strtab_size
= filedata
->string_table_length
;
12598 else if (section
->sh_link
< filedata
->file_header
.e_shnum
)
12600 Elf_Internal_Shdr
* string_sec
;
12602 string_sec
= filedata
->section_headers
+ section
->sh_link
;
12604 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
,
12605 1, string_sec
->sh_size
,
12606 _("string table"));
12607 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
12610 for (si
= 0; si
< num_syms
; si
++)
12611 print_dynamic_symbol (filedata
, si
, symtab
, section
,
12612 strtab
, strtab_size
);
12615 if (strtab
!= filedata
->string_table
)
12621 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
12623 if (do_histogram
&& filedata
->buckets
!= NULL
)
12625 unsigned long * lengths
;
12626 unsigned long * counts
;
12629 unsigned long maxlength
= 0;
12630 unsigned long nzero_counts
= 0;
12631 unsigned long nsyms
= 0;
12634 printf (ngettext ("\nHistogram for bucket list length "
12635 "(total of %lu bucket):\n",
12636 "\nHistogram for bucket list length "
12637 "(total of %lu buckets):\n",
12638 (unsigned long) filedata
->nbuckets
),
12639 (unsigned long) filedata
->nbuckets
);
12641 lengths
= (unsigned long *) calloc (filedata
->nbuckets
,
12642 sizeof (*lengths
));
12643 if (lengths
== NULL
)
12645 error (_("Out of memory allocating space for histogram buckets\n"));
12648 visited
= xcmalloc (filedata
->nchains
, 1);
12649 memset (visited
, 0, filedata
->nchains
);
12651 printf (_(" Length Number %% of total Coverage\n"));
12652 for (hn
= 0; hn
< filedata
->nbuckets
; ++hn
)
12654 for (si
= filedata
->buckets
[hn
]; si
> 0; si
= filedata
->chains
[si
])
12657 if (maxlength
< ++lengths
[hn
])
12659 if (si
>= filedata
->nchains
|| visited
[si
])
12661 error (_("histogram chain is corrupt\n"));
12669 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
12670 if (counts
== NULL
)
12673 error (_("Out of memory allocating space for histogram counts\n"));
12677 for (hn
= 0; hn
< filedata
->nbuckets
; ++hn
)
12678 ++counts
[lengths
[hn
]];
12680 if (filedata
->nbuckets
> 0)
12683 printf (" 0 %-10lu (%5.1f%%)\n",
12684 counts
[0], (counts
[0] * 100.0) / filedata
->nbuckets
);
12685 for (i
= 1; i
<= maxlength
; ++i
)
12687 nzero_counts
+= counts
[i
] * i
;
12688 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
12689 i
, counts
[i
], (counts
[i
] * 100.0) / filedata
->nbuckets
,
12690 (nzero_counts
* 100.0) / nsyms
);
12698 free (filedata
->buckets
);
12699 filedata
->buckets
= NULL
;
12700 filedata
->nbuckets
= 0;
12701 free (filedata
->chains
);
12702 filedata
->chains
= NULL
;
12704 if (do_histogram
&& filedata
->gnubuckets
!= NULL
)
12706 unsigned long * lengths
;
12707 unsigned long * counts
;
12709 unsigned long maxlength
= 0;
12710 unsigned long nzero_counts
= 0;
12711 unsigned long nsyms
= 0;
12713 printf (ngettext ("\nHistogram for `%s' bucket list length "
12714 "(total of %lu bucket):\n",
12715 "\nHistogram for `%s' bucket list length "
12716 "(total of %lu buckets):\n",
12717 (unsigned long) filedata
->ngnubuckets
),
12718 GNU_HASH_SECTION_NAME (filedata
),
12719 (unsigned long) filedata
->ngnubuckets
);
12721 lengths
= (unsigned long *) calloc (filedata
->ngnubuckets
,
12722 sizeof (*lengths
));
12723 if (lengths
== NULL
)
12725 error (_("Out of memory allocating space for gnu histogram buckets\n"));
12729 printf (_(" Length Number %% of total Coverage\n"));
12731 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
12732 if (filedata
->gnubuckets
[hn
] != 0)
12734 bfd_vma off
, length
= 1;
12736 for (off
= filedata
->gnubuckets
[hn
] - filedata
->gnusymidx
;
12737 /* PR 17531 file: 010-77222-0.004. */
12738 off
< filedata
->ngnuchains
12739 && (filedata
->gnuchains
[off
] & 1) == 0;
12742 lengths
[hn
] = length
;
12743 if (length
> maxlength
)
12744 maxlength
= length
;
12748 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
12749 if (counts
== NULL
)
12752 error (_("Out of memory allocating space for gnu histogram counts\n"));
12756 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
12757 ++counts
[lengths
[hn
]];
12759 if (filedata
->ngnubuckets
> 0)
12762 printf (" 0 %-10lu (%5.1f%%)\n",
12763 counts
[0], (counts
[0] * 100.0) / filedata
->ngnubuckets
);
12764 for (j
= 1; j
<= maxlength
; ++j
)
12766 nzero_counts
+= counts
[j
] * j
;
12767 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
12768 j
, counts
[j
], (counts
[j
] * 100.0) / filedata
->ngnubuckets
,
12769 (nzero_counts
* 100.0) / nsyms
);
12776 free (filedata
->gnubuckets
);
12777 filedata
->gnubuckets
= NULL
;
12778 filedata
->ngnubuckets
= 0;
12779 free (filedata
->gnuchains
);
12780 filedata
->gnuchains
= NULL
;
12781 filedata
->ngnuchains
= 0;
12782 free (filedata
->mipsxlat
);
12783 filedata
->mipsxlat
= NULL
;
12787 free (filedata
->gnubuckets
);
12788 filedata
->gnubuckets
= NULL
;
12789 filedata
->ngnubuckets
= 0;
12790 free (filedata
->gnuchains
);
12791 filedata
->gnuchains
= NULL
;
12792 filedata
->ngnuchains
= 0;
12793 free (filedata
->mipsxlat
);
12794 filedata
->mipsxlat
= NULL
;
12795 free (filedata
->buckets
);
12796 filedata
->buckets
= NULL
;
12797 filedata
->nbuckets
= 0;
12798 free (filedata
->chains
);
12799 filedata
->chains
= NULL
;
12804 process_syminfo (Filedata
* filedata ATTRIBUTE_UNUSED
)
12808 if (filedata
->dynamic_syminfo
== NULL
12810 /* No syminfo, this is ok. */
12813 /* There better should be a dynamic symbol section. */
12814 if (filedata
->dynamic_symbols
== NULL
|| filedata
->dynamic_strings
== NULL
)
12817 if (filedata
->dynamic_addr
)
12818 printf (ngettext ("\nDynamic info segment at offset 0x%lx "
12819 "contains %d entry:\n",
12820 "\nDynamic info segment at offset 0x%lx "
12821 "contains %d entries:\n",
12822 filedata
->dynamic_syminfo_nent
),
12823 filedata
->dynamic_syminfo_offset
, filedata
->dynamic_syminfo_nent
);
12825 printf (_(" Num: Name BoundTo Flags\n"));
12826 for (i
= 0; i
< filedata
->dynamic_syminfo_nent
; ++i
)
12828 unsigned short int flags
= filedata
->dynamic_syminfo
[i
].si_flags
;
12830 printf ("%4d: ", i
);
12831 if (i
>= filedata
->num_dynamic_syms
)
12832 printf (_("<corrupt index>"));
12833 else if (VALID_DYNAMIC_NAME (filedata
, filedata
->dynamic_symbols
[i
].st_name
))
12834 print_symbol (30, GET_DYNAMIC_NAME (filedata
,
12835 filedata
->dynamic_symbols
[i
].st_name
));
12837 printf (_("<corrupt: %19ld>"), filedata
->dynamic_symbols
[i
].st_name
);
12840 switch (filedata
->dynamic_syminfo
[i
].si_boundto
)
12842 case SYMINFO_BT_SELF
:
12843 fputs ("SELF ", stdout
);
12845 case SYMINFO_BT_PARENT
:
12846 fputs ("PARENT ", stdout
);
12849 if (filedata
->dynamic_syminfo
[i
].si_boundto
> 0
12850 && filedata
->dynamic_syminfo
[i
].si_boundto
< filedata
->dynamic_nent
12851 && VALID_DYNAMIC_NAME (filedata
,
12852 filedata
->dynamic_section
[filedata
->dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
12854 print_symbol (10, GET_DYNAMIC_NAME (filedata
,
12855 filedata
->dynamic_section
[filedata
->dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
12859 printf ("%-10d ", filedata
->dynamic_syminfo
[i
].si_boundto
);
12863 if (flags
& SYMINFO_FLG_DIRECT
)
12864 printf (" DIRECT");
12865 if (flags
& SYMINFO_FLG_PASSTHRU
)
12866 printf (" PASSTHRU");
12867 if (flags
& SYMINFO_FLG_COPY
)
12869 if (flags
& SYMINFO_FLG_LAZYLOAD
)
12870 printf (" LAZYLOAD");
12878 /* A macro which evaluates to TRUE if the region ADDR .. ADDR + NELEM
12879 is contained by the region START .. END. The types of ADDR, START
12880 and END should all be the same. Note both ADDR + NELEM and END
12881 point to just beyond the end of the regions that are being tested. */
12882 #define IN_RANGE(START,END,ADDR,NELEM) \
12883 (((ADDR) >= (START)) && ((ADDR) < (END)) && ((ADDR) + (NELEM) <= (END)))
12885 /* Check to see if the given reloc needs to be handled in a target specific
12886 manner. If so then process the reloc and return TRUE otherwise return
12889 If called with reloc == NULL, then this is a signal that reloc processing
12890 for the current section has finished, and any saved state should be
12894 target_specific_reloc_handling (Filedata
* filedata
,
12895 Elf_Internal_Rela
* reloc
,
12896 unsigned char * start
,
12897 unsigned char * end
,
12898 Elf_Internal_Sym
* symtab
,
12899 unsigned long num_syms
)
12901 unsigned int reloc_type
= 0;
12902 unsigned long sym_index
= 0;
12906 reloc_type
= get_reloc_type (filedata
, reloc
->r_info
);
12907 sym_index
= get_reloc_symindex (reloc
->r_info
);
12910 switch (filedata
->file_header
.e_machine
)
12913 case EM_MSP430_OLD
:
12915 static Elf_Internal_Sym
* saved_sym
= NULL
;
12923 switch (reloc_type
)
12925 case 10: /* R_MSP430_SYM_DIFF */
12926 case 12: /* R_MSP430_GNU_SUB_ULEB128 */
12927 if (uses_msp430x_relocs (filedata
))
12929 /* Fall through. */
12930 case 21: /* R_MSP430X_SYM_DIFF */
12931 case 23: /* R_MSP430X_GNU_SUB_ULEB128 */
12933 if (sym_index
>= num_syms
)
12934 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
12937 saved_sym
= symtab
+ sym_index
;
12940 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
12941 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
12942 goto handle_sym_diff
;
12944 case 5: /* R_MSP430_16_BYTE */
12945 case 9: /* R_MSP430_8 */
12946 case 11: /* R_MSP430_GNU_SET_ULEB128 */
12947 if (uses_msp430x_relocs (filedata
))
12949 goto handle_sym_diff
;
12951 case 2: /* R_MSP430_ABS16 */
12952 case 15: /* R_MSP430X_ABS16 */
12953 case 22: /* R_MSP430X_GNU_SET_ULEB128 */
12954 if (! uses_msp430x_relocs (filedata
))
12956 goto handle_sym_diff
;
12959 if (saved_sym
!= NULL
)
12962 unsigned int reloc_size
= 0;
12964 switch (reloc_type
)
12966 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
12969 case 11: /* R_MSP430_GNU_SET_ULEB128 */
12970 case 22: /* R_MSP430X_GNU_SET_ULEB128 */
12971 if (reloc
->r_offset
< (size_t) (end
- start
))
12972 read_leb128 (start
+ reloc
->r_offset
, end
, FALSE
,
12973 &reloc_size
, &leb_ret
);
12980 if (leb_ret
!= 0 || reloc_size
== 0 || reloc_size
> 8)
12981 error (_("MSP430 ULEB128 field at 0x%lx contains invalid "
12982 "ULEB128 value\n"),
12983 (long) reloc
->r_offset
);
12984 else if (sym_index
>= num_syms
)
12985 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
12989 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12990 - saved_sym
->st_value
);
12992 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12993 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12996 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
12997 (long) reloc
->r_offset
);
13006 if (saved_sym
!= NULL
)
13007 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
13014 case EM_CYGNUS_MN10300
:
13016 static Elf_Internal_Sym
* saved_sym
= NULL
;
13024 switch (reloc_type
)
13026 case 34: /* R_MN10300_ALIGN */
13028 case 33: /* R_MN10300_SYM_DIFF */
13029 if (sym_index
>= num_syms
)
13030 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
13033 saved_sym
= symtab
+ sym_index
;
13036 case 1: /* R_MN10300_32 */
13037 case 2: /* R_MN10300_16 */
13038 if (saved_sym
!= NULL
)
13040 int reloc_size
= reloc_type
== 1 ? 4 : 2;
13043 if (sym_index
>= num_syms
)
13044 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
13048 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
13049 - saved_sym
->st_value
);
13051 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
13052 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
13054 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
13055 (long) reloc
->r_offset
);
13063 if (saved_sym
!= NULL
)
13064 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
13072 static bfd_vma saved_sym1
= 0;
13073 static bfd_vma saved_sym2
= 0;
13074 static bfd_vma value
;
13078 saved_sym1
= saved_sym2
= 0;
13082 switch (reloc_type
)
13084 case 0x80: /* R_RL78_SYM. */
13085 saved_sym1
= saved_sym2
;
13086 if (sym_index
>= num_syms
)
13087 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
13091 saved_sym2
= symtab
[sym_index
].st_value
;
13092 saved_sym2
+= reloc
->r_addend
;
13096 case 0x83: /* R_RL78_OPsub. */
13097 value
= saved_sym1
- saved_sym2
;
13098 saved_sym2
= saved_sym1
= 0;
13102 case 0x41: /* R_RL78_ABS32. */
13103 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 4))
13104 byte_put (start
+ reloc
->r_offset
, value
, 4);
13106 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
13107 (long) reloc
->r_offset
);
13111 case 0x43: /* R_RL78_ABS16. */
13112 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 2))
13113 byte_put (start
+ reloc
->r_offset
, value
, 2);
13115 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
13116 (long) reloc
->r_offset
);
13130 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
13131 DWARF debug sections. This is a target specific test. Note - we do not
13132 go through the whole including-target-headers-multiple-times route, (as
13133 we have already done with <elf/h8.h>) because this would become very
13134 messy and even then this function would have to contain target specific
13135 information (the names of the relocs instead of their numeric values).
13136 FIXME: This is not the correct way to solve this problem. The proper way
13137 is to have target specific reloc sizing and typing functions created by
13138 the reloc-macros.h header, in the same way that it already creates the
13139 reloc naming functions. */
13142 is_32bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13144 /* Please keep this table alpha-sorted for ease of visual lookup. */
13145 switch (filedata
->file_header
.e_machine
)
13149 return reloc_type
== 1; /* R_386_32. */
13151 return reloc_type
== 1; /* R_68K_32. */
13153 return reloc_type
== 1; /* R_860_32. */
13155 return reloc_type
== 2; /* R_960_32. */
13157 return (reloc_type
== 258
13158 || reloc_type
== 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
13160 return reloc_type
== 11; /* R_BPF_DATA_32 */
13161 case EM_ADAPTEVA_EPIPHANY
:
13162 return reloc_type
== 3;
13164 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
13166 return reloc_type
== 1; /* R_ARC_32. */
13167 case EM_ARC_COMPACT
:
13168 case EM_ARC_COMPACT2
:
13169 return reloc_type
== 4; /* R_ARC_32. */
13171 return reloc_type
== 2; /* R_ARM_ABS32 */
13174 return reloc_type
== 1;
13176 return reloc_type
== 0x12; /* R_byte4_data. */
13178 return reloc_type
== 3; /* R_CRIS_32. */
13180 return reloc_type
== 3; /* R_CR16_NUM32. */
13182 return reloc_type
== 15; /* R_CRX_NUM32. */
13184 return reloc_type
== 1; /* R_CKCORE_ADDR32. */
13185 case EM_CYGNUS_FRV
:
13186 return reloc_type
== 1;
13187 case EM_CYGNUS_D10V
:
13189 return reloc_type
== 6; /* R_D10V_32. */
13190 case EM_CYGNUS_D30V
:
13192 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
13194 return reloc_type
== 3; /* R_DLX_RELOC_32. */
13195 case EM_CYGNUS_FR30
:
13197 return reloc_type
== 3; /* R_FR30_32. */
13199 return reloc_type
== 1; /* R_FT32_32. */
13203 return reloc_type
== 1; /* R_H8_DIR32. */
13205 return (reloc_type
== 0x64 /* R_IA64_SECREL32MSB. */
13206 || reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
13207 || reloc_type
== 0x24 /* R_IA64_DIR32MSB. */
13208 || reloc_type
== 0x25 /* R_IA64_DIR32LSB. */);
13211 return reloc_type
== 2; /* R_IP2K_32. */
13213 return reloc_type
== 2; /* R_IQ2000_32. */
13214 case EM_LATTICEMICO32
:
13215 return reloc_type
== 3; /* R_LM32_32. */
13218 return reloc_type
== 3; /* R_M32C_32. */
13220 return reloc_type
== 34; /* R_M32R_32_RELA. */
13223 return reloc_type
== 6; /* R_M68HC11_32. */
13225 return reloc_type
== 7 || /* R_S12Z_EXT32 */
13226 reloc_type
== 6; /* R_S12Z_CW32. */
13228 return reloc_type
== 1; /* R_MCORE_ADDR32. */
13229 case EM_CYGNUS_MEP
:
13230 return reloc_type
== 4; /* R_MEP_32. */
13232 return reloc_type
== 2; /* R_METAG_ADDR32. */
13233 case EM_MICROBLAZE
:
13234 return reloc_type
== 1; /* R_MICROBLAZE_32. */
13236 return reloc_type
== 2; /* R_MIPS_32. */
13238 return reloc_type
== 4; /* R_MMIX_32. */
13239 case EM_CYGNUS_MN10200
:
13241 return reloc_type
== 1; /* R_MN10200_32. */
13242 case EM_CYGNUS_MN10300
:
13244 return reloc_type
== 1; /* R_MN10300_32. */
13246 return reloc_type
== 1; /* R_MOXIE_32. */
13247 case EM_MSP430_OLD
:
13249 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
13251 return reloc_type
== 2; /* R_MT_32. */
13253 return reloc_type
== 20; /* R_NDS32_RELA. */
13254 case EM_ALTERA_NIOS2
:
13255 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
13257 return reloc_type
== 1; /* R_NIOS_32. */
13259 return reloc_type
== 1; /* R_OR1K_32. */
13261 return (reloc_type
== 1 /* R_PARISC_DIR32. */
13262 || reloc_type
== 2 /* R_PARISC_DIR21L. */
13263 || reloc_type
== 41); /* R_PARISC_SECREL32. */
13266 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
13268 return reloc_type
== 1; /* R_PPC64_ADDR32. */
13270 return reloc_type
== 1; /* R_PPC_ADDR32. */
13272 return reloc_type
== 11; /* R_PRU_BFD_RELOC_32. */
13274 return reloc_type
== 1; /* R_RISCV_32. */
13276 return reloc_type
== 1; /* R_RL78_DIR32. */
13278 return reloc_type
== 1; /* R_RX_DIR32. */
13280 return reloc_type
== 1; /* R_I370_ADDR31. */
13283 return reloc_type
== 4; /* R_S390_32. */
13285 return reloc_type
== 8; /* R_SCORE_ABS32. */
13287 return reloc_type
== 1; /* R_SH_DIR32. */
13288 case EM_SPARC32PLUS
:
13291 return reloc_type
== 3 /* R_SPARC_32. */
13292 || reloc_type
== 23; /* R_SPARC_UA32. */
13294 return reloc_type
== 6; /* R_SPU_ADDR32 */
13296 return reloc_type
== 1; /* R_C6000_ABS32. */
13298 return reloc_type
== 2; /* R_TILEGX_32. */
13300 return reloc_type
== 1; /* R_TILEPRO_32. */
13301 case EM_CYGNUS_V850
:
13303 return reloc_type
== 6; /* R_V850_ABS32. */
13305 return reloc_type
== 0x33; /* R_V810_WORD. */
13307 return reloc_type
== 1; /* R_VAX_32. */
13309 return reloc_type
== 3; /* R_VISIUM_32. */
13310 case EM_WEBASSEMBLY
:
13311 return reloc_type
== 1; /* R_WASM32_32. */
13315 return reloc_type
== 10; /* R_X86_64_32. */
13318 return reloc_type
== 3; /* R_XC16C_ABS_32. */
13320 return reloc_type
== 4; /* R_XGATE_32. */
13322 return reloc_type
== 1; /* R_XSTROMY16_32. */
13323 case EM_XTENSA_OLD
:
13325 return reloc_type
== 1; /* R_XTENSA_32. */
13327 return reloc_type
== 6; /* R_Z80_32. */
13330 static unsigned int prev_warn
= 0;
13332 /* Avoid repeating the same warning multiple times. */
13333 if (prev_warn
!= filedata
->file_header
.e_machine
)
13334 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
13335 filedata
->file_header
.e_machine
);
13336 prev_warn
= filedata
->file_header
.e_machine
;
13342 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13343 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
13346 is_32bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13348 switch (filedata
->file_header
.e_machine
)
13349 /* Please keep this table alpha-sorted for ease of visual lookup. */
13353 return reloc_type
== 2; /* R_386_PC32. */
13355 return reloc_type
== 4; /* R_68K_PC32. */
13357 return reloc_type
== 261; /* R_AARCH64_PREL32 */
13358 case EM_ADAPTEVA_EPIPHANY
:
13359 return reloc_type
== 6;
13361 return reloc_type
== 10; /* R_ALPHA_SREL32. */
13362 case EM_ARC_COMPACT
:
13363 case EM_ARC_COMPACT2
:
13364 return reloc_type
== 49; /* R_ARC_32_PCREL. */
13366 return reloc_type
== 3; /* R_ARM_REL32 */
13369 return reloc_type
== 36; /* R_AVR_32_PCREL. */
13370 case EM_MICROBLAZE
:
13371 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
13373 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
13375 return reloc_type
== 9; /* R_PARISC_PCREL32. */
13377 return reloc_type
== 26; /* R_PPC_REL32. */
13379 return reloc_type
== 26; /* R_PPC64_REL32. */
13381 return reloc_type
== 57; /* R_RISCV_32_PCREL. */
13384 return reloc_type
== 5; /* R_390_PC32. */
13386 return reloc_type
== 2; /* R_SH_REL32. */
13387 case EM_SPARC32PLUS
:
13390 return reloc_type
== 6; /* R_SPARC_DISP32. */
13392 return reloc_type
== 13; /* R_SPU_REL32. */
13394 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
13396 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
13398 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
13402 return reloc_type
== 2; /* R_X86_64_PC32. */
13404 return reloc_type
== 4; /* R_VAX_PCREL32. */
13405 case EM_XTENSA_OLD
:
13407 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
13409 /* Do not abort or issue an error message here. Not all targets use
13410 pc-relative 32-bit relocs in their DWARF debug information and we
13411 have already tested for target coverage in is_32bit_abs_reloc. A
13412 more helpful warning message will be generated by apply_relocations
13413 anyway, so just return. */
13418 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13419 a 64-bit absolute RELA relocation used in DWARF debug sections. */
13422 is_64bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13424 switch (filedata
->file_header
.e_machine
)
13427 return reloc_type
== 257; /* R_AARCH64_ABS64. */
13429 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
13431 return (reloc_type
== 0x26 /* R_IA64_DIR64MSB. */
13432 || reloc_type
== 0x27 /* R_IA64_DIR64LSB. */);
13434 return reloc_type
== 80; /* R_PARISC_DIR64. */
13436 return reloc_type
== 38; /* R_PPC64_ADDR64. */
13438 return reloc_type
== 2; /* R_RISCV_64. */
13439 case EM_SPARC32PLUS
:
13442 return reloc_type
== 32 /* R_SPARC_64. */
13443 || reloc_type
== 54; /* R_SPARC_UA64. */
13447 return reloc_type
== 1; /* R_X86_64_64. */
13450 return reloc_type
== 22; /* R_S390_64. */
13452 return reloc_type
== 1; /* R_TILEGX_64. */
13454 return reloc_type
== 18; /* R_MIPS_64. */
13460 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
13461 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
13464 is_64bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13466 switch (filedata
->file_header
.e_machine
)
13469 return reloc_type
== 260; /* R_AARCH64_PREL64. */
13471 return reloc_type
== 11; /* R_ALPHA_SREL64. */
13473 return (reloc_type
== 0x4e /* R_IA64_PCREL64MSB. */
13474 || reloc_type
== 0x4f /* R_IA64_PCREL64LSB. */);
13476 return reloc_type
== 72; /* R_PARISC_PCREL64. */
13478 return reloc_type
== 44; /* R_PPC64_REL64. */
13479 case EM_SPARC32PLUS
:
13482 return reloc_type
== 46; /* R_SPARC_DISP64. */
13486 return reloc_type
== 24; /* R_X86_64_PC64. */
13489 return reloc_type
== 23; /* R_S390_PC64. */
13491 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
13497 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13498 a 24-bit absolute RELA relocation used in DWARF debug sections. */
13501 is_24bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13503 switch (filedata
->file_header
.e_machine
)
13505 case EM_CYGNUS_MN10200
:
13507 return reloc_type
== 4; /* R_MN10200_24. */
13509 return reloc_type
== 5; /* R_FT32_20. */
13511 return reloc_type
== 5; /* R_Z80_24. */
13517 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13518 a 16-bit absolute RELA relocation used in DWARF debug sections. */
13521 is_16bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13523 /* Please keep this table alpha-sorted for ease of visual lookup. */
13524 switch (filedata
->file_header
.e_machine
)
13527 case EM_ARC_COMPACT
:
13528 case EM_ARC_COMPACT2
:
13529 return reloc_type
== 2; /* R_ARC_16. */
13530 case EM_ADAPTEVA_EPIPHANY
:
13531 return reloc_type
== 5;
13534 return reloc_type
== 4; /* R_AVR_16. */
13535 case EM_CYGNUS_D10V
:
13537 return reloc_type
== 3; /* R_D10V_16. */
13539 return reloc_type
== 2; /* R_FT32_16. */
13543 return reloc_type
== R_H8_DIR16
;
13546 return reloc_type
== 1; /* R_IP2K_16. */
13549 return reloc_type
== 1; /* R_M32C_16 */
13550 case EM_CYGNUS_MN10200
:
13552 return reloc_type
== 2; /* R_MN10200_16. */
13553 case EM_CYGNUS_MN10300
:
13555 return reloc_type
== 2; /* R_MN10300_16. */
13557 if (uses_msp430x_relocs (filedata
))
13558 return reloc_type
== 2; /* R_MSP430_ABS16. */
13559 /* Fall through. */
13560 case EM_MSP430_OLD
:
13561 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
13563 return reloc_type
== 19; /* R_NDS32_RELA. */
13564 case EM_ALTERA_NIOS2
:
13565 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
13567 return reloc_type
== 9; /* R_NIOS_16. */
13569 return reloc_type
== 2; /* R_OR1K_16. */
13571 return reloc_type
== 55; /* R_RISCV_SET16. */
13573 return reloc_type
== 8; /* R_PRU_BFD_RELOC_16. */
13575 return reloc_type
== 2; /* R_C6000_ABS16. */
13577 return reloc_type
== 2; /* R_VISIUM_16. */
13580 return reloc_type
== 2; /* R_XC16C_ABS_16. */
13582 return reloc_type
== 3; /* R_XGATE_16. */
13584 return reloc_type
== 4; /* R_Z80_16. */
13590 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13591 a 8-bit absolute RELA relocation used in DWARF debug sections. */
13594 is_8bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13596 switch (filedata
->file_header
.e_machine
)
13599 return reloc_type
== 54; /* R_RISCV_SET8. */
13601 return reloc_type
== 1; /* R_Z80_8. */
13607 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13608 a 6-bit absolute RELA relocation used in DWARF debug sections. */
13611 is_6bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13613 switch (filedata
->file_header
.e_machine
)
13616 return reloc_type
== 53; /* R_RISCV_SET6. */
13622 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13623 a 32-bit inplace add RELA relocation used in DWARF debug sections. */
13626 is_32bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13628 /* Please keep this table alpha-sorted for ease of visual lookup. */
13629 switch (filedata
->file_header
.e_machine
)
13632 return reloc_type
== 35; /* R_RISCV_ADD32. */
13638 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13639 a 32-bit inplace sub RELA relocation used in DWARF debug sections. */
13642 is_32bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13644 /* Please keep this table alpha-sorted for ease of visual lookup. */
13645 switch (filedata
->file_header
.e_machine
)
13648 return reloc_type
== 39; /* R_RISCV_SUB32. */
13654 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13655 a 64-bit inplace add RELA relocation used in DWARF debug sections. */
13658 is_64bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13660 /* Please keep this table alpha-sorted for ease of visual lookup. */
13661 switch (filedata
->file_header
.e_machine
)
13664 return reloc_type
== 36; /* R_RISCV_ADD64. */
13670 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13671 a 64-bit inplace sub RELA relocation used in DWARF debug sections. */
13674 is_64bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13676 /* Please keep this table alpha-sorted for ease of visual lookup. */
13677 switch (filedata
->file_header
.e_machine
)
13680 return reloc_type
== 40; /* R_RISCV_SUB64. */
13686 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13687 a 16-bit inplace add RELA relocation used in DWARF debug sections. */
13690 is_16bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13692 /* Please keep this table alpha-sorted for ease of visual lookup. */
13693 switch (filedata
->file_header
.e_machine
)
13696 return reloc_type
== 34; /* R_RISCV_ADD16. */
13702 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13703 a 16-bit inplace sub RELA relocation used in DWARF debug sections. */
13706 is_16bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13708 /* Please keep this table alpha-sorted for ease of visual lookup. */
13709 switch (filedata
->file_header
.e_machine
)
13712 return reloc_type
== 38; /* R_RISCV_SUB16. */
13718 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13719 a 8-bit inplace add RELA relocation used in DWARF debug sections. */
13722 is_8bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13724 /* Please keep this table alpha-sorted for ease of visual lookup. */
13725 switch (filedata
->file_header
.e_machine
)
13728 return reloc_type
== 33; /* R_RISCV_ADD8. */
13734 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13735 a 8-bit inplace sub RELA relocation used in DWARF debug sections. */
13738 is_8bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13740 /* Please keep this table alpha-sorted for ease of visual lookup. */
13741 switch (filedata
->file_header
.e_machine
)
13744 return reloc_type
== 37; /* R_RISCV_SUB8. */
13750 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13751 a 6-bit inplace sub RELA relocation used in DWARF debug sections. */
13754 is_6bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13756 switch (filedata
->file_header
.e_machine
)
13759 return reloc_type
== 52; /* R_RISCV_SUB6. */
13765 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
13766 relocation entries (possibly formerly used for SHT_GROUP sections). */
13769 is_none_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13771 switch (filedata
->file_header
.e_machine
)
13773 case EM_386
: /* R_386_NONE. */
13774 case EM_68K
: /* R_68K_NONE. */
13775 case EM_ADAPTEVA_EPIPHANY
:
13776 case EM_ALPHA
: /* R_ALPHA_NONE. */
13777 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
13778 case EM_ARC
: /* R_ARC_NONE. */
13779 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
13780 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
13781 case EM_ARM
: /* R_ARM_NONE. */
13782 case EM_C166
: /* R_XC16X_NONE. */
13783 case EM_CRIS
: /* R_CRIS_NONE. */
13784 case EM_FT32
: /* R_FT32_NONE. */
13785 case EM_IA_64
: /* R_IA64_NONE. */
13786 case EM_K1OM
: /* R_X86_64_NONE. */
13787 case EM_L1OM
: /* R_X86_64_NONE. */
13788 case EM_M32R
: /* R_M32R_NONE. */
13789 case EM_MIPS
: /* R_MIPS_NONE. */
13790 case EM_MN10300
: /* R_MN10300_NONE. */
13791 case EM_MOXIE
: /* R_MOXIE_NONE. */
13792 case EM_NIOS32
: /* R_NIOS_NONE. */
13793 case EM_OR1K
: /* R_OR1K_NONE. */
13794 case EM_PARISC
: /* R_PARISC_NONE. */
13795 case EM_PPC64
: /* R_PPC64_NONE. */
13796 case EM_PPC
: /* R_PPC_NONE. */
13797 case EM_RISCV
: /* R_RISCV_NONE. */
13798 case EM_S390
: /* R_390_NONE. */
13800 case EM_SH
: /* R_SH_NONE. */
13801 case EM_SPARC32PLUS
:
13802 case EM_SPARC
: /* R_SPARC_NONE. */
13804 case EM_TILEGX
: /* R_TILEGX_NONE. */
13805 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
13806 case EM_TI_C6000
:/* R_C6000_NONE. */
13807 case EM_X86_64
: /* R_X86_64_NONE. */
13809 case EM_Z80
: /* R_Z80_NONE. */
13810 case EM_WEBASSEMBLY
: /* R_WASM32_NONE. */
13811 return reloc_type
== 0;
13814 return reloc_type
== 0 || reloc_type
== 256;
13817 return (reloc_type
== 0 /* R_AVR_NONE. */
13818 || reloc_type
== 30 /* R_AVR_DIFF8. */
13819 || reloc_type
== 31 /* R_AVR_DIFF16. */
13820 || reloc_type
== 32 /* R_AVR_DIFF32. */);
13822 return reloc_type
== 3; /* R_METAG_NONE. */
13824 return (reloc_type
== 0 /* R_XTENSA_NONE. */
13825 || reloc_type
== 204 /* R_NDS32_DIFF8. */
13826 || reloc_type
== 205 /* R_NDS32_DIFF16. */
13827 || reloc_type
== 206 /* R_NDS32_DIFF32. */
13828 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
13830 return (reloc_type
== 0 /* R_PRU_NONE. */
13831 || reloc_type
== 65 /* R_PRU_DIFF8. */
13832 || reloc_type
== 66 /* R_PRU_DIFF16. */
13833 || reloc_type
== 67 /* R_PRU_DIFF32. */);
13834 case EM_XTENSA_OLD
:
13836 return (reloc_type
== 0 /* R_XTENSA_NONE. */
13837 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
13838 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
13839 || reloc_type
== 19 /* R_XTENSA_DIFF32. */
13840 || reloc_type
== 57 /* R_XTENSA_PDIFF8. */
13841 || reloc_type
== 58 /* R_XTENSA_PDIFF16. */
13842 || reloc_type
== 59 /* R_XTENSA_PDIFF32. */
13843 || reloc_type
== 60 /* R_XTENSA_NDIFF8. */
13844 || reloc_type
== 61 /* R_XTENSA_NDIFF16. */
13845 || reloc_type
== 62 /* R_XTENSA_NDIFF32. */);
13850 /* Returns TRUE if there is a relocation against
13851 section NAME at OFFSET bytes. */
13854 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
13856 Elf_Internal_Rela
* relocs
;
13857 Elf_Internal_Rela
* rp
;
13859 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
13862 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
13864 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
13865 if (rp
->r_offset
== offset
)
13871 /* Apply relocations to a section.
13872 Returns TRUE upon success, FALSE otherwise.
13873 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
13874 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
13875 will be set to the number of relocs loaded.
13877 Note: So far support has been added only for those relocations
13878 which can be found in debug sections. FIXME: Add support for
13879 more relocations ? */
13882 apply_relocations (Filedata
* filedata
,
13883 const Elf_Internal_Shdr
* section
,
13884 unsigned char * start
,
13885 bfd_size_type size
,
13886 void ** relocs_return
,
13887 unsigned long * num_relocs_return
)
13889 Elf_Internal_Shdr
* relsec
;
13890 unsigned char * end
= start
+ size
;
13892 if (relocs_return
!= NULL
)
13894 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
13895 * num_relocs_return
= 0;
13898 if (filedata
->file_header
.e_type
!= ET_REL
)
13899 /* No relocs to apply. */
13902 /* Find the reloc section associated with the section. */
13903 for (relsec
= filedata
->section_headers
;
13904 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13907 bfd_boolean is_rela
;
13908 unsigned long num_relocs
;
13909 Elf_Internal_Rela
* relocs
;
13910 Elf_Internal_Rela
* rp
;
13911 Elf_Internal_Shdr
* symsec
;
13912 Elf_Internal_Sym
* symtab
;
13913 unsigned long num_syms
;
13914 Elf_Internal_Sym
* sym
;
13916 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13917 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13918 || filedata
->section_headers
+ relsec
->sh_info
!= section
13919 || relsec
->sh_size
== 0
13920 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13923 symsec
= filedata
->section_headers
+ relsec
->sh_link
;
13924 if (symsec
->sh_type
!= SHT_SYMTAB
13925 && symsec
->sh_type
!= SHT_DYNSYM
)
13928 is_rela
= relsec
->sh_type
== SHT_RELA
;
13932 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
,
13933 relsec
->sh_size
, & relocs
, & num_relocs
))
13938 if (!slurp_rel_relocs (filedata
, relsec
->sh_offset
,
13939 relsec
->sh_size
, & relocs
, & num_relocs
))
13943 /* SH uses RELA but uses in place value instead of the addend field. */
13944 if (filedata
->file_header
.e_machine
== EM_SH
)
13947 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & num_syms
);
13949 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
13952 unsigned int reloc_type
;
13953 unsigned int reloc_size
;
13954 bfd_boolean reloc_inplace
= FALSE
;
13955 bfd_boolean reloc_subtract
= FALSE
;
13956 unsigned char * rloc
;
13957 unsigned long sym_index
;
13959 reloc_type
= get_reloc_type (filedata
, rp
->r_info
);
13961 if (target_specific_reloc_handling (filedata
, rp
, start
, end
, symtab
, num_syms
))
13963 else if (is_none_reloc (filedata
, reloc_type
))
13965 else if (is_32bit_abs_reloc (filedata
, reloc_type
)
13966 || is_32bit_pcrel_reloc (filedata
, reloc_type
))
13968 else if (is_64bit_abs_reloc (filedata
, reloc_type
)
13969 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
13971 else if (is_24bit_abs_reloc (filedata
, reloc_type
))
13973 else if (is_16bit_abs_reloc (filedata
, reloc_type
))
13975 else if (is_8bit_abs_reloc (filedata
, reloc_type
)
13976 || is_6bit_abs_reloc (filedata
, reloc_type
))
13978 else if ((reloc_subtract
= is_32bit_inplace_sub_reloc (filedata
,
13980 || is_32bit_inplace_add_reloc (filedata
, reloc_type
))
13983 reloc_inplace
= TRUE
;
13985 else if ((reloc_subtract
= is_64bit_inplace_sub_reloc (filedata
,
13987 || is_64bit_inplace_add_reloc (filedata
, reloc_type
))
13990 reloc_inplace
= TRUE
;
13992 else if ((reloc_subtract
= is_16bit_inplace_sub_reloc (filedata
,
13994 || is_16bit_inplace_add_reloc (filedata
, reloc_type
))
13997 reloc_inplace
= TRUE
;
13999 else if ((reloc_subtract
= is_8bit_inplace_sub_reloc (filedata
,
14001 || is_8bit_inplace_add_reloc (filedata
, reloc_type
))
14004 reloc_inplace
= TRUE
;
14006 else if ((reloc_subtract
= is_6bit_inplace_sub_reloc (filedata
,
14010 reloc_inplace
= TRUE
;
14014 static unsigned int prev_reloc
= 0;
14016 if (reloc_type
!= prev_reloc
)
14017 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
14018 reloc_type
, printable_section_name (filedata
, section
));
14019 prev_reloc
= reloc_type
;
14023 rloc
= start
+ rp
->r_offset
;
14024 if (!IN_RANGE (start
, end
, rloc
, reloc_size
))
14026 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
14027 (unsigned long) rp
->r_offset
,
14028 printable_section_name (filedata
, section
));
14032 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
14033 if (sym_index
>= num_syms
)
14035 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
14036 sym_index
, printable_section_name (filedata
, section
));
14039 sym
= symtab
+ sym_index
;
14041 /* If the reloc has a symbol associated with it,
14042 make sure that it is of an appropriate type.
14044 Relocations against symbols without type can happen.
14045 Gcc -feliminate-dwarf2-dups may generate symbols
14046 without type for debug info.
14048 Icc generates relocations against function symbols
14049 instead of local labels.
14051 Relocations against object symbols can happen, eg when
14052 referencing a global array. For an example of this see
14053 the _clz.o binary in libgcc.a. */
14055 && ELF_ST_TYPE (sym
->st_info
) != STT_COMMON
14056 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
14058 warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
14059 get_symbol_type (filedata
, ELF_ST_TYPE (sym
->st_info
)),
14060 printable_section_name (filedata
, relsec
),
14061 (long int)(rp
- relocs
));
14067 addend
+= rp
->r_addend
;
14068 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
14069 partial_inplace. */
14071 || (filedata
->file_header
.e_machine
== EM_XTENSA
14072 && reloc_type
== 1)
14073 || ((filedata
->file_header
.e_machine
== EM_PJ
14074 || filedata
->file_header
.e_machine
== EM_PJ_OLD
)
14075 && reloc_type
== 1)
14076 || ((filedata
->file_header
.e_machine
== EM_D30V
14077 || filedata
->file_header
.e_machine
== EM_CYGNUS_D30V
)
14078 && reloc_type
== 12)
14081 if (is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
14082 addend
+= byte_get (rloc
, reloc_size
) & 0x3f;
14084 addend
+= byte_get (rloc
, reloc_size
);
14087 if (is_32bit_pcrel_reloc (filedata
, reloc_type
)
14088 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
14090 /* On HPPA, all pc-relative relocations are biased by 8. */
14091 if (filedata
->file_header
.e_machine
== EM_PARISC
)
14093 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
14096 else if (is_6bit_abs_reloc (filedata
, reloc_type
)
14097 || is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
14099 if (reloc_subtract
)
14100 addend
-= sym
->st_value
;
14102 addend
+= sym
->st_value
;
14103 addend
= (addend
& 0x3f) | (byte_get (rloc
, reloc_size
) & 0xc0);
14104 byte_put (rloc
, addend
, reloc_size
);
14106 else if (reloc_subtract
)
14107 byte_put (rloc
, addend
- sym
->st_value
, reloc_size
);
14109 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
14113 /* Let the target specific reloc processing code know that
14114 we have finished with these relocs. */
14115 target_specific_reloc_handling (filedata
, NULL
, NULL
, NULL
, NULL
, 0);
14119 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
14120 * num_relocs_return
= num_relocs
;
14131 #ifdef SUPPORT_DISASSEMBLY
14133 disassemble_section (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
14135 printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata
, section
));
14137 /* FIXME: XXX -- to be done --- XXX */
14143 /* Reads in the contents of SECTION from FILE, returning a pointer
14144 to a malloc'ed buffer or NULL if something went wrong. */
14147 get_section_contents (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
14149 bfd_size_type num_bytes
= section
->sh_size
;
14151 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
14153 printf (_("Section '%s' has no data to dump.\n"),
14154 printable_section_name (filedata
, section
));
14158 return (char *) get_data (NULL
, filedata
, section
->sh_offset
, 1, num_bytes
,
14159 _("section contents"));
14162 /* Uncompresses a section that was compressed using zlib, in place. */
14165 uncompress_section_contents (unsigned char ** buffer
,
14166 dwarf_size_type uncompressed_size
,
14167 dwarf_size_type
* size
)
14169 dwarf_size_type compressed_size
= *size
;
14170 unsigned char * compressed_buffer
= *buffer
;
14171 unsigned char * uncompressed_buffer
;
14175 /* It is possible the section consists of several compressed
14176 buffers concatenated together, so we uncompress in a loop. */
14177 /* PR 18313: The state field in the z_stream structure is supposed
14178 to be invisible to the user (ie us), but some compilers will
14179 still complain about it being used without initialisation. So
14180 we first zero the entire z_stream structure and then set the fields
14182 memset (& strm
, 0, sizeof strm
);
14183 strm
.avail_in
= compressed_size
;
14184 strm
.next_in
= (Bytef
*) compressed_buffer
;
14185 strm
.avail_out
= uncompressed_size
;
14186 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
14188 rc
= inflateInit (& strm
);
14189 while (strm
.avail_in
> 0)
14193 strm
.next_out
= ((Bytef
*) uncompressed_buffer
14194 + (uncompressed_size
- strm
.avail_out
));
14195 rc
= inflate (&strm
, Z_FINISH
);
14196 if (rc
!= Z_STREAM_END
)
14198 rc
= inflateReset (& strm
);
14200 rc
= inflateEnd (& strm
);
14202 || strm
.avail_out
!= 0)
14205 *buffer
= uncompressed_buffer
;
14206 *size
= uncompressed_size
;
14210 free (uncompressed_buffer
);
14211 /* Indicate decompression failure. */
14217 dump_section_as_strings (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
14219 Elf_Internal_Shdr
* relsec
;
14220 bfd_size_type num_bytes
;
14221 unsigned char * data
;
14222 unsigned char * end
;
14223 unsigned char * real_start
;
14224 unsigned char * start
;
14225 bfd_boolean some_strings_shown
;
14227 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
14229 /* PR 21820: Do not fail if the section was empty. */
14230 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
14232 num_bytes
= section
->sh_size
;
14234 printf (_("\nString dump of section '%s':\n"), printable_section_name (filedata
, section
));
14236 if (decompress_dumps
)
14238 dwarf_size_type new_size
= num_bytes
;
14239 dwarf_size_type uncompressed_size
= 0;
14241 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
14243 Elf_Internal_Chdr chdr
;
14244 unsigned int compression_header_size
14245 = get_compression_header (& chdr
, (unsigned char *) start
,
14247 if (compression_header_size
== 0)
14248 /* An error message will have already been generated
14249 by get_compression_header. */
14252 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
14254 warn (_("section '%s' has unsupported compress type: %d\n"),
14255 printable_section_name (filedata
, section
), chdr
.ch_type
);
14258 uncompressed_size
= chdr
.ch_size
;
14259 start
+= compression_header_size
;
14260 new_size
-= compression_header_size
;
14262 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
14264 /* Read the zlib header. In this case, it should be "ZLIB"
14265 followed by the uncompressed section size, 8 bytes in
14266 big-endian order. */
14267 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
14268 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
14269 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
14270 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
14271 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
14272 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
14273 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
14274 uncompressed_size
+= start
[11];
14279 if (uncompressed_size
)
14281 if (uncompress_section_contents (& start
,
14282 uncompressed_size
, & new_size
))
14283 num_bytes
= new_size
;
14286 error (_("Unable to decompress section %s\n"),
14287 printable_section_name (filedata
, section
));
14292 start
= real_start
;
14295 /* If the section being dumped has relocations against it the user might
14296 be expecting these relocations to have been applied. Check for this
14297 case and issue a warning message in order to avoid confusion.
14298 FIXME: Maybe we ought to have an option that dumps a section with
14299 relocs applied ? */
14300 for (relsec
= filedata
->section_headers
;
14301 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
14304 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
14305 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
14306 || filedata
->section_headers
+ relsec
->sh_info
!= section
14307 || relsec
->sh_size
== 0
14308 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
14311 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
14316 end
= start
+ num_bytes
;
14317 some_strings_shown
= FALSE
;
14319 #ifdef HAVE_MBSTATE_T
14321 /* Initialise the multibyte conversion state. */
14322 memset (& state
, 0, sizeof (state
));
14325 bfd_boolean continuing
= FALSE
;
14329 while (!ISPRINT (* data
))
14330 if (++ data
>= end
)
14335 size_t maxlen
= end
- data
;
14340 continuing
= FALSE
;
14344 printf (" [%6lx] ", (unsigned long) (data
- start
));
14358 /* PR 25543: Treat new-lines as string-ending characters. */
14367 /* Do not print control characters directly as they can affect terminal
14368 settings. Such characters usually appear in the names generated
14369 by the assembler for local labels. */
14372 printf ("^%c", c
+ 0x40);
14374 else if (ISPRINT (c
))
14381 #ifdef HAVE_MBSTATE_T
14384 /* Let printf do the hard work of displaying multibyte characters. */
14385 printf ("%.1s", data
- 1);
14386 #ifdef HAVE_MBSTATE_T
14387 /* Try to find out how many bytes made up the character that was
14388 just printed. Advance the symbol pointer past the bytes that
14390 n
= mbrtowc (& w
, (char *)(data
- 1), MB_CUR_MAX
, & state
);
14394 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
14404 printf (_("<corrupt>\n"));
14407 some_strings_shown
= TRUE
;
14411 if (! some_strings_shown
)
14412 printf (_(" No strings found in this section."));
14425 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
14426 Filedata
* filedata
,
14427 bfd_boolean relocate
)
14429 Elf_Internal_Shdr
* relsec
;
14430 bfd_size_type bytes
;
14431 bfd_size_type section_size
;
14433 unsigned char * data
;
14434 unsigned char * real_start
;
14435 unsigned char * start
;
14437 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
14439 /* PR 21820: Do not fail if the section was empty. */
14440 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
14442 section_size
= section
->sh_size
;
14444 printf (_("\nHex dump of section '%s':\n"), printable_section_name (filedata
, section
));
14446 if (decompress_dumps
)
14448 dwarf_size_type new_size
= section_size
;
14449 dwarf_size_type uncompressed_size
= 0;
14451 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
14453 Elf_Internal_Chdr chdr
;
14454 unsigned int compression_header_size
14455 = get_compression_header (& chdr
, start
, section_size
);
14457 if (compression_header_size
== 0)
14458 /* An error message will have already been generated
14459 by get_compression_header. */
14462 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
14464 warn (_("section '%s' has unsupported compress type: %d\n"),
14465 printable_section_name (filedata
, section
), chdr
.ch_type
);
14468 uncompressed_size
= chdr
.ch_size
;
14469 start
+= compression_header_size
;
14470 new_size
-= compression_header_size
;
14472 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
14474 /* Read the zlib header. In this case, it should be "ZLIB"
14475 followed by the uncompressed section size, 8 bytes in
14476 big-endian order. */
14477 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
14478 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
14479 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
14480 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
14481 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
14482 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
14483 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
14484 uncompressed_size
+= start
[11];
14489 if (uncompressed_size
)
14491 if (uncompress_section_contents (& start
, uncompressed_size
,
14494 section_size
= new_size
;
14498 error (_("Unable to decompress section %s\n"),
14499 printable_section_name (filedata
, section
));
14500 /* FIXME: Print the section anyway ? */
14505 start
= real_start
;
14510 if (! apply_relocations (filedata
, section
, start
, section_size
, NULL
, NULL
))
14515 /* If the section being dumped has relocations against it the user might
14516 be expecting these relocations to have been applied. Check for this
14517 case and issue a warning message in order to avoid confusion.
14518 FIXME: Maybe we ought to have an option that dumps a section with
14519 relocs applied ? */
14520 for (relsec
= filedata
->section_headers
;
14521 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
14524 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
14525 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
14526 || filedata
->section_headers
+ relsec
->sh_info
!= section
14527 || relsec
->sh_size
== 0
14528 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
14531 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
14536 addr
= section
->sh_addr
;
14537 bytes
= section_size
;
14546 lbytes
= (bytes
> 16 ? 16 : bytes
);
14548 printf (" 0x%8.8lx ", (unsigned long) addr
);
14550 for (j
= 0; j
< 16; j
++)
14553 printf ("%2.2x", data
[j
]);
14561 for (j
= 0; j
< lbytes
; j
++)
14564 if (k
>= ' ' && k
< 0x7f)
14587 #ifdef ENABLE_LIBCTF
14588 static ctf_sect_t
*
14589 shdr_to_ctf_sect (ctf_sect_t
*buf
, Elf_Internal_Shdr
*shdr
, Filedata
*filedata
)
14591 buf
->cts_name
= SECTION_NAME_PRINT (shdr
);
14592 buf
->cts_size
= shdr
->sh_size
;
14593 buf
->cts_entsize
= shdr
->sh_entsize
;
14598 /* Formatting callback function passed to ctf_dump. Returns either the pointer
14599 it is passed, or a pointer to newly-allocated storage, in which case
14600 dump_ctf() will free it when it no longer needs it. */
14603 dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED
,
14604 char *s
, void *arg
)
14606 const char *blanks
= arg
;
14609 if (asprintf (&new_s
, "%s%s", blanks
, s
) < 0)
14614 /* Dump CTF errors/warnings. */
14616 dump_ctf_errs (ctf_dict_t
*fp
)
14618 ctf_next_t
*it
= NULL
;
14623 /* Dump accumulated errors and warnings. */
14624 while ((errtext
= ctf_errwarning_next (fp
, &it
, &is_warning
, &err
)) != NULL
)
14626 error (_("%s: %s"), is_warning
? _("warning"): _("error"),
14630 if (err
!= ECTF_NEXT_END
)
14631 error (_("CTF error: cannot get CTF errors: `%s'"), ctf_errmsg (err
));
14634 /* Dump one CTF archive member. */
14637 dump_ctf_archive_member (ctf_dict_t
*ctf
, const char *name
, void *arg
)
14639 ctf_dict_t
*parent
= (ctf_dict_t
*) arg
;
14640 const char *things
[] = {"Header", "Labels", "Data objects",
14641 "Function objects", "Variables", "Types", "Strings",
14643 const char **thing
;
14647 /* Only print out the name of non-default-named archive members.
14648 The name .ctf appears everywhere, even for things that aren't
14649 really archives, so printing it out is liable to be confusing.
14651 The parent, if there is one, is the default-owned archive member:
14652 avoid importing it into itself. (This does no harm, but looks
14655 if (strcmp (name
, ".ctf") != 0)
14657 printf (_("\nCTF archive member: %s:\n"), name
);
14658 ctf_import (ctf
, parent
);
14661 for (i
= 0, thing
= things
; *thing
[0]; thing
++, i
++)
14663 ctf_dump_state_t
*s
= NULL
;
14666 printf ("\n %s:\n", *thing
);
14667 while ((item
= ctf_dump (ctf
, &s
, i
, dump_ctf_indent_lines
,
14668 (void *) " ")) != NULL
)
14670 printf ("%s\n", item
);
14674 if (ctf_errno (ctf
))
14676 error (_("Iteration failed: %s, %s\n"), *thing
,
14677 ctf_errmsg (ctf_errno (ctf
)));
14684 dump_ctf_errs (ctf
);
14689 dump_section_as_ctf (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
14691 Elf_Internal_Shdr
* parent_sec
= NULL
;
14692 Elf_Internal_Shdr
* symtab_sec
= NULL
;
14693 Elf_Internal_Shdr
* strtab_sec
= NULL
;
14694 void * data
= NULL
;
14695 void * symdata
= NULL
;
14696 void * strdata
= NULL
;
14697 void * parentdata
= NULL
;
14698 ctf_sect_t ctfsect
, symsect
, strsect
, parentsect
;
14699 ctf_sect_t
* symsectp
= NULL
;
14700 ctf_sect_t
* strsectp
= NULL
;
14701 ctf_archive_t
* ctfa
= NULL
;
14702 ctf_archive_t
* parenta
= NULL
, *lookparent
;
14703 ctf_dict_t
* parent
= NULL
;
14706 bfd_boolean ret
= FALSE
;
14708 shdr_to_ctf_sect (&ctfsect
, section
, filedata
);
14709 data
= get_section_contents (section
, filedata
);
14710 ctfsect
.cts_data
= data
;
14712 if (!dump_ctf_symtab_name
)
14713 dump_ctf_symtab_name
= strdup (".dynsym");
14715 if (!dump_ctf_strtab_name
)
14716 dump_ctf_strtab_name
= strdup (".dynstr");
14718 if (dump_ctf_symtab_name
&& dump_ctf_symtab_name
[0] != 0)
14720 if ((symtab_sec
= find_section (filedata
, dump_ctf_symtab_name
)) == NULL
)
14722 error (_("No symbol section named %s\n"), dump_ctf_symtab_name
);
14725 if ((symdata
= (void *) get_data (NULL
, filedata
,
14726 symtab_sec
->sh_offset
, 1,
14727 symtab_sec
->sh_size
,
14728 _("symbols"))) == NULL
)
14730 symsectp
= shdr_to_ctf_sect (&symsect
, symtab_sec
, filedata
);
14731 symsect
.cts_data
= symdata
;
14733 if (dump_ctf_strtab_name
&& dump_ctf_strtab_name
[0] != 0)
14735 if ((strtab_sec
= find_section (filedata
, dump_ctf_strtab_name
)) == NULL
)
14737 error (_("No string table section named %s\n"),
14738 dump_ctf_strtab_name
);
14741 if ((strdata
= (void *) get_data (NULL
, filedata
,
14742 strtab_sec
->sh_offset
, 1,
14743 strtab_sec
->sh_size
,
14744 _("strings"))) == NULL
)
14746 strsectp
= shdr_to_ctf_sect (&strsect
, strtab_sec
, filedata
);
14747 strsect
.cts_data
= strdata
;
14749 if (dump_ctf_parent_name
)
14751 if ((parent_sec
= find_section (filedata
, dump_ctf_parent_name
)) == NULL
)
14753 error (_("No CTF parent section named %s\n"), dump_ctf_parent_name
);
14756 if ((parentdata
= (void *) get_data (NULL
, filedata
,
14757 parent_sec
->sh_offset
, 1,
14758 parent_sec
->sh_size
,
14759 _("CTF parent"))) == NULL
)
14761 shdr_to_ctf_sect (&parentsect
, parent_sec
, filedata
);
14762 parentsect
.cts_data
= parentdata
;
14765 /* Load the CTF file and dump it. It may be a raw CTF section, or an archive:
14766 libctf papers over the difference, so we can pretend it is always an
14767 archive. Possibly open the parent as well, if one was specified. */
14769 if ((ctfa
= ctf_arc_bufopen (&ctfsect
, symsectp
, strsectp
, &err
)) == NULL
)
14771 dump_ctf_errs (NULL
);
14772 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
14776 ctf_arc_symsect_endianness (ctfa
, filedata
->file_header
.e_ident
[EI_DATA
]
14781 if ((parenta
= ctf_arc_bufopen (&parentsect
, symsectp
, strsectp
,
14784 dump_ctf_errs (NULL
);
14785 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
14788 lookparent
= parenta
;
14793 /* Assume that the applicable parent archive member is the default one.
14794 (This is what all known implementations are expected to do, if they
14795 put CTFs and their parents in archives together.) */
14796 if ((parent
= ctf_dict_open (lookparent
, NULL
, &err
)) == NULL
)
14798 dump_ctf_errs (NULL
);
14799 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
14805 printf (_("\nDump of CTF section '%s':\n"),
14806 printable_section_name (filedata
, section
));
14808 if ((err
= ctf_archive_iter (ctfa
, dump_ctf_archive_member
, parent
)) != 0)
14810 dump_ctf_errs (NULL
);
14811 error (_("CTF member open failure: %s\n"), ctf_errmsg (err
));
14816 ctf_dict_close (parent
);
14818 ctf_close (parenta
);
14828 load_specific_debug_section (enum dwarf_section_display_enum debug
,
14829 const Elf_Internal_Shdr
* sec
,
14832 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14834 Filedata
* filedata
= (Filedata
*) data
;
14836 if (section
->start
!= NULL
)
14838 /* If it is already loaded, do nothing. */
14839 if (streq (section
->filename
, filedata
->file_name
))
14841 free (section
->start
);
14844 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
14845 section
->address
= sec
->sh_addr
;
14846 section
->user_data
= NULL
;
14847 section
->filename
= filedata
->file_name
;
14848 section
->start
= (unsigned char *) get_data (NULL
, filedata
,
14850 sec
->sh_size
, buf
);
14851 if (section
->start
== NULL
)
14855 unsigned char *start
= section
->start
;
14856 dwarf_size_type size
= sec
->sh_size
;
14857 dwarf_size_type uncompressed_size
= 0;
14859 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
14861 Elf_Internal_Chdr chdr
;
14862 unsigned int compression_header_size
;
14864 if (size
< (is_32bit_elf
14865 ? sizeof (Elf32_External_Chdr
)
14866 : sizeof (Elf64_External_Chdr
)))
14868 warn (_("compressed section %s is too small to contain a compression header\n"),
14873 compression_header_size
= get_compression_header (&chdr
, start
, size
);
14874 if (compression_header_size
== 0)
14875 /* An error message will have already been generated
14876 by get_compression_header. */
14879 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
14881 warn (_("section '%s' has unsupported compress type: %d\n"),
14882 section
->name
, chdr
.ch_type
);
14885 uncompressed_size
= chdr
.ch_size
;
14886 start
+= compression_header_size
;
14887 size
-= compression_header_size
;
14889 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
14891 /* Read the zlib header. In this case, it should be "ZLIB"
14892 followed by the uncompressed section size, 8 bytes in
14893 big-endian order. */
14894 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
14895 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
14896 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
14897 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
14898 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
14899 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
14900 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
14901 uncompressed_size
+= start
[11];
14906 if (uncompressed_size
)
14908 if (uncompress_section_contents (&start
, uncompressed_size
,
14911 /* Free the compressed buffer, update the section buffer
14912 and the section size if uncompress is successful. */
14913 free (section
->start
);
14914 section
->start
= start
;
14918 error (_("Unable to decompress section %s\n"),
14919 printable_section_name (filedata
, sec
));
14924 section
->size
= size
;
14927 if (section
->start
== NULL
)
14930 if (debug_displays
[debug
].relocate
)
14932 if (! apply_relocations (filedata
, sec
, section
->start
, section
->size
,
14933 & section
->reloc_info
, & section
->num_relocs
))
14938 section
->reloc_info
= NULL
;
14939 section
->num_relocs
= 0;
14945 #if HAVE_LIBDEBUGINFOD
14946 /* Return a hex string representation of the build-id. */
14948 get_build_id (void * data
)
14950 Filedata
* filedata
= (Filedata
*)data
;
14951 Elf_Internal_Shdr
* shdr
;
14954 /* Iterate through notes to find note.gnu.build-id.
14955 FIXME: Only the first note in any note section is examined. */
14956 for (i
= 0, shdr
= filedata
->section_headers
;
14957 i
< filedata
->file_header
.e_shnum
&& shdr
!= NULL
;
14960 if (shdr
->sh_type
!= SHT_NOTE
)
14965 size_t data_remaining
;
14967 Elf_External_Note
* enote
;
14968 Elf_Internal_Note inote
;
14970 bfd_vma offset
= shdr
->sh_offset
;
14971 bfd_vma align
= shdr
->sh_addralign
;
14972 bfd_vma length
= shdr
->sh_size
;
14974 enote
= (Elf_External_Note
*) get_section_contents (shdr
, filedata
);
14980 else if (align
!= 4 && align
!= 8)
14986 end
= (char *) enote
+ length
;
14987 data_remaining
= end
- (char *) enote
;
14989 if (!is_ia64_vms (filedata
))
14991 min_notesz
= offsetof (Elf_External_Note
, name
);
14992 if (data_remaining
< min_notesz
)
14995 malformed note encountered in section %s whilst scanning for build-id note\n"),
14996 printable_section_name (filedata
, shdr
));
15000 data_remaining
-= min_notesz
;
15002 inote
.type
= BYTE_GET (enote
->type
);
15003 inote
.namesz
= BYTE_GET (enote
->namesz
);
15004 inote
.namedata
= enote
->name
;
15005 inote
.descsz
= BYTE_GET (enote
->descsz
);
15006 inote
.descdata
= ((char *) enote
15007 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
15008 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
15009 next
= ((char *) enote
15010 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
15014 Elf64_External_VMS_Note
*vms_enote
;
15016 /* PR binutils/15191
15017 Make sure that there is enough data to read. */
15018 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
15019 if (data_remaining
< min_notesz
)
15022 malformed note encountered in section %s whilst scanning for build-id note\n"),
15023 printable_section_name (filedata
, shdr
));
15027 data_remaining
-= min_notesz
;
15029 vms_enote
= (Elf64_External_VMS_Note
*) enote
;
15030 inote
.type
= BYTE_GET (vms_enote
->type
);
15031 inote
.namesz
= BYTE_GET (vms_enote
->namesz
);
15032 inote
.namedata
= vms_enote
->name
;
15033 inote
.descsz
= BYTE_GET (vms_enote
->descsz
);
15034 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
15035 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
15036 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
15039 /* Skip malformed notes. */
15040 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
15041 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
15042 || (size_t) (next
- inote
.descdata
) < inote
.descsz
15043 || ((size_t) (next
- inote
.descdata
)
15044 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
15047 malformed note encountered in section %s whilst scanning for build-id note\n"),
15048 printable_section_name (filedata
, shdr
));
15053 /* Check if this is the build-id note. If so then convert the build-id
15054 bytes to a hex string. */
15055 if (inote
.namesz
> 0
15056 && const_strneq (inote
.namedata
, "GNU")
15057 && inote
.type
== NT_GNU_BUILD_ID
)
15062 build_id
= malloc (inote
.descsz
* 2 + 1);
15063 if (build_id
== NULL
)
15069 for (j
= 0; j
< inote
.descsz
; ++j
)
15070 sprintf (build_id
+ (j
* 2), "%02x", inote
.descdata
[j
] & 0xff);
15071 build_id
[inote
.descsz
* 2] = '\0';
15074 return (unsigned char *) build_id
;
15081 #endif /* HAVE_LIBDEBUGINFOD */
15083 /* If this is not NULL, load_debug_section will only look for sections
15084 within the list of sections given here. */
15085 static unsigned int * section_subset
= NULL
;
15088 load_debug_section (enum dwarf_section_display_enum debug
, void * data
)
15090 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
15091 Elf_Internal_Shdr
* sec
;
15092 Filedata
* filedata
= (Filedata
*) data
;
15094 /* Without section headers we cannot find any sections. */
15095 if (filedata
->section_headers
== NULL
)
15098 if (filedata
->string_table
== NULL
15099 && filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
15100 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
15102 Elf_Internal_Shdr
* strs
;
15104 /* Read in the string table, so that we have section names to scan. */
15105 strs
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
15107 if (strs
!= NULL
&& strs
->sh_size
!= 0)
15109 filedata
->string_table
15110 = (char *) get_data (NULL
, filedata
, strs
->sh_offset
,
15111 1, strs
->sh_size
, _("string table"));
15113 filedata
->string_table_length
15114 = filedata
->string_table
!= NULL
? strs
->sh_size
: 0;
15118 /* Locate the debug section. */
15119 sec
= find_section_in_set (filedata
, section
->uncompressed_name
, section_subset
);
15121 section
->name
= section
->uncompressed_name
;
15124 sec
= find_section_in_set (filedata
, section
->compressed_name
, section_subset
);
15126 section
->name
= section
->compressed_name
;
15131 /* If we're loading from a subset of sections, and we've loaded
15132 a section matching this name before, it's likely that it's a
15134 if (section_subset
!= NULL
)
15135 free_debug_section (debug
);
15137 return load_specific_debug_section (debug
, sec
, data
);
15141 free_debug_section (enum dwarf_section_display_enum debug
)
15143 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
15145 if (section
->start
== NULL
)
15148 free ((char *) section
->start
);
15149 section
->start
= NULL
;
15150 section
->address
= 0;
15153 free (section
->reloc_info
);
15154 section
->reloc_info
= NULL
;
15155 section
->num_relocs
= 0;
15159 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, Filedata
* filedata
)
15161 char * name
= SECTION_NAME_VALID (section
) ? SECTION_NAME (section
) : "";
15162 const char * print_name
= printable_section_name (filedata
, section
);
15163 bfd_size_type length
;
15164 bfd_boolean result
= TRUE
;
15167 length
= section
->sh_size
;
15170 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
15173 if (section
->sh_type
== SHT_NOBITS
)
15175 /* There is no point in dumping the contents of a debugging section
15176 which has the NOBITS type - the bits in the file will be random.
15177 This can happen when a file containing a .eh_frame section is
15178 stripped with the --only-keep-debug command line option. */
15179 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
15184 if (const_strneq (name
, ".gnu.linkonce.wi."))
15185 name
= ".debug_info";
15187 /* See if we know how to display the contents of this section. */
15188 for (i
= 0; i
< max
; i
++)
15190 enum dwarf_section_display_enum id
= (enum dwarf_section_display_enum
) i
;
15191 struct dwarf_section_display
* display
= debug_displays
+ i
;
15192 struct dwarf_section
* sec
= & display
->section
;
15194 if (streq (sec
->uncompressed_name
, name
)
15195 || (id
== line
&& const_strneq (name
, ".debug_line."))
15196 || streq (sec
->compressed_name
, name
))
15198 bfd_boolean secondary
= (section
!= find_section (filedata
, name
));
15201 free_debug_section (id
);
15203 if (i
== line
&& const_strneq (name
, ".debug_line."))
15205 else if (streq (sec
->uncompressed_name
, name
))
15206 sec
->name
= sec
->uncompressed_name
;
15208 sec
->name
= sec
->compressed_name
;
15210 if (load_specific_debug_section (id
, section
, filedata
))
15212 /* If this debug section is part of a CU/TU set in a .dwp file,
15213 restrict load_debug_section to the sections in that set. */
15214 section_subset
= find_cu_tu_set (filedata
, shndx
);
15216 result
&= display
->display (sec
, filedata
);
15218 section_subset
= NULL
;
15220 if (secondary
|| (id
!= info
&& id
!= abbrev
))
15221 free_debug_section (id
);
15229 printf (_("Unrecognized debug section: %s\n"), print_name
);
15236 /* Set DUMP_SECTS for all sections where dumps were requested
15237 based on section name. */
15240 initialise_dumps_byname (Filedata
* filedata
)
15242 struct dump_list_entry
* cur
;
15244 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
15247 bfd_boolean any
= FALSE
;
15249 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
15250 if (SECTION_NAME_VALID (filedata
->section_headers
+ i
)
15251 && streq (SECTION_NAME (filedata
->section_headers
+ i
), cur
->name
))
15253 request_dump_bynumber (&filedata
->dump
, i
, cur
->type
);
15258 warn (_("Section '%s' was not dumped because it does not exist!\n"),
15264 process_section_contents (Filedata
* filedata
)
15266 Elf_Internal_Shdr
* section
;
15268 bfd_boolean res
= TRUE
;
15273 initialise_dumps_byname (filedata
);
15275 for (i
= 0, section
= filedata
->section_headers
;
15276 i
< filedata
->file_header
.e_shnum
&& i
< filedata
->dump
.num_dump_sects
;
15279 dump_type dump
= filedata
->dump
.dump_sects
[i
];
15281 #ifdef SUPPORT_DISASSEMBLY
15282 if (dump
& DISASS_DUMP
)
15284 if (! disassemble_section (section
, filedata
))
15288 if (dump
& HEX_DUMP
)
15290 if (! dump_section_as_bytes (section
, filedata
, FALSE
))
15294 if (dump
& RELOC_DUMP
)
15296 if (! dump_section_as_bytes (section
, filedata
, TRUE
))
15300 if (dump
& STRING_DUMP
)
15302 if (! dump_section_as_strings (section
, filedata
))
15306 if (dump
& DEBUG_DUMP
)
15308 if (! display_debug_section (i
, section
, filedata
))
15312 #ifdef ENABLE_LIBCTF
15313 if (dump
& CTF_DUMP
)
15315 if (! dump_section_as_ctf (section
, filedata
))
15321 /* Check to see if the user requested a
15322 dump of a section that does not exist. */
15323 while (i
< filedata
->dump
.num_dump_sects
)
15325 if (filedata
->dump
.dump_sects
[i
])
15327 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
15337 process_mips_fpe_exception (int mask
)
15341 bfd_boolean first
= TRUE
;
15343 if (mask
& OEX_FPU_INEX
)
15344 fputs ("INEX", stdout
), first
= FALSE
;
15345 if (mask
& OEX_FPU_UFLO
)
15346 printf ("%sUFLO", first
? "" : "|"), first
= FALSE
;
15347 if (mask
& OEX_FPU_OFLO
)
15348 printf ("%sOFLO", first
? "" : "|"), first
= FALSE
;
15349 if (mask
& OEX_FPU_DIV0
)
15350 printf ("%sDIV0", first
? "" : "|"), first
= FALSE
;
15351 if (mask
& OEX_FPU_INVAL
)
15352 printf ("%sINVAL", first
? "" : "|");
15355 fputs ("0", stdout
);
15358 /* Display's the value of TAG at location P. If TAG is
15359 greater than 0 it is assumed to be an unknown tag, and
15360 a message is printed to this effect. Otherwise it is
15361 assumed that a message has already been printed.
15363 If the bottom bit of TAG is set it assumed to have a
15364 string value, otherwise it is assumed to have an integer
15367 Returns an updated P pointing to the first unread byte
15368 beyond the end of TAG's value.
15370 Reads at or beyond END will not be made. */
15372 static unsigned char *
15373 display_tag_value (signed int tag
,
15375 const unsigned char * const end
)
15380 printf (" Tag_unknown_%d: ", tag
);
15384 warn (_("<corrupt tag>\n"));
15388 /* PR 17531 file: 027-19978-0.004. */
15389 size_t maxlen
= (end
- p
) - 1;
15394 print_symbol ((int) maxlen
, (const char *) p
);
15395 p
+= strnlen ((char *) p
, maxlen
) + 1;
15399 printf (_("<corrupt string tag>"));
15400 p
= (unsigned char *) end
;
15406 READ_ULEB (val
, p
, end
);
15407 printf ("%ld (0x%lx)\n", val
, val
);
15414 /* ARC ABI attributes section. */
15416 static unsigned char *
15417 display_arc_attribute (unsigned char * p
,
15418 const unsigned char * const end
)
15423 READ_ULEB (tag
, p
, end
);
15427 case Tag_ARC_PCS_config
:
15428 READ_ULEB (val
, p
, end
);
15429 printf (" Tag_ARC_PCS_config: ");
15433 printf (_("Absent/Non standard\n"));
15436 printf (_("Bare metal/mwdt\n"));
15439 printf (_("Bare metal/newlib\n"));
15442 printf (_("Linux/uclibc\n"));
15445 printf (_("Linux/glibc\n"));
15448 printf (_("Unknown\n"));
15453 case Tag_ARC_CPU_base
:
15454 READ_ULEB (val
, p
, end
);
15455 printf (" Tag_ARC_CPU_base: ");
15460 printf (_("Absent\n"));
15462 case TAG_CPU_ARC6xx
:
15463 printf ("ARC6xx\n");
15465 case TAG_CPU_ARC7xx
:
15466 printf ("ARC7xx\n");
15468 case TAG_CPU_ARCEM
:
15469 printf ("ARCEM\n");
15471 case TAG_CPU_ARCHS
:
15472 printf ("ARCHS\n");
15477 case Tag_ARC_CPU_variation
:
15478 READ_ULEB (val
, p
, end
);
15479 printf (" Tag_ARC_CPU_variation: ");
15483 if (val
> 0 && val
< 16)
15484 printf ("Core%d\n", val
);
15486 printf ("Unknown\n");
15490 printf (_("Absent\n"));
15495 case Tag_ARC_CPU_name
:
15496 printf (" Tag_ARC_CPU_name: ");
15497 p
= display_tag_value (-1, p
, end
);
15500 case Tag_ARC_ABI_rf16
:
15501 READ_ULEB (val
, p
, end
);
15502 printf (" Tag_ARC_ABI_rf16: %s\n", val
? _("yes") : _("no"));
15505 case Tag_ARC_ABI_osver
:
15506 READ_ULEB (val
, p
, end
);
15507 printf (" Tag_ARC_ABI_osver: v%d\n", val
);
15510 case Tag_ARC_ABI_pic
:
15511 case Tag_ARC_ABI_sda
:
15512 READ_ULEB (val
, p
, end
);
15513 printf (tag
== Tag_ARC_ABI_sda
? " Tag_ARC_ABI_sda: "
15514 : " Tag_ARC_ABI_pic: ");
15518 printf (_("Absent\n"));
15527 printf (_("Unknown\n"));
15532 case Tag_ARC_ABI_tls
:
15533 READ_ULEB (val
, p
, end
);
15534 printf (" Tag_ARC_ABI_tls: %s\n", val
? "r25": "none");
15537 case Tag_ARC_ABI_enumsize
:
15538 READ_ULEB (val
, p
, end
);
15539 printf (" Tag_ARC_ABI_enumsize: %s\n", val
? _("default") :
15543 case Tag_ARC_ABI_exceptions
:
15544 READ_ULEB (val
, p
, end
);
15545 printf (" Tag_ARC_ABI_exceptions: %s\n", val
? _("OPTFP")
15549 case Tag_ARC_ABI_double_size
:
15550 READ_ULEB (val
, p
, end
);
15551 printf (" Tag_ARC_ABI_double_size: %d\n", val
);
15554 case Tag_ARC_ISA_config
:
15555 printf (" Tag_ARC_ISA_config: ");
15556 p
= display_tag_value (-1, p
, end
);
15559 case Tag_ARC_ISA_apex
:
15560 printf (" Tag_ARC_ISA_apex: ");
15561 p
= display_tag_value (-1, p
, end
);
15564 case Tag_ARC_ISA_mpy_option
:
15565 READ_ULEB (val
, p
, end
);
15566 printf (" Tag_ARC_ISA_mpy_option: %d\n", val
);
15569 case Tag_ARC_ATR_version
:
15570 READ_ULEB (val
, p
, end
);
15571 printf (" Tag_ARC_ATR_version: %d\n", val
);
15575 return display_tag_value (tag
& 1, p
, end
);
15581 /* ARM EABI attributes section. */
15586 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
15588 const char *const *table
;
15589 } arm_attr_public_tag
;
15591 static const char *const arm_attr_tag_CPU_arch
[] =
15592 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
15593 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
15594 "v8-M.mainline", "", "", "", "v8.1-M.mainline"};
15595 static const char *const arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
15596 static const char *const arm_attr_tag_THUMB_ISA_use
[] =
15597 {"No", "Thumb-1", "Thumb-2", "Yes"};
15598 static const char *const arm_attr_tag_FP_arch
[] =
15599 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
15600 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
15601 static const char *const arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
15602 static const char *const arm_attr_tag_Advanced_SIMD_arch
[] =
15603 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
15604 "NEON for ARMv8.1"};
15605 static const char *const arm_attr_tag_PCS_config
[] =
15606 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
15607 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
15608 static const char *const arm_attr_tag_ABI_PCS_R9_use
[] =
15609 {"V6", "SB", "TLS", "Unused"};
15610 static const char *const arm_attr_tag_ABI_PCS_RW_data
[] =
15611 {"Absolute", "PC-relative", "SB-relative", "None"};
15612 static const char *const arm_attr_tag_ABI_PCS_RO_data
[] =
15613 {"Absolute", "PC-relative", "None"};
15614 static const char *const arm_attr_tag_ABI_PCS_GOT_use
[] =
15615 {"None", "direct", "GOT-indirect"};
15616 static const char *const arm_attr_tag_ABI_PCS_wchar_t
[] =
15617 {"None", "??? 1", "2", "??? 3", "4"};
15618 static const char *const arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
15619 static const char *const arm_attr_tag_ABI_FP_denormal
[] =
15620 {"Unused", "Needed", "Sign only"};
15621 static const char *const arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
15622 static const char *const arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
15623 static const char *const arm_attr_tag_ABI_FP_number_model
[] =
15624 {"Unused", "Finite", "RTABI", "IEEE 754"};
15625 static const char *const arm_attr_tag_ABI_enum_size
[] =
15626 {"Unused", "small", "int", "forced to int"};
15627 static const char *const arm_attr_tag_ABI_HardFP_use
[] =
15628 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
15629 static const char *const arm_attr_tag_ABI_VFP_args
[] =
15630 {"AAPCS", "VFP registers", "custom", "compatible"};
15631 static const char *const arm_attr_tag_ABI_WMMX_args
[] =
15632 {"AAPCS", "WMMX registers", "custom"};
15633 static const char *const arm_attr_tag_ABI_optimization_goals
[] =
15634 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
15635 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
15636 static const char *const arm_attr_tag_ABI_FP_optimization_goals
[] =
15637 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
15638 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
15639 static const char *const arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
15640 static const char *const arm_attr_tag_FP_HP_extension
[] =
15641 {"Not Allowed", "Allowed"};
15642 static const char *const arm_attr_tag_ABI_FP_16bit_format
[] =
15643 {"None", "IEEE 754", "Alternative Format"};
15644 static const char *const arm_attr_tag_DSP_extension
[] =
15645 {"Follow architecture", "Allowed"};
15646 static const char *const arm_attr_tag_MPextension_use
[] =
15647 {"Not Allowed", "Allowed"};
15648 static const char *const arm_attr_tag_DIV_use
[] =
15649 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
15650 "Allowed in v7-A with integer division extension"};
15651 static const char *const arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
15652 static const char *const arm_attr_tag_Virtualization_use
[] =
15653 {"Not Allowed", "TrustZone", "Virtualization Extensions",
15654 "TrustZone and Virtualization Extensions"};
15655 static const char *const arm_attr_tag_MPextension_use_legacy
[] =
15656 {"Not Allowed", "Allowed"};
15658 static const char *const arm_attr_tag_MVE_arch
[] =
15659 {"No MVE", "MVE Integer only", "MVE Integer and FP"};
15661 #define LOOKUP(id, name) \
15662 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
15663 static arm_attr_public_tag arm_attr_public_tags
[] =
15665 {4, "CPU_raw_name", 1, NULL
},
15666 {5, "CPU_name", 1, NULL
},
15667 LOOKUP(6, CPU_arch
),
15668 {7, "CPU_arch_profile", 0, NULL
},
15669 LOOKUP(8, ARM_ISA_use
),
15670 LOOKUP(9, THUMB_ISA_use
),
15671 LOOKUP(10, FP_arch
),
15672 LOOKUP(11, WMMX_arch
),
15673 LOOKUP(12, Advanced_SIMD_arch
),
15674 LOOKUP(13, PCS_config
),
15675 LOOKUP(14, ABI_PCS_R9_use
),
15676 LOOKUP(15, ABI_PCS_RW_data
),
15677 LOOKUP(16, ABI_PCS_RO_data
),
15678 LOOKUP(17, ABI_PCS_GOT_use
),
15679 LOOKUP(18, ABI_PCS_wchar_t
),
15680 LOOKUP(19, ABI_FP_rounding
),
15681 LOOKUP(20, ABI_FP_denormal
),
15682 LOOKUP(21, ABI_FP_exceptions
),
15683 LOOKUP(22, ABI_FP_user_exceptions
),
15684 LOOKUP(23, ABI_FP_number_model
),
15685 {24, "ABI_align_needed", 0, NULL
},
15686 {25, "ABI_align_preserved", 0, NULL
},
15687 LOOKUP(26, ABI_enum_size
),
15688 LOOKUP(27, ABI_HardFP_use
),
15689 LOOKUP(28, ABI_VFP_args
),
15690 LOOKUP(29, ABI_WMMX_args
),
15691 LOOKUP(30, ABI_optimization_goals
),
15692 LOOKUP(31, ABI_FP_optimization_goals
),
15693 {32, "compatibility", 0, NULL
},
15694 LOOKUP(34, CPU_unaligned_access
),
15695 LOOKUP(36, FP_HP_extension
),
15696 LOOKUP(38, ABI_FP_16bit_format
),
15697 LOOKUP(42, MPextension_use
),
15698 LOOKUP(44, DIV_use
),
15699 LOOKUP(46, DSP_extension
),
15700 LOOKUP(48, MVE_arch
),
15701 {64, "nodefaults", 0, NULL
},
15702 {65, "also_compatible_with", 0, NULL
},
15703 LOOKUP(66, T2EE_use
),
15704 {67, "conformance", 1, NULL
},
15705 LOOKUP(68, Virtualization_use
),
15706 LOOKUP(70, MPextension_use_legacy
)
15710 static unsigned char *
15711 display_arm_attribute (unsigned char * p
,
15712 const unsigned char * const end
)
15716 arm_attr_public_tag
* attr
;
15720 READ_ULEB (tag
, p
, end
);
15722 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
15724 if (arm_attr_public_tags
[i
].tag
== tag
)
15726 attr
= &arm_attr_public_tags
[i
];
15733 printf (" Tag_%s: ", attr
->name
);
15734 switch (attr
->type
)
15739 case 7: /* Tag_CPU_arch_profile. */
15740 READ_ULEB (val
, p
, end
);
15743 case 0: printf (_("None\n")); break;
15744 case 'A': printf (_("Application\n")); break;
15745 case 'R': printf (_("Realtime\n")); break;
15746 case 'M': printf (_("Microcontroller\n")); break;
15747 case 'S': printf (_("Application or Realtime\n")); break;
15748 default: printf ("??? (%d)\n", val
); break;
15752 case 24: /* Tag_align_needed. */
15753 READ_ULEB (val
, p
, end
);
15756 case 0: printf (_("None\n")); break;
15757 case 1: printf (_("8-byte\n")); break;
15758 case 2: printf (_("4-byte\n")); break;
15759 case 3: printf ("??? 3\n"); break;
15762 printf (_("8-byte and up to %d-byte extended\n"),
15765 printf ("??? (%d)\n", val
);
15770 case 25: /* Tag_align_preserved. */
15771 READ_ULEB (val
, p
, end
);
15774 case 0: printf (_("None\n")); break;
15775 case 1: printf (_("8-byte, except leaf SP\n")); break;
15776 case 2: printf (_("8-byte\n")); break;
15777 case 3: printf ("??? 3\n"); break;
15780 printf (_("8-byte and up to %d-byte extended\n"),
15783 printf ("??? (%d)\n", val
);
15788 case 32: /* Tag_compatibility. */
15790 READ_ULEB (val
, p
, end
);
15791 printf (_("flag = %d, vendor = "), val
);
15794 size_t maxlen
= (end
- p
) - 1;
15796 print_symbol ((int) maxlen
, (const char *) p
);
15797 p
+= strnlen ((char *) p
, maxlen
) + 1;
15801 printf (_("<corrupt>"));
15802 p
= (unsigned char *) end
;
15808 case 64: /* Tag_nodefaults. */
15809 /* PR 17531: file: 001-505008-0.01. */
15812 printf (_("True\n"));
15815 case 65: /* Tag_also_compatible_with. */
15816 READ_ULEB (val
, p
, end
);
15817 if (val
== 6 /* Tag_CPU_arch. */)
15819 READ_ULEB (val
, p
, end
);
15820 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
15821 printf ("??? (%d)\n", val
);
15823 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
15827 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
15832 printf (_("<unknown: %d>\n"), tag
);
15838 return display_tag_value (-1, p
, end
);
15840 return display_tag_value (0, p
, end
);
15843 assert (attr
->type
& 0x80);
15844 READ_ULEB (val
, p
, end
);
15845 type
= attr
->type
& 0x7f;
15847 printf ("??? (%d)\n", val
);
15849 printf ("%s\n", attr
->table
[val
]);
15854 return display_tag_value (tag
, p
, end
);
15857 static unsigned char *
15858 display_gnu_attribute (unsigned char * p
,
15859 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const),
15860 const unsigned char * const end
)
15865 READ_ULEB (tag
, p
, end
);
15867 /* Tag_compatibility is the only generic GNU attribute defined at
15871 READ_ULEB (val
, p
, end
);
15873 printf (_("flag = %d, vendor = "), val
);
15876 printf (_("<corrupt>\n"));
15877 warn (_("corrupt vendor attribute\n"));
15883 size_t maxlen
= (end
- p
) - 1;
15885 print_symbol ((int) maxlen
, (const char *) p
);
15886 p
+= strnlen ((char *) p
, maxlen
) + 1;
15890 printf (_("<corrupt>"));
15891 p
= (unsigned char *) end
;
15898 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
15899 return display_proc_gnu_attribute (p
, tag
, end
);
15901 return display_tag_value (tag
, p
, end
);
15904 static unsigned char *
15905 display_m68k_gnu_attribute (unsigned char * p
,
15907 const unsigned char * const end
)
15911 if (tag
== Tag_GNU_M68K_ABI_FP
)
15913 printf (" Tag_GNU_M68K_ABI_FP: ");
15916 printf (_("<corrupt>\n"));
15919 READ_ULEB (val
, p
, end
);
15922 printf ("(%#x), ", val
);
15927 printf (_("unspecified hard/soft float\n"));
15930 printf (_("hard float\n"));
15933 printf (_("soft float\n"));
15939 return display_tag_value (tag
& 1, p
, end
);
15942 static unsigned char *
15943 display_power_gnu_attribute (unsigned char * p
,
15945 const unsigned char * const end
)
15949 if (tag
== Tag_GNU_Power_ABI_FP
)
15951 printf (" Tag_GNU_Power_ABI_FP: ");
15954 printf (_("<corrupt>\n"));
15957 READ_ULEB (val
, p
, end
);
15960 printf ("(%#x), ", val
);
15965 printf (_("unspecified hard/soft float, "));
15968 printf (_("hard float, "));
15971 printf (_("soft float, "));
15974 printf (_("single-precision hard float, "));
15981 printf (_("unspecified long double\n"));
15984 printf (_("128-bit IBM long double\n"));
15987 printf (_("64-bit long double\n"));
15990 printf (_("128-bit IEEE long double\n"));
15996 if (tag
== Tag_GNU_Power_ABI_Vector
)
15998 printf (" Tag_GNU_Power_ABI_Vector: ");
16001 printf (_("<corrupt>\n"));
16004 READ_ULEB (val
, p
, end
);
16007 printf ("(%#x), ", val
);
16012 printf (_("unspecified\n"));
16015 printf (_("generic\n"));
16018 printf ("AltiVec\n");
16027 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
16029 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
16032 printf (_("<corrupt>\n"));
16035 READ_ULEB (val
, p
, end
);
16038 printf ("(%#x), ", val
);
16043 printf (_("unspecified\n"));
16046 printf ("r3/r4\n");
16049 printf (_("memory\n"));
16058 return display_tag_value (tag
& 1, p
, end
);
16061 static unsigned char *
16062 display_s390_gnu_attribute (unsigned char * p
,
16064 const unsigned char * const end
)
16068 if (tag
== Tag_GNU_S390_ABI_Vector
)
16070 printf (" Tag_GNU_S390_ABI_Vector: ");
16071 READ_ULEB (val
, p
, end
);
16076 printf (_("any\n"));
16079 printf (_("software\n"));
16082 printf (_("hardware\n"));
16085 printf ("??? (%d)\n", val
);
16091 return display_tag_value (tag
& 1, p
, end
);
16095 display_sparc_hwcaps (unsigned int mask
)
16099 bfd_boolean first
= TRUE
;
16101 if (mask
& ELF_SPARC_HWCAP_MUL32
)
16102 fputs ("mul32", stdout
), first
= FALSE
;
16103 if (mask
& ELF_SPARC_HWCAP_DIV32
)
16104 printf ("%sdiv32", first
? "" : "|"), first
= FALSE
;
16105 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
16106 printf ("%sfsmuld", first
? "" : "|"), first
= FALSE
;
16107 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
16108 printf ("%sv8plus", first
? "" : "|"), first
= FALSE
;
16109 if (mask
& ELF_SPARC_HWCAP_POPC
)
16110 printf ("%spopc", first
? "" : "|"), first
= FALSE
;
16111 if (mask
& ELF_SPARC_HWCAP_VIS
)
16112 printf ("%svis", first
? "" : "|"), first
= FALSE
;
16113 if (mask
& ELF_SPARC_HWCAP_VIS2
)
16114 printf ("%svis2", first
? "" : "|"), first
= FALSE
;
16115 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
16116 printf ("%sASIBlkInit", first
? "" : "|"), first
= FALSE
;
16117 if (mask
& ELF_SPARC_HWCAP_FMAF
)
16118 printf ("%sfmaf", first
? "" : "|"), first
= FALSE
;
16119 if (mask
& ELF_SPARC_HWCAP_VIS3
)
16120 printf ("%svis3", first
? "" : "|"), first
= FALSE
;
16121 if (mask
& ELF_SPARC_HWCAP_HPC
)
16122 printf ("%shpc", first
? "" : "|"), first
= FALSE
;
16123 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
16124 printf ("%srandom", first
? "" : "|"), first
= FALSE
;
16125 if (mask
& ELF_SPARC_HWCAP_TRANS
)
16126 printf ("%strans", first
? "" : "|"), first
= FALSE
;
16127 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
16128 printf ("%sfjfmau", first
? "" : "|"), first
= FALSE
;
16129 if (mask
& ELF_SPARC_HWCAP_IMA
)
16130 printf ("%sima", first
? "" : "|"), first
= FALSE
;
16131 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
16132 printf ("%scspare", first
? "" : "|"), first
= FALSE
;
16135 fputc ('0', stdout
);
16136 fputc ('\n', stdout
);
16140 display_sparc_hwcaps2 (unsigned int mask
)
16144 bfd_boolean first
= TRUE
;
16146 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
16147 fputs ("fjathplus", stdout
), first
= FALSE
;
16148 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
16149 printf ("%svis3b", first
? "" : "|"), first
= FALSE
;
16150 if (mask
& ELF_SPARC_HWCAP2_ADP
)
16151 printf ("%sadp", first
? "" : "|"), first
= FALSE
;
16152 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
16153 printf ("%ssparc5", first
? "" : "|"), first
= FALSE
;
16154 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
16155 printf ("%smwait", first
? "" : "|"), first
= FALSE
;
16156 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
16157 printf ("%sxmpmul", first
? "" : "|"), first
= FALSE
;
16158 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
16159 printf ("%sxmont2", first
? "" : "|"), first
= FALSE
;
16160 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
16161 printf ("%snsec", first
? "" : "|"), first
= FALSE
;
16162 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
16163 printf ("%sfjathhpc", first
? "" : "|"), first
= FALSE
;
16164 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
16165 printf ("%sfjdes", first
? "" : "|"), first
= FALSE
;
16166 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
16167 printf ("%sfjaes", first
? "" : "|"), first
= FALSE
;
16170 fputc ('0', stdout
);
16171 fputc ('\n', stdout
);
16174 static unsigned char *
16175 display_sparc_gnu_attribute (unsigned char * p
,
16177 const unsigned char * const end
)
16181 if (tag
== Tag_GNU_Sparc_HWCAPS
)
16183 READ_ULEB (val
, p
, end
);
16184 printf (" Tag_GNU_Sparc_HWCAPS: ");
16185 display_sparc_hwcaps (val
);
16188 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
16190 READ_ULEB (val
, p
, end
);
16191 printf (" Tag_GNU_Sparc_HWCAPS2: ");
16192 display_sparc_hwcaps2 (val
);
16196 return display_tag_value (tag
, p
, end
);
16200 print_mips_fp_abi_value (unsigned int val
)
16204 case Val_GNU_MIPS_ABI_FP_ANY
:
16205 printf (_("Hard or soft float\n"));
16207 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
16208 printf (_("Hard float (double precision)\n"));
16210 case Val_GNU_MIPS_ABI_FP_SINGLE
:
16211 printf (_("Hard float (single precision)\n"));
16213 case Val_GNU_MIPS_ABI_FP_SOFT
:
16214 printf (_("Soft float\n"));
16216 case Val_GNU_MIPS_ABI_FP_OLD_64
:
16217 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
16219 case Val_GNU_MIPS_ABI_FP_XX
:
16220 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
16222 case Val_GNU_MIPS_ABI_FP_64
:
16223 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
16225 case Val_GNU_MIPS_ABI_FP_64A
:
16226 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
16228 case Val_GNU_MIPS_ABI_FP_NAN2008
:
16229 printf (_("NaN 2008 compatibility\n"));
16232 printf ("??? (%d)\n", val
);
16237 static unsigned char *
16238 display_mips_gnu_attribute (unsigned char * p
,
16240 const unsigned char * const end
)
16242 if (tag
== Tag_GNU_MIPS_ABI_FP
)
16246 printf (" Tag_GNU_MIPS_ABI_FP: ");
16247 READ_ULEB (val
, p
, end
);
16248 print_mips_fp_abi_value (val
);
16252 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
16256 printf (" Tag_GNU_MIPS_ABI_MSA: ");
16257 READ_ULEB (val
, p
, end
);
16261 case Val_GNU_MIPS_ABI_MSA_ANY
:
16262 printf (_("Any MSA or not\n"));
16264 case Val_GNU_MIPS_ABI_MSA_128
:
16265 printf (_("128-bit MSA\n"));
16268 printf ("??? (%d)\n", val
);
16274 return display_tag_value (tag
& 1, p
, end
);
16277 static unsigned char *
16278 display_tic6x_attribute (unsigned char * p
,
16279 const unsigned char * const end
)
16284 READ_ULEB (tag
, p
, end
);
16289 printf (" Tag_ISA: ");
16290 READ_ULEB (val
, p
, end
);
16294 case C6XABI_Tag_ISA_none
:
16295 printf (_("None\n"));
16297 case C6XABI_Tag_ISA_C62X
:
16300 case C6XABI_Tag_ISA_C67X
:
16303 case C6XABI_Tag_ISA_C67XP
:
16304 printf ("C67x+\n");
16306 case C6XABI_Tag_ISA_C64X
:
16309 case C6XABI_Tag_ISA_C64XP
:
16310 printf ("C64x+\n");
16312 case C6XABI_Tag_ISA_C674X
:
16313 printf ("C674x\n");
16316 printf ("??? (%d)\n", val
);
16321 case Tag_ABI_wchar_t
:
16322 printf (" Tag_ABI_wchar_t: ");
16323 READ_ULEB (val
, p
, end
);
16327 printf (_("Not used\n"));
16330 printf (_("2 bytes\n"));
16333 printf (_("4 bytes\n"));
16336 printf ("??? (%d)\n", val
);
16341 case Tag_ABI_stack_align_needed
:
16342 printf (" Tag_ABI_stack_align_needed: ");
16343 READ_ULEB (val
, p
, end
);
16347 printf (_("8-byte\n"));
16350 printf (_("16-byte\n"));
16353 printf ("??? (%d)\n", val
);
16358 case Tag_ABI_stack_align_preserved
:
16359 READ_ULEB (val
, p
, end
);
16360 printf (" Tag_ABI_stack_align_preserved: ");
16364 printf (_("8-byte\n"));
16367 printf (_("16-byte\n"));
16370 printf ("??? (%d)\n", val
);
16376 READ_ULEB (val
, p
, end
);
16377 printf (" Tag_ABI_DSBT: ");
16381 printf (_("DSBT addressing not used\n"));
16384 printf (_("DSBT addressing used\n"));
16387 printf ("??? (%d)\n", val
);
16393 READ_ULEB (val
, p
, end
);
16394 printf (" Tag_ABI_PID: ");
16398 printf (_("Data addressing position-dependent\n"));
16401 printf (_("Data addressing position-independent, GOT near DP\n"));
16404 printf (_("Data addressing position-independent, GOT far from DP\n"));
16407 printf ("??? (%d)\n", val
);
16413 READ_ULEB (val
, p
, end
);
16414 printf (" Tag_ABI_PIC: ");
16418 printf (_("Code addressing position-dependent\n"));
16421 printf (_("Code addressing position-independent\n"));
16424 printf ("??? (%d)\n", val
);
16429 case Tag_ABI_array_object_alignment
:
16430 READ_ULEB (val
, p
, end
);
16431 printf (" Tag_ABI_array_object_alignment: ");
16435 printf (_("8-byte\n"));
16438 printf (_("4-byte\n"));
16441 printf (_("16-byte\n"));
16444 printf ("??? (%d)\n", val
);
16449 case Tag_ABI_array_object_align_expected
:
16450 READ_ULEB (val
, p
, end
);
16451 printf (" Tag_ABI_array_object_align_expected: ");
16455 printf (_("8-byte\n"));
16458 printf (_("4-byte\n"));
16461 printf (_("16-byte\n"));
16464 printf ("??? (%d)\n", val
);
16469 case Tag_ABI_compatibility
:
16471 READ_ULEB (val
, p
, end
);
16472 printf (" Tag_ABI_compatibility: ");
16473 printf (_("flag = %d, vendor = "), val
);
16476 size_t maxlen
= (end
- p
) - 1;
16478 print_symbol ((int) maxlen
, (const char *) p
);
16479 p
+= strnlen ((char *) p
, maxlen
) + 1;
16483 printf (_("<corrupt>"));
16484 p
= (unsigned char *) end
;
16490 case Tag_ABI_conformance
:
16492 printf (" Tag_ABI_conformance: \"");
16495 size_t maxlen
= (end
- p
) - 1;
16497 print_symbol ((int) maxlen
, (const char *) p
);
16498 p
+= strnlen ((char *) p
, maxlen
) + 1;
16502 printf (_("<corrupt>"));
16503 p
= (unsigned char *) end
;
16510 return display_tag_value (tag
, p
, end
);
16514 display_raw_attribute (unsigned char * p
, unsigned char const * const end
)
16516 unsigned long addr
= 0;
16517 size_t bytes
= end
- p
;
16524 int lbytes
= (bytes
> 16 ? 16 : bytes
);
16526 printf (" 0x%8.8lx ", addr
);
16528 for (j
= 0; j
< 16; j
++)
16531 printf ("%2.2x", p
[j
]);
16539 for (j
= 0; j
< lbytes
; j
++)
16542 if (k
>= ' ' && k
< 0x7f)
16558 static unsigned char *
16559 display_msp430_attribute (unsigned char * p
,
16560 const unsigned char * const end
)
16565 READ_ULEB (tag
, p
, end
);
16569 case OFBA_MSPABI_Tag_ISA
:
16570 printf (" Tag_ISA: ");
16571 READ_ULEB (val
, p
, end
);
16574 case 0: printf (_("None\n")); break;
16575 case 1: printf (_("MSP430\n")); break;
16576 case 2: printf (_("MSP430X\n")); break;
16577 default: printf ("??? (%d)\n", val
); break;
16581 case OFBA_MSPABI_Tag_Code_Model
:
16582 printf (" Tag_Code_Model: ");
16583 READ_ULEB (val
, p
, end
);
16586 case 0: printf (_("None\n")); break;
16587 case 1: printf (_("Small\n")); break;
16588 case 2: printf (_("Large\n")); break;
16589 default: printf ("??? (%d)\n", val
); break;
16593 case OFBA_MSPABI_Tag_Data_Model
:
16594 printf (" Tag_Data_Model: ");
16595 READ_ULEB (val
, p
, end
);
16598 case 0: printf (_("None\n")); break;
16599 case 1: printf (_("Small\n")); break;
16600 case 2: printf (_("Large\n")); break;
16601 case 3: printf (_("Restricted Large\n")); break;
16602 default: printf ("??? (%d)\n", val
); break;
16607 printf (_(" <unknown tag %d>: "), tag
);
16614 size_t maxlen
= (end
- p
) - 1;
16616 print_symbol ((int) maxlen
, (const char *) p
);
16617 p
+= strnlen ((char *) p
, maxlen
) + 1;
16621 printf (_("<corrupt>"));
16622 p
= (unsigned char *) end
;
16628 READ_ULEB (val
, p
, end
);
16629 printf ("%d (0x%x)\n", val
, val
);
16638 static unsigned char *
16639 display_msp430_gnu_attribute (unsigned char * p
,
16641 const unsigned char * const end
)
16643 if (tag
== Tag_GNU_MSP430_Data_Region
)
16647 printf (" Tag_GNU_MSP430_Data_Region: ");
16648 READ_ULEB (val
, p
, end
);
16652 case Val_GNU_MSP430_Data_Region_Any
:
16653 printf (_("Any Region\n"));
16655 case Val_GNU_MSP430_Data_Region_Lower
:
16656 printf (_("Lower Region Only\n"));
16659 printf ("??? (%u)\n", val
);
16663 return display_tag_value (tag
& 1, p
, end
);
16666 struct riscv_attr_tag_t
{
16671 static struct riscv_attr_tag_t riscv_attr_tag
[] =
16673 #define T(tag) {"Tag_RISCV_" #tag, Tag_RISCV_##tag}
16676 T(priv_spec_minor
),
16677 T(priv_spec_revision
),
16678 T(unaligned_access
),
16683 static unsigned char *
16684 display_riscv_attribute (unsigned char *p
,
16685 const unsigned char * const end
)
16689 struct riscv_attr_tag_t
*attr
= NULL
;
16692 READ_ULEB (tag
, p
, end
);
16694 /* Find the name of attribute. */
16695 for (i
= 0; i
< ARRAY_SIZE (riscv_attr_tag
); i
++)
16697 if (riscv_attr_tag
[i
].tag
== tag
)
16699 attr
= &riscv_attr_tag
[i
];
16705 printf (" %s: ", attr
->name
);
16707 return display_tag_value (tag
, p
, end
);
16711 case Tag_RISCV_priv_spec
:
16712 case Tag_RISCV_priv_spec_minor
:
16713 case Tag_RISCV_priv_spec_revision
:
16714 READ_ULEB (val
, p
, end
);
16715 printf (_("%u\n"), val
);
16717 case Tag_RISCV_unaligned_access
:
16718 READ_ULEB (val
, p
, end
);
16722 printf (_("No unaligned access\n"));
16725 printf (_("Unaligned access\n"));
16729 case Tag_RISCV_stack_align
:
16730 READ_ULEB (val
, p
, end
);
16731 printf (_("%u-bytes\n"), val
);
16733 case Tag_RISCV_arch
:
16734 p
= display_tag_value (-1, p
, end
);
16737 return display_tag_value (tag
, p
, end
);
16743 static unsigned char *
16744 display_csky_attribute (unsigned char * p
,
16745 const unsigned char * const end
)
16749 READ_ULEB (tag
, p
, end
);
16751 if (tag
>= Tag_CSKY_MAX
)
16753 return display_tag_value (-1, p
, end
);
16758 case Tag_CSKY_ARCH_NAME
:
16759 printf (" Tag_CSKY_ARCH_NAME:\t\t");
16760 return display_tag_value (-1, p
, end
);
16761 case Tag_CSKY_CPU_NAME
:
16762 printf (" Tag_CSKY_CPU_NAME:\t\t");
16763 return display_tag_value (-1, p
, end
);
16765 case Tag_CSKY_ISA_FLAGS
:
16766 printf (" Tag_CSKY_ISA_FLAGS:\t\t");
16767 return display_tag_value (0, p
, end
);
16768 case Tag_CSKY_ISA_EXT_FLAGS
:
16769 printf (" Tag_CSKY_ISA_EXT_FLAGS:\t");
16770 return display_tag_value (0, p
, end
);
16772 case Tag_CSKY_DSP_VERSION
:
16773 printf (" Tag_CSKY_DSP_VERSION:\t\t");
16774 READ_ULEB (val
, p
, end
);
16775 if (val
== VAL_CSKY_DSP_VERSION_EXTENSION
)
16776 printf ("DSP Extension\n");
16777 else if (val
== VAL_CSKY_DSP_VERSION_2
)
16778 printf ("DSP 2.0\n");
16781 case Tag_CSKY_VDSP_VERSION
:
16782 printf (" Tag_CSKY_VDSP_VERSION:\t");
16783 READ_ULEB (val
, p
, end
);
16784 printf ("VDSP Version %d\n", val
);
16787 case Tag_CSKY_FPU_VERSION
:
16788 printf (" Tag_CSKY_FPU_VERSION:\t\t");
16789 READ_ULEB (val
, p
, end
);
16790 if (val
== VAL_CSKY_FPU_VERSION_1
)
16791 printf ("ABIV1 FPU Version 1\n");
16792 else if (val
== VAL_CSKY_FPU_VERSION_2
)
16793 printf ("FPU Version 2\n");
16796 case Tag_CSKY_FPU_ABI
:
16797 printf (" Tag_CSKY_FPU_ABI:\t\t");
16798 READ_ULEB (val
, p
, end
);
16799 if (val
== VAL_CSKY_FPU_ABI_HARD
)
16801 else if (val
== VAL_CSKY_FPU_ABI_SOFTFP
)
16802 printf ("SoftFP\n");
16803 else if (val
== VAL_CSKY_FPU_ABI_SOFT
)
16806 case Tag_CSKY_FPU_ROUNDING
:
16807 READ_ULEB (val
, p
, end
);
16809 printf (" Tag_CSKY_FPU_ROUNDING:\t");
16810 printf ("Needed\n");
16813 case Tag_CSKY_FPU_DENORMAL
:
16814 READ_ULEB (val
, p
, end
);
16816 printf (" Tag_CSKY_FPU_DENORMAL:\t");
16817 printf ("Needed\n");
16820 case Tag_CSKY_FPU_Exception
:
16821 READ_ULEB (val
, p
, end
);
16823 printf (" Tag_CSKY_FPU_Exception:\t");
16824 printf ("Needed\n");
16827 case Tag_CSKY_FPU_NUMBER_MODULE
:
16828 printf (" Tag_CSKY_FPU_NUMBER_MODULE:\t");
16829 return display_tag_value (-1, p
, end
);
16830 case Tag_CSKY_FPU_HARDFP
:
16831 printf (" Tag_CSKY_FPU_HARDFP:\t\t");
16832 READ_ULEB (val
, p
, end
);
16833 if (val
& VAL_CSKY_FPU_HARDFP_HALF
)
16835 if (val
& VAL_CSKY_FPU_HARDFP_SINGLE
)
16836 printf (" Single");
16837 if (val
& VAL_CSKY_FPU_HARDFP_DOUBLE
)
16838 printf (" Double");
16842 return display_tag_value (tag
, p
, end
);
16848 process_attributes (Filedata
* filedata
,
16849 const char * public_name
,
16850 unsigned int proc_type
,
16851 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
16852 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const))
16854 Elf_Internal_Shdr
* sect
;
16856 bfd_boolean res
= TRUE
;
16858 /* Find the section header so that we get the size. */
16859 for (i
= 0, sect
= filedata
->section_headers
;
16860 i
< filedata
->file_header
.e_shnum
;
16863 unsigned char * contents
;
16866 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
16869 contents
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
, 1,
16870 sect
->sh_size
, _("attributes"));
16871 if (contents
== NULL
)
16878 /* The first character is the version of the attributes.
16879 Currently only version 1, (aka 'A') is recognised here. */
16882 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p
, *p
);
16887 bfd_vma section_len
;
16889 section_len
= sect
->sh_size
- 1;
16892 while (section_len
> 0)
16895 unsigned int namelen
;
16896 bfd_boolean public_section
;
16897 bfd_boolean gnu_section
;
16899 if (section_len
<= 4)
16901 error (_("Tag section ends prematurely\n"));
16905 attr_len
= byte_get (p
, 4);
16908 if (attr_len
> section_len
)
16910 error (_("Bad attribute length (%u > %u)\n"),
16911 (unsigned) attr_len
, (unsigned) section_len
);
16912 attr_len
= section_len
;
16915 /* PR 17531: file: 001-101425-0.004 */
16916 else if (attr_len
< 5)
16918 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
16923 section_len
-= attr_len
;
16926 namelen
= strnlen ((char *) p
, attr_len
) + 1;
16927 if (namelen
== 0 || namelen
>= attr_len
)
16929 error (_("Corrupt attribute section name\n"));
16934 printf (_("Attribute Section: "));
16935 print_symbol (INT_MAX
, (const char *) p
);
16938 if (public_name
&& streq ((char *) p
, public_name
))
16939 public_section
= TRUE
;
16941 public_section
= FALSE
;
16943 if (streq ((char *) p
, "gnu"))
16944 gnu_section
= TRUE
;
16946 gnu_section
= FALSE
;
16949 attr_len
-= namelen
;
16951 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
16956 unsigned char * end
;
16958 /* PR binutils/17531: Safe handling of corrupt files. */
16961 error (_("Unused bytes at end of section\n"));
16968 size
= byte_get (p
, 4);
16969 if (size
> attr_len
)
16971 error (_("Bad subsection length (%u > %u)\n"),
16972 (unsigned) size
, (unsigned) attr_len
);
16976 /* PR binutils/17531: Safe handling of corrupt files. */
16979 error (_("Bad subsection length (%u < 6)\n"),
16987 end
= p
+ size
- 1;
16988 assert (end
<= contents
+ sect
->sh_size
);
16994 printf (_("File Attributes\n"));
16997 printf (_("Section Attributes:"));
17000 printf (_("Symbol Attributes:"));
17001 /* Fall through. */
17005 READ_ULEB (val
, p
, end
);
17008 printf (" %d", val
);
17013 printf (_("Unknown tag: %d\n"), tag
);
17014 public_section
= FALSE
;
17018 if (public_section
&& display_pub_attribute
!= NULL
)
17021 p
= display_pub_attribute (p
, end
);
17024 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
17027 p
= display_gnu_attribute (p
,
17028 display_proc_gnu_attribute
,
17034 printf (_(" Unknown attribute:\n"));
17035 display_raw_attribute (p
, end
);
17050 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
17051 Print the Address, Access and Initial fields of an entry at VMA ADDR
17052 and return the VMA of the next entry, or -1 if there was a problem.
17053 Does not read from DATA_END or beyond. */
17056 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
17057 unsigned char * data_end
)
17060 print_vma (addr
, LONG_HEX
);
17062 if (addr
< pltgot
+ 0xfff0)
17063 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
17065 printf ("%10s", "");
17068 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
17072 unsigned char * from
= data
+ addr
- pltgot
;
17074 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
17076 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
17077 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
17078 return (bfd_vma
) -1;
17082 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
17083 print_vma (entry
, LONG_HEX
);
17086 return addr
+ (is_32bit_elf
? 4 : 8);
17089 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
17090 PLTGOT. Print the Address and Initial fields of an entry at VMA
17091 ADDR and return the VMA of the next entry. */
17094 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
17097 print_vma (addr
, LONG_HEX
);
17100 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
17105 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
17106 print_vma (entry
, LONG_HEX
);
17108 return addr
+ (is_32bit_elf
? 4 : 8);
17112 print_mips_ases (unsigned int mask
)
17114 if (mask
& AFL_ASE_DSP
)
17115 fputs ("\n\tDSP ASE", stdout
);
17116 if (mask
& AFL_ASE_DSPR2
)
17117 fputs ("\n\tDSP R2 ASE", stdout
);
17118 if (mask
& AFL_ASE_DSPR3
)
17119 fputs ("\n\tDSP R3 ASE", stdout
);
17120 if (mask
& AFL_ASE_EVA
)
17121 fputs ("\n\tEnhanced VA Scheme", stdout
);
17122 if (mask
& AFL_ASE_MCU
)
17123 fputs ("\n\tMCU (MicroController) ASE", stdout
);
17124 if (mask
& AFL_ASE_MDMX
)
17125 fputs ("\n\tMDMX ASE", stdout
);
17126 if (mask
& AFL_ASE_MIPS3D
)
17127 fputs ("\n\tMIPS-3D ASE", stdout
);
17128 if (mask
& AFL_ASE_MT
)
17129 fputs ("\n\tMT ASE", stdout
);
17130 if (mask
& AFL_ASE_SMARTMIPS
)
17131 fputs ("\n\tSmartMIPS ASE", stdout
);
17132 if (mask
& AFL_ASE_VIRT
)
17133 fputs ("\n\tVZ ASE", stdout
);
17134 if (mask
& AFL_ASE_MSA
)
17135 fputs ("\n\tMSA ASE", stdout
);
17136 if (mask
& AFL_ASE_MIPS16
)
17137 fputs ("\n\tMIPS16 ASE", stdout
);
17138 if (mask
& AFL_ASE_MICROMIPS
)
17139 fputs ("\n\tMICROMIPS ASE", stdout
);
17140 if (mask
& AFL_ASE_XPA
)
17141 fputs ("\n\tXPA ASE", stdout
);
17142 if (mask
& AFL_ASE_MIPS16E2
)
17143 fputs ("\n\tMIPS16e2 ASE", stdout
);
17144 if (mask
& AFL_ASE_CRC
)
17145 fputs ("\n\tCRC ASE", stdout
);
17146 if (mask
& AFL_ASE_GINV
)
17147 fputs ("\n\tGINV ASE", stdout
);
17148 if (mask
& AFL_ASE_LOONGSON_MMI
)
17149 fputs ("\n\tLoongson MMI ASE", stdout
);
17150 if (mask
& AFL_ASE_LOONGSON_CAM
)
17151 fputs ("\n\tLoongson CAM ASE", stdout
);
17152 if (mask
& AFL_ASE_LOONGSON_EXT
)
17153 fputs ("\n\tLoongson EXT ASE", stdout
);
17154 if (mask
& AFL_ASE_LOONGSON_EXT2
)
17155 fputs ("\n\tLoongson EXT2 ASE", stdout
);
17157 fprintf (stdout
, "\n\t%s", _("None"));
17158 else if ((mask
& ~AFL_ASE_MASK
) != 0)
17159 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
17163 print_mips_isa_ext (unsigned int isa_ext
)
17168 fputs (_("None"), stdout
);
17171 fputs ("RMI XLR", stdout
);
17173 case AFL_EXT_OCTEON3
:
17174 fputs ("Cavium Networks Octeon3", stdout
);
17176 case AFL_EXT_OCTEON2
:
17177 fputs ("Cavium Networks Octeon2", stdout
);
17179 case AFL_EXT_OCTEONP
:
17180 fputs ("Cavium Networks OcteonP", stdout
);
17182 case AFL_EXT_OCTEON
:
17183 fputs ("Cavium Networks Octeon", stdout
);
17186 fputs ("Toshiba R5900", stdout
);
17189 fputs ("MIPS R4650", stdout
);
17192 fputs ("LSI R4010", stdout
);
17195 fputs ("NEC VR4100", stdout
);
17198 fputs ("Toshiba R3900", stdout
);
17200 case AFL_EXT_10000
:
17201 fputs ("MIPS R10000", stdout
);
17204 fputs ("Broadcom SB-1", stdout
);
17207 fputs ("NEC VR4111/VR4181", stdout
);
17210 fputs ("NEC VR4120", stdout
);
17213 fputs ("NEC VR5400", stdout
);
17216 fputs ("NEC VR5500", stdout
);
17218 case AFL_EXT_LOONGSON_2E
:
17219 fputs ("ST Microelectronics Loongson 2E", stdout
);
17221 case AFL_EXT_LOONGSON_2F
:
17222 fputs ("ST Microelectronics Loongson 2F", stdout
);
17224 case AFL_EXT_INTERAPTIV_MR2
:
17225 fputs ("Imagination interAptiv MR2", stdout
);
17228 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
17233 get_mips_reg_size (int reg_size
)
17235 return (reg_size
== AFL_REG_NONE
) ? 0
17236 : (reg_size
== AFL_REG_32
) ? 32
17237 : (reg_size
== AFL_REG_64
) ? 64
17238 : (reg_size
== AFL_REG_128
) ? 128
17243 process_mips_specific (Filedata
* filedata
)
17245 Elf_Internal_Dyn
* entry
;
17246 Elf_Internal_Shdr
*sect
= NULL
;
17247 size_t liblist_offset
= 0;
17248 size_t liblistno
= 0;
17249 size_t conflictsno
= 0;
17250 size_t options_offset
= 0;
17251 size_t conflicts_offset
= 0;
17252 size_t pltrelsz
= 0;
17254 bfd_vma pltgot
= 0;
17255 bfd_vma mips_pltgot
= 0;
17256 bfd_vma jmprel
= 0;
17257 bfd_vma local_gotno
= 0;
17258 bfd_vma gotsym
= 0;
17259 bfd_vma symtabno
= 0;
17260 bfd_boolean res
= TRUE
;
17262 if (! process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
17263 display_mips_gnu_attribute
))
17266 sect
= find_section (filedata
, ".MIPS.abiflags");
17270 Elf_External_ABIFlags_v0
*abiflags_ext
;
17271 Elf_Internal_ABIFlags_v0 abiflags_in
;
17273 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
17275 error (_("Corrupt MIPS ABI Flags section.\n"));
17280 abiflags_ext
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
17281 sect
->sh_size
, _("MIPS ABI Flags section"));
17284 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
17285 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
17286 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
17287 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
17288 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
17289 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
17290 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
17291 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
17292 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
17293 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
17294 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
17296 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
17297 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
17298 if (abiflags_in
.isa_rev
> 1)
17299 printf ("r%d", abiflags_in
.isa_rev
);
17300 printf ("\nGPR size: %d",
17301 get_mips_reg_size (abiflags_in
.gpr_size
));
17302 printf ("\nCPR1 size: %d",
17303 get_mips_reg_size (abiflags_in
.cpr1_size
));
17304 printf ("\nCPR2 size: %d",
17305 get_mips_reg_size (abiflags_in
.cpr2_size
));
17306 fputs ("\nFP ABI: ", stdout
);
17307 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
17308 fputs ("ISA Extension: ", stdout
);
17309 print_mips_isa_ext (abiflags_in
.isa_ext
);
17310 fputs ("\nASEs:", stdout
);
17311 print_mips_ases (abiflags_in
.ases
);
17312 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
17313 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
17314 fputc ('\n', stdout
);
17315 free (abiflags_ext
);
17320 /* We have a lot of special sections. Thanks SGI! */
17321 if (filedata
->dynamic_section
== NULL
)
17323 /* No dynamic information available. See if there is static GOT. */
17324 sect
= find_section (filedata
, ".got");
17327 unsigned char *data_end
;
17328 unsigned char *data
;
17332 pltgot
= sect
->sh_addr
;
17335 addr_size
= (is_32bit_elf
? 4 : 8);
17336 end
= pltgot
+ sect
->sh_size
;
17338 data
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
,
17340 _("Global Offset Table data"));
17341 /* PR 12855: Null data is handled gracefully throughout. */
17342 data_end
= data
+ (end
- pltgot
);
17344 printf (_("\nStatic GOT:\n"));
17345 printf (_(" Canonical gp value: "));
17346 print_vma (ent
+ 0x7ff0, LONG_HEX
);
17349 /* In a dynamic binary GOT[0] is reserved for the dynamic
17350 loader to store the lazy resolver pointer, however in
17351 a static binary it may well have been omitted and GOT
17352 reduced to a table of addresses.
17353 PR 21344: Check for the entry being fully available
17354 before fetching it. */
17356 && data
+ ent
- pltgot
+ addr_size
<= data_end
17357 && byte_get (data
+ ent
- pltgot
, addr_size
) == 0)
17359 printf (_(" Reserved entries:\n"));
17360 printf (_(" %*s %10s %*s\n"),
17361 addr_size
* 2, _("Address"), _("Access"),
17362 addr_size
* 2, _("Value"));
17363 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17365 if (ent
== (bfd_vma
) -1)
17366 goto sgot_print_fail
;
17368 /* Check for the MSB of GOT[1] being set, identifying a
17369 GNU object. This entry will be used by some runtime
17370 loaders, to store the module pointer. Otherwise this
17371 is an ordinary local entry.
17372 PR 21344: Check for the entry being fully available
17373 before fetching it. */
17375 && data
+ ent
- pltgot
+ addr_size
<= data_end
17376 && (byte_get (data
+ ent
- pltgot
, addr_size
)
17377 >> (addr_size
* 8 - 1)) != 0)
17379 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17381 if (ent
== (bfd_vma
) -1)
17382 goto sgot_print_fail
;
17387 if (data
!= NULL
&& ent
< end
)
17389 printf (_(" Local entries:\n"));
17390 printf (" %*s %10s %*s\n",
17391 addr_size
* 2, _("Address"), _("Access"),
17392 addr_size
* 2, _("Value"));
17395 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17397 if (ent
== (bfd_vma
) -1)
17398 goto sgot_print_fail
;
17409 for (entry
= filedata
->dynamic_section
;
17410 /* PR 17531 file: 012-50589-0.004. */
17411 (entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
17412 && entry
->d_tag
!= DT_NULL
);
17414 switch (entry
->d_tag
)
17416 case DT_MIPS_LIBLIST
:
17418 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
17419 liblistno
* sizeof (Elf32_External_Lib
));
17421 case DT_MIPS_LIBLISTNO
:
17422 liblistno
= entry
->d_un
.d_val
;
17424 case DT_MIPS_OPTIONS
:
17425 options_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
17427 case DT_MIPS_CONFLICT
:
17429 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
17430 conflictsno
* sizeof (Elf32_External_Conflict
));
17432 case DT_MIPS_CONFLICTNO
:
17433 conflictsno
= entry
->d_un
.d_val
;
17436 pltgot
= entry
->d_un
.d_ptr
;
17438 case DT_MIPS_LOCAL_GOTNO
:
17439 local_gotno
= entry
->d_un
.d_val
;
17441 case DT_MIPS_GOTSYM
:
17442 gotsym
= entry
->d_un
.d_val
;
17444 case DT_MIPS_SYMTABNO
:
17445 symtabno
= entry
->d_un
.d_val
;
17447 case DT_MIPS_PLTGOT
:
17448 mips_pltgot
= entry
->d_un
.d_ptr
;
17451 pltrel
= entry
->d_un
.d_val
;
17454 pltrelsz
= entry
->d_un
.d_val
;
17457 jmprel
= entry
->d_un
.d_ptr
;
17463 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
17465 Elf32_External_Lib
* elib
;
17468 elib
= (Elf32_External_Lib
*) get_data (NULL
, filedata
, liblist_offset
,
17469 sizeof (Elf32_External_Lib
),
17471 _("liblist section data"));
17474 printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
17475 "\nSection '.liblist' contains %lu entries:\n",
17476 (unsigned long) liblistno
),
17477 (unsigned long) liblistno
);
17478 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
17481 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
17488 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
17489 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
17490 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
17491 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
17492 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
17494 tmp
= gmtime (&atime
);
17495 snprintf (timebuf
, sizeof (timebuf
),
17496 "%04u-%02u-%02uT%02u:%02u:%02u",
17497 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
17498 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
17500 printf ("%3lu: ", (unsigned long) cnt
);
17501 if (VALID_DYNAMIC_NAME (filedata
, liblist
.l_name
))
17502 print_symbol (20, GET_DYNAMIC_NAME (filedata
, liblist
.l_name
));
17504 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
17505 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
17506 liblist
.l_version
);
17508 if (liblist
.l_flags
== 0)
17512 static const struct
17519 { " EXACT_MATCH", LL_EXACT_MATCH
},
17520 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
17521 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
17522 { " EXPORTS", LL_EXPORTS
},
17523 { " DELAY_LOAD", LL_DELAY_LOAD
},
17524 { " DELTA", LL_DELTA
}
17526 int flags
= liblist
.l_flags
;
17529 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
17530 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
17532 fputs (l_flags_vals
[fcnt
].name
, stdout
);
17533 flags
^= l_flags_vals
[fcnt
].bit
;
17536 printf (" %#x", (unsigned int) flags
);
17548 if (options_offset
!= 0)
17550 Elf_External_Options
* eopt
;
17553 sect
= filedata
->section_headers
;
17555 /* Find the section header so that we get the size. */
17556 sect
= find_section_by_type (filedata
, SHT_MIPS_OPTIONS
);
17557 /* PR 17533 file: 012-277276-0.004. */
17560 error (_("No MIPS_OPTIONS header found\n"));
17564 if (sect
->sh_size
< sizeof (* eopt
))
17566 error (_("The MIPS options section is too small.\n"));
17570 eopt
= (Elf_External_Options
*) get_data (NULL
, filedata
, options_offset
, 1,
17571 sect
->sh_size
, _("options"));
17574 Elf_Internal_Options option
;
17577 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
17579 Elf_External_Options
* eoption
;
17580 unsigned int optsize
;
17582 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
17584 optsize
= BYTE_GET (eoption
->size
);
17586 /* PR 17531: file: ffa0fa3b. */
17587 if (optsize
< sizeof (* eopt
)
17588 || optsize
> sect
->sh_size
- offset
)
17590 error (_("Invalid size (%u) for MIPS option\n"),
17599 printf (ngettext ("\nSection '%s' contains %d entry:\n",
17600 "\nSection '%s' contains %d entries:\n",
17602 printable_section_name (filedata
, sect
), cnt
);
17608 Elf_External_Options
* eoption
;
17610 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
17612 option
.kind
= BYTE_GET (eoption
->kind
);
17613 option
.size
= BYTE_GET (eoption
->size
);
17614 option
.section
= BYTE_GET (eoption
->section
);
17615 option
.info
= BYTE_GET (eoption
->info
);
17617 switch (option
.kind
)
17620 /* This shouldn't happen. */
17621 printf (" NULL %" PRId16
" %" PRIx32
,
17622 option
.section
, option
.info
);
17626 printf (" REGINFO ");
17627 if (filedata
->file_header
.e_machine
== EM_MIPS
)
17629 Elf32_External_RegInfo
* ereg
;
17630 Elf32_RegInfo reginfo
;
17633 if (option
.size
< (sizeof (Elf_External_Options
)
17634 + sizeof (Elf32_External_RegInfo
)))
17636 printf (_("<corrupt>\n"));
17637 error (_("Truncated MIPS REGINFO option\n"));
17642 ereg
= (Elf32_External_RegInfo
*) (eoption
+ 1);
17644 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
17645 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
17646 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
17647 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
17648 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
17649 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
17651 printf ("GPR %08" PRIx32
" GP 0x%" PRIx32
"\n",
17652 reginfo
.ri_gprmask
, reginfo
.ri_gp_value
);
17654 " CPR0 %08" PRIx32
" CPR1 %08" PRIx32
17655 " CPR2 %08" PRIx32
" CPR3 %08" PRIx32
"\n",
17656 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
17657 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
17662 Elf64_External_RegInfo
* ereg
;
17663 Elf64_Internal_RegInfo reginfo
;
17665 if (option
.size
< (sizeof (Elf_External_Options
)
17666 + sizeof (Elf64_External_RegInfo
)))
17668 printf (_("<corrupt>\n"));
17669 error (_("Truncated MIPS REGINFO option\n"));
17674 ereg
= (Elf64_External_RegInfo
*) (eoption
+ 1);
17675 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
17676 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
17677 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
17678 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
17679 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
17680 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
17682 printf ("GPR %08" PRIx32
" GP 0x%" PRIx64
"\n",
17683 reginfo
.ri_gprmask
, reginfo
.ri_gp_value
);
17685 " CPR0 %08" PRIx32
" CPR1 %08" PRIx32
17686 " CPR2 %08" PRIx32
" CPR3 %08" PRIx32
"\n",
17687 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
17688 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
17690 offset
+= option
.size
;
17693 case ODK_EXCEPTIONS
:
17694 fputs (" EXCEPTIONS fpe_min(", stdout
);
17695 process_mips_fpe_exception (option
.info
& OEX_FPU_MIN
);
17696 fputs (") fpe_max(", stdout
);
17697 process_mips_fpe_exception ((option
.info
& OEX_FPU_MAX
) >> 8);
17698 fputs (")", stdout
);
17700 if (option
.info
& OEX_PAGE0
)
17701 fputs (" PAGE0", stdout
);
17702 if (option
.info
& OEX_SMM
)
17703 fputs (" SMM", stdout
);
17704 if (option
.info
& OEX_FPDBUG
)
17705 fputs (" FPDBUG", stdout
);
17706 if (option
.info
& OEX_DISMISS
)
17707 fputs (" DISMISS", stdout
);
17711 fputs (" PAD ", stdout
);
17712 if (option
.info
& OPAD_PREFIX
)
17713 fputs (" PREFIX", stdout
);
17714 if (option
.info
& OPAD_POSTFIX
)
17715 fputs (" POSTFIX", stdout
);
17716 if (option
.info
& OPAD_SYMBOL
)
17717 fputs (" SYMBOL", stdout
);
17721 fputs (" HWPATCH ", stdout
);
17722 if (option
.info
& OHW_R4KEOP
)
17723 fputs (" R4KEOP", stdout
);
17724 if (option
.info
& OHW_R8KPFETCH
)
17725 fputs (" R8KPFETCH", stdout
);
17726 if (option
.info
& OHW_R5KEOP
)
17727 fputs (" R5KEOP", stdout
);
17728 if (option
.info
& OHW_R5KCVTL
)
17729 fputs (" R5KCVTL", stdout
);
17733 fputs (" FILL ", stdout
);
17734 /* XXX Print content of info word? */
17738 fputs (" TAGS ", stdout
);
17739 /* XXX Print content of info word? */
17743 fputs (" HWAND ", stdout
);
17744 if (option
.info
& OHWA0_R4KEOP_CHECKED
)
17745 fputs (" R4KEOP_CHECKED", stdout
);
17746 if (option
.info
& OHWA0_R4KEOP_CLEAN
)
17747 fputs (" R4KEOP_CLEAN", stdout
);
17751 fputs (" HWOR ", stdout
);
17752 if (option
.info
& OHWA0_R4KEOP_CHECKED
)
17753 fputs (" R4KEOP_CHECKED", stdout
);
17754 if (option
.info
& OHWA0_R4KEOP_CLEAN
)
17755 fputs (" R4KEOP_CLEAN", stdout
);
17759 printf (" GP_GROUP %#06x self-contained %#06x",
17760 option
.info
& OGP_GROUP
,
17761 (option
.info
& OGP_SELF
) >> 16);
17765 printf (" IDENT %#06x self-contained %#06x",
17766 option
.info
& OGP_GROUP
,
17767 (option
.info
& OGP_SELF
) >> 16);
17771 /* This shouldn't happen. */
17772 printf (" %3d ??? %" PRId16
" %" PRIx32
,
17773 option
.kind
, option
.section
, option
.info
);
17777 len
= sizeof (* eopt
);
17778 while (len
< option
.size
)
17780 unsigned char datum
= *((unsigned char *) eoption
+ len
);
17782 if (ISPRINT (datum
))
17783 printf ("%c", datum
);
17785 printf ("\\%03o", datum
);
17788 fputs ("\n", stdout
);
17790 offset
+= option
.size
;
17798 if (conflicts_offset
!= 0 && conflictsno
!= 0)
17800 Elf32_Conflict
* iconf
;
17803 if (filedata
->dynamic_symbols
== NULL
)
17805 error (_("conflict list found without a dynamic symbol table\n"));
17809 /* PR 21345 - print a slightly more helpful error message
17810 if we are sure that the cmalloc will fail. */
17811 if (conflictsno
> filedata
->file_size
/ sizeof (* iconf
))
17813 error (_("Overlarge number of conflicts detected: %lx\n"),
17814 (long) conflictsno
);
17818 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
17821 error (_("Out of memory allocating space for dynamic conflicts\n"));
17827 Elf32_External_Conflict
* econf32
;
17829 econf32
= (Elf32_External_Conflict
*)
17830 get_data (NULL
, filedata
, conflicts_offset
,
17831 sizeof (*econf32
), conflictsno
, _("conflict"));
17838 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
17839 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
17845 Elf64_External_Conflict
* econf64
;
17847 econf64
= (Elf64_External_Conflict
*)
17848 get_data (NULL
, filedata
, conflicts_offset
,
17849 sizeof (*econf64
), conflictsno
, _("conflict"));
17856 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
17857 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
17862 printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
17863 "\nSection '.conflict' contains %lu entries:\n",
17864 (unsigned long) conflictsno
),
17865 (unsigned long) conflictsno
);
17866 puts (_(" Num: Index Value Name"));
17868 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
17870 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
17872 if (iconf
[cnt
] >= filedata
->num_dynamic_syms
)
17873 printf (_("<corrupt symbol index>"));
17876 Elf_Internal_Sym
* psym
;
17878 psym
= & filedata
->dynamic_symbols
[iconf
[cnt
]];
17879 print_vma (psym
->st_value
, FULL_HEX
);
17881 if (VALID_DYNAMIC_NAME (filedata
, psym
->st_name
))
17882 print_symbol (25, GET_DYNAMIC_NAME (filedata
, psym
->st_name
));
17884 printf (_("<corrupt: %14ld>"), psym
->st_name
);
17892 if (pltgot
!= 0 && local_gotno
!= 0)
17894 bfd_vma ent
, local_end
, global_end
;
17896 unsigned char * data
;
17897 unsigned char * data_end
;
17901 addr_size
= (is_32bit_elf
? 4 : 8);
17902 local_end
= pltgot
+ local_gotno
* addr_size
;
17904 /* PR binutils/17533 file: 012-111227-0.004 */
17905 if (symtabno
< gotsym
)
17907 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
17908 (unsigned long) gotsym
, (unsigned long) symtabno
);
17912 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
17913 /* PR 17531: file: 54c91a34. */
17914 if (global_end
< local_end
)
17916 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
17920 offset
= offset_from_vma (filedata
, pltgot
, global_end
- pltgot
);
17921 data
= (unsigned char *) get_data (NULL
, filedata
, offset
,
17922 global_end
- pltgot
, 1,
17923 _("Global Offset Table data"));
17924 /* PR 12855: Null data is handled gracefully throughout. */
17925 data_end
= data
+ (global_end
- pltgot
);
17927 printf (_("\nPrimary GOT:\n"));
17928 printf (_(" Canonical gp value: "));
17929 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
17932 printf (_(" Reserved entries:\n"));
17933 printf (_(" %*s %10s %*s Purpose\n"),
17934 addr_size
* 2, _("Address"), _("Access"),
17935 addr_size
* 2, _("Initial"));
17936 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17937 printf (_(" Lazy resolver\n"));
17938 if (ent
== (bfd_vma
) -1)
17939 goto got_print_fail
;
17941 /* Check for the MSB of GOT[1] being set, denoting a GNU object.
17942 This entry will be used by some runtime loaders, to store the
17943 module pointer. Otherwise this is an ordinary local entry.
17944 PR 21344: Check for the entry being fully available before
17947 && data
+ ent
- pltgot
+ addr_size
<= data_end
17948 && (byte_get (data
+ ent
- pltgot
, addr_size
)
17949 >> (addr_size
* 8 - 1)) != 0)
17951 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17952 printf (_(" Module pointer (GNU extension)\n"));
17953 if (ent
== (bfd_vma
) -1)
17954 goto got_print_fail
;
17958 if (data
!= NULL
&& ent
< local_end
)
17960 printf (_(" Local entries:\n"));
17961 printf (" %*s %10s %*s\n",
17962 addr_size
* 2, _("Address"), _("Access"),
17963 addr_size
* 2, _("Initial"));
17964 while (ent
< local_end
)
17966 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17968 if (ent
== (bfd_vma
) -1)
17969 goto got_print_fail
;
17974 if (data
!= NULL
&& gotsym
< symtabno
)
17978 printf (_(" Global entries:\n"));
17979 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
17980 addr_size
* 2, _("Address"),
17982 addr_size
* 2, _("Initial"),
17983 addr_size
* 2, _("Sym.Val."),
17985 /* Note for translators: "Ndx" = abbreviated form of "Index". */
17986 _("Ndx"), _("Name"));
17988 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
17990 for (i
= gotsym
; i
< symtabno
; i
++)
17992 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17995 if (filedata
->dynamic_symbols
== NULL
)
17996 printf (_("<no dynamic symbols>"));
17997 else if (i
< filedata
->num_dynamic_syms
)
17999 Elf_Internal_Sym
* psym
= filedata
->dynamic_symbols
+ i
;
18001 print_vma (psym
->st_value
, LONG_HEX
);
18002 printf (" %-7s %3s ",
18003 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
18004 get_symbol_index_type (filedata
, psym
->st_shndx
));
18006 if (VALID_DYNAMIC_NAME (filedata
, psym
->st_name
))
18007 print_symbol (sym_width
,
18008 GET_DYNAMIC_NAME (filedata
, psym
->st_name
));
18010 printf (_("<corrupt: %14ld>"), psym
->st_name
);
18013 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
18014 (unsigned long) i
);
18017 if (ent
== (bfd_vma
) -1)
18027 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
18030 size_t offset
, rel_offset
;
18031 unsigned long count
, i
;
18032 unsigned char * data
;
18033 int addr_size
, sym_width
;
18034 Elf_Internal_Rela
* rels
;
18036 rel_offset
= offset_from_vma (filedata
, jmprel
, pltrelsz
);
18037 if (pltrel
== DT_RELA
)
18039 if (!slurp_rela_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
18044 if (!slurp_rel_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
18049 addr_size
= (is_32bit_elf
? 4 : 8);
18050 end
= mips_pltgot
+ (2 + count
) * addr_size
;
18052 offset
= offset_from_vma (filedata
, mips_pltgot
, end
- mips_pltgot
);
18053 data
= (unsigned char *) get_data (NULL
, filedata
, offset
, end
- mips_pltgot
,
18054 1, _("Procedure Linkage Table data"));
18061 printf ("\nPLT GOT:\n\n");
18062 printf (_(" Reserved entries:\n"));
18063 printf (_(" %*s %*s Purpose\n"),
18064 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
18065 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
18066 printf (_(" PLT lazy resolver\n"));
18067 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
18068 printf (_(" Module pointer\n"));
18071 printf (_(" Entries:\n"));
18072 printf (" %*s %*s %*s %-7s %3s %s\n",
18073 addr_size
* 2, _("Address"),
18074 addr_size
* 2, _("Initial"),
18075 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
18076 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
18077 for (i
= 0; i
< count
; i
++)
18079 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
18081 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
18084 if (idx
>= filedata
->num_dynamic_syms
)
18085 printf (_("<corrupt symbol index: %lu>"), idx
);
18088 Elf_Internal_Sym
* psym
= filedata
->dynamic_symbols
+ idx
;
18090 print_vma (psym
->st_value
, LONG_HEX
);
18091 printf (" %-7s %3s ",
18092 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
18093 get_symbol_index_type (filedata
, psym
->st_shndx
));
18094 if (VALID_DYNAMIC_NAME (filedata
, psym
->st_name
))
18095 print_symbol (sym_width
,
18096 GET_DYNAMIC_NAME (filedata
, psym
->st_name
));
18098 printf (_("<corrupt: %14ld>"), psym
->st_name
);
18112 process_nds32_specific (Filedata
* filedata
)
18114 Elf_Internal_Shdr
*sect
= NULL
;
18116 sect
= find_section (filedata
, ".nds32_e_flags");
18117 if (sect
!= NULL
&& sect
->sh_size
>= 4)
18119 unsigned char *buf
;
18122 printf ("\nNDS32 elf flags section:\n");
18123 buf
= get_data (NULL
, filedata
, sect
->sh_offset
, 1, 4,
18124 _("NDS32 elf flags section"));
18129 flag
= byte_get (buf
, 4);
18131 switch (flag
& 0x3)
18134 printf ("(VEC_SIZE):\tNo entry.\n");
18137 printf ("(VEC_SIZE):\t4 bytes\n");
18140 printf ("(VEC_SIZE):\t16 bytes\n");
18143 printf ("(VEC_SIZE):\treserved\n");
18152 process_gnu_liblist (Filedata
* filedata
)
18154 Elf_Internal_Shdr
* section
;
18155 Elf_Internal_Shdr
* string_sec
;
18156 Elf32_External_Lib
* elib
;
18158 size_t strtab_size
;
18160 unsigned long num_liblist
;
18162 bfd_boolean res
= TRUE
;
18167 for (i
= 0, section
= filedata
->section_headers
;
18168 i
< filedata
->file_header
.e_shnum
;
18171 switch (section
->sh_type
)
18173 case SHT_GNU_LIBLIST
:
18174 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
18177 elib
= (Elf32_External_Lib
*)
18178 get_data (NULL
, filedata
, section
->sh_offset
, 1, section
->sh_size
,
18179 _("liblist section data"));
18187 string_sec
= filedata
->section_headers
+ section
->sh_link
;
18188 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
18189 string_sec
->sh_size
,
18190 _("liblist string table"));
18192 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
18199 strtab_size
= string_sec
->sh_size
;
18201 num_liblist
= section
->sh_size
/ sizeof (Elf32_External_Lib
);
18202 printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
18203 "\nLibrary list section '%s' contains %lu entries:\n",
18205 printable_section_name (filedata
, section
),
18208 puts (_(" Library Time Stamp Checksum Version Flags"));
18210 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
18218 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
18219 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
18220 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
18221 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
18222 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
18224 tmp
= gmtime (&atime
);
18225 snprintf (timebuf
, sizeof (timebuf
),
18226 "%04u-%02u-%02uT%02u:%02u:%02u",
18227 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
18228 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
18230 printf ("%3lu: ", (unsigned long) cnt
);
18232 printf ("%-20s", liblist
.l_name
< strtab_size
18233 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
18235 printf ("%-20.20s", liblist
.l_name
< strtab_size
18236 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
18237 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
18238 liblist
.l_version
, liblist
.l_flags
);
18249 static const char *
18250 get_note_type (Filedata
* filedata
, unsigned e_type
)
18252 static char buff
[64];
18254 if (filedata
->file_header
.e_type
== ET_CORE
)
18258 return _("NT_AUXV (auxiliary vector)");
18260 return _("NT_PRSTATUS (prstatus structure)");
18262 return _("NT_FPREGSET (floating point registers)");
18264 return _("NT_PRPSINFO (prpsinfo structure)");
18265 case NT_TASKSTRUCT
:
18266 return _("NT_TASKSTRUCT (task structure)");
18268 return _("NT_PRXFPREG (user_xfpregs structure)");
18270 return _("NT_PPC_VMX (ppc Altivec registers)");
18272 return _("NT_PPC_VSX (ppc VSX registers)");
18274 return _("NT_PPC_TAR (ppc TAR register)");
18276 return _("NT_PPC_PPR (ppc PPR register)");
18278 return _("NT_PPC_DSCR (ppc DSCR register)");
18280 return _("NT_PPC_EBB (ppc EBB registers)");
18282 return _("NT_PPC_PMU (ppc PMU registers)");
18283 case NT_PPC_TM_CGPR
:
18284 return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
18285 case NT_PPC_TM_CFPR
:
18286 return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
18287 case NT_PPC_TM_CVMX
:
18288 return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
18289 case NT_PPC_TM_CVSX
:
18290 return _("NT_PPC_TM_CVSX (ppc checkpointed VSX registers)");
18291 case NT_PPC_TM_SPR
:
18292 return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
18293 case NT_PPC_TM_CTAR
:
18294 return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
18295 case NT_PPC_TM_CPPR
:
18296 return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
18297 case NT_PPC_TM_CDSCR
:
18298 return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
18300 return _("NT_386_TLS (x86 TLS information)");
18301 case NT_386_IOPERM
:
18302 return _("NT_386_IOPERM (x86 I/O permissions)");
18303 case NT_X86_XSTATE
:
18304 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
18306 return _("NT_X86_CET (x86 CET state)");
18307 case NT_S390_HIGH_GPRS
:
18308 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
18309 case NT_S390_TIMER
:
18310 return _("NT_S390_TIMER (s390 timer register)");
18311 case NT_S390_TODCMP
:
18312 return _("NT_S390_TODCMP (s390 TOD comparator register)");
18313 case NT_S390_TODPREG
:
18314 return _("NT_S390_TODPREG (s390 TOD programmable register)");
18316 return _("NT_S390_CTRS (s390 control registers)");
18317 case NT_S390_PREFIX
:
18318 return _("NT_S390_PREFIX (s390 prefix register)");
18319 case NT_S390_LAST_BREAK
:
18320 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
18321 case NT_S390_SYSTEM_CALL
:
18322 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
18324 return _("NT_S390_TDB (s390 transaction diagnostic block)");
18325 case NT_S390_VXRS_LOW
:
18326 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
18327 case NT_S390_VXRS_HIGH
:
18328 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
18329 case NT_S390_GS_CB
:
18330 return _("NT_S390_GS_CB (s390 guarded-storage registers)");
18331 case NT_S390_GS_BC
:
18332 return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
18334 return _("NT_ARM_VFP (arm VFP registers)");
18336 return _("NT_ARM_TLS (AArch TLS registers)");
18337 case NT_ARM_HW_BREAK
:
18338 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
18339 case NT_ARM_HW_WATCH
:
18340 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
18342 return _("NT_ARC_V2 (ARC HS accumulator/extra registers)");
18344 return _("NT_PSTATUS (pstatus structure)");
18346 return _("NT_FPREGS (floating point registers)");
18348 return _("NT_PSINFO (psinfo structure)");
18350 return _("NT_LWPSTATUS (lwpstatus_t structure)");
18352 return _("NT_LWPSINFO (lwpsinfo_t structure)");
18353 case NT_WIN32PSTATUS
:
18354 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
18356 return _("NT_SIGINFO (siginfo_t data)");
18358 return _("NT_FILE (mapped files)");
18366 return _("NT_VERSION (version)");
18368 return _("NT_ARCH (architecture)");
18369 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
18371 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
18377 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18382 print_core_note (Elf_Internal_Note
*pnote
)
18384 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
18385 bfd_vma count
, page_size
;
18386 unsigned char *descdata
, *filenames
, *descend
;
18388 if (pnote
->type
!= NT_FILE
)
18398 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
18399 /* Still "successful". */
18404 if (pnote
->descsz
< 2 * addr_size
)
18406 error (_(" Malformed note - too short for header\n"));
18410 descdata
= (unsigned char *) pnote
->descdata
;
18411 descend
= descdata
+ pnote
->descsz
;
18413 if (descdata
[pnote
->descsz
- 1] != '\0')
18415 error (_(" Malformed note - does not end with \\0\n"));
18419 count
= byte_get (descdata
, addr_size
);
18420 descdata
+= addr_size
;
18422 page_size
= byte_get (descdata
, addr_size
);
18423 descdata
+= addr_size
;
18425 if (count
> ((bfd_vma
) -1 - 2 * addr_size
) / (3 * addr_size
)
18426 || pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
18428 error (_(" Malformed note - too short for supplied file count\n"));
18432 printf (_(" Page size: "));
18433 print_vma (page_size
, DEC
);
18436 printf (_(" %*s%*s%*s\n"),
18437 (int) (2 + 2 * addr_size
), _("Start"),
18438 (int) (4 + 2 * addr_size
), _("End"),
18439 (int) (4 + 2 * addr_size
), _("Page Offset"));
18440 filenames
= descdata
+ count
* 3 * addr_size
;
18441 while (count
-- > 0)
18443 bfd_vma start
, end
, file_ofs
;
18445 if (filenames
== descend
)
18447 error (_(" Malformed note - filenames end too early\n"));
18451 start
= byte_get (descdata
, addr_size
);
18452 descdata
+= addr_size
;
18453 end
= byte_get (descdata
, addr_size
);
18454 descdata
+= addr_size
;
18455 file_ofs
= byte_get (descdata
, addr_size
);
18456 descdata
+= addr_size
;
18459 print_vma (start
, FULL_HEX
);
18461 print_vma (end
, FULL_HEX
);
18463 print_vma (file_ofs
, FULL_HEX
);
18464 printf ("\n %s\n", filenames
);
18466 filenames
+= 1 + strlen ((char *) filenames
);
18472 static const char *
18473 get_gnu_elf_note_type (unsigned e_type
)
18475 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
18478 case NT_GNU_ABI_TAG
:
18479 return _("NT_GNU_ABI_TAG (ABI version tag)");
18481 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
18482 case NT_GNU_BUILD_ID
:
18483 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
18484 case NT_GNU_GOLD_VERSION
:
18485 return _("NT_GNU_GOLD_VERSION (gold version)");
18486 case NT_GNU_PROPERTY_TYPE_0
:
18487 return _("NT_GNU_PROPERTY_TYPE_0");
18488 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
18489 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
18490 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
18491 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
18494 static char buff
[64];
18496 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18503 decode_x86_compat_isa (unsigned int bitmask
)
18507 unsigned int bit
= bitmask
& (- bitmask
);
18512 case GNU_PROPERTY_X86_COMPAT_ISA_1_486
:
18515 case GNU_PROPERTY_X86_COMPAT_ISA_1_586
:
18518 case GNU_PROPERTY_X86_COMPAT_ISA_1_686
:
18521 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE
:
18524 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE2
:
18527 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE3
:
18530 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSSE3
:
18533 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_1
:
18536 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_2
:
18539 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX
:
18542 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX2
:
18545 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512F
:
18546 printf ("AVX512F");
18548 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512CD
:
18549 printf ("AVX512CD");
18551 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512ER
:
18552 printf ("AVX512ER");
18554 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512PF
:
18555 printf ("AVX512PF");
18557 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512VL
:
18558 printf ("AVX512VL");
18560 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512DQ
:
18561 printf ("AVX512DQ");
18563 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512BW
:
18564 printf ("AVX512BW");
18567 printf (_("<unknown: %x>"), bit
);
18576 decode_x86_compat_2_isa (unsigned int bitmask
)
18580 printf (_("<None>"));
18586 unsigned int bit
= bitmask
& (- bitmask
);
18591 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_CMOV
:
18594 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE
:
18597 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE2
:
18600 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE3
:
18603 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSSE3
:
18606 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE4_1
:
18609 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE4_2
:
18612 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX
:
18615 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX2
:
18618 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_FMA
:
18621 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512F
:
18622 printf ("AVX512F");
18624 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512CD
:
18625 printf ("AVX512CD");
18627 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512ER
:
18628 printf ("AVX512ER");
18630 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512PF
:
18631 printf ("AVX512PF");
18633 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512VL
:
18634 printf ("AVX512VL");
18636 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512DQ
:
18637 printf ("AVX512DQ");
18639 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512BW
:
18640 printf ("AVX512BW");
18642 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_4FMAPS
:
18643 printf ("AVX512_4FMAPS");
18645 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_4VNNIW
:
18646 printf ("AVX512_4VNNIW");
18648 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_BITALG
:
18649 printf ("AVX512_BITALG");
18651 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_IFMA
:
18652 printf ("AVX512_IFMA");
18654 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_VBMI
:
18655 printf ("AVX512_VBMI");
18657 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_VBMI2
:
18658 printf ("AVX512_VBMI2");
18660 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_VNNI
:
18661 printf ("AVX512_VNNI");
18663 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_BF16
:
18664 printf ("AVX512_BF16");
18667 printf (_("<unknown: %x>"), bit
);
18676 decode_x86_isa (unsigned int bitmask
)
18680 unsigned int bit
= bitmask
& (- bitmask
);
18685 case GNU_PROPERTY_X86_ISA_1_BASELINE
:
18686 printf ("x86-64-baseline");
18688 case GNU_PROPERTY_X86_ISA_1_V2
:
18689 printf ("x86-64-v2");
18691 case GNU_PROPERTY_X86_ISA_1_V3
:
18692 printf ("x86-64-v3");
18694 case GNU_PROPERTY_X86_ISA_1_V4
:
18695 printf ("x86-64-v4");
18698 printf (_("<unknown: %x>"), bit
);
18707 decode_x86_feature_1 (unsigned int bitmask
)
18711 printf (_("<None>"));
18717 unsigned int bit
= bitmask
& (- bitmask
);
18722 case GNU_PROPERTY_X86_FEATURE_1_IBT
:
18725 case GNU_PROPERTY_X86_FEATURE_1_SHSTK
:
18729 printf (_("<unknown: %x>"), bit
);
18738 decode_x86_feature_2 (unsigned int bitmask
)
18742 printf (_("<None>"));
18748 unsigned int bit
= bitmask
& (- bitmask
);
18753 case GNU_PROPERTY_X86_FEATURE_2_X86
:
18756 case GNU_PROPERTY_X86_FEATURE_2_X87
:
18759 case GNU_PROPERTY_X86_FEATURE_2_MMX
:
18762 case GNU_PROPERTY_X86_FEATURE_2_XMM
:
18765 case GNU_PROPERTY_X86_FEATURE_2_YMM
:
18768 case GNU_PROPERTY_X86_FEATURE_2_ZMM
:
18771 case GNU_PROPERTY_X86_FEATURE_2_TMM
:
18774 case GNU_PROPERTY_X86_FEATURE_2_MASK
:
18777 case GNU_PROPERTY_X86_FEATURE_2_FXSR
:
18780 case GNU_PROPERTY_X86_FEATURE_2_XSAVE
:
18783 case GNU_PROPERTY_X86_FEATURE_2_XSAVEOPT
:
18784 printf ("XSAVEOPT");
18786 case GNU_PROPERTY_X86_FEATURE_2_XSAVEC
:
18790 printf (_("<unknown: %x>"), bit
);
18799 decode_aarch64_feature_1_and (unsigned int bitmask
)
18803 unsigned int bit
= bitmask
& (- bitmask
);
18808 case GNU_PROPERTY_AARCH64_FEATURE_1_BTI
:
18812 case GNU_PROPERTY_AARCH64_FEATURE_1_PAC
:
18817 printf (_("<unknown: %x>"), bit
);
18826 print_gnu_property_note (Filedata
* filedata
, Elf_Internal_Note
* pnote
)
18828 unsigned char * ptr
= (unsigned char *) pnote
->descdata
;
18829 unsigned char * ptr_end
= ptr
+ pnote
->descsz
;
18830 unsigned int size
= is_32bit_elf
? 4 : 8;
18832 printf (_(" Properties: "));
18834 if (pnote
->descsz
< 8 || (pnote
->descsz
% size
) != 0)
18836 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote
->descsz
);
18840 while (ptr
< ptr_end
)
18844 unsigned int datasz
;
18846 if ((size_t) (ptr_end
- ptr
) < 8)
18848 printf (_("<corrupt descsz: %#lx>\n"), pnote
->descsz
);
18852 type
= byte_get (ptr
, 4);
18853 datasz
= byte_get (ptr
+ 4, 4);
18857 if (datasz
> (size_t) (ptr_end
- ptr
))
18859 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
18864 if (type
>= GNU_PROPERTY_LOPROC
&& type
<= GNU_PROPERTY_HIPROC
)
18866 if (filedata
->file_header
.e_machine
== EM_X86_64
18867 || filedata
->file_header
.e_machine
== EM_IAMCU
18868 || filedata
->file_header
.e_machine
== EM_386
)
18870 unsigned int bitmask
;
18873 bitmask
= byte_get (ptr
, 4);
18879 case GNU_PROPERTY_X86_ISA_1_USED
:
18881 printf (_("x86 ISA used: <corrupt length: %#x> "),
18885 printf ("x86 ISA used: ");
18886 decode_x86_isa (bitmask
);
18890 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
18892 printf (_("x86 ISA needed: <corrupt length: %#x> "),
18896 printf ("x86 ISA needed: ");
18897 decode_x86_isa (bitmask
);
18901 case GNU_PROPERTY_X86_FEATURE_1_AND
:
18903 printf (_("x86 feature: <corrupt length: %#x> "),
18907 printf ("x86 feature: ");
18908 decode_x86_feature_1 (bitmask
);
18912 case GNU_PROPERTY_X86_FEATURE_2_USED
:
18914 printf (_("x86 feature used: <corrupt length: %#x> "),
18918 printf ("x86 feature used: ");
18919 decode_x86_feature_2 (bitmask
);
18923 case GNU_PROPERTY_X86_FEATURE_2_NEEDED
:
18925 printf (_("x86 feature needed: <corrupt length: %#x> "), datasz
);
18928 printf ("x86 feature needed: ");
18929 decode_x86_feature_2 (bitmask
);
18933 case GNU_PROPERTY_X86_COMPAT_ISA_1_USED
:
18935 printf (_("x86 ISA used: <corrupt length: %#x> "),
18939 printf ("x86 ISA used: ");
18940 decode_x86_compat_isa (bitmask
);
18944 case GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED
:
18946 printf (_("x86 ISA needed: <corrupt length: %#x> "),
18950 printf ("x86 ISA needed: ");
18951 decode_x86_compat_isa (bitmask
);
18955 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_USED
:
18957 printf (_("x86 ISA used: <corrupt length: %#x> "),
18961 printf ("x86 ISA used: ");
18962 decode_x86_compat_2_isa (bitmask
);
18966 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_NEEDED
:
18968 printf (_("x86 ISA needed: <corrupt length: %#x> "),
18972 printf ("x86 ISA needed: ");
18973 decode_x86_compat_2_isa (bitmask
);
18981 else if (filedata
->file_header
.e_machine
== EM_AARCH64
)
18983 if (type
== GNU_PROPERTY_AARCH64_FEATURE_1_AND
)
18985 printf ("AArch64 feature: ");
18987 printf (_("<corrupt length: %#x> "), datasz
);
18989 decode_aarch64_feature_1_and (byte_get (ptr
, 4));
18998 case GNU_PROPERTY_STACK_SIZE
:
18999 printf (_("stack size: "));
19000 if (datasz
!= size
)
19001 printf (_("<corrupt length: %#x> "), datasz
);
19003 printf ("%#lx", (unsigned long) byte_get (ptr
, size
));
19006 case GNU_PROPERTY_NO_COPY_ON_PROTECTED
:
19007 printf ("no copy on protected ");
19009 printf (_("<corrupt length: %#x> "), datasz
);
19017 if (type
< GNU_PROPERTY_LOPROC
)
19018 printf (_("<unknown type %#x data: "), type
);
19019 else if (type
< GNU_PROPERTY_LOUSER
)
19020 printf (_("<procesor-specific type %#x data: "), type
);
19022 printf (_("<application-specific type %#x data: "), type
);
19023 for (j
= 0; j
< datasz
; ++j
)
19024 printf ("%02x ", ptr
[j
] & 0xff);
19028 ptr
+= ((datasz
+ (size
- 1)) & ~ (size
- 1));
19029 if (ptr
== ptr_end
)
19042 print_gnu_note (Filedata
* filedata
, Elf_Internal_Note
*pnote
)
19044 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
19045 switch (pnote
->type
)
19047 case NT_GNU_BUILD_ID
:
19051 printf (_(" Build ID: "));
19052 for (i
= 0; i
< pnote
->descsz
; ++i
)
19053 printf ("%02x", pnote
->descdata
[i
] & 0xff);
19058 case NT_GNU_ABI_TAG
:
19060 unsigned long os
, major
, minor
, subminor
;
19061 const char *osname
;
19063 /* PR 17531: file: 030-599401-0.004. */
19064 if (pnote
->descsz
< 16)
19066 printf (_(" <corrupt GNU_ABI_TAG>\n"));
19070 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
19071 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
19072 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
19073 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
19077 case GNU_ABI_TAG_LINUX
:
19080 case GNU_ABI_TAG_HURD
:
19083 case GNU_ABI_TAG_SOLARIS
:
19084 osname
= "Solaris";
19086 case GNU_ABI_TAG_FREEBSD
:
19087 osname
= "FreeBSD";
19089 case GNU_ABI_TAG_NETBSD
:
19092 case GNU_ABI_TAG_SYLLABLE
:
19093 osname
= "Syllable";
19095 case GNU_ABI_TAG_NACL
:
19099 osname
= "Unknown";
19103 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
19104 major
, minor
, subminor
);
19108 case NT_GNU_GOLD_VERSION
:
19112 printf (_(" Version: "));
19113 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
19114 printf ("%c", pnote
->descdata
[i
]);
19121 unsigned long num_entries
, mask
;
19123 /* Hardware capabilities information. Word 0 is the number of entries.
19124 Word 1 is a bitmask of enabled entries. The rest of the descriptor
19125 is a series of entries, where each entry is a single byte followed
19126 by a nul terminated string. The byte gives the bit number to test
19127 if enabled in the bitmask. */
19128 printf (_(" Hardware Capabilities: "));
19129 if (pnote
->descsz
< 8)
19131 error (_("<corrupt GNU_HWCAP>\n"));
19134 num_entries
= byte_get ((unsigned char *) pnote
->descdata
, 4);
19135 mask
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
19136 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries
, mask
);
19137 /* FIXME: Add code to display the entries... */
19141 case NT_GNU_PROPERTY_TYPE_0
:
19142 print_gnu_property_note (filedata
, pnote
);
19146 /* Handle unrecognised types. An error message should have already been
19147 created by get_gnu_elf_note_type(), so all that we need to do is to
19148 display the data. */
19152 printf (_(" Description data: "));
19153 for (i
= 0; i
< pnote
->descsz
; ++i
)
19154 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
19163 static const char *
19164 get_v850_elf_note_type (enum v850_notes n_type
)
19166 static char buff
[64];
19170 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
19171 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
19172 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
19173 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
19174 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
19175 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
19177 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
19183 print_v850_note (Elf_Internal_Note
* pnote
)
19187 if (pnote
->descsz
!= 4)
19190 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
19194 printf (_("not set\n"));
19198 switch (pnote
->type
)
19200 case V850_NOTE_ALIGNMENT
:
19203 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return TRUE
;
19204 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return TRUE
;
19208 case V850_NOTE_DATA_SIZE
:
19211 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return TRUE
;
19212 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return TRUE
;
19216 case V850_NOTE_FPU_INFO
:
19219 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return TRUE
;
19220 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return TRUE
;
19224 case V850_NOTE_MMU_INFO
:
19225 case V850_NOTE_CACHE_INFO
:
19226 case V850_NOTE_SIMD_INFO
:
19227 if (val
== EF_RH850_SIMD
)
19229 printf (_("yes\n"));
19235 /* An 'unknown note type' message will already have been displayed. */
19239 printf (_("unknown value: %x\n"), val
);
19244 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
19246 unsigned int version
;
19248 switch (pnote
->type
)
19250 case NT_NETBSD_IDENT
:
19251 if (pnote
->descsz
< 1)
19253 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
19254 if ((version
/ 10000) % 100)
19255 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
19256 version
, version
/ 100000000, (version
/ 1000000) % 100,
19257 (version
/ 10000) % 100 > 26 ? "Z" : "",
19258 'A' + (version
/ 10000) % 26);
19260 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
19261 version
, version
/ 100000000, (version
/ 1000000) % 100,
19262 (version
/ 100) % 100);
19265 case NT_NETBSD_MARCH
:
19266 printf (" NetBSD\t\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
19270 #ifdef NT_NETBSD_PAX
19271 case NT_NETBSD_PAX
:
19272 if (pnote
->descsz
< 1)
19274 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
19275 printf (" NetBSD\t\t0x%08lx\tPaX <%s%s%s%s%s%s>\n", pnote
->descsz
,
19276 ((version
& NT_NETBSD_PAX_MPROTECT
) ? "+mprotect" : ""),
19277 ((version
& NT_NETBSD_PAX_NOMPROTECT
) ? "-mprotect" : ""),
19278 ((version
& NT_NETBSD_PAX_GUARD
) ? "+guard" : ""),
19279 ((version
& NT_NETBSD_PAX_NOGUARD
) ? "-guard" : ""),
19280 ((version
& NT_NETBSD_PAX_ASLR
) ? "+ASLR" : ""),
19281 ((version
& NT_NETBSD_PAX_NOASLR
) ? "-ASLR" : ""));
19286 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n",
19287 pnote
->descsz
, pnote
->type
);
19291 static const char *
19292 get_freebsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
19296 case NT_FREEBSD_THRMISC
:
19297 return _("NT_THRMISC (thrmisc structure)");
19298 case NT_FREEBSD_PROCSTAT_PROC
:
19299 return _("NT_PROCSTAT_PROC (proc data)");
19300 case NT_FREEBSD_PROCSTAT_FILES
:
19301 return _("NT_PROCSTAT_FILES (files data)");
19302 case NT_FREEBSD_PROCSTAT_VMMAP
:
19303 return _("NT_PROCSTAT_VMMAP (vmmap data)");
19304 case NT_FREEBSD_PROCSTAT_GROUPS
:
19305 return _("NT_PROCSTAT_GROUPS (groups data)");
19306 case NT_FREEBSD_PROCSTAT_UMASK
:
19307 return _("NT_PROCSTAT_UMASK (umask data)");
19308 case NT_FREEBSD_PROCSTAT_RLIMIT
:
19309 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
19310 case NT_FREEBSD_PROCSTAT_OSREL
:
19311 return _("NT_PROCSTAT_OSREL (osreldate data)");
19312 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
19313 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
19314 case NT_FREEBSD_PROCSTAT_AUXV
:
19315 return _("NT_PROCSTAT_AUXV (auxv data)");
19316 case NT_FREEBSD_PTLWPINFO
:
19317 return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
19319 return get_note_type (filedata
, e_type
);
19322 static const char *
19323 get_netbsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
19325 static char buff
[64];
19329 case NT_NETBSDCORE_PROCINFO
:
19330 /* NetBSD core "procinfo" structure. */
19331 return _("NetBSD procinfo structure");
19333 #ifdef NT_NETBSDCORE_AUXV
19334 case NT_NETBSDCORE_AUXV
:
19335 return _("NetBSD ELF auxiliary vector data");
19338 #ifdef NT_NETBSDCORE_LWPSTATUS
19339 case NT_NETBSDCORE_LWPSTATUS
:
19340 return _("PT_LWPSTATUS (ptrace_lwpstatus structure)");
19344 /* As of Jan 2020 there are no other machine-independent notes
19345 defined for NetBSD core files. If the note type is less
19346 than the start of the machine-dependent note types, we don't
19349 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
19351 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
19357 switch (filedata
->file_header
.e_machine
)
19359 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
19360 and PT_GETFPREGS == mach+2. */
19365 case EM_SPARC32PLUS
:
19369 case NT_NETBSDCORE_FIRSTMACH
+ 0:
19370 return _("PT_GETREGS (reg structure)");
19371 case NT_NETBSDCORE_FIRSTMACH
+ 2:
19372 return _("PT_GETFPREGS (fpreg structure)");
19378 /* On SuperH, PT_GETREGS == mach+3 and PT_GETFPREGS == mach+5.
19379 There's also old PT___GETREGS40 == mach + 1 for old reg
19380 structure which lacks GBR. */
19384 case NT_NETBSDCORE_FIRSTMACH
+ 1:
19385 return _("PT___GETREGS40 (old reg structure)");
19386 case NT_NETBSDCORE_FIRSTMACH
+ 3:
19387 return _("PT_GETREGS (reg structure)");
19388 case NT_NETBSDCORE_FIRSTMACH
+ 5:
19389 return _("PT_GETFPREGS (fpreg structure)");
19395 /* On all other arch's, PT_GETREGS == mach+1 and
19396 PT_GETFPREGS == mach+3. */
19400 case NT_NETBSDCORE_FIRSTMACH
+ 1:
19401 return _("PT_GETREGS (reg structure)");
19402 case NT_NETBSDCORE_FIRSTMACH
+ 3:
19403 return _("PT_GETFPREGS (fpreg structure)");
19409 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
19410 e_type
- NT_NETBSDCORE_FIRSTMACH
);
19414 static const char *
19415 get_stapsdt_note_type (unsigned e_type
)
19417 static char buff
[64];
19422 return _("NT_STAPSDT (SystemTap probe descriptors)");
19428 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
19433 print_stapsdt_note (Elf_Internal_Note
*pnote
)
19435 size_t len
, maxlen
;
19436 unsigned long addr_size
= is_32bit_elf
? 4 : 8;
19437 char *data
= pnote
->descdata
;
19438 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
19439 bfd_vma pc
, base_addr
, semaphore
;
19440 char *provider
, *probe
, *arg_fmt
;
19442 if (pnote
->descsz
< (addr_size
* 3))
19443 goto stapdt_note_too_small
;
19445 pc
= byte_get ((unsigned char *) data
, addr_size
);
19448 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
19451 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
19454 if (data
>= data_end
)
19455 goto stapdt_note_too_small
;
19456 maxlen
= data_end
- data
;
19457 len
= strnlen (data
, maxlen
);
19464 goto stapdt_note_too_small
;
19466 if (data
>= data_end
)
19467 goto stapdt_note_too_small
;
19468 maxlen
= data_end
- data
;
19469 len
= strnlen (data
, maxlen
);
19476 goto stapdt_note_too_small
;
19478 if (data
>= data_end
)
19479 goto stapdt_note_too_small
;
19480 maxlen
= data_end
- data
;
19481 len
= strnlen (data
, maxlen
);
19488 goto stapdt_note_too_small
;
19490 printf (_(" Provider: %s\n"), provider
);
19491 printf (_(" Name: %s\n"), probe
);
19492 printf (_(" Location: "));
19493 print_vma (pc
, FULL_HEX
);
19494 printf (_(", Base: "));
19495 print_vma (base_addr
, FULL_HEX
);
19496 printf (_(", Semaphore: "));
19497 print_vma (semaphore
, FULL_HEX
);
19499 printf (_(" Arguments: %s\n"), arg_fmt
);
19501 return data
== data_end
;
19503 stapdt_note_too_small
:
19504 printf (_(" <corrupt - note is too small>\n"));
19505 error (_("corrupt stapdt note - the data size is too small\n"));
19509 static const char *
19510 get_ia64_vms_note_type (unsigned e_type
)
19512 static char buff
[64];
19517 return _("NT_VMS_MHD (module header)");
19519 return _("NT_VMS_LNM (language name)");
19521 return _("NT_VMS_SRC (source files)");
19523 return "NT_VMS_TITLE";
19525 return _("NT_VMS_EIDC (consistency check)");
19526 case NT_VMS_FPMODE
:
19527 return _("NT_VMS_FPMODE (FP mode)");
19528 case NT_VMS_LINKTIME
:
19529 return "NT_VMS_LINKTIME";
19530 case NT_VMS_IMGNAM
:
19531 return _("NT_VMS_IMGNAM (image name)");
19533 return _("NT_VMS_IMGID (image id)");
19534 case NT_VMS_LINKID
:
19535 return _("NT_VMS_LINKID (link id)");
19536 case NT_VMS_IMGBID
:
19537 return _("NT_VMS_IMGBID (build id)");
19538 case NT_VMS_GSTNAM
:
19539 return _("NT_VMS_GSTNAM (sym table name)");
19540 case NT_VMS_ORIG_DYN
:
19541 return "NT_VMS_ORIG_DYN";
19542 case NT_VMS_PATCHTIME
:
19543 return "NT_VMS_PATCHTIME";
19545 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
19551 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
19553 int maxlen
= pnote
->descsz
;
19555 if (maxlen
< 2 || (unsigned long) maxlen
!= pnote
->descsz
)
19556 goto desc_size_fail
;
19558 switch (pnote
->type
)
19562 goto desc_size_fail
;
19564 int l
= (int) strnlen (pnote
->descdata
+ 34, maxlen
- 34);
19566 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
19567 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
19568 if (l
+ 34 < maxlen
)
19570 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
19571 if (l
+ 35 < maxlen
)
19572 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
19574 printf (_(" Module version : <missing>\n"));
19578 printf (_(" Module name : <missing>\n"));
19579 printf (_(" Module version : <missing>\n"));
19584 printf (_(" Language: %.*s\n"), maxlen
, pnote
->descdata
);
19588 case NT_VMS_FPMODE
:
19589 printf (_(" Floating Point mode: "));
19591 goto desc_size_fail
;
19592 /* FIXME: Generate an error if descsz > 8 ? */
19594 printf ("0x%016" BFD_VMA_FMT
"x\n",
19595 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
19598 case NT_VMS_LINKTIME
:
19599 printf (_(" Link time: "));
19601 goto desc_size_fail
;
19602 /* FIXME: Generate an error if descsz > 8 ? */
19605 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
19609 case NT_VMS_PATCHTIME
:
19610 printf (_(" Patch time: "));
19612 goto desc_size_fail
;
19613 /* FIXME: Generate an error if descsz > 8 ? */
19616 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
19620 case NT_VMS_ORIG_DYN
:
19622 goto desc_size_fail
;
19624 printf (_(" Major id: %u, minor id: %u\n"),
19625 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
19626 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
19627 printf (_(" Last modified : "));
19629 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
19630 printf (_("\n Link flags : "));
19631 printf ("0x%016" BFD_VMA_FMT
"x\n",
19632 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
19633 printf (_(" Header flags: 0x%08x\n"),
19634 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
19635 printf (_(" Image id : %.*s\n"), maxlen
- 32, pnote
->descdata
+ 32);
19639 case NT_VMS_IMGNAM
:
19640 printf (_(" Image name: %.*s\n"), maxlen
, pnote
->descdata
);
19643 case NT_VMS_GSTNAM
:
19644 printf (_(" Global symbol table name: %.*s\n"), maxlen
, pnote
->descdata
);
19648 printf (_(" Image id: %.*s\n"), maxlen
, pnote
->descdata
);
19651 case NT_VMS_LINKID
:
19652 printf (_(" Linker id: %.*s\n"), maxlen
, pnote
->descdata
);
19662 printf (_(" <corrupt - data size is too small>\n"));
19663 error (_("corrupt IA64 note: data size is too small\n"));
19667 struct build_attr_cache
{
19668 Filedata
*filedata
;
19670 unsigned long strtablen
;
19671 Elf_Internal_Sym
*symtab
;
19672 unsigned long nsyms
;
19675 /* Find the symbol associated with a build attribute that is attached
19676 to address OFFSET. If PNAME is non-NULL then store the name of
19677 the symbol (if found) in the provided pointer, Returns NULL if a
19678 symbol could not be found. */
19680 static Elf_Internal_Sym
*
19681 get_symbol_for_build_attribute (Filedata
* filedata
,
19682 unsigned long offset
,
19683 bfd_boolean is_open_attr
,
19684 const char ** pname
)
19686 Elf_Internal_Sym
*saved_sym
= NULL
;
19687 Elf_Internal_Sym
*sym
;
19689 if (filedata
->section_headers
!= NULL
19690 && (ba_cache
.filedata
== NULL
|| filedata
!= ba_cache
.filedata
))
19692 Elf_Internal_Shdr
* symsec
;
19694 free (ba_cache
.strtab
);
19695 ba_cache
.strtab
= NULL
;
19696 free (ba_cache
.symtab
);
19697 ba_cache
.symtab
= NULL
;
19699 /* Load the symbol and string sections. */
19700 for (symsec
= filedata
->section_headers
;
19701 symsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
19704 if (symsec
->sh_type
== SHT_SYMTAB
19705 && get_symtab (filedata
, symsec
,
19706 &ba_cache
.symtab
, &ba_cache
.nsyms
,
19707 &ba_cache
.strtab
, &ba_cache
.strtablen
))
19710 ba_cache
.filedata
= filedata
;
19713 if (ba_cache
.symtab
== NULL
)
19716 /* Find a symbol whose value matches offset. */
19717 for (sym
= ba_cache
.symtab
; sym
< ba_cache
.symtab
+ ba_cache
.nsyms
; sym
++)
19718 if (sym
->st_value
== offset
)
19720 if (sym
->st_name
>= ba_cache
.strtablen
)
19721 /* Huh ? This should not happen. */
19724 if (ba_cache
.strtab
[sym
->st_name
] == 0)
19727 /* The AArch64 and ARM architectures define mapping symbols
19728 (eg $d, $x, $t) which we want to ignore. */
19729 if (ba_cache
.strtab
[sym
->st_name
] == '$'
19730 && ba_cache
.strtab
[sym
->st_name
+ 1] != 0
19731 && ba_cache
.strtab
[sym
->st_name
+ 2] == 0)
19736 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
19737 and FILE or OBJECT symbols over NOTYPE symbols. We skip
19738 FUNC symbols entirely. */
19739 switch (ELF_ST_TYPE (sym
->st_info
))
19746 /* If the symbol has a size associated
19747 with it then we can stop searching. */
19748 sym
= ba_cache
.symtab
+ ba_cache
.nsyms
;
19753 /* Ignore function symbols. */
19760 switch (ELF_ST_BIND (sym
->st_info
))
19763 if (saved_sym
== NULL
19764 || ELF_ST_TYPE (saved_sym
->st_info
) != STT_OBJECT
)
19769 if (saved_sym
== NULL
)
19779 if (ELF_ST_TYPE (sym
->st_info
) != STT_FUNC
)
19787 if (saved_sym
&& pname
)
19788 * pname
= ba_cache
.strtab
+ saved_sym
->st_name
;
19793 /* Returns true iff addr1 and addr2 are in the same section. */
19796 same_section (Filedata
* filedata
, unsigned long addr1
, unsigned long addr2
)
19798 Elf_Internal_Shdr
* a1
;
19799 Elf_Internal_Shdr
* a2
;
19801 a1
= find_section_by_address (filedata
, addr1
);
19802 a2
= find_section_by_address (filedata
, addr2
);
19804 return a1
== a2
&& a1
!= NULL
;
19808 print_gnu_build_attribute_description (Elf_Internal_Note
* pnote
,
19809 Filedata
* filedata
)
19811 static unsigned long global_offset
= 0;
19812 static unsigned long global_end
= 0;
19813 static unsigned long func_offset
= 0;
19814 static unsigned long func_end
= 0;
19816 Elf_Internal_Sym
* sym
;
19818 unsigned long start
;
19820 bfd_boolean is_open_attr
= pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
;
19822 switch (pnote
->descsz
)
19825 /* A zero-length description means that the range of
19826 the previous note of the same type should be used. */
19829 if (global_end
> global_offset
)
19830 printf (_(" Applies to region from %#lx to %#lx\n"),
19831 global_offset
, global_end
);
19833 printf (_(" Applies to region from %#lx\n"), global_offset
);
19837 if (func_end
> func_offset
)
19838 printf (_(" Applies to region from %#lx to %#lx\n"), func_offset
, func_end
);
19840 printf (_(" Applies to region from %#lx\n"), func_offset
);
19845 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
19852 /* FIXME: We should check that version 3+ notes are being used here... */
19853 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
19854 end
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
19858 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
19864 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
19865 end
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 8);
19869 error (_(" <invalid description size: %lx>\n"), pnote
->descsz
);
19870 printf (_(" <invalid descsz>"));
19875 sym
= get_symbol_for_build_attribute (filedata
, start
, is_open_attr
, & name
);
19876 /* As of version 5 of the annobin plugin, filename symbols are biased by 2
19877 in order to avoid them being confused with the start address of the
19878 first function in the file... */
19879 if (sym
== NULL
&& is_open_attr
)
19880 sym
= get_symbol_for_build_attribute (filedata
, start
+ 2, is_open_attr
,
19883 if (end
== 0 && sym
!= NULL
&& sym
->st_size
> 0)
19884 end
= start
+ sym
->st_size
;
19888 /* FIXME: Need to properly allow for section alignment.
19889 16 is just the alignment used on x86_64. */
19891 && start
> BFD_ALIGN (global_end
, 16)
19892 /* Build notes are not guaranteed to be organised in order of
19893 increasing address, but we should find the all of the notes
19894 for one section in the same place. */
19895 && same_section (filedata
, start
, global_end
))
19896 warn (_("Gap in build notes detected from %#lx to %#lx\n"),
19897 global_end
+ 1, start
- 1);
19899 printf (_(" Applies to region from %#lx"), start
);
19900 global_offset
= start
;
19904 printf (_(" to %#lx"), end
);
19910 printf (_(" Applies to region from %#lx"), start
);
19911 func_offset
= start
;
19915 printf (_(" to %#lx"), end
);
19921 printf (_(" (%s)"), name
);
19928 print_gnu_build_attribute_name (Elf_Internal_Note
* pnote
)
19930 static const char string_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING
, 0 };
19931 static const char number_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
, 0 };
19932 static const char bool_expected
[3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
, 0 };
19934 char name_attribute
;
19935 const char * expected_types
;
19936 const char * name
= pnote
->namedata
;
19940 if (name
== NULL
|| pnote
->namesz
< 2)
19942 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
19943 print_symbol (-20, _(" <corrupt name>"));
19952 /* Version 2 of the spec adds a "GA" prefix to the name field. */
19953 if (name
[0] == 'G' && name
[1] == 'A')
19955 if (pnote
->namesz
< 4)
19957 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
19958 print_symbol (-20, _(" <corrupt name>"));
19967 switch ((name_type
= * name
))
19969 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
19970 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
19971 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
19972 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
19973 printf ("%c", * name
);
19977 error (_("unrecognised attribute type in name field: %d\n"), name_type
);
19978 print_symbol (-20, _("<unknown name type>"));
19985 switch ((name_attribute
= * name
))
19987 case GNU_BUILD_ATTRIBUTE_VERSION
:
19988 text
= _("<version>");
19989 expected_types
= string_expected
;
19992 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
19993 text
= _("<stack prot>");
19994 expected_types
= "!+*";
19997 case GNU_BUILD_ATTRIBUTE_RELRO
:
19998 text
= _("<relro>");
19999 expected_types
= bool_expected
;
20002 case GNU_BUILD_ATTRIBUTE_STACK_SIZE
:
20003 text
= _("<stack size>");
20004 expected_types
= number_expected
;
20007 case GNU_BUILD_ATTRIBUTE_TOOL
:
20008 text
= _("<tool>");
20009 expected_types
= string_expected
;
20012 case GNU_BUILD_ATTRIBUTE_ABI
:
20014 expected_types
= "$*";
20017 case GNU_BUILD_ATTRIBUTE_PIC
:
20019 expected_types
= number_expected
;
20022 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM
:
20023 text
= _("<short enum>");
20024 expected_types
= bool_expected
;
20028 if (ISPRINT (* name
))
20030 int len
= strnlen (name
, pnote
->namesz
- (name
- pnote
->namedata
)) + 1;
20032 if (len
> left
&& ! do_wide
)
20034 printf ("%.*s:", len
, name
);
20040 static char tmpbuf
[128];
20042 error (_("unrecognised byte in name field: %d\n"), * name
);
20043 sprintf (tmpbuf
, _("<unknown:_%d>"), * name
);
20047 expected_types
= "*$!+";
20052 left
-= printf ("%s", text
);
20054 if (strchr (expected_types
, name_type
) == NULL
)
20055 warn (_("attribute does not have an expected type (%c)\n"), name_type
);
20057 if ((unsigned long)(name
- pnote
->namedata
) > pnote
->namesz
)
20059 error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
20060 (unsigned long) pnote
->namesz
,
20061 (long) (name
- pnote
->namedata
));
20065 if (left
< 1 && ! do_wide
)
20070 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
20072 unsigned int bytes
;
20073 unsigned long long val
= 0;
20074 unsigned int shift
= 0;
20075 char * decoded
= NULL
;
20077 bytes
= pnote
->namesz
- (name
- pnote
->namedata
);
20079 /* The -1 is because the name field is always 0 terminated, and we
20080 want to be able to ensure that the shift in the while loop below
20081 will not overflow. */
20084 if (bytes
> sizeof (val
))
20086 error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
20088 bytes
= sizeof (val
);
20090 /* We do not bother to warn if bytes == 0 as this can
20091 happen with some early versions of the gcc plugin. */
20095 unsigned long long byte
= *name
++ & 0xff;
20097 val
|= byte
<< shift
;
20101 switch (name_attribute
)
20103 case GNU_BUILD_ATTRIBUTE_PIC
:
20106 case 0: decoded
= "static"; break;
20107 case 1: decoded
= "pic"; break;
20108 case 2: decoded
= "PIC"; break;
20109 case 3: decoded
= "pie"; break;
20110 case 4: decoded
= "PIE"; break;
20114 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
20117 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
20118 case 0: decoded
= "off"; break;
20119 case 1: decoded
= "on"; break;
20120 case 2: decoded
= "all"; break;
20121 case 3: decoded
= "strong"; break;
20122 case 4: decoded
= "explicit"; break;
20130 if (decoded
!= NULL
)
20132 print_symbol (-left
, decoded
);
20143 left
-= printf ("0x%llx", val
);
20145 left
-= printf ("0x%-.*llx", left
, val
);
20149 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
20150 left
-= print_symbol (- left
, name
);
20152 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
20153 left
-= print_symbol (- left
, "true");
20155 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
20156 left
-= print_symbol (- left
, "false");
20160 if (do_wide
&& left
> 0)
20161 printf ("%-*s", left
, " ");
20166 /* Note that by the ELF standard, the name field is already null byte
20167 terminated, and namesz includes the terminating null byte.
20168 I.E. the value of namesz for the name "FSF" is 4.
20170 If the value of namesz is zero, there is no name present. */
20173 process_note (Elf_Internal_Note
* pnote
,
20174 Filedata
* filedata
)
20176 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
20179 if (pnote
->namesz
== 0)
20180 /* If there is no note name, then use the default set of
20181 note type strings. */
20182 nt
= get_note_type (filedata
, pnote
->type
);
20184 else if (const_strneq (pnote
->namedata
, "GNU"))
20185 /* GNU-specific object file notes. */
20186 nt
= get_gnu_elf_note_type (pnote
->type
);
20188 else if (const_strneq (pnote
->namedata
, "FreeBSD"))
20189 /* FreeBSD-specific core file notes. */
20190 nt
= get_freebsd_elfcore_note_type (filedata
, pnote
->type
);
20192 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
20193 /* NetBSD-specific core file notes. */
20194 nt
= get_netbsd_elfcore_note_type (filedata
, pnote
->type
);
20196 else if (const_strneq (pnote
->namedata
, "NetBSD"))
20197 /* NetBSD-specific core file notes. */
20198 return process_netbsd_elf_note (pnote
);
20200 else if (const_strneq (pnote
->namedata
, "PaX"))
20201 /* NetBSD-specific core file notes. */
20202 return process_netbsd_elf_note (pnote
);
20204 else if (strneq (pnote
->namedata
, "SPU/", 4))
20206 /* SPU-specific core file notes. */
20207 nt
= pnote
->namedata
+ 4;
20211 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
20212 /* VMS/ia64-specific file notes. */
20213 nt
= get_ia64_vms_note_type (pnote
->type
);
20215 else if (const_strneq (pnote
->namedata
, "stapsdt"))
20216 nt
= get_stapsdt_note_type (pnote
->type
);
20219 /* Don't recognize this note name; just use the default set of
20220 note type strings. */
20221 nt
= get_note_type (filedata
, pnote
->type
);
20225 if (((const_strneq (pnote
->namedata
, "GA")
20226 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
20227 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
20228 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
20229 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
20230 print_gnu_build_attribute_name (pnote
);
20232 print_symbol (-20, name
);
20235 printf (" 0x%08lx\t%s\t", pnote
->descsz
, nt
);
20237 printf (" 0x%08lx\t%s\n", pnote
->descsz
, nt
);
20239 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
20240 return print_ia64_vms_note (pnote
);
20241 else if (const_strneq (pnote
->namedata
, "GNU"))
20242 return print_gnu_note (filedata
, pnote
);
20243 else if (const_strneq (pnote
->namedata
, "stapsdt"))
20244 return print_stapsdt_note (pnote
);
20245 else if (const_strneq (pnote
->namedata
, "CORE"))
20246 return print_core_note (pnote
);
20247 else if (((const_strneq (pnote
->namedata
, "GA")
20248 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
20249 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
20250 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
20251 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
20252 return print_gnu_build_attribute_description (pnote
, filedata
);
20258 printf (_(" description data: "));
20259 for (i
= 0; i
< pnote
->descsz
; i
++)
20260 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
20272 process_notes_at (Filedata
* filedata
,
20273 Elf_Internal_Shdr
* section
,
20278 Elf_External_Note
* pnotes
;
20279 Elf_External_Note
* external
;
20281 bfd_boolean res
= TRUE
;
20288 pnotes
= (Elf_External_Note
*) get_section_contents (section
, filedata
);
20291 if (! apply_relocations (filedata
, section
, (unsigned char *) pnotes
, length
, NULL
, NULL
))
20299 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
20302 if (pnotes
== NULL
)
20308 printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (filedata
, section
));
20310 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
20311 (unsigned long) offset
, (unsigned long) length
);
20313 /* NB: Some note sections may have alignment value of 0 or 1. gABI
20314 specifies that notes should be aligned to 4 bytes in 32-bit
20315 objects and to 8 bytes in 64-bit objects. As a Linux extension,
20316 we also support 4 byte alignment in 64-bit objects. If section
20317 alignment is less than 4, we treate alignment as 4 bytes. */
20320 else if (align
!= 4 && align
!= 8)
20322 warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
20328 printf (_(" %-20s %-10s\tDescription\n"), _("Owner"), _("Data size"));
20330 end
= (char *) pnotes
+ length
;
20331 while ((char *) external
< end
)
20333 Elf_Internal_Note inote
;
20336 char * temp
= NULL
;
20337 size_t data_remaining
= end
- (char *) external
;
20339 if (!is_ia64_vms (filedata
))
20341 /* PR binutils/15191
20342 Make sure that there is enough data to read. */
20343 min_notesz
= offsetof (Elf_External_Note
, name
);
20344 if (data_remaining
< min_notesz
)
20346 warn (ngettext ("Corrupt note: only %ld byte remains, "
20347 "not enough for a full note\n",
20348 "Corrupt note: only %ld bytes remain, "
20349 "not enough for a full note\n",
20351 (long) data_remaining
);
20354 data_remaining
-= min_notesz
;
20356 inote
.type
= BYTE_GET (external
->type
);
20357 inote
.namesz
= BYTE_GET (external
->namesz
);
20358 inote
.namedata
= external
->name
;
20359 inote
.descsz
= BYTE_GET (external
->descsz
);
20360 inote
.descdata
= ((char *) external
20361 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
20362 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
20363 next
= ((char *) external
20364 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
20368 Elf64_External_VMS_Note
*vms_external
;
20370 /* PR binutils/15191
20371 Make sure that there is enough data to read. */
20372 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
20373 if (data_remaining
< min_notesz
)
20375 warn (ngettext ("Corrupt note: only %ld byte remains, "
20376 "not enough for a full note\n",
20377 "Corrupt note: only %ld bytes remain, "
20378 "not enough for a full note\n",
20380 (long) data_remaining
);
20383 data_remaining
-= min_notesz
;
20385 vms_external
= (Elf64_External_VMS_Note
*) external
;
20386 inote
.type
= BYTE_GET (vms_external
->type
);
20387 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
20388 inote
.namedata
= vms_external
->name
;
20389 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
20390 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
20391 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
20392 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
20395 /* PR 17531: file: 3443835e. */
20396 /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
20397 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
20398 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
20399 || (size_t) (next
- inote
.descdata
) < inote
.descsz
20400 || ((size_t) (next
- inote
.descdata
)
20401 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
20403 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
20404 (unsigned long) ((char *) external
- (char *) pnotes
));
20405 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
20406 inote
.type
, inote
.namesz
, inote
.descsz
, (int) align
);
20410 external
= (Elf_External_Note
*) next
;
20412 /* Verify that name is null terminated. It appears that at least
20413 one version of Linux (RedHat 6.0) generates corefiles that don't
20414 comply with the ELF spec by failing to include the null byte in
20416 if (inote
.namesz
> 0 && inote
.namedata
[inote
.namesz
- 1] != '\0')
20418 if ((size_t) (inote
.descdata
- inote
.namedata
) == inote
.namesz
)
20420 temp
= (char *) malloc (inote
.namesz
+ 1);
20423 error (_("Out of memory allocating space for inote name\n"));
20428 memcpy (temp
, inote
.namedata
, inote
.namesz
);
20429 inote
.namedata
= temp
;
20431 inote
.namedata
[inote
.namesz
] = 0;
20434 if (! process_note (& inote
, filedata
))
20447 process_corefile_note_segments (Filedata
* filedata
)
20449 Elf_Internal_Phdr
* segment
;
20451 bfd_boolean res
= TRUE
;
20453 if (! get_program_headers (filedata
))
20456 for (i
= 0, segment
= filedata
->program_headers
;
20457 i
< filedata
->file_header
.e_phnum
;
20460 if (segment
->p_type
== PT_NOTE
)
20461 if (! process_notes_at (filedata
, NULL
,
20462 (bfd_vma
) segment
->p_offset
,
20463 (bfd_vma
) segment
->p_filesz
,
20464 (bfd_vma
) segment
->p_align
))
20472 process_v850_notes (Filedata
* filedata
, bfd_vma offset
, bfd_vma length
)
20474 Elf_External_Note
* pnotes
;
20475 Elf_External_Note
* external
;
20477 bfd_boolean res
= TRUE
;
20482 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
20484 if (pnotes
== NULL
)
20488 end
= (char*) pnotes
+ length
;
20490 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
20491 (unsigned long) offset
, (unsigned long) length
);
20493 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
20495 Elf_External_Note
* next
;
20496 Elf_Internal_Note inote
;
20498 inote
.type
= BYTE_GET (external
->type
);
20499 inote
.namesz
= BYTE_GET (external
->namesz
);
20500 inote
.namedata
= external
->name
;
20501 inote
.descsz
= BYTE_GET (external
->descsz
);
20502 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
20503 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
20505 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
20507 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
20508 inote
.descdata
= inote
.namedata
;
20512 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
20514 if ( ((char *) next
> end
)
20515 || ((char *) next
< (char *) pnotes
))
20517 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
20518 (unsigned long) ((char *) external
- (char *) pnotes
));
20519 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
20520 inote
.type
, inote
.namesz
, inote
.descsz
);
20526 /* Prevent out-of-bounds indexing. */
20527 if ( inote
.namedata
+ inote
.namesz
> end
20528 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
20530 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
20531 (unsigned long) ((char *) external
- (char *) pnotes
));
20532 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
20533 inote
.type
, inote
.namesz
, inote
.descsz
);
20537 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
20539 if (! print_v850_note (& inote
))
20542 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
20543 inote
.namesz
, inote
.descsz
);
20553 process_note_sections (Filedata
* filedata
)
20555 Elf_Internal_Shdr
* section
;
20557 unsigned int n
= 0;
20558 bfd_boolean res
= TRUE
;
20560 for (i
= 0, section
= filedata
->section_headers
;
20561 i
< filedata
->file_header
.e_shnum
&& section
!= NULL
;
20564 if (section
->sh_type
== SHT_NOTE
)
20566 if (! process_notes_at (filedata
, section
,
20567 (bfd_vma
) section
->sh_offset
,
20568 (bfd_vma
) section
->sh_size
,
20569 (bfd_vma
) section
->sh_addralign
))
20574 if (( filedata
->file_header
.e_machine
== EM_V800
20575 || filedata
->file_header
.e_machine
== EM_V850
20576 || filedata
->file_header
.e_machine
== EM_CYGNUS_V850
)
20577 && section
->sh_type
== SHT_RENESAS_INFO
)
20579 if (! process_v850_notes (filedata
,
20580 (bfd_vma
) section
->sh_offset
,
20581 (bfd_vma
) section
->sh_size
))
20588 /* Try processing NOTE segments instead. */
20589 return process_corefile_note_segments (filedata
);
20595 process_notes (Filedata
* filedata
)
20597 /* If we have not been asked to display the notes then do nothing. */
20601 if (filedata
->file_header
.e_type
!= ET_CORE
)
20602 return process_note_sections (filedata
);
20604 /* No program headers means no NOTE segment. */
20605 if (filedata
->file_header
.e_phnum
> 0)
20606 return process_corefile_note_segments (filedata
);
20608 printf (_("No note segments present in the core file.\n"));
20612 static unsigned char *
20613 display_public_gnu_attributes (unsigned char * start
,
20614 const unsigned char * const end
)
20616 printf (_(" Unknown GNU attribute: %s\n"), start
);
20618 start
+= strnlen ((char *) start
, end
- start
);
20619 display_raw_attribute (start
, end
);
20621 return (unsigned char *) end
;
20624 static unsigned char *
20625 display_generic_attribute (unsigned char * start
,
20627 const unsigned char * const end
)
20630 return (unsigned char *) end
;
20632 return display_tag_value (tag
, start
, end
);
20636 process_arch_specific (Filedata
* filedata
)
20641 switch (filedata
->file_header
.e_machine
)
20644 case EM_ARC_COMPACT
:
20645 case EM_ARC_COMPACT2
:
20646 return process_attributes (filedata
, "ARC", SHT_ARC_ATTRIBUTES
,
20647 display_arc_attribute
,
20648 display_generic_attribute
);
20650 return process_attributes (filedata
, "aeabi", SHT_ARM_ATTRIBUTES
,
20651 display_arm_attribute
,
20652 display_generic_attribute
);
20655 case EM_MIPS_RS3_LE
:
20656 return process_mips_specific (filedata
);
20659 return process_attributes (filedata
, "mspabi", SHT_MSP430_ATTRIBUTES
,
20660 display_msp430_attribute
,
20661 display_msp430_gnu_attribute
);
20664 return process_attributes (filedata
, "riscv", SHT_RISCV_ATTRIBUTES
,
20665 display_riscv_attribute
,
20666 display_generic_attribute
);
20669 return process_nds32_specific (filedata
);
20672 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
20673 display_m68k_gnu_attribute
);
20677 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
20678 display_power_gnu_attribute
);
20682 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
20683 display_s390_gnu_attribute
);
20686 case EM_SPARC32PLUS
:
20688 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
20689 display_sparc_gnu_attribute
);
20692 return process_attributes (filedata
, "c6xabi", SHT_C6000_ATTRIBUTES
,
20693 display_tic6x_attribute
,
20694 display_generic_attribute
);
20697 return process_attributes (filedata
, "csky", SHT_CSKY_ATTRIBUTES
,
20698 display_csky_attribute
, NULL
);
20701 return process_attributes (filedata
, "gnu", SHT_GNU_ATTRIBUTES
,
20702 display_public_gnu_attributes
,
20703 display_generic_attribute
);
20708 get_file_header (Filedata
* filedata
)
20710 /* Read in the identity array. */
20711 if (fread (filedata
->file_header
.e_ident
, EI_NIDENT
, 1, filedata
->handle
) != 1)
20714 /* Determine how to read the rest of the header. */
20715 switch (filedata
->file_header
.e_ident
[EI_DATA
])
20720 byte_get
= byte_get_little_endian
;
20721 byte_put
= byte_put_little_endian
;
20724 byte_get
= byte_get_big_endian
;
20725 byte_put
= byte_put_big_endian
;
20729 /* For now we only support 32 bit and 64 bit ELF files. */
20730 is_32bit_elf
= (filedata
->file_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
20732 /* Read in the rest of the header. */
20735 Elf32_External_Ehdr ehdr32
;
20737 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
20740 filedata
->file_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
20741 filedata
->file_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
20742 filedata
->file_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
20743 filedata
->file_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
20744 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
20745 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
20746 filedata
->file_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
20747 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
20748 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
20749 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
20750 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
20751 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
20752 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
20756 Elf64_External_Ehdr ehdr64
;
20758 /* If we have been compiled with sizeof (bfd_vma) == 4, then
20759 we will not be able to cope with the 64bit data found in
20760 64 ELF files. Detect this now and abort before we start
20761 overwriting things. */
20762 if (sizeof (bfd_vma
) < 8)
20764 error (_("This instance of readelf has been built without support for a\n\
20765 64 bit data type and so it cannot read 64 bit ELF files.\n"));
20769 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
20772 filedata
->file_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
20773 filedata
->file_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
20774 filedata
->file_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
20775 filedata
->file_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
20776 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
20777 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
20778 filedata
->file_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
20779 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
20780 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
20781 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
20782 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
20783 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
20784 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
20787 if (filedata
->file_header
.e_shoff
)
20789 /* There may be some extensions in the first section header. Don't
20790 bomb if we can't read it. */
20792 get_32bit_section_headers (filedata
, TRUE
);
20794 get_64bit_section_headers (filedata
, TRUE
);
20801 close_file (Filedata
* filedata
)
20805 if (filedata
->handle
)
20806 fclose (filedata
->handle
);
20812 close_debug_file (void * data
)
20814 close_file ((Filedata
*) data
);
20818 open_file (const char * pathname
)
20820 struct stat statbuf
;
20821 Filedata
* filedata
= NULL
;
20823 if (stat (pathname
, & statbuf
) < 0
20824 || ! S_ISREG (statbuf
.st_mode
))
20827 filedata
= calloc (1, sizeof * filedata
);
20828 if (filedata
== NULL
)
20831 filedata
->handle
= fopen (pathname
, "rb");
20832 if (filedata
->handle
== NULL
)
20835 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
20836 filedata
->file_name
= pathname
;
20838 if (! get_file_header (filedata
))
20841 if (filedata
->file_header
.e_shoff
)
20845 /* Read the section headers again, this time for real. */
20847 res
= get_32bit_section_headers (filedata
, FALSE
);
20849 res
= get_64bit_section_headers (filedata
, FALSE
);
20860 if (filedata
->handle
)
20861 fclose (filedata
->handle
);
20868 open_debug_file (const char * pathname
)
20870 return open_file (pathname
);
20873 /* Process one ELF object file according to the command line options.
20874 This file may actually be stored in an archive. The file is
20875 positioned at the start of the ELF object. Returns TRUE if no
20876 problems were encountered, FALSE otherwise. */
20879 process_object (Filedata
* filedata
)
20881 bfd_boolean have_separate_files
;
20885 if (! get_file_header (filedata
))
20887 error (_("%s: Failed to read file header\n"), filedata
->file_name
);
20891 /* Initialise per file variables. */
20892 for (i
= ARRAY_SIZE (filedata
->version_info
); i
--;)
20893 filedata
->version_info
[i
] = 0;
20895 for (i
= ARRAY_SIZE (filedata
->dynamic_info
); i
--;)
20896 filedata
->dynamic_info
[i
] = 0;
20897 filedata
->dynamic_info_DT_GNU_HASH
= 0;
20898 filedata
->dynamic_info_DT_MIPS_XHASH
= 0;
20900 /* Process the file. */
20902 printf (_("\nFile: %s\n"), filedata
->file_name
);
20904 /* Initialise the dump_sects array from the cmdline_dump_sects array.
20905 Note we do this even if cmdline_dump_sects is empty because we
20906 must make sure that the dump_sets array is zeroed out before each
20907 object file is processed. */
20908 if (filedata
->dump
.num_dump_sects
> cmdline
.num_dump_sects
)
20909 memset (filedata
->dump
.dump_sects
, 0,
20910 filedata
->dump
.num_dump_sects
* sizeof (*filedata
->dump
.dump_sects
));
20912 if (cmdline
.num_dump_sects
> 0)
20914 if (filedata
->dump
.num_dump_sects
== 0)
20915 /* A sneaky way of allocating the dump_sects array. */
20916 request_dump_bynumber (&filedata
->dump
, cmdline
.num_dump_sects
, 0);
20918 assert (filedata
->dump
.num_dump_sects
>= cmdline
.num_dump_sects
);
20919 memcpy (filedata
->dump
.dump_sects
, cmdline
.dump_sects
,
20920 cmdline
.num_dump_sects
* sizeof (*filedata
->dump
.dump_sects
));
20923 if (! process_file_header (filedata
))
20926 if (! process_section_headers (filedata
))
20928 /* Without loaded section headers we cannot process lots of things. */
20929 do_unwind
= do_version
= do_dump
= do_arch
= FALSE
;
20931 if (! do_using_dynamic
)
20932 do_syms
= do_dyn_syms
= do_reloc
= FALSE
;
20935 if (! process_section_groups (filedata
))
20936 /* Without loaded section groups we cannot process unwind. */
20939 res
= process_program_headers (filedata
);
20941 res
= process_dynamic_section (filedata
);
20943 if (! process_relocs (filedata
))
20946 if (! process_unwind (filedata
))
20949 if (! process_symbol_table (filedata
))
20952 if (! process_lto_symbol_tables (filedata
))
20955 if (! process_syminfo (filedata
))
20958 if (! process_version_sections (filedata
))
20961 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
)
20962 have_separate_files
= load_separate_debug_files (filedata
, filedata
->file_name
);
20964 have_separate_files
= FALSE
;
20966 if (! process_section_contents (filedata
))
20969 if (have_separate_files
)
20973 for (d
= first_separate_info
; d
!= NULL
; d
= d
->next
)
20975 if (! process_section_headers (d
->handle
))
20977 else if (! process_section_contents (d
->handle
))
20981 /* The file handles are closed by the call to free_debug_memory() below. */
20984 if (! process_notes (filedata
))
20987 if (! process_gnu_liblist (filedata
))
20990 if (! process_arch_specific (filedata
))
20993 free (filedata
->program_headers
);
20994 filedata
->program_headers
= NULL
;
20996 free (filedata
->section_headers
);
20997 filedata
->section_headers
= NULL
;
20999 free (filedata
->string_table
);
21000 filedata
->string_table
= NULL
;
21001 filedata
->string_table_length
= 0;
21003 free (filedata
->dump
.dump_sects
);
21004 filedata
->dump
.dump_sects
= NULL
;
21005 filedata
->dump
.num_dump_sects
= 0;
21007 free (filedata
->dynamic_strings
);
21008 filedata
->dynamic_strings
= NULL
;
21009 filedata
->dynamic_strings_length
= 0;
21011 free (filedata
->dynamic_symbols
);
21012 filedata
->dynamic_symbols
= NULL
;
21013 filedata
->num_dynamic_syms
= 0;
21015 free (filedata
->dynamic_syminfo
);
21016 filedata
->dynamic_syminfo
= NULL
;
21018 free (filedata
->dynamic_section
);
21019 filedata
->dynamic_section
= NULL
;
21021 while (filedata
->symtab_shndx_list
!= NULL
)
21023 elf_section_list
*next
= filedata
->symtab_shndx_list
->next
;
21024 free (filedata
->symtab_shndx_list
);
21025 filedata
->symtab_shndx_list
= next
;
21028 free (filedata
->section_headers_groups
);
21029 filedata
->section_headers_groups
= NULL
;
21031 if (filedata
->section_groups
)
21033 struct group_list
* g
;
21034 struct group_list
* next
;
21036 for (i
= 0; i
< filedata
->group_count
; i
++)
21038 for (g
= filedata
->section_groups
[i
].root
; g
!= NULL
; g
= next
)
21045 free (filedata
->section_groups
);
21046 filedata
->section_groups
= NULL
;
21049 free_debug_memory ();
21054 /* Process an ELF archive.
21055 On entry the file is positioned just after the ARMAG string.
21056 Returns TRUE upon success, FALSE otherwise. */
21059 process_archive (Filedata
* filedata
, bfd_boolean is_thin_archive
)
21061 struct archive_info arch
;
21062 struct archive_info nested_arch
;
21064 bfd_boolean ret
= TRUE
;
21068 /* The ARCH structure is used to hold information about this archive. */
21069 arch
.file_name
= NULL
;
21071 arch
.index_array
= NULL
;
21072 arch
.sym_table
= NULL
;
21073 arch
.longnames
= NULL
;
21075 /* The NESTED_ARCH structure is used as a single-item cache of information
21076 about a nested archive (when members of a thin archive reside within
21077 another regular archive file). */
21078 nested_arch
.file_name
= NULL
;
21079 nested_arch
.file
= NULL
;
21080 nested_arch
.index_array
= NULL
;
21081 nested_arch
.sym_table
= NULL
;
21082 nested_arch
.longnames
= NULL
;
21084 if (setup_archive (&arch
, filedata
->file_name
, filedata
->handle
,
21085 filedata
->file_size
, is_thin_archive
,
21086 do_archive_index
) != 0)
21092 if (do_archive_index
)
21094 if (arch
.sym_table
== NULL
)
21095 error (_("%s: unable to dump the index as none was found\n"),
21096 filedata
->file_name
);
21099 unsigned long i
, l
;
21100 unsigned long current_pos
;
21102 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes "
21103 "in the symbol table)\n"),
21104 filedata
->file_name
, (unsigned long) arch
.index_num
,
21107 current_pos
= ftell (filedata
->handle
);
21109 for (i
= l
= 0; i
< arch
.index_num
; i
++)
21112 || (i
> 0 && arch
.index_array
[i
] != arch
.index_array
[i
- 1]))
21115 = get_archive_member_name_at (&arch
, arch
.index_array
[i
],
21118 if (member_name
!= NULL
)
21120 char * qualified_name
21121 = make_qualified_name (&arch
, &nested_arch
,
21124 if (qualified_name
!= NULL
)
21126 printf (_("Contents of binary %s at offset "),
21128 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
21130 free (qualified_name
);
21132 free (member_name
);
21136 if (l
>= arch
.sym_size
)
21138 error (_("%s: end of the symbol table reached "
21139 "before the end of the index\n"),
21140 filedata
->file_name
);
21144 /* PR 17531: file: 0b6630b2. */
21145 printf ("\t%.*s\n",
21146 (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
21147 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
21150 if (arch
.uses_64bit_indices
)
21155 if (l
< arch
.sym_size
)
21157 error (ngettext ("%s: %ld byte remains in the symbol table, "
21158 "but without corresponding entries in "
21159 "the index table\n",
21160 "%s: %ld bytes remain in the symbol table, "
21161 "but without corresponding entries in "
21162 "the index table\n",
21163 arch
.sym_size
- l
),
21164 filedata
->file_name
, arch
.sym_size
- l
);
21168 if (fseek (filedata
->handle
, current_pos
, SEEK_SET
) != 0)
21170 error (_("%s: failed to seek back to start of object files "
21171 "in the archive\n"),
21172 filedata
->file_name
);
21178 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
21179 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
21180 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
21181 && !do_section_groups
&& !do_dyn_syms
)
21183 ret
= TRUE
; /* Archive index only. */
21192 char * qualified_name
;
21194 /* Read the next archive header. */
21195 if (fseek (filedata
->handle
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
21197 error (_("%s: failed to seek to next archive header\n"),
21202 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, filedata
->handle
);
21203 if (got
!= sizeof arch
.arhdr
)
21207 /* PR 24049 - we cannot use filedata->file_name as this will
21208 have already been freed. */
21209 error (_("%s: failed to read archive header\n"), arch
.file_name
);
21214 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
21216 error (_("%s: did not find a valid archive header\n"),
21222 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
21224 filedata
->archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
21225 if (filedata
->archive_file_size
& 01)
21226 ++filedata
->archive_file_size
;
21228 name
= get_archive_member_name (&arch
, &nested_arch
);
21231 error (_("%s: bad archive file name\n"), arch
.file_name
);
21235 namelen
= strlen (name
);
21237 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
21238 if (qualified_name
== NULL
)
21240 error (_("%s: bad archive file name\n"), arch
.file_name
);
21246 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
21248 /* This is a proxy for an external member of a thin archive. */
21249 Filedata
* member_filedata
;
21250 char * member_file_name
= adjust_relative_path
21251 (filedata
->file_name
, name
, namelen
);
21254 if (member_file_name
== NULL
)
21256 free (qualified_name
);
21261 member_filedata
= open_file (member_file_name
);
21262 if (member_filedata
== NULL
)
21264 error (_("Input file '%s' is not readable.\n"), member_file_name
);
21265 free (member_file_name
);
21266 free (qualified_name
);
21271 filedata
->archive_file_offset
= arch
.nested_member_origin
;
21272 member_filedata
->file_name
= qualified_name
;
21274 if (! process_object (member_filedata
))
21277 close_file (member_filedata
);
21278 free (member_file_name
);
21280 else if (is_thin_archive
)
21282 Filedata thin_filedata
;
21284 memset (&thin_filedata
, 0, sizeof (thin_filedata
));
21286 /* PR 15140: Allow for corrupt thin archives. */
21287 if (nested_arch
.file
== NULL
)
21289 error (_("%s: contains corrupt thin archive: %s\n"),
21290 qualified_name
, name
);
21291 free (qualified_name
);
21298 /* This is a proxy for a member of a nested archive. */
21299 filedata
->archive_file_offset
21300 = arch
.nested_member_origin
+ sizeof arch
.arhdr
;
21302 /* The nested archive file will have been opened and setup by
21303 get_archive_member_name. */
21304 if (fseek (nested_arch
.file
, filedata
->archive_file_offset
,
21307 error (_("%s: failed to seek to archive member.\n"),
21308 nested_arch
.file_name
);
21309 free (qualified_name
);
21314 thin_filedata
.handle
= nested_arch
.file
;
21315 thin_filedata
.file_name
= qualified_name
;
21317 if (! process_object (& thin_filedata
))
21323 filedata
->archive_file_offset
= arch
.next_arhdr_offset
;
21324 filedata
->file_name
= qualified_name
;
21325 if (! process_object (filedata
))
21327 arch
.next_arhdr_offset
+= filedata
->archive_file_size
;
21328 /* Stop looping with "negative" archive_file_size. */
21329 if (arch
.next_arhdr_offset
< filedata
->archive_file_size
)
21330 arch
.next_arhdr_offset
= -1ul;
21333 free (qualified_name
);
21337 if (nested_arch
.file
!= NULL
)
21338 fclose (nested_arch
.file
);
21339 release_archive (&nested_arch
);
21340 release_archive (&arch
);
21346 process_file (char * file_name
)
21348 Filedata
* filedata
= NULL
;
21349 struct stat statbuf
;
21350 char armag
[SARMAG
];
21351 bfd_boolean ret
= TRUE
;
21353 if (stat (file_name
, &statbuf
) < 0)
21355 if (errno
== ENOENT
)
21356 error (_("'%s': No such file\n"), file_name
);
21358 error (_("Could not locate '%s'. System error message: %s\n"),
21359 file_name
, strerror (errno
));
21363 if (! S_ISREG (statbuf
.st_mode
))
21365 error (_("'%s' is not an ordinary file\n"), file_name
);
21369 filedata
= calloc (1, sizeof * filedata
);
21370 if (filedata
== NULL
)
21372 error (_("Out of memory allocating file data structure\n"));
21376 filedata
->file_name
= file_name
;
21377 filedata
->handle
= fopen (file_name
, "rb");
21378 if (filedata
->handle
== NULL
)
21380 error (_("Input file '%s' is not readable.\n"), file_name
);
21385 if (fread (armag
, SARMAG
, 1, filedata
->handle
) != 1)
21387 error (_("%s: Failed to read file's magic number\n"), file_name
);
21388 fclose (filedata
->handle
);
21393 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
21395 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
21397 if (! process_archive (filedata
, FALSE
))
21400 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
21402 if ( ! process_archive (filedata
, TRUE
))
21407 if (do_archive_index
&& !check_all
)
21408 error (_("File %s is not an archive so its index cannot be displayed.\n"),
21411 rewind (filedata
->handle
);
21412 filedata
->archive_file_size
= filedata
->archive_file_offset
= 0;
21414 if (! process_object (filedata
))
21418 fclose (filedata
->handle
);
21419 free (filedata
->section_headers
);
21420 free (filedata
->program_headers
);
21421 free (filedata
->string_table
);
21422 free (filedata
->dump
.dump_sects
);
21425 free (ba_cache
.strtab
);
21426 ba_cache
.strtab
= NULL
;
21427 free (ba_cache
.symtab
);
21428 ba_cache
.symtab
= NULL
;
21429 ba_cache
.filedata
= NULL
;
21434 #ifdef SUPPORT_DISASSEMBLY
21435 /* Needed by the i386 disassembler. For extra credit, someone could
21436 fix this so that we insert symbolic addresses here, esp for GOT/PLT
21440 print_address (unsigned int addr
, FILE * outfile
)
21442 fprintf (outfile
,"0x%8.8x", addr
);
21445 /* Needed by the i386 disassembler. */
21448 db_task_printsym (unsigned int addr
)
21450 print_address (addr
, stderr
);
21455 main (int argc
, char ** argv
)
21459 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
21460 setlocale (LC_MESSAGES
, "");
21462 #if defined (HAVE_SETLOCALE)
21463 setlocale (LC_CTYPE
, "");
21465 bindtextdomain (PACKAGE
, LOCALEDIR
);
21466 textdomain (PACKAGE
);
21468 expandargv (&argc
, &argv
);
21470 parse_args (& cmdline
, argc
, argv
);
21472 if (optind
< (argc
- 1))
21473 /* When displaying information for more than one file,
21474 prefix the information with the file name. */
21476 else if (optind
>= argc
)
21478 /* Ensure that the warning is always displayed. */
21481 warn (_("Nothing to do.\n"));
21486 while (optind
< argc
)
21487 if (! process_file (argv
[optind
++]))
21490 free (cmdline
.dump_sects
);
21492 free (dump_ctf_symtab_name
);
21493 free (dump_ctf_strtab_name
);
21494 free (dump_ctf_parent_name
);
21496 return err
? EXIT_FAILURE
: EXIT_SUCCESS
;