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";
2235 case DT_GNU_FLAGS_1
: return "GNU_FLAGS_1";
2238 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
2240 const char * result
;
2242 switch (filedata
->file_header
.e_machine
)
2245 result
= get_aarch64_dynamic_type (type
);
2248 case EM_MIPS_RS3_LE
:
2249 result
= get_mips_dynamic_type (type
);
2252 result
= get_sparc64_dynamic_type (type
);
2255 result
= get_ppc_dynamic_type (type
);
2258 result
= get_ppc64_dynamic_type (type
);
2261 result
= get_ia64_dynamic_type (type
);
2264 result
= get_alpha_dynamic_type (type
);
2267 result
= get_score_dynamic_type (type
);
2270 result
= get_tic6x_dynamic_type (type
);
2272 case EM_ALTERA_NIOS2
:
2273 result
= get_nios2_dynamic_type (type
);
2276 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2277 result
= get_solaris_dynamic_type (type
);
2286 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
2288 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
2289 || (filedata
->file_header
.e_machine
== EM_PARISC
2290 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
2292 const char * result
;
2294 switch (filedata
->file_header
.e_machine
)
2297 result
= get_parisc_dynamic_type (type
);
2300 result
= get_ia64_dynamic_type (type
);
2303 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2304 result
= get_solaris_dynamic_type (type
);
2313 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
2317 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
2324 get_file_type (unsigned e_type
)
2326 static char buff
[64];
2330 case ET_NONE
: return _("NONE (None)");
2331 case ET_REL
: return _("REL (Relocatable file)");
2332 case ET_EXEC
: return _("EXEC (Executable file)");
2333 case ET_DYN
: return _("DYN (Shared object file)");
2334 case ET_CORE
: return _("CORE (Core file)");
2337 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
2338 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
2339 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
2340 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
2342 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
2348 get_machine_name (unsigned e_machine
)
2350 static char buff
[64]; /* XXX */
2354 /* Please keep this switch table sorted by increasing EM_ value. */
2356 case EM_NONE
: return _("None");
2357 case EM_M32
: return "WE32100";
2358 case EM_SPARC
: return "Sparc";
2359 case EM_386
: return "Intel 80386";
2360 case EM_68K
: return "MC68000";
2361 case EM_88K
: return "MC88000";
2362 case EM_IAMCU
: return "Intel MCU";
2363 case EM_860
: return "Intel 80860";
2364 case EM_MIPS
: return "MIPS R3000";
2365 case EM_S370
: return "IBM System/370";
2367 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
2368 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
2369 case EM_PARISC
: return "HPPA";
2370 case EM_VPP550
: return "Fujitsu VPP500";
2371 case EM_SPARC32PLUS
: return "Sparc v8+" ;
2372 case EM_960
: return "Intel 80960";
2373 case EM_PPC
: return "PowerPC";
2375 case EM_PPC64
: return "PowerPC64";
2377 case EM_S390
: return "IBM S/390";
2378 case EM_SPU
: return "SPU";
2380 case EM_V800
: return "Renesas V850 (using RH850 ABI)";
2381 case EM_FR20
: return "Fujitsu FR20";
2382 case EM_RH32
: return "TRW RH32";
2383 case EM_MCORE
: return "MCORE";
2385 case EM_ARM
: return "ARM";
2386 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
2387 case EM_SH
: return "Renesas / SuperH SH";
2388 case EM_SPARCV9
: return "Sparc v9";
2389 case EM_TRICORE
: return "Siemens Tricore";
2390 case EM_ARC
: return "ARC";
2391 case EM_H8_300
: return "Renesas H8/300";
2392 case EM_H8_300H
: return "Renesas H8/300H";
2393 case EM_H8S
: return "Renesas H8S";
2394 case EM_H8_500
: return "Renesas H8/500";
2396 case EM_IA_64
: return "Intel IA-64";
2397 case EM_MIPS_X
: return "Stanford MIPS-X";
2398 case EM_COLDFIRE
: return "Motorola Coldfire";
2399 case EM_68HC12
: return "Motorola MC68HC12 Microcontroller";
2400 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
2401 case EM_PCP
: return "Siemens PCP";
2402 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
2403 case EM_NDR1
: return "Denso NDR1 microprocesspr";
2404 case EM_STARCORE
: return "Motorola Star*Core processor";
2405 case EM_ME16
: return "Toyota ME16 processor";
2407 case EM_ST100
: return "STMicroelectronics ST100 processor";
2408 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
2409 case EM_X86_64
: return "Advanced Micro Devices X86-64";
2410 case EM_PDSP
: return "Sony DSP processor";
2411 case EM_PDP10
: return "Digital Equipment Corp. PDP-10";
2412 case EM_PDP11
: return "Digital Equipment Corp. PDP-11";
2413 case EM_FX66
: return "Siemens FX66 microcontroller";
2414 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2415 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
2416 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
2418 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
2419 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
2420 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
2421 case EM_SVX
: return "Silicon Graphics SVx";
2422 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
2423 case EM_VAX
: return "Digital VAX";
2424 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
2425 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
2426 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
2427 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
2429 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
2430 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
2431 case EM_PRISM
: return "Vitesse Prism";
2433 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
2434 case EM_CYGNUS_FR30
:
2435 case EM_FR30
: return "Fujitsu FR30";
2436 case EM_CYGNUS_D10V
:
2437 case EM_D10V
: return "d10v";
2438 case EM_CYGNUS_D30V
:
2439 case EM_D30V
: return "d30v";
2440 case EM_CYGNUS_V850
:
2441 case EM_V850
: return "Renesas V850";
2442 case EM_CYGNUS_M32R
:
2443 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
2444 case EM_CYGNUS_MN10300
:
2445 case EM_MN10300
: return "mn10300";
2447 case EM_CYGNUS_MN10200
:
2448 case EM_MN10200
: return "mn10200";
2449 case EM_PJ
: return "picoJava";
2450 case EM_OR1K
: return "OpenRISC 1000";
2451 case EM_ARC_COMPACT
: return "ARCompact";
2453 case EM_XTENSA
: return "Tensilica Xtensa Processor";
2454 case EM_VIDEOCORE
: return "Alphamosaic VideoCore processor";
2455 case EM_TMM_GPP
: return "Thompson Multimedia General Purpose Processor";
2456 case EM_NS32K
: return "National Semiconductor 32000 series";
2457 case EM_TPC
: return "Tenor Network TPC processor";
2458 case EM_SNP1K
: return "Trebia SNP 1000 processor";
2460 case EM_ST200
: return "STMicroelectronics ST200 microcontroller";
2462 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
2463 case EM_MAX
: return "MAX Processor";
2464 case EM_CR
: return "National Semiconductor CompactRISC";
2465 case EM_F2MC16
: return "Fujitsu F2MC16";
2466 case EM_MSP430
: return "Texas Instruments msp430 microcontroller";
2467 case EM_BLACKFIN
: return "Analog Devices Blackfin";
2468 case EM_SE_C33
: return "S1C33 Family of Seiko Epson processors";
2469 case EM_SEP
: return "Sharp embedded microprocessor";
2470 case EM_ARCA
: return "Arca RISC microprocessor";
2472 case EM_UNICORE
: return "Unicore";
2473 case EM_EXCESS
: return "eXcess 16/32/64-bit configurable embedded CPU";
2474 case EM_DXP
: return "Icera Semiconductor Inc. Deep Execution Processor";
2475 case EM_ALTERA_NIOS2
: return "Altera Nios II";
2476 case EM_CRX
: return "National Semiconductor CRX microprocessor";
2477 case EM_XGATE
: return "Motorola XGATE embedded processor";
2479 case EM_XC16X
: return "Infineon Technologies xc16x";
2480 case EM_M16C
: return "Renesas M16C series microprocessors";
2481 case EM_DSPIC30F
: return "Microchip Technology dsPIC30F Digital Signal Controller";
2482 case EM_CE
: return "Freescale Communication Engine RISC core";
2484 case EM_M32C
: return "Renesas M32c";
2486 case EM_TSK3000
: return "Altium TSK3000 core";
2487 case EM_RS08
: return "Freescale RS08 embedded processor";
2488 case EM_ECOG2
: return "Cyan Technology eCOG2 microprocessor";
2489 case EM_SCORE
: return "SUNPLUS S+Core";
2490 case EM_DSP24
: return "New Japan Radio (NJR) 24-bit DSP Processor";
2491 case EM_VIDEOCORE3
: return "Broadcom VideoCore III processor";
2492 case EM_LATTICEMICO32
: return "Lattice Mico32";
2493 case EM_SE_C17
: return "Seiko Epson C17 family";
2495 case EM_TI_C6000
: return "Texas Instruments TMS320C6000 DSP family";
2496 case EM_TI_C2000
: return "Texas Instruments TMS320C2000 DSP family";
2497 case EM_TI_C5500
: return "Texas Instruments TMS320C55x DSP family";
2498 case EM_TI_PRU
: return "TI PRU I/O processor";
2500 case EM_MMDSP_PLUS
: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2501 case EM_CYPRESS_M8C
: return "Cypress M8C microprocessor";
2502 case EM_R32C
: return "Renesas R32C series microprocessors";
2503 case EM_TRIMEDIA
: return "NXP Semiconductors TriMedia architecture family";
2504 case EM_QDSP6
: return "QUALCOMM DSP6 Processor";
2505 case EM_8051
: return "Intel 8051 and variants";
2506 case EM_STXP7X
: return "STMicroelectronics STxP7x family";
2507 case EM_NDS32
: return "Andes Technology compact code size embedded RISC processor family";
2508 case EM_ECOG1X
: return "Cyan Technology eCOG1X family";
2509 case EM_MAXQ30
: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2511 case EM_XIMO16
: return "New Japan Radio (NJR) 16-bit DSP Processor";
2512 case EM_MANIK
: return "M2000 Reconfigurable RISC Microprocessor";
2513 case EM_CRAYNV2
: return "Cray Inc. NV2 vector architecture";
2514 case EM_RX
: return "Renesas RX";
2515 case EM_METAG
: return "Imagination Technologies Meta processor architecture";
2516 case EM_MCST_ELBRUS
: return "MCST Elbrus general purpose hardware architecture";
2517 case EM_ECOG16
: return "Cyan Technology eCOG16 family";
2520 case EM_MICROBLAZE_OLD
: return "Xilinx MicroBlaze";
2521 case EM_ETPU
: return "Freescale Extended Time Processing Unit";
2522 case EM_SLE9X
: return "Infineon Technologies SLE9X core";
2524 case EM_L1OM
: return "Intel L1OM";
2525 case EM_K1OM
: return "Intel K1OM";
2526 case EM_INTEL182
: return "Intel (reserved)";
2527 case EM_AARCH64
: return "AArch64";
2528 case EM_ARM184
: return "ARM (reserved)";
2529 case EM_AVR32
: return "Atmel Corporation 32-bit microprocessor";
2530 case EM_STM8
: return "STMicroeletronics STM8 8-bit microcontroller";
2531 case EM_TILE64
: return "Tilera TILE64 multicore architecture family";
2532 case EM_TILEPRO
: return "Tilera TILEPro multicore architecture family";
2534 case EM_CUDA
: return "NVIDIA CUDA architecture";
2535 case EM_TILEGX
: return "Tilera TILE-Gx multicore architecture family";
2536 case EM_CLOUDSHIELD
: return "CloudShield architecture family";
2537 case EM_COREA_1ST
: return "KIPO-KAIST Core-A 1st generation processor family";
2538 case EM_COREA_2ND
: return "KIPO-KAIST Core-A 2nd generation processor family";
2539 case EM_ARC_COMPACT2
: return "ARCv2";
2540 case EM_OPEN8
: return "Open8 8-bit RISC soft processor core";
2541 case EM_RL78
: return "Renesas RL78";
2542 case EM_VIDEOCORE5
: return "Broadcom VideoCore V processor";
2543 case EM_78K0R
: return "Renesas 78K0R";
2545 case EM_56800EX
: return "Freescale 56800EX Digital Signal Controller (DSC)";
2546 case EM_BA1
: return "Beyond BA1 CPU architecture";
2547 case EM_BA2
: return "Beyond BA2 CPU architecture";
2548 case EM_XCORE
: return "XMOS xCORE processor family";
2549 case EM_MCHP_PIC
: return "Microchip 8-bit PIC(r) family";
2551 case EM_KM32
: return "KM211 KM32 32-bit processor";
2552 case EM_KMX32
: return "KM211 KMX32 32-bit processor";
2553 case EM_KMX16
: return "KM211 KMX16 16-bit processor";
2554 case EM_KMX8
: return "KM211 KMX8 8-bit processor";
2555 case EM_KVARC
: return "KM211 KVARC processor";
2556 case EM_CDP
: return "Paneve CDP architecture family";
2557 case EM_COGE
: return "Cognitive Smart Memory Processor";
2558 case EM_COOL
: return "Bluechip Systems CoolEngine";
2559 case EM_NORC
: return "Nanoradio Optimized RISC";
2560 case EM_CSR_KALIMBA
: return "CSR Kalimba architecture family";
2562 case EM_Z80
: return "Zilog Z80";
2563 case EM_VISIUM
: return "CDS VISIUMcore processor";
2564 case EM_FT32
: return "FTDI Chip FT32";
2565 case EM_MOXIE
: return "Moxie";
2566 case EM_AMDGPU
: return "AMD GPU";
2567 /* 230 (all reserved) */
2569 case EM_RISCV
: return "RISC-V";
2570 case EM_LANAI
: return "Lanai 32-bit processor";
2571 case EM_CEVA
: return "CEVA Processor Architecture Family";
2572 case EM_CEVA_X2
: return "CEVA X2 Processor Family";
2573 case EM_BPF
: return "Linux BPF";
2574 case EM_GRAPHCORE_IPU
: return "Graphcore Intelligent Processing Unit";
2575 case EM_IMG1
: return "Imagination Technologies";
2577 case EM_NFP
: return "Netronome Flow Processor";
2578 case EM_VE
: return "NEC Vector Engine";
2579 case EM_CSKY
: return "C-SKY";
2580 case EM_ARC_COMPACT3_64
: return "Synopsys ARCv2.3 64-bit";
2581 case EM_MCS6502
: return "MOS Technology MCS 6502 processor";
2582 case EM_ARC_COMPACT3
: return "Synopsys ARCv2.3 32-bit";
2583 case EM_KVX
: return "Kalray VLIW core of the MPPA processor family";
2584 case EM_65816
: return "WDC 65816/65C816";
2585 case EM_LOONGARCH
: return "Loongson Loongarch";
2586 case EM_KF32
: return "ChipON KungFu32";
2588 /* Large numbers... */
2589 case EM_MT
: return "Morpho Techologies MT processor";
2590 case EM_ALPHA
: return "Alpha";
2591 case EM_WEBASSEMBLY
: return "Web Assembly";
2592 case EM_DLX
: return "OpenDLX";
2593 case EM_XSTORMY16
: return "Sanyo XStormy16 CPU core";
2594 case EM_IQ2000
: return "Vitesse IQ2000";
2596 case EM_NIOS32
: return "Altera Nios";
2597 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
2598 case EM_ADAPTEVA_EPIPHANY
: return "Adapteva EPIPHANY";
2599 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
2600 case EM_S12Z
: return "Freescale S12Z";
2603 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
2609 decode_ARC_machine_flags (unsigned e_flags
, unsigned e_machine
, char buf
[])
2611 /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2. Some
2612 other compilers don't a specific architecture type in the e_flags, and
2613 instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
2614 architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
2617 Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
2618 but also sets a specific architecture type in the e_flags field.
2620 However, when decoding the flags we don't worry if we see an
2621 unexpected pairing, for example EM_ARC_COMPACT machine type, with
2622 ARCEM architecture type. */
2624 switch (e_flags
& EF_ARC_MACH_MSK
)
2626 /* We only expect these to occur for EM_ARC_COMPACT2. */
2627 case EF_ARC_CPU_ARCV2EM
:
2628 strcat (buf
, ", ARC EM");
2630 case EF_ARC_CPU_ARCV2HS
:
2631 strcat (buf
, ", ARC HS");
2634 /* We only expect these to occur for EM_ARC_COMPACT. */
2635 case E_ARC_MACH_ARC600
:
2636 strcat (buf
, ", ARC600");
2638 case E_ARC_MACH_ARC601
:
2639 strcat (buf
, ", ARC601");
2641 case E_ARC_MACH_ARC700
:
2642 strcat (buf
, ", ARC700");
2645 /* The only times we should end up here are (a) A corrupt ELF, (b) A
2646 new ELF with new architecture being read by an old version of
2647 readelf, or (c) An ELF built with non-GNU compiler that does not
2648 set the architecture in the e_flags. */
2650 if (e_machine
== EM_ARC_COMPACT
)
2651 strcat (buf
, ", Unknown ARCompact");
2653 strcat (buf
, ", Unknown ARC");
2657 switch (e_flags
& EF_ARC_OSABI_MSK
)
2659 case E_ARC_OSABI_ORIG
:
2660 strcat (buf
, ", (ABI:legacy)");
2662 case E_ARC_OSABI_V2
:
2663 strcat (buf
, ", (ABI:v2)");
2665 /* Only upstream 3.9+ kernels will support ARCv2 ISA. */
2666 case E_ARC_OSABI_V3
:
2667 strcat (buf
, ", v3 no-legacy-syscalls ABI");
2669 case E_ARC_OSABI_V4
:
2670 strcat (buf
, ", v4 ABI");
2673 strcat (buf
, ", unrecognised ARC OSABI flag");
2679 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
2682 bfd_boolean unknown
= FALSE
;
2684 eabi
= EF_ARM_EABI_VERSION (e_flags
);
2685 e_flags
&= ~ EF_ARM_EABIMASK
;
2687 /* Handle "generic" ARM flags. */
2688 if (e_flags
& EF_ARM_RELEXEC
)
2690 strcat (buf
, ", relocatable executable");
2691 e_flags
&= ~ EF_ARM_RELEXEC
;
2694 if (e_flags
& EF_ARM_PIC
)
2696 strcat (buf
, ", position independent");
2697 e_flags
&= ~ EF_ARM_PIC
;
2700 /* Now handle EABI specific flags. */
2704 strcat (buf
, ", <unrecognized EABI>");
2709 case EF_ARM_EABI_VER1
:
2710 strcat (buf
, ", Version1 EABI");
2715 /* Process flags one bit at a time. */
2716 flag
= e_flags
& - e_flags
;
2721 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2722 strcat (buf
, ", sorted symbol tables");
2732 case EF_ARM_EABI_VER2
:
2733 strcat (buf
, ", Version2 EABI");
2738 /* Process flags one bit at a time. */
2739 flag
= e_flags
& - e_flags
;
2744 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2745 strcat (buf
, ", sorted symbol tables");
2748 case EF_ARM_DYNSYMSUSESEGIDX
:
2749 strcat (buf
, ", dynamic symbols use segment index");
2752 case EF_ARM_MAPSYMSFIRST
:
2753 strcat (buf
, ", mapping symbols precede others");
2763 case EF_ARM_EABI_VER3
:
2764 strcat (buf
, ", Version3 EABI");
2767 case EF_ARM_EABI_VER4
:
2768 strcat (buf
, ", Version4 EABI");
2773 /* Process flags one bit at a time. */
2774 flag
= e_flags
& - e_flags
;
2780 strcat (buf
, ", BE8");
2784 strcat (buf
, ", LE8");
2794 case EF_ARM_EABI_VER5
:
2795 strcat (buf
, ", Version5 EABI");
2800 /* Process flags one bit at a time. */
2801 flag
= e_flags
& - e_flags
;
2807 strcat (buf
, ", BE8");
2811 strcat (buf
, ", LE8");
2814 case EF_ARM_ABI_FLOAT_SOFT
: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2815 strcat (buf
, ", soft-float ABI");
2818 case EF_ARM_ABI_FLOAT_HARD
: /* Conflicts with EF_ARM_VFP_FLOAT. */
2819 strcat (buf
, ", hard-float ABI");
2829 case EF_ARM_EABI_UNKNOWN
:
2830 strcat (buf
, ", GNU EABI");
2835 /* Process flags one bit at a time. */
2836 flag
= e_flags
& - e_flags
;
2841 case EF_ARM_INTERWORK
:
2842 strcat (buf
, ", interworking enabled");
2845 case EF_ARM_APCS_26
:
2846 strcat (buf
, ", uses APCS/26");
2849 case EF_ARM_APCS_FLOAT
:
2850 strcat (buf
, ", uses APCS/float");
2854 strcat (buf
, ", position independent");
2858 strcat (buf
, ", 8 bit structure alignment");
2861 case EF_ARM_NEW_ABI
:
2862 strcat (buf
, ", uses new ABI");
2865 case EF_ARM_OLD_ABI
:
2866 strcat (buf
, ", uses old ABI");
2869 case EF_ARM_SOFT_FLOAT
:
2870 strcat (buf
, ", software FP");
2873 case EF_ARM_VFP_FLOAT
:
2874 strcat (buf
, ", VFP");
2877 case EF_ARM_MAVERICK_FLOAT
:
2878 strcat (buf
, ", Maverick FP");
2889 strcat (buf
,_(", <unknown>"));
2893 decode_AVR_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2895 --size
; /* Leave space for null terminator. */
2897 switch (e_flags
& EF_AVR_MACH
)
2899 case E_AVR_MACH_AVR1
:
2900 strncat (buf
, ", avr:1", size
);
2902 case E_AVR_MACH_AVR2
:
2903 strncat (buf
, ", avr:2", size
);
2905 case E_AVR_MACH_AVR25
:
2906 strncat (buf
, ", avr:25", size
);
2908 case E_AVR_MACH_AVR3
:
2909 strncat (buf
, ", avr:3", size
);
2911 case E_AVR_MACH_AVR31
:
2912 strncat (buf
, ", avr:31", size
);
2914 case E_AVR_MACH_AVR35
:
2915 strncat (buf
, ", avr:35", size
);
2917 case E_AVR_MACH_AVR4
:
2918 strncat (buf
, ", avr:4", size
);
2920 case E_AVR_MACH_AVR5
:
2921 strncat (buf
, ", avr:5", size
);
2923 case E_AVR_MACH_AVR51
:
2924 strncat (buf
, ", avr:51", size
);
2926 case E_AVR_MACH_AVR6
:
2927 strncat (buf
, ", avr:6", size
);
2929 case E_AVR_MACH_AVRTINY
:
2930 strncat (buf
, ", avr:100", size
);
2932 case E_AVR_MACH_XMEGA1
:
2933 strncat (buf
, ", avr:101", size
);
2935 case E_AVR_MACH_XMEGA2
:
2936 strncat (buf
, ", avr:102", size
);
2938 case E_AVR_MACH_XMEGA3
:
2939 strncat (buf
, ", avr:103", size
);
2941 case E_AVR_MACH_XMEGA4
:
2942 strncat (buf
, ", avr:104", size
);
2944 case E_AVR_MACH_XMEGA5
:
2945 strncat (buf
, ", avr:105", size
);
2947 case E_AVR_MACH_XMEGA6
:
2948 strncat (buf
, ", avr:106", size
);
2950 case E_AVR_MACH_XMEGA7
:
2951 strncat (buf
, ", avr:107", size
);
2954 strncat (buf
, ", avr:<unknown>", size
);
2958 size
-= strlen (buf
);
2959 if (e_flags
& EF_AVR_LINKRELAX_PREPARED
)
2960 strncat (buf
, ", link-relax", size
);
2964 decode_NDS32_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2970 bfd_boolean has_fpu
= FALSE
;
2973 static const char *ABI_STRINGS
[] =
2975 "ABI v0", /* use r5 as return register; only used in N1213HC */
2976 "ABI v1", /* use r0 as return register */
2977 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2978 "ABI v2fp", /* for FPU */
2982 static const char *VER_STRINGS
[] =
2984 "Andes ELF V1.3 or older",
2988 static const char *ARCH_STRINGS
[] =
2997 abi
= EF_NDS_ABI
& e_flags
;
2998 arch
= EF_NDS_ARCH
& e_flags
;
2999 config
= EF_NDS_INST
& e_flags
;
3000 version
= EF_NDS32_ELF_VERSION
& e_flags
;
3002 memset (buf
, 0, size
);
3009 case E_NDS_ABI_V2FP
:
3010 case E_NDS_ABI_AABI
:
3011 case E_NDS_ABI_V2FP_PLUS
:
3012 /* In case there are holes in the array. */
3013 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ABI_STRINGS
[abi
>> EF_NDS_ABI_SHIFT
]);
3017 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ABI>");
3023 case E_NDS32_ELF_VER_1_2
:
3024 case E_NDS32_ELF_VER_1_3
:
3025 case E_NDS32_ELF_VER_1_4
:
3026 r
+= snprintf (buf
+ r
, size
- r
, ", %s", VER_STRINGS
[version
>> EF_NDS32_ELF_VERSION_SHIFT
]);
3030 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ELF version number>");
3034 if (E_NDS_ABI_V0
== abi
)
3036 /* OLD ABI; only used in N1213HC, has performance extension 1. */
3037 r
+= snprintf (buf
+ r
, size
- r
, ", Andes Star v1.0, N1213HC, MAC, PERF1");
3038 if (arch
== E_NDS_ARCH_STAR_V1_0
)
3039 r
+= snprintf (buf
+ r
, size
-r
, ", 16b"); /* has 16-bit instructions */
3045 case E_NDS_ARCH_STAR_V1_0
:
3046 case E_NDS_ARCH_STAR_V2_0
:
3047 case E_NDS_ARCH_STAR_V3_0
:
3048 case E_NDS_ARCH_STAR_V3_M
:
3049 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ARCH_STRINGS
[arch
>> EF_NDS_ARCH_SHIFT
]);
3053 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized architecture>");
3054 /* ARCH version determines how the e_flags are interpreted.
3055 If it is unknown, we cannot proceed. */
3059 /* Newer ABI; Now handle architecture specific flags. */
3060 if (arch
== E_NDS_ARCH_STAR_V1_0
)
3062 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
3063 r
+= snprintf (buf
+ r
, size
-r
, ", MFUSR_PC");
3065 if (!(config
& E_NDS32_HAS_NO_MAC_INST
))
3066 r
+= snprintf (buf
+ r
, size
-r
, ", MAC");
3068 if (config
& E_NDS32_HAS_DIV_INST
)
3069 r
+= snprintf (buf
+ r
, size
-r
, ", DIV");
3071 if (config
& E_NDS32_HAS_16BIT_INST
)
3072 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
3076 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
3078 if (version
<= E_NDS32_ELF_VER_1_3
)
3079 r
+= snprintf (buf
+ r
, size
-r
, ", [B8]");
3081 r
+= snprintf (buf
+ r
, size
-r
, ", EX9");
3084 if (config
& E_NDS32_HAS_MAC_DX_INST
)
3085 r
+= snprintf (buf
+ r
, size
-r
, ", MAC_DX");
3087 if (config
& E_NDS32_HAS_DIV_DX_INST
)
3088 r
+= snprintf (buf
+ r
, size
-r
, ", DIV_DX");
3090 if (config
& E_NDS32_HAS_16BIT_INST
)
3092 if (version
<= E_NDS32_ELF_VER_1_3
)
3093 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
3095 r
+= snprintf (buf
+ r
, size
-r
, ", IFC");
3099 if (config
& E_NDS32_HAS_EXT_INST
)
3100 r
+= snprintf (buf
+ r
, size
-r
, ", PERF1");
3102 if (config
& E_NDS32_HAS_EXT2_INST
)
3103 r
+= snprintf (buf
+ r
, size
-r
, ", PERF2");
3105 if (config
& E_NDS32_HAS_FPU_INST
)
3108 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_SP");
3111 if (config
& E_NDS32_HAS_FPU_DP_INST
)
3114 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_DP");
3117 if (config
& E_NDS32_HAS_FPU_MAC_INST
)
3120 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_MAC");
3125 switch ((config
& E_NDS32_FPU_REG_CONF
) >> E_NDS32_FPU_REG_CONF_SHIFT
)
3127 case E_NDS32_FPU_REG_8SP_4DP
:
3128 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:8/4");
3130 case E_NDS32_FPU_REG_16SP_8DP
:
3131 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:16/8");
3133 case E_NDS32_FPU_REG_32SP_16DP
:
3134 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/16");
3136 case E_NDS32_FPU_REG_32SP_32DP
:
3137 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/32");
3142 if (config
& E_NDS32_HAS_AUDIO_INST
)
3143 r
+= snprintf (buf
+ r
, size
-r
, ", AUDIO");
3145 if (config
& E_NDS32_HAS_STRING_INST
)
3146 r
+= snprintf (buf
+ r
, size
-r
, ", STR");
3148 if (config
& E_NDS32_HAS_REDUCED_REGS
)
3149 r
+= snprintf (buf
+ r
, size
-r
, ", 16REG");
3151 if (config
& E_NDS32_HAS_VIDEO_INST
)
3153 if (version
<= E_NDS32_ELF_VER_1_3
)
3154 r
+= snprintf (buf
+ r
, size
-r
, ", VIDEO");
3156 r
+= snprintf (buf
+ r
, size
-r
, ", SATURATION");
3159 if (config
& E_NDS32_HAS_ENCRIPT_INST
)
3160 r
+= snprintf (buf
+ r
, size
-r
, ", ENCRP");
3162 if (config
& E_NDS32_HAS_L2C_INST
)
3163 r
+= snprintf (buf
+ r
, size
-r
, ", L2C");
3167 get_machine_flags (Filedata
* filedata
, unsigned e_flags
, unsigned e_machine
)
3169 static char buf
[1024];
3180 case EM_ARC_COMPACT2
:
3181 case EM_ARC_COMPACT
:
3182 decode_ARC_machine_flags (e_flags
, e_machine
, buf
);
3186 decode_ARM_machine_flags (e_flags
, buf
);
3190 decode_AVR_machine_flags (e_flags
, buf
, sizeof buf
);
3194 if (e_flags
& EF_BFIN_PIC
)
3195 strcat (buf
, ", PIC");
3197 if (e_flags
& EF_BFIN_FDPIC
)
3198 strcat (buf
, ", FDPIC");
3200 if (e_flags
& EF_BFIN_CODE_IN_L1
)
3201 strcat (buf
, ", code in L1");
3203 if (e_flags
& EF_BFIN_DATA_IN_L1
)
3204 strcat (buf
, ", data in L1");
3209 switch (e_flags
& EF_FRV_CPU_MASK
)
3211 case EF_FRV_CPU_GENERIC
:
3215 strcat (buf
, ", fr???");
3218 case EF_FRV_CPU_FR300
:
3219 strcat (buf
, ", fr300");
3222 case EF_FRV_CPU_FR400
:
3223 strcat (buf
, ", fr400");
3225 case EF_FRV_CPU_FR405
:
3226 strcat (buf
, ", fr405");
3229 case EF_FRV_CPU_FR450
:
3230 strcat (buf
, ", fr450");
3233 case EF_FRV_CPU_FR500
:
3234 strcat (buf
, ", fr500");
3236 case EF_FRV_CPU_FR550
:
3237 strcat (buf
, ", fr550");
3240 case EF_FRV_CPU_SIMPLE
:
3241 strcat (buf
, ", simple");
3243 case EF_FRV_CPU_TOMCAT
:
3244 strcat (buf
, ", tomcat");
3250 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
3251 strcat (buf
, ", m68000");
3252 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
3253 strcat (buf
, ", cpu32");
3254 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
3255 strcat (buf
, ", fido_a");
3258 char const * isa
= _("unknown");
3259 char const * mac
= _("unknown mac");
3260 char const * additional
= NULL
;
3262 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
3264 case EF_M68K_CF_ISA_A_NODIV
:
3266 additional
= ", nodiv";
3268 case EF_M68K_CF_ISA_A
:
3271 case EF_M68K_CF_ISA_A_PLUS
:
3274 case EF_M68K_CF_ISA_B_NOUSP
:
3276 additional
= ", nousp";
3278 case EF_M68K_CF_ISA_B
:
3281 case EF_M68K_CF_ISA_C
:
3284 case EF_M68K_CF_ISA_C_NODIV
:
3286 additional
= ", nodiv";
3289 strcat (buf
, ", cf, isa ");
3292 strcat (buf
, additional
);
3293 if (e_flags
& EF_M68K_CF_FLOAT
)
3294 strcat (buf
, ", float");
3295 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
3300 case EF_M68K_CF_MAC
:
3303 case EF_M68K_CF_EMAC
:
3306 case EF_M68K_CF_EMAC_B
:
3319 switch (e_flags
& EF_MEP_CPU_MASK
)
3321 case EF_MEP_CPU_MEP
: strcat (buf
, ", generic MeP"); break;
3322 case EF_MEP_CPU_C2
: strcat (buf
, ", MeP C2"); break;
3323 case EF_MEP_CPU_C3
: strcat (buf
, ", MeP C3"); break;
3324 case EF_MEP_CPU_C4
: strcat (buf
, ", MeP C4"); break;
3325 case EF_MEP_CPU_C5
: strcat (buf
, ", MeP C5"); break;
3326 case EF_MEP_CPU_H1
: strcat (buf
, ", MeP H1"); break;
3327 default: strcat (buf
, _(", <unknown MeP cpu type>")); break;
3330 switch (e_flags
& EF_MEP_COP_MASK
)
3332 case EF_MEP_COP_NONE
: break;
3333 case EF_MEP_COP_AVC
: strcat (buf
, ", AVC coprocessor"); break;
3334 case EF_MEP_COP_AVC2
: strcat (buf
, ", AVC2 coprocessor"); break;
3335 case EF_MEP_COP_FMAX
: strcat (buf
, ", FMAX coprocessor"); break;
3336 case EF_MEP_COP_IVC2
: strcat (buf
, ", IVC2 coprocessor"); break;
3337 default: strcat (buf
, _("<unknown MeP copro type>")); break;
3340 if (e_flags
& EF_MEP_LIBRARY
)
3341 strcat (buf
, ", Built for Library");
3343 if (e_flags
& EF_MEP_INDEX_MASK
)
3344 sprintf (buf
+ strlen (buf
), ", Configuration Index: %#x",
3345 e_flags
& EF_MEP_INDEX_MASK
);
3347 if (e_flags
& ~ EF_MEP_ALL_FLAGS
)
3348 sprintf (buf
+ strlen (buf
), _(", unknown flags bits: %#x"),
3349 e_flags
& ~ EF_MEP_ALL_FLAGS
);
3353 if (e_flags
& EF_PPC_EMB
)
3354 strcat (buf
, ", emb");
3356 if (e_flags
& EF_PPC_RELOCATABLE
)
3357 strcat (buf
, _(", relocatable"));
3359 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
3360 strcat (buf
, _(", relocatable-lib"));
3364 if (e_flags
& EF_PPC64_ABI
)
3366 char abi
[] = ", abiv0";
3368 abi
[6] += e_flags
& EF_PPC64_ABI
;
3374 if ((e_flags
& EF_RH850_ABI
) == EF_RH850_ABI
)
3375 strcat (buf
, ", RH850 ABI");
3377 if (e_flags
& EF_V800_850E3
)
3378 strcat (buf
, ", V3 architecture");
3380 if ((e_flags
& (EF_RH850_FPU_DOUBLE
| EF_RH850_FPU_SINGLE
)) == 0)
3381 strcat (buf
, ", FPU not used");
3383 if ((e_flags
& (EF_RH850_REGMODE22
| EF_RH850_REGMODE32
)) == 0)
3384 strcat (buf
, ", regmode: COMMON");
3386 if ((e_flags
& (EF_RH850_GP_FIX
| EF_RH850_GP_NOFIX
)) == 0)
3387 strcat (buf
, ", r4 not used");
3389 if ((e_flags
& (EF_RH850_EP_FIX
| EF_RH850_EP_NOFIX
)) == 0)
3390 strcat (buf
, ", r30 not used");
3392 if ((e_flags
& (EF_RH850_TP_FIX
| EF_RH850_TP_NOFIX
)) == 0)
3393 strcat (buf
, ", r5 not used");
3395 if ((e_flags
& (EF_RH850_REG2_RESERVE
| EF_RH850_REG2_NORESERVE
)) == 0)
3396 strcat (buf
, ", r2 not used");
3398 for (e_flags
&= 0xFFFF; e_flags
; e_flags
&= ~ (e_flags
& - e_flags
))
3400 switch (e_flags
& - e_flags
)
3402 case EF_RH850_FPU_DOUBLE
: strcat (buf
, ", double precision FPU"); break;
3403 case EF_RH850_FPU_SINGLE
: strcat (buf
, ", single precision FPU"); break;
3404 case EF_RH850_REGMODE22
: strcat (buf
, ", regmode:22"); break;
3405 case EF_RH850_REGMODE32
: strcat (buf
, ", regmode:23"); break;
3406 case EF_RH850_GP_FIX
: strcat (buf
, ", r4 fixed"); break;
3407 case EF_RH850_GP_NOFIX
: strcat (buf
, ", r4 free"); break;
3408 case EF_RH850_EP_FIX
: strcat (buf
, ", r30 fixed"); break;
3409 case EF_RH850_EP_NOFIX
: strcat (buf
, ", r30 free"); break;
3410 case EF_RH850_TP_FIX
: strcat (buf
, ", r5 fixed"); break;
3411 case EF_RH850_TP_NOFIX
: strcat (buf
, ", r5 free"); break;
3412 case EF_RH850_REG2_RESERVE
: strcat (buf
, ", r2 fixed"); break;
3413 case EF_RH850_REG2_NORESERVE
: strcat (buf
, ", r2 free"); break;
3420 case EM_CYGNUS_V850
:
3421 switch (e_flags
& EF_V850_ARCH
)
3423 case E_V850E3V5_ARCH
:
3424 strcat (buf
, ", v850e3v5");
3426 case E_V850E2V3_ARCH
:
3427 strcat (buf
, ", v850e2v3");
3430 strcat (buf
, ", v850e2");
3433 strcat (buf
, ", v850e1");
3436 strcat (buf
, ", v850e");
3439 strcat (buf
, ", v850");
3442 strcat (buf
, _(", unknown v850 architecture variant"));
3448 case EM_CYGNUS_M32R
:
3449 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
3450 strcat (buf
, ", m32r");
3454 case EM_MIPS_RS3_LE
:
3455 if (e_flags
& EF_MIPS_NOREORDER
)
3456 strcat (buf
, ", noreorder");
3458 if (e_flags
& EF_MIPS_PIC
)
3459 strcat (buf
, ", pic");
3461 if (e_flags
& EF_MIPS_CPIC
)
3462 strcat (buf
, ", cpic");
3464 if (e_flags
& EF_MIPS_UCODE
)
3465 strcat (buf
, ", ugen_reserved");
3467 if (e_flags
& EF_MIPS_ABI2
)
3468 strcat (buf
, ", abi2");
3470 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
3471 strcat (buf
, ", odk first");
3473 if (e_flags
& EF_MIPS_32BITMODE
)
3474 strcat (buf
, ", 32bitmode");
3476 if (e_flags
& EF_MIPS_NAN2008
)
3477 strcat (buf
, ", nan2008");
3479 if (e_flags
& EF_MIPS_FP64
)
3480 strcat (buf
, ", fp64");
3482 switch ((e_flags
& EF_MIPS_MACH
))
3484 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
3485 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
3486 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
3487 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
3488 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
3489 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
3490 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
3491 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
3492 case E_MIPS_MACH_5900
: strcat (buf
, ", 5900"); break;
3493 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
3494 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
3495 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
3496 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
3497 case E_MIPS_MACH_GS464
: strcat (buf
, ", gs464"); break;
3498 case E_MIPS_MACH_GS464E
: strcat (buf
, ", gs464e"); break;
3499 case E_MIPS_MACH_GS264E
: strcat (buf
, ", gs264e"); break;
3500 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
3501 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
3502 case E_MIPS_MACH_OCTEON3
: strcat (buf
, ", octeon3"); break;
3503 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
3504 case E_MIPS_MACH_IAMR2
: strcat (buf
, ", interaptiv-mr2"); break;
3506 /* We simply ignore the field in this case to avoid confusion:
3507 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3510 default: strcat (buf
, _(", unknown CPU")); break;
3513 switch ((e_flags
& EF_MIPS_ABI
))
3515 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
3516 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
3517 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
3518 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
3520 /* We simply ignore the field in this case to avoid confusion:
3521 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3522 This means it is likely to be an o32 file, but not for
3525 default: strcat (buf
, _(", unknown ABI")); break;
3528 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
3529 strcat (buf
, ", mdmx");
3531 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
3532 strcat (buf
, ", mips16");
3534 if (e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
3535 strcat (buf
, ", micromips");
3537 switch ((e_flags
& EF_MIPS_ARCH
))
3539 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
3540 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
3541 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
3542 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
3543 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
3544 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
3545 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
3546 case E_MIPS_ARCH_32R6
: strcat (buf
, ", mips32r6"); break;
3547 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
3548 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
3549 case E_MIPS_ARCH_64R6
: strcat (buf
, ", mips64r6"); break;
3550 default: strcat (buf
, _(", unknown ISA")); break;
3555 decode_NDS32_machine_flags (e_flags
, buf
, sizeof buf
);
3559 switch (EF_NFP_MACH (e_flags
))
3561 case E_NFP_MACH_3200
:
3562 strcat (buf
, ", NFP-32xx");
3564 case E_NFP_MACH_6000
:
3565 strcat (buf
, ", NFP-6xxx");
3571 if (e_flags
& EF_RISCV_RVC
)
3572 strcat (buf
, ", RVC");
3574 if (e_flags
& EF_RISCV_RVE
)
3575 strcat (buf
, ", RVE");
3577 switch (e_flags
& EF_RISCV_FLOAT_ABI
)
3579 case EF_RISCV_FLOAT_ABI_SOFT
:
3580 strcat (buf
, ", soft-float ABI");
3583 case EF_RISCV_FLOAT_ABI_SINGLE
:
3584 strcat (buf
, ", single-float ABI");
3587 case EF_RISCV_FLOAT_ABI_DOUBLE
:
3588 strcat (buf
, ", double-float ABI");
3591 case EF_RISCV_FLOAT_ABI_QUAD
:
3592 strcat (buf
, ", quad-float ABI");
3598 switch ((e_flags
& EF_SH_MACH_MASK
))
3600 case EF_SH1
: strcat (buf
, ", sh1"); break;
3601 case EF_SH2
: strcat (buf
, ", sh2"); break;
3602 case EF_SH3
: strcat (buf
, ", sh3"); break;
3603 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
3604 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
3605 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
3606 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
3607 case EF_SH4
: strcat (buf
, ", sh4"); break;
3608 case EF_SH5
: strcat (buf
, ", sh5"); break;
3609 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
3610 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
3611 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
3612 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
3613 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
3614 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
3615 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
3616 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
3617 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3618 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
3619 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
3620 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
3621 default: strcat (buf
, _(", unknown ISA")); break;
3624 if (e_flags
& EF_SH_PIC
)
3625 strcat (buf
, ", pic");
3627 if (e_flags
& EF_SH_FDPIC
)
3628 strcat (buf
, ", fdpic");
3632 if (e_flags
& EF_OR1K_NODELAY
)
3633 strcat (buf
, ", no delay");
3637 if (e_flags
& EF_SPARC_32PLUS
)
3638 strcat (buf
, ", v8+");
3640 if (e_flags
& EF_SPARC_SUN_US1
)
3641 strcat (buf
, ", ultrasparcI");
3643 if (e_flags
& EF_SPARC_SUN_US3
)
3644 strcat (buf
, ", ultrasparcIII");
3646 if (e_flags
& EF_SPARC_HAL_R1
)
3647 strcat (buf
, ", halr1");
3649 if (e_flags
& EF_SPARC_LEDATA
)
3650 strcat (buf
, ", ledata");
3652 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
3653 strcat (buf
, ", tso");
3655 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
3656 strcat (buf
, ", pso");
3658 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
3659 strcat (buf
, ", rmo");
3663 switch (e_flags
& EF_PARISC_ARCH
)
3665 case EFA_PARISC_1_0
:
3666 strcpy (buf
, ", PA-RISC 1.0");
3668 case EFA_PARISC_1_1
:
3669 strcpy (buf
, ", PA-RISC 1.1");
3671 case EFA_PARISC_2_0
:
3672 strcpy (buf
, ", PA-RISC 2.0");
3677 if (e_flags
& EF_PARISC_TRAPNIL
)
3678 strcat (buf
, ", trapnil");
3679 if (e_flags
& EF_PARISC_EXT
)
3680 strcat (buf
, ", ext");
3681 if (e_flags
& EF_PARISC_LSB
)
3682 strcat (buf
, ", lsb");
3683 if (e_flags
& EF_PARISC_WIDE
)
3684 strcat (buf
, ", wide");
3685 if (e_flags
& EF_PARISC_NO_KABP
)
3686 strcat (buf
, ", no kabp");
3687 if (e_flags
& EF_PARISC_LAZYSWAP
)
3688 strcat (buf
, ", lazyswap");
3693 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
3694 strcat (buf
, ", new calling convention");
3696 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
3697 strcat (buf
, ", gnu calling convention");
3701 if ((e_flags
& EF_IA_64_ABI64
))
3702 strcat (buf
, ", 64-bit");
3704 strcat (buf
, ", 32-bit");
3705 if ((e_flags
& EF_IA_64_REDUCEDFP
))
3706 strcat (buf
, ", reduced fp model");
3707 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
3708 strcat (buf
, ", no function descriptors, constant gp");
3709 else if ((e_flags
& EF_IA_64_CONS_GP
))
3710 strcat (buf
, ", constant gp");
3711 if ((e_flags
& EF_IA_64_ABSOLUTE
))
3712 strcat (buf
, ", absolute");
3713 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
3715 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
3716 strcat (buf
, ", vms_linkages");
3717 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
3719 case EF_IA_64_VMS_COMCOD_SUCCESS
:
3721 case EF_IA_64_VMS_COMCOD_WARNING
:
3722 strcat (buf
, ", warning");
3724 case EF_IA_64_VMS_COMCOD_ERROR
:
3725 strcat (buf
, ", error");
3727 case EF_IA_64_VMS_COMCOD_ABORT
:
3728 strcat (buf
, ", abort");
3731 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3732 e_flags
& EF_IA_64_VMS_COMCOD
);
3733 strcat (buf
, ", <unknown>");
3739 if ((e_flags
& EF_VAX_NONPIC
))
3740 strcat (buf
, ", non-PIC");
3741 if ((e_flags
& EF_VAX_DFLOAT
))
3742 strcat (buf
, ", D-Float");
3743 if ((e_flags
& EF_VAX_GFLOAT
))
3744 strcat (buf
, ", G-Float");
3748 if (e_flags
& EF_VISIUM_ARCH_MCM
)
3749 strcat (buf
, ", mcm");
3750 else if (e_flags
& EF_VISIUM_ARCH_MCM24
)
3751 strcat (buf
, ", mcm24");
3752 if (e_flags
& EF_VISIUM_ARCH_GR6
)
3753 strcat (buf
, ", gr6");
3757 switch (e_flags
& E_FLAG_RL78_CPU_MASK
)
3759 case E_FLAG_RL78_ANY_CPU
: break;
3760 case E_FLAG_RL78_G10
: strcat (buf
, ", G10"); break;
3761 case E_FLAG_RL78_G13
: strcat (buf
, ", G13"); break;
3762 case E_FLAG_RL78_G14
: strcat (buf
, ", G14"); break;
3764 if (e_flags
& E_FLAG_RL78_64BIT_DOUBLES
)
3765 strcat (buf
, ", 64-bit doubles");
3769 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
3770 strcat (buf
, ", 64-bit doubles");
3771 if (e_flags
& E_FLAG_RX_DSP
)
3772 strcat (buf
, ", dsp");
3773 if (e_flags
& E_FLAG_RX_PID
)
3774 strcat (buf
, ", pid");
3775 if (e_flags
& E_FLAG_RX_ABI
)
3776 strcat (buf
, ", RX ABI");
3777 if (e_flags
& E_FLAG_RX_SINSNS_SET
)
3778 strcat (buf
, e_flags
& E_FLAG_RX_SINSNS_YES
3779 ? ", uses String instructions" : ", bans String instructions");
3780 if (e_flags
& E_FLAG_RX_V2
)
3781 strcat (buf
, ", V2");
3782 if (e_flags
& E_FLAG_RX_V3
)
3783 strcat (buf
, ", V3");
3787 if (e_flags
& EF_S390_HIGH_GPRS
)
3788 strcat (buf
, ", highgprs");
3792 if ((e_flags
& EF_C6000_REL
))
3793 strcat (buf
, ", relocatable module");
3797 strcat (buf
, _(": architecture variant: "));
3798 switch (e_flags
& EF_MSP430_MACH
)
3800 case E_MSP430_MACH_MSP430x11
: strcat (buf
, "MSP430x11"); break;
3801 case E_MSP430_MACH_MSP430x11x1
: strcat (buf
, "MSP430x11x1 "); break;
3802 case E_MSP430_MACH_MSP430x12
: strcat (buf
, "MSP430x12"); break;
3803 case E_MSP430_MACH_MSP430x13
: strcat (buf
, "MSP430x13"); break;
3804 case E_MSP430_MACH_MSP430x14
: strcat (buf
, "MSP430x14"); break;
3805 case E_MSP430_MACH_MSP430x15
: strcat (buf
, "MSP430x15"); break;
3806 case E_MSP430_MACH_MSP430x16
: strcat (buf
, "MSP430x16"); break;
3807 case E_MSP430_MACH_MSP430x31
: strcat (buf
, "MSP430x31"); break;
3808 case E_MSP430_MACH_MSP430x32
: strcat (buf
, "MSP430x32"); break;
3809 case E_MSP430_MACH_MSP430x33
: strcat (buf
, "MSP430x33"); break;
3810 case E_MSP430_MACH_MSP430x41
: strcat (buf
, "MSP430x41"); break;
3811 case E_MSP430_MACH_MSP430x42
: strcat (buf
, "MSP430x42"); break;
3812 case E_MSP430_MACH_MSP430x43
: strcat (buf
, "MSP430x43"); break;
3813 case E_MSP430_MACH_MSP430x44
: strcat (buf
, "MSP430x44"); break;
3814 case E_MSP430_MACH_MSP430X
: strcat (buf
, "MSP430X"); break;
3816 strcat (buf
, _(": unknown")); break;
3819 if (e_flags
& ~ EF_MSP430_MACH
)
3820 strcat (buf
, _(": unknown extra flag bits also present"));
3824 switch (e_flags
& EF_Z80_MACH_MSK
)
3826 case EF_Z80_MACH_Z80
: strcat (buf
, ", Z80"); break;
3827 case EF_Z80_MACH_Z180
: strcat (buf
, ", Z180"); break;
3828 case EF_Z80_MACH_R800
: strcat (buf
, ", R800"); break;
3829 case EF_Z80_MACH_EZ80_Z80
: strcat (buf
, ", EZ80"); break;
3830 case EF_Z80_MACH_EZ80_ADL
: strcat (buf
, ", EZ80, ADL"); break;
3831 case EF_Z80_MACH_GBZ80
: strcat (buf
, ", GBZ80"); break;
3832 case EF_Z80_MACH_Z80N
: strcat (buf
, ", Z80N"); break;
3834 strcat (buf
, _(", unknown")); break;
3844 get_osabi_name (Filedata
* filedata
, unsigned int osabi
)
3846 static char buff
[32];
3850 case ELFOSABI_NONE
: return "UNIX - System V";
3851 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
3852 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
3853 case ELFOSABI_GNU
: return "UNIX - GNU";
3854 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
3855 case ELFOSABI_AIX
: return "UNIX - AIX";
3856 case ELFOSABI_IRIX
: return "UNIX - IRIX";
3857 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
3858 case ELFOSABI_TRU64
: return "UNIX - TRU64";
3859 case ELFOSABI_MODESTO
: return "Novell - Modesto";
3860 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
3861 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
3862 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
3863 case ELFOSABI_AROS
: return "AROS";
3864 case ELFOSABI_FENIXOS
: return "FenixOS";
3865 case ELFOSABI_CLOUDABI
: return "Nuxi CloudABI";
3866 case ELFOSABI_OPENVOS
: return "Stratus Technologies OpenVOS";
3869 switch (filedata
->file_header
.e_machine
)
3874 case ELFOSABI_ARM
: return "ARM";
3875 case ELFOSABI_ARM_FDPIC
: return "ARM FDPIC";
3886 case ELFOSABI_STANDALONE
: return _("Standalone App");
3895 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
3896 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
3905 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
3911 get_aarch64_segment_type (unsigned long type
)
3915 case PT_AARCH64_ARCHEXT
: return "AARCH64_ARCHEXT";
3916 default: return NULL
;
3921 get_arm_segment_type (unsigned long type
)
3925 case PT_ARM_EXIDX
: return "EXIDX";
3926 default: return NULL
;
3931 get_s390_segment_type (unsigned long type
)
3935 case PT_S390_PGSTE
: return "S390_PGSTE";
3936 default: return NULL
;
3941 get_mips_segment_type (unsigned long type
)
3945 case PT_MIPS_REGINFO
: return "REGINFO";
3946 case PT_MIPS_RTPROC
: return "RTPROC";
3947 case PT_MIPS_OPTIONS
: return "OPTIONS";
3948 case PT_MIPS_ABIFLAGS
: return "ABIFLAGS";
3949 default: return NULL
;
3954 get_parisc_segment_type (unsigned long type
)
3958 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
3959 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
3960 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
3961 default: return NULL
;
3966 get_ia64_segment_type (unsigned long type
)
3970 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
3971 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
3972 default: return NULL
;
3977 get_tic6x_segment_type (unsigned long type
)
3981 case PT_C6000_PHATTR
: return "C6000_PHATTR";
3982 default: return NULL
;
3987 get_hpux_segment_type (unsigned long type
, unsigned e_machine
)
3989 if (e_machine
== EM_PARISC
)
3992 case PT_HP_TLS
: return "HP_TLS";
3993 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
3994 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
3995 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
3996 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
3997 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
3998 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
3999 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
4000 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
4001 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
4002 case PT_HP_PARALLEL
: return "HP_PARALLEL";
4003 case PT_HP_FASTBIND
: return "HP_FASTBIND";
4004 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
4005 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
4006 case PT_HP_STACK
: return "HP_STACK";
4007 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
4008 default: return NULL
;
4011 if (e_machine
== EM_IA_64
)
4014 case PT_HP_TLS
: return "HP_TLS";
4015 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
4016 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
4017 case PT_IA_64_HP_STACK
: return "HP_STACK";
4018 default: return NULL
;
4025 get_solaris_segment_type (unsigned long type
)
4029 case 0x6464e550: return "PT_SUNW_UNWIND";
4030 case 0x6474e550: return "PT_SUNW_EH_FRAME";
4031 case 0x6ffffff7: return "PT_LOSUNW";
4032 case 0x6ffffffa: return "PT_SUNWBSS";
4033 case 0x6ffffffb: return "PT_SUNWSTACK";
4034 case 0x6ffffffc: return "PT_SUNWDTRACE";
4035 case 0x6ffffffd: return "PT_SUNWCAP";
4036 case 0x6fffffff: return "PT_HISUNW";
4037 default: return NULL
;
4042 get_segment_type (Filedata
* filedata
, unsigned long p_type
)
4044 static char buff
[32];
4048 case PT_NULL
: return "NULL";
4049 case PT_LOAD
: return "LOAD";
4050 case PT_DYNAMIC
: return "DYNAMIC";
4051 case PT_INTERP
: return "INTERP";
4052 case PT_NOTE
: return "NOTE";
4053 case PT_SHLIB
: return "SHLIB";
4054 case PT_PHDR
: return "PHDR";
4055 case PT_TLS
: return "TLS";
4056 case PT_GNU_EH_FRAME
: return "GNU_EH_FRAME";
4057 case PT_GNU_STACK
: return "GNU_STACK";
4058 case PT_GNU_RELRO
: return "GNU_RELRO";
4059 case PT_GNU_PROPERTY
: return "GNU_PROPERTY";
4061 case PT_OPENBSD_RANDOMIZE
: return "OPENBSD_RANDOMIZE";
4062 case PT_OPENBSD_WXNEEDED
: return "OPENBSD_WXNEEDED";
4063 case PT_OPENBSD_BOOTDATA
: return "OPENBSD_BOOTDATA";
4066 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
4068 const char * result
;
4070 switch (filedata
->file_header
.e_machine
)
4073 result
= get_aarch64_segment_type (p_type
);
4076 result
= get_arm_segment_type (p_type
);
4079 case EM_MIPS_RS3_LE
:
4080 result
= get_mips_segment_type (p_type
);
4083 result
= get_parisc_segment_type (p_type
);
4086 result
= get_ia64_segment_type (p_type
);
4089 result
= get_tic6x_segment_type (p_type
);
4093 result
= get_s390_segment_type (p_type
);
4103 sprintf (buff
, "LOPROC+%#lx", p_type
- PT_LOPROC
);
4105 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
4107 const char * result
= NULL
;
4109 switch (filedata
->file_header
.e_ident
[EI_OSABI
])
4112 case ELFOSABI_FREEBSD
:
4113 if (p_type
>= PT_GNU_MBIND_LO
&& p_type
<= PT_GNU_MBIND_HI
)
4115 sprintf (buff
, "GNU_MBIND+%#lx", p_type
- PT_GNU_MBIND_LO
);
4120 result
= get_hpux_segment_type (p_type
,
4121 filedata
->file_header
.e_machine
);
4123 case ELFOSABI_SOLARIS
:
4124 result
= get_solaris_segment_type (p_type
);
4132 sprintf (buff
, "LOOS+%#lx", p_type
- PT_LOOS
);
4135 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
4142 get_arc_section_type_name (unsigned int sh_type
)
4146 case SHT_ARC_ATTRIBUTES
: return "ARC_ATTRIBUTES";
4154 get_mips_section_type_name (unsigned int sh_type
)
4158 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
4159 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
4160 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
4161 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
4162 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
4163 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
4164 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
4165 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
4166 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
4167 case SHT_MIPS_RELD
: return "MIPS_RELD";
4168 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
4169 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
4170 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
4171 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
4172 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
4173 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
4174 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
4175 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
4176 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
4177 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
4178 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
4179 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
4180 case SHT_MIPS_LINE
: return "MIPS_LINE";
4181 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
4182 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
4183 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
4184 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
4185 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
4186 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
4187 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
4188 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
4189 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
4190 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
4191 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
4192 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
4193 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
4194 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
4195 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
4196 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
4197 case SHT_MIPS_ABIFLAGS
: return "MIPS_ABIFLAGS";
4198 case SHT_MIPS_XHASH
: return "MIPS_XHASH";
4206 get_parisc_section_type_name (unsigned int sh_type
)
4210 case SHT_PARISC_EXT
: return "PARISC_EXT";
4211 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
4212 case SHT_PARISC_DOC
: return "PARISC_DOC";
4213 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
4214 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
4215 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
4216 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
4217 default: return NULL
;
4222 get_ia64_section_type_name (Filedata
* filedata
, unsigned int sh_type
)
4224 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
4225 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
4226 return get_osabi_name (filedata
, (sh_type
& 0x00FF0000) >> 16);
4230 case SHT_IA_64_EXT
: return "IA_64_EXT";
4231 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
4232 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
4233 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
4234 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
4235 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
4236 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
4237 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
4238 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
4239 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
4247 get_x86_64_section_type_name (unsigned int sh_type
)
4251 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
4252 default: return NULL
;
4257 get_aarch64_section_type_name (unsigned int sh_type
)
4261 case SHT_AARCH64_ATTRIBUTES
: return "AARCH64_ATTRIBUTES";
4262 default: return NULL
;
4267 get_arm_section_type_name (unsigned int sh_type
)
4271 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
4272 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
4273 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
4274 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
4275 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
4276 default: return NULL
;
4281 get_tic6x_section_type_name (unsigned int sh_type
)
4285 case SHT_C6000_UNWIND
: return "C6000_UNWIND";
4286 case SHT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
4287 case SHT_C6000_ATTRIBUTES
: return "C6000_ATTRIBUTES";
4288 case SHT_TI_ICODE
: return "TI_ICODE";
4289 case SHT_TI_XREF
: return "TI_XREF";
4290 case SHT_TI_HANDLER
: return "TI_HANDLER";
4291 case SHT_TI_INITINFO
: return "TI_INITINFO";
4292 case SHT_TI_PHATTRS
: return "TI_PHATTRS";
4293 default: return NULL
;
4298 get_msp430_section_type_name (unsigned int sh_type
)
4302 case SHT_MSP430_SEC_FLAGS
: return "MSP430_SEC_FLAGS";
4303 case SHT_MSP430_SYM_ALIASES
: return "MSP430_SYM_ALIASES";
4304 case SHT_MSP430_ATTRIBUTES
: return "MSP430_ATTRIBUTES";
4305 default: return NULL
;
4310 get_nfp_section_type_name (unsigned int sh_type
)
4314 case SHT_NFP_MECONFIG
: return "NFP_MECONFIG";
4315 case SHT_NFP_INITREG
: return "NFP_INITREG";
4316 case SHT_NFP_UDEBUG
: return "NFP_UDEBUG";
4317 default: return NULL
;
4322 get_v850_section_type_name (unsigned int sh_type
)
4326 case SHT_V850_SCOMMON
: return "V850 Small Common";
4327 case SHT_V850_TCOMMON
: return "V850 Tiny Common";
4328 case SHT_V850_ZCOMMON
: return "V850 Zero Common";
4329 case SHT_RENESAS_IOP
: return "RENESAS IOP";
4330 case SHT_RENESAS_INFO
: return "RENESAS INFO";
4331 default: return NULL
;
4336 get_riscv_section_type_name (unsigned int sh_type
)
4340 case SHT_RISCV_ATTRIBUTES
: return "RISCV_ATTRIBUTES";
4341 default: return NULL
;
4346 get_csky_section_type_name (unsigned int sh_type
)
4350 case SHT_CSKY_ATTRIBUTES
: return "CSKY_ATTRIBUTES";
4351 default: return NULL
;
4356 get_section_type_name (Filedata
* filedata
, unsigned int sh_type
)
4358 static char buff
[32];
4359 const char * result
;
4363 case SHT_NULL
: return "NULL";
4364 case SHT_PROGBITS
: return "PROGBITS";
4365 case SHT_SYMTAB
: return "SYMTAB";
4366 case SHT_STRTAB
: return "STRTAB";
4367 case SHT_RELA
: return "RELA";
4368 case SHT_HASH
: return "HASH";
4369 case SHT_DYNAMIC
: return "DYNAMIC";
4370 case SHT_NOTE
: return "NOTE";
4371 case SHT_NOBITS
: return "NOBITS";
4372 case SHT_REL
: return "REL";
4373 case SHT_SHLIB
: return "SHLIB";
4374 case SHT_DYNSYM
: return "DYNSYM";
4375 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
4376 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
4377 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
4378 case SHT_GNU_HASH
: return "GNU_HASH";
4379 case SHT_GROUP
: return "GROUP";
4380 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICES";
4381 case SHT_GNU_verdef
: return "VERDEF";
4382 case SHT_GNU_verneed
: return "VERNEED";
4383 case SHT_GNU_versym
: return "VERSYM";
4384 case 0x6ffffff0: return "VERSYM";
4385 case 0x6ffffffc: return "VERDEF";
4386 case 0x7ffffffd: return "AUXILIARY";
4387 case 0x7fffffff: return "FILTER";
4388 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
4391 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
4393 switch (filedata
->file_header
.e_machine
)
4396 case EM_ARC_COMPACT
:
4397 case EM_ARC_COMPACT2
:
4398 result
= get_arc_section_type_name (sh_type
);
4401 case EM_MIPS_RS3_LE
:
4402 result
= get_mips_section_type_name (sh_type
);
4405 result
= get_parisc_section_type_name (sh_type
);
4408 result
= get_ia64_section_type_name (filedata
, sh_type
);
4413 result
= get_x86_64_section_type_name (sh_type
);
4416 result
= get_aarch64_section_type_name (sh_type
);
4419 result
= get_arm_section_type_name (sh_type
);
4422 result
= get_tic6x_section_type_name (sh_type
);
4425 result
= get_msp430_section_type_name (sh_type
);
4428 result
= get_nfp_section_type_name (sh_type
);
4432 case EM_CYGNUS_V850
:
4433 result
= get_v850_section_type_name (sh_type
);
4436 result
= get_riscv_section_type_name (sh_type
);
4439 result
= get_csky_section_type_name (sh_type
);
4449 sprintf (buff
, "LOPROC+%#x", sh_type
- SHT_LOPROC
);
4451 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
4453 switch (filedata
->file_header
.e_machine
)
4456 result
= get_ia64_section_type_name (filedata
, sh_type
);
4459 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
4460 result
= get_solaris_section_type (sh_type
);
4465 case SHT_GNU_INCREMENTAL_INPUTS
: result
= "GNU_INCREMENTAL_INPUTS"; break;
4466 case SHT_GNU_ATTRIBUTES
: result
= "GNU_ATTRIBUTES"; break;
4467 case SHT_GNU_HASH
: result
= "GNU_HASH"; break;
4468 case SHT_GNU_LIBLIST
: result
= "GNU_LIBLIST"; break;
4480 sprintf (buff
, "LOOS+%#x", sh_type
- SHT_LOOS
);
4482 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
4484 switch (filedata
->file_header
.e_machine
)
4488 case EM_CYGNUS_V850
:
4489 result
= get_v850_section_type_name (sh_type
);
4499 sprintf (buff
, "LOUSER+%#x", sh_type
- SHT_LOUSER
);
4502 /* This message is probably going to be displayed in a 15
4503 character wide field, so put the hex value first. */
4504 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
4510 enum long_option_values
4512 OPTION_DEBUG_DUMP
= 512,
4522 OPTION_WITH_SYMBOL_VERSIONS
,
4523 OPTION_RECURSE_LIMIT
,
4524 OPTION_NO_RECURSE_LIMIT
,
4525 OPTION_NO_DEMANGLING
4528 static struct option options
[] =
4530 /* Note - This table is alpha-sorted on the 'val'
4531 field in order to make adding new options easier. */
4532 {"arch-specific", no_argument
, 0, 'A'},
4533 {"all", no_argument
, 0, 'a'},
4534 {"demangle", optional_argument
, 0, 'C'},
4535 {"archive-index", no_argument
, 0, 'c'},
4536 {"use-dynamic", no_argument
, 0, 'D'},
4537 {"dynamic", no_argument
, 0, 'd'},
4538 {"headers", no_argument
, 0, 'e'},
4539 {"section-groups", no_argument
, 0, 'g'},
4540 {"help", no_argument
, 0, 'H'},
4541 {"file-header", no_argument
, 0, 'h'},
4542 {"histogram", no_argument
, 0, 'I'},
4543 {"lint", no_argument
, 0, 'L'},
4544 {"enable-checks", no_argument
, 0, 'L'},
4545 {"program-headers", no_argument
, 0, 'l'},
4546 {"segments", no_argument
, 0, 'l'},
4547 {"full-section-name",no_argument
, 0, 'N'},
4548 {"notes", no_argument
, 0, 'n'},
4549 {"string-dump", required_argument
, 0, 'p'},
4550 {"relocated-dump", required_argument
, 0, 'R'},
4551 {"relocs", no_argument
, 0, 'r'},
4552 {"section-headers", no_argument
, 0, 'S'},
4553 {"sections", no_argument
, 0, 'S'},
4554 {"symbols", no_argument
, 0, 's'},
4555 {"syms", no_argument
, 0, 's'},
4556 {"silent-truncation",no_argument
, 0, 'T'},
4557 {"section-details", no_argument
, 0, 't'},
4558 {"unwind", no_argument
, 0, 'u'},
4559 {"version-info", no_argument
, 0, 'V'},
4560 {"version", no_argument
, 0, 'v'},
4561 {"wide", no_argument
, 0, 'W'},
4562 {"hex-dump", required_argument
, 0, 'x'},
4563 {"decompress", no_argument
, 0, 'z'},
4565 {"no-demangle", no_argument
, 0, OPTION_NO_DEMANGLING
},
4566 {"recurse-limit", no_argument
, NULL
, OPTION_RECURSE_LIMIT
},
4567 {"no-recurse-limit", no_argument
, NULL
, OPTION_NO_RECURSE_LIMIT
},
4568 {"no-recursion-limit", no_argument
, NULL
, OPTION_NO_RECURSE_LIMIT
},
4569 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
4570 {"lto-syms", no_argument
, 0, OPTION_LTO_SYMS
},
4571 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
4572 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
4573 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
4574 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
4575 #ifdef ENABLE_LIBCTF
4576 {"ctf", required_argument
, 0, OPTION_CTF_DUMP
},
4577 {"ctf-symbols", required_argument
, 0, OPTION_CTF_SYMBOLS
},
4578 {"ctf-strings", required_argument
, 0, OPTION_CTF_STRINGS
},
4579 {"ctf-parent", required_argument
, 0, OPTION_CTF_PARENT
},
4582 {0, no_argument
, 0, 0}
4586 usage (FILE * stream
)
4588 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
4589 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
4590 fprintf (stream
, _(" Options are:\n\
4591 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4592 -h --file-header Display the ELF file header\n\
4593 -l --program-headers Display the program headers\n\
4594 --segments An alias for --program-headers\n\
4595 -S --section-headers Display the sections' header\n\
4596 --sections An alias for --section-headers\n\
4597 -g --section-groups Display the section groups\n\
4598 -t --section-details Display the section details\n\
4599 -e --headers Equivalent to: -h -l -S\n\
4600 -s --syms Display the symbol table\n\
4601 --symbols An alias for --syms\n\
4602 --dyn-syms Display the dynamic symbol table\n\
4603 --lto-syms Display LTO symbol tables\n\
4604 -C --demangle[=STYLE] Decode low-level symbol names into user-level names\n\
4605 The STYLE, if specified, can be `auto' (the default),\n\
4606 `gnu', `lucid', `arm', `hp', `edg', `gnu-v3', `java'\n\
4608 --no-demangle Do not demangle low-level symbol names. (This is the default)\n\
4609 --recurse-limit Enable a demangling recursion limit. (This is the default)\n\
4610 --no-recurse-limit Disable a demangling recursion limit\n\
4611 -n --notes Display the core notes (if present)\n\
4612 -r --relocs Display the relocations (if present)\n\
4613 -u --unwind Display the unwind info (if present)\n\
4614 -d --dynamic Display the dynamic section (if present)\n\
4615 -V --version-info Display the version sections (if present)\n\
4616 -A --arch-specific Display architecture specific information (if any)\n\
4617 -c --archive-index Display the symbol/file index in an archive\n\
4618 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
4619 -L --lint|--enable-checks Display warning messages for possible problems\n\
4620 -x --hex-dump=<number|name>\n\
4621 Dump the contents of section <number|name> as bytes\n\
4622 -p --string-dump=<number|name>\n\
4623 Dump the contents of section <number|name> as strings\n\
4624 -R --relocated-dump=<number|name>\n\
4625 Dump the contents of section <number|name> as relocated bytes\n\
4626 -z --decompress Decompress section before dumping it\n\
4627 -w[lLiaprmfFsoORtUuTgAckK] or\n\
4628 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4629 =frames-interp,=str,=str-offsets,=loc,=Ranges,=pubtypes,\n\
4630 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4631 =addr,=cu_index,=links,=follow-links]\n\
4632 Display the contents of DWARF debug sections\n"));
4633 fprintf (stream
, _("\
4634 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4635 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4637 #ifdef ENABLE_LIBCTF
4638 fprintf (stream
, _("\
4639 --ctf=<number|name> Display CTF info from section <number|name>\n\
4640 --ctf-parent=<number|name>\n\
4641 Use section <number|name> as the CTF parent\n\n\
4642 --ctf-symbols=<number|name>\n\
4643 Use section <number|name> as the CTF external symtab\n\n\
4644 --ctf-strings=<number|name>\n\
4645 Use section <number|name> as the CTF external strtab\n\n"));
4648 #ifdef SUPPORT_DISASSEMBLY
4649 fprintf (stream
, _("\
4650 -i --instruction-dump=<number|name>\n\
4651 Disassemble the contents of section <number|name>\n"));
4653 fprintf (stream
, _("\
4654 -I --histogram Display histogram of bucket list lengths\n\
4655 -W --wide Allow output width to exceed 80 characters\n\
4656 -T --silent-truncation If a symbol name is truncated, do not add a suffix [...]\n\
4657 @<file> Read options from <file>\n\
4658 -H --help Display this information\n\
4659 -v --version Display the version number of readelf\n"));
4661 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
4662 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
4664 exit (stream
== stdout
? 0 : 1);
4667 /* Record the fact that the user wants the contents of section number
4668 SECTION to be displayed using the method(s) encoded as flags bits
4669 in TYPE. Note, TYPE can be zero if we are creating the array for
4673 request_dump_bynumber (struct dump_data
*dumpdata
,
4674 unsigned int section
, dump_type type
)
4676 if (section
>= dumpdata
->num_dump_sects
)
4678 dump_type
* new_dump_sects
;
4680 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
4681 sizeof (* new_dump_sects
));
4683 if (new_dump_sects
== NULL
)
4684 error (_("Out of memory allocating dump request table.\n"));
4687 if (dumpdata
->dump_sects
)
4689 /* Copy current flag settings. */
4690 memcpy (new_dump_sects
, dumpdata
->dump_sects
,
4691 dumpdata
->num_dump_sects
* sizeof (* new_dump_sects
));
4693 free (dumpdata
->dump_sects
);
4696 dumpdata
->dump_sects
= new_dump_sects
;
4697 dumpdata
->num_dump_sects
= section
+ 1;
4701 if (dumpdata
->dump_sects
)
4702 dumpdata
->dump_sects
[section
] |= type
;
4705 /* Request a dump by section name. */
4708 request_dump_byname (const char * section
, dump_type type
)
4710 struct dump_list_entry
* new_request
;
4712 new_request
= (struct dump_list_entry
*)
4713 malloc (sizeof (struct dump_list_entry
));
4715 error (_("Out of memory allocating dump request table.\n"));
4717 new_request
->name
= strdup (section
);
4718 if (!new_request
->name
)
4719 error (_("Out of memory allocating dump request table.\n"));
4721 new_request
->type
= type
;
4723 new_request
->next
= dump_sects_byname
;
4724 dump_sects_byname
= new_request
;
4728 request_dump (struct dump_data
*dumpdata
, dump_type type
)
4734 section
= strtoul (optarg
, & cp
, 0);
4736 if (! *cp
&& section
>= 0)
4737 request_dump_bynumber (dumpdata
, section
, type
);
4739 request_dump_byname (optarg
, type
);
4743 parse_args (struct dump_data
*dumpdata
, int argc
, char ** argv
)
4750 while ((c
= getopt_long
4751 (argc
, argv
, "ACDHILNR:STVWacdeghi:lnp:rstuvw::x:z", options
, NULL
)) != EOF
)
4769 do_section_groups
= TRUE
;
4772 do_histogram
= TRUE
;
4778 do_section_groups
= TRUE
;
4783 do_section_details
= TRUE
;
4794 do_using_dynamic
= TRUE
;
4818 do_histogram
= TRUE
;
4824 do_archive_index
= TRUE
;
4830 request_dump (dumpdata
, HEX_DUMP
);
4833 request_dump (dumpdata
, STRING_DUMP
);
4836 request_dump (dumpdata
, RELOC_DUMP
);
4839 decompress_dumps
= TRUE
;
4845 do_debugging
= TRUE
;
4846 dwarf_select_sections_all ();
4850 do_debugging
= FALSE
;
4851 dwarf_select_sections_by_letters (optarg
);
4854 case OPTION_DEBUG_DUMP
:
4857 do_debugging
= TRUE
;
4860 do_debugging
= FALSE
;
4861 dwarf_select_sections_by_names (optarg
);
4864 case OPTION_DWARF_DEPTH
:
4868 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
4871 case OPTION_DWARF_START
:
4875 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
4878 case OPTION_DWARF_CHECK
:
4881 case OPTION_CTF_DUMP
:
4883 request_dump (dumpdata
, CTF_DUMP
);
4885 case OPTION_CTF_SYMBOLS
:
4886 free (dump_ctf_symtab_name
);
4887 dump_ctf_symtab_name
= strdup (optarg
);
4889 case OPTION_CTF_STRINGS
:
4890 free (dump_ctf_strtab_name
);
4891 dump_ctf_strtab_name
= strdup (optarg
);
4893 case OPTION_CTF_PARENT
:
4894 free (dump_ctf_parent_name
);
4895 dump_ctf_parent_name
= strdup (optarg
);
4897 case OPTION_DYN_SYMS
:
4900 case OPTION_LTO_SYMS
:
4903 #ifdef SUPPORT_DISASSEMBLY
4905 request_dump (dumpdata
, DISASS_DUMP
);
4909 print_version (program_name
);
4918 do_not_show_symbol_truncation
= TRUE
;
4924 enum demangling_styles style
;
4926 style
= cplus_demangle_name_to_style (optarg
);
4927 if (style
== unknown_demangling
)
4928 error (_("unknown demangling style `%s'"), optarg
);
4930 cplus_demangle_set_style (style
);
4933 case OPTION_NO_DEMANGLING
:
4934 do_demangle
= FALSE
;
4936 case OPTION_RECURSE_LIMIT
:
4937 demangle_flags
&= ~ DMGL_NO_RECURSE_LIMIT
;
4939 case OPTION_NO_RECURSE_LIMIT
:
4940 demangle_flags
|= DMGL_NO_RECURSE_LIMIT
;
4942 case OPTION_WITH_SYMBOL_VERSIONS
:
4943 /* Ignored for backward compatibility. */
4947 /* xgettext:c-format */
4948 error (_("Invalid option '-%c'\n"), c
);
4955 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
4956 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
4957 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
4958 && !do_section_groups
&& !do_archive_index
4959 && !do_dyn_syms
&& !do_lto_syms
)
4964 do_dynamic
= do_syms
= do_reloc
= do_unwind
= do_sections
= TRUE
;
4965 do_segments
= do_header
= do_dump
= do_version
= TRUE
;
4966 do_histogram
= do_debugging
= do_arch
= do_notes
= TRUE
;
4967 do_section_groups
= do_archive_index
= do_dyn_syms
= TRUE
;
4976 get_elf_class (unsigned int elf_class
)
4978 static char buff
[32];
4982 case ELFCLASSNONE
: return _("none");
4983 case ELFCLASS32
: return "ELF32";
4984 case ELFCLASS64
: return "ELF64";
4986 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
4992 get_data_encoding (unsigned int encoding
)
4994 static char buff
[32];
4998 case ELFDATANONE
: return _("none");
4999 case ELFDATA2LSB
: return _("2's complement, little endian");
5000 case ELFDATA2MSB
: return _("2's complement, big endian");
5002 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
5007 /* Decode the data held in 'filedata->file_header'. */
5010 process_file_header (Filedata
* filedata
)
5012 Elf_Internal_Ehdr
* header
= & filedata
->file_header
;
5014 if ( header
->e_ident
[EI_MAG0
] != ELFMAG0
5015 || header
->e_ident
[EI_MAG1
] != ELFMAG1
5016 || header
->e_ident
[EI_MAG2
] != ELFMAG2
5017 || header
->e_ident
[EI_MAG3
] != ELFMAG3
)
5020 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
5024 init_dwarf_regnames_by_elf_machine_code (header
->e_machine
);
5030 printf (_("ELF Header:\n"));
5031 printf (_(" Magic: "));
5032 for (i
= 0; i
< EI_NIDENT
; i
++)
5033 printf ("%2.2x ", header
->e_ident
[i
]);
5035 printf (_(" Class: %s\n"),
5036 get_elf_class (header
->e_ident
[EI_CLASS
]));
5037 printf (_(" Data: %s\n"),
5038 get_data_encoding (header
->e_ident
[EI_DATA
]));
5039 printf (_(" Version: %d%s\n"),
5040 header
->e_ident
[EI_VERSION
],
5041 (header
->e_ident
[EI_VERSION
] == EV_CURRENT
5043 : (header
->e_ident
[EI_VERSION
] != EV_NONE
5046 printf (_(" OS/ABI: %s\n"),
5047 get_osabi_name (filedata
, header
->e_ident
[EI_OSABI
]));
5048 printf (_(" ABI Version: %d\n"),
5049 header
->e_ident
[EI_ABIVERSION
]);
5050 printf (_(" Type: %s\n"),
5051 get_file_type (header
->e_type
));
5052 printf (_(" Machine: %s\n"),
5053 get_machine_name (header
->e_machine
));
5054 printf (_(" Version: 0x%lx\n"),
5057 printf (_(" Entry point address: "));
5058 print_vma (header
->e_entry
, PREFIX_HEX
);
5059 printf (_("\n Start of program headers: "));
5060 print_vma (header
->e_phoff
, DEC
);
5061 printf (_(" (bytes into file)\n Start of section headers: "));
5062 print_vma (header
->e_shoff
, DEC
);
5063 printf (_(" (bytes into file)\n"));
5065 printf (_(" Flags: 0x%lx%s\n"),
5067 get_machine_flags (filedata
, header
->e_flags
, header
->e_machine
));
5068 printf (_(" Size of this header: %u (bytes)\n"),
5070 printf (_(" Size of program headers: %u (bytes)\n"),
5071 header
->e_phentsize
);
5072 printf (_(" Number of program headers: %u"),
5074 if (filedata
->section_headers
!= NULL
5075 && header
->e_phnum
== PN_XNUM
5076 && filedata
->section_headers
[0].sh_info
!= 0)
5078 header
->e_phnum
= filedata
->section_headers
[0].sh_info
;
5079 printf (" (%u)", header
->e_phnum
);
5081 putc ('\n', stdout
);
5082 printf (_(" Size of section headers: %u (bytes)\n"),
5083 header
->e_shentsize
);
5084 printf (_(" Number of section headers: %u"),
5086 if (filedata
->section_headers
!= NULL
&& header
->e_shnum
== SHN_UNDEF
)
5088 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
5089 printf (" (%u)", header
->e_shnum
);
5091 putc ('\n', stdout
);
5092 printf (_(" Section header string table index: %u"),
5093 header
->e_shstrndx
);
5094 if (filedata
->section_headers
!= NULL
5095 && header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
5097 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
5098 printf (" (%u)", header
->e_shstrndx
);
5100 if (header
->e_shstrndx
!= SHN_UNDEF
5101 && header
->e_shstrndx
>= header
->e_shnum
)
5103 header
->e_shstrndx
= SHN_UNDEF
;
5104 printf (_(" <corrupt: out of range>"));
5106 putc ('\n', stdout
);
5109 if (filedata
->section_headers
!= NULL
)
5111 if (header
->e_phnum
== PN_XNUM
5112 && filedata
->section_headers
[0].sh_info
!= 0)
5113 header
->e_phnum
= filedata
->section_headers
[0].sh_info
;
5114 if (header
->e_shnum
== SHN_UNDEF
)
5115 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
5116 if (header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
5117 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
5118 if (header
->e_shstrndx
>= header
->e_shnum
)
5119 header
->e_shstrndx
= SHN_UNDEF
;
5120 free (filedata
->section_headers
);
5121 filedata
->section_headers
= NULL
;
5127 /* Read in the program headers from FILEDATA and store them in PHEADERS.
5128 Returns TRUE upon success, FALSE otherwise. Loads 32-bit headers. */
5131 get_32bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
5133 Elf32_External_Phdr
* phdrs
;
5134 Elf32_External_Phdr
* external
;
5135 Elf_Internal_Phdr
* internal
;
5137 unsigned int size
= filedata
->file_header
.e_phentsize
;
5138 unsigned int num
= filedata
->file_header
.e_phnum
;
5140 /* PR binutils/17531: Cope with unexpected section header sizes. */
5141 if (size
== 0 || num
== 0)
5143 if (size
< sizeof * phdrs
)
5145 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
5148 if (size
> sizeof * phdrs
)
5149 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
5151 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
5152 size
, num
, _("program headers"));
5156 for (i
= 0, internal
= pheaders
, external
= phdrs
;
5157 i
< filedata
->file_header
.e_phnum
;
5158 i
++, internal
++, external
++)
5160 internal
->p_type
= BYTE_GET (external
->p_type
);
5161 internal
->p_offset
= BYTE_GET (external
->p_offset
);
5162 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
5163 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
5164 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
5165 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
5166 internal
->p_flags
= BYTE_GET (external
->p_flags
);
5167 internal
->p_align
= BYTE_GET (external
->p_align
);
5174 /* Read in the program headers from FILEDATA and store them in PHEADERS.
5175 Returns TRUE upon success, FALSE otherwise. Loads 64-bit headers. */
5178 get_64bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
5180 Elf64_External_Phdr
* phdrs
;
5181 Elf64_External_Phdr
* external
;
5182 Elf_Internal_Phdr
* internal
;
5184 unsigned int size
= filedata
->file_header
.e_phentsize
;
5185 unsigned int num
= filedata
->file_header
.e_phnum
;
5187 /* PR binutils/17531: Cope with unexpected section header sizes. */
5188 if (size
== 0 || num
== 0)
5190 if (size
< sizeof * phdrs
)
5192 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
5195 if (size
> sizeof * phdrs
)
5196 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
5198 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
5199 size
, num
, _("program headers"));
5203 for (i
= 0, internal
= pheaders
, external
= phdrs
;
5204 i
< filedata
->file_header
.e_phnum
;
5205 i
++, internal
++, external
++)
5207 internal
->p_type
= BYTE_GET (external
->p_type
);
5208 internal
->p_flags
= BYTE_GET (external
->p_flags
);
5209 internal
->p_offset
= BYTE_GET (external
->p_offset
);
5210 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
5211 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
5212 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
5213 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
5214 internal
->p_align
= BYTE_GET (external
->p_align
);
5221 /* Returns TRUE if the program headers were read into `program_headers'. */
5224 get_program_headers (Filedata
* filedata
)
5226 Elf_Internal_Phdr
* phdrs
;
5228 /* Check cache of prior read. */
5229 if (filedata
->program_headers
!= NULL
)
5232 /* Be kind to memory checkers by looking for
5233 e_phnum values which we know must be invalid. */
5234 if (filedata
->file_header
.e_phnum
5235 * (is_32bit_elf
? sizeof (Elf32_External_Phdr
) : sizeof (Elf64_External_Phdr
))
5236 >= filedata
->file_size
)
5238 error (_("Too many program headers - %#x - the file is not that big\n"),
5239 filedata
->file_header
.e_phnum
);
5243 phdrs
= (Elf_Internal_Phdr
*) cmalloc (filedata
->file_header
.e_phnum
,
5244 sizeof (Elf_Internal_Phdr
));
5247 error (_("Out of memory reading %u program headers\n"),
5248 filedata
->file_header
.e_phnum
);
5253 ? get_32bit_program_headers (filedata
, phdrs
)
5254 : get_64bit_program_headers (filedata
, phdrs
))
5256 filedata
->program_headers
= phdrs
;
5264 /* Returns TRUE if the program headers were loaded. */
5267 process_program_headers (Filedata
* filedata
)
5269 Elf_Internal_Phdr
* segment
;
5271 Elf_Internal_Phdr
* previous_load
= NULL
;
5273 filedata
->dynamic_addr
= 0;
5274 filedata
->dynamic_size
= 0;
5276 if (filedata
->file_header
.e_phnum
== 0)
5278 /* PR binutils/12467. */
5279 if (filedata
->file_header
.e_phoff
!= 0)
5281 warn (_("possibly corrupt ELF header - it has a non-zero program"
5282 " header offset, but no program headers\n"));
5285 else if (do_segments
)
5286 printf (_("\nThere are no program headers in this file.\n"));
5290 if (do_segments
&& !do_header
)
5292 printf (_("\nElf file type is %s\n"), get_file_type (filedata
->file_header
.e_type
));
5293 printf (_("Entry point 0x%s\n"), bfd_vmatoa ("x", filedata
->file_header
.e_entry
));
5294 printf (ngettext ("There is %d program header, starting at offset %s\n",
5295 "There are %d program headers, starting at offset %s\n",
5296 filedata
->file_header
.e_phnum
),
5297 filedata
->file_header
.e_phnum
,
5298 bfd_vmatoa ("u", filedata
->file_header
.e_phoff
));
5301 if (! get_program_headers (filedata
))
5306 if (filedata
->file_header
.e_phnum
> 1)
5307 printf (_("\nProgram Headers:\n"));
5309 printf (_("\nProgram Headers:\n"));
5313 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5316 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5320 (_(" Type Offset VirtAddr PhysAddr\n"));
5322 (_(" FileSiz MemSiz Flags Align\n"));
5326 for (i
= 0, segment
= filedata
->program_headers
;
5327 i
< filedata
->file_header
.e_phnum
;
5332 printf (" %-14.14s ", get_segment_type (filedata
, segment
->p_type
));
5336 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
5337 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
5338 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
5339 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
5340 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
5342 (segment
->p_flags
& PF_R
? 'R' : ' '),
5343 (segment
->p_flags
& PF_W
? 'W' : ' '),
5344 (segment
->p_flags
& PF_X
? 'E' : ' '));
5345 printf ("%#lx", (unsigned long) segment
->p_align
);
5349 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
5350 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
5353 print_vma (segment
->p_offset
, FULL_HEX
);
5357 print_vma (segment
->p_vaddr
, FULL_HEX
);
5359 print_vma (segment
->p_paddr
, FULL_HEX
);
5362 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
5363 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
5366 print_vma (segment
->p_filesz
, FULL_HEX
);
5370 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
5371 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
5374 print_vma (segment
->p_memsz
, FULL_HEX
);
5378 (segment
->p_flags
& PF_R
? 'R' : ' '),
5379 (segment
->p_flags
& PF_W
? 'W' : ' '),
5380 (segment
->p_flags
& PF_X
? 'E' : ' '));
5382 if ((unsigned long) segment
->p_align
== segment
->p_align
)
5383 printf ("%#lx", (unsigned long) segment
->p_align
);
5386 print_vma (segment
->p_align
, PREFIX_HEX
);
5391 print_vma (segment
->p_offset
, FULL_HEX
);
5393 print_vma (segment
->p_vaddr
, FULL_HEX
);
5395 print_vma (segment
->p_paddr
, FULL_HEX
);
5397 print_vma (segment
->p_filesz
, FULL_HEX
);
5399 print_vma (segment
->p_memsz
, FULL_HEX
);
5401 (segment
->p_flags
& PF_R
? 'R' : ' '),
5402 (segment
->p_flags
& PF_W
? 'W' : ' '),
5403 (segment
->p_flags
& PF_X
? 'E' : ' '));
5404 print_vma (segment
->p_align
, PREFIX_HEX
);
5407 putc ('\n', stdout
);
5410 switch (segment
->p_type
)
5413 #if 0 /* Do not warn about out of order PT_LOAD segments. Although officially
5414 required by the ELF standard, several programs, including the Linux
5415 kernel, make use of non-ordered segments. */
5417 && previous_load
->p_vaddr
> segment
->p_vaddr
)
5418 error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
5420 if (segment
->p_memsz
< segment
->p_filesz
)
5421 error (_("the segment's file size is larger than its memory size\n"));
5422 previous_load
= segment
;
5426 /* PR 20815 - Verify that the program header is loaded into memory. */
5427 if (i
> 0 && previous_load
!= NULL
)
5428 error (_("the PHDR segment must occur before any LOAD segment\n"));
5429 if (filedata
->file_header
.e_machine
!= EM_PARISC
)
5433 for (j
= 1; j
< filedata
->file_header
.e_phnum
; j
++)
5435 Elf_Internal_Phdr
*load
= filedata
->program_headers
+ j
;
5436 if (load
->p_type
== PT_LOAD
5437 && load
->p_offset
<= segment
->p_offset
5438 && (load
->p_offset
+ load
->p_filesz
5439 >= segment
->p_offset
+ segment
->p_filesz
)
5440 && load
->p_vaddr
<= segment
->p_vaddr
5441 && (load
->p_vaddr
+ load
->p_filesz
5442 >= segment
->p_vaddr
+ segment
->p_filesz
))
5445 if (j
== filedata
->file_header
.e_phnum
)
5446 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5451 if (filedata
->dynamic_addr
)
5452 error (_("more than one dynamic segment\n"));
5454 /* By default, assume that the .dynamic section is the first
5455 section in the DYNAMIC segment. */
5456 filedata
->dynamic_addr
= segment
->p_offset
;
5457 filedata
->dynamic_size
= segment
->p_filesz
;
5459 /* Try to locate the .dynamic section. If there is
5460 a section header table, we can easily locate it. */
5461 if (filedata
->section_headers
!= NULL
)
5463 Elf_Internal_Shdr
* sec
;
5465 sec
= find_section (filedata
, ".dynamic");
5466 if (sec
== NULL
|| sec
->sh_size
== 0)
5468 /* A corresponding .dynamic section is expected, but on
5469 IA-64/OpenVMS it is OK for it to be missing. */
5470 if (!is_ia64_vms (filedata
))
5471 error (_("no .dynamic section in the dynamic segment\n"));
5475 if (sec
->sh_type
== SHT_NOBITS
)
5477 filedata
->dynamic_size
= 0;
5481 filedata
->dynamic_addr
= sec
->sh_offset
;
5482 filedata
->dynamic_size
= sec
->sh_size
;
5484 /* The PT_DYNAMIC segment, which is used by the run-time
5485 loader, should exactly match the .dynamic section. */
5487 && (filedata
->dynamic_addr
!= segment
->p_offset
5488 || filedata
->dynamic_size
!= segment
->p_filesz
))
5490 the .dynamic section is not the same as the dynamic segment\n"));
5493 /* PR binutils/17512: Avoid corrupt dynamic section info in the
5494 segment. Check this after matching against the section headers
5495 so we don't warn on debuginfo file (which have NOBITS .dynamic
5497 if (filedata
->dynamic_addr
> filedata
->file_size
5498 || (filedata
->dynamic_size
5499 > filedata
->file_size
- filedata
->dynamic_addr
))
5501 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5502 filedata
->dynamic_addr
= filedata
->dynamic_size
= 0;
5507 if (fseek (filedata
->handle
,
5508 filedata
->archive_file_offset
+ (long) segment
->p_offset
,
5510 error (_("Unable to find program interpreter name\n"));
5514 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
- 1);
5516 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
5517 error (_("Internal error: failed to create format string to display program interpreter\n"));
5519 filedata
->program_interpreter
[0] = 0;
5520 if (fscanf (filedata
->handle
, fmt
,
5521 filedata
->program_interpreter
) <= 0)
5522 error (_("Unable to read program interpreter name\n"));
5525 printf (_(" [Requesting program interpreter: %s]\n"),
5526 filedata
->program_interpreter
);
5533 && filedata
->section_headers
!= NULL
5534 && filedata
->string_table
!= NULL
)
5536 printf (_("\n Section to Segment mapping:\n"));
5537 printf (_(" Segment Sections...\n"));
5539 for (i
= 0; i
< filedata
->file_header
.e_phnum
; i
++)
5542 Elf_Internal_Shdr
* section
;
5544 segment
= filedata
->program_headers
+ i
;
5545 section
= filedata
->section_headers
+ 1;
5547 printf (" %2.2d ", i
);
5549 for (j
= 1; j
< filedata
->file_header
.e_shnum
; j
++, section
++)
5551 if (!ELF_TBSS_SPECIAL (section
, segment
)
5552 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
5553 printf ("%s ", printable_section_name (filedata
, section
));
5564 /* Find the file offset corresponding to VMA by using the program headers. */
5567 offset_from_vma (Filedata
* filedata
, bfd_vma vma
, bfd_size_type size
)
5569 Elf_Internal_Phdr
* seg
;
5571 if (! get_program_headers (filedata
))
5573 warn (_("Cannot interpret virtual addresses without program headers.\n"));
5577 for (seg
= filedata
->program_headers
;
5578 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
5581 if (seg
->p_type
!= PT_LOAD
)
5584 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
5585 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
5586 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
5589 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5590 (unsigned long) vma
);
5595 /* Allocate memory and load the sections headers into FILEDATA->filedata->section_headers.
5596 If PROBE is true, this is just a probe and we do not generate any error
5597 messages if the load fails. */
5600 get_32bit_section_headers (Filedata
* filedata
, bfd_boolean probe
)
5602 Elf32_External_Shdr
* shdrs
;
5603 Elf_Internal_Shdr
* internal
;
5605 unsigned int size
= filedata
->file_header
.e_shentsize
;
5606 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
5608 /* PR binutils/17531: Cope with unexpected section header sizes. */
5609 if (size
== 0 || num
== 0)
5611 if (size
< sizeof * shdrs
)
5614 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5617 if (!probe
&& size
> sizeof * shdrs
)
5618 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5620 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_shoff
,
5622 probe
? NULL
: _("section headers"));
5626 free (filedata
->section_headers
);
5627 filedata
->section_headers
= (Elf_Internal_Shdr
*)
5628 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
5629 if (filedata
->section_headers
== NULL
)
5632 error (_("Out of memory reading %u section headers\n"), num
);
5637 for (i
= 0, internal
= filedata
->section_headers
;
5641 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5642 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5643 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5644 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5645 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5646 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5647 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5648 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5649 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5650 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5651 if (!probe
&& internal
->sh_link
> num
)
5652 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5653 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5654 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5661 /* Like get_32bit_section_headers, except that it fetches 64-bit headers. */
5664 get_64bit_section_headers (Filedata
* filedata
, bfd_boolean probe
)
5666 Elf64_External_Shdr
* shdrs
;
5667 Elf_Internal_Shdr
* internal
;
5669 unsigned int size
= filedata
->file_header
.e_shentsize
;
5670 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
5672 /* PR binutils/17531: Cope with unexpected section header sizes. */
5673 if (size
== 0 || num
== 0)
5676 if (size
< sizeof * shdrs
)
5679 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5683 if (! probe
&& size
> sizeof * shdrs
)
5684 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5686 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, filedata
,
5687 filedata
->file_header
.e_shoff
,
5689 probe
? NULL
: _("section headers"));
5693 free (filedata
->section_headers
);
5694 filedata
->section_headers
= (Elf_Internal_Shdr
*)
5695 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
5696 if (filedata
->section_headers
== NULL
)
5699 error (_("Out of memory reading %u section headers\n"), num
);
5704 for (i
= 0, internal
= filedata
->section_headers
;
5708 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5709 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5710 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5711 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5712 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5713 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5714 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5715 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5716 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5717 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5718 if (!probe
&& internal
->sh_link
> num
)
5719 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5720 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5721 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5728 static Elf_Internal_Sym
*
5729 get_32bit_elf_symbols (Filedata
* filedata
,
5730 Elf_Internal_Shdr
* section
,
5731 unsigned long * num_syms_return
)
5733 unsigned long number
= 0;
5734 Elf32_External_Sym
* esyms
= NULL
;
5735 Elf_External_Sym_Shndx
* shndx
= NULL
;
5736 Elf_Internal_Sym
* isyms
= NULL
;
5737 Elf_Internal_Sym
* psym
;
5739 elf_section_list
* entry
;
5741 if (section
->sh_size
== 0)
5743 if (num_syms_return
!= NULL
)
5744 * num_syms_return
= 0;
5748 /* Run some sanity checks first. */
5749 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5751 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5752 printable_section_name (filedata
, section
),
5753 (unsigned long) section
->sh_entsize
);
5757 if (section
->sh_size
> filedata
->file_size
)
5759 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5760 printable_section_name (filedata
, section
),
5761 (unsigned long) section
->sh_size
);
5765 number
= section
->sh_size
/ section
->sh_entsize
;
5767 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
5769 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5770 (unsigned long) section
->sh_size
,
5771 printable_section_name (filedata
, section
),
5772 (unsigned long) section
->sh_entsize
);
5776 esyms
= (Elf32_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
5777 section
->sh_size
, _("symbols"));
5782 for (entry
= filedata
->symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5784 if (entry
->hdr
->sh_link
!= (unsigned long) (section
- filedata
->section_headers
))
5789 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5793 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
5794 entry
->hdr
->sh_offset
,
5795 1, entry
->hdr
->sh_size
,
5796 _("symbol table section indices"));
5800 /* PR17531: file: heap-buffer-overflow */
5801 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5803 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5804 printable_section_name (filedata
, entry
->hdr
),
5805 (unsigned long) entry
->hdr
->sh_size
,
5806 (unsigned long) section
->sh_size
);
5811 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5815 error (_("Out of memory reading %lu symbols\n"),
5816 (unsigned long) number
);
5820 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5822 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5823 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5824 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5825 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5826 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5828 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5829 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5830 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5831 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5832 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5839 if (num_syms_return
!= NULL
)
5840 * num_syms_return
= isyms
== NULL
? 0 : number
;
5845 static Elf_Internal_Sym
*
5846 get_64bit_elf_symbols (Filedata
* filedata
,
5847 Elf_Internal_Shdr
* section
,
5848 unsigned long * num_syms_return
)
5850 unsigned long number
= 0;
5851 Elf64_External_Sym
* esyms
= NULL
;
5852 Elf_External_Sym_Shndx
* shndx
= NULL
;
5853 Elf_Internal_Sym
* isyms
= NULL
;
5854 Elf_Internal_Sym
* psym
;
5856 elf_section_list
* entry
;
5858 if (section
->sh_size
== 0)
5860 if (num_syms_return
!= NULL
)
5861 * num_syms_return
= 0;
5865 /* Run some sanity checks first. */
5866 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5868 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5869 printable_section_name (filedata
, section
),
5870 (unsigned long) section
->sh_entsize
);
5874 if (section
->sh_size
> filedata
->file_size
)
5876 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5877 printable_section_name (filedata
, section
),
5878 (unsigned long) section
->sh_size
);
5882 number
= section
->sh_size
/ section
->sh_entsize
;
5884 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
5886 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5887 (unsigned long) section
->sh_size
,
5888 printable_section_name (filedata
, section
),
5889 (unsigned long) section
->sh_entsize
);
5893 esyms
= (Elf64_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
5894 section
->sh_size
, _("symbols"));
5899 for (entry
= filedata
->symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5901 if (entry
->hdr
->sh_link
!= (unsigned long) (section
- filedata
->section_headers
))
5906 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5910 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
5911 entry
->hdr
->sh_offset
,
5912 1, entry
->hdr
->sh_size
,
5913 _("symbol table section indices"));
5917 /* PR17531: file: heap-buffer-overflow */
5918 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5920 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5921 printable_section_name (filedata
, entry
->hdr
),
5922 (unsigned long) entry
->hdr
->sh_size
,
5923 (unsigned long) section
->sh_size
);
5928 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5932 error (_("Out of memory reading %lu symbols\n"),
5933 (unsigned long) number
);
5937 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5939 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5940 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5941 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5942 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5944 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5946 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5947 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5948 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5950 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5951 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5958 if (num_syms_return
!= NULL
)
5959 * num_syms_return
= isyms
== NULL
? 0 : number
;
5965 get_elf_section_flags (Filedata
* filedata
, bfd_vma sh_flags
)
5967 static char buff
[1024];
5969 unsigned int field_size
= is_32bit_elf
? 8 : 16;
5971 unsigned int size
= sizeof (buff
) - (field_size
+ 4 + 1);
5972 bfd_vma os_flags
= 0;
5973 bfd_vma proc_flags
= 0;
5974 bfd_vma unknown_flags
= 0;
5982 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5983 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5984 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5985 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5986 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5987 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5988 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5989 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5990 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5991 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5992 /* IA-64 specific. */
5993 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5994 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5995 /* IA-64 OpenVMS specific. */
5996 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5997 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5998 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5999 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
6000 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
6001 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
6003 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
6004 /* SPARC specific. */
6005 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
6006 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
6008 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
6009 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
6010 /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
6012 /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
6014 /* 25 */ { STRING_COMMA_LEN ("VLE") },
6016 /* 26 */ { STRING_COMMA_LEN ("GNU_RETAIN") },
6019 if (do_section_details
)
6021 sprintf (buff
, "[%*.*lx]: ",
6022 field_size
, field_size
, (unsigned long) sh_flags
);
6023 p
+= field_size
+ 4;
6030 flag
= sh_flags
& - sh_flags
;
6033 if (do_section_details
)
6037 case SHF_WRITE
: sindex
= 0; break;
6038 case SHF_ALLOC
: sindex
= 1; break;
6039 case SHF_EXECINSTR
: sindex
= 2; break;
6040 case SHF_MERGE
: sindex
= 3; break;
6041 case SHF_STRINGS
: sindex
= 4; break;
6042 case SHF_INFO_LINK
: sindex
= 5; break;
6043 case SHF_LINK_ORDER
: sindex
= 6; break;
6044 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
6045 case SHF_GROUP
: sindex
= 8; break;
6046 case SHF_TLS
: sindex
= 9; break;
6047 case SHF_EXCLUDE
: sindex
= 18; break;
6048 case SHF_COMPRESSED
: sindex
= 20; break;
6052 switch (filedata
->file_header
.e_machine
)
6055 if (flag
== SHF_IA_64_SHORT
)
6057 else if (flag
== SHF_IA_64_NORECOV
)
6060 else if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
6063 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
6064 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
6065 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
6066 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
6067 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
6068 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
6079 case EM_OLD_SPARCV9
:
6080 case EM_SPARC32PLUS
:
6083 if (flag
== SHF_ORDERED
)
6090 case SHF_ENTRYSECT
: sindex
= 21; break;
6091 case SHF_ARM_PURECODE
: sindex
= 22; break;
6092 case SHF_COMDEF
: sindex
= 23; break;
6097 if (flag
== SHF_PPC_VLE
)
6104 switch (filedata
->file_header
.e_ident
[EI_OSABI
])
6107 case ELFOSABI_FREEBSD
:
6108 if (flag
== SHF_GNU_RETAIN
)
6112 if (flag
== SHF_GNU_MBIND
)
6113 /* We should not recognize SHF_GNU_MBIND for
6114 ELFOSABI_NONE, but binutils as of 2019-07-23 did
6115 not set the EI_OSABI header byte. */
6126 if (p
!= buff
+ field_size
+ 4)
6128 if (size
< (10 + 2))
6130 warn (_("Internal error: not enough buffer room for section flag info"));
6131 return _("<unknown>");
6138 size
-= flags
[sindex
].len
;
6139 p
= stpcpy (p
, flags
[sindex
].str
);
6141 else if (flag
& SHF_MASKOS
)
6143 else if (flag
& SHF_MASKPROC
)
6146 unknown_flags
|= flag
;
6152 case SHF_WRITE
: *p
= 'W'; break;
6153 case SHF_ALLOC
: *p
= 'A'; break;
6154 case SHF_EXECINSTR
: *p
= 'X'; break;
6155 case SHF_MERGE
: *p
= 'M'; break;
6156 case SHF_STRINGS
: *p
= 'S'; break;
6157 case SHF_INFO_LINK
: *p
= 'I'; break;
6158 case SHF_LINK_ORDER
: *p
= 'L'; break;
6159 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
6160 case SHF_GROUP
: *p
= 'G'; break;
6161 case SHF_TLS
: *p
= 'T'; break;
6162 case SHF_EXCLUDE
: *p
= 'E'; break;
6163 case SHF_COMPRESSED
: *p
= 'C'; break;
6166 if ((filedata
->file_header
.e_machine
== EM_X86_64
6167 || filedata
->file_header
.e_machine
== EM_L1OM
6168 || filedata
->file_header
.e_machine
== EM_K1OM
)
6169 && flag
== SHF_X86_64_LARGE
)
6171 else if (filedata
->file_header
.e_machine
== EM_ARM
6172 && flag
== SHF_ARM_PURECODE
)
6174 else if (filedata
->file_header
.e_machine
== EM_PPC
6175 && flag
== SHF_PPC_VLE
)
6177 else if (flag
& SHF_MASKOS
)
6179 switch (filedata
->file_header
.e_ident
[EI_OSABI
])
6182 case ELFOSABI_FREEBSD
:
6183 if (flag
== SHF_GNU_RETAIN
)
6190 if (flag
== SHF_GNU_MBIND
)
6192 /* We should not recognize SHF_GNU_MBIND for
6193 ELFOSABI_NONE, but binutils as of 2019-07-23 did
6194 not set the EI_OSABI header byte. */
6201 sh_flags
&= ~SHF_MASKOS
;
6205 else if (flag
& SHF_MASKPROC
)
6208 sh_flags
&= ~ SHF_MASKPROC
;
6218 if (do_section_details
)
6222 size
-= 5 + field_size
;
6223 if (p
!= buff
+ field_size
+ 4)
6227 warn (_("Internal error: not enough buffer room for section flag info"));
6228 return _("<unknown>");
6234 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
6235 (unsigned long) os_flags
);
6236 p
+= 5 + field_size
;
6240 size
-= 7 + field_size
;
6241 if (p
!= buff
+ field_size
+ 4)
6245 warn (_("Internal error: not enough buffer room for section flag info"));
6246 return _("<unknown>");
6252 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
6253 (unsigned long) proc_flags
);
6254 p
+= 7 + field_size
;
6258 size
-= 10 + field_size
;
6259 if (p
!= buff
+ field_size
+ 4)
6263 warn (_("Internal error: not enough buffer room for section flag info"));
6264 return _("<unknown>");
6270 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
6271 (unsigned long) unknown_flags
);
6272 p
+= 10 + field_size
;
6280 static unsigned int ATTRIBUTE_WARN_UNUSED_RESULT
6281 get_compression_header (Elf_Internal_Chdr
*chdr
, unsigned char *buf
, bfd_size_type size
)
6285 Elf32_External_Chdr
*echdr
= (Elf32_External_Chdr
*) buf
;
6287 if (size
< sizeof (* echdr
))
6289 error (_("Compressed section is too small even for a compression header\n"));
6293 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
6294 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
6295 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
6296 return sizeof (*echdr
);
6300 Elf64_External_Chdr
*echdr
= (Elf64_External_Chdr
*) buf
;
6302 if (size
< sizeof (* echdr
))
6304 error (_("Compressed section is too small even for a compression header\n"));
6308 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
6309 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
6310 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
6311 return sizeof (*echdr
);
6316 process_section_headers (Filedata
* filedata
)
6318 Elf_Internal_Shdr
* section
;
6321 free (filedata
->section_headers
);
6322 filedata
->section_headers
= NULL
;
6323 free (filedata
->dynamic_symbols
);
6324 filedata
->dynamic_symbols
= NULL
;
6325 filedata
->num_dynamic_syms
= 0;
6326 free (filedata
->dynamic_strings
);
6327 filedata
->dynamic_strings
= NULL
;
6328 filedata
->dynamic_strings_length
= 0;
6329 free (filedata
->dynamic_syminfo
);
6330 filedata
->dynamic_syminfo
= NULL
;
6331 while (filedata
->symtab_shndx_list
!= NULL
)
6333 elf_section_list
*next
= filedata
->symtab_shndx_list
->next
;
6334 free (filedata
->symtab_shndx_list
);
6335 filedata
->symtab_shndx_list
= next
;
6338 if (filedata
->file_header
.e_shnum
== 0)
6340 /* PR binutils/12467. */
6341 if (filedata
->file_header
.e_shoff
!= 0)
6343 warn (_("possibly corrupt ELF file header - it has a non-zero"
6344 " section header offset, but no section headers\n"));
6347 else if (do_sections
)
6348 printf (_("\nThere are no sections in this file.\n"));
6353 if (do_sections
&& !do_header
)
6354 printf (ngettext ("There is %d section header, "
6355 "starting at offset 0x%lx:\n",
6356 "There are %d section headers, "
6357 "starting at offset 0x%lx:\n",
6358 filedata
->file_header
.e_shnum
),
6359 filedata
->file_header
.e_shnum
,
6360 (unsigned long) filedata
->file_header
.e_shoff
);
6364 if (! get_32bit_section_headers (filedata
, FALSE
))
6369 if (! get_64bit_section_headers (filedata
, FALSE
))
6373 /* Read in the string table, so that we have names to display. */
6374 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
6375 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
6377 section
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
6379 if (section
->sh_size
!= 0)
6381 filedata
->string_table
= (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6382 1, section
->sh_size
,
6385 filedata
->string_table_length
= filedata
->string_table
!= NULL
? section
->sh_size
: 0;
6389 /* Scan the sections for the dynamic symbol table
6390 and dynamic string table and debug sections. */
6391 eh_addr_size
= is_32bit_elf
? 4 : 8;
6392 switch (filedata
->file_header
.e_machine
)
6395 case EM_MIPS_RS3_LE
:
6396 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
6397 FDE addresses. However, the ABI also has a semi-official ILP32
6398 variant for which the normal FDE address size rules apply.
6400 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
6401 section, where XX is the size of longs in bits. Unfortunately,
6402 earlier compilers provided no way of distinguishing ILP32 objects
6403 from LP64 objects, so if there's any doubt, we should assume that
6404 the official LP64 form is being used. */
6405 if ((filedata
->file_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
6406 && find_section (filedata
, ".gcc_compiled_long32") == NULL
)
6412 switch (filedata
->file_header
.e_flags
& EF_H8_MACH
)
6414 case E_H8_MACH_H8300
:
6415 case E_H8_MACH_H8300HN
:
6416 case E_H8_MACH_H8300SN
:
6417 case E_H8_MACH_H8300SXN
:
6420 case E_H8_MACH_H8300H
:
6421 case E_H8_MACH_H8300S
:
6422 case E_H8_MACH_H8300SX
:
6430 switch (filedata
->file_header
.e_flags
& EF_M32C_CPU_MASK
)
6432 case EF_M32C_CPU_M16C
:
6439 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
6442 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
6443 if (section->sh_entsize != expected_entsize) \
6446 sprintf_vma (buf, section->sh_entsize); \
6447 /* Note: coded this way so that there is a single string for \
6449 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
6450 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
6451 (unsigned) expected_entsize); \
6452 section->sh_entsize = expected_entsize; \
6457 #define CHECK_ENTSIZE(section, i, type) \
6458 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
6459 sizeof (Elf64_External_##type))
6461 for (i
= 0, section
= filedata
->section_headers
;
6462 i
< filedata
->file_header
.e_shnum
;
6465 char * name
= SECTION_NAME_PRINT (section
);
6467 /* Run some sanity checks on the headers and
6468 possibly fill in some file data as well. */
6469 switch (section
->sh_type
)
6472 if (filedata
->dynamic_symbols
!= NULL
)
6474 error (_("File contains multiple dynamic symbol tables\n"));
6478 CHECK_ENTSIZE (section
, i
, Sym
);
6479 filedata
->dynamic_symbols
6480 = GET_ELF_SYMBOLS (filedata
, section
, &filedata
->num_dynamic_syms
);
6481 filedata
->dynamic_symtab_section
= section
;
6485 if (streq (name
, ".dynstr"))
6487 if (filedata
->dynamic_strings
!= NULL
)
6489 error (_("File contains multiple dynamic string tables\n"));
6493 filedata
->dynamic_strings
6494 = (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6495 1, section
->sh_size
, _("dynamic strings"));
6496 filedata
->dynamic_strings_length
6497 = filedata
->dynamic_strings
== NULL
? 0 : section
->sh_size
;
6498 filedata
->dynamic_strtab_section
= section
;
6502 case SHT_SYMTAB_SHNDX
:
6504 elf_section_list
* entry
= xmalloc (sizeof * entry
);
6506 entry
->hdr
= section
;
6507 entry
->next
= filedata
->symtab_shndx_list
;
6508 filedata
->symtab_shndx_list
= entry
;
6513 CHECK_ENTSIZE (section
, i
, Sym
);
6517 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
6521 CHECK_ENTSIZE (section
, i
, Rel
);
6522 if (do_checks
&& section
->sh_size
== 0)
6523 warn (_("Section '%s': zero-sized relocation section\n"), name
);
6527 CHECK_ENTSIZE (section
, i
, Rela
);
6528 if (do_checks
&& section
->sh_size
== 0)
6529 warn (_("Section '%s': zero-sized relocation section\n"), name
);
6534 /* Having a zero sized section is not illegal according to the
6535 ELF standard, but it might be an indication that something
6536 is wrong. So issue a warning if we are running in lint mode. */
6537 if (do_checks
&& section
->sh_size
== 0)
6538 warn (_("Section '%s': has a size of zero - is this intended ?\n"), name
);
6545 if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
6546 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
6547 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
6548 || do_debug_str
|| do_debug_str_offsets
|| do_debug_loc
|| do_debug_ranges
6549 || do_debug_addr
|| do_debug_cu_index
|| do_debug_links
)
6550 && (const_strneq (name
, ".debug_")
6551 || const_strneq (name
, ".zdebug_")))
6554 name
+= sizeof (".zdebug_") - 1;
6556 name
+= sizeof (".debug_") - 1;
6559 || (do_debug_info
&& const_strneq (name
, "info"))
6560 || (do_debug_info
&& const_strneq (name
, "types"))
6561 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
6562 || (do_debug_lines
&& strcmp (name
, "line") == 0)
6563 || (do_debug_lines
&& const_strneq (name
, "line."))
6564 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
6565 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
6566 || (do_debug_pubnames
&& const_strneq (name
, "gnu_pubnames"))
6567 || (do_debug_pubtypes
&& const_strneq (name
, "gnu_pubtypes"))
6568 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
6569 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
6570 || (do_debug_ranges
&& const_strneq (name
, "rnglists"))
6571 || (do_debug_frames
&& const_strneq (name
, "frame"))
6572 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
6573 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
6574 || (do_debug_str
&& const_strneq (name
, "str"))
6575 || (do_debug_str_offsets
&& const_strneq (name
, "str_offsets"))
6576 || (do_debug_loc
&& const_strneq (name
, "loc"))
6577 || (do_debug_loc
&& const_strneq (name
, "loclists"))
6578 || (do_debug_addr
&& const_strneq (name
, "addr"))
6579 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
6580 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
6582 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6584 /* Linkonce section to be combined with .debug_info at link time. */
6585 else if ((do_debugging
|| do_debug_info
)
6586 && const_strneq (name
, ".gnu.linkonce.wi."))
6587 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6588 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
6589 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6590 else if (do_gdb_index
&& (streq (name
, ".gdb_index")
6591 || streq (name
, ".debug_names")))
6592 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6593 /* Trace sections for Itanium VMS. */
6594 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
6595 || do_trace_aranges
)
6596 && const_strneq (name
, ".trace_"))
6598 name
+= sizeof (".trace_") - 1;
6601 || (do_trace_info
&& streq (name
, "info"))
6602 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
6603 || (do_trace_aranges
&& streq (name
, "aranges"))
6605 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6607 else if ((do_debugging
|| do_debug_links
)
6608 && (const_strneq (name
, ".gnu_debuglink")
6609 || const_strneq (name
, ".gnu_debugaltlink")))
6610 request_dump_bynumber (&filedata
->dump
, i
, DEBUG_DUMP
);
6616 if (filedata
->file_header
.e_shnum
> 1)
6617 printf (_("\nSection Headers:\n"));
6619 printf (_("\nSection Header:\n"));
6623 if (do_section_details
)
6625 printf (_(" [Nr] Name\n"));
6626 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
6630 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
6634 if (do_section_details
)
6636 printf (_(" [Nr] Name\n"));
6637 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
6641 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
6645 if (do_section_details
)
6647 printf (_(" [Nr] Name\n"));
6648 printf (_(" Type Address Offset Link\n"));
6649 printf (_(" Size EntSize Info Align\n"));
6653 printf (_(" [Nr] Name Type Address Offset\n"));
6654 printf (_(" Size EntSize Flags Link Info Align\n"));
6658 if (do_section_details
)
6659 printf (_(" Flags\n"));
6661 for (i
= 0, section
= filedata
->section_headers
;
6662 i
< filedata
->file_header
.e_shnum
;
6665 /* Run some sanity checks on the section header. */
6667 /* Check the sh_link field. */
6668 switch (section
->sh_type
)
6672 if (section
->sh_link
== 0
6673 && (filedata
->file_header
.e_type
== ET_EXEC
6674 || filedata
->file_header
.e_type
== ET_DYN
))
6675 /* A dynamic relocation section where all entries use a
6676 zero symbol index need not specify a symtab section. */
6679 case SHT_SYMTAB_SHNDX
:
6683 case SHT_GNU_versym
:
6684 if (section
->sh_link
== 0
6685 || section
->sh_link
>= filedata
->file_header
.e_shnum
6686 || (filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_SYMTAB
6687 && filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_DYNSYM
))
6688 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6689 i
, section
->sh_link
);
6695 case SHT_GNU_verneed
:
6696 case SHT_GNU_verdef
:
6697 case SHT_GNU_LIBLIST
:
6698 if (section
->sh_link
== 0
6699 || section
->sh_link
>= filedata
->file_header
.e_shnum
6700 || filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_STRTAB
)
6701 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6702 i
, section
->sh_link
);
6705 case SHT_INIT_ARRAY
:
6706 case SHT_FINI_ARRAY
:
6707 case SHT_PREINIT_ARRAY
:
6708 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6709 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6710 i
, section
->sh_link
);
6714 /* FIXME: Add support for target specific section types. */
6715 #if 0 /* Currently we do not check other section types as there are too
6716 many special cases. Stab sections for example have a type
6717 of SHT_PROGBITS but an sh_link field that links to the .stabstr
6719 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6720 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6721 i
, section
->sh_link
);
6726 /* Check the sh_info field. */
6727 switch (section
->sh_type
)
6731 if (section
->sh_info
== 0
6732 && (filedata
->file_header
.e_type
== ET_EXEC
6733 || filedata
->file_header
.e_type
== ET_DYN
))
6734 /* Dynamic relocations apply to segments, so they do not
6735 need to specify the section they relocate. */
6737 if (section
->sh_info
== 0
6738 || section
->sh_info
>= filedata
->file_header
.e_shnum
6739 || (filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PROGBITS
6740 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOBITS
6741 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOTE
6742 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_INIT_ARRAY
6743 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_FINI_ARRAY
6744 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PREINIT_ARRAY
6745 /* FIXME: Are other section types valid ? */
6746 && filedata
->section_headers
[section
->sh_info
].sh_type
< SHT_LOOS
))
6747 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6748 i
, section
->sh_info
);
6753 case SHT_SYMTAB_SHNDX
:
6754 case SHT_INIT_ARRAY
:
6755 case SHT_FINI_ARRAY
:
6756 case SHT_PREINIT_ARRAY
:
6757 if (section
->sh_info
!= 0)
6758 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6759 i
, section
->sh_info
);
6765 /* A symbol index - we assume that it is valid. */
6769 /* FIXME: Add support for target specific section types. */
6770 if (section
->sh_type
== SHT_NOBITS
)
6771 /* NOBITS section headers with non-zero sh_info fields can be
6772 created when a binary is stripped of everything but its debug
6773 information. The stripped sections have their headers
6774 preserved but their types set to SHT_NOBITS. So do not check
6775 this type of section. */
6777 else if (section
->sh_flags
& SHF_INFO_LINK
)
6779 if (section
->sh_info
< 1 || section
->sh_info
>= filedata
->file_header
.e_shnum
)
6780 warn (_("[%2u]: Expected link to another section in info field"), i
);
6782 else if (section
->sh_type
< SHT_LOOS
6783 && (section
->sh_flags
& SHF_GNU_MBIND
) == 0
6784 && section
->sh_info
!= 0)
6785 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6786 i
, section
->sh_info
);
6790 /* Check the sh_size field. */
6791 if (section
->sh_size
> filedata
->file_size
6792 && section
->sh_type
!= SHT_NOBITS
6793 && section
->sh_type
!= SHT_NULL
6794 && section
->sh_type
< SHT_LOOS
)
6795 warn (_("Size of section %u is larger than the entire file!\n"), i
);
6797 printf (" [%2u] ", i
);
6798 if (do_section_details
)
6799 printf ("%s\n ", printable_section_name (filedata
, section
));
6801 print_symbol (-17, SECTION_NAME_PRINT (section
));
6803 printf (do_wide
? " %-15s " : " %-15.15s ",
6804 get_section_type_name (filedata
, section
->sh_type
));
6808 const char * link_too_big
= NULL
;
6810 print_vma (section
->sh_addr
, LONG_HEX
);
6812 printf ( " %6.6lx %6.6lx %2.2lx",
6813 (unsigned long) section
->sh_offset
,
6814 (unsigned long) section
->sh_size
,
6815 (unsigned long) section
->sh_entsize
);
6817 if (do_section_details
)
6818 fputs (" ", stdout
);
6820 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6822 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
6825 /* The sh_link value is out of range. Normally this indicates
6826 an error but it can have special values in Solaris binaries. */
6827 switch (filedata
->file_header
.e_machine
)
6834 case EM_OLD_SPARCV9
:
6835 case EM_SPARC32PLUS
:
6838 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
6839 link_too_big
= "BEFORE";
6840 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
6841 link_too_big
= "AFTER";
6848 if (do_section_details
)
6850 if (link_too_big
!= NULL
&& * link_too_big
)
6851 printf ("<%s> ", link_too_big
);
6853 printf ("%2u ", section
->sh_link
);
6854 printf ("%3u %2lu\n", section
->sh_info
,
6855 (unsigned long) section
->sh_addralign
);
6858 printf ("%2u %3u %2lu\n",
6861 (unsigned long) section
->sh_addralign
);
6863 if (link_too_big
&& ! * link_too_big
)
6864 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6865 i
, section
->sh_link
);
6869 print_vma (section
->sh_addr
, LONG_HEX
);
6871 if ((long) section
->sh_offset
== section
->sh_offset
)
6872 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
6876 print_vma (section
->sh_offset
, LONG_HEX
);
6879 if ((unsigned long) section
->sh_size
== section
->sh_size
)
6880 printf (" %6.6lx", (unsigned long) section
->sh_size
);
6884 print_vma (section
->sh_size
, LONG_HEX
);
6887 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
6888 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
6892 print_vma (section
->sh_entsize
, LONG_HEX
);
6895 if (do_section_details
)
6896 fputs (" ", stdout
);
6898 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6900 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
6902 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
6903 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
6906 print_vma (section
->sh_addralign
, DEC
);
6910 else if (do_section_details
)
6913 print_vma (section
->sh_addr
, LONG_HEX
);
6914 if ((long) section
->sh_offset
== section
->sh_offset
)
6915 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
6919 print_vma (section
->sh_offset
, LONG_HEX
);
6921 printf (" %u\n ", section
->sh_link
);
6922 print_vma (section
->sh_size
, LONG_HEX
);
6924 print_vma (section
->sh_entsize
, LONG_HEX
);
6926 printf (" %-16u %lu\n",
6928 (unsigned long) section
->sh_addralign
);
6933 print_vma (section
->sh_addr
, LONG_HEX
);
6934 if ((long) section
->sh_offset
== section
->sh_offset
)
6935 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
6939 print_vma (section
->sh_offset
, LONG_HEX
);
6942 print_vma (section
->sh_size
, LONG_HEX
);
6944 print_vma (section
->sh_entsize
, LONG_HEX
);
6946 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6948 printf (" %2u %3u %lu\n",
6951 (unsigned long) section
->sh_addralign
);
6954 if (do_section_details
)
6956 printf (" %s\n", get_elf_section_flags (filedata
, section
->sh_flags
));
6957 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
6959 /* Minimum section size is 12 bytes for 32-bit compression
6960 header + 12 bytes for compressed data header. */
6961 unsigned char buf
[24];
6963 assert (sizeof (buf
) >= sizeof (Elf64_External_Chdr
));
6964 if (get_data (&buf
, filedata
, section
->sh_offset
, 1,
6965 sizeof (buf
), _("compression header")))
6967 Elf_Internal_Chdr chdr
;
6969 if (get_compression_header (&chdr
, buf
, sizeof (buf
)) == 0)
6970 printf (_(" [<corrupt>]\n"));
6973 if (chdr
.ch_type
== ELFCOMPRESS_ZLIB
)
6976 printf (_(" [<unknown>: 0x%x], "),
6978 print_vma (chdr
.ch_size
, LONG_HEX
);
6979 printf (", %lu\n", (unsigned long) chdr
.ch_addralign
);
6986 if (!do_section_details
)
6988 /* The ordering of the letters shown here matches the ordering of the
6989 corresponding SHF_xxx values, and hence the order in which these
6990 letters will be displayed to the user. */
6991 printf (_("Key to Flags:\n\
6992 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6993 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6994 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
6995 if (filedata
->file_header
.e_machine
== EM_X86_64
6996 || filedata
->file_header
.e_machine
== EM_L1OM
6997 || filedata
->file_header
.e_machine
== EM_K1OM
)
6998 printf (_("l (large), "));
6999 else if (filedata
->file_header
.e_machine
== EM_ARM
)
7000 printf (_("y (purecode), "));
7001 else if (filedata
->file_header
.e_machine
== EM_PPC
)
7002 printf (_("v (VLE), "));
7003 printf ("p (processor specific)\n");
7010 get_symtab (Filedata
*filedata
, Elf_Internal_Shdr
*symsec
,
7011 Elf_Internal_Sym
**symtab
, unsigned long *nsyms
,
7012 char **strtab
, unsigned long *strtablen
)
7016 *symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, nsyms
);
7018 if (*symtab
== NULL
)
7021 if (symsec
->sh_link
!= 0)
7023 Elf_Internal_Shdr
*strsec
;
7025 if (symsec
->sh_link
>= filedata
->file_header
.e_shnum
)
7027 error (_("Bad sh_link in symbol table section\n"));
7034 strsec
= filedata
->section_headers
+ symsec
->sh_link
;
7036 *strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
7037 1, strsec
->sh_size
, _("string table"));
7038 if (*strtab
== NULL
)
7045 *strtablen
= strsec
->sh_size
;
7051 get_group_flags (unsigned int flags
)
7053 static char buff
[128];
7057 else if (flags
== GRP_COMDAT
)
7060 snprintf (buff
, sizeof buff
, "[0x%x: %s%s%s]",
7062 flags
& GRP_MASKOS
? _("<OS specific>") : "",
7063 flags
& GRP_MASKPROC
? _("<PROC specific>") : "",
7064 (flags
& ~(GRP_COMDAT
| GRP_MASKOS
| GRP_MASKPROC
)
7065 ? _("<unknown>") : ""));
7071 process_section_groups (Filedata
* filedata
)
7073 Elf_Internal_Shdr
* section
;
7075 struct group
* group
;
7076 Elf_Internal_Shdr
* symtab_sec
;
7077 Elf_Internal_Shdr
* strtab_sec
;
7078 Elf_Internal_Sym
* symtab
;
7079 unsigned long num_syms
;
7083 /* Don't process section groups unless needed. */
7084 if (!do_unwind
&& !do_section_groups
)
7087 if (filedata
->file_header
.e_shnum
== 0)
7089 if (do_section_groups
)
7090 printf (_("\nThere are no sections to group in this file.\n"));
7095 if (filedata
->section_headers
== NULL
)
7097 error (_("Section headers are not available!\n"));
7098 /* PR 13622: This can happen with a corrupt ELF header. */
7102 filedata
->section_headers_groups
7103 = (struct group
**) calloc (filedata
->file_header
.e_shnum
,
7104 sizeof (struct group
*));
7106 if (filedata
->section_headers_groups
== NULL
)
7108 error (_("Out of memory reading %u section group headers\n"),
7109 filedata
->file_header
.e_shnum
);
7113 /* Scan the sections for the group section. */
7114 filedata
->group_count
= 0;
7115 for (i
= 0, section
= filedata
->section_headers
;
7116 i
< filedata
->file_header
.e_shnum
;
7118 if (section
->sh_type
== SHT_GROUP
)
7119 filedata
->group_count
++;
7121 if (filedata
->group_count
== 0)
7123 if (do_section_groups
)
7124 printf (_("\nThere are no section groups in this file.\n"));
7129 filedata
->section_groups
= (struct group
*) calloc (filedata
->group_count
,
7130 sizeof (struct group
));
7132 if (filedata
->section_groups
== NULL
)
7134 error (_("Out of memory reading %lu groups\n"),
7135 (unsigned long) filedata
->group_count
);
7145 for (i
= 0, section
= filedata
->section_headers
, group
= filedata
->section_groups
;
7146 i
< filedata
->file_header
.e_shnum
;
7149 if (section
->sh_type
== SHT_GROUP
)
7151 const char * name
= printable_section_name (filedata
, section
);
7152 const char * group_name
;
7153 unsigned char * start
;
7154 unsigned char * indices
;
7155 unsigned int entry
, j
, size
;
7156 Elf_Internal_Shdr
* sec
;
7157 Elf_Internal_Sym
* sym
;
7159 /* Get the symbol table. */
7160 if (section
->sh_link
>= filedata
->file_header
.e_shnum
7161 || ((sec
= filedata
->section_headers
+ section
->sh_link
)->sh_type
7164 error (_("Bad sh_link in group section `%s'\n"), name
);
7168 if (symtab_sec
!= sec
)
7172 symtab
= GET_ELF_SYMBOLS (filedata
, symtab_sec
, & num_syms
);
7177 error (_("Corrupt header in group section `%s'\n"), name
);
7181 if (section
->sh_info
>= num_syms
)
7183 error (_("Bad sh_info in group section `%s'\n"), name
);
7187 sym
= symtab
+ section
->sh_info
;
7189 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
7191 if (sym
->st_shndx
== 0
7192 || sym
->st_shndx
>= filedata
->file_header
.e_shnum
)
7194 error (_("Bad sh_info in group section `%s'\n"), name
);
7198 group_name
= SECTION_NAME_PRINT (filedata
->section_headers
7207 /* Get the string table. */
7208 if (symtab_sec
->sh_link
>= filedata
->file_header
.e_shnum
)
7216 != (sec
= filedata
->section_headers
+ symtab_sec
->sh_link
))
7221 strtab
= (char *) get_data (NULL
, filedata
, strtab_sec
->sh_offset
,
7222 1, strtab_sec
->sh_size
,
7224 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
7226 group_name
= sym
->st_name
< strtab_size
7227 ? strtab
+ sym
->st_name
: _("<corrupt>");
7230 /* PR 17531: file: loop. */
7231 if (section
->sh_entsize
> section
->sh_size
)
7233 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
7234 printable_section_name (filedata
, section
),
7235 (unsigned long) section
->sh_entsize
,
7236 (unsigned long) section
->sh_size
);
7240 start
= (unsigned char *) get_data (NULL
, filedata
, section
->sh_offset
,
7241 1, section
->sh_size
,
7247 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
7248 entry
= byte_get (indices
, 4);
7251 if (do_section_groups
)
7253 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
7254 get_group_flags (entry
), i
, name
, group_name
, size
);
7256 printf (_(" [Index] Name\n"));
7259 group
->group_index
= i
;
7261 for (j
= 0; j
< size
; j
++)
7263 struct group_list
* g
;
7265 entry
= byte_get (indices
, 4);
7268 if (entry
>= filedata
->file_header
.e_shnum
)
7270 static unsigned num_group_errors
= 0;
7272 if (num_group_errors
++ < 10)
7274 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
7275 entry
, i
, filedata
->file_header
.e_shnum
- 1);
7276 if (num_group_errors
== 10)
7277 warn (_("Further error messages about overlarge group section indices suppressed\n"));
7282 if (filedata
->section_headers_groups
[entry
] != NULL
)
7286 static unsigned num_errs
= 0;
7288 if (num_errs
++ < 10)
7290 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
7292 filedata
->section_headers_groups
[entry
]->group_index
);
7294 warn (_("Further error messages about already contained group sections suppressed\n"));
7300 /* Intel C/C++ compiler may put section 0 in a
7301 section group. We just warn it the first time
7302 and ignore it afterwards. */
7303 static bfd_boolean warned
= FALSE
;
7306 error (_("section 0 in group section [%5u]\n"),
7307 filedata
->section_headers_groups
[entry
]->group_index
);
7313 filedata
->section_headers_groups
[entry
] = group
;
7315 if (do_section_groups
)
7317 sec
= filedata
->section_headers
+ entry
;
7318 printf (" [%5u] %s\n", entry
, printable_section_name (filedata
, sec
));
7321 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
7322 g
->section_index
= entry
;
7323 g
->next
= group
->root
;
7338 /* Data used to display dynamic fixups. */
7340 struct ia64_vms_dynfixup
7342 bfd_vma needed_ident
; /* Library ident number. */
7343 bfd_vma needed
; /* Index in the dstrtab of the library name. */
7344 bfd_vma fixup_needed
; /* Index of the library. */
7345 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
7346 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
7349 /* Data used to display dynamic relocations. */
7351 struct ia64_vms_dynimgrela
7353 bfd_vma img_rela_cnt
; /* Number of relocations. */
7354 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
7357 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
7361 dump_ia64_vms_dynamic_fixups (Filedata
* filedata
,
7362 struct ia64_vms_dynfixup
* fixup
,
7363 const char * strtab
,
7364 unsigned int strtab_sz
)
7366 Elf64_External_VMS_IMAGE_FIXUP
* imfs
;
7368 const char * lib_name
;
7370 imfs
= get_data (NULL
, filedata
,
7371 filedata
->dynamic_addr
+ fixup
->fixup_rela_off
,
7372 sizeof (*imfs
), fixup
->fixup_rela_cnt
,
7373 _("dynamic section image fixups"));
7377 if (fixup
->needed
< strtab_sz
)
7378 lib_name
= strtab
+ fixup
->needed
;
7381 warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
7382 (unsigned long) fixup
->needed
);
7386 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
7387 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
7389 (_("Seg Offset Type SymVec DataType\n"));
7391 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
7396 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
7397 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
7398 type
= BYTE_GET (imfs
[i
].type
);
7399 rtype
= elf_ia64_reloc_type (type
);
7401 printf (" 0x%08x ", type
);
7403 printf (" %-32s ", rtype
);
7404 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
7405 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
7412 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
7415 dump_ia64_vms_dynamic_relocs (Filedata
* filedata
, struct ia64_vms_dynimgrela
*imgrela
)
7417 Elf64_External_VMS_IMAGE_RELA
*imrs
;
7420 imrs
= get_data (NULL
, filedata
,
7421 filedata
->dynamic_addr
+ imgrela
->img_rela_off
,
7422 sizeof (*imrs
), imgrela
->img_rela_cnt
,
7423 _("dynamic section image relocations"));
7427 printf (_("\nImage relocs\n"));
7429 (_("Seg Offset Type Addend Seg Sym Off\n"));
7431 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
7436 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
7437 printf ("%08" BFD_VMA_FMT
"x ",
7438 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
7439 type
= BYTE_GET (imrs
[i
].type
);
7440 rtype
= elf_ia64_reloc_type (type
);
7442 printf ("0x%08x ", type
);
7444 printf ("%-31s ", rtype
);
7445 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
7446 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
7447 printf ("%08" BFD_VMA_FMT
"x\n",
7448 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
7455 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
7458 process_ia64_vms_dynamic_relocs (Filedata
* filedata
)
7460 struct ia64_vms_dynfixup fixup
;
7461 struct ia64_vms_dynimgrela imgrela
;
7462 Elf_Internal_Dyn
*entry
;
7463 bfd_vma strtab_off
= 0;
7464 bfd_vma strtab_sz
= 0;
7465 char *strtab
= NULL
;
7466 bfd_boolean res
= TRUE
;
7468 memset (&fixup
, 0, sizeof (fixup
));
7469 memset (&imgrela
, 0, sizeof (imgrela
));
7471 /* Note: the order of the entries is specified by the OpenVMS specs. */
7472 for (entry
= filedata
->dynamic_section
;
7473 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
7476 switch (entry
->d_tag
)
7478 case DT_IA_64_VMS_STRTAB_OFFSET
:
7479 strtab_off
= entry
->d_un
.d_val
;
7482 strtab_sz
= entry
->d_un
.d_val
;
7484 strtab
= get_data (NULL
, filedata
,
7485 filedata
->dynamic_addr
+ strtab_off
,
7486 1, strtab_sz
, _("dynamic string section"));
7491 case DT_IA_64_VMS_NEEDED_IDENT
:
7492 fixup
.needed_ident
= entry
->d_un
.d_val
;
7495 fixup
.needed
= entry
->d_un
.d_val
;
7497 case DT_IA_64_VMS_FIXUP_NEEDED
:
7498 fixup
.fixup_needed
= entry
->d_un
.d_val
;
7500 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
7501 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
7503 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
7504 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
7505 if (! dump_ia64_vms_dynamic_fixups (filedata
, &fixup
, strtab
, strtab_sz
))
7508 case DT_IA_64_VMS_IMG_RELA_CNT
:
7509 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
7511 case DT_IA_64_VMS_IMG_RELA_OFF
:
7512 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
7513 if (! dump_ia64_vms_dynamic_relocs (filedata
, &imgrela
))
7534 dynamic_relocations
[] =
7536 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
7537 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
7538 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
7541 /* Process the reloc section. */
7544 process_relocs (Filedata
* filedata
)
7546 unsigned long rel_size
;
7547 unsigned long rel_offset
;
7552 if (do_using_dynamic
)
7556 bfd_boolean has_dynamic_reloc
;
7559 has_dynamic_reloc
= FALSE
;
7561 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7563 is_rela
= dynamic_relocations
[i
].rela
;
7564 name
= dynamic_relocations
[i
].name
;
7565 rel_size
= filedata
->dynamic_info
[dynamic_relocations
[i
].size
];
7566 rel_offset
= filedata
->dynamic_info
[dynamic_relocations
[i
].reloc
];
7569 has_dynamic_reloc
= TRUE
;
7571 if (is_rela
== UNKNOWN
)
7573 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
7574 switch (filedata
->dynamic_info
[DT_PLTREL
])
7588 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7589 name
, rel_offset
, rel_size
);
7591 dump_relocations (filedata
,
7592 offset_from_vma (filedata
, rel_offset
, rel_size
),
7594 filedata
->dynamic_symbols
,
7595 filedata
->num_dynamic_syms
,
7596 filedata
->dynamic_strings
,
7597 filedata
->dynamic_strings_length
,
7598 is_rela
, TRUE
/* is_dynamic */);
7602 if (is_ia64_vms (filedata
))
7603 if (process_ia64_vms_dynamic_relocs (filedata
))
7604 has_dynamic_reloc
= TRUE
;
7606 if (! has_dynamic_reloc
)
7607 printf (_("\nThere are no dynamic relocations in this file.\n"));
7611 Elf_Internal_Shdr
* section
;
7613 bfd_boolean found
= FALSE
;
7615 for (i
= 0, section
= filedata
->section_headers
;
7616 i
< filedata
->file_header
.e_shnum
;
7619 if ( section
->sh_type
!= SHT_RELA
7620 && section
->sh_type
!= SHT_REL
)
7623 rel_offset
= section
->sh_offset
;
7624 rel_size
= section
->sh_size
;
7629 unsigned long num_rela
;
7631 printf (_("\nRelocation section "));
7633 if (filedata
->string_table
== NULL
)
7634 printf ("%d", section
->sh_name
);
7636 printf ("'%s'", printable_section_name (filedata
, section
));
7638 num_rela
= rel_size
/ section
->sh_entsize
;
7639 printf (ngettext (" at offset 0x%lx contains %lu entry:\n",
7640 " at offset 0x%lx contains %lu entries:\n",
7642 rel_offset
, num_rela
);
7644 is_rela
= section
->sh_type
== SHT_RELA
;
7646 if (section
->sh_link
!= 0
7647 && section
->sh_link
< filedata
->file_header
.e_shnum
)
7649 Elf_Internal_Shdr
* symsec
;
7650 Elf_Internal_Sym
* symtab
;
7651 unsigned long nsyms
;
7652 unsigned long strtablen
= 0;
7653 char * strtab
= NULL
;
7655 symsec
= filedata
->section_headers
+ section
->sh_link
;
7656 if (symsec
->sh_type
!= SHT_SYMTAB
7657 && symsec
->sh_type
!= SHT_DYNSYM
)
7660 if (!get_symtab (filedata
, symsec
,
7661 &symtab
, &nsyms
, &strtab
, &strtablen
))
7664 dump_relocations (filedata
, rel_offset
, rel_size
,
7665 symtab
, nsyms
, strtab
, strtablen
,
7667 symsec
->sh_type
== SHT_DYNSYM
);
7672 dump_relocations (filedata
, rel_offset
, rel_size
,
7673 NULL
, 0, NULL
, 0, is_rela
,
7674 FALSE
/* is_dynamic */);
7682 /* Users sometimes forget the -D option, so try to be helpful. */
7683 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7685 if (filedata
->dynamic_info
[dynamic_relocations
[i
].size
])
7687 printf (_("\nThere are no static relocations in this file."));
7688 printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
7693 if (i
== ARRAY_SIZE (dynamic_relocations
))
7694 printf (_("\nThere are no relocations in this file.\n"));
7701 /* An absolute address consists of a section and an offset. If the
7702 section is NULL, the offset itself is the address, otherwise, the
7703 address equals to LOAD_ADDRESS(section) + offset. */
7707 unsigned short section
;
7711 /* Find the nearest symbol at or below ADDR. Returns the symbol
7712 name, if found, and the offset from the symbol to ADDR. */
7715 find_symbol_for_address (Filedata
* filedata
,
7716 Elf_Internal_Sym
* symtab
,
7717 unsigned long nsyms
,
7718 const char * strtab
,
7719 unsigned long strtab_size
,
7720 struct absaddr addr
,
7721 const char ** symname
,
7724 bfd_vma dist
= 0x100000;
7725 Elf_Internal_Sym
* sym
;
7726 Elf_Internal_Sym
* beg
;
7727 Elf_Internal_Sym
* end
;
7728 Elf_Internal_Sym
* best
= NULL
;
7730 REMOVE_ARCH_BITS (addr
.offset
);
7732 end
= symtab
+ nsyms
;
7738 sym
= beg
+ (end
- beg
) / 2;
7740 value
= sym
->st_value
;
7741 REMOVE_ARCH_BITS (value
);
7743 if (sym
->st_name
!= 0
7744 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
7745 && addr
.offset
>= value
7746 && addr
.offset
- value
< dist
)
7749 dist
= addr
.offset
- value
;
7754 if (addr
.offset
< value
)
7762 *symname
= (best
->st_name
>= strtab_size
7763 ? _("<corrupt>") : strtab
+ best
->st_name
);
7769 *offset
= addr
.offset
;
7772 static /* signed */ int
7773 symcmp (const void *p
, const void *q
)
7775 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
7776 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
7778 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
7781 /* Process the unwind section. */
7783 #include "unwind-ia64.h"
7785 struct ia64_unw_table_entry
7787 struct absaddr start
;
7789 struct absaddr info
;
7792 struct ia64_unw_aux_info
7794 struct ia64_unw_table_entry
* table
; /* Unwind table. */
7795 unsigned long table_len
; /* Length of unwind table. */
7796 unsigned char * info
; /* Unwind info. */
7797 unsigned long info_size
; /* Size of unwind info. */
7798 bfd_vma info_addr
; /* Starting address of unwind info. */
7799 bfd_vma seg_base
; /* Starting address of segment. */
7800 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7801 unsigned long nsyms
; /* Number of symbols. */
7802 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7803 unsigned long nfuns
; /* Number of entries in funtab. */
7804 char * strtab
; /* The string table. */
7805 unsigned long strtab_size
; /* Size of string table. */
7809 dump_ia64_unwind (Filedata
* filedata
, struct ia64_unw_aux_info
* aux
)
7811 struct ia64_unw_table_entry
* tp
;
7812 unsigned long j
, nfuns
;
7814 bfd_boolean res
= TRUE
;
7816 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7817 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7818 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7819 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7821 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7823 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7827 const unsigned char * dp
;
7828 const unsigned char * head
;
7829 const unsigned char * end
;
7830 const char * procname
;
7832 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7833 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
7835 fputs ("\n<", stdout
);
7839 fputs (procname
, stdout
);
7842 printf ("+%lx", (unsigned long) offset
);
7845 fputs (">: [", stdout
);
7846 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7847 fputc ('-', stdout
);
7848 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7849 printf ("], info at +0x%lx\n",
7850 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
7852 /* PR 17531: file: 86232b32. */
7853 if (aux
->info
== NULL
)
7856 offset
= tp
->info
.offset
;
7857 if (tp
->info
.section
)
7859 if (tp
->info
.section
>= filedata
->file_header
.e_shnum
)
7861 warn (_("Invalid section %u in table entry %ld\n"),
7862 tp
->info
.section
, (long) (tp
- aux
->table
));
7866 offset
+= filedata
->section_headers
[tp
->info
.section
].sh_addr
;
7868 offset
-= aux
->info_addr
;
7869 /* PR 17531: file: 0997b4d1. */
7870 if (offset
>= aux
->info_size
7871 || aux
->info_size
- offset
< 8)
7873 warn (_("Invalid offset %lx in table entry %ld\n"),
7874 (long) tp
->info
.offset
, (long) (tp
- aux
->table
));
7879 head
= aux
->info
+ offset
;
7880 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
7882 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7883 (unsigned) UNW_VER (stamp
),
7884 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
7885 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
7886 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
7887 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
7889 if (UNW_VER (stamp
) != 1)
7891 printf (_("\tUnknown version.\n"));
7896 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
7897 /* PR 17531: file: 16ceda89. */
7898 if (end
> aux
->info
+ aux
->info_size
)
7899 end
= aux
->info
+ aux
->info_size
;
7900 for (dp
= head
+ 8; dp
< end
;)
7901 dp
= unw_decode (dp
, in_body
, & in_body
, end
);
7910 slurp_ia64_unwind_table (Filedata
* filedata
,
7911 struct ia64_unw_aux_info
* aux
,
7912 Elf_Internal_Shdr
* sec
)
7914 unsigned long size
, nrelas
, i
;
7915 Elf_Internal_Phdr
* seg
;
7916 struct ia64_unw_table_entry
* tep
;
7917 Elf_Internal_Shdr
* relsec
;
7918 Elf_Internal_Rela
* rela
;
7919 Elf_Internal_Rela
* rp
;
7920 unsigned char * table
;
7922 Elf_Internal_Sym
* sym
;
7923 const char * relname
;
7927 /* First, find the starting address of the segment that includes
7930 if (filedata
->file_header
.e_phnum
)
7932 if (! get_program_headers (filedata
))
7935 for (seg
= filedata
->program_headers
;
7936 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
7939 if (seg
->p_type
!= PT_LOAD
)
7942 if (sec
->sh_addr
>= seg
->p_vaddr
7943 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7945 aux
->seg_base
= seg
->p_vaddr
;
7951 /* Second, build the unwind table from the contents of the unwind section: */
7952 size
= sec
->sh_size
;
7953 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
7958 aux
->table_len
= size
/ (3 * eh_addr_size
);
7959 aux
->table
= (struct ia64_unw_table_entry
*)
7960 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
7963 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
7965 tep
->start
.section
= SHN_UNDEF
;
7966 tep
->end
.section
= SHN_UNDEF
;
7967 tep
->info
.section
= SHN_UNDEF
;
7968 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7969 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7970 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7971 tep
->start
.offset
+= aux
->seg_base
;
7972 tep
->end
.offset
+= aux
->seg_base
;
7973 tep
->info
.offset
+= aux
->seg_base
;
7977 /* Third, apply any relocations to the unwind table: */
7978 for (relsec
= filedata
->section_headers
;
7979 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
7982 if (relsec
->sh_type
!= SHT_RELA
7983 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
7984 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
7987 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
7996 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7998 unsigned int sym_ndx
;
7999 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
8000 relname
= elf_ia64_reloc_type (r_type
);
8002 /* PR 17531: file: 9fa67536. */
8003 if (relname
== NULL
)
8005 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
8009 if (! const_strneq (relname
, "R_IA64_SEGREL"))
8011 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
8015 i
= rp
->r_offset
/ (3 * eh_addr_size
);
8017 /* PR 17531: file: 5bc8d9bf. */
8018 if (i
>= aux
->table_len
)
8020 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
8024 sym_ndx
= get_reloc_symindex (rp
->r_info
);
8025 if (sym_ndx
>= aux
->nsyms
)
8027 warn (_("Skipping reloc with invalid symbol index: %u\n"),
8031 sym
= aux
->symtab
+ sym_ndx
;
8033 switch (rp
->r_offset
/ eh_addr_size
% 3)
8036 aux
->table
[i
].start
.section
= sym
->st_shndx
;
8037 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
8040 aux
->table
[i
].end
.section
= sym
->st_shndx
;
8041 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
8044 aux
->table
[i
].info
.section
= sym
->st_shndx
;
8045 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
8059 ia64_process_unwind (Filedata
* filedata
)
8061 Elf_Internal_Shdr
* sec
;
8062 Elf_Internal_Shdr
* unwsec
= NULL
;
8063 unsigned long i
, unwcount
= 0, unwstart
= 0;
8064 struct ia64_unw_aux_info aux
;
8065 bfd_boolean res
= TRUE
;
8067 memset (& aux
, 0, sizeof (aux
));
8069 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8071 if (sec
->sh_type
== SHT_SYMTAB
)
8075 error (_("Multiple symbol tables encountered\n"));
8081 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
8082 &aux
.strtab
, &aux
.strtab_size
))
8085 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
8090 printf (_("\nThere are no unwind sections in this file.\n"));
8092 while (unwcount
-- > 0)
8097 for (i
= unwstart
, sec
= filedata
->section_headers
+ unwstart
, unwsec
= NULL
;
8098 i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8099 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
8104 /* We have already counted the number of SHT_IA64_UNWIND
8105 sections so the loop above should never fail. */
8106 assert (unwsec
!= NULL
);
8109 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
8111 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
8113 /* We need to find which section group it is in. */
8114 struct group_list
* g
;
8116 if (filedata
->section_headers_groups
== NULL
8117 || filedata
->section_headers_groups
[i
] == NULL
)
8118 i
= filedata
->file_header
.e_shnum
;
8121 g
= filedata
->section_headers_groups
[i
]->root
;
8123 for (; g
!= NULL
; g
= g
->next
)
8125 sec
= filedata
->section_headers
+ g
->section_index
;
8127 if (SECTION_NAME_VALID (sec
)
8128 && streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
8133 i
= filedata
->file_header
.e_shnum
;
8136 else if (SECTION_NAME_VALID (unwsec
)
8137 && strneq (SECTION_NAME (unwsec
),
8138 ELF_STRING_ia64_unwind_once
, len
))
8140 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
8141 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
8142 suffix
= SECTION_NAME (unwsec
) + len
;
8143 for (i
= 0, sec
= filedata
->section_headers
;
8144 i
< filedata
->file_header
.e_shnum
;
8146 if (SECTION_NAME_VALID (sec
)
8147 && strneq (SECTION_NAME (sec
),
8148 ELF_STRING_ia64_unwind_info_once
, len2
)
8149 && streq (SECTION_NAME (sec
) + len2
, suffix
))
8154 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
8155 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
8156 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
8157 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
8159 if (SECTION_NAME_VALID (unwsec
)
8160 && strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
8161 suffix
= SECTION_NAME (unwsec
) + len
;
8162 for (i
= 0, sec
= filedata
->section_headers
;
8163 i
< filedata
->file_header
.e_shnum
;
8165 if (SECTION_NAME_VALID (sec
)
8166 && strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
8167 && streq (SECTION_NAME (sec
) + len2
, suffix
))
8171 if (i
== filedata
->file_header
.e_shnum
)
8173 printf (_("\nCould not find unwind info section for "));
8175 if (filedata
->string_table
== NULL
)
8176 printf ("%d", unwsec
->sh_name
);
8178 printf ("'%s'", printable_section_name (filedata
, unwsec
));
8182 aux
.info_addr
= sec
->sh_addr
;
8183 aux
.info
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1,
8186 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
8188 printf (_("\nUnwind section "));
8190 if (filedata
->string_table
== NULL
)
8191 printf ("%d", unwsec
->sh_name
);
8193 printf ("'%s'", printable_section_name (filedata
, unwsec
));
8195 printf (_(" at offset 0x%lx contains %lu entries:\n"),
8196 (unsigned long) unwsec
->sh_offset
,
8197 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
8199 if (slurp_ia64_unwind_table (filedata
, & aux
, unwsec
)
8200 && aux
.table_len
> 0)
8201 dump_ia64_unwind (filedata
, & aux
);
8203 free ((char *) aux
.table
);
8204 free ((char *) aux
.info
);
8211 free ((char *) aux
.strtab
);
8216 struct hppa_unw_table_entry
8218 struct absaddr start
;
8220 unsigned int Cannot_unwind
:1; /* 0 */
8221 unsigned int Millicode
:1; /* 1 */
8222 unsigned int Millicode_save_sr0
:1; /* 2 */
8223 unsigned int Region_description
:2; /* 3..4 */
8224 unsigned int reserved1
:1; /* 5 */
8225 unsigned int Entry_SR
:1; /* 6 */
8226 unsigned int Entry_FR
:4; /* Number saved 7..10 */
8227 unsigned int Entry_GR
:5; /* Number saved 11..15 */
8228 unsigned int Args_stored
:1; /* 16 */
8229 unsigned int Variable_Frame
:1; /* 17 */
8230 unsigned int Separate_Package_Body
:1; /* 18 */
8231 unsigned int Frame_Extension_Millicode
:1; /* 19 */
8232 unsigned int Stack_Overflow_Check
:1; /* 20 */
8233 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
8234 unsigned int Ada_Region
:1; /* 22 */
8235 unsigned int cxx_info
:1; /* 23 */
8236 unsigned int cxx_try_catch
:1; /* 24 */
8237 unsigned int sched_entry_seq
:1; /* 25 */
8238 unsigned int reserved2
:1; /* 26 */
8239 unsigned int Save_SP
:1; /* 27 */
8240 unsigned int Save_RP
:1; /* 28 */
8241 unsigned int Save_MRP_in_frame
:1; /* 29 */
8242 unsigned int extn_ptr_defined
:1; /* 30 */
8243 unsigned int Cleanup_defined
:1; /* 31 */
8245 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
8246 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
8247 unsigned int Large_frame
:1; /* 2 */
8248 unsigned int Pseudo_SP_Set
:1; /* 3 */
8249 unsigned int reserved4
:1; /* 4 */
8250 unsigned int Total_frame_size
:27; /* 5..31 */
8253 struct hppa_unw_aux_info
8255 struct hppa_unw_table_entry
* table
; /* Unwind table. */
8256 unsigned long table_len
; /* Length of unwind table. */
8257 bfd_vma seg_base
; /* Starting address of segment. */
8258 Elf_Internal_Sym
* symtab
; /* The symbol table. */
8259 unsigned long nsyms
; /* Number of symbols. */
8260 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8261 unsigned long nfuns
; /* Number of entries in funtab. */
8262 char * strtab
; /* The string table. */
8263 unsigned long strtab_size
; /* Size of string table. */
8267 dump_hppa_unwind (Filedata
* filedata
, struct hppa_unw_aux_info
* aux
)
8269 struct hppa_unw_table_entry
* tp
;
8270 unsigned long j
, nfuns
;
8271 bfd_boolean res
= TRUE
;
8273 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
8274 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
8275 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
8276 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
8278 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
8280 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
8283 const char * procname
;
8285 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8286 aux
->strtab_size
, tp
->start
, &procname
,
8289 fputs ("\n<", stdout
);
8293 fputs (procname
, stdout
);
8296 printf ("+%lx", (unsigned long) offset
);
8299 fputs (">: [", stdout
);
8300 print_vma (tp
->start
.offset
, PREFIX_HEX
);
8301 fputc ('-', stdout
);
8302 print_vma (tp
->end
.offset
, PREFIX_HEX
);
8305 #define PF(_m) if (tp->_m) printf (#_m " ");
8306 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
8309 PF(Millicode_save_sr0
);
8310 /* PV(Region_description); */
8316 PF(Separate_Package_Body
);
8317 PF(Frame_Extension_Millicode
);
8318 PF(Stack_Overflow_Check
);
8319 PF(Two_Instruction_SP_Increment
);
8323 PF(sched_entry_seq
);
8326 PF(Save_MRP_in_frame
);
8327 PF(extn_ptr_defined
);
8328 PF(Cleanup_defined
);
8329 PF(MPE_XL_interrupt_marker
);
8330 PF(HP_UX_interrupt_marker
);
8333 PV(Total_frame_size
);
8346 slurp_hppa_unwind_table (Filedata
* filedata
,
8347 struct hppa_unw_aux_info
* aux
,
8348 Elf_Internal_Shdr
* sec
)
8350 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
8351 Elf_Internal_Phdr
* seg
;
8352 struct hppa_unw_table_entry
* tep
;
8353 Elf_Internal_Shdr
* relsec
;
8354 Elf_Internal_Rela
* rela
;
8355 Elf_Internal_Rela
* rp
;
8356 unsigned char * table
;
8358 Elf_Internal_Sym
* sym
;
8359 const char * relname
;
8361 /* First, find the starting address of the segment that includes
8363 if (filedata
->file_header
.e_phnum
)
8365 if (! get_program_headers (filedata
))
8368 for (seg
= filedata
->program_headers
;
8369 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
8372 if (seg
->p_type
!= PT_LOAD
)
8375 if (sec
->sh_addr
>= seg
->p_vaddr
8376 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
8378 aux
->seg_base
= seg
->p_vaddr
;
8384 /* Second, build the unwind table from the contents of the unwind
8386 size
= sec
->sh_size
;
8387 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
8393 nentries
= size
/ unw_ent_size
;
8394 size
= unw_ent_size
* nentries
;
8396 aux
->table_len
= nentries
;
8397 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
8398 xcmalloc (nentries
, sizeof (aux
->table
[0]));
8400 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
8402 unsigned int tmp1
, tmp2
;
8404 tep
->start
.section
= SHN_UNDEF
;
8405 tep
->end
.section
= SHN_UNDEF
;
8407 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
8408 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
8409 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
8410 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
8412 tep
->start
.offset
+= aux
->seg_base
;
8413 tep
->end
.offset
+= aux
->seg_base
;
8415 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
8416 tep
->Millicode
= (tmp1
>> 30) & 0x1;
8417 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
8418 tep
->Region_description
= (tmp1
>> 27) & 0x3;
8419 tep
->reserved1
= (tmp1
>> 26) & 0x1;
8420 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
8421 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
8422 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
8423 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
8424 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
8425 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
8426 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
8427 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
8428 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
8429 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
8430 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
8431 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
8432 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
8433 tep
->reserved2
= (tmp1
>> 5) & 0x1;
8434 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
8435 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
8436 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
8437 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
8438 tep
->Cleanup_defined
= tmp1
& 0x1;
8440 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
8441 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
8442 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
8443 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
8444 tep
->reserved4
= (tmp2
>> 27) & 0x1;
8445 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
8449 /* Third, apply any relocations to the unwind table. */
8450 for (relsec
= filedata
->section_headers
;
8451 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8454 if (relsec
->sh_type
!= SHT_RELA
8455 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
8456 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
8459 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
8463 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
8465 unsigned int sym_ndx
;
8466 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
8467 relname
= elf_hppa_reloc_type (r_type
);
8469 if (relname
== NULL
)
8471 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
8475 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
8476 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
8478 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
8482 i
= rp
->r_offset
/ unw_ent_size
;
8483 if (i
>= aux
->table_len
)
8485 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
8489 sym_ndx
= get_reloc_symindex (rp
->r_info
);
8490 if (sym_ndx
>= aux
->nsyms
)
8492 warn (_("Skipping reloc with invalid symbol index: %u\n"),
8496 sym
= aux
->symtab
+ sym_ndx
;
8498 switch ((rp
->r_offset
% unw_ent_size
) / 4)
8501 aux
->table
[i
].start
.section
= sym
->st_shndx
;
8502 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
8505 aux
->table
[i
].end
.section
= sym
->st_shndx
;
8506 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
8520 hppa_process_unwind (Filedata
* filedata
)
8522 struct hppa_unw_aux_info aux
;
8523 Elf_Internal_Shdr
* unwsec
= NULL
;
8524 Elf_Internal_Shdr
* sec
;
8526 bfd_boolean res
= TRUE
;
8528 if (filedata
->string_table
== NULL
)
8531 memset (& aux
, 0, sizeof (aux
));
8533 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8535 if (sec
->sh_type
== SHT_SYMTAB
)
8539 error (_("Multiple symbol tables encountered\n"));
8545 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
8546 &aux
.strtab
, &aux
.strtab_size
))
8549 else if (SECTION_NAME_VALID (sec
)
8550 && streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8555 printf (_("\nThere are no unwind sections in this file.\n"));
8557 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8559 if (SECTION_NAME_VALID (sec
)
8560 && streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8562 unsigned long num_unwind
= sec
->sh_size
/ 16;
8564 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
8565 "contains %lu entry:\n",
8566 "\nUnwind section '%s' at offset 0x%lx "
8567 "contains %lu entries:\n",
8569 printable_section_name (filedata
, sec
),
8570 (unsigned long) sec
->sh_offset
,
8573 if (! slurp_hppa_unwind_table (filedata
, &aux
, sec
))
8576 if (res
&& aux
.table_len
> 0)
8578 if (! dump_hppa_unwind (filedata
, &aux
))
8582 free ((char *) aux
.table
);
8588 free ((char *) aux
.strtab
);
8595 unsigned char * data
; /* The unwind data. */
8596 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
8597 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
8598 unsigned long nrelas
; /* The number of relocations. */
8599 unsigned int rel_type
; /* REL or RELA ? */
8600 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
8603 struct arm_unw_aux_info
8605 Filedata
* filedata
; /* The file containing the unwind sections. */
8606 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
8607 unsigned long nsyms
; /* Number of symbols. */
8608 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8609 unsigned long nfuns
; /* Number of these symbols. */
8610 char * strtab
; /* The file's string table. */
8611 unsigned long strtab_size
; /* Size of string table. */
8615 arm_print_vma_and_name (Filedata
* filedata
,
8616 struct arm_unw_aux_info
* aux
,
8618 struct absaddr addr
)
8620 const char *procname
;
8623 if (addr
.section
== SHN_UNDEF
)
8626 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8627 aux
->strtab_size
, addr
, &procname
,
8630 print_vma (fn
, PREFIX_HEX
);
8634 fputs (" <", stdout
);
8635 fputs (procname
, stdout
);
8638 printf ("+0x%lx", (unsigned long) sym_offset
);
8639 fputc ('>', stdout
);
8646 arm_free_section (struct arm_section
*arm_sec
)
8648 free (arm_sec
->data
);
8649 free (arm_sec
->rela
);
8652 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8653 cached section and install SEC instead.
8654 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8655 and return its valued in * WORDP, relocating if necessary.
8656 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8657 relocation's offset in ADDR.
8658 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8659 into the string table of the symbol associated with the reloc. If no
8660 reloc was applied store -1 there.
8661 5) Return TRUE upon success, FALSE otherwise. */
8664 get_unwind_section_word (Filedata
* filedata
,
8665 struct arm_unw_aux_info
* aux
,
8666 struct arm_section
* arm_sec
,
8667 Elf_Internal_Shdr
* sec
,
8668 bfd_vma word_offset
,
8669 unsigned int * wordp
,
8670 struct absaddr
* addr
,
8673 Elf_Internal_Rela
*rp
;
8674 Elf_Internal_Sym
*sym
;
8675 const char * relname
;
8677 bfd_boolean wrapped
;
8679 if (sec
== NULL
|| arm_sec
== NULL
)
8682 addr
->section
= SHN_UNDEF
;
8685 if (sym_name
!= NULL
)
8686 *sym_name
= (bfd_vma
) -1;
8688 /* If necessary, update the section cache. */
8689 if (sec
!= arm_sec
->sec
)
8691 Elf_Internal_Shdr
*relsec
;
8693 arm_free_section (arm_sec
);
8696 arm_sec
->data
= get_data (NULL
, aux
->filedata
, sec
->sh_offset
, 1,
8697 sec
->sh_size
, _("unwind data"));
8698 arm_sec
->rela
= NULL
;
8699 arm_sec
->nrelas
= 0;
8701 for (relsec
= filedata
->section_headers
;
8702 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8705 if (relsec
->sh_info
>= filedata
->file_header
.e_shnum
8706 || filedata
->section_headers
+ relsec
->sh_info
!= sec
8707 /* PR 15745: Check the section type as well. */
8708 || (relsec
->sh_type
!= SHT_REL
8709 && relsec
->sh_type
!= SHT_RELA
))
8712 arm_sec
->rel_type
= relsec
->sh_type
;
8713 if (relsec
->sh_type
== SHT_REL
)
8715 if (!slurp_rel_relocs (aux
->filedata
, relsec
->sh_offset
,
8717 & arm_sec
->rela
, & arm_sec
->nrelas
))
8720 else /* relsec->sh_type == SHT_RELA */
8722 if (!slurp_rela_relocs (aux
->filedata
, relsec
->sh_offset
,
8724 & arm_sec
->rela
, & arm_sec
->nrelas
))
8730 arm_sec
->next_rela
= arm_sec
->rela
;
8733 /* If there is no unwind data we can do nothing. */
8734 if (arm_sec
->data
== NULL
)
8737 /* If the offset is invalid then fail. */
8738 if (/* PR 21343 *//* PR 18879 */
8740 || word_offset
> (sec
->sh_size
- 4)
8741 || ((bfd_signed_vma
) word_offset
) < 0)
8744 /* Get the word at the required offset. */
8745 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
8747 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
8748 if (arm_sec
->rela
== NULL
)
8754 /* Look through the relocs to find the one that applies to the provided offset. */
8756 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
8758 bfd_vma prelval
, offset
;
8760 if (rp
->r_offset
> word_offset
&& !wrapped
)
8765 if (rp
->r_offset
> word_offset
)
8768 if (rp
->r_offset
& 3)
8770 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8771 (unsigned long) rp
->r_offset
);
8775 if (rp
->r_offset
< word_offset
)
8778 /* PR 17531: file: 027-161405-0.004 */
8779 if (aux
->symtab
== NULL
)
8782 if (arm_sec
->rel_type
== SHT_REL
)
8784 offset
= word
& 0x7fffffff;
8785 if (offset
& 0x40000000)
8786 offset
|= ~ (bfd_vma
) 0x7fffffff;
8788 else if (arm_sec
->rel_type
== SHT_RELA
)
8789 offset
= rp
->r_addend
;
8792 error (_("Unknown section relocation type %d encountered\n"),
8797 /* PR 17531 file: 027-1241568-0.004. */
8798 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
8800 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8801 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
8805 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
8806 offset
+= sym
->st_value
;
8807 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
8809 /* Check that we are processing the expected reloc type. */
8810 if (filedata
->file_header
.e_machine
== EM_ARM
)
8812 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8813 if (relname
== NULL
)
8815 warn (_("Skipping unknown ARM relocation type: %d\n"),
8816 (int) ELF32_R_TYPE (rp
->r_info
));
8820 if (streq (relname
, "R_ARM_NONE"))
8823 if (! streq (relname
, "R_ARM_PREL31"))
8825 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
8829 else if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
8831 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8832 if (relname
== NULL
)
8834 warn (_("Skipping unknown C6000 relocation type: %d\n"),
8835 (int) ELF32_R_TYPE (rp
->r_info
));
8839 if (streq (relname
, "R_C6000_NONE"))
8842 if (! streq (relname
, "R_C6000_PREL31"))
8844 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
8852 /* This function currently only supports ARM and TI unwinders. */
8853 warn (_("Only TI and ARM unwinders are currently supported\n"));
8857 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
8858 addr
->section
= sym
->st_shndx
;
8859 addr
->offset
= offset
;
8862 * sym_name
= sym
->st_name
;
8867 arm_sec
->next_rela
= rp
;
8872 static const char *tic6x_unwind_regnames
[16] =
8874 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8875 "A14", "A13", "A12", "A11", "A10",
8876 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8880 decode_tic6x_unwind_regmask (unsigned int mask
)
8884 for (i
= 12; mask
; mask
>>= 1, i
--)
8888 fputs (tic6x_unwind_regnames
[i
], stdout
);
8890 fputs (", ", stdout
);
8896 if (remaining == 0 && more_words) \
8899 if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, \
8900 data_offset, & word, & addr, NULL)) \
8906 #define GET_OP(OP) \
8911 (OP) = word >> 24; \
8916 printf (_("[Truncated opcode]\n")); \
8919 printf ("0x%02x ", OP)
8922 decode_arm_unwind_bytecode (Filedata
* filedata
,
8923 struct arm_unw_aux_info
* aux
,
8925 unsigned int remaining
,
8926 unsigned int more_words
,
8927 bfd_vma data_offset
,
8928 Elf_Internal_Shdr
* data_sec
,
8929 struct arm_section
* data_arm_sec
)
8931 struct absaddr addr
;
8932 bfd_boolean res
= TRUE
;
8934 /* Decode the unwinding instructions. */
8937 unsigned int op
, op2
;
8946 printf (" 0x%02x ", op
);
8948 if ((op
& 0xc0) == 0x00)
8950 int offset
= ((op
& 0x3f) << 2) + 4;
8952 printf (" vsp = vsp + %d", offset
);
8954 else if ((op
& 0xc0) == 0x40)
8956 int offset
= ((op
& 0x3f) << 2) + 4;
8958 printf (" vsp = vsp - %d", offset
);
8960 else if ((op
& 0xf0) == 0x80)
8963 if (op
== 0x80 && op2
== 0)
8964 printf (_("Refuse to unwind"));
8967 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
8968 bfd_boolean first
= TRUE
;
8972 for (i
= 0; i
< 12; i
++)
8973 if (mask
& (1 << i
))
8979 printf ("r%d", 4 + i
);
8984 else if ((op
& 0xf0) == 0x90)
8986 if (op
== 0x9d || op
== 0x9f)
8987 printf (_(" [Reserved]"));
8989 printf (" vsp = r%d", op
& 0x0f);
8991 else if ((op
& 0xf0) == 0xa0)
8993 int end
= 4 + (op
& 0x07);
8994 bfd_boolean first
= TRUE
;
8998 for (i
= 4; i
<= end
; i
++)
9014 else if (op
== 0xb0)
9015 printf (_(" finish"));
9016 else if (op
== 0xb1)
9019 if (op2
== 0 || (op2
& 0xf0) != 0)
9020 printf (_("[Spare]"));
9023 unsigned int mask
= op2
& 0x0f;
9024 bfd_boolean first
= TRUE
;
9028 for (i
= 0; i
< 12; i
++)
9029 if (mask
& (1 << i
))
9040 else if (op
== 0xb2)
9042 unsigned char buf
[9];
9043 unsigned int i
, len
;
9044 unsigned long offset
;
9046 for (i
= 0; i
< sizeof (buf
); i
++)
9049 if ((buf
[i
] & 0x80) == 0)
9052 if (i
== sizeof (buf
))
9054 error (_("corrupt change to vsp\n"));
9059 offset
= read_leb128 (buf
, buf
+ i
+ 1, FALSE
, &len
, NULL
);
9060 assert (len
== i
+ 1);
9061 offset
= offset
* 4 + 0x204;
9062 printf ("vsp = vsp + %ld", offset
);
9065 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
9067 unsigned int first
, last
;
9074 printf ("pop {D%d", first
);
9076 printf ("-D%d", first
+ last
);
9079 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
9081 unsigned int count
= op
& 0x07;
9085 printf ("-D%d", 8 + count
);
9088 else if (op
>= 0xc0 && op
<= 0xc5)
9090 unsigned int count
= op
& 0x07;
9092 printf (" pop {wR10");
9094 printf ("-wR%d", 10 + count
);
9097 else if (op
== 0xc6)
9099 unsigned int first
, last
;
9104 printf ("pop {wR%d", first
);
9106 printf ("-wR%d", first
+ last
);
9109 else if (op
== 0xc7)
9112 if (op2
== 0 || (op2
& 0xf0) != 0)
9113 printf (_("[Spare]"));
9116 unsigned int mask
= op2
& 0x0f;
9117 bfd_boolean first
= TRUE
;
9121 for (i
= 0; i
< 4; i
++)
9122 if (mask
& (1 << i
))
9128 printf ("wCGR%d", i
);
9135 printf (_(" [unsupported opcode]"));
9146 decode_tic6x_unwind_bytecode (Filedata
* filedata
,
9147 struct arm_unw_aux_info
* aux
,
9149 unsigned int remaining
,
9150 unsigned int more_words
,
9151 bfd_vma data_offset
,
9152 Elf_Internal_Shdr
* data_sec
,
9153 struct arm_section
* data_arm_sec
)
9155 struct absaddr addr
;
9157 /* Decode the unwinding instructions. */
9160 unsigned int op
, op2
;
9169 printf (" 0x%02x ", op
);
9171 if ((op
& 0xc0) == 0x00)
9173 int offset
= ((op
& 0x3f) << 3) + 8;
9174 printf (" sp = sp + %d", offset
);
9176 else if ((op
& 0xc0) == 0x80)
9179 if (op
== 0x80 && op2
== 0)
9180 printf (_("Refuse to unwind"));
9183 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
9185 printf ("pop compact {");
9189 decode_tic6x_unwind_regmask (mask
);
9193 else if ((op
& 0xf0) == 0xc0)
9201 unsigned int offset
;
9205 /* Scan entire instruction first so that GET_OP output is not
9206 interleaved with disassembly. */
9208 for (i
= 0; nregs
< (op
& 0xf); i
++)
9214 regpos
[nregs
].offset
= i
* 2;
9215 regpos
[nregs
].reg
= reg
;
9222 regpos
[nregs
].offset
= i
* 2 + 1;
9223 regpos
[nregs
].reg
= reg
;
9228 printf (_("pop frame {"));
9231 printf (_("*corrupt* - no registers specified"));
9236 for (i
= i
* 2; i
> 0; i
--)
9238 if (regpos
[reg
].offset
== i
- 1)
9240 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
9247 fputs (name
, stdout
);
9255 else if (op
== 0xd0)
9256 printf (" MOV FP, SP");
9257 else if (op
== 0xd1)
9258 printf (" __c6xabi_pop_rts");
9259 else if (op
== 0xd2)
9261 unsigned char buf
[9];
9262 unsigned int i
, len
;
9263 unsigned long offset
;
9265 for (i
= 0; i
< sizeof (buf
); i
++)
9268 if ((buf
[i
] & 0x80) == 0)
9271 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
9272 if (i
== sizeof (buf
))
9274 warn (_("Corrupt stack pointer adjustment detected\n"));
9278 offset
= read_leb128 (buf
, buf
+ i
+ 1, FALSE
, &len
, NULL
);
9279 assert (len
== i
+ 1);
9280 offset
= offset
* 8 + 0x408;
9281 printf (_("sp = sp + %ld"), offset
);
9283 else if ((op
& 0xf0) == 0xe0)
9285 if ((op
& 0x0f) == 7)
9288 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
9292 printf (_(" [unsupported opcode]"));
9301 arm_expand_prel31 (Filedata
* filedata
, bfd_vma word
, bfd_vma where
)
9305 offset
= word
& 0x7fffffff;
9306 if (offset
& 0x40000000)
9307 offset
|= ~ (bfd_vma
) 0x7fffffff;
9309 if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
9312 return offset
+ where
;
9316 decode_arm_unwind (Filedata
* filedata
,
9317 struct arm_unw_aux_info
* aux
,
9319 unsigned int remaining
,
9320 bfd_vma data_offset
,
9321 Elf_Internal_Shdr
* data_sec
,
9322 struct arm_section
* data_arm_sec
)
9325 unsigned int more_words
= 0;
9326 struct absaddr addr
;
9327 bfd_vma sym_name
= (bfd_vma
) -1;
9328 bfd_boolean res
= TRUE
;
9332 /* Fetch the first word.
9333 Note - when decoding an object file the address extracted
9334 here will always be 0. So we also pass in the sym_name
9335 parameter so that we can find the symbol associated with
9336 the personality routine. */
9337 if (! get_unwind_section_word (filedata
, aux
, data_arm_sec
, data_sec
, data_offset
,
9338 & word
, & addr
, & sym_name
))
9345 addr
.section
= SHN_UNDEF
;
9349 if ((word
& 0x80000000) == 0)
9351 /* Expand prel31 for personality routine. */
9353 const char *procname
;
9355 fn
= arm_expand_prel31 (filedata
, word
, data_sec
->sh_addr
+ data_offset
);
9356 printf (_(" Personality routine: "));
9358 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
9359 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
9361 procname
= aux
->strtab
+ sym_name
;
9362 print_vma (fn
, PREFIX_HEX
);
9365 fputs (" <", stdout
);
9366 fputs (procname
, stdout
);
9367 fputc ('>', stdout
);
9371 procname
= arm_print_vma_and_name (filedata
, aux
, fn
, addr
);
9372 fputc ('\n', stdout
);
9374 /* The GCC personality routines use the standard compact
9375 encoding, starting with one byte giving the number of
9377 if (procname
!= NULL
9378 && (const_strneq (procname
, "__gcc_personality_v0")
9379 || const_strneq (procname
, "__gxx_personality_v0")
9380 || const_strneq (procname
, "__gcj_personality_v0")
9381 || const_strneq (procname
, "__gnu_objc_personality_v0")))
9388 printf (_(" [Truncated data]\n"));
9391 more_words
= word
>> 24;
9401 /* ARM EHABI Section 6.3:
9403 An exception-handling table entry for the compact model looks like:
9407 1 0 index Data for personalityRoutine[index] */
9409 if (filedata
->file_header
.e_machine
== EM_ARM
9410 && (word
& 0x70000000))
9412 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
9416 per_index
= (word
>> 24) & 0x7f;
9417 printf (_(" Compact model index: %d\n"), per_index
);
9424 else if (per_index
< 3)
9426 more_words
= (word
>> 16) & 0xff;
9432 switch (filedata
->file_header
.e_machine
)
9437 if (! decode_arm_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
9438 data_offset
, data_sec
, data_arm_sec
))
9443 warn (_("Unknown ARM compact model index encountered\n"));
9444 printf (_(" [reserved]\n"));
9452 if (! decode_tic6x_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
9453 data_offset
, data_sec
, data_arm_sec
))
9456 else if (per_index
< 5)
9458 if (((word
>> 17) & 0x7f) == 0x7f)
9459 printf (_(" Restore stack from frame pointer\n"));
9461 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
9462 printf (_(" Registers restored: "));
9464 printf (" (compact) ");
9465 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
9467 printf (_(" Return register: %s\n"),
9468 tic6x_unwind_regnames
[word
& 0xf]);
9471 printf (_(" [reserved (%d)]\n"), per_index
);
9475 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
9476 filedata
->file_header
.e_machine
);
9480 /* Decode the descriptors. Not implemented. */
9486 dump_arm_unwind (Filedata
* filedata
,
9487 struct arm_unw_aux_info
* aux
,
9488 Elf_Internal_Shdr
* exidx_sec
)
9490 struct arm_section exidx_arm_sec
, extab_arm_sec
;
9491 unsigned int i
, exidx_len
;
9492 unsigned long j
, nfuns
;
9493 bfd_boolean res
= TRUE
;
9495 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
9496 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
9497 exidx_len
= exidx_sec
->sh_size
/ 8;
9499 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
9500 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
9501 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
9502 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
9504 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
9506 for (i
= 0; i
< exidx_len
; i
++)
9508 unsigned int exidx_fn
, exidx_entry
;
9509 struct absaddr fn_addr
, entry_addr
;
9512 fputc ('\n', stdout
);
9514 if (! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9515 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
9516 || ! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9517 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
9520 arm_free_section (& exidx_arm_sec
);
9521 arm_free_section (& extab_arm_sec
);
9525 /* ARM EHABI, Section 5:
9526 An index table entry consists of 2 words.
9527 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
9528 if (exidx_fn
& 0x80000000)
9530 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
9534 fn
= arm_expand_prel31 (filedata
, exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
9536 arm_print_vma_and_name (filedata
, aux
, fn
, fn_addr
);
9537 fputs (": ", stdout
);
9539 if (exidx_entry
== 1)
9541 print_vma (exidx_entry
, PREFIX_HEX
);
9542 fputs (" [cantunwind]\n", stdout
);
9544 else if (exidx_entry
& 0x80000000)
9546 print_vma (exidx_entry
, PREFIX_HEX
);
9547 fputc ('\n', stdout
);
9548 decode_arm_unwind (filedata
, aux
, exidx_entry
, 4, 0, NULL
, NULL
);
9552 bfd_vma table
, table_offset
= 0;
9553 Elf_Internal_Shdr
*table_sec
;
9555 fputs ("@", stdout
);
9556 table
= arm_expand_prel31 (filedata
, exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
9557 print_vma (table
, PREFIX_HEX
);
9560 /* Locate the matching .ARM.extab. */
9561 if (entry_addr
.section
!= SHN_UNDEF
9562 && entry_addr
.section
< filedata
->file_header
.e_shnum
)
9564 table_sec
= filedata
->section_headers
+ entry_addr
.section
;
9565 table_offset
= entry_addr
.offset
;
9567 if (table_offset
> table_sec
->sh_size
9568 || ((bfd_signed_vma
) table_offset
) < 0)
9570 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
9571 (unsigned long) table_offset
,
9572 printable_section_name (filedata
, table_sec
));
9579 table_sec
= find_section_by_address (filedata
, table
);
9580 if (table_sec
!= NULL
)
9581 table_offset
= table
- table_sec
->sh_addr
;
9584 if (table_sec
== NULL
)
9586 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
9587 (unsigned long) table
);
9592 if (! decode_arm_unwind (filedata
, aux
, 0, 0, table_offset
, table_sec
,
9601 arm_free_section (&exidx_arm_sec
);
9602 arm_free_section (&extab_arm_sec
);
9607 /* Used for both ARM and C6X unwinding tables. */
9610 arm_process_unwind (Filedata
* filedata
)
9612 struct arm_unw_aux_info aux
;
9613 Elf_Internal_Shdr
*unwsec
= NULL
;
9614 Elf_Internal_Shdr
*sec
;
9616 unsigned int sec_type
;
9617 bfd_boolean res
= TRUE
;
9619 switch (filedata
->file_header
.e_machine
)
9622 sec_type
= SHT_ARM_EXIDX
;
9626 sec_type
= SHT_C6000_UNWIND
;
9630 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9631 filedata
->file_header
.e_machine
);
9635 if (filedata
->string_table
== NULL
)
9638 memset (& aux
, 0, sizeof (aux
));
9639 aux
.filedata
= filedata
;
9641 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9643 if (sec
->sh_type
== SHT_SYMTAB
)
9647 error (_("Multiple symbol tables encountered\n"));
9653 if (!get_symtab (filedata
, sec
, &aux
.symtab
, &aux
.nsyms
,
9654 &aux
.strtab
, &aux
.strtab_size
))
9657 else if (sec
->sh_type
== sec_type
)
9662 printf (_("\nThere are no unwind sections in this file.\n"));
9664 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9666 if (sec
->sh_type
== sec_type
)
9668 unsigned long num_unwind
= sec
->sh_size
/ (2 * eh_addr_size
);
9669 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
9670 "contains %lu entry:\n",
9671 "\nUnwind section '%s' at offset 0x%lx "
9672 "contains %lu entries:\n",
9674 printable_section_name (filedata
, sec
),
9675 (unsigned long) sec
->sh_offset
,
9678 if (! dump_arm_unwind (filedata
, &aux
, sec
))
9684 free ((char *) aux
.strtab
);
9690 process_unwind (Filedata
* filedata
)
9692 struct unwind_handler
9694 unsigned int machtype
;
9695 bfd_boolean (* handler
)(Filedata
*);
9698 { EM_ARM
, arm_process_unwind
},
9699 { EM_IA_64
, ia64_process_unwind
},
9700 { EM_PARISC
, hppa_process_unwind
},
9701 { EM_TI_C6000
, arm_process_unwind
},
9709 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
9710 if (filedata
->file_header
.e_machine
== handlers
[i
].machtype
)
9711 return handlers
[i
].handler (filedata
);
9713 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9714 get_machine_name (filedata
->file_header
.e_machine
));
9719 dynamic_section_aarch64_val (Elf_Internal_Dyn
* entry
)
9721 switch (entry
->d_tag
)
9723 case DT_AARCH64_BTI_PLT
:
9724 case DT_AARCH64_PAC_PLT
:
9727 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9734 dynamic_section_mips_val (Filedata
* filedata
, Elf_Internal_Dyn
* entry
)
9736 switch (entry
->d_tag
)
9739 if (entry
->d_un
.d_val
== 0)
9743 static const char * opts
[] =
9745 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9746 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9747 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9748 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9752 bfd_boolean first
= TRUE
;
9754 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
9755 if (entry
->d_un
.d_val
& (1 << cnt
))
9757 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
9763 case DT_MIPS_IVERSION
:
9764 if (VALID_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
))
9765 printf (_("Interface Version: %s"),
9766 GET_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
));
9770 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
9771 /* Note: coded this way so that there is a single string for translation. */
9772 printf (_("<corrupt: %s>"), buf
);
9776 case DT_MIPS_TIME_STAMP
:
9780 time_t atime
= entry
->d_un
.d_val
;
9782 tmp
= gmtime (&atime
);
9783 /* PR 17531: file: 6accc532. */
9785 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
9787 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
9788 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9789 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9790 printf (_("Time Stamp: %s"), timebuf
);
9794 case DT_MIPS_RLD_VERSION
:
9795 case DT_MIPS_LOCAL_GOTNO
:
9796 case DT_MIPS_CONFLICTNO
:
9797 case DT_MIPS_LIBLISTNO
:
9798 case DT_MIPS_SYMTABNO
:
9799 case DT_MIPS_UNREFEXTNO
:
9800 case DT_MIPS_HIPAGENO
:
9801 case DT_MIPS_DELTA_CLASS_NO
:
9802 case DT_MIPS_DELTA_INSTANCE_NO
:
9803 case DT_MIPS_DELTA_RELOC_NO
:
9804 case DT_MIPS_DELTA_SYM_NO
:
9805 case DT_MIPS_DELTA_CLASSSYM_NO
:
9806 case DT_MIPS_COMPACT_SIZE
:
9807 print_vma (entry
->d_un
.d_val
, DEC
);
9811 filedata
->dynamic_info_DT_MIPS_XHASH
= entry
->d_un
.d_val
;
9812 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
9813 /* Falls through. */
9816 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9822 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
9824 switch (entry
->d_tag
)
9826 case DT_HP_DLD_FLAGS
:
9835 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
9836 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
9837 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
9838 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
9839 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
9840 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
9841 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
9842 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
9843 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
9844 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
9845 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
9846 { DT_HP_GST
, "HP_GST" },
9847 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
9848 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
9849 { DT_HP_NODELETE
, "HP_NODELETE" },
9850 { DT_HP_GROUP
, "HP_GROUP" },
9851 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
9853 bfd_boolean first
= TRUE
;
9855 bfd_vma val
= entry
->d_un
.d_val
;
9857 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
9858 if (val
& flags
[cnt
].bit
)
9862 fputs (flags
[cnt
].str
, stdout
);
9864 val
^= flags
[cnt
].bit
;
9867 if (val
!= 0 || first
)
9871 print_vma (val
, HEX
);
9877 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9885 /* VMS vs Unix time offset and factor. */
9887 #define VMS_EPOCH_OFFSET 35067168000000000LL
9888 #define VMS_GRANULARITY_FACTOR 10000000
9890 /* Display a VMS time in a human readable format. */
9893 print_vms_time (bfd_int64_t vmstime
)
9898 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
9899 tm
= gmtime (&unxtime
);
9900 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9901 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
9902 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
9907 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
9909 switch (entry
->d_tag
)
9911 case DT_IA_64_PLT_RESERVE
:
9912 /* First 3 slots reserved. */
9913 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9915 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
9918 case DT_IA_64_VMS_LINKTIME
:
9920 print_vms_time (entry
->d_un
.d_val
);
9924 case DT_IA_64_VMS_LNKFLAGS
:
9925 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9926 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
9927 printf (" CALL_DEBUG");
9928 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
9929 printf (" NOP0BUFS");
9930 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
9931 printf (" P0IMAGE");
9932 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
9933 printf (" MKTHREADS");
9934 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
9935 printf (" UPCALLS");
9936 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
9938 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
9939 printf (" INITIALIZE");
9940 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
9942 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
9943 printf (" EXE_INIT");
9944 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
9945 printf (" TBK_IN_IMG");
9946 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
9947 printf (" DBG_IN_IMG");
9948 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
9949 printf (" TBK_IN_DSF");
9950 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
9951 printf (" DBG_IN_DSF");
9952 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
9953 printf (" SIGNATURES");
9954 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
9955 printf (" REL_SEG_OFF");
9959 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9966 get_32bit_dynamic_section (Filedata
* filedata
)
9968 Elf32_External_Dyn
* edyn
;
9969 Elf32_External_Dyn
* ext
;
9970 Elf_Internal_Dyn
* entry
;
9972 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, filedata
,
9973 filedata
->dynamic_addr
, 1,
9974 filedata
->dynamic_size
,
9975 _("dynamic section"));
9979 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9980 might not have the luxury of section headers. Look for the DT_NULL
9981 terminator to determine the number of entries. */
9982 for (ext
= edyn
, filedata
->dynamic_nent
= 0;
9983 (char *) (ext
+ 1) <= (char *) edyn
+ filedata
->dynamic_size
;
9986 filedata
->dynamic_nent
++;
9987 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9991 filedata
->dynamic_section
9992 = (Elf_Internal_Dyn
*) cmalloc (filedata
->dynamic_nent
, sizeof (* entry
));
9993 if (filedata
->dynamic_section
== NULL
)
9995 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9996 (unsigned long) filedata
->dynamic_nent
);
10001 for (ext
= edyn
, entry
= filedata
->dynamic_section
;
10002 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10005 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
10006 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
10015 get_64bit_dynamic_section (Filedata
* filedata
)
10017 Elf64_External_Dyn
* edyn
;
10018 Elf64_External_Dyn
* ext
;
10019 Elf_Internal_Dyn
* entry
;
10021 /* Read in the data. */
10022 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, filedata
,
10023 filedata
->dynamic_addr
, 1,
10024 filedata
->dynamic_size
,
10025 _("dynamic section"));
10029 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
10030 might not have the luxury of section headers. Look for the DT_NULL
10031 terminator to determine the number of entries. */
10032 for (ext
= edyn
, filedata
->dynamic_nent
= 0;
10033 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
10034 (char *) (ext
+ 1) <= (char *) edyn
+ filedata
->dynamic_size
;
10037 filedata
->dynamic_nent
++;
10038 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
10042 filedata
->dynamic_section
10043 = (Elf_Internal_Dyn
*) cmalloc (filedata
->dynamic_nent
, sizeof (* entry
));
10044 if (filedata
->dynamic_section
== NULL
)
10046 error (_("Out of memory allocating space for %lu dynamic entries\n"),
10047 (unsigned long) filedata
->dynamic_nent
);
10052 /* Convert from external to internal formats. */
10053 for (ext
= edyn
, entry
= filedata
->dynamic_section
;
10054 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10057 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
10058 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
10067 print_dynamic_flags (bfd_vma flags
)
10069 bfd_boolean first
= TRUE
;
10075 flag
= flags
& - flags
;
10081 putc (' ', stdout
);
10085 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
10086 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
10087 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
10088 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
10089 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
10090 default: fputs (_("unknown"), stdout
); break;
10097 get_dynamic_data (Filedata
* filedata
, bfd_size_type number
, unsigned int ent_size
)
10099 unsigned char * e_data
;
10102 /* If the size_t type is smaller than the bfd_size_type, eg because
10103 you are building a 32-bit tool on a 64-bit host, then make sure
10104 that when (number) is cast to (size_t) no information is lost. */
10105 if (sizeof (size_t) < sizeof (bfd_size_type
)
10106 && (bfd_size_type
) ((size_t) number
) != number
)
10108 error (_("Size truncation prevents reading %s elements of size %u\n"),
10109 bfd_vmatoa ("u", number
), ent_size
);
10113 /* Be kind to memory checkers (eg valgrind, address sanitizer) by not
10114 attempting to allocate memory when the read is bound to fail. */
10115 if (ent_size
* number
> filedata
->file_size
)
10117 error (_("Invalid number of dynamic entries: %s\n"),
10118 bfd_vmatoa ("u", number
));
10122 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
10123 if (e_data
== NULL
)
10125 error (_("Out of memory reading %s dynamic entries\n"),
10126 bfd_vmatoa ("u", number
));
10130 if (fread (e_data
, ent_size
, (size_t) number
, filedata
->handle
) != number
)
10132 error (_("Unable to read in %s bytes of dynamic data\n"),
10133 bfd_vmatoa ("u", number
* ent_size
));
10138 i_data
= (bfd_vma
*) cmalloc ((size_t) number
, sizeof (*i_data
));
10139 if (i_data
== NULL
)
10141 error (_("Out of memory allocating space for %s dynamic entries\n"),
10142 bfd_vmatoa ("u", number
));
10148 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
10155 static unsigned long
10156 get_num_dynamic_syms (Filedata
* filedata
)
10158 unsigned long num_of_syms
= 0;
10160 if (!do_histogram
&& (!do_using_dynamic
|| do_dyn_syms
))
10161 return num_of_syms
;
10163 if (filedata
->dynamic_info
[DT_HASH
])
10165 unsigned char nb
[8];
10166 unsigned char nc
[8];
10167 unsigned int hash_ent_size
= 4;
10169 if ((filedata
->file_header
.e_machine
== EM_ALPHA
10170 || filedata
->file_header
.e_machine
== EM_S390
10171 || filedata
->file_header
.e_machine
== EM_S390_OLD
)
10172 && filedata
->file_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
10175 if (fseek (filedata
->handle
,
10176 (filedata
->archive_file_offset
10177 + offset_from_vma (filedata
, filedata
->dynamic_info
[DT_HASH
],
10178 sizeof nb
+ sizeof nc
)),
10181 error (_("Unable to seek to start of dynamic information\n"));
10185 if (fread (nb
, hash_ent_size
, 1, filedata
->handle
) != 1)
10187 error (_("Failed to read in number of buckets\n"));
10191 if (fread (nc
, hash_ent_size
, 1, filedata
->handle
) != 1)
10193 error (_("Failed to read in number of chains\n"));
10197 filedata
->nbuckets
= byte_get (nb
, hash_ent_size
);
10198 filedata
->nchains
= byte_get (nc
, hash_ent_size
);
10200 if (filedata
->nbuckets
!= 0 && filedata
->nchains
!= 0)
10202 filedata
->buckets
= get_dynamic_data (filedata
, filedata
->nbuckets
,
10204 filedata
->chains
= get_dynamic_data (filedata
, filedata
->nchains
,
10207 if (filedata
->buckets
!= NULL
&& filedata
->chains
!= NULL
)
10208 num_of_syms
= filedata
->nchains
;
10211 if (num_of_syms
== 0)
10213 free (filedata
->buckets
);
10214 filedata
->buckets
= NULL
;
10215 free (filedata
->chains
);
10216 filedata
->chains
= NULL
;
10217 filedata
->nbuckets
= 0;
10221 if (filedata
->dynamic_info_DT_GNU_HASH
)
10223 unsigned char nb
[16];
10224 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
10225 bfd_vma buckets_vma
;
10228 if (fseek (filedata
->handle
,
10229 (filedata
->archive_file_offset
10230 + offset_from_vma (filedata
,
10231 filedata
->dynamic_info_DT_GNU_HASH
,
10235 error (_("Unable to seek to start of dynamic information\n"));
10239 if (fread (nb
, 16, 1, filedata
->handle
) != 1)
10241 error (_("Failed to read in number of buckets\n"));
10245 filedata
->ngnubuckets
= byte_get (nb
, 4);
10246 filedata
->gnusymidx
= byte_get (nb
+ 4, 4);
10247 bitmaskwords
= byte_get (nb
+ 8, 4);
10248 buckets_vma
= filedata
->dynamic_info_DT_GNU_HASH
+ 16;
10250 buckets_vma
+= bitmaskwords
* 4;
10252 buckets_vma
+= bitmaskwords
* 8;
10254 if (fseek (filedata
->handle
,
10255 (filedata
->archive_file_offset
10256 + offset_from_vma (filedata
, buckets_vma
, 4)),
10259 error (_("Unable to seek to start of dynamic information\n"));
10263 filedata
->gnubuckets
10264 = get_dynamic_data (filedata
, filedata
->ngnubuckets
, 4);
10266 if (filedata
->gnubuckets
== NULL
)
10269 for (i
= 0; i
< filedata
->ngnubuckets
; i
++)
10270 if (filedata
->gnubuckets
[i
] != 0)
10272 if (filedata
->gnubuckets
[i
] < filedata
->gnusymidx
)
10275 if (maxchain
== 0xffffffff || filedata
->gnubuckets
[i
] > maxchain
)
10276 maxchain
= filedata
->gnubuckets
[i
];
10279 if (maxchain
== 0xffffffff)
10282 maxchain
-= filedata
->gnusymidx
;
10284 if (fseek (filedata
->handle
,
10285 (filedata
->archive_file_offset
10286 + offset_from_vma (filedata
,
10287 buckets_vma
+ 4 * (filedata
->ngnubuckets
10292 error (_("Unable to seek to start of dynamic information\n"));
10298 if (fread (nb
, 4, 1, filedata
->handle
) != 1)
10300 error (_("Failed to determine last chain length\n"));
10304 if (maxchain
+ 1 == 0)
10309 while ((byte_get (nb
, 4) & 1) == 0);
10311 if (fseek (filedata
->handle
,
10312 (filedata
->archive_file_offset
10313 + offset_from_vma (filedata
, (buckets_vma
10314 + 4 * filedata
->ngnubuckets
),
10318 error (_("Unable to seek to start of dynamic information\n"));
10322 filedata
->gnuchains
= get_dynamic_data (filedata
, maxchain
, 4);
10323 filedata
->ngnuchains
= maxchain
;
10325 if (filedata
->gnuchains
== NULL
)
10328 if (filedata
->dynamic_info_DT_MIPS_XHASH
)
10330 if (fseek (filedata
->handle
,
10331 (filedata
->archive_file_offset
10332 + offset_from_vma (filedata
, (buckets_vma
10333 + 4 * (filedata
->ngnubuckets
10337 error (_("Unable to seek to start of dynamic information\n"));
10341 filedata
->mipsxlat
= get_dynamic_data (filedata
, maxchain
, 4);
10342 if (filedata
->mipsxlat
== NULL
)
10346 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
10347 if (filedata
->gnubuckets
[hn
] != 0)
10349 bfd_vma si
= filedata
->gnubuckets
[hn
];
10350 bfd_vma off
= si
- filedata
->gnusymidx
;
10354 if (filedata
->dynamic_info_DT_MIPS_XHASH
)
10356 if (off
< filedata
->ngnuchains
10357 && filedata
->mipsxlat
[off
] >= num_of_syms
)
10358 num_of_syms
= filedata
->mipsxlat
[off
] + 1;
10362 if (si
>= num_of_syms
)
10363 num_of_syms
= si
+ 1;
10367 while (off
< filedata
->ngnuchains
10368 && (filedata
->gnuchains
[off
++] & 1) == 0);
10371 if (num_of_syms
== 0)
10374 free (filedata
->mipsxlat
);
10375 filedata
->mipsxlat
= NULL
;
10376 free (filedata
->gnuchains
);
10377 filedata
->gnuchains
= NULL
;
10378 free (filedata
->gnubuckets
);
10379 filedata
->gnubuckets
= NULL
;
10380 filedata
->ngnubuckets
= 0;
10381 filedata
->ngnuchains
= 0;
10385 return num_of_syms
;
10388 /* Parse and display the contents of the dynamic section. */
10391 process_dynamic_section (Filedata
* filedata
)
10393 Elf_Internal_Dyn
* entry
;
10395 if (filedata
->dynamic_size
== 0)
10398 printf (_("\nThere is no dynamic section in this file.\n"));
10405 if (! get_32bit_dynamic_section (filedata
))
10410 if (! get_64bit_dynamic_section (filedata
))
10414 /* Find the appropriate symbol table. */
10415 if (filedata
->dynamic_symbols
== NULL
|| do_histogram
)
10417 unsigned long num_of_syms
;
10419 for (entry
= filedata
->dynamic_section
;
10420 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10422 if (entry
->d_tag
== DT_SYMTAB
)
10423 filedata
->dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
10424 else if (entry
->d_tag
== DT_SYMENT
)
10425 filedata
->dynamic_info
[DT_SYMENT
] = entry
->d_un
.d_val
;
10426 else if (entry
->d_tag
== DT_HASH
)
10427 filedata
->dynamic_info
[DT_HASH
] = entry
->d_un
.d_val
;
10428 else if (entry
->d_tag
== DT_GNU_HASH
)
10429 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10430 else if ((filedata
->file_header
.e_machine
== EM_MIPS
10431 || filedata
->file_header
.e_machine
== EM_MIPS_RS3_LE
)
10432 && entry
->d_tag
== DT_MIPS_XHASH
)
10434 filedata
->dynamic_info_DT_MIPS_XHASH
= entry
->d_un
.d_val
;
10435 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10438 num_of_syms
= get_num_dynamic_syms (filedata
);
10440 if (num_of_syms
!= 0
10441 && filedata
->dynamic_symbols
== NULL
10442 && filedata
->dynamic_info
[DT_SYMTAB
]
10443 && filedata
->dynamic_info
[DT_SYMENT
])
10445 Elf_Internal_Phdr
*seg
;
10446 bfd_vma vma
= filedata
->dynamic_info
[DT_SYMTAB
];
10448 if (! get_program_headers (filedata
))
10450 error (_("Cannot interpret virtual addresses "
10451 "without program headers.\n"));
10455 for (seg
= filedata
->program_headers
;
10456 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
10459 if (seg
->p_type
!= PT_LOAD
)
10462 if (seg
->p_offset
+ seg
->p_filesz
> filedata
->file_size
)
10464 /* See PR 21379 for a reproducer. */
10465 error (_("Invalid PT_LOAD entry\n"));
10469 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
10470 && vma
< seg
->p_vaddr
+ seg
->p_filesz
)
10472 /* Since we do not know how big the symbol table is,
10473 we default to reading in up to the end of PT_LOAD
10474 segment and processing that. This is overkill, I
10475 know, but it should work. */
10476 Elf_Internal_Shdr section
;
10477 section
.sh_offset
= (vma
- seg
->p_vaddr
10479 section
.sh_size
= (num_of_syms
10480 * filedata
->dynamic_info
[DT_SYMENT
]);
10481 section
.sh_entsize
= filedata
->dynamic_info
[DT_SYMENT
];
10484 && filedata
->dynamic_symtab_section
!= NULL
10485 && ((filedata
->dynamic_symtab_section
->sh_offset
10486 != section
.sh_offset
)
10487 || (filedata
->dynamic_symtab_section
->sh_size
10488 != section
.sh_size
)
10489 || (filedata
->dynamic_symtab_section
->sh_entsize
10490 != section
.sh_entsize
)))
10492 the .dynsym section doesn't match the DT_SYMTAB and DT_SYMENT tags\n"));
10494 section
.sh_name
= filedata
->string_table_length
;
10495 filedata
->dynamic_symbols
10496 = GET_ELF_SYMBOLS (filedata
, §ion
,
10497 &filedata
->num_dynamic_syms
);
10498 if (filedata
->dynamic_symbols
== NULL
10499 || filedata
->num_dynamic_syms
!= num_of_syms
)
10501 error (_("Corrupt DT_SYMTAB dynamic entry\n"));
10510 /* Similarly find a string table. */
10511 if (filedata
->dynamic_strings
== NULL
)
10512 for (entry
= filedata
->dynamic_section
;
10513 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10516 if (entry
->d_tag
== DT_STRTAB
)
10517 filedata
->dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
10519 if (entry
->d_tag
== DT_STRSZ
)
10520 filedata
->dynamic_info
[DT_STRSZ
] = entry
->d_un
.d_val
;
10522 if (filedata
->dynamic_info
[DT_STRTAB
]
10523 && filedata
->dynamic_info
[DT_STRSZ
])
10525 unsigned long offset
;
10526 bfd_size_type str_tab_len
= filedata
->dynamic_info
[DT_STRSZ
];
10528 offset
= offset_from_vma (filedata
,
10529 filedata
->dynamic_info
[DT_STRTAB
],
10532 && filedata
->dynamic_strtab_section
10533 && ((filedata
->dynamic_strtab_section
->sh_offset
10534 != (file_ptr
) offset
)
10535 || (filedata
->dynamic_strtab_section
->sh_size
10538 the .dynstr section doesn't match the DT_STRTAB and DT_STRSZ tags\n"));
10540 filedata
->dynamic_strings
10541 = (char *) get_data (NULL
, filedata
, offset
, 1, str_tab_len
,
10542 _("dynamic string table"));
10543 if (filedata
->dynamic_strings
== NULL
)
10545 error (_("Corrupt DT_STRTAB dynamic entry\n"));
10549 filedata
->dynamic_strings_length
= str_tab_len
;
10554 /* And find the syminfo section if available. */
10555 if (filedata
->dynamic_syminfo
== NULL
)
10557 unsigned long syminsz
= 0;
10559 for (entry
= filedata
->dynamic_section
;
10560 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10563 if (entry
->d_tag
== DT_SYMINENT
)
10565 /* Note: these braces are necessary to avoid a syntax
10566 error from the SunOS4 C compiler. */
10567 /* PR binutils/17531: A corrupt file can trigger this test.
10568 So do not use an assert, instead generate an error message. */
10569 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
10570 error (_("Bad value (%d) for SYMINENT entry\n"),
10571 (int) entry
->d_un
.d_val
);
10573 else if (entry
->d_tag
== DT_SYMINSZ
)
10574 syminsz
= entry
->d_un
.d_val
;
10575 else if (entry
->d_tag
== DT_SYMINFO
)
10576 filedata
->dynamic_syminfo_offset
10577 = offset_from_vma (filedata
, entry
->d_un
.d_val
, syminsz
);
10580 if (filedata
->dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
10582 Elf_External_Syminfo
* extsyminfo
;
10583 Elf_External_Syminfo
* extsym
;
10584 Elf_Internal_Syminfo
* syminfo
;
10586 /* There is a syminfo section. Read the data. */
10587 extsyminfo
= (Elf_External_Syminfo
*)
10588 get_data (NULL
, filedata
, filedata
->dynamic_syminfo_offset
,
10589 1, syminsz
, _("symbol information"));
10593 if (filedata
->dynamic_syminfo
!= NULL
)
10595 error (_("Multiple dynamic symbol information sections found\n"));
10596 free (filedata
->dynamic_syminfo
);
10598 filedata
->dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
10599 if (filedata
->dynamic_syminfo
== NULL
)
10601 error (_("Out of memory allocating %lu bytes "
10602 "for dynamic symbol info\n"),
10603 (unsigned long) syminsz
);
10607 filedata
->dynamic_syminfo_nent
10608 = syminsz
/ sizeof (Elf_External_Syminfo
);
10609 for (syminfo
= filedata
->dynamic_syminfo
, extsym
= extsyminfo
;
10610 syminfo
< (filedata
->dynamic_syminfo
10611 + filedata
->dynamic_syminfo_nent
);
10612 ++syminfo
, ++extsym
)
10614 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
10615 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
10622 if (do_dynamic
&& filedata
->dynamic_addr
)
10623 printf (ngettext ("\nDynamic section at offset 0x%lx "
10624 "contains %lu entry:\n",
10625 "\nDynamic section at offset 0x%lx "
10626 "contains %lu entries:\n",
10627 filedata
->dynamic_nent
),
10628 filedata
->dynamic_addr
, (unsigned long) filedata
->dynamic_nent
);
10630 printf (_(" Tag Type Name/Value\n"));
10632 for (entry
= filedata
->dynamic_section
;
10633 entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
;
10638 const char * dtype
;
10641 print_vma (entry
->d_tag
, FULL_HEX
);
10642 dtype
= get_dynamic_type (filedata
, entry
->d_tag
);
10643 printf (" (%s)%*s", dtype
,
10644 ((is_32bit_elf
? 27 : 19) - (int) strlen (dtype
)), " ");
10647 switch (entry
->d_tag
)
10651 print_dynamic_flags (entry
->d_un
.d_val
);
10661 switch (entry
->d_tag
)
10664 printf (_("Auxiliary library"));
10668 printf (_("Filter library"));
10672 printf (_("Configuration file"));
10676 printf (_("Dependency audit library"));
10680 printf (_("Audit library"));
10684 if (VALID_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
))
10685 printf (": [%s]\n",
10686 GET_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
));
10690 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10699 printf (_("Flags:"));
10701 if (entry
->d_un
.d_val
== 0)
10702 printf (_(" None\n"));
10705 unsigned long int val
= entry
->d_un
.d_val
;
10707 if (val
& DTF_1_PARINIT
)
10709 printf (" PARINIT");
10710 val
^= DTF_1_PARINIT
;
10712 if (val
& DTF_1_CONFEXP
)
10714 printf (" CONFEXP");
10715 val
^= DTF_1_CONFEXP
;
10718 printf (" %lx", val
);
10727 printf (_("Flags:"));
10729 if (entry
->d_un
.d_val
== 0)
10730 printf (_(" None\n"));
10733 unsigned long int val
= entry
->d_un
.d_val
;
10735 if (val
& DF_P1_LAZYLOAD
)
10737 printf (" LAZYLOAD");
10738 val
^= DF_P1_LAZYLOAD
;
10740 if (val
& DF_P1_GROUPPERM
)
10742 printf (" GROUPPERM");
10743 val
^= DF_P1_GROUPPERM
;
10746 printf (" %lx", val
);
10755 printf (_("Flags:"));
10756 if (entry
->d_un
.d_val
== 0)
10757 printf (_(" None\n"));
10760 unsigned long int val
= entry
->d_un
.d_val
;
10762 if (val
& DF_1_NOW
)
10767 if (val
& DF_1_GLOBAL
)
10769 printf (" GLOBAL");
10770 val
^= DF_1_GLOBAL
;
10772 if (val
& DF_1_GROUP
)
10777 if (val
& DF_1_NODELETE
)
10779 printf (" NODELETE");
10780 val
^= DF_1_NODELETE
;
10782 if (val
& DF_1_LOADFLTR
)
10784 printf (" LOADFLTR");
10785 val
^= DF_1_LOADFLTR
;
10787 if (val
& DF_1_INITFIRST
)
10789 printf (" INITFIRST");
10790 val
^= DF_1_INITFIRST
;
10792 if (val
& DF_1_NOOPEN
)
10794 printf (" NOOPEN");
10795 val
^= DF_1_NOOPEN
;
10797 if (val
& DF_1_ORIGIN
)
10799 printf (" ORIGIN");
10800 val
^= DF_1_ORIGIN
;
10802 if (val
& DF_1_DIRECT
)
10804 printf (" DIRECT");
10805 val
^= DF_1_DIRECT
;
10807 if (val
& DF_1_TRANS
)
10812 if (val
& DF_1_INTERPOSE
)
10814 printf (" INTERPOSE");
10815 val
^= DF_1_INTERPOSE
;
10817 if (val
& DF_1_NODEFLIB
)
10819 printf (" NODEFLIB");
10820 val
^= DF_1_NODEFLIB
;
10822 if (val
& DF_1_NODUMP
)
10824 printf (" NODUMP");
10825 val
^= DF_1_NODUMP
;
10827 if (val
& DF_1_CONFALT
)
10829 printf (" CONFALT");
10830 val
^= DF_1_CONFALT
;
10832 if (val
& DF_1_ENDFILTEE
)
10834 printf (" ENDFILTEE");
10835 val
^= DF_1_ENDFILTEE
;
10837 if (val
& DF_1_DISPRELDNE
)
10839 printf (" DISPRELDNE");
10840 val
^= DF_1_DISPRELDNE
;
10842 if (val
& DF_1_DISPRELPND
)
10844 printf (" DISPRELPND");
10845 val
^= DF_1_DISPRELPND
;
10847 if (val
& DF_1_NODIRECT
)
10849 printf (" NODIRECT");
10850 val
^= DF_1_NODIRECT
;
10852 if (val
& DF_1_IGNMULDEF
)
10854 printf (" IGNMULDEF");
10855 val
^= DF_1_IGNMULDEF
;
10857 if (val
& DF_1_NOKSYMS
)
10859 printf (" NOKSYMS");
10860 val
^= DF_1_NOKSYMS
;
10862 if (val
& DF_1_NOHDR
)
10867 if (val
& DF_1_EDITED
)
10869 printf (" EDITED");
10870 val
^= DF_1_EDITED
;
10872 if (val
& DF_1_NORELOC
)
10874 printf (" NORELOC");
10875 val
^= DF_1_NORELOC
;
10877 if (val
& DF_1_SYMINTPOSE
)
10879 printf (" SYMINTPOSE");
10880 val
^= DF_1_SYMINTPOSE
;
10882 if (val
& DF_1_GLOBAUDIT
)
10884 printf (" GLOBAUDIT");
10885 val
^= DF_1_GLOBAUDIT
;
10887 if (val
& DF_1_SINGLETON
)
10889 printf (" SINGLETON");
10890 val
^= DF_1_SINGLETON
;
10892 if (val
& DF_1_STUB
)
10897 if (val
& DF_1_PIE
)
10902 if (val
& DF_1_KMOD
)
10907 if (val
& DF_1_WEAKFILTER
)
10909 printf (" WEAKFILTER");
10910 val
^= DF_1_WEAKFILTER
;
10912 if (val
& DF_1_NOCOMMON
)
10914 printf (" NOCOMMON");
10915 val
^= DF_1_NOCOMMON
;
10918 printf (" %lx", val
);
10925 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10927 puts (get_dynamic_type (filedata
, entry
->d_un
.d_val
));
10947 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10953 if (VALID_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
))
10954 name
= GET_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
);
10960 switch (entry
->d_tag
)
10963 printf (_("Shared library: [%s]"), name
);
10965 if (streq (name
, filedata
->program_interpreter
))
10966 printf (_(" program interpreter"));
10970 printf (_("Library soname: [%s]"), name
);
10974 printf (_("Library rpath: [%s]"), name
);
10978 printf (_("Library runpath: [%s]"), name
);
10982 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10987 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
11000 filedata
->dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
11001 /* Fall through. */
11005 case DT_INIT_ARRAYSZ
:
11006 case DT_FINI_ARRAYSZ
:
11007 case DT_GNU_CONFLICTSZ
:
11008 case DT_GNU_LIBLISTSZ
:
11011 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
11012 printf (_(" (bytes)\n"));
11017 case DT_VERNEEDNUM
:
11022 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
11031 case DT_INIT_ARRAY
:
11032 case DT_FINI_ARRAY
:
11035 if (entry
->d_tag
== DT_USED
11036 && VALID_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
))
11038 char * name
= GET_DYNAMIC_NAME (filedata
, entry
->d_un
.d_val
);
11042 printf (_("Not needed object: [%s]\n"), name
);
11047 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
11053 /* The value of this entry is ignored. */
11058 case DT_GNU_PRELINKED
:
11062 time_t atime
= entry
->d_un
.d_val
;
11064 tmp
= gmtime (&atime
);
11065 /* PR 17533 file: 041-1244816-0.004. */
11067 printf (_("<corrupt time val: %lx"),
11068 (unsigned long) atime
);
11070 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
11071 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
11072 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
11078 filedata
->dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
11081 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
11086 case DT_GNU_FLAGS_1
:
11089 printf (_("Flags:"));
11090 if (entry
->d_un
.d_val
== 0)
11091 printf (_(" None\n"));
11094 unsigned long int val
= entry
->d_un
.d_val
;
11096 if (val
& DF_GNU_1_UNIQUE
)
11098 printf (" UNIQUE");
11099 val
^= DF_GNU_1_UNIQUE
;
11102 printf (" %lx", val
);
11109 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
11110 filedata
->version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)]
11111 = entry
->d_un
.d_val
;
11115 switch (filedata
->file_header
.e_machine
)
11118 dynamic_section_aarch64_val (entry
);
11121 case EM_MIPS_RS3_LE
:
11122 dynamic_section_mips_val (filedata
, entry
);
11125 dynamic_section_parisc_val (entry
);
11128 dynamic_section_ia64_val (entry
);
11131 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
11143 get_ver_flags (unsigned int flags
)
11145 static char buff
[128];
11152 if (flags
& VER_FLG_BASE
)
11153 strcat (buff
, "BASE");
11155 if (flags
& VER_FLG_WEAK
)
11157 if (flags
& VER_FLG_BASE
)
11158 strcat (buff
, " | ");
11160 strcat (buff
, "WEAK");
11163 if (flags
& VER_FLG_INFO
)
11165 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
11166 strcat (buff
, " | ");
11168 strcat (buff
, "INFO");
11171 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
11173 if (flags
& (VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
11174 strcat (buff
, " | ");
11176 strcat (buff
, _("<unknown>"));
11182 /* Display the contents of the version sections. */
11185 process_version_sections (Filedata
* filedata
)
11187 Elf_Internal_Shdr
* section
;
11189 bfd_boolean found
= FALSE
;
11194 for (i
= 0, section
= filedata
->section_headers
;
11195 i
< filedata
->file_header
.e_shnum
;
11198 switch (section
->sh_type
)
11200 case SHT_GNU_verdef
:
11202 Elf_External_Verdef
* edefs
;
11209 printf (ngettext ("\nVersion definition section '%s' "
11210 "contains %u entry:\n",
11211 "\nVersion definition section '%s' "
11212 "contains %u entries:\n",
11214 printable_section_name (filedata
, section
),
11217 printf (_(" Addr: 0x"));
11218 printf_vma (section
->sh_addr
);
11219 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
11220 (unsigned long) section
->sh_offset
, section
->sh_link
,
11221 printable_section_name_from_index (filedata
, section
->sh_link
));
11223 edefs
= (Elf_External_Verdef
*)
11224 get_data (NULL
, filedata
, section
->sh_offset
, 1,section
->sh_size
,
11225 _("version definition section"));
11228 endbuf
= (char *) edefs
+ section
->sh_size
;
11230 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
11233 Elf_External_Verdef
* edef
;
11234 Elf_Internal_Verdef ent
;
11235 Elf_External_Verdaux
* eaux
;
11236 Elf_Internal_Verdaux aux
;
11237 unsigned long isum
;
11240 vstart
= ((char *) edefs
) + idx
;
11241 if (vstart
+ sizeof (*edef
) > endbuf
)
11244 edef
= (Elf_External_Verdef
*) vstart
;
11246 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
11247 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
11248 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
11249 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
11250 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
11251 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
11252 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
11254 printf (_(" %#06lx: Rev: %d Flags: %s"),
11255 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
11257 printf (_(" Index: %d Cnt: %d "),
11258 ent
.vd_ndx
, ent
.vd_cnt
);
11260 /* Check for overflow. */
11261 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
11264 vstart
+= ent
.vd_aux
;
11266 if (vstart
+ sizeof (*eaux
) > endbuf
)
11268 eaux
= (Elf_External_Verdaux
*) vstart
;
11270 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
11271 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
11273 if (VALID_DYNAMIC_NAME (filedata
, aux
.vda_name
))
11274 printf (_("Name: %s\n"),
11275 GET_DYNAMIC_NAME (filedata
, aux
.vda_name
));
11277 printf (_("Name index: %ld\n"), aux
.vda_name
);
11279 isum
= idx
+ ent
.vd_aux
;
11281 for (j
= 1; j
< ent
.vd_cnt
; j
++)
11283 if (aux
.vda_next
< sizeof (*eaux
)
11284 && !(j
== ent
.vd_cnt
- 1 && aux
.vda_next
== 0))
11286 warn (_("Invalid vda_next field of %lx\n"),
11291 /* Check for overflow. */
11292 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
11295 isum
+= aux
.vda_next
;
11296 vstart
+= aux
.vda_next
;
11298 if (vstart
+ sizeof (*eaux
) > endbuf
)
11300 eaux
= (Elf_External_Verdaux
*) vstart
;
11302 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
11303 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
11305 if (VALID_DYNAMIC_NAME (filedata
, aux
.vda_name
))
11306 printf (_(" %#06lx: Parent %d: %s\n"),
11308 GET_DYNAMIC_NAME (filedata
, aux
.vda_name
));
11310 printf (_(" %#06lx: Parent %d, name index: %ld\n"),
11311 isum
, j
, aux
.vda_name
);
11314 if (j
< ent
.vd_cnt
)
11315 printf (_(" Version def aux past end of section\n"));
11318 file: id:000001,src:000172+005151,op:splice,rep:2. */
11319 if (ent
.vd_next
< sizeof (*edef
)
11320 && !(cnt
== section
->sh_info
- 1 && ent
.vd_next
== 0))
11322 warn (_("Invalid vd_next field of %lx\n"), ent
.vd_next
);
11323 cnt
= section
->sh_info
;
11326 if (ent
.vd_next
> (size_t) (endbuf
- ((char *) edefs
+ idx
)))
11329 idx
+= ent
.vd_next
;
11332 if (cnt
< section
->sh_info
)
11333 printf (_(" Version definition past end of section\n"));
11339 case SHT_GNU_verneed
:
11341 Elf_External_Verneed
* eneed
;
11348 printf (ngettext ("\nVersion needs section '%s' "
11349 "contains %u entry:\n",
11350 "\nVersion needs section '%s' "
11351 "contains %u entries:\n",
11353 printable_section_name (filedata
, section
), section
->sh_info
);
11355 printf (_(" Addr: 0x"));
11356 printf_vma (section
->sh_addr
);
11357 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
11358 (unsigned long) section
->sh_offset
, section
->sh_link
,
11359 printable_section_name_from_index (filedata
, section
->sh_link
));
11361 eneed
= (Elf_External_Verneed
*) get_data (NULL
, filedata
,
11362 section
->sh_offset
, 1,
11364 _("Version Needs section"));
11367 endbuf
= (char *) eneed
+ section
->sh_size
;
11369 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
11371 Elf_External_Verneed
* entry
;
11372 Elf_Internal_Verneed ent
;
11373 unsigned long isum
;
11377 vstart
= ((char *) eneed
) + idx
;
11378 if (vstart
+ sizeof (*entry
) > endbuf
)
11381 entry
= (Elf_External_Verneed
*) vstart
;
11383 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
11384 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
11385 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
11386 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
11387 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
11389 printf (_(" %#06lx: Version: %d"), idx
, ent
.vn_version
);
11391 if (VALID_DYNAMIC_NAME (filedata
, ent
.vn_file
))
11392 printf (_(" File: %s"),
11393 GET_DYNAMIC_NAME (filedata
, ent
.vn_file
));
11395 printf (_(" File: %lx"), ent
.vn_file
);
11397 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
11399 /* Check for overflow. */
11400 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
11402 vstart
+= ent
.vn_aux
;
11404 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
11406 Elf_External_Vernaux
* eaux
;
11407 Elf_Internal_Vernaux aux
;
11409 if (vstart
+ sizeof (*eaux
) > endbuf
)
11411 eaux
= (Elf_External_Vernaux
*) vstart
;
11413 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
11414 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
11415 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
11416 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
11417 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
11419 if (VALID_DYNAMIC_NAME (filedata
, aux
.vna_name
))
11420 printf (_(" %#06lx: Name: %s"),
11421 isum
, GET_DYNAMIC_NAME (filedata
, aux
.vna_name
));
11423 printf (_(" %#06lx: Name index: %lx"),
11424 isum
, aux
.vna_name
);
11426 printf (_(" Flags: %s Version: %d\n"),
11427 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
11429 if (aux
.vna_next
< sizeof (*eaux
)
11430 && !(j
== ent
.vn_cnt
- 1 && aux
.vna_next
== 0))
11432 warn (_("Invalid vna_next field of %lx\n"),
11437 /* Check for overflow. */
11438 if (aux
.vna_next
> (size_t) (endbuf
- vstart
))
11440 isum
+= aux
.vna_next
;
11441 vstart
+= aux
.vna_next
;
11444 if (j
< ent
.vn_cnt
)
11445 warn (_("Missing Version Needs auxillary information\n"));
11447 if (ent
.vn_next
< sizeof (*entry
)
11448 && !(cnt
== section
->sh_info
- 1 && ent
.vn_next
== 0))
11450 warn (_("Invalid vn_next field of %lx\n"), ent
.vn_next
);
11451 cnt
= section
->sh_info
;
11454 if (ent
.vn_next
> (size_t) (endbuf
- ((char *) eneed
+ idx
)))
11456 idx
+= ent
.vn_next
;
11459 if (cnt
< section
->sh_info
)
11460 warn (_("Missing Version Needs information\n"));
11466 case SHT_GNU_versym
:
11468 Elf_Internal_Shdr
* link_section
;
11471 unsigned char * edata
;
11472 unsigned short * data
;
11474 Elf_Internal_Sym
* symbols
;
11475 Elf_Internal_Shdr
* string_sec
;
11476 unsigned long num_syms
;
11479 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
11482 link_section
= filedata
->section_headers
+ section
->sh_link
;
11483 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
11485 if (link_section
->sh_link
>= filedata
->file_header
.e_shnum
)
11490 symbols
= GET_ELF_SYMBOLS (filedata
, link_section
, & num_syms
);
11491 if (symbols
== NULL
)
11494 string_sec
= filedata
->section_headers
+ link_section
->sh_link
;
11496 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
11497 string_sec
->sh_size
,
11498 _("version string table"));
11505 printf (ngettext ("\nVersion symbols section '%s' "
11506 "contains %lu entry:\n",
11507 "\nVersion symbols section '%s' "
11508 "contains %lu entries:\n",
11510 printable_section_name (filedata
, section
), (unsigned long) total
);
11512 printf (_(" Addr: 0x"));
11513 printf_vma (section
->sh_addr
);
11514 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
11515 (unsigned long) section
->sh_offset
, section
->sh_link
,
11516 printable_section_name (filedata
, link_section
));
11518 off
= offset_from_vma (filedata
,
11519 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
11520 total
* sizeof (short));
11521 edata
= (unsigned char *) get_data (NULL
, filedata
, off
,
11522 sizeof (short), total
,
11523 _("version symbol data"));
11531 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
11533 for (cnt
= total
; cnt
--;)
11534 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
11539 for (cnt
= 0; cnt
< total
; cnt
+= 4)
11543 char *invalid
= _("*invalid*");
11545 printf (" %03x:", cnt
);
11547 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
11548 switch (data
[cnt
+ j
])
11551 fputs (_(" 0 (*local*) "), stdout
);
11555 fputs (_(" 1 (*global*) "), stdout
);
11559 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
11560 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
11562 /* If this index value is greater than the size of the symbols
11563 array, break to avoid an out-of-bounds read. */
11564 if ((unsigned long)(cnt
+ j
) >= num_syms
)
11566 warn (_("invalid index into symbol array\n"));
11571 if (filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
11573 Elf_Internal_Verneed ivn
;
11574 unsigned long offset
;
11576 offset
= offset_from_vma
11578 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
11579 sizeof (Elf_External_Verneed
));
11583 Elf_Internal_Vernaux ivna
;
11584 Elf_External_Verneed evn
;
11585 Elf_External_Vernaux evna
;
11586 unsigned long a_off
;
11588 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
11589 _("version need")) == NULL
)
11592 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
11593 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
11595 a_off
= offset
+ ivn
.vn_aux
;
11599 if (get_data (&evna
, filedata
, a_off
, sizeof (evna
),
11600 1, _("version need aux (2)")) == NULL
)
11603 ivna
.vna_other
= 0;
11607 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
11608 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
11611 a_off
+= ivna
.vna_next
;
11613 while (ivna
.vna_other
!= data
[cnt
+ j
]
11614 && ivna
.vna_next
!= 0);
11616 if (ivna
.vna_other
== data
[cnt
+ j
])
11618 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
11620 if (ivna
.vna_name
>= string_sec
->sh_size
)
11623 name
= strtab
+ ivna
.vna_name
;
11627 offset
+= ivn
.vn_next
;
11629 while (ivn
.vn_next
);
11632 if (data
[cnt
+ j
] != 0x8001
11633 && filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
11635 Elf_Internal_Verdef ivd
;
11636 Elf_External_Verdef evd
;
11637 unsigned long offset
;
11639 offset
= offset_from_vma
11641 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
11646 if (get_data (&evd
, filedata
, offset
, sizeof (evd
), 1,
11647 _("version def")) == NULL
)
11650 /* PR 17531: file: 046-1082287-0.004. */
11651 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
11656 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
11657 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
11660 offset
+= ivd
.vd_next
;
11662 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
11663 && ivd
.vd_next
!= 0);
11665 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
11667 Elf_External_Verdaux evda
;
11668 Elf_Internal_Verdaux ivda
;
11670 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
11672 if (get_data (&evda
, filedata
,
11673 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
11675 _("version def aux")) == NULL
)
11678 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
11680 if (ivda
.vda_name
>= string_sec
->sh_size
)
11682 else if (name
!= NULL
&& name
!= invalid
)
11683 name
= _("*both*");
11685 name
= strtab
+ ivda
.vda_name
;
11689 nn
+= printf ("(%s%-*s",
11691 12 - (int) strlen (name
),
11695 printf ("%*c", 18 - nn
, ' ');
11713 printf (_("\nNo version information found in this file.\n"));
11718 static const char *
11719 get_symbol_binding (Filedata
* filedata
, unsigned int binding
)
11721 static char buff
[64];
11725 case STB_LOCAL
: return "LOCAL";
11726 case STB_GLOBAL
: return "GLOBAL";
11727 case STB_WEAK
: return "WEAK";
11729 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
11730 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
11732 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
11734 if (binding
== STB_GNU_UNIQUE
11735 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
)
11737 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
11740 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
11745 static const char *
11746 get_symbol_type (Filedata
* filedata
, unsigned int type
)
11748 static char buff
[64];
11752 case STT_NOTYPE
: return "NOTYPE";
11753 case STT_OBJECT
: return "OBJECT";
11754 case STT_FUNC
: return "FUNC";
11755 case STT_SECTION
: return "SECTION";
11756 case STT_FILE
: return "FILE";
11757 case STT_COMMON
: return "COMMON";
11758 case STT_TLS
: return "TLS";
11759 case STT_RELC
: return "RELC";
11760 case STT_SRELC
: return "SRELC";
11762 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
11764 if (filedata
->file_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
11765 return "THUMB_FUNC";
11767 if (filedata
->file_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
11770 if (filedata
->file_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
11771 return "PARISC_MILLI";
11773 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
11775 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
11777 if (filedata
->file_header
.e_machine
== EM_PARISC
)
11779 if (type
== STT_HP_OPAQUE
)
11780 return "HP_OPAQUE";
11781 if (type
== STT_HP_STUB
)
11785 if (type
== STT_GNU_IFUNC
11786 && (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
11787 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
))
11790 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
11793 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
11798 static const char *
11799 get_symbol_visibility (unsigned int visibility
)
11801 switch (visibility
)
11803 case STV_DEFAULT
: return "DEFAULT";
11804 case STV_INTERNAL
: return "INTERNAL";
11805 case STV_HIDDEN
: return "HIDDEN";
11806 case STV_PROTECTED
: return "PROTECTED";
11808 error (_("Unrecognized visibility value: %u\n"), visibility
);
11809 return _("<unknown>");
11813 static const char *
11814 get_alpha_symbol_other (unsigned int other
)
11818 case STO_ALPHA_NOPV
: return "NOPV";
11819 case STO_ALPHA_STD_GPLOAD
: return "STD GPLOAD";
11821 error (_("Unrecognized alpha specific other value: %u\n"), other
);
11822 return _("<unknown>");
11826 static const char *
11827 get_solaris_symbol_visibility (unsigned int visibility
)
11829 switch (visibility
)
11831 case 4: return "EXPORTED";
11832 case 5: return "SINGLETON";
11833 case 6: return "ELIMINATE";
11834 default: return get_symbol_visibility (visibility
);
11838 static const char *
11839 get_aarch64_symbol_other (unsigned int other
)
11841 static char buf
[32];
11843 if (other
& STO_AARCH64_VARIANT_PCS
)
11845 other
&= ~STO_AARCH64_VARIANT_PCS
;
11847 return "VARIANT_PCS";
11848 snprintf (buf
, sizeof buf
, "VARIANT_PCS | %x", other
);
11854 static const char *
11855 get_mips_symbol_other (unsigned int other
)
11859 case STO_OPTIONAL
: return "OPTIONAL";
11860 case STO_MIPS_PLT
: return "MIPS PLT";
11861 case STO_MIPS_PIC
: return "MIPS PIC";
11862 case STO_MICROMIPS
: return "MICROMIPS";
11863 case STO_MICROMIPS
| STO_MIPS_PIC
: return "MICROMIPS, MIPS PIC";
11864 case STO_MIPS16
: return "MIPS16";
11865 default: return NULL
;
11869 static const char *
11870 get_ia64_symbol_other (Filedata
* filedata
, unsigned int other
)
11872 if (is_ia64_vms (filedata
))
11874 static char res
[32];
11878 /* Function types is for images and .STB files only. */
11879 switch (filedata
->file_header
.e_type
)
11883 switch (VMS_ST_FUNC_TYPE (other
))
11885 case VMS_SFT_CODE_ADDR
:
11886 strcat (res
, " CA");
11888 case VMS_SFT_SYMV_IDX
:
11889 strcat (res
, " VEC");
11892 strcat (res
, " FD");
11894 case VMS_SFT_RESERVE
:
11895 strcat (res
, " RSV");
11898 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
11899 VMS_ST_FUNC_TYPE (other
));
11900 strcat (res
, " <unknown>");
11907 switch (VMS_ST_LINKAGE (other
))
11909 case VMS_STL_IGNORE
:
11910 strcat (res
, " IGN");
11912 case VMS_STL_RESERVE
:
11913 strcat (res
, " RSV");
11916 strcat (res
, " STD");
11919 strcat (res
, " LNK");
11922 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
11923 VMS_ST_LINKAGE (other
));
11924 strcat (res
, " <unknown>");
11936 static const char *
11937 get_ppc64_symbol_other (unsigned int other
)
11939 if ((other
& ~STO_PPC64_LOCAL_MASK
) != 0)
11942 other
>>= STO_PPC64_LOCAL_BIT
;
11945 static char buf
[64];
11947 other
= ppc64_decode_local_entry (other
);
11948 snprintf (buf
, sizeof buf
, _("<localentry>: %d"), other
);
11954 static const char *
11955 get_symbol_other (Filedata
* filedata
, unsigned int other
)
11957 const char * result
= NULL
;
11958 static char buff
[64];
11963 switch (filedata
->file_header
.e_machine
)
11966 result
= get_alpha_symbol_other (other
);
11969 result
= get_aarch64_symbol_other (other
);
11972 result
= get_mips_symbol_other (other
);
11975 result
= get_ia64_symbol_other (filedata
, other
);
11978 result
= get_ppc64_symbol_other (other
);
11988 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
11992 static const char *
11993 get_symbol_index_type (Filedata
* filedata
, unsigned int type
)
11995 static char buff
[32];
11999 case SHN_UNDEF
: return "UND";
12000 case SHN_ABS
: return "ABS";
12001 case SHN_COMMON
: return "COM";
12003 if (type
== SHN_IA_64_ANSI_COMMON
12004 && filedata
->file_header
.e_machine
== EM_IA_64
12005 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
12007 else if ((filedata
->file_header
.e_machine
== EM_X86_64
12008 || filedata
->file_header
.e_machine
== EM_L1OM
12009 || filedata
->file_header
.e_machine
== EM_K1OM
)
12010 && type
== SHN_X86_64_LCOMMON
)
12011 return "LARGE_COM";
12012 else if ((type
== SHN_MIPS_SCOMMON
12013 && filedata
->file_header
.e_machine
== EM_MIPS
)
12014 || (type
== SHN_TIC6X_SCOMMON
12015 && filedata
->file_header
.e_machine
== EM_TI_C6000
))
12017 else if (type
== SHN_MIPS_SUNDEFINED
12018 && filedata
->file_header
.e_machine
== EM_MIPS
)
12020 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
12021 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
12022 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
12023 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
12024 else if (type
>= SHN_LORESERVE
)
12025 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
12026 else if (filedata
->file_header
.e_shnum
!= 0
12027 && type
>= filedata
->file_header
.e_shnum
)
12028 sprintf (buff
, _("bad section index[%3d]"), type
);
12030 sprintf (buff
, "%3d", type
);
12037 static const char *
12038 get_symbol_version_string (Filedata
* filedata
,
12039 bfd_boolean is_dynsym
,
12040 const char * strtab
,
12041 unsigned long int strtab_size
,
12043 Elf_Internal_Sym
* psym
,
12044 enum versioned_symbol_info
* sym_info
,
12045 unsigned short * vna_other
)
12047 unsigned char data
[2];
12048 unsigned short vers_data
;
12049 unsigned long offset
;
12050 unsigned short max_vd_ndx
;
12053 || filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
12056 offset
= offset_from_vma (filedata
,
12057 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
12058 sizeof data
+ si
* sizeof (vers_data
));
12060 if (get_data (&data
, filedata
, offset
+ si
* sizeof (vers_data
),
12061 sizeof (data
), 1, _("version data")) == NULL
)
12064 vers_data
= byte_get (data
, 2);
12066 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
== 0)
12069 *sym_info
= (vers_data
& VERSYM_HIDDEN
) != 0 ? symbol_hidden
: symbol_public
;
12072 /* Usually we'd only see verdef for defined symbols, and verneed for
12073 undefined symbols. However, symbols defined by the linker in
12074 .dynbss for variables copied from a shared library in order to
12075 avoid text relocations are defined yet have verneed. We could
12076 use a heuristic to detect the special case, for example, check
12077 for verneed first on symbols defined in SHT_NOBITS sections, but
12078 it is simpler and more reliable to just look for both verdef and
12079 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
12081 if (psym
->st_shndx
!= SHN_UNDEF
12082 && vers_data
!= 0x8001
12083 && filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
12085 Elf_Internal_Verdef ivd
;
12086 Elf_Internal_Verdaux ivda
;
12087 Elf_External_Verdaux evda
;
12090 off
= offset_from_vma (filedata
,
12091 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
12092 sizeof (Elf_External_Verdef
));
12096 Elf_External_Verdef evd
;
12098 if (get_data (&evd
, filedata
, off
, sizeof (evd
), 1,
12099 _("version def")) == NULL
)
12108 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
12109 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
12110 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
12111 ivd
.vd_flags
= BYTE_GET (evd
.vd_flags
);
12114 if ((ivd
.vd_ndx
& VERSYM_VERSION
) > max_vd_ndx
)
12115 max_vd_ndx
= ivd
.vd_ndx
& VERSYM_VERSION
;
12117 off
+= ivd
.vd_next
;
12119 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
12121 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
12123 if (ivd
.vd_ndx
== 1 && ivd
.vd_flags
== VER_FLG_BASE
)
12126 off
-= ivd
.vd_next
;
12129 if (get_data (&evda
, filedata
, off
, sizeof (evda
), 1,
12130 _("version def aux")) != NULL
)
12132 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
12134 if (psym
->st_name
!= ivda
.vda_name
)
12135 return (ivda
.vda_name
< strtab_size
12136 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
12141 if (filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
12143 Elf_External_Verneed evn
;
12144 Elf_Internal_Verneed ivn
;
12145 Elf_Internal_Vernaux ivna
;
12147 offset
= offset_from_vma (filedata
,
12148 filedata
->version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
12152 unsigned long vna_off
;
12154 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
12155 _("version need")) == NULL
)
12158 ivna
.vna_other
= 0;
12163 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
12164 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
12166 vna_off
= offset
+ ivn
.vn_aux
;
12170 Elf_External_Vernaux evna
;
12172 if (get_data (&evna
, filedata
, vna_off
, sizeof (evna
), 1,
12173 _("version need aux (3)")) == NULL
)
12176 ivna
.vna_other
= 0;
12181 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
12182 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
12183 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
12186 vna_off
+= ivna
.vna_next
;
12188 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
12190 if (ivna
.vna_other
== vers_data
)
12193 offset
+= ivn
.vn_next
;
12195 while (ivn
.vn_next
!= 0);
12197 if (ivna
.vna_other
== vers_data
)
12199 *sym_info
= symbol_undefined
;
12200 *vna_other
= ivna
.vna_other
;
12201 return (ivna
.vna_name
< strtab_size
12202 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
12204 else if ((max_vd_ndx
|| (vers_data
& VERSYM_VERSION
) != 1)
12205 && (vers_data
& VERSYM_VERSION
) > max_vd_ndx
)
12206 return _("<corrupt>");
12212 print_dynamic_symbol (Filedata
*filedata
, unsigned long si
,
12213 Elf_Internal_Sym
*symtab
,
12214 Elf_Internal_Shdr
*section
,
12215 char *strtab
, size_t strtab_size
)
12217 const char *version_string
;
12218 enum versioned_symbol_info sym_info
;
12219 unsigned short vna_other
;
12220 Elf_Internal_Sym
*psym
= symtab
+ si
;
12222 printf ("%6ld: ", si
);
12223 print_vma (psym
->st_value
, LONG_HEX
);
12225 print_vma (psym
->st_size
, DEC_5
);
12226 printf (" %-7s", get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)));
12227 printf (" %-6s", get_symbol_binding (filedata
, ELF_ST_BIND (psym
->st_info
)));
12228 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
12229 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
12232 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
12234 printf (" %-7s", get_symbol_visibility (vis
));
12235 /* Check to see if any other bits in the st_other field are set.
12236 Note - displaying this information disrupts the layout of the
12237 table being generated, but for the moment this case is very rare. */
12238 if (psym
->st_other
^ vis
)
12239 printf (" [%s] ", get_symbol_other (filedata
, psym
->st_other
^ vis
));
12241 printf (" %4s ", get_symbol_index_type (filedata
, psym
->st_shndx
));
12243 bfd_boolean is_valid
= VALID_SYMBOL_NAME (strtab
, strtab_size
,
12245 const char * sstr
= is_valid
? strtab
+ psym
->st_name
: _("<corrupt>");
12248 = get_symbol_version_string (filedata
,
12250 || section
->sh_type
== SHT_DYNSYM
),
12251 strtab
, strtab_size
, si
,
12252 psym
, &sym_info
, &vna_other
);
12254 int len_avail
= 21;
12255 if (! do_wide
&& version_string
!= NULL
)
12259 len_avail
-= 1 + strlen (version_string
);
12261 if (sym_info
== symbol_undefined
)
12262 len_avail
-= sprintf (buffer
," (%d)", vna_other
);
12263 else if (sym_info
!= symbol_hidden
)
12267 print_symbol (len_avail
, sstr
);
12269 if (version_string
)
12271 if (sym_info
== symbol_undefined
)
12272 printf ("@%s (%d)", version_string
, vna_other
);
12274 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
12280 if (ELF_ST_BIND (psym
->st_info
) == STB_LOCAL
12282 && si
>= section
->sh_info
12283 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
12284 && filedata
->file_header
.e_machine
!= EM_MIPS
12285 /* Solaris binaries have been found to violate this requirement as
12286 well. Not sure if this is a bug or an ABI requirement. */
12287 && filedata
->file_header
.e_ident
[EI_OSABI
] != ELFOSABI_SOLARIS
)
12288 warn (_("local symbol %lu found at index >= %s's sh_info value of %u\n"),
12289 si
, printable_section_name (filedata
, section
), section
->sh_info
);
12292 static const char *
12293 get_lto_kind (unsigned int kind
)
12297 case 0: return "DEF";
12298 case 1: return "WEAKDEF";
12299 case 2: return "UNDEF";
12300 case 3: return "WEAKUNDEF";
12301 case 4: return "COMMON";
12306 static char buffer
[30];
12307 error (_("Unknown LTO symbol definition encountered: %u\n"), kind
);
12308 sprintf (buffer
, "<unknown: %u>", kind
);
12312 static const char *
12313 get_lto_visibility (unsigned int visibility
)
12315 switch (visibility
)
12317 case 0: return "DEFAULT";
12318 case 1: return "PROTECTED";
12319 case 2: return "INTERNAL";
12320 case 3: return "HIDDEN";
12325 static char buffer
[30];
12326 error (_("Unknown LTO symbol visibility encountered: %u\n"), visibility
);
12327 sprintf (buffer
, "<unknown: %u>", visibility
);
12331 static const char *
12332 get_lto_sym_type (unsigned int sym_type
)
12336 case 0: return "UNKNOWN";
12337 case 1: return "FUNCTION";
12338 case 2: return "VARIABLE";
12343 static char buffer
[30];
12344 error (_("Unknown LTO symbol type encountered: %u\n"), sym_type
);
12345 sprintf (buffer
, "<unknown: %u>", sym_type
);
12349 /* Display an LTO format symbol table.
12350 FIXME: The format of LTO symbol tables is not formalized.
12351 So this code could need changing in the future. */
12354 display_lto_symtab (Filedata
* filedata
,
12355 Elf_Internal_Shdr
* section
)
12357 if (section
->sh_size
== 0)
12359 printf (_("\nLTO Symbol table '%s' is empty!\n"),
12360 printable_section_name (filedata
, section
));
12364 if (section
->sh_size
> filedata
->file_size
)
12366 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
12367 printable_section_name (filedata
, section
),
12368 (unsigned long) section
->sh_size
);
12372 void * alloced_data
= get_data (NULL
, filedata
, section
->sh_offset
,
12373 section
->sh_size
, 1, _("LTO symbols"));
12374 if (alloced_data
== NULL
)
12377 /* Look for extended data for the symbol table. */
12378 Elf_Internal_Shdr
* ext
;
12379 void * ext_data_orig
= NULL
;
12380 char * ext_data
= NULL
;
12381 char * ext_data_end
= NULL
;
12382 char * ext_name
= NULL
;
12384 if (asprintf (& ext_name
, ".gnu.lto_.ext_symtab.%s",
12385 SECTION_NAME (section
) + sizeof (".gnu.lto_.symtab.") - 1) > 0
12386 && ext_name
!= NULL
/* Paranoia. */
12387 && (ext
= find_section (filedata
, ext_name
)) != NULL
)
12389 if (ext
->sh_size
< 3)
12390 error (_("LTO Symbol extension table '%s' is empty!\n"),
12391 printable_section_name (filedata
, ext
));
12394 ext_data_orig
= ext_data
= get_data (NULL
, filedata
, ext
->sh_offset
,
12396 _("LTO ext symbol data"));
12397 if (ext_data
!= NULL
)
12399 ext_data_end
= ext_data
+ ext
->sh_size
;
12400 if (* ext_data
++ != 1)
12401 error (_("Unexpected version number in symbol extension table\n"));
12406 const unsigned char * data
= (const unsigned char *) alloced_data
;
12407 const unsigned char * end
= data
+ section
->sh_size
;
12409 if (ext_data_orig
!= NULL
)
12412 printf (_("\nLTO Symbol table '%s' and extension table '%s' contain:\n"),
12413 printable_section_name (filedata
, section
),
12414 printable_section_name (filedata
, ext
));
12417 printf (_("\nLTO Symbol table '%s'\n"),
12418 printable_section_name (filedata
, section
));
12419 printf (_(" and extension table '%s' contain:\n"),
12420 printable_section_name (filedata
, ext
));
12424 printf (_("\nLTO Symbol table '%s' contains:\n"),
12425 printable_section_name (filedata
, section
));
12428 /* FIXME: Add a wide version. */
12429 if (ext_data_orig
!= NULL
)
12430 printf (_(" Comdat_Key Kind Visibility Size Slot Type Section Name\n"));
12432 printf (_(" Comdat_Key Kind Visibility Size Slot Name\n"));
12434 /* FIXME: We do not handle style prefixes. */
12438 const unsigned char * sym_name
= data
;
12439 data
+= strnlen ((const char *) sym_name
, end
- data
) + 1;
12443 const unsigned char * comdat_key
= data
;
12444 data
+= strnlen ((const char *) comdat_key
, end
- data
) + 1;
12448 if (data
+ 2 + 8 + 4 > end
)
12451 unsigned int kind
= *data
++;
12452 unsigned int visibility
= *data
++;
12454 elf_vma size
= byte_get (data
, 8);
12457 elf_vma slot
= byte_get (data
, 4);
12460 if (ext_data
!= NULL
)
12462 if (ext_data
< (ext_data_end
- 1))
12464 unsigned int sym_type
= * ext_data
++;
12465 unsigned int sec_kind
= * ext_data
++;
12467 printf (" %10s %10s %11s %08lx %08lx %9s %08lx _",
12468 * comdat_key
== 0 ? "-" : (char *) comdat_key
,
12469 get_lto_kind (kind
),
12470 get_lto_visibility (visibility
),
12473 get_lto_sym_type (sym_type
),
12475 print_symbol (6, (const char *) sym_name
);
12479 error (_("Ran out of LTO symbol extension data\n"));
12481 /* FIXME: return FAIL result ? */
12486 printf (" %10s %10s %11s %08lx %08lx _",
12487 * comdat_key
== 0 ? "-" : (char *) comdat_key
,
12488 get_lto_kind (kind
),
12489 get_lto_visibility (visibility
),
12492 print_symbol (21, (const char *) sym_name
);
12497 if (ext_data
!= NULL
&& ext_data
< ext_data_end
)
12499 error (_("Data remains in the LTO symbol extension table\n"));
12503 free (alloced_data
);
12504 free (ext_data_orig
);
12509 error (_("Buffer overrun encountered whilst decoding LTO symbol table\n"));
12510 free (alloced_data
);
12511 free (ext_data_orig
);
12516 /* Display LTO symbol tables. */
12519 process_lto_symbol_tables (Filedata
* filedata
)
12521 Elf_Internal_Shdr
* section
;
12523 bfd_boolean res
= TRUE
;
12528 if (filedata
->section_headers
== NULL
)
12531 for (i
= 0, section
= filedata
->section_headers
;
12532 i
< filedata
->file_header
.e_shnum
;
12534 if (SECTION_NAME_VALID (section
)
12535 && CONST_STRNEQ (SECTION_NAME (section
), ".gnu.lto_.symtab."))
12536 res
&= display_lto_symtab (filedata
, section
);
12541 /* Dump the symbol table. */
12544 process_symbol_table (Filedata
* filedata
)
12546 Elf_Internal_Shdr
* section
;
12548 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
12551 if ((filedata
->dynamic_info
[DT_HASH
] || filedata
->dynamic_info_DT_GNU_HASH
)
12553 && do_using_dynamic
12554 && filedata
->dynamic_strings
!= NULL
12555 && filedata
->dynamic_symbols
!= NULL
)
12559 printf (ngettext ("\nSymbol table for image contains %lu entry:\n",
12560 "\nSymbol table for image contains %lu entries:\n",
12561 filedata
->num_dynamic_syms
),
12562 filedata
->num_dynamic_syms
);
12564 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12566 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12568 for (si
= 0; si
< filedata
->num_dynamic_syms
; si
++)
12569 print_dynamic_symbol (filedata
, si
, filedata
->dynamic_symbols
, NULL
,
12570 filedata
->dynamic_strings
,
12571 filedata
->dynamic_strings_length
);
12573 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
12574 && filedata
->section_headers
!= NULL
)
12578 for (i
= 0, section
= filedata
->section_headers
;
12579 i
< filedata
->file_header
.e_shnum
;
12582 char * strtab
= NULL
;
12583 unsigned long int strtab_size
= 0;
12584 Elf_Internal_Sym
* symtab
;
12585 unsigned long si
, num_syms
;
12587 if ((section
->sh_type
!= SHT_SYMTAB
12588 && section
->sh_type
!= SHT_DYNSYM
)
12590 && section
->sh_type
== SHT_SYMTAB
))
12593 if (section
->sh_entsize
== 0)
12595 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
12596 printable_section_name (filedata
, section
));
12600 num_syms
= section
->sh_size
/ section
->sh_entsize
;
12601 printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
12602 "\nSymbol table '%s' contains %lu entries:\n",
12604 printable_section_name (filedata
, section
),
12608 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12610 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
12612 symtab
= GET_ELF_SYMBOLS (filedata
, section
, & num_syms
);
12613 if (symtab
== NULL
)
12616 if (section
->sh_link
== filedata
->file_header
.e_shstrndx
)
12618 strtab
= filedata
->string_table
;
12619 strtab_size
= filedata
->string_table_length
;
12621 else if (section
->sh_link
< filedata
->file_header
.e_shnum
)
12623 Elf_Internal_Shdr
* string_sec
;
12625 string_sec
= filedata
->section_headers
+ section
->sh_link
;
12627 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
,
12628 1, string_sec
->sh_size
,
12629 _("string table"));
12630 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
12633 for (si
= 0; si
< num_syms
; si
++)
12634 print_dynamic_symbol (filedata
, si
, symtab
, section
,
12635 strtab
, strtab_size
);
12638 if (strtab
!= filedata
->string_table
)
12644 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
12646 if (do_histogram
&& filedata
->buckets
!= NULL
)
12648 unsigned long * lengths
;
12649 unsigned long * counts
;
12652 unsigned long maxlength
= 0;
12653 unsigned long nzero_counts
= 0;
12654 unsigned long nsyms
= 0;
12657 printf (ngettext ("\nHistogram for bucket list length "
12658 "(total of %lu bucket):\n",
12659 "\nHistogram for bucket list length "
12660 "(total of %lu buckets):\n",
12661 (unsigned long) filedata
->nbuckets
),
12662 (unsigned long) filedata
->nbuckets
);
12664 lengths
= (unsigned long *) calloc (filedata
->nbuckets
,
12665 sizeof (*lengths
));
12666 if (lengths
== NULL
)
12668 error (_("Out of memory allocating space for histogram buckets\n"));
12671 visited
= xcmalloc (filedata
->nchains
, 1);
12672 memset (visited
, 0, filedata
->nchains
);
12674 printf (_(" Length Number %% of total Coverage\n"));
12675 for (hn
= 0; hn
< filedata
->nbuckets
; ++hn
)
12677 for (si
= filedata
->buckets
[hn
]; si
> 0; si
= filedata
->chains
[si
])
12680 if (maxlength
< ++lengths
[hn
])
12682 if (si
>= filedata
->nchains
|| visited
[si
])
12684 error (_("histogram chain is corrupt\n"));
12692 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
12693 if (counts
== NULL
)
12696 error (_("Out of memory allocating space for histogram counts\n"));
12700 for (hn
= 0; hn
< filedata
->nbuckets
; ++hn
)
12701 ++counts
[lengths
[hn
]];
12703 if (filedata
->nbuckets
> 0)
12706 printf (" 0 %-10lu (%5.1f%%)\n",
12707 counts
[0], (counts
[0] * 100.0) / filedata
->nbuckets
);
12708 for (i
= 1; i
<= maxlength
; ++i
)
12710 nzero_counts
+= counts
[i
] * i
;
12711 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
12712 i
, counts
[i
], (counts
[i
] * 100.0) / filedata
->nbuckets
,
12713 (nzero_counts
* 100.0) / nsyms
);
12721 free (filedata
->buckets
);
12722 filedata
->buckets
= NULL
;
12723 filedata
->nbuckets
= 0;
12724 free (filedata
->chains
);
12725 filedata
->chains
= NULL
;
12727 if (do_histogram
&& filedata
->gnubuckets
!= NULL
)
12729 unsigned long * lengths
;
12730 unsigned long * counts
;
12732 unsigned long maxlength
= 0;
12733 unsigned long nzero_counts
= 0;
12734 unsigned long nsyms
= 0;
12736 printf (ngettext ("\nHistogram for `%s' bucket list length "
12737 "(total of %lu bucket):\n",
12738 "\nHistogram for `%s' bucket list length "
12739 "(total of %lu buckets):\n",
12740 (unsigned long) filedata
->ngnubuckets
),
12741 GNU_HASH_SECTION_NAME (filedata
),
12742 (unsigned long) filedata
->ngnubuckets
);
12744 lengths
= (unsigned long *) calloc (filedata
->ngnubuckets
,
12745 sizeof (*lengths
));
12746 if (lengths
== NULL
)
12748 error (_("Out of memory allocating space for gnu histogram buckets\n"));
12752 printf (_(" Length Number %% of total Coverage\n"));
12754 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
12755 if (filedata
->gnubuckets
[hn
] != 0)
12757 bfd_vma off
, length
= 1;
12759 for (off
= filedata
->gnubuckets
[hn
] - filedata
->gnusymidx
;
12760 /* PR 17531 file: 010-77222-0.004. */
12761 off
< filedata
->ngnuchains
12762 && (filedata
->gnuchains
[off
] & 1) == 0;
12765 lengths
[hn
] = length
;
12766 if (length
> maxlength
)
12767 maxlength
= length
;
12771 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
12772 if (counts
== NULL
)
12775 error (_("Out of memory allocating space for gnu histogram counts\n"));
12779 for (hn
= 0; hn
< filedata
->ngnubuckets
; ++hn
)
12780 ++counts
[lengths
[hn
]];
12782 if (filedata
->ngnubuckets
> 0)
12785 printf (" 0 %-10lu (%5.1f%%)\n",
12786 counts
[0], (counts
[0] * 100.0) / filedata
->ngnubuckets
);
12787 for (j
= 1; j
<= maxlength
; ++j
)
12789 nzero_counts
+= counts
[j
] * j
;
12790 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
12791 j
, counts
[j
], (counts
[j
] * 100.0) / filedata
->ngnubuckets
,
12792 (nzero_counts
* 100.0) / nsyms
);
12799 free (filedata
->gnubuckets
);
12800 filedata
->gnubuckets
= NULL
;
12801 filedata
->ngnubuckets
= 0;
12802 free (filedata
->gnuchains
);
12803 filedata
->gnuchains
= NULL
;
12804 filedata
->ngnuchains
= 0;
12805 free (filedata
->mipsxlat
);
12806 filedata
->mipsxlat
= NULL
;
12810 free (filedata
->gnubuckets
);
12811 filedata
->gnubuckets
= NULL
;
12812 filedata
->ngnubuckets
= 0;
12813 free (filedata
->gnuchains
);
12814 filedata
->gnuchains
= NULL
;
12815 filedata
->ngnuchains
= 0;
12816 free (filedata
->mipsxlat
);
12817 filedata
->mipsxlat
= NULL
;
12818 free (filedata
->buckets
);
12819 filedata
->buckets
= NULL
;
12820 filedata
->nbuckets
= 0;
12821 free (filedata
->chains
);
12822 filedata
->chains
= NULL
;
12827 process_syminfo (Filedata
* filedata ATTRIBUTE_UNUSED
)
12831 if (filedata
->dynamic_syminfo
== NULL
12833 /* No syminfo, this is ok. */
12836 /* There better should be a dynamic symbol section. */
12837 if (filedata
->dynamic_symbols
== NULL
|| filedata
->dynamic_strings
== NULL
)
12840 if (filedata
->dynamic_addr
)
12841 printf (ngettext ("\nDynamic info segment at offset 0x%lx "
12842 "contains %d entry:\n",
12843 "\nDynamic info segment at offset 0x%lx "
12844 "contains %d entries:\n",
12845 filedata
->dynamic_syminfo_nent
),
12846 filedata
->dynamic_syminfo_offset
, filedata
->dynamic_syminfo_nent
);
12848 printf (_(" Num: Name BoundTo Flags\n"));
12849 for (i
= 0; i
< filedata
->dynamic_syminfo_nent
; ++i
)
12851 unsigned short int flags
= filedata
->dynamic_syminfo
[i
].si_flags
;
12853 printf ("%4d: ", i
);
12854 if (i
>= filedata
->num_dynamic_syms
)
12855 printf (_("<corrupt index>"));
12856 else if (VALID_DYNAMIC_NAME (filedata
, filedata
->dynamic_symbols
[i
].st_name
))
12857 print_symbol (30, GET_DYNAMIC_NAME (filedata
,
12858 filedata
->dynamic_symbols
[i
].st_name
));
12860 printf (_("<corrupt: %19ld>"), filedata
->dynamic_symbols
[i
].st_name
);
12863 switch (filedata
->dynamic_syminfo
[i
].si_boundto
)
12865 case SYMINFO_BT_SELF
:
12866 fputs ("SELF ", stdout
);
12868 case SYMINFO_BT_PARENT
:
12869 fputs ("PARENT ", stdout
);
12872 if (filedata
->dynamic_syminfo
[i
].si_boundto
> 0
12873 && filedata
->dynamic_syminfo
[i
].si_boundto
< filedata
->dynamic_nent
12874 && VALID_DYNAMIC_NAME (filedata
,
12875 filedata
->dynamic_section
[filedata
->dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
12877 print_symbol (10, GET_DYNAMIC_NAME (filedata
,
12878 filedata
->dynamic_section
[filedata
->dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
12882 printf ("%-10d ", filedata
->dynamic_syminfo
[i
].si_boundto
);
12886 if (flags
& SYMINFO_FLG_DIRECT
)
12887 printf (" DIRECT");
12888 if (flags
& SYMINFO_FLG_PASSTHRU
)
12889 printf (" PASSTHRU");
12890 if (flags
& SYMINFO_FLG_COPY
)
12892 if (flags
& SYMINFO_FLG_LAZYLOAD
)
12893 printf (" LAZYLOAD");
12901 /* A macro which evaluates to TRUE if the region ADDR .. ADDR + NELEM
12902 is contained by the region START .. END. The types of ADDR, START
12903 and END should all be the same. Note both ADDR + NELEM and END
12904 point to just beyond the end of the regions that are being tested. */
12905 #define IN_RANGE(START,END,ADDR,NELEM) \
12906 (((ADDR) >= (START)) && ((ADDR) < (END)) && ((ADDR) + (NELEM) <= (END)))
12908 /* Check to see if the given reloc needs to be handled in a target specific
12909 manner. If so then process the reloc and return TRUE otherwise return
12912 If called with reloc == NULL, then this is a signal that reloc processing
12913 for the current section has finished, and any saved state should be
12917 target_specific_reloc_handling (Filedata
* filedata
,
12918 Elf_Internal_Rela
* reloc
,
12919 unsigned char * start
,
12920 unsigned char * end
,
12921 Elf_Internal_Sym
* symtab
,
12922 unsigned long num_syms
)
12924 unsigned int reloc_type
= 0;
12925 unsigned long sym_index
= 0;
12929 reloc_type
= get_reloc_type (filedata
, reloc
->r_info
);
12930 sym_index
= get_reloc_symindex (reloc
->r_info
);
12933 switch (filedata
->file_header
.e_machine
)
12936 case EM_MSP430_OLD
:
12938 static Elf_Internal_Sym
* saved_sym
= NULL
;
12946 switch (reloc_type
)
12948 case 10: /* R_MSP430_SYM_DIFF */
12949 case 12: /* R_MSP430_GNU_SUB_ULEB128 */
12950 if (uses_msp430x_relocs (filedata
))
12952 /* Fall through. */
12953 case 21: /* R_MSP430X_SYM_DIFF */
12954 case 23: /* R_MSP430X_GNU_SUB_ULEB128 */
12956 if (sym_index
>= num_syms
)
12957 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
12960 saved_sym
= symtab
+ sym_index
;
12963 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
12964 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
12965 goto handle_sym_diff
;
12967 case 5: /* R_MSP430_16_BYTE */
12968 case 9: /* R_MSP430_8 */
12969 case 11: /* R_MSP430_GNU_SET_ULEB128 */
12970 if (uses_msp430x_relocs (filedata
))
12972 goto handle_sym_diff
;
12974 case 2: /* R_MSP430_ABS16 */
12975 case 15: /* R_MSP430X_ABS16 */
12976 case 22: /* R_MSP430X_GNU_SET_ULEB128 */
12977 if (! uses_msp430x_relocs (filedata
))
12979 goto handle_sym_diff
;
12982 if (saved_sym
!= NULL
)
12985 unsigned int reloc_size
= 0;
12987 switch (reloc_type
)
12989 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
12992 case 11: /* R_MSP430_GNU_SET_ULEB128 */
12993 case 22: /* R_MSP430X_GNU_SET_ULEB128 */
12994 if (reloc
->r_offset
< (size_t) (end
- start
))
12995 read_leb128 (start
+ reloc
->r_offset
, end
, FALSE
,
12996 &reloc_size
, &leb_ret
);
13003 if (leb_ret
!= 0 || reloc_size
== 0 || reloc_size
> 8)
13004 error (_("MSP430 ULEB128 field at 0x%lx contains invalid "
13005 "ULEB128 value\n"),
13006 (long) reloc
->r_offset
);
13007 else if (sym_index
>= num_syms
)
13008 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
13012 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
13013 - saved_sym
->st_value
);
13015 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
13016 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
13019 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
13020 (long) reloc
->r_offset
);
13029 if (saved_sym
!= NULL
)
13030 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
13037 case EM_CYGNUS_MN10300
:
13039 static Elf_Internal_Sym
* saved_sym
= NULL
;
13047 switch (reloc_type
)
13049 case 34: /* R_MN10300_ALIGN */
13051 case 33: /* R_MN10300_SYM_DIFF */
13052 if (sym_index
>= num_syms
)
13053 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
13056 saved_sym
= symtab
+ sym_index
;
13059 case 1: /* R_MN10300_32 */
13060 case 2: /* R_MN10300_16 */
13061 if (saved_sym
!= NULL
)
13063 int reloc_size
= reloc_type
== 1 ? 4 : 2;
13066 if (sym_index
>= num_syms
)
13067 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
13071 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
13072 - saved_sym
->st_value
);
13074 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
13075 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
13077 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
13078 (long) reloc
->r_offset
);
13086 if (saved_sym
!= NULL
)
13087 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
13095 static bfd_vma saved_sym1
= 0;
13096 static bfd_vma saved_sym2
= 0;
13097 static bfd_vma value
;
13101 saved_sym1
= saved_sym2
= 0;
13105 switch (reloc_type
)
13107 case 0x80: /* R_RL78_SYM. */
13108 saved_sym1
= saved_sym2
;
13109 if (sym_index
>= num_syms
)
13110 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
13114 saved_sym2
= symtab
[sym_index
].st_value
;
13115 saved_sym2
+= reloc
->r_addend
;
13119 case 0x83: /* R_RL78_OPsub. */
13120 value
= saved_sym1
- saved_sym2
;
13121 saved_sym2
= saved_sym1
= 0;
13125 case 0x41: /* R_RL78_ABS32. */
13126 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 4))
13127 byte_put (start
+ reloc
->r_offset
, value
, 4);
13129 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
13130 (long) reloc
->r_offset
);
13134 case 0x43: /* R_RL78_ABS16. */
13135 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 2))
13136 byte_put (start
+ reloc
->r_offset
, value
, 2);
13138 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
13139 (long) reloc
->r_offset
);
13153 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
13154 DWARF debug sections. This is a target specific test. Note - we do not
13155 go through the whole including-target-headers-multiple-times route, (as
13156 we have already done with <elf/h8.h>) because this would become very
13157 messy and even then this function would have to contain target specific
13158 information (the names of the relocs instead of their numeric values).
13159 FIXME: This is not the correct way to solve this problem. The proper way
13160 is to have target specific reloc sizing and typing functions created by
13161 the reloc-macros.h header, in the same way that it already creates the
13162 reloc naming functions. */
13165 is_32bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13167 /* Please keep this table alpha-sorted for ease of visual lookup. */
13168 switch (filedata
->file_header
.e_machine
)
13172 return reloc_type
== 1; /* R_386_32. */
13174 return reloc_type
== 1; /* R_68K_32. */
13176 return reloc_type
== 1; /* R_860_32. */
13178 return reloc_type
== 2; /* R_960_32. */
13180 return (reloc_type
== 258
13181 || reloc_type
== 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
13183 return reloc_type
== 11; /* R_BPF_DATA_32 */
13184 case EM_ADAPTEVA_EPIPHANY
:
13185 return reloc_type
== 3;
13187 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
13189 return reloc_type
== 1; /* R_ARC_32. */
13190 case EM_ARC_COMPACT
:
13191 case EM_ARC_COMPACT2
:
13192 return reloc_type
== 4; /* R_ARC_32. */
13194 return reloc_type
== 2; /* R_ARM_ABS32 */
13197 return reloc_type
== 1;
13199 return reloc_type
== 0x12; /* R_byte4_data. */
13201 return reloc_type
== 3; /* R_CRIS_32. */
13203 return reloc_type
== 3; /* R_CR16_NUM32. */
13205 return reloc_type
== 15; /* R_CRX_NUM32. */
13207 return reloc_type
== 1; /* R_CKCORE_ADDR32. */
13208 case EM_CYGNUS_FRV
:
13209 return reloc_type
== 1;
13210 case EM_CYGNUS_D10V
:
13212 return reloc_type
== 6; /* R_D10V_32. */
13213 case EM_CYGNUS_D30V
:
13215 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
13217 return reloc_type
== 3; /* R_DLX_RELOC_32. */
13218 case EM_CYGNUS_FR30
:
13220 return reloc_type
== 3; /* R_FR30_32. */
13222 return reloc_type
== 1; /* R_FT32_32. */
13226 return reloc_type
== 1; /* R_H8_DIR32. */
13228 return (reloc_type
== 0x64 /* R_IA64_SECREL32MSB. */
13229 || reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
13230 || reloc_type
== 0x24 /* R_IA64_DIR32MSB. */
13231 || reloc_type
== 0x25 /* R_IA64_DIR32LSB. */);
13234 return reloc_type
== 2; /* R_IP2K_32. */
13236 return reloc_type
== 2; /* R_IQ2000_32. */
13237 case EM_LATTICEMICO32
:
13238 return reloc_type
== 3; /* R_LM32_32. */
13241 return reloc_type
== 3; /* R_M32C_32. */
13243 return reloc_type
== 34; /* R_M32R_32_RELA. */
13246 return reloc_type
== 6; /* R_M68HC11_32. */
13248 return reloc_type
== 7 || /* R_S12Z_EXT32 */
13249 reloc_type
== 6; /* R_S12Z_CW32. */
13251 return reloc_type
== 1; /* R_MCORE_ADDR32. */
13252 case EM_CYGNUS_MEP
:
13253 return reloc_type
== 4; /* R_MEP_32. */
13255 return reloc_type
== 2; /* R_METAG_ADDR32. */
13256 case EM_MICROBLAZE
:
13257 return reloc_type
== 1; /* R_MICROBLAZE_32. */
13259 return reloc_type
== 2; /* R_MIPS_32. */
13261 return reloc_type
== 4; /* R_MMIX_32. */
13262 case EM_CYGNUS_MN10200
:
13264 return reloc_type
== 1; /* R_MN10200_32. */
13265 case EM_CYGNUS_MN10300
:
13267 return reloc_type
== 1; /* R_MN10300_32. */
13269 return reloc_type
== 1; /* R_MOXIE_32. */
13270 case EM_MSP430_OLD
:
13272 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
13274 return reloc_type
== 2; /* R_MT_32. */
13276 return reloc_type
== 20; /* R_NDS32_RELA. */
13277 case EM_ALTERA_NIOS2
:
13278 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
13280 return reloc_type
== 1; /* R_NIOS_32. */
13282 return reloc_type
== 1; /* R_OR1K_32. */
13284 return (reloc_type
== 1 /* R_PARISC_DIR32. */
13285 || reloc_type
== 2 /* R_PARISC_DIR21L. */
13286 || reloc_type
== 41); /* R_PARISC_SECREL32. */
13289 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
13291 return reloc_type
== 1; /* R_PPC64_ADDR32. */
13293 return reloc_type
== 1; /* R_PPC_ADDR32. */
13295 return reloc_type
== 11; /* R_PRU_BFD_RELOC_32. */
13297 return reloc_type
== 1; /* R_RISCV_32. */
13299 return reloc_type
== 1; /* R_RL78_DIR32. */
13301 return reloc_type
== 1; /* R_RX_DIR32. */
13303 return reloc_type
== 1; /* R_I370_ADDR31. */
13306 return reloc_type
== 4; /* R_S390_32. */
13308 return reloc_type
== 8; /* R_SCORE_ABS32. */
13310 return reloc_type
== 1; /* R_SH_DIR32. */
13311 case EM_SPARC32PLUS
:
13314 return reloc_type
== 3 /* R_SPARC_32. */
13315 || reloc_type
== 23; /* R_SPARC_UA32. */
13317 return reloc_type
== 6; /* R_SPU_ADDR32 */
13319 return reloc_type
== 1; /* R_C6000_ABS32. */
13321 return reloc_type
== 2; /* R_TILEGX_32. */
13323 return reloc_type
== 1; /* R_TILEPRO_32. */
13324 case EM_CYGNUS_V850
:
13326 return reloc_type
== 6; /* R_V850_ABS32. */
13328 return reloc_type
== 0x33; /* R_V810_WORD. */
13330 return reloc_type
== 1; /* R_VAX_32. */
13332 return reloc_type
== 3; /* R_VISIUM_32. */
13333 case EM_WEBASSEMBLY
:
13334 return reloc_type
== 1; /* R_WASM32_32. */
13338 return reloc_type
== 10; /* R_X86_64_32. */
13341 return reloc_type
== 3; /* R_XC16C_ABS_32. */
13343 return reloc_type
== 4; /* R_XGATE_32. */
13345 return reloc_type
== 1; /* R_XSTROMY16_32. */
13346 case EM_XTENSA_OLD
:
13348 return reloc_type
== 1; /* R_XTENSA_32. */
13350 return reloc_type
== 6; /* R_Z80_32. */
13353 static unsigned int prev_warn
= 0;
13355 /* Avoid repeating the same warning multiple times. */
13356 if (prev_warn
!= filedata
->file_header
.e_machine
)
13357 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
13358 filedata
->file_header
.e_machine
);
13359 prev_warn
= filedata
->file_header
.e_machine
;
13365 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13366 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
13369 is_32bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13371 switch (filedata
->file_header
.e_machine
)
13372 /* Please keep this table alpha-sorted for ease of visual lookup. */
13376 return reloc_type
== 2; /* R_386_PC32. */
13378 return reloc_type
== 4; /* R_68K_PC32. */
13380 return reloc_type
== 261; /* R_AARCH64_PREL32 */
13381 case EM_ADAPTEVA_EPIPHANY
:
13382 return reloc_type
== 6;
13384 return reloc_type
== 10; /* R_ALPHA_SREL32. */
13385 case EM_ARC_COMPACT
:
13386 case EM_ARC_COMPACT2
:
13387 return reloc_type
== 49; /* R_ARC_32_PCREL. */
13389 return reloc_type
== 3; /* R_ARM_REL32 */
13392 return reloc_type
== 36; /* R_AVR_32_PCREL. */
13393 case EM_MICROBLAZE
:
13394 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
13396 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
13398 return reloc_type
== 9; /* R_PARISC_PCREL32. */
13400 return reloc_type
== 26; /* R_PPC_REL32. */
13402 return reloc_type
== 26; /* R_PPC64_REL32. */
13404 return reloc_type
== 57; /* R_RISCV_32_PCREL. */
13407 return reloc_type
== 5; /* R_390_PC32. */
13409 return reloc_type
== 2; /* R_SH_REL32. */
13410 case EM_SPARC32PLUS
:
13413 return reloc_type
== 6; /* R_SPARC_DISP32. */
13415 return reloc_type
== 13; /* R_SPU_REL32. */
13417 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
13419 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
13421 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
13425 return reloc_type
== 2; /* R_X86_64_PC32. */
13427 return reloc_type
== 4; /* R_VAX_PCREL32. */
13428 case EM_XTENSA_OLD
:
13430 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
13432 /* Do not abort or issue an error message here. Not all targets use
13433 pc-relative 32-bit relocs in their DWARF debug information and we
13434 have already tested for target coverage in is_32bit_abs_reloc. A
13435 more helpful warning message will be generated by apply_relocations
13436 anyway, so just return. */
13441 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13442 a 64-bit absolute RELA relocation used in DWARF debug sections. */
13445 is_64bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13447 switch (filedata
->file_header
.e_machine
)
13450 return reloc_type
== 257; /* R_AARCH64_ABS64. */
13452 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
13454 return (reloc_type
== 0x26 /* R_IA64_DIR64MSB. */
13455 || reloc_type
== 0x27 /* R_IA64_DIR64LSB. */);
13457 return reloc_type
== 80; /* R_PARISC_DIR64. */
13459 return reloc_type
== 38; /* R_PPC64_ADDR64. */
13461 return reloc_type
== 2; /* R_RISCV_64. */
13462 case EM_SPARC32PLUS
:
13465 return reloc_type
== 32 /* R_SPARC_64. */
13466 || reloc_type
== 54; /* R_SPARC_UA64. */
13470 return reloc_type
== 1; /* R_X86_64_64. */
13473 return reloc_type
== 22; /* R_S390_64. */
13475 return reloc_type
== 1; /* R_TILEGX_64. */
13477 return reloc_type
== 18; /* R_MIPS_64. */
13483 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
13484 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
13487 is_64bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13489 switch (filedata
->file_header
.e_machine
)
13492 return reloc_type
== 260; /* R_AARCH64_PREL64. */
13494 return reloc_type
== 11; /* R_ALPHA_SREL64. */
13496 return (reloc_type
== 0x4e /* R_IA64_PCREL64MSB. */
13497 || reloc_type
== 0x4f /* R_IA64_PCREL64LSB. */);
13499 return reloc_type
== 72; /* R_PARISC_PCREL64. */
13501 return reloc_type
== 44; /* R_PPC64_REL64. */
13502 case EM_SPARC32PLUS
:
13505 return reloc_type
== 46; /* R_SPARC_DISP64. */
13509 return reloc_type
== 24; /* R_X86_64_PC64. */
13512 return reloc_type
== 23; /* R_S390_PC64. */
13514 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
13520 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13521 a 24-bit absolute RELA relocation used in DWARF debug sections. */
13524 is_24bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13526 switch (filedata
->file_header
.e_machine
)
13528 case EM_CYGNUS_MN10200
:
13530 return reloc_type
== 4; /* R_MN10200_24. */
13532 return reloc_type
== 5; /* R_FT32_20. */
13534 return reloc_type
== 5; /* R_Z80_24. */
13540 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13541 a 16-bit absolute RELA relocation used in DWARF debug sections. */
13544 is_16bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13546 /* Please keep this table alpha-sorted for ease of visual lookup. */
13547 switch (filedata
->file_header
.e_machine
)
13550 case EM_ARC_COMPACT
:
13551 case EM_ARC_COMPACT2
:
13552 return reloc_type
== 2; /* R_ARC_16. */
13553 case EM_ADAPTEVA_EPIPHANY
:
13554 return reloc_type
== 5;
13557 return reloc_type
== 4; /* R_AVR_16. */
13558 case EM_CYGNUS_D10V
:
13560 return reloc_type
== 3; /* R_D10V_16. */
13562 return reloc_type
== 2; /* R_FT32_16. */
13566 return reloc_type
== R_H8_DIR16
;
13569 return reloc_type
== 1; /* R_IP2K_16. */
13572 return reloc_type
== 1; /* R_M32C_16 */
13573 case EM_CYGNUS_MN10200
:
13575 return reloc_type
== 2; /* R_MN10200_16. */
13576 case EM_CYGNUS_MN10300
:
13578 return reloc_type
== 2; /* R_MN10300_16. */
13580 if (uses_msp430x_relocs (filedata
))
13581 return reloc_type
== 2; /* R_MSP430_ABS16. */
13582 /* Fall through. */
13583 case EM_MSP430_OLD
:
13584 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
13586 return reloc_type
== 19; /* R_NDS32_RELA. */
13587 case EM_ALTERA_NIOS2
:
13588 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
13590 return reloc_type
== 9; /* R_NIOS_16. */
13592 return reloc_type
== 2; /* R_OR1K_16. */
13594 return reloc_type
== 55; /* R_RISCV_SET16. */
13596 return reloc_type
== 8; /* R_PRU_BFD_RELOC_16. */
13598 return reloc_type
== 2; /* R_C6000_ABS16. */
13600 return reloc_type
== 2; /* R_VISIUM_16. */
13603 return reloc_type
== 2; /* R_XC16C_ABS_16. */
13605 return reloc_type
== 3; /* R_XGATE_16. */
13607 return reloc_type
== 4; /* R_Z80_16. */
13613 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13614 a 8-bit absolute RELA relocation used in DWARF debug sections. */
13617 is_8bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13619 switch (filedata
->file_header
.e_machine
)
13622 return reloc_type
== 54; /* R_RISCV_SET8. */
13624 return reloc_type
== 1; /* R_Z80_8. */
13630 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13631 a 6-bit absolute RELA relocation used in DWARF debug sections. */
13634 is_6bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13636 switch (filedata
->file_header
.e_machine
)
13639 return reloc_type
== 53; /* R_RISCV_SET6. */
13645 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13646 a 32-bit inplace add RELA relocation used in DWARF debug sections. */
13649 is_32bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13651 /* Please keep this table alpha-sorted for ease of visual lookup. */
13652 switch (filedata
->file_header
.e_machine
)
13655 return reloc_type
== 35; /* R_RISCV_ADD32. */
13661 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13662 a 32-bit inplace sub RELA relocation used in DWARF debug sections. */
13665 is_32bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13667 /* Please keep this table alpha-sorted for ease of visual lookup. */
13668 switch (filedata
->file_header
.e_machine
)
13671 return reloc_type
== 39; /* R_RISCV_SUB32. */
13677 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13678 a 64-bit inplace add RELA relocation used in DWARF debug sections. */
13681 is_64bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13683 /* Please keep this table alpha-sorted for ease of visual lookup. */
13684 switch (filedata
->file_header
.e_machine
)
13687 return reloc_type
== 36; /* R_RISCV_ADD64. */
13693 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13694 a 64-bit inplace sub RELA relocation used in DWARF debug sections. */
13697 is_64bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13699 /* Please keep this table alpha-sorted for ease of visual lookup. */
13700 switch (filedata
->file_header
.e_machine
)
13703 return reloc_type
== 40; /* R_RISCV_SUB64. */
13709 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13710 a 16-bit inplace add RELA relocation used in DWARF debug sections. */
13713 is_16bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13715 /* Please keep this table alpha-sorted for ease of visual lookup. */
13716 switch (filedata
->file_header
.e_machine
)
13719 return reloc_type
== 34; /* R_RISCV_ADD16. */
13725 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13726 a 16-bit inplace sub RELA relocation used in DWARF debug sections. */
13729 is_16bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13731 /* Please keep this table alpha-sorted for ease of visual lookup. */
13732 switch (filedata
->file_header
.e_machine
)
13735 return reloc_type
== 38; /* R_RISCV_SUB16. */
13741 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13742 a 8-bit inplace add RELA relocation used in DWARF debug sections. */
13745 is_8bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13747 /* Please keep this table alpha-sorted for ease of visual lookup. */
13748 switch (filedata
->file_header
.e_machine
)
13751 return reloc_type
== 33; /* R_RISCV_ADD8. */
13757 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13758 a 8-bit inplace sub RELA relocation used in DWARF debug sections. */
13761 is_8bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13763 /* Please keep this table alpha-sorted for ease of visual lookup. */
13764 switch (filedata
->file_header
.e_machine
)
13767 return reloc_type
== 37; /* R_RISCV_SUB8. */
13773 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13774 a 6-bit inplace sub RELA relocation used in DWARF debug sections. */
13777 is_6bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13779 switch (filedata
->file_header
.e_machine
)
13782 return reloc_type
== 52; /* R_RISCV_SUB6. */
13788 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
13789 relocation entries (possibly formerly used for SHT_GROUP sections). */
13792 is_none_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13794 switch (filedata
->file_header
.e_machine
)
13796 case EM_386
: /* R_386_NONE. */
13797 case EM_68K
: /* R_68K_NONE. */
13798 case EM_ADAPTEVA_EPIPHANY
:
13799 case EM_ALPHA
: /* R_ALPHA_NONE. */
13800 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
13801 case EM_ARC
: /* R_ARC_NONE. */
13802 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
13803 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
13804 case EM_ARM
: /* R_ARM_NONE. */
13805 case EM_C166
: /* R_XC16X_NONE. */
13806 case EM_CRIS
: /* R_CRIS_NONE. */
13807 case EM_FT32
: /* R_FT32_NONE. */
13808 case EM_IA_64
: /* R_IA64_NONE. */
13809 case EM_K1OM
: /* R_X86_64_NONE. */
13810 case EM_L1OM
: /* R_X86_64_NONE. */
13811 case EM_M32R
: /* R_M32R_NONE. */
13812 case EM_MIPS
: /* R_MIPS_NONE. */
13813 case EM_MN10300
: /* R_MN10300_NONE. */
13814 case EM_MOXIE
: /* R_MOXIE_NONE. */
13815 case EM_NIOS32
: /* R_NIOS_NONE. */
13816 case EM_OR1K
: /* R_OR1K_NONE. */
13817 case EM_PARISC
: /* R_PARISC_NONE. */
13818 case EM_PPC64
: /* R_PPC64_NONE. */
13819 case EM_PPC
: /* R_PPC_NONE. */
13820 case EM_RISCV
: /* R_RISCV_NONE. */
13821 case EM_S390
: /* R_390_NONE. */
13823 case EM_SH
: /* R_SH_NONE. */
13824 case EM_SPARC32PLUS
:
13825 case EM_SPARC
: /* R_SPARC_NONE. */
13827 case EM_TILEGX
: /* R_TILEGX_NONE. */
13828 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
13829 case EM_TI_C6000
:/* R_C6000_NONE. */
13830 case EM_X86_64
: /* R_X86_64_NONE. */
13832 case EM_Z80
: /* R_Z80_NONE. */
13833 case EM_WEBASSEMBLY
: /* R_WASM32_NONE. */
13834 return reloc_type
== 0;
13837 return reloc_type
== 0 || reloc_type
== 256;
13840 return (reloc_type
== 0 /* R_AVR_NONE. */
13841 || reloc_type
== 30 /* R_AVR_DIFF8. */
13842 || reloc_type
== 31 /* R_AVR_DIFF16. */
13843 || reloc_type
== 32 /* R_AVR_DIFF32. */);
13845 return reloc_type
== 3; /* R_METAG_NONE. */
13847 return (reloc_type
== 0 /* R_XTENSA_NONE. */
13848 || reloc_type
== 204 /* R_NDS32_DIFF8. */
13849 || reloc_type
== 205 /* R_NDS32_DIFF16. */
13850 || reloc_type
== 206 /* R_NDS32_DIFF32. */
13851 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
13853 return (reloc_type
== 0 /* R_PRU_NONE. */
13854 || reloc_type
== 65 /* R_PRU_DIFF8. */
13855 || reloc_type
== 66 /* R_PRU_DIFF16. */
13856 || reloc_type
== 67 /* R_PRU_DIFF32. */);
13857 case EM_XTENSA_OLD
:
13859 return (reloc_type
== 0 /* R_XTENSA_NONE. */
13860 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
13861 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
13862 || reloc_type
== 19 /* R_XTENSA_DIFF32. */
13863 || reloc_type
== 57 /* R_XTENSA_PDIFF8. */
13864 || reloc_type
== 58 /* R_XTENSA_PDIFF16. */
13865 || reloc_type
== 59 /* R_XTENSA_PDIFF32. */
13866 || reloc_type
== 60 /* R_XTENSA_NDIFF8. */
13867 || reloc_type
== 61 /* R_XTENSA_NDIFF16. */
13868 || reloc_type
== 62 /* R_XTENSA_NDIFF32. */);
13873 /* Returns TRUE if there is a relocation against
13874 section NAME at OFFSET bytes. */
13877 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
13879 Elf_Internal_Rela
* relocs
;
13880 Elf_Internal_Rela
* rp
;
13882 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
13885 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
13887 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
13888 if (rp
->r_offset
== offset
)
13894 /* Apply relocations to a section.
13895 Returns TRUE upon success, FALSE otherwise.
13896 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
13897 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
13898 will be set to the number of relocs loaded.
13900 Note: So far support has been added only for those relocations
13901 which can be found in debug sections. FIXME: Add support for
13902 more relocations ? */
13905 apply_relocations (Filedata
* filedata
,
13906 const Elf_Internal_Shdr
* section
,
13907 unsigned char * start
,
13908 bfd_size_type size
,
13909 void ** relocs_return
,
13910 unsigned long * num_relocs_return
)
13912 Elf_Internal_Shdr
* relsec
;
13913 unsigned char * end
= start
+ size
;
13915 if (relocs_return
!= NULL
)
13917 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
13918 * num_relocs_return
= 0;
13921 if (filedata
->file_header
.e_type
!= ET_REL
)
13922 /* No relocs to apply. */
13925 /* Find the reloc section associated with the section. */
13926 for (relsec
= filedata
->section_headers
;
13927 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13930 bfd_boolean is_rela
;
13931 unsigned long num_relocs
;
13932 Elf_Internal_Rela
* relocs
;
13933 Elf_Internal_Rela
* rp
;
13934 Elf_Internal_Shdr
* symsec
;
13935 Elf_Internal_Sym
* symtab
;
13936 unsigned long num_syms
;
13937 Elf_Internal_Sym
* sym
;
13939 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13940 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13941 || filedata
->section_headers
+ relsec
->sh_info
!= section
13942 || relsec
->sh_size
== 0
13943 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13946 symsec
= filedata
->section_headers
+ relsec
->sh_link
;
13947 if (symsec
->sh_type
!= SHT_SYMTAB
13948 && symsec
->sh_type
!= SHT_DYNSYM
)
13951 is_rela
= relsec
->sh_type
== SHT_RELA
;
13955 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
,
13956 relsec
->sh_size
, & relocs
, & num_relocs
))
13961 if (!slurp_rel_relocs (filedata
, relsec
->sh_offset
,
13962 relsec
->sh_size
, & relocs
, & num_relocs
))
13966 /* SH uses RELA but uses in place value instead of the addend field. */
13967 if (filedata
->file_header
.e_machine
== EM_SH
)
13970 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & num_syms
);
13972 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
13975 unsigned int reloc_type
;
13976 unsigned int reloc_size
;
13977 bfd_boolean reloc_inplace
= FALSE
;
13978 bfd_boolean reloc_subtract
= FALSE
;
13979 unsigned char * rloc
;
13980 unsigned long sym_index
;
13982 reloc_type
= get_reloc_type (filedata
, rp
->r_info
);
13984 if (target_specific_reloc_handling (filedata
, rp
, start
, end
, symtab
, num_syms
))
13986 else if (is_none_reloc (filedata
, reloc_type
))
13988 else if (is_32bit_abs_reloc (filedata
, reloc_type
)
13989 || is_32bit_pcrel_reloc (filedata
, reloc_type
))
13991 else if (is_64bit_abs_reloc (filedata
, reloc_type
)
13992 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
13994 else if (is_24bit_abs_reloc (filedata
, reloc_type
))
13996 else if (is_16bit_abs_reloc (filedata
, reloc_type
))
13998 else if (is_8bit_abs_reloc (filedata
, reloc_type
)
13999 || is_6bit_abs_reloc (filedata
, reloc_type
))
14001 else if ((reloc_subtract
= is_32bit_inplace_sub_reloc (filedata
,
14003 || is_32bit_inplace_add_reloc (filedata
, reloc_type
))
14006 reloc_inplace
= TRUE
;
14008 else if ((reloc_subtract
= is_64bit_inplace_sub_reloc (filedata
,
14010 || is_64bit_inplace_add_reloc (filedata
, reloc_type
))
14013 reloc_inplace
= TRUE
;
14015 else if ((reloc_subtract
= is_16bit_inplace_sub_reloc (filedata
,
14017 || is_16bit_inplace_add_reloc (filedata
, reloc_type
))
14020 reloc_inplace
= TRUE
;
14022 else if ((reloc_subtract
= is_8bit_inplace_sub_reloc (filedata
,
14024 || is_8bit_inplace_add_reloc (filedata
, reloc_type
))
14027 reloc_inplace
= TRUE
;
14029 else if ((reloc_subtract
= is_6bit_inplace_sub_reloc (filedata
,
14033 reloc_inplace
= TRUE
;
14037 static unsigned int prev_reloc
= 0;
14039 if (reloc_type
!= prev_reloc
)
14040 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
14041 reloc_type
, printable_section_name (filedata
, section
));
14042 prev_reloc
= reloc_type
;
14046 rloc
= start
+ rp
->r_offset
;
14047 if (!IN_RANGE (start
, end
, rloc
, reloc_size
))
14049 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
14050 (unsigned long) rp
->r_offset
,
14051 printable_section_name (filedata
, section
));
14055 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
14056 if (sym_index
>= num_syms
)
14058 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
14059 sym_index
, printable_section_name (filedata
, section
));
14062 sym
= symtab
+ sym_index
;
14064 /* If the reloc has a symbol associated with it,
14065 make sure that it is of an appropriate type.
14067 Relocations against symbols without type can happen.
14068 Gcc -feliminate-dwarf2-dups may generate symbols
14069 without type for debug info.
14071 Icc generates relocations against function symbols
14072 instead of local labels.
14074 Relocations against object symbols can happen, eg when
14075 referencing a global array. For an example of this see
14076 the _clz.o binary in libgcc.a. */
14078 && ELF_ST_TYPE (sym
->st_info
) != STT_COMMON
14079 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
14081 warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
14082 get_symbol_type (filedata
, ELF_ST_TYPE (sym
->st_info
)),
14083 printable_section_name (filedata
, relsec
),
14084 (long int)(rp
- relocs
));
14090 addend
+= rp
->r_addend
;
14091 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
14092 partial_inplace. */
14094 || (filedata
->file_header
.e_machine
== EM_XTENSA
14095 && reloc_type
== 1)
14096 || ((filedata
->file_header
.e_machine
== EM_PJ
14097 || filedata
->file_header
.e_machine
== EM_PJ_OLD
)
14098 && reloc_type
== 1)
14099 || ((filedata
->file_header
.e_machine
== EM_D30V
14100 || filedata
->file_header
.e_machine
== EM_CYGNUS_D30V
)
14101 && reloc_type
== 12)
14104 if (is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
14105 addend
+= byte_get (rloc
, reloc_size
) & 0x3f;
14107 addend
+= byte_get (rloc
, reloc_size
);
14110 if (is_32bit_pcrel_reloc (filedata
, reloc_type
)
14111 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
14113 /* On HPPA, all pc-relative relocations are biased by 8. */
14114 if (filedata
->file_header
.e_machine
== EM_PARISC
)
14116 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
14119 else if (is_6bit_abs_reloc (filedata
, reloc_type
)
14120 || is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
14122 if (reloc_subtract
)
14123 addend
-= sym
->st_value
;
14125 addend
+= sym
->st_value
;
14126 addend
= (addend
& 0x3f) | (byte_get (rloc
, reloc_size
) & 0xc0);
14127 byte_put (rloc
, addend
, reloc_size
);
14129 else if (reloc_subtract
)
14130 byte_put (rloc
, addend
- sym
->st_value
, reloc_size
);
14132 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
14136 /* Let the target specific reloc processing code know that
14137 we have finished with these relocs. */
14138 target_specific_reloc_handling (filedata
, NULL
, NULL
, NULL
, NULL
, 0);
14142 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
14143 * num_relocs_return
= num_relocs
;
14154 #ifdef SUPPORT_DISASSEMBLY
14156 disassemble_section (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
14158 printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata
, section
));
14160 /* FIXME: XXX -- to be done --- XXX */
14166 /* Reads in the contents of SECTION from FILE, returning a pointer
14167 to a malloc'ed buffer or NULL if something went wrong. */
14170 get_section_contents (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
14172 bfd_size_type num_bytes
= section
->sh_size
;
14174 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
14176 printf (_("Section '%s' has no data to dump.\n"),
14177 printable_section_name (filedata
, section
));
14181 return (char *) get_data (NULL
, filedata
, section
->sh_offset
, 1, num_bytes
,
14182 _("section contents"));
14185 /* Uncompresses a section that was compressed using zlib, in place. */
14188 uncompress_section_contents (unsigned char ** buffer
,
14189 dwarf_size_type uncompressed_size
,
14190 dwarf_size_type
* size
)
14192 dwarf_size_type compressed_size
= *size
;
14193 unsigned char * compressed_buffer
= *buffer
;
14194 unsigned char * uncompressed_buffer
;
14198 /* It is possible the section consists of several compressed
14199 buffers concatenated together, so we uncompress in a loop. */
14200 /* PR 18313: The state field in the z_stream structure is supposed
14201 to be invisible to the user (ie us), but some compilers will
14202 still complain about it being used without initialisation. So
14203 we first zero the entire z_stream structure and then set the fields
14205 memset (& strm
, 0, sizeof strm
);
14206 strm
.avail_in
= compressed_size
;
14207 strm
.next_in
= (Bytef
*) compressed_buffer
;
14208 strm
.avail_out
= uncompressed_size
;
14209 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
14211 rc
= inflateInit (& strm
);
14212 while (strm
.avail_in
> 0)
14216 strm
.next_out
= ((Bytef
*) uncompressed_buffer
14217 + (uncompressed_size
- strm
.avail_out
));
14218 rc
= inflate (&strm
, Z_FINISH
);
14219 if (rc
!= Z_STREAM_END
)
14221 rc
= inflateReset (& strm
);
14223 rc
= inflateEnd (& strm
);
14225 || strm
.avail_out
!= 0)
14228 *buffer
= uncompressed_buffer
;
14229 *size
= uncompressed_size
;
14233 free (uncompressed_buffer
);
14234 /* Indicate decompression failure. */
14240 dump_section_as_strings (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
14242 Elf_Internal_Shdr
* relsec
;
14243 bfd_size_type num_bytes
;
14244 unsigned char * data
;
14245 unsigned char * end
;
14246 unsigned char * real_start
;
14247 unsigned char * start
;
14248 bfd_boolean some_strings_shown
;
14250 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
14252 /* PR 21820: Do not fail if the section was empty. */
14253 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
14255 num_bytes
= section
->sh_size
;
14257 printf (_("\nString dump of section '%s':\n"), printable_section_name (filedata
, section
));
14259 if (decompress_dumps
)
14261 dwarf_size_type new_size
= num_bytes
;
14262 dwarf_size_type uncompressed_size
= 0;
14264 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
14266 Elf_Internal_Chdr chdr
;
14267 unsigned int compression_header_size
14268 = get_compression_header (& chdr
, (unsigned char *) start
,
14270 if (compression_header_size
== 0)
14271 /* An error message will have already been generated
14272 by get_compression_header. */
14275 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
14277 warn (_("section '%s' has unsupported compress type: %d\n"),
14278 printable_section_name (filedata
, section
), chdr
.ch_type
);
14281 uncompressed_size
= chdr
.ch_size
;
14282 start
+= compression_header_size
;
14283 new_size
-= compression_header_size
;
14285 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
14287 /* Read the zlib header. In this case, it should be "ZLIB"
14288 followed by the uncompressed section size, 8 bytes in
14289 big-endian order. */
14290 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
14291 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
14292 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
14293 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
14294 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
14295 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
14296 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
14297 uncompressed_size
+= start
[11];
14302 if (uncompressed_size
)
14304 if (uncompress_section_contents (& start
,
14305 uncompressed_size
, & new_size
))
14306 num_bytes
= new_size
;
14309 error (_("Unable to decompress section %s\n"),
14310 printable_section_name (filedata
, section
));
14315 start
= real_start
;
14318 /* If the section being dumped has relocations against it the user might
14319 be expecting these relocations to have been applied. Check for this
14320 case and issue a warning message in order to avoid confusion.
14321 FIXME: Maybe we ought to have an option that dumps a section with
14322 relocs applied ? */
14323 for (relsec
= filedata
->section_headers
;
14324 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
14327 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
14328 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
14329 || filedata
->section_headers
+ relsec
->sh_info
!= section
14330 || relsec
->sh_size
== 0
14331 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
14334 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
14339 end
= start
+ num_bytes
;
14340 some_strings_shown
= FALSE
;
14342 #ifdef HAVE_MBSTATE_T
14344 /* Initialise the multibyte conversion state. */
14345 memset (& state
, 0, sizeof (state
));
14348 bfd_boolean continuing
= FALSE
;
14352 while (!ISPRINT (* data
))
14353 if (++ data
>= end
)
14358 size_t maxlen
= end
- data
;
14363 continuing
= FALSE
;
14367 printf (" [%6lx] ", (unsigned long) (data
- start
));
14381 /* PR 25543: Treat new-lines as string-ending characters. */
14390 /* Do not print control characters directly as they can affect terminal
14391 settings. Such characters usually appear in the names generated
14392 by the assembler for local labels. */
14395 printf ("^%c", c
+ 0x40);
14397 else if (ISPRINT (c
))
14404 #ifdef HAVE_MBSTATE_T
14407 /* Let printf do the hard work of displaying multibyte characters. */
14408 printf ("%.1s", data
- 1);
14409 #ifdef HAVE_MBSTATE_T
14410 /* Try to find out how many bytes made up the character that was
14411 just printed. Advance the symbol pointer past the bytes that
14413 n
= mbrtowc (& w
, (char *)(data
- 1), MB_CUR_MAX
, & state
);
14417 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
14427 printf (_("<corrupt>\n"));
14430 some_strings_shown
= TRUE
;
14434 if (! some_strings_shown
)
14435 printf (_(" No strings found in this section."));
14448 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
14449 Filedata
* filedata
,
14450 bfd_boolean relocate
)
14452 Elf_Internal_Shdr
* relsec
;
14453 bfd_size_type bytes
;
14454 bfd_size_type section_size
;
14456 unsigned char * data
;
14457 unsigned char * real_start
;
14458 unsigned char * start
;
14460 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
14462 /* PR 21820: Do not fail if the section was empty. */
14463 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
14465 section_size
= section
->sh_size
;
14467 printf (_("\nHex dump of section '%s':\n"), printable_section_name (filedata
, section
));
14469 if (decompress_dumps
)
14471 dwarf_size_type new_size
= section_size
;
14472 dwarf_size_type uncompressed_size
= 0;
14474 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
14476 Elf_Internal_Chdr chdr
;
14477 unsigned int compression_header_size
14478 = get_compression_header (& chdr
, start
, section_size
);
14480 if (compression_header_size
== 0)
14481 /* An error message will have already been generated
14482 by get_compression_header. */
14485 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
14487 warn (_("section '%s' has unsupported compress type: %d\n"),
14488 printable_section_name (filedata
, section
), chdr
.ch_type
);
14491 uncompressed_size
= chdr
.ch_size
;
14492 start
+= compression_header_size
;
14493 new_size
-= compression_header_size
;
14495 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
14497 /* Read the zlib header. In this case, it should be "ZLIB"
14498 followed by the uncompressed section size, 8 bytes in
14499 big-endian order. */
14500 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
14501 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
14502 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
14503 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
14504 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
14505 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
14506 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
14507 uncompressed_size
+= start
[11];
14512 if (uncompressed_size
)
14514 if (uncompress_section_contents (& start
, uncompressed_size
,
14517 section_size
= new_size
;
14521 error (_("Unable to decompress section %s\n"),
14522 printable_section_name (filedata
, section
));
14523 /* FIXME: Print the section anyway ? */
14528 start
= real_start
;
14533 if (! apply_relocations (filedata
, section
, start
, section_size
, NULL
, NULL
))
14538 /* If the section being dumped has relocations against it the user might
14539 be expecting these relocations to have been applied. Check for this
14540 case and issue a warning message in order to avoid confusion.
14541 FIXME: Maybe we ought to have an option that dumps a section with
14542 relocs applied ? */
14543 for (relsec
= filedata
->section_headers
;
14544 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
14547 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
14548 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
14549 || filedata
->section_headers
+ relsec
->sh_info
!= section
14550 || relsec
->sh_size
== 0
14551 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
14554 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
14559 addr
= section
->sh_addr
;
14560 bytes
= section_size
;
14569 lbytes
= (bytes
> 16 ? 16 : bytes
);
14571 printf (" 0x%8.8lx ", (unsigned long) addr
);
14573 for (j
= 0; j
< 16; j
++)
14576 printf ("%2.2x", data
[j
]);
14584 for (j
= 0; j
< lbytes
; j
++)
14587 if (k
>= ' ' && k
< 0x7f)
14610 #ifdef ENABLE_LIBCTF
14611 static ctf_sect_t
*
14612 shdr_to_ctf_sect (ctf_sect_t
*buf
, Elf_Internal_Shdr
*shdr
, Filedata
*filedata
)
14614 buf
->cts_name
= SECTION_NAME_PRINT (shdr
);
14615 buf
->cts_size
= shdr
->sh_size
;
14616 buf
->cts_entsize
= shdr
->sh_entsize
;
14621 /* Formatting callback function passed to ctf_dump. Returns either the pointer
14622 it is passed, or a pointer to newly-allocated storage, in which case
14623 dump_ctf() will free it when it no longer needs it. */
14626 dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED
,
14627 char *s
, void *arg
)
14629 const char *blanks
= arg
;
14632 if (asprintf (&new_s
, "%s%s", blanks
, s
) < 0)
14637 /* Dump CTF errors/warnings. */
14639 dump_ctf_errs (ctf_dict_t
*fp
)
14641 ctf_next_t
*it
= NULL
;
14646 /* Dump accumulated errors and warnings. */
14647 while ((errtext
= ctf_errwarning_next (fp
, &it
, &is_warning
, &err
)) != NULL
)
14649 error (_("%s: %s"), is_warning
? _("warning"): _("error"),
14653 if (err
!= ECTF_NEXT_END
)
14654 error (_("CTF error: cannot get CTF errors: `%s'"), ctf_errmsg (err
));
14657 /* Dump one CTF archive member. */
14660 dump_ctf_archive_member (ctf_dict_t
*ctf
, const char *name
, void *arg
)
14662 ctf_dict_t
*parent
= (ctf_dict_t
*) arg
;
14663 const char *things
[] = {"Header", "Labels", "Data objects",
14664 "Function objects", "Variables", "Types", "Strings",
14666 const char **thing
;
14670 /* Only print out the name of non-default-named archive members.
14671 The name .ctf appears everywhere, even for things that aren't
14672 really archives, so printing it out is liable to be confusing.
14674 The parent, if there is one, is the default-owned archive member:
14675 avoid importing it into itself. (This does no harm, but looks
14678 if (strcmp (name
, ".ctf") != 0)
14680 printf (_("\nCTF archive member: %s:\n"), name
);
14681 ctf_import (ctf
, parent
);
14684 for (i
= 0, thing
= things
; *thing
[0]; thing
++, i
++)
14686 ctf_dump_state_t
*s
= NULL
;
14689 printf ("\n %s:\n", *thing
);
14690 while ((item
= ctf_dump (ctf
, &s
, i
, dump_ctf_indent_lines
,
14691 (void *) " ")) != NULL
)
14693 printf ("%s\n", item
);
14697 if (ctf_errno (ctf
))
14699 error (_("Iteration failed: %s, %s\n"), *thing
,
14700 ctf_errmsg (ctf_errno (ctf
)));
14707 dump_ctf_errs (ctf
);
14712 dump_section_as_ctf (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
14714 Elf_Internal_Shdr
* parent_sec
= NULL
;
14715 Elf_Internal_Shdr
* symtab_sec
= NULL
;
14716 Elf_Internal_Shdr
* strtab_sec
= NULL
;
14717 void * data
= NULL
;
14718 void * symdata
= NULL
;
14719 void * strdata
= NULL
;
14720 void * parentdata
= NULL
;
14721 ctf_sect_t ctfsect
, symsect
, strsect
, parentsect
;
14722 ctf_sect_t
* symsectp
= NULL
;
14723 ctf_sect_t
* strsectp
= NULL
;
14724 ctf_archive_t
* ctfa
= NULL
;
14725 ctf_archive_t
* parenta
= NULL
, *lookparent
;
14726 ctf_dict_t
* parent
= NULL
;
14729 bfd_boolean ret
= FALSE
;
14731 shdr_to_ctf_sect (&ctfsect
, section
, filedata
);
14732 data
= get_section_contents (section
, filedata
);
14733 ctfsect
.cts_data
= data
;
14735 if (!dump_ctf_symtab_name
)
14736 dump_ctf_symtab_name
= strdup (".dynsym");
14738 if (!dump_ctf_strtab_name
)
14739 dump_ctf_strtab_name
= strdup (".dynstr");
14741 if (dump_ctf_symtab_name
&& dump_ctf_symtab_name
[0] != 0)
14743 if ((symtab_sec
= find_section (filedata
, dump_ctf_symtab_name
)) == NULL
)
14745 error (_("No symbol section named %s\n"), dump_ctf_symtab_name
);
14748 if ((symdata
= (void *) get_data (NULL
, filedata
,
14749 symtab_sec
->sh_offset
, 1,
14750 symtab_sec
->sh_size
,
14751 _("symbols"))) == NULL
)
14753 symsectp
= shdr_to_ctf_sect (&symsect
, symtab_sec
, filedata
);
14754 symsect
.cts_data
= symdata
;
14756 if (dump_ctf_strtab_name
&& dump_ctf_strtab_name
[0] != 0)
14758 if ((strtab_sec
= find_section (filedata
, dump_ctf_strtab_name
)) == NULL
)
14760 error (_("No string table section named %s\n"),
14761 dump_ctf_strtab_name
);
14764 if ((strdata
= (void *) get_data (NULL
, filedata
,
14765 strtab_sec
->sh_offset
, 1,
14766 strtab_sec
->sh_size
,
14767 _("strings"))) == NULL
)
14769 strsectp
= shdr_to_ctf_sect (&strsect
, strtab_sec
, filedata
);
14770 strsect
.cts_data
= strdata
;
14772 if (dump_ctf_parent_name
)
14774 if ((parent_sec
= find_section (filedata
, dump_ctf_parent_name
)) == NULL
)
14776 error (_("No CTF parent section named %s\n"), dump_ctf_parent_name
);
14779 if ((parentdata
= (void *) get_data (NULL
, filedata
,
14780 parent_sec
->sh_offset
, 1,
14781 parent_sec
->sh_size
,
14782 _("CTF parent"))) == NULL
)
14784 shdr_to_ctf_sect (&parentsect
, parent_sec
, filedata
);
14785 parentsect
.cts_data
= parentdata
;
14788 /* Load the CTF file and dump it. It may be a raw CTF section, or an archive:
14789 libctf papers over the difference, so we can pretend it is always an
14790 archive. Possibly open the parent as well, if one was specified. */
14792 if ((ctfa
= ctf_arc_bufopen (&ctfsect
, symsectp
, strsectp
, &err
)) == NULL
)
14794 dump_ctf_errs (NULL
);
14795 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
14799 ctf_arc_symsect_endianness (ctfa
, filedata
->file_header
.e_ident
[EI_DATA
]
14804 if ((parenta
= ctf_arc_bufopen (&parentsect
, symsectp
, strsectp
,
14807 dump_ctf_errs (NULL
);
14808 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
14811 lookparent
= parenta
;
14816 /* Assume that the applicable parent archive member is the default one.
14817 (This is what all known implementations are expected to do, if they
14818 put CTFs and their parents in archives together.) */
14819 if ((parent
= ctf_dict_open (lookparent
, NULL
, &err
)) == NULL
)
14821 dump_ctf_errs (NULL
);
14822 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
14828 printf (_("\nDump of CTF section '%s':\n"),
14829 printable_section_name (filedata
, section
));
14831 if ((err
= ctf_archive_iter (ctfa
, dump_ctf_archive_member
, parent
)) != 0)
14833 dump_ctf_errs (NULL
);
14834 error (_("CTF member open failure: %s\n"), ctf_errmsg (err
));
14839 ctf_dict_close (parent
);
14841 ctf_close (parenta
);
14851 load_specific_debug_section (enum dwarf_section_display_enum debug
,
14852 const Elf_Internal_Shdr
* sec
,
14855 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14857 Filedata
* filedata
= (Filedata
*) data
;
14859 if (section
->start
!= NULL
)
14861 /* If it is already loaded, do nothing. */
14862 if (streq (section
->filename
, filedata
->file_name
))
14864 free (section
->start
);
14867 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
14868 section
->address
= sec
->sh_addr
;
14869 section
->user_data
= NULL
;
14870 section
->filename
= filedata
->file_name
;
14871 section
->start
= (unsigned char *) get_data (NULL
, filedata
,
14873 sec
->sh_size
, buf
);
14874 if (section
->start
== NULL
)
14878 unsigned char *start
= section
->start
;
14879 dwarf_size_type size
= sec
->sh_size
;
14880 dwarf_size_type uncompressed_size
= 0;
14882 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
14884 Elf_Internal_Chdr chdr
;
14885 unsigned int compression_header_size
;
14887 if (size
< (is_32bit_elf
14888 ? sizeof (Elf32_External_Chdr
)
14889 : sizeof (Elf64_External_Chdr
)))
14891 warn (_("compressed section %s is too small to contain a compression header\n"),
14896 compression_header_size
= get_compression_header (&chdr
, start
, size
);
14897 if (compression_header_size
== 0)
14898 /* An error message will have already been generated
14899 by get_compression_header. */
14902 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
14904 warn (_("section '%s' has unsupported compress type: %d\n"),
14905 section
->name
, chdr
.ch_type
);
14908 uncompressed_size
= chdr
.ch_size
;
14909 start
+= compression_header_size
;
14910 size
-= compression_header_size
;
14912 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
14914 /* Read the zlib header. In this case, it should be "ZLIB"
14915 followed by the uncompressed section size, 8 bytes in
14916 big-endian order. */
14917 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
14918 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
14919 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
14920 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
14921 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
14922 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
14923 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
14924 uncompressed_size
+= start
[11];
14929 if (uncompressed_size
)
14931 if (uncompress_section_contents (&start
, uncompressed_size
,
14934 /* Free the compressed buffer, update the section buffer
14935 and the section size if uncompress is successful. */
14936 free (section
->start
);
14937 section
->start
= start
;
14941 error (_("Unable to decompress section %s\n"),
14942 printable_section_name (filedata
, sec
));
14947 section
->size
= size
;
14950 if (section
->start
== NULL
)
14953 if (debug_displays
[debug
].relocate
)
14955 if (! apply_relocations (filedata
, sec
, section
->start
, section
->size
,
14956 & section
->reloc_info
, & section
->num_relocs
))
14961 section
->reloc_info
= NULL
;
14962 section
->num_relocs
= 0;
14968 #if HAVE_LIBDEBUGINFOD
14969 /* Return a hex string representation of the build-id. */
14971 get_build_id (void * data
)
14973 Filedata
* filedata
= (Filedata
*)data
;
14974 Elf_Internal_Shdr
* shdr
;
14977 /* Iterate through notes to find note.gnu.build-id.
14978 FIXME: Only the first note in any note section is examined. */
14979 for (i
= 0, shdr
= filedata
->section_headers
;
14980 i
< filedata
->file_header
.e_shnum
&& shdr
!= NULL
;
14983 if (shdr
->sh_type
!= SHT_NOTE
)
14988 size_t data_remaining
;
14990 Elf_External_Note
* enote
;
14991 Elf_Internal_Note inote
;
14993 bfd_vma offset
= shdr
->sh_offset
;
14994 bfd_vma align
= shdr
->sh_addralign
;
14995 bfd_vma length
= shdr
->sh_size
;
14997 enote
= (Elf_External_Note
*) get_section_contents (shdr
, filedata
);
15003 else if (align
!= 4 && align
!= 8)
15009 end
= (char *) enote
+ length
;
15010 data_remaining
= end
- (char *) enote
;
15012 if (!is_ia64_vms (filedata
))
15014 min_notesz
= offsetof (Elf_External_Note
, name
);
15015 if (data_remaining
< min_notesz
)
15018 malformed note encountered in section %s whilst scanning for build-id note\n"),
15019 printable_section_name (filedata
, shdr
));
15023 data_remaining
-= min_notesz
;
15025 inote
.type
= BYTE_GET (enote
->type
);
15026 inote
.namesz
= BYTE_GET (enote
->namesz
);
15027 inote
.namedata
= enote
->name
;
15028 inote
.descsz
= BYTE_GET (enote
->descsz
);
15029 inote
.descdata
= ((char *) enote
15030 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
15031 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
15032 next
= ((char *) enote
15033 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
15037 Elf64_External_VMS_Note
*vms_enote
;
15039 /* PR binutils/15191
15040 Make sure that there is enough data to read. */
15041 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
15042 if (data_remaining
< min_notesz
)
15045 malformed note encountered in section %s whilst scanning for build-id note\n"),
15046 printable_section_name (filedata
, shdr
));
15050 data_remaining
-= min_notesz
;
15052 vms_enote
= (Elf64_External_VMS_Note
*) enote
;
15053 inote
.type
= BYTE_GET (vms_enote
->type
);
15054 inote
.namesz
= BYTE_GET (vms_enote
->namesz
);
15055 inote
.namedata
= vms_enote
->name
;
15056 inote
.descsz
= BYTE_GET (vms_enote
->descsz
);
15057 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
15058 inote
.descpos
= offset
+ (inote
.descdata
- (char *) enote
);
15059 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
15062 /* Skip malformed notes. */
15063 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
15064 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
15065 || (size_t) (next
- inote
.descdata
) < inote
.descsz
15066 || ((size_t) (next
- inote
.descdata
)
15067 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
15070 malformed note encountered in section %s whilst scanning for build-id note\n"),
15071 printable_section_name (filedata
, shdr
));
15076 /* Check if this is the build-id note. If so then convert the build-id
15077 bytes to a hex string. */
15078 if (inote
.namesz
> 0
15079 && const_strneq (inote
.namedata
, "GNU")
15080 && inote
.type
== NT_GNU_BUILD_ID
)
15085 build_id
= malloc (inote
.descsz
* 2 + 1);
15086 if (build_id
== NULL
)
15092 for (j
= 0; j
< inote
.descsz
; ++j
)
15093 sprintf (build_id
+ (j
* 2), "%02x", inote
.descdata
[j
] & 0xff);
15094 build_id
[inote
.descsz
* 2] = '\0';
15097 return (unsigned char *) build_id
;
15104 #endif /* HAVE_LIBDEBUGINFOD */
15106 /* If this is not NULL, load_debug_section will only look for sections
15107 within the list of sections given here. */
15108 static unsigned int * section_subset
= NULL
;
15111 load_debug_section (enum dwarf_section_display_enum debug
, void * data
)
15113 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
15114 Elf_Internal_Shdr
* sec
;
15115 Filedata
* filedata
= (Filedata
*) data
;
15117 /* Without section headers we cannot find any sections. */
15118 if (filedata
->section_headers
== NULL
)
15121 if (filedata
->string_table
== NULL
15122 && filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
15123 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
15125 Elf_Internal_Shdr
* strs
;
15127 /* Read in the string table, so that we have section names to scan. */
15128 strs
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
15130 if (strs
!= NULL
&& strs
->sh_size
!= 0)
15132 filedata
->string_table
15133 = (char *) get_data (NULL
, filedata
, strs
->sh_offset
,
15134 1, strs
->sh_size
, _("string table"));
15136 filedata
->string_table_length
15137 = filedata
->string_table
!= NULL
? strs
->sh_size
: 0;
15141 /* Locate the debug section. */
15142 sec
= find_section_in_set (filedata
, section
->uncompressed_name
, section_subset
);
15144 section
->name
= section
->uncompressed_name
;
15147 sec
= find_section_in_set (filedata
, section
->compressed_name
, section_subset
);
15149 section
->name
= section
->compressed_name
;
15154 /* If we're loading from a subset of sections, and we've loaded
15155 a section matching this name before, it's likely that it's a
15157 if (section_subset
!= NULL
)
15158 free_debug_section (debug
);
15160 return load_specific_debug_section (debug
, sec
, data
);
15164 free_debug_section (enum dwarf_section_display_enum debug
)
15166 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
15168 if (section
->start
== NULL
)
15171 free ((char *) section
->start
);
15172 section
->start
= NULL
;
15173 section
->address
= 0;
15176 free (section
->reloc_info
);
15177 section
->reloc_info
= NULL
;
15178 section
->num_relocs
= 0;
15182 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, Filedata
* filedata
)
15184 char * name
= SECTION_NAME_VALID (section
) ? SECTION_NAME (section
) : "";
15185 const char * print_name
= printable_section_name (filedata
, section
);
15186 bfd_size_type length
;
15187 bfd_boolean result
= TRUE
;
15190 length
= section
->sh_size
;
15193 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
15196 if (section
->sh_type
== SHT_NOBITS
)
15198 /* There is no point in dumping the contents of a debugging section
15199 which has the NOBITS type - the bits in the file will be random.
15200 This can happen when a file containing a .eh_frame section is
15201 stripped with the --only-keep-debug command line option. */
15202 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
15207 if (const_strneq (name
, ".gnu.linkonce.wi."))
15208 name
= ".debug_info";
15210 /* See if we know how to display the contents of this section. */
15211 for (i
= 0; i
< max
; i
++)
15213 enum dwarf_section_display_enum id
= (enum dwarf_section_display_enum
) i
;
15214 struct dwarf_section_display
* display
= debug_displays
+ i
;
15215 struct dwarf_section
* sec
= & display
->section
;
15217 if (streq (sec
->uncompressed_name
, name
)
15218 || (id
== line
&& const_strneq (name
, ".debug_line."))
15219 || streq (sec
->compressed_name
, name
))
15221 bfd_boolean secondary
= (section
!= find_section (filedata
, name
));
15224 free_debug_section (id
);
15226 if (i
== line
&& const_strneq (name
, ".debug_line."))
15228 else if (streq (sec
->uncompressed_name
, name
))
15229 sec
->name
= sec
->uncompressed_name
;
15231 sec
->name
= sec
->compressed_name
;
15233 if (load_specific_debug_section (id
, section
, filedata
))
15235 /* If this debug section is part of a CU/TU set in a .dwp file,
15236 restrict load_debug_section to the sections in that set. */
15237 section_subset
= find_cu_tu_set (filedata
, shndx
);
15239 result
&= display
->display (sec
, filedata
);
15241 section_subset
= NULL
;
15243 if (secondary
|| (id
!= info
&& id
!= abbrev
))
15244 free_debug_section (id
);
15252 printf (_("Unrecognized debug section: %s\n"), print_name
);
15259 /* Set DUMP_SECTS for all sections where dumps were requested
15260 based on section name. */
15263 initialise_dumps_byname (Filedata
* filedata
)
15265 struct dump_list_entry
* cur
;
15267 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
15270 bfd_boolean any
= FALSE
;
15272 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
15273 if (SECTION_NAME_VALID (filedata
->section_headers
+ i
)
15274 && streq (SECTION_NAME (filedata
->section_headers
+ i
), cur
->name
))
15276 request_dump_bynumber (&filedata
->dump
, i
, cur
->type
);
15281 warn (_("Section '%s' was not dumped because it does not exist!\n"),
15287 process_section_contents (Filedata
* filedata
)
15289 Elf_Internal_Shdr
* section
;
15291 bfd_boolean res
= TRUE
;
15296 initialise_dumps_byname (filedata
);
15298 for (i
= 0, section
= filedata
->section_headers
;
15299 i
< filedata
->file_header
.e_shnum
&& i
< filedata
->dump
.num_dump_sects
;
15302 dump_type dump
= filedata
->dump
.dump_sects
[i
];
15304 #ifdef SUPPORT_DISASSEMBLY
15305 if (dump
& DISASS_DUMP
)
15307 if (! disassemble_section (section
, filedata
))
15311 if (dump
& HEX_DUMP
)
15313 if (! dump_section_as_bytes (section
, filedata
, FALSE
))
15317 if (dump
& RELOC_DUMP
)
15319 if (! dump_section_as_bytes (section
, filedata
, TRUE
))
15323 if (dump
& STRING_DUMP
)
15325 if (! dump_section_as_strings (section
, filedata
))
15329 if (dump
& DEBUG_DUMP
)
15331 if (! display_debug_section (i
, section
, filedata
))
15335 #ifdef ENABLE_LIBCTF
15336 if (dump
& CTF_DUMP
)
15338 if (! dump_section_as_ctf (section
, filedata
))
15344 /* Check to see if the user requested a
15345 dump of a section that does not exist. */
15346 while (i
< filedata
->dump
.num_dump_sects
)
15348 if (filedata
->dump
.dump_sects
[i
])
15350 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
15360 process_mips_fpe_exception (int mask
)
15364 bfd_boolean first
= TRUE
;
15366 if (mask
& OEX_FPU_INEX
)
15367 fputs ("INEX", stdout
), first
= FALSE
;
15368 if (mask
& OEX_FPU_UFLO
)
15369 printf ("%sUFLO", first
? "" : "|"), first
= FALSE
;
15370 if (mask
& OEX_FPU_OFLO
)
15371 printf ("%sOFLO", first
? "" : "|"), first
= FALSE
;
15372 if (mask
& OEX_FPU_DIV0
)
15373 printf ("%sDIV0", first
? "" : "|"), first
= FALSE
;
15374 if (mask
& OEX_FPU_INVAL
)
15375 printf ("%sINVAL", first
? "" : "|");
15378 fputs ("0", stdout
);
15381 /* Display's the value of TAG at location P. If TAG is
15382 greater than 0 it is assumed to be an unknown tag, and
15383 a message is printed to this effect. Otherwise it is
15384 assumed that a message has already been printed.
15386 If the bottom bit of TAG is set it assumed to have a
15387 string value, otherwise it is assumed to have an integer
15390 Returns an updated P pointing to the first unread byte
15391 beyond the end of TAG's value.
15393 Reads at or beyond END will not be made. */
15395 static unsigned char *
15396 display_tag_value (signed int tag
,
15398 const unsigned char * const end
)
15403 printf (" Tag_unknown_%d: ", tag
);
15407 warn (_("<corrupt tag>\n"));
15411 /* PR 17531 file: 027-19978-0.004. */
15412 size_t maxlen
= (end
- p
) - 1;
15417 print_symbol ((int) maxlen
, (const char *) p
);
15418 p
+= strnlen ((char *) p
, maxlen
) + 1;
15422 printf (_("<corrupt string tag>"));
15423 p
= (unsigned char *) end
;
15429 READ_ULEB (val
, p
, end
);
15430 printf ("%ld (0x%lx)\n", val
, val
);
15437 /* ARC ABI attributes section. */
15439 static unsigned char *
15440 display_arc_attribute (unsigned char * p
,
15441 const unsigned char * const end
)
15446 READ_ULEB (tag
, p
, end
);
15450 case Tag_ARC_PCS_config
:
15451 READ_ULEB (val
, p
, end
);
15452 printf (" Tag_ARC_PCS_config: ");
15456 printf (_("Absent/Non standard\n"));
15459 printf (_("Bare metal/mwdt\n"));
15462 printf (_("Bare metal/newlib\n"));
15465 printf (_("Linux/uclibc\n"));
15468 printf (_("Linux/glibc\n"));
15471 printf (_("Unknown\n"));
15476 case Tag_ARC_CPU_base
:
15477 READ_ULEB (val
, p
, end
);
15478 printf (" Tag_ARC_CPU_base: ");
15483 printf (_("Absent\n"));
15485 case TAG_CPU_ARC6xx
:
15486 printf ("ARC6xx\n");
15488 case TAG_CPU_ARC7xx
:
15489 printf ("ARC7xx\n");
15491 case TAG_CPU_ARCEM
:
15492 printf ("ARCEM\n");
15494 case TAG_CPU_ARCHS
:
15495 printf ("ARCHS\n");
15500 case Tag_ARC_CPU_variation
:
15501 READ_ULEB (val
, p
, end
);
15502 printf (" Tag_ARC_CPU_variation: ");
15506 if (val
> 0 && val
< 16)
15507 printf ("Core%d\n", val
);
15509 printf ("Unknown\n");
15513 printf (_("Absent\n"));
15518 case Tag_ARC_CPU_name
:
15519 printf (" Tag_ARC_CPU_name: ");
15520 p
= display_tag_value (-1, p
, end
);
15523 case Tag_ARC_ABI_rf16
:
15524 READ_ULEB (val
, p
, end
);
15525 printf (" Tag_ARC_ABI_rf16: %s\n", val
? _("yes") : _("no"));
15528 case Tag_ARC_ABI_osver
:
15529 READ_ULEB (val
, p
, end
);
15530 printf (" Tag_ARC_ABI_osver: v%d\n", val
);
15533 case Tag_ARC_ABI_pic
:
15534 case Tag_ARC_ABI_sda
:
15535 READ_ULEB (val
, p
, end
);
15536 printf (tag
== Tag_ARC_ABI_sda
? " Tag_ARC_ABI_sda: "
15537 : " Tag_ARC_ABI_pic: ");
15541 printf (_("Absent\n"));
15550 printf (_("Unknown\n"));
15555 case Tag_ARC_ABI_tls
:
15556 READ_ULEB (val
, p
, end
);
15557 printf (" Tag_ARC_ABI_tls: %s\n", val
? "r25": "none");
15560 case Tag_ARC_ABI_enumsize
:
15561 READ_ULEB (val
, p
, end
);
15562 printf (" Tag_ARC_ABI_enumsize: %s\n", val
? _("default") :
15566 case Tag_ARC_ABI_exceptions
:
15567 READ_ULEB (val
, p
, end
);
15568 printf (" Tag_ARC_ABI_exceptions: %s\n", val
? _("OPTFP")
15572 case Tag_ARC_ABI_double_size
:
15573 READ_ULEB (val
, p
, end
);
15574 printf (" Tag_ARC_ABI_double_size: %d\n", val
);
15577 case Tag_ARC_ISA_config
:
15578 printf (" Tag_ARC_ISA_config: ");
15579 p
= display_tag_value (-1, p
, end
);
15582 case Tag_ARC_ISA_apex
:
15583 printf (" Tag_ARC_ISA_apex: ");
15584 p
= display_tag_value (-1, p
, end
);
15587 case Tag_ARC_ISA_mpy_option
:
15588 READ_ULEB (val
, p
, end
);
15589 printf (" Tag_ARC_ISA_mpy_option: %d\n", val
);
15592 case Tag_ARC_ATR_version
:
15593 READ_ULEB (val
, p
, end
);
15594 printf (" Tag_ARC_ATR_version: %d\n", val
);
15598 return display_tag_value (tag
& 1, p
, end
);
15604 /* ARM EABI attributes section. */
15609 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
15611 const char *const *table
;
15612 } arm_attr_public_tag
;
15614 static const char *const arm_attr_tag_CPU_arch
[] =
15615 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
15616 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
15617 "v8-M.mainline", "", "", "", "v8.1-M.mainline"};
15618 static const char *const arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
15619 static const char *const arm_attr_tag_THUMB_ISA_use
[] =
15620 {"No", "Thumb-1", "Thumb-2", "Yes"};
15621 static const char *const arm_attr_tag_FP_arch
[] =
15622 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
15623 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
15624 static const char *const arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
15625 static const char *const arm_attr_tag_Advanced_SIMD_arch
[] =
15626 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
15627 "NEON for ARMv8.1"};
15628 static const char *const arm_attr_tag_PCS_config
[] =
15629 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
15630 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
15631 static const char *const arm_attr_tag_ABI_PCS_R9_use
[] =
15632 {"V6", "SB", "TLS", "Unused"};
15633 static const char *const arm_attr_tag_ABI_PCS_RW_data
[] =
15634 {"Absolute", "PC-relative", "SB-relative", "None"};
15635 static const char *const arm_attr_tag_ABI_PCS_RO_data
[] =
15636 {"Absolute", "PC-relative", "None"};
15637 static const char *const arm_attr_tag_ABI_PCS_GOT_use
[] =
15638 {"None", "direct", "GOT-indirect"};
15639 static const char *const arm_attr_tag_ABI_PCS_wchar_t
[] =
15640 {"None", "??? 1", "2", "??? 3", "4"};
15641 static const char *const arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
15642 static const char *const arm_attr_tag_ABI_FP_denormal
[] =
15643 {"Unused", "Needed", "Sign only"};
15644 static const char *const arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
15645 static const char *const arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
15646 static const char *const arm_attr_tag_ABI_FP_number_model
[] =
15647 {"Unused", "Finite", "RTABI", "IEEE 754"};
15648 static const char *const arm_attr_tag_ABI_enum_size
[] =
15649 {"Unused", "small", "int", "forced to int"};
15650 static const char *const arm_attr_tag_ABI_HardFP_use
[] =
15651 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
15652 static const char *const arm_attr_tag_ABI_VFP_args
[] =
15653 {"AAPCS", "VFP registers", "custom", "compatible"};
15654 static const char *const arm_attr_tag_ABI_WMMX_args
[] =
15655 {"AAPCS", "WMMX registers", "custom"};
15656 static const char *const arm_attr_tag_ABI_optimization_goals
[] =
15657 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
15658 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
15659 static const char *const arm_attr_tag_ABI_FP_optimization_goals
[] =
15660 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
15661 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
15662 static const char *const arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
15663 static const char *const arm_attr_tag_FP_HP_extension
[] =
15664 {"Not Allowed", "Allowed"};
15665 static const char *const arm_attr_tag_ABI_FP_16bit_format
[] =
15666 {"None", "IEEE 754", "Alternative Format"};
15667 static const char *const arm_attr_tag_DSP_extension
[] =
15668 {"Follow architecture", "Allowed"};
15669 static const char *const arm_attr_tag_MPextension_use
[] =
15670 {"Not Allowed", "Allowed"};
15671 static const char *const arm_attr_tag_DIV_use
[] =
15672 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
15673 "Allowed in v7-A with integer division extension"};
15674 static const char *const arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
15675 static const char *const arm_attr_tag_Virtualization_use
[] =
15676 {"Not Allowed", "TrustZone", "Virtualization Extensions",
15677 "TrustZone and Virtualization Extensions"};
15678 static const char *const arm_attr_tag_MPextension_use_legacy
[] =
15679 {"Not Allowed", "Allowed"};
15681 static const char *const arm_attr_tag_MVE_arch
[] =
15682 {"No MVE", "MVE Integer only", "MVE Integer and FP"};
15684 #define LOOKUP(id, name) \
15685 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
15686 static arm_attr_public_tag arm_attr_public_tags
[] =
15688 {4, "CPU_raw_name", 1, NULL
},
15689 {5, "CPU_name", 1, NULL
},
15690 LOOKUP(6, CPU_arch
),
15691 {7, "CPU_arch_profile", 0, NULL
},
15692 LOOKUP(8, ARM_ISA_use
),
15693 LOOKUP(9, THUMB_ISA_use
),
15694 LOOKUP(10, FP_arch
),
15695 LOOKUP(11, WMMX_arch
),
15696 LOOKUP(12, Advanced_SIMD_arch
),
15697 LOOKUP(13, PCS_config
),
15698 LOOKUP(14, ABI_PCS_R9_use
),
15699 LOOKUP(15, ABI_PCS_RW_data
),
15700 LOOKUP(16, ABI_PCS_RO_data
),
15701 LOOKUP(17, ABI_PCS_GOT_use
),
15702 LOOKUP(18, ABI_PCS_wchar_t
),
15703 LOOKUP(19, ABI_FP_rounding
),
15704 LOOKUP(20, ABI_FP_denormal
),
15705 LOOKUP(21, ABI_FP_exceptions
),
15706 LOOKUP(22, ABI_FP_user_exceptions
),
15707 LOOKUP(23, ABI_FP_number_model
),
15708 {24, "ABI_align_needed", 0, NULL
},
15709 {25, "ABI_align_preserved", 0, NULL
},
15710 LOOKUP(26, ABI_enum_size
),
15711 LOOKUP(27, ABI_HardFP_use
),
15712 LOOKUP(28, ABI_VFP_args
),
15713 LOOKUP(29, ABI_WMMX_args
),
15714 LOOKUP(30, ABI_optimization_goals
),
15715 LOOKUP(31, ABI_FP_optimization_goals
),
15716 {32, "compatibility", 0, NULL
},
15717 LOOKUP(34, CPU_unaligned_access
),
15718 LOOKUP(36, FP_HP_extension
),
15719 LOOKUP(38, ABI_FP_16bit_format
),
15720 LOOKUP(42, MPextension_use
),
15721 LOOKUP(44, DIV_use
),
15722 LOOKUP(46, DSP_extension
),
15723 LOOKUP(48, MVE_arch
),
15724 {64, "nodefaults", 0, NULL
},
15725 {65, "also_compatible_with", 0, NULL
},
15726 LOOKUP(66, T2EE_use
),
15727 {67, "conformance", 1, NULL
},
15728 LOOKUP(68, Virtualization_use
),
15729 LOOKUP(70, MPextension_use_legacy
)
15733 static unsigned char *
15734 display_arm_attribute (unsigned char * p
,
15735 const unsigned char * const end
)
15739 arm_attr_public_tag
* attr
;
15743 READ_ULEB (tag
, p
, end
);
15745 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
15747 if (arm_attr_public_tags
[i
].tag
== tag
)
15749 attr
= &arm_attr_public_tags
[i
];
15756 printf (" Tag_%s: ", attr
->name
);
15757 switch (attr
->type
)
15762 case 7: /* Tag_CPU_arch_profile. */
15763 READ_ULEB (val
, p
, end
);
15766 case 0: printf (_("None\n")); break;
15767 case 'A': printf (_("Application\n")); break;
15768 case 'R': printf (_("Realtime\n")); break;
15769 case 'M': printf (_("Microcontroller\n")); break;
15770 case 'S': printf (_("Application or Realtime\n")); break;
15771 default: printf ("??? (%d)\n", val
); break;
15775 case 24: /* Tag_align_needed. */
15776 READ_ULEB (val
, p
, end
);
15779 case 0: printf (_("None\n")); break;
15780 case 1: printf (_("8-byte\n")); break;
15781 case 2: printf (_("4-byte\n")); break;
15782 case 3: printf ("??? 3\n"); break;
15785 printf (_("8-byte and up to %d-byte extended\n"),
15788 printf ("??? (%d)\n", val
);
15793 case 25: /* Tag_align_preserved. */
15794 READ_ULEB (val
, p
, end
);
15797 case 0: printf (_("None\n")); break;
15798 case 1: printf (_("8-byte, except leaf SP\n")); break;
15799 case 2: printf (_("8-byte\n")); break;
15800 case 3: printf ("??? 3\n"); break;
15803 printf (_("8-byte and up to %d-byte extended\n"),
15806 printf ("??? (%d)\n", val
);
15811 case 32: /* Tag_compatibility. */
15813 READ_ULEB (val
, p
, end
);
15814 printf (_("flag = %d, vendor = "), val
);
15817 size_t maxlen
= (end
- p
) - 1;
15819 print_symbol ((int) maxlen
, (const char *) p
);
15820 p
+= strnlen ((char *) p
, maxlen
) + 1;
15824 printf (_("<corrupt>"));
15825 p
= (unsigned char *) end
;
15831 case 64: /* Tag_nodefaults. */
15832 /* PR 17531: file: 001-505008-0.01. */
15835 printf (_("True\n"));
15838 case 65: /* Tag_also_compatible_with. */
15839 READ_ULEB (val
, p
, end
);
15840 if (val
== 6 /* Tag_CPU_arch. */)
15842 READ_ULEB (val
, p
, end
);
15843 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
15844 printf ("??? (%d)\n", val
);
15846 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
15850 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
15855 printf (_("<unknown: %d>\n"), tag
);
15861 return display_tag_value (-1, p
, end
);
15863 return display_tag_value (0, p
, end
);
15866 assert (attr
->type
& 0x80);
15867 READ_ULEB (val
, p
, end
);
15868 type
= attr
->type
& 0x7f;
15870 printf ("??? (%d)\n", val
);
15872 printf ("%s\n", attr
->table
[val
]);
15877 return display_tag_value (tag
, p
, end
);
15880 static unsigned char *
15881 display_gnu_attribute (unsigned char * p
,
15882 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const),
15883 const unsigned char * const end
)
15888 READ_ULEB (tag
, p
, end
);
15890 /* Tag_compatibility is the only generic GNU attribute defined at
15894 READ_ULEB (val
, p
, end
);
15896 printf (_("flag = %d, vendor = "), val
);
15899 printf (_("<corrupt>\n"));
15900 warn (_("corrupt vendor attribute\n"));
15906 size_t maxlen
= (end
- p
) - 1;
15908 print_symbol ((int) maxlen
, (const char *) p
);
15909 p
+= strnlen ((char *) p
, maxlen
) + 1;
15913 printf (_("<corrupt>"));
15914 p
= (unsigned char *) end
;
15921 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
15922 return display_proc_gnu_attribute (p
, tag
, end
);
15924 return display_tag_value (tag
, p
, end
);
15927 static unsigned char *
15928 display_m68k_gnu_attribute (unsigned char * p
,
15930 const unsigned char * const end
)
15934 if (tag
== Tag_GNU_M68K_ABI_FP
)
15936 printf (" Tag_GNU_M68K_ABI_FP: ");
15939 printf (_("<corrupt>\n"));
15942 READ_ULEB (val
, p
, end
);
15945 printf ("(%#x), ", val
);
15950 printf (_("unspecified hard/soft float\n"));
15953 printf (_("hard float\n"));
15956 printf (_("soft float\n"));
15962 return display_tag_value (tag
& 1, p
, end
);
15965 static unsigned char *
15966 display_power_gnu_attribute (unsigned char * p
,
15968 const unsigned char * const end
)
15972 if (tag
== Tag_GNU_Power_ABI_FP
)
15974 printf (" Tag_GNU_Power_ABI_FP: ");
15977 printf (_("<corrupt>\n"));
15980 READ_ULEB (val
, p
, end
);
15983 printf ("(%#x), ", val
);
15988 printf (_("unspecified hard/soft float, "));
15991 printf (_("hard float, "));
15994 printf (_("soft float, "));
15997 printf (_("single-precision hard float, "));
16004 printf (_("unspecified long double\n"));
16007 printf (_("128-bit IBM long double\n"));
16010 printf (_("64-bit long double\n"));
16013 printf (_("128-bit IEEE long double\n"));
16019 if (tag
== Tag_GNU_Power_ABI_Vector
)
16021 printf (" Tag_GNU_Power_ABI_Vector: ");
16024 printf (_("<corrupt>\n"));
16027 READ_ULEB (val
, p
, end
);
16030 printf ("(%#x), ", val
);
16035 printf (_("unspecified\n"));
16038 printf (_("generic\n"));
16041 printf ("AltiVec\n");
16050 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
16052 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
16055 printf (_("<corrupt>\n"));
16058 READ_ULEB (val
, p
, end
);
16061 printf ("(%#x), ", val
);
16066 printf (_("unspecified\n"));
16069 printf ("r3/r4\n");
16072 printf (_("memory\n"));
16081 return display_tag_value (tag
& 1, p
, end
);
16084 static unsigned char *
16085 display_s390_gnu_attribute (unsigned char * p
,
16087 const unsigned char * const end
)
16091 if (tag
== Tag_GNU_S390_ABI_Vector
)
16093 printf (" Tag_GNU_S390_ABI_Vector: ");
16094 READ_ULEB (val
, p
, end
);
16099 printf (_("any\n"));
16102 printf (_("software\n"));
16105 printf (_("hardware\n"));
16108 printf ("??? (%d)\n", val
);
16114 return display_tag_value (tag
& 1, p
, end
);
16118 display_sparc_hwcaps (unsigned int mask
)
16122 bfd_boolean first
= TRUE
;
16124 if (mask
& ELF_SPARC_HWCAP_MUL32
)
16125 fputs ("mul32", stdout
), first
= FALSE
;
16126 if (mask
& ELF_SPARC_HWCAP_DIV32
)
16127 printf ("%sdiv32", first
? "" : "|"), first
= FALSE
;
16128 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
16129 printf ("%sfsmuld", first
? "" : "|"), first
= FALSE
;
16130 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
16131 printf ("%sv8plus", first
? "" : "|"), first
= FALSE
;
16132 if (mask
& ELF_SPARC_HWCAP_POPC
)
16133 printf ("%spopc", first
? "" : "|"), first
= FALSE
;
16134 if (mask
& ELF_SPARC_HWCAP_VIS
)
16135 printf ("%svis", first
? "" : "|"), first
= FALSE
;
16136 if (mask
& ELF_SPARC_HWCAP_VIS2
)
16137 printf ("%svis2", first
? "" : "|"), first
= FALSE
;
16138 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
16139 printf ("%sASIBlkInit", first
? "" : "|"), first
= FALSE
;
16140 if (mask
& ELF_SPARC_HWCAP_FMAF
)
16141 printf ("%sfmaf", first
? "" : "|"), first
= FALSE
;
16142 if (mask
& ELF_SPARC_HWCAP_VIS3
)
16143 printf ("%svis3", first
? "" : "|"), first
= FALSE
;
16144 if (mask
& ELF_SPARC_HWCAP_HPC
)
16145 printf ("%shpc", first
? "" : "|"), first
= FALSE
;
16146 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
16147 printf ("%srandom", first
? "" : "|"), first
= FALSE
;
16148 if (mask
& ELF_SPARC_HWCAP_TRANS
)
16149 printf ("%strans", first
? "" : "|"), first
= FALSE
;
16150 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
16151 printf ("%sfjfmau", first
? "" : "|"), first
= FALSE
;
16152 if (mask
& ELF_SPARC_HWCAP_IMA
)
16153 printf ("%sima", first
? "" : "|"), first
= FALSE
;
16154 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
16155 printf ("%scspare", first
? "" : "|"), first
= FALSE
;
16158 fputc ('0', stdout
);
16159 fputc ('\n', stdout
);
16163 display_sparc_hwcaps2 (unsigned int mask
)
16167 bfd_boolean first
= TRUE
;
16169 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
16170 fputs ("fjathplus", stdout
), first
= FALSE
;
16171 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
16172 printf ("%svis3b", first
? "" : "|"), first
= FALSE
;
16173 if (mask
& ELF_SPARC_HWCAP2_ADP
)
16174 printf ("%sadp", first
? "" : "|"), first
= FALSE
;
16175 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
16176 printf ("%ssparc5", first
? "" : "|"), first
= FALSE
;
16177 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
16178 printf ("%smwait", first
? "" : "|"), first
= FALSE
;
16179 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
16180 printf ("%sxmpmul", first
? "" : "|"), first
= FALSE
;
16181 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
16182 printf ("%sxmont2", first
? "" : "|"), first
= FALSE
;
16183 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
16184 printf ("%snsec", first
? "" : "|"), first
= FALSE
;
16185 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
16186 printf ("%sfjathhpc", first
? "" : "|"), first
= FALSE
;
16187 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
16188 printf ("%sfjdes", first
? "" : "|"), first
= FALSE
;
16189 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
16190 printf ("%sfjaes", first
? "" : "|"), first
= FALSE
;
16193 fputc ('0', stdout
);
16194 fputc ('\n', stdout
);
16197 static unsigned char *
16198 display_sparc_gnu_attribute (unsigned char * p
,
16200 const unsigned char * const end
)
16204 if (tag
== Tag_GNU_Sparc_HWCAPS
)
16206 READ_ULEB (val
, p
, end
);
16207 printf (" Tag_GNU_Sparc_HWCAPS: ");
16208 display_sparc_hwcaps (val
);
16211 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
16213 READ_ULEB (val
, p
, end
);
16214 printf (" Tag_GNU_Sparc_HWCAPS2: ");
16215 display_sparc_hwcaps2 (val
);
16219 return display_tag_value (tag
, p
, end
);
16223 print_mips_fp_abi_value (unsigned int val
)
16227 case Val_GNU_MIPS_ABI_FP_ANY
:
16228 printf (_("Hard or soft float\n"));
16230 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
16231 printf (_("Hard float (double precision)\n"));
16233 case Val_GNU_MIPS_ABI_FP_SINGLE
:
16234 printf (_("Hard float (single precision)\n"));
16236 case Val_GNU_MIPS_ABI_FP_SOFT
:
16237 printf (_("Soft float\n"));
16239 case Val_GNU_MIPS_ABI_FP_OLD_64
:
16240 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
16242 case Val_GNU_MIPS_ABI_FP_XX
:
16243 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
16245 case Val_GNU_MIPS_ABI_FP_64
:
16246 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
16248 case Val_GNU_MIPS_ABI_FP_64A
:
16249 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
16251 case Val_GNU_MIPS_ABI_FP_NAN2008
:
16252 printf (_("NaN 2008 compatibility\n"));
16255 printf ("??? (%d)\n", val
);
16260 static unsigned char *
16261 display_mips_gnu_attribute (unsigned char * p
,
16263 const unsigned char * const end
)
16265 if (tag
== Tag_GNU_MIPS_ABI_FP
)
16269 printf (" Tag_GNU_MIPS_ABI_FP: ");
16270 READ_ULEB (val
, p
, end
);
16271 print_mips_fp_abi_value (val
);
16275 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
16279 printf (" Tag_GNU_MIPS_ABI_MSA: ");
16280 READ_ULEB (val
, p
, end
);
16284 case Val_GNU_MIPS_ABI_MSA_ANY
:
16285 printf (_("Any MSA or not\n"));
16287 case Val_GNU_MIPS_ABI_MSA_128
:
16288 printf (_("128-bit MSA\n"));
16291 printf ("??? (%d)\n", val
);
16297 return display_tag_value (tag
& 1, p
, end
);
16300 static unsigned char *
16301 display_tic6x_attribute (unsigned char * p
,
16302 const unsigned char * const end
)
16307 READ_ULEB (tag
, p
, end
);
16312 printf (" Tag_ISA: ");
16313 READ_ULEB (val
, p
, end
);
16317 case C6XABI_Tag_ISA_none
:
16318 printf (_("None\n"));
16320 case C6XABI_Tag_ISA_C62X
:
16323 case C6XABI_Tag_ISA_C67X
:
16326 case C6XABI_Tag_ISA_C67XP
:
16327 printf ("C67x+\n");
16329 case C6XABI_Tag_ISA_C64X
:
16332 case C6XABI_Tag_ISA_C64XP
:
16333 printf ("C64x+\n");
16335 case C6XABI_Tag_ISA_C674X
:
16336 printf ("C674x\n");
16339 printf ("??? (%d)\n", val
);
16344 case Tag_ABI_wchar_t
:
16345 printf (" Tag_ABI_wchar_t: ");
16346 READ_ULEB (val
, p
, end
);
16350 printf (_("Not used\n"));
16353 printf (_("2 bytes\n"));
16356 printf (_("4 bytes\n"));
16359 printf ("??? (%d)\n", val
);
16364 case Tag_ABI_stack_align_needed
:
16365 printf (" Tag_ABI_stack_align_needed: ");
16366 READ_ULEB (val
, p
, end
);
16370 printf (_("8-byte\n"));
16373 printf (_("16-byte\n"));
16376 printf ("??? (%d)\n", val
);
16381 case Tag_ABI_stack_align_preserved
:
16382 READ_ULEB (val
, p
, end
);
16383 printf (" Tag_ABI_stack_align_preserved: ");
16387 printf (_("8-byte\n"));
16390 printf (_("16-byte\n"));
16393 printf ("??? (%d)\n", val
);
16399 READ_ULEB (val
, p
, end
);
16400 printf (" Tag_ABI_DSBT: ");
16404 printf (_("DSBT addressing not used\n"));
16407 printf (_("DSBT addressing used\n"));
16410 printf ("??? (%d)\n", val
);
16416 READ_ULEB (val
, p
, end
);
16417 printf (" Tag_ABI_PID: ");
16421 printf (_("Data addressing position-dependent\n"));
16424 printf (_("Data addressing position-independent, GOT near DP\n"));
16427 printf (_("Data addressing position-independent, GOT far from DP\n"));
16430 printf ("??? (%d)\n", val
);
16436 READ_ULEB (val
, p
, end
);
16437 printf (" Tag_ABI_PIC: ");
16441 printf (_("Code addressing position-dependent\n"));
16444 printf (_("Code addressing position-independent\n"));
16447 printf ("??? (%d)\n", val
);
16452 case Tag_ABI_array_object_alignment
:
16453 READ_ULEB (val
, p
, end
);
16454 printf (" Tag_ABI_array_object_alignment: ");
16458 printf (_("8-byte\n"));
16461 printf (_("4-byte\n"));
16464 printf (_("16-byte\n"));
16467 printf ("??? (%d)\n", val
);
16472 case Tag_ABI_array_object_align_expected
:
16473 READ_ULEB (val
, p
, end
);
16474 printf (" Tag_ABI_array_object_align_expected: ");
16478 printf (_("8-byte\n"));
16481 printf (_("4-byte\n"));
16484 printf (_("16-byte\n"));
16487 printf ("??? (%d)\n", val
);
16492 case Tag_ABI_compatibility
:
16494 READ_ULEB (val
, p
, end
);
16495 printf (" Tag_ABI_compatibility: ");
16496 printf (_("flag = %d, vendor = "), val
);
16499 size_t maxlen
= (end
- p
) - 1;
16501 print_symbol ((int) maxlen
, (const char *) p
);
16502 p
+= strnlen ((char *) p
, maxlen
) + 1;
16506 printf (_("<corrupt>"));
16507 p
= (unsigned char *) end
;
16513 case Tag_ABI_conformance
:
16515 printf (" Tag_ABI_conformance: \"");
16518 size_t maxlen
= (end
- p
) - 1;
16520 print_symbol ((int) maxlen
, (const char *) p
);
16521 p
+= strnlen ((char *) p
, maxlen
) + 1;
16525 printf (_("<corrupt>"));
16526 p
= (unsigned char *) end
;
16533 return display_tag_value (tag
, p
, end
);
16537 display_raw_attribute (unsigned char * p
, unsigned char const * const end
)
16539 unsigned long addr
= 0;
16540 size_t bytes
= end
- p
;
16547 int lbytes
= (bytes
> 16 ? 16 : bytes
);
16549 printf (" 0x%8.8lx ", addr
);
16551 for (j
= 0; j
< 16; j
++)
16554 printf ("%2.2x", p
[j
]);
16562 for (j
= 0; j
< lbytes
; j
++)
16565 if (k
>= ' ' && k
< 0x7f)
16581 static unsigned char *
16582 display_msp430_attribute (unsigned char * p
,
16583 const unsigned char * const end
)
16588 READ_ULEB (tag
, p
, end
);
16592 case OFBA_MSPABI_Tag_ISA
:
16593 printf (" Tag_ISA: ");
16594 READ_ULEB (val
, p
, end
);
16597 case 0: printf (_("None\n")); break;
16598 case 1: printf (_("MSP430\n")); break;
16599 case 2: printf (_("MSP430X\n")); break;
16600 default: printf ("??? (%d)\n", val
); break;
16604 case OFBA_MSPABI_Tag_Code_Model
:
16605 printf (" Tag_Code_Model: ");
16606 READ_ULEB (val
, p
, end
);
16609 case 0: printf (_("None\n")); break;
16610 case 1: printf (_("Small\n")); break;
16611 case 2: printf (_("Large\n")); break;
16612 default: printf ("??? (%d)\n", val
); break;
16616 case OFBA_MSPABI_Tag_Data_Model
:
16617 printf (" Tag_Data_Model: ");
16618 READ_ULEB (val
, p
, end
);
16621 case 0: printf (_("None\n")); break;
16622 case 1: printf (_("Small\n")); break;
16623 case 2: printf (_("Large\n")); break;
16624 case 3: printf (_("Restricted Large\n")); break;
16625 default: printf ("??? (%d)\n", val
); break;
16630 printf (_(" <unknown tag %d>: "), tag
);
16637 size_t maxlen
= (end
- p
) - 1;
16639 print_symbol ((int) maxlen
, (const char *) p
);
16640 p
+= strnlen ((char *) p
, maxlen
) + 1;
16644 printf (_("<corrupt>"));
16645 p
= (unsigned char *) end
;
16651 READ_ULEB (val
, p
, end
);
16652 printf ("%d (0x%x)\n", val
, val
);
16661 static unsigned char *
16662 display_msp430_gnu_attribute (unsigned char * p
,
16664 const unsigned char * const end
)
16666 if (tag
== Tag_GNU_MSP430_Data_Region
)
16670 printf (" Tag_GNU_MSP430_Data_Region: ");
16671 READ_ULEB (val
, p
, end
);
16675 case Val_GNU_MSP430_Data_Region_Any
:
16676 printf (_("Any Region\n"));
16678 case Val_GNU_MSP430_Data_Region_Lower
:
16679 printf (_("Lower Region Only\n"));
16682 printf ("??? (%u)\n", val
);
16686 return display_tag_value (tag
& 1, p
, end
);
16689 struct riscv_attr_tag_t
{
16694 static struct riscv_attr_tag_t riscv_attr_tag
[] =
16696 #define T(tag) {"Tag_RISCV_" #tag, Tag_RISCV_##tag}
16699 T(priv_spec_minor
),
16700 T(priv_spec_revision
),
16701 T(unaligned_access
),
16706 static unsigned char *
16707 display_riscv_attribute (unsigned char *p
,
16708 const unsigned char * const end
)
16712 struct riscv_attr_tag_t
*attr
= NULL
;
16715 READ_ULEB (tag
, p
, end
);
16717 /* Find the name of attribute. */
16718 for (i
= 0; i
< ARRAY_SIZE (riscv_attr_tag
); i
++)
16720 if (riscv_attr_tag
[i
].tag
== tag
)
16722 attr
= &riscv_attr_tag
[i
];
16728 printf (" %s: ", attr
->name
);
16730 return display_tag_value (tag
, p
, end
);
16734 case Tag_RISCV_priv_spec
:
16735 case Tag_RISCV_priv_spec_minor
:
16736 case Tag_RISCV_priv_spec_revision
:
16737 READ_ULEB (val
, p
, end
);
16738 printf (_("%u\n"), val
);
16740 case Tag_RISCV_unaligned_access
:
16741 READ_ULEB (val
, p
, end
);
16745 printf (_("No unaligned access\n"));
16748 printf (_("Unaligned access\n"));
16752 case Tag_RISCV_stack_align
:
16753 READ_ULEB (val
, p
, end
);
16754 printf (_("%u-bytes\n"), val
);
16756 case Tag_RISCV_arch
:
16757 p
= display_tag_value (-1, p
, end
);
16760 return display_tag_value (tag
, p
, end
);
16766 static unsigned char *
16767 display_csky_attribute (unsigned char * p
,
16768 const unsigned char * const end
)
16772 READ_ULEB (tag
, p
, end
);
16774 if (tag
>= Tag_CSKY_MAX
)
16776 return display_tag_value (-1, p
, end
);
16781 case Tag_CSKY_ARCH_NAME
:
16782 printf (" Tag_CSKY_ARCH_NAME:\t\t");
16783 return display_tag_value (-1, p
, end
);
16784 case Tag_CSKY_CPU_NAME
:
16785 printf (" Tag_CSKY_CPU_NAME:\t\t");
16786 return display_tag_value (-1, p
, end
);
16788 case Tag_CSKY_ISA_FLAGS
:
16789 printf (" Tag_CSKY_ISA_FLAGS:\t\t");
16790 return display_tag_value (0, p
, end
);
16791 case Tag_CSKY_ISA_EXT_FLAGS
:
16792 printf (" Tag_CSKY_ISA_EXT_FLAGS:\t");
16793 return display_tag_value (0, p
, end
);
16795 case Tag_CSKY_DSP_VERSION
:
16796 printf (" Tag_CSKY_DSP_VERSION:\t\t");
16797 READ_ULEB (val
, p
, end
);
16798 if (val
== VAL_CSKY_DSP_VERSION_EXTENSION
)
16799 printf ("DSP Extension\n");
16800 else if (val
== VAL_CSKY_DSP_VERSION_2
)
16801 printf ("DSP 2.0\n");
16804 case Tag_CSKY_VDSP_VERSION
:
16805 printf (" Tag_CSKY_VDSP_VERSION:\t");
16806 READ_ULEB (val
, p
, end
);
16807 printf ("VDSP Version %d\n", val
);
16810 case Tag_CSKY_FPU_VERSION
:
16811 printf (" Tag_CSKY_FPU_VERSION:\t\t");
16812 READ_ULEB (val
, p
, end
);
16813 if (val
== VAL_CSKY_FPU_VERSION_1
)
16814 printf ("ABIV1 FPU Version 1\n");
16815 else if (val
== VAL_CSKY_FPU_VERSION_2
)
16816 printf ("FPU Version 2\n");
16819 case Tag_CSKY_FPU_ABI
:
16820 printf (" Tag_CSKY_FPU_ABI:\t\t");
16821 READ_ULEB (val
, p
, end
);
16822 if (val
== VAL_CSKY_FPU_ABI_HARD
)
16824 else if (val
== VAL_CSKY_FPU_ABI_SOFTFP
)
16825 printf ("SoftFP\n");
16826 else if (val
== VAL_CSKY_FPU_ABI_SOFT
)
16829 case Tag_CSKY_FPU_ROUNDING
:
16830 READ_ULEB (val
, p
, end
);
16832 printf (" Tag_CSKY_FPU_ROUNDING:\t");
16833 printf ("Needed\n");
16836 case Tag_CSKY_FPU_DENORMAL
:
16837 READ_ULEB (val
, p
, end
);
16839 printf (" Tag_CSKY_FPU_DENORMAL:\t");
16840 printf ("Needed\n");
16843 case Tag_CSKY_FPU_Exception
:
16844 READ_ULEB (val
, p
, end
);
16846 printf (" Tag_CSKY_FPU_Exception:\t");
16847 printf ("Needed\n");
16850 case Tag_CSKY_FPU_NUMBER_MODULE
:
16851 printf (" Tag_CSKY_FPU_NUMBER_MODULE:\t");
16852 return display_tag_value (-1, p
, end
);
16853 case Tag_CSKY_FPU_HARDFP
:
16854 printf (" Tag_CSKY_FPU_HARDFP:\t\t");
16855 READ_ULEB (val
, p
, end
);
16856 if (val
& VAL_CSKY_FPU_HARDFP_HALF
)
16858 if (val
& VAL_CSKY_FPU_HARDFP_SINGLE
)
16859 printf (" Single");
16860 if (val
& VAL_CSKY_FPU_HARDFP_DOUBLE
)
16861 printf (" Double");
16865 return display_tag_value (tag
, p
, end
);
16871 process_attributes (Filedata
* filedata
,
16872 const char * public_name
,
16873 unsigned int proc_type
,
16874 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
16875 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const))
16877 Elf_Internal_Shdr
* sect
;
16879 bfd_boolean res
= TRUE
;
16881 /* Find the section header so that we get the size. */
16882 for (i
= 0, sect
= filedata
->section_headers
;
16883 i
< filedata
->file_header
.e_shnum
;
16886 unsigned char * contents
;
16889 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
16892 contents
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
, 1,
16893 sect
->sh_size
, _("attributes"));
16894 if (contents
== NULL
)
16901 /* The first character is the version of the attributes.
16902 Currently only version 1, (aka 'A') is recognised here. */
16905 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p
, *p
);
16910 bfd_vma section_len
;
16912 section_len
= sect
->sh_size
- 1;
16915 while (section_len
> 0)
16918 unsigned int namelen
;
16919 bfd_boolean public_section
;
16920 bfd_boolean gnu_section
;
16922 if (section_len
<= 4)
16924 error (_("Tag section ends prematurely\n"));
16928 attr_len
= byte_get (p
, 4);
16931 if (attr_len
> section_len
)
16933 error (_("Bad attribute length (%u > %u)\n"),
16934 (unsigned) attr_len
, (unsigned) section_len
);
16935 attr_len
= section_len
;
16938 /* PR 17531: file: 001-101425-0.004 */
16939 else if (attr_len
< 5)
16941 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
16946 section_len
-= attr_len
;
16949 namelen
= strnlen ((char *) p
, attr_len
) + 1;
16950 if (namelen
== 0 || namelen
>= attr_len
)
16952 error (_("Corrupt attribute section name\n"));
16957 printf (_("Attribute Section: "));
16958 print_symbol (INT_MAX
, (const char *) p
);
16961 if (public_name
&& streq ((char *) p
, public_name
))
16962 public_section
= TRUE
;
16964 public_section
= FALSE
;
16966 if (streq ((char *) p
, "gnu"))
16967 gnu_section
= TRUE
;
16969 gnu_section
= FALSE
;
16972 attr_len
-= namelen
;
16974 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
16979 unsigned char * end
;
16981 /* PR binutils/17531: Safe handling of corrupt files. */
16984 error (_("Unused bytes at end of section\n"));
16991 size
= byte_get (p
, 4);
16992 if (size
> attr_len
)
16994 error (_("Bad subsection length (%u > %u)\n"),
16995 (unsigned) size
, (unsigned) attr_len
);
16999 /* PR binutils/17531: Safe handling of corrupt files. */
17002 error (_("Bad subsection length (%u < 6)\n"),
17010 end
= p
+ size
- 1;
17011 assert (end
<= contents
+ sect
->sh_size
);
17017 printf (_("File Attributes\n"));
17020 printf (_("Section Attributes:"));
17023 printf (_("Symbol Attributes:"));
17024 /* Fall through. */
17028 READ_ULEB (val
, p
, end
);
17031 printf (" %d", val
);
17036 printf (_("Unknown tag: %d\n"), tag
);
17037 public_section
= FALSE
;
17041 if (public_section
&& display_pub_attribute
!= NULL
)
17044 p
= display_pub_attribute (p
, end
);
17047 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
17050 p
= display_gnu_attribute (p
,
17051 display_proc_gnu_attribute
,
17057 printf (_(" Unknown attribute:\n"));
17058 display_raw_attribute (p
, end
);
17073 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
17074 Print the Address, Access and Initial fields of an entry at VMA ADDR
17075 and return the VMA of the next entry, or -1 if there was a problem.
17076 Does not read from DATA_END or beyond. */
17079 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
17080 unsigned char * data_end
)
17083 print_vma (addr
, LONG_HEX
);
17085 if (addr
< pltgot
+ 0xfff0)
17086 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
17088 printf ("%10s", "");
17091 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
17095 unsigned char * from
= data
+ addr
- pltgot
;
17097 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
17099 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
17100 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
17101 return (bfd_vma
) -1;
17105 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
17106 print_vma (entry
, LONG_HEX
);
17109 return addr
+ (is_32bit_elf
? 4 : 8);
17112 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
17113 PLTGOT. Print the Address and Initial fields of an entry at VMA
17114 ADDR and return the VMA of the next entry. */
17117 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
17120 print_vma (addr
, LONG_HEX
);
17123 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
17128 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
17129 print_vma (entry
, LONG_HEX
);
17131 return addr
+ (is_32bit_elf
? 4 : 8);
17135 print_mips_ases (unsigned int mask
)
17137 if (mask
& AFL_ASE_DSP
)
17138 fputs ("\n\tDSP ASE", stdout
);
17139 if (mask
& AFL_ASE_DSPR2
)
17140 fputs ("\n\tDSP R2 ASE", stdout
);
17141 if (mask
& AFL_ASE_DSPR3
)
17142 fputs ("\n\tDSP R3 ASE", stdout
);
17143 if (mask
& AFL_ASE_EVA
)
17144 fputs ("\n\tEnhanced VA Scheme", stdout
);
17145 if (mask
& AFL_ASE_MCU
)
17146 fputs ("\n\tMCU (MicroController) ASE", stdout
);
17147 if (mask
& AFL_ASE_MDMX
)
17148 fputs ("\n\tMDMX ASE", stdout
);
17149 if (mask
& AFL_ASE_MIPS3D
)
17150 fputs ("\n\tMIPS-3D ASE", stdout
);
17151 if (mask
& AFL_ASE_MT
)
17152 fputs ("\n\tMT ASE", stdout
);
17153 if (mask
& AFL_ASE_SMARTMIPS
)
17154 fputs ("\n\tSmartMIPS ASE", stdout
);
17155 if (mask
& AFL_ASE_VIRT
)
17156 fputs ("\n\tVZ ASE", stdout
);
17157 if (mask
& AFL_ASE_MSA
)
17158 fputs ("\n\tMSA ASE", stdout
);
17159 if (mask
& AFL_ASE_MIPS16
)
17160 fputs ("\n\tMIPS16 ASE", stdout
);
17161 if (mask
& AFL_ASE_MICROMIPS
)
17162 fputs ("\n\tMICROMIPS ASE", stdout
);
17163 if (mask
& AFL_ASE_XPA
)
17164 fputs ("\n\tXPA ASE", stdout
);
17165 if (mask
& AFL_ASE_MIPS16E2
)
17166 fputs ("\n\tMIPS16e2 ASE", stdout
);
17167 if (mask
& AFL_ASE_CRC
)
17168 fputs ("\n\tCRC ASE", stdout
);
17169 if (mask
& AFL_ASE_GINV
)
17170 fputs ("\n\tGINV ASE", stdout
);
17171 if (mask
& AFL_ASE_LOONGSON_MMI
)
17172 fputs ("\n\tLoongson MMI ASE", stdout
);
17173 if (mask
& AFL_ASE_LOONGSON_CAM
)
17174 fputs ("\n\tLoongson CAM ASE", stdout
);
17175 if (mask
& AFL_ASE_LOONGSON_EXT
)
17176 fputs ("\n\tLoongson EXT ASE", stdout
);
17177 if (mask
& AFL_ASE_LOONGSON_EXT2
)
17178 fputs ("\n\tLoongson EXT2 ASE", stdout
);
17180 fprintf (stdout
, "\n\t%s", _("None"));
17181 else if ((mask
& ~AFL_ASE_MASK
) != 0)
17182 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
17186 print_mips_isa_ext (unsigned int isa_ext
)
17191 fputs (_("None"), stdout
);
17194 fputs ("RMI XLR", stdout
);
17196 case AFL_EXT_OCTEON3
:
17197 fputs ("Cavium Networks Octeon3", stdout
);
17199 case AFL_EXT_OCTEON2
:
17200 fputs ("Cavium Networks Octeon2", stdout
);
17202 case AFL_EXT_OCTEONP
:
17203 fputs ("Cavium Networks OcteonP", stdout
);
17205 case AFL_EXT_OCTEON
:
17206 fputs ("Cavium Networks Octeon", stdout
);
17209 fputs ("Toshiba R5900", stdout
);
17212 fputs ("MIPS R4650", stdout
);
17215 fputs ("LSI R4010", stdout
);
17218 fputs ("NEC VR4100", stdout
);
17221 fputs ("Toshiba R3900", stdout
);
17223 case AFL_EXT_10000
:
17224 fputs ("MIPS R10000", stdout
);
17227 fputs ("Broadcom SB-1", stdout
);
17230 fputs ("NEC VR4111/VR4181", stdout
);
17233 fputs ("NEC VR4120", stdout
);
17236 fputs ("NEC VR5400", stdout
);
17239 fputs ("NEC VR5500", stdout
);
17241 case AFL_EXT_LOONGSON_2E
:
17242 fputs ("ST Microelectronics Loongson 2E", stdout
);
17244 case AFL_EXT_LOONGSON_2F
:
17245 fputs ("ST Microelectronics Loongson 2F", stdout
);
17247 case AFL_EXT_INTERAPTIV_MR2
:
17248 fputs ("Imagination interAptiv MR2", stdout
);
17251 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
17256 get_mips_reg_size (int reg_size
)
17258 return (reg_size
== AFL_REG_NONE
) ? 0
17259 : (reg_size
== AFL_REG_32
) ? 32
17260 : (reg_size
== AFL_REG_64
) ? 64
17261 : (reg_size
== AFL_REG_128
) ? 128
17266 process_mips_specific (Filedata
* filedata
)
17268 Elf_Internal_Dyn
* entry
;
17269 Elf_Internal_Shdr
*sect
= NULL
;
17270 size_t liblist_offset
= 0;
17271 size_t liblistno
= 0;
17272 size_t conflictsno
= 0;
17273 size_t options_offset
= 0;
17274 size_t conflicts_offset
= 0;
17275 size_t pltrelsz
= 0;
17277 bfd_vma pltgot
= 0;
17278 bfd_vma mips_pltgot
= 0;
17279 bfd_vma jmprel
= 0;
17280 bfd_vma local_gotno
= 0;
17281 bfd_vma gotsym
= 0;
17282 bfd_vma symtabno
= 0;
17283 bfd_boolean res
= TRUE
;
17285 if (! process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
17286 display_mips_gnu_attribute
))
17289 sect
= find_section (filedata
, ".MIPS.abiflags");
17293 Elf_External_ABIFlags_v0
*abiflags_ext
;
17294 Elf_Internal_ABIFlags_v0 abiflags_in
;
17296 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
17298 error (_("Corrupt MIPS ABI Flags section.\n"));
17303 abiflags_ext
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
17304 sect
->sh_size
, _("MIPS ABI Flags section"));
17307 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
17308 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
17309 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
17310 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
17311 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
17312 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
17313 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
17314 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
17315 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
17316 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
17317 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
17319 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
17320 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
17321 if (abiflags_in
.isa_rev
> 1)
17322 printf ("r%d", abiflags_in
.isa_rev
);
17323 printf ("\nGPR size: %d",
17324 get_mips_reg_size (abiflags_in
.gpr_size
));
17325 printf ("\nCPR1 size: %d",
17326 get_mips_reg_size (abiflags_in
.cpr1_size
));
17327 printf ("\nCPR2 size: %d",
17328 get_mips_reg_size (abiflags_in
.cpr2_size
));
17329 fputs ("\nFP ABI: ", stdout
);
17330 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
17331 fputs ("ISA Extension: ", stdout
);
17332 print_mips_isa_ext (abiflags_in
.isa_ext
);
17333 fputs ("\nASEs:", stdout
);
17334 print_mips_ases (abiflags_in
.ases
);
17335 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
17336 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
17337 fputc ('\n', stdout
);
17338 free (abiflags_ext
);
17343 /* We have a lot of special sections. Thanks SGI! */
17344 if (filedata
->dynamic_section
== NULL
)
17346 /* No dynamic information available. See if there is static GOT. */
17347 sect
= find_section (filedata
, ".got");
17350 unsigned char *data_end
;
17351 unsigned char *data
;
17355 pltgot
= sect
->sh_addr
;
17358 addr_size
= (is_32bit_elf
? 4 : 8);
17359 end
= pltgot
+ sect
->sh_size
;
17361 data
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
,
17363 _("Global Offset Table data"));
17364 /* PR 12855: Null data is handled gracefully throughout. */
17365 data_end
= data
+ (end
- pltgot
);
17367 printf (_("\nStatic GOT:\n"));
17368 printf (_(" Canonical gp value: "));
17369 print_vma (ent
+ 0x7ff0, LONG_HEX
);
17372 /* In a dynamic binary GOT[0] is reserved for the dynamic
17373 loader to store the lazy resolver pointer, however in
17374 a static binary it may well have been omitted and GOT
17375 reduced to a table of addresses.
17376 PR 21344: Check for the entry being fully available
17377 before fetching it. */
17379 && data
+ ent
- pltgot
+ addr_size
<= data_end
17380 && byte_get (data
+ ent
- pltgot
, addr_size
) == 0)
17382 printf (_(" Reserved entries:\n"));
17383 printf (_(" %*s %10s %*s\n"),
17384 addr_size
* 2, _("Address"), _("Access"),
17385 addr_size
* 2, _("Value"));
17386 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17388 if (ent
== (bfd_vma
) -1)
17389 goto sgot_print_fail
;
17391 /* Check for the MSB of GOT[1] being set, identifying a
17392 GNU object. This entry will be used by some runtime
17393 loaders, to store the module pointer. Otherwise this
17394 is an ordinary local entry.
17395 PR 21344: Check for the entry being fully available
17396 before fetching it. */
17398 && data
+ ent
- pltgot
+ addr_size
<= data_end
17399 && (byte_get (data
+ ent
- pltgot
, addr_size
)
17400 >> (addr_size
* 8 - 1)) != 0)
17402 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17404 if (ent
== (bfd_vma
) -1)
17405 goto sgot_print_fail
;
17410 if (data
!= NULL
&& ent
< end
)
17412 printf (_(" Local entries:\n"));
17413 printf (" %*s %10s %*s\n",
17414 addr_size
* 2, _("Address"), _("Access"),
17415 addr_size
* 2, _("Value"));
17418 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17420 if (ent
== (bfd_vma
) -1)
17421 goto sgot_print_fail
;
17432 for (entry
= filedata
->dynamic_section
;
17433 /* PR 17531 file: 012-50589-0.004. */
17434 (entry
< filedata
->dynamic_section
+ filedata
->dynamic_nent
17435 && entry
->d_tag
!= DT_NULL
);
17437 switch (entry
->d_tag
)
17439 case DT_MIPS_LIBLIST
:
17441 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
17442 liblistno
* sizeof (Elf32_External_Lib
));
17444 case DT_MIPS_LIBLISTNO
:
17445 liblistno
= entry
->d_un
.d_val
;
17447 case DT_MIPS_OPTIONS
:
17448 options_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
17450 case DT_MIPS_CONFLICT
:
17452 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
17453 conflictsno
* sizeof (Elf32_External_Conflict
));
17455 case DT_MIPS_CONFLICTNO
:
17456 conflictsno
= entry
->d_un
.d_val
;
17459 pltgot
= entry
->d_un
.d_ptr
;
17461 case DT_MIPS_LOCAL_GOTNO
:
17462 local_gotno
= entry
->d_un
.d_val
;
17464 case DT_MIPS_GOTSYM
:
17465 gotsym
= entry
->d_un
.d_val
;
17467 case DT_MIPS_SYMTABNO
:
17468 symtabno
= entry
->d_un
.d_val
;
17470 case DT_MIPS_PLTGOT
:
17471 mips_pltgot
= entry
->d_un
.d_ptr
;
17474 pltrel
= entry
->d_un
.d_val
;
17477 pltrelsz
= entry
->d_un
.d_val
;
17480 jmprel
= entry
->d_un
.d_ptr
;
17486 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
17488 Elf32_External_Lib
* elib
;
17491 elib
= (Elf32_External_Lib
*) get_data (NULL
, filedata
, liblist_offset
,
17492 sizeof (Elf32_External_Lib
),
17494 _("liblist section data"));
17497 printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
17498 "\nSection '.liblist' contains %lu entries:\n",
17499 (unsigned long) liblistno
),
17500 (unsigned long) liblistno
);
17501 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
17504 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
17511 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
17512 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
17513 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
17514 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
17515 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
17517 tmp
= gmtime (&atime
);
17518 snprintf (timebuf
, sizeof (timebuf
),
17519 "%04u-%02u-%02uT%02u:%02u:%02u",
17520 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
17521 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
17523 printf ("%3lu: ", (unsigned long) cnt
);
17524 if (VALID_DYNAMIC_NAME (filedata
, liblist
.l_name
))
17525 print_symbol (20, GET_DYNAMIC_NAME (filedata
, liblist
.l_name
));
17527 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
17528 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
17529 liblist
.l_version
);
17531 if (liblist
.l_flags
== 0)
17535 static const struct
17542 { " EXACT_MATCH", LL_EXACT_MATCH
},
17543 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
17544 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
17545 { " EXPORTS", LL_EXPORTS
},
17546 { " DELAY_LOAD", LL_DELAY_LOAD
},
17547 { " DELTA", LL_DELTA
}
17549 int flags
= liblist
.l_flags
;
17552 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
17553 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
17555 fputs (l_flags_vals
[fcnt
].name
, stdout
);
17556 flags
^= l_flags_vals
[fcnt
].bit
;
17559 printf (" %#x", (unsigned int) flags
);
17571 if (options_offset
!= 0)
17573 Elf_External_Options
* eopt
;
17576 sect
= filedata
->section_headers
;
17578 /* Find the section header so that we get the size. */
17579 sect
= find_section_by_type (filedata
, SHT_MIPS_OPTIONS
);
17580 /* PR 17533 file: 012-277276-0.004. */
17583 error (_("No MIPS_OPTIONS header found\n"));
17587 if (sect
->sh_size
< sizeof (* eopt
))
17589 error (_("The MIPS options section is too small.\n"));
17593 eopt
= (Elf_External_Options
*) get_data (NULL
, filedata
, options_offset
, 1,
17594 sect
->sh_size
, _("options"));
17597 Elf_Internal_Options option
;
17600 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
17602 Elf_External_Options
* eoption
;
17603 unsigned int optsize
;
17605 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
17607 optsize
= BYTE_GET (eoption
->size
);
17609 /* PR 17531: file: ffa0fa3b. */
17610 if (optsize
< sizeof (* eopt
)
17611 || optsize
> sect
->sh_size
- offset
)
17613 error (_("Invalid size (%u) for MIPS option\n"),
17622 printf (ngettext ("\nSection '%s' contains %d entry:\n",
17623 "\nSection '%s' contains %d entries:\n",
17625 printable_section_name (filedata
, sect
), cnt
);
17631 Elf_External_Options
* eoption
;
17633 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
17635 option
.kind
= BYTE_GET (eoption
->kind
);
17636 option
.size
= BYTE_GET (eoption
->size
);
17637 option
.section
= BYTE_GET (eoption
->section
);
17638 option
.info
= BYTE_GET (eoption
->info
);
17640 switch (option
.kind
)
17643 /* This shouldn't happen. */
17644 printf (" NULL %" PRId16
" %" PRIx32
,
17645 option
.section
, option
.info
);
17649 printf (" REGINFO ");
17650 if (filedata
->file_header
.e_machine
== EM_MIPS
)
17652 Elf32_External_RegInfo
* ereg
;
17653 Elf32_RegInfo reginfo
;
17656 if (option
.size
< (sizeof (Elf_External_Options
)
17657 + sizeof (Elf32_External_RegInfo
)))
17659 printf (_("<corrupt>\n"));
17660 error (_("Truncated MIPS REGINFO option\n"));
17665 ereg
= (Elf32_External_RegInfo
*) (eoption
+ 1);
17667 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
17668 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
17669 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
17670 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
17671 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
17672 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
17674 printf ("GPR %08" PRIx32
" GP 0x%" PRIx32
"\n",
17675 reginfo
.ri_gprmask
, reginfo
.ri_gp_value
);
17677 " CPR0 %08" PRIx32
" CPR1 %08" PRIx32
17678 " CPR2 %08" PRIx32
" CPR3 %08" PRIx32
"\n",
17679 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
17680 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
17685 Elf64_External_RegInfo
* ereg
;
17686 Elf64_Internal_RegInfo reginfo
;
17688 if (option
.size
< (sizeof (Elf_External_Options
)
17689 + sizeof (Elf64_External_RegInfo
)))
17691 printf (_("<corrupt>\n"));
17692 error (_("Truncated MIPS REGINFO option\n"));
17697 ereg
= (Elf64_External_RegInfo
*) (eoption
+ 1);
17698 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
17699 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
17700 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
17701 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
17702 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
17703 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
17705 printf ("GPR %08" PRIx32
" GP 0x%" PRIx64
"\n",
17706 reginfo
.ri_gprmask
, reginfo
.ri_gp_value
);
17708 " CPR0 %08" PRIx32
" CPR1 %08" PRIx32
17709 " CPR2 %08" PRIx32
" CPR3 %08" PRIx32
"\n",
17710 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
17711 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
17713 offset
+= option
.size
;
17716 case ODK_EXCEPTIONS
:
17717 fputs (" EXCEPTIONS fpe_min(", stdout
);
17718 process_mips_fpe_exception (option
.info
& OEX_FPU_MIN
);
17719 fputs (") fpe_max(", stdout
);
17720 process_mips_fpe_exception ((option
.info
& OEX_FPU_MAX
) >> 8);
17721 fputs (")", stdout
);
17723 if (option
.info
& OEX_PAGE0
)
17724 fputs (" PAGE0", stdout
);
17725 if (option
.info
& OEX_SMM
)
17726 fputs (" SMM", stdout
);
17727 if (option
.info
& OEX_FPDBUG
)
17728 fputs (" FPDBUG", stdout
);
17729 if (option
.info
& OEX_DISMISS
)
17730 fputs (" DISMISS", stdout
);
17734 fputs (" PAD ", stdout
);
17735 if (option
.info
& OPAD_PREFIX
)
17736 fputs (" PREFIX", stdout
);
17737 if (option
.info
& OPAD_POSTFIX
)
17738 fputs (" POSTFIX", stdout
);
17739 if (option
.info
& OPAD_SYMBOL
)
17740 fputs (" SYMBOL", stdout
);
17744 fputs (" HWPATCH ", stdout
);
17745 if (option
.info
& OHW_R4KEOP
)
17746 fputs (" R4KEOP", stdout
);
17747 if (option
.info
& OHW_R8KPFETCH
)
17748 fputs (" R8KPFETCH", stdout
);
17749 if (option
.info
& OHW_R5KEOP
)
17750 fputs (" R5KEOP", stdout
);
17751 if (option
.info
& OHW_R5KCVTL
)
17752 fputs (" R5KCVTL", stdout
);
17756 fputs (" FILL ", stdout
);
17757 /* XXX Print content of info word? */
17761 fputs (" TAGS ", stdout
);
17762 /* XXX Print content of info word? */
17766 fputs (" HWAND ", stdout
);
17767 if (option
.info
& OHWA0_R4KEOP_CHECKED
)
17768 fputs (" R4KEOP_CHECKED", stdout
);
17769 if (option
.info
& OHWA0_R4KEOP_CLEAN
)
17770 fputs (" R4KEOP_CLEAN", stdout
);
17774 fputs (" HWOR ", stdout
);
17775 if (option
.info
& OHWA0_R4KEOP_CHECKED
)
17776 fputs (" R4KEOP_CHECKED", stdout
);
17777 if (option
.info
& OHWA0_R4KEOP_CLEAN
)
17778 fputs (" R4KEOP_CLEAN", stdout
);
17782 printf (" GP_GROUP %#06x self-contained %#06x",
17783 option
.info
& OGP_GROUP
,
17784 (option
.info
& OGP_SELF
) >> 16);
17788 printf (" IDENT %#06x self-contained %#06x",
17789 option
.info
& OGP_GROUP
,
17790 (option
.info
& OGP_SELF
) >> 16);
17794 /* This shouldn't happen. */
17795 printf (" %3d ??? %" PRId16
" %" PRIx32
,
17796 option
.kind
, option
.section
, option
.info
);
17800 len
= sizeof (* eopt
);
17801 while (len
< option
.size
)
17803 unsigned char datum
= *((unsigned char *) eoption
+ len
);
17805 if (ISPRINT (datum
))
17806 printf ("%c", datum
);
17808 printf ("\\%03o", datum
);
17811 fputs ("\n", stdout
);
17813 offset
+= option
.size
;
17821 if (conflicts_offset
!= 0 && conflictsno
!= 0)
17823 Elf32_Conflict
* iconf
;
17826 if (filedata
->dynamic_symbols
== NULL
)
17828 error (_("conflict list found without a dynamic symbol table\n"));
17832 /* PR 21345 - print a slightly more helpful error message
17833 if we are sure that the cmalloc will fail. */
17834 if (conflictsno
> filedata
->file_size
/ sizeof (* iconf
))
17836 error (_("Overlarge number of conflicts detected: %lx\n"),
17837 (long) conflictsno
);
17841 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
17844 error (_("Out of memory allocating space for dynamic conflicts\n"));
17850 Elf32_External_Conflict
* econf32
;
17852 econf32
= (Elf32_External_Conflict
*)
17853 get_data (NULL
, filedata
, conflicts_offset
,
17854 sizeof (*econf32
), conflictsno
, _("conflict"));
17861 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
17862 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
17868 Elf64_External_Conflict
* econf64
;
17870 econf64
= (Elf64_External_Conflict
*)
17871 get_data (NULL
, filedata
, conflicts_offset
,
17872 sizeof (*econf64
), conflictsno
, _("conflict"));
17879 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
17880 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
17885 printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
17886 "\nSection '.conflict' contains %lu entries:\n",
17887 (unsigned long) conflictsno
),
17888 (unsigned long) conflictsno
);
17889 puts (_(" Num: Index Value Name"));
17891 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
17893 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
17895 if (iconf
[cnt
] >= filedata
->num_dynamic_syms
)
17896 printf (_("<corrupt symbol index>"));
17899 Elf_Internal_Sym
* psym
;
17901 psym
= & filedata
->dynamic_symbols
[iconf
[cnt
]];
17902 print_vma (psym
->st_value
, FULL_HEX
);
17904 if (VALID_DYNAMIC_NAME (filedata
, psym
->st_name
))
17905 print_symbol (25, GET_DYNAMIC_NAME (filedata
, psym
->st_name
));
17907 printf (_("<corrupt: %14ld>"), psym
->st_name
);
17915 if (pltgot
!= 0 && local_gotno
!= 0)
17917 bfd_vma ent
, local_end
, global_end
;
17919 unsigned char * data
;
17920 unsigned char * data_end
;
17924 addr_size
= (is_32bit_elf
? 4 : 8);
17925 local_end
= pltgot
+ local_gotno
* addr_size
;
17927 /* PR binutils/17533 file: 012-111227-0.004 */
17928 if (symtabno
< gotsym
)
17930 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
17931 (unsigned long) gotsym
, (unsigned long) symtabno
);
17935 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
17936 /* PR 17531: file: 54c91a34. */
17937 if (global_end
< local_end
)
17939 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
17943 offset
= offset_from_vma (filedata
, pltgot
, global_end
- pltgot
);
17944 data
= (unsigned char *) get_data (NULL
, filedata
, offset
,
17945 global_end
- pltgot
, 1,
17946 _("Global Offset Table data"));
17947 /* PR 12855: Null data is handled gracefully throughout. */
17948 data_end
= data
+ (global_end
- pltgot
);
17950 printf (_("\nPrimary GOT:\n"));
17951 printf (_(" Canonical gp value: "));
17952 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
17955 printf (_(" Reserved entries:\n"));
17956 printf (_(" %*s %10s %*s Purpose\n"),
17957 addr_size
* 2, _("Address"), _("Access"),
17958 addr_size
* 2, _("Initial"));
17959 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17960 printf (_(" Lazy resolver\n"));
17961 if (ent
== (bfd_vma
) -1)
17962 goto got_print_fail
;
17964 /* Check for the MSB of GOT[1] being set, denoting a GNU object.
17965 This entry will be used by some runtime loaders, to store the
17966 module pointer. Otherwise this is an ordinary local entry.
17967 PR 21344: Check for the entry being fully available before
17970 && data
+ ent
- pltgot
+ addr_size
<= data_end
17971 && (byte_get (data
+ ent
- pltgot
, addr_size
)
17972 >> (addr_size
* 8 - 1)) != 0)
17974 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17975 printf (_(" Module pointer (GNU extension)\n"));
17976 if (ent
== (bfd_vma
) -1)
17977 goto got_print_fail
;
17981 if (data
!= NULL
&& ent
< local_end
)
17983 printf (_(" Local entries:\n"));
17984 printf (" %*s %10s %*s\n",
17985 addr_size
* 2, _("Address"), _("Access"),
17986 addr_size
* 2, _("Initial"));
17987 while (ent
< local_end
)
17989 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
17991 if (ent
== (bfd_vma
) -1)
17992 goto got_print_fail
;
17997 if (data
!= NULL
&& gotsym
< symtabno
)
18001 printf (_(" Global entries:\n"));
18002 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
18003 addr_size
* 2, _("Address"),
18005 addr_size
* 2, _("Initial"),
18006 addr_size
* 2, _("Sym.Val."),
18008 /* Note for translators: "Ndx" = abbreviated form of "Index". */
18009 _("Ndx"), _("Name"));
18011 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
18013 for (i
= gotsym
; i
< symtabno
; i
++)
18015 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
18018 if (filedata
->dynamic_symbols
== NULL
)
18019 printf (_("<no dynamic symbols>"));
18020 else if (i
< filedata
->num_dynamic_syms
)
18022 Elf_Internal_Sym
* psym
= filedata
->dynamic_symbols
+ i
;
18024 print_vma (psym
->st_value
, LONG_HEX
);
18025 printf (" %-7s %3s ",
18026 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
18027 get_symbol_index_type (filedata
, psym
->st_shndx
));
18029 if (VALID_DYNAMIC_NAME (filedata
, psym
->st_name
))
18030 print_symbol (sym_width
,
18031 GET_DYNAMIC_NAME (filedata
, psym
->st_name
));
18033 printf (_("<corrupt: %14ld>"), psym
->st_name
);
18036 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
18037 (unsigned long) i
);
18040 if (ent
== (bfd_vma
) -1)
18050 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
18053 size_t offset
, rel_offset
;
18054 unsigned long count
, i
;
18055 unsigned char * data
;
18056 int addr_size
, sym_width
;
18057 Elf_Internal_Rela
* rels
;
18059 rel_offset
= offset_from_vma (filedata
, jmprel
, pltrelsz
);
18060 if (pltrel
== DT_RELA
)
18062 if (!slurp_rela_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
18067 if (!slurp_rel_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
18072 addr_size
= (is_32bit_elf
? 4 : 8);
18073 end
= mips_pltgot
+ (2 + count
) * addr_size
;
18075 offset
= offset_from_vma (filedata
, mips_pltgot
, end
- mips_pltgot
);
18076 data
= (unsigned char *) get_data (NULL
, filedata
, offset
, end
- mips_pltgot
,
18077 1, _("Procedure Linkage Table data"));
18084 printf ("\nPLT GOT:\n\n");
18085 printf (_(" Reserved entries:\n"));
18086 printf (_(" %*s %*s Purpose\n"),
18087 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
18088 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
18089 printf (_(" PLT lazy resolver\n"));
18090 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
18091 printf (_(" Module pointer\n"));
18094 printf (_(" Entries:\n"));
18095 printf (" %*s %*s %*s %-7s %3s %s\n",
18096 addr_size
* 2, _("Address"),
18097 addr_size
* 2, _("Initial"),
18098 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
18099 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
18100 for (i
= 0; i
< count
; i
++)
18102 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
18104 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
18107 if (idx
>= filedata
->num_dynamic_syms
)
18108 printf (_("<corrupt symbol index: %lu>"), idx
);
18111 Elf_Internal_Sym
* psym
= filedata
->dynamic_symbols
+ idx
;
18113 print_vma (psym
->st_value
, LONG_HEX
);
18114 printf (" %-7s %3s ",
18115 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
18116 get_symbol_index_type (filedata
, psym
->st_shndx
));
18117 if (VALID_DYNAMIC_NAME (filedata
, psym
->st_name
))
18118 print_symbol (sym_width
,
18119 GET_DYNAMIC_NAME (filedata
, psym
->st_name
));
18121 printf (_("<corrupt: %14ld>"), psym
->st_name
);
18135 process_nds32_specific (Filedata
* filedata
)
18137 Elf_Internal_Shdr
*sect
= NULL
;
18139 sect
= find_section (filedata
, ".nds32_e_flags");
18140 if (sect
!= NULL
&& sect
->sh_size
>= 4)
18142 unsigned char *buf
;
18145 printf ("\nNDS32 elf flags section:\n");
18146 buf
= get_data (NULL
, filedata
, sect
->sh_offset
, 1, 4,
18147 _("NDS32 elf flags section"));
18152 flag
= byte_get (buf
, 4);
18154 switch (flag
& 0x3)
18157 printf ("(VEC_SIZE):\tNo entry.\n");
18160 printf ("(VEC_SIZE):\t4 bytes\n");
18163 printf ("(VEC_SIZE):\t16 bytes\n");
18166 printf ("(VEC_SIZE):\treserved\n");
18175 process_gnu_liblist (Filedata
* filedata
)
18177 Elf_Internal_Shdr
* section
;
18178 Elf_Internal_Shdr
* string_sec
;
18179 Elf32_External_Lib
* elib
;
18181 size_t strtab_size
;
18183 unsigned long num_liblist
;
18185 bfd_boolean res
= TRUE
;
18190 for (i
= 0, section
= filedata
->section_headers
;
18191 i
< filedata
->file_header
.e_shnum
;
18194 switch (section
->sh_type
)
18196 case SHT_GNU_LIBLIST
:
18197 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
18200 elib
= (Elf32_External_Lib
*)
18201 get_data (NULL
, filedata
, section
->sh_offset
, 1, section
->sh_size
,
18202 _("liblist section data"));
18210 string_sec
= filedata
->section_headers
+ section
->sh_link
;
18211 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
18212 string_sec
->sh_size
,
18213 _("liblist string table"));
18215 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
18222 strtab_size
= string_sec
->sh_size
;
18224 num_liblist
= section
->sh_size
/ sizeof (Elf32_External_Lib
);
18225 printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
18226 "\nLibrary list section '%s' contains %lu entries:\n",
18228 printable_section_name (filedata
, section
),
18231 puts (_(" Library Time Stamp Checksum Version Flags"));
18233 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
18241 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
18242 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
18243 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
18244 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
18245 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
18247 tmp
= gmtime (&atime
);
18248 snprintf (timebuf
, sizeof (timebuf
),
18249 "%04u-%02u-%02uT%02u:%02u:%02u",
18250 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
18251 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
18253 printf ("%3lu: ", (unsigned long) cnt
);
18255 printf ("%-20s", liblist
.l_name
< strtab_size
18256 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
18258 printf ("%-20.20s", liblist
.l_name
< strtab_size
18259 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
18260 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
18261 liblist
.l_version
, liblist
.l_flags
);
18272 static const char *
18273 get_note_type (Filedata
* filedata
, unsigned e_type
)
18275 static char buff
[64];
18277 if (filedata
->file_header
.e_type
== ET_CORE
)
18281 return _("NT_AUXV (auxiliary vector)");
18283 return _("NT_PRSTATUS (prstatus structure)");
18285 return _("NT_FPREGSET (floating point registers)");
18287 return _("NT_PRPSINFO (prpsinfo structure)");
18288 case NT_TASKSTRUCT
:
18289 return _("NT_TASKSTRUCT (task structure)");
18291 return _("NT_PRXFPREG (user_xfpregs structure)");
18293 return _("NT_PPC_VMX (ppc Altivec registers)");
18295 return _("NT_PPC_VSX (ppc VSX registers)");
18297 return _("NT_PPC_TAR (ppc TAR register)");
18299 return _("NT_PPC_PPR (ppc PPR register)");
18301 return _("NT_PPC_DSCR (ppc DSCR register)");
18303 return _("NT_PPC_EBB (ppc EBB registers)");
18305 return _("NT_PPC_PMU (ppc PMU registers)");
18306 case NT_PPC_TM_CGPR
:
18307 return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
18308 case NT_PPC_TM_CFPR
:
18309 return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
18310 case NT_PPC_TM_CVMX
:
18311 return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
18312 case NT_PPC_TM_CVSX
:
18313 return _("NT_PPC_TM_CVSX (ppc checkpointed VSX registers)");
18314 case NT_PPC_TM_SPR
:
18315 return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
18316 case NT_PPC_TM_CTAR
:
18317 return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
18318 case NT_PPC_TM_CPPR
:
18319 return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
18320 case NT_PPC_TM_CDSCR
:
18321 return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
18323 return _("NT_386_TLS (x86 TLS information)");
18324 case NT_386_IOPERM
:
18325 return _("NT_386_IOPERM (x86 I/O permissions)");
18326 case NT_X86_XSTATE
:
18327 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
18329 return _("NT_X86_CET (x86 CET state)");
18330 case NT_S390_HIGH_GPRS
:
18331 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
18332 case NT_S390_TIMER
:
18333 return _("NT_S390_TIMER (s390 timer register)");
18334 case NT_S390_TODCMP
:
18335 return _("NT_S390_TODCMP (s390 TOD comparator register)");
18336 case NT_S390_TODPREG
:
18337 return _("NT_S390_TODPREG (s390 TOD programmable register)");
18339 return _("NT_S390_CTRS (s390 control registers)");
18340 case NT_S390_PREFIX
:
18341 return _("NT_S390_PREFIX (s390 prefix register)");
18342 case NT_S390_LAST_BREAK
:
18343 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
18344 case NT_S390_SYSTEM_CALL
:
18345 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
18347 return _("NT_S390_TDB (s390 transaction diagnostic block)");
18348 case NT_S390_VXRS_LOW
:
18349 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
18350 case NT_S390_VXRS_HIGH
:
18351 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
18352 case NT_S390_GS_CB
:
18353 return _("NT_S390_GS_CB (s390 guarded-storage registers)");
18354 case NT_S390_GS_BC
:
18355 return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
18357 return _("NT_ARM_VFP (arm VFP registers)");
18359 return _("NT_ARM_TLS (AArch TLS registers)");
18360 case NT_ARM_HW_BREAK
:
18361 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
18362 case NT_ARM_HW_WATCH
:
18363 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
18365 return _("NT_ARC_V2 (ARC HS accumulator/extra registers)");
18367 return _("NT_PSTATUS (pstatus structure)");
18369 return _("NT_FPREGS (floating point registers)");
18371 return _("NT_PSINFO (psinfo structure)");
18373 return _("NT_LWPSTATUS (lwpstatus_t structure)");
18375 return _("NT_LWPSINFO (lwpsinfo_t structure)");
18376 case NT_WIN32PSTATUS
:
18377 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
18379 return _("NT_SIGINFO (siginfo_t data)");
18381 return _("NT_FILE (mapped files)");
18389 return _("NT_VERSION (version)");
18391 return _("NT_ARCH (architecture)");
18392 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
18394 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
18400 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18405 print_core_note (Elf_Internal_Note
*pnote
)
18407 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
18408 bfd_vma count
, page_size
;
18409 unsigned char *descdata
, *filenames
, *descend
;
18411 if (pnote
->type
!= NT_FILE
)
18421 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
18422 /* Still "successful". */
18427 if (pnote
->descsz
< 2 * addr_size
)
18429 error (_(" Malformed note - too short for header\n"));
18433 descdata
= (unsigned char *) pnote
->descdata
;
18434 descend
= descdata
+ pnote
->descsz
;
18436 if (descdata
[pnote
->descsz
- 1] != '\0')
18438 error (_(" Malformed note - does not end with \\0\n"));
18442 count
= byte_get (descdata
, addr_size
);
18443 descdata
+= addr_size
;
18445 page_size
= byte_get (descdata
, addr_size
);
18446 descdata
+= addr_size
;
18448 if (count
> ((bfd_vma
) -1 - 2 * addr_size
) / (3 * addr_size
)
18449 || pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
18451 error (_(" Malformed note - too short for supplied file count\n"));
18455 printf (_(" Page size: "));
18456 print_vma (page_size
, DEC
);
18459 printf (_(" %*s%*s%*s\n"),
18460 (int) (2 + 2 * addr_size
), _("Start"),
18461 (int) (4 + 2 * addr_size
), _("End"),
18462 (int) (4 + 2 * addr_size
), _("Page Offset"));
18463 filenames
= descdata
+ count
* 3 * addr_size
;
18464 while (count
-- > 0)
18466 bfd_vma start
, end
, file_ofs
;
18468 if (filenames
== descend
)
18470 error (_(" Malformed note - filenames end too early\n"));
18474 start
= byte_get (descdata
, addr_size
);
18475 descdata
+= addr_size
;
18476 end
= byte_get (descdata
, addr_size
);
18477 descdata
+= addr_size
;
18478 file_ofs
= byte_get (descdata
, addr_size
);
18479 descdata
+= addr_size
;
18482 print_vma (start
, FULL_HEX
);
18484 print_vma (end
, FULL_HEX
);
18486 print_vma (file_ofs
, FULL_HEX
);
18487 printf ("\n %s\n", filenames
);
18489 filenames
+= 1 + strlen ((char *) filenames
);
18495 static const char *
18496 get_gnu_elf_note_type (unsigned e_type
)
18498 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
18501 case NT_GNU_ABI_TAG
:
18502 return _("NT_GNU_ABI_TAG (ABI version tag)");
18504 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
18505 case NT_GNU_BUILD_ID
:
18506 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
18507 case NT_GNU_GOLD_VERSION
:
18508 return _("NT_GNU_GOLD_VERSION (gold version)");
18509 case NT_GNU_PROPERTY_TYPE_0
:
18510 return _("NT_GNU_PROPERTY_TYPE_0");
18511 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
18512 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
18513 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
18514 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
18517 static char buff
[64];
18519 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18526 decode_x86_compat_isa (unsigned int bitmask
)
18530 unsigned int bit
= bitmask
& (- bitmask
);
18535 case GNU_PROPERTY_X86_COMPAT_ISA_1_486
:
18538 case GNU_PROPERTY_X86_COMPAT_ISA_1_586
:
18541 case GNU_PROPERTY_X86_COMPAT_ISA_1_686
:
18544 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE
:
18547 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE2
:
18550 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE3
:
18553 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSSE3
:
18556 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_1
:
18559 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_2
:
18562 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX
:
18565 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX2
:
18568 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512F
:
18569 printf ("AVX512F");
18571 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512CD
:
18572 printf ("AVX512CD");
18574 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512ER
:
18575 printf ("AVX512ER");
18577 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512PF
:
18578 printf ("AVX512PF");
18580 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512VL
:
18581 printf ("AVX512VL");
18583 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512DQ
:
18584 printf ("AVX512DQ");
18586 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512BW
:
18587 printf ("AVX512BW");
18590 printf (_("<unknown: %x>"), bit
);
18599 decode_x86_compat_2_isa (unsigned int bitmask
)
18603 printf (_("<None>"));
18609 unsigned int bit
= bitmask
& (- bitmask
);
18614 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_CMOV
:
18617 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE
:
18620 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE2
:
18623 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE3
:
18626 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSSE3
:
18629 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE4_1
:
18632 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_SSE4_2
:
18635 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX
:
18638 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX2
:
18641 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_FMA
:
18644 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512F
:
18645 printf ("AVX512F");
18647 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512CD
:
18648 printf ("AVX512CD");
18650 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512ER
:
18651 printf ("AVX512ER");
18653 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512PF
:
18654 printf ("AVX512PF");
18656 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512VL
:
18657 printf ("AVX512VL");
18659 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512DQ
:
18660 printf ("AVX512DQ");
18662 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512BW
:
18663 printf ("AVX512BW");
18665 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_4FMAPS
:
18666 printf ("AVX512_4FMAPS");
18668 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_4VNNIW
:
18669 printf ("AVX512_4VNNIW");
18671 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_BITALG
:
18672 printf ("AVX512_BITALG");
18674 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_IFMA
:
18675 printf ("AVX512_IFMA");
18677 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_VBMI
:
18678 printf ("AVX512_VBMI");
18680 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_VBMI2
:
18681 printf ("AVX512_VBMI2");
18683 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_VNNI
:
18684 printf ("AVX512_VNNI");
18686 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_AVX512_BF16
:
18687 printf ("AVX512_BF16");
18690 printf (_("<unknown: %x>"), bit
);
18699 decode_x86_isa (unsigned int bitmask
)
18703 unsigned int bit
= bitmask
& (- bitmask
);
18708 case GNU_PROPERTY_X86_ISA_1_BASELINE
:
18709 printf ("x86-64-baseline");
18711 case GNU_PROPERTY_X86_ISA_1_V2
:
18712 printf ("x86-64-v2");
18714 case GNU_PROPERTY_X86_ISA_1_V3
:
18715 printf ("x86-64-v3");
18717 case GNU_PROPERTY_X86_ISA_1_V4
:
18718 printf ("x86-64-v4");
18721 printf (_("<unknown: %x>"), bit
);
18730 decode_x86_feature_1 (unsigned int bitmask
)
18734 printf (_("<None>"));
18740 unsigned int bit
= bitmask
& (- bitmask
);
18745 case GNU_PROPERTY_X86_FEATURE_1_IBT
:
18748 case GNU_PROPERTY_X86_FEATURE_1_SHSTK
:
18752 printf (_("<unknown: %x>"), bit
);
18761 decode_x86_feature_2 (unsigned int bitmask
)
18765 printf (_("<None>"));
18771 unsigned int bit
= bitmask
& (- bitmask
);
18776 case GNU_PROPERTY_X86_FEATURE_2_X86
:
18779 case GNU_PROPERTY_X86_FEATURE_2_X87
:
18782 case GNU_PROPERTY_X86_FEATURE_2_MMX
:
18785 case GNU_PROPERTY_X86_FEATURE_2_XMM
:
18788 case GNU_PROPERTY_X86_FEATURE_2_YMM
:
18791 case GNU_PROPERTY_X86_FEATURE_2_ZMM
:
18794 case GNU_PROPERTY_X86_FEATURE_2_TMM
:
18797 case GNU_PROPERTY_X86_FEATURE_2_MASK
:
18800 case GNU_PROPERTY_X86_FEATURE_2_FXSR
:
18803 case GNU_PROPERTY_X86_FEATURE_2_XSAVE
:
18806 case GNU_PROPERTY_X86_FEATURE_2_XSAVEOPT
:
18807 printf ("XSAVEOPT");
18809 case GNU_PROPERTY_X86_FEATURE_2_XSAVEC
:
18813 printf (_("<unknown: %x>"), bit
);
18822 decode_aarch64_feature_1_and (unsigned int bitmask
)
18826 unsigned int bit
= bitmask
& (- bitmask
);
18831 case GNU_PROPERTY_AARCH64_FEATURE_1_BTI
:
18835 case GNU_PROPERTY_AARCH64_FEATURE_1_PAC
:
18840 printf (_("<unknown: %x>"), bit
);
18849 print_gnu_property_note (Filedata
* filedata
, Elf_Internal_Note
* pnote
)
18851 unsigned char * ptr
= (unsigned char *) pnote
->descdata
;
18852 unsigned char * ptr_end
= ptr
+ pnote
->descsz
;
18853 unsigned int size
= is_32bit_elf
? 4 : 8;
18855 printf (_(" Properties: "));
18857 if (pnote
->descsz
< 8 || (pnote
->descsz
% size
) != 0)
18859 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote
->descsz
);
18863 while (ptr
< ptr_end
)
18867 unsigned int datasz
;
18869 if ((size_t) (ptr_end
- ptr
) < 8)
18871 printf (_("<corrupt descsz: %#lx>\n"), pnote
->descsz
);
18875 type
= byte_get (ptr
, 4);
18876 datasz
= byte_get (ptr
+ 4, 4);
18880 if (datasz
> (size_t) (ptr_end
- ptr
))
18882 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
18887 if (type
>= GNU_PROPERTY_LOPROC
&& type
<= GNU_PROPERTY_HIPROC
)
18889 if (filedata
->file_header
.e_machine
== EM_X86_64
18890 || filedata
->file_header
.e_machine
== EM_IAMCU
18891 || filedata
->file_header
.e_machine
== EM_386
)
18893 unsigned int bitmask
;
18896 bitmask
= byte_get (ptr
, 4);
18902 case GNU_PROPERTY_X86_ISA_1_USED
:
18904 printf (_("x86 ISA used: <corrupt length: %#x> "),
18908 printf ("x86 ISA used: ");
18909 decode_x86_isa (bitmask
);
18913 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
18915 printf (_("x86 ISA needed: <corrupt length: %#x> "),
18919 printf ("x86 ISA needed: ");
18920 decode_x86_isa (bitmask
);
18924 case GNU_PROPERTY_X86_FEATURE_1_AND
:
18926 printf (_("x86 feature: <corrupt length: %#x> "),
18930 printf ("x86 feature: ");
18931 decode_x86_feature_1 (bitmask
);
18935 case GNU_PROPERTY_X86_FEATURE_2_USED
:
18937 printf (_("x86 feature used: <corrupt length: %#x> "),
18941 printf ("x86 feature used: ");
18942 decode_x86_feature_2 (bitmask
);
18946 case GNU_PROPERTY_X86_FEATURE_2_NEEDED
:
18948 printf (_("x86 feature needed: <corrupt length: %#x> "), datasz
);
18951 printf ("x86 feature needed: ");
18952 decode_x86_feature_2 (bitmask
);
18956 case GNU_PROPERTY_X86_COMPAT_ISA_1_USED
:
18958 printf (_("x86 ISA used: <corrupt length: %#x> "),
18962 printf ("x86 ISA used: ");
18963 decode_x86_compat_isa (bitmask
);
18967 case GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED
:
18969 printf (_("x86 ISA needed: <corrupt length: %#x> "),
18973 printf ("x86 ISA needed: ");
18974 decode_x86_compat_isa (bitmask
);
18978 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_USED
:
18980 printf (_("x86 ISA used: <corrupt length: %#x> "),
18984 printf ("x86 ISA used: ");
18985 decode_x86_compat_2_isa (bitmask
);
18989 case GNU_PROPERTY_X86_COMPAT_2_ISA_1_NEEDED
:
18991 printf (_("x86 ISA needed: <corrupt length: %#x> "),
18995 printf ("x86 ISA needed: ");
18996 decode_x86_compat_2_isa (bitmask
);
19004 else if (filedata
->file_header
.e_machine
== EM_AARCH64
)
19006 if (type
== GNU_PROPERTY_AARCH64_FEATURE_1_AND
)
19008 printf ("AArch64 feature: ");
19010 printf (_("<corrupt length: %#x> "), datasz
);
19012 decode_aarch64_feature_1_and (byte_get (ptr
, 4));
19021 case GNU_PROPERTY_STACK_SIZE
:
19022 printf (_("stack size: "));
19023 if (datasz
!= size
)
19024 printf (_("<corrupt length: %#x> "), datasz
);
19026 printf ("%#lx", (unsigned long) byte_get (ptr
, size
));
19029 case GNU_PROPERTY_NO_COPY_ON_PROTECTED
:
19030 printf ("no copy on protected ");
19032 printf (_("<corrupt length: %#x> "), datasz
);
19040 if (type
< GNU_PROPERTY_LOPROC
)
19041 printf (_("<unknown type %#x data: "), type
);
19042 else if (type
< GNU_PROPERTY_LOUSER
)
19043 printf (_("<procesor-specific type %#x data: "), type
);
19045 printf (_("<application-specific type %#x data: "), type
);
19046 for (j
= 0; j
< datasz
; ++j
)
19047 printf ("%02x ", ptr
[j
] & 0xff);
19051 ptr
+= ((datasz
+ (size
- 1)) & ~ (size
- 1));
19052 if (ptr
== ptr_end
)
19065 print_gnu_note (Filedata
* filedata
, Elf_Internal_Note
*pnote
)
19067 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
19068 switch (pnote
->type
)
19070 case NT_GNU_BUILD_ID
:
19074 printf (_(" Build ID: "));
19075 for (i
= 0; i
< pnote
->descsz
; ++i
)
19076 printf ("%02x", pnote
->descdata
[i
] & 0xff);
19081 case NT_GNU_ABI_TAG
:
19083 unsigned long os
, major
, minor
, subminor
;
19084 const char *osname
;
19086 /* PR 17531: file: 030-599401-0.004. */
19087 if (pnote
->descsz
< 16)
19089 printf (_(" <corrupt GNU_ABI_TAG>\n"));
19093 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
19094 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
19095 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
19096 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
19100 case GNU_ABI_TAG_LINUX
:
19103 case GNU_ABI_TAG_HURD
:
19106 case GNU_ABI_TAG_SOLARIS
:
19107 osname
= "Solaris";
19109 case GNU_ABI_TAG_FREEBSD
:
19110 osname
= "FreeBSD";
19112 case GNU_ABI_TAG_NETBSD
:
19115 case GNU_ABI_TAG_SYLLABLE
:
19116 osname
= "Syllable";
19118 case GNU_ABI_TAG_NACL
:
19122 osname
= "Unknown";
19126 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
19127 major
, minor
, subminor
);
19131 case NT_GNU_GOLD_VERSION
:
19135 printf (_(" Version: "));
19136 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
19137 printf ("%c", pnote
->descdata
[i
]);
19144 unsigned long num_entries
, mask
;
19146 /* Hardware capabilities information. Word 0 is the number of entries.
19147 Word 1 is a bitmask of enabled entries. The rest of the descriptor
19148 is a series of entries, where each entry is a single byte followed
19149 by a nul terminated string. The byte gives the bit number to test
19150 if enabled in the bitmask. */
19151 printf (_(" Hardware Capabilities: "));
19152 if (pnote
->descsz
< 8)
19154 error (_("<corrupt GNU_HWCAP>\n"));
19157 num_entries
= byte_get ((unsigned char *) pnote
->descdata
, 4);
19158 mask
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
19159 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries
, mask
);
19160 /* FIXME: Add code to display the entries... */
19164 case NT_GNU_PROPERTY_TYPE_0
:
19165 print_gnu_property_note (filedata
, pnote
);
19169 /* Handle unrecognised types. An error message should have already been
19170 created by get_gnu_elf_note_type(), so all that we need to do is to
19171 display the data. */
19175 printf (_(" Description data: "));
19176 for (i
= 0; i
< pnote
->descsz
; ++i
)
19177 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
19186 static const char *
19187 get_v850_elf_note_type (enum v850_notes n_type
)
19189 static char buff
[64];
19193 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
19194 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
19195 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
19196 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
19197 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
19198 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
19200 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
19206 print_v850_note (Elf_Internal_Note
* pnote
)
19210 if (pnote
->descsz
!= 4)
19213 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
19217 printf (_("not set\n"));
19221 switch (pnote
->type
)
19223 case V850_NOTE_ALIGNMENT
:
19226 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return TRUE
;
19227 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return TRUE
;
19231 case V850_NOTE_DATA_SIZE
:
19234 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return TRUE
;
19235 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return TRUE
;
19239 case V850_NOTE_FPU_INFO
:
19242 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return TRUE
;
19243 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return TRUE
;
19247 case V850_NOTE_MMU_INFO
:
19248 case V850_NOTE_CACHE_INFO
:
19249 case V850_NOTE_SIMD_INFO
:
19250 if (val
== EF_RH850_SIMD
)
19252 printf (_("yes\n"));
19258 /* An 'unknown note type' message will already have been displayed. */
19262 printf (_("unknown value: %x\n"), val
);
19267 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
19269 unsigned int version
;
19271 switch (pnote
->type
)
19273 case NT_NETBSD_IDENT
:
19274 if (pnote
->descsz
< 1)
19276 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
19277 if ((version
/ 10000) % 100)
19278 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
19279 version
, version
/ 100000000, (version
/ 1000000) % 100,
19280 (version
/ 10000) % 100 > 26 ? "Z" : "",
19281 'A' + (version
/ 10000) % 26);
19283 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
19284 version
, version
/ 100000000, (version
/ 1000000) % 100,
19285 (version
/ 100) % 100);
19288 case NT_NETBSD_MARCH
:
19289 printf (" NetBSD\t\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
19293 #ifdef NT_NETBSD_PAX
19294 case NT_NETBSD_PAX
:
19295 if (pnote
->descsz
< 1)
19297 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
19298 printf (" NetBSD\t\t0x%08lx\tPaX <%s%s%s%s%s%s>\n", pnote
->descsz
,
19299 ((version
& NT_NETBSD_PAX_MPROTECT
) ? "+mprotect" : ""),
19300 ((version
& NT_NETBSD_PAX_NOMPROTECT
) ? "-mprotect" : ""),
19301 ((version
& NT_NETBSD_PAX_GUARD
) ? "+guard" : ""),
19302 ((version
& NT_NETBSD_PAX_NOGUARD
) ? "-guard" : ""),
19303 ((version
& NT_NETBSD_PAX_ASLR
) ? "+ASLR" : ""),
19304 ((version
& NT_NETBSD_PAX_NOASLR
) ? "-ASLR" : ""));
19309 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n",
19310 pnote
->descsz
, pnote
->type
);
19314 static const char *
19315 get_freebsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
19319 case NT_FREEBSD_THRMISC
:
19320 return _("NT_THRMISC (thrmisc structure)");
19321 case NT_FREEBSD_PROCSTAT_PROC
:
19322 return _("NT_PROCSTAT_PROC (proc data)");
19323 case NT_FREEBSD_PROCSTAT_FILES
:
19324 return _("NT_PROCSTAT_FILES (files data)");
19325 case NT_FREEBSD_PROCSTAT_VMMAP
:
19326 return _("NT_PROCSTAT_VMMAP (vmmap data)");
19327 case NT_FREEBSD_PROCSTAT_GROUPS
:
19328 return _("NT_PROCSTAT_GROUPS (groups data)");
19329 case NT_FREEBSD_PROCSTAT_UMASK
:
19330 return _("NT_PROCSTAT_UMASK (umask data)");
19331 case NT_FREEBSD_PROCSTAT_RLIMIT
:
19332 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
19333 case NT_FREEBSD_PROCSTAT_OSREL
:
19334 return _("NT_PROCSTAT_OSREL (osreldate data)");
19335 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
19336 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
19337 case NT_FREEBSD_PROCSTAT_AUXV
:
19338 return _("NT_PROCSTAT_AUXV (auxv data)");
19339 case NT_FREEBSD_PTLWPINFO
:
19340 return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
19342 return get_note_type (filedata
, e_type
);
19345 static const char *
19346 get_netbsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
19348 static char buff
[64];
19352 case NT_NETBSDCORE_PROCINFO
:
19353 /* NetBSD core "procinfo" structure. */
19354 return _("NetBSD procinfo structure");
19356 #ifdef NT_NETBSDCORE_AUXV
19357 case NT_NETBSDCORE_AUXV
:
19358 return _("NetBSD ELF auxiliary vector data");
19361 #ifdef NT_NETBSDCORE_LWPSTATUS
19362 case NT_NETBSDCORE_LWPSTATUS
:
19363 return _("PT_LWPSTATUS (ptrace_lwpstatus structure)");
19367 /* As of Jan 2020 there are no other machine-independent notes
19368 defined for NetBSD core files. If the note type is less
19369 than the start of the machine-dependent note types, we don't
19372 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
19374 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
19380 switch (filedata
->file_header
.e_machine
)
19382 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
19383 and PT_GETFPREGS == mach+2. */
19388 case EM_SPARC32PLUS
:
19392 case NT_NETBSDCORE_FIRSTMACH
+ 0:
19393 return _("PT_GETREGS (reg structure)");
19394 case NT_NETBSDCORE_FIRSTMACH
+ 2:
19395 return _("PT_GETFPREGS (fpreg structure)");
19401 /* On SuperH, PT_GETREGS == mach+3 and PT_GETFPREGS == mach+5.
19402 There's also old PT___GETREGS40 == mach + 1 for old reg
19403 structure which lacks GBR. */
19407 case NT_NETBSDCORE_FIRSTMACH
+ 1:
19408 return _("PT___GETREGS40 (old reg structure)");
19409 case NT_NETBSDCORE_FIRSTMACH
+ 3:
19410 return _("PT_GETREGS (reg structure)");
19411 case NT_NETBSDCORE_FIRSTMACH
+ 5:
19412 return _("PT_GETFPREGS (fpreg structure)");
19418 /* On all other arch's, PT_GETREGS == mach+1 and
19419 PT_GETFPREGS == mach+3. */
19423 case NT_NETBSDCORE_FIRSTMACH
+ 1:
19424 return _("PT_GETREGS (reg structure)");
19425 case NT_NETBSDCORE_FIRSTMACH
+ 3:
19426 return _("PT_GETFPREGS (fpreg structure)");
19432 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
19433 e_type
- NT_NETBSDCORE_FIRSTMACH
);
19437 static const char *
19438 get_stapsdt_note_type (unsigned e_type
)
19440 static char buff
[64];
19445 return _("NT_STAPSDT (SystemTap probe descriptors)");
19451 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
19456 print_stapsdt_note (Elf_Internal_Note
*pnote
)
19458 size_t len
, maxlen
;
19459 unsigned long addr_size
= is_32bit_elf
? 4 : 8;
19460 char *data
= pnote
->descdata
;
19461 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
19462 bfd_vma pc
, base_addr
, semaphore
;
19463 char *provider
, *probe
, *arg_fmt
;
19465 if (pnote
->descsz
< (addr_size
* 3))
19466 goto stapdt_note_too_small
;
19468 pc
= byte_get ((unsigned char *) data
, addr_size
);
19471 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
19474 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
19477 if (data
>= data_end
)
19478 goto stapdt_note_too_small
;
19479 maxlen
= data_end
- data
;
19480 len
= strnlen (data
, maxlen
);
19487 goto stapdt_note_too_small
;
19489 if (data
>= data_end
)
19490 goto stapdt_note_too_small
;
19491 maxlen
= data_end
- data
;
19492 len
= strnlen (data
, maxlen
);
19499 goto stapdt_note_too_small
;
19501 if (data
>= data_end
)
19502 goto stapdt_note_too_small
;
19503 maxlen
= data_end
- data
;
19504 len
= strnlen (data
, maxlen
);
19511 goto stapdt_note_too_small
;
19513 printf (_(" Provider: %s\n"), provider
);
19514 printf (_(" Name: %s\n"), probe
);
19515 printf (_(" Location: "));
19516 print_vma (pc
, FULL_HEX
);
19517 printf (_(", Base: "));
19518 print_vma (base_addr
, FULL_HEX
);
19519 printf (_(", Semaphore: "));
19520 print_vma (semaphore
, FULL_HEX
);
19522 printf (_(" Arguments: %s\n"), arg_fmt
);
19524 return data
== data_end
;
19526 stapdt_note_too_small
:
19527 printf (_(" <corrupt - note is too small>\n"));
19528 error (_("corrupt stapdt note - the data size is too small\n"));
19532 static const char *
19533 get_ia64_vms_note_type (unsigned e_type
)
19535 static char buff
[64];
19540 return _("NT_VMS_MHD (module header)");
19542 return _("NT_VMS_LNM (language name)");
19544 return _("NT_VMS_SRC (source files)");
19546 return "NT_VMS_TITLE";
19548 return _("NT_VMS_EIDC (consistency check)");
19549 case NT_VMS_FPMODE
:
19550 return _("NT_VMS_FPMODE (FP mode)");
19551 case NT_VMS_LINKTIME
:
19552 return "NT_VMS_LINKTIME";
19553 case NT_VMS_IMGNAM
:
19554 return _("NT_VMS_IMGNAM (image name)");
19556 return _("NT_VMS_IMGID (image id)");
19557 case NT_VMS_LINKID
:
19558 return _("NT_VMS_LINKID (link id)");
19559 case NT_VMS_IMGBID
:
19560 return _("NT_VMS_IMGBID (build id)");
19561 case NT_VMS_GSTNAM
:
19562 return _("NT_VMS_GSTNAM (sym table name)");
19563 case NT_VMS_ORIG_DYN
:
19564 return "NT_VMS_ORIG_DYN";
19565 case NT_VMS_PATCHTIME
:
19566 return "NT_VMS_PATCHTIME";
19568 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
19574 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
19576 int maxlen
= pnote
->descsz
;
19578 if (maxlen
< 2 || (unsigned long) maxlen
!= pnote
->descsz
)
19579 goto desc_size_fail
;
19581 switch (pnote
->type
)
19585 goto desc_size_fail
;
19587 int l
= (int) strnlen (pnote
->descdata
+ 34, maxlen
- 34);
19589 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
19590 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
19591 if (l
+ 34 < maxlen
)
19593 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
19594 if (l
+ 35 < maxlen
)
19595 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
19597 printf (_(" Module version : <missing>\n"));
19601 printf (_(" Module name : <missing>\n"));
19602 printf (_(" Module version : <missing>\n"));
19607 printf (_(" Language: %.*s\n"), maxlen
, pnote
->descdata
);
19611 case NT_VMS_FPMODE
:
19612 printf (_(" Floating Point mode: "));
19614 goto desc_size_fail
;
19615 /* FIXME: Generate an error if descsz > 8 ? */
19617 printf ("0x%016" BFD_VMA_FMT
"x\n",
19618 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
19621 case NT_VMS_LINKTIME
:
19622 printf (_(" Link time: "));
19624 goto desc_size_fail
;
19625 /* FIXME: Generate an error if descsz > 8 ? */
19628 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
19632 case NT_VMS_PATCHTIME
:
19633 printf (_(" Patch time: "));
19635 goto desc_size_fail
;
19636 /* FIXME: Generate an error if descsz > 8 ? */
19639 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
19643 case NT_VMS_ORIG_DYN
:
19645 goto desc_size_fail
;
19647 printf (_(" Major id: %u, minor id: %u\n"),
19648 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
19649 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
19650 printf (_(" Last modified : "));
19652 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
19653 printf (_("\n Link flags : "));
19654 printf ("0x%016" BFD_VMA_FMT
"x\n",
19655 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
19656 printf (_(" Header flags: 0x%08x\n"),
19657 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
19658 printf (_(" Image id : %.*s\n"), maxlen
- 32, pnote
->descdata
+ 32);
19662 case NT_VMS_IMGNAM
:
19663 printf (_(" Image name: %.*s\n"), maxlen
, pnote
->descdata
);
19666 case NT_VMS_GSTNAM
:
19667 printf (_(" Global symbol table name: %.*s\n"), maxlen
, pnote
->descdata
);
19671 printf (_(" Image id: %.*s\n"), maxlen
, pnote
->descdata
);
19674 case NT_VMS_LINKID
:
19675 printf (_(" Linker id: %.*s\n"), maxlen
, pnote
->descdata
);
19685 printf (_(" <corrupt - data size is too small>\n"));
19686 error (_("corrupt IA64 note: data size is too small\n"));
19690 struct build_attr_cache
{
19691 Filedata
*filedata
;
19693 unsigned long strtablen
;
19694 Elf_Internal_Sym
*symtab
;
19695 unsigned long nsyms
;
19698 /* Find the symbol associated with a build attribute that is attached
19699 to address OFFSET. If PNAME is non-NULL then store the name of
19700 the symbol (if found) in the provided pointer, Returns NULL if a
19701 symbol could not be found. */
19703 static Elf_Internal_Sym
*
19704 get_symbol_for_build_attribute (Filedata
* filedata
,
19705 unsigned long offset
,
19706 bfd_boolean is_open_attr
,
19707 const char ** pname
)
19709 Elf_Internal_Sym
*saved_sym
= NULL
;
19710 Elf_Internal_Sym
*sym
;
19712 if (filedata
->section_headers
!= NULL
19713 && (ba_cache
.filedata
== NULL
|| filedata
!= ba_cache
.filedata
))
19715 Elf_Internal_Shdr
* symsec
;
19717 free (ba_cache
.strtab
);
19718 ba_cache
.strtab
= NULL
;
19719 free (ba_cache
.symtab
);
19720 ba_cache
.symtab
= NULL
;
19722 /* Load the symbol and string sections. */
19723 for (symsec
= filedata
->section_headers
;
19724 symsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
19727 if (symsec
->sh_type
== SHT_SYMTAB
19728 && get_symtab (filedata
, symsec
,
19729 &ba_cache
.symtab
, &ba_cache
.nsyms
,
19730 &ba_cache
.strtab
, &ba_cache
.strtablen
))
19733 ba_cache
.filedata
= filedata
;
19736 if (ba_cache
.symtab
== NULL
)
19739 /* Find a symbol whose value matches offset. */
19740 for (sym
= ba_cache
.symtab
; sym
< ba_cache
.symtab
+ ba_cache
.nsyms
; sym
++)
19741 if (sym
->st_value
== offset
)
19743 if (sym
->st_name
>= ba_cache
.strtablen
)
19744 /* Huh ? This should not happen. */
19747 if (ba_cache
.strtab
[sym
->st_name
] == 0)
19750 /* The AArch64 and ARM architectures define mapping symbols
19751 (eg $d, $x, $t) which we want to ignore. */
19752 if (ba_cache
.strtab
[sym
->st_name
] == '$'
19753 && ba_cache
.strtab
[sym
->st_name
+ 1] != 0
19754 && ba_cache
.strtab
[sym
->st_name
+ 2] == 0)
19759 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
19760 and FILE or OBJECT symbols over NOTYPE symbols. We skip
19761 FUNC symbols entirely. */
19762 switch (ELF_ST_TYPE (sym
->st_info
))
19769 /* If the symbol has a size associated
19770 with it then we can stop searching. */
19771 sym
= ba_cache
.symtab
+ ba_cache
.nsyms
;
19776 /* Ignore function symbols. */
19783 switch (ELF_ST_BIND (sym
->st_info
))
19786 if (saved_sym
== NULL
19787 || ELF_ST_TYPE (saved_sym
->st_info
) != STT_OBJECT
)
19792 if (saved_sym
== NULL
)
19802 if (ELF_ST_TYPE (sym
->st_info
) != STT_FUNC
)
19810 if (saved_sym
&& pname
)
19811 * pname
= ba_cache
.strtab
+ saved_sym
->st_name
;
19816 /* Returns true iff addr1 and addr2 are in the same section. */
19819 same_section (Filedata
* filedata
, unsigned long addr1
, unsigned long addr2
)
19821 Elf_Internal_Shdr
* a1
;
19822 Elf_Internal_Shdr
* a2
;
19824 a1
= find_section_by_address (filedata
, addr1
);
19825 a2
= find_section_by_address (filedata
, addr2
);
19827 return a1
== a2
&& a1
!= NULL
;
19831 print_gnu_build_attribute_description (Elf_Internal_Note
* pnote
,
19832 Filedata
* filedata
)
19834 static unsigned long global_offset
= 0;
19835 static unsigned long global_end
= 0;
19836 static unsigned long func_offset
= 0;
19837 static unsigned long func_end
= 0;
19839 Elf_Internal_Sym
* sym
;
19841 unsigned long start
;
19843 bfd_boolean is_open_attr
= pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
;
19845 switch (pnote
->descsz
)
19848 /* A zero-length description means that the range of
19849 the previous note of the same type should be used. */
19852 if (global_end
> global_offset
)
19853 printf (_(" Applies to region from %#lx to %#lx\n"),
19854 global_offset
, global_end
);
19856 printf (_(" Applies to region from %#lx\n"), global_offset
);
19860 if (func_end
> func_offset
)
19861 printf (_(" Applies to region from %#lx to %#lx\n"), func_offset
, func_end
);
19863 printf (_(" Applies to region from %#lx\n"), func_offset
);
19868 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
19875 /* FIXME: We should check that version 3+ notes are being used here... */
19876 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
19877 end
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
19881 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
19887 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
19888 end
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 8);
19892 error (_(" <invalid description size: %lx>\n"), pnote
->descsz
);
19893 printf (_(" <invalid descsz>"));
19898 sym
= get_symbol_for_build_attribute (filedata
, start
, is_open_attr
, & name
);
19899 /* As of version 5 of the annobin plugin, filename symbols are biased by 2
19900 in order to avoid them being confused with the start address of the
19901 first function in the file... */
19902 if (sym
== NULL
&& is_open_attr
)
19903 sym
= get_symbol_for_build_attribute (filedata
, start
+ 2, is_open_attr
,
19906 if (end
== 0 && sym
!= NULL
&& sym
->st_size
> 0)
19907 end
= start
+ sym
->st_size
;
19911 /* FIXME: Need to properly allow for section alignment.
19912 16 is just the alignment used on x86_64. */
19914 && start
> BFD_ALIGN (global_end
, 16)
19915 /* Build notes are not guaranteed to be organised in order of
19916 increasing address, but we should find the all of the notes
19917 for one section in the same place. */
19918 && same_section (filedata
, start
, global_end
))
19919 warn (_("Gap in build notes detected from %#lx to %#lx\n"),
19920 global_end
+ 1, start
- 1);
19922 printf (_(" Applies to region from %#lx"), start
);
19923 global_offset
= start
;
19927 printf (_(" to %#lx"), end
);
19933 printf (_(" Applies to region from %#lx"), start
);
19934 func_offset
= start
;
19938 printf (_(" to %#lx"), end
);
19944 printf (_(" (%s)"), name
);
19951 print_gnu_build_attribute_name (Elf_Internal_Note
* pnote
)
19953 static const char string_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING
, 0 };
19954 static const char number_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
, 0 };
19955 static const char bool_expected
[3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
, 0 };
19957 char name_attribute
;
19958 const char * expected_types
;
19959 const char * name
= pnote
->namedata
;
19963 if (name
== NULL
|| pnote
->namesz
< 2)
19965 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
19966 print_symbol (-20, _(" <corrupt name>"));
19975 /* Version 2 of the spec adds a "GA" prefix to the name field. */
19976 if (name
[0] == 'G' && name
[1] == 'A')
19978 if (pnote
->namesz
< 4)
19980 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
19981 print_symbol (-20, _(" <corrupt name>"));
19990 switch ((name_type
= * name
))
19992 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
19993 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
19994 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
19995 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
19996 printf ("%c", * name
);
20000 error (_("unrecognised attribute type in name field: %d\n"), name_type
);
20001 print_symbol (-20, _("<unknown name type>"));
20008 switch ((name_attribute
= * name
))
20010 case GNU_BUILD_ATTRIBUTE_VERSION
:
20011 text
= _("<version>");
20012 expected_types
= string_expected
;
20015 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
20016 text
= _("<stack prot>");
20017 expected_types
= "!+*";
20020 case GNU_BUILD_ATTRIBUTE_RELRO
:
20021 text
= _("<relro>");
20022 expected_types
= bool_expected
;
20025 case GNU_BUILD_ATTRIBUTE_STACK_SIZE
:
20026 text
= _("<stack size>");
20027 expected_types
= number_expected
;
20030 case GNU_BUILD_ATTRIBUTE_TOOL
:
20031 text
= _("<tool>");
20032 expected_types
= string_expected
;
20035 case GNU_BUILD_ATTRIBUTE_ABI
:
20037 expected_types
= "$*";
20040 case GNU_BUILD_ATTRIBUTE_PIC
:
20042 expected_types
= number_expected
;
20045 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM
:
20046 text
= _("<short enum>");
20047 expected_types
= bool_expected
;
20051 if (ISPRINT (* name
))
20053 int len
= strnlen (name
, pnote
->namesz
- (name
- pnote
->namedata
)) + 1;
20055 if (len
> left
&& ! do_wide
)
20057 printf ("%.*s:", len
, name
);
20063 static char tmpbuf
[128];
20065 error (_("unrecognised byte in name field: %d\n"), * name
);
20066 sprintf (tmpbuf
, _("<unknown:_%d>"), * name
);
20070 expected_types
= "*$!+";
20075 left
-= printf ("%s", text
);
20077 if (strchr (expected_types
, name_type
) == NULL
)
20078 warn (_("attribute does not have an expected type (%c)\n"), name_type
);
20080 if ((unsigned long)(name
- pnote
->namedata
) > pnote
->namesz
)
20082 error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
20083 (unsigned long) pnote
->namesz
,
20084 (long) (name
- pnote
->namedata
));
20088 if (left
< 1 && ! do_wide
)
20093 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
20095 unsigned int bytes
;
20096 unsigned long long val
= 0;
20097 unsigned int shift
= 0;
20098 char * decoded
= NULL
;
20100 bytes
= pnote
->namesz
- (name
- pnote
->namedata
);
20102 /* The -1 is because the name field is always 0 terminated, and we
20103 want to be able to ensure that the shift in the while loop below
20104 will not overflow. */
20107 if (bytes
> sizeof (val
))
20109 error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
20111 bytes
= sizeof (val
);
20113 /* We do not bother to warn if bytes == 0 as this can
20114 happen with some early versions of the gcc plugin. */
20118 unsigned long long byte
= *name
++ & 0xff;
20120 val
|= byte
<< shift
;
20124 switch (name_attribute
)
20126 case GNU_BUILD_ATTRIBUTE_PIC
:
20129 case 0: decoded
= "static"; break;
20130 case 1: decoded
= "pic"; break;
20131 case 2: decoded
= "PIC"; break;
20132 case 3: decoded
= "pie"; break;
20133 case 4: decoded
= "PIE"; break;
20137 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
20140 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
20141 case 0: decoded
= "off"; break;
20142 case 1: decoded
= "on"; break;
20143 case 2: decoded
= "all"; break;
20144 case 3: decoded
= "strong"; break;
20145 case 4: decoded
= "explicit"; break;
20153 if (decoded
!= NULL
)
20155 print_symbol (-left
, decoded
);
20166 left
-= printf ("0x%llx", val
);
20168 left
-= printf ("0x%-.*llx", left
, val
);
20172 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
20173 left
-= print_symbol (- left
, name
);
20175 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
20176 left
-= print_symbol (- left
, "true");
20178 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
20179 left
-= print_symbol (- left
, "false");
20183 if (do_wide
&& left
> 0)
20184 printf ("%-*s", left
, " ");
20189 /* Note that by the ELF standard, the name field is already null byte
20190 terminated, and namesz includes the terminating null byte.
20191 I.E. the value of namesz for the name "FSF" is 4.
20193 If the value of namesz is zero, there is no name present. */
20196 process_note (Elf_Internal_Note
* pnote
,
20197 Filedata
* filedata
)
20199 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
20202 if (pnote
->namesz
== 0)
20203 /* If there is no note name, then use the default set of
20204 note type strings. */
20205 nt
= get_note_type (filedata
, pnote
->type
);
20207 else if (const_strneq (pnote
->namedata
, "GNU"))
20208 /* GNU-specific object file notes. */
20209 nt
= get_gnu_elf_note_type (pnote
->type
);
20211 else if (const_strneq (pnote
->namedata
, "FreeBSD"))
20212 /* FreeBSD-specific core file notes. */
20213 nt
= get_freebsd_elfcore_note_type (filedata
, pnote
->type
);
20215 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
20216 /* NetBSD-specific core file notes. */
20217 nt
= get_netbsd_elfcore_note_type (filedata
, pnote
->type
);
20219 else if (const_strneq (pnote
->namedata
, "NetBSD"))
20220 /* NetBSD-specific core file notes. */
20221 return process_netbsd_elf_note (pnote
);
20223 else if (const_strneq (pnote
->namedata
, "PaX"))
20224 /* NetBSD-specific core file notes. */
20225 return process_netbsd_elf_note (pnote
);
20227 else if (strneq (pnote
->namedata
, "SPU/", 4))
20229 /* SPU-specific core file notes. */
20230 nt
= pnote
->namedata
+ 4;
20234 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
20235 /* VMS/ia64-specific file notes. */
20236 nt
= get_ia64_vms_note_type (pnote
->type
);
20238 else if (const_strneq (pnote
->namedata
, "stapsdt"))
20239 nt
= get_stapsdt_note_type (pnote
->type
);
20242 /* Don't recognize this note name; just use the default set of
20243 note type strings. */
20244 nt
= get_note_type (filedata
, pnote
->type
);
20248 if (((const_strneq (pnote
->namedata
, "GA")
20249 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
20250 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
20251 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
20252 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
20253 print_gnu_build_attribute_name (pnote
);
20255 print_symbol (-20, name
);
20258 printf (" 0x%08lx\t%s\t", pnote
->descsz
, nt
);
20260 printf (" 0x%08lx\t%s\n", pnote
->descsz
, nt
);
20262 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
20263 return print_ia64_vms_note (pnote
);
20264 else if (const_strneq (pnote
->namedata
, "GNU"))
20265 return print_gnu_note (filedata
, pnote
);
20266 else if (const_strneq (pnote
->namedata
, "stapsdt"))
20267 return print_stapsdt_note (pnote
);
20268 else if (const_strneq (pnote
->namedata
, "CORE"))
20269 return print_core_note (pnote
);
20270 else if (((const_strneq (pnote
->namedata
, "GA")
20271 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
20272 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
20273 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
20274 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
20275 return print_gnu_build_attribute_description (pnote
, filedata
);
20281 printf (_(" description data: "));
20282 for (i
= 0; i
< pnote
->descsz
; i
++)
20283 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
20295 process_notes_at (Filedata
* filedata
,
20296 Elf_Internal_Shdr
* section
,
20301 Elf_External_Note
* pnotes
;
20302 Elf_External_Note
* external
;
20304 bfd_boolean res
= TRUE
;
20311 pnotes
= (Elf_External_Note
*) get_section_contents (section
, filedata
);
20314 if (! apply_relocations (filedata
, section
, (unsigned char *) pnotes
, length
, NULL
, NULL
))
20322 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
20325 if (pnotes
== NULL
)
20331 printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (filedata
, section
));
20333 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
20334 (unsigned long) offset
, (unsigned long) length
);
20336 /* NB: Some note sections may have alignment value of 0 or 1. gABI
20337 specifies that notes should be aligned to 4 bytes in 32-bit
20338 objects and to 8 bytes in 64-bit objects. As a Linux extension,
20339 we also support 4 byte alignment in 64-bit objects. If section
20340 alignment is less than 4, we treate alignment as 4 bytes. */
20343 else if (align
!= 4 && align
!= 8)
20345 warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
20351 printf (_(" %-20s %-10s\tDescription\n"), _("Owner"), _("Data size"));
20353 end
= (char *) pnotes
+ length
;
20354 while ((char *) external
< end
)
20356 Elf_Internal_Note inote
;
20359 char * temp
= NULL
;
20360 size_t data_remaining
= end
- (char *) external
;
20362 if (!is_ia64_vms (filedata
))
20364 /* PR binutils/15191
20365 Make sure that there is enough data to read. */
20366 min_notesz
= offsetof (Elf_External_Note
, name
);
20367 if (data_remaining
< min_notesz
)
20369 warn (ngettext ("Corrupt note: only %ld byte remains, "
20370 "not enough for a full note\n",
20371 "Corrupt note: only %ld bytes remain, "
20372 "not enough for a full note\n",
20374 (long) data_remaining
);
20377 data_remaining
-= min_notesz
;
20379 inote
.type
= BYTE_GET (external
->type
);
20380 inote
.namesz
= BYTE_GET (external
->namesz
);
20381 inote
.namedata
= external
->name
;
20382 inote
.descsz
= BYTE_GET (external
->descsz
);
20383 inote
.descdata
= ((char *) external
20384 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
20385 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
20386 next
= ((char *) external
20387 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
20391 Elf64_External_VMS_Note
*vms_external
;
20393 /* PR binutils/15191
20394 Make sure that there is enough data to read. */
20395 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
20396 if (data_remaining
< min_notesz
)
20398 warn (ngettext ("Corrupt note: only %ld byte remains, "
20399 "not enough for a full note\n",
20400 "Corrupt note: only %ld bytes remain, "
20401 "not enough for a full note\n",
20403 (long) data_remaining
);
20406 data_remaining
-= min_notesz
;
20408 vms_external
= (Elf64_External_VMS_Note
*) external
;
20409 inote
.type
= BYTE_GET (vms_external
->type
);
20410 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
20411 inote
.namedata
= vms_external
->name
;
20412 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
20413 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
20414 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
20415 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
20418 /* PR 17531: file: 3443835e. */
20419 /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
20420 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
20421 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
20422 || (size_t) (next
- inote
.descdata
) < inote
.descsz
20423 || ((size_t) (next
- inote
.descdata
)
20424 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
20426 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
20427 (unsigned long) ((char *) external
- (char *) pnotes
));
20428 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
20429 inote
.type
, inote
.namesz
, inote
.descsz
, (int) align
);
20433 external
= (Elf_External_Note
*) next
;
20435 /* Verify that name is null terminated. It appears that at least
20436 one version of Linux (RedHat 6.0) generates corefiles that don't
20437 comply with the ELF spec by failing to include the null byte in
20439 if (inote
.namesz
> 0 && inote
.namedata
[inote
.namesz
- 1] != '\0')
20441 if ((size_t) (inote
.descdata
- inote
.namedata
) == inote
.namesz
)
20443 temp
= (char *) malloc (inote
.namesz
+ 1);
20446 error (_("Out of memory allocating space for inote name\n"));
20451 memcpy (temp
, inote
.namedata
, inote
.namesz
);
20452 inote
.namedata
= temp
;
20454 inote
.namedata
[inote
.namesz
] = 0;
20457 if (! process_note (& inote
, filedata
))
20470 process_corefile_note_segments (Filedata
* filedata
)
20472 Elf_Internal_Phdr
* segment
;
20474 bfd_boolean res
= TRUE
;
20476 if (! get_program_headers (filedata
))
20479 for (i
= 0, segment
= filedata
->program_headers
;
20480 i
< filedata
->file_header
.e_phnum
;
20483 if (segment
->p_type
== PT_NOTE
)
20484 if (! process_notes_at (filedata
, NULL
,
20485 (bfd_vma
) segment
->p_offset
,
20486 (bfd_vma
) segment
->p_filesz
,
20487 (bfd_vma
) segment
->p_align
))
20495 process_v850_notes (Filedata
* filedata
, bfd_vma offset
, bfd_vma length
)
20497 Elf_External_Note
* pnotes
;
20498 Elf_External_Note
* external
;
20500 bfd_boolean res
= TRUE
;
20505 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
20507 if (pnotes
== NULL
)
20511 end
= (char*) pnotes
+ length
;
20513 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
20514 (unsigned long) offset
, (unsigned long) length
);
20516 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
20518 Elf_External_Note
* next
;
20519 Elf_Internal_Note inote
;
20521 inote
.type
= BYTE_GET (external
->type
);
20522 inote
.namesz
= BYTE_GET (external
->namesz
);
20523 inote
.namedata
= external
->name
;
20524 inote
.descsz
= BYTE_GET (external
->descsz
);
20525 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
20526 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
20528 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
20530 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
20531 inote
.descdata
= inote
.namedata
;
20535 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
20537 if ( ((char *) next
> end
)
20538 || ((char *) next
< (char *) pnotes
))
20540 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
20541 (unsigned long) ((char *) external
- (char *) pnotes
));
20542 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
20543 inote
.type
, inote
.namesz
, inote
.descsz
);
20549 /* Prevent out-of-bounds indexing. */
20550 if ( inote
.namedata
+ inote
.namesz
> end
20551 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
20553 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
20554 (unsigned long) ((char *) external
- (char *) pnotes
));
20555 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
20556 inote
.type
, inote
.namesz
, inote
.descsz
);
20560 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
20562 if (! print_v850_note (& inote
))
20565 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
20566 inote
.namesz
, inote
.descsz
);
20576 process_note_sections (Filedata
* filedata
)
20578 Elf_Internal_Shdr
* section
;
20580 unsigned int n
= 0;
20581 bfd_boolean res
= TRUE
;
20583 for (i
= 0, section
= filedata
->section_headers
;
20584 i
< filedata
->file_header
.e_shnum
&& section
!= NULL
;
20587 if (section
->sh_type
== SHT_NOTE
)
20589 if (! process_notes_at (filedata
, section
,
20590 (bfd_vma
) section
->sh_offset
,
20591 (bfd_vma
) section
->sh_size
,
20592 (bfd_vma
) section
->sh_addralign
))
20597 if (( filedata
->file_header
.e_machine
== EM_V800
20598 || filedata
->file_header
.e_machine
== EM_V850
20599 || filedata
->file_header
.e_machine
== EM_CYGNUS_V850
)
20600 && section
->sh_type
== SHT_RENESAS_INFO
)
20602 if (! process_v850_notes (filedata
,
20603 (bfd_vma
) section
->sh_offset
,
20604 (bfd_vma
) section
->sh_size
))
20611 /* Try processing NOTE segments instead. */
20612 return process_corefile_note_segments (filedata
);
20618 process_notes (Filedata
* filedata
)
20620 /* If we have not been asked to display the notes then do nothing. */
20624 if (filedata
->file_header
.e_type
!= ET_CORE
)
20625 return process_note_sections (filedata
);
20627 /* No program headers means no NOTE segment. */
20628 if (filedata
->file_header
.e_phnum
> 0)
20629 return process_corefile_note_segments (filedata
);
20631 printf (_("No note segments present in the core file.\n"));
20635 static unsigned char *
20636 display_public_gnu_attributes (unsigned char * start
,
20637 const unsigned char * const end
)
20639 printf (_(" Unknown GNU attribute: %s\n"), start
);
20641 start
+= strnlen ((char *) start
, end
- start
);
20642 display_raw_attribute (start
, end
);
20644 return (unsigned char *) end
;
20647 static unsigned char *
20648 display_generic_attribute (unsigned char * start
,
20650 const unsigned char * const end
)
20653 return (unsigned char *) end
;
20655 return display_tag_value (tag
, start
, end
);
20659 process_arch_specific (Filedata
* filedata
)
20664 switch (filedata
->file_header
.e_machine
)
20667 case EM_ARC_COMPACT
:
20668 case EM_ARC_COMPACT2
:
20669 return process_attributes (filedata
, "ARC", SHT_ARC_ATTRIBUTES
,
20670 display_arc_attribute
,
20671 display_generic_attribute
);
20673 return process_attributes (filedata
, "aeabi", SHT_ARM_ATTRIBUTES
,
20674 display_arm_attribute
,
20675 display_generic_attribute
);
20678 case EM_MIPS_RS3_LE
:
20679 return process_mips_specific (filedata
);
20682 return process_attributes (filedata
, "mspabi", SHT_MSP430_ATTRIBUTES
,
20683 display_msp430_attribute
,
20684 display_msp430_gnu_attribute
);
20687 return process_attributes (filedata
, "riscv", SHT_RISCV_ATTRIBUTES
,
20688 display_riscv_attribute
,
20689 display_generic_attribute
);
20692 return process_nds32_specific (filedata
);
20695 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
20696 display_m68k_gnu_attribute
);
20700 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
20701 display_power_gnu_attribute
);
20705 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
20706 display_s390_gnu_attribute
);
20709 case EM_SPARC32PLUS
:
20711 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
20712 display_sparc_gnu_attribute
);
20715 return process_attributes (filedata
, "c6xabi", SHT_C6000_ATTRIBUTES
,
20716 display_tic6x_attribute
,
20717 display_generic_attribute
);
20720 return process_attributes (filedata
, "csky", SHT_CSKY_ATTRIBUTES
,
20721 display_csky_attribute
, NULL
);
20724 return process_attributes (filedata
, "gnu", SHT_GNU_ATTRIBUTES
,
20725 display_public_gnu_attributes
,
20726 display_generic_attribute
);
20731 get_file_header (Filedata
* filedata
)
20733 /* Read in the identity array. */
20734 if (fread (filedata
->file_header
.e_ident
, EI_NIDENT
, 1, filedata
->handle
) != 1)
20737 /* Determine how to read the rest of the header. */
20738 switch (filedata
->file_header
.e_ident
[EI_DATA
])
20743 byte_get
= byte_get_little_endian
;
20744 byte_put
= byte_put_little_endian
;
20747 byte_get
= byte_get_big_endian
;
20748 byte_put
= byte_put_big_endian
;
20752 /* For now we only support 32 bit and 64 bit ELF files. */
20753 is_32bit_elf
= (filedata
->file_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
20755 /* Read in the rest of the header. */
20758 Elf32_External_Ehdr ehdr32
;
20760 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
20763 filedata
->file_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
20764 filedata
->file_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
20765 filedata
->file_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
20766 filedata
->file_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
20767 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
20768 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
20769 filedata
->file_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
20770 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
20771 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
20772 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
20773 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
20774 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
20775 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
20779 Elf64_External_Ehdr ehdr64
;
20781 /* If we have been compiled with sizeof (bfd_vma) == 4, then
20782 we will not be able to cope with the 64bit data found in
20783 64 ELF files. Detect this now and abort before we start
20784 overwriting things. */
20785 if (sizeof (bfd_vma
) < 8)
20787 error (_("This instance of readelf has been built without support for a\n\
20788 64 bit data type and so it cannot read 64 bit ELF files.\n"));
20792 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
20795 filedata
->file_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
20796 filedata
->file_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
20797 filedata
->file_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
20798 filedata
->file_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
20799 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
20800 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
20801 filedata
->file_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
20802 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
20803 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
20804 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
20805 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
20806 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
20807 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
20810 if (filedata
->file_header
.e_shoff
)
20812 /* There may be some extensions in the first section header. Don't
20813 bomb if we can't read it. */
20815 get_32bit_section_headers (filedata
, TRUE
);
20817 get_64bit_section_headers (filedata
, TRUE
);
20824 close_file (Filedata
* filedata
)
20828 if (filedata
->handle
)
20829 fclose (filedata
->handle
);
20835 close_debug_file (void * data
)
20837 close_file ((Filedata
*) data
);
20841 open_file (const char * pathname
)
20843 struct stat statbuf
;
20844 Filedata
* filedata
= NULL
;
20846 if (stat (pathname
, & statbuf
) < 0
20847 || ! S_ISREG (statbuf
.st_mode
))
20850 filedata
= calloc (1, sizeof * filedata
);
20851 if (filedata
== NULL
)
20854 filedata
->handle
= fopen (pathname
, "rb");
20855 if (filedata
->handle
== NULL
)
20858 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
20859 filedata
->file_name
= pathname
;
20861 if (! get_file_header (filedata
))
20864 if (filedata
->file_header
.e_shoff
)
20868 /* Read the section headers again, this time for real. */
20870 res
= get_32bit_section_headers (filedata
, FALSE
);
20872 res
= get_64bit_section_headers (filedata
, FALSE
);
20883 if (filedata
->handle
)
20884 fclose (filedata
->handle
);
20891 open_debug_file (const char * pathname
)
20893 return open_file (pathname
);
20896 /* Process one ELF object file according to the command line options.
20897 This file may actually be stored in an archive. The file is
20898 positioned at the start of the ELF object. Returns TRUE if no
20899 problems were encountered, FALSE otherwise. */
20902 process_object (Filedata
* filedata
)
20904 bfd_boolean have_separate_files
;
20908 if (! get_file_header (filedata
))
20910 error (_("%s: Failed to read file header\n"), filedata
->file_name
);
20914 /* Initialise per file variables. */
20915 for (i
= ARRAY_SIZE (filedata
->version_info
); i
--;)
20916 filedata
->version_info
[i
] = 0;
20918 for (i
= ARRAY_SIZE (filedata
->dynamic_info
); i
--;)
20919 filedata
->dynamic_info
[i
] = 0;
20920 filedata
->dynamic_info_DT_GNU_HASH
= 0;
20921 filedata
->dynamic_info_DT_MIPS_XHASH
= 0;
20923 /* Process the file. */
20925 printf (_("\nFile: %s\n"), filedata
->file_name
);
20927 /* Initialise the dump_sects array from the cmdline_dump_sects array.
20928 Note we do this even if cmdline_dump_sects is empty because we
20929 must make sure that the dump_sets array is zeroed out before each
20930 object file is processed. */
20931 if (filedata
->dump
.num_dump_sects
> cmdline
.num_dump_sects
)
20932 memset (filedata
->dump
.dump_sects
, 0,
20933 filedata
->dump
.num_dump_sects
* sizeof (*filedata
->dump
.dump_sects
));
20935 if (cmdline
.num_dump_sects
> 0)
20937 if (filedata
->dump
.num_dump_sects
== 0)
20938 /* A sneaky way of allocating the dump_sects array. */
20939 request_dump_bynumber (&filedata
->dump
, cmdline
.num_dump_sects
, 0);
20941 assert (filedata
->dump
.num_dump_sects
>= cmdline
.num_dump_sects
);
20942 memcpy (filedata
->dump
.dump_sects
, cmdline
.dump_sects
,
20943 cmdline
.num_dump_sects
* sizeof (*filedata
->dump
.dump_sects
));
20946 if (! process_file_header (filedata
))
20949 if (! process_section_headers (filedata
))
20951 /* Without loaded section headers we cannot process lots of things. */
20952 do_unwind
= do_version
= do_dump
= do_arch
= FALSE
;
20954 if (! do_using_dynamic
)
20955 do_syms
= do_dyn_syms
= do_reloc
= FALSE
;
20958 if (! process_section_groups (filedata
))
20959 /* Without loaded section groups we cannot process unwind. */
20962 res
= process_program_headers (filedata
);
20964 res
= process_dynamic_section (filedata
);
20966 if (! process_relocs (filedata
))
20969 if (! process_unwind (filedata
))
20972 if (! process_symbol_table (filedata
))
20975 if (! process_lto_symbol_tables (filedata
))
20978 if (! process_syminfo (filedata
))
20981 if (! process_version_sections (filedata
))
20984 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
)
20985 have_separate_files
= load_separate_debug_files (filedata
, filedata
->file_name
);
20987 have_separate_files
= FALSE
;
20989 if (! process_section_contents (filedata
))
20992 if (have_separate_files
)
20996 for (d
= first_separate_info
; d
!= NULL
; d
= d
->next
)
20998 if (! process_section_headers (d
->handle
))
21000 else if (! process_section_contents (d
->handle
))
21004 /* The file handles are closed by the call to free_debug_memory() below. */
21007 if (! process_notes (filedata
))
21010 if (! process_gnu_liblist (filedata
))
21013 if (! process_arch_specific (filedata
))
21016 free (filedata
->program_headers
);
21017 filedata
->program_headers
= NULL
;
21019 free (filedata
->section_headers
);
21020 filedata
->section_headers
= NULL
;
21022 free (filedata
->string_table
);
21023 filedata
->string_table
= NULL
;
21024 filedata
->string_table_length
= 0;
21026 free (filedata
->dump
.dump_sects
);
21027 filedata
->dump
.dump_sects
= NULL
;
21028 filedata
->dump
.num_dump_sects
= 0;
21030 free (filedata
->dynamic_strings
);
21031 filedata
->dynamic_strings
= NULL
;
21032 filedata
->dynamic_strings_length
= 0;
21034 free (filedata
->dynamic_symbols
);
21035 filedata
->dynamic_symbols
= NULL
;
21036 filedata
->num_dynamic_syms
= 0;
21038 free (filedata
->dynamic_syminfo
);
21039 filedata
->dynamic_syminfo
= NULL
;
21041 free (filedata
->dynamic_section
);
21042 filedata
->dynamic_section
= NULL
;
21044 while (filedata
->symtab_shndx_list
!= NULL
)
21046 elf_section_list
*next
= filedata
->symtab_shndx_list
->next
;
21047 free (filedata
->symtab_shndx_list
);
21048 filedata
->symtab_shndx_list
= next
;
21051 free (filedata
->section_headers_groups
);
21052 filedata
->section_headers_groups
= NULL
;
21054 if (filedata
->section_groups
)
21056 struct group_list
* g
;
21057 struct group_list
* next
;
21059 for (i
= 0; i
< filedata
->group_count
; i
++)
21061 for (g
= filedata
->section_groups
[i
].root
; g
!= NULL
; g
= next
)
21068 free (filedata
->section_groups
);
21069 filedata
->section_groups
= NULL
;
21072 free_debug_memory ();
21077 /* Process an ELF archive.
21078 On entry the file is positioned just after the ARMAG string.
21079 Returns TRUE upon success, FALSE otherwise. */
21082 process_archive (Filedata
* filedata
, bfd_boolean is_thin_archive
)
21084 struct archive_info arch
;
21085 struct archive_info nested_arch
;
21087 bfd_boolean ret
= TRUE
;
21091 /* The ARCH structure is used to hold information about this archive. */
21092 arch
.file_name
= NULL
;
21094 arch
.index_array
= NULL
;
21095 arch
.sym_table
= NULL
;
21096 arch
.longnames
= NULL
;
21098 /* The NESTED_ARCH structure is used as a single-item cache of information
21099 about a nested archive (when members of a thin archive reside within
21100 another regular archive file). */
21101 nested_arch
.file_name
= NULL
;
21102 nested_arch
.file
= NULL
;
21103 nested_arch
.index_array
= NULL
;
21104 nested_arch
.sym_table
= NULL
;
21105 nested_arch
.longnames
= NULL
;
21107 if (setup_archive (&arch
, filedata
->file_name
, filedata
->handle
,
21108 filedata
->file_size
, is_thin_archive
,
21109 do_archive_index
) != 0)
21115 if (do_archive_index
)
21117 if (arch
.sym_table
== NULL
)
21118 error (_("%s: unable to dump the index as none was found\n"),
21119 filedata
->file_name
);
21122 unsigned long i
, l
;
21123 unsigned long current_pos
;
21125 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes "
21126 "in the symbol table)\n"),
21127 filedata
->file_name
, (unsigned long) arch
.index_num
,
21130 current_pos
= ftell (filedata
->handle
);
21132 for (i
= l
= 0; i
< arch
.index_num
; i
++)
21135 || (i
> 0 && arch
.index_array
[i
] != arch
.index_array
[i
- 1]))
21138 = get_archive_member_name_at (&arch
, arch
.index_array
[i
],
21141 if (member_name
!= NULL
)
21143 char * qualified_name
21144 = make_qualified_name (&arch
, &nested_arch
,
21147 if (qualified_name
!= NULL
)
21149 printf (_("Contents of binary %s at offset "),
21151 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
21153 free (qualified_name
);
21155 free (member_name
);
21159 if (l
>= arch
.sym_size
)
21161 error (_("%s: end of the symbol table reached "
21162 "before the end of the index\n"),
21163 filedata
->file_name
);
21167 /* PR 17531: file: 0b6630b2. */
21168 printf ("\t%.*s\n",
21169 (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
21170 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
21173 if (arch
.uses_64bit_indices
)
21178 if (l
< arch
.sym_size
)
21180 error (ngettext ("%s: %ld byte remains in the symbol table, "
21181 "but without corresponding entries in "
21182 "the index table\n",
21183 "%s: %ld bytes remain in the symbol table, "
21184 "but without corresponding entries in "
21185 "the index table\n",
21186 arch
.sym_size
- l
),
21187 filedata
->file_name
, arch
.sym_size
- l
);
21191 if (fseek (filedata
->handle
, current_pos
, SEEK_SET
) != 0)
21193 error (_("%s: failed to seek back to start of object files "
21194 "in the archive\n"),
21195 filedata
->file_name
);
21201 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
21202 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
21203 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
21204 && !do_section_groups
&& !do_dyn_syms
)
21206 ret
= TRUE
; /* Archive index only. */
21215 char * qualified_name
;
21217 /* Read the next archive header. */
21218 if (fseek (filedata
->handle
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
21220 error (_("%s: failed to seek to next archive header\n"),
21225 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, filedata
->handle
);
21226 if (got
!= sizeof arch
.arhdr
)
21230 /* PR 24049 - we cannot use filedata->file_name as this will
21231 have already been freed. */
21232 error (_("%s: failed to read archive header\n"), arch
.file_name
);
21237 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
21239 error (_("%s: did not find a valid archive header\n"),
21245 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
21247 filedata
->archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
21248 if (filedata
->archive_file_size
& 01)
21249 ++filedata
->archive_file_size
;
21251 name
= get_archive_member_name (&arch
, &nested_arch
);
21254 error (_("%s: bad archive file name\n"), arch
.file_name
);
21258 namelen
= strlen (name
);
21260 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
21261 if (qualified_name
== NULL
)
21263 error (_("%s: bad archive file name\n"), arch
.file_name
);
21269 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
21271 /* This is a proxy for an external member of a thin archive. */
21272 Filedata
* member_filedata
;
21273 char * member_file_name
= adjust_relative_path
21274 (filedata
->file_name
, name
, namelen
);
21277 if (member_file_name
== NULL
)
21279 free (qualified_name
);
21284 member_filedata
= open_file (member_file_name
);
21285 if (member_filedata
== NULL
)
21287 error (_("Input file '%s' is not readable.\n"), member_file_name
);
21288 free (member_file_name
);
21289 free (qualified_name
);
21294 filedata
->archive_file_offset
= arch
.nested_member_origin
;
21295 member_filedata
->file_name
= qualified_name
;
21297 if (! process_object (member_filedata
))
21300 close_file (member_filedata
);
21301 free (member_file_name
);
21303 else if (is_thin_archive
)
21305 Filedata thin_filedata
;
21307 memset (&thin_filedata
, 0, sizeof (thin_filedata
));
21309 /* PR 15140: Allow for corrupt thin archives. */
21310 if (nested_arch
.file
== NULL
)
21312 error (_("%s: contains corrupt thin archive: %s\n"),
21313 qualified_name
, name
);
21314 free (qualified_name
);
21321 /* This is a proxy for a member of a nested archive. */
21322 filedata
->archive_file_offset
21323 = arch
.nested_member_origin
+ sizeof arch
.arhdr
;
21325 /* The nested archive file will have been opened and setup by
21326 get_archive_member_name. */
21327 if (fseek (nested_arch
.file
, filedata
->archive_file_offset
,
21330 error (_("%s: failed to seek to archive member.\n"),
21331 nested_arch
.file_name
);
21332 free (qualified_name
);
21337 thin_filedata
.handle
= nested_arch
.file
;
21338 thin_filedata
.file_name
= qualified_name
;
21340 if (! process_object (& thin_filedata
))
21346 filedata
->archive_file_offset
= arch
.next_arhdr_offset
;
21347 filedata
->file_name
= qualified_name
;
21348 if (! process_object (filedata
))
21350 arch
.next_arhdr_offset
+= filedata
->archive_file_size
;
21351 /* Stop looping with "negative" archive_file_size. */
21352 if (arch
.next_arhdr_offset
< filedata
->archive_file_size
)
21353 arch
.next_arhdr_offset
= -1ul;
21356 free (qualified_name
);
21360 if (nested_arch
.file
!= NULL
)
21361 fclose (nested_arch
.file
);
21362 release_archive (&nested_arch
);
21363 release_archive (&arch
);
21369 process_file (char * file_name
)
21371 Filedata
* filedata
= NULL
;
21372 struct stat statbuf
;
21373 char armag
[SARMAG
];
21374 bfd_boolean ret
= TRUE
;
21376 if (stat (file_name
, &statbuf
) < 0)
21378 if (errno
== ENOENT
)
21379 error (_("'%s': No such file\n"), file_name
);
21381 error (_("Could not locate '%s'. System error message: %s\n"),
21382 file_name
, strerror (errno
));
21386 if (! S_ISREG (statbuf
.st_mode
))
21388 error (_("'%s' is not an ordinary file\n"), file_name
);
21392 filedata
= calloc (1, sizeof * filedata
);
21393 if (filedata
== NULL
)
21395 error (_("Out of memory allocating file data structure\n"));
21399 filedata
->file_name
= file_name
;
21400 filedata
->handle
= fopen (file_name
, "rb");
21401 if (filedata
->handle
== NULL
)
21403 error (_("Input file '%s' is not readable.\n"), file_name
);
21408 if (fread (armag
, SARMAG
, 1, filedata
->handle
) != 1)
21410 error (_("%s: Failed to read file's magic number\n"), file_name
);
21411 fclose (filedata
->handle
);
21416 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
21418 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
21420 if (! process_archive (filedata
, FALSE
))
21423 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
21425 if ( ! process_archive (filedata
, TRUE
))
21430 if (do_archive_index
&& !check_all
)
21431 error (_("File %s is not an archive so its index cannot be displayed.\n"),
21434 rewind (filedata
->handle
);
21435 filedata
->archive_file_size
= filedata
->archive_file_offset
= 0;
21437 if (! process_object (filedata
))
21441 fclose (filedata
->handle
);
21442 free (filedata
->section_headers
);
21443 free (filedata
->program_headers
);
21444 free (filedata
->string_table
);
21445 free (filedata
->dump
.dump_sects
);
21448 free (ba_cache
.strtab
);
21449 ba_cache
.strtab
= NULL
;
21450 free (ba_cache
.symtab
);
21451 ba_cache
.symtab
= NULL
;
21452 ba_cache
.filedata
= NULL
;
21457 #ifdef SUPPORT_DISASSEMBLY
21458 /* Needed by the i386 disassembler. For extra credit, someone could
21459 fix this so that we insert symbolic addresses here, esp for GOT/PLT
21463 print_address (unsigned int addr
, FILE * outfile
)
21465 fprintf (outfile
,"0x%8.8x", addr
);
21468 /* Needed by the i386 disassembler. */
21471 db_task_printsym (unsigned int addr
)
21473 print_address (addr
, stderr
);
21478 main (int argc
, char ** argv
)
21482 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
21483 setlocale (LC_MESSAGES
, "");
21485 #if defined (HAVE_SETLOCALE)
21486 setlocale (LC_CTYPE
, "");
21488 bindtextdomain (PACKAGE
, LOCALEDIR
);
21489 textdomain (PACKAGE
);
21491 expandargv (&argc
, &argv
);
21493 parse_args (& cmdline
, argc
, argv
);
21495 if (optind
< (argc
- 1))
21496 /* When displaying information for more than one file,
21497 prefix the information with the file name. */
21499 else if (optind
>= argc
)
21501 /* Ensure that the warning is always displayed. */
21504 warn (_("Nothing to do.\n"));
21509 while (optind
< argc
)
21510 if (! process_file (argv
[optind
++]))
21513 free (cmdline
.dump_sects
);
21515 free (dump_ctf_symtab_name
);
21516 free (dump_ctf_strtab_name
);
21517 free (dump_ctf_parent_name
);
21519 return err
? EXIT_FAILURE
: EXIT_SUCCESS
;