1 /* readelf.c -- display contents of an ELF format file
2 Copyright (C) 1998-2019 Free Software Foundation, Inc.
4 Originally developed by Eric Youngdale <eric@andante.jic.com>
5 Modifications by Nick Clifton <nickc@redhat.com>
7 This file is part of GNU Binutils.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
24 /* The difference between readelf and objdump:
26 Both programs are capable of displaying the contents of ELF format files,
27 so why does the binutils project have two file dumpers ?
29 The reason is that objdump sees an ELF file through a BFD filter of the
30 world; if BFD has a bug where, say, it disagrees about a machine constant
31 in e_flags, then the odds are good that it will remain internally
32 consistent. The linker sees it the BFD way, objdump sees it the BFD way,
33 GAS sees it the BFD way. There was need for a tool to go find out what
34 the file actually says.
36 This is why the readelf program does not link against the BFD library - it
37 exists as an independent program to help verify the correct working of BFD.
39 There is also the case that readelf can provide more information about an
40 ELF file than is provided by objdump. In particular it can display DWARF
41 debugging information which (at the moment) objdump cannot. */
52 /* Define BFD64 here, even if our default architecture is 32 bit ELF
53 as this will allow us to read in and parse 64bit and 32bit ELF files.
54 Only do this if we believe that the compiler can support a 64 bit
55 data type. For now we only rely on GCC being able to do this. */
65 #include "elf/common.h"
66 #include "elf/external.h"
67 #include "elf/internal.h"
70 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
71 we can obtain the H8 reloc numbers. We need these for the
72 get_reloc_size() function. We include h8.h again after defining
73 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
78 /* Undo the effects of #including reloc-macros.h. */
80 #undef START_RELOC_NUMBERS
84 #undef END_RELOC_NUMBERS
85 #undef _RELOC_MACROS_H
87 /* The following headers use the elf/reloc-macros.h file to
88 automatically generate relocation recognition functions
89 such as elf_mips_reloc_type() */
91 #define RELOC_MACROS_GEN_FUNC
93 #include "elf/aarch64.h"
94 #include "elf/alpha.h"
100 #include "elf/cris.h"
102 #include "elf/csky.h"
103 #include "elf/d10v.h"
104 #include "elf/d30v.h"
107 #include "elf/epiphany.h"
108 #include "elf/fr30.h"
110 #include "elf/ft32.h"
112 #include "elf/hppa.h"
113 #include "elf/i386.h"
114 #include "elf/i370.h"
115 #include "elf/i860.h"
116 #include "elf/i960.h"
117 #include "elf/ia64.h"
118 #include "elf/ip2k.h"
119 #include "elf/lm32.h"
120 #include "elf/iq2000.h"
121 #include "elf/m32c.h"
122 #include "elf/m32r.h"
123 #include "elf/m68k.h"
124 #include "elf/m68hc11.h"
125 #include "elf/s12z.h"
126 #include "elf/mcore.h"
128 #include "elf/metag.h"
129 #include "elf/microblaze.h"
130 #include "elf/mips.h"
131 #include "elf/mmix.h"
132 #include "elf/mn10200.h"
133 #include "elf/mn10300.h"
134 #include "elf/moxie.h"
136 #include "elf/msp430.h"
137 #include "elf/nds32.h"
139 #include "elf/nios2.h"
140 #include "elf/or1k.h"
143 #include "elf/ppc64.h"
145 #include "elf/riscv.h"
146 #include "elf/rl78.h"
148 #include "elf/s390.h"
149 #include "elf/score.h"
151 #include "elf/sparc.h"
153 #include "elf/tic6x.h"
154 #include "elf/tilegx.h"
155 #include "elf/tilepro.h"
156 #include "elf/v850.h"
158 #include "elf/visium.h"
159 #include "elf/wasm32.h"
160 #include "elf/x86-64.h"
161 #include "elf/xc16x.h"
162 #include "elf/xgate.h"
163 #include "elf/xstormy16.h"
164 #include "elf/xtensa.h"
167 #include "libiberty.h"
168 #include "safe-ctype.h"
169 #include "filenames.h"
172 #define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
175 typedef struct elf_section_list
177 Elf_Internal_Shdr
* hdr
;
178 struct elf_section_list
* next
;
181 /* Flag bits indicating particular types of dump. */
182 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
183 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
184 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
185 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
186 #define RELOC_DUMP (1 << 4) /* The -R command line switch. */
187 #define CTF_DUMP (1 << 5) /* The --ctf command line switch. */
189 typedef unsigned char dump_type
;
191 /* A linked list of the section names for which dumps were requested. */
192 struct dump_list_entry
196 struct dump_list_entry
* next
;
199 typedef struct filedata
201 const char * file_name
;
203 bfd_size_type file_size
;
204 Elf_Internal_Ehdr file_header
;
205 Elf_Internal_Shdr
* section_headers
;
206 Elf_Internal_Phdr
* program_headers
;
208 unsigned long string_table_length
;
209 /* A dynamic array of flags indicating for which sections a dump of
210 some kind has been requested. It is reset on a per-object file
211 basis and then initialised from the cmdline_dump_sects array,
212 the results of interpreting the -w switch, and the
213 dump_sects_byname list. */
214 dump_type
* dump_sects
;
215 unsigned int num_dump_sects
;
218 char * program_name
= "readelf";
220 static unsigned long archive_file_offset
;
221 static unsigned long archive_file_size
;
222 static unsigned long dynamic_addr
;
223 static bfd_size_type dynamic_size
;
224 static size_t dynamic_nent
;
225 static char * dynamic_strings
;
226 static unsigned long dynamic_strings_length
;
227 static unsigned long num_dynamic_syms
;
228 static Elf_Internal_Sym
* dynamic_symbols
;
229 static Elf_Internal_Syminfo
* dynamic_syminfo
;
230 static unsigned long dynamic_syminfo_offset
;
231 static unsigned int dynamic_syminfo_nent
;
232 static char program_interpreter
[PATH_MAX
];
233 static bfd_vma dynamic_info
[DT_ENCODING
];
234 static bfd_vma dynamic_info_DT_GNU_HASH
;
235 static bfd_vma version_info
[16];
236 static Elf_Internal_Dyn
* dynamic_section
;
237 static elf_section_list
* symtab_shndx_list
;
238 static bfd_boolean show_name
= FALSE
;
239 static bfd_boolean do_dynamic
= FALSE
;
240 static bfd_boolean do_syms
= FALSE
;
241 static bfd_boolean do_dyn_syms
= FALSE
;
242 static bfd_boolean do_reloc
= FALSE
;
243 static bfd_boolean do_sections
= FALSE
;
244 static bfd_boolean do_section_groups
= FALSE
;
245 static bfd_boolean do_section_details
= FALSE
;
246 static bfd_boolean do_segments
= FALSE
;
247 static bfd_boolean do_unwind
= FALSE
;
248 static bfd_boolean do_using_dynamic
= FALSE
;
249 static bfd_boolean do_header
= FALSE
;
250 static bfd_boolean do_dump
= FALSE
;
251 static bfd_boolean do_version
= FALSE
;
252 static bfd_boolean do_histogram
= FALSE
;
253 static bfd_boolean do_debugging
= FALSE
;
254 static bfd_boolean do_ctf
= FALSE
;
255 static bfd_boolean do_arch
= FALSE
;
256 static bfd_boolean do_notes
= FALSE
;
257 static bfd_boolean do_archive_index
= FALSE
;
258 static bfd_boolean is_32bit_elf
= FALSE
;
259 static bfd_boolean decompress_dumps
= FALSE
;
261 static char *dump_ctf_parent_name
;
262 static char *dump_ctf_symtab_name
;
263 static char *dump_ctf_strtab_name
;
267 struct group_list
* next
;
268 unsigned int section_index
;
273 struct group_list
* root
;
274 unsigned int group_index
;
277 static size_t group_count
;
278 static struct group
* section_groups
;
279 static struct group
** section_headers_groups
;
281 /* A dynamic array of flags indicating for which sections a dump
282 has been requested via command line switches. */
283 static Filedata cmdline
;
285 static struct dump_list_entry
* dump_sects_byname
;
287 /* How to print a vma value. */
288 typedef enum print_mode
300 /* Versioned symbol info. */
301 enum versioned_symbol_info
308 static const char * get_symbol_version_string
309 (Filedata
*, bfd_boolean
, const char *, unsigned long, unsigned,
310 Elf_Internal_Sym
*, enum versioned_symbol_info
*, unsigned short *);
314 #define SECTION_NAME(X) \
315 ((X) == NULL ? _("<none>") \
316 : filedata->string_table == NULL ? _("<no-strings>") \
317 : ((X)->sh_name >= filedata->string_table_length ? _("<corrupt>") \
318 : filedata->string_table + (X)->sh_name))
320 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
322 #define GET_ELF_SYMBOLS(file, section, sym_count) \
323 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
324 : get_64bit_elf_symbols (file, section, sym_count))
326 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
327 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
328 already been called and verified that the string exists. */
329 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
331 #define REMOVE_ARCH_BITS(ADDR) \
334 if (filedata->file_header.e_machine == EM_ARM) \
339 /* Print a BFD_VMA to an internal buffer, for use in error messages.
340 BFD_FMA_FMT can't be used in translated strings. */
343 bfd_vmatoa (char *fmtch
, bfd_vma value
)
345 /* bfd_vmatoa is used more then once in a printf call for output.
346 Cycle through an array of buffers. */
347 static int buf_pos
= 0;
348 static struct bfd_vmatoa_buf
355 ret
= buf
[buf_pos
++].place
;
356 buf_pos
%= ARRAY_SIZE (buf
);
358 sprintf (fmt
, "%%%s%s", BFD_VMA_FMT
, fmtch
);
359 snprintf (ret
, sizeof (buf
[0].place
), fmt
, value
);
363 /* Retrieve NMEMB structures, each SIZE bytes long from FILEDATA starting at
364 OFFSET + the offset of the current archive member, if we are examining an
365 archive. Put the retrieved data into VAR, if it is not NULL. Otherwise
366 allocate a buffer using malloc and fill that. In either case return the
367 pointer to the start of the retrieved data or NULL if something went wrong.
368 If something does go wrong and REASON is not NULL then emit an error
369 message using REASON as part of the context. */
372 get_data (void * var
,
374 unsigned long offset
,
380 bfd_size_type amt
= size
* nmemb
;
382 if (size
== 0 || nmemb
== 0)
385 /* If the size_t type is smaller than the bfd_size_type, eg because
386 you are building a 32-bit tool on a 64-bit host, then make sure
387 that when the sizes are cast to (size_t) no information is lost. */
388 if (sizeof (size_t) < sizeof (bfd_size_type
)
389 && ( (bfd_size_type
) ((size_t) size
) != size
390 || (bfd_size_type
) ((size_t) nmemb
) != nmemb
))
393 error (_("Size truncation prevents reading %s"
394 " elements of size %s for %s\n"),
395 bfd_vmatoa ("u", nmemb
), bfd_vmatoa ("u", size
), reason
);
399 /* Check for size overflow. */
403 error (_("Size overflow prevents reading %s"
404 " elements of size %s for %s\n"),
405 bfd_vmatoa ("u", nmemb
), bfd_vmatoa ("u", size
), reason
);
409 /* Be kind to memory checkers (eg valgrind, address sanitizer) by not
410 attempting to allocate memory when the read is bound to fail. */
411 if (archive_file_offset
> filedata
->file_size
412 || offset
> filedata
->file_size
- archive_file_offset
413 || amt
> filedata
->file_size
- archive_file_offset
- offset
)
416 error (_("Reading %s bytes extends past end of file for %s\n"),
417 bfd_vmatoa ("u", amt
), reason
);
421 if (fseek (filedata
->handle
, archive_file_offset
+ offset
, SEEK_SET
))
424 error (_("Unable to seek to 0x%lx for %s\n"),
425 archive_file_offset
+ offset
, reason
);
432 /* Check for overflow. */
433 if (nmemb
< (~(bfd_size_type
) 0 - 1) / size
)
434 /* + 1 so that we can '\0' terminate invalid string table sections. */
435 mvar
= malloc ((size_t) amt
+ 1);
440 error (_("Out of memory allocating %s bytes for %s\n"),
441 bfd_vmatoa ("u", amt
), reason
);
445 ((char *) mvar
)[amt
] = '\0';
448 if (fread (mvar
, (size_t) size
, (size_t) nmemb
, filedata
->handle
) != nmemb
)
451 error (_("Unable to read in %s bytes of %s\n"),
452 bfd_vmatoa ("u", amt
), reason
);
461 /* Print a VMA value in the MODE specified.
462 Returns the number of characters displayed. */
465 print_vma (bfd_vma vma
, print_mode mode
)
477 return nc
+ printf ("%8.8" BFD_VMA_FMT
"x", vma
);
484 return printf ("%5" BFD_VMA_FMT
"d", vma
);
490 return nc
+ printf ("%" BFD_VMA_FMT
"x", vma
);
493 return printf ("%" BFD_VMA_FMT
"d", vma
);
496 return printf ("%" BFD_VMA_FMT
"u", vma
);
499 /* FIXME: Report unrecognised mode ? */
504 /* Display a symbol on stdout. Handles the display of control characters and
505 multibye characters (assuming the host environment supports them).
507 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
509 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
510 padding as necessary.
512 Returns the number of emitted characters. */
515 print_symbol (signed int width
, const char *symbol
)
517 bfd_boolean extra_padding
= FALSE
;
518 signed int num_printed
= 0;
519 #ifdef HAVE_MBSTATE_T
522 unsigned int width_remaining
;
526 /* Keep the width positive. This helps the code below. */
528 extra_padding
= TRUE
;
534 /* Set the remaining width to a very large value.
535 This simplifies the code below. */
536 width_remaining
= INT_MAX
;
538 width_remaining
= width
;
540 #ifdef HAVE_MBSTATE_T
541 /* Initialise the multibyte conversion state. */
542 memset (& state
, 0, sizeof (state
));
545 while (width_remaining
)
548 const char c
= *symbol
++;
553 /* Do not print control characters directly as they can affect terminal
554 settings. Such characters usually appear in the names generated
555 by the assembler for local labels. */
558 if (width_remaining
< 2)
561 printf ("^%c", c
+ 0x40);
562 width_remaining
-= 2;
565 else if (ISPRINT (c
))
573 #ifdef HAVE_MBSTATE_T
576 /* Let printf do the hard work of displaying multibyte characters. */
577 printf ("%.1s", symbol
- 1);
581 #ifdef HAVE_MBSTATE_T
582 /* Try to find out how many bytes made up the character that was
583 just printed. Advance the symbol pointer past the bytes that
585 n
= mbrtowc (& w
, symbol
- 1, MB_CUR_MAX
, & state
);
589 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
594 if (extra_padding
&& num_printed
< width
)
596 /* Fill in the remaining spaces. */
597 printf ("%-*s", width
- num_printed
, " ");
604 /* Returns a pointer to a static buffer containing a printable version of
605 the given section's name. Like print_symbol, except that it does not try
606 to print multibyte characters, it just interprets them as hex values. */
609 printable_section_name (Filedata
* filedata
, const Elf_Internal_Shdr
* sec
)
611 #define MAX_PRINT_SEC_NAME_LEN 128
612 static char sec_name_buf
[MAX_PRINT_SEC_NAME_LEN
+ 1];
613 const char * name
= SECTION_NAME (sec
);
614 char * buf
= sec_name_buf
;
616 unsigned int remaining
= MAX_PRINT_SEC_NAME_LEN
;
618 while ((c
= * name
++) != 0)
629 else if (ISPRINT (c
))
636 static char hex
[17] = "0123456789ABCDEF";
641 * buf
++ = hex
[(c
& 0xf0) >> 4];
642 * buf
++ = hex
[c
& 0x0f];
656 printable_section_name_from_index (Filedata
* filedata
, unsigned long ndx
)
658 if (ndx
>= filedata
->file_header
.e_shnum
)
659 return _("<corrupt>");
661 return printable_section_name (filedata
, filedata
->section_headers
+ ndx
);
664 /* Return a pointer to section NAME, or NULL if no such section exists. */
666 static Elf_Internal_Shdr
*
667 find_section (Filedata
* filedata
, const char * name
)
671 if (filedata
->section_headers
== NULL
)
674 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
675 if (streq (SECTION_NAME (filedata
->section_headers
+ i
), name
))
676 return filedata
->section_headers
+ i
;
681 /* Return a pointer to a section containing ADDR, or NULL if no such
684 static Elf_Internal_Shdr
*
685 find_section_by_address (Filedata
* filedata
, bfd_vma addr
)
689 if (filedata
->section_headers
== NULL
)
692 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
694 Elf_Internal_Shdr
*sec
= filedata
->section_headers
+ i
;
696 if (addr
>= sec
->sh_addr
&& addr
< sec
->sh_addr
+ sec
->sh_size
)
703 static Elf_Internal_Shdr
*
704 find_section_by_type (Filedata
* filedata
, unsigned int type
)
708 if (filedata
->section_headers
== NULL
)
711 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
713 Elf_Internal_Shdr
*sec
= filedata
->section_headers
+ i
;
715 if (sec
->sh_type
== type
)
722 /* Return a pointer to section NAME, or NULL if no such section exists,
723 restricted to the list of sections given in SET. */
725 static Elf_Internal_Shdr
*
726 find_section_in_set (Filedata
* filedata
, const char * name
, unsigned int * set
)
730 if (filedata
->section_headers
== NULL
)
735 while ((i
= *set
++) > 0)
737 /* See PR 21156 for a reproducer. */
738 if (i
>= filedata
->file_header
.e_shnum
)
739 continue; /* FIXME: Should we issue an error message ? */
741 if (streq (SECTION_NAME (filedata
->section_headers
+ i
), name
))
742 return filedata
->section_headers
+ i
;
746 return find_section (filedata
, name
);
749 /* Read an unsigned LEB128 encoded value from DATA.
750 Set *LENGTH_RETURN to the number of bytes read. */
752 static inline unsigned long
753 read_uleb128 (unsigned char * data
,
754 unsigned int * length_return
,
755 const unsigned char * const end
)
757 return read_leb128 (data
, length_return
, FALSE
, end
);
760 /* Return TRUE if the current file is for IA-64 machine and OpenVMS ABI.
761 This OS has so many departures from the ELF standard that we test it at
764 static inline bfd_boolean
765 is_ia64_vms (Filedata
* filedata
)
767 return filedata
->file_header
.e_machine
== EM_IA_64
768 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
;
771 /* Guess the relocation size commonly used by the specific machines. */
774 guess_is_rela (unsigned int e_machine
)
778 /* Targets that use REL relocations. */
795 /* Targets that use RELA relocations. */
799 case EM_ADAPTEVA_EPIPHANY
:
801 case EM_ALTERA_NIOS2
:
804 case EM_ARC_COMPACT2
:
825 case EM_LATTICEMICO32
:
834 case EM_CYGNUS_MN10200
:
836 case EM_CYGNUS_MN10300
:
872 case EM_MICROBLAZE_OLD
:
894 warn (_("Don't know about relocations on this machine architecture\n"));
899 /* Load RELA type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
900 Returns TRUE upon success, FALSE otherwise. If successful then a
901 pointer to a malloc'ed buffer containing the relocs is placed in *RELASP,
902 and the number of relocs loaded is placed in *NRELASP. It is the caller's
903 responsibility to free the allocated buffer. */
906 slurp_rela_relocs (Filedata
* filedata
,
907 unsigned long rel_offset
,
908 unsigned long rel_size
,
909 Elf_Internal_Rela
** relasp
,
910 unsigned long * nrelasp
)
912 Elf_Internal_Rela
* relas
;
918 Elf32_External_Rela
* erelas
;
920 erelas
= (Elf32_External_Rela
*) get_data (NULL
, filedata
, rel_offset
, 1,
921 rel_size
, _("32-bit relocation data"));
925 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
927 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
928 sizeof (Elf_Internal_Rela
));
933 error (_("out of memory parsing relocs\n"));
937 for (i
= 0; i
< nrelas
; i
++)
939 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
940 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
941 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
948 Elf64_External_Rela
* erelas
;
950 erelas
= (Elf64_External_Rela
*) get_data (NULL
, filedata
, rel_offset
, 1,
951 rel_size
, _("64-bit relocation data"));
955 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
957 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
958 sizeof (Elf_Internal_Rela
));
963 error (_("out of memory parsing relocs\n"));
967 for (i
= 0; i
< nrelas
; i
++)
969 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
970 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
971 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
973 /* The #ifdef BFD64 below is to prevent a compile time
974 warning. We know that if we do not have a 64 bit data
975 type that we will never execute this code anyway. */
977 if (filedata
->file_header
.e_machine
== EM_MIPS
978 && filedata
->file_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
980 /* In little-endian objects, r_info isn't really a
981 64-bit little-endian value: it has a 32-bit
982 little-endian symbol index followed by four
983 individual byte fields. Reorder INFO
985 bfd_vma inf
= relas
[i
].r_info
;
986 inf
= (((inf
& 0xffffffff) << 32)
987 | ((inf
>> 56) & 0xff)
988 | ((inf
>> 40) & 0xff00)
989 | ((inf
>> 24) & 0xff0000)
990 | ((inf
>> 8) & 0xff000000));
991 relas
[i
].r_info
= inf
;
1004 /* Load REL type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
1005 Returns TRUE upon success, FALSE otherwise. If successful then a
1006 pointer to a malloc'ed buffer containing the relocs is placed in *RELSP,
1007 and the number of relocs loaded is placed in *NRELSP. It is the caller's
1008 responsibility to free the allocated buffer. */
1011 slurp_rel_relocs (Filedata
* filedata
,
1012 unsigned long rel_offset
,
1013 unsigned long rel_size
,
1014 Elf_Internal_Rela
** relsp
,
1015 unsigned long * nrelsp
)
1017 Elf_Internal_Rela
* rels
;
1023 Elf32_External_Rel
* erels
;
1025 erels
= (Elf32_External_Rel
*) get_data (NULL
, filedata
, rel_offset
, 1,
1026 rel_size
, _("32-bit relocation data"));
1030 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
1032 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
1037 error (_("out of memory parsing relocs\n"));
1041 for (i
= 0; i
< nrels
; i
++)
1043 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
1044 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
1045 rels
[i
].r_addend
= 0;
1052 Elf64_External_Rel
* erels
;
1054 erels
= (Elf64_External_Rel
*) get_data (NULL
, filedata
, rel_offset
, 1,
1055 rel_size
, _("64-bit relocation data"));
1059 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
1061 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
1066 error (_("out of memory parsing relocs\n"));
1070 for (i
= 0; i
< nrels
; i
++)
1072 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
1073 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
1074 rels
[i
].r_addend
= 0;
1076 /* The #ifdef BFD64 below is to prevent a compile time
1077 warning. We know that if we do not have a 64 bit data
1078 type that we will never execute this code anyway. */
1080 if (filedata
->file_header
.e_machine
== EM_MIPS
1081 && filedata
->file_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
1083 /* In little-endian objects, r_info isn't really a
1084 64-bit little-endian value: it has a 32-bit
1085 little-endian symbol index followed by four
1086 individual byte fields. Reorder INFO
1088 bfd_vma inf
= rels
[i
].r_info
;
1089 inf
= (((inf
& 0xffffffff) << 32)
1090 | ((inf
>> 56) & 0xff)
1091 | ((inf
>> 40) & 0xff00)
1092 | ((inf
>> 24) & 0xff0000)
1093 | ((inf
>> 8) & 0xff000000));
1094 rels
[i
].r_info
= inf
;
1107 /* Returns the reloc type extracted from the reloc info field. */
1110 get_reloc_type (Filedata
* filedata
, bfd_vma reloc_info
)
1113 return ELF32_R_TYPE (reloc_info
);
1115 switch (filedata
->file_header
.e_machine
)
1118 /* Note: We assume that reloc_info has already been adjusted for us. */
1119 return ELF64_MIPS_R_TYPE (reloc_info
);
1122 return ELF64_R_TYPE_ID (reloc_info
);
1125 return ELF64_R_TYPE (reloc_info
);
1129 /* Return the symbol index extracted from the reloc info field. */
1132 get_reloc_symindex (bfd_vma reloc_info
)
1134 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
1137 static inline bfd_boolean
1138 uses_msp430x_relocs (Filedata
* filedata
)
1141 filedata
->file_header
.e_machine
== EM_MSP430
/* Paranoia. */
1142 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1143 && (((filedata
->file_header
.e_flags
& EF_MSP430_MACH
) == E_MSP430_MACH_MSP430X
)
1144 /* TI compiler uses ELFOSABI_NONE. */
1145 || (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
));
1148 /* Display the contents of the relocation data found at the specified
1152 dump_relocations (Filedata
* filedata
,
1153 unsigned long rel_offset
,
1154 unsigned long rel_size
,
1155 Elf_Internal_Sym
* symtab
,
1156 unsigned long nsyms
,
1158 unsigned long strtablen
,
1160 bfd_boolean is_dynsym
)
1163 Elf_Internal_Rela
* rels
;
1164 bfd_boolean res
= TRUE
;
1166 if (is_rela
== UNKNOWN
)
1167 is_rela
= guess_is_rela (filedata
->file_header
.e_machine
);
1171 if (!slurp_rela_relocs (filedata
, rel_offset
, rel_size
, &rels
, &rel_size
))
1176 if (!slurp_rel_relocs (filedata
, rel_offset
, rel_size
, &rels
, &rel_size
))
1185 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1187 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1192 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1194 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1202 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
1204 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1209 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
1211 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1215 for (i
= 0; i
< rel_size
; i
++)
1220 bfd_vma symtab_index
;
1223 offset
= rels
[i
].r_offset
;
1224 inf
= rels
[i
].r_info
;
1226 type
= get_reloc_type (filedata
, inf
);
1227 symtab_index
= get_reloc_symindex (inf
);
1231 printf ("%8.8lx %8.8lx ",
1232 (unsigned long) offset
& 0xffffffff,
1233 (unsigned long) inf
& 0xffffffff);
1237 #if BFD_HOST_64BIT_LONG
1239 ? "%16.16lx %16.16lx "
1240 : "%12.12lx %12.12lx ",
1242 #elif BFD_HOST_64BIT_LONG_LONG
1245 ? "%16.16llx %16.16llx "
1246 : "%12.12llx %12.12llx ",
1250 ? "%16.16I64x %16.16I64x "
1251 : "%12.12I64x %12.12I64x ",
1256 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1257 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1258 _bfd_int64_high (offset
),
1259 _bfd_int64_low (offset
),
1260 _bfd_int64_high (inf
),
1261 _bfd_int64_low (inf
));
1265 switch (filedata
->file_header
.e_machine
)
1272 rtype
= elf_aarch64_reloc_type (type
);
1276 case EM_CYGNUS_M32R
:
1277 rtype
= elf_m32r_reloc_type (type
);
1282 rtype
= elf_i386_reloc_type (type
);
1287 rtype
= elf_m68hc11_reloc_type (type
);
1291 rtype
= elf_s12z_reloc_type (type
);
1295 rtype
= elf_m68k_reloc_type (type
);
1299 rtype
= elf_i960_reloc_type (type
);
1304 rtype
= elf_avr_reloc_type (type
);
1307 case EM_OLD_SPARCV9
:
1308 case EM_SPARC32PLUS
:
1311 rtype
= elf_sparc_reloc_type (type
);
1315 rtype
= elf_spu_reloc_type (type
);
1319 rtype
= v800_reloc_type (type
);
1322 case EM_CYGNUS_V850
:
1323 rtype
= v850_reloc_type (type
);
1327 case EM_CYGNUS_D10V
:
1328 rtype
= elf_d10v_reloc_type (type
);
1332 case EM_CYGNUS_D30V
:
1333 rtype
= elf_d30v_reloc_type (type
);
1337 rtype
= elf_dlx_reloc_type (type
);
1341 rtype
= elf_sh_reloc_type (type
);
1345 case EM_CYGNUS_MN10300
:
1346 rtype
= elf_mn10300_reloc_type (type
);
1350 case EM_CYGNUS_MN10200
:
1351 rtype
= elf_mn10200_reloc_type (type
);
1355 case EM_CYGNUS_FR30
:
1356 rtype
= elf_fr30_reloc_type (type
);
1360 rtype
= elf_frv_reloc_type (type
);
1364 rtype
= elf_csky_reloc_type (type
);
1368 rtype
= elf_ft32_reloc_type (type
);
1372 rtype
= elf_mcore_reloc_type (type
);
1376 rtype
= elf_mmix_reloc_type (type
);
1380 rtype
= elf_moxie_reloc_type (type
);
1384 if (uses_msp430x_relocs (filedata
))
1386 rtype
= elf_msp430x_reloc_type (type
);
1391 rtype
= elf_msp430_reloc_type (type
);
1395 rtype
= elf_nds32_reloc_type (type
);
1399 rtype
= elf_ppc_reloc_type (type
);
1403 rtype
= elf_ppc64_reloc_type (type
);
1407 case EM_MIPS_RS3_LE
:
1408 rtype
= elf_mips_reloc_type (type
);
1412 rtype
= elf_riscv_reloc_type (type
);
1416 rtype
= elf_alpha_reloc_type (type
);
1420 rtype
= elf_arm_reloc_type (type
);
1424 case EM_ARC_COMPACT
:
1425 case EM_ARC_COMPACT2
:
1426 rtype
= elf_arc_reloc_type (type
);
1430 rtype
= elf_hppa_reloc_type (type
);
1436 rtype
= elf_h8_reloc_type (type
);
1440 rtype
= elf_or1k_reloc_type (type
);
1445 rtype
= elf_pj_reloc_type (type
);
1448 rtype
= elf_ia64_reloc_type (type
);
1452 rtype
= elf_cris_reloc_type (type
);
1456 rtype
= elf_i860_reloc_type (type
);
1462 rtype
= elf_x86_64_reloc_type (type
);
1466 rtype
= i370_reloc_type (type
);
1471 rtype
= elf_s390_reloc_type (type
);
1475 rtype
= elf_score_reloc_type (type
);
1479 rtype
= elf_xstormy16_reloc_type (type
);
1483 rtype
= elf_crx_reloc_type (type
);
1487 rtype
= elf_vax_reloc_type (type
);
1491 rtype
= elf_visium_reloc_type (type
);
1495 rtype
= elf_bpf_reloc_type (type
);
1498 case EM_ADAPTEVA_EPIPHANY
:
1499 rtype
= elf_epiphany_reloc_type (type
);
1504 rtype
= elf_ip2k_reloc_type (type
);
1508 rtype
= elf_iq2000_reloc_type (type
);
1513 rtype
= elf_xtensa_reloc_type (type
);
1516 case EM_LATTICEMICO32
:
1517 rtype
= elf_lm32_reloc_type (type
);
1522 rtype
= elf_m32c_reloc_type (type
);
1526 rtype
= elf_mt_reloc_type (type
);
1530 rtype
= elf_bfin_reloc_type (type
);
1534 rtype
= elf_mep_reloc_type (type
);
1538 rtype
= elf_cr16_reloc_type (type
);
1542 case EM_MICROBLAZE_OLD
:
1543 rtype
= elf_microblaze_reloc_type (type
);
1547 rtype
= elf_rl78_reloc_type (type
);
1551 rtype
= elf_rx_reloc_type (type
);
1555 rtype
= elf_metag_reloc_type (type
);
1560 rtype
= elf_xc16x_reloc_type (type
);
1564 rtype
= elf_tic6x_reloc_type (type
);
1568 rtype
= elf_tilegx_reloc_type (type
);
1572 rtype
= elf_tilepro_reloc_type (type
);
1575 case EM_WEBASSEMBLY
:
1576 rtype
= elf_wasm32_reloc_type (type
);
1580 rtype
= elf_xgate_reloc_type (type
);
1583 case EM_ALTERA_NIOS2
:
1584 rtype
= elf_nios2_reloc_type (type
);
1588 rtype
= elf_pru_reloc_type (type
);
1592 if (EF_NFP_MACH (filedata
->file_header
.e_flags
) == E_NFP_MACH_3200
)
1593 rtype
= elf_nfp3200_reloc_type (type
);
1595 rtype
= elf_nfp_reloc_type (type
);
1600 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1602 printf (do_wide
? "%-22s" : "%-17.17s", rtype
);
1604 if (filedata
->file_header
.e_machine
== EM_ALPHA
1606 && streq (rtype
, "R_ALPHA_LITUSE")
1609 switch (rels
[i
].r_addend
)
1611 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1612 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1613 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1614 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1615 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1616 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1617 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1618 default: rtype
= NULL
;
1622 printf (" (%s)", rtype
);
1626 printf (_("<unknown addend: %lx>"),
1627 (unsigned long) rels
[i
].r_addend
);
1631 else if (symtab_index
)
1633 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1635 error (_(" bad symbol index: %08lx in reloc"), (unsigned long) symtab_index
);
1640 Elf_Internal_Sym
* psym
;
1641 const char * version_string
;
1642 enum versioned_symbol_info sym_info
;
1643 unsigned short vna_other
;
1645 psym
= symtab
+ symtab_index
;
1648 = get_symbol_version_string (filedata
, is_dynsym
,
1657 if (ELF_ST_TYPE (psym
->st_info
) == STT_GNU_IFUNC
)
1661 unsigned int width
= is_32bit_elf
? 8 : 14;
1663 /* Relocations against GNU_IFUNC symbols do not use the value
1664 of the symbol as the address to relocate against. Instead
1665 they invoke the function named by the symbol and use its
1666 result as the address for relocation.
1668 To indicate this to the user, do not display the value of
1669 the symbol in the "Symbols's Value" field. Instead show
1670 its name followed by () as a hint that the symbol is
1674 || psym
->st_name
== 0
1675 || psym
->st_name
>= strtablen
)
1678 name
= strtab
+ psym
->st_name
;
1680 len
= print_symbol (width
, name
);
1682 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1684 printf ("()%-*s", len
<= width
? (width
+ 1) - len
: 1, " ");
1688 print_vma (psym
->st_value
, LONG_HEX
);
1690 printf (is_32bit_elf
? " " : " ");
1693 if (psym
->st_name
== 0)
1695 const char * sec_name
= "<null>";
1698 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1700 if (psym
->st_shndx
< filedata
->file_header
.e_shnum
)
1701 sec_name
= SECTION_NAME (filedata
->section_headers
+ psym
->st_shndx
);
1702 else if (psym
->st_shndx
== SHN_ABS
)
1704 else if (psym
->st_shndx
== SHN_COMMON
)
1705 sec_name
= "COMMON";
1706 else if ((filedata
->file_header
.e_machine
== EM_MIPS
1707 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1708 || (filedata
->file_header
.e_machine
== EM_TI_C6000
1709 && psym
->st_shndx
== SHN_TIC6X_SCOMMON
))
1710 sec_name
= "SCOMMON";
1711 else if (filedata
->file_header
.e_machine
== EM_MIPS
1712 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1713 sec_name
= "SUNDEF";
1714 else if ((filedata
->file_header
.e_machine
== EM_X86_64
1715 || filedata
->file_header
.e_machine
== EM_L1OM
1716 || filedata
->file_header
.e_machine
== EM_K1OM
)
1717 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1718 sec_name
= "LARGE_COMMON";
1719 else if (filedata
->file_header
.e_machine
== EM_IA_64
1720 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1721 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1722 sec_name
= "ANSI_COM";
1723 else if (is_ia64_vms (filedata
)
1724 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
1725 sec_name
= "VMS_SYMVEC";
1728 sprintf (name_buf
, "<section 0x%x>",
1729 (unsigned int) psym
->st_shndx
);
1730 sec_name
= name_buf
;
1733 print_symbol (22, sec_name
);
1735 else if (strtab
== NULL
)
1736 printf (_("<string table index: %3ld>"), psym
->st_name
);
1737 else if (psym
->st_name
>= strtablen
)
1739 error (_("<corrupt string table index: %3ld>"), psym
->st_name
);
1744 print_symbol (22, strtab
+ psym
->st_name
);
1746 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1752 bfd_vma off
= rels
[i
].r_addend
;
1754 if ((bfd_signed_vma
) off
< 0)
1755 printf (" - %" BFD_VMA_FMT
"x", - off
);
1757 printf (" + %" BFD_VMA_FMT
"x", off
);
1763 bfd_vma off
= rels
[i
].r_addend
;
1765 printf ("%*c", is_32bit_elf
? 12 : 20, ' ');
1766 if ((bfd_signed_vma
) off
< 0)
1767 printf ("-%" BFD_VMA_FMT
"x", - off
);
1769 printf ("%" BFD_VMA_FMT
"x", off
);
1772 if (filedata
->file_header
.e_machine
== EM_SPARCV9
1774 && streq (rtype
, "R_SPARC_OLO10"))
1775 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf
));
1780 if (! is_32bit_elf
&& filedata
->file_header
.e_machine
== EM_MIPS
)
1782 bfd_vma type2
= ELF64_MIPS_R_TYPE2 (inf
);
1783 bfd_vma type3
= ELF64_MIPS_R_TYPE3 (inf
);
1784 const char * rtype2
= elf_mips_reloc_type (type2
);
1785 const char * rtype3
= elf_mips_reloc_type (type3
);
1787 printf (" Type2: ");
1790 printf (_("unrecognized: %-7lx"),
1791 (unsigned long) type2
& 0xffffffff);
1793 printf ("%-17.17s", rtype2
);
1795 printf ("\n Type3: ");
1798 printf (_("unrecognized: %-7lx"),
1799 (unsigned long) type3
& 0xffffffff);
1801 printf ("%-17.17s", rtype3
);
1814 get_aarch64_dynamic_type (unsigned long type
)
1818 case DT_AARCH64_BTI_PLT
: return "AARCH64_BTI_PLT";
1819 case DT_AARCH64_PAC_PLT
: return "AARCH64_PAC_PLT";
1820 case DT_AARCH64_VARIANT_PCS
: return "AARCH64_VARIANT_PCS";
1827 get_mips_dynamic_type (unsigned long type
)
1831 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1832 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1833 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1834 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1835 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1836 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1837 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1838 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1839 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1840 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1841 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1842 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1843 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1844 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1845 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1846 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1847 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1848 case DT_MIPS_RLD_MAP_REL
: return "MIPS_RLD_MAP_REL";
1849 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1850 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1851 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1852 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1853 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1854 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1855 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1856 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1857 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1858 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1859 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1860 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1861 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1862 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1863 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1864 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1865 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1866 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1867 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1868 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1869 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1870 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1871 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1872 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1873 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1874 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1875 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
1876 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
1883 get_sparc64_dynamic_type (unsigned long type
)
1887 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1894 get_ppc_dynamic_type (unsigned long type
)
1898 case DT_PPC_GOT
: return "PPC_GOT";
1899 case DT_PPC_OPT
: return "PPC_OPT";
1906 get_ppc64_dynamic_type (unsigned long type
)
1910 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1911 case DT_PPC64_OPD
: return "PPC64_OPD";
1912 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1913 case DT_PPC64_OPT
: return "PPC64_OPT";
1920 get_parisc_dynamic_type (unsigned long type
)
1924 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1925 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1926 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1927 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1928 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1929 case DT_HP_PREINIT
: return "HP_PREINIT";
1930 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1931 case DT_HP_NEEDED
: return "HP_NEEDED";
1932 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1933 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1934 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1935 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1936 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1937 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1938 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1939 case DT_HP_FILTERED
: return "HP_FILTERED";
1940 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1941 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1942 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1943 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1944 case DT_PLT
: return "PLT";
1945 case DT_PLT_SIZE
: return "PLT_SIZE";
1946 case DT_DLT
: return "DLT";
1947 case DT_DLT_SIZE
: return "DLT_SIZE";
1954 get_ia64_dynamic_type (unsigned long type
)
1958 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1959 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
1960 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
1961 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
1962 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
1963 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
1964 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
1965 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
1966 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
1967 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
1968 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
1969 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
1970 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
1971 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
1972 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
1973 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
1974 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
1975 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
1976 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
1977 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
1978 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
1979 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
1980 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
1981 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
1982 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
1983 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
1984 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
1985 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
1986 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
1987 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
1988 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
1995 get_solaris_section_type (unsigned long type
)
1999 case 0x6fffffee: return "SUNW_ancillary";
2000 case 0x6fffffef: return "SUNW_capchain";
2001 case 0x6ffffff0: return "SUNW_capinfo";
2002 case 0x6ffffff1: return "SUNW_symsort";
2003 case 0x6ffffff2: return "SUNW_tlssort";
2004 case 0x6ffffff3: return "SUNW_LDYNSYM";
2005 case 0x6ffffff4: return "SUNW_dof";
2006 case 0x6ffffff5: return "SUNW_cap";
2007 case 0x6ffffff6: return "SUNW_SIGNATURE";
2008 case 0x6ffffff7: return "SUNW_ANNOTATE";
2009 case 0x6ffffff8: return "SUNW_DEBUGSTR";
2010 case 0x6ffffff9: return "SUNW_DEBUG";
2011 case 0x6ffffffa: return "SUNW_move";
2012 case 0x6ffffffb: return "SUNW_COMDAT";
2013 case 0x6ffffffc: return "SUNW_syminfo";
2014 case 0x6ffffffd: return "SUNW_verdef";
2015 case 0x6ffffffe: return "SUNW_verneed";
2016 case 0x6fffffff: return "SUNW_versym";
2017 case 0x70000000: return "SPARC_GOTDATA";
2018 default: return NULL
;
2023 get_alpha_dynamic_type (unsigned long type
)
2027 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
2028 default: return NULL
;
2033 get_score_dynamic_type (unsigned long type
)
2037 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
2038 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
2039 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
2040 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
2041 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
2042 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
2043 default: return NULL
;
2048 get_tic6x_dynamic_type (unsigned long type
)
2052 case DT_C6000_GSYM_OFFSET
: return "C6000_GSYM_OFFSET";
2053 case DT_C6000_GSTR_OFFSET
: return "C6000_GSTR_OFFSET";
2054 case DT_C6000_DSBT_BASE
: return "C6000_DSBT_BASE";
2055 case DT_C6000_DSBT_SIZE
: return "C6000_DSBT_SIZE";
2056 case DT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
2057 case DT_C6000_DSBT_INDEX
: return "C6000_DSBT_INDEX";
2058 default: return NULL
;
2063 get_nios2_dynamic_type (unsigned long type
)
2067 case DT_NIOS2_GP
: return "NIOS2_GP";
2068 default: return NULL
;
2073 get_solaris_dynamic_type (unsigned long type
)
2077 case 0x6000000d: return "SUNW_AUXILIARY";
2078 case 0x6000000e: return "SUNW_RTLDINF";
2079 case 0x6000000f: return "SUNW_FILTER";
2080 case 0x60000010: return "SUNW_CAP";
2081 case 0x60000011: return "SUNW_SYMTAB";
2082 case 0x60000012: return "SUNW_SYMSZ";
2083 case 0x60000013: return "SUNW_SORTENT";
2084 case 0x60000014: return "SUNW_SYMSORT";
2085 case 0x60000015: return "SUNW_SYMSORTSZ";
2086 case 0x60000016: return "SUNW_TLSSORT";
2087 case 0x60000017: return "SUNW_TLSSORTSZ";
2088 case 0x60000018: return "SUNW_CAPINFO";
2089 case 0x60000019: return "SUNW_STRPAD";
2090 case 0x6000001a: return "SUNW_CAPCHAIN";
2091 case 0x6000001b: return "SUNW_LDMACH";
2092 case 0x6000001d: return "SUNW_CAPCHAINENT";
2093 case 0x6000001f: return "SUNW_CAPCHAINSZ";
2094 case 0x60000021: return "SUNW_PARENT";
2095 case 0x60000023: return "SUNW_ASLR";
2096 case 0x60000025: return "SUNW_RELAX";
2097 case 0x60000029: return "SUNW_NXHEAP";
2098 case 0x6000002b: return "SUNW_NXSTACK";
2100 case 0x70000001: return "SPARC_REGISTER";
2101 case 0x7ffffffd: return "AUXILIARY";
2102 case 0x7ffffffe: return "USED";
2103 case 0x7fffffff: return "FILTER";
2105 default: return NULL
;
2110 get_dynamic_type (Filedata
* filedata
, unsigned long type
)
2112 static char buff
[64];
2116 case DT_NULL
: return "NULL";
2117 case DT_NEEDED
: return "NEEDED";
2118 case DT_PLTRELSZ
: return "PLTRELSZ";
2119 case DT_PLTGOT
: return "PLTGOT";
2120 case DT_HASH
: return "HASH";
2121 case DT_STRTAB
: return "STRTAB";
2122 case DT_SYMTAB
: return "SYMTAB";
2123 case DT_RELA
: return "RELA";
2124 case DT_RELASZ
: return "RELASZ";
2125 case DT_RELAENT
: return "RELAENT";
2126 case DT_STRSZ
: return "STRSZ";
2127 case DT_SYMENT
: return "SYMENT";
2128 case DT_INIT
: return "INIT";
2129 case DT_FINI
: return "FINI";
2130 case DT_SONAME
: return "SONAME";
2131 case DT_RPATH
: return "RPATH";
2132 case DT_SYMBOLIC
: return "SYMBOLIC";
2133 case DT_REL
: return "REL";
2134 case DT_RELSZ
: return "RELSZ";
2135 case DT_RELENT
: return "RELENT";
2136 case DT_PLTREL
: return "PLTREL";
2137 case DT_DEBUG
: return "DEBUG";
2138 case DT_TEXTREL
: return "TEXTREL";
2139 case DT_JMPREL
: return "JMPREL";
2140 case DT_BIND_NOW
: return "BIND_NOW";
2141 case DT_INIT_ARRAY
: return "INIT_ARRAY";
2142 case DT_FINI_ARRAY
: return "FINI_ARRAY";
2143 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
2144 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
2145 case DT_RUNPATH
: return "RUNPATH";
2146 case DT_FLAGS
: return "FLAGS";
2148 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2149 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
2150 case DT_SYMTAB_SHNDX
: return "SYMTAB_SHNDX";
2152 case DT_CHECKSUM
: return "CHECKSUM";
2153 case DT_PLTPADSZ
: return "PLTPADSZ";
2154 case DT_MOVEENT
: return "MOVEENT";
2155 case DT_MOVESZ
: return "MOVESZ";
2156 case DT_FEATURE
: return "FEATURE";
2157 case DT_POSFLAG_1
: return "POSFLAG_1";
2158 case DT_SYMINSZ
: return "SYMINSZ";
2159 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
2161 case DT_ADDRRNGLO
: return "ADDRRNGLO";
2162 case DT_CONFIG
: return "CONFIG";
2163 case DT_DEPAUDIT
: return "DEPAUDIT";
2164 case DT_AUDIT
: return "AUDIT";
2165 case DT_PLTPAD
: return "PLTPAD";
2166 case DT_MOVETAB
: return "MOVETAB";
2167 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
2169 case DT_VERSYM
: return "VERSYM";
2171 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
2172 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
2173 case DT_RELACOUNT
: return "RELACOUNT";
2174 case DT_RELCOUNT
: return "RELCOUNT";
2175 case DT_FLAGS_1
: return "FLAGS_1";
2176 case DT_VERDEF
: return "VERDEF";
2177 case DT_VERDEFNUM
: return "VERDEFNUM";
2178 case DT_VERNEED
: return "VERNEED";
2179 case DT_VERNEEDNUM
: return "VERNEEDNUM";
2181 case DT_AUXILIARY
: return "AUXILIARY";
2182 case DT_USED
: return "USED";
2183 case DT_FILTER
: return "FILTER";
2185 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
2186 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
2187 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
2188 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
2189 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
2190 case DT_GNU_HASH
: return "GNU_HASH";
2193 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
2195 const char * result
;
2197 switch (filedata
->file_header
.e_machine
)
2200 result
= get_aarch64_dynamic_type (type
);
2203 case EM_MIPS_RS3_LE
:
2204 result
= get_mips_dynamic_type (type
);
2207 result
= get_sparc64_dynamic_type (type
);
2210 result
= get_ppc_dynamic_type (type
);
2213 result
= get_ppc64_dynamic_type (type
);
2216 result
= get_ia64_dynamic_type (type
);
2219 result
= get_alpha_dynamic_type (type
);
2222 result
= get_score_dynamic_type (type
);
2225 result
= get_tic6x_dynamic_type (type
);
2227 case EM_ALTERA_NIOS2
:
2228 result
= get_nios2_dynamic_type (type
);
2231 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2232 result
= get_solaris_dynamic_type (type
);
2241 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
2243 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
2244 || (filedata
->file_header
.e_machine
== EM_PARISC
2245 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
2247 const char * result
;
2249 switch (filedata
->file_header
.e_machine
)
2252 result
= get_parisc_dynamic_type (type
);
2255 result
= get_ia64_dynamic_type (type
);
2258 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2259 result
= get_solaris_dynamic_type (type
);
2268 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
2272 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
2279 get_file_type (unsigned e_type
)
2281 static char buff
[32];
2285 case ET_NONE
: return _("NONE (None)");
2286 case ET_REL
: return _("REL (Relocatable file)");
2287 case ET_EXEC
: return _("EXEC (Executable file)");
2288 case ET_DYN
: return _("DYN (Shared object file)");
2289 case ET_CORE
: return _("CORE (Core file)");
2292 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
2293 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
2294 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
2295 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
2297 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
2303 get_machine_name (unsigned e_machine
)
2305 static char buff
[64]; /* XXX */
2309 /* Please keep this switch table sorted by increasing EM_ value. */
2311 case EM_NONE
: return _("None");
2312 case EM_M32
: return "WE32100";
2313 case EM_SPARC
: return "Sparc";
2314 case EM_386
: return "Intel 80386";
2315 case EM_68K
: return "MC68000";
2316 case EM_88K
: return "MC88000";
2317 case EM_IAMCU
: return "Intel MCU";
2318 case EM_860
: return "Intel 80860";
2319 case EM_MIPS
: return "MIPS R3000";
2320 case EM_S370
: return "IBM System/370";
2322 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
2323 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
2324 case EM_PARISC
: return "HPPA";
2325 case EM_VPP550
: return "Fujitsu VPP500";
2326 case EM_SPARC32PLUS
: return "Sparc v8+" ;
2327 case EM_960
: return "Intel 80960";
2328 case EM_PPC
: return "PowerPC";
2330 case EM_PPC64
: return "PowerPC64";
2332 case EM_S390
: return "IBM S/390";
2333 case EM_SPU
: return "SPU";
2335 case EM_V800
: return "Renesas V850 (using RH850 ABI)";
2336 case EM_FR20
: return "Fujitsu FR20";
2337 case EM_RH32
: return "TRW RH32";
2338 case EM_MCORE
: return "MCORE";
2340 case EM_ARM
: return "ARM";
2341 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
2342 case EM_SH
: return "Renesas / SuperH SH";
2343 case EM_SPARCV9
: return "Sparc v9";
2344 case EM_TRICORE
: return "Siemens Tricore";
2345 case EM_ARC
: return "ARC";
2346 case EM_H8_300
: return "Renesas H8/300";
2347 case EM_H8_300H
: return "Renesas H8/300H";
2348 case EM_H8S
: return "Renesas H8S";
2349 case EM_H8_500
: return "Renesas H8/500";
2351 case EM_IA_64
: return "Intel IA-64";
2352 case EM_MIPS_X
: return "Stanford MIPS-X";
2353 case EM_COLDFIRE
: return "Motorola Coldfire";
2354 case EM_68HC12
: return "Motorola MC68HC12 Microcontroller";
2355 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
2356 case EM_PCP
: return "Siemens PCP";
2357 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
2358 case EM_NDR1
: return "Denso NDR1 microprocesspr";
2359 case EM_STARCORE
: return "Motorola Star*Core processor";
2360 case EM_ME16
: return "Toyota ME16 processor";
2362 case EM_ST100
: return "STMicroelectronics ST100 processor";
2363 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
2364 case EM_X86_64
: return "Advanced Micro Devices X86-64";
2365 case EM_PDSP
: return "Sony DSP processor";
2366 case EM_PDP10
: return "Digital Equipment Corp. PDP-10";
2367 case EM_PDP11
: return "Digital Equipment Corp. PDP-11";
2368 case EM_FX66
: return "Siemens FX66 microcontroller";
2369 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2370 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
2371 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
2373 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
2374 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
2375 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
2376 case EM_SVX
: return "Silicon Graphics SVx";
2377 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
2378 case EM_VAX
: return "Digital VAX";
2379 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
2380 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
2381 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
2382 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
2384 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
2385 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
2386 case EM_PRISM
: return "Vitesse Prism";
2388 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
2389 case EM_CYGNUS_FR30
:
2390 case EM_FR30
: return "Fujitsu FR30";
2391 case EM_CYGNUS_D10V
:
2392 case EM_D10V
: return "d10v";
2393 case EM_CYGNUS_D30V
:
2394 case EM_D30V
: return "d30v";
2395 case EM_CYGNUS_V850
:
2396 case EM_V850
: return "Renesas V850";
2397 case EM_CYGNUS_M32R
:
2398 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
2399 case EM_CYGNUS_MN10300
:
2400 case EM_MN10300
: return "mn10300";
2402 case EM_CYGNUS_MN10200
:
2403 case EM_MN10200
: return "mn10200";
2404 case EM_PJ
: return "picoJava";
2405 case EM_OR1K
: return "OpenRISC 1000";
2406 case EM_ARC_COMPACT
: return "ARCompact";
2408 case EM_XTENSA
: return "Tensilica Xtensa Processor";
2409 case EM_VIDEOCORE
: return "Alphamosaic VideoCore processor";
2410 case EM_TMM_GPP
: return "Thompson Multimedia General Purpose Processor";
2411 case EM_NS32K
: return "National Semiconductor 32000 series";
2412 case EM_TPC
: return "Tenor Network TPC processor";
2413 case EM_SNP1K
: return "Trebia SNP 1000 processor";
2415 case EM_ST200
: return "STMicroelectronics ST200 microcontroller";
2417 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
2418 case EM_MAX
: return "MAX Processor";
2419 case EM_CR
: return "National Semiconductor CompactRISC";
2420 case EM_F2MC16
: return "Fujitsu F2MC16";
2421 case EM_MSP430
: return "Texas Instruments msp430 microcontroller";
2422 case EM_BLACKFIN
: return "Analog Devices Blackfin";
2423 case EM_SE_C33
: return "S1C33 Family of Seiko Epson processors";
2424 case EM_SEP
: return "Sharp embedded microprocessor";
2425 case EM_ARCA
: return "Arca RISC microprocessor";
2427 case EM_UNICORE
: return "Unicore";
2428 case EM_EXCESS
: return "eXcess 16/32/64-bit configurable embedded CPU";
2429 case EM_DXP
: return "Icera Semiconductor Inc. Deep Execution Processor";
2430 case EM_ALTERA_NIOS2
: return "Altera Nios II";
2431 case EM_CRX
: return "National Semiconductor CRX microprocessor";
2432 case EM_XGATE
: return "Motorola XGATE embedded processor";
2434 case EM_XC16X
: return "Infineon Technologies xc16x";
2435 case EM_M16C
: return "Renesas M16C series microprocessors";
2436 case EM_DSPIC30F
: return "Microchip Technology dsPIC30F Digital Signal Controller";
2437 case EM_CE
: return "Freescale Communication Engine RISC core";
2439 case EM_M32C
: return "Renesas M32c";
2441 case EM_TSK3000
: return "Altium TSK3000 core";
2442 case EM_RS08
: return "Freescale RS08 embedded processor";
2443 case EM_ECOG2
: return "Cyan Technology eCOG2 microprocessor";
2444 case EM_SCORE
: return "SUNPLUS S+Core";
2445 case EM_DSP24
: return "New Japan Radio (NJR) 24-bit DSP Processor";
2446 case EM_VIDEOCORE3
: return "Broadcom VideoCore III processor";
2447 case EM_LATTICEMICO32
: return "Lattice Mico32";
2448 case EM_SE_C17
: return "Seiko Epson C17 family";
2450 case EM_TI_C6000
: return "Texas Instruments TMS320C6000 DSP family";
2451 case EM_TI_C2000
: return "Texas Instruments TMS320C2000 DSP family";
2452 case EM_TI_C5500
: return "Texas Instruments TMS320C55x DSP family";
2453 case EM_TI_PRU
: return "TI PRU I/O processor";
2455 case EM_MMDSP_PLUS
: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2456 case EM_CYPRESS_M8C
: return "Cypress M8C microprocessor";
2457 case EM_R32C
: return "Renesas R32C series microprocessors";
2458 case EM_TRIMEDIA
: return "NXP Semiconductors TriMedia architecture family";
2459 case EM_QDSP6
: return "QUALCOMM DSP6 Processor";
2460 case EM_8051
: return "Intel 8051 and variants";
2461 case EM_STXP7X
: return "STMicroelectronics STxP7x family";
2462 case EM_NDS32
: return "Andes Technology compact code size embedded RISC processor family";
2463 case EM_ECOG1X
: return "Cyan Technology eCOG1X family";
2464 case EM_MAXQ30
: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2466 case EM_XIMO16
: return "New Japan Radio (NJR) 16-bit DSP Processor";
2467 case EM_MANIK
: return "M2000 Reconfigurable RISC Microprocessor";
2468 case EM_CRAYNV2
: return "Cray Inc. NV2 vector architecture";
2469 case EM_RX
: return "Renesas RX";
2470 case EM_METAG
: return "Imagination Technologies Meta processor architecture";
2471 case EM_MCST_ELBRUS
: return "MCST Elbrus general purpose hardware architecture";
2472 case EM_ECOG16
: return "Cyan Technology eCOG16 family";
2475 case EM_MICROBLAZE_OLD
: return "Xilinx MicroBlaze";
2476 case EM_ETPU
: return "Freescale Extended Time Processing Unit";
2477 case EM_SLE9X
: return "Infineon Technologies SLE9X core";
2479 case EM_L1OM
: return "Intel L1OM";
2480 case EM_K1OM
: return "Intel K1OM";
2481 case EM_INTEL182
: return "Intel (reserved)";
2482 case EM_AARCH64
: return "AArch64";
2483 case EM_ARM184
: return "ARM (reserved)";
2484 case EM_AVR32
: return "Atmel Corporation 32-bit microprocessor";
2485 case EM_STM8
: return "STMicroeletronics STM8 8-bit microcontroller";
2486 case EM_TILE64
: return "Tilera TILE64 multicore architecture family";
2487 case EM_TILEPRO
: return "Tilera TILEPro multicore architecture family";
2489 case EM_CUDA
: return "NVIDIA CUDA architecture";
2490 case EM_TILEGX
: return "Tilera TILE-Gx multicore architecture family";
2491 case EM_CLOUDSHIELD
: return "CloudShield architecture family";
2492 case EM_COREA_1ST
: return "KIPO-KAIST Core-A 1st generation processor family";
2493 case EM_COREA_2ND
: return "KIPO-KAIST Core-A 2nd generation processor family";
2494 case EM_ARC_COMPACT2
: return "ARCv2";
2495 case EM_OPEN8
: return "Open8 8-bit RISC soft processor core";
2496 case EM_RL78
: return "Renesas RL78";
2497 case EM_VIDEOCORE5
: return "Broadcom VideoCore V processor";
2498 case EM_78K0R
: return "Renesas 78K0R";
2500 case EM_56800EX
: return "Freescale 56800EX Digital Signal Controller (DSC)";
2501 case EM_BA1
: return "Beyond BA1 CPU architecture";
2502 case EM_BA2
: return "Beyond BA2 CPU architecture";
2503 case EM_XCORE
: return "XMOS xCORE processor family";
2504 case EM_MCHP_PIC
: return "Microchip 8-bit PIC(r) family";
2506 case EM_KM32
: return "KM211 KM32 32-bit processor";
2507 case EM_KMX32
: return "KM211 KMX32 32-bit processor";
2508 case EM_KMX16
: return "KM211 KMX16 16-bit processor";
2509 case EM_KMX8
: return "KM211 KMX8 8-bit processor";
2510 case EM_KVARC
: return "KM211 KVARC processor";
2511 case EM_CDP
: return "Paneve CDP architecture family";
2512 case EM_COGE
: return "Cognitive Smart Memory Processor";
2513 case EM_COOL
: return "Bluechip Systems CoolEngine";
2514 case EM_NORC
: return "Nanoradio Optimized RISC";
2515 case EM_CSR_KALIMBA
: return "CSR Kalimba architecture family";
2517 case EM_Z80
: return "Zilog Z80";
2518 case EM_VISIUM
: return "CDS VISIUMcore processor";
2519 case EM_FT32
: return "FTDI Chip FT32";
2520 case EM_MOXIE
: return "Moxie";
2521 case EM_AMDGPU
: return "AMD GPU";
2522 case EM_RISCV
: return "RISC-V";
2523 case EM_LANAI
: return "Lanai 32-bit processor";
2524 case EM_BPF
: return "Linux BPF";
2525 case EM_NFP
: return "Netronome Flow Processor";
2527 /* Large numbers... */
2528 case EM_MT
: return "Morpho Techologies MT processor";
2529 case EM_ALPHA
: return "Alpha";
2530 case EM_WEBASSEMBLY
: return "Web Assembly";
2531 case EM_DLX
: return "OpenDLX";
2532 case EM_XSTORMY16
: return "Sanyo XStormy16 CPU core";
2533 case EM_IQ2000
: return "Vitesse IQ2000";
2535 case EM_NIOS32
: return "Altera Nios";
2536 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
2537 case EM_ADAPTEVA_EPIPHANY
: return "Adapteva EPIPHANY";
2538 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
2539 case EM_S12Z
: return "Freescale S12Z";
2540 case EM_CSKY
: return "C-SKY";
2543 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
2549 decode_ARC_machine_flags (unsigned e_flags
, unsigned e_machine
, char buf
[])
2551 /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2. Some
2552 other compilers don't a specific architecture type in the e_flags, and
2553 instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
2554 architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
2557 Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
2558 but also sets a specific architecture type in the e_flags field.
2560 However, when decoding the flags we don't worry if we see an
2561 unexpected pairing, for example EM_ARC_COMPACT machine type, with
2562 ARCEM architecture type. */
2564 switch (e_flags
& EF_ARC_MACH_MSK
)
2566 /* We only expect these to occur for EM_ARC_COMPACT2. */
2567 case EF_ARC_CPU_ARCV2EM
:
2568 strcat (buf
, ", ARC EM");
2570 case EF_ARC_CPU_ARCV2HS
:
2571 strcat (buf
, ", ARC HS");
2574 /* We only expect these to occur for EM_ARC_COMPACT. */
2575 case E_ARC_MACH_ARC600
:
2576 strcat (buf
, ", ARC600");
2578 case E_ARC_MACH_ARC601
:
2579 strcat (buf
, ", ARC601");
2581 case E_ARC_MACH_ARC700
:
2582 strcat (buf
, ", ARC700");
2585 /* The only times we should end up here are (a) A corrupt ELF, (b) A
2586 new ELF with new architecture being read by an old version of
2587 readelf, or (c) An ELF built with non-GNU compiler that does not
2588 set the architecture in the e_flags. */
2590 if (e_machine
== EM_ARC_COMPACT
)
2591 strcat (buf
, ", Unknown ARCompact");
2593 strcat (buf
, ", Unknown ARC");
2597 switch (e_flags
& EF_ARC_OSABI_MSK
)
2599 case E_ARC_OSABI_ORIG
:
2600 strcat (buf
, ", (ABI:legacy)");
2602 case E_ARC_OSABI_V2
:
2603 strcat (buf
, ", (ABI:v2)");
2605 /* Only upstream 3.9+ kernels will support ARCv2 ISA. */
2606 case E_ARC_OSABI_V3
:
2607 strcat (buf
, ", v3 no-legacy-syscalls ABI");
2609 case E_ARC_OSABI_V4
:
2610 strcat (buf
, ", v4 ABI");
2613 strcat (buf
, ", unrecognised ARC OSABI flag");
2619 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
2622 bfd_boolean unknown
= FALSE
;
2624 eabi
= EF_ARM_EABI_VERSION (e_flags
);
2625 e_flags
&= ~ EF_ARM_EABIMASK
;
2627 /* Handle "generic" ARM flags. */
2628 if (e_flags
& EF_ARM_RELEXEC
)
2630 strcat (buf
, ", relocatable executable");
2631 e_flags
&= ~ EF_ARM_RELEXEC
;
2634 if (e_flags
& EF_ARM_PIC
)
2636 strcat (buf
, ", position independent");
2637 e_flags
&= ~ EF_ARM_PIC
;
2640 /* Now handle EABI specific flags. */
2644 strcat (buf
, ", <unrecognized EABI>");
2649 case EF_ARM_EABI_VER1
:
2650 strcat (buf
, ", Version1 EABI");
2655 /* Process flags one bit at a time. */
2656 flag
= e_flags
& - e_flags
;
2661 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2662 strcat (buf
, ", sorted symbol tables");
2672 case EF_ARM_EABI_VER2
:
2673 strcat (buf
, ", Version2 EABI");
2678 /* Process flags one bit at a time. */
2679 flag
= e_flags
& - e_flags
;
2684 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2685 strcat (buf
, ", sorted symbol tables");
2688 case EF_ARM_DYNSYMSUSESEGIDX
:
2689 strcat (buf
, ", dynamic symbols use segment index");
2692 case EF_ARM_MAPSYMSFIRST
:
2693 strcat (buf
, ", mapping symbols precede others");
2703 case EF_ARM_EABI_VER3
:
2704 strcat (buf
, ", Version3 EABI");
2707 case EF_ARM_EABI_VER4
:
2708 strcat (buf
, ", Version4 EABI");
2713 /* Process flags one bit at a time. */
2714 flag
= e_flags
& - e_flags
;
2720 strcat (buf
, ", BE8");
2724 strcat (buf
, ", LE8");
2734 case EF_ARM_EABI_VER5
:
2735 strcat (buf
, ", Version5 EABI");
2740 /* Process flags one bit at a time. */
2741 flag
= e_flags
& - e_flags
;
2747 strcat (buf
, ", BE8");
2751 strcat (buf
, ", LE8");
2754 case EF_ARM_ABI_FLOAT_SOFT
: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2755 strcat (buf
, ", soft-float ABI");
2758 case EF_ARM_ABI_FLOAT_HARD
: /* Conflicts with EF_ARM_VFP_FLOAT. */
2759 strcat (buf
, ", hard-float ABI");
2769 case EF_ARM_EABI_UNKNOWN
:
2770 strcat (buf
, ", GNU EABI");
2775 /* Process flags one bit at a time. */
2776 flag
= e_flags
& - e_flags
;
2781 case EF_ARM_INTERWORK
:
2782 strcat (buf
, ", interworking enabled");
2785 case EF_ARM_APCS_26
:
2786 strcat (buf
, ", uses APCS/26");
2789 case EF_ARM_APCS_FLOAT
:
2790 strcat (buf
, ", uses APCS/float");
2794 strcat (buf
, ", position independent");
2798 strcat (buf
, ", 8 bit structure alignment");
2801 case EF_ARM_NEW_ABI
:
2802 strcat (buf
, ", uses new ABI");
2805 case EF_ARM_OLD_ABI
:
2806 strcat (buf
, ", uses old ABI");
2809 case EF_ARM_SOFT_FLOAT
:
2810 strcat (buf
, ", software FP");
2813 case EF_ARM_VFP_FLOAT
:
2814 strcat (buf
, ", VFP");
2817 case EF_ARM_MAVERICK_FLOAT
:
2818 strcat (buf
, ", Maverick FP");
2829 strcat (buf
,_(", <unknown>"));
2833 decode_AVR_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2835 --size
; /* Leave space for null terminator. */
2837 switch (e_flags
& EF_AVR_MACH
)
2839 case E_AVR_MACH_AVR1
:
2840 strncat (buf
, ", avr:1", size
);
2842 case E_AVR_MACH_AVR2
:
2843 strncat (buf
, ", avr:2", size
);
2845 case E_AVR_MACH_AVR25
:
2846 strncat (buf
, ", avr:25", size
);
2848 case E_AVR_MACH_AVR3
:
2849 strncat (buf
, ", avr:3", size
);
2851 case E_AVR_MACH_AVR31
:
2852 strncat (buf
, ", avr:31", size
);
2854 case E_AVR_MACH_AVR35
:
2855 strncat (buf
, ", avr:35", size
);
2857 case E_AVR_MACH_AVR4
:
2858 strncat (buf
, ", avr:4", size
);
2860 case E_AVR_MACH_AVR5
:
2861 strncat (buf
, ", avr:5", size
);
2863 case E_AVR_MACH_AVR51
:
2864 strncat (buf
, ", avr:51", size
);
2866 case E_AVR_MACH_AVR6
:
2867 strncat (buf
, ", avr:6", size
);
2869 case E_AVR_MACH_AVRTINY
:
2870 strncat (buf
, ", avr:100", size
);
2872 case E_AVR_MACH_XMEGA1
:
2873 strncat (buf
, ", avr:101", size
);
2875 case E_AVR_MACH_XMEGA2
:
2876 strncat (buf
, ", avr:102", size
);
2878 case E_AVR_MACH_XMEGA3
:
2879 strncat (buf
, ", avr:103", size
);
2881 case E_AVR_MACH_XMEGA4
:
2882 strncat (buf
, ", avr:104", size
);
2884 case E_AVR_MACH_XMEGA5
:
2885 strncat (buf
, ", avr:105", size
);
2887 case E_AVR_MACH_XMEGA6
:
2888 strncat (buf
, ", avr:106", size
);
2890 case E_AVR_MACH_XMEGA7
:
2891 strncat (buf
, ", avr:107", size
);
2894 strncat (buf
, ", avr:<unknown>", size
);
2898 size
-= strlen (buf
);
2899 if (e_flags
& EF_AVR_LINKRELAX_PREPARED
)
2900 strncat (buf
, ", link-relax", size
);
2904 decode_NDS32_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2910 bfd_boolean has_fpu
= FALSE
;
2913 static const char *ABI_STRINGS
[] =
2915 "ABI v0", /* use r5 as return register; only used in N1213HC */
2916 "ABI v1", /* use r0 as return register */
2917 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2918 "ABI v2fp", /* for FPU */
2922 static const char *VER_STRINGS
[] =
2924 "Andes ELF V1.3 or older",
2928 static const char *ARCH_STRINGS
[] =
2937 abi
= EF_NDS_ABI
& e_flags
;
2938 arch
= EF_NDS_ARCH
& e_flags
;
2939 config
= EF_NDS_INST
& e_flags
;
2940 version
= EF_NDS32_ELF_VERSION
& e_flags
;
2942 memset (buf
, 0, size
);
2949 case E_NDS_ABI_V2FP
:
2950 case E_NDS_ABI_AABI
:
2951 case E_NDS_ABI_V2FP_PLUS
:
2952 /* In case there are holes in the array. */
2953 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ABI_STRINGS
[abi
>> EF_NDS_ABI_SHIFT
]);
2957 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ABI>");
2963 case E_NDS32_ELF_VER_1_2
:
2964 case E_NDS32_ELF_VER_1_3
:
2965 case E_NDS32_ELF_VER_1_4
:
2966 r
+= snprintf (buf
+ r
, size
- r
, ", %s", VER_STRINGS
[version
>> EF_NDS32_ELF_VERSION_SHIFT
]);
2970 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ELF version number>");
2974 if (E_NDS_ABI_V0
== abi
)
2976 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2977 r
+= snprintf (buf
+ r
, size
- r
, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2978 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2979 r
+= snprintf (buf
+ r
, size
-r
, ", 16b"); /* has 16-bit instructions */
2985 case E_NDS_ARCH_STAR_V1_0
:
2986 case E_NDS_ARCH_STAR_V2_0
:
2987 case E_NDS_ARCH_STAR_V3_0
:
2988 case E_NDS_ARCH_STAR_V3_M
:
2989 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ARCH_STRINGS
[arch
>> EF_NDS_ARCH_SHIFT
]);
2993 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized architecture>");
2994 /* ARCH version determines how the e_flags are interpreted.
2995 If it is unknown, we cannot proceed. */
2999 /* Newer ABI; Now handle architecture specific flags. */
3000 if (arch
== E_NDS_ARCH_STAR_V1_0
)
3002 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
3003 r
+= snprintf (buf
+ r
, size
-r
, ", MFUSR_PC");
3005 if (!(config
& E_NDS32_HAS_NO_MAC_INST
))
3006 r
+= snprintf (buf
+ r
, size
-r
, ", MAC");
3008 if (config
& E_NDS32_HAS_DIV_INST
)
3009 r
+= snprintf (buf
+ r
, size
-r
, ", DIV");
3011 if (config
& E_NDS32_HAS_16BIT_INST
)
3012 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
3016 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
3018 if (version
<= E_NDS32_ELF_VER_1_3
)
3019 r
+= snprintf (buf
+ r
, size
-r
, ", [B8]");
3021 r
+= snprintf (buf
+ r
, size
-r
, ", EX9");
3024 if (config
& E_NDS32_HAS_MAC_DX_INST
)
3025 r
+= snprintf (buf
+ r
, size
-r
, ", MAC_DX");
3027 if (config
& E_NDS32_HAS_DIV_DX_INST
)
3028 r
+= snprintf (buf
+ r
, size
-r
, ", DIV_DX");
3030 if (config
& E_NDS32_HAS_16BIT_INST
)
3032 if (version
<= E_NDS32_ELF_VER_1_3
)
3033 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
3035 r
+= snprintf (buf
+ r
, size
-r
, ", IFC");
3039 if (config
& E_NDS32_HAS_EXT_INST
)
3040 r
+= snprintf (buf
+ r
, size
-r
, ", PERF1");
3042 if (config
& E_NDS32_HAS_EXT2_INST
)
3043 r
+= snprintf (buf
+ r
, size
-r
, ", PERF2");
3045 if (config
& E_NDS32_HAS_FPU_INST
)
3048 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_SP");
3051 if (config
& E_NDS32_HAS_FPU_DP_INST
)
3054 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_DP");
3057 if (config
& E_NDS32_HAS_FPU_MAC_INST
)
3060 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_MAC");
3065 switch ((config
& E_NDS32_FPU_REG_CONF
) >> E_NDS32_FPU_REG_CONF_SHIFT
)
3067 case E_NDS32_FPU_REG_8SP_4DP
:
3068 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:8/4");
3070 case E_NDS32_FPU_REG_16SP_8DP
:
3071 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:16/8");
3073 case E_NDS32_FPU_REG_32SP_16DP
:
3074 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/16");
3076 case E_NDS32_FPU_REG_32SP_32DP
:
3077 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/32");
3082 if (config
& E_NDS32_HAS_AUDIO_INST
)
3083 r
+= snprintf (buf
+ r
, size
-r
, ", AUDIO");
3085 if (config
& E_NDS32_HAS_STRING_INST
)
3086 r
+= snprintf (buf
+ r
, size
-r
, ", STR");
3088 if (config
& E_NDS32_HAS_REDUCED_REGS
)
3089 r
+= snprintf (buf
+ r
, size
-r
, ", 16REG");
3091 if (config
& E_NDS32_HAS_VIDEO_INST
)
3093 if (version
<= E_NDS32_ELF_VER_1_3
)
3094 r
+= snprintf (buf
+ r
, size
-r
, ", VIDEO");
3096 r
+= snprintf (buf
+ r
, size
-r
, ", SATURATION");
3099 if (config
& E_NDS32_HAS_ENCRIPT_INST
)
3100 r
+= snprintf (buf
+ r
, size
-r
, ", ENCRP");
3102 if (config
& E_NDS32_HAS_L2C_INST
)
3103 r
+= snprintf (buf
+ r
, size
-r
, ", L2C");
3107 get_machine_flags (Filedata
* filedata
, unsigned e_flags
, unsigned e_machine
)
3109 static char buf
[1024];
3120 case EM_ARC_COMPACT2
:
3121 case EM_ARC_COMPACT
:
3122 decode_ARC_machine_flags (e_flags
, e_machine
, buf
);
3126 decode_ARM_machine_flags (e_flags
, buf
);
3130 decode_AVR_machine_flags (e_flags
, buf
, sizeof buf
);
3134 if (e_flags
& EF_BFIN_PIC
)
3135 strcat (buf
, ", PIC");
3137 if (e_flags
& EF_BFIN_FDPIC
)
3138 strcat (buf
, ", FDPIC");
3140 if (e_flags
& EF_BFIN_CODE_IN_L1
)
3141 strcat (buf
, ", code in L1");
3143 if (e_flags
& EF_BFIN_DATA_IN_L1
)
3144 strcat (buf
, ", data in L1");
3149 switch (e_flags
& EF_FRV_CPU_MASK
)
3151 case EF_FRV_CPU_GENERIC
:
3155 strcat (buf
, ", fr???");
3158 case EF_FRV_CPU_FR300
:
3159 strcat (buf
, ", fr300");
3162 case EF_FRV_CPU_FR400
:
3163 strcat (buf
, ", fr400");
3165 case EF_FRV_CPU_FR405
:
3166 strcat (buf
, ", fr405");
3169 case EF_FRV_CPU_FR450
:
3170 strcat (buf
, ", fr450");
3173 case EF_FRV_CPU_FR500
:
3174 strcat (buf
, ", fr500");
3176 case EF_FRV_CPU_FR550
:
3177 strcat (buf
, ", fr550");
3180 case EF_FRV_CPU_SIMPLE
:
3181 strcat (buf
, ", simple");
3183 case EF_FRV_CPU_TOMCAT
:
3184 strcat (buf
, ", tomcat");
3190 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
3191 strcat (buf
, ", m68000");
3192 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
3193 strcat (buf
, ", cpu32");
3194 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
3195 strcat (buf
, ", fido_a");
3198 char const * isa
= _("unknown");
3199 char const * mac
= _("unknown mac");
3200 char const * additional
= NULL
;
3202 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
3204 case EF_M68K_CF_ISA_A_NODIV
:
3206 additional
= ", nodiv";
3208 case EF_M68K_CF_ISA_A
:
3211 case EF_M68K_CF_ISA_A_PLUS
:
3214 case EF_M68K_CF_ISA_B_NOUSP
:
3216 additional
= ", nousp";
3218 case EF_M68K_CF_ISA_B
:
3221 case EF_M68K_CF_ISA_C
:
3224 case EF_M68K_CF_ISA_C_NODIV
:
3226 additional
= ", nodiv";
3229 strcat (buf
, ", cf, isa ");
3232 strcat (buf
, additional
);
3233 if (e_flags
& EF_M68K_CF_FLOAT
)
3234 strcat (buf
, ", float");
3235 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
3240 case EF_M68K_CF_MAC
:
3243 case EF_M68K_CF_EMAC
:
3246 case EF_M68K_CF_EMAC_B
:
3259 switch (e_flags
& EF_MEP_CPU_MASK
)
3261 case EF_MEP_CPU_MEP
: strcat (buf
, ", generic MeP"); break;
3262 case EF_MEP_CPU_C2
: strcat (buf
, ", MeP C2"); break;
3263 case EF_MEP_CPU_C3
: strcat (buf
, ", MeP C3"); break;
3264 case EF_MEP_CPU_C4
: strcat (buf
, ", MeP C4"); break;
3265 case EF_MEP_CPU_C5
: strcat (buf
, ", MeP C5"); break;
3266 case EF_MEP_CPU_H1
: strcat (buf
, ", MeP H1"); break;
3267 default: strcat (buf
, _(", <unknown MeP cpu type>")); break;
3270 switch (e_flags
& EF_MEP_COP_MASK
)
3272 case EF_MEP_COP_NONE
: break;
3273 case EF_MEP_COP_AVC
: strcat (buf
, ", AVC coprocessor"); break;
3274 case EF_MEP_COP_AVC2
: strcat (buf
, ", AVC2 coprocessor"); break;
3275 case EF_MEP_COP_FMAX
: strcat (buf
, ", FMAX coprocessor"); break;
3276 case EF_MEP_COP_IVC2
: strcat (buf
, ", IVC2 coprocessor"); break;
3277 default: strcat (buf
, _("<unknown MeP copro type>")); break;
3280 if (e_flags
& EF_MEP_LIBRARY
)
3281 strcat (buf
, ", Built for Library");
3283 if (e_flags
& EF_MEP_INDEX_MASK
)
3284 sprintf (buf
+ strlen (buf
), ", Configuration Index: %#x",
3285 e_flags
& EF_MEP_INDEX_MASK
);
3287 if (e_flags
& ~ EF_MEP_ALL_FLAGS
)
3288 sprintf (buf
+ strlen (buf
), _(", unknown flags bits: %#x"),
3289 e_flags
& ~ EF_MEP_ALL_FLAGS
);
3293 if (e_flags
& EF_PPC_EMB
)
3294 strcat (buf
, ", emb");
3296 if (e_flags
& EF_PPC_RELOCATABLE
)
3297 strcat (buf
, _(", relocatable"));
3299 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
3300 strcat (buf
, _(", relocatable-lib"));
3304 if (e_flags
& EF_PPC64_ABI
)
3306 char abi
[] = ", abiv0";
3308 abi
[6] += e_flags
& EF_PPC64_ABI
;
3314 if ((e_flags
& EF_RH850_ABI
) == EF_RH850_ABI
)
3315 strcat (buf
, ", RH850 ABI");
3317 if (e_flags
& EF_V800_850E3
)
3318 strcat (buf
, ", V3 architecture");
3320 if ((e_flags
& (EF_RH850_FPU_DOUBLE
| EF_RH850_FPU_SINGLE
)) == 0)
3321 strcat (buf
, ", FPU not used");
3323 if ((e_flags
& (EF_RH850_REGMODE22
| EF_RH850_REGMODE32
)) == 0)
3324 strcat (buf
, ", regmode: COMMON");
3326 if ((e_flags
& (EF_RH850_GP_FIX
| EF_RH850_GP_NOFIX
)) == 0)
3327 strcat (buf
, ", r4 not used");
3329 if ((e_flags
& (EF_RH850_EP_FIX
| EF_RH850_EP_NOFIX
)) == 0)
3330 strcat (buf
, ", r30 not used");
3332 if ((e_flags
& (EF_RH850_TP_FIX
| EF_RH850_TP_NOFIX
)) == 0)
3333 strcat (buf
, ", r5 not used");
3335 if ((e_flags
& (EF_RH850_REG2_RESERVE
| EF_RH850_REG2_NORESERVE
)) == 0)
3336 strcat (buf
, ", r2 not used");
3338 for (e_flags
&= 0xFFFF; e_flags
; e_flags
&= ~ (e_flags
& - e_flags
))
3340 switch (e_flags
& - e_flags
)
3342 case EF_RH850_FPU_DOUBLE
: strcat (buf
, ", double precision FPU"); break;
3343 case EF_RH850_FPU_SINGLE
: strcat (buf
, ", single precision FPU"); break;
3344 case EF_RH850_REGMODE22
: strcat (buf
, ", regmode:22"); break;
3345 case EF_RH850_REGMODE32
: strcat (buf
, ", regmode:23"); break;
3346 case EF_RH850_GP_FIX
: strcat (buf
, ", r4 fixed"); break;
3347 case EF_RH850_GP_NOFIX
: strcat (buf
, ", r4 free"); break;
3348 case EF_RH850_EP_FIX
: strcat (buf
, ", r30 fixed"); break;
3349 case EF_RH850_EP_NOFIX
: strcat (buf
, ", r30 free"); break;
3350 case EF_RH850_TP_FIX
: strcat (buf
, ", r5 fixed"); break;
3351 case EF_RH850_TP_NOFIX
: strcat (buf
, ", r5 free"); break;
3352 case EF_RH850_REG2_RESERVE
: strcat (buf
, ", r2 fixed"); break;
3353 case EF_RH850_REG2_NORESERVE
: strcat (buf
, ", r2 free"); break;
3360 case EM_CYGNUS_V850
:
3361 switch (e_flags
& EF_V850_ARCH
)
3363 case E_V850E3V5_ARCH
:
3364 strcat (buf
, ", v850e3v5");
3366 case E_V850E2V3_ARCH
:
3367 strcat (buf
, ", v850e2v3");
3370 strcat (buf
, ", v850e2");
3373 strcat (buf
, ", v850e1");
3376 strcat (buf
, ", v850e");
3379 strcat (buf
, ", v850");
3382 strcat (buf
, _(", unknown v850 architecture variant"));
3388 case EM_CYGNUS_M32R
:
3389 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
3390 strcat (buf
, ", m32r");
3394 case EM_MIPS_RS3_LE
:
3395 if (e_flags
& EF_MIPS_NOREORDER
)
3396 strcat (buf
, ", noreorder");
3398 if (e_flags
& EF_MIPS_PIC
)
3399 strcat (buf
, ", pic");
3401 if (e_flags
& EF_MIPS_CPIC
)
3402 strcat (buf
, ", cpic");
3404 if (e_flags
& EF_MIPS_UCODE
)
3405 strcat (buf
, ", ugen_reserved");
3407 if (e_flags
& EF_MIPS_ABI2
)
3408 strcat (buf
, ", abi2");
3410 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
3411 strcat (buf
, ", odk first");
3413 if (e_flags
& EF_MIPS_32BITMODE
)
3414 strcat (buf
, ", 32bitmode");
3416 if (e_flags
& EF_MIPS_NAN2008
)
3417 strcat (buf
, ", nan2008");
3419 if (e_flags
& EF_MIPS_FP64
)
3420 strcat (buf
, ", fp64");
3422 switch ((e_flags
& EF_MIPS_MACH
))
3424 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
3425 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
3426 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
3427 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
3428 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
3429 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
3430 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
3431 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
3432 case E_MIPS_MACH_5900
: strcat (buf
, ", 5900"); break;
3433 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
3434 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
3435 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
3436 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
3437 case E_MIPS_MACH_GS464
: strcat (buf
, ", gs464"); break;
3438 case E_MIPS_MACH_GS464E
: strcat (buf
, ", gs464e"); break;
3439 case E_MIPS_MACH_GS264E
: strcat (buf
, ", gs264e"); break;
3440 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
3441 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
3442 case E_MIPS_MACH_OCTEON3
: strcat (buf
, ", octeon3"); break;
3443 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
3444 case E_MIPS_MACH_IAMR2
: strcat (buf
, ", interaptiv-mr2"); break;
3446 /* We simply ignore the field in this case to avoid confusion:
3447 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3450 default: strcat (buf
, _(", unknown CPU")); break;
3453 switch ((e_flags
& EF_MIPS_ABI
))
3455 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
3456 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
3457 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
3458 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
3460 /* We simply ignore the field in this case to avoid confusion:
3461 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3462 This means it is likely to be an o32 file, but not for
3465 default: strcat (buf
, _(", unknown ABI")); break;
3468 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
3469 strcat (buf
, ", mdmx");
3471 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
3472 strcat (buf
, ", mips16");
3474 if (e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
3475 strcat (buf
, ", micromips");
3477 switch ((e_flags
& EF_MIPS_ARCH
))
3479 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
3480 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
3481 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
3482 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
3483 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
3484 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
3485 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
3486 case E_MIPS_ARCH_32R6
: strcat (buf
, ", mips32r6"); break;
3487 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
3488 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
3489 case E_MIPS_ARCH_64R6
: strcat (buf
, ", mips64r6"); break;
3490 default: strcat (buf
, _(", unknown ISA")); break;
3495 decode_NDS32_machine_flags (e_flags
, buf
, sizeof buf
);
3499 switch (EF_NFP_MACH (e_flags
))
3501 case E_NFP_MACH_3200
:
3502 strcat (buf
, ", NFP-32xx");
3504 case E_NFP_MACH_6000
:
3505 strcat (buf
, ", NFP-6xxx");
3511 if (e_flags
& EF_RISCV_RVC
)
3512 strcat (buf
, ", RVC");
3514 if (e_flags
& EF_RISCV_RVE
)
3515 strcat (buf
, ", RVE");
3517 switch (e_flags
& EF_RISCV_FLOAT_ABI
)
3519 case EF_RISCV_FLOAT_ABI_SOFT
:
3520 strcat (buf
, ", soft-float ABI");
3523 case EF_RISCV_FLOAT_ABI_SINGLE
:
3524 strcat (buf
, ", single-float ABI");
3527 case EF_RISCV_FLOAT_ABI_DOUBLE
:
3528 strcat (buf
, ", double-float ABI");
3531 case EF_RISCV_FLOAT_ABI_QUAD
:
3532 strcat (buf
, ", quad-float ABI");
3538 switch ((e_flags
& EF_SH_MACH_MASK
))
3540 case EF_SH1
: strcat (buf
, ", sh1"); break;
3541 case EF_SH2
: strcat (buf
, ", sh2"); break;
3542 case EF_SH3
: strcat (buf
, ", sh3"); break;
3543 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
3544 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
3545 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
3546 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
3547 case EF_SH4
: strcat (buf
, ", sh4"); break;
3548 case EF_SH5
: strcat (buf
, ", sh5"); break;
3549 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
3550 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
3551 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
3552 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
3553 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
3554 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
3555 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
3556 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
3557 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3558 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
3559 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
3560 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
3561 default: strcat (buf
, _(", unknown ISA")); break;
3564 if (e_flags
& EF_SH_PIC
)
3565 strcat (buf
, ", pic");
3567 if (e_flags
& EF_SH_FDPIC
)
3568 strcat (buf
, ", fdpic");
3572 if (e_flags
& EF_OR1K_NODELAY
)
3573 strcat (buf
, ", no delay");
3577 if (e_flags
& EF_SPARC_32PLUS
)
3578 strcat (buf
, ", v8+");
3580 if (e_flags
& EF_SPARC_SUN_US1
)
3581 strcat (buf
, ", ultrasparcI");
3583 if (e_flags
& EF_SPARC_SUN_US3
)
3584 strcat (buf
, ", ultrasparcIII");
3586 if (e_flags
& EF_SPARC_HAL_R1
)
3587 strcat (buf
, ", halr1");
3589 if (e_flags
& EF_SPARC_LEDATA
)
3590 strcat (buf
, ", ledata");
3592 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
3593 strcat (buf
, ", tso");
3595 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
3596 strcat (buf
, ", pso");
3598 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
3599 strcat (buf
, ", rmo");
3603 switch (e_flags
& EF_PARISC_ARCH
)
3605 case EFA_PARISC_1_0
:
3606 strcpy (buf
, ", PA-RISC 1.0");
3608 case EFA_PARISC_1_1
:
3609 strcpy (buf
, ", PA-RISC 1.1");
3611 case EFA_PARISC_2_0
:
3612 strcpy (buf
, ", PA-RISC 2.0");
3617 if (e_flags
& EF_PARISC_TRAPNIL
)
3618 strcat (buf
, ", trapnil");
3619 if (e_flags
& EF_PARISC_EXT
)
3620 strcat (buf
, ", ext");
3621 if (e_flags
& EF_PARISC_LSB
)
3622 strcat (buf
, ", lsb");
3623 if (e_flags
& EF_PARISC_WIDE
)
3624 strcat (buf
, ", wide");
3625 if (e_flags
& EF_PARISC_NO_KABP
)
3626 strcat (buf
, ", no kabp");
3627 if (e_flags
& EF_PARISC_LAZYSWAP
)
3628 strcat (buf
, ", lazyswap");
3633 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
3634 strcat (buf
, ", new calling convention");
3636 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
3637 strcat (buf
, ", gnu calling convention");
3641 if ((e_flags
& EF_IA_64_ABI64
))
3642 strcat (buf
, ", 64-bit");
3644 strcat (buf
, ", 32-bit");
3645 if ((e_flags
& EF_IA_64_REDUCEDFP
))
3646 strcat (buf
, ", reduced fp model");
3647 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
3648 strcat (buf
, ", no function descriptors, constant gp");
3649 else if ((e_flags
& EF_IA_64_CONS_GP
))
3650 strcat (buf
, ", constant gp");
3651 if ((e_flags
& EF_IA_64_ABSOLUTE
))
3652 strcat (buf
, ", absolute");
3653 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
3655 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
3656 strcat (buf
, ", vms_linkages");
3657 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
3659 case EF_IA_64_VMS_COMCOD_SUCCESS
:
3661 case EF_IA_64_VMS_COMCOD_WARNING
:
3662 strcat (buf
, ", warning");
3664 case EF_IA_64_VMS_COMCOD_ERROR
:
3665 strcat (buf
, ", error");
3667 case EF_IA_64_VMS_COMCOD_ABORT
:
3668 strcat (buf
, ", abort");
3671 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3672 e_flags
& EF_IA_64_VMS_COMCOD
);
3673 strcat (buf
, ", <unknown>");
3679 if ((e_flags
& EF_VAX_NONPIC
))
3680 strcat (buf
, ", non-PIC");
3681 if ((e_flags
& EF_VAX_DFLOAT
))
3682 strcat (buf
, ", D-Float");
3683 if ((e_flags
& EF_VAX_GFLOAT
))
3684 strcat (buf
, ", G-Float");
3688 if (e_flags
& EF_VISIUM_ARCH_MCM
)
3689 strcat (buf
, ", mcm");
3690 else if (e_flags
& EF_VISIUM_ARCH_MCM24
)
3691 strcat (buf
, ", mcm24");
3692 if (e_flags
& EF_VISIUM_ARCH_GR6
)
3693 strcat (buf
, ", gr6");
3697 switch (e_flags
& E_FLAG_RL78_CPU_MASK
)
3699 case E_FLAG_RL78_ANY_CPU
: break;
3700 case E_FLAG_RL78_G10
: strcat (buf
, ", G10"); break;
3701 case E_FLAG_RL78_G13
: strcat (buf
, ", G13"); break;
3702 case E_FLAG_RL78_G14
: strcat (buf
, ", G14"); break;
3704 if (e_flags
& E_FLAG_RL78_64BIT_DOUBLES
)
3705 strcat (buf
, ", 64-bit doubles");
3709 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
3710 strcat (buf
, ", 64-bit doubles");
3711 if (e_flags
& E_FLAG_RX_DSP
)
3712 strcat (buf
, ", dsp");
3713 if (e_flags
& E_FLAG_RX_PID
)
3714 strcat (buf
, ", pid");
3715 if (e_flags
& E_FLAG_RX_ABI
)
3716 strcat (buf
, ", RX ABI");
3717 if (e_flags
& E_FLAG_RX_SINSNS_SET
)
3718 strcat (buf
, e_flags
& E_FLAG_RX_SINSNS_YES
3719 ? ", uses String instructions" : ", bans String instructions");
3720 if (e_flags
& E_FLAG_RX_V2
)
3721 strcat (buf
, ", V2");
3722 if (e_flags
& E_FLAG_RX_V3
)
3723 strcat (buf
, ", V3");
3727 if (e_flags
& EF_S390_HIGH_GPRS
)
3728 strcat (buf
, ", highgprs");
3732 if ((e_flags
& EF_C6000_REL
))
3733 strcat (buf
, ", relocatable module");
3737 strcat (buf
, _(": architecture variant: "));
3738 switch (e_flags
& EF_MSP430_MACH
)
3740 case E_MSP430_MACH_MSP430x11
: strcat (buf
, "MSP430x11"); break;
3741 case E_MSP430_MACH_MSP430x11x1
: strcat (buf
, "MSP430x11x1 "); break;
3742 case E_MSP430_MACH_MSP430x12
: strcat (buf
, "MSP430x12"); break;
3743 case E_MSP430_MACH_MSP430x13
: strcat (buf
, "MSP430x13"); break;
3744 case E_MSP430_MACH_MSP430x14
: strcat (buf
, "MSP430x14"); break;
3745 case E_MSP430_MACH_MSP430x15
: strcat (buf
, "MSP430x15"); break;
3746 case E_MSP430_MACH_MSP430x16
: strcat (buf
, "MSP430x16"); break;
3747 case E_MSP430_MACH_MSP430x31
: strcat (buf
, "MSP430x31"); break;
3748 case E_MSP430_MACH_MSP430x32
: strcat (buf
, "MSP430x32"); break;
3749 case E_MSP430_MACH_MSP430x33
: strcat (buf
, "MSP430x33"); break;
3750 case E_MSP430_MACH_MSP430x41
: strcat (buf
, "MSP430x41"); break;
3751 case E_MSP430_MACH_MSP430x42
: strcat (buf
, "MSP430x42"); break;
3752 case E_MSP430_MACH_MSP430x43
: strcat (buf
, "MSP430x43"); break;
3753 case E_MSP430_MACH_MSP430x44
: strcat (buf
, "MSP430x44"); break;
3754 case E_MSP430_MACH_MSP430X
: strcat (buf
, "MSP430X"); break;
3756 strcat (buf
, _(": unknown")); break;
3759 if (e_flags
& ~ EF_MSP430_MACH
)
3760 strcat (buf
, _(": unknown extra flag bits also present"));
3768 get_osabi_name (Filedata
* filedata
, unsigned int osabi
)
3770 static char buff
[32];
3774 case ELFOSABI_NONE
: return "UNIX - System V";
3775 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
3776 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
3777 case ELFOSABI_GNU
: return "UNIX - GNU";
3778 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
3779 case ELFOSABI_AIX
: return "UNIX - AIX";
3780 case ELFOSABI_IRIX
: return "UNIX - IRIX";
3781 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
3782 case ELFOSABI_TRU64
: return "UNIX - TRU64";
3783 case ELFOSABI_MODESTO
: return "Novell - Modesto";
3784 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
3785 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
3786 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
3787 case ELFOSABI_AROS
: return "AROS";
3788 case ELFOSABI_FENIXOS
: return "FenixOS";
3789 case ELFOSABI_CLOUDABI
: return "Nuxi CloudABI";
3790 case ELFOSABI_OPENVOS
: return "Stratus Technologies OpenVOS";
3793 switch (filedata
->file_header
.e_machine
)
3798 case ELFOSABI_ARM
: return "ARM";
3799 case ELFOSABI_ARM_FDPIC
: return "ARM FDPIC";
3810 case ELFOSABI_STANDALONE
: return _("Standalone App");
3819 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
3820 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
3829 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
3835 get_aarch64_segment_type (unsigned long type
)
3839 case PT_AARCH64_ARCHEXT
: return "AARCH64_ARCHEXT";
3840 default: return NULL
;
3845 get_arm_segment_type (unsigned long type
)
3849 case PT_ARM_EXIDX
: return "EXIDX";
3850 default: return NULL
;
3855 get_s390_segment_type (unsigned long type
)
3859 case PT_S390_PGSTE
: return "S390_PGSTE";
3860 default: return NULL
;
3865 get_mips_segment_type (unsigned long type
)
3869 case PT_MIPS_REGINFO
: return "REGINFO";
3870 case PT_MIPS_RTPROC
: return "RTPROC";
3871 case PT_MIPS_OPTIONS
: return "OPTIONS";
3872 case PT_MIPS_ABIFLAGS
: return "ABIFLAGS";
3873 default: return NULL
;
3878 get_parisc_segment_type (unsigned long type
)
3882 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
3883 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
3884 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
3885 default: return NULL
;
3890 get_ia64_segment_type (unsigned long type
)
3894 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
3895 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
3896 default: return NULL
;
3901 get_tic6x_segment_type (unsigned long type
)
3905 case PT_C6000_PHATTR
: return "C6000_PHATTR";
3906 default: return NULL
;
3911 get_hpux_segment_type (unsigned long type
, unsigned e_machine
)
3913 if (e_machine
== EM_PARISC
)
3916 case PT_HP_TLS
: return "HP_TLS";
3917 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
3918 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
3919 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
3920 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
3921 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
3922 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
3923 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
3924 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
3925 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
3926 case PT_HP_PARALLEL
: return "HP_PARALLEL";
3927 case PT_HP_FASTBIND
: return "HP_FASTBIND";
3928 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
3929 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
3930 case PT_HP_STACK
: return "HP_STACK";
3931 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
3932 default: return NULL
;
3935 if (e_machine
== EM_IA_64
)
3938 case PT_HP_TLS
: return "HP_TLS";
3939 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
3940 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
3941 case PT_IA_64_HP_STACK
: return "HP_STACK";
3942 default: return NULL
;
3949 get_solaris_segment_type (unsigned long type
)
3953 case 0x6464e550: return "PT_SUNW_UNWIND";
3954 case 0x6474e550: return "PT_SUNW_EH_FRAME";
3955 case 0x6ffffff7: return "PT_LOSUNW";
3956 case 0x6ffffffa: return "PT_SUNWBSS";
3957 case 0x6ffffffb: return "PT_SUNWSTACK";
3958 case 0x6ffffffc: return "PT_SUNWDTRACE";
3959 case 0x6ffffffd: return "PT_SUNWCAP";
3960 case 0x6fffffff: return "PT_HISUNW";
3961 default: return NULL
;
3966 get_segment_type (Filedata
* filedata
, unsigned long p_type
)
3968 static char buff
[32];
3972 case PT_NULL
: return "NULL";
3973 case PT_LOAD
: return "LOAD";
3974 case PT_DYNAMIC
: return "DYNAMIC";
3975 case PT_INTERP
: return "INTERP";
3976 case PT_NOTE
: return "NOTE";
3977 case PT_SHLIB
: return "SHLIB";
3978 case PT_PHDR
: return "PHDR";
3979 case PT_TLS
: return "TLS";
3980 case PT_GNU_EH_FRAME
: return "GNU_EH_FRAME";
3981 case PT_GNU_STACK
: return "GNU_STACK";
3982 case PT_GNU_RELRO
: return "GNU_RELRO";
3983 case PT_GNU_PROPERTY
: return "GNU_PROPERTY";
3986 if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
3988 const char * result
;
3990 switch (filedata
->file_header
.e_machine
)
3993 result
= get_aarch64_segment_type (p_type
);
3996 result
= get_arm_segment_type (p_type
);
3999 case EM_MIPS_RS3_LE
:
4000 result
= get_mips_segment_type (p_type
);
4003 result
= get_parisc_segment_type (p_type
);
4006 result
= get_ia64_segment_type (p_type
);
4009 result
= get_tic6x_segment_type (p_type
);
4013 result
= get_s390_segment_type (p_type
);
4023 sprintf (buff
, "LOPROC+%#lx", p_type
- PT_LOPROC
);
4025 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
4027 const char * result
= NULL
;
4029 switch (filedata
->file_header
.e_ident
[EI_OSABI
])
4032 case ELFOSABI_FREEBSD
:
4033 if (p_type
>= PT_GNU_MBIND_LO
&& p_type
<= PT_GNU_MBIND_HI
)
4035 sprintf (buff
, "GNU_MBIND+%#lx", p_type
- PT_GNU_MBIND_LO
);
4040 result
= get_hpux_segment_type (p_type
,
4041 filedata
->file_header
.e_machine
);
4043 case ELFOSABI_SOLARIS
:
4044 result
= get_solaris_segment_type (p_type
);
4052 sprintf (buff
, "LOOS+%#lx", p_type
- PT_LOOS
);
4055 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
4062 get_arc_section_type_name (unsigned int sh_type
)
4066 case SHT_ARC_ATTRIBUTES
: return "ARC_ATTRIBUTES";
4074 get_mips_section_type_name (unsigned int sh_type
)
4078 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
4079 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
4080 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
4081 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
4082 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
4083 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
4084 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
4085 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
4086 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
4087 case SHT_MIPS_RELD
: return "MIPS_RELD";
4088 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
4089 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
4090 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
4091 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
4092 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
4093 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
4094 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
4095 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
4096 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
4097 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
4098 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
4099 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
4100 case SHT_MIPS_LINE
: return "MIPS_LINE";
4101 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
4102 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
4103 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
4104 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
4105 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
4106 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
4107 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
4108 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
4109 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
4110 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
4111 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
4112 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
4113 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
4114 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
4115 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
4116 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
4117 case SHT_MIPS_ABIFLAGS
: return "MIPS_ABIFLAGS";
4125 get_parisc_section_type_name (unsigned int sh_type
)
4129 case SHT_PARISC_EXT
: return "PARISC_EXT";
4130 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
4131 case SHT_PARISC_DOC
: return "PARISC_DOC";
4132 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
4133 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
4134 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
4135 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
4136 default: return NULL
;
4141 get_ia64_section_type_name (Filedata
* filedata
, unsigned int sh_type
)
4143 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
4144 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
4145 return get_osabi_name (filedata
, (sh_type
& 0x00FF0000) >> 16);
4149 case SHT_IA_64_EXT
: return "IA_64_EXT";
4150 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
4151 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
4152 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
4153 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
4154 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
4155 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
4156 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
4157 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
4158 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
4166 get_x86_64_section_type_name (unsigned int sh_type
)
4170 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
4171 default: return NULL
;
4176 get_aarch64_section_type_name (unsigned int sh_type
)
4180 case SHT_AARCH64_ATTRIBUTES
: return "AARCH64_ATTRIBUTES";
4181 default: return NULL
;
4186 get_arm_section_type_name (unsigned int sh_type
)
4190 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
4191 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
4192 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
4193 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
4194 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
4195 default: return NULL
;
4200 get_tic6x_section_type_name (unsigned int sh_type
)
4204 case SHT_C6000_UNWIND
: return "C6000_UNWIND";
4205 case SHT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
4206 case SHT_C6000_ATTRIBUTES
: return "C6000_ATTRIBUTES";
4207 case SHT_TI_ICODE
: return "TI_ICODE";
4208 case SHT_TI_XREF
: return "TI_XREF";
4209 case SHT_TI_HANDLER
: return "TI_HANDLER";
4210 case SHT_TI_INITINFO
: return "TI_INITINFO";
4211 case SHT_TI_PHATTRS
: return "TI_PHATTRS";
4212 default: return NULL
;
4217 get_msp430x_section_type_name (unsigned int sh_type
)
4221 case SHT_MSP430_SEC_FLAGS
: return "MSP430_SEC_FLAGS";
4222 case SHT_MSP430_SYM_ALIASES
: return "MSP430_SYM_ALIASES";
4223 case SHT_MSP430_ATTRIBUTES
: return "MSP430_ATTRIBUTES";
4224 default: return NULL
;
4229 get_nfp_section_type_name (unsigned int sh_type
)
4233 case SHT_NFP_MECONFIG
: return "NFP_MECONFIG";
4234 case SHT_NFP_INITREG
: return "NFP_INITREG";
4235 case SHT_NFP_UDEBUG
: return "NFP_UDEBUG";
4236 default: return NULL
;
4241 get_v850_section_type_name (unsigned int sh_type
)
4245 case SHT_V850_SCOMMON
: return "V850 Small Common";
4246 case SHT_V850_TCOMMON
: return "V850 Tiny Common";
4247 case SHT_V850_ZCOMMON
: return "V850 Zero Common";
4248 case SHT_RENESAS_IOP
: return "RENESAS IOP";
4249 case SHT_RENESAS_INFO
: return "RENESAS INFO";
4250 default: return NULL
;
4255 get_riscv_section_type_name (unsigned int sh_type
)
4259 case SHT_RISCV_ATTRIBUTES
: return "RISCV_ATTRIBUTES";
4260 default: return NULL
;
4265 get_section_type_name (Filedata
* filedata
, unsigned int sh_type
)
4267 static char buff
[32];
4268 const char * result
;
4272 case SHT_NULL
: return "NULL";
4273 case SHT_PROGBITS
: return "PROGBITS";
4274 case SHT_SYMTAB
: return "SYMTAB";
4275 case SHT_STRTAB
: return "STRTAB";
4276 case SHT_RELA
: return "RELA";
4277 case SHT_HASH
: return "HASH";
4278 case SHT_DYNAMIC
: return "DYNAMIC";
4279 case SHT_NOTE
: return "NOTE";
4280 case SHT_NOBITS
: return "NOBITS";
4281 case SHT_REL
: return "REL";
4282 case SHT_SHLIB
: return "SHLIB";
4283 case SHT_DYNSYM
: return "DYNSYM";
4284 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
4285 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
4286 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
4287 case SHT_GNU_HASH
: return "GNU_HASH";
4288 case SHT_GROUP
: return "GROUP";
4289 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICES";
4290 case SHT_GNU_verdef
: return "VERDEF";
4291 case SHT_GNU_verneed
: return "VERNEED";
4292 case SHT_GNU_versym
: return "VERSYM";
4293 case 0x6ffffff0: return "VERSYM";
4294 case 0x6ffffffc: return "VERDEF";
4295 case 0x7ffffffd: return "AUXILIARY";
4296 case 0x7fffffff: return "FILTER";
4297 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
4300 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
4302 switch (filedata
->file_header
.e_machine
)
4305 case EM_ARC_COMPACT
:
4306 case EM_ARC_COMPACT2
:
4307 result
= get_arc_section_type_name (sh_type
);
4310 case EM_MIPS_RS3_LE
:
4311 result
= get_mips_section_type_name (sh_type
);
4314 result
= get_parisc_section_type_name (sh_type
);
4317 result
= get_ia64_section_type_name (filedata
, sh_type
);
4322 result
= get_x86_64_section_type_name (sh_type
);
4325 result
= get_aarch64_section_type_name (sh_type
);
4328 result
= get_arm_section_type_name (sh_type
);
4331 result
= get_tic6x_section_type_name (sh_type
);
4334 result
= get_msp430x_section_type_name (sh_type
);
4337 result
= get_nfp_section_type_name (sh_type
);
4341 case EM_CYGNUS_V850
:
4342 result
= get_v850_section_type_name (sh_type
);
4345 result
= get_riscv_section_type_name (sh_type
);
4355 sprintf (buff
, "LOPROC+%#x", sh_type
- SHT_LOPROC
);
4357 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
4359 switch (filedata
->file_header
.e_machine
)
4362 result
= get_ia64_section_type_name (filedata
, sh_type
);
4365 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
4366 result
= get_solaris_section_type (sh_type
);
4371 case SHT_GNU_INCREMENTAL_INPUTS
: result
= "GNU_INCREMENTAL_INPUTS"; break;
4372 case SHT_GNU_ATTRIBUTES
: result
= "GNU_ATTRIBUTES"; break;
4373 case SHT_GNU_HASH
: result
= "GNU_HASH"; break;
4374 case SHT_GNU_LIBLIST
: result
= "GNU_LIBLIST"; break;
4386 sprintf (buff
, "LOOS+%#x", sh_type
- SHT_LOOS
);
4388 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
4390 switch (filedata
->file_header
.e_machine
)
4394 case EM_CYGNUS_V850
:
4395 result
= get_v850_section_type_name (sh_type
);
4405 sprintf (buff
, "LOUSER+%#x", sh_type
- SHT_LOUSER
);
4408 /* This message is probably going to be displayed in a 15
4409 character wide field, so put the hex value first. */
4410 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
4416 #define OPTION_DEBUG_DUMP 512
4417 #define OPTION_DYN_SYMS 513
4418 #define OPTION_DWARF_DEPTH 514
4419 #define OPTION_DWARF_START 515
4420 #define OPTION_DWARF_CHECK 516
4421 #define OPTION_CTF_DUMP 517
4422 #define OPTION_CTF_PARENT 518
4423 #define OPTION_CTF_SYMBOLS 519
4424 #define OPTION_CTF_STRINGS 520
4426 static struct option options
[] =
4428 {"all", no_argument
, 0, 'a'},
4429 {"file-header", no_argument
, 0, 'h'},
4430 {"program-headers", no_argument
, 0, 'l'},
4431 {"headers", no_argument
, 0, 'e'},
4432 {"histogram", no_argument
, 0, 'I'},
4433 {"segments", no_argument
, 0, 'l'},
4434 {"sections", no_argument
, 0, 'S'},
4435 {"section-headers", no_argument
, 0, 'S'},
4436 {"section-groups", no_argument
, 0, 'g'},
4437 {"section-details", no_argument
, 0, 't'},
4438 {"full-section-name",no_argument
, 0, 'N'},
4439 {"symbols", no_argument
, 0, 's'},
4440 {"syms", no_argument
, 0, 's'},
4441 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
4442 {"relocs", no_argument
, 0, 'r'},
4443 {"notes", no_argument
, 0, 'n'},
4444 {"dynamic", no_argument
, 0, 'd'},
4445 {"arch-specific", no_argument
, 0, 'A'},
4446 {"version-info", no_argument
, 0, 'V'},
4447 {"use-dynamic", no_argument
, 0, 'D'},
4448 {"unwind", no_argument
, 0, 'u'},
4449 {"archive-index", no_argument
, 0, 'c'},
4450 {"hex-dump", required_argument
, 0, 'x'},
4451 {"relocated-dump", required_argument
, 0, 'R'},
4452 {"string-dump", required_argument
, 0, 'p'},
4453 {"decompress", no_argument
, 0, 'z'},
4454 #ifdef SUPPORT_DISASSEMBLY
4455 {"instruction-dump", required_argument
, 0, 'i'},
4457 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
4459 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
4460 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
4461 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
4463 {"ctf", required_argument
, 0, OPTION_CTF_DUMP
},
4465 {"ctf-symbols", required_argument
, 0, OPTION_CTF_SYMBOLS
},
4466 {"ctf-strings", required_argument
, 0, OPTION_CTF_STRINGS
},
4467 {"ctf-parent", required_argument
, 0, OPTION_CTF_PARENT
},
4469 {"version", no_argument
, 0, 'v'},
4470 {"wide", no_argument
, 0, 'W'},
4471 {"help", no_argument
, 0, 'H'},
4472 {0, no_argument
, 0, 0}
4476 usage (FILE * stream
)
4478 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
4479 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
4480 fprintf (stream
, _(" Options are:\n\
4481 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4482 -h --file-header Display the ELF file header\n\
4483 -l --program-headers Display the program headers\n\
4484 --segments An alias for --program-headers\n\
4485 -S --section-headers Display the sections' header\n\
4486 --sections An alias for --section-headers\n\
4487 -g --section-groups Display the section groups\n\
4488 -t --section-details Display the section details\n\
4489 -e --headers Equivalent to: -h -l -S\n\
4490 -s --syms Display the symbol table\n\
4491 --symbols An alias for --syms\n\
4492 --dyn-syms Display the dynamic symbol table\n\
4493 -n --notes Display the core notes (if present)\n\
4494 -r --relocs Display the relocations (if present)\n\
4495 -u --unwind Display the unwind info (if present)\n\
4496 -d --dynamic Display the dynamic section (if present)\n\
4497 -V --version-info Display the version sections (if present)\n\
4498 -A --arch-specific Display architecture specific information (if any)\n\
4499 -c --archive-index Display the symbol/file index in an archive\n\
4500 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
4501 -x --hex-dump=<number|name>\n\
4502 Dump the contents of section <number|name> as bytes\n\
4503 -p --string-dump=<number|name>\n\
4504 Dump the contents of section <number|name> as strings\n\
4505 -R --relocated-dump=<number|name>\n\
4506 Dump the contents of section <number|name> as relocated bytes\n\
4507 -z --decompress Decompress section before dumping it\n\
4508 -w[lLiaprmfFsoRtUuTgAckK] or\n\
4509 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4510 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4511 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4512 =addr,=cu_index,=links,=follow-links]\n\
4513 Display the contents of DWARF debug sections\n"));
4514 fprintf (stream
, _("\
4515 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4516 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4518 fprintf (stream
, _("\
4519 --ctf=<number|name> Display CTF info from section <number|name>\n\
4520 --ctf-parent=<number|name>\n\
4521 Use section <number|name> as the CTF parent\n\n\
4522 --ctf-symbols=<number|name>\n\
4523 Use section <number|name> as the CTF external symtab\n\n\
4524 --ctf-strings=<number|name>\n\
4525 Use section <number|name> as the CTF external strtab\n\n"));
4527 #ifdef SUPPORT_DISASSEMBLY
4528 fprintf (stream
, _("\
4529 -i --instruction-dump=<number|name>\n\
4530 Disassemble the contents of section <number|name>\n"));
4532 fprintf (stream
, _("\
4533 -I --histogram Display histogram of bucket list lengths\n\
4534 -W --wide Allow output width to exceed 80 characters\n\
4535 @<file> Read options from <file>\n\
4536 -H --help Display this information\n\
4537 -v --version Display the version number of readelf\n"));
4539 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
4540 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
4542 exit (stream
== stdout
? 0 : 1);
4545 /* Record the fact that the user wants the contents of section number
4546 SECTION to be displayed using the method(s) encoded as flags bits
4547 in TYPE. Note, TYPE can be zero if we are creating the array for
4551 request_dump_bynumber (Filedata
* filedata
, unsigned int section
, dump_type type
)
4553 if (section
>= filedata
->num_dump_sects
)
4555 dump_type
* new_dump_sects
;
4557 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
4558 sizeof (* new_dump_sects
));
4560 if (new_dump_sects
== NULL
)
4561 error (_("Out of memory allocating dump request table.\n"));
4564 if (filedata
->dump_sects
)
4566 /* Copy current flag settings. */
4567 memcpy (new_dump_sects
, filedata
->dump_sects
,
4568 filedata
->num_dump_sects
* sizeof (* new_dump_sects
));
4570 free (filedata
->dump_sects
);
4573 filedata
->dump_sects
= new_dump_sects
;
4574 filedata
->num_dump_sects
= section
+ 1;
4578 if (filedata
->dump_sects
)
4579 filedata
->dump_sects
[section
] |= type
;
4582 /* Request a dump by section name. */
4585 request_dump_byname (const char * section
, dump_type type
)
4587 struct dump_list_entry
* new_request
;
4589 new_request
= (struct dump_list_entry
*)
4590 malloc (sizeof (struct dump_list_entry
));
4592 error (_("Out of memory allocating dump request table.\n"));
4594 new_request
->name
= strdup (section
);
4595 if (!new_request
->name
)
4596 error (_("Out of memory allocating dump request table.\n"));
4598 new_request
->type
= type
;
4600 new_request
->next
= dump_sects_byname
;
4601 dump_sects_byname
= new_request
;
4605 request_dump (Filedata
* filedata
, dump_type type
)
4611 section
= strtoul (optarg
, & cp
, 0);
4613 if (! *cp
&& section
>= 0)
4614 request_dump_bynumber (filedata
, section
, type
);
4616 request_dump_byname (optarg
, type
);
4620 parse_args (Filedata
* filedata
, int argc
, char ** argv
)
4627 while ((c
= getopt_long
4628 (argc
, argv
, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options
, NULL
)) != EOF
)
4646 do_section_groups
= TRUE
;
4649 do_histogram
= TRUE
;
4654 do_section_groups
= TRUE
;
4659 do_section_details
= TRUE
;
4670 do_using_dynamic
= TRUE
;
4694 do_histogram
= TRUE
;
4700 do_archive_index
= TRUE
;
4703 request_dump (filedata
, HEX_DUMP
);
4706 request_dump (filedata
, STRING_DUMP
);
4709 request_dump (filedata
, RELOC_DUMP
);
4712 decompress_dumps
= TRUE
;
4718 do_debugging
= TRUE
;
4719 dwarf_select_sections_all ();
4723 do_debugging
= FALSE
;
4724 dwarf_select_sections_by_letters (optarg
);
4727 case OPTION_DEBUG_DUMP
:
4730 do_debugging
= TRUE
;
4733 do_debugging
= FALSE
;
4734 dwarf_select_sections_by_names (optarg
);
4737 case OPTION_DWARF_DEPTH
:
4741 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
4744 case OPTION_DWARF_START
:
4748 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
4751 case OPTION_DWARF_CHECK
:
4754 case OPTION_CTF_DUMP
:
4756 request_dump (filedata
, CTF_DUMP
);
4758 case OPTION_CTF_SYMBOLS
:
4759 dump_ctf_symtab_name
= strdup (optarg
);
4761 case OPTION_CTF_STRINGS
:
4762 dump_ctf_strtab_name
= strdup (optarg
);
4764 case OPTION_CTF_PARENT
:
4765 dump_ctf_parent_name
= strdup (optarg
);
4767 case OPTION_DYN_SYMS
:
4770 #ifdef SUPPORT_DISASSEMBLY
4772 request_dump (filedata
, DISASS_DUMP
);
4776 print_version (program_name
);
4785 /* xgettext:c-format */
4786 error (_("Invalid option '-%c'\n"), c
);
4793 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
4794 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
4795 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
4796 && !do_section_groups
&& !do_archive_index
4802 get_elf_class (unsigned int elf_class
)
4804 static char buff
[32];
4808 case ELFCLASSNONE
: return _("none");
4809 case ELFCLASS32
: return "ELF32";
4810 case ELFCLASS64
: return "ELF64";
4812 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
4818 get_data_encoding (unsigned int encoding
)
4820 static char buff
[32];
4824 case ELFDATANONE
: return _("none");
4825 case ELFDATA2LSB
: return _("2's complement, little endian");
4826 case ELFDATA2MSB
: return _("2's complement, big endian");
4828 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
4833 /* Decode the data held in 'filedata->file_header'. */
4836 process_file_header (Filedata
* filedata
)
4838 Elf_Internal_Ehdr
* header
= & filedata
->file_header
;
4840 if ( header
->e_ident
[EI_MAG0
] != ELFMAG0
4841 || header
->e_ident
[EI_MAG1
] != ELFMAG1
4842 || header
->e_ident
[EI_MAG2
] != ELFMAG2
4843 || header
->e_ident
[EI_MAG3
] != ELFMAG3
)
4846 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4850 init_dwarf_regnames (header
->e_machine
);
4856 printf (_("ELF Header:\n"));
4857 printf (_(" Magic: "));
4858 for (i
= 0; i
< EI_NIDENT
; i
++)
4859 printf ("%2.2x ", header
->e_ident
[i
]);
4861 printf (_(" Class: %s\n"),
4862 get_elf_class (header
->e_ident
[EI_CLASS
]));
4863 printf (_(" Data: %s\n"),
4864 get_data_encoding (header
->e_ident
[EI_DATA
]));
4865 printf (_(" Version: %d%s\n"),
4866 header
->e_ident
[EI_VERSION
],
4867 (header
->e_ident
[EI_VERSION
] == EV_CURRENT
4869 : (header
->e_ident
[EI_VERSION
] != EV_NONE
4872 printf (_(" OS/ABI: %s\n"),
4873 get_osabi_name (filedata
, header
->e_ident
[EI_OSABI
]));
4874 printf (_(" ABI Version: %d\n"),
4875 header
->e_ident
[EI_ABIVERSION
]);
4876 printf (_(" Type: %s\n"),
4877 get_file_type (header
->e_type
));
4878 printf (_(" Machine: %s\n"),
4879 get_machine_name (header
->e_machine
));
4880 printf (_(" Version: 0x%lx\n"),
4883 printf (_(" Entry point address: "));
4884 print_vma (header
->e_entry
, PREFIX_HEX
);
4885 printf (_("\n Start of program headers: "));
4886 print_vma (header
->e_phoff
, DEC
);
4887 printf (_(" (bytes into file)\n Start of section headers: "));
4888 print_vma (header
->e_shoff
, DEC
);
4889 printf (_(" (bytes into file)\n"));
4891 printf (_(" Flags: 0x%lx%s\n"),
4893 get_machine_flags (filedata
, header
->e_flags
, header
->e_machine
));
4894 printf (_(" Size of this header: %u (bytes)\n"),
4896 printf (_(" Size of program headers: %u (bytes)\n"),
4897 header
->e_phentsize
);
4898 printf (_(" Number of program headers: %u"),
4900 if (filedata
->section_headers
!= NULL
4901 && header
->e_phnum
== PN_XNUM
4902 && filedata
->section_headers
[0].sh_info
!= 0)
4904 header
->e_phnum
= filedata
->section_headers
[0].sh_info
;
4905 printf (" (%u)", header
->e_phnum
);
4907 putc ('\n', stdout
);
4908 printf (_(" Size of section headers: %u (bytes)\n"),
4909 header
->e_shentsize
);
4910 printf (_(" Number of section headers: %u"),
4912 if (filedata
->section_headers
!= NULL
&& header
->e_shnum
== SHN_UNDEF
)
4914 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
4915 printf (" (%u)", header
->e_shnum
);
4917 putc ('\n', stdout
);
4918 printf (_(" Section header string table index: %u"),
4919 header
->e_shstrndx
);
4920 if (filedata
->section_headers
!= NULL
4921 && header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
4923 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
4924 printf (" (%u)", header
->e_shstrndx
);
4926 if (header
->e_shstrndx
!= SHN_UNDEF
4927 && header
->e_shstrndx
>= header
->e_shnum
)
4929 header
->e_shstrndx
= SHN_UNDEF
;
4930 printf (_(" <corrupt: out of range>"));
4932 putc ('\n', stdout
);
4935 if (filedata
->section_headers
!= NULL
)
4937 if (header
->e_phnum
== PN_XNUM
4938 && filedata
->section_headers
[0].sh_info
!= 0)
4939 header
->e_phnum
= filedata
->section_headers
[0].sh_info
;
4940 if (header
->e_shnum
== SHN_UNDEF
)
4941 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
4942 if (header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
4943 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
4944 if (header
->e_shstrndx
>= header
->e_shnum
)
4945 header
->e_shstrndx
= SHN_UNDEF
;
4946 free (filedata
->section_headers
);
4947 filedata
->section_headers
= NULL
;
4953 /* Read in the program headers from FILEDATA and store them in PHEADERS.
4954 Returns TRUE upon success, FALSE otherwise. Loads 32-bit headers. */
4957 get_32bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
4959 Elf32_External_Phdr
* phdrs
;
4960 Elf32_External_Phdr
* external
;
4961 Elf_Internal_Phdr
* internal
;
4963 unsigned int size
= filedata
->file_header
.e_phentsize
;
4964 unsigned int num
= filedata
->file_header
.e_phnum
;
4966 /* PR binutils/17531: Cope with unexpected section header sizes. */
4967 if (size
== 0 || num
== 0)
4969 if (size
< sizeof * phdrs
)
4971 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4974 if (size
> sizeof * phdrs
)
4975 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4977 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
4978 size
, num
, _("program headers"));
4982 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4983 i
< filedata
->file_header
.e_phnum
;
4984 i
++, internal
++, external
++)
4986 internal
->p_type
= BYTE_GET (external
->p_type
);
4987 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4988 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4989 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4990 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4991 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4992 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4993 internal
->p_align
= BYTE_GET (external
->p_align
);
5000 /* Read in the program headers from FILEDATA and store them in PHEADERS.
5001 Returns TRUE upon success, FALSE otherwise. Loads 64-bit headers. */
5004 get_64bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
5006 Elf64_External_Phdr
* phdrs
;
5007 Elf64_External_Phdr
* external
;
5008 Elf_Internal_Phdr
* internal
;
5010 unsigned int size
= filedata
->file_header
.e_phentsize
;
5011 unsigned int num
= filedata
->file_header
.e_phnum
;
5013 /* PR binutils/17531: Cope with unexpected section header sizes. */
5014 if (size
== 0 || num
== 0)
5016 if (size
< sizeof * phdrs
)
5018 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
5021 if (size
> sizeof * phdrs
)
5022 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
5024 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
5025 size
, num
, _("program headers"));
5029 for (i
= 0, internal
= pheaders
, external
= phdrs
;
5030 i
< filedata
->file_header
.e_phnum
;
5031 i
++, internal
++, external
++)
5033 internal
->p_type
= BYTE_GET (external
->p_type
);
5034 internal
->p_flags
= BYTE_GET (external
->p_flags
);
5035 internal
->p_offset
= BYTE_GET (external
->p_offset
);
5036 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
5037 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
5038 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
5039 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
5040 internal
->p_align
= BYTE_GET (external
->p_align
);
5047 /* Returns TRUE if the program headers were read into `program_headers'. */
5050 get_program_headers (Filedata
* filedata
)
5052 Elf_Internal_Phdr
* phdrs
;
5054 /* Check cache of prior read. */
5055 if (filedata
->program_headers
!= NULL
)
5058 /* Be kind to memory checkers by looking for
5059 e_phnum values which we know must be invalid. */
5060 if (filedata
->file_header
.e_phnum
5061 * (is_32bit_elf
? sizeof (Elf32_External_Phdr
) : sizeof (Elf64_External_Phdr
))
5062 >= filedata
->file_size
)
5064 error (_("Too many program headers - %#x - the file is not that big\n"),
5065 filedata
->file_header
.e_phnum
);
5069 phdrs
= (Elf_Internal_Phdr
*) cmalloc (filedata
->file_header
.e_phnum
,
5070 sizeof (Elf_Internal_Phdr
));
5073 error (_("Out of memory reading %u program headers\n"),
5074 filedata
->file_header
.e_phnum
);
5079 ? get_32bit_program_headers (filedata
, phdrs
)
5080 : get_64bit_program_headers (filedata
, phdrs
))
5082 filedata
->program_headers
= phdrs
;
5090 /* Returns TRUE if the program headers were loaded. */
5093 process_program_headers (Filedata
* filedata
)
5095 Elf_Internal_Phdr
* segment
;
5097 Elf_Internal_Phdr
* previous_load
= NULL
;
5099 if (filedata
->file_header
.e_phnum
== 0)
5101 /* PR binutils/12467. */
5102 if (filedata
->file_header
.e_phoff
!= 0)
5104 warn (_("possibly corrupt ELF header - it has a non-zero program"
5105 " header offset, but no program headers\n"));
5108 else if (do_segments
)
5109 printf (_("\nThere are no program headers in this file.\n"));
5113 if (do_segments
&& !do_header
)
5115 printf (_("\nElf file type is %s\n"), get_file_type (filedata
->file_header
.e_type
));
5116 printf (_("Entry point 0x%s\n"), bfd_vmatoa ("x", filedata
->file_header
.e_entry
));
5117 printf (ngettext ("There is %d program header, starting at offset %s\n",
5118 "There are %d program headers, starting at offset %s\n",
5119 filedata
->file_header
.e_phnum
),
5120 filedata
->file_header
.e_phnum
,
5121 bfd_vmatoa ("u", filedata
->file_header
.e_phoff
));
5124 if (! get_program_headers (filedata
))
5129 if (filedata
->file_header
.e_phnum
> 1)
5130 printf (_("\nProgram Headers:\n"));
5132 printf (_("\nProgram Headers:\n"));
5136 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5139 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5143 (_(" Type Offset VirtAddr PhysAddr\n"));
5145 (_(" FileSiz MemSiz Flags Align\n"));
5152 for (i
= 0, segment
= filedata
->program_headers
;
5153 i
< filedata
->file_header
.e_phnum
;
5158 printf (" %-14.14s ", get_segment_type (filedata
, segment
->p_type
));
5162 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
5163 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
5164 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
5165 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
5166 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
5168 (segment
->p_flags
& PF_R
? 'R' : ' '),
5169 (segment
->p_flags
& PF_W
? 'W' : ' '),
5170 (segment
->p_flags
& PF_X
? 'E' : ' '));
5171 printf ("%#lx", (unsigned long) segment
->p_align
);
5175 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
5176 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
5179 print_vma (segment
->p_offset
, FULL_HEX
);
5183 print_vma (segment
->p_vaddr
, FULL_HEX
);
5185 print_vma (segment
->p_paddr
, FULL_HEX
);
5188 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
5189 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
5192 print_vma (segment
->p_filesz
, FULL_HEX
);
5196 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
5197 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
5200 print_vma (segment
->p_memsz
, FULL_HEX
);
5204 (segment
->p_flags
& PF_R
? 'R' : ' '),
5205 (segment
->p_flags
& PF_W
? 'W' : ' '),
5206 (segment
->p_flags
& PF_X
? 'E' : ' '));
5208 if ((unsigned long) segment
->p_align
== segment
->p_align
)
5209 printf ("%#lx", (unsigned long) segment
->p_align
);
5212 print_vma (segment
->p_align
, PREFIX_HEX
);
5217 print_vma (segment
->p_offset
, FULL_HEX
);
5219 print_vma (segment
->p_vaddr
, FULL_HEX
);
5221 print_vma (segment
->p_paddr
, FULL_HEX
);
5223 print_vma (segment
->p_filesz
, FULL_HEX
);
5225 print_vma (segment
->p_memsz
, FULL_HEX
);
5227 (segment
->p_flags
& PF_R
? 'R' : ' '),
5228 (segment
->p_flags
& PF_W
? 'W' : ' '),
5229 (segment
->p_flags
& PF_X
? 'E' : ' '));
5230 print_vma (segment
->p_align
, PREFIX_HEX
);
5233 putc ('\n', stdout
);
5236 switch (segment
->p_type
)
5239 #if 0 /* Do not warn about out of order PT_LOAD segments. Although officially
5240 required by the ELF standard, several programs, including the Linux
5241 kernel, make use of non-ordered segments. */
5243 && previous_load
->p_vaddr
> segment
->p_vaddr
)
5244 error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
5246 if (segment
->p_memsz
< segment
->p_filesz
)
5247 error (_("the segment's file size is larger than its memory size\n"));
5248 previous_load
= segment
;
5252 /* PR 20815 - Verify that the program header is loaded into memory. */
5253 if (i
> 0 && previous_load
!= NULL
)
5254 error (_("the PHDR segment must occur before any LOAD segment\n"));
5255 if (filedata
->file_header
.e_machine
!= EM_PARISC
)
5259 for (j
= 1; j
< filedata
->file_header
.e_phnum
; j
++)
5260 if (filedata
->program_headers
[j
].p_vaddr
<= segment
->p_vaddr
5261 && (filedata
->program_headers
[j
].p_vaddr
5262 + filedata
->program_headers
[j
].p_memsz
)
5263 >= (segment
->p_vaddr
+ segment
->p_filesz
))
5265 if (j
== filedata
->file_header
.e_phnum
)
5266 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5272 error (_("more than one dynamic segment\n"));
5274 /* By default, assume that the .dynamic section is the first
5275 section in the DYNAMIC segment. */
5276 dynamic_addr
= segment
->p_offset
;
5277 dynamic_size
= segment
->p_filesz
;
5279 /* Try to locate the .dynamic section. If there is
5280 a section header table, we can easily locate it. */
5281 if (filedata
->section_headers
!= NULL
)
5283 Elf_Internal_Shdr
* sec
;
5285 sec
= find_section (filedata
, ".dynamic");
5286 if (sec
== NULL
|| sec
->sh_size
== 0)
5288 /* A corresponding .dynamic section is expected, but on
5289 IA-64/OpenVMS it is OK for it to be missing. */
5290 if (!is_ia64_vms (filedata
))
5291 error (_("no .dynamic section in the dynamic segment\n"));
5295 if (sec
->sh_type
== SHT_NOBITS
)
5301 dynamic_addr
= sec
->sh_offset
;
5302 dynamic_size
= sec
->sh_size
;
5304 if (dynamic_addr
< segment
->p_offset
5305 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
5306 warn (_("the .dynamic section is not contained"
5307 " within the dynamic segment\n"));
5308 else if (dynamic_addr
> segment
->p_offset
)
5309 warn (_("the .dynamic section is not the first section"
5310 " in the dynamic segment.\n"));
5313 /* PR binutils/17512: Avoid corrupt dynamic section info in the
5314 segment. Check this after matching against the section headers
5315 so we don't warn on debuginfo file (which have NOBITS .dynamic
5317 if (dynamic_addr
> filedata
->file_size
5318 || dynamic_size
> filedata
->file_size
- dynamic_addr
)
5320 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5321 dynamic_addr
= dynamic_size
= 0;
5326 if (fseek (filedata
->handle
, archive_file_offset
+ (long) segment
->p_offset
,
5328 error (_("Unable to find program interpreter name\n"));
5332 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
- 1);
5334 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
5335 error (_("Internal error: failed to create format string to display program interpreter\n"));
5337 program_interpreter
[0] = 0;
5338 if (fscanf (filedata
->handle
, fmt
, program_interpreter
) <= 0)
5339 error (_("Unable to read program interpreter name\n"));
5342 printf (_(" [Requesting program interpreter: %s]\n"),
5343 program_interpreter
);
5350 && filedata
->section_headers
!= NULL
5351 && filedata
->string_table
!= NULL
)
5353 printf (_("\n Section to Segment mapping:\n"));
5354 printf (_(" Segment Sections...\n"));
5356 for (i
= 0; i
< filedata
->file_header
.e_phnum
; i
++)
5359 Elf_Internal_Shdr
* section
;
5361 segment
= filedata
->program_headers
+ i
;
5362 section
= filedata
->section_headers
+ 1;
5364 printf (" %2.2d ", i
);
5366 for (j
= 1; j
< filedata
->file_header
.e_shnum
; j
++, section
++)
5368 if (!ELF_TBSS_SPECIAL (section
, segment
)
5369 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
5370 printf ("%s ", printable_section_name (filedata
, section
));
5381 /* Find the file offset corresponding to VMA by using the program headers. */
5384 offset_from_vma (Filedata
* filedata
, bfd_vma vma
, bfd_size_type size
)
5386 Elf_Internal_Phdr
* seg
;
5388 if (! get_program_headers (filedata
))
5390 warn (_("Cannot interpret virtual addresses without program headers.\n"));
5394 for (seg
= filedata
->program_headers
;
5395 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
5398 if (seg
->p_type
!= PT_LOAD
)
5401 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
5402 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
5403 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
5406 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5407 (unsigned long) vma
);
5412 /* Allocate memory and load the sections headers into FILEDATA->filedata->section_headers.
5413 If PROBE is true, this is just a probe and we do not generate any error
5414 messages if the load fails. */
5417 get_32bit_section_headers (Filedata
* filedata
, bfd_boolean probe
)
5419 Elf32_External_Shdr
* shdrs
;
5420 Elf_Internal_Shdr
* internal
;
5422 unsigned int size
= filedata
->file_header
.e_shentsize
;
5423 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
5425 /* PR binutils/17531: Cope with unexpected section header sizes. */
5426 if (size
== 0 || num
== 0)
5428 if (size
< sizeof * shdrs
)
5431 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5434 if (!probe
&& size
> sizeof * shdrs
)
5435 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5437 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_shoff
,
5439 probe
? NULL
: _("section headers"));
5443 free (filedata
->section_headers
);
5444 filedata
->section_headers
= (Elf_Internal_Shdr
*)
5445 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
5446 if (filedata
->section_headers
== NULL
)
5449 error (_("Out of memory reading %u section headers\n"), num
);
5454 for (i
= 0, internal
= filedata
->section_headers
;
5458 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5459 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5460 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5461 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5462 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5463 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5464 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5465 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5466 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5467 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5468 if (!probe
&& internal
->sh_link
> num
)
5469 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5470 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5471 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5478 /* Like get_32bit_section_headers, except that it fetches 64-bit headers. */
5481 get_64bit_section_headers (Filedata
* filedata
, bfd_boolean probe
)
5483 Elf64_External_Shdr
* shdrs
;
5484 Elf_Internal_Shdr
* internal
;
5486 unsigned int size
= filedata
->file_header
.e_shentsize
;
5487 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
5489 /* PR binutils/17531: Cope with unexpected section header sizes. */
5490 if (size
== 0 || num
== 0)
5493 if (size
< sizeof * shdrs
)
5496 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5500 if (! probe
&& size
> sizeof * shdrs
)
5501 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5503 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, filedata
,
5504 filedata
->file_header
.e_shoff
,
5506 probe
? NULL
: _("section headers"));
5510 free (filedata
->section_headers
);
5511 filedata
->section_headers
= (Elf_Internal_Shdr
*)
5512 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
5513 if (filedata
->section_headers
== NULL
)
5516 error (_("Out of memory reading %u section headers\n"), num
);
5521 for (i
= 0, internal
= filedata
->section_headers
;
5525 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5526 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5527 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5528 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5529 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5530 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5531 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5532 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5533 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5534 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5535 if (!probe
&& internal
->sh_link
> num
)
5536 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5537 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5538 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5545 static Elf_Internal_Sym
*
5546 get_32bit_elf_symbols (Filedata
* filedata
,
5547 Elf_Internal_Shdr
* section
,
5548 unsigned long * num_syms_return
)
5550 unsigned long number
= 0;
5551 Elf32_External_Sym
* esyms
= NULL
;
5552 Elf_External_Sym_Shndx
* shndx
= NULL
;
5553 Elf_Internal_Sym
* isyms
= NULL
;
5554 Elf_Internal_Sym
* psym
;
5556 elf_section_list
* entry
;
5558 if (section
->sh_size
== 0)
5560 if (num_syms_return
!= NULL
)
5561 * num_syms_return
= 0;
5565 /* Run some sanity checks first. */
5566 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5568 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5569 printable_section_name (filedata
, section
),
5570 (unsigned long) section
->sh_entsize
);
5574 if (section
->sh_size
> filedata
->file_size
)
5576 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5577 printable_section_name (filedata
, section
),
5578 (unsigned long) section
->sh_size
);
5582 number
= section
->sh_size
/ section
->sh_entsize
;
5584 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
5586 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5587 (unsigned long) section
->sh_size
,
5588 printable_section_name (filedata
, section
),
5589 (unsigned long) section
->sh_entsize
);
5593 esyms
= (Elf32_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
5594 section
->sh_size
, _("symbols"));
5599 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5601 if (entry
->hdr
->sh_link
!= (unsigned long) (section
- filedata
->section_headers
))
5606 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5610 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
5611 entry
->hdr
->sh_offset
,
5612 1, entry
->hdr
->sh_size
,
5613 _("symbol table section indices"));
5617 /* PR17531: file: heap-buffer-overflow */
5618 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5620 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5621 printable_section_name (filedata
, entry
->hdr
),
5622 (unsigned long) entry
->hdr
->sh_size
,
5623 (unsigned long) section
->sh_size
);
5628 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5632 error (_("Out of memory reading %lu symbols\n"),
5633 (unsigned long) number
);
5637 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5639 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5640 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5641 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5642 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5643 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5645 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5646 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5647 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5648 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5649 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5656 if (num_syms_return
!= NULL
)
5657 * num_syms_return
= isyms
== NULL
? 0 : number
;
5662 static Elf_Internal_Sym
*
5663 get_64bit_elf_symbols (Filedata
* filedata
,
5664 Elf_Internal_Shdr
* section
,
5665 unsigned long * num_syms_return
)
5667 unsigned long number
= 0;
5668 Elf64_External_Sym
* esyms
= NULL
;
5669 Elf_External_Sym_Shndx
* shndx
= NULL
;
5670 Elf_Internal_Sym
* isyms
= NULL
;
5671 Elf_Internal_Sym
* psym
;
5673 elf_section_list
* entry
;
5675 if (section
->sh_size
== 0)
5677 if (num_syms_return
!= NULL
)
5678 * num_syms_return
= 0;
5682 /* Run some sanity checks first. */
5683 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5685 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5686 printable_section_name (filedata
, section
),
5687 (unsigned long) section
->sh_entsize
);
5691 if (section
->sh_size
> filedata
->file_size
)
5693 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5694 printable_section_name (filedata
, section
),
5695 (unsigned long) section
->sh_size
);
5699 number
= section
->sh_size
/ section
->sh_entsize
;
5701 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
5703 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5704 (unsigned long) section
->sh_size
,
5705 printable_section_name (filedata
, section
),
5706 (unsigned long) section
->sh_entsize
);
5710 esyms
= (Elf64_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
5711 section
->sh_size
, _("symbols"));
5716 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5718 if (entry
->hdr
->sh_link
!= (unsigned long) (section
- filedata
->section_headers
))
5723 error (_("Multiple symbol table index sections associated with the same symbol section\n"));
5727 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
5728 entry
->hdr
->sh_offset
,
5729 1, entry
->hdr
->sh_size
,
5730 _("symbol table section indices"));
5734 /* PR17531: file: heap-buffer-overflow */
5735 if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5737 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5738 printable_section_name (filedata
, entry
->hdr
),
5739 (unsigned long) entry
->hdr
->sh_size
,
5740 (unsigned long) section
->sh_size
);
5745 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5749 error (_("Out of memory reading %lu symbols\n"),
5750 (unsigned long) number
);
5754 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5756 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5757 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5758 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5759 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5761 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5763 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5764 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5765 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5767 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5768 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5775 if (num_syms_return
!= NULL
)
5776 * num_syms_return
= isyms
== NULL
? 0 : number
;
5782 get_elf_section_flags (Filedata
* filedata
, bfd_vma sh_flags
)
5784 static char buff
[1024];
5786 unsigned int field_size
= is_32bit_elf
? 8 : 16;
5788 unsigned int size
= sizeof (buff
) - (field_size
+ 4 + 1);
5789 bfd_vma os_flags
= 0;
5790 bfd_vma proc_flags
= 0;
5791 bfd_vma unknown_flags
= 0;
5799 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5800 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5801 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5802 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5803 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5804 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5805 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5806 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5807 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5808 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5809 /* IA-64 specific. */
5810 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5811 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5812 /* IA-64 OpenVMS specific. */
5813 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5814 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5815 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5816 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5817 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5818 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5820 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5821 /* SPARC specific. */
5822 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5823 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5825 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5826 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5827 /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
5829 /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
5831 /* 25 */ { STRING_COMMA_LEN ("VLE") },
5834 if (do_section_details
)
5836 sprintf (buff
, "[%*.*lx]: ",
5837 field_size
, field_size
, (unsigned long) sh_flags
);
5838 p
+= field_size
+ 4;
5845 flag
= sh_flags
& - sh_flags
;
5848 if (do_section_details
)
5852 case SHF_WRITE
: sindex
= 0; break;
5853 case SHF_ALLOC
: sindex
= 1; break;
5854 case SHF_EXECINSTR
: sindex
= 2; break;
5855 case SHF_MERGE
: sindex
= 3; break;
5856 case SHF_STRINGS
: sindex
= 4; break;
5857 case SHF_INFO_LINK
: sindex
= 5; break;
5858 case SHF_LINK_ORDER
: sindex
= 6; break;
5859 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
5860 case SHF_GROUP
: sindex
= 8; break;
5861 case SHF_TLS
: sindex
= 9; break;
5862 case SHF_EXCLUDE
: sindex
= 18; break;
5863 case SHF_COMPRESSED
: sindex
= 20; break;
5864 case SHF_GNU_MBIND
: sindex
= 24; break;
5868 switch (filedata
->file_header
.e_machine
)
5871 if (flag
== SHF_IA_64_SHORT
)
5873 else if (flag
== SHF_IA_64_NORECOV
)
5876 else if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
5879 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
5880 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
5881 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
5882 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
5883 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
5884 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
5895 case EM_OLD_SPARCV9
:
5896 case EM_SPARC32PLUS
:
5899 if (flag
== SHF_ORDERED
)
5906 case SHF_ENTRYSECT
: sindex
= 21; break;
5907 case SHF_ARM_PURECODE
: sindex
= 22; break;
5908 case SHF_COMDEF
: sindex
= 23; break;
5913 if (flag
== SHF_PPC_VLE
)
5924 if (p
!= buff
+ field_size
+ 4)
5926 if (size
< (10 + 2))
5928 warn (_("Internal error: not enough buffer room for section flag info"));
5929 return _("<unknown>");
5936 size
-= flags
[sindex
].len
;
5937 p
= stpcpy (p
, flags
[sindex
].str
);
5939 else if (flag
& SHF_MASKOS
)
5941 else if (flag
& SHF_MASKPROC
)
5944 unknown_flags
|= flag
;
5950 case SHF_WRITE
: *p
= 'W'; break;
5951 case SHF_ALLOC
: *p
= 'A'; break;
5952 case SHF_EXECINSTR
: *p
= 'X'; break;
5953 case SHF_MERGE
: *p
= 'M'; break;
5954 case SHF_STRINGS
: *p
= 'S'; break;
5955 case SHF_INFO_LINK
: *p
= 'I'; break;
5956 case SHF_LINK_ORDER
: *p
= 'L'; break;
5957 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
5958 case SHF_GROUP
: *p
= 'G'; break;
5959 case SHF_TLS
: *p
= 'T'; break;
5960 case SHF_EXCLUDE
: *p
= 'E'; break;
5961 case SHF_COMPRESSED
: *p
= 'C'; break;
5962 case SHF_GNU_MBIND
: *p
= 'D'; break;
5965 if ((filedata
->file_header
.e_machine
== EM_X86_64
5966 || filedata
->file_header
.e_machine
== EM_L1OM
5967 || filedata
->file_header
.e_machine
== EM_K1OM
)
5968 && flag
== SHF_X86_64_LARGE
)
5970 else if (filedata
->file_header
.e_machine
== EM_ARM
5971 && flag
== SHF_ARM_PURECODE
)
5973 else if (filedata
->file_header
.e_machine
== EM_PPC
5974 && flag
== SHF_PPC_VLE
)
5976 else if (flag
& SHF_MASKOS
)
5979 sh_flags
&= ~ SHF_MASKOS
;
5981 else if (flag
& SHF_MASKPROC
)
5984 sh_flags
&= ~ SHF_MASKPROC
;
5994 if (do_section_details
)
5998 size
-= 5 + field_size
;
5999 if (p
!= buff
+ field_size
+ 4)
6003 warn (_("Internal error: not enough buffer room for section flag info"));
6004 return _("<unknown>");
6010 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
6011 (unsigned long) os_flags
);
6012 p
+= 5 + field_size
;
6016 size
-= 7 + field_size
;
6017 if (p
!= buff
+ field_size
+ 4)
6021 warn (_("Internal error: not enough buffer room for section flag info"));
6022 return _("<unknown>");
6028 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
6029 (unsigned long) proc_flags
);
6030 p
+= 7 + field_size
;
6034 size
-= 10 + field_size
;
6035 if (p
!= buff
+ field_size
+ 4)
6039 warn (_("Internal error: not enough buffer room for section flag info"));
6040 return _("<unknown>");
6046 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
6047 (unsigned long) unknown_flags
);
6048 p
+= 10 + field_size
;
6057 get_compression_header (Elf_Internal_Chdr
*chdr
, unsigned char *buf
, bfd_size_type size
)
6061 Elf32_External_Chdr
*echdr
= (Elf32_External_Chdr
*) buf
;
6063 if (size
< sizeof (* echdr
))
6065 error (_("Compressed section is too small even for a compression header\n"));
6069 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
6070 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
6071 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
6072 return sizeof (*echdr
);
6076 Elf64_External_Chdr
*echdr
= (Elf64_External_Chdr
*) buf
;
6078 if (size
< sizeof (* echdr
))
6080 error (_("Compressed section is too small even for a compression header\n"));
6084 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
6085 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
6086 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
6087 return sizeof (*echdr
);
6092 process_section_headers (Filedata
* filedata
)
6094 Elf_Internal_Shdr
* section
;
6097 filedata
->section_headers
= NULL
;
6099 if (filedata
->file_header
.e_shnum
== 0)
6101 /* PR binutils/12467. */
6102 if (filedata
->file_header
.e_shoff
!= 0)
6104 warn (_("possibly corrupt ELF file header - it has a non-zero"
6105 " section header offset, but no section headers\n"));
6108 else if (do_sections
)
6109 printf (_("\nThere are no sections in this file.\n"));
6114 if (do_sections
&& !do_header
)
6115 printf (ngettext ("There is %d section header, "
6116 "starting at offset 0x%lx:\n",
6117 "There are %d section headers, "
6118 "starting at offset 0x%lx:\n",
6119 filedata
->file_header
.e_shnum
),
6120 filedata
->file_header
.e_shnum
,
6121 (unsigned long) filedata
->file_header
.e_shoff
);
6125 if (! get_32bit_section_headers (filedata
, FALSE
))
6130 if (! get_64bit_section_headers (filedata
, FALSE
))
6134 /* Read in the string table, so that we have names to display. */
6135 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
6136 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
6138 section
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
6140 if (section
->sh_size
!= 0)
6142 filedata
->string_table
= (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6143 1, section
->sh_size
,
6146 filedata
->string_table_length
= filedata
->string_table
!= NULL
? section
->sh_size
: 0;
6150 /* Scan the sections for the dynamic symbol table
6151 and dynamic string table and debug sections. */
6152 dynamic_symbols
= NULL
;
6153 dynamic_strings
= NULL
;
6154 dynamic_syminfo
= NULL
;
6155 symtab_shndx_list
= NULL
;
6157 eh_addr_size
= is_32bit_elf
? 4 : 8;
6158 switch (filedata
->file_header
.e_machine
)
6161 case EM_MIPS_RS3_LE
:
6162 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
6163 FDE addresses. However, the ABI also has a semi-official ILP32
6164 variant for which the normal FDE address size rules apply.
6166 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
6167 section, where XX is the size of longs in bits. Unfortunately,
6168 earlier compilers provided no way of distinguishing ILP32 objects
6169 from LP64 objects, so if there's any doubt, we should assume that
6170 the official LP64 form is being used. */
6171 if ((filedata
->file_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
6172 && find_section (filedata
, ".gcc_compiled_long32") == NULL
)
6178 switch (filedata
->file_header
.e_flags
& EF_H8_MACH
)
6180 case E_H8_MACH_H8300
:
6181 case E_H8_MACH_H8300HN
:
6182 case E_H8_MACH_H8300SN
:
6183 case E_H8_MACH_H8300SXN
:
6186 case E_H8_MACH_H8300H
:
6187 case E_H8_MACH_H8300S
:
6188 case E_H8_MACH_H8300SX
:
6196 switch (filedata
->file_header
.e_flags
& EF_M32C_CPU_MASK
)
6198 case EF_M32C_CPU_M16C
:
6205 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
6208 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
6209 if (section->sh_entsize != expected_entsize) \
6212 sprintf_vma (buf, section->sh_entsize); \
6213 /* Note: coded this way so that there is a single string for \
6215 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
6216 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
6217 (unsigned) expected_entsize); \
6218 section->sh_entsize = expected_entsize; \
6223 #define CHECK_ENTSIZE(section, i, type) \
6224 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
6225 sizeof (Elf64_External_##type))
6227 for (i
= 0, section
= filedata
->section_headers
;
6228 i
< filedata
->file_header
.e_shnum
;
6231 char * name
= SECTION_NAME (section
);
6233 if (section
->sh_type
== SHT_DYNSYM
)
6235 if (dynamic_symbols
!= NULL
)
6237 error (_("File contains multiple dynamic symbol tables\n"));
6241 CHECK_ENTSIZE (section
, i
, Sym
);
6242 dynamic_symbols
= GET_ELF_SYMBOLS (filedata
, section
, & num_dynamic_syms
);
6244 else if (section
->sh_type
== SHT_STRTAB
6245 && streq (name
, ".dynstr"))
6247 if (dynamic_strings
!= NULL
)
6249 error (_("File contains multiple dynamic string tables\n"));
6253 dynamic_strings
= (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6254 1, section
->sh_size
,
6255 _("dynamic strings"));
6256 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : section
->sh_size
;
6258 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
6260 elf_section_list
* entry
= xmalloc (sizeof * entry
);
6262 entry
->hdr
= section
;
6263 entry
->next
= symtab_shndx_list
;
6264 symtab_shndx_list
= entry
;
6266 else if (section
->sh_type
== SHT_SYMTAB
)
6267 CHECK_ENTSIZE (section
, i
, Sym
);
6268 else if (section
->sh_type
== SHT_GROUP
)
6269 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
6270 else if (section
->sh_type
== SHT_REL
)
6271 CHECK_ENTSIZE (section
, i
, Rel
);
6272 else if (section
->sh_type
== SHT_RELA
)
6273 CHECK_ENTSIZE (section
, i
, Rela
);
6274 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
6275 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
6276 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
6277 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
6278 || do_debug_addr
|| do_debug_cu_index
|| do_debug_links
)
6279 && (const_strneq (name
, ".debug_")
6280 || const_strneq (name
, ".zdebug_")))
6283 name
+= sizeof (".zdebug_") - 1;
6285 name
+= sizeof (".debug_") - 1;
6288 || (do_debug_info
&& const_strneq (name
, "info"))
6289 || (do_debug_info
&& const_strneq (name
, "types"))
6290 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
6291 || (do_debug_lines
&& strcmp (name
, "line") == 0)
6292 || (do_debug_lines
&& const_strneq (name
, "line."))
6293 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
6294 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
6295 || (do_debug_pubnames
&& const_strneq (name
, "gnu_pubnames"))
6296 || (do_debug_pubtypes
&& const_strneq (name
, "gnu_pubtypes"))
6297 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
6298 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
6299 || (do_debug_ranges
&& const_strneq (name
, "rnglists"))
6300 || (do_debug_frames
&& const_strneq (name
, "frame"))
6301 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
6302 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
6303 || (do_debug_str
&& const_strneq (name
, "str"))
6304 || (do_debug_loc
&& const_strneq (name
, "loc"))
6305 || (do_debug_loc
&& const_strneq (name
, "loclists"))
6306 || (do_debug_addr
&& const_strneq (name
, "addr"))
6307 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
6308 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
6310 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6312 /* Linkonce section to be combined with .debug_info at link time. */
6313 else if ((do_debugging
|| do_debug_info
)
6314 && const_strneq (name
, ".gnu.linkonce.wi."))
6315 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6316 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
6317 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6318 else if (do_gdb_index
&& (streq (name
, ".gdb_index")
6319 || streq (name
, ".debug_names")))
6320 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6321 /* Trace sections for Itanium VMS. */
6322 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
6323 || do_trace_aranges
)
6324 && const_strneq (name
, ".trace_"))
6326 name
+= sizeof (".trace_") - 1;
6329 || (do_trace_info
&& streq (name
, "info"))
6330 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
6331 || (do_trace_aranges
&& streq (name
, "aranges"))
6333 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6335 else if ((do_debugging
|| do_debug_links
)
6336 && (const_strneq (name
, ".gnu_debuglink")
6337 || const_strneq (name
, ".gnu_debugaltlink")))
6338 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6344 if (filedata
->file_header
.e_shnum
> 1)
6345 printf (_("\nSection Headers:\n"));
6347 printf (_("\nSection Header:\n"));
6351 if (do_section_details
)
6353 printf (_(" [Nr] Name\n"));
6354 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
6358 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
6362 if (do_section_details
)
6364 printf (_(" [Nr] Name\n"));
6365 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
6369 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
6373 if (do_section_details
)
6375 printf (_(" [Nr] Name\n"));
6376 printf (_(" Type Address Offset Link\n"));
6377 printf (_(" Size EntSize Info Align\n"));
6381 printf (_(" [Nr] Name Type Address Offset\n"));
6382 printf (_(" Size EntSize Flags Link Info Align\n"));
6386 if (do_section_details
)
6387 printf (_(" Flags\n"));
6389 for (i
= 0, section
= filedata
->section_headers
;
6390 i
< filedata
->file_header
.e_shnum
;
6393 /* Run some sanity checks on the section header. */
6395 /* Check the sh_link field. */
6396 switch (section
->sh_type
)
6400 if (section
->sh_link
== 0
6401 && (filedata
->file_header
.e_type
== ET_EXEC
6402 || filedata
->file_header
.e_type
== ET_DYN
))
6403 /* A dynamic relocation section where all entries use a
6404 zero symbol index need not specify a symtab section. */
6407 case SHT_SYMTAB_SHNDX
:
6411 case SHT_GNU_versym
:
6412 if (section
->sh_link
== 0
6413 || section
->sh_link
>= filedata
->file_header
.e_shnum
6414 || (filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_SYMTAB
6415 && filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_DYNSYM
))
6416 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6417 i
, section
->sh_link
);
6423 case SHT_GNU_verneed
:
6424 case SHT_GNU_verdef
:
6425 case SHT_GNU_LIBLIST
:
6426 if (section
->sh_link
== 0
6427 || section
->sh_link
>= filedata
->file_header
.e_shnum
6428 || filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_STRTAB
)
6429 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6430 i
, section
->sh_link
);
6433 case SHT_INIT_ARRAY
:
6434 case SHT_FINI_ARRAY
:
6435 case SHT_PREINIT_ARRAY
:
6436 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6437 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6438 i
, section
->sh_link
);
6442 /* FIXME: Add support for target specific section types. */
6443 #if 0 /* Currently we do not check other section types as there are too
6444 many special cases. Stab sections for example have a type
6445 of SHT_PROGBITS but an sh_link field that links to the .stabstr
6447 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6448 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6449 i
, section
->sh_link
);
6454 /* Check the sh_info field. */
6455 switch (section
->sh_type
)
6459 if (section
->sh_info
== 0
6460 && (filedata
->file_header
.e_type
== ET_EXEC
6461 || filedata
->file_header
.e_type
== ET_DYN
))
6462 /* Dynamic relocations apply to segments, so they do not
6463 need to specify the section they relocate. */
6465 if (section
->sh_info
== 0
6466 || section
->sh_info
>= filedata
->file_header
.e_shnum
6467 || (filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PROGBITS
6468 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOBITS
6469 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOTE
6470 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_INIT_ARRAY
6471 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_FINI_ARRAY
6472 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PREINIT_ARRAY
6473 /* FIXME: Are other section types valid ? */
6474 && filedata
->section_headers
[section
->sh_info
].sh_type
< SHT_LOOS
))
6475 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6476 i
, section
->sh_info
);
6481 case SHT_SYMTAB_SHNDX
:
6482 case SHT_INIT_ARRAY
:
6483 case SHT_FINI_ARRAY
:
6484 case SHT_PREINIT_ARRAY
:
6485 if (section
->sh_info
!= 0)
6486 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6487 i
, section
->sh_info
);
6493 /* A symbol index - we assume that it is valid. */
6497 /* FIXME: Add support for target specific section types. */
6498 if (section
->sh_type
== SHT_NOBITS
)
6499 /* NOBITS section headers with non-zero sh_info fields can be
6500 created when a binary is stripped of everything but its debug
6501 information. The stripped sections have their headers
6502 preserved but their types set to SHT_NOBITS. So do not check
6503 this type of section. */
6505 else if (section
->sh_flags
& SHF_INFO_LINK
)
6507 if (section
->sh_info
< 1 || section
->sh_info
>= filedata
->file_header
.e_shnum
)
6508 warn (_("[%2u]: Expected link to another section in info field"), i
);
6510 else if (section
->sh_type
< SHT_LOOS
6511 && (section
->sh_flags
& SHF_GNU_MBIND
) == 0
6512 && section
->sh_info
!= 0)
6513 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6514 i
, section
->sh_info
);
6518 /* Check the sh_size field. */
6519 if (section
->sh_size
> filedata
->file_size
6520 && section
->sh_type
!= SHT_NOBITS
6521 && section
->sh_type
!= SHT_NULL
6522 && section
->sh_type
< SHT_LOOS
)
6523 warn (_("Size of section %u is larger than the entire file!\n"), i
);
6525 printf (" [%2u] ", i
);
6526 if (do_section_details
)
6527 printf ("%s\n ", printable_section_name (filedata
, section
));
6529 print_symbol (-17, SECTION_NAME (section
));
6531 printf (do_wide
? " %-15s " : " %-15.15s ",
6532 get_section_type_name (filedata
, section
->sh_type
));
6536 const char * link_too_big
= NULL
;
6538 print_vma (section
->sh_addr
, LONG_HEX
);
6540 printf ( " %6.6lx %6.6lx %2.2lx",
6541 (unsigned long) section
->sh_offset
,
6542 (unsigned long) section
->sh_size
,
6543 (unsigned long) section
->sh_entsize
);
6545 if (do_section_details
)
6546 fputs (" ", stdout
);
6548 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6550 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
6553 /* The sh_link value is out of range. Normally this indicates
6554 an error but it can have special values in Solaris binaries. */
6555 switch (filedata
->file_header
.e_machine
)
6562 case EM_OLD_SPARCV9
:
6563 case EM_SPARC32PLUS
:
6566 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
6567 link_too_big
= "BEFORE";
6568 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
6569 link_too_big
= "AFTER";
6576 if (do_section_details
)
6578 if (link_too_big
!= NULL
&& * link_too_big
)
6579 printf ("<%s> ", link_too_big
);
6581 printf ("%2u ", section
->sh_link
);
6582 printf ("%3u %2lu\n", section
->sh_info
,
6583 (unsigned long) section
->sh_addralign
);
6586 printf ("%2u %3u %2lu\n",
6589 (unsigned long) section
->sh_addralign
);
6591 if (link_too_big
&& ! * link_too_big
)
6592 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6593 i
, section
->sh_link
);
6597 print_vma (section
->sh_addr
, LONG_HEX
);
6599 if ((long) section
->sh_offset
== section
->sh_offset
)
6600 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
6604 print_vma (section
->sh_offset
, LONG_HEX
);
6607 if ((unsigned long) section
->sh_size
== section
->sh_size
)
6608 printf (" %6.6lx", (unsigned long) section
->sh_size
);
6612 print_vma (section
->sh_size
, LONG_HEX
);
6615 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
6616 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
6620 print_vma (section
->sh_entsize
, LONG_HEX
);
6623 if (do_section_details
)
6624 fputs (" ", stdout
);
6626 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6628 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
6630 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
6631 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
6634 print_vma (section
->sh_addralign
, DEC
);
6638 else if (do_section_details
)
6641 print_vma (section
->sh_addr
, LONG_HEX
);
6642 if ((long) section
->sh_offset
== section
->sh_offset
)
6643 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
6647 print_vma (section
->sh_offset
, LONG_HEX
);
6649 printf (" %u\n ", section
->sh_link
);
6650 print_vma (section
->sh_size
, LONG_HEX
);
6652 print_vma (section
->sh_entsize
, LONG_HEX
);
6654 printf (" %-16u %lu\n",
6656 (unsigned long) section
->sh_addralign
);
6661 print_vma (section
->sh_addr
, LONG_HEX
);
6662 if ((long) section
->sh_offset
== section
->sh_offset
)
6663 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
6667 print_vma (section
->sh_offset
, LONG_HEX
);
6670 print_vma (section
->sh_size
, LONG_HEX
);
6672 print_vma (section
->sh_entsize
, LONG_HEX
);
6674 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6676 printf (" %2u %3u %lu\n",
6679 (unsigned long) section
->sh_addralign
);
6682 if (do_section_details
)
6684 printf (" %s\n", get_elf_section_flags (filedata
, section
->sh_flags
));
6685 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
6687 /* Minimum section size is 12 bytes for 32-bit compression
6688 header + 12 bytes for compressed data header. */
6689 unsigned char buf
[24];
6691 assert (sizeof (buf
) >= sizeof (Elf64_External_Chdr
));
6692 if (get_data (&buf
, filedata
, section
->sh_offset
, 1,
6693 sizeof (buf
), _("compression header")))
6695 Elf_Internal_Chdr chdr
;
6697 (void) get_compression_header (&chdr
, buf
, sizeof (buf
));
6699 if (chdr
.ch_type
== ELFCOMPRESS_ZLIB
)
6702 printf (_(" [<unknown>: 0x%x], "),
6704 print_vma (chdr
.ch_size
, LONG_HEX
);
6705 printf (", %lu\n", (unsigned long) chdr
.ch_addralign
);
6711 if (!do_section_details
)
6713 /* The ordering of the letters shown here matches the ordering of the
6714 corresponding SHF_xxx values, and hence the order in which these
6715 letters will be displayed to the user. */
6716 printf (_("Key to Flags:\n\
6717 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6718 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6719 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
6720 if (filedata
->file_header
.e_machine
== EM_X86_64
6721 || filedata
->file_header
.e_machine
== EM_L1OM
6722 || filedata
->file_header
.e_machine
== EM_K1OM
)
6723 printf (_("l (large), "));
6724 else if (filedata
->file_header
.e_machine
== EM_ARM
)
6725 printf (_("y (purecode), "));
6726 else if (filedata
->file_header
.e_machine
== EM_PPC
)
6727 printf (_("v (VLE), "));
6728 printf ("p (processor specific)\n");
6735 get_group_flags (unsigned int flags
)
6737 static char buff
[128];
6741 else if (flags
== GRP_COMDAT
)
6744 snprintf (buff
, 14, _("[0x%x: "), flags
);
6746 flags
&= ~ GRP_COMDAT
;
6747 if (flags
& GRP_MASKOS
)
6749 strcat (buff
, "<OS specific>");
6750 flags
&= ~ GRP_MASKOS
;
6753 if (flags
& GRP_MASKPROC
)
6755 strcat (buff
, "<PROC specific>");
6756 flags
&= ~ GRP_MASKPROC
;
6760 strcat (buff
, "<unknown>");
6767 process_section_groups (Filedata
* filedata
)
6769 Elf_Internal_Shdr
* section
;
6771 struct group
* group
;
6772 Elf_Internal_Shdr
* symtab_sec
;
6773 Elf_Internal_Shdr
* strtab_sec
;
6774 Elf_Internal_Sym
* symtab
;
6775 unsigned long num_syms
;
6779 /* Don't process section groups unless needed. */
6780 if (!do_unwind
&& !do_section_groups
)
6783 if (filedata
->file_header
.e_shnum
== 0)
6785 if (do_section_groups
)
6786 printf (_("\nThere are no sections to group in this file.\n"));
6791 if (filedata
->section_headers
== NULL
)
6793 error (_("Section headers are not available!\n"));
6794 /* PR 13622: This can happen with a corrupt ELF header. */
6798 section_headers_groups
= (struct group
**) calloc (filedata
->file_header
.e_shnum
,
6799 sizeof (struct group
*));
6801 if (section_headers_groups
== NULL
)
6803 error (_("Out of memory reading %u section group headers\n"),
6804 filedata
->file_header
.e_shnum
);
6808 /* Scan the sections for the group section. */
6810 for (i
= 0, section
= filedata
->section_headers
;
6811 i
< filedata
->file_header
.e_shnum
;
6813 if (section
->sh_type
== SHT_GROUP
)
6816 if (group_count
== 0)
6818 if (do_section_groups
)
6819 printf (_("\nThere are no section groups in this file.\n"));
6824 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
6826 if (section_groups
== NULL
)
6828 error (_("Out of memory reading %lu groups\n"),
6829 (unsigned long) group_count
);
6839 for (i
= 0, section
= filedata
->section_headers
, group
= section_groups
;
6840 i
< filedata
->file_header
.e_shnum
;
6843 if (section
->sh_type
== SHT_GROUP
)
6845 const char * name
= printable_section_name (filedata
, section
);
6846 const char * group_name
;
6847 unsigned char * start
;
6848 unsigned char * indices
;
6849 unsigned int entry
, j
, size
;
6850 Elf_Internal_Shdr
* sec
;
6851 Elf_Internal_Sym
* sym
;
6853 /* Get the symbol table. */
6854 if (section
->sh_link
>= filedata
->file_header
.e_shnum
6855 || ((sec
= filedata
->section_headers
+ section
->sh_link
)->sh_type
6858 error (_("Bad sh_link in group section `%s'\n"), name
);
6862 if (symtab_sec
!= sec
)
6867 symtab
= GET_ELF_SYMBOLS (filedata
, symtab_sec
, & num_syms
);
6872 error (_("Corrupt header in group section `%s'\n"), name
);
6876 if (section
->sh_info
>= num_syms
)
6878 error (_("Bad sh_info in group section `%s'\n"), name
);
6882 sym
= symtab
+ section
->sh_info
;
6884 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
6886 if (sym
->st_shndx
== 0
6887 || sym
->st_shndx
>= filedata
->file_header
.e_shnum
)
6889 error (_("Bad sh_info in group section `%s'\n"), name
);
6893 group_name
= SECTION_NAME (filedata
->section_headers
+ sym
->st_shndx
);
6902 /* Get the string table. */
6903 if (symtab_sec
->sh_link
>= filedata
->file_header
.e_shnum
)
6912 != (sec
= filedata
->section_headers
+ symtab_sec
->sh_link
))
6918 strtab
= (char *) get_data (NULL
, filedata
, strtab_sec
->sh_offset
,
6919 1, strtab_sec
->sh_size
,
6921 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
6923 group_name
= sym
->st_name
< strtab_size
6924 ? strtab
+ sym
->st_name
: _("<corrupt>");
6927 /* PR 17531: file: loop. */
6928 if (section
->sh_entsize
> section
->sh_size
)
6930 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6931 printable_section_name (filedata
, section
),
6932 (unsigned long) section
->sh_entsize
,
6933 (unsigned long) section
->sh_size
);
6937 start
= (unsigned char *) get_data (NULL
, filedata
, section
->sh_offset
,
6938 1, section
->sh_size
,
6944 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
6945 entry
= byte_get (indices
, 4);
6948 if (do_section_groups
)
6950 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6951 get_group_flags (entry
), i
, name
, group_name
, size
);
6953 printf (_(" [Index] Name\n"));
6956 group
->group_index
= i
;
6958 for (j
= 0; j
< size
; j
++)
6960 struct group_list
* g
;
6962 entry
= byte_get (indices
, 4);
6965 if (entry
>= filedata
->file_header
.e_shnum
)
6967 static unsigned num_group_errors
= 0;
6969 if (num_group_errors
++ < 10)
6971 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6972 entry
, i
, filedata
->file_header
.e_shnum
- 1);
6973 if (num_group_errors
== 10)
6974 warn (_("Further error messages about overlarge group section indices suppressed\n"));
6979 if (section_headers_groups
[entry
] != NULL
)
6983 static unsigned num_errs
= 0;
6985 if (num_errs
++ < 10)
6987 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6989 section_headers_groups
[entry
]->group_index
);
6991 warn (_("Further error messages about already contained group sections suppressed\n"));
6997 /* Intel C/C++ compiler may put section 0 in a
6998 section group. We just warn it the first time
6999 and ignore it afterwards. */
7000 static bfd_boolean warned
= FALSE
;
7003 error (_("section 0 in group section [%5u]\n"),
7004 section_headers_groups
[entry
]->group_index
);
7010 section_headers_groups
[entry
] = group
;
7012 if (do_section_groups
)
7014 sec
= filedata
->section_headers
+ entry
;
7015 printf (" [%5u] %s\n", entry
, printable_section_name (filedata
, sec
));
7018 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
7019 g
->section_index
= entry
;
7020 g
->next
= group
->root
;
7038 /* Data used to display dynamic fixups. */
7040 struct ia64_vms_dynfixup
7042 bfd_vma needed_ident
; /* Library ident number. */
7043 bfd_vma needed
; /* Index in the dstrtab of the library name. */
7044 bfd_vma fixup_needed
; /* Index of the library. */
7045 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
7046 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
7049 /* Data used to display dynamic relocations. */
7051 struct ia64_vms_dynimgrela
7053 bfd_vma img_rela_cnt
; /* Number of relocations. */
7054 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
7057 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
7061 dump_ia64_vms_dynamic_fixups (Filedata
* filedata
,
7062 struct ia64_vms_dynfixup
* fixup
,
7063 const char * strtab
,
7064 unsigned int strtab_sz
)
7066 Elf64_External_VMS_IMAGE_FIXUP
* imfs
;
7068 const char * lib_name
;
7070 imfs
= get_data (NULL
, filedata
, dynamic_addr
+ fixup
->fixup_rela_off
,
7071 1, fixup
->fixup_rela_cnt
* sizeof (*imfs
),
7072 _("dynamic section image fixups"));
7076 if (fixup
->needed
< strtab_sz
)
7077 lib_name
= strtab
+ fixup
->needed
;
7080 warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
7081 (unsigned long) fixup
->needed
);
7084 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
7085 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
7087 (_("Seg Offset Type SymVec DataType\n"));
7089 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
7094 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
7095 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
7096 type
= BYTE_GET (imfs
[i
].type
);
7097 rtype
= elf_ia64_reloc_type (type
);
7099 printf (" 0x%08x ", type
);
7101 printf (" %-32s ", rtype
);
7102 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
7103 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
7110 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
7113 dump_ia64_vms_dynamic_relocs (Filedata
* filedata
, struct ia64_vms_dynimgrela
*imgrela
)
7115 Elf64_External_VMS_IMAGE_RELA
*imrs
;
7118 imrs
= get_data (NULL
, filedata
, dynamic_addr
+ imgrela
->img_rela_off
,
7119 1, imgrela
->img_rela_cnt
* sizeof (*imrs
),
7120 _("dynamic section image relocations"));
7124 printf (_("\nImage relocs\n"));
7126 (_("Seg Offset Type Addend Seg Sym Off\n"));
7128 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
7133 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
7134 printf ("%08" BFD_VMA_FMT
"x ",
7135 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
7136 type
= BYTE_GET (imrs
[i
].type
);
7137 rtype
= elf_ia64_reloc_type (type
);
7139 printf ("0x%08x ", type
);
7141 printf ("%-31s ", rtype
);
7142 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
7143 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
7144 printf ("%08" BFD_VMA_FMT
"x\n",
7145 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
7152 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
7155 process_ia64_vms_dynamic_relocs (Filedata
* filedata
)
7157 struct ia64_vms_dynfixup fixup
;
7158 struct ia64_vms_dynimgrela imgrela
;
7159 Elf_Internal_Dyn
*entry
;
7160 bfd_vma strtab_off
= 0;
7161 bfd_vma strtab_sz
= 0;
7162 char *strtab
= NULL
;
7163 bfd_boolean res
= TRUE
;
7165 memset (&fixup
, 0, sizeof (fixup
));
7166 memset (&imgrela
, 0, sizeof (imgrela
));
7168 /* Note: the order of the entries is specified by the OpenVMS specs. */
7169 for (entry
= dynamic_section
;
7170 entry
< dynamic_section
+ dynamic_nent
;
7173 switch (entry
->d_tag
)
7175 case DT_IA_64_VMS_STRTAB_OFFSET
:
7176 strtab_off
= entry
->d_un
.d_val
;
7179 strtab_sz
= entry
->d_un
.d_val
;
7181 strtab
= get_data (NULL
, filedata
, dynamic_addr
+ strtab_off
,
7182 1, strtab_sz
, _("dynamic string section"));
7185 case DT_IA_64_VMS_NEEDED_IDENT
:
7186 fixup
.needed_ident
= entry
->d_un
.d_val
;
7189 fixup
.needed
= entry
->d_un
.d_val
;
7191 case DT_IA_64_VMS_FIXUP_NEEDED
:
7192 fixup
.fixup_needed
= entry
->d_un
.d_val
;
7194 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
7195 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
7197 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
7198 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
7199 if (! dump_ia64_vms_dynamic_fixups (filedata
, &fixup
, strtab
, strtab_sz
))
7202 case DT_IA_64_VMS_IMG_RELA_CNT
:
7203 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
7205 case DT_IA_64_VMS_IMG_RELA_OFF
:
7206 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
7207 if (! dump_ia64_vms_dynamic_relocs (filedata
, &imgrela
))
7229 dynamic_relocations
[] =
7231 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
7232 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
7233 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
7236 /* Process the reloc section. */
7239 process_relocs (Filedata
* filedata
)
7241 unsigned long rel_size
;
7242 unsigned long rel_offset
;
7247 if (do_using_dynamic
)
7251 bfd_boolean has_dynamic_reloc
;
7254 has_dynamic_reloc
= FALSE
;
7256 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7258 is_rela
= dynamic_relocations
[i
].rela
;
7259 name
= dynamic_relocations
[i
].name
;
7260 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
7261 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
7264 has_dynamic_reloc
= TRUE
;
7266 if (is_rela
== UNKNOWN
)
7268 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
7269 switch (dynamic_info
[DT_PLTREL
])
7283 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7284 name
, rel_offset
, rel_size
);
7286 dump_relocations (filedata
,
7287 offset_from_vma (filedata
, rel_offset
, rel_size
),
7289 dynamic_symbols
, num_dynamic_syms
,
7290 dynamic_strings
, dynamic_strings_length
,
7291 is_rela
, TRUE
/* is_dynamic */);
7295 if (is_ia64_vms (filedata
))
7296 if (process_ia64_vms_dynamic_relocs (filedata
))
7297 has_dynamic_reloc
= TRUE
;
7299 if (! has_dynamic_reloc
)
7300 printf (_("\nThere are no dynamic relocations in this file.\n"));
7304 Elf_Internal_Shdr
* section
;
7306 bfd_boolean found
= FALSE
;
7308 for (i
= 0, section
= filedata
->section_headers
;
7309 i
< filedata
->file_header
.e_shnum
;
7312 if ( section
->sh_type
!= SHT_RELA
7313 && section
->sh_type
!= SHT_REL
)
7316 rel_offset
= section
->sh_offset
;
7317 rel_size
= section
->sh_size
;
7321 Elf_Internal_Shdr
* strsec
;
7323 unsigned long num_rela
;
7325 printf (_("\nRelocation section "));
7327 if (filedata
->string_table
== NULL
)
7328 printf ("%d", section
->sh_name
);
7330 printf ("'%s'", printable_section_name (filedata
, section
));
7332 num_rela
= rel_size
/ section
->sh_entsize
;
7333 printf (ngettext (" at offset 0x%lx contains %lu entry:\n",
7334 " at offset 0x%lx contains %lu entries:\n",
7336 rel_offset
, num_rela
);
7338 is_rela
= section
->sh_type
== SHT_RELA
;
7340 if (section
->sh_link
!= 0
7341 && section
->sh_link
< filedata
->file_header
.e_shnum
)
7343 Elf_Internal_Shdr
* symsec
;
7344 Elf_Internal_Sym
* symtab
;
7345 unsigned long nsyms
;
7346 unsigned long strtablen
= 0;
7347 char * strtab
= NULL
;
7349 symsec
= filedata
->section_headers
+ section
->sh_link
;
7350 if (symsec
->sh_type
!= SHT_SYMTAB
7351 && symsec
->sh_type
!= SHT_DYNSYM
)
7354 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & nsyms
);
7359 if (symsec
->sh_link
!= 0
7360 && symsec
->sh_link
< filedata
->file_header
.e_shnum
)
7362 strsec
= filedata
->section_headers
+ symsec
->sh_link
;
7364 strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
7367 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
7370 dump_relocations (filedata
, rel_offset
, rel_size
,
7371 symtab
, nsyms
, strtab
, strtablen
,
7373 symsec
->sh_type
== SHT_DYNSYM
);
7379 dump_relocations (filedata
, rel_offset
, rel_size
,
7380 NULL
, 0, NULL
, 0, is_rela
,
7381 FALSE
/* is_dynamic */);
7389 /* Users sometimes forget the -D option, so try to be helpful. */
7390 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7392 if (dynamic_info
[dynamic_relocations
[i
].size
])
7394 printf (_("\nThere are no static relocations in this file."));
7395 printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
7400 if (i
== ARRAY_SIZE (dynamic_relocations
))
7401 printf (_("\nThere are no relocations in this file.\n"));
7408 /* An absolute address consists of a section and an offset. If the
7409 section is NULL, the offset itself is the address, otherwise, the
7410 address equals to LOAD_ADDRESS(section) + offset. */
7414 unsigned short section
;
7418 #define ABSADDR(a) \
7420 ? filedata->section_headers [(a).section].sh_addr + (a).offset \
7423 /* Find the nearest symbol at or below ADDR. Returns the symbol
7424 name, if found, and the offset from the symbol to ADDR. */
7427 find_symbol_for_address (Filedata
* filedata
,
7428 Elf_Internal_Sym
* symtab
,
7429 unsigned long nsyms
,
7430 const char * strtab
,
7431 unsigned long strtab_size
,
7432 struct absaddr addr
,
7433 const char ** symname
,
7436 bfd_vma dist
= 0x100000;
7437 Elf_Internal_Sym
* sym
;
7438 Elf_Internal_Sym
* beg
;
7439 Elf_Internal_Sym
* end
;
7440 Elf_Internal_Sym
* best
= NULL
;
7442 REMOVE_ARCH_BITS (addr
.offset
);
7444 end
= symtab
+ nsyms
;
7450 sym
= beg
+ (end
- beg
) / 2;
7452 value
= sym
->st_value
;
7453 REMOVE_ARCH_BITS (value
);
7455 if (sym
->st_name
!= 0
7456 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
7457 && addr
.offset
>= value
7458 && addr
.offset
- value
< dist
)
7461 dist
= addr
.offset
- value
;
7466 if (addr
.offset
< value
)
7474 *symname
= (best
->st_name
>= strtab_size
7475 ? _("<corrupt>") : strtab
+ best
->st_name
);
7481 *offset
= addr
.offset
;
7484 static /* signed */ int
7485 symcmp (const void *p
, const void *q
)
7487 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
7488 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
7490 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
7493 /* Process the unwind section. */
7495 #include "unwind-ia64.h"
7497 struct ia64_unw_table_entry
7499 struct absaddr start
;
7501 struct absaddr info
;
7504 struct ia64_unw_aux_info
7506 struct ia64_unw_table_entry
* table
; /* Unwind table. */
7507 unsigned long table_len
; /* Length of unwind table. */
7508 unsigned char * info
; /* Unwind info. */
7509 unsigned long info_size
; /* Size of unwind info. */
7510 bfd_vma info_addr
; /* Starting address of unwind info. */
7511 bfd_vma seg_base
; /* Starting address of segment. */
7512 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7513 unsigned long nsyms
; /* Number of symbols. */
7514 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7515 unsigned long nfuns
; /* Number of entries in funtab. */
7516 char * strtab
; /* The string table. */
7517 unsigned long strtab_size
; /* Size of string table. */
7521 dump_ia64_unwind (Filedata
* filedata
, struct ia64_unw_aux_info
* aux
)
7523 struct ia64_unw_table_entry
* tp
;
7524 unsigned long j
, nfuns
;
7526 bfd_boolean res
= TRUE
;
7528 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7529 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7530 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7531 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7533 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7535 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7539 const unsigned char * dp
;
7540 const unsigned char * head
;
7541 const unsigned char * end
;
7542 const char * procname
;
7544 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7545 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
7547 fputs ("\n<", stdout
);
7551 fputs (procname
, stdout
);
7554 printf ("+%lx", (unsigned long) offset
);
7557 fputs (">: [", stdout
);
7558 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7559 fputc ('-', stdout
);
7560 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7561 printf ("], info at +0x%lx\n",
7562 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
7564 /* PR 17531: file: 86232b32. */
7565 if (aux
->info
== NULL
)
7568 /* PR 17531: file: 0997b4d1. */
7569 if ((ABSADDR (tp
->info
) - aux
->info_addr
) >= aux
->info_size
)
7571 warn (_("Invalid offset %lx in table entry %ld\n"),
7572 (long) tp
->info
.offset
, (long) (tp
- aux
->table
));
7577 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
7578 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
7580 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7581 (unsigned) UNW_VER (stamp
),
7582 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
7583 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
7584 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
7585 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
7587 if (UNW_VER (stamp
) != 1)
7589 printf (_("\tUnknown version.\n"));
7594 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
7595 /* PR 17531: file: 16ceda89. */
7596 if (end
> aux
->info
+ aux
->info_size
)
7597 end
= aux
->info
+ aux
->info_size
;
7598 for (dp
= head
+ 8; dp
< end
;)
7599 dp
= unw_decode (dp
, in_body
, & in_body
, end
);
7608 slurp_ia64_unwind_table (Filedata
* filedata
,
7609 struct ia64_unw_aux_info
* aux
,
7610 Elf_Internal_Shdr
* sec
)
7612 unsigned long size
, nrelas
, i
;
7613 Elf_Internal_Phdr
* seg
;
7614 struct ia64_unw_table_entry
* tep
;
7615 Elf_Internal_Shdr
* relsec
;
7616 Elf_Internal_Rela
* rela
;
7617 Elf_Internal_Rela
* rp
;
7618 unsigned char * table
;
7620 Elf_Internal_Sym
* sym
;
7621 const char * relname
;
7625 /* First, find the starting address of the segment that includes
7628 if (filedata
->file_header
.e_phnum
)
7630 if (! get_program_headers (filedata
))
7633 for (seg
= filedata
->program_headers
;
7634 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
7637 if (seg
->p_type
!= PT_LOAD
)
7640 if (sec
->sh_addr
>= seg
->p_vaddr
7641 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7643 aux
->seg_base
= seg
->p_vaddr
;
7649 /* Second, build the unwind table from the contents of the unwind section: */
7650 size
= sec
->sh_size
;
7651 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
7656 aux
->table_len
= size
/ (3 * eh_addr_size
);
7657 aux
->table
= (struct ia64_unw_table_entry
*)
7658 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
7661 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
7663 tep
->start
.section
= SHN_UNDEF
;
7664 tep
->end
.section
= SHN_UNDEF
;
7665 tep
->info
.section
= SHN_UNDEF
;
7666 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7667 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7668 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7669 tep
->start
.offset
+= aux
->seg_base
;
7670 tep
->end
.offset
+= aux
->seg_base
;
7671 tep
->info
.offset
+= aux
->seg_base
;
7675 /* Third, apply any relocations to the unwind table: */
7676 for (relsec
= filedata
->section_headers
;
7677 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
7680 if (relsec
->sh_type
!= SHT_RELA
7681 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
7682 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
7685 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
7694 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7696 unsigned int sym_ndx
;
7697 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
7698 relname
= elf_ia64_reloc_type (r_type
);
7700 /* PR 17531: file: 9fa67536. */
7701 if (relname
== NULL
)
7703 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
7707 if (! const_strneq (relname
, "R_IA64_SEGREL"))
7709 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
7713 i
= rp
->r_offset
/ (3 * eh_addr_size
);
7715 /* PR 17531: file: 5bc8d9bf. */
7716 if (i
>= aux
->table_len
)
7718 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
7722 sym_ndx
= get_reloc_symindex (rp
->r_info
);
7723 if (sym_ndx
>= aux
->nsyms
)
7725 warn (_("Skipping reloc with invalid symbol index: %u\n"),
7729 sym
= aux
->symtab
+ sym_ndx
;
7731 switch (rp
->r_offset
/ eh_addr_size
% 3)
7734 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7735 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
7738 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7739 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
7742 aux
->table
[i
].info
.section
= sym
->st_shndx
;
7743 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
7757 ia64_process_unwind (Filedata
* filedata
)
7759 Elf_Internal_Shdr
* sec
;
7760 Elf_Internal_Shdr
* unwsec
= NULL
;
7761 Elf_Internal_Shdr
* strsec
;
7762 unsigned long i
, unwcount
= 0, unwstart
= 0;
7763 struct ia64_unw_aux_info aux
;
7764 bfd_boolean res
= TRUE
;
7766 memset (& aux
, 0, sizeof (aux
));
7768 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
7770 if (sec
->sh_type
== SHT_SYMTAB
7771 && sec
->sh_link
< filedata
->file_header
.e_shnum
)
7773 aux
.symtab
= GET_ELF_SYMBOLS (filedata
, sec
, & aux
.nsyms
);
7775 strsec
= filedata
->section_headers
+ sec
->sh_link
;
7776 if (aux
.strtab
!= NULL
)
7778 error (_("Multiple auxillary string tables encountered\n"));
7782 aux
.strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
7785 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7787 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7792 printf (_("\nThere are no unwind sections in this file.\n"));
7794 while (unwcount
-- > 0)
7799 for (i
= unwstart
, sec
= filedata
->section_headers
+ unwstart
, unwsec
= NULL
;
7800 i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
7801 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7806 /* We have already counted the number of SHT_IA64_UNWIND
7807 sections so the loop above should never fail. */
7808 assert (unwsec
!= NULL
);
7811 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
7813 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
7815 /* We need to find which section group it is in. */
7816 struct group_list
* g
;
7818 if (section_headers_groups
== NULL
7819 || section_headers_groups
[i
] == NULL
)
7820 i
= filedata
->file_header
.e_shnum
;
7823 g
= section_headers_groups
[i
]->root
;
7825 for (; g
!= NULL
; g
= g
->next
)
7827 sec
= filedata
->section_headers
+ g
->section_index
;
7829 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
7834 i
= filedata
->file_header
.e_shnum
;
7837 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
7839 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
7840 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
7841 suffix
= SECTION_NAME (unwsec
) + len
;
7842 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
;
7844 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
7845 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7850 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7851 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
7852 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
7853 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
7855 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
7856 suffix
= SECTION_NAME (unwsec
) + len
;
7857 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
;
7859 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
7860 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7864 if (i
== filedata
->file_header
.e_shnum
)
7866 printf (_("\nCould not find unwind info section for "));
7868 if (filedata
->string_table
== NULL
)
7869 printf ("%d", unwsec
->sh_name
);
7871 printf ("'%s'", printable_section_name (filedata
, unwsec
));
7875 aux
.info_addr
= sec
->sh_addr
;
7876 aux
.info
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1,
7879 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
7881 printf (_("\nUnwind section "));
7883 if (filedata
->string_table
== NULL
)
7884 printf ("%d", unwsec
->sh_name
);
7886 printf ("'%s'", printable_section_name (filedata
, unwsec
));
7888 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7889 (unsigned long) unwsec
->sh_offset
,
7890 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
7892 if (slurp_ia64_unwind_table (filedata
, & aux
, unwsec
)
7893 && aux
.table_len
> 0)
7894 dump_ia64_unwind (filedata
, & aux
);
7897 free ((char *) aux
.table
);
7899 free ((char *) aux
.info
);
7908 free ((char *) aux
.strtab
);
7913 struct hppa_unw_table_entry
7915 struct absaddr start
;
7917 unsigned int Cannot_unwind
:1; /* 0 */
7918 unsigned int Millicode
:1; /* 1 */
7919 unsigned int Millicode_save_sr0
:1; /* 2 */
7920 unsigned int Region_description
:2; /* 3..4 */
7921 unsigned int reserved1
:1; /* 5 */
7922 unsigned int Entry_SR
:1; /* 6 */
7923 unsigned int Entry_FR
:4; /* Number saved 7..10 */
7924 unsigned int Entry_GR
:5; /* Number saved 11..15 */
7925 unsigned int Args_stored
:1; /* 16 */
7926 unsigned int Variable_Frame
:1; /* 17 */
7927 unsigned int Separate_Package_Body
:1; /* 18 */
7928 unsigned int Frame_Extension_Millicode
:1; /* 19 */
7929 unsigned int Stack_Overflow_Check
:1; /* 20 */
7930 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
7931 unsigned int Ada_Region
:1; /* 22 */
7932 unsigned int cxx_info
:1; /* 23 */
7933 unsigned int cxx_try_catch
:1; /* 24 */
7934 unsigned int sched_entry_seq
:1; /* 25 */
7935 unsigned int reserved2
:1; /* 26 */
7936 unsigned int Save_SP
:1; /* 27 */
7937 unsigned int Save_RP
:1; /* 28 */
7938 unsigned int Save_MRP_in_frame
:1; /* 29 */
7939 unsigned int extn_ptr_defined
:1; /* 30 */
7940 unsigned int Cleanup_defined
:1; /* 31 */
7942 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
7943 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
7944 unsigned int Large_frame
:1; /* 2 */
7945 unsigned int Pseudo_SP_Set
:1; /* 3 */
7946 unsigned int reserved4
:1; /* 4 */
7947 unsigned int Total_frame_size
:27; /* 5..31 */
7950 struct hppa_unw_aux_info
7952 struct hppa_unw_table_entry
* table
; /* Unwind table. */
7953 unsigned long table_len
; /* Length of unwind table. */
7954 bfd_vma seg_base
; /* Starting address of segment. */
7955 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7956 unsigned long nsyms
; /* Number of symbols. */
7957 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7958 unsigned long nfuns
; /* Number of entries in funtab. */
7959 char * strtab
; /* The string table. */
7960 unsigned long strtab_size
; /* Size of string table. */
7964 dump_hppa_unwind (Filedata
* filedata
, struct hppa_unw_aux_info
* aux
)
7966 struct hppa_unw_table_entry
* tp
;
7967 unsigned long j
, nfuns
;
7968 bfd_boolean res
= TRUE
;
7970 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7971 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7972 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7973 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7975 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7977 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7980 const char * procname
;
7982 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7983 aux
->strtab_size
, tp
->start
, &procname
,
7986 fputs ("\n<", stdout
);
7990 fputs (procname
, stdout
);
7993 printf ("+%lx", (unsigned long) offset
);
7996 fputs (">: [", stdout
);
7997 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7998 fputc ('-', stdout
);
7999 print_vma (tp
->end
.offset
, PREFIX_HEX
);
8002 #define PF(_m) if (tp->_m) printf (#_m " ");
8003 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
8006 PF(Millicode_save_sr0
);
8007 /* PV(Region_description); */
8013 PF(Separate_Package_Body
);
8014 PF(Frame_Extension_Millicode
);
8015 PF(Stack_Overflow_Check
);
8016 PF(Two_Instruction_SP_Increment
);
8020 PF(sched_entry_seq
);
8023 PF(Save_MRP_in_frame
);
8024 PF(extn_ptr_defined
);
8025 PF(Cleanup_defined
);
8026 PF(MPE_XL_interrupt_marker
);
8027 PF(HP_UX_interrupt_marker
);
8030 PV(Total_frame_size
);
8043 slurp_hppa_unwind_table (Filedata
* filedata
,
8044 struct hppa_unw_aux_info
* aux
,
8045 Elf_Internal_Shdr
* sec
)
8047 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
8048 Elf_Internal_Phdr
* seg
;
8049 struct hppa_unw_table_entry
* tep
;
8050 Elf_Internal_Shdr
* relsec
;
8051 Elf_Internal_Rela
* rela
;
8052 Elf_Internal_Rela
* rp
;
8053 unsigned char * table
;
8055 Elf_Internal_Sym
* sym
;
8056 const char * relname
;
8058 /* First, find the starting address of the segment that includes
8060 if (filedata
->file_header
.e_phnum
)
8062 if (! get_program_headers (filedata
))
8065 for (seg
= filedata
->program_headers
;
8066 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
8069 if (seg
->p_type
!= PT_LOAD
)
8072 if (sec
->sh_addr
>= seg
->p_vaddr
8073 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
8075 aux
->seg_base
= seg
->p_vaddr
;
8081 /* Second, build the unwind table from the contents of the unwind
8083 size
= sec
->sh_size
;
8084 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
8090 nentries
= size
/ unw_ent_size
;
8091 size
= unw_ent_size
* nentries
;
8093 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
8094 xcmalloc (nentries
, sizeof (aux
->table
[0]));
8096 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
8098 unsigned int tmp1
, tmp2
;
8100 tep
->start
.section
= SHN_UNDEF
;
8101 tep
->end
.section
= SHN_UNDEF
;
8103 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
8104 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
8105 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
8106 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
8108 tep
->start
.offset
+= aux
->seg_base
;
8109 tep
->end
.offset
+= aux
->seg_base
;
8111 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
8112 tep
->Millicode
= (tmp1
>> 30) & 0x1;
8113 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
8114 tep
->Region_description
= (tmp1
>> 27) & 0x3;
8115 tep
->reserved1
= (tmp1
>> 26) & 0x1;
8116 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
8117 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
8118 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
8119 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
8120 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
8121 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
8122 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
8123 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
8124 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
8125 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
8126 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
8127 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
8128 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
8129 tep
->reserved2
= (tmp1
>> 5) & 0x1;
8130 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
8131 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
8132 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
8133 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
8134 tep
->Cleanup_defined
= tmp1
& 0x1;
8136 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
8137 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
8138 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
8139 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
8140 tep
->reserved4
= (tmp2
>> 27) & 0x1;
8141 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
8145 /* Third, apply any relocations to the unwind table. */
8146 for (relsec
= filedata
->section_headers
;
8147 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8150 if (relsec
->sh_type
!= SHT_RELA
8151 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
8152 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
8155 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
8159 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
8161 unsigned int sym_ndx
;
8162 unsigned int r_type
= get_reloc_type (filedata
, rp
->r_info
);
8163 relname
= elf_hppa_reloc_type (r_type
);
8165 if (relname
== NULL
)
8167 warn (_("Skipping unknown relocation type: %u\n"), r_type
);
8171 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
8172 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
8174 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
8178 i
= rp
->r_offset
/ unw_ent_size
;
8179 if (i
>= aux
->table_len
)
8181 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
8185 sym_ndx
= get_reloc_symindex (rp
->r_info
);
8186 if (sym_ndx
>= aux
->nsyms
)
8188 warn (_("Skipping reloc with invalid symbol index: %u\n"),
8192 sym
= aux
->symtab
+ sym_ndx
;
8194 switch ((rp
->r_offset
% unw_ent_size
) / 4)
8197 aux
->table
[i
].start
.section
= sym
->st_shndx
;
8198 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
8201 aux
->table
[i
].end
.section
= sym
->st_shndx
;
8202 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
8212 aux
->table_len
= nentries
;
8218 hppa_process_unwind (Filedata
* filedata
)
8220 struct hppa_unw_aux_info aux
;
8221 Elf_Internal_Shdr
* unwsec
= NULL
;
8222 Elf_Internal_Shdr
* strsec
;
8223 Elf_Internal_Shdr
* sec
;
8225 bfd_boolean res
= TRUE
;
8227 if (filedata
->string_table
== NULL
)
8230 memset (& aux
, 0, sizeof (aux
));
8232 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8234 if (sec
->sh_type
== SHT_SYMTAB
8235 && sec
->sh_link
< filedata
->file_header
.e_shnum
)
8237 aux
.symtab
= GET_ELF_SYMBOLS (filedata
, sec
, & aux
.nsyms
);
8239 strsec
= filedata
->section_headers
+ sec
->sh_link
;
8240 if (aux
.strtab
!= NULL
)
8242 error (_("Multiple auxillary string tables encountered\n"));
8246 aux
.strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
8249 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
8251 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8256 printf (_("\nThere are no unwind sections in this file.\n"));
8258 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8260 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8262 unsigned long num_unwind
= sec
->sh_size
/ 16;
8264 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
8265 "contains %lu entry:\n",
8266 "\nUnwind section '%s' at offset 0x%lx "
8267 "contains %lu entries:\n",
8269 printable_section_name (filedata
, sec
),
8270 (unsigned long) sec
->sh_offset
,
8273 if (! slurp_hppa_unwind_table (filedata
, &aux
, sec
))
8276 if (res
&& aux
.table_len
> 0)
8278 if (! dump_hppa_unwind (filedata
, &aux
))
8283 free ((char *) aux
.table
);
8291 free ((char *) aux
.strtab
);
8298 unsigned char * data
; /* The unwind data. */
8299 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
8300 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
8301 unsigned long nrelas
; /* The number of relocations. */
8302 unsigned int rel_type
; /* REL or RELA ? */
8303 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
8306 struct arm_unw_aux_info
8308 Filedata
* filedata
; /* The file containing the unwind sections. */
8309 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
8310 unsigned long nsyms
; /* Number of symbols. */
8311 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8312 unsigned long nfuns
; /* Number of these symbols. */
8313 char * strtab
; /* The file's string table. */
8314 unsigned long strtab_size
; /* Size of string table. */
8318 arm_print_vma_and_name (Filedata
* filedata
,
8319 struct arm_unw_aux_info
* aux
,
8321 struct absaddr addr
)
8323 const char *procname
;
8326 if (addr
.section
== SHN_UNDEF
)
8329 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8330 aux
->strtab_size
, addr
, &procname
,
8333 print_vma (fn
, PREFIX_HEX
);
8337 fputs (" <", stdout
);
8338 fputs (procname
, stdout
);
8341 printf ("+0x%lx", (unsigned long) sym_offset
);
8342 fputc ('>', stdout
);
8349 arm_free_section (struct arm_section
*arm_sec
)
8351 if (arm_sec
->data
!= NULL
)
8352 free (arm_sec
->data
);
8354 if (arm_sec
->rela
!= NULL
)
8355 free (arm_sec
->rela
);
8358 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8359 cached section and install SEC instead.
8360 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8361 and return its valued in * WORDP, relocating if necessary.
8362 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8363 relocation's offset in ADDR.
8364 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8365 into the string table of the symbol associated with the reloc. If no
8366 reloc was applied store -1 there.
8367 5) Return TRUE upon success, FALSE otherwise. */
8370 get_unwind_section_word (Filedata
* filedata
,
8371 struct arm_unw_aux_info
* aux
,
8372 struct arm_section
* arm_sec
,
8373 Elf_Internal_Shdr
* sec
,
8374 bfd_vma word_offset
,
8375 unsigned int * wordp
,
8376 struct absaddr
* addr
,
8379 Elf_Internal_Rela
*rp
;
8380 Elf_Internal_Sym
*sym
;
8381 const char * relname
;
8383 bfd_boolean wrapped
;
8385 if (sec
== NULL
|| arm_sec
== NULL
)
8388 addr
->section
= SHN_UNDEF
;
8391 if (sym_name
!= NULL
)
8392 *sym_name
= (bfd_vma
) -1;
8394 /* If necessary, update the section cache. */
8395 if (sec
!= arm_sec
->sec
)
8397 Elf_Internal_Shdr
*relsec
;
8399 arm_free_section (arm_sec
);
8402 arm_sec
->data
= get_data (NULL
, aux
->filedata
, sec
->sh_offset
, 1,
8403 sec
->sh_size
, _("unwind data"));
8404 arm_sec
->rela
= NULL
;
8405 arm_sec
->nrelas
= 0;
8407 for (relsec
= filedata
->section_headers
;
8408 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8411 if (relsec
->sh_info
>= filedata
->file_header
.e_shnum
8412 || filedata
->section_headers
+ relsec
->sh_info
!= sec
8413 /* PR 15745: Check the section type as well. */
8414 || (relsec
->sh_type
!= SHT_REL
8415 && relsec
->sh_type
!= SHT_RELA
))
8418 arm_sec
->rel_type
= relsec
->sh_type
;
8419 if (relsec
->sh_type
== SHT_REL
)
8421 if (!slurp_rel_relocs (aux
->filedata
, relsec
->sh_offset
,
8423 & arm_sec
->rela
, & arm_sec
->nrelas
))
8426 else /* relsec->sh_type == SHT_RELA */
8428 if (!slurp_rela_relocs (aux
->filedata
, relsec
->sh_offset
,
8430 & arm_sec
->rela
, & arm_sec
->nrelas
))
8436 arm_sec
->next_rela
= arm_sec
->rela
;
8439 /* If there is no unwind data we can do nothing. */
8440 if (arm_sec
->data
== NULL
)
8443 /* If the offset is invalid then fail. */
8444 if (/* PR 21343 *//* PR 18879 */
8446 || word_offset
> (sec
->sh_size
- 4)
8447 || ((bfd_signed_vma
) word_offset
) < 0)
8450 /* Get the word at the required offset. */
8451 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
8453 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
8454 if (arm_sec
->rela
== NULL
)
8460 /* Look through the relocs to find the one that applies to the provided offset. */
8462 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
8464 bfd_vma prelval
, offset
;
8466 if (rp
->r_offset
> word_offset
&& !wrapped
)
8471 if (rp
->r_offset
> word_offset
)
8474 if (rp
->r_offset
& 3)
8476 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8477 (unsigned long) rp
->r_offset
);
8481 if (rp
->r_offset
< word_offset
)
8484 /* PR 17531: file: 027-161405-0.004 */
8485 if (aux
->symtab
== NULL
)
8488 if (arm_sec
->rel_type
== SHT_REL
)
8490 offset
= word
& 0x7fffffff;
8491 if (offset
& 0x40000000)
8492 offset
|= ~ (bfd_vma
) 0x7fffffff;
8494 else if (arm_sec
->rel_type
== SHT_RELA
)
8495 offset
= rp
->r_addend
;
8498 error (_("Unknown section relocation type %d encountered\n"),
8503 /* PR 17531 file: 027-1241568-0.004. */
8504 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
8506 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8507 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
8511 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
8512 offset
+= sym
->st_value
;
8513 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
8515 /* Check that we are processing the expected reloc type. */
8516 if (filedata
->file_header
.e_machine
== EM_ARM
)
8518 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8519 if (relname
== NULL
)
8521 warn (_("Skipping unknown ARM relocation type: %d\n"),
8522 (int) ELF32_R_TYPE (rp
->r_info
));
8526 if (streq (relname
, "R_ARM_NONE"))
8529 if (! streq (relname
, "R_ARM_PREL31"))
8531 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
8535 else if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
8537 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8538 if (relname
== NULL
)
8540 warn (_("Skipping unknown C6000 relocation type: %d\n"),
8541 (int) ELF32_R_TYPE (rp
->r_info
));
8545 if (streq (relname
, "R_C6000_NONE"))
8548 if (! streq (relname
, "R_C6000_PREL31"))
8550 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
8558 /* This function currently only supports ARM and TI unwinders. */
8559 warn (_("Only TI and ARM unwinders are currently supported\n"));
8563 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
8564 addr
->section
= sym
->st_shndx
;
8565 addr
->offset
= offset
;
8568 * sym_name
= sym
->st_name
;
8573 arm_sec
->next_rela
= rp
;
8578 static const char *tic6x_unwind_regnames
[16] =
8580 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8581 "A14", "A13", "A12", "A11", "A10",
8582 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8586 decode_tic6x_unwind_regmask (unsigned int mask
)
8590 for (i
= 12; mask
; mask
>>= 1, i
--)
8594 fputs (tic6x_unwind_regnames
[i
], stdout
);
8596 fputs (", ", stdout
);
8602 if (remaining == 0 && more_words) \
8605 if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, \
8606 data_offset, & word, & addr, NULL)) \
8612 #define GET_OP(OP) \
8617 (OP) = word >> 24; \
8622 printf (_("[Truncated opcode]\n")); \
8625 printf ("0x%02x ", OP)
8628 decode_arm_unwind_bytecode (Filedata
* filedata
,
8629 struct arm_unw_aux_info
* aux
,
8631 unsigned int remaining
,
8632 unsigned int more_words
,
8633 bfd_vma data_offset
,
8634 Elf_Internal_Shdr
* data_sec
,
8635 struct arm_section
* data_arm_sec
)
8637 struct absaddr addr
;
8638 bfd_boolean res
= TRUE
;
8640 /* Decode the unwinding instructions. */
8643 unsigned int op
, op2
;
8652 printf (" 0x%02x ", op
);
8654 if ((op
& 0xc0) == 0x00)
8656 int offset
= ((op
& 0x3f) << 2) + 4;
8658 printf (" vsp = vsp + %d", offset
);
8660 else if ((op
& 0xc0) == 0x40)
8662 int offset
= ((op
& 0x3f) << 2) + 4;
8664 printf (" vsp = vsp - %d", offset
);
8666 else if ((op
& 0xf0) == 0x80)
8669 if (op
== 0x80 && op2
== 0)
8670 printf (_("Refuse to unwind"));
8673 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
8674 bfd_boolean first
= TRUE
;
8678 for (i
= 0; i
< 12; i
++)
8679 if (mask
& (1 << i
))
8685 printf ("r%d", 4 + i
);
8690 else if ((op
& 0xf0) == 0x90)
8692 if (op
== 0x9d || op
== 0x9f)
8693 printf (_(" [Reserved]"));
8695 printf (" vsp = r%d", op
& 0x0f);
8697 else if ((op
& 0xf0) == 0xa0)
8699 int end
= 4 + (op
& 0x07);
8700 bfd_boolean first
= TRUE
;
8704 for (i
= 4; i
<= end
; i
++)
8720 else if (op
== 0xb0)
8721 printf (_(" finish"));
8722 else if (op
== 0xb1)
8725 if (op2
== 0 || (op2
& 0xf0) != 0)
8726 printf (_("[Spare]"));
8729 unsigned int mask
= op2
& 0x0f;
8730 bfd_boolean first
= TRUE
;
8734 for (i
= 0; i
< 12; i
++)
8735 if (mask
& (1 << i
))
8746 else if (op
== 0xb2)
8748 unsigned char buf
[9];
8749 unsigned int i
, len
;
8750 unsigned long offset
;
8752 for (i
= 0; i
< sizeof (buf
); i
++)
8755 if ((buf
[i
] & 0x80) == 0)
8758 if (i
== sizeof (buf
))
8760 error (_("corrupt change to vsp"));
8765 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8766 assert (len
== i
+ 1);
8767 offset
= offset
* 4 + 0x204;
8768 printf ("vsp = vsp + %ld", offset
);
8771 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
8773 unsigned int first
, last
;
8780 printf ("pop {D%d", first
);
8782 printf ("-D%d", first
+ last
);
8785 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
8787 unsigned int count
= op
& 0x07;
8791 printf ("-D%d", 8 + count
);
8794 else if (op
>= 0xc0 && op
<= 0xc5)
8796 unsigned int count
= op
& 0x07;
8798 printf (" pop {wR10");
8800 printf ("-wR%d", 10 + count
);
8803 else if (op
== 0xc6)
8805 unsigned int first
, last
;
8810 printf ("pop {wR%d", first
);
8812 printf ("-wR%d", first
+ last
);
8815 else if (op
== 0xc7)
8818 if (op2
== 0 || (op2
& 0xf0) != 0)
8819 printf (_("[Spare]"));
8822 unsigned int mask
= op2
& 0x0f;
8823 bfd_boolean first
= TRUE
;
8827 for (i
= 0; i
< 4; i
++)
8828 if (mask
& (1 << i
))
8834 printf ("wCGR%d", i
);
8841 printf (_(" [unsupported opcode]"));
8852 decode_tic6x_unwind_bytecode (Filedata
* filedata
,
8853 struct arm_unw_aux_info
* aux
,
8855 unsigned int remaining
,
8856 unsigned int more_words
,
8857 bfd_vma data_offset
,
8858 Elf_Internal_Shdr
* data_sec
,
8859 struct arm_section
* data_arm_sec
)
8861 struct absaddr addr
;
8863 /* Decode the unwinding instructions. */
8866 unsigned int op
, op2
;
8875 printf (" 0x%02x ", op
);
8877 if ((op
& 0xc0) == 0x00)
8879 int offset
= ((op
& 0x3f) << 3) + 8;
8880 printf (" sp = sp + %d", offset
);
8882 else if ((op
& 0xc0) == 0x80)
8885 if (op
== 0x80 && op2
== 0)
8886 printf (_("Refuse to unwind"));
8889 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
8891 printf ("pop compact {");
8895 decode_tic6x_unwind_regmask (mask
);
8899 else if ((op
& 0xf0) == 0xc0)
8907 unsigned int offset
;
8911 /* Scan entire instruction first so that GET_OP output is not
8912 interleaved with disassembly. */
8914 for (i
= 0; nregs
< (op
& 0xf); i
++)
8920 regpos
[nregs
].offset
= i
* 2;
8921 regpos
[nregs
].reg
= reg
;
8928 regpos
[nregs
].offset
= i
* 2 + 1;
8929 regpos
[nregs
].reg
= reg
;
8934 printf (_("pop frame {"));
8937 printf (_("*corrupt* - no registers specified"));
8942 for (i
= i
* 2; i
> 0; i
--)
8944 if (regpos
[reg
].offset
== i
- 1)
8946 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
8953 fputs (name
, stdout
);
8961 else if (op
== 0xd0)
8962 printf (" MOV FP, SP");
8963 else if (op
== 0xd1)
8964 printf (" __c6xabi_pop_rts");
8965 else if (op
== 0xd2)
8967 unsigned char buf
[9];
8968 unsigned int i
, len
;
8969 unsigned long offset
;
8971 for (i
= 0; i
< sizeof (buf
); i
++)
8974 if ((buf
[i
] & 0x80) == 0)
8977 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
8978 if (i
== sizeof (buf
))
8980 warn (_("Corrupt stack pointer adjustment detected\n"));
8984 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8985 assert (len
== i
+ 1);
8986 offset
= offset
* 8 + 0x408;
8987 printf (_("sp = sp + %ld"), offset
);
8989 else if ((op
& 0xf0) == 0xe0)
8991 if ((op
& 0x0f) == 7)
8994 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
8998 printf (_(" [unsupported opcode]"));
9007 arm_expand_prel31 (Filedata
* filedata
, bfd_vma word
, bfd_vma where
)
9011 offset
= word
& 0x7fffffff;
9012 if (offset
& 0x40000000)
9013 offset
|= ~ (bfd_vma
) 0x7fffffff;
9015 if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
9018 return offset
+ where
;
9022 decode_arm_unwind (Filedata
* filedata
,
9023 struct arm_unw_aux_info
* aux
,
9025 unsigned int remaining
,
9026 bfd_vma data_offset
,
9027 Elf_Internal_Shdr
* data_sec
,
9028 struct arm_section
* data_arm_sec
)
9031 unsigned int more_words
= 0;
9032 struct absaddr addr
;
9033 bfd_vma sym_name
= (bfd_vma
) -1;
9034 bfd_boolean res
= TRUE
;
9038 /* Fetch the first word.
9039 Note - when decoding an object file the address extracted
9040 here will always be 0. So we also pass in the sym_name
9041 parameter so that we can find the symbol associated with
9042 the personality routine. */
9043 if (! get_unwind_section_word (filedata
, aux
, data_arm_sec
, data_sec
, data_offset
,
9044 & word
, & addr
, & sym_name
))
9051 addr
.section
= SHN_UNDEF
;
9055 if ((word
& 0x80000000) == 0)
9057 /* Expand prel31 for personality routine. */
9059 const char *procname
;
9061 fn
= arm_expand_prel31 (filedata
, word
, data_sec
->sh_addr
+ data_offset
);
9062 printf (_(" Personality routine: "));
9064 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
9065 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
9067 procname
= aux
->strtab
+ sym_name
;
9068 print_vma (fn
, PREFIX_HEX
);
9071 fputs (" <", stdout
);
9072 fputs (procname
, stdout
);
9073 fputc ('>', stdout
);
9077 procname
= arm_print_vma_and_name (filedata
, aux
, fn
, addr
);
9078 fputc ('\n', stdout
);
9080 /* The GCC personality routines use the standard compact
9081 encoding, starting with one byte giving the number of
9083 if (procname
!= NULL
9084 && (const_strneq (procname
, "__gcc_personality_v0")
9085 || const_strneq (procname
, "__gxx_personality_v0")
9086 || const_strneq (procname
, "__gcj_personality_v0")
9087 || const_strneq (procname
, "__gnu_objc_personality_v0")))
9094 printf (_(" [Truncated data]\n"));
9097 more_words
= word
>> 24;
9107 /* ARM EHABI Section 6.3:
9109 An exception-handling table entry for the compact model looks like:
9113 1 0 index Data for personalityRoutine[index] */
9115 if (filedata
->file_header
.e_machine
== EM_ARM
9116 && (word
& 0x70000000))
9118 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
9122 per_index
= (word
>> 24) & 0x7f;
9123 printf (_(" Compact model index: %d\n"), per_index
);
9130 else if (per_index
< 3)
9132 more_words
= (word
>> 16) & 0xff;
9138 switch (filedata
->file_header
.e_machine
)
9143 if (! decode_arm_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
9144 data_offset
, data_sec
, data_arm_sec
))
9149 warn (_("Unknown ARM compact model index encountered\n"));
9150 printf (_(" [reserved]\n"));
9158 if (! decode_tic6x_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
9159 data_offset
, data_sec
, data_arm_sec
))
9162 else if (per_index
< 5)
9164 if (((word
>> 17) & 0x7f) == 0x7f)
9165 printf (_(" Restore stack from frame pointer\n"));
9167 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
9168 printf (_(" Registers restored: "));
9170 printf (" (compact) ");
9171 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
9173 printf (_(" Return register: %s\n"),
9174 tic6x_unwind_regnames
[word
& 0xf]);
9177 printf (_(" [reserved (%d)]\n"), per_index
);
9181 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
9182 filedata
->file_header
.e_machine
);
9186 /* Decode the descriptors. Not implemented. */
9192 dump_arm_unwind (Filedata
* filedata
,
9193 struct arm_unw_aux_info
* aux
,
9194 Elf_Internal_Shdr
* exidx_sec
)
9196 struct arm_section exidx_arm_sec
, extab_arm_sec
;
9197 unsigned int i
, exidx_len
;
9198 unsigned long j
, nfuns
;
9199 bfd_boolean res
= TRUE
;
9201 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
9202 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
9203 exidx_len
= exidx_sec
->sh_size
/ 8;
9205 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
9206 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
9207 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
9208 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
9210 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
9212 for (i
= 0; i
< exidx_len
; i
++)
9214 unsigned int exidx_fn
, exidx_entry
;
9215 struct absaddr fn_addr
, entry_addr
;
9218 fputc ('\n', stdout
);
9220 if (! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9221 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
9222 || ! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9223 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
9226 arm_free_section (& exidx_arm_sec
);
9227 arm_free_section (& extab_arm_sec
);
9231 /* ARM EHABI, Section 5:
9232 An index table entry consists of 2 words.
9233 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
9234 if (exidx_fn
& 0x80000000)
9236 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
9240 fn
= arm_expand_prel31 (filedata
, exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
9242 arm_print_vma_and_name (filedata
, aux
, fn
, fn_addr
);
9243 fputs (": ", stdout
);
9245 if (exidx_entry
== 1)
9247 print_vma (exidx_entry
, PREFIX_HEX
);
9248 fputs (" [cantunwind]\n", stdout
);
9250 else if (exidx_entry
& 0x80000000)
9252 print_vma (exidx_entry
, PREFIX_HEX
);
9253 fputc ('\n', stdout
);
9254 decode_arm_unwind (filedata
, aux
, exidx_entry
, 4, 0, NULL
, NULL
);
9258 bfd_vma table
, table_offset
= 0;
9259 Elf_Internal_Shdr
*table_sec
;
9261 fputs ("@", stdout
);
9262 table
= arm_expand_prel31 (filedata
, exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
9263 print_vma (table
, PREFIX_HEX
);
9266 /* Locate the matching .ARM.extab. */
9267 if (entry_addr
.section
!= SHN_UNDEF
9268 && entry_addr
.section
< filedata
->file_header
.e_shnum
)
9270 table_sec
= filedata
->section_headers
+ entry_addr
.section
;
9271 table_offset
= entry_addr
.offset
;
9273 if (table_offset
> table_sec
->sh_size
9274 || ((bfd_signed_vma
) table_offset
) < 0)
9276 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
9277 (unsigned long) table_offset
,
9278 printable_section_name (filedata
, table_sec
));
9285 table_sec
= find_section_by_address (filedata
, table
);
9286 if (table_sec
!= NULL
)
9287 table_offset
= table
- table_sec
->sh_addr
;
9290 if (table_sec
== NULL
)
9292 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
9293 (unsigned long) table
);
9298 if (! decode_arm_unwind (filedata
, aux
, 0, 0, table_offset
, table_sec
,
9307 arm_free_section (&exidx_arm_sec
);
9308 arm_free_section (&extab_arm_sec
);
9313 /* Used for both ARM and C6X unwinding tables. */
9316 arm_process_unwind (Filedata
* filedata
)
9318 struct arm_unw_aux_info aux
;
9319 Elf_Internal_Shdr
*unwsec
= NULL
;
9320 Elf_Internal_Shdr
*strsec
;
9321 Elf_Internal_Shdr
*sec
;
9323 unsigned int sec_type
;
9324 bfd_boolean res
= TRUE
;
9326 switch (filedata
->file_header
.e_machine
)
9329 sec_type
= SHT_ARM_EXIDX
;
9333 sec_type
= SHT_C6000_UNWIND
;
9337 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9338 filedata
->file_header
.e_machine
);
9342 if (filedata
->string_table
== NULL
)
9345 memset (& aux
, 0, sizeof (aux
));
9346 aux
.filedata
= filedata
;
9348 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9350 if (sec
->sh_type
== SHT_SYMTAB
&& sec
->sh_link
< filedata
->file_header
.e_shnum
)
9352 aux
.symtab
= GET_ELF_SYMBOLS (filedata
, sec
, & aux
.nsyms
);
9354 strsec
= filedata
->section_headers
+ sec
->sh_link
;
9356 /* PR binutils/17531 file: 011-12666-0.004. */
9357 if (aux
.strtab
!= NULL
)
9359 error (_("Multiple string tables found in file.\n"));
9363 aux
.strtab
= get_data (NULL
, filedata
, strsec
->sh_offset
,
9364 1, strsec
->sh_size
, _("string table"));
9365 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
9367 else if (sec
->sh_type
== sec_type
)
9372 printf (_("\nThere are no unwind sections in this file.\n"));
9374 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9376 if (sec
->sh_type
== sec_type
)
9378 unsigned long num_unwind
= sec
->sh_size
/ (2 * eh_addr_size
);
9379 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
9380 "contains %lu entry:\n",
9381 "\nUnwind section '%s' at offset 0x%lx "
9382 "contains %lu entries:\n",
9384 printable_section_name (filedata
, sec
),
9385 (unsigned long) sec
->sh_offset
,
9388 if (! dump_arm_unwind (filedata
, &aux
, sec
))
9396 free ((char *) aux
.strtab
);
9402 process_unwind (Filedata
* filedata
)
9404 struct unwind_handler
9406 unsigned int machtype
;
9407 bfd_boolean (* handler
)(Filedata
*);
9410 { EM_ARM
, arm_process_unwind
},
9411 { EM_IA_64
, ia64_process_unwind
},
9412 { EM_PARISC
, hppa_process_unwind
},
9413 { EM_TI_C6000
, arm_process_unwind
},
9421 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
9422 if (filedata
->file_header
.e_machine
== handlers
[i
].machtype
)
9423 return handlers
[i
].handler (filedata
);
9425 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9426 get_machine_name (filedata
->file_header
.e_machine
));
9431 dynamic_section_aarch64_val (Elf_Internal_Dyn
* entry
)
9433 switch (entry
->d_tag
)
9435 case DT_AARCH64_BTI_PLT
:
9436 case DT_AARCH64_PAC_PLT
:
9439 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9446 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
9448 switch (entry
->d_tag
)
9451 if (entry
->d_un
.d_val
== 0)
9455 static const char * opts
[] =
9457 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9458 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9459 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9460 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9464 bfd_boolean first
= TRUE
;
9466 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
9467 if (entry
->d_un
.d_val
& (1 << cnt
))
9469 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
9475 case DT_MIPS_IVERSION
:
9476 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9477 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
9481 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
9482 /* Note: coded this way so that there is a single string for translation. */
9483 printf (_("<corrupt: %s>"), buf
);
9487 case DT_MIPS_TIME_STAMP
:
9491 time_t atime
= entry
->d_un
.d_val
;
9493 tmp
= gmtime (&atime
);
9494 /* PR 17531: file: 6accc532. */
9496 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
9498 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
9499 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9500 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9501 printf (_("Time Stamp: %s"), timebuf
);
9505 case DT_MIPS_RLD_VERSION
:
9506 case DT_MIPS_LOCAL_GOTNO
:
9507 case DT_MIPS_CONFLICTNO
:
9508 case DT_MIPS_LIBLISTNO
:
9509 case DT_MIPS_SYMTABNO
:
9510 case DT_MIPS_UNREFEXTNO
:
9511 case DT_MIPS_HIPAGENO
:
9512 case DT_MIPS_DELTA_CLASS_NO
:
9513 case DT_MIPS_DELTA_INSTANCE_NO
:
9514 case DT_MIPS_DELTA_RELOC_NO
:
9515 case DT_MIPS_DELTA_SYM_NO
:
9516 case DT_MIPS_DELTA_CLASSSYM_NO
:
9517 case DT_MIPS_COMPACT_SIZE
:
9518 print_vma (entry
->d_un
.d_val
, DEC
);
9522 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9528 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
9530 switch (entry
->d_tag
)
9532 case DT_HP_DLD_FLAGS
:
9541 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
9542 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
9543 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
9544 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
9545 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
9546 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
9547 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
9548 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
9549 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
9550 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
9551 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
9552 { DT_HP_GST
, "HP_GST" },
9553 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
9554 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
9555 { DT_HP_NODELETE
, "HP_NODELETE" },
9556 { DT_HP_GROUP
, "HP_GROUP" },
9557 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
9559 bfd_boolean first
= TRUE
;
9561 bfd_vma val
= entry
->d_un
.d_val
;
9563 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
9564 if (val
& flags
[cnt
].bit
)
9568 fputs (flags
[cnt
].str
, stdout
);
9570 val
^= flags
[cnt
].bit
;
9573 if (val
!= 0 || first
)
9577 print_vma (val
, HEX
);
9583 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9591 /* VMS vs Unix time offset and factor. */
9593 #define VMS_EPOCH_OFFSET 35067168000000000LL
9594 #define VMS_GRANULARITY_FACTOR 10000000
9596 /* Display a VMS time in a human readable format. */
9599 print_vms_time (bfd_int64_t vmstime
)
9604 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
9605 tm
= gmtime (&unxtime
);
9606 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9607 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
9608 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
9613 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
9615 switch (entry
->d_tag
)
9617 case DT_IA_64_PLT_RESERVE
:
9618 /* First 3 slots reserved. */
9619 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9621 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
9624 case DT_IA_64_VMS_LINKTIME
:
9626 print_vms_time (entry
->d_un
.d_val
);
9630 case DT_IA_64_VMS_LNKFLAGS
:
9631 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9632 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
9633 printf (" CALL_DEBUG");
9634 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
9635 printf (" NOP0BUFS");
9636 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
9637 printf (" P0IMAGE");
9638 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
9639 printf (" MKTHREADS");
9640 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
9641 printf (" UPCALLS");
9642 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
9644 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
9645 printf (" INITIALIZE");
9646 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
9648 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
9649 printf (" EXE_INIT");
9650 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
9651 printf (" TBK_IN_IMG");
9652 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
9653 printf (" DBG_IN_IMG");
9654 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
9655 printf (" TBK_IN_DSF");
9656 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
9657 printf (" DBG_IN_DSF");
9658 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
9659 printf (" SIGNATURES");
9660 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
9661 printf (" REL_SEG_OFF");
9665 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9672 get_32bit_dynamic_section (Filedata
* filedata
)
9674 Elf32_External_Dyn
* edyn
;
9675 Elf32_External_Dyn
* ext
;
9676 Elf_Internal_Dyn
* entry
;
9678 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, filedata
, dynamic_addr
, 1,
9679 dynamic_size
, _("dynamic section"));
9683 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9684 might not have the luxury of section headers. Look for the DT_NULL
9685 terminator to determine the number of entries. */
9686 for (ext
= edyn
, dynamic_nent
= 0;
9687 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9691 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9695 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9697 if (dynamic_section
== NULL
)
9699 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9700 (unsigned long) dynamic_nent
);
9705 for (ext
= edyn
, entry
= dynamic_section
;
9706 entry
< dynamic_section
+ dynamic_nent
;
9709 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9710 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9719 get_64bit_dynamic_section (Filedata
* filedata
)
9721 Elf64_External_Dyn
* edyn
;
9722 Elf64_External_Dyn
* ext
;
9723 Elf_Internal_Dyn
* entry
;
9725 /* Read in the data. */
9726 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, filedata
, dynamic_addr
, 1,
9727 dynamic_size
, _("dynamic section"));
9731 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9732 might not have the luxury of section headers. Look for the DT_NULL
9733 terminator to determine the number of entries. */
9734 for (ext
= edyn
, dynamic_nent
= 0;
9735 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
9736 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9740 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9744 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9746 if (dynamic_section
== NULL
)
9748 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9749 (unsigned long) dynamic_nent
);
9754 /* Convert from external to internal formats. */
9755 for (ext
= edyn
, entry
= dynamic_section
;
9756 entry
< dynamic_section
+ dynamic_nent
;
9759 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9760 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9769 print_dynamic_flags (bfd_vma flags
)
9771 bfd_boolean first
= TRUE
;
9777 flag
= flags
& - flags
;
9787 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
9788 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
9789 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
9790 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
9791 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
9792 default: fputs (_("unknown"), stdout
); break;
9798 /* Parse and display the contents of the dynamic section. */
9801 process_dynamic_section (Filedata
* filedata
)
9803 Elf_Internal_Dyn
* entry
;
9805 if (dynamic_size
== 0)
9808 printf (_("\nThere is no dynamic section in this file.\n"));
9815 if (! get_32bit_dynamic_section (filedata
))
9820 if (! get_64bit_dynamic_section (filedata
))
9824 /* Find the appropriate symbol table. */
9825 if (dynamic_symbols
== NULL
)
9827 for (entry
= dynamic_section
;
9828 entry
< dynamic_section
+ dynamic_nent
;
9831 Elf_Internal_Shdr section
;
9833 if (entry
->d_tag
!= DT_SYMTAB
)
9836 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
9838 /* Since we do not know how big the symbol table is,
9839 we default to reading in the entire file (!) and
9840 processing that. This is overkill, I know, but it
9842 section
.sh_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
9843 if ((bfd_size_type
) section
.sh_offset
> filedata
->file_size
)
9845 /* See PR 21379 for a reproducer. */
9846 error (_("Invalid DT_SYMTAB entry: %lx"), (long) section
.sh_offset
);
9850 if (archive_file_offset
!= 0)
9851 section
.sh_size
= archive_file_size
- section
.sh_offset
;
9853 section
.sh_size
= filedata
->file_size
- section
.sh_offset
;
9856 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
9858 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
9859 section
.sh_name
= filedata
->string_table_length
;
9861 if (dynamic_symbols
!= NULL
)
9863 error (_("Multiple dynamic symbol table sections found\n"));
9864 free (dynamic_symbols
);
9866 dynamic_symbols
= GET_ELF_SYMBOLS (filedata
, §ion
, & num_dynamic_syms
);
9867 if (num_dynamic_syms
< 1)
9869 error (_("Unable to determine the number of symbols to load\n"));
9875 /* Similarly find a string table. */
9876 if (dynamic_strings
== NULL
)
9878 for (entry
= dynamic_section
;
9879 entry
< dynamic_section
+ dynamic_nent
;
9882 unsigned long offset
;
9885 if (entry
->d_tag
!= DT_STRTAB
)
9888 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
9890 /* Since we do not know how big the string table is,
9891 we default to reading in the entire file (!) and
9892 processing that. This is overkill, I know, but it
9895 offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
9897 if (archive_file_offset
!= 0)
9898 str_tab_len
= archive_file_size
- offset
;
9900 str_tab_len
= filedata
->file_size
- offset
;
9902 if (str_tab_len
< 1)
9905 (_("Unable to determine the length of the dynamic string table\n"));
9909 if (dynamic_strings
!= NULL
)
9911 error (_("Multiple dynamic string tables found\n"));
9912 free (dynamic_strings
);
9915 dynamic_strings
= (char *) get_data (NULL
, filedata
, offset
, 1,
9917 _("dynamic string table"));
9918 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : str_tab_len
;
9922 /* And find the syminfo section if available. */
9923 if (dynamic_syminfo
== NULL
)
9925 unsigned long syminsz
= 0;
9927 for (entry
= dynamic_section
;
9928 entry
< dynamic_section
+ dynamic_nent
;
9931 if (entry
->d_tag
== DT_SYMINENT
)
9933 /* Note: these braces are necessary to avoid a syntax
9934 error from the SunOS4 C compiler. */
9935 /* PR binutils/17531: A corrupt file can trigger this test.
9936 So do not use an assert, instead generate an error message. */
9937 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
9938 error (_("Bad value (%d) for SYMINENT entry\n"),
9939 (int) entry
->d_un
.d_val
);
9941 else if (entry
->d_tag
== DT_SYMINSZ
)
9942 syminsz
= entry
->d_un
.d_val
;
9943 else if (entry
->d_tag
== DT_SYMINFO
)
9944 dynamic_syminfo_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
,
9948 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
9950 Elf_External_Syminfo
* extsyminfo
;
9951 Elf_External_Syminfo
* extsym
;
9952 Elf_Internal_Syminfo
* syminfo
;
9954 /* There is a syminfo section. Read the data. */
9955 extsyminfo
= (Elf_External_Syminfo
*)
9956 get_data (NULL
, filedata
, dynamic_syminfo_offset
, 1, syminsz
,
9957 _("symbol information"));
9961 if (dynamic_syminfo
!= NULL
)
9963 error (_("Multiple dynamic symbol information sections found\n"));
9964 free (dynamic_syminfo
);
9966 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
9967 if (dynamic_syminfo
== NULL
)
9969 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9970 (unsigned long) syminsz
);
9974 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
9975 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
9976 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
9977 ++syminfo
, ++extsym
)
9979 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
9980 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
9987 if (do_dynamic
&& dynamic_addr
)
9988 printf (ngettext ("\nDynamic section at offset 0x%lx "
9989 "contains %lu entry:\n",
9990 "\nDynamic section at offset 0x%lx "
9991 "contains %lu entries:\n",
9993 dynamic_addr
, (unsigned long) dynamic_nent
);
9995 printf (_(" Tag Type Name/Value\n"));
9997 for (entry
= dynamic_section
;
9998 entry
< dynamic_section
+ dynamic_nent
;
10003 const char * dtype
;
10006 print_vma (entry
->d_tag
, FULL_HEX
);
10007 dtype
= get_dynamic_type (filedata
, entry
->d_tag
);
10008 printf (" (%s)%*s", dtype
,
10009 ((is_32bit_elf
? 27 : 19) - (int) strlen (dtype
)), " ");
10012 switch (entry
->d_tag
)
10016 print_dynamic_flags (entry
->d_un
.d_val
);
10026 switch (entry
->d_tag
)
10029 printf (_("Auxiliary library"));
10033 printf (_("Filter library"));
10037 printf (_("Configuration file"));
10041 printf (_("Dependency audit library"));
10045 printf (_("Audit library"));
10049 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
10050 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
10054 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10063 printf (_("Flags:"));
10065 if (entry
->d_un
.d_val
== 0)
10066 printf (_(" None\n"));
10069 unsigned long int val
= entry
->d_un
.d_val
;
10071 if (val
& DTF_1_PARINIT
)
10073 printf (" PARINIT");
10074 val
^= DTF_1_PARINIT
;
10076 if (val
& DTF_1_CONFEXP
)
10078 printf (" CONFEXP");
10079 val
^= DTF_1_CONFEXP
;
10082 printf (" %lx", val
);
10091 printf (_("Flags:"));
10093 if (entry
->d_un
.d_val
== 0)
10094 printf (_(" None\n"));
10097 unsigned long int val
= entry
->d_un
.d_val
;
10099 if (val
& DF_P1_LAZYLOAD
)
10101 printf (" LAZYLOAD");
10102 val
^= DF_P1_LAZYLOAD
;
10104 if (val
& DF_P1_GROUPPERM
)
10106 printf (" GROUPPERM");
10107 val
^= DF_P1_GROUPPERM
;
10110 printf (" %lx", val
);
10119 printf (_("Flags:"));
10120 if (entry
->d_un
.d_val
== 0)
10121 printf (_(" None\n"));
10124 unsigned long int val
= entry
->d_un
.d_val
;
10126 if (val
& DF_1_NOW
)
10131 if (val
& DF_1_GLOBAL
)
10133 printf (" GLOBAL");
10134 val
^= DF_1_GLOBAL
;
10136 if (val
& DF_1_GROUP
)
10141 if (val
& DF_1_NODELETE
)
10143 printf (" NODELETE");
10144 val
^= DF_1_NODELETE
;
10146 if (val
& DF_1_LOADFLTR
)
10148 printf (" LOADFLTR");
10149 val
^= DF_1_LOADFLTR
;
10151 if (val
& DF_1_INITFIRST
)
10153 printf (" INITFIRST");
10154 val
^= DF_1_INITFIRST
;
10156 if (val
& DF_1_NOOPEN
)
10158 printf (" NOOPEN");
10159 val
^= DF_1_NOOPEN
;
10161 if (val
& DF_1_ORIGIN
)
10163 printf (" ORIGIN");
10164 val
^= DF_1_ORIGIN
;
10166 if (val
& DF_1_DIRECT
)
10168 printf (" DIRECT");
10169 val
^= DF_1_DIRECT
;
10171 if (val
& DF_1_TRANS
)
10176 if (val
& DF_1_INTERPOSE
)
10178 printf (" INTERPOSE");
10179 val
^= DF_1_INTERPOSE
;
10181 if (val
& DF_1_NODEFLIB
)
10183 printf (" NODEFLIB");
10184 val
^= DF_1_NODEFLIB
;
10186 if (val
& DF_1_NODUMP
)
10188 printf (" NODUMP");
10189 val
^= DF_1_NODUMP
;
10191 if (val
& DF_1_CONFALT
)
10193 printf (" CONFALT");
10194 val
^= DF_1_CONFALT
;
10196 if (val
& DF_1_ENDFILTEE
)
10198 printf (" ENDFILTEE");
10199 val
^= DF_1_ENDFILTEE
;
10201 if (val
& DF_1_DISPRELDNE
)
10203 printf (" DISPRELDNE");
10204 val
^= DF_1_DISPRELDNE
;
10206 if (val
& DF_1_DISPRELPND
)
10208 printf (" DISPRELPND");
10209 val
^= DF_1_DISPRELPND
;
10211 if (val
& DF_1_NODIRECT
)
10213 printf (" NODIRECT");
10214 val
^= DF_1_NODIRECT
;
10216 if (val
& DF_1_IGNMULDEF
)
10218 printf (" IGNMULDEF");
10219 val
^= DF_1_IGNMULDEF
;
10221 if (val
& DF_1_NOKSYMS
)
10223 printf (" NOKSYMS");
10224 val
^= DF_1_NOKSYMS
;
10226 if (val
& DF_1_NOHDR
)
10231 if (val
& DF_1_EDITED
)
10233 printf (" EDITED");
10234 val
^= DF_1_EDITED
;
10236 if (val
& DF_1_NORELOC
)
10238 printf (" NORELOC");
10239 val
^= DF_1_NORELOC
;
10241 if (val
& DF_1_SYMINTPOSE
)
10243 printf (" SYMINTPOSE");
10244 val
^= DF_1_SYMINTPOSE
;
10246 if (val
& DF_1_GLOBAUDIT
)
10248 printf (" GLOBAUDIT");
10249 val
^= DF_1_GLOBAUDIT
;
10251 if (val
& DF_1_SINGLETON
)
10253 printf (" SINGLETON");
10254 val
^= DF_1_SINGLETON
;
10256 if (val
& DF_1_STUB
)
10261 if (val
& DF_1_PIE
)
10266 if (val
& DF_1_KMOD
)
10271 if (val
& DF_1_WEAKFILTER
)
10273 printf (" WEAKFILTER");
10274 val
^= DF_1_WEAKFILTER
;
10276 if (val
& DF_1_NOCOMMON
)
10278 printf (" NOCOMMON");
10279 val
^= DF_1_NOCOMMON
;
10282 printf (" %lx", val
);
10289 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10291 puts (get_dynamic_type (filedata
, entry
->d_un
.d_val
));
10311 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10317 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
10318 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
10324 switch (entry
->d_tag
)
10327 printf (_("Shared library: [%s]"), name
);
10329 if (streq (name
, program_interpreter
))
10330 printf (_(" program interpreter"));
10334 printf (_("Library soname: [%s]"), name
);
10338 printf (_("Library rpath: [%s]"), name
);
10342 printf (_("Library runpath: [%s]"), name
);
10346 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10351 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10364 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10365 /* Fall through. */
10369 case DT_INIT_ARRAYSZ
:
10370 case DT_FINI_ARRAYSZ
:
10371 case DT_GNU_CONFLICTSZ
:
10372 case DT_GNU_LIBLISTSZ
:
10375 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10376 printf (_(" (bytes)\n"));
10381 case DT_VERNEEDNUM
:
10386 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10395 case DT_INIT_ARRAY
:
10396 case DT_FINI_ARRAY
:
10399 if (entry
->d_tag
== DT_USED
10400 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
10402 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
10406 printf (_("Not needed object: [%s]\n"), name
);
10411 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10417 /* The value of this entry is ignored. */
10422 case DT_GNU_PRELINKED
:
10426 time_t atime
= entry
->d_un
.d_val
;
10428 tmp
= gmtime (&atime
);
10429 /* PR 17533 file: 041-1244816-0.004. */
10431 printf (_("<corrupt time val: %lx"),
10432 (unsigned long) atime
);
10434 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10435 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
10436 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
10442 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10445 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10451 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
10452 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
10457 switch (filedata
->file_header
.e_machine
)
10460 dynamic_section_aarch64_val (entry
);
10463 case EM_MIPS_RS3_LE
:
10464 dynamic_section_mips_val (entry
);
10467 dynamic_section_parisc_val (entry
);
10470 dynamic_section_ia64_val (entry
);
10473 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10485 get_ver_flags (unsigned int flags
)
10487 static char buff
[128];
10494 if (flags
& VER_FLG_BASE
)
10495 strcat (buff
, "BASE");
10497 if (flags
& VER_FLG_WEAK
)
10499 if (flags
& VER_FLG_BASE
)
10500 strcat (buff
, " | ");
10502 strcat (buff
, "WEAK");
10505 if (flags
& VER_FLG_INFO
)
10507 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
10508 strcat (buff
, " | ");
10510 strcat (buff
, "INFO");
10513 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10515 if (flags
& (VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10516 strcat (buff
, " | ");
10518 strcat (buff
, _("<unknown>"));
10524 /* Display the contents of the version sections. */
10527 process_version_sections (Filedata
* filedata
)
10529 Elf_Internal_Shdr
* section
;
10531 bfd_boolean found
= FALSE
;
10536 for (i
= 0, section
= filedata
->section_headers
;
10537 i
< filedata
->file_header
.e_shnum
;
10540 switch (section
->sh_type
)
10542 case SHT_GNU_verdef
:
10544 Elf_External_Verdef
* edefs
;
10551 printf (ngettext ("\nVersion definition section '%s' "
10552 "contains %u entry:\n",
10553 "\nVersion definition section '%s' "
10554 "contains %u entries:\n",
10556 printable_section_name (filedata
, section
),
10559 printf (_(" Addr: 0x"));
10560 printf_vma (section
->sh_addr
);
10561 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10562 (unsigned long) section
->sh_offset
, section
->sh_link
,
10563 printable_section_name_from_index (filedata
, section
->sh_link
));
10565 edefs
= (Elf_External_Verdef
*)
10566 get_data (NULL
, filedata
, section
->sh_offset
, 1,section
->sh_size
,
10567 _("version definition section"));
10570 endbuf
= (char *) edefs
+ section
->sh_size
;
10572 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
10575 Elf_External_Verdef
* edef
;
10576 Elf_Internal_Verdef ent
;
10577 Elf_External_Verdaux
* eaux
;
10578 Elf_Internal_Verdaux aux
;
10579 unsigned long isum
;
10582 vstart
= ((char *) edefs
) + idx
;
10583 if (vstart
+ sizeof (*edef
) > endbuf
)
10586 edef
= (Elf_External_Verdef
*) vstart
;
10588 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
10589 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
10590 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
10591 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
10592 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
10593 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
10594 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
10596 printf (_(" %#06lx: Rev: %d Flags: %s"),
10597 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
10599 printf (_(" Index: %d Cnt: %d "),
10600 ent
.vd_ndx
, ent
.vd_cnt
);
10602 /* Check for overflow. */
10603 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
10606 vstart
+= ent
.vd_aux
;
10608 if (vstart
+ sizeof (*eaux
) > endbuf
)
10610 eaux
= (Elf_External_Verdaux
*) vstart
;
10612 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10613 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10615 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10616 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
10618 printf (_("Name index: %ld\n"), aux
.vda_name
);
10620 isum
= idx
+ ent
.vd_aux
;
10622 for (j
= 1; j
< ent
.vd_cnt
; j
++)
10624 if (aux
.vda_next
< sizeof (*eaux
)
10625 && !(j
== ent
.vd_cnt
- 1 && aux
.vda_next
== 0))
10627 warn (_("Invalid vda_next field of %lx\n"),
10632 /* Check for overflow. */
10633 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
10636 isum
+= aux
.vda_next
;
10637 vstart
+= aux
.vda_next
;
10639 if (vstart
+ sizeof (*eaux
) > endbuf
)
10641 eaux
= (Elf_External_Verdaux
*) vstart
;
10643 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10644 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10646 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10647 printf (_(" %#06lx: Parent %d: %s\n"),
10648 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
10650 printf (_(" %#06lx: Parent %d, name index: %ld\n"),
10651 isum
, j
, aux
.vda_name
);
10654 if (j
< ent
.vd_cnt
)
10655 printf (_(" Version def aux past end of section\n"));
10658 file: id:000001,src:000172+005151,op:splice,rep:2. */
10659 if (ent
.vd_next
< sizeof (*edef
)
10660 && !(cnt
== section
->sh_info
- 1 && ent
.vd_next
== 0))
10662 warn (_("Invalid vd_next field of %lx\n"), ent
.vd_next
);
10663 cnt
= section
->sh_info
;
10666 if (ent
.vd_next
> (size_t) (endbuf
- ((char *) edefs
+ idx
)))
10669 idx
+= ent
.vd_next
;
10672 if (cnt
< section
->sh_info
)
10673 printf (_(" Version definition past end of section\n"));
10679 case SHT_GNU_verneed
:
10681 Elf_External_Verneed
* eneed
;
10688 printf (ngettext ("\nVersion needs section '%s' "
10689 "contains %u entry:\n",
10690 "\nVersion needs section '%s' "
10691 "contains %u entries:\n",
10693 printable_section_name (filedata
, section
), section
->sh_info
);
10695 printf (_(" Addr: 0x"));
10696 printf_vma (section
->sh_addr
);
10697 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10698 (unsigned long) section
->sh_offset
, section
->sh_link
,
10699 printable_section_name_from_index (filedata
, section
->sh_link
));
10701 eneed
= (Elf_External_Verneed
*) get_data (NULL
, filedata
,
10702 section
->sh_offset
, 1,
10704 _("Version Needs section"));
10707 endbuf
= (char *) eneed
+ section
->sh_size
;
10709 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
10711 Elf_External_Verneed
* entry
;
10712 Elf_Internal_Verneed ent
;
10713 unsigned long isum
;
10717 vstart
= ((char *) eneed
) + idx
;
10718 if (vstart
+ sizeof (*entry
) > endbuf
)
10721 entry
= (Elf_External_Verneed
*) vstart
;
10723 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
10724 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
10725 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
10726 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
10727 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
10729 printf (_(" %#06lx: Version: %d"), idx
, ent
.vn_version
);
10731 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
10732 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
10734 printf (_(" File: %lx"), ent
.vn_file
);
10736 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
10738 /* Check for overflow. */
10739 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
10741 vstart
+= ent
.vn_aux
;
10743 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
10745 Elf_External_Vernaux
* eaux
;
10746 Elf_Internal_Vernaux aux
;
10748 if (vstart
+ sizeof (*eaux
) > endbuf
)
10750 eaux
= (Elf_External_Vernaux
*) vstart
;
10752 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
10753 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
10754 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
10755 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
10756 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
10758 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
10759 printf (_(" %#06lx: Name: %s"),
10760 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
10762 printf (_(" %#06lx: Name index: %lx"),
10763 isum
, aux
.vna_name
);
10765 printf (_(" Flags: %s Version: %d\n"),
10766 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
10768 if (aux
.vna_next
< sizeof (*eaux
)
10769 && !(j
== ent
.vn_cnt
- 1 && aux
.vna_next
== 0))
10771 warn (_("Invalid vna_next field of %lx\n"),
10776 /* Check for overflow. */
10777 if (aux
.vna_next
> (size_t) (endbuf
- vstart
))
10779 isum
+= aux
.vna_next
;
10780 vstart
+= aux
.vna_next
;
10783 if (j
< ent
.vn_cnt
)
10784 warn (_("Missing Version Needs auxillary information\n"));
10786 if (ent
.vn_next
< sizeof (*entry
)
10787 && !(cnt
== section
->sh_info
- 1 && ent
.vn_next
== 0))
10789 warn (_("Invalid vn_next field of %lx\n"), ent
.vn_next
);
10790 cnt
= section
->sh_info
;
10793 if (ent
.vn_next
> (size_t) (endbuf
- ((char *) eneed
+ idx
)))
10795 idx
+= ent
.vn_next
;
10798 if (cnt
< section
->sh_info
)
10799 warn (_("Missing Version Needs information\n"));
10805 case SHT_GNU_versym
:
10807 Elf_Internal_Shdr
* link_section
;
10810 unsigned char * edata
;
10811 unsigned short * data
;
10813 Elf_Internal_Sym
* symbols
;
10814 Elf_Internal_Shdr
* string_sec
;
10815 unsigned long num_syms
;
10818 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
10821 link_section
= filedata
->section_headers
+ section
->sh_link
;
10822 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
10824 if (link_section
->sh_link
>= filedata
->file_header
.e_shnum
)
10829 symbols
= GET_ELF_SYMBOLS (filedata
, link_section
, & num_syms
);
10830 if (symbols
== NULL
)
10833 string_sec
= filedata
->section_headers
+ link_section
->sh_link
;
10835 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
10836 string_sec
->sh_size
,
10837 _("version string table"));
10844 printf (ngettext ("\nVersion symbols section '%s' "
10845 "contains %lu entry:\n",
10846 "\nVersion symbols section '%s' "
10847 "contains %lu entries:\n",
10849 printable_section_name (filedata
, section
), (unsigned long) total
);
10851 printf (_(" Addr: 0x"));
10852 printf_vma (section
->sh_addr
);
10853 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10854 (unsigned long) section
->sh_offset
, section
->sh_link
,
10855 printable_section_name (filedata
, link_section
));
10857 off
= offset_from_vma (filedata
,
10858 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
10859 total
* sizeof (short));
10860 edata
= (unsigned char *) get_data (NULL
, filedata
, off
, total
,
10862 _("version symbol data"));
10870 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
10872 for (cnt
= total
; cnt
--;)
10873 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
10878 for (cnt
= 0; cnt
< total
; cnt
+= 4)
10882 char *invalid
= _("*invalid*");
10884 printf (" %03x:", cnt
);
10886 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
10887 switch (data
[cnt
+ j
])
10890 fputs (_(" 0 (*local*) "), stdout
);
10894 fputs (_(" 1 (*global*) "), stdout
);
10898 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
10899 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
10901 /* If this index value is greater than the size of the symbols
10902 array, break to avoid an out-of-bounds read. */
10903 if ((unsigned long)(cnt
+ j
) >= num_syms
)
10905 warn (_("invalid index into symbol array\n"));
10910 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
10912 Elf_Internal_Verneed ivn
;
10913 unsigned long offset
;
10915 offset
= offset_from_vma
10916 (filedata
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
10917 sizeof (Elf_External_Verneed
));
10921 Elf_Internal_Vernaux ivna
;
10922 Elf_External_Verneed evn
;
10923 Elf_External_Vernaux evna
;
10924 unsigned long a_off
;
10926 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
10927 _("version need")) == NULL
)
10930 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
10931 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
10933 a_off
= offset
+ ivn
.vn_aux
;
10937 if (get_data (&evna
, filedata
, a_off
, sizeof (evna
),
10938 1, _("version need aux (2)")) == NULL
)
10941 ivna
.vna_other
= 0;
10945 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
10946 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
10949 a_off
+= ivna
.vna_next
;
10951 while (ivna
.vna_other
!= data
[cnt
+ j
]
10952 && ivna
.vna_next
!= 0);
10954 if (ivna
.vna_other
== data
[cnt
+ j
])
10956 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
10958 if (ivna
.vna_name
>= string_sec
->sh_size
)
10961 name
= strtab
+ ivna
.vna_name
;
10965 offset
+= ivn
.vn_next
;
10967 while (ivn
.vn_next
);
10970 if (data
[cnt
+ j
] != 0x8001
10971 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
10973 Elf_Internal_Verdef ivd
;
10974 Elf_External_Verdef evd
;
10975 unsigned long offset
;
10977 offset
= offset_from_vma
10978 (filedata
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
10983 if (get_data (&evd
, filedata
, offset
, sizeof (evd
), 1,
10984 _("version def")) == NULL
)
10987 /* PR 17531: file: 046-1082287-0.004. */
10988 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
10993 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
10994 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
10997 offset
+= ivd
.vd_next
;
10999 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
11000 && ivd
.vd_next
!= 0);
11002 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
11004 Elf_External_Verdaux evda
;
11005 Elf_Internal_Verdaux ivda
;
11007 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
11009 if (get_data (&evda
, filedata
,
11010 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
11012 _("version def aux")) == NULL
)
11015 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
11017 if (ivda
.vda_name
>= string_sec
->sh_size
)
11019 else if (name
!= NULL
&& name
!= invalid
)
11020 name
= _("*both*");
11022 name
= strtab
+ ivda
.vda_name
;
11026 nn
+= printf ("(%s%-*s",
11028 12 - (int) strlen (name
),
11032 printf ("%*c", 18 - nn
, ' ');
11050 printf (_("\nNo version information found in this file.\n"));
11055 static const char *
11056 get_symbol_binding (Filedata
* filedata
, unsigned int binding
)
11058 static char buff
[32];
11062 case STB_LOCAL
: return "LOCAL";
11063 case STB_GLOBAL
: return "GLOBAL";
11064 case STB_WEAK
: return "WEAK";
11066 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
11067 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
11069 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
11071 if (binding
== STB_GNU_UNIQUE
11072 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
)
11074 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
11077 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
11082 static const char *
11083 get_symbol_type (Filedata
* filedata
, unsigned int type
)
11085 static char buff
[32];
11089 case STT_NOTYPE
: return "NOTYPE";
11090 case STT_OBJECT
: return "OBJECT";
11091 case STT_FUNC
: return "FUNC";
11092 case STT_SECTION
: return "SECTION";
11093 case STT_FILE
: return "FILE";
11094 case STT_COMMON
: return "COMMON";
11095 case STT_TLS
: return "TLS";
11096 case STT_RELC
: return "RELC";
11097 case STT_SRELC
: return "SRELC";
11099 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
11101 if (filedata
->file_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
11102 return "THUMB_FUNC";
11104 if (filedata
->file_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
11107 if (filedata
->file_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
11108 return "PARISC_MILLI";
11110 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
11112 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
11114 if (filedata
->file_header
.e_machine
== EM_PARISC
)
11116 if (type
== STT_HP_OPAQUE
)
11117 return "HP_OPAQUE";
11118 if (type
== STT_HP_STUB
)
11122 if (type
== STT_GNU_IFUNC
11123 && (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
11124 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
))
11127 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
11130 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
11135 static const char *
11136 get_symbol_visibility (unsigned int visibility
)
11138 switch (visibility
)
11140 case STV_DEFAULT
: return "DEFAULT";
11141 case STV_INTERNAL
: return "INTERNAL";
11142 case STV_HIDDEN
: return "HIDDEN";
11143 case STV_PROTECTED
: return "PROTECTED";
11145 error (_("Unrecognized visibility value: %u"), visibility
);
11146 return _("<unknown>");
11150 static const char *
11151 get_alpha_symbol_other (unsigned int other
)
11155 case STO_ALPHA_NOPV
: return "NOPV";
11156 case STO_ALPHA_STD_GPLOAD
: return "STD GPLOAD";
11158 error (_("Unrecognized alpah specific other value: %u"), other
);
11159 return _("<unknown>");
11163 static const char *
11164 get_solaris_symbol_visibility (unsigned int visibility
)
11166 switch (visibility
)
11168 case 4: return "EXPORTED";
11169 case 5: return "SINGLETON";
11170 case 6: return "ELIMINATE";
11171 default: return get_symbol_visibility (visibility
);
11175 static const char *
11176 get_aarch64_symbol_other (unsigned int other
)
11178 static char buf
[32];
11180 if (other
& STO_AARCH64_VARIANT_PCS
)
11182 other
&= ~STO_AARCH64_VARIANT_PCS
;
11184 return "VARIANT_PCS";
11185 snprintf (buf
, sizeof buf
, "VARIANT_PCS | %x", other
);
11191 static const char *
11192 get_mips_symbol_other (unsigned int other
)
11196 case STO_OPTIONAL
: return "OPTIONAL";
11197 case STO_MIPS_PLT
: return "MIPS PLT";
11198 case STO_MIPS_PIC
: return "MIPS PIC";
11199 case STO_MICROMIPS
: return "MICROMIPS";
11200 case STO_MICROMIPS
| STO_MIPS_PIC
: return "MICROMIPS, MIPS PIC";
11201 case STO_MIPS16
: return "MIPS16";
11202 default: return NULL
;
11206 static const char *
11207 get_ia64_symbol_other (Filedata
* filedata
, unsigned int other
)
11209 if (is_ia64_vms (filedata
))
11211 static char res
[32];
11215 /* Function types is for images and .STB files only. */
11216 switch (filedata
->file_header
.e_type
)
11220 switch (VMS_ST_FUNC_TYPE (other
))
11222 case VMS_SFT_CODE_ADDR
:
11223 strcat (res
, " CA");
11225 case VMS_SFT_SYMV_IDX
:
11226 strcat (res
, " VEC");
11229 strcat (res
, " FD");
11231 case VMS_SFT_RESERVE
:
11232 strcat (res
, " RSV");
11235 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
11236 VMS_ST_FUNC_TYPE (other
));
11237 strcat (res
, " <unknown>");
11244 switch (VMS_ST_LINKAGE (other
))
11246 case VMS_STL_IGNORE
:
11247 strcat (res
, " IGN");
11249 case VMS_STL_RESERVE
:
11250 strcat (res
, " RSV");
11253 strcat (res
, " STD");
11256 strcat (res
, " LNK");
11259 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
11260 VMS_ST_LINKAGE (other
));
11261 strcat (res
, " <unknown>");
11273 static const char *
11274 get_ppc64_symbol_other (unsigned int other
)
11276 if ((other
& ~STO_PPC64_LOCAL_MASK
) != 0)
11279 other
>>= STO_PPC64_LOCAL_BIT
;
11282 static char buf
[32];
11284 other
= ppc64_decode_local_entry (other
);
11285 snprintf (buf
, sizeof buf
, _("<localentry>: %d"), other
);
11291 static const char *
11292 get_symbol_other (Filedata
* filedata
, unsigned int other
)
11294 const char * result
= NULL
;
11295 static char buff
[32];
11300 switch (filedata
->file_header
.e_machine
)
11303 result
= get_alpha_symbol_other (other
);
11306 result
= get_aarch64_symbol_other (other
);
11309 result
= get_mips_symbol_other (other
);
11312 result
= get_ia64_symbol_other (filedata
, other
);
11315 result
= get_ppc64_symbol_other (other
);
11325 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
11329 static const char *
11330 get_symbol_index_type (Filedata
* filedata
, unsigned int type
)
11332 static char buff
[32];
11336 case SHN_UNDEF
: return "UND";
11337 case SHN_ABS
: return "ABS";
11338 case SHN_COMMON
: return "COM";
11340 if (type
== SHN_IA_64_ANSI_COMMON
11341 && filedata
->file_header
.e_machine
== EM_IA_64
11342 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
11344 else if ((filedata
->file_header
.e_machine
== EM_X86_64
11345 || filedata
->file_header
.e_machine
== EM_L1OM
11346 || filedata
->file_header
.e_machine
== EM_K1OM
)
11347 && type
== SHN_X86_64_LCOMMON
)
11348 return "LARGE_COM";
11349 else if ((type
== SHN_MIPS_SCOMMON
11350 && filedata
->file_header
.e_machine
== EM_MIPS
)
11351 || (type
== SHN_TIC6X_SCOMMON
11352 && filedata
->file_header
.e_machine
== EM_TI_C6000
))
11354 else if (type
== SHN_MIPS_SUNDEFINED
11355 && filedata
->file_header
.e_machine
== EM_MIPS
)
11357 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
11358 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
11359 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
11360 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
11361 else if (type
>= SHN_LORESERVE
)
11362 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
11363 else if (type
>= filedata
->file_header
.e_shnum
)
11364 sprintf (buff
, _("bad section index[%3d]"), type
);
11366 sprintf (buff
, "%3d", type
);
11374 get_dynamic_data (Filedata
* filedata
, bfd_size_type number
, unsigned int ent_size
)
11376 unsigned char * e_data
;
11379 /* If the size_t type is smaller than the bfd_size_type, eg because
11380 you are building a 32-bit tool on a 64-bit host, then make sure
11381 that when (number) is cast to (size_t) no information is lost. */
11382 if (sizeof (size_t) < sizeof (bfd_size_type
)
11383 && (bfd_size_type
) ((size_t) number
) != number
)
11385 error (_("Size truncation prevents reading %s elements of size %u\n"),
11386 bfd_vmatoa ("u", number
), ent_size
);
11390 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
11391 attempting to allocate memory when the read is bound to fail. */
11392 if (ent_size
* number
> filedata
->file_size
)
11394 error (_("Invalid number of dynamic entries: %s\n"),
11395 bfd_vmatoa ("u", number
));
11399 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
11400 if (e_data
== NULL
)
11402 error (_("Out of memory reading %s dynamic entries\n"),
11403 bfd_vmatoa ("u", number
));
11407 if (fread (e_data
, ent_size
, (size_t) number
, filedata
->handle
) != number
)
11409 error (_("Unable to read in %s bytes of dynamic data\n"),
11410 bfd_vmatoa ("u", number
* ent_size
));
11415 i_data
= (bfd_vma
*) cmalloc ((size_t) number
, sizeof (*i_data
));
11416 if (i_data
== NULL
)
11418 error (_("Out of memory allocating space for %s dynamic entries\n"),
11419 bfd_vmatoa ("u", number
));
11425 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
11433 print_dynamic_symbol (Filedata
* filedata
, bfd_vma si
, unsigned long hn
)
11435 Elf_Internal_Sym
* psym
;
11438 n
= print_vma (si
, DEC_5
);
11440 fputs (&" "[n
], stdout
);
11441 printf (" %3lu: ", hn
);
11443 if (dynamic_symbols
== NULL
|| si
>= num_dynamic_syms
)
11445 printf (_("<No info available for dynamic symbol number %lu>\n"),
11446 (unsigned long) si
);
11450 psym
= dynamic_symbols
+ si
;
11451 print_vma (psym
->st_value
, LONG_HEX
);
11453 print_vma (psym
->st_size
, DEC_5
);
11455 printf (" %-7s", get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)));
11456 printf (" %-6s", get_symbol_binding (filedata
, ELF_ST_BIND (psym
->st_info
)));
11458 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
11459 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
11462 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
11464 printf (" %-7s", get_symbol_visibility (vis
));
11465 /* Check to see if any other bits in the st_other field are set.
11466 Note - displaying this information disrupts the layout of the
11467 table being generated, but for the moment this case is very
11469 if (psym
->st_other
^ vis
)
11470 printf (" [%s] ", get_symbol_other (filedata
, psym
->st_other
^ vis
));
11473 printf (" %3.3s ", get_symbol_index_type (filedata
, psym
->st_shndx
));
11474 if (VALID_DYNAMIC_NAME (psym
->st_name
))
11475 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
11477 printf (_(" <corrupt: %14ld>"), psym
->st_name
);
11481 static const char *
11482 get_symbol_version_string (Filedata
* filedata
,
11483 bfd_boolean is_dynsym
,
11484 const char * strtab
,
11485 unsigned long int strtab_size
,
11487 Elf_Internal_Sym
* psym
,
11488 enum versioned_symbol_info
* sym_info
,
11489 unsigned short * vna_other
)
11491 unsigned char data
[2];
11492 unsigned short vers_data
;
11493 unsigned long offset
;
11494 unsigned short max_vd_ndx
;
11497 || version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
11500 offset
= offset_from_vma (filedata
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
11501 sizeof data
+ si
* sizeof (vers_data
));
11503 if (get_data (&data
, filedata
, offset
+ si
* sizeof (vers_data
),
11504 sizeof (data
), 1, _("version data")) == NULL
)
11507 vers_data
= byte_get (data
, 2);
11509 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
== 0)
11514 /* Usually we'd only see verdef for defined symbols, and verneed for
11515 undefined symbols. However, symbols defined by the linker in
11516 .dynbss for variables copied from a shared library in order to
11517 avoid text relocations are defined yet have verneed. We could
11518 use a heuristic to detect the special case, for example, check
11519 for verneed first on symbols defined in SHT_NOBITS sections, but
11520 it is simpler and more reliable to just look for both verdef and
11521 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
11523 if (psym
->st_shndx
!= SHN_UNDEF
11524 && vers_data
!= 0x8001
11525 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
11527 Elf_Internal_Verdef ivd
;
11528 Elf_Internal_Verdaux ivda
;
11529 Elf_External_Verdaux evda
;
11532 off
= offset_from_vma (filedata
,
11533 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
11534 sizeof (Elf_External_Verdef
));
11538 Elf_External_Verdef evd
;
11540 if (get_data (&evd
, filedata
, off
, sizeof (evd
), 1,
11541 _("version def")) == NULL
)
11550 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
11551 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
11552 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
11553 ivd
.vd_flags
= BYTE_GET (evd
.vd_flags
);
11556 if ((ivd
.vd_ndx
& VERSYM_VERSION
) > max_vd_ndx
)
11557 max_vd_ndx
= ivd
.vd_ndx
& VERSYM_VERSION
;
11559 off
+= ivd
.vd_next
;
11561 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
11563 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
11565 if (ivd
.vd_ndx
== 1 && ivd
.vd_flags
== VER_FLG_BASE
)
11568 off
-= ivd
.vd_next
;
11571 if (get_data (&evda
, filedata
, off
, sizeof (evda
), 1,
11572 _("version def aux")) != NULL
)
11574 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
11576 if (psym
->st_name
!= ivda
.vda_name
)
11578 *sym_info
= ((vers_data
& VERSYM_HIDDEN
) != 0
11579 ? symbol_hidden
: symbol_public
);
11580 return (ivda
.vda_name
< strtab_size
11581 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
11587 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
11589 Elf_External_Verneed evn
;
11590 Elf_Internal_Verneed ivn
;
11591 Elf_Internal_Vernaux ivna
;
11593 offset
= offset_from_vma (filedata
,
11594 version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
11598 unsigned long vna_off
;
11600 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
11601 _("version need")) == NULL
)
11604 ivna
.vna_other
= 0;
11609 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
11610 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
11612 vna_off
= offset
+ ivn
.vn_aux
;
11616 Elf_External_Vernaux evna
;
11618 if (get_data (&evna
, filedata
, vna_off
, sizeof (evna
), 1,
11619 _("version need aux (3)")) == NULL
)
11622 ivna
.vna_other
= 0;
11627 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
11628 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
11629 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
11632 vna_off
+= ivna
.vna_next
;
11634 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
11636 if (ivna
.vna_other
== vers_data
)
11639 offset
+= ivn
.vn_next
;
11641 while (ivn
.vn_next
!= 0);
11643 if (ivna
.vna_other
== vers_data
)
11645 *sym_info
= symbol_undefined
;
11646 *vna_other
= ivna
.vna_other
;
11647 return (ivna
.vna_name
< strtab_size
11648 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
11650 else if ((max_vd_ndx
|| (vers_data
& VERSYM_VERSION
) != 1)
11651 && (vers_data
& VERSYM_VERSION
) > max_vd_ndx
)
11652 return _("<corrupt>");
11657 /* Dump the symbol table. */
11659 process_symbol_table (Filedata
* filedata
)
11661 Elf_Internal_Shdr
* section
;
11662 bfd_size_type nbuckets
= 0;
11663 bfd_size_type nchains
= 0;
11664 bfd_vma
* buckets
= NULL
;
11665 bfd_vma
* chains
= NULL
;
11666 bfd_vma ngnubuckets
= 0;
11667 bfd_vma
* gnubuckets
= NULL
;
11668 bfd_vma
* gnuchains
= NULL
;
11669 bfd_vma gnusymidx
= 0;
11670 bfd_size_type ngnuchains
= 0;
11672 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
11675 if (dynamic_info
[DT_HASH
]
11677 || (do_using_dynamic
11679 && dynamic_strings
!= NULL
)))
11681 unsigned char nb
[8];
11682 unsigned char nc
[8];
11683 unsigned int hash_ent_size
= 4;
11685 if ((filedata
->file_header
.e_machine
== EM_ALPHA
11686 || filedata
->file_header
.e_machine
== EM_S390
11687 || filedata
->file_header
.e_machine
== EM_S390_OLD
)
11688 && filedata
->file_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
11691 if (fseek (filedata
->handle
,
11692 (archive_file_offset
11693 + offset_from_vma (filedata
, dynamic_info
[DT_HASH
],
11694 sizeof nb
+ sizeof nc
)),
11697 error (_("Unable to seek to start of dynamic information\n"));
11701 if (fread (nb
, hash_ent_size
, 1, filedata
->handle
) != 1)
11703 error (_("Failed to read in number of buckets\n"));
11707 if (fread (nc
, hash_ent_size
, 1, filedata
->handle
) != 1)
11709 error (_("Failed to read in number of chains\n"));
11713 nbuckets
= byte_get (nb
, hash_ent_size
);
11714 nchains
= byte_get (nc
, hash_ent_size
);
11716 buckets
= get_dynamic_data (filedata
, nbuckets
, hash_ent_size
);
11717 chains
= get_dynamic_data (filedata
, nchains
, hash_ent_size
);
11720 if (buckets
== NULL
|| chains
== NULL
)
11722 if (do_using_dynamic
)
11733 if (dynamic_info_DT_GNU_HASH
11735 || (do_using_dynamic
11737 && dynamic_strings
!= NULL
)))
11739 unsigned char nb
[16];
11740 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
11741 bfd_vma buckets_vma
;
11743 if (fseek (filedata
->handle
,
11744 (archive_file_offset
11745 + offset_from_vma (filedata
, dynamic_info_DT_GNU_HASH
,
11749 error (_("Unable to seek to start of dynamic information\n"));
11753 if (fread (nb
, 16, 1, filedata
->handle
) != 1)
11755 error (_("Failed to read in number of buckets\n"));
11759 ngnubuckets
= byte_get (nb
, 4);
11760 gnusymidx
= byte_get (nb
+ 4, 4);
11761 bitmaskwords
= byte_get (nb
+ 8, 4);
11762 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
11764 buckets_vma
+= bitmaskwords
* 4;
11766 buckets_vma
+= bitmaskwords
* 8;
11768 if (fseek (filedata
->handle
,
11769 (archive_file_offset
11770 + offset_from_vma (filedata
, buckets_vma
, 4)),
11773 error (_("Unable to seek to start of dynamic information\n"));
11777 gnubuckets
= get_dynamic_data (filedata
, ngnubuckets
, 4);
11779 if (gnubuckets
== NULL
)
11782 for (i
= 0; i
< ngnubuckets
; i
++)
11783 if (gnubuckets
[i
] != 0)
11785 if (gnubuckets
[i
] < gnusymidx
)
11788 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
11789 maxchain
= gnubuckets
[i
];
11792 if (maxchain
== 0xffffffff)
11795 maxchain
-= gnusymidx
;
11797 if (fseek (filedata
->handle
,
11798 (archive_file_offset
11799 + offset_from_vma (filedata
, buckets_vma
11800 + 4 * (ngnubuckets
+ maxchain
), 4)),
11803 error (_("Unable to seek to start of dynamic information\n"));
11809 if (fread (nb
, 4, 1, filedata
->handle
) != 1)
11811 error (_("Failed to determine last chain length\n"));
11815 if (maxchain
+ 1 == 0)
11820 while ((byte_get (nb
, 4) & 1) == 0);
11822 if (fseek (filedata
->handle
,
11823 (archive_file_offset
11824 + offset_from_vma (filedata
, buckets_vma
+ 4 * ngnubuckets
, 4)),
11827 error (_("Unable to seek to start of dynamic information\n"));
11831 gnuchains
= get_dynamic_data (filedata
, maxchain
, 4);
11832 ngnuchains
= maxchain
;
11835 if (gnuchains
== NULL
)
11840 if (do_using_dynamic
)
11845 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
11847 && do_using_dynamic
11848 && dynamic_strings
!= NULL
11849 && dynamic_symbols
!= NULL
)
11853 if (dynamic_info
[DT_HASH
])
11858 printf (_("\nSymbol table for image:\n"));
11860 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11862 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11864 visited
= xcmalloc (nchains
, 1);
11865 memset (visited
, 0, nchains
);
11866 for (hn
= 0; hn
< nbuckets
; hn
++)
11868 for (si
= buckets
[hn
]; si
> 0; si
= chains
[si
])
11870 print_dynamic_symbol (filedata
, si
, hn
);
11871 if (si
>= nchains
|| visited
[si
])
11873 error (_("histogram chain is corrupt\n"));
11882 if (dynamic_info_DT_GNU_HASH
)
11884 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
11886 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11888 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11890 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11891 if (gnubuckets
[hn
] != 0)
11893 bfd_vma si
= gnubuckets
[hn
];
11894 bfd_vma off
= si
- gnusymidx
;
11898 print_dynamic_symbol (filedata
, si
, hn
);
11901 while (off
< ngnuchains
&& (gnuchains
[off
++] & 1) == 0);
11905 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
11906 && filedata
->section_headers
!= NULL
)
11910 for (i
= 0, section
= filedata
->section_headers
;
11911 i
< filedata
->file_header
.e_shnum
;
11915 char * strtab
= NULL
;
11916 unsigned long int strtab_size
= 0;
11917 Elf_Internal_Sym
* symtab
;
11918 Elf_Internal_Sym
* psym
;
11919 unsigned long num_syms
;
11921 if ((section
->sh_type
!= SHT_SYMTAB
11922 && section
->sh_type
!= SHT_DYNSYM
)
11924 && section
->sh_type
== SHT_SYMTAB
))
11927 if (section
->sh_entsize
== 0)
11929 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
11930 printable_section_name (filedata
, section
));
11934 num_syms
= section
->sh_size
/ section
->sh_entsize
;
11935 printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
11936 "\nSymbol table '%s' contains %lu entries:\n",
11938 printable_section_name (filedata
, section
),
11942 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11944 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11946 symtab
= GET_ELF_SYMBOLS (filedata
, section
, & num_syms
);
11947 if (symtab
== NULL
)
11950 if (section
->sh_link
== filedata
->file_header
.e_shstrndx
)
11952 strtab
= filedata
->string_table
;
11953 strtab_size
= filedata
->string_table_length
;
11955 else if (section
->sh_link
< filedata
->file_header
.e_shnum
)
11957 Elf_Internal_Shdr
* string_sec
;
11959 string_sec
= filedata
->section_headers
+ section
->sh_link
;
11961 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
,
11962 1, string_sec
->sh_size
,
11963 _("string table"));
11964 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
11967 for (si
= 0, psym
= symtab
; si
< num_syms
; si
++, psym
++)
11969 const char *version_string
;
11970 enum versioned_symbol_info sym_info
;
11971 unsigned short vna_other
;
11973 printf ("%6d: ", si
);
11974 print_vma (psym
->st_value
, LONG_HEX
);
11976 print_vma (psym
->st_size
, DEC_5
);
11977 printf (" %-7s", get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)));
11978 printf (" %-6s", get_symbol_binding (filedata
, ELF_ST_BIND (psym
->st_info
)));
11979 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
11980 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
11983 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
11985 printf (" %-7s", get_symbol_visibility (vis
));
11986 /* Check to see if any other bits in the st_other field are set.
11987 Note - displaying this information disrupts the layout of the
11988 table being generated, but for the moment this case is very rare. */
11989 if (psym
->st_other
^ vis
)
11990 printf (" [%s] ", get_symbol_other (filedata
, psym
->st_other
^ vis
));
11992 printf (" %4s ", get_symbol_index_type (filedata
, psym
->st_shndx
));
11993 print_symbol (25, psym
->st_name
< strtab_size
11994 ? strtab
+ psym
->st_name
: _("<corrupt>"));
11997 = get_symbol_version_string (filedata
,
11998 section
->sh_type
== SHT_DYNSYM
,
11999 strtab
, strtab_size
, si
,
12000 psym
, &sym_info
, &vna_other
);
12001 if (version_string
)
12003 if (sym_info
== symbol_undefined
)
12004 printf ("@%s (%d)", version_string
, vna_other
);
12006 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
12012 if (ELF_ST_BIND (psym
->st_info
) == STB_LOCAL
12013 && si
>= section
->sh_info
12014 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
12015 && filedata
->file_header
.e_machine
!= EM_MIPS
12016 /* Solaris binaries have been found to violate this requirement as
12017 well. Not sure if this is a bug or an ABI requirement. */
12018 && filedata
->file_header
.e_ident
[EI_OSABI
] != ELFOSABI_SOLARIS
)
12019 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
12020 si
, printable_section_name (filedata
, section
), section
->sh_info
);
12024 if (strtab
!= filedata
->string_table
)
12030 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
12032 if (do_histogram
&& buckets
!= NULL
)
12034 unsigned long * lengths
;
12035 unsigned long * counts
;
12038 unsigned long maxlength
= 0;
12039 unsigned long nzero_counts
= 0;
12040 unsigned long nsyms
= 0;
12043 printf (ngettext ("\nHistogram for bucket list length "
12044 "(total of %lu bucket):\n",
12045 "\nHistogram for bucket list length "
12046 "(total of %lu buckets):\n",
12047 (unsigned long) nbuckets
),
12048 (unsigned long) nbuckets
);
12050 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
12051 if (lengths
== NULL
)
12053 error (_("Out of memory allocating space for histogram buckets\n"));
12056 visited
= xcmalloc (nchains
, 1);
12057 memset (visited
, 0, nchains
);
12059 printf (_(" Length Number %% of total Coverage\n"));
12060 for (hn
= 0; hn
< nbuckets
; ++hn
)
12062 for (si
= buckets
[hn
]; si
> 0; si
= chains
[si
])
12065 if (maxlength
< ++lengths
[hn
])
12067 if (si
>= nchains
|| visited
[si
])
12069 error (_("histogram chain is corrupt\n"));
12077 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
12078 if (counts
== NULL
)
12081 error (_("Out of memory allocating space for histogram counts\n"));
12085 for (hn
= 0; hn
< nbuckets
; ++hn
)
12086 ++counts
[lengths
[hn
]];
12091 printf (" 0 %-10lu (%5.1f%%)\n",
12092 counts
[0], (counts
[0] * 100.0) / nbuckets
);
12093 for (i
= 1; i
<= maxlength
; ++i
)
12095 nzero_counts
+= counts
[i
] * i
;
12096 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
12097 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
12098 (nzero_counts
* 100.0) / nsyms
);
12106 if (buckets
!= NULL
)
12112 if (do_histogram
&& gnubuckets
!= NULL
)
12114 unsigned long * lengths
;
12115 unsigned long * counts
;
12117 unsigned long maxlength
= 0;
12118 unsigned long nzero_counts
= 0;
12119 unsigned long nsyms
= 0;
12121 printf (ngettext ("\nHistogram for `.gnu.hash' bucket list length "
12122 "(total of %lu bucket):\n",
12123 "\nHistogram for `.gnu.hash' bucket list length "
12124 "(total of %lu buckets):\n",
12125 (unsigned long) ngnubuckets
),
12126 (unsigned long) ngnubuckets
);
12128 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
12129 if (lengths
== NULL
)
12131 error (_("Out of memory allocating space for gnu histogram buckets\n"));
12135 printf (_(" Length Number %% of total Coverage\n"));
12137 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
12138 if (gnubuckets
[hn
] != 0)
12140 bfd_vma off
, length
= 1;
12142 for (off
= gnubuckets
[hn
] - gnusymidx
;
12143 /* PR 17531 file: 010-77222-0.004. */
12144 off
< ngnuchains
&& (gnuchains
[off
] & 1) == 0;
12147 lengths
[hn
] = length
;
12148 if (length
> maxlength
)
12149 maxlength
= length
;
12153 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
12154 if (counts
== NULL
)
12157 error (_("Out of memory allocating space for gnu histogram counts\n"));
12161 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
12162 ++counts
[lengths
[hn
]];
12164 if (ngnubuckets
> 0)
12167 printf (" 0 %-10lu (%5.1f%%)\n",
12168 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
12169 for (j
= 1; j
<= maxlength
; ++j
)
12171 nzero_counts
+= counts
[j
] * j
;
12172 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
12173 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
12174 (nzero_counts
* 100.0) / nsyms
);
12188 process_syminfo (Filedata
* filedata ATTRIBUTE_UNUSED
)
12192 if (dynamic_syminfo
== NULL
12194 /* No syminfo, this is ok. */
12197 /* There better should be a dynamic symbol section. */
12198 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
12202 printf (ngettext ("\nDynamic info segment at offset 0x%lx "
12203 "contains %d entry:\n",
12204 "\nDynamic info segment at offset 0x%lx "
12205 "contains %d entries:\n",
12206 dynamic_syminfo_nent
),
12207 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
12209 printf (_(" Num: Name BoundTo Flags\n"));
12210 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
12212 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
12214 printf ("%4d: ", i
);
12215 if (i
>= num_dynamic_syms
)
12216 printf (_("<corrupt index>"));
12217 else if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
12218 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
12220 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
12223 switch (dynamic_syminfo
[i
].si_boundto
)
12225 case SYMINFO_BT_SELF
:
12226 fputs ("SELF ", stdout
);
12228 case SYMINFO_BT_PARENT
:
12229 fputs ("PARENT ", stdout
);
12232 if (dynamic_syminfo
[i
].si_boundto
> 0
12233 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
12234 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
12236 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
12240 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
12244 if (flags
& SYMINFO_FLG_DIRECT
)
12245 printf (" DIRECT");
12246 if (flags
& SYMINFO_FLG_PASSTHRU
)
12247 printf (" PASSTHRU");
12248 if (flags
& SYMINFO_FLG_COPY
)
12250 if (flags
& SYMINFO_FLG_LAZYLOAD
)
12251 printf (" LAZYLOAD");
12259 #define IN_RANGE(START,END,ADDR,OFF) \
12260 (((ADDR) >= (START)) && ((ADDR) + (OFF) < (END)))
12262 /* Check to see if the given reloc needs to be handled in a target specific
12263 manner. If so then process the reloc and return TRUE otherwise return
12266 If called with reloc == NULL, then this is a signal that reloc processing
12267 for the current section has finished, and any saved state should be
12271 target_specific_reloc_handling (Filedata
* filedata
,
12272 Elf_Internal_Rela
* reloc
,
12273 unsigned char * start
,
12274 unsigned char * end
,
12275 Elf_Internal_Sym
* symtab
,
12276 unsigned long num_syms
)
12278 unsigned int reloc_type
= 0;
12279 unsigned long sym_index
= 0;
12283 reloc_type
= get_reloc_type (filedata
, reloc
->r_info
);
12284 sym_index
= get_reloc_symindex (reloc
->r_info
);
12287 switch (filedata
->file_header
.e_machine
)
12290 case EM_MSP430_OLD
:
12292 static Elf_Internal_Sym
* saved_sym
= NULL
;
12300 switch (reloc_type
)
12302 case 10: /* R_MSP430_SYM_DIFF */
12303 if (uses_msp430x_relocs (filedata
))
12305 /* Fall through. */
12306 case 21: /* R_MSP430X_SYM_DIFF */
12308 if (sym_index
>= num_syms
)
12309 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
12312 saved_sym
= symtab
+ sym_index
;
12315 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
12316 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
12317 goto handle_sym_diff
;
12319 case 5: /* R_MSP430_16_BYTE */
12320 case 9: /* R_MSP430_8 */
12321 if (uses_msp430x_relocs (filedata
))
12323 goto handle_sym_diff
;
12325 case 2: /* R_MSP430_ABS16 */
12326 case 15: /* R_MSP430X_ABS16 */
12327 if (! uses_msp430x_relocs (filedata
))
12329 goto handle_sym_diff
;
12332 if (saved_sym
!= NULL
)
12334 int reloc_size
= reloc_type
== 1 ? 4 : 2;
12337 if (sym_index
>= num_syms
)
12338 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
12342 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12343 - saved_sym
->st_value
);
12345 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12346 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12349 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
12350 (long) reloc
->r_offset
);
12359 if (saved_sym
!= NULL
)
12360 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
12367 case EM_CYGNUS_MN10300
:
12369 static Elf_Internal_Sym
* saved_sym
= NULL
;
12377 switch (reloc_type
)
12379 case 34: /* R_MN10300_ALIGN */
12381 case 33: /* R_MN10300_SYM_DIFF */
12382 if (sym_index
>= num_syms
)
12383 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
12386 saved_sym
= symtab
+ sym_index
;
12389 case 1: /* R_MN10300_32 */
12390 case 2: /* R_MN10300_16 */
12391 if (saved_sym
!= NULL
)
12393 int reloc_size
= reloc_type
== 1 ? 4 : 2;
12396 if (sym_index
>= num_syms
)
12397 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
12401 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12402 - saved_sym
->st_value
);
12404 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12405 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12407 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
12408 (long) reloc
->r_offset
);
12416 if (saved_sym
!= NULL
)
12417 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
12425 static bfd_vma saved_sym1
= 0;
12426 static bfd_vma saved_sym2
= 0;
12427 static bfd_vma value
;
12431 saved_sym1
= saved_sym2
= 0;
12435 switch (reloc_type
)
12437 case 0x80: /* R_RL78_SYM. */
12438 saved_sym1
= saved_sym2
;
12439 if (sym_index
>= num_syms
)
12440 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
12444 saved_sym2
= symtab
[sym_index
].st_value
;
12445 saved_sym2
+= reloc
->r_addend
;
12449 case 0x83: /* R_RL78_OPsub. */
12450 value
= saved_sym1
- saved_sym2
;
12451 saved_sym2
= saved_sym1
= 0;
12455 case 0x41: /* R_RL78_ABS32. */
12456 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 4))
12457 byte_put (start
+ reloc
->r_offset
, value
, 4);
12459 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12460 (long) reloc
->r_offset
);
12464 case 0x43: /* R_RL78_ABS16. */
12465 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 2))
12466 byte_put (start
+ reloc
->r_offset
, value
, 2);
12468 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12469 (long) reloc
->r_offset
);
12483 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12484 DWARF debug sections. This is a target specific test. Note - we do not
12485 go through the whole including-target-headers-multiple-times route, (as
12486 we have already done with <elf/h8.h>) because this would become very
12487 messy and even then this function would have to contain target specific
12488 information (the names of the relocs instead of their numeric values).
12489 FIXME: This is not the correct way to solve this problem. The proper way
12490 is to have target specific reloc sizing and typing functions created by
12491 the reloc-macros.h header, in the same way that it already creates the
12492 reloc naming functions. */
12495 is_32bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12497 /* Please keep this table alpha-sorted for ease of visual lookup. */
12498 switch (filedata
->file_header
.e_machine
)
12502 return reloc_type
== 1; /* R_386_32. */
12504 return reloc_type
== 1; /* R_68K_32. */
12506 return reloc_type
== 1; /* R_860_32. */
12508 return reloc_type
== 2; /* R_960_32. */
12510 return (reloc_type
== 258
12511 || reloc_type
== 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12513 return reloc_type
== 11; /* R_BPF_DATA_32 */
12514 case EM_ADAPTEVA_EPIPHANY
:
12515 return reloc_type
== 3;
12517 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
12519 return reloc_type
== 1; /* R_ARC_32. */
12520 case EM_ARC_COMPACT
:
12521 case EM_ARC_COMPACT2
:
12522 return reloc_type
== 4; /* R_ARC_32. */
12524 return reloc_type
== 2; /* R_ARM_ABS32 */
12527 return reloc_type
== 1;
12529 return reloc_type
== 0x12; /* R_byte4_data. */
12531 return reloc_type
== 3; /* R_CRIS_32. */
12533 return reloc_type
== 3; /* R_CR16_NUM32. */
12535 return reloc_type
== 15; /* R_CRX_NUM32. */
12537 return reloc_type
== 1; /* R_CKCORE_ADDR32. */
12538 case EM_CYGNUS_FRV
:
12539 return reloc_type
== 1;
12540 case EM_CYGNUS_D10V
:
12542 return reloc_type
== 6; /* R_D10V_32. */
12543 case EM_CYGNUS_D30V
:
12545 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
12547 return reloc_type
== 3; /* R_DLX_RELOC_32. */
12548 case EM_CYGNUS_FR30
:
12550 return reloc_type
== 3; /* R_FR30_32. */
12552 return reloc_type
== 1; /* R_FT32_32. */
12556 return reloc_type
== 1; /* R_H8_DIR32. */
12558 return (reloc_type
== 0x64 /* R_IA64_SECREL32MSB. */
12559 || reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
12560 || reloc_type
== 0x24 /* R_IA64_DIR32MSB. */
12561 || reloc_type
== 0x25 /* R_IA64_DIR32LSB. */);
12564 return reloc_type
== 2; /* R_IP2K_32. */
12566 return reloc_type
== 2; /* R_IQ2000_32. */
12567 case EM_LATTICEMICO32
:
12568 return reloc_type
== 3; /* R_LM32_32. */
12571 return reloc_type
== 3; /* R_M32C_32. */
12573 return reloc_type
== 34; /* R_M32R_32_RELA. */
12576 return reloc_type
== 6; /* R_M68HC11_32. */
12578 return reloc_type
== 7 || /* R_S12Z_EXT32 */
12579 reloc_type
== 6; /* R_S12Z_CW32. */
12581 return reloc_type
== 1; /* R_MCORE_ADDR32. */
12582 case EM_CYGNUS_MEP
:
12583 return reloc_type
== 4; /* R_MEP_32. */
12585 return reloc_type
== 2; /* R_METAG_ADDR32. */
12586 case EM_MICROBLAZE
:
12587 return reloc_type
== 1; /* R_MICROBLAZE_32. */
12589 return reloc_type
== 2; /* R_MIPS_32. */
12591 return reloc_type
== 4; /* R_MMIX_32. */
12592 case EM_CYGNUS_MN10200
:
12594 return reloc_type
== 1; /* R_MN10200_32. */
12595 case EM_CYGNUS_MN10300
:
12597 return reloc_type
== 1; /* R_MN10300_32. */
12599 return reloc_type
== 1; /* R_MOXIE_32. */
12600 case EM_MSP430_OLD
:
12602 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
12604 return reloc_type
== 2; /* R_MT_32. */
12606 return reloc_type
== 20; /* R_NDS32_RELA. */
12607 case EM_ALTERA_NIOS2
:
12608 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
12610 return reloc_type
== 1; /* R_NIOS_32. */
12612 return reloc_type
== 1; /* R_OR1K_32. */
12614 return (reloc_type
== 1 /* R_PARISC_DIR32. */
12615 || reloc_type
== 2 /* R_PARISC_DIR21L. */
12616 || reloc_type
== 41); /* R_PARISC_SECREL32. */
12619 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
12621 return reloc_type
== 1; /* R_PPC64_ADDR32. */
12623 return reloc_type
== 1; /* R_PPC_ADDR32. */
12625 return reloc_type
== 11; /* R_PRU_BFD_RELOC_32. */
12627 return reloc_type
== 1; /* R_RISCV_32. */
12629 return reloc_type
== 1; /* R_RL78_DIR32. */
12631 return reloc_type
== 1; /* R_RX_DIR32. */
12633 return reloc_type
== 1; /* R_I370_ADDR31. */
12636 return reloc_type
== 4; /* R_S390_32. */
12638 return reloc_type
== 8; /* R_SCORE_ABS32. */
12640 return reloc_type
== 1; /* R_SH_DIR32. */
12641 case EM_SPARC32PLUS
:
12644 return reloc_type
== 3 /* R_SPARC_32. */
12645 || reloc_type
== 23; /* R_SPARC_UA32. */
12647 return reloc_type
== 6; /* R_SPU_ADDR32 */
12649 return reloc_type
== 1; /* R_C6000_ABS32. */
12651 return reloc_type
== 2; /* R_TILEGX_32. */
12653 return reloc_type
== 1; /* R_TILEPRO_32. */
12654 case EM_CYGNUS_V850
:
12656 return reloc_type
== 6; /* R_V850_ABS32. */
12658 return reloc_type
== 0x33; /* R_V810_WORD. */
12660 return reloc_type
== 1; /* R_VAX_32. */
12662 return reloc_type
== 3; /* R_VISIUM_32. */
12663 case EM_WEBASSEMBLY
:
12664 return reloc_type
== 1; /* R_WASM32_32. */
12668 return reloc_type
== 10; /* R_X86_64_32. */
12671 return reloc_type
== 3; /* R_XC16C_ABS_32. */
12673 return reloc_type
== 4; /* R_XGATE_32. */
12675 return reloc_type
== 1; /* R_XSTROMY16_32. */
12676 case EM_XTENSA_OLD
:
12678 return reloc_type
== 1; /* R_XTENSA_32. */
12681 static unsigned int prev_warn
= 0;
12683 /* Avoid repeating the same warning multiple times. */
12684 if (prev_warn
!= filedata
->file_header
.e_machine
)
12685 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12686 filedata
->file_header
.e_machine
);
12687 prev_warn
= filedata
->file_header
.e_machine
;
12693 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12694 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
12697 is_32bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12699 switch (filedata
->file_header
.e_machine
)
12700 /* Please keep this table alpha-sorted for ease of visual lookup. */
12704 return reloc_type
== 2; /* R_386_PC32. */
12706 return reloc_type
== 4; /* R_68K_PC32. */
12708 return reloc_type
== 261; /* R_AARCH64_PREL32 */
12709 case EM_ADAPTEVA_EPIPHANY
:
12710 return reloc_type
== 6;
12712 return reloc_type
== 10; /* R_ALPHA_SREL32. */
12713 case EM_ARC_COMPACT
:
12714 case EM_ARC_COMPACT2
:
12715 return reloc_type
== 49; /* R_ARC_32_PCREL. */
12717 return reloc_type
== 3; /* R_ARM_REL32 */
12720 return reloc_type
== 36; /* R_AVR_32_PCREL. */
12721 case EM_MICROBLAZE
:
12722 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
12724 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
12726 return reloc_type
== 9; /* R_PARISC_PCREL32. */
12728 return reloc_type
== 26; /* R_PPC_REL32. */
12730 return reloc_type
== 26; /* R_PPC64_REL32. */
12732 return reloc_type
== 57; /* R_RISCV_32_PCREL. */
12735 return reloc_type
== 5; /* R_390_PC32. */
12737 return reloc_type
== 2; /* R_SH_REL32. */
12738 case EM_SPARC32PLUS
:
12741 return reloc_type
== 6; /* R_SPARC_DISP32. */
12743 return reloc_type
== 13; /* R_SPU_REL32. */
12745 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
12747 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
12749 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
12753 return reloc_type
== 2; /* R_X86_64_PC32. */
12755 return reloc_type
== 4; /* R_VAX_PCREL32. */
12756 case EM_XTENSA_OLD
:
12758 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
12760 /* Do not abort or issue an error message here. Not all targets use
12761 pc-relative 32-bit relocs in their DWARF debug information and we
12762 have already tested for target coverage in is_32bit_abs_reloc. A
12763 more helpful warning message will be generated by apply_relocations
12764 anyway, so just return. */
12769 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12770 a 64-bit absolute RELA relocation used in DWARF debug sections. */
12773 is_64bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12775 switch (filedata
->file_header
.e_machine
)
12778 return reloc_type
== 257; /* R_AARCH64_ABS64. */
12780 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
12782 return (reloc_type
== 0x26 /* R_IA64_DIR64MSB. */
12783 || reloc_type
== 0x27 /* R_IA64_DIR64LSB. */);
12785 return reloc_type
== 80; /* R_PARISC_DIR64. */
12787 return reloc_type
== 38; /* R_PPC64_ADDR64. */
12789 return reloc_type
== 2; /* R_RISCV_64. */
12790 case EM_SPARC32PLUS
:
12793 return reloc_type
== 32 /* R_SPARC_64. */
12794 || reloc_type
== 54; /* R_SPARC_UA64. */
12798 return reloc_type
== 1; /* R_X86_64_64. */
12801 return reloc_type
== 22; /* R_S390_64. */
12803 return reloc_type
== 1; /* R_TILEGX_64. */
12805 return reloc_type
== 18; /* R_MIPS_64. */
12811 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12812 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
12815 is_64bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12817 switch (filedata
->file_header
.e_machine
)
12820 return reloc_type
== 260; /* R_AARCH64_PREL64. */
12822 return reloc_type
== 11; /* R_ALPHA_SREL64. */
12824 return (reloc_type
== 0x4e /* R_IA64_PCREL64MSB. */
12825 || reloc_type
== 0x4f /* R_IA64_PCREL64LSB. */);
12827 return reloc_type
== 72; /* R_PARISC_PCREL64. */
12829 return reloc_type
== 44; /* R_PPC64_REL64. */
12830 case EM_SPARC32PLUS
:
12833 return reloc_type
== 46; /* R_SPARC_DISP64. */
12837 return reloc_type
== 24; /* R_X86_64_PC64. */
12840 return reloc_type
== 23; /* R_S390_PC64. */
12842 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
12848 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12849 a 24-bit absolute RELA relocation used in DWARF debug sections. */
12852 is_24bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12854 switch (filedata
->file_header
.e_machine
)
12856 case EM_CYGNUS_MN10200
:
12858 return reloc_type
== 4; /* R_MN10200_24. */
12860 return reloc_type
== 5; /* R_FT32_20. */
12866 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12867 a 16-bit absolute RELA relocation used in DWARF debug sections. */
12870 is_16bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12872 /* Please keep this table alpha-sorted for ease of visual lookup. */
12873 switch (filedata
->file_header
.e_machine
)
12876 case EM_ARC_COMPACT
:
12877 case EM_ARC_COMPACT2
:
12878 return reloc_type
== 2; /* R_ARC_16. */
12879 case EM_ADAPTEVA_EPIPHANY
:
12880 return reloc_type
== 5;
12883 return reloc_type
== 4; /* R_AVR_16. */
12884 case EM_CYGNUS_D10V
:
12886 return reloc_type
== 3; /* R_D10V_16. */
12888 return reloc_type
== 2; /* R_FT32_16. */
12892 return reloc_type
== R_H8_DIR16
;
12895 return reloc_type
== 1; /* R_IP2K_16. */
12898 return reloc_type
== 1; /* R_M32C_16 */
12899 case EM_CYGNUS_MN10200
:
12901 return reloc_type
== 2; /* R_MN10200_16. */
12902 case EM_CYGNUS_MN10300
:
12904 return reloc_type
== 2; /* R_MN10300_16. */
12906 if (uses_msp430x_relocs (filedata
))
12907 return reloc_type
== 2; /* R_MSP430_ABS16. */
12908 /* Fall through. */
12909 case EM_MSP430_OLD
:
12910 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
12912 return reloc_type
== 19; /* R_NDS32_RELA. */
12913 case EM_ALTERA_NIOS2
:
12914 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
12916 return reloc_type
== 9; /* R_NIOS_16. */
12918 return reloc_type
== 2; /* R_OR1K_16. */
12920 return reloc_type
== 55; /* R_RISCV_SET16. */
12922 return reloc_type
== 8; /* R_PRU_BFD_RELOC_16. */
12924 return reloc_type
== 2; /* R_C6000_ABS16. */
12926 return reloc_type
== 2; /* R_VISIUM_16. */
12929 return reloc_type
== 2; /* R_XC16C_ABS_16. */
12931 return reloc_type
== 3; /* R_XGATE_16. */
12937 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12938 a 8-bit absolute RELA relocation used in DWARF debug sections. */
12941 is_8bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12943 switch (filedata
->file_header
.e_machine
)
12946 return reloc_type
== 54; /* R_RISCV_SET8. */
12952 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12953 a 6-bit absolute RELA relocation used in DWARF debug sections. */
12956 is_6bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12958 switch (filedata
->file_header
.e_machine
)
12961 return reloc_type
== 53; /* R_RISCV_SET6. */
12967 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12968 a 32-bit inplace add RELA relocation used in DWARF debug sections. */
12971 is_32bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12973 /* Please keep this table alpha-sorted for ease of visual lookup. */
12974 switch (filedata
->file_header
.e_machine
)
12977 return reloc_type
== 35; /* R_RISCV_ADD32. */
12983 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12984 a 32-bit inplace sub RELA relocation used in DWARF debug sections. */
12987 is_32bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12989 /* Please keep this table alpha-sorted for ease of visual lookup. */
12990 switch (filedata
->file_header
.e_machine
)
12993 return reloc_type
== 39; /* R_RISCV_SUB32. */
12999 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13000 a 64-bit inplace add RELA relocation used in DWARF debug sections. */
13003 is_64bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13005 /* Please keep this table alpha-sorted for ease of visual lookup. */
13006 switch (filedata
->file_header
.e_machine
)
13009 return reloc_type
== 36; /* R_RISCV_ADD64. */
13015 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13016 a 64-bit inplace sub RELA relocation used in DWARF debug sections. */
13019 is_64bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13021 /* Please keep this table alpha-sorted for ease of visual lookup. */
13022 switch (filedata
->file_header
.e_machine
)
13025 return reloc_type
== 40; /* R_RISCV_SUB64. */
13031 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13032 a 16-bit inplace add RELA relocation used in DWARF debug sections. */
13035 is_16bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13037 /* Please keep this table alpha-sorted for ease of visual lookup. */
13038 switch (filedata
->file_header
.e_machine
)
13041 return reloc_type
== 34; /* R_RISCV_ADD16. */
13047 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13048 a 16-bit inplace sub RELA relocation used in DWARF debug sections. */
13051 is_16bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13053 /* Please keep this table alpha-sorted for ease of visual lookup. */
13054 switch (filedata
->file_header
.e_machine
)
13057 return reloc_type
== 38; /* R_RISCV_SUB16. */
13063 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13064 a 8-bit inplace add RELA relocation used in DWARF debug sections. */
13067 is_8bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13069 /* Please keep this table alpha-sorted for ease of visual lookup. */
13070 switch (filedata
->file_header
.e_machine
)
13073 return reloc_type
== 33; /* R_RISCV_ADD8. */
13079 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13080 a 8-bit inplace sub RELA relocation used in DWARF debug sections. */
13083 is_8bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13085 /* Please keep this table alpha-sorted for ease of visual lookup. */
13086 switch (filedata
->file_header
.e_machine
)
13089 return reloc_type
== 37; /* R_RISCV_SUB8. */
13095 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
13096 a 6-bit inplace sub RELA relocation used in DWARF debug sections. */
13099 is_6bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13101 switch (filedata
->file_header
.e_machine
)
13104 return reloc_type
== 52; /* R_RISCV_SUB6. */
13110 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
13111 relocation entries (possibly formerly used for SHT_GROUP sections). */
13114 is_none_reloc (Filedata
* filedata
, unsigned int reloc_type
)
13116 switch (filedata
->file_header
.e_machine
)
13118 case EM_386
: /* R_386_NONE. */
13119 case EM_68K
: /* R_68K_NONE. */
13120 case EM_ADAPTEVA_EPIPHANY
:
13121 case EM_ALPHA
: /* R_ALPHA_NONE. */
13122 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
13123 case EM_ARC
: /* R_ARC_NONE. */
13124 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
13125 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
13126 case EM_ARM
: /* R_ARM_NONE. */
13127 case EM_C166
: /* R_XC16X_NONE. */
13128 case EM_CRIS
: /* R_CRIS_NONE. */
13129 case EM_FT32
: /* R_FT32_NONE. */
13130 case EM_IA_64
: /* R_IA64_NONE. */
13131 case EM_K1OM
: /* R_X86_64_NONE. */
13132 case EM_L1OM
: /* R_X86_64_NONE. */
13133 case EM_M32R
: /* R_M32R_NONE. */
13134 case EM_MIPS
: /* R_MIPS_NONE. */
13135 case EM_MN10300
: /* R_MN10300_NONE. */
13136 case EM_MOXIE
: /* R_MOXIE_NONE. */
13137 case EM_NIOS32
: /* R_NIOS_NONE. */
13138 case EM_OR1K
: /* R_OR1K_NONE. */
13139 case EM_PARISC
: /* R_PARISC_NONE. */
13140 case EM_PPC64
: /* R_PPC64_NONE. */
13141 case EM_PPC
: /* R_PPC_NONE. */
13142 case EM_RISCV
: /* R_RISCV_NONE. */
13143 case EM_S390
: /* R_390_NONE. */
13145 case EM_SH
: /* R_SH_NONE. */
13146 case EM_SPARC32PLUS
:
13147 case EM_SPARC
: /* R_SPARC_NONE. */
13149 case EM_TILEGX
: /* R_TILEGX_NONE. */
13150 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
13151 case EM_TI_C6000
:/* R_C6000_NONE. */
13152 case EM_X86_64
: /* R_X86_64_NONE. */
13154 case EM_WEBASSEMBLY
: /* R_WASM32_NONE. */
13155 return reloc_type
== 0;
13158 return reloc_type
== 0 || reloc_type
== 256;
13161 return (reloc_type
== 0 /* R_AVR_NONE. */
13162 || reloc_type
== 30 /* R_AVR_DIFF8. */
13163 || reloc_type
== 31 /* R_AVR_DIFF16. */
13164 || reloc_type
== 32 /* R_AVR_DIFF32. */);
13166 return reloc_type
== 3; /* R_METAG_NONE. */
13168 return (reloc_type
== 0 /* R_XTENSA_NONE. */
13169 || reloc_type
== 204 /* R_NDS32_DIFF8. */
13170 || reloc_type
== 205 /* R_NDS32_DIFF16. */
13171 || reloc_type
== 206 /* R_NDS32_DIFF32. */
13172 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
13174 return (reloc_type
== 0 /* R_PRU_NONE. */
13175 || reloc_type
== 65 /* R_PRU_DIFF8. */
13176 || reloc_type
== 66 /* R_PRU_DIFF16. */
13177 || reloc_type
== 67 /* R_PRU_DIFF32. */);
13178 case EM_XTENSA_OLD
:
13180 return (reloc_type
== 0 /* R_XTENSA_NONE. */
13181 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
13182 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
13183 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
13188 /* Returns TRUE if there is a relocation against
13189 section NAME at OFFSET bytes. */
13192 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
13194 Elf_Internal_Rela
* relocs
;
13195 Elf_Internal_Rela
* rp
;
13197 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
13200 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
13202 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
13203 if (rp
->r_offset
== offset
)
13209 /* Apply relocations to a section.
13210 Returns TRUE upon success, FALSE otherwise.
13211 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
13212 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
13213 will be set to the number of relocs loaded.
13215 Note: So far support has been added only for those relocations
13216 which can be found in debug sections. FIXME: Add support for
13217 more relocations ? */
13220 apply_relocations (Filedata
* filedata
,
13221 const Elf_Internal_Shdr
* section
,
13222 unsigned char * start
,
13223 bfd_size_type size
,
13224 void ** relocs_return
,
13225 unsigned long * num_relocs_return
)
13227 Elf_Internal_Shdr
* relsec
;
13228 unsigned char * end
= start
+ size
;
13230 if (relocs_return
!= NULL
)
13232 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
13233 * num_relocs_return
= 0;
13236 if (filedata
->file_header
.e_type
!= ET_REL
)
13237 /* No relocs to apply. */
13240 /* Find the reloc section associated with the section. */
13241 for (relsec
= filedata
->section_headers
;
13242 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13245 bfd_boolean is_rela
;
13246 unsigned long num_relocs
;
13247 Elf_Internal_Rela
* relocs
;
13248 Elf_Internal_Rela
* rp
;
13249 Elf_Internal_Shdr
* symsec
;
13250 Elf_Internal_Sym
* symtab
;
13251 unsigned long num_syms
;
13252 Elf_Internal_Sym
* sym
;
13254 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13255 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13256 || filedata
->section_headers
+ relsec
->sh_info
!= section
13257 || relsec
->sh_size
== 0
13258 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13261 is_rela
= relsec
->sh_type
== SHT_RELA
;
13265 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
,
13266 relsec
->sh_size
, & relocs
, & num_relocs
))
13271 if (!slurp_rel_relocs (filedata
, relsec
->sh_offset
,
13272 relsec
->sh_size
, & relocs
, & num_relocs
))
13276 /* SH uses RELA but uses in place value instead of the addend field. */
13277 if (filedata
->file_header
.e_machine
== EM_SH
)
13280 symsec
= filedata
->section_headers
+ relsec
->sh_link
;
13281 if (symsec
->sh_type
!= SHT_SYMTAB
13282 && symsec
->sh_type
!= SHT_DYNSYM
)
13284 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & num_syms
);
13286 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
13289 unsigned int reloc_type
;
13290 unsigned int reloc_size
;
13291 bfd_boolean reloc_inplace
= FALSE
;
13292 bfd_boolean reloc_subtract
= FALSE
;
13293 unsigned char * rloc
;
13294 unsigned long sym_index
;
13296 reloc_type
= get_reloc_type (filedata
, rp
->r_info
);
13298 if (target_specific_reloc_handling (filedata
, rp
, start
, end
, symtab
, num_syms
))
13300 else if (is_none_reloc (filedata
, reloc_type
))
13302 else if (is_32bit_abs_reloc (filedata
, reloc_type
)
13303 || is_32bit_pcrel_reloc (filedata
, reloc_type
))
13305 else if (is_64bit_abs_reloc (filedata
, reloc_type
)
13306 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
13308 else if (is_24bit_abs_reloc (filedata
, reloc_type
))
13310 else if (is_16bit_abs_reloc (filedata
, reloc_type
))
13312 else if (is_8bit_abs_reloc (filedata
, reloc_type
)
13313 || is_6bit_abs_reloc (filedata
, reloc_type
))
13315 else if ((reloc_subtract
= is_32bit_inplace_sub_reloc (filedata
,
13317 || is_32bit_inplace_add_reloc (filedata
, reloc_type
))
13320 reloc_inplace
= TRUE
;
13322 else if ((reloc_subtract
= is_64bit_inplace_sub_reloc (filedata
,
13324 || is_64bit_inplace_add_reloc (filedata
, reloc_type
))
13327 reloc_inplace
= TRUE
;
13329 else if ((reloc_subtract
= is_16bit_inplace_sub_reloc (filedata
,
13331 || is_16bit_inplace_add_reloc (filedata
, reloc_type
))
13334 reloc_inplace
= TRUE
;
13336 else if ((reloc_subtract
= is_8bit_inplace_sub_reloc (filedata
,
13338 || is_8bit_inplace_add_reloc (filedata
, reloc_type
))
13341 reloc_inplace
= TRUE
;
13343 else if ((reloc_subtract
= is_6bit_inplace_sub_reloc (filedata
,
13347 reloc_inplace
= TRUE
;
13351 static unsigned int prev_reloc
= 0;
13353 if (reloc_type
!= prev_reloc
)
13354 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
13355 reloc_type
, printable_section_name (filedata
, section
));
13356 prev_reloc
= reloc_type
;
13360 rloc
= start
+ rp
->r_offset
;
13361 if ((rloc
+ reloc_size
) > end
|| (rloc
< start
))
13363 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
13364 (unsigned long) rp
->r_offset
,
13365 printable_section_name (filedata
, section
));
13369 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
13370 if (sym_index
>= num_syms
)
13372 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
13373 sym_index
, printable_section_name (filedata
, section
));
13376 sym
= symtab
+ sym_index
;
13378 /* If the reloc has a symbol associated with it,
13379 make sure that it is of an appropriate type.
13381 Relocations against symbols without type can happen.
13382 Gcc -feliminate-dwarf2-dups may generate symbols
13383 without type for debug info.
13385 Icc generates relocations against function symbols
13386 instead of local labels.
13388 Relocations against object symbols can happen, eg when
13389 referencing a global array. For an example of this see
13390 the _clz.o binary in libgcc.a. */
13392 && ELF_ST_TYPE (sym
->st_info
) != STT_COMMON
13393 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
13395 warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
13396 get_symbol_type (filedata
, ELF_ST_TYPE (sym
->st_info
)),
13397 printable_section_name (filedata
, relsec
),
13398 (long int)(rp
- relocs
));
13404 addend
+= rp
->r_addend
;
13405 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
13406 partial_inplace. */
13408 || (filedata
->file_header
.e_machine
== EM_XTENSA
13409 && reloc_type
== 1)
13410 || ((filedata
->file_header
.e_machine
== EM_PJ
13411 || filedata
->file_header
.e_machine
== EM_PJ_OLD
)
13412 && reloc_type
== 1)
13413 || ((filedata
->file_header
.e_machine
== EM_D30V
13414 || filedata
->file_header
.e_machine
== EM_CYGNUS_D30V
)
13415 && reloc_type
== 12)
13418 if (is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
13419 addend
+= byte_get (rloc
, reloc_size
) & 0x3f;
13421 addend
+= byte_get (rloc
, reloc_size
);
13424 if (is_32bit_pcrel_reloc (filedata
, reloc_type
)
13425 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
13427 /* On HPPA, all pc-relative relocations are biased by 8. */
13428 if (filedata
->file_header
.e_machine
== EM_PARISC
)
13430 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
13433 else if (is_6bit_abs_reloc (filedata
, reloc_type
)
13434 || is_6bit_inplace_sub_reloc (filedata
, reloc_type
))
13436 if (reloc_subtract
)
13437 addend
-= sym
->st_value
;
13439 addend
+= sym
->st_value
;
13440 addend
= (addend
& 0x3f) | (byte_get (rloc
, reloc_size
) & 0xc0);
13441 byte_put (rloc
, addend
, reloc_size
);
13443 else if (reloc_subtract
)
13444 byte_put (rloc
, addend
- sym
->st_value
, reloc_size
);
13446 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
13450 /* Let the target specific reloc processing code know that
13451 we have finished with these relocs. */
13452 target_specific_reloc_handling (filedata
, NULL
, NULL
, NULL
, NULL
, 0);
13456 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
13457 * num_relocs_return
= num_relocs
;
13468 #ifdef SUPPORT_DISASSEMBLY
13470 disassemble_section (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13472 printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata
, section
));
13474 /* FIXME: XXX -- to be done --- XXX */
13480 /* Reads in the contents of SECTION from FILE, returning a pointer
13481 to a malloc'ed buffer or NULL if something went wrong. */
13484 get_section_contents (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13486 bfd_size_type num_bytes
= section
->sh_size
;
13488 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
13490 printf (_("Section '%s' has no data to dump.\n"),
13491 printable_section_name (filedata
, section
));
13495 return (char *) get_data (NULL
, filedata
, section
->sh_offset
, 1, num_bytes
,
13496 _("section contents"));
13499 /* Uncompresses a section that was compressed using zlib, in place. */
13502 uncompress_section_contents (unsigned char ** buffer
,
13503 dwarf_size_type uncompressed_size
,
13504 dwarf_size_type
* size
)
13506 dwarf_size_type compressed_size
= *size
;
13507 unsigned char * compressed_buffer
= *buffer
;
13508 unsigned char * uncompressed_buffer
;
13512 /* It is possible the section consists of several compressed
13513 buffers concatenated together, so we uncompress in a loop. */
13514 /* PR 18313: The state field in the z_stream structure is supposed
13515 to be invisible to the user (ie us), but some compilers will
13516 still complain about it being used without initialisation. So
13517 we first zero the entire z_stream structure and then set the fields
13519 memset (& strm
, 0, sizeof strm
);
13520 strm
.avail_in
= compressed_size
;
13521 strm
.next_in
= (Bytef
*) compressed_buffer
;
13522 strm
.avail_out
= uncompressed_size
;
13523 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
13525 rc
= inflateInit (& strm
);
13526 while (strm
.avail_in
> 0)
13530 strm
.next_out
= ((Bytef
*) uncompressed_buffer
13531 + (uncompressed_size
- strm
.avail_out
));
13532 rc
= inflate (&strm
, Z_FINISH
);
13533 if (rc
!= Z_STREAM_END
)
13535 rc
= inflateReset (& strm
);
13537 rc
= inflateEnd (& strm
);
13539 || strm
.avail_out
!= 0)
13542 *buffer
= uncompressed_buffer
;
13543 *size
= uncompressed_size
;
13547 free (uncompressed_buffer
);
13548 /* Indicate decompression failure. */
13554 dump_section_as_strings (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13556 Elf_Internal_Shdr
* relsec
;
13557 bfd_size_type num_bytes
;
13558 unsigned char * data
;
13559 unsigned char * end
;
13560 unsigned char * real_start
;
13561 unsigned char * start
;
13562 bfd_boolean some_strings_shown
;
13564 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
13566 /* PR 21820: Do not fail if the section was empty. */
13567 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
13569 num_bytes
= section
->sh_size
;
13571 printf (_("\nString dump of section '%s':\n"), printable_section_name (filedata
, section
));
13573 if (decompress_dumps
)
13575 dwarf_size_type new_size
= num_bytes
;
13576 dwarf_size_type uncompressed_size
= 0;
13578 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
13580 Elf_Internal_Chdr chdr
;
13581 unsigned int compression_header_size
13582 = get_compression_header (& chdr
, (unsigned char *) start
,
13585 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13587 warn (_("section '%s' has unsupported compress type: %d\n"),
13588 printable_section_name (filedata
, section
), chdr
.ch_type
);
13591 uncompressed_size
= chdr
.ch_size
;
13592 start
+= compression_header_size
;
13593 new_size
-= compression_header_size
;
13595 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
13597 /* Read the zlib header. In this case, it should be "ZLIB"
13598 followed by the uncompressed section size, 8 bytes in
13599 big-endian order. */
13600 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13601 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13602 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13603 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13604 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13605 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13606 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13607 uncompressed_size
+= start
[11];
13612 if (uncompressed_size
)
13614 if (uncompress_section_contents (& start
,
13615 uncompressed_size
, & new_size
))
13616 num_bytes
= new_size
;
13619 error (_("Unable to decompress section %s\n"),
13620 printable_section_name (filedata
, section
));
13625 start
= real_start
;
13628 /* If the section being dumped has relocations against it the user might
13629 be expecting these relocations to have been applied. Check for this
13630 case and issue a warning message in order to avoid confusion.
13631 FIXME: Maybe we ought to have an option that dumps a section with
13632 relocs applied ? */
13633 for (relsec
= filedata
->section_headers
;
13634 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13637 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13638 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13639 || filedata
->section_headers
+ relsec
->sh_info
!= section
13640 || relsec
->sh_size
== 0
13641 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13644 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13649 end
= start
+ num_bytes
;
13650 some_strings_shown
= FALSE
;
13654 while (!ISPRINT (* data
))
13655 if (++ data
>= end
)
13660 size_t maxlen
= end
- data
;
13663 /* PR 11128: Use two separate invocations in order to work
13664 around bugs in the Solaris 8 implementation of printf. */
13665 printf (" [%6tx] ", data
- start
);
13667 printf (" [%6Ix] ", (size_t) (data
- start
));
13671 print_symbol ((int) maxlen
, (const char *) data
);
13673 data
+= strnlen ((const char *) data
, maxlen
);
13677 printf (_("<corrupt>\n"));
13680 some_strings_shown
= TRUE
;
13684 if (! some_strings_shown
)
13685 printf (_(" No strings found in this section."));
13694 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
13695 Filedata
* filedata
,
13696 bfd_boolean relocate
)
13698 Elf_Internal_Shdr
* relsec
;
13699 bfd_size_type bytes
;
13700 bfd_size_type section_size
;
13702 unsigned char * data
;
13703 unsigned char * real_start
;
13704 unsigned char * start
;
13706 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
13708 /* PR 21820: Do not fail if the section was empty. */
13709 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
13711 section_size
= section
->sh_size
;
13713 printf (_("\nHex dump of section '%s':\n"), printable_section_name (filedata
, section
));
13715 if (decompress_dumps
)
13717 dwarf_size_type new_size
= section_size
;
13718 dwarf_size_type uncompressed_size
= 0;
13720 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
13722 Elf_Internal_Chdr chdr
;
13723 unsigned int compression_header_size
13724 = get_compression_header (& chdr
, start
, section_size
);
13726 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13728 warn (_("section '%s' has unsupported compress type: %d\n"),
13729 printable_section_name (filedata
, section
), chdr
.ch_type
);
13732 uncompressed_size
= chdr
.ch_size
;
13733 start
+= compression_header_size
;
13734 new_size
-= compression_header_size
;
13736 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
13738 /* Read the zlib header. In this case, it should be "ZLIB"
13739 followed by the uncompressed section size, 8 bytes in
13740 big-endian order. */
13741 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13742 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13743 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13744 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13745 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13746 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13747 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13748 uncompressed_size
+= start
[11];
13753 if (uncompressed_size
)
13755 if (uncompress_section_contents (& start
, uncompressed_size
,
13758 section_size
= new_size
;
13762 error (_("Unable to decompress section %s\n"),
13763 printable_section_name (filedata
, section
));
13764 /* FIXME: Print the section anyway ? */
13769 start
= real_start
;
13774 if (! apply_relocations (filedata
, section
, start
, section_size
, NULL
, NULL
))
13779 /* If the section being dumped has relocations against it the user might
13780 be expecting these relocations to have been applied. Check for this
13781 case and issue a warning message in order to avoid confusion.
13782 FIXME: Maybe we ought to have an option that dumps a section with
13783 relocs applied ? */
13784 for (relsec
= filedata
->section_headers
;
13785 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13788 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13789 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13790 || filedata
->section_headers
+ relsec
->sh_info
!= section
13791 || relsec
->sh_size
== 0
13792 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13795 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13800 addr
= section
->sh_addr
;
13801 bytes
= section_size
;
13810 lbytes
= (bytes
> 16 ? 16 : bytes
);
13812 printf (" 0x%8.8lx ", (unsigned long) addr
);
13814 for (j
= 0; j
< 16; j
++)
13817 printf ("%2.2x", data
[j
]);
13825 for (j
= 0; j
< lbytes
; j
++)
13828 if (k
>= ' ' && k
< 0x7f)
13847 static ctf_sect_t
*
13848 shdr_to_ctf_sect (ctf_sect_t
*buf
, Elf_Internal_Shdr
*shdr
, Filedata
*filedata
)
13850 buf
->cts_name
= SECTION_NAME (shdr
);
13851 buf
->cts_size
= shdr
->sh_size
;
13852 buf
->cts_entsize
= shdr
->sh_entsize
;
13857 /* Formatting callback function passed to ctf_dump. Returns either the pointer
13858 it is passed, or a pointer to newly-allocated storage, in which case
13859 dump_ctf() will free it when it no longer needs it. */
13861 static char *dump_ctf_indent_lines (ctf_sect_names_t sect ATTRIBUTE_UNUSED
,
13862 char *s
, void *arg
)
13864 const char *blanks
= arg
;
13867 if (asprintf (&new_s
, "%s%s", blanks
, s
) < 0)
13873 dump_section_as_ctf (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13875 Elf_Internal_Shdr
* parent_sec
= NULL
;
13876 Elf_Internal_Shdr
* symtab_sec
= NULL
;
13877 Elf_Internal_Shdr
* strtab_sec
= NULL
;
13878 void * data
= NULL
;
13879 void * symdata
= NULL
;
13880 void * strdata
= NULL
;
13881 void * parentdata
= NULL
;
13882 ctf_sect_t ctfsect
, symsect
, strsect
, parentsect
;
13883 ctf_sect_t
* symsectp
= NULL
;
13884 ctf_sect_t
* strsectp
= NULL
;
13885 ctf_file_t
* ctf
= NULL
;
13886 ctf_file_t
* parent
= NULL
;
13888 const char *things
[] = {"Labels", "Data objects", "Function objects",
13889 "Variables", "Types", "Strings", ""};
13890 const char **thing
;
13892 bfd_boolean ret
= FALSE
;
13895 shdr_to_ctf_sect (&ctfsect
, section
, filedata
);
13896 data
= get_section_contents (section
, filedata
);
13897 ctfsect
.cts_data
= data
;
13899 if (dump_ctf_symtab_name
)
13901 if ((symtab_sec
= find_section (filedata
, dump_ctf_symtab_name
)) == NULL
)
13903 error (_("No symbol section named %s\n"), dump_ctf_symtab_name
);
13906 if ((symdata
= (void *) get_data (NULL
, filedata
,
13907 symtab_sec
->sh_offset
, 1,
13908 symtab_sec
->sh_size
,
13909 _("symbols"))) == NULL
)
13911 symsectp
= shdr_to_ctf_sect (&symsect
, symtab_sec
, filedata
);
13912 symsect
.cts_data
= symdata
;
13914 if (dump_ctf_strtab_name
)
13916 if ((strtab_sec
= find_section (filedata
, dump_ctf_strtab_name
)) == NULL
)
13918 error (_("No string table section named %s\n"),
13919 dump_ctf_strtab_name
);
13922 if ((strdata
= (void *) get_data (NULL
, filedata
,
13923 strtab_sec
->sh_offset
, 1,
13924 strtab_sec
->sh_size
,
13925 _("strings"))) == NULL
)
13927 strsectp
= shdr_to_ctf_sect (&strsect
, strtab_sec
, filedata
);
13928 strsect
.cts_data
= strdata
;
13930 if (dump_ctf_parent_name
)
13932 if ((parent_sec
= find_section (filedata
, dump_ctf_parent_name
)) == NULL
)
13934 error (_("No CTF parent section named %s\n"), dump_ctf_parent_name
);
13937 if ((parentdata
= (void *) get_data (NULL
, filedata
,
13938 parent_sec
->sh_offset
, 1,
13939 parent_sec
->sh_size
,
13940 _("CTF parent"))) == NULL
)
13942 shdr_to_ctf_sect (&parentsect
, parent_sec
, filedata
);
13943 parentsect
.cts_data
= parentdata
;
13946 /* Load the CTF file and dump it. */
13948 if ((ctf
= ctf_bufopen (&ctfsect
, symsectp
, strsectp
, &err
)) == NULL
)
13950 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
13956 if ((parent
= ctf_bufopen (&parentsect
, symsectp
, strsectp
, &err
)) == NULL
)
13958 error (_("CTF open failure: %s\n"), ctf_errmsg (err
));
13962 ctf_import (ctf
, parent
);
13967 printf (_("\nDump of CTF section '%s':\n"),
13968 printable_section_name (filedata
, section
));
13970 for (i
= 1, thing
= things
; *thing
[0]; thing
++, i
++)
13972 ctf_dump_state_t
*s
= NULL
;
13975 printf ("\n %s:\n", *thing
);
13976 while ((item
= ctf_dump (ctf
, &s
, i
, dump_ctf_indent_lines
,
13977 (void *) " ")) != NULL
)
13979 printf ("%s\n", item
);
13983 if (ctf_errno (ctf
))
13985 error (_("Iteration failed: %s, %s\n"), *thing
,
13986 ctf_errmsg (ctf_errno (ctf
)));
13992 ctf_file_close (ctf
);
13993 ctf_file_close (parent
);
14002 load_specific_debug_section (enum dwarf_section_display_enum debug
,
14003 const Elf_Internal_Shdr
* sec
,
14006 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14008 Filedata
* filedata
= (Filedata
*) data
;
14010 if (section
->start
!= NULL
)
14012 /* If it is already loaded, do nothing. */
14013 if (streq (section
->filename
, filedata
->file_name
))
14015 free (section
->start
);
14018 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
14019 section
->address
= sec
->sh_addr
;
14020 section
->user_data
= NULL
;
14021 section
->filename
= filedata
->file_name
;
14022 section
->start
= (unsigned char *) get_data (NULL
, filedata
,
14024 sec
->sh_size
, buf
);
14025 if (section
->start
== NULL
)
14029 unsigned char *start
= section
->start
;
14030 dwarf_size_type size
= sec
->sh_size
;
14031 dwarf_size_type uncompressed_size
= 0;
14033 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
14035 Elf_Internal_Chdr chdr
;
14036 unsigned int compression_header_size
;
14038 if (size
< (is_32bit_elf
14039 ? sizeof (Elf32_External_Chdr
)
14040 : sizeof (Elf64_External_Chdr
)))
14042 warn (_("compressed section %s is too small to contain a compression header"),
14047 compression_header_size
= get_compression_header (&chdr
, start
, size
);
14049 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
14051 warn (_("section '%s' has unsupported compress type: %d\n"),
14052 section
->name
, chdr
.ch_type
);
14055 uncompressed_size
= chdr
.ch_size
;
14056 start
+= compression_header_size
;
14057 size
-= compression_header_size
;
14059 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
14061 /* Read the zlib header. In this case, it should be "ZLIB"
14062 followed by the uncompressed section size, 8 bytes in
14063 big-endian order. */
14064 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
14065 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
14066 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
14067 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
14068 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
14069 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
14070 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
14071 uncompressed_size
+= start
[11];
14076 if (uncompressed_size
)
14078 if (uncompress_section_contents (&start
, uncompressed_size
,
14081 /* Free the compressed buffer, update the section buffer
14082 and the section size if uncompress is successful. */
14083 free (section
->start
);
14084 section
->start
= start
;
14088 error (_("Unable to decompress section %s\n"),
14089 printable_section_name (filedata
, sec
));
14094 section
->size
= size
;
14097 if (section
->start
== NULL
)
14100 if (debug_displays
[debug
].relocate
)
14102 if (! apply_relocations (filedata
, sec
, section
->start
, section
->size
,
14103 & section
->reloc_info
, & section
->num_relocs
))
14108 section
->reloc_info
= NULL
;
14109 section
->num_relocs
= 0;
14115 /* If this is not NULL, load_debug_section will only look for sections
14116 within the list of sections given here. */
14117 static unsigned int * section_subset
= NULL
;
14120 load_debug_section (enum dwarf_section_display_enum debug
, void * data
)
14122 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14123 Elf_Internal_Shdr
* sec
;
14124 Filedata
* filedata
= (Filedata
*) data
;
14126 /* Without section headers we cannot find any sections. */
14127 if (filedata
->section_headers
== NULL
)
14130 if (filedata
->string_table
== NULL
14131 && filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
14132 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
14134 Elf_Internal_Shdr
* strs
;
14136 /* Read in the string table, so that we have section names to scan. */
14137 strs
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
14139 if (strs
!= NULL
&& strs
->sh_size
!= 0)
14141 filedata
->string_table
14142 = (char *) get_data (NULL
, filedata
, strs
->sh_offset
,
14143 1, strs
->sh_size
, _("string table"));
14145 filedata
->string_table_length
14146 = filedata
->string_table
!= NULL
? strs
->sh_size
: 0;
14150 /* Locate the debug section. */
14151 sec
= find_section_in_set (filedata
, section
->uncompressed_name
, section_subset
);
14153 section
->name
= section
->uncompressed_name
;
14156 sec
= find_section_in_set (filedata
, section
->compressed_name
, section_subset
);
14158 section
->name
= section
->compressed_name
;
14163 /* If we're loading from a subset of sections, and we've loaded
14164 a section matching this name before, it's likely that it's a
14166 if (section_subset
!= NULL
)
14167 free_debug_section (debug
);
14169 return load_specific_debug_section (debug
, sec
, data
);
14173 free_debug_section (enum dwarf_section_display_enum debug
)
14175 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
14177 if (section
->start
== NULL
)
14180 free ((char *) section
->start
);
14181 section
->start
= NULL
;
14182 section
->address
= 0;
14187 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, Filedata
* filedata
)
14189 char * name
= SECTION_NAME (section
);
14190 const char * print_name
= printable_section_name (filedata
, section
);
14191 bfd_size_type length
;
14192 bfd_boolean result
= TRUE
;
14195 length
= section
->sh_size
;
14198 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
14201 if (section
->sh_type
== SHT_NOBITS
)
14203 /* There is no point in dumping the contents of a debugging section
14204 which has the NOBITS type - the bits in the file will be random.
14205 This can happen when a file containing a .eh_frame section is
14206 stripped with the --only-keep-debug command line option. */
14207 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
14212 if (const_strneq (name
, ".gnu.linkonce.wi."))
14213 name
= ".debug_info";
14215 /* See if we know how to display the contents of this section. */
14216 for (i
= 0; i
< max
; i
++)
14218 enum dwarf_section_display_enum id
= (enum dwarf_section_display_enum
) i
;
14219 struct dwarf_section_display
* display
= debug_displays
+ i
;
14220 struct dwarf_section
* sec
= & display
->section
;
14222 if (streq (sec
->uncompressed_name
, name
)
14223 || (id
== line
&& const_strneq (name
, ".debug_line."))
14224 || streq (sec
->compressed_name
, name
))
14226 bfd_boolean secondary
= (section
!= find_section (filedata
, name
));
14229 free_debug_section (id
);
14231 if (i
== line
&& const_strneq (name
, ".debug_line."))
14233 else if (streq (sec
->uncompressed_name
, name
))
14234 sec
->name
= sec
->uncompressed_name
;
14236 sec
->name
= sec
->compressed_name
;
14238 if (load_specific_debug_section (id
, section
, filedata
))
14240 /* If this debug section is part of a CU/TU set in a .dwp file,
14241 restrict load_debug_section to the sections in that set. */
14242 section_subset
= find_cu_tu_set (filedata
, shndx
);
14244 result
&= display
->display (sec
, filedata
);
14246 section_subset
= NULL
;
14248 if (secondary
|| (id
!= info
&& id
!= abbrev
))
14249 free_debug_section (id
);
14257 printf (_("Unrecognized debug section: %s\n"), print_name
);
14264 /* Set DUMP_SECTS for all sections where dumps were requested
14265 based on section name. */
14268 initialise_dumps_byname (Filedata
* filedata
)
14270 struct dump_list_entry
* cur
;
14272 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
14275 bfd_boolean any
= FALSE
;
14277 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
14278 if (streq (SECTION_NAME (filedata
->section_headers
+ i
), cur
->name
))
14280 request_dump_bynumber (filedata
, i
, cur
->type
);
14285 warn (_("Section '%s' was not dumped because it does not exist!\n"),
14291 process_section_contents (Filedata
* filedata
)
14293 Elf_Internal_Shdr
* section
;
14295 bfd_boolean res
= TRUE
;
14300 initialise_dumps_byname (filedata
);
14302 for (i
= 0, section
= filedata
->section_headers
;
14303 i
< filedata
->file_header
.e_shnum
&& i
< filedata
->num_dump_sects
;
14306 dump_type dump
= filedata
->dump_sects
[i
];
14308 #ifdef SUPPORT_DISASSEMBLY
14309 if (dump
& DISASS_DUMP
)
14311 if (! disassemble_section (section
, filedata
))
14315 if (dump
& HEX_DUMP
)
14317 if (! dump_section_as_bytes (section
, filedata
, FALSE
))
14321 if (dump
& RELOC_DUMP
)
14323 if (! dump_section_as_bytes (section
, filedata
, TRUE
))
14327 if (dump
& STRING_DUMP
)
14329 if (! dump_section_as_strings (section
, filedata
))
14333 if (dump
& DEBUG_DUMP
)
14335 if (! display_debug_section (i
, section
, filedata
))
14339 if (dump
& CTF_DUMP
)
14341 if (! dump_section_as_ctf (section
, filedata
))
14346 /* Check to see if the user requested a
14347 dump of a section that does not exist. */
14348 while (i
< filedata
->num_dump_sects
)
14350 if (filedata
->dump_sects
[i
])
14352 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
14362 process_mips_fpe_exception (int mask
)
14366 bfd_boolean first
= TRUE
;
14368 if (mask
& OEX_FPU_INEX
)
14369 fputs ("INEX", stdout
), first
= FALSE
;
14370 if (mask
& OEX_FPU_UFLO
)
14371 printf ("%sUFLO", first
? "" : "|"), first
= FALSE
;
14372 if (mask
& OEX_FPU_OFLO
)
14373 printf ("%sOFLO", first
? "" : "|"), first
= FALSE
;
14374 if (mask
& OEX_FPU_DIV0
)
14375 printf ("%sDIV0", first
? "" : "|"), first
= FALSE
;
14376 if (mask
& OEX_FPU_INVAL
)
14377 printf ("%sINVAL", first
? "" : "|");
14380 fputs ("0", stdout
);
14383 /* Display's the value of TAG at location P. If TAG is
14384 greater than 0 it is assumed to be an unknown tag, and
14385 a message is printed to this effect. Otherwise it is
14386 assumed that a message has already been printed.
14388 If the bottom bit of TAG is set it assumed to have a
14389 string value, otherwise it is assumed to have an integer
14392 Returns an updated P pointing to the first unread byte
14393 beyond the end of TAG's value.
14395 Reads at or beyond END will not be made. */
14397 static unsigned char *
14398 display_tag_value (signed int tag
,
14400 const unsigned char * const end
)
14405 printf (" Tag_unknown_%d: ", tag
);
14409 warn (_("<corrupt tag>\n"));
14413 /* PR 17531 file: 027-19978-0.004. */
14414 size_t maxlen
= (end
- p
) - 1;
14419 print_symbol ((int) maxlen
, (const char *) p
);
14420 p
+= strnlen ((char *) p
, maxlen
) + 1;
14424 printf (_("<corrupt string tag>"));
14425 p
= (unsigned char *) end
;
14433 val
= read_uleb128 (p
, &len
, end
);
14435 printf ("%ld (0x%lx)\n", val
, val
);
14442 /* ARC ABI attributes section. */
14444 static unsigned char *
14445 display_arc_attribute (unsigned char * p
,
14446 const unsigned char * const end
)
14452 tag
= read_uleb128 (p
, &len
, end
);
14457 case Tag_ARC_PCS_config
:
14458 val
= read_uleb128 (p
, &len
, end
);
14460 printf (" Tag_ARC_PCS_config: ");
14464 printf (_("Absent/Non standard\n"));
14467 printf (_("Bare metal/mwdt\n"));
14470 printf (_("Bare metal/newlib\n"));
14473 printf (_("Linux/uclibc\n"));
14476 printf (_("Linux/glibc\n"));
14479 printf (_("Unknown\n"));
14484 case Tag_ARC_CPU_base
:
14485 val
= read_uleb128 (p
, &len
, end
);
14487 printf (" Tag_ARC_CPU_base: ");
14492 printf (_("Absent\n"));
14494 case TAG_CPU_ARC6xx
:
14495 printf ("ARC6xx\n");
14497 case TAG_CPU_ARC7xx
:
14498 printf ("ARC7xx\n");
14500 case TAG_CPU_ARCEM
:
14501 printf ("ARCEM\n");
14503 case TAG_CPU_ARCHS
:
14504 printf ("ARCHS\n");
14509 case Tag_ARC_CPU_variation
:
14510 val
= read_uleb128 (p
, &len
, end
);
14512 printf (" Tag_ARC_CPU_variation: ");
14516 if (val
> 0 && val
< 16)
14517 printf ("Core%d\n", val
);
14519 printf ("Unknown\n");
14523 printf (_("Absent\n"));
14528 case Tag_ARC_CPU_name
:
14529 printf (" Tag_ARC_CPU_name: ");
14530 p
= display_tag_value (-1, p
, end
);
14533 case Tag_ARC_ABI_rf16
:
14534 val
= read_uleb128 (p
, &len
, end
);
14536 printf (" Tag_ARC_ABI_rf16: %s\n", val
? _("yes") : _("no"));
14539 case Tag_ARC_ABI_osver
:
14540 val
= read_uleb128 (p
, &len
, end
);
14542 printf (" Tag_ARC_ABI_osver: v%d\n", val
);
14545 case Tag_ARC_ABI_pic
:
14546 case Tag_ARC_ABI_sda
:
14547 val
= read_uleb128 (p
, &len
, end
);
14549 printf (tag
== Tag_ARC_ABI_sda
? " Tag_ARC_ABI_sda: "
14550 : " Tag_ARC_ABI_pic: ");
14554 printf (_("Absent\n"));
14563 printf (_("Unknown\n"));
14568 case Tag_ARC_ABI_tls
:
14569 val
= read_uleb128 (p
, &len
, end
);
14571 printf (" Tag_ARC_ABI_tls: %s\n", val
? "r25": "none");
14574 case Tag_ARC_ABI_enumsize
:
14575 val
= read_uleb128 (p
, &len
, end
);
14577 printf (" Tag_ARC_ABI_enumsize: %s\n", val
? _("default") :
14581 case Tag_ARC_ABI_exceptions
:
14582 val
= read_uleb128 (p
, &len
, end
);
14584 printf (" Tag_ARC_ABI_exceptions: %s\n", val
? _("OPTFP")
14588 case Tag_ARC_ABI_double_size
:
14589 val
= read_uleb128 (p
, &len
, end
);
14591 printf (" Tag_ARC_ABI_double_size: %d\n", val
);
14594 case Tag_ARC_ISA_config
:
14595 printf (" Tag_ARC_ISA_config: ");
14596 p
= display_tag_value (-1, p
, end
);
14599 case Tag_ARC_ISA_apex
:
14600 printf (" Tag_ARC_ISA_apex: ");
14601 p
= display_tag_value (-1, p
, end
);
14604 case Tag_ARC_ISA_mpy_option
:
14605 val
= read_uleb128 (p
, &len
, end
);
14607 printf (" Tag_ARC_ISA_mpy_option: %d\n", val
);
14610 case Tag_ARC_ATR_version
:
14611 val
= read_uleb128 (p
, &len
, end
);
14613 printf (" Tag_ARC_ATR_version: %d\n", val
);
14617 return display_tag_value (tag
& 1, p
, end
);
14623 /* ARM EABI attributes section. */
14628 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
14630 const char ** table
;
14631 } arm_attr_public_tag
;
14633 static const char * arm_attr_tag_CPU_arch
[] =
14634 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
14635 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
14636 "v8-M.mainline", "", "", "", "v8.1-M.mainline"};
14637 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
14638 static const char * arm_attr_tag_THUMB_ISA_use
[] =
14639 {"No", "Thumb-1", "Thumb-2", "Yes"};
14640 static const char * arm_attr_tag_FP_arch
[] =
14641 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
14642 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
14643 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
14644 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
14645 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
14646 "NEON for ARMv8.1"};
14647 static const char * arm_attr_tag_PCS_config
[] =
14648 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
14649 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
14650 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
14651 {"V6", "SB", "TLS", "Unused"};
14652 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
14653 {"Absolute", "PC-relative", "SB-relative", "None"};
14654 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
14655 {"Absolute", "PC-relative", "None"};
14656 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
14657 {"None", "direct", "GOT-indirect"};
14658 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
14659 {"None", "??? 1", "2", "??? 3", "4"};
14660 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
14661 static const char * arm_attr_tag_ABI_FP_denormal
[] =
14662 {"Unused", "Needed", "Sign only"};
14663 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
14664 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
14665 static const char * arm_attr_tag_ABI_FP_number_model
[] =
14666 {"Unused", "Finite", "RTABI", "IEEE 754"};
14667 static const char * arm_attr_tag_ABI_enum_size
[] =
14668 {"Unused", "small", "int", "forced to int"};
14669 static const char * arm_attr_tag_ABI_HardFP_use
[] =
14670 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
14671 static const char * arm_attr_tag_ABI_VFP_args
[] =
14672 {"AAPCS", "VFP registers", "custom", "compatible"};
14673 static const char * arm_attr_tag_ABI_WMMX_args
[] =
14674 {"AAPCS", "WMMX registers", "custom"};
14675 static const char * arm_attr_tag_ABI_optimization_goals
[] =
14676 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14677 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
14678 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
14679 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14680 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
14681 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
14682 static const char * arm_attr_tag_FP_HP_extension
[] =
14683 {"Not Allowed", "Allowed"};
14684 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
14685 {"None", "IEEE 754", "Alternative Format"};
14686 static const char * arm_attr_tag_DSP_extension
[] =
14687 {"Follow architecture", "Allowed"};
14688 static const char * arm_attr_tag_MPextension_use
[] =
14689 {"Not Allowed", "Allowed"};
14690 static const char * arm_attr_tag_DIV_use
[] =
14691 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
14692 "Allowed in v7-A with integer division extension"};
14693 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
14694 static const char * arm_attr_tag_Virtualization_use
[] =
14695 {"Not Allowed", "TrustZone", "Virtualization Extensions",
14696 "TrustZone and Virtualization Extensions"};
14697 static const char * arm_attr_tag_MPextension_use_legacy
[] =
14698 {"Not Allowed", "Allowed"};
14700 static const char * arm_attr_tag_MVE_arch
[] =
14701 {"No MVE", "MVE Integer only", "MVE Integer and FP"};
14703 #define LOOKUP(id, name) \
14704 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
14705 static arm_attr_public_tag arm_attr_public_tags
[] =
14707 {4, "CPU_raw_name", 1, NULL
},
14708 {5, "CPU_name", 1, NULL
},
14709 LOOKUP(6, CPU_arch
),
14710 {7, "CPU_arch_profile", 0, NULL
},
14711 LOOKUP(8, ARM_ISA_use
),
14712 LOOKUP(9, THUMB_ISA_use
),
14713 LOOKUP(10, FP_arch
),
14714 LOOKUP(11, WMMX_arch
),
14715 LOOKUP(12, Advanced_SIMD_arch
),
14716 LOOKUP(13, PCS_config
),
14717 LOOKUP(14, ABI_PCS_R9_use
),
14718 LOOKUP(15, ABI_PCS_RW_data
),
14719 LOOKUP(16, ABI_PCS_RO_data
),
14720 LOOKUP(17, ABI_PCS_GOT_use
),
14721 LOOKUP(18, ABI_PCS_wchar_t
),
14722 LOOKUP(19, ABI_FP_rounding
),
14723 LOOKUP(20, ABI_FP_denormal
),
14724 LOOKUP(21, ABI_FP_exceptions
),
14725 LOOKUP(22, ABI_FP_user_exceptions
),
14726 LOOKUP(23, ABI_FP_number_model
),
14727 {24, "ABI_align_needed", 0, NULL
},
14728 {25, "ABI_align_preserved", 0, NULL
},
14729 LOOKUP(26, ABI_enum_size
),
14730 LOOKUP(27, ABI_HardFP_use
),
14731 LOOKUP(28, ABI_VFP_args
),
14732 LOOKUP(29, ABI_WMMX_args
),
14733 LOOKUP(30, ABI_optimization_goals
),
14734 LOOKUP(31, ABI_FP_optimization_goals
),
14735 {32, "compatibility", 0, NULL
},
14736 LOOKUP(34, CPU_unaligned_access
),
14737 LOOKUP(36, FP_HP_extension
),
14738 LOOKUP(38, ABI_FP_16bit_format
),
14739 LOOKUP(42, MPextension_use
),
14740 LOOKUP(44, DIV_use
),
14741 LOOKUP(46, DSP_extension
),
14742 LOOKUP(48, MVE_arch
),
14743 {64, "nodefaults", 0, NULL
},
14744 {65, "also_compatible_with", 0, NULL
},
14745 LOOKUP(66, T2EE_use
),
14746 {67, "conformance", 1, NULL
},
14747 LOOKUP(68, Virtualization_use
),
14748 LOOKUP(70, MPextension_use_legacy
)
14752 static unsigned char *
14753 display_arm_attribute (unsigned char * p
,
14754 const unsigned char * const end
)
14759 arm_attr_public_tag
* attr
;
14763 tag
= read_uleb128 (p
, &len
, end
);
14766 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
14768 if (arm_attr_public_tags
[i
].tag
== tag
)
14770 attr
= &arm_attr_public_tags
[i
];
14777 printf (" Tag_%s: ", attr
->name
);
14778 switch (attr
->type
)
14783 case 7: /* Tag_CPU_arch_profile. */
14784 val
= read_uleb128 (p
, &len
, end
);
14788 case 0: printf (_("None\n")); break;
14789 case 'A': printf (_("Application\n")); break;
14790 case 'R': printf (_("Realtime\n")); break;
14791 case 'M': printf (_("Microcontroller\n")); break;
14792 case 'S': printf (_("Application or Realtime\n")); break;
14793 default: printf ("??? (%d)\n", val
); break;
14797 case 24: /* Tag_align_needed. */
14798 val
= read_uleb128 (p
, &len
, end
);
14802 case 0: printf (_("None\n")); break;
14803 case 1: printf (_("8-byte\n")); break;
14804 case 2: printf (_("4-byte\n")); break;
14805 case 3: printf ("??? 3\n"); break;
14808 printf (_("8-byte and up to %d-byte extended\n"),
14811 printf ("??? (%d)\n", val
);
14816 case 25: /* Tag_align_preserved. */
14817 val
= read_uleb128 (p
, &len
, end
);
14821 case 0: printf (_("None\n")); break;
14822 case 1: printf (_("8-byte, except leaf SP\n")); break;
14823 case 2: printf (_("8-byte\n")); break;
14824 case 3: printf ("??? 3\n"); break;
14827 printf (_("8-byte and up to %d-byte extended\n"),
14830 printf ("??? (%d)\n", val
);
14835 case 32: /* Tag_compatibility. */
14837 val
= read_uleb128 (p
, &len
, end
);
14839 printf (_("flag = %d, vendor = "), val
);
14842 size_t maxlen
= (end
- p
) - 1;
14844 print_symbol ((int) maxlen
, (const char *) p
);
14845 p
+= strnlen ((char *) p
, maxlen
) + 1;
14849 printf (_("<corrupt>"));
14850 p
= (unsigned char *) end
;
14856 case 64: /* Tag_nodefaults. */
14857 /* PR 17531: file: 001-505008-0.01. */
14860 printf (_("True\n"));
14863 case 65: /* Tag_also_compatible_with. */
14864 val
= read_uleb128 (p
, &len
, end
);
14866 if (val
== 6 /* Tag_CPU_arch. */)
14868 val
= read_uleb128 (p
, &len
, end
);
14870 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
14871 printf ("??? (%d)\n", val
);
14873 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
14877 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
14882 printf (_("<unknown: %d>\n"), tag
);
14888 return display_tag_value (-1, p
, end
);
14890 return display_tag_value (0, p
, end
);
14893 assert (attr
->type
& 0x80);
14894 val
= read_uleb128 (p
, &len
, end
);
14896 type
= attr
->type
& 0x7f;
14898 printf ("??? (%d)\n", val
);
14900 printf ("%s\n", attr
->table
[val
]);
14905 return display_tag_value (tag
, p
, end
);
14908 static unsigned char *
14909 display_gnu_attribute (unsigned char * p
,
14910 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const),
14911 const unsigned char * const end
)
14917 tag
= read_uleb128 (p
, &len
, end
);
14920 /* Tag_compatibility is the only generic GNU attribute defined at
14924 val
= read_uleb128 (p
, &len
, end
);
14927 printf (_("flag = %d, vendor = "), val
);
14930 printf (_("<corrupt>\n"));
14931 warn (_("corrupt vendor attribute\n"));
14937 size_t maxlen
= (end
- p
) - 1;
14939 print_symbol ((int) maxlen
, (const char *) p
);
14940 p
+= strnlen ((char *) p
, maxlen
) + 1;
14944 printf (_("<corrupt>"));
14945 p
= (unsigned char *) end
;
14952 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
14953 return display_proc_gnu_attribute (p
, tag
, end
);
14955 return display_tag_value (tag
, p
, end
);
14958 static unsigned char *
14959 display_power_gnu_attribute (unsigned char * p
,
14961 const unsigned char * const end
)
14966 if (tag
== Tag_GNU_Power_ABI_FP
)
14968 val
= read_uleb128 (p
, &len
, end
);
14970 printf (" Tag_GNU_Power_ABI_FP: ");
14973 printf (_("<corrupt>\n"));
14978 printf ("(%#x), ", val
);
14983 printf (_("unspecified hard/soft float, "));
14986 printf (_("hard float, "));
14989 printf (_("soft float, "));
14992 printf (_("single-precision hard float, "));
14999 printf (_("unspecified long double\n"));
15002 printf (_("128-bit IBM long double\n"));
15005 printf (_("64-bit long double\n"));
15008 printf (_("128-bit IEEE long double\n"));
15014 if (tag
== Tag_GNU_Power_ABI_Vector
)
15016 val
= read_uleb128 (p
, &len
, end
);
15018 printf (" Tag_GNU_Power_ABI_Vector: ");
15021 printf (_("<corrupt>\n"));
15026 printf ("(%#x), ", val
);
15031 printf (_("unspecified\n"));
15034 printf (_("generic\n"));
15037 printf ("AltiVec\n");
15046 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
15048 val
= read_uleb128 (p
, &len
, end
);
15050 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
15053 printf (_("<corrupt>\n"));
15058 printf ("(%#x), ", val
);
15063 printf (_("unspecified\n"));
15066 printf ("r3/r4\n");
15069 printf (_("memory\n"));
15078 return display_tag_value (tag
& 1, p
, end
);
15081 static unsigned char *
15082 display_s390_gnu_attribute (unsigned char * p
,
15084 const unsigned char * const end
)
15089 if (tag
== Tag_GNU_S390_ABI_Vector
)
15091 val
= read_uleb128 (p
, &len
, end
);
15093 printf (" Tag_GNU_S390_ABI_Vector: ");
15098 printf (_("any\n"));
15101 printf (_("software\n"));
15104 printf (_("hardware\n"));
15107 printf ("??? (%d)\n", val
);
15113 return display_tag_value (tag
& 1, p
, end
);
15117 display_sparc_hwcaps (unsigned int mask
)
15121 bfd_boolean first
= TRUE
;
15123 if (mask
& ELF_SPARC_HWCAP_MUL32
)
15124 fputs ("mul32", stdout
), first
= FALSE
;
15125 if (mask
& ELF_SPARC_HWCAP_DIV32
)
15126 printf ("%sdiv32", first
? "" : "|"), first
= FALSE
;
15127 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
15128 printf ("%sfsmuld", first
? "" : "|"), first
= FALSE
;
15129 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
15130 printf ("%sv8plus", first
? "" : "|"), first
= FALSE
;
15131 if (mask
& ELF_SPARC_HWCAP_POPC
)
15132 printf ("%spopc", first
? "" : "|"), first
= FALSE
;
15133 if (mask
& ELF_SPARC_HWCAP_VIS
)
15134 printf ("%svis", first
? "" : "|"), first
= FALSE
;
15135 if (mask
& ELF_SPARC_HWCAP_VIS2
)
15136 printf ("%svis2", first
? "" : "|"), first
= FALSE
;
15137 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
15138 printf ("%sASIBlkInit", first
? "" : "|"), first
= FALSE
;
15139 if (mask
& ELF_SPARC_HWCAP_FMAF
)
15140 printf ("%sfmaf", first
? "" : "|"), first
= FALSE
;
15141 if (mask
& ELF_SPARC_HWCAP_VIS3
)
15142 printf ("%svis3", first
? "" : "|"), first
= FALSE
;
15143 if (mask
& ELF_SPARC_HWCAP_HPC
)
15144 printf ("%shpc", first
? "" : "|"), first
= FALSE
;
15145 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
15146 printf ("%srandom", first
? "" : "|"), first
= FALSE
;
15147 if (mask
& ELF_SPARC_HWCAP_TRANS
)
15148 printf ("%strans", first
? "" : "|"), first
= FALSE
;
15149 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
15150 printf ("%sfjfmau", first
? "" : "|"), first
= FALSE
;
15151 if (mask
& ELF_SPARC_HWCAP_IMA
)
15152 printf ("%sima", first
? "" : "|"), first
= FALSE
;
15153 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
15154 printf ("%scspare", first
? "" : "|"), first
= FALSE
;
15157 fputc ('0', stdout
);
15158 fputc ('\n', stdout
);
15162 display_sparc_hwcaps2 (unsigned int mask
)
15166 bfd_boolean first
= TRUE
;
15168 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
15169 fputs ("fjathplus", stdout
), first
= FALSE
;
15170 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
15171 printf ("%svis3b", first
? "" : "|"), first
= FALSE
;
15172 if (mask
& ELF_SPARC_HWCAP2_ADP
)
15173 printf ("%sadp", first
? "" : "|"), first
= FALSE
;
15174 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
15175 printf ("%ssparc5", first
? "" : "|"), first
= FALSE
;
15176 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
15177 printf ("%smwait", first
? "" : "|"), first
= FALSE
;
15178 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
15179 printf ("%sxmpmul", first
? "" : "|"), first
= FALSE
;
15180 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
15181 printf ("%sxmont2", first
? "" : "|"), first
= FALSE
;
15182 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
15183 printf ("%snsec", first
? "" : "|"), first
= FALSE
;
15184 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
15185 printf ("%sfjathhpc", first
? "" : "|"), first
= FALSE
;
15186 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
15187 printf ("%sfjdes", first
? "" : "|"), first
= FALSE
;
15188 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
15189 printf ("%sfjaes", first
? "" : "|"), first
= FALSE
;
15192 fputc ('0', stdout
);
15193 fputc ('\n', stdout
);
15196 static unsigned char *
15197 display_sparc_gnu_attribute (unsigned char * p
,
15199 const unsigned char * const end
)
15204 if (tag
== Tag_GNU_Sparc_HWCAPS
)
15206 val
= read_uleb128 (p
, &len
, end
);
15208 printf (" Tag_GNU_Sparc_HWCAPS: ");
15209 display_sparc_hwcaps (val
);
15212 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
15214 val
= read_uleb128 (p
, &len
, end
);
15216 printf (" Tag_GNU_Sparc_HWCAPS2: ");
15217 display_sparc_hwcaps2 (val
);
15221 return display_tag_value (tag
, p
, end
);
15225 print_mips_fp_abi_value (unsigned int val
)
15229 case Val_GNU_MIPS_ABI_FP_ANY
:
15230 printf (_("Hard or soft float\n"));
15232 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
15233 printf (_("Hard float (double precision)\n"));
15235 case Val_GNU_MIPS_ABI_FP_SINGLE
:
15236 printf (_("Hard float (single precision)\n"));
15238 case Val_GNU_MIPS_ABI_FP_SOFT
:
15239 printf (_("Soft float\n"));
15241 case Val_GNU_MIPS_ABI_FP_OLD_64
:
15242 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
15244 case Val_GNU_MIPS_ABI_FP_XX
:
15245 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
15247 case Val_GNU_MIPS_ABI_FP_64
:
15248 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
15250 case Val_GNU_MIPS_ABI_FP_64A
:
15251 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
15253 case Val_GNU_MIPS_ABI_FP_NAN2008
:
15254 printf (_("NaN 2008 compatibility\n"));
15257 printf ("??? (%d)\n", val
);
15262 static unsigned char *
15263 display_mips_gnu_attribute (unsigned char * p
,
15265 const unsigned char * const end
)
15267 if (tag
== Tag_GNU_MIPS_ABI_FP
)
15272 val
= read_uleb128 (p
, &len
, end
);
15274 printf (" Tag_GNU_MIPS_ABI_FP: ");
15276 print_mips_fp_abi_value (val
);
15281 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
15286 val
= read_uleb128 (p
, &len
, end
);
15288 printf (" Tag_GNU_MIPS_ABI_MSA: ");
15292 case Val_GNU_MIPS_ABI_MSA_ANY
:
15293 printf (_("Any MSA or not\n"));
15295 case Val_GNU_MIPS_ABI_MSA_128
:
15296 printf (_("128-bit MSA\n"));
15299 printf ("??? (%d)\n", val
);
15305 return display_tag_value (tag
& 1, p
, end
);
15308 static unsigned char *
15309 display_tic6x_attribute (unsigned char * p
,
15310 const unsigned char * const end
)
15316 tag
= read_uleb128 (p
, &len
, end
);
15322 val
= read_uleb128 (p
, &len
, end
);
15324 printf (" Tag_ISA: ");
15328 case C6XABI_Tag_ISA_none
:
15329 printf (_("None\n"));
15331 case C6XABI_Tag_ISA_C62X
:
15334 case C6XABI_Tag_ISA_C67X
:
15337 case C6XABI_Tag_ISA_C67XP
:
15338 printf ("C67x+\n");
15340 case C6XABI_Tag_ISA_C64X
:
15343 case C6XABI_Tag_ISA_C64XP
:
15344 printf ("C64x+\n");
15346 case C6XABI_Tag_ISA_C674X
:
15347 printf ("C674x\n");
15350 printf ("??? (%d)\n", val
);
15355 case Tag_ABI_wchar_t
:
15356 val
= read_uleb128 (p
, &len
, end
);
15358 printf (" Tag_ABI_wchar_t: ");
15362 printf (_("Not used\n"));
15365 printf (_("2 bytes\n"));
15368 printf (_("4 bytes\n"));
15371 printf ("??? (%d)\n", val
);
15376 case Tag_ABI_stack_align_needed
:
15377 val
= read_uleb128 (p
, &len
, end
);
15379 printf (" Tag_ABI_stack_align_needed: ");
15383 printf (_("8-byte\n"));
15386 printf (_("16-byte\n"));
15389 printf ("??? (%d)\n", val
);
15394 case Tag_ABI_stack_align_preserved
:
15395 val
= read_uleb128 (p
, &len
, end
);
15397 printf (" Tag_ABI_stack_align_preserved: ");
15401 printf (_("8-byte\n"));
15404 printf (_("16-byte\n"));
15407 printf ("??? (%d)\n", val
);
15413 val
= read_uleb128 (p
, &len
, end
);
15415 printf (" Tag_ABI_DSBT: ");
15419 printf (_("DSBT addressing not used\n"));
15422 printf (_("DSBT addressing used\n"));
15425 printf ("??? (%d)\n", val
);
15431 val
= read_uleb128 (p
, &len
, end
);
15433 printf (" Tag_ABI_PID: ");
15437 printf (_("Data addressing position-dependent\n"));
15440 printf (_("Data addressing position-independent, GOT near DP\n"));
15443 printf (_("Data addressing position-independent, GOT far from DP\n"));
15446 printf ("??? (%d)\n", val
);
15452 val
= read_uleb128 (p
, &len
, end
);
15454 printf (" Tag_ABI_PIC: ");
15458 printf (_("Code addressing position-dependent\n"));
15461 printf (_("Code addressing position-independent\n"));
15464 printf ("??? (%d)\n", val
);
15469 case Tag_ABI_array_object_alignment
:
15470 val
= read_uleb128 (p
, &len
, end
);
15472 printf (" Tag_ABI_array_object_alignment: ");
15476 printf (_("8-byte\n"));
15479 printf (_("4-byte\n"));
15482 printf (_("16-byte\n"));
15485 printf ("??? (%d)\n", val
);
15490 case Tag_ABI_array_object_align_expected
:
15491 val
= read_uleb128 (p
, &len
, end
);
15493 printf (" Tag_ABI_array_object_align_expected: ");
15497 printf (_("8-byte\n"));
15500 printf (_("4-byte\n"));
15503 printf (_("16-byte\n"));
15506 printf ("??? (%d)\n", val
);
15511 case Tag_ABI_compatibility
:
15513 val
= read_uleb128 (p
, &len
, end
);
15515 printf (" Tag_ABI_compatibility: ");
15516 printf (_("flag = %d, vendor = "), val
);
15519 size_t maxlen
= (end
- p
) - 1;
15521 print_symbol ((int) maxlen
, (const char *) p
);
15522 p
+= strnlen ((char *) p
, maxlen
) + 1;
15526 printf (_("<corrupt>"));
15527 p
= (unsigned char *) end
;
15533 case Tag_ABI_conformance
:
15535 printf (" Tag_ABI_conformance: \"");
15538 size_t maxlen
= (end
- p
) - 1;
15540 print_symbol ((int) maxlen
, (const char *) p
);
15541 p
+= strnlen ((char *) p
, maxlen
) + 1;
15545 printf (_("<corrupt>"));
15546 p
= (unsigned char *) end
;
15553 return display_tag_value (tag
, p
, end
);
15557 display_raw_attribute (unsigned char * p
, unsigned char const * const end
)
15559 unsigned long addr
= 0;
15560 size_t bytes
= end
- p
;
15567 int lbytes
= (bytes
> 16 ? 16 : bytes
);
15569 printf (" 0x%8.8lx ", addr
);
15571 for (j
= 0; j
< 16; j
++)
15574 printf ("%2.2x", p
[j
]);
15582 for (j
= 0; j
< lbytes
; j
++)
15585 if (k
>= ' ' && k
< 0x7f)
15601 static unsigned char *
15602 display_msp430x_attribute (unsigned char * p
,
15603 const unsigned char * const end
)
15609 tag
= read_uleb128 (p
, & len
, end
);
15614 case OFBA_MSPABI_Tag_ISA
:
15615 val
= read_uleb128 (p
, &len
, end
);
15617 printf (" Tag_ISA: ");
15620 case 0: printf (_("None\n")); break;
15621 case 1: printf (_("MSP430\n")); break;
15622 case 2: printf (_("MSP430X\n")); break;
15623 default: printf ("??? (%d)\n", val
); break;
15627 case OFBA_MSPABI_Tag_Code_Model
:
15628 val
= read_uleb128 (p
, &len
, end
);
15630 printf (" Tag_Code_Model: ");
15633 case 0: printf (_("None\n")); break;
15634 case 1: printf (_("Small\n")); break;
15635 case 2: printf (_("Large\n")); break;
15636 default: printf ("??? (%d)\n", val
); break;
15640 case OFBA_MSPABI_Tag_Data_Model
:
15641 val
= read_uleb128 (p
, &len
, end
);
15643 printf (" Tag_Data_Model: ");
15646 case 0: printf (_("None\n")); break;
15647 case 1: printf (_("Small\n")); break;
15648 case 2: printf (_("Large\n")); break;
15649 case 3: printf (_("Restricted Large\n")); break;
15650 default: printf ("??? (%d)\n", val
); break;
15655 printf (_(" <unknown tag %d>: "), tag
);
15662 size_t maxlen
= (end
- p
) - 1;
15664 print_symbol ((int) maxlen
, (const char *) p
);
15665 p
+= strnlen ((char *) p
, maxlen
) + 1;
15669 printf (_("<corrupt>"));
15670 p
= (unsigned char *) end
;
15676 val
= read_uleb128 (p
, &len
, end
);
15678 printf ("%d (0x%x)\n", val
, val
);
15687 struct riscv_attr_tag_t
{
15692 static struct riscv_attr_tag_t riscv_attr_tag
[] =
15694 #define T(tag) {"Tag_RISCV_" #tag, Tag_RISCV_##tag}
15697 T(priv_spec_minor
),
15698 T(priv_spec_revision
),
15699 T(unaligned_access
),
15704 static unsigned char *
15705 display_riscv_attribute (unsigned char *p
,
15706 const unsigned char * const end
)
15711 struct riscv_attr_tag_t
*attr
= NULL
;
15714 tag
= read_uleb128 (p
, &len
, end
);
15717 /* Find the name of attribute. */
15718 for (i
= 0; i
< ARRAY_SIZE (riscv_attr_tag
); i
++)
15720 if (riscv_attr_tag
[i
].tag
== tag
)
15722 attr
= &riscv_attr_tag
[i
];
15728 printf (" %s: ", attr
->name
);
15730 return display_tag_value (tag
, p
, end
);
15734 case Tag_RISCV_priv_spec
:
15735 case Tag_RISCV_priv_spec_minor
:
15736 case Tag_RISCV_priv_spec_revision
:
15737 val
= read_uleb128 (p
, &len
, end
);
15739 printf (_("%d\n"), val
);
15741 case Tag_RISCV_unaligned_access
:
15742 val
= read_uleb128 (p
, &len
, end
);
15747 printf (_("No unaligned access\n"));
15750 printf (_("Unaligned access\n"));
15754 case Tag_RISCV_stack_align
:
15755 val
= read_uleb128 (p
, &len
, end
);
15757 printf (_("%d-bytes\n"), val
);
15759 case Tag_RISCV_arch
:
15760 p
= display_tag_value (-1, p
, end
);
15763 return display_tag_value (tag
, p
, end
);
15770 process_attributes (Filedata
* filedata
,
15771 const char * public_name
,
15772 unsigned int proc_type
,
15773 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
15774 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const))
15776 Elf_Internal_Shdr
* sect
;
15778 bfd_boolean res
= TRUE
;
15780 /* Find the section header so that we get the size. */
15781 for (i
= 0, sect
= filedata
->section_headers
;
15782 i
< filedata
->file_header
.e_shnum
;
15785 unsigned char * contents
;
15788 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
15791 contents
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
, 1,
15792 sect
->sh_size
, _("attributes"));
15793 if (contents
== NULL
)
15800 /* The first character is the version of the attributes.
15801 Currently only version 1, (aka 'A') is recognised here. */
15804 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p
, *p
);
15809 bfd_vma section_len
;
15811 section_len
= sect
->sh_size
- 1;
15814 while (section_len
> 0)
15817 unsigned int namelen
;
15818 bfd_boolean public_section
;
15819 bfd_boolean gnu_section
;
15821 if (section_len
<= 4)
15823 error (_("Tag section ends prematurely\n"));
15827 attr_len
= byte_get (p
, 4);
15830 if (attr_len
> section_len
)
15832 error (_("Bad attribute length (%u > %u)\n"),
15833 (unsigned) attr_len
, (unsigned) section_len
);
15834 attr_len
= section_len
;
15837 /* PR 17531: file: 001-101425-0.004 */
15838 else if (attr_len
< 5)
15840 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
15845 section_len
-= attr_len
;
15848 namelen
= strnlen ((char *) p
, attr_len
) + 1;
15849 if (namelen
== 0 || namelen
>= attr_len
)
15851 error (_("Corrupt attribute section name\n"));
15856 printf (_("Attribute Section: "));
15857 print_symbol (INT_MAX
, (const char *) p
);
15860 if (public_name
&& streq ((char *) p
, public_name
))
15861 public_section
= TRUE
;
15863 public_section
= FALSE
;
15865 if (streq ((char *) p
, "gnu"))
15866 gnu_section
= TRUE
;
15868 gnu_section
= FALSE
;
15871 attr_len
-= namelen
;
15873 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
15878 unsigned char * end
;
15880 /* PR binutils/17531: Safe handling of corrupt files. */
15883 error (_("Unused bytes at end of section\n"));
15890 size
= byte_get (p
, 4);
15891 if (size
> attr_len
)
15893 error (_("Bad subsection length (%u > %u)\n"),
15894 (unsigned) size
, (unsigned) attr_len
);
15898 /* PR binutils/17531: Safe handling of corrupt files. */
15901 error (_("Bad subsection length (%u < 6)\n"),
15909 end
= p
+ size
- 1;
15910 assert (end
<= contents
+ sect
->sh_size
);
15916 printf (_("File Attributes\n"));
15919 printf (_("Section Attributes:"));
15922 printf (_("Symbol Attributes:"));
15923 /* Fall through. */
15929 val
= read_uleb128 (p
, &j
, end
);
15933 printf (" %d", val
);
15938 printf (_("Unknown tag: %d\n"), tag
);
15939 public_section
= FALSE
;
15943 if (public_section
&& display_pub_attribute
!= NULL
)
15946 p
= display_pub_attribute (p
, end
);
15949 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
15952 p
= display_gnu_attribute (p
,
15953 display_proc_gnu_attribute
,
15959 printf (_(" Unknown attribute:\n"));
15960 display_raw_attribute (p
, end
);
15975 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
15976 Print the Address, Access and Initial fields of an entry at VMA ADDR
15977 and return the VMA of the next entry, or -1 if there was a problem.
15978 Does not read from DATA_END or beyond. */
15981 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
15982 unsigned char * data_end
)
15985 print_vma (addr
, LONG_HEX
);
15987 if (addr
< pltgot
+ 0xfff0)
15988 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
15990 printf ("%10s", "");
15993 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
15997 unsigned char * from
= data
+ addr
- pltgot
;
15999 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
16001 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
16002 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
16003 return (bfd_vma
) -1;
16007 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
16008 print_vma (entry
, LONG_HEX
);
16011 return addr
+ (is_32bit_elf
? 4 : 8);
16014 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
16015 PLTGOT. Print the Address and Initial fields of an entry at VMA
16016 ADDR and return the VMA of the next entry. */
16019 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
16022 print_vma (addr
, LONG_HEX
);
16025 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
16030 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
16031 print_vma (entry
, LONG_HEX
);
16033 return addr
+ (is_32bit_elf
? 4 : 8);
16037 print_mips_ases (unsigned int mask
)
16039 if (mask
& AFL_ASE_DSP
)
16040 fputs ("\n\tDSP ASE", stdout
);
16041 if (mask
& AFL_ASE_DSPR2
)
16042 fputs ("\n\tDSP R2 ASE", stdout
);
16043 if (mask
& AFL_ASE_DSPR3
)
16044 fputs ("\n\tDSP R3 ASE", stdout
);
16045 if (mask
& AFL_ASE_EVA
)
16046 fputs ("\n\tEnhanced VA Scheme", stdout
);
16047 if (mask
& AFL_ASE_MCU
)
16048 fputs ("\n\tMCU (MicroController) ASE", stdout
);
16049 if (mask
& AFL_ASE_MDMX
)
16050 fputs ("\n\tMDMX ASE", stdout
);
16051 if (mask
& AFL_ASE_MIPS3D
)
16052 fputs ("\n\tMIPS-3D ASE", stdout
);
16053 if (mask
& AFL_ASE_MT
)
16054 fputs ("\n\tMT ASE", stdout
);
16055 if (mask
& AFL_ASE_SMARTMIPS
)
16056 fputs ("\n\tSmartMIPS ASE", stdout
);
16057 if (mask
& AFL_ASE_VIRT
)
16058 fputs ("\n\tVZ ASE", stdout
);
16059 if (mask
& AFL_ASE_MSA
)
16060 fputs ("\n\tMSA ASE", stdout
);
16061 if (mask
& AFL_ASE_MIPS16
)
16062 fputs ("\n\tMIPS16 ASE", stdout
);
16063 if (mask
& AFL_ASE_MICROMIPS
)
16064 fputs ("\n\tMICROMIPS ASE", stdout
);
16065 if (mask
& AFL_ASE_XPA
)
16066 fputs ("\n\tXPA ASE", stdout
);
16067 if (mask
& AFL_ASE_MIPS16E2
)
16068 fputs ("\n\tMIPS16e2 ASE", stdout
);
16069 if (mask
& AFL_ASE_CRC
)
16070 fputs ("\n\tCRC ASE", stdout
);
16071 if (mask
& AFL_ASE_GINV
)
16072 fputs ("\n\tGINV ASE", stdout
);
16073 if (mask
& AFL_ASE_LOONGSON_MMI
)
16074 fputs ("\n\tLoongson MMI ASE", stdout
);
16075 if (mask
& AFL_ASE_LOONGSON_CAM
)
16076 fputs ("\n\tLoongson CAM ASE", stdout
);
16077 if (mask
& AFL_ASE_LOONGSON_EXT
)
16078 fputs ("\n\tLoongson EXT ASE", stdout
);
16079 if (mask
& AFL_ASE_LOONGSON_EXT2
)
16080 fputs ("\n\tLoongson EXT2 ASE", stdout
);
16082 fprintf (stdout
, "\n\t%s", _("None"));
16083 else if ((mask
& ~AFL_ASE_MASK
) != 0)
16084 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
16088 print_mips_isa_ext (unsigned int isa_ext
)
16093 fputs (_("None"), stdout
);
16096 fputs ("RMI XLR", stdout
);
16098 case AFL_EXT_OCTEON3
:
16099 fputs ("Cavium Networks Octeon3", stdout
);
16101 case AFL_EXT_OCTEON2
:
16102 fputs ("Cavium Networks Octeon2", stdout
);
16104 case AFL_EXT_OCTEONP
:
16105 fputs ("Cavium Networks OcteonP", stdout
);
16107 case AFL_EXT_OCTEON
:
16108 fputs ("Cavium Networks Octeon", stdout
);
16111 fputs ("Toshiba R5900", stdout
);
16114 fputs ("MIPS R4650", stdout
);
16117 fputs ("LSI R4010", stdout
);
16120 fputs ("NEC VR4100", stdout
);
16123 fputs ("Toshiba R3900", stdout
);
16125 case AFL_EXT_10000
:
16126 fputs ("MIPS R10000", stdout
);
16129 fputs ("Broadcom SB-1", stdout
);
16132 fputs ("NEC VR4111/VR4181", stdout
);
16135 fputs ("NEC VR4120", stdout
);
16138 fputs ("NEC VR5400", stdout
);
16141 fputs ("NEC VR5500", stdout
);
16143 case AFL_EXT_LOONGSON_2E
:
16144 fputs ("ST Microelectronics Loongson 2E", stdout
);
16146 case AFL_EXT_LOONGSON_2F
:
16147 fputs ("ST Microelectronics Loongson 2F", stdout
);
16149 case AFL_EXT_INTERAPTIV_MR2
:
16150 fputs ("Imagination interAptiv MR2", stdout
);
16153 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
16158 get_mips_reg_size (int reg_size
)
16160 return (reg_size
== AFL_REG_NONE
) ? 0
16161 : (reg_size
== AFL_REG_32
) ? 32
16162 : (reg_size
== AFL_REG_64
) ? 64
16163 : (reg_size
== AFL_REG_128
) ? 128
16168 process_mips_specific (Filedata
* filedata
)
16170 Elf_Internal_Dyn
* entry
;
16171 Elf_Internal_Shdr
*sect
= NULL
;
16172 size_t liblist_offset
= 0;
16173 size_t liblistno
= 0;
16174 size_t conflictsno
= 0;
16175 size_t options_offset
= 0;
16176 size_t conflicts_offset
= 0;
16177 size_t pltrelsz
= 0;
16179 bfd_vma pltgot
= 0;
16180 bfd_vma mips_pltgot
= 0;
16181 bfd_vma jmprel
= 0;
16182 bfd_vma local_gotno
= 0;
16183 bfd_vma gotsym
= 0;
16184 bfd_vma symtabno
= 0;
16185 bfd_boolean res
= TRUE
;
16187 if (! process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
16188 display_mips_gnu_attribute
))
16191 sect
= find_section (filedata
, ".MIPS.abiflags");
16195 Elf_External_ABIFlags_v0
*abiflags_ext
;
16196 Elf_Internal_ABIFlags_v0 abiflags_in
;
16198 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
16200 error (_("Corrupt MIPS ABI Flags section.\n"));
16205 abiflags_ext
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
16206 sect
->sh_size
, _("MIPS ABI Flags section"));
16209 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
16210 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
16211 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
16212 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
16213 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
16214 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
16215 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
16216 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
16217 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
16218 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
16219 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
16221 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
16222 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
16223 if (abiflags_in
.isa_rev
> 1)
16224 printf ("r%d", abiflags_in
.isa_rev
);
16225 printf ("\nGPR size: %d",
16226 get_mips_reg_size (abiflags_in
.gpr_size
));
16227 printf ("\nCPR1 size: %d",
16228 get_mips_reg_size (abiflags_in
.cpr1_size
));
16229 printf ("\nCPR2 size: %d",
16230 get_mips_reg_size (abiflags_in
.cpr2_size
));
16231 fputs ("\nFP ABI: ", stdout
);
16232 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
16233 fputs ("ISA Extension: ", stdout
);
16234 print_mips_isa_ext (abiflags_in
.isa_ext
);
16235 fputs ("\nASEs:", stdout
);
16236 print_mips_ases (abiflags_in
.ases
);
16237 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
16238 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
16239 fputc ('\n', stdout
);
16240 free (abiflags_ext
);
16245 /* We have a lot of special sections. Thanks SGI! */
16246 if (dynamic_section
== NULL
)
16248 /* No dynamic information available. See if there is static GOT. */
16249 sect
= find_section (filedata
, ".got");
16252 unsigned char *data_end
;
16253 unsigned char *data
;
16257 pltgot
= sect
->sh_addr
;
16260 addr_size
= (is_32bit_elf
? 4 : 8);
16261 end
= pltgot
+ sect
->sh_size
;
16263 data
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
,
16265 _("Global Offset Table data"));
16266 /* PR 12855: Null data is handled gracefully throughout. */
16267 data_end
= data
+ (end
- pltgot
);
16269 printf (_("\nStatic GOT:\n"));
16270 printf (_(" Canonical gp value: "));
16271 print_vma (ent
+ 0x7ff0, LONG_HEX
);
16274 /* In a dynamic binary GOT[0] is reserved for the dynamic
16275 loader to store the lazy resolver pointer, however in
16276 a static binary it may well have been omitted and GOT
16277 reduced to a table of addresses.
16278 PR 21344: Check for the entry being fully available
16279 before fetching it. */
16281 && data
+ ent
- pltgot
+ addr_size
<= data_end
16282 && byte_get (data
+ ent
- pltgot
, addr_size
) == 0)
16284 printf (_(" Reserved entries:\n"));
16285 printf (_(" %*s %10s %*s\n"),
16286 addr_size
* 2, _("Address"), _("Access"),
16287 addr_size
* 2, _("Value"));
16288 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16290 if (ent
== (bfd_vma
) -1)
16291 goto sgot_print_fail
;
16293 /* Check for the MSB of GOT[1] being set, identifying a
16294 GNU object. This entry will be used by some runtime
16295 loaders, to store the module pointer. Otherwise this
16296 is an ordinary local entry.
16297 PR 21344: Check for the entry being fully available
16298 before fetching it. */
16300 && data
+ ent
- pltgot
+ addr_size
<= data_end
16301 && (byte_get (data
+ ent
- pltgot
, addr_size
)
16302 >> (addr_size
* 8 - 1)) != 0)
16304 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16306 if (ent
== (bfd_vma
) -1)
16307 goto sgot_print_fail
;
16312 if (data
!= NULL
&& ent
< end
)
16314 printf (_(" Local entries:\n"));
16315 printf (" %*s %10s %*s\n",
16316 addr_size
* 2, _("Address"), _("Access"),
16317 addr_size
* 2, _("Value"));
16320 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16322 if (ent
== (bfd_vma
) -1)
16323 goto sgot_print_fail
;
16335 for (entry
= dynamic_section
;
16336 /* PR 17531 file: 012-50589-0.004. */
16337 entry
< dynamic_section
+ dynamic_nent
&& entry
->d_tag
!= DT_NULL
;
16339 switch (entry
->d_tag
)
16341 case DT_MIPS_LIBLIST
:
16343 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
16344 liblistno
* sizeof (Elf32_External_Lib
));
16346 case DT_MIPS_LIBLISTNO
:
16347 liblistno
= entry
->d_un
.d_val
;
16349 case DT_MIPS_OPTIONS
:
16350 options_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
16352 case DT_MIPS_CONFLICT
:
16354 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
16355 conflictsno
* sizeof (Elf32_External_Conflict
));
16357 case DT_MIPS_CONFLICTNO
:
16358 conflictsno
= entry
->d_un
.d_val
;
16361 pltgot
= entry
->d_un
.d_ptr
;
16363 case DT_MIPS_LOCAL_GOTNO
:
16364 local_gotno
= entry
->d_un
.d_val
;
16366 case DT_MIPS_GOTSYM
:
16367 gotsym
= entry
->d_un
.d_val
;
16369 case DT_MIPS_SYMTABNO
:
16370 symtabno
= entry
->d_un
.d_val
;
16372 case DT_MIPS_PLTGOT
:
16373 mips_pltgot
= entry
->d_un
.d_ptr
;
16376 pltrel
= entry
->d_un
.d_val
;
16379 pltrelsz
= entry
->d_un
.d_val
;
16382 jmprel
= entry
->d_un
.d_ptr
;
16388 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
16390 Elf32_External_Lib
* elib
;
16393 elib
= (Elf32_External_Lib
*) get_data (NULL
, filedata
, liblist_offset
,
16395 sizeof (Elf32_External_Lib
),
16396 _("liblist section data"));
16399 printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
16400 "\nSection '.liblist' contains %lu entries:\n",
16401 (unsigned long) liblistno
),
16402 (unsigned long) liblistno
);
16403 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
16406 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
16413 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
16414 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
16415 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
16416 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
16417 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
16419 tmp
= gmtime (&atime
);
16420 snprintf (timebuf
, sizeof (timebuf
),
16421 "%04u-%02u-%02uT%02u:%02u:%02u",
16422 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
16423 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
16425 printf ("%3lu: ", (unsigned long) cnt
);
16426 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
16427 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
16429 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
16430 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
16431 liblist
.l_version
);
16433 if (liblist
.l_flags
== 0)
16437 static const struct
16444 { " EXACT_MATCH", LL_EXACT_MATCH
},
16445 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
16446 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
16447 { " EXPORTS", LL_EXPORTS
},
16448 { " DELAY_LOAD", LL_DELAY_LOAD
},
16449 { " DELTA", LL_DELTA
}
16451 int flags
= liblist
.l_flags
;
16454 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
16455 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
16457 fputs (l_flags_vals
[fcnt
].name
, stdout
);
16458 flags
^= l_flags_vals
[fcnt
].bit
;
16461 printf (" %#x", (unsigned int) flags
);
16473 if (options_offset
!= 0)
16475 Elf_External_Options
* eopt
;
16476 Elf_Internal_Options
* iopt
;
16477 Elf_Internal_Options
* option
;
16480 sect
= filedata
->section_headers
;
16482 /* Find the section header so that we get the size. */
16483 sect
= find_section_by_type (filedata
, SHT_MIPS_OPTIONS
);
16484 /* PR 17533 file: 012-277276-0.004. */
16487 error (_("No MIPS_OPTIONS header found\n"));
16491 if (sect
->sh_size
< sizeof (* eopt
))
16493 error (_("The MIPS options section is too small.\n"));
16497 eopt
= (Elf_External_Options
*) get_data (NULL
, filedata
, options_offset
, 1,
16498 sect
->sh_size
, _("options"));
16501 iopt
= (Elf_Internal_Options
*)
16502 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
16505 error (_("Out of memory allocating space for MIPS options\n"));
16512 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
16514 Elf_External_Options
* eoption
;
16516 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
16518 option
->kind
= BYTE_GET (eoption
->kind
);
16519 option
->size
= BYTE_GET (eoption
->size
);
16520 option
->section
= BYTE_GET (eoption
->section
);
16521 option
->info
= BYTE_GET (eoption
->info
);
16523 /* PR 17531: file: ffa0fa3b. */
16524 if (option
->size
< sizeof (* eopt
)
16525 || offset
+ option
->size
> sect
->sh_size
)
16527 error (_("Invalid size (%u) for MIPS option\n"), option
->size
);
16530 offset
+= option
->size
;
16536 printf (ngettext ("\nSection '%s' contains %d entry:\n",
16537 "\nSection '%s' contains %d entries:\n",
16539 printable_section_name (filedata
, sect
), cnt
);
16548 switch (option
->kind
)
16551 /* This shouldn't happen. */
16552 printf (" NULL %d %lx", option
->section
, option
->info
);
16555 printf (" REGINFO ");
16556 if (filedata
->file_header
.e_machine
== EM_MIPS
)
16559 Elf32_External_RegInfo
* ereg
;
16560 Elf32_RegInfo reginfo
;
16562 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
16563 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
16564 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
16565 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
16566 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
16567 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
16568 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
16570 printf ("GPR %08lx GP 0x%lx\n",
16571 reginfo
.ri_gprmask
,
16572 (unsigned long) reginfo
.ri_gp_value
);
16573 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
16574 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
16575 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
16580 Elf64_External_RegInfo
* ereg
;
16581 Elf64_Internal_RegInfo reginfo
;
16583 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
16584 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
16585 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
16586 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
16587 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
16588 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
16589 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
16591 printf ("GPR %08lx GP 0x",
16592 reginfo
.ri_gprmask
);
16593 printf_vma (reginfo
.ri_gp_value
);
16596 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
16597 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
16598 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
16602 case ODK_EXCEPTIONS
:
16603 fputs (" EXCEPTIONS fpe_min(", stdout
);
16604 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
16605 fputs (") fpe_max(", stdout
);
16606 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
16607 fputs (")", stdout
);
16609 if (option
->info
& OEX_PAGE0
)
16610 fputs (" PAGE0", stdout
);
16611 if (option
->info
& OEX_SMM
)
16612 fputs (" SMM", stdout
);
16613 if (option
->info
& OEX_FPDBUG
)
16614 fputs (" FPDBUG", stdout
);
16615 if (option
->info
& OEX_DISMISS
)
16616 fputs (" DISMISS", stdout
);
16619 fputs (" PAD ", stdout
);
16620 if (option
->info
& OPAD_PREFIX
)
16621 fputs (" PREFIX", stdout
);
16622 if (option
->info
& OPAD_POSTFIX
)
16623 fputs (" POSTFIX", stdout
);
16624 if (option
->info
& OPAD_SYMBOL
)
16625 fputs (" SYMBOL", stdout
);
16628 fputs (" HWPATCH ", stdout
);
16629 if (option
->info
& OHW_R4KEOP
)
16630 fputs (" R4KEOP", stdout
);
16631 if (option
->info
& OHW_R8KPFETCH
)
16632 fputs (" R8KPFETCH", stdout
);
16633 if (option
->info
& OHW_R5KEOP
)
16634 fputs (" R5KEOP", stdout
);
16635 if (option
->info
& OHW_R5KCVTL
)
16636 fputs (" R5KCVTL", stdout
);
16639 fputs (" FILL ", stdout
);
16640 /* XXX Print content of info word? */
16643 fputs (" TAGS ", stdout
);
16644 /* XXX Print content of info word? */
16647 fputs (" HWAND ", stdout
);
16648 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
16649 fputs (" R4KEOP_CHECKED", stdout
);
16650 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
16651 fputs (" R4KEOP_CLEAN", stdout
);
16654 fputs (" HWOR ", stdout
);
16655 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
16656 fputs (" R4KEOP_CHECKED", stdout
);
16657 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
16658 fputs (" R4KEOP_CLEAN", stdout
);
16661 printf (" GP_GROUP %#06lx self-contained %#06lx",
16662 option
->info
& OGP_GROUP
,
16663 (option
->info
& OGP_SELF
) >> 16);
16666 printf (" IDENT %#06lx self-contained %#06lx",
16667 option
->info
& OGP_GROUP
,
16668 (option
->info
& OGP_SELF
) >> 16);
16671 /* This shouldn't happen. */
16672 printf (" %3d ??? %d %lx",
16673 option
->kind
, option
->section
, option
->info
);
16677 len
= sizeof (* eopt
);
16678 while (len
< option
->size
)
16680 unsigned char datum
= * ((unsigned char *) eopt
+ offset
+ len
);
16682 if (ISPRINT (datum
))
16683 printf ("%c", datum
);
16685 printf ("\\%03o", datum
);
16688 fputs ("\n", stdout
);
16690 offset
+= option
->size
;
16700 if (conflicts_offset
!= 0 && conflictsno
!= 0)
16702 Elf32_Conflict
* iconf
;
16705 if (dynamic_symbols
== NULL
)
16707 error (_("conflict list found without a dynamic symbol table\n"));
16711 /* PR 21345 - print a slightly more helpful error message
16712 if we are sure that the cmalloc will fail. */
16713 if (conflictsno
* sizeof (* iconf
) > filedata
->file_size
)
16715 error (_("Overlarge number of conflicts detected: %lx\n"),
16716 (long) conflictsno
);
16720 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
16723 error (_("Out of memory allocating space for dynamic conflicts\n"));
16729 Elf32_External_Conflict
* econf32
;
16731 econf32
= (Elf32_External_Conflict
*)
16732 get_data (NULL
, filedata
, conflicts_offset
, conflictsno
,
16733 sizeof (* econf32
), _("conflict"));
16737 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
16738 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
16744 Elf64_External_Conflict
* econf64
;
16746 econf64
= (Elf64_External_Conflict
*)
16747 get_data (NULL
, filedata
, conflicts_offset
, conflictsno
,
16748 sizeof (* econf64
), _("conflict"));
16752 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
16753 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
16758 printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
16759 "\nSection '.conflict' contains %lu entries:\n",
16760 (unsigned long) conflictsno
),
16761 (unsigned long) conflictsno
);
16762 puts (_(" Num: Index Value Name"));
16764 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
16766 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
16768 if (iconf
[cnt
] >= num_dynamic_syms
)
16769 printf (_("<corrupt symbol index>"));
16772 Elf_Internal_Sym
* psym
;
16774 psym
= & dynamic_symbols
[iconf
[cnt
]];
16775 print_vma (psym
->st_value
, FULL_HEX
);
16777 if (VALID_DYNAMIC_NAME (psym
->st_name
))
16778 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
16780 printf (_("<corrupt: %14ld>"), psym
->st_name
);
16788 if (pltgot
!= 0 && local_gotno
!= 0)
16790 bfd_vma ent
, local_end
, global_end
;
16792 unsigned char * data
;
16793 unsigned char * data_end
;
16797 addr_size
= (is_32bit_elf
? 4 : 8);
16798 local_end
= pltgot
+ local_gotno
* addr_size
;
16800 /* PR binutils/17533 file: 012-111227-0.004 */
16801 if (symtabno
< gotsym
)
16803 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
16804 (unsigned long) gotsym
, (unsigned long) symtabno
);
16808 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
16809 /* PR 17531: file: 54c91a34. */
16810 if (global_end
< local_end
)
16812 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
16816 offset
= offset_from_vma (filedata
, pltgot
, global_end
- pltgot
);
16817 data
= (unsigned char *) get_data (NULL
, filedata
, offset
,
16818 global_end
- pltgot
, 1,
16819 _("Global Offset Table data"));
16820 /* PR 12855: Null data is handled gracefully throughout. */
16821 data_end
= data
+ (global_end
- pltgot
);
16823 printf (_("\nPrimary GOT:\n"));
16824 printf (_(" Canonical gp value: "));
16825 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
16828 printf (_(" Reserved entries:\n"));
16829 printf (_(" %*s %10s %*s Purpose\n"),
16830 addr_size
* 2, _("Address"), _("Access"),
16831 addr_size
* 2, _("Initial"));
16832 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16833 printf (_(" Lazy resolver\n"));
16834 if (ent
== (bfd_vma
) -1)
16835 goto got_print_fail
;
16837 /* Check for the MSB of GOT[1] being set, denoting a GNU object.
16838 This entry will be used by some runtime loaders, to store the
16839 module pointer. Otherwise this is an ordinary local entry.
16840 PR 21344: Check for the entry being fully available before
16843 && data
+ ent
- pltgot
+ addr_size
<= data_end
16844 && (byte_get (data
+ ent
- pltgot
, addr_size
)
16845 >> (addr_size
* 8 - 1)) != 0)
16847 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16848 printf (_(" Module pointer (GNU extension)\n"));
16849 if (ent
== (bfd_vma
) -1)
16850 goto got_print_fail
;
16854 if (data
!= NULL
&& ent
< local_end
)
16856 printf (_(" Local entries:\n"));
16857 printf (" %*s %10s %*s\n",
16858 addr_size
* 2, _("Address"), _("Access"),
16859 addr_size
* 2, _("Initial"));
16860 while (ent
< local_end
)
16862 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16864 if (ent
== (bfd_vma
) -1)
16865 goto got_print_fail
;
16870 if (data
!= NULL
&& gotsym
< symtabno
)
16874 printf (_(" Global entries:\n"));
16875 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
16876 addr_size
* 2, _("Address"),
16878 addr_size
* 2, _("Initial"),
16879 addr_size
* 2, _("Sym.Val."),
16881 /* Note for translators: "Ndx" = abbreviated form of "Index". */
16882 _("Ndx"), _("Name"));
16884 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
16886 for (i
= gotsym
; i
< symtabno
; i
++)
16888 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16891 if (dynamic_symbols
== NULL
)
16892 printf (_("<no dynamic symbols>"));
16893 else if (i
< num_dynamic_syms
)
16895 Elf_Internal_Sym
* psym
= dynamic_symbols
+ i
;
16897 print_vma (psym
->st_value
, LONG_HEX
);
16898 printf (" %-7s %3s ",
16899 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
16900 get_symbol_index_type (filedata
, psym
->st_shndx
));
16902 if (VALID_DYNAMIC_NAME (psym
->st_name
))
16903 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
16905 printf (_("<corrupt: %14ld>"), psym
->st_name
);
16908 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
16909 (unsigned long) i
);
16912 if (ent
== (bfd_vma
) -1)
16923 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
16926 size_t offset
, rel_offset
;
16927 unsigned long count
, i
;
16928 unsigned char * data
;
16929 int addr_size
, sym_width
;
16930 Elf_Internal_Rela
* rels
;
16932 rel_offset
= offset_from_vma (filedata
, jmprel
, pltrelsz
);
16933 if (pltrel
== DT_RELA
)
16935 if (!slurp_rela_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
16940 if (!slurp_rel_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
16945 addr_size
= (is_32bit_elf
? 4 : 8);
16946 end
= mips_pltgot
+ (2 + count
) * addr_size
;
16948 offset
= offset_from_vma (filedata
, mips_pltgot
, end
- mips_pltgot
);
16949 data
= (unsigned char *) get_data (NULL
, filedata
, offset
, end
- mips_pltgot
,
16950 1, _("Procedure Linkage Table data"));
16954 printf ("\nPLT GOT:\n\n");
16955 printf (_(" Reserved entries:\n"));
16956 printf (_(" %*s %*s Purpose\n"),
16957 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
16958 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
16959 printf (_(" PLT lazy resolver\n"));
16960 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
16961 printf (_(" Module pointer\n"));
16964 printf (_(" Entries:\n"));
16965 printf (" %*s %*s %*s %-7s %3s %s\n",
16966 addr_size
* 2, _("Address"),
16967 addr_size
* 2, _("Initial"),
16968 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
16969 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
16970 for (i
= 0; i
< count
; i
++)
16972 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
16974 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
16977 if (idx
>= num_dynamic_syms
)
16978 printf (_("<corrupt symbol index: %lu>"), idx
);
16981 Elf_Internal_Sym
* psym
= dynamic_symbols
+ idx
;
16983 print_vma (psym
->st_value
, LONG_HEX
);
16984 printf (" %-7s %3s ",
16985 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
16986 get_symbol_index_type (filedata
, psym
->st_shndx
));
16987 if (VALID_DYNAMIC_NAME (psym
->st_name
))
16988 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
16990 printf (_("<corrupt: %14ld>"), psym
->st_name
);
17005 process_nds32_specific (Filedata
* filedata
)
17007 Elf_Internal_Shdr
*sect
= NULL
;
17009 sect
= find_section (filedata
, ".nds32_e_flags");
17012 unsigned int *flag
;
17014 printf ("\nNDS32 elf flags section:\n");
17015 flag
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
17016 sect
->sh_size
, _("NDS32 elf flags section"));
17021 switch ((*flag
) & 0x3)
17024 printf ("(VEC_SIZE):\tNo entry.\n");
17027 printf ("(VEC_SIZE):\t4 bytes\n");
17030 printf ("(VEC_SIZE):\t16 bytes\n");
17033 printf ("(VEC_SIZE):\treserved\n");
17042 process_gnu_liblist (Filedata
* filedata
)
17044 Elf_Internal_Shdr
* section
;
17045 Elf_Internal_Shdr
* string_sec
;
17046 Elf32_External_Lib
* elib
;
17048 size_t strtab_size
;
17050 unsigned long num_liblist
;
17052 bfd_boolean res
= TRUE
;
17057 for (i
= 0, section
= filedata
->section_headers
;
17058 i
< filedata
->file_header
.e_shnum
;
17061 switch (section
->sh_type
)
17063 case SHT_GNU_LIBLIST
:
17064 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
17067 elib
= (Elf32_External_Lib
*)
17068 get_data (NULL
, filedata
, section
->sh_offset
, 1, section
->sh_size
,
17069 _("liblist section data"));
17077 string_sec
= filedata
->section_headers
+ section
->sh_link
;
17078 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
17079 string_sec
->sh_size
,
17080 _("liblist string table"));
17082 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
17089 strtab_size
= string_sec
->sh_size
;
17091 num_liblist
= section
->sh_size
/ sizeof (Elf32_External_Lib
);
17092 printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
17093 "\nLibrary list section '%s' contains %lu entries:\n",
17095 printable_section_name (filedata
, section
),
17098 puts (_(" Library Time Stamp Checksum Version Flags"));
17100 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
17108 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
17109 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
17110 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
17111 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
17112 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
17114 tmp
= gmtime (&atime
);
17115 snprintf (timebuf
, sizeof (timebuf
),
17116 "%04u-%02u-%02uT%02u:%02u:%02u",
17117 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
17118 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
17120 printf ("%3lu: ", (unsigned long) cnt
);
17122 printf ("%-20s", liblist
.l_name
< strtab_size
17123 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
17125 printf ("%-20.20s", liblist
.l_name
< strtab_size
17126 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
17127 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
17128 liblist
.l_version
, liblist
.l_flags
);
17139 static const char *
17140 get_note_type (Filedata
* filedata
, unsigned e_type
)
17142 static char buff
[64];
17144 if (filedata
->file_header
.e_type
== ET_CORE
)
17148 return _("NT_AUXV (auxiliary vector)");
17150 return _("NT_PRSTATUS (prstatus structure)");
17152 return _("NT_FPREGSET (floating point registers)");
17154 return _("NT_PRPSINFO (prpsinfo structure)");
17155 case NT_TASKSTRUCT
:
17156 return _("NT_TASKSTRUCT (task structure)");
17158 return _("NT_PRXFPREG (user_xfpregs structure)");
17160 return _("NT_PPC_VMX (ppc Altivec registers)");
17162 return _("NT_PPC_VSX (ppc VSX registers)");
17164 return _("NT_PPC_TAR (ppc TAR register)");
17166 return _("NT_PPC_PPR (ppc PPR register)");
17168 return _("NT_PPC_DSCR (ppc DSCR register)");
17170 return _("NT_PPC_EBB (ppc EBB registers)");
17172 return _("NT_PPC_PMU (ppc PMU registers)");
17173 case NT_PPC_TM_CGPR
:
17174 return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
17175 case NT_PPC_TM_CFPR
:
17176 return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
17177 case NT_PPC_TM_CVMX
:
17178 return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
17179 case NT_PPC_TM_CVSX
:
17180 return _("NT_PPC_TM_CVSX (ppc checkpointed VSX registers)");
17181 case NT_PPC_TM_SPR
:
17182 return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
17183 case NT_PPC_TM_CTAR
:
17184 return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
17185 case NT_PPC_TM_CPPR
:
17186 return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
17187 case NT_PPC_TM_CDSCR
:
17188 return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
17190 return _("NT_386_TLS (x86 TLS information)");
17191 case NT_386_IOPERM
:
17192 return _("NT_386_IOPERM (x86 I/O permissions)");
17193 case NT_X86_XSTATE
:
17194 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
17195 case NT_S390_HIGH_GPRS
:
17196 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
17197 case NT_S390_TIMER
:
17198 return _("NT_S390_TIMER (s390 timer register)");
17199 case NT_S390_TODCMP
:
17200 return _("NT_S390_TODCMP (s390 TOD comparator register)");
17201 case NT_S390_TODPREG
:
17202 return _("NT_S390_TODPREG (s390 TOD programmable register)");
17204 return _("NT_S390_CTRS (s390 control registers)");
17205 case NT_S390_PREFIX
:
17206 return _("NT_S390_PREFIX (s390 prefix register)");
17207 case NT_S390_LAST_BREAK
:
17208 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
17209 case NT_S390_SYSTEM_CALL
:
17210 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
17212 return _("NT_S390_TDB (s390 transaction diagnostic block)");
17213 case NT_S390_VXRS_LOW
:
17214 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
17215 case NT_S390_VXRS_HIGH
:
17216 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
17217 case NT_S390_GS_CB
:
17218 return _("NT_S390_GS_CB (s390 guarded-storage registers)");
17219 case NT_S390_GS_BC
:
17220 return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
17222 return _("NT_ARM_VFP (arm VFP registers)");
17224 return _("NT_ARM_TLS (AArch TLS registers)");
17225 case NT_ARM_HW_BREAK
:
17226 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
17227 case NT_ARM_HW_WATCH
:
17228 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
17230 return _("NT_PSTATUS (pstatus structure)");
17232 return _("NT_FPREGS (floating point registers)");
17234 return _("NT_PSINFO (psinfo structure)");
17236 return _("NT_LWPSTATUS (lwpstatus_t structure)");
17238 return _("NT_LWPSINFO (lwpsinfo_t structure)");
17239 case NT_WIN32PSTATUS
:
17240 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
17242 return _("NT_SIGINFO (siginfo_t data)");
17244 return _("NT_FILE (mapped files)");
17252 return _("NT_VERSION (version)");
17254 return _("NT_ARCH (architecture)");
17255 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
17257 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
17263 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17268 print_core_note (Elf_Internal_Note
*pnote
)
17270 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
17271 bfd_vma count
, page_size
;
17272 unsigned char *descdata
, *filenames
, *descend
;
17274 if (pnote
->type
!= NT_FILE
)
17284 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
17285 /* Still "successful". */
17290 if (pnote
->descsz
< 2 * addr_size
)
17292 error (_(" Malformed note - too short for header\n"));
17296 descdata
= (unsigned char *) pnote
->descdata
;
17297 descend
= descdata
+ pnote
->descsz
;
17299 if (descdata
[pnote
->descsz
- 1] != '\0')
17301 error (_(" Malformed note - does not end with \\0\n"));
17305 count
= byte_get (descdata
, addr_size
);
17306 descdata
+= addr_size
;
17308 page_size
= byte_get (descdata
, addr_size
);
17309 descdata
+= addr_size
;
17311 if (count
> ((bfd_vma
) -1 - 2 * addr_size
) / (3 * addr_size
)
17312 || pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
17314 error (_(" Malformed note - too short for supplied file count\n"));
17318 printf (_(" Page size: "));
17319 print_vma (page_size
, DEC
);
17322 printf (_(" %*s%*s%*s\n"),
17323 (int) (2 + 2 * addr_size
), _("Start"),
17324 (int) (4 + 2 * addr_size
), _("End"),
17325 (int) (4 + 2 * addr_size
), _("Page Offset"));
17326 filenames
= descdata
+ count
* 3 * addr_size
;
17327 while (count
-- > 0)
17329 bfd_vma start
, end
, file_ofs
;
17331 if (filenames
== descend
)
17333 error (_(" Malformed note - filenames end too early\n"));
17337 start
= byte_get (descdata
, addr_size
);
17338 descdata
+= addr_size
;
17339 end
= byte_get (descdata
, addr_size
);
17340 descdata
+= addr_size
;
17341 file_ofs
= byte_get (descdata
, addr_size
);
17342 descdata
+= addr_size
;
17345 print_vma (start
, FULL_HEX
);
17347 print_vma (end
, FULL_HEX
);
17349 print_vma (file_ofs
, FULL_HEX
);
17350 printf ("\n %s\n", filenames
);
17352 filenames
+= 1 + strlen ((char *) filenames
);
17358 static const char *
17359 get_gnu_elf_note_type (unsigned e_type
)
17361 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
17364 case NT_GNU_ABI_TAG
:
17365 return _("NT_GNU_ABI_TAG (ABI version tag)");
17367 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
17368 case NT_GNU_BUILD_ID
:
17369 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
17370 case NT_GNU_GOLD_VERSION
:
17371 return _("NT_GNU_GOLD_VERSION (gold version)");
17372 case NT_GNU_PROPERTY_TYPE_0
:
17373 return _("NT_GNU_PROPERTY_TYPE_0");
17374 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
17375 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
17376 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
17377 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
17380 static char buff
[64];
17382 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17389 decode_x86_compat_isa (unsigned int bitmask
)
17393 unsigned int bit
= bitmask
& (- bitmask
);
17398 case GNU_PROPERTY_X86_COMPAT_ISA_1_486
:
17401 case GNU_PROPERTY_X86_COMPAT_ISA_1_586
:
17404 case GNU_PROPERTY_X86_COMPAT_ISA_1_686
:
17407 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE
:
17410 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE2
:
17413 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE3
:
17416 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSSE3
:
17419 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_1
:
17422 case GNU_PROPERTY_X86_COMPAT_ISA_1_SSE4_2
:
17425 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX
:
17428 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX2
:
17431 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512F
:
17432 printf ("AVX512F");
17434 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512CD
:
17435 printf ("AVX512CD");
17437 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512ER
:
17438 printf ("AVX512ER");
17440 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512PF
:
17441 printf ("AVX512PF");
17443 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512VL
:
17444 printf ("AVX512VL");
17446 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512DQ
:
17447 printf ("AVX512DQ");
17449 case GNU_PROPERTY_X86_COMPAT_ISA_1_AVX512BW
:
17450 printf ("AVX512BW");
17453 printf (_("<unknown: %x>"), bit
);
17462 decode_x86_isa (unsigned int bitmask
)
17466 printf (_("<None>"));
17472 unsigned int bit
= bitmask
& (- bitmask
);
17477 case GNU_PROPERTY_X86_ISA_1_CMOV
:
17480 case GNU_PROPERTY_X86_ISA_1_SSE
:
17483 case GNU_PROPERTY_X86_ISA_1_SSE2
:
17486 case GNU_PROPERTY_X86_ISA_1_SSE3
:
17489 case GNU_PROPERTY_X86_ISA_1_SSSE3
:
17492 case GNU_PROPERTY_X86_ISA_1_SSE4_1
:
17495 case GNU_PROPERTY_X86_ISA_1_SSE4_2
:
17498 case GNU_PROPERTY_X86_ISA_1_AVX
:
17501 case GNU_PROPERTY_X86_ISA_1_AVX2
:
17504 case GNU_PROPERTY_X86_ISA_1_FMA
:
17507 case GNU_PROPERTY_X86_ISA_1_AVX512F
:
17508 printf ("AVX512F");
17510 case GNU_PROPERTY_X86_ISA_1_AVX512CD
:
17511 printf ("AVX512CD");
17513 case GNU_PROPERTY_X86_ISA_1_AVX512ER
:
17514 printf ("AVX512ER");
17516 case GNU_PROPERTY_X86_ISA_1_AVX512PF
:
17517 printf ("AVX512PF");
17519 case GNU_PROPERTY_X86_ISA_1_AVX512VL
:
17520 printf ("AVX512VL");
17522 case GNU_PROPERTY_X86_ISA_1_AVX512DQ
:
17523 printf ("AVX512DQ");
17525 case GNU_PROPERTY_X86_ISA_1_AVX512BW
:
17526 printf ("AVX512BW");
17528 case GNU_PROPERTY_X86_ISA_1_AVX512_4FMAPS
:
17529 printf ("AVX512_4FMAPS");
17531 case GNU_PROPERTY_X86_ISA_1_AVX512_4VNNIW
:
17532 printf ("AVX512_4VNNIW");
17534 case GNU_PROPERTY_X86_ISA_1_AVX512_BITALG
:
17535 printf ("AVX512_BITALG");
17537 case GNU_PROPERTY_X86_ISA_1_AVX512_IFMA
:
17538 printf ("AVX512_IFMA");
17540 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI
:
17541 printf ("AVX512_VBMI");
17543 case GNU_PROPERTY_X86_ISA_1_AVX512_VBMI2
:
17544 printf ("AVX512_VBMI2");
17546 case GNU_PROPERTY_X86_ISA_1_AVX512_VNNI
:
17547 printf ("AVX512_VNNI");
17549 case GNU_PROPERTY_X86_ISA_1_AVX512_BF16
:
17550 printf ("AVX512_BF16");
17553 printf (_("<unknown: %x>"), bit
);
17562 decode_x86_feature_1 (unsigned int bitmask
)
17566 printf (_("<None>"));
17572 unsigned int bit
= bitmask
& (- bitmask
);
17577 case GNU_PROPERTY_X86_FEATURE_1_IBT
:
17580 case GNU_PROPERTY_X86_FEATURE_1_SHSTK
:
17584 printf (_("<unknown: %x>"), bit
);
17593 decode_x86_feature_2 (unsigned int bitmask
)
17597 printf (_("<None>"));
17603 unsigned int bit
= bitmask
& (- bitmask
);
17608 case GNU_PROPERTY_X86_FEATURE_2_X86
:
17611 case GNU_PROPERTY_X86_FEATURE_2_X87
:
17614 case GNU_PROPERTY_X86_FEATURE_2_MMX
:
17617 case GNU_PROPERTY_X86_FEATURE_2_XMM
:
17620 case GNU_PROPERTY_X86_FEATURE_2_YMM
:
17623 case GNU_PROPERTY_X86_FEATURE_2_ZMM
:
17626 case GNU_PROPERTY_X86_FEATURE_2_FXSR
:
17629 case GNU_PROPERTY_X86_FEATURE_2_XSAVE
:
17632 case GNU_PROPERTY_X86_FEATURE_2_XSAVEOPT
:
17633 printf ("XSAVEOPT");
17635 case GNU_PROPERTY_X86_FEATURE_2_XSAVEC
:
17639 printf (_("<unknown: %x>"), bit
);
17648 decode_aarch64_feature_1_and (unsigned int bitmask
)
17652 unsigned int bit
= bitmask
& (- bitmask
);
17657 case GNU_PROPERTY_AARCH64_FEATURE_1_BTI
:
17661 case GNU_PROPERTY_AARCH64_FEATURE_1_PAC
:
17666 printf (_("<unknown: %x>"), bit
);
17675 print_gnu_property_note (Filedata
* filedata
, Elf_Internal_Note
* pnote
)
17677 unsigned char * ptr
= (unsigned char *) pnote
->descdata
;
17678 unsigned char * ptr_end
= ptr
+ pnote
->descsz
;
17679 unsigned int size
= is_32bit_elf
? 4 : 8;
17681 printf (_(" Properties: "));
17683 if (pnote
->descsz
< 8 || (pnote
->descsz
% size
) != 0)
17685 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote
->descsz
);
17689 while (ptr
< ptr_end
)
17693 unsigned int datasz
;
17695 if ((size_t) (ptr_end
- ptr
) < 8)
17697 printf (_("<corrupt descsz: %#lx>\n"), pnote
->descsz
);
17701 type
= byte_get (ptr
, 4);
17702 datasz
= byte_get (ptr
+ 4, 4);
17706 if (datasz
> (size_t) (ptr_end
- ptr
))
17708 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
17713 if (type
>= GNU_PROPERTY_LOPROC
&& type
<= GNU_PROPERTY_HIPROC
)
17715 if (filedata
->file_header
.e_machine
== EM_X86_64
17716 || filedata
->file_header
.e_machine
== EM_IAMCU
17717 || filedata
->file_header
.e_machine
== EM_386
)
17719 unsigned int bitmask
;
17722 bitmask
= byte_get (ptr
, 4);
17728 case GNU_PROPERTY_X86_ISA_1_USED
:
17730 printf (_("x86 ISA used: <corrupt length: %#x> "),
17734 printf ("x86 ISA used: ");
17735 decode_x86_isa (bitmask
);
17739 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
17741 printf (_("x86 ISA needed: <corrupt length: %#x> "),
17745 printf ("x86 ISA needed: ");
17746 decode_x86_isa (bitmask
);
17750 case GNU_PROPERTY_X86_FEATURE_1_AND
:
17752 printf (_("x86 feature: <corrupt length: %#x> "),
17756 printf ("x86 feature: ");
17757 decode_x86_feature_1 (bitmask
);
17761 case GNU_PROPERTY_X86_FEATURE_2_USED
:
17763 printf (_("x86 feature used: <corrupt length: %#x> "),
17767 printf ("x86 feature used: ");
17768 decode_x86_feature_2 (bitmask
);
17772 case GNU_PROPERTY_X86_FEATURE_2_NEEDED
:
17774 printf (_("x86 feature needed: <corrupt length: %#x> "), datasz
);
17777 printf ("x86 feature needed: ");
17778 decode_x86_feature_2 (bitmask
);
17782 case GNU_PROPERTY_X86_COMPAT_ISA_1_USED
:
17784 printf (_("x86 ISA used: <corrupt length: %#x> "),
17788 printf ("x86 ISA used: ");
17789 decode_x86_compat_isa (bitmask
);
17793 case GNU_PROPERTY_X86_COMPAT_ISA_1_NEEDED
:
17795 printf (_("x86 ISA needed: <corrupt length: %#x> "),
17799 printf ("x86 ISA needed: ");
17800 decode_x86_compat_isa (bitmask
);
17808 else if (filedata
->file_header
.e_machine
== EM_AARCH64
)
17810 if (type
== GNU_PROPERTY_AARCH64_FEATURE_1_AND
)
17812 printf ("AArch64 feature: ");
17814 printf (_("<corrupt length: %#x> "), datasz
);
17816 decode_aarch64_feature_1_and (byte_get (ptr
, 4));
17825 case GNU_PROPERTY_STACK_SIZE
:
17826 printf (_("stack size: "));
17827 if (datasz
!= size
)
17828 printf (_("<corrupt length: %#x> "), datasz
);
17830 printf ("%#lx", (unsigned long) byte_get (ptr
, size
));
17833 case GNU_PROPERTY_NO_COPY_ON_PROTECTED
:
17834 printf ("no copy on protected ");
17836 printf (_("<corrupt length: %#x> "), datasz
);
17844 if (type
< GNU_PROPERTY_LOPROC
)
17845 printf (_("<unknown type %#x data: "), type
);
17846 else if (type
< GNU_PROPERTY_LOUSER
)
17847 printf (_("<procesor-specific type %#x data: "), type
);
17849 printf (_("<application-specific type %#x data: "), type
);
17850 for (j
= 0; j
< datasz
; ++j
)
17851 printf ("%02x ", ptr
[j
] & 0xff);
17855 ptr
+= ((datasz
+ (size
- 1)) & ~ (size
- 1));
17856 if (ptr
== ptr_end
)
17869 print_gnu_note (Filedata
* filedata
, Elf_Internal_Note
*pnote
)
17871 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
17872 switch (pnote
->type
)
17874 case NT_GNU_BUILD_ID
:
17878 printf (_(" Build ID: "));
17879 for (i
= 0; i
< pnote
->descsz
; ++i
)
17880 printf ("%02x", pnote
->descdata
[i
] & 0xff);
17885 case NT_GNU_ABI_TAG
:
17887 unsigned long os
, major
, minor
, subminor
;
17888 const char *osname
;
17890 /* PR 17531: file: 030-599401-0.004. */
17891 if (pnote
->descsz
< 16)
17893 printf (_(" <corrupt GNU_ABI_TAG>\n"));
17897 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
17898 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
17899 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
17900 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
17904 case GNU_ABI_TAG_LINUX
:
17907 case GNU_ABI_TAG_HURD
:
17910 case GNU_ABI_TAG_SOLARIS
:
17911 osname
= "Solaris";
17913 case GNU_ABI_TAG_FREEBSD
:
17914 osname
= "FreeBSD";
17916 case GNU_ABI_TAG_NETBSD
:
17919 case GNU_ABI_TAG_SYLLABLE
:
17920 osname
= "Syllable";
17922 case GNU_ABI_TAG_NACL
:
17926 osname
= "Unknown";
17930 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
17931 major
, minor
, subminor
);
17935 case NT_GNU_GOLD_VERSION
:
17939 printf (_(" Version: "));
17940 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
17941 printf ("%c", pnote
->descdata
[i
]);
17948 unsigned long num_entries
, mask
;
17950 /* Hardware capabilities information. Word 0 is the number of entries.
17951 Word 1 is a bitmask of enabled entries. The rest of the descriptor
17952 is a series of entries, where each entry is a single byte followed
17953 by a nul terminated string. The byte gives the bit number to test
17954 if enabled in the bitmask. */
17955 printf (_(" Hardware Capabilities: "));
17956 if (pnote
->descsz
< 8)
17958 error (_("<corrupt GNU_HWCAP>\n"));
17961 num_entries
= byte_get ((unsigned char *) pnote
->descdata
, 4);
17962 mask
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
17963 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries
, mask
);
17964 /* FIXME: Add code to display the entries... */
17968 case NT_GNU_PROPERTY_TYPE_0
:
17969 print_gnu_property_note (filedata
, pnote
);
17973 /* Handle unrecognised types. An error message should have already been
17974 created by get_gnu_elf_note_type(), so all that we need to do is to
17975 display the data. */
17979 printf (_(" Description data: "));
17980 for (i
= 0; i
< pnote
->descsz
; ++i
)
17981 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
17990 static const char *
17991 get_v850_elf_note_type (enum v850_notes n_type
)
17993 static char buff
[64];
17997 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
17998 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
17999 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
18000 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
18001 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
18002 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
18004 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
18010 print_v850_note (Elf_Internal_Note
* pnote
)
18014 if (pnote
->descsz
!= 4)
18017 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
18021 printf (_("not set\n"));
18025 switch (pnote
->type
)
18027 case V850_NOTE_ALIGNMENT
:
18030 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return TRUE
;
18031 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return TRUE
;
18035 case V850_NOTE_DATA_SIZE
:
18038 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return TRUE
;
18039 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return TRUE
;
18043 case V850_NOTE_FPU_INFO
:
18046 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return TRUE
;
18047 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return TRUE
;
18051 case V850_NOTE_MMU_INFO
:
18052 case V850_NOTE_CACHE_INFO
:
18053 case V850_NOTE_SIMD_INFO
:
18054 if (val
== EF_RH850_SIMD
)
18056 printf (_("yes\n"));
18062 /* An 'unknown note type' message will already have been displayed. */
18066 printf (_("unknown value: %x\n"), val
);
18071 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
18073 unsigned int version
;
18075 switch (pnote
->type
)
18077 case NT_NETBSD_IDENT
:
18078 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
18079 if ((version
/ 10000) % 100)
18080 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
18081 version
, version
/ 100000000, (version
/ 1000000) % 100,
18082 (version
/ 10000) % 100 > 26 ? "Z" : "",
18083 'A' + (version
/ 10000) % 26);
18085 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
18086 version
, version
/ 100000000, (version
/ 1000000) % 100,
18087 (version
/ 100) % 100);
18090 case NT_NETBSD_MARCH
:
18091 printf (" NetBSD\t\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
18095 #ifdef NT_NETBSD_PAX
18096 case NT_NETBSD_PAX
:
18097 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
18098 printf (" NetBSD\t\t0x%08lx\tPaX <%s%s%s%s%s%s>\n", pnote
->descsz
,
18099 ((version
& NT_NETBSD_PAX_MPROTECT
) ? "+mprotect" : ""),
18100 ((version
& NT_NETBSD_PAX_NOMPROTECT
) ? "-mprotect" : ""),
18101 ((version
& NT_NETBSD_PAX_GUARD
) ? "+guard" : ""),
18102 ((version
& NT_NETBSD_PAX_NOGUARD
) ? "-guard" : ""),
18103 ((version
& NT_NETBSD_PAX_ASLR
) ? "+ASLR" : ""),
18104 ((version
& NT_NETBSD_PAX_NOASLR
) ? "-ASLR" : ""));
18109 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote
->descsz
,
18115 static const char *
18116 get_freebsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
18120 case NT_FREEBSD_THRMISC
:
18121 return _("NT_THRMISC (thrmisc structure)");
18122 case NT_FREEBSD_PROCSTAT_PROC
:
18123 return _("NT_PROCSTAT_PROC (proc data)");
18124 case NT_FREEBSD_PROCSTAT_FILES
:
18125 return _("NT_PROCSTAT_FILES (files data)");
18126 case NT_FREEBSD_PROCSTAT_VMMAP
:
18127 return _("NT_PROCSTAT_VMMAP (vmmap data)");
18128 case NT_FREEBSD_PROCSTAT_GROUPS
:
18129 return _("NT_PROCSTAT_GROUPS (groups data)");
18130 case NT_FREEBSD_PROCSTAT_UMASK
:
18131 return _("NT_PROCSTAT_UMASK (umask data)");
18132 case NT_FREEBSD_PROCSTAT_RLIMIT
:
18133 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
18134 case NT_FREEBSD_PROCSTAT_OSREL
:
18135 return _("NT_PROCSTAT_OSREL (osreldate data)");
18136 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
18137 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
18138 case NT_FREEBSD_PROCSTAT_AUXV
:
18139 return _("NT_PROCSTAT_AUXV (auxv data)");
18140 case NT_FREEBSD_PTLWPINFO
:
18141 return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
18143 return get_note_type (filedata
, e_type
);
18146 static const char *
18147 get_netbsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
18149 static char buff
[64];
18153 case NT_NETBSDCORE_PROCINFO
:
18154 /* NetBSD core "procinfo" structure. */
18155 return _("NetBSD procinfo structure");
18157 #ifdef NT_NETBSDCORE_AUXV
18158 case NT_NETBSDCORE_AUXV
:
18159 return _("NetBSD ELF auxiliary vector data");
18163 /* As of Jan 2002 there are no other machine-independent notes
18164 defined for NetBSD core files. If the note type is less
18165 than the start of the machine-dependent note types, we don't
18168 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
18170 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18176 switch (filedata
->file_header
.e_machine
)
18178 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
18179 and PT_GETFPREGS == mach+2. */
18184 case EM_SPARC32PLUS
:
18188 case NT_NETBSDCORE_FIRSTMACH
+ 0:
18189 return _("PT_GETREGS (reg structure)");
18190 case NT_NETBSDCORE_FIRSTMACH
+ 2:
18191 return _("PT_GETFPREGS (fpreg structure)");
18197 /* On SuperH, PT_GETREGS == mach+3 and PT_GETFPREGS == mach+5.
18198 There's also old PT___GETREGS40 == mach + 1 for old reg
18199 structure which lacks GBR. */
18203 case NT_NETBSDCORE_FIRSTMACH
+ 1:
18204 return _("PT___GETREGS40 (old reg structure)");
18205 case NT_NETBSDCORE_FIRSTMACH
+ 3:
18206 return _("PT_GETREGS (reg structure)");
18207 case NT_NETBSDCORE_FIRSTMACH
+ 5:
18208 return _("PT_GETFPREGS (fpreg structure)");
18214 /* On all other arch's, PT_GETREGS == mach+1 and
18215 PT_GETFPREGS == mach+3. */
18219 case NT_NETBSDCORE_FIRSTMACH
+ 1:
18220 return _("PT_GETREGS (reg structure)");
18221 case NT_NETBSDCORE_FIRSTMACH
+ 3:
18222 return _("PT_GETFPREGS (fpreg structure)");
18228 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
18229 e_type
- NT_NETBSDCORE_FIRSTMACH
);
18233 static const char *
18234 get_stapsdt_note_type (unsigned e_type
)
18236 static char buff
[64];
18241 return _("NT_STAPSDT (SystemTap probe descriptors)");
18247 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18252 print_stapsdt_note (Elf_Internal_Note
*pnote
)
18254 size_t len
, maxlen
;
18255 unsigned long addr_size
= is_32bit_elf
? 4 : 8;
18256 char *data
= pnote
->descdata
;
18257 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
18258 bfd_vma pc
, base_addr
, semaphore
;
18259 char *provider
, *probe
, *arg_fmt
;
18261 if (pnote
->descsz
< (addr_size
* 3))
18262 goto stapdt_note_too_small
;
18264 pc
= byte_get ((unsigned char *) data
, addr_size
);
18267 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
18270 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
18273 if (data
>= data_end
)
18274 goto stapdt_note_too_small
;
18275 maxlen
= data_end
- data
;
18276 len
= strnlen (data
, maxlen
);
18283 goto stapdt_note_too_small
;
18285 if (data
>= data_end
)
18286 goto stapdt_note_too_small
;
18287 maxlen
= data_end
- data
;
18288 len
= strnlen (data
, maxlen
);
18295 goto stapdt_note_too_small
;
18297 if (data
>= data_end
)
18298 goto stapdt_note_too_small
;
18299 maxlen
= data_end
- data
;
18300 len
= strnlen (data
, maxlen
);
18307 goto stapdt_note_too_small
;
18309 printf (_(" Provider: %s\n"), provider
);
18310 printf (_(" Name: %s\n"), probe
);
18311 printf (_(" Location: "));
18312 print_vma (pc
, FULL_HEX
);
18313 printf (_(", Base: "));
18314 print_vma (base_addr
, FULL_HEX
);
18315 printf (_(", Semaphore: "));
18316 print_vma (semaphore
, FULL_HEX
);
18318 printf (_(" Arguments: %s\n"), arg_fmt
);
18320 return data
== data_end
;
18322 stapdt_note_too_small
:
18323 printf (_(" <corrupt - note is too small>\n"));
18324 error (_("corrupt stapdt note - the data size is too small\n"));
18328 static const char *
18329 get_ia64_vms_note_type (unsigned e_type
)
18331 static char buff
[64];
18336 return _("NT_VMS_MHD (module header)");
18338 return _("NT_VMS_LNM (language name)");
18340 return _("NT_VMS_SRC (source files)");
18342 return "NT_VMS_TITLE";
18344 return _("NT_VMS_EIDC (consistency check)");
18345 case NT_VMS_FPMODE
:
18346 return _("NT_VMS_FPMODE (FP mode)");
18347 case NT_VMS_LINKTIME
:
18348 return "NT_VMS_LINKTIME";
18349 case NT_VMS_IMGNAM
:
18350 return _("NT_VMS_IMGNAM (image name)");
18352 return _("NT_VMS_IMGID (image id)");
18353 case NT_VMS_LINKID
:
18354 return _("NT_VMS_LINKID (link id)");
18355 case NT_VMS_IMGBID
:
18356 return _("NT_VMS_IMGBID (build id)");
18357 case NT_VMS_GSTNAM
:
18358 return _("NT_VMS_GSTNAM (sym table name)");
18359 case NT_VMS_ORIG_DYN
:
18360 return "NT_VMS_ORIG_DYN";
18361 case NT_VMS_PATCHTIME
:
18362 return "NT_VMS_PATCHTIME";
18364 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
18370 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
18372 int maxlen
= pnote
->descsz
;
18374 if (maxlen
< 2 || (unsigned long) maxlen
!= pnote
->descsz
)
18375 goto desc_size_fail
;
18377 switch (pnote
->type
)
18381 goto desc_size_fail
;
18383 int l
= (int) strnlen (pnote
->descdata
+ 34, maxlen
- 34);
18385 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
18386 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
18387 if (l
+ 34 < maxlen
)
18389 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
18390 if (l
+ 35 < maxlen
)
18391 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
18393 printf (_(" Module version : <missing>\n"));
18397 printf (_(" Module name : <missing>\n"));
18398 printf (_(" Module version : <missing>\n"));
18403 printf (_(" Language: %.*s\n"), maxlen
, pnote
->descdata
);
18407 case NT_VMS_FPMODE
:
18408 printf (_(" Floating Point mode: "));
18410 goto desc_size_fail
;
18411 /* FIXME: Generate an error if descsz > 8 ? */
18413 printf ("0x%016" BFD_VMA_FMT
"x\n",
18414 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
18417 case NT_VMS_LINKTIME
:
18418 printf (_(" Link time: "));
18420 goto desc_size_fail
;
18421 /* FIXME: Generate an error if descsz > 8 ? */
18424 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
18428 case NT_VMS_PATCHTIME
:
18429 printf (_(" Patch time: "));
18431 goto desc_size_fail
;
18432 /* FIXME: Generate an error if descsz > 8 ? */
18435 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
18439 case NT_VMS_ORIG_DYN
:
18441 goto desc_size_fail
;
18443 printf (_(" Major id: %u, minor id: %u\n"),
18444 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
18445 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
18446 printf (_(" Last modified : "));
18448 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
18449 printf (_("\n Link flags : "));
18450 printf ("0x%016" BFD_VMA_FMT
"x\n",
18451 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
18452 printf (_(" Header flags: 0x%08x\n"),
18453 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
18454 printf (_(" Image id : %.*s\n"), maxlen
- 32, pnote
->descdata
+ 32);
18458 case NT_VMS_IMGNAM
:
18459 printf (_(" Image name: %.*s\n"), maxlen
, pnote
->descdata
);
18462 case NT_VMS_GSTNAM
:
18463 printf (_(" Global symbol table name: %.*s\n"), maxlen
, pnote
->descdata
);
18467 printf (_(" Image id: %.*s\n"), maxlen
, pnote
->descdata
);
18470 case NT_VMS_LINKID
:
18471 printf (_(" Linker id: %.*s\n"), maxlen
, pnote
->descdata
);
18481 printf (_(" <corrupt - data size is too small>\n"));
18482 error (_("corrupt IA64 note: data size is too small\n"));
18486 /* Find the symbol associated with a build attribute that is attached
18487 to address OFFSET. If PNAME is non-NULL then store the name of
18488 the symbol (if found) in the provided pointer, Returns NULL if a
18489 symbol could not be found. */
18491 static Elf_Internal_Sym
*
18492 get_symbol_for_build_attribute (Filedata
* filedata
,
18493 unsigned long offset
,
18494 bfd_boolean is_open_attr
,
18495 const char ** pname
)
18497 static Filedata
* saved_filedata
= NULL
;
18498 static char * strtab
;
18499 static unsigned long strtablen
;
18500 static Elf_Internal_Sym
* symtab
;
18501 static unsigned long nsyms
;
18502 Elf_Internal_Sym
* saved_sym
= NULL
;
18503 Elf_Internal_Sym
* sym
;
18505 if (filedata
->section_headers
!= NULL
18506 && (saved_filedata
== NULL
|| filedata
!= saved_filedata
))
18508 Elf_Internal_Shdr
* symsec
;
18510 /* Load the symbol and string sections. */
18511 for (symsec
= filedata
->section_headers
;
18512 symsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
18515 if (symsec
->sh_type
== SHT_SYMTAB
)
18517 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & nsyms
);
18519 if (symsec
->sh_link
< filedata
->file_header
.e_shnum
)
18521 Elf_Internal_Shdr
* strtab_sec
= filedata
->section_headers
+ symsec
->sh_link
;
18523 strtab
= (char *) get_data (NULL
, filedata
, strtab_sec
->sh_offset
,
18524 1, strtab_sec
->sh_size
,
18525 _("string table"));
18526 strtablen
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
18530 saved_filedata
= filedata
;
18533 if (symtab
== NULL
|| strtab
== NULL
)
18536 /* Find a symbol whose value matches offset. */
18537 for (sym
= symtab
; sym
< symtab
+ nsyms
; sym
++)
18538 if (sym
->st_value
== offset
)
18540 if (sym
->st_name
>= strtablen
)
18541 /* Huh ? This should not happen. */
18544 if (strtab
[sym
->st_name
] == 0)
18547 /* The AArch64 and ARM architectures define mapping symbols
18548 (eg $d, $x, $t) which we want to ignore. */
18549 if (strtab
[sym
->st_name
] == '$'
18550 && strtab
[sym
->st_name
+ 1] != 0
18551 && strtab
[sym
->st_name
+ 2] == 0)
18556 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
18557 and FILE or OBJECT symbols over NOTYPE symbols. We skip
18558 FUNC symbols entirely. */
18559 switch (ELF_ST_TYPE (sym
->st_info
))
18566 /* If the symbol has a size associated
18567 with it then we can stop searching. */
18568 sym
= symtab
+ nsyms
;
18573 /* Ignore function symbols. */
18580 switch (ELF_ST_BIND (sym
->st_info
))
18583 if (saved_sym
== NULL
18584 || ELF_ST_TYPE (saved_sym
->st_info
) != STT_OBJECT
)
18589 if (saved_sym
== NULL
)
18599 if (ELF_ST_TYPE (sym
->st_info
) != STT_FUNC
)
18607 if (saved_sym
&& pname
)
18608 * pname
= strtab
+ saved_sym
->st_name
;
18613 /* Returns true iff addr1 and addr2 are in the same section. */
18616 same_section (Filedata
* filedata
, unsigned long addr1
, unsigned long addr2
)
18618 Elf_Internal_Shdr
* a1
;
18619 Elf_Internal_Shdr
* a2
;
18621 a1
= find_section_by_address (filedata
, addr1
);
18622 a2
= find_section_by_address (filedata
, addr2
);
18624 return a1
== a2
&& a1
!= NULL
;
18628 print_gnu_build_attribute_description (Elf_Internal_Note
* pnote
,
18629 Filedata
* filedata
)
18631 static unsigned long global_offset
= 0;
18632 static unsigned long global_end
= 0;
18633 static unsigned long func_offset
= 0;
18634 static unsigned long func_end
= 0;
18636 Elf_Internal_Sym
* sym
;
18638 unsigned long start
;
18640 bfd_boolean is_open_attr
= pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
;
18642 switch (pnote
->descsz
)
18645 /* A zero-length description means that the range of
18646 the previous note of the same type should be used. */
18649 if (global_end
> global_offset
)
18650 printf (_(" Applies to region from %#lx to %#lx\n"),
18651 global_offset
, global_end
);
18653 printf (_(" Applies to region from %#lx\n"), global_offset
);
18657 if (func_end
> func_offset
)
18658 printf (_(" Applies to region from %#lx to %#lx\n"), func_offset
, func_end
);
18660 printf (_(" Applies to region from %#lx\n"), func_offset
);
18665 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
18672 /* FIXME: We should check that version 3+ notes are being used here... */
18673 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
18674 end
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
18678 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
18684 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
18685 end
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 8);
18689 error (_(" <invalid description size: %lx>\n"), pnote
->descsz
);
18690 printf (_(" <invalid descsz>"));
18695 sym
= get_symbol_for_build_attribute (filedata
, start
, is_open_attr
, & name
);
18696 /* As of version 5 of the annobin plugin, filename symbols are biased by 2
18697 in order to avoid them being confused with the start address of the
18698 first function in the file... */
18699 if (sym
== NULL
&& is_open_attr
)
18700 sym
= get_symbol_for_build_attribute (filedata
, start
+ 2, is_open_attr
,
18703 if (end
== 0 && sym
!= NULL
&& sym
->st_size
> 0)
18704 end
= start
+ sym
->st_size
;
18708 /* FIXME: Need to properly allow for section alignment.
18709 16 is just the alignment used on x86_64. */
18711 && start
> BFD_ALIGN (global_end
, 16)
18712 /* Build notes are not guaranteed to be organised in order of
18713 increasing address, but we should find the all of the notes
18714 for one section in the same place. */
18715 && same_section (filedata
, start
, global_end
))
18716 warn (_("Gap in build notes detected from %#lx to %#lx\n"),
18717 global_end
+ 1, start
- 1);
18719 printf (_(" Applies to region from %#lx"), start
);
18720 global_offset
= start
;
18724 printf (_(" to %#lx"), end
);
18730 printf (_(" Applies to region from %#lx"), start
);
18731 func_offset
= start
;
18735 printf (_(" to %#lx"), end
);
18741 printf (_(" (%s)"), name
);
18748 print_gnu_build_attribute_name (Elf_Internal_Note
* pnote
)
18750 static const char string_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING
, 0 };
18751 static const char number_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
, 0 };
18752 static const char bool_expected
[3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
, 0 };
18754 char name_attribute
;
18755 const char * expected_types
;
18756 const char * name
= pnote
->namedata
;
18760 if (name
== NULL
|| pnote
->namesz
< 2)
18762 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
18763 print_symbol (-20, _(" <corrupt name>"));
18772 /* Version 2 of the spec adds a "GA" prefix to the name field. */
18773 if (name
[0] == 'G' && name
[1] == 'A')
18775 if (pnote
->namesz
< 4)
18777 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
18778 print_symbol (-20, _(" <corrupt name>"));
18787 switch ((name_type
= * name
))
18789 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
18790 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
18791 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
18792 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
18793 printf ("%c", * name
);
18797 error (_("unrecognised attribute type in name field: %d\n"), name_type
);
18798 print_symbol (-20, _("<unknown name type>"));
18805 switch ((name_attribute
= * name
))
18807 case GNU_BUILD_ATTRIBUTE_VERSION
:
18808 text
= _("<version>");
18809 expected_types
= string_expected
;
18812 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
18813 text
= _("<stack prot>");
18814 expected_types
= "!+*";
18817 case GNU_BUILD_ATTRIBUTE_RELRO
:
18818 text
= _("<relro>");
18819 expected_types
= bool_expected
;
18822 case GNU_BUILD_ATTRIBUTE_STACK_SIZE
:
18823 text
= _("<stack size>");
18824 expected_types
= number_expected
;
18827 case GNU_BUILD_ATTRIBUTE_TOOL
:
18828 text
= _("<tool>");
18829 expected_types
= string_expected
;
18832 case GNU_BUILD_ATTRIBUTE_ABI
:
18834 expected_types
= "$*";
18837 case GNU_BUILD_ATTRIBUTE_PIC
:
18839 expected_types
= number_expected
;
18842 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM
:
18843 text
= _("<short enum>");
18844 expected_types
= bool_expected
;
18848 if (ISPRINT (* name
))
18850 int len
= strnlen (name
, pnote
->namesz
- (name
- pnote
->namedata
)) + 1;
18852 if (len
> left
&& ! do_wide
)
18854 printf ("%.*s:", len
, name
);
18860 static char tmpbuf
[128];
18862 error (_("unrecognised byte in name field: %d\n"), * name
);
18863 sprintf (tmpbuf
, _("<unknown:_%d>"), * name
);
18867 expected_types
= "*$!+";
18872 left
-= printf ("%s", text
);
18874 if (strchr (expected_types
, name_type
) == NULL
)
18875 warn (_("attribute does not have an expected type (%c)\n"), name_type
);
18877 if ((unsigned long)(name
- pnote
->namedata
) > pnote
->namesz
)
18879 error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
18880 (unsigned long) pnote
->namesz
,
18881 (long) (name
- pnote
->namedata
));
18885 if (left
< 1 && ! do_wide
)
18890 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
18892 unsigned int bytes
;
18893 unsigned long long val
= 0;
18894 unsigned int shift
= 0;
18895 char * decoded
= NULL
;
18897 bytes
= pnote
->namesz
- (name
- pnote
->namedata
);
18899 /* The -1 is because the name field is always 0 terminated, and we
18900 want to be able to ensure that the shift in the while loop below
18901 will not overflow. */
18904 if (bytes
> sizeof (val
))
18906 error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
18908 bytes
= sizeof (val
);
18910 /* We do not bother to warn if bytes == 0 as this can
18911 happen with some early versions of the gcc plugin. */
18915 unsigned long byte
= (* name
++) & 0xff;
18917 val
|= byte
<< shift
;
18921 switch (name_attribute
)
18923 case GNU_BUILD_ATTRIBUTE_PIC
:
18926 case 0: decoded
= "static"; break;
18927 case 1: decoded
= "pic"; break;
18928 case 2: decoded
= "PIC"; break;
18929 case 3: decoded
= "pie"; break;
18930 case 4: decoded
= "PIE"; break;
18934 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
18937 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
18938 case 0: decoded
= "off"; break;
18939 case 1: decoded
= "on"; break;
18940 case 2: decoded
= "all"; break;
18941 case 3: decoded
= "strong"; break;
18942 case 4: decoded
= "explicit"; break;
18950 if (decoded
!= NULL
)
18952 print_symbol (-left
, decoded
);
18963 left
-= printf ("0x%llx", val
);
18965 left
-= printf ("0x%-.*llx", left
, val
);
18969 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
18970 left
-= print_symbol (- left
, name
);
18972 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
18973 left
-= print_symbol (- left
, "true");
18975 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
18976 left
-= print_symbol (- left
, "false");
18980 if (do_wide
&& left
> 0)
18981 printf ("%-*s", left
, " ");
18986 /* Note that by the ELF standard, the name field is already null byte
18987 terminated, and namesz includes the terminating null byte.
18988 I.E. the value of namesz for the name "FSF" is 4.
18990 If the value of namesz is zero, there is no name present. */
18993 process_note (Elf_Internal_Note
* pnote
,
18994 Filedata
* filedata
)
18996 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
18999 if (pnote
->namesz
== 0)
19000 /* If there is no note name, then use the default set of
19001 note type strings. */
19002 nt
= get_note_type (filedata
, pnote
->type
);
19004 else if (const_strneq (pnote
->namedata
, "GNU"))
19005 /* GNU-specific object file notes. */
19006 nt
= get_gnu_elf_note_type (pnote
->type
);
19008 else if (const_strneq (pnote
->namedata
, "FreeBSD"))
19009 /* FreeBSD-specific core file notes. */
19010 nt
= get_freebsd_elfcore_note_type (filedata
, pnote
->type
);
19012 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
19013 /* NetBSD-specific core file notes. */
19014 nt
= get_netbsd_elfcore_note_type (filedata
, pnote
->type
);
19016 else if (const_strneq (pnote
->namedata
, "NetBSD"))
19017 /* NetBSD-specific core file notes. */
19018 return process_netbsd_elf_note (pnote
);
19020 else if (const_strneq (pnote
->namedata
, "PaX"))
19021 /* NetBSD-specific core file notes. */
19022 return process_netbsd_elf_note (pnote
);
19024 else if (strneq (pnote
->namedata
, "SPU/", 4))
19026 /* SPU-specific core file notes. */
19027 nt
= pnote
->namedata
+ 4;
19031 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
19032 /* VMS/ia64-specific file notes. */
19033 nt
= get_ia64_vms_note_type (pnote
->type
);
19035 else if (const_strneq (pnote
->namedata
, "stapsdt"))
19036 nt
= get_stapsdt_note_type (pnote
->type
);
19039 /* Don't recognize this note name; just use the default set of
19040 note type strings. */
19041 nt
= get_note_type (filedata
, pnote
->type
);
19045 if (((const_strneq (pnote
->namedata
, "GA")
19046 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
19047 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
19048 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
19049 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
19050 print_gnu_build_attribute_name (pnote
);
19052 print_symbol (-20, name
);
19055 printf (" 0x%08lx\t%s\t", pnote
->descsz
, nt
);
19057 printf (" 0x%08lx\t%s\n", pnote
->descsz
, nt
);
19059 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
19060 return print_ia64_vms_note (pnote
);
19061 else if (const_strneq (pnote
->namedata
, "GNU"))
19062 return print_gnu_note (filedata
, pnote
);
19063 else if (const_strneq (pnote
->namedata
, "stapsdt"))
19064 return print_stapsdt_note (pnote
);
19065 else if (const_strneq (pnote
->namedata
, "CORE"))
19066 return print_core_note (pnote
);
19067 else if (((const_strneq (pnote
->namedata
, "GA")
19068 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
19069 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
19070 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
19071 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
19072 return print_gnu_build_attribute_description (pnote
, filedata
);
19078 printf (_(" description data: "));
19079 for (i
= 0; i
< pnote
->descsz
; i
++)
19080 printf ("%02x ", pnote
->descdata
[i
]);
19092 process_notes_at (Filedata
* filedata
,
19093 Elf_Internal_Shdr
* section
,
19098 Elf_External_Note
* pnotes
;
19099 Elf_External_Note
* external
;
19101 bfd_boolean res
= TRUE
;
19108 pnotes
= (Elf_External_Note
*) get_section_contents (section
, filedata
);
19111 if (! apply_relocations (filedata
, section
, (unsigned char *) pnotes
, length
, NULL
, NULL
))
19116 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
19119 if (pnotes
== NULL
)
19125 printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (filedata
, section
));
19127 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
19128 (unsigned long) offset
, (unsigned long) length
);
19130 /* NB: Some note sections may have alignment value of 0 or 1. gABI
19131 specifies that notes should be aligned to 4 bytes in 32-bit
19132 objects and to 8 bytes in 64-bit objects. As a Linux extension,
19133 we also support 4 byte alignment in 64-bit objects. If section
19134 alignment is less than 4, we treate alignment as 4 bytes. */
19137 else if (align
!= 4 && align
!= 8)
19139 warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
19144 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
19146 end
= (char *) pnotes
+ length
;
19147 while ((char *) external
< end
)
19149 Elf_Internal_Note inote
;
19152 char * temp
= NULL
;
19153 size_t data_remaining
= end
- (char *) external
;
19155 if (!is_ia64_vms (filedata
))
19157 /* PR binutils/15191
19158 Make sure that there is enough data to read. */
19159 min_notesz
= offsetof (Elf_External_Note
, name
);
19160 if (data_remaining
< min_notesz
)
19162 warn (ngettext ("Corrupt note: only %ld byte remains, "
19163 "not enough for a full note\n",
19164 "Corrupt note: only %ld bytes remain, "
19165 "not enough for a full note\n",
19167 (long) data_remaining
);
19170 data_remaining
-= min_notesz
;
19172 inote
.type
= BYTE_GET (external
->type
);
19173 inote
.namesz
= BYTE_GET (external
->namesz
);
19174 inote
.namedata
= external
->name
;
19175 inote
.descsz
= BYTE_GET (external
->descsz
);
19176 inote
.descdata
= ((char *) external
19177 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
19178 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
19179 next
= ((char *) external
19180 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
19184 Elf64_External_VMS_Note
*vms_external
;
19186 /* PR binutils/15191
19187 Make sure that there is enough data to read. */
19188 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
19189 if (data_remaining
< min_notesz
)
19191 warn (ngettext ("Corrupt note: only %ld byte remains, "
19192 "not enough for a full note\n",
19193 "Corrupt note: only %ld bytes remain, "
19194 "not enough for a full note\n",
19196 (long) data_remaining
);
19199 data_remaining
-= min_notesz
;
19201 vms_external
= (Elf64_External_VMS_Note
*) external
;
19202 inote
.type
= BYTE_GET (vms_external
->type
);
19203 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
19204 inote
.namedata
= vms_external
->name
;
19205 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
19206 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
19207 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
19208 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
19211 /* PR 17531: file: 3443835e. */
19212 /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
19213 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
19214 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
19215 || (size_t) (next
- inote
.descdata
) < inote
.descsz
19216 || ((size_t) (next
- inote
.descdata
)
19217 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
19219 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
19220 (unsigned long) ((char *) external
- (char *) pnotes
));
19221 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
19222 inote
.type
, inote
.namesz
, inote
.descsz
, (int) align
);
19226 external
= (Elf_External_Note
*) next
;
19228 /* Verify that name is null terminated. It appears that at least
19229 one version of Linux (RedHat 6.0) generates corefiles that don't
19230 comply with the ELF spec by failing to include the null byte in
19232 if (inote
.namesz
> 0 && inote
.namedata
[inote
.namesz
- 1] != '\0')
19234 if ((size_t) (inote
.descdata
- inote
.namedata
) == inote
.namesz
)
19236 temp
= (char *) malloc (inote
.namesz
+ 1);
19239 error (_("Out of memory allocating space for inote name\n"));
19244 memcpy (temp
, inote
.namedata
, inote
.namesz
);
19245 inote
.namedata
= temp
;
19247 inote
.namedata
[inote
.namesz
] = 0;
19250 if (! process_note (& inote
, filedata
))
19266 process_corefile_note_segments (Filedata
* filedata
)
19268 Elf_Internal_Phdr
* segment
;
19270 bfd_boolean res
= TRUE
;
19272 if (! get_program_headers (filedata
))
19275 for (i
= 0, segment
= filedata
->program_headers
;
19276 i
< filedata
->file_header
.e_phnum
;
19279 if (segment
->p_type
== PT_NOTE
)
19280 if (! process_notes_at (filedata
, NULL
,
19281 (bfd_vma
) segment
->p_offset
,
19282 (bfd_vma
) segment
->p_filesz
,
19283 (bfd_vma
) segment
->p_align
))
19291 process_v850_notes (Filedata
* filedata
, bfd_vma offset
, bfd_vma length
)
19293 Elf_External_Note
* pnotes
;
19294 Elf_External_Note
* external
;
19296 bfd_boolean res
= TRUE
;
19301 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
19303 if (pnotes
== NULL
)
19307 end
= (char*) pnotes
+ length
;
19309 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
19310 (unsigned long) offset
, (unsigned long) length
);
19312 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
19314 Elf_External_Note
* next
;
19315 Elf_Internal_Note inote
;
19317 inote
.type
= BYTE_GET (external
->type
);
19318 inote
.namesz
= BYTE_GET (external
->namesz
);
19319 inote
.namedata
= external
->name
;
19320 inote
.descsz
= BYTE_GET (external
->descsz
);
19321 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
19322 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
19324 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
19326 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
19327 inote
.descdata
= inote
.namedata
;
19331 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
19333 if ( ((char *) next
> end
)
19334 || ((char *) next
< (char *) pnotes
))
19336 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
19337 (unsigned long) ((char *) external
- (char *) pnotes
));
19338 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
19339 inote
.type
, inote
.namesz
, inote
.descsz
);
19345 /* Prevent out-of-bounds indexing. */
19346 if ( inote
.namedata
+ inote
.namesz
> end
19347 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
19349 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
19350 (unsigned long) ((char *) external
- (char *) pnotes
));
19351 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
19352 inote
.type
, inote
.namesz
, inote
.descsz
);
19356 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
19358 if (! print_v850_note (& inote
))
19361 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
19362 inote
.namesz
, inote
.descsz
);
19372 process_note_sections (Filedata
* filedata
)
19374 Elf_Internal_Shdr
* section
;
19376 unsigned int n
= 0;
19377 bfd_boolean res
= TRUE
;
19379 for (i
= 0, section
= filedata
->section_headers
;
19380 i
< filedata
->file_header
.e_shnum
&& section
!= NULL
;
19383 if (section
->sh_type
== SHT_NOTE
)
19385 if (! process_notes_at (filedata
, section
,
19386 (bfd_vma
) section
->sh_offset
,
19387 (bfd_vma
) section
->sh_size
,
19388 (bfd_vma
) section
->sh_addralign
))
19393 if (( filedata
->file_header
.e_machine
== EM_V800
19394 || filedata
->file_header
.e_machine
== EM_V850
19395 || filedata
->file_header
.e_machine
== EM_CYGNUS_V850
)
19396 && section
->sh_type
== SHT_RENESAS_INFO
)
19398 if (! process_v850_notes (filedata
,
19399 (bfd_vma
) section
->sh_offset
,
19400 (bfd_vma
) section
->sh_size
))
19407 /* Try processing NOTE segments instead. */
19408 return process_corefile_note_segments (filedata
);
19414 process_notes (Filedata
* filedata
)
19416 /* If we have not been asked to display the notes then do nothing. */
19420 if (filedata
->file_header
.e_type
!= ET_CORE
)
19421 return process_note_sections (filedata
);
19423 /* No program headers means no NOTE segment. */
19424 if (filedata
->file_header
.e_phnum
> 0)
19425 return process_corefile_note_segments (filedata
);
19427 printf (_("No note segments present in the core file.\n"));
19431 static unsigned char *
19432 display_public_gnu_attributes (unsigned char * start
,
19433 const unsigned char * const end
)
19435 printf (_(" Unknown GNU attribute: %s\n"), start
);
19437 start
+= strnlen ((char *) start
, end
- start
);
19438 display_raw_attribute (start
, end
);
19440 return (unsigned char *) end
;
19443 static unsigned char *
19444 display_generic_attribute (unsigned char * start
,
19446 const unsigned char * const end
)
19449 return (unsigned char *) end
;
19451 return display_tag_value (tag
, start
, end
);
19455 process_arch_specific (Filedata
* filedata
)
19460 switch (filedata
->file_header
.e_machine
)
19463 case EM_ARC_COMPACT
:
19464 case EM_ARC_COMPACT2
:
19465 return process_attributes (filedata
, "ARC", SHT_ARC_ATTRIBUTES
,
19466 display_arc_attribute
,
19467 display_generic_attribute
);
19469 return process_attributes (filedata
, "aeabi", SHT_ARM_ATTRIBUTES
,
19470 display_arm_attribute
,
19471 display_generic_attribute
);
19474 case EM_MIPS_RS3_LE
:
19475 return process_mips_specific (filedata
);
19478 return process_attributes (filedata
, "mspabi", SHT_MSP430_ATTRIBUTES
,
19479 display_msp430x_attribute
,
19480 display_generic_attribute
);
19483 return process_attributes (filedata
, "riscv", SHT_RISCV_ATTRIBUTES
,
19484 display_riscv_attribute
,
19485 display_generic_attribute
);
19488 return process_nds32_specific (filedata
);
19492 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
19493 display_power_gnu_attribute
);
19497 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
19498 display_s390_gnu_attribute
);
19501 case EM_SPARC32PLUS
:
19503 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
19504 display_sparc_gnu_attribute
);
19507 return process_attributes (filedata
, "c6xabi", SHT_C6000_ATTRIBUTES
,
19508 display_tic6x_attribute
,
19509 display_generic_attribute
);
19512 return process_attributes (filedata
, "gnu", SHT_GNU_ATTRIBUTES
,
19513 display_public_gnu_attributes
,
19514 display_generic_attribute
);
19519 get_file_header (Filedata
* filedata
)
19521 /* Read in the identity array. */
19522 if (fread (filedata
->file_header
.e_ident
, EI_NIDENT
, 1, filedata
->handle
) != 1)
19525 /* Determine how to read the rest of the header. */
19526 switch (filedata
->file_header
.e_ident
[EI_DATA
])
19531 byte_get
= byte_get_little_endian
;
19532 byte_put
= byte_put_little_endian
;
19535 byte_get
= byte_get_big_endian
;
19536 byte_put
= byte_put_big_endian
;
19540 /* For now we only support 32 bit and 64 bit ELF files. */
19541 is_32bit_elf
= (filedata
->file_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
19543 /* Read in the rest of the header. */
19546 Elf32_External_Ehdr ehdr32
;
19548 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
19551 filedata
->file_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
19552 filedata
->file_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
19553 filedata
->file_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
19554 filedata
->file_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
19555 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
19556 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
19557 filedata
->file_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
19558 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
19559 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
19560 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
19561 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
19562 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
19563 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
19567 Elf64_External_Ehdr ehdr64
;
19569 /* If we have been compiled with sizeof (bfd_vma) == 4, then
19570 we will not be able to cope with the 64bit data found in
19571 64 ELF files. Detect this now and abort before we start
19572 overwriting things. */
19573 if (sizeof (bfd_vma
) < 8)
19575 error (_("This instance of readelf has been built without support for a\n\
19576 64 bit data type and so it cannot read 64 bit ELF files.\n"));
19580 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
19583 filedata
->file_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
19584 filedata
->file_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
19585 filedata
->file_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
19586 filedata
->file_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
19587 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
19588 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
19589 filedata
->file_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
19590 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
19591 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
19592 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
19593 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
19594 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
19595 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
19598 if (filedata
->file_header
.e_shoff
)
19600 /* There may be some extensions in the first section header. Don't
19601 bomb if we can't read it. */
19603 get_32bit_section_headers (filedata
, TRUE
);
19605 get_64bit_section_headers (filedata
, TRUE
);
19612 close_file (Filedata
* filedata
)
19616 if (filedata
->handle
)
19617 fclose (filedata
->handle
);
19623 close_debug_file (void * data
)
19625 close_file ((Filedata
*) data
);
19629 open_file (const char * pathname
)
19631 struct stat statbuf
;
19632 Filedata
* filedata
= NULL
;
19634 if (stat (pathname
, & statbuf
) < 0
19635 || ! S_ISREG (statbuf
.st_mode
))
19638 filedata
= calloc (1, sizeof * filedata
);
19639 if (filedata
== NULL
)
19642 filedata
->handle
= fopen (pathname
, "rb");
19643 if (filedata
->handle
== NULL
)
19646 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
19647 filedata
->file_name
= pathname
;
19649 if (! get_file_header (filedata
))
19652 if (filedata
->file_header
.e_shoff
)
19656 /* Read the section headers again, this time for real. */
19658 res
= get_32bit_section_headers (filedata
, FALSE
);
19660 res
= get_64bit_section_headers (filedata
, FALSE
);
19671 if (filedata
->handle
)
19672 fclose (filedata
->handle
);
19679 open_debug_file (const char * pathname
)
19681 return open_file (pathname
);
19684 /* Process one ELF object file according to the command line options.
19685 This file may actually be stored in an archive. The file is
19686 positioned at the start of the ELF object. Returns TRUE if no
19687 problems were encountered, FALSE otherwise. */
19690 process_object (Filedata
* filedata
)
19692 bfd_boolean have_separate_files
;
19694 bfd_boolean res
= TRUE
;
19696 if (! get_file_header (filedata
))
19698 error (_("%s: Failed to read file header\n"), filedata
->file_name
);
19702 /* Initialise per file variables. */
19703 for (i
= ARRAY_SIZE (version_info
); i
--;)
19704 version_info
[i
] = 0;
19706 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
19707 dynamic_info
[i
] = 0;
19708 dynamic_info_DT_GNU_HASH
= 0;
19710 /* Process the file. */
19712 printf (_("\nFile: %s\n"), filedata
->file_name
);
19714 /* Initialise the dump_sects array from the cmdline_dump_sects array.
19715 Note we do this even if cmdline_dump_sects is empty because we
19716 must make sure that the dump_sets array is zeroed out before each
19717 object file is processed. */
19718 if (filedata
->num_dump_sects
> cmdline
.num_dump_sects
)
19719 memset (filedata
->dump_sects
, 0, filedata
->num_dump_sects
* sizeof (* filedata
->dump_sects
));
19721 if (cmdline
.num_dump_sects
> 0)
19723 if (filedata
->num_dump_sects
== 0)
19724 /* A sneaky way of allocating the dump_sects array. */
19725 request_dump_bynumber (filedata
, cmdline
.num_dump_sects
, 0);
19727 assert (filedata
->num_dump_sects
>= cmdline
.num_dump_sects
);
19728 memcpy (filedata
->dump_sects
, cmdline
.dump_sects
,
19729 cmdline
.num_dump_sects
* sizeof (* filedata
->dump_sects
));
19732 if (! process_file_header (filedata
))
19735 if (! process_section_headers (filedata
))
19737 /* Without loaded section headers we cannot process lots of things. */
19738 do_unwind
= do_version
= do_dump
= do_arch
= FALSE
;
19740 if (! do_using_dynamic
)
19741 do_syms
= do_dyn_syms
= do_reloc
= FALSE
;
19744 if (! process_section_groups (filedata
))
19745 /* Without loaded section groups we cannot process unwind. */
19748 if (process_program_headers (filedata
))
19749 process_dynamic_section (filedata
);
19753 if (! process_relocs (filedata
))
19756 if (! process_unwind (filedata
))
19759 if (! process_symbol_table (filedata
))
19762 if (! process_syminfo (filedata
))
19765 if (! process_version_sections (filedata
))
19768 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
)
19769 have_separate_files
= load_separate_debug_files (filedata
, filedata
->file_name
);
19771 have_separate_files
= FALSE
;
19773 if (! process_section_contents (filedata
))
19776 if (have_separate_files
)
19780 for (d
= first_separate_info
; d
!= NULL
; d
= d
->next
)
19782 if (! process_section_headers (d
->handle
))
19784 else if (! process_section_contents (d
->handle
))
19788 /* The file handles are closed by the call to free_debug_memory() below. */
19791 if (! process_notes (filedata
))
19794 if (! process_gnu_liblist (filedata
))
19797 if (! process_arch_specific (filedata
))
19800 free (filedata
->program_headers
);
19801 filedata
->program_headers
= NULL
;
19803 free (filedata
->section_headers
);
19804 filedata
->section_headers
= NULL
;
19806 free (filedata
->string_table
);
19807 filedata
->string_table
= NULL
;
19808 filedata
->string_table_length
= 0;
19810 if (dynamic_strings
)
19812 free (dynamic_strings
);
19813 dynamic_strings
= NULL
;
19814 dynamic_strings_length
= 0;
19817 if (dynamic_symbols
)
19819 free (dynamic_symbols
);
19820 dynamic_symbols
= NULL
;
19821 num_dynamic_syms
= 0;
19824 if (dynamic_syminfo
)
19826 free (dynamic_syminfo
);
19827 dynamic_syminfo
= NULL
;
19830 if (dynamic_section
)
19832 free (dynamic_section
);
19833 dynamic_section
= NULL
;
19836 if (section_headers_groups
)
19838 free (section_headers_groups
);
19839 section_headers_groups
= NULL
;
19842 if (section_groups
)
19844 struct group_list
* g
;
19845 struct group_list
* next
;
19847 for (i
= 0; i
< group_count
; i
++)
19849 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
19856 free (section_groups
);
19857 section_groups
= NULL
;
19860 free_debug_memory ();
19865 /* Process an ELF archive.
19866 On entry the file is positioned just after the ARMAG string.
19867 Returns TRUE upon success, FALSE otherwise. */
19870 process_archive (Filedata
* filedata
, bfd_boolean is_thin_archive
)
19872 struct archive_info arch
;
19873 struct archive_info nested_arch
;
19875 bfd_boolean ret
= TRUE
;
19879 /* The ARCH structure is used to hold information about this archive. */
19880 arch
.file_name
= NULL
;
19882 arch
.index_array
= NULL
;
19883 arch
.sym_table
= NULL
;
19884 arch
.longnames
= NULL
;
19886 /* The NESTED_ARCH structure is used as a single-item cache of information
19887 about a nested archive (when members of a thin archive reside within
19888 another regular archive file). */
19889 nested_arch
.file_name
= NULL
;
19890 nested_arch
.file
= NULL
;
19891 nested_arch
.index_array
= NULL
;
19892 nested_arch
.sym_table
= NULL
;
19893 nested_arch
.longnames
= NULL
;
19895 if (setup_archive (&arch
, filedata
->file_name
, filedata
->handle
,
19896 is_thin_archive
, do_archive_index
) != 0)
19902 if (do_archive_index
)
19904 if (arch
.sym_table
== NULL
)
19905 error (_("%s: unable to dump the index as none was found\n"), filedata
->file_name
);
19908 unsigned long i
, l
;
19909 unsigned long current_pos
;
19911 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
19912 filedata
->file_name
, (unsigned long) arch
.index_num
, arch
.sym_size
);
19914 current_pos
= ftell (filedata
->handle
);
19916 for (i
= l
= 0; i
< arch
.index_num
; i
++)
19918 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
19920 char * member_name
;
19922 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
19924 if (member_name
!= NULL
)
19926 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
19928 if (qualified_name
!= NULL
)
19930 printf (_("Contents of binary %s at offset "), qualified_name
);
19931 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
19933 free (qualified_name
);
19938 if (l
>= arch
.sym_size
)
19940 error (_("%s: end of the symbol table reached before the end of the index\n"),
19941 filedata
->file_name
);
19945 /* PR 17531: file: 0b6630b2. */
19946 printf ("\t%.*s\n", (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
19947 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
19950 if (arch
.uses_64bit_indices
)
19955 if (l
< arch
.sym_size
)
19957 error (ngettext ("%s: %ld byte remains in the symbol table, "
19958 "but without corresponding entries in "
19959 "the index table\n",
19960 "%s: %ld bytes remain in the symbol table, "
19961 "but without corresponding entries in "
19962 "the index table\n",
19963 arch
.sym_size
- l
),
19964 filedata
->file_name
, arch
.sym_size
- l
);
19968 if (fseek (filedata
->handle
, current_pos
, SEEK_SET
) != 0)
19970 error (_("%s: failed to seek back to start of object files in the archive\n"),
19971 filedata
->file_name
);
19977 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
19978 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
19979 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
19980 && !do_section_groups
&& !do_dyn_syms
)
19982 ret
= TRUE
; /* Archive index only. */
19991 char * qualified_name
;
19993 /* Read the next archive header. */
19994 if (fseek (filedata
->handle
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
19996 error (_("%s: failed to seek to next archive header\n"), arch
.file_name
);
19999 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, filedata
->handle
);
20000 if (got
!= sizeof arch
.arhdr
)
20004 /* PR 24049 - we cannot use filedata->file_name as this will
20005 have already been freed. */
20006 error (_("%s: failed to read archive header\n"), arch
.file_name
);
20011 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
20013 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
20018 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
20020 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
20021 if (archive_file_size
& 01)
20022 ++archive_file_size
;
20024 name
= get_archive_member_name (&arch
, &nested_arch
);
20027 error (_("%s: bad archive file name\n"), arch
.file_name
);
20031 namelen
= strlen (name
);
20033 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
20034 if (qualified_name
== NULL
)
20036 error (_("%s: bad archive file name\n"), arch
.file_name
);
20041 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
20043 /* This is a proxy for an external member of a thin archive. */
20044 Filedata
* member_filedata
;
20045 char * member_file_name
= adjust_relative_path
20046 (filedata
->file_name
, name
, namelen
);
20048 if (member_file_name
== NULL
)
20054 member_filedata
= open_file (member_file_name
);
20055 if (member_filedata
== NULL
)
20057 error (_("Input file '%s' is not readable.\n"), member_file_name
);
20058 free (member_file_name
);
20063 archive_file_offset
= arch
.nested_member_origin
;
20064 member_filedata
->file_name
= qualified_name
;
20066 if (! process_object (member_filedata
))
20069 close_file (member_filedata
);
20070 free (member_file_name
);
20072 else if (is_thin_archive
)
20074 Filedata thin_filedata
;
20076 memset (&thin_filedata
, 0, sizeof (thin_filedata
));
20078 /* PR 15140: Allow for corrupt thin archives. */
20079 if (nested_arch
.file
== NULL
)
20081 error (_("%s: contains corrupt thin archive: %s\n"),
20082 qualified_name
, name
);
20087 /* This is a proxy for a member of a nested archive. */
20088 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
20090 /* The nested archive file will have been opened and setup by
20091 get_archive_member_name. */
20092 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
20094 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
20099 thin_filedata
.handle
= nested_arch
.file
;
20100 thin_filedata
.file_name
= qualified_name
;
20102 if (! process_object (& thin_filedata
))
20107 archive_file_offset
= arch
.next_arhdr_offset
;
20108 arch
.next_arhdr_offset
+= archive_file_size
;
20110 filedata
->file_name
= qualified_name
;
20111 if (! process_object (filedata
))
20115 if (filedata
->dump_sects
!= NULL
)
20117 free (filedata
->dump_sects
);
20118 filedata
->dump_sects
= NULL
;
20119 filedata
->num_dump_sects
= 0;
20122 free (qualified_name
);
20126 if (nested_arch
.file
!= NULL
)
20127 fclose (nested_arch
.file
);
20128 release_archive (&nested_arch
);
20129 release_archive (&arch
);
20135 process_file (char * file_name
)
20137 Filedata
* filedata
= NULL
;
20138 struct stat statbuf
;
20139 char armag
[SARMAG
];
20140 bfd_boolean ret
= TRUE
;
20142 if (stat (file_name
, &statbuf
) < 0)
20144 if (errno
== ENOENT
)
20145 error (_("'%s': No such file\n"), file_name
);
20147 error (_("Could not locate '%s'. System error message: %s\n"),
20148 file_name
, strerror (errno
));
20152 if (! S_ISREG (statbuf
.st_mode
))
20154 error (_("'%s' is not an ordinary file\n"), file_name
);
20158 filedata
= calloc (1, sizeof * filedata
);
20159 if (filedata
== NULL
)
20161 error (_("Out of memory allocating file data structure\n"));
20165 filedata
->file_name
= file_name
;
20166 filedata
->handle
= fopen (file_name
, "rb");
20167 if (filedata
->handle
== NULL
)
20169 error (_("Input file '%s' is not readable.\n"), file_name
);
20174 if (fread (armag
, SARMAG
, 1, filedata
->handle
) != 1)
20176 error (_("%s: Failed to read file's magic number\n"), file_name
);
20177 fclose (filedata
->handle
);
20182 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
20184 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
20186 if (! process_archive (filedata
, FALSE
))
20189 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
20191 if ( ! process_archive (filedata
, TRUE
))
20196 if (do_archive_index
)
20197 error (_("File %s is not an archive so its index cannot be displayed.\n"),
20200 rewind (filedata
->handle
);
20201 archive_file_size
= archive_file_offset
= 0;
20203 if (! process_object (filedata
))
20207 fclose (filedata
->handle
);
20213 #ifdef SUPPORT_DISASSEMBLY
20214 /* Needed by the i386 disassembler. For extra credit, someone could
20215 fix this so that we insert symbolic addresses here, esp for GOT/PLT
20219 print_address (unsigned int addr
, FILE * outfile
)
20221 fprintf (outfile
,"0x%8.8x", addr
);
20224 /* Needed by the i386 disassembler. */
20227 db_task_printsym (unsigned int addr
)
20229 print_address (addr
, stderr
);
20234 main (int argc
, char ** argv
)
20238 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
20239 setlocale (LC_MESSAGES
, "");
20241 #if defined (HAVE_SETLOCALE)
20242 setlocale (LC_CTYPE
, "");
20244 bindtextdomain (PACKAGE
, LOCALEDIR
);
20245 textdomain (PACKAGE
);
20247 expandargv (&argc
, &argv
);
20249 cmdline
.file_name
= "<cmdline>";
20250 parse_args (& cmdline
, argc
, argv
);
20252 if (optind
< (argc
- 1))
20254 else if (optind
>= argc
)
20256 warn (_("Nothing to do.\n"));
20261 while (optind
< argc
)
20262 if (! process_file (argv
[optind
++]))
20265 if (cmdline
.dump_sects
!= NULL
)
20266 free (cmdline
.dump_sects
);
20268 free (dump_ctf_symtab_name
);
20269 free (dump_ctf_strtab_name
);
20270 free (dump_ctf_parent_name
);
20272 return err
? EXIT_FAILURE
: EXIT_SUCCESS
;