1 /* readelf.c -- display contents of an ELF format file
2 Copyright (C) 1998-2018 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. */
64 #include "elf/common.h"
65 #include "elf/external.h"
66 #include "elf/internal.h"
69 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
70 we can obtain the H8 reloc numbers. We need these for the
71 get_reloc_size() function. We include h8.h again after defining
72 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
77 /* Undo the effects of #including reloc-macros.h. */
79 #undef START_RELOC_NUMBERS
83 #undef END_RELOC_NUMBERS
84 #undef _RELOC_MACROS_H
86 /* The following headers use the elf/reloc-macros.h file to
87 automatically generate relocation recognition functions
88 such as elf_mips_reloc_type() */
90 #define RELOC_MACROS_GEN_FUNC
92 #include "elf/aarch64.h"
93 #include "elf/alpha.h"
101 #include "elf/d10v.h"
102 #include "elf/d30v.h"
104 #include "elf/epiphany.h"
105 #include "elf/fr30.h"
107 #include "elf/ft32.h"
109 #include "elf/hppa.h"
110 #include "elf/i386.h"
111 #include "elf/i370.h"
112 #include "elf/ia64.h"
113 #include "elf/ip2k.h"
114 #include "elf/lm32.h"
115 #include "elf/iq2000.h"
116 #include "elf/m32c.h"
117 #include "elf/m32r.h"
118 #include "elf/m68k.h"
119 #include "elf/m68hc11.h"
120 #include "elf/mcore.h"
122 #include "elf/metag.h"
123 #include "elf/microblaze.h"
124 #include "elf/mips.h"
125 #include "elf/mmix.h"
126 #include "elf/mn10200.h"
127 #include "elf/mn10300.h"
128 #include "elf/moxie.h"
130 #include "elf/msp430.h"
131 #include "elf/nds32.h"
132 #include "elf/nios2.h"
133 #include "elf/or1k.h"
136 #include "elf/ppc64.h"
138 #include "elf/riscv.h"
139 #include "elf/rl78.h"
141 #include "elf/s390.h"
142 #include "elf/score.h"
144 #include "elf/sparc.h"
146 #include "elf/tic6x.h"
147 #include "elf/tilegx.h"
148 #include "elf/tilepro.h"
149 #include "elf/v850.h"
151 #include "elf/visium.h"
152 #include "elf/wasm32.h"
153 #include "elf/x86-64.h"
154 #include "elf/xc16x.h"
155 #include "elf/xgate.h"
156 #include "elf/xstormy16.h"
157 #include "elf/xtensa.h"
160 #include "libiberty.h"
161 #include "safe-ctype.h"
162 #include "filenames.h"
165 #define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
168 typedef struct elf_section_list
170 Elf_Internal_Shdr
* hdr
;
171 struct elf_section_list
* next
;
174 /* Flag bits indicating particular types of dump. */
175 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
176 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
177 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
178 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
179 #define RELOC_DUMP (1 << 4) /* The -R command line switch. */
181 typedef unsigned char dump_type
;
183 /* A linked list of the section names for which dumps were requested. */
184 struct dump_list_entry
188 struct dump_list_entry
* next
;
191 typedef struct filedata
193 const char * file_name
;
195 bfd_size_type file_size
;
196 Elf_Internal_Ehdr file_header
;
197 Elf_Internal_Shdr
* section_headers
;
198 Elf_Internal_Phdr
* program_headers
;
200 unsigned long string_table_length
;
201 /* A dynamic array of flags indicating for which sections a dump of
202 some kind has been requested. It is reset on a per-object file
203 basis and then initialised from the cmdline_dump_sects array,
204 the results of interpreting the -w switch, and the
205 dump_sects_byname list. */
206 dump_type
* dump_sects
;
207 unsigned int num_dump_sects
;
210 char * program_name
= "readelf";
212 static unsigned long archive_file_offset
;
213 static unsigned long archive_file_size
;
214 static unsigned long dynamic_addr
;
215 static bfd_size_type dynamic_size
;
216 static size_t dynamic_nent
;
217 static char * dynamic_strings
;
218 static unsigned long dynamic_strings_length
;
219 static unsigned long num_dynamic_syms
;
220 static Elf_Internal_Sym
* dynamic_symbols
;
221 static Elf_Internal_Syminfo
* dynamic_syminfo
;
222 static unsigned long dynamic_syminfo_offset
;
223 static unsigned int dynamic_syminfo_nent
;
224 static char program_interpreter
[PATH_MAX
];
225 static bfd_vma dynamic_info
[DT_ENCODING
];
226 static bfd_vma dynamic_info_DT_GNU_HASH
;
227 static bfd_vma version_info
[16];
228 static Elf_Internal_Dyn
* dynamic_section
;
229 static elf_section_list
* symtab_shndx_list
;
230 static bfd_boolean show_name
= FALSE
;
231 static bfd_boolean do_dynamic
= FALSE
;
232 static bfd_boolean do_syms
= FALSE
;
233 static bfd_boolean do_dyn_syms
= FALSE
;
234 static bfd_boolean do_reloc
= FALSE
;
235 static bfd_boolean do_sections
= FALSE
;
236 static bfd_boolean do_section_groups
= FALSE
;
237 static bfd_boolean do_section_details
= FALSE
;
238 static bfd_boolean do_segments
= FALSE
;
239 static bfd_boolean do_unwind
= FALSE
;
240 static bfd_boolean do_using_dynamic
= FALSE
;
241 static bfd_boolean do_header
= FALSE
;
242 static bfd_boolean do_dump
= FALSE
;
243 static bfd_boolean do_version
= FALSE
;
244 static bfd_boolean do_histogram
= FALSE
;
245 static bfd_boolean do_debugging
= FALSE
;
246 static bfd_boolean do_arch
= FALSE
;
247 static bfd_boolean do_notes
= FALSE
;
248 static bfd_boolean do_archive_index
= FALSE
;
249 static bfd_boolean is_32bit_elf
= FALSE
;
250 static bfd_boolean decompress_dumps
= FALSE
;
254 struct group_list
* next
;
255 unsigned int section_index
;
260 struct group_list
* root
;
261 unsigned int group_index
;
264 static size_t group_count
;
265 static struct group
* section_groups
;
266 static struct group
** section_headers_groups
;
268 /* A dynamic array of flags indicating for which sections a dump
269 has been requested via command line switches. */
270 static Filedata cmdline
;
272 static struct dump_list_entry
* dump_sects_byname
;
274 /* How to print a vma value. */
275 typedef enum print_mode
287 /* Versioned symbol info. */
288 enum versioned_symbol_info
295 static const char * get_symbol_version_string
296 (Filedata
*, bfd_boolean
, const char *, unsigned long, unsigned,
297 Elf_Internal_Sym
*, enum versioned_symbol_info
*, unsigned short *);
301 #define SECTION_NAME(X) \
302 ((X) == NULL ? _("<none>") \
303 : filedata->string_table == NULL ? _("<no-strings>") \
304 : ((X)->sh_name >= filedata->string_table_length ? _("<corrupt>") \
305 : filedata->string_table + (X)->sh_name))
307 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
309 #define GET_ELF_SYMBOLS(file, section, sym_count) \
310 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
311 : get_64bit_elf_symbols (file, section, sym_count))
313 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
314 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
315 already been called and verified that the string exists. */
316 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
318 #define REMOVE_ARCH_BITS(ADDR) \
321 if (filedata->file_header.e_machine == EM_ARM) \
326 /* Print a BFD_VMA to an internal buffer, for use in error messages.
327 BFD_FMA_FMT can't be used in translated strings. */
330 bfd_vmatoa (char *fmtch
, bfd_vma value
)
332 /* bfd_vmatoa is used more then once in a printf call for output.
333 Cycle through an array of buffers. */
334 static int buf_pos
= 0;
335 static struct bfd_vmatoa_buf
342 ret
= buf
[buf_pos
++].place
;
343 buf_pos
%= ARRAY_SIZE (buf
);
345 sprintf (fmt
, "%%%s%s", BFD_VMA_FMT
, fmtch
);
346 snprintf (ret
, sizeof (buf
[0].place
), fmt
, value
);
350 /* Retrieve NMEMB structures, each SIZE bytes long from FILEDATA starting at
351 OFFSET + the offset of the current archive member, if we are examining an
352 archive. Put the retrieved data into VAR, if it is not NULL. Otherwise
353 allocate a buffer using malloc and fill that. In either case return the
354 pointer to the start of the retrieved data or NULL if something went wrong.
355 If something does go wrong and REASON is not NULL then emit an error
356 message using REASON as part of the context. */
359 get_data (void * var
,
361 unsigned long offset
,
367 bfd_size_type amt
= size
* nmemb
;
369 if (size
== 0 || nmemb
== 0)
372 /* If the size_t type is smaller than the bfd_size_type, eg because
373 you are building a 32-bit tool on a 64-bit host, then make sure
374 that when the sizes are cast to (size_t) no information is lost. */
375 if (sizeof (size_t) < sizeof (bfd_size_type
)
376 && ( (bfd_size_type
) ((size_t) size
) != size
377 || (bfd_size_type
) ((size_t) nmemb
) != nmemb
))
380 error (_("Size truncation prevents reading %s"
381 " elements of size %s for %s\n"),
382 bfd_vmatoa ("u", nmemb
), bfd_vmatoa ("u", size
), reason
);
386 /* Check for size overflow. */
390 error (_("Size overflow prevents reading %s"
391 " elements of size %s for %s\n"),
392 bfd_vmatoa ("u", nmemb
), bfd_vmatoa ("u", size
), reason
);
396 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
397 attempting to allocate memory when the read is bound to fail. */
398 if (amt
> filedata
->file_size
399 || offset
+ archive_file_offset
+ amt
> filedata
->file_size
)
402 error (_("Reading %s bytes extends past end of file for %s\n"),
403 bfd_vmatoa ("u", amt
), reason
);
407 if (fseek (filedata
->handle
, archive_file_offset
+ offset
, SEEK_SET
))
410 error (_("Unable to seek to 0x%lx for %s\n"),
411 archive_file_offset
+ offset
, reason
);
418 /* Check for overflow. */
419 if (nmemb
< (~(bfd_size_type
) 0 - 1) / size
)
420 /* + 1 so that we can '\0' terminate invalid string table sections. */
421 mvar
= malloc ((size_t) amt
+ 1);
426 error (_("Out of memory allocating %s bytes for %s\n"),
427 bfd_vmatoa ("u", amt
), reason
);
431 ((char *) mvar
)[amt
] = '\0';
434 if (fread (mvar
, (size_t) size
, (size_t) nmemb
, filedata
->handle
) != nmemb
)
437 error (_("Unable to read in %s bytes of %s\n"),
438 bfd_vmatoa ("u", amt
), reason
);
447 /* Print a VMA value in the MODE specified.
448 Returns the number of characters displayed. */
451 print_vma (bfd_vma vma
, print_mode mode
)
463 return nc
+ printf ("%8.8" BFD_VMA_FMT
"x", vma
);
470 return printf ("%5" BFD_VMA_FMT
"d", vma
);
476 return nc
+ printf ("%" BFD_VMA_FMT
"x", vma
);
479 return printf ("%" BFD_VMA_FMT
"d", vma
);
482 return printf ("%" BFD_VMA_FMT
"u", vma
);
485 /* FIXME: Report unrecognised mode ? */
490 /* Display a symbol on stdout. Handles the display of control characters and
491 multibye characters (assuming the host environment supports them).
493 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
495 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
496 padding as necessary.
498 Returns the number of emitted characters. */
501 print_symbol (signed int width
, const char *symbol
)
503 bfd_boolean extra_padding
= FALSE
;
504 signed int num_printed
= 0;
505 #ifdef HAVE_MBSTATE_T
508 unsigned int width_remaining
;
512 /* Keep the width positive. This helps the code below. */
514 extra_padding
= TRUE
;
519 /* Set the remaining width to a very large value.
520 This simplifies the code below. */
521 width_remaining
= INT_MAX
;
523 width_remaining
= width
;
525 #ifdef HAVE_MBSTATE_T
526 /* Initialise the multibyte conversion state. */
527 memset (& state
, 0, sizeof (state
));
530 while (width_remaining
)
533 const char c
= *symbol
++;
538 /* Do not print control characters directly as they can affect terminal
539 settings. Such characters usually appear in the names generated
540 by the assembler for local labels. */
543 if (width_remaining
< 2)
546 printf ("^%c", c
+ 0x40);
547 width_remaining
-= 2;
550 else if (ISPRINT (c
))
558 #ifdef HAVE_MBSTATE_T
561 /* Let printf do the hard work of displaying multibyte characters. */
562 printf ("%.1s", symbol
- 1);
566 #ifdef HAVE_MBSTATE_T
567 /* Try to find out how many bytes made up the character that was
568 just printed. Advance the symbol pointer past the bytes that
570 n
= mbrtowc (& w
, symbol
- 1, MB_CUR_MAX
, & state
);
574 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
579 if (extra_padding
&& num_printed
< width
)
581 /* Fill in the remaining spaces. */
582 printf ("%-*s", width
- num_printed
, " ");
589 /* Returns a pointer to a static buffer containing a printable version of
590 the given section's name. Like print_symbol, except that it does not try
591 to print multibyte characters, it just interprets them as hex values. */
594 printable_section_name (Filedata
* filedata
, const Elf_Internal_Shdr
* sec
)
596 #define MAX_PRINT_SEC_NAME_LEN 128
597 static char sec_name_buf
[MAX_PRINT_SEC_NAME_LEN
+ 1];
598 const char * name
= SECTION_NAME (sec
);
599 char * buf
= sec_name_buf
;
601 unsigned int remaining
= MAX_PRINT_SEC_NAME_LEN
;
603 while ((c
= * name
++) != 0)
614 else if (ISPRINT (c
))
621 static char hex
[17] = "0123456789ABCDEF";
626 * buf
++ = hex
[(c
& 0xf0) >> 4];
627 * buf
++ = hex
[c
& 0x0f];
641 printable_section_name_from_index (Filedata
* filedata
, unsigned long ndx
)
643 if (ndx
>= filedata
->file_header
.e_shnum
)
644 return _("<corrupt>");
646 return printable_section_name (filedata
, filedata
->section_headers
+ ndx
);
649 /* Return a pointer to section NAME, or NULL if no such section exists. */
651 static Elf_Internal_Shdr
*
652 find_section (Filedata
* filedata
, const char * name
)
656 if (filedata
->section_headers
== NULL
)
659 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
660 if (streq (SECTION_NAME (filedata
->section_headers
+ i
), name
))
661 return filedata
->section_headers
+ i
;
666 /* Return a pointer to a section containing ADDR, or NULL if no such
669 static Elf_Internal_Shdr
*
670 find_section_by_address (Filedata
* filedata
, bfd_vma addr
)
674 if (filedata
->section_headers
== NULL
)
677 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
679 Elf_Internal_Shdr
*sec
= filedata
->section_headers
+ i
;
681 if (addr
>= sec
->sh_addr
&& addr
< sec
->sh_addr
+ sec
->sh_size
)
688 static Elf_Internal_Shdr
*
689 find_section_by_type (Filedata
* filedata
, unsigned int type
)
693 if (filedata
->section_headers
== NULL
)
696 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
698 Elf_Internal_Shdr
*sec
= filedata
->section_headers
+ i
;
700 if (sec
->sh_type
== type
)
707 /* Return a pointer to section NAME, or NULL if no such section exists,
708 restricted to the list of sections given in SET. */
710 static Elf_Internal_Shdr
*
711 find_section_in_set (Filedata
* filedata
, const char * name
, unsigned int * set
)
715 if (filedata
->section_headers
== NULL
)
720 while ((i
= *set
++) > 0)
722 /* See PR 21156 for a reproducer. */
723 if (i
>= filedata
->file_header
.e_shnum
)
724 continue; /* FIXME: Should we issue an error message ? */
726 if (streq (SECTION_NAME (filedata
->section_headers
+ i
), name
))
727 return filedata
->section_headers
+ i
;
731 return find_section (filedata
, name
);
734 /* Read an unsigned LEB128 encoded value from DATA.
735 Set *LENGTH_RETURN to the number of bytes read. */
737 static inline unsigned long
738 read_uleb128 (unsigned char * data
,
739 unsigned int * length_return
,
740 const unsigned char * const end
)
742 return read_leb128 (data
, length_return
, FALSE
, end
);
745 /* Return TRUE if the current file is for IA-64 machine and OpenVMS ABI.
746 This OS has so many departures from the ELF standard that we test it at
749 static inline bfd_boolean
750 is_ia64_vms (Filedata
* filedata
)
752 return filedata
->file_header
.e_machine
== EM_IA_64
753 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
;
756 /* Guess the relocation size commonly used by the specific machines. */
759 guess_is_rela (unsigned int e_machine
)
763 /* Targets that use REL relocations. */
777 /* Targets that use RELA relocations. */
780 case EM_ADAPTEVA_EPIPHANY
:
782 case EM_ALTERA_NIOS2
:
785 case EM_ARC_COMPACT2
:
805 case EM_LATTICEMICO32
:
814 case EM_CYGNUS_MN10200
:
816 case EM_CYGNUS_MN10300
:
852 case EM_MICROBLAZE_OLD
:
874 warn (_("Don't know about relocations on this machine architecture\n"));
879 /* Load RELA type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
880 Returns TRUE upon success, FALSE otherwise. If successful then a
881 pointer to a malloc'ed buffer containing the relocs is placed in *RELASP,
882 and the number of relocs loaded is placed in *NRELASP. It is the caller's
883 responsibility to free the allocated buffer. */
886 slurp_rela_relocs (Filedata
* filedata
,
887 unsigned long rel_offset
,
888 unsigned long rel_size
,
889 Elf_Internal_Rela
** relasp
,
890 unsigned long * nrelasp
)
892 Elf_Internal_Rela
* relas
;
898 Elf32_External_Rela
* erelas
;
900 erelas
= (Elf32_External_Rela
*) get_data (NULL
, filedata
, rel_offset
, 1,
901 rel_size
, _("32-bit relocation data"));
905 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
907 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
908 sizeof (Elf_Internal_Rela
));
913 error (_("out of memory parsing relocs\n"));
917 for (i
= 0; i
< nrelas
; i
++)
919 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
920 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
921 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
928 Elf64_External_Rela
* erelas
;
930 erelas
= (Elf64_External_Rela
*) get_data (NULL
, filedata
, rel_offset
, 1,
931 rel_size
, _("64-bit relocation data"));
935 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
937 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
938 sizeof (Elf_Internal_Rela
));
943 error (_("out of memory parsing relocs\n"));
947 for (i
= 0; i
< nrelas
; i
++)
949 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
950 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
951 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
953 /* The #ifdef BFD64 below is to prevent a compile time
954 warning. We know that if we do not have a 64 bit data
955 type that we will never execute this code anyway. */
957 if (filedata
->file_header
.e_machine
== EM_MIPS
958 && filedata
->file_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
960 /* In little-endian objects, r_info isn't really a
961 64-bit little-endian value: it has a 32-bit
962 little-endian symbol index followed by four
963 individual byte fields. Reorder INFO
965 bfd_vma inf
= relas
[i
].r_info
;
966 inf
= (((inf
& 0xffffffff) << 32)
967 | ((inf
>> 56) & 0xff)
968 | ((inf
>> 40) & 0xff00)
969 | ((inf
>> 24) & 0xff0000)
970 | ((inf
>> 8) & 0xff000000));
971 relas
[i
].r_info
= inf
;
984 /* Load REL type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
985 Returns TRUE upon success, FALSE otherwise. If successful then a
986 pointer to a malloc'ed buffer containing the relocs is placed in *RELSP,
987 and the number of relocs loaded is placed in *NRELSP. It is the caller's
988 responsibility to free the allocated buffer. */
991 slurp_rel_relocs (Filedata
* filedata
,
992 unsigned long rel_offset
,
993 unsigned long rel_size
,
994 Elf_Internal_Rela
** relsp
,
995 unsigned long * nrelsp
)
997 Elf_Internal_Rela
* rels
;
1003 Elf32_External_Rel
* erels
;
1005 erels
= (Elf32_External_Rel
*) get_data (NULL
, filedata
, rel_offset
, 1,
1006 rel_size
, _("32-bit relocation data"));
1010 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
1012 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
1017 error (_("out of memory parsing relocs\n"));
1021 for (i
= 0; i
< nrels
; i
++)
1023 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
1024 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
1025 rels
[i
].r_addend
= 0;
1032 Elf64_External_Rel
* erels
;
1034 erels
= (Elf64_External_Rel
*) get_data (NULL
, filedata
, rel_offset
, 1,
1035 rel_size
, _("64-bit relocation data"));
1039 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
1041 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
1046 error (_("out of memory parsing relocs\n"));
1050 for (i
= 0; i
< nrels
; i
++)
1052 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
1053 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
1054 rels
[i
].r_addend
= 0;
1056 /* The #ifdef BFD64 below is to prevent a compile time
1057 warning. We know that if we do not have a 64 bit data
1058 type that we will never execute this code anyway. */
1060 if (filedata
->file_header
.e_machine
== EM_MIPS
1061 && filedata
->file_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
1063 /* In little-endian objects, r_info isn't really a
1064 64-bit little-endian value: it has a 32-bit
1065 little-endian symbol index followed by four
1066 individual byte fields. Reorder INFO
1068 bfd_vma inf
= rels
[i
].r_info
;
1069 inf
= (((inf
& 0xffffffff) << 32)
1070 | ((inf
>> 56) & 0xff)
1071 | ((inf
>> 40) & 0xff00)
1072 | ((inf
>> 24) & 0xff0000)
1073 | ((inf
>> 8) & 0xff000000));
1074 rels
[i
].r_info
= inf
;
1087 /* Returns the reloc type extracted from the reloc info field. */
1090 get_reloc_type (Filedata
* filedata
, bfd_vma reloc_info
)
1093 return ELF32_R_TYPE (reloc_info
);
1095 switch (filedata
->file_header
.e_machine
)
1098 /* Note: We assume that reloc_info has already been adjusted for us. */
1099 return ELF64_MIPS_R_TYPE (reloc_info
);
1102 return ELF64_R_TYPE_ID (reloc_info
);
1105 return ELF64_R_TYPE (reloc_info
);
1109 /* Return the symbol index extracted from the reloc info field. */
1112 get_reloc_symindex (bfd_vma reloc_info
)
1114 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
1117 static inline bfd_boolean
1118 uses_msp430x_relocs (Filedata
* filedata
)
1121 filedata
->file_header
.e_machine
== EM_MSP430
/* Paranoia. */
1122 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1123 && (((filedata
->file_header
.e_flags
& EF_MSP430_MACH
) == E_MSP430_MACH_MSP430X
)
1124 /* TI compiler uses ELFOSABI_NONE. */
1125 || (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
));
1128 /* Display the contents of the relocation data found at the specified
1132 dump_relocations (Filedata
* filedata
,
1133 unsigned long rel_offset
,
1134 unsigned long rel_size
,
1135 Elf_Internal_Sym
* symtab
,
1136 unsigned long nsyms
,
1138 unsigned long strtablen
,
1140 bfd_boolean is_dynsym
)
1143 Elf_Internal_Rela
* rels
;
1144 bfd_boolean res
= TRUE
;
1146 if (is_rela
== UNKNOWN
)
1147 is_rela
= guess_is_rela (filedata
->file_header
.e_machine
);
1151 if (!slurp_rela_relocs (filedata
, rel_offset
, rel_size
, &rels
, &rel_size
))
1156 if (!slurp_rel_relocs (filedata
, rel_offset
, rel_size
, &rels
, &rel_size
))
1165 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1167 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1172 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1174 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1182 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
1184 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1189 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
1191 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1195 for (i
= 0; i
< rel_size
; i
++)
1200 bfd_vma symtab_index
;
1203 offset
= rels
[i
].r_offset
;
1204 inf
= rels
[i
].r_info
;
1206 type
= get_reloc_type (filedata
, inf
);
1207 symtab_index
= get_reloc_symindex (inf
);
1211 printf ("%8.8lx %8.8lx ",
1212 (unsigned long) offset
& 0xffffffff,
1213 (unsigned long) inf
& 0xffffffff);
1217 #if BFD_HOST_64BIT_LONG
1219 ? "%16.16lx %16.16lx "
1220 : "%12.12lx %12.12lx ",
1222 #elif BFD_HOST_64BIT_LONG_LONG
1225 ? "%16.16llx %16.16llx "
1226 : "%12.12llx %12.12llx ",
1230 ? "%16.16I64x %16.16I64x "
1231 : "%12.12I64x %12.12I64x ",
1236 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1237 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1238 _bfd_int64_high (offset
),
1239 _bfd_int64_low (offset
),
1240 _bfd_int64_high (inf
),
1241 _bfd_int64_low (inf
));
1245 switch (filedata
->file_header
.e_machine
)
1252 rtype
= elf_aarch64_reloc_type (type
);
1256 case EM_CYGNUS_M32R
:
1257 rtype
= elf_m32r_reloc_type (type
);
1262 rtype
= elf_i386_reloc_type (type
);
1267 rtype
= elf_m68hc11_reloc_type (type
);
1271 rtype
= elf_m68k_reloc_type (type
);
1276 rtype
= elf_avr_reloc_type (type
);
1279 case EM_OLD_SPARCV9
:
1280 case EM_SPARC32PLUS
:
1283 rtype
= elf_sparc_reloc_type (type
);
1287 rtype
= elf_spu_reloc_type (type
);
1291 rtype
= v800_reloc_type (type
);
1294 case EM_CYGNUS_V850
:
1295 rtype
= v850_reloc_type (type
);
1299 case EM_CYGNUS_D10V
:
1300 rtype
= elf_d10v_reloc_type (type
);
1304 case EM_CYGNUS_D30V
:
1305 rtype
= elf_d30v_reloc_type (type
);
1309 rtype
= elf_dlx_reloc_type (type
);
1313 rtype
= elf_sh_reloc_type (type
);
1317 case EM_CYGNUS_MN10300
:
1318 rtype
= elf_mn10300_reloc_type (type
);
1322 case EM_CYGNUS_MN10200
:
1323 rtype
= elf_mn10200_reloc_type (type
);
1327 case EM_CYGNUS_FR30
:
1328 rtype
= elf_fr30_reloc_type (type
);
1332 rtype
= elf_frv_reloc_type (type
);
1336 rtype
= elf_ft32_reloc_type (type
);
1340 rtype
= elf_mcore_reloc_type (type
);
1344 rtype
= elf_mmix_reloc_type (type
);
1348 rtype
= elf_moxie_reloc_type (type
);
1352 if (uses_msp430x_relocs (filedata
))
1354 rtype
= elf_msp430x_reloc_type (type
);
1359 rtype
= elf_msp430_reloc_type (type
);
1363 rtype
= elf_nds32_reloc_type (type
);
1367 rtype
= elf_ppc_reloc_type (type
);
1371 rtype
= elf_ppc64_reloc_type (type
);
1375 case EM_MIPS_RS3_LE
:
1376 rtype
= elf_mips_reloc_type (type
);
1380 rtype
= elf_riscv_reloc_type (type
);
1384 rtype
= elf_alpha_reloc_type (type
);
1388 rtype
= elf_arm_reloc_type (type
);
1392 case EM_ARC_COMPACT
:
1393 case EM_ARC_COMPACT2
:
1394 rtype
= elf_arc_reloc_type (type
);
1398 rtype
= elf_hppa_reloc_type (type
);
1404 rtype
= elf_h8_reloc_type (type
);
1408 rtype
= elf_or1k_reloc_type (type
);
1413 rtype
= elf_pj_reloc_type (type
);
1416 rtype
= elf_ia64_reloc_type (type
);
1420 rtype
= elf_cris_reloc_type (type
);
1426 rtype
= elf_x86_64_reloc_type (type
);
1430 rtype
= i370_reloc_type (type
);
1435 rtype
= elf_s390_reloc_type (type
);
1439 rtype
= elf_score_reloc_type (type
);
1443 rtype
= elf_xstormy16_reloc_type (type
);
1447 rtype
= elf_crx_reloc_type (type
);
1451 rtype
= elf_vax_reloc_type (type
);
1455 rtype
= elf_visium_reloc_type (type
);
1458 case EM_ADAPTEVA_EPIPHANY
:
1459 rtype
= elf_epiphany_reloc_type (type
);
1464 rtype
= elf_ip2k_reloc_type (type
);
1468 rtype
= elf_iq2000_reloc_type (type
);
1473 rtype
= elf_xtensa_reloc_type (type
);
1476 case EM_LATTICEMICO32
:
1477 rtype
= elf_lm32_reloc_type (type
);
1482 rtype
= elf_m32c_reloc_type (type
);
1486 rtype
= elf_mt_reloc_type (type
);
1490 rtype
= elf_bfin_reloc_type (type
);
1494 rtype
= elf_mep_reloc_type (type
);
1498 rtype
= elf_cr16_reloc_type (type
);
1502 case EM_MICROBLAZE_OLD
:
1503 rtype
= elf_microblaze_reloc_type (type
);
1507 rtype
= elf_rl78_reloc_type (type
);
1511 rtype
= elf_rx_reloc_type (type
);
1515 rtype
= elf_metag_reloc_type (type
);
1520 rtype
= elf_xc16x_reloc_type (type
);
1524 rtype
= elf_tic6x_reloc_type (type
);
1528 rtype
= elf_tilegx_reloc_type (type
);
1532 rtype
= elf_tilepro_reloc_type (type
);
1535 case EM_WEBASSEMBLY
:
1536 rtype
= elf_wasm32_reloc_type (type
);
1540 rtype
= elf_xgate_reloc_type (type
);
1543 case EM_ALTERA_NIOS2
:
1544 rtype
= elf_nios2_reloc_type (type
);
1548 rtype
= elf_pru_reloc_type (type
);
1553 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1555 printf (do_wide
? "%-22s" : "%-17.17s", rtype
);
1557 if (filedata
->file_header
.e_machine
== EM_ALPHA
1559 && streq (rtype
, "R_ALPHA_LITUSE")
1562 switch (rels
[i
].r_addend
)
1564 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1565 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1566 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1567 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1568 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1569 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1570 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1571 default: rtype
= NULL
;
1575 printf (" (%s)", rtype
);
1579 printf (_("<unknown addend: %lx>"),
1580 (unsigned long) rels
[i
].r_addend
);
1584 else if (symtab_index
)
1586 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1588 error (_(" bad symbol index: %08lx in reloc"), (unsigned long) symtab_index
);
1593 Elf_Internal_Sym
* psym
;
1594 const char * version_string
;
1595 enum versioned_symbol_info sym_info
;
1596 unsigned short vna_other
;
1598 psym
= symtab
+ symtab_index
;
1601 = get_symbol_version_string (filedata
, is_dynsym
,
1610 if (ELF_ST_TYPE (psym
->st_info
) == STT_GNU_IFUNC
)
1614 unsigned int width
= is_32bit_elf
? 8 : 14;
1616 /* Relocations against GNU_IFUNC symbols do not use the value
1617 of the symbol as the address to relocate against. Instead
1618 they invoke the function named by the symbol and use its
1619 result as the address for relocation.
1621 To indicate this to the user, do not display the value of
1622 the symbol in the "Symbols's Value" field. Instead show
1623 its name followed by () as a hint that the symbol is
1627 || psym
->st_name
== 0
1628 || psym
->st_name
>= strtablen
)
1631 name
= strtab
+ psym
->st_name
;
1633 len
= print_symbol (width
, name
);
1635 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1637 printf ("()%-*s", len
<= width
? (width
+ 1) - len
: 1, " ");
1641 print_vma (psym
->st_value
, LONG_HEX
);
1643 printf (is_32bit_elf
? " " : " ");
1646 if (psym
->st_name
== 0)
1648 const char * sec_name
= "<null>";
1651 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1653 if (psym
->st_shndx
< filedata
->file_header
.e_shnum
)
1654 sec_name
= SECTION_NAME (filedata
->section_headers
+ psym
->st_shndx
);
1655 else if (psym
->st_shndx
== SHN_ABS
)
1657 else if (psym
->st_shndx
== SHN_COMMON
)
1658 sec_name
= "COMMON";
1659 else if ((filedata
->file_header
.e_machine
== EM_MIPS
1660 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1661 || (filedata
->file_header
.e_machine
== EM_TI_C6000
1662 && psym
->st_shndx
== SHN_TIC6X_SCOMMON
))
1663 sec_name
= "SCOMMON";
1664 else if (filedata
->file_header
.e_machine
== EM_MIPS
1665 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1666 sec_name
= "SUNDEF";
1667 else if ((filedata
->file_header
.e_machine
== EM_X86_64
1668 || filedata
->file_header
.e_machine
== EM_L1OM
1669 || filedata
->file_header
.e_machine
== EM_K1OM
)
1670 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1671 sec_name
= "LARGE_COMMON";
1672 else if (filedata
->file_header
.e_machine
== EM_IA_64
1673 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1674 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1675 sec_name
= "ANSI_COM";
1676 else if (is_ia64_vms (filedata
)
1677 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
1678 sec_name
= "VMS_SYMVEC";
1681 sprintf (name_buf
, "<section 0x%x>",
1682 (unsigned int) psym
->st_shndx
);
1683 sec_name
= name_buf
;
1686 print_symbol (22, sec_name
);
1688 else if (strtab
== NULL
)
1689 printf (_("<string table index: %3ld>"), psym
->st_name
);
1690 else if (psym
->st_name
>= strtablen
)
1692 error (_("<corrupt string table index: %3ld>"), psym
->st_name
);
1697 print_symbol (22, strtab
+ psym
->st_name
);
1699 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1705 bfd_vma off
= rels
[i
].r_addend
;
1707 if ((bfd_signed_vma
) off
< 0)
1708 printf (" - %" BFD_VMA_FMT
"x", - off
);
1710 printf (" + %" BFD_VMA_FMT
"x", off
);
1716 bfd_vma off
= rels
[i
].r_addend
;
1718 printf ("%*c", is_32bit_elf
? 12 : 20, ' ');
1719 if ((bfd_signed_vma
) off
< 0)
1720 printf ("-%" BFD_VMA_FMT
"x", - off
);
1722 printf ("%" BFD_VMA_FMT
"x", off
);
1725 if (filedata
->file_header
.e_machine
== EM_SPARCV9
1727 && streq (rtype
, "R_SPARC_OLO10"))
1728 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf
));
1733 if (! is_32bit_elf
&& filedata
->file_header
.e_machine
== EM_MIPS
)
1735 bfd_vma type2
= ELF64_MIPS_R_TYPE2 (inf
);
1736 bfd_vma type3
= ELF64_MIPS_R_TYPE3 (inf
);
1737 const char * rtype2
= elf_mips_reloc_type (type2
);
1738 const char * rtype3
= elf_mips_reloc_type (type3
);
1740 printf (" Type2: ");
1743 printf (_("unrecognized: %-7lx"),
1744 (unsigned long) type2
& 0xffffffff);
1746 printf ("%-17.17s", rtype2
);
1748 printf ("\n Type3: ");
1751 printf (_("unrecognized: %-7lx"),
1752 (unsigned long) type3
& 0xffffffff);
1754 printf ("%-17.17s", rtype3
);
1767 get_mips_dynamic_type (unsigned long type
)
1771 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1772 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1773 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1774 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1775 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1776 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1777 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1778 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1779 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1780 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1781 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1782 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1783 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1784 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1785 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1786 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1787 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1788 case DT_MIPS_RLD_MAP_REL
: return "MIPS_RLD_MAP_REL";
1789 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1790 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1791 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1792 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1793 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1794 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1795 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1796 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1797 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1798 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1799 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1800 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1801 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1802 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1803 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1804 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1805 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1806 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1807 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1808 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1809 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1810 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1811 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1812 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1813 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1814 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1815 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
1816 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
1823 get_sparc64_dynamic_type (unsigned long type
)
1827 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1834 get_ppc_dynamic_type (unsigned long type
)
1838 case DT_PPC_GOT
: return "PPC_GOT";
1839 case DT_PPC_OPT
: return "PPC_OPT";
1846 get_ppc64_dynamic_type (unsigned long type
)
1850 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1851 case DT_PPC64_OPD
: return "PPC64_OPD";
1852 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1853 case DT_PPC64_OPT
: return "PPC64_OPT";
1860 get_parisc_dynamic_type (unsigned long type
)
1864 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1865 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1866 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1867 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1868 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1869 case DT_HP_PREINIT
: return "HP_PREINIT";
1870 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1871 case DT_HP_NEEDED
: return "HP_NEEDED";
1872 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1873 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1874 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1875 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1876 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1877 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1878 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1879 case DT_HP_FILTERED
: return "HP_FILTERED";
1880 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1881 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1882 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1883 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1884 case DT_PLT
: return "PLT";
1885 case DT_PLT_SIZE
: return "PLT_SIZE";
1886 case DT_DLT
: return "DLT";
1887 case DT_DLT_SIZE
: return "DLT_SIZE";
1894 get_ia64_dynamic_type (unsigned long type
)
1898 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1899 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
1900 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
1901 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
1902 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
1903 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
1904 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
1905 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
1906 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
1907 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
1908 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
1909 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
1910 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
1911 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
1912 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
1913 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
1914 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
1915 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
1916 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
1917 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
1918 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
1919 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
1920 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
1921 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
1922 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
1923 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
1924 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
1925 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
1926 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
1927 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
1928 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
1935 get_solaris_section_type (unsigned long type
)
1939 case 0x6fffffee: return "SUNW_ancillary";
1940 case 0x6fffffef: return "SUNW_capchain";
1941 case 0x6ffffff0: return "SUNW_capinfo";
1942 case 0x6ffffff1: return "SUNW_symsort";
1943 case 0x6ffffff2: return "SUNW_tlssort";
1944 case 0x6ffffff3: return "SUNW_LDYNSYM";
1945 case 0x6ffffff4: return "SUNW_dof";
1946 case 0x6ffffff5: return "SUNW_cap";
1947 case 0x6ffffff6: return "SUNW_SIGNATURE";
1948 case 0x6ffffff7: return "SUNW_ANNOTATE";
1949 case 0x6ffffff8: return "SUNW_DEBUGSTR";
1950 case 0x6ffffff9: return "SUNW_DEBUG";
1951 case 0x6ffffffa: return "SUNW_move";
1952 case 0x6ffffffb: return "SUNW_COMDAT";
1953 case 0x6ffffffc: return "SUNW_syminfo";
1954 case 0x6ffffffd: return "SUNW_verdef";
1955 case 0x6ffffffe: return "SUNW_verneed";
1956 case 0x6fffffff: return "SUNW_versym";
1957 case 0x70000000: return "SPARC_GOTDATA";
1958 default: return NULL
;
1963 get_alpha_dynamic_type (unsigned long type
)
1967 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
1968 default: return NULL
;
1973 get_score_dynamic_type (unsigned long type
)
1977 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
1978 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
1979 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
1980 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
1981 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
1982 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
1983 default: return NULL
;
1988 get_tic6x_dynamic_type (unsigned long type
)
1992 case DT_C6000_GSYM_OFFSET
: return "C6000_GSYM_OFFSET";
1993 case DT_C6000_GSTR_OFFSET
: return "C6000_GSTR_OFFSET";
1994 case DT_C6000_DSBT_BASE
: return "C6000_DSBT_BASE";
1995 case DT_C6000_DSBT_SIZE
: return "C6000_DSBT_SIZE";
1996 case DT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
1997 case DT_C6000_DSBT_INDEX
: return "C6000_DSBT_INDEX";
1998 default: return NULL
;
2003 get_nios2_dynamic_type (unsigned long type
)
2007 case DT_NIOS2_GP
: return "NIOS2_GP";
2008 default: return NULL
;
2013 get_solaris_dynamic_type (unsigned long type
)
2017 case 0x6000000d: return "SUNW_AUXILIARY";
2018 case 0x6000000e: return "SUNW_RTLDINF";
2019 case 0x6000000f: return "SUNW_FILTER";
2020 case 0x60000010: return "SUNW_CAP";
2021 case 0x60000011: return "SUNW_SYMTAB";
2022 case 0x60000012: return "SUNW_SYMSZ";
2023 case 0x60000013: return "SUNW_SORTENT";
2024 case 0x60000014: return "SUNW_SYMSORT";
2025 case 0x60000015: return "SUNW_SYMSORTSZ";
2026 case 0x60000016: return "SUNW_TLSSORT";
2027 case 0x60000017: return "SUNW_TLSSORTSZ";
2028 case 0x60000018: return "SUNW_CAPINFO";
2029 case 0x60000019: return "SUNW_STRPAD";
2030 case 0x6000001a: return "SUNW_CAPCHAIN";
2031 case 0x6000001b: return "SUNW_LDMACH";
2032 case 0x6000001d: return "SUNW_CAPCHAINENT";
2033 case 0x6000001f: return "SUNW_CAPCHAINSZ";
2034 case 0x60000021: return "SUNW_PARENT";
2035 case 0x60000023: return "SUNW_ASLR";
2036 case 0x60000025: return "SUNW_RELAX";
2037 case 0x60000029: return "SUNW_NXHEAP";
2038 case 0x6000002b: return "SUNW_NXSTACK";
2040 case 0x70000001: return "SPARC_REGISTER";
2041 case 0x7ffffffd: return "AUXILIARY";
2042 case 0x7ffffffe: return "USED";
2043 case 0x7fffffff: return "FILTER";
2045 default: return NULL
;
2050 get_dynamic_type (Filedata
* filedata
, unsigned long type
)
2052 static char buff
[64];
2056 case DT_NULL
: return "NULL";
2057 case DT_NEEDED
: return "NEEDED";
2058 case DT_PLTRELSZ
: return "PLTRELSZ";
2059 case DT_PLTGOT
: return "PLTGOT";
2060 case DT_HASH
: return "HASH";
2061 case DT_STRTAB
: return "STRTAB";
2062 case DT_SYMTAB
: return "SYMTAB";
2063 case DT_RELA
: return "RELA";
2064 case DT_RELASZ
: return "RELASZ";
2065 case DT_RELAENT
: return "RELAENT";
2066 case DT_STRSZ
: return "STRSZ";
2067 case DT_SYMENT
: return "SYMENT";
2068 case DT_INIT
: return "INIT";
2069 case DT_FINI
: return "FINI";
2070 case DT_SONAME
: return "SONAME";
2071 case DT_RPATH
: return "RPATH";
2072 case DT_SYMBOLIC
: return "SYMBOLIC";
2073 case DT_REL
: return "REL";
2074 case DT_RELSZ
: return "RELSZ";
2075 case DT_RELENT
: return "RELENT";
2076 case DT_PLTREL
: return "PLTREL";
2077 case DT_DEBUG
: return "DEBUG";
2078 case DT_TEXTREL
: return "TEXTREL";
2079 case DT_JMPREL
: return "JMPREL";
2080 case DT_BIND_NOW
: return "BIND_NOW";
2081 case DT_INIT_ARRAY
: return "INIT_ARRAY";
2082 case DT_FINI_ARRAY
: return "FINI_ARRAY";
2083 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
2084 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
2085 case DT_RUNPATH
: return "RUNPATH";
2086 case DT_FLAGS
: return "FLAGS";
2088 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2089 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
2090 case DT_SYMTAB_SHNDX
: return "SYMTAB_SHNDX";
2092 case DT_CHECKSUM
: return "CHECKSUM";
2093 case DT_PLTPADSZ
: return "PLTPADSZ";
2094 case DT_MOVEENT
: return "MOVEENT";
2095 case DT_MOVESZ
: return "MOVESZ";
2096 case DT_FEATURE
: return "FEATURE";
2097 case DT_POSFLAG_1
: return "POSFLAG_1";
2098 case DT_SYMINSZ
: return "SYMINSZ";
2099 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
2101 case DT_ADDRRNGLO
: return "ADDRRNGLO";
2102 case DT_CONFIG
: return "CONFIG";
2103 case DT_DEPAUDIT
: return "DEPAUDIT";
2104 case DT_AUDIT
: return "AUDIT";
2105 case DT_PLTPAD
: return "PLTPAD";
2106 case DT_MOVETAB
: return "MOVETAB";
2107 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
2109 case DT_VERSYM
: return "VERSYM";
2111 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
2112 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
2113 case DT_RELACOUNT
: return "RELACOUNT";
2114 case DT_RELCOUNT
: return "RELCOUNT";
2115 case DT_FLAGS_1
: return "FLAGS_1";
2116 case DT_VERDEF
: return "VERDEF";
2117 case DT_VERDEFNUM
: return "VERDEFNUM";
2118 case DT_VERNEED
: return "VERNEED";
2119 case DT_VERNEEDNUM
: return "VERNEEDNUM";
2121 case DT_AUXILIARY
: return "AUXILIARY";
2122 case DT_USED
: return "USED";
2123 case DT_FILTER
: return "FILTER";
2125 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
2126 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
2127 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
2128 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
2129 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
2130 case DT_GNU_HASH
: return "GNU_HASH";
2133 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
2135 const char * result
;
2137 switch (filedata
->file_header
.e_machine
)
2140 case EM_MIPS_RS3_LE
:
2141 result
= get_mips_dynamic_type (type
);
2144 result
= get_sparc64_dynamic_type (type
);
2147 result
= get_ppc_dynamic_type (type
);
2150 result
= get_ppc64_dynamic_type (type
);
2153 result
= get_ia64_dynamic_type (type
);
2156 result
= get_alpha_dynamic_type (type
);
2159 result
= get_score_dynamic_type (type
);
2162 result
= get_tic6x_dynamic_type (type
);
2164 case EM_ALTERA_NIOS2
:
2165 result
= get_nios2_dynamic_type (type
);
2168 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2169 result
= get_solaris_dynamic_type (type
);
2178 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
2180 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
2181 || (filedata
->file_header
.e_machine
== EM_PARISC
2182 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
2184 const char * result
;
2186 switch (filedata
->file_header
.e_machine
)
2189 result
= get_parisc_dynamic_type (type
);
2192 result
= get_ia64_dynamic_type (type
);
2195 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2196 result
= get_solaris_dynamic_type (type
);
2205 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
2209 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
2216 get_file_type (unsigned e_type
)
2218 static char buff
[32];
2222 case ET_NONE
: return _("NONE (None)");
2223 case ET_REL
: return _("REL (Relocatable file)");
2224 case ET_EXEC
: return _("EXEC (Executable file)");
2225 case ET_DYN
: return _("DYN (Shared object file)");
2226 case ET_CORE
: return _("CORE (Core file)");
2229 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
2230 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
2231 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
2232 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
2234 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
2240 get_machine_name (unsigned e_machine
)
2242 static char buff
[64]; /* XXX */
2246 /* Please keep this switch table sorted by increasing EM_ value. */
2248 case EM_NONE
: return _("None");
2249 case EM_M32
: return "WE32100";
2250 case EM_SPARC
: return "Sparc";
2251 case EM_386
: return "Intel 80386";
2252 case EM_68K
: return "MC68000";
2253 case EM_88K
: return "MC88000";
2254 case EM_IAMCU
: return "Intel MCU";
2255 case EM_MIPS
: return "MIPS R3000";
2256 case EM_S370
: return "IBM System/370";
2258 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
2259 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
2260 case EM_PARISC
: return "HPPA";
2261 case EM_VPP550
: return "Fujitsu VPP500";
2262 case EM_SPARC32PLUS
: return "Sparc v8+" ;
2263 case EM_PPC
: return "PowerPC";
2265 case EM_PPC64
: return "PowerPC64";
2267 case EM_S390
: return "IBM S/390";
2268 case EM_SPU
: return "SPU";
2270 case EM_V800
: return "Renesas V850 (using RH850 ABI)";
2271 case EM_FR20
: return "Fujitsu FR20";
2272 case EM_RH32
: return "TRW RH32";
2273 case EM_MCORE
: return "MCORE";
2275 case EM_ARM
: return "ARM";
2276 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
2277 case EM_SH
: return "Renesas / SuperH SH";
2278 case EM_SPARCV9
: return "Sparc v9";
2279 case EM_TRICORE
: return "Siemens Tricore";
2280 case EM_ARC
: return "ARC";
2281 case EM_H8_300
: return "Renesas H8/300";
2282 case EM_H8_300H
: return "Renesas H8/300H";
2283 case EM_H8S
: return "Renesas H8S";
2284 case EM_H8_500
: return "Renesas H8/500";
2286 case EM_IA_64
: return "Intel IA-64";
2287 case EM_MIPS_X
: return "Stanford MIPS-X";
2288 case EM_COLDFIRE
: return "Motorola Coldfire";
2289 case EM_68HC12
: return "Motorola MC68HC12 Microcontroller";
2290 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
2291 case EM_PCP
: return "Siemens PCP";
2292 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
2293 case EM_NDR1
: return "Denso NDR1 microprocesspr";
2294 case EM_STARCORE
: return "Motorola Star*Core processor";
2295 case EM_ME16
: return "Toyota ME16 processor";
2297 case EM_ST100
: return "STMicroelectronics ST100 processor";
2298 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
2299 case EM_X86_64
: return "Advanced Micro Devices X86-64";
2300 case EM_PDSP
: return "Sony DSP processor";
2301 case EM_PDP10
: return "Digital Equipment Corp. PDP-10";
2302 case EM_PDP11
: return "Digital Equipment Corp. PDP-11";
2303 case EM_FX66
: return "Siemens FX66 microcontroller";
2304 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2305 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
2306 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
2308 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
2309 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
2310 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
2311 case EM_SVX
: return "Silicon Graphics SVx";
2312 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
2313 case EM_VAX
: return "Digital VAX";
2314 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
2315 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
2316 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
2317 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
2319 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
2320 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
2321 case EM_PRISM
: return "Vitesse Prism";
2323 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
2324 case EM_CYGNUS_FR30
:
2325 case EM_FR30
: return "Fujitsu FR30";
2326 case EM_CYGNUS_D10V
:
2327 case EM_D10V
: return "d10v";
2328 case EM_CYGNUS_D30V
:
2329 case EM_D30V
: return "d30v";
2330 case EM_CYGNUS_V850
:
2331 case EM_V850
: return "Renesas V850";
2332 case EM_CYGNUS_M32R
:
2333 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
2334 case EM_CYGNUS_MN10300
:
2335 case EM_MN10300
: return "mn10300";
2337 case EM_CYGNUS_MN10200
:
2338 case EM_MN10200
: return "mn10200";
2339 case EM_PJ
: return "picoJava";
2340 case EM_OR1K
: return "OpenRISC 1000";
2341 case EM_ARC_COMPACT
: return "ARCompact";
2343 case EM_XTENSA
: return "Tensilica Xtensa Processor";
2344 case EM_VIDEOCORE
: return "Alphamosaic VideoCore processor";
2345 case EM_TMM_GPP
: return "Thompson Multimedia General Purpose Processor";
2346 case EM_NS32K
: return "National Semiconductor 32000 series";
2347 case EM_TPC
: return "Tenor Network TPC processor";
2348 case EM_SNP1K
: return "Trebia SNP 1000 processor";
2350 case EM_ST200
: return "STMicroelectronics ST200 microcontroller";
2352 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
2353 case EM_MAX
: return "MAX Processor";
2354 case EM_CR
: return "National Semiconductor CompactRISC";
2355 case EM_F2MC16
: return "Fujitsu F2MC16";
2356 case EM_MSP430
: return "Texas Instruments msp430 microcontroller";
2357 case EM_BLACKFIN
: return "Analog Devices Blackfin";
2358 case EM_SE_C33
: return "S1C33 Family of Seiko Epson processors";
2359 case EM_SEP
: return "Sharp embedded microprocessor";
2360 case EM_ARCA
: return "Arca RISC microprocessor";
2362 case EM_UNICORE
: return "Unicore";
2363 case EM_EXCESS
: return "eXcess 16/32/64-bit configurable embedded CPU";
2364 case EM_DXP
: return "Icera Semiconductor Inc. Deep Execution Processor";
2365 case EM_ALTERA_NIOS2
: return "Altera Nios II";
2366 case EM_CRX
: return "National Semiconductor CRX microprocessor";
2367 case EM_XGATE
: return "Motorola XGATE embedded processor";
2369 case EM_XC16X
: return "Infineon Technologies xc16x";
2370 case EM_M16C
: return "Renesas M16C series microprocessors";
2371 case EM_DSPIC30F
: return "Microchip Technology dsPIC30F Digital Signal Controller";
2372 case EM_CE
: return "Freescale Communication Engine RISC core";
2374 case EM_M32C
: return "Renesas M32c";
2376 case EM_TSK3000
: return "Altium TSK3000 core";
2377 case EM_RS08
: return "Freescale RS08 embedded processor";
2378 case EM_ECOG2
: return "Cyan Technology eCOG2 microprocessor";
2379 case EM_SCORE
: return "SUNPLUS S+Core";
2380 case EM_DSP24
: return "New Japan Radio (NJR) 24-bit DSP Processor";
2381 case EM_VIDEOCORE3
: return "Broadcom VideoCore III processor";
2382 case EM_LATTICEMICO32
: return "Lattice Mico32";
2383 case EM_SE_C17
: return "Seiko Epson C17 family";
2385 case EM_TI_C6000
: return "Texas Instruments TMS320C6000 DSP family";
2386 case EM_TI_C2000
: return "Texas Instruments TMS320C2000 DSP family";
2387 case EM_TI_C5500
: return "Texas Instruments TMS320C55x DSP family";
2388 case EM_TI_PRU
: return "TI PRU I/O processor";
2390 case EM_MMDSP_PLUS
: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2391 case EM_CYPRESS_M8C
: return "Cypress M8C microprocessor";
2392 case EM_R32C
: return "Renesas R32C series microprocessors";
2393 case EM_TRIMEDIA
: return "NXP Semiconductors TriMedia architecture family";
2394 case EM_QDSP6
: return "QUALCOMM DSP6 Processor";
2395 case EM_8051
: return "Intel 8051 and variants";
2396 case EM_STXP7X
: return "STMicroelectronics STxP7x family";
2397 case EM_NDS32
: return "Andes Technology compact code size embedded RISC processor family";
2398 case EM_ECOG1X
: return "Cyan Technology eCOG1X family";
2399 case EM_MAXQ30
: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2401 case EM_XIMO16
: return "New Japan Radio (NJR) 16-bit DSP Processor";
2402 case EM_MANIK
: return "M2000 Reconfigurable RISC Microprocessor";
2403 case EM_CRAYNV2
: return "Cray Inc. NV2 vector architecture";
2404 case EM_RX
: return "Renesas RX";
2405 case EM_METAG
: return "Imagination Technologies Meta processor architecture";
2406 case EM_MCST_ELBRUS
: return "MCST Elbrus general purpose hardware architecture";
2407 case EM_ECOG16
: return "Cyan Technology eCOG16 family";
2410 case EM_MICROBLAZE_OLD
: return "Xilinx MicroBlaze";
2411 case EM_ETPU
: return "Freescale Extended Time Processing Unit";
2412 case EM_SLE9X
: return "Infineon Technologies SLE9X core";
2414 case EM_L1OM
: return "Intel L1OM";
2415 case EM_K1OM
: return "Intel K1OM";
2416 case EM_INTEL182
: return "Intel (reserved)";
2417 case EM_AARCH64
: return "AArch64";
2418 case EM_ARM184
: return "ARM (reserved)";
2419 case EM_AVR32
: return "Atmel Corporation 32-bit microprocessor";
2420 case EM_STM8
: return "STMicroeletronics STM8 8-bit microcontroller";
2421 case EM_TILE64
: return "Tilera TILE64 multicore architecture family";
2422 case EM_TILEPRO
: return "Tilera TILEPro multicore architecture family";
2424 case EM_CUDA
: return "NVIDIA CUDA architecture";
2425 case EM_TILEGX
: return "Tilera TILE-Gx multicore architecture family";
2426 case EM_CLOUDSHIELD
: return "CloudShield architecture family";
2427 case EM_COREA_1ST
: return "KIPO-KAIST Core-A 1st generation processor family";
2428 case EM_COREA_2ND
: return "KIPO-KAIST Core-A 2nd generation processor family";
2429 case EM_ARC_COMPACT2
: return "ARCv2";
2430 case EM_OPEN8
: return "Open8 8-bit RISC soft processor core";
2431 case EM_RL78
: return "Renesas RL78";
2432 case EM_VIDEOCORE5
: return "Broadcom VideoCore V processor";
2433 case EM_78K0R
: return "Renesas 78K0R";
2435 case EM_56800EX
: return "Freescale 56800EX Digital Signal Controller (DSC)";
2436 case EM_BA1
: return "Beyond BA1 CPU architecture";
2437 case EM_BA2
: return "Beyond BA2 CPU architecture";
2438 case EM_XCORE
: return "XMOS xCORE processor family";
2439 case EM_MCHP_PIC
: return "Microchip 8-bit PIC(r) family";
2441 case EM_KM32
: return "KM211 KM32 32-bit processor";
2442 case EM_KMX32
: return "KM211 KMX32 32-bit processor";
2443 case EM_KMX16
: return "KM211 KMX16 16-bit processor";
2444 case EM_KMX8
: return "KM211 KMX8 8-bit processor";
2445 case EM_KVARC
: return "KM211 KVARC processor";
2446 case EM_CDP
: return "Paneve CDP architecture family";
2447 case EM_COGE
: return "Cognitive Smart Memory Processor";
2448 case EM_COOL
: return "Bluechip Systems CoolEngine";
2449 case EM_NORC
: return "Nanoradio Optimized RISC";
2450 case EM_CSR_KALIMBA
: return "CSR Kalimba architecture family";
2452 case EM_Z80
: return "Zilog Z80";
2453 case EM_VISIUM
: return "CDS VISIUMcore processor";
2454 case EM_FT32
: return "FTDI Chip FT32";
2455 case EM_MOXIE
: return "Moxie";
2456 case EM_AMDGPU
: return "AMD GPU";
2457 case EM_RISCV
: return "RISC-V";
2458 case EM_LANAI
: return "Lanai 32-bit processor";
2459 case EM_BPF
: return "Linux BPF";
2461 /* Large numbers... */
2462 case EM_MT
: return "Morpho Techologies MT processor";
2463 case EM_ALPHA
: return "Alpha";
2464 case EM_WEBASSEMBLY
: return "Web Assembly";
2465 case EM_DLX
: return "OpenDLX";
2466 case EM_XSTORMY16
: return "Sanyo XStormy16 CPU core";
2467 case EM_IQ2000
: return "Vitesse IQ2000";
2469 case EM_NIOS32
: return "Altera Nios";
2470 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
2471 case EM_ADAPTEVA_EPIPHANY
: return "Adapteva EPIPHANY";
2472 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
2475 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
2481 decode_ARC_machine_flags (unsigned e_flags
, unsigned e_machine
, char buf
[])
2483 /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2. Some
2484 other compilers don't a specific architecture type in the e_flags, and
2485 instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
2486 architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
2489 Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
2490 but also sets a specific architecture type in the e_flags field.
2492 However, when decoding the flags we don't worry if we see an
2493 unexpected pairing, for example EM_ARC_COMPACT machine type, with
2494 ARCEM architecture type. */
2496 switch (e_flags
& EF_ARC_MACH_MSK
)
2498 /* We only expect these to occur for EM_ARC_COMPACT2. */
2499 case EF_ARC_CPU_ARCV2EM
:
2500 strcat (buf
, ", ARC EM");
2502 case EF_ARC_CPU_ARCV2HS
:
2503 strcat (buf
, ", ARC HS");
2506 /* We only expect these to occur for EM_ARC_COMPACT. */
2507 case E_ARC_MACH_ARC600
:
2508 strcat (buf
, ", ARC600");
2510 case E_ARC_MACH_ARC601
:
2511 strcat (buf
, ", ARC601");
2513 case E_ARC_MACH_ARC700
:
2514 strcat (buf
, ", ARC700");
2517 /* The only times we should end up here are (a) A corrupt ELF, (b) A
2518 new ELF with new architecture being read by an old version of
2519 readelf, or (c) An ELF built with non-GNU compiler that does not
2520 set the architecture in the e_flags. */
2522 if (e_machine
== EM_ARC_COMPACT
)
2523 strcat (buf
, ", Unknown ARCompact");
2525 strcat (buf
, ", Unknown ARC");
2529 switch (e_flags
& EF_ARC_OSABI_MSK
)
2531 case E_ARC_OSABI_ORIG
:
2532 strcat (buf
, ", (ABI:legacy)");
2534 case E_ARC_OSABI_V2
:
2535 strcat (buf
, ", (ABI:v2)");
2537 /* Only upstream 3.9+ kernels will support ARCv2 ISA. */
2538 case E_ARC_OSABI_V3
:
2539 strcat (buf
, ", v3 no-legacy-syscalls ABI");
2541 case E_ARC_OSABI_V4
:
2542 strcat (buf
, ", v4 ABI");
2545 strcat (buf
, ", unrecognised ARC OSABI flag");
2551 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
2554 bfd_boolean unknown
= FALSE
;
2556 eabi
= EF_ARM_EABI_VERSION (e_flags
);
2557 e_flags
&= ~ EF_ARM_EABIMASK
;
2559 /* Handle "generic" ARM flags. */
2560 if (e_flags
& EF_ARM_RELEXEC
)
2562 strcat (buf
, ", relocatable executable");
2563 e_flags
&= ~ EF_ARM_RELEXEC
;
2566 /* Now handle EABI specific flags. */
2570 strcat (buf
, ", <unrecognized EABI>");
2575 case EF_ARM_EABI_VER1
:
2576 strcat (buf
, ", Version1 EABI");
2581 /* Process flags one bit at a time. */
2582 flag
= e_flags
& - e_flags
;
2587 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2588 strcat (buf
, ", sorted symbol tables");
2598 case EF_ARM_EABI_VER2
:
2599 strcat (buf
, ", Version2 EABI");
2604 /* Process flags one bit at a time. */
2605 flag
= e_flags
& - e_flags
;
2610 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2611 strcat (buf
, ", sorted symbol tables");
2614 case EF_ARM_DYNSYMSUSESEGIDX
:
2615 strcat (buf
, ", dynamic symbols use segment index");
2618 case EF_ARM_MAPSYMSFIRST
:
2619 strcat (buf
, ", mapping symbols precede others");
2629 case EF_ARM_EABI_VER3
:
2630 strcat (buf
, ", Version3 EABI");
2633 case EF_ARM_EABI_VER4
:
2634 strcat (buf
, ", Version4 EABI");
2639 /* Process flags one bit at a time. */
2640 flag
= e_flags
& - e_flags
;
2646 strcat (buf
, ", BE8");
2650 strcat (buf
, ", LE8");
2660 case EF_ARM_EABI_VER5
:
2661 strcat (buf
, ", Version5 EABI");
2666 /* Process flags one bit at a time. */
2667 flag
= e_flags
& - e_flags
;
2673 strcat (buf
, ", BE8");
2677 strcat (buf
, ", LE8");
2680 case EF_ARM_ABI_FLOAT_SOFT
: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2681 strcat (buf
, ", soft-float ABI");
2684 case EF_ARM_ABI_FLOAT_HARD
: /* Conflicts with EF_ARM_VFP_FLOAT. */
2685 strcat (buf
, ", hard-float ABI");
2695 case EF_ARM_EABI_UNKNOWN
:
2696 strcat (buf
, ", GNU EABI");
2701 /* Process flags one bit at a time. */
2702 flag
= e_flags
& - e_flags
;
2707 case EF_ARM_INTERWORK
:
2708 strcat (buf
, ", interworking enabled");
2711 case EF_ARM_APCS_26
:
2712 strcat (buf
, ", uses APCS/26");
2715 case EF_ARM_APCS_FLOAT
:
2716 strcat (buf
, ", uses APCS/float");
2720 strcat (buf
, ", position independent");
2724 strcat (buf
, ", 8 bit structure alignment");
2727 case EF_ARM_NEW_ABI
:
2728 strcat (buf
, ", uses new ABI");
2731 case EF_ARM_OLD_ABI
:
2732 strcat (buf
, ", uses old ABI");
2735 case EF_ARM_SOFT_FLOAT
:
2736 strcat (buf
, ", software FP");
2739 case EF_ARM_VFP_FLOAT
:
2740 strcat (buf
, ", VFP");
2743 case EF_ARM_MAVERICK_FLOAT
:
2744 strcat (buf
, ", Maverick FP");
2755 strcat (buf
,_(", <unknown>"));
2759 decode_AVR_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2761 --size
; /* Leave space for null terminator. */
2763 switch (e_flags
& EF_AVR_MACH
)
2765 case E_AVR_MACH_AVR1
:
2766 strncat (buf
, ", avr:1", size
);
2768 case E_AVR_MACH_AVR2
:
2769 strncat (buf
, ", avr:2", size
);
2771 case E_AVR_MACH_AVR25
:
2772 strncat (buf
, ", avr:25", size
);
2774 case E_AVR_MACH_AVR3
:
2775 strncat (buf
, ", avr:3", size
);
2777 case E_AVR_MACH_AVR31
:
2778 strncat (buf
, ", avr:31", size
);
2780 case E_AVR_MACH_AVR35
:
2781 strncat (buf
, ", avr:35", size
);
2783 case E_AVR_MACH_AVR4
:
2784 strncat (buf
, ", avr:4", size
);
2786 case E_AVR_MACH_AVR5
:
2787 strncat (buf
, ", avr:5", size
);
2789 case E_AVR_MACH_AVR51
:
2790 strncat (buf
, ", avr:51", size
);
2792 case E_AVR_MACH_AVR6
:
2793 strncat (buf
, ", avr:6", size
);
2795 case E_AVR_MACH_AVRTINY
:
2796 strncat (buf
, ", avr:100", size
);
2798 case E_AVR_MACH_XMEGA1
:
2799 strncat (buf
, ", avr:101", size
);
2801 case E_AVR_MACH_XMEGA2
:
2802 strncat (buf
, ", avr:102", size
);
2804 case E_AVR_MACH_XMEGA3
:
2805 strncat (buf
, ", avr:103", size
);
2807 case E_AVR_MACH_XMEGA4
:
2808 strncat (buf
, ", avr:104", size
);
2810 case E_AVR_MACH_XMEGA5
:
2811 strncat (buf
, ", avr:105", size
);
2813 case E_AVR_MACH_XMEGA6
:
2814 strncat (buf
, ", avr:106", size
);
2816 case E_AVR_MACH_XMEGA7
:
2817 strncat (buf
, ", avr:107", size
);
2820 strncat (buf
, ", avr:<unknown>", size
);
2824 size
-= strlen (buf
);
2825 if (e_flags
& EF_AVR_LINKRELAX_PREPARED
)
2826 strncat (buf
, ", link-relax", size
);
2830 decode_NDS32_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2836 bfd_boolean has_fpu
= FALSE
;
2839 static const char *ABI_STRINGS
[] =
2841 "ABI v0", /* use r5 as return register; only used in N1213HC */
2842 "ABI v1", /* use r0 as return register */
2843 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2844 "ABI v2fp", /* for FPU */
2848 static const char *VER_STRINGS
[] =
2850 "Andes ELF V1.3 or older",
2854 static const char *ARCH_STRINGS
[] =
2863 abi
= EF_NDS_ABI
& e_flags
;
2864 arch
= EF_NDS_ARCH
& e_flags
;
2865 config
= EF_NDS_INST
& e_flags
;
2866 version
= EF_NDS32_ELF_VERSION
& e_flags
;
2868 memset (buf
, 0, size
);
2875 case E_NDS_ABI_V2FP
:
2876 case E_NDS_ABI_AABI
:
2877 case E_NDS_ABI_V2FP_PLUS
:
2878 /* In case there are holes in the array. */
2879 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ABI_STRINGS
[abi
>> EF_NDS_ABI_SHIFT
]);
2883 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ABI>");
2889 case E_NDS32_ELF_VER_1_2
:
2890 case E_NDS32_ELF_VER_1_3
:
2891 case E_NDS32_ELF_VER_1_4
:
2892 r
+= snprintf (buf
+ r
, size
- r
, ", %s", VER_STRINGS
[version
>> EF_NDS32_ELF_VERSION_SHIFT
]);
2896 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ELF version number>");
2900 if (E_NDS_ABI_V0
== abi
)
2902 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2903 r
+= snprintf (buf
+ r
, size
- r
, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2904 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2905 r
+= snprintf (buf
+ r
, size
-r
, ", 16b"); /* has 16-bit instructions */
2911 case E_NDS_ARCH_STAR_V1_0
:
2912 case E_NDS_ARCH_STAR_V2_0
:
2913 case E_NDS_ARCH_STAR_V3_0
:
2914 case E_NDS_ARCH_STAR_V3_M
:
2915 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ARCH_STRINGS
[arch
>> EF_NDS_ARCH_SHIFT
]);
2919 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized architecture>");
2920 /* ARCH version determines how the e_flags are interpreted.
2921 If it is unknown, we cannot proceed. */
2925 /* Newer ABI; Now handle architecture specific flags. */
2926 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2928 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2929 r
+= snprintf (buf
+ r
, size
-r
, ", MFUSR_PC");
2931 if (!(config
& E_NDS32_HAS_NO_MAC_INST
))
2932 r
+= snprintf (buf
+ r
, size
-r
, ", MAC");
2934 if (config
& E_NDS32_HAS_DIV_INST
)
2935 r
+= snprintf (buf
+ r
, size
-r
, ", DIV");
2937 if (config
& E_NDS32_HAS_16BIT_INST
)
2938 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
2942 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2944 if (version
<= E_NDS32_ELF_VER_1_3
)
2945 r
+= snprintf (buf
+ r
, size
-r
, ", [B8]");
2947 r
+= snprintf (buf
+ r
, size
-r
, ", EX9");
2950 if (config
& E_NDS32_HAS_MAC_DX_INST
)
2951 r
+= snprintf (buf
+ r
, size
-r
, ", MAC_DX");
2953 if (config
& E_NDS32_HAS_DIV_DX_INST
)
2954 r
+= snprintf (buf
+ r
, size
-r
, ", DIV_DX");
2956 if (config
& E_NDS32_HAS_16BIT_INST
)
2958 if (version
<= E_NDS32_ELF_VER_1_3
)
2959 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
2961 r
+= snprintf (buf
+ r
, size
-r
, ", IFC");
2965 if (config
& E_NDS32_HAS_EXT_INST
)
2966 r
+= snprintf (buf
+ r
, size
-r
, ", PERF1");
2968 if (config
& E_NDS32_HAS_EXT2_INST
)
2969 r
+= snprintf (buf
+ r
, size
-r
, ", PERF2");
2971 if (config
& E_NDS32_HAS_FPU_INST
)
2974 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_SP");
2977 if (config
& E_NDS32_HAS_FPU_DP_INST
)
2980 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_DP");
2983 if (config
& E_NDS32_HAS_FPU_MAC_INST
)
2986 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_MAC");
2991 switch ((config
& E_NDS32_FPU_REG_CONF
) >> E_NDS32_FPU_REG_CONF_SHIFT
)
2993 case E_NDS32_FPU_REG_8SP_4DP
:
2994 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:8/4");
2996 case E_NDS32_FPU_REG_16SP_8DP
:
2997 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:16/8");
2999 case E_NDS32_FPU_REG_32SP_16DP
:
3000 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/16");
3002 case E_NDS32_FPU_REG_32SP_32DP
:
3003 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/32");
3008 if (config
& E_NDS32_HAS_AUDIO_INST
)
3009 r
+= snprintf (buf
+ r
, size
-r
, ", AUDIO");
3011 if (config
& E_NDS32_HAS_STRING_INST
)
3012 r
+= snprintf (buf
+ r
, size
-r
, ", STR");
3014 if (config
& E_NDS32_HAS_REDUCED_REGS
)
3015 r
+= snprintf (buf
+ r
, size
-r
, ", 16REG");
3017 if (config
& E_NDS32_HAS_VIDEO_INST
)
3019 if (version
<= E_NDS32_ELF_VER_1_3
)
3020 r
+= snprintf (buf
+ r
, size
-r
, ", VIDEO");
3022 r
+= snprintf (buf
+ r
, size
-r
, ", SATURATION");
3025 if (config
& E_NDS32_HAS_ENCRIPT_INST
)
3026 r
+= snprintf (buf
+ r
, size
-r
, ", ENCRP");
3028 if (config
& E_NDS32_HAS_L2C_INST
)
3029 r
+= snprintf (buf
+ r
, size
-r
, ", L2C");
3033 get_machine_flags (Filedata
* filedata
, unsigned e_flags
, unsigned e_machine
)
3035 static char buf
[1024];
3046 case EM_ARC_COMPACT2
:
3047 case EM_ARC_COMPACT
:
3048 decode_ARC_machine_flags (e_flags
, e_machine
, buf
);
3052 decode_ARM_machine_flags (e_flags
, buf
);
3056 decode_AVR_machine_flags (e_flags
, buf
, sizeof buf
);
3060 if (e_flags
& EF_BFIN_PIC
)
3061 strcat (buf
, ", PIC");
3063 if (e_flags
& EF_BFIN_FDPIC
)
3064 strcat (buf
, ", FDPIC");
3066 if (e_flags
& EF_BFIN_CODE_IN_L1
)
3067 strcat (buf
, ", code in L1");
3069 if (e_flags
& EF_BFIN_DATA_IN_L1
)
3070 strcat (buf
, ", data in L1");
3075 switch (e_flags
& EF_FRV_CPU_MASK
)
3077 case EF_FRV_CPU_GENERIC
:
3081 strcat (buf
, ", fr???");
3084 case EF_FRV_CPU_FR300
:
3085 strcat (buf
, ", fr300");
3088 case EF_FRV_CPU_FR400
:
3089 strcat (buf
, ", fr400");
3091 case EF_FRV_CPU_FR405
:
3092 strcat (buf
, ", fr405");
3095 case EF_FRV_CPU_FR450
:
3096 strcat (buf
, ", fr450");
3099 case EF_FRV_CPU_FR500
:
3100 strcat (buf
, ", fr500");
3102 case EF_FRV_CPU_FR550
:
3103 strcat (buf
, ", fr550");
3106 case EF_FRV_CPU_SIMPLE
:
3107 strcat (buf
, ", simple");
3109 case EF_FRV_CPU_TOMCAT
:
3110 strcat (buf
, ", tomcat");
3116 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
3117 strcat (buf
, ", m68000");
3118 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
3119 strcat (buf
, ", cpu32");
3120 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
3121 strcat (buf
, ", fido_a");
3124 char const * isa
= _("unknown");
3125 char const * mac
= _("unknown mac");
3126 char const * additional
= NULL
;
3128 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
3130 case EF_M68K_CF_ISA_A_NODIV
:
3132 additional
= ", nodiv";
3134 case EF_M68K_CF_ISA_A
:
3137 case EF_M68K_CF_ISA_A_PLUS
:
3140 case EF_M68K_CF_ISA_B_NOUSP
:
3142 additional
= ", nousp";
3144 case EF_M68K_CF_ISA_B
:
3147 case EF_M68K_CF_ISA_C
:
3150 case EF_M68K_CF_ISA_C_NODIV
:
3152 additional
= ", nodiv";
3155 strcat (buf
, ", cf, isa ");
3158 strcat (buf
, additional
);
3159 if (e_flags
& EF_M68K_CF_FLOAT
)
3160 strcat (buf
, ", float");
3161 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
3166 case EF_M68K_CF_MAC
:
3169 case EF_M68K_CF_EMAC
:
3172 case EF_M68K_CF_EMAC_B
:
3185 switch (e_flags
& EF_MEP_CPU_MASK
)
3187 case EF_MEP_CPU_MEP
: strcat (buf
, ", generic MeP"); break;
3188 case EF_MEP_CPU_C2
: strcat (buf
, ", MeP C2"); break;
3189 case EF_MEP_CPU_C3
: strcat (buf
, ", MeP C3"); break;
3190 case EF_MEP_CPU_C4
: strcat (buf
, ", MeP C4"); break;
3191 case EF_MEP_CPU_C5
: strcat (buf
, ", MeP C5"); break;
3192 case EF_MEP_CPU_H1
: strcat (buf
, ", MeP H1"); break;
3193 default: strcat (buf
, _(", <unknown MeP cpu type>")); break;
3196 switch (e_flags
& EF_MEP_COP_MASK
)
3198 case EF_MEP_COP_NONE
: break;
3199 case EF_MEP_COP_AVC
: strcat (buf
, ", AVC coprocessor"); break;
3200 case EF_MEP_COP_AVC2
: strcat (buf
, ", AVC2 coprocessor"); break;
3201 case EF_MEP_COP_FMAX
: strcat (buf
, ", FMAX coprocessor"); break;
3202 case EF_MEP_COP_IVC2
: strcat (buf
, ", IVC2 coprocessor"); break;
3203 default: strcat (buf
, _("<unknown MeP copro type>")); break;
3206 if (e_flags
& EF_MEP_LIBRARY
)
3207 strcat (buf
, ", Built for Library");
3209 if (e_flags
& EF_MEP_INDEX_MASK
)
3210 sprintf (buf
+ strlen (buf
), ", Configuration Index: %#x",
3211 e_flags
& EF_MEP_INDEX_MASK
);
3213 if (e_flags
& ~ EF_MEP_ALL_FLAGS
)
3214 sprintf (buf
+ strlen (buf
), _(", unknown flags bits: %#x"),
3215 e_flags
& ~ EF_MEP_ALL_FLAGS
);
3219 if (e_flags
& EF_PPC_EMB
)
3220 strcat (buf
, ", emb");
3222 if (e_flags
& EF_PPC_RELOCATABLE
)
3223 strcat (buf
, _(", relocatable"));
3225 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
3226 strcat (buf
, _(", relocatable-lib"));
3230 if (e_flags
& EF_PPC64_ABI
)
3232 char abi
[] = ", abiv0";
3234 abi
[6] += e_flags
& EF_PPC64_ABI
;
3240 if ((e_flags
& EF_RH850_ABI
) == EF_RH850_ABI
)
3241 strcat (buf
, ", RH850 ABI");
3243 if (e_flags
& EF_V800_850E3
)
3244 strcat (buf
, ", V3 architecture");
3246 if ((e_flags
& (EF_RH850_FPU_DOUBLE
| EF_RH850_FPU_SINGLE
)) == 0)
3247 strcat (buf
, ", FPU not used");
3249 if ((e_flags
& (EF_RH850_REGMODE22
| EF_RH850_REGMODE32
)) == 0)
3250 strcat (buf
, ", regmode: COMMON");
3252 if ((e_flags
& (EF_RH850_GP_FIX
| EF_RH850_GP_NOFIX
)) == 0)
3253 strcat (buf
, ", r4 not used");
3255 if ((e_flags
& (EF_RH850_EP_FIX
| EF_RH850_EP_NOFIX
)) == 0)
3256 strcat (buf
, ", r30 not used");
3258 if ((e_flags
& (EF_RH850_TP_FIX
| EF_RH850_TP_NOFIX
)) == 0)
3259 strcat (buf
, ", r5 not used");
3261 if ((e_flags
& (EF_RH850_REG2_RESERVE
| EF_RH850_REG2_NORESERVE
)) == 0)
3262 strcat (buf
, ", r2 not used");
3264 for (e_flags
&= 0xFFFF; e_flags
; e_flags
&= ~ (e_flags
& - e_flags
))
3266 switch (e_flags
& - e_flags
)
3268 case EF_RH850_FPU_DOUBLE
: strcat (buf
, ", double precision FPU"); break;
3269 case EF_RH850_FPU_SINGLE
: strcat (buf
, ", single precision FPU"); break;
3270 case EF_RH850_REGMODE22
: strcat (buf
, ", regmode:22"); break;
3271 case EF_RH850_REGMODE32
: strcat (buf
, ", regmode:23"); break;
3272 case EF_RH850_GP_FIX
: strcat (buf
, ", r4 fixed"); break;
3273 case EF_RH850_GP_NOFIX
: strcat (buf
, ", r4 free"); break;
3274 case EF_RH850_EP_FIX
: strcat (buf
, ", r30 fixed"); break;
3275 case EF_RH850_EP_NOFIX
: strcat (buf
, ", r30 free"); break;
3276 case EF_RH850_TP_FIX
: strcat (buf
, ", r5 fixed"); break;
3277 case EF_RH850_TP_NOFIX
: strcat (buf
, ", r5 free"); break;
3278 case EF_RH850_REG2_RESERVE
: strcat (buf
, ", r2 fixed"); break;
3279 case EF_RH850_REG2_NORESERVE
: strcat (buf
, ", r2 free"); break;
3286 case EM_CYGNUS_V850
:
3287 switch (e_flags
& EF_V850_ARCH
)
3289 case E_V850E3V5_ARCH
:
3290 strcat (buf
, ", v850e3v5");
3292 case E_V850E2V3_ARCH
:
3293 strcat (buf
, ", v850e2v3");
3296 strcat (buf
, ", v850e2");
3299 strcat (buf
, ", v850e1");
3302 strcat (buf
, ", v850e");
3305 strcat (buf
, ", v850");
3308 strcat (buf
, _(", unknown v850 architecture variant"));
3314 case EM_CYGNUS_M32R
:
3315 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
3316 strcat (buf
, ", m32r");
3320 case EM_MIPS_RS3_LE
:
3321 if (e_flags
& EF_MIPS_NOREORDER
)
3322 strcat (buf
, ", noreorder");
3324 if (e_flags
& EF_MIPS_PIC
)
3325 strcat (buf
, ", pic");
3327 if (e_flags
& EF_MIPS_CPIC
)
3328 strcat (buf
, ", cpic");
3330 if (e_flags
& EF_MIPS_UCODE
)
3331 strcat (buf
, ", ugen_reserved");
3333 if (e_flags
& EF_MIPS_ABI2
)
3334 strcat (buf
, ", abi2");
3336 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
3337 strcat (buf
, ", odk first");
3339 if (e_flags
& EF_MIPS_32BITMODE
)
3340 strcat (buf
, ", 32bitmode");
3342 if (e_flags
& EF_MIPS_NAN2008
)
3343 strcat (buf
, ", nan2008");
3345 if (e_flags
& EF_MIPS_FP64
)
3346 strcat (buf
, ", fp64");
3348 switch ((e_flags
& EF_MIPS_MACH
))
3350 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
3351 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
3352 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
3353 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
3354 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
3355 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
3356 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
3357 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
3358 case E_MIPS_MACH_5900
: strcat (buf
, ", 5900"); break;
3359 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
3360 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
3361 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
3362 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
3363 case E_MIPS_MACH_LS3A
: strcat (buf
, ", loongson-3a"); break;
3364 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
3365 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
3366 case E_MIPS_MACH_OCTEON3
: strcat (buf
, ", octeon3"); break;
3367 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
3368 case E_MIPS_MACH_IAMR2
: strcat (buf
, ", interaptiv-mr2"); break;
3370 /* We simply ignore the field in this case to avoid confusion:
3371 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3374 default: strcat (buf
, _(", unknown CPU")); break;
3377 switch ((e_flags
& EF_MIPS_ABI
))
3379 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
3380 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
3381 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
3382 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
3384 /* We simply ignore the field in this case to avoid confusion:
3385 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3386 This means it is likely to be an o32 file, but not for
3389 default: strcat (buf
, _(", unknown ABI")); break;
3392 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
3393 strcat (buf
, ", mdmx");
3395 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
3396 strcat (buf
, ", mips16");
3398 if (e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
3399 strcat (buf
, ", micromips");
3401 switch ((e_flags
& EF_MIPS_ARCH
))
3403 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
3404 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
3405 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
3406 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
3407 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
3408 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
3409 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
3410 case E_MIPS_ARCH_32R6
: strcat (buf
, ", mips32r6"); break;
3411 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
3412 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
3413 case E_MIPS_ARCH_64R6
: strcat (buf
, ", mips64r6"); break;
3414 default: strcat (buf
, _(", unknown ISA")); break;
3419 decode_NDS32_machine_flags (e_flags
, buf
, sizeof buf
);
3423 if (e_flags
& EF_RISCV_RVC
)
3424 strcat (buf
, ", RVC");
3426 switch (e_flags
& EF_RISCV_FLOAT_ABI
)
3428 case EF_RISCV_FLOAT_ABI_SOFT
:
3429 strcat (buf
, ", soft-float ABI");
3432 case EF_RISCV_FLOAT_ABI_SINGLE
:
3433 strcat (buf
, ", single-float ABI");
3436 case EF_RISCV_FLOAT_ABI_DOUBLE
:
3437 strcat (buf
, ", double-float ABI");
3440 case EF_RISCV_FLOAT_ABI_QUAD
:
3441 strcat (buf
, ", quad-float ABI");
3447 switch ((e_flags
& EF_SH_MACH_MASK
))
3449 case EF_SH1
: strcat (buf
, ", sh1"); break;
3450 case EF_SH2
: strcat (buf
, ", sh2"); break;
3451 case EF_SH3
: strcat (buf
, ", sh3"); break;
3452 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
3453 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
3454 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
3455 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
3456 case EF_SH4
: strcat (buf
, ", sh4"); break;
3457 case EF_SH5
: strcat (buf
, ", sh5"); break;
3458 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
3459 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
3460 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
3461 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
3462 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
3463 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
3464 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
3465 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
3466 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3467 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
3468 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
3469 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
3470 default: strcat (buf
, _(", unknown ISA")); break;
3473 if (e_flags
& EF_SH_PIC
)
3474 strcat (buf
, ", pic");
3476 if (e_flags
& EF_SH_FDPIC
)
3477 strcat (buf
, ", fdpic");
3481 if (e_flags
& EF_OR1K_NODELAY
)
3482 strcat (buf
, ", no delay");
3486 if (e_flags
& EF_SPARC_32PLUS
)
3487 strcat (buf
, ", v8+");
3489 if (e_flags
& EF_SPARC_SUN_US1
)
3490 strcat (buf
, ", ultrasparcI");
3492 if (e_flags
& EF_SPARC_SUN_US3
)
3493 strcat (buf
, ", ultrasparcIII");
3495 if (e_flags
& EF_SPARC_HAL_R1
)
3496 strcat (buf
, ", halr1");
3498 if (e_flags
& EF_SPARC_LEDATA
)
3499 strcat (buf
, ", ledata");
3501 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
3502 strcat (buf
, ", tso");
3504 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
3505 strcat (buf
, ", pso");
3507 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
3508 strcat (buf
, ", rmo");
3512 switch (e_flags
& EF_PARISC_ARCH
)
3514 case EFA_PARISC_1_0
:
3515 strcpy (buf
, ", PA-RISC 1.0");
3517 case EFA_PARISC_1_1
:
3518 strcpy (buf
, ", PA-RISC 1.1");
3520 case EFA_PARISC_2_0
:
3521 strcpy (buf
, ", PA-RISC 2.0");
3526 if (e_flags
& EF_PARISC_TRAPNIL
)
3527 strcat (buf
, ", trapnil");
3528 if (e_flags
& EF_PARISC_EXT
)
3529 strcat (buf
, ", ext");
3530 if (e_flags
& EF_PARISC_LSB
)
3531 strcat (buf
, ", lsb");
3532 if (e_flags
& EF_PARISC_WIDE
)
3533 strcat (buf
, ", wide");
3534 if (e_flags
& EF_PARISC_NO_KABP
)
3535 strcat (buf
, ", no kabp");
3536 if (e_flags
& EF_PARISC_LAZYSWAP
)
3537 strcat (buf
, ", lazyswap");
3542 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
3543 strcat (buf
, ", new calling convention");
3545 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
3546 strcat (buf
, ", gnu calling convention");
3550 if ((e_flags
& EF_IA_64_ABI64
))
3551 strcat (buf
, ", 64-bit");
3553 strcat (buf
, ", 32-bit");
3554 if ((e_flags
& EF_IA_64_REDUCEDFP
))
3555 strcat (buf
, ", reduced fp model");
3556 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
3557 strcat (buf
, ", no function descriptors, constant gp");
3558 else if ((e_flags
& EF_IA_64_CONS_GP
))
3559 strcat (buf
, ", constant gp");
3560 if ((e_flags
& EF_IA_64_ABSOLUTE
))
3561 strcat (buf
, ", absolute");
3562 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
3564 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
3565 strcat (buf
, ", vms_linkages");
3566 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
3568 case EF_IA_64_VMS_COMCOD_SUCCESS
:
3570 case EF_IA_64_VMS_COMCOD_WARNING
:
3571 strcat (buf
, ", warning");
3573 case EF_IA_64_VMS_COMCOD_ERROR
:
3574 strcat (buf
, ", error");
3576 case EF_IA_64_VMS_COMCOD_ABORT
:
3577 strcat (buf
, ", abort");
3580 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3581 e_flags
& EF_IA_64_VMS_COMCOD
);
3582 strcat (buf
, ", <unknown>");
3588 if ((e_flags
& EF_VAX_NONPIC
))
3589 strcat (buf
, ", non-PIC");
3590 if ((e_flags
& EF_VAX_DFLOAT
))
3591 strcat (buf
, ", D-Float");
3592 if ((e_flags
& EF_VAX_GFLOAT
))
3593 strcat (buf
, ", G-Float");
3597 if (e_flags
& EF_VISIUM_ARCH_MCM
)
3598 strcat (buf
, ", mcm");
3599 else if (e_flags
& EF_VISIUM_ARCH_MCM24
)
3600 strcat (buf
, ", mcm24");
3601 if (e_flags
& EF_VISIUM_ARCH_GR6
)
3602 strcat (buf
, ", gr6");
3606 switch (e_flags
& E_FLAG_RL78_CPU_MASK
)
3608 case E_FLAG_RL78_ANY_CPU
: break;
3609 case E_FLAG_RL78_G10
: strcat (buf
, ", G10"); break;
3610 case E_FLAG_RL78_G13
: strcat (buf
, ", G13"); break;
3611 case E_FLAG_RL78_G14
: strcat (buf
, ", G14"); break;
3613 if (e_flags
& E_FLAG_RL78_64BIT_DOUBLES
)
3614 strcat (buf
, ", 64-bit doubles");
3618 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
3619 strcat (buf
, ", 64-bit doubles");
3620 if (e_flags
& E_FLAG_RX_DSP
)
3621 strcat (buf
, ", dsp");
3622 if (e_flags
& E_FLAG_RX_PID
)
3623 strcat (buf
, ", pid");
3624 if (e_flags
& E_FLAG_RX_ABI
)
3625 strcat (buf
, ", RX ABI");
3626 if (e_flags
& E_FLAG_RX_SINSNS_SET
)
3627 strcat (buf
, e_flags
& E_FLAG_RX_SINSNS_YES
3628 ? ", uses String instructions" : ", bans String instructions");
3629 if (e_flags
& E_FLAG_RX_V2
)
3630 strcat (buf
, ", V2");
3634 if (e_flags
& EF_S390_HIGH_GPRS
)
3635 strcat (buf
, ", highgprs");
3639 if ((e_flags
& EF_C6000_REL
))
3640 strcat (buf
, ", relocatable module");
3644 strcat (buf
, _(": architecture variant: "));
3645 switch (e_flags
& EF_MSP430_MACH
)
3647 case E_MSP430_MACH_MSP430x11
: strcat (buf
, "MSP430x11"); break;
3648 case E_MSP430_MACH_MSP430x11x1
: strcat (buf
, "MSP430x11x1 "); break;
3649 case E_MSP430_MACH_MSP430x12
: strcat (buf
, "MSP430x12"); break;
3650 case E_MSP430_MACH_MSP430x13
: strcat (buf
, "MSP430x13"); break;
3651 case E_MSP430_MACH_MSP430x14
: strcat (buf
, "MSP430x14"); break;
3652 case E_MSP430_MACH_MSP430x15
: strcat (buf
, "MSP430x15"); break;
3653 case E_MSP430_MACH_MSP430x16
: strcat (buf
, "MSP430x16"); break;
3654 case E_MSP430_MACH_MSP430x31
: strcat (buf
, "MSP430x31"); break;
3655 case E_MSP430_MACH_MSP430x32
: strcat (buf
, "MSP430x32"); break;
3656 case E_MSP430_MACH_MSP430x33
: strcat (buf
, "MSP430x33"); break;
3657 case E_MSP430_MACH_MSP430x41
: strcat (buf
, "MSP430x41"); break;
3658 case E_MSP430_MACH_MSP430x42
: strcat (buf
, "MSP430x42"); break;
3659 case E_MSP430_MACH_MSP430x43
: strcat (buf
, "MSP430x43"); break;
3660 case E_MSP430_MACH_MSP430x44
: strcat (buf
, "MSP430x44"); break;
3661 case E_MSP430_MACH_MSP430X
: strcat (buf
, "MSP430X"); break;
3663 strcat (buf
, _(": unknown")); break;
3666 if (e_flags
& ~ EF_MSP430_MACH
)
3667 strcat (buf
, _(": unknown extra flag bits also present"));
3675 get_osabi_name (Filedata
* filedata
, unsigned int osabi
)
3677 static char buff
[32];
3681 case ELFOSABI_NONE
: return "UNIX - System V";
3682 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
3683 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
3684 case ELFOSABI_GNU
: return "UNIX - GNU";
3685 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
3686 case ELFOSABI_AIX
: return "UNIX - AIX";
3687 case ELFOSABI_IRIX
: return "UNIX - IRIX";
3688 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
3689 case ELFOSABI_TRU64
: return "UNIX - TRU64";
3690 case ELFOSABI_MODESTO
: return "Novell - Modesto";
3691 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
3692 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
3693 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
3694 case ELFOSABI_AROS
: return "AROS";
3695 case ELFOSABI_FENIXOS
: return "FenixOS";
3696 case ELFOSABI_CLOUDABI
: return "Nuxi CloudABI";
3697 case ELFOSABI_OPENVOS
: return "Stratus Technologies OpenVOS";
3700 switch (filedata
->file_header
.e_machine
)
3705 case ELFOSABI_ARM
: return "ARM";
3716 case ELFOSABI_STANDALONE
: return _("Standalone App");
3725 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
3726 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
3735 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
3741 get_aarch64_segment_type (unsigned long type
)
3745 case PT_AARCH64_ARCHEXT
: return "AARCH64_ARCHEXT";
3746 default: return NULL
;
3751 get_arm_segment_type (unsigned long type
)
3755 case PT_ARM_EXIDX
: return "EXIDX";
3756 default: return NULL
;
3761 get_s390_segment_type (unsigned long type
)
3765 case PT_S390_PGSTE
: return "S390_PGSTE";
3766 default: return NULL
;
3771 get_mips_segment_type (unsigned long type
)
3775 case PT_MIPS_REGINFO
: return "REGINFO";
3776 case PT_MIPS_RTPROC
: return "RTPROC";
3777 case PT_MIPS_OPTIONS
: return "OPTIONS";
3778 case PT_MIPS_ABIFLAGS
: return "ABIFLAGS";
3779 default: return NULL
;
3784 get_parisc_segment_type (unsigned long type
)
3788 case PT_HP_TLS
: return "HP_TLS";
3789 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
3790 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
3791 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
3792 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
3793 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
3794 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
3795 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
3796 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
3797 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
3798 case PT_HP_PARALLEL
: return "HP_PARALLEL";
3799 case PT_HP_FASTBIND
: return "HP_FASTBIND";
3800 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
3801 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
3802 case PT_HP_STACK
: return "HP_STACK";
3803 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
3804 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
3805 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
3806 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
3807 default: return NULL
;
3812 get_ia64_segment_type (unsigned long type
)
3816 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
3817 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
3818 case PT_HP_TLS
: return "HP_TLS";
3819 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
3820 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
3821 case PT_IA_64_HP_STACK
: return "HP_STACK";
3822 default: return NULL
;
3827 get_tic6x_segment_type (unsigned long type
)
3831 case PT_C6000_PHATTR
: return "C6000_PHATTR";
3832 default: return NULL
;
3837 get_solaris_segment_type (unsigned long type
)
3841 case 0x6464e550: return "PT_SUNW_UNWIND";
3842 case 0x6474e550: return "PT_SUNW_EH_FRAME";
3843 case 0x6ffffff7: return "PT_LOSUNW";
3844 case 0x6ffffffa: return "PT_SUNWBSS";
3845 case 0x6ffffffb: return "PT_SUNWSTACK";
3846 case 0x6ffffffc: return "PT_SUNWDTRACE";
3847 case 0x6ffffffd: return "PT_SUNWCAP";
3848 case 0x6fffffff: return "PT_HISUNW";
3849 default: return NULL
;
3854 get_segment_type (Filedata
* filedata
, unsigned long p_type
)
3856 static char buff
[32];
3860 case PT_NULL
: return "NULL";
3861 case PT_LOAD
: return "LOAD";
3862 case PT_DYNAMIC
: return "DYNAMIC";
3863 case PT_INTERP
: return "INTERP";
3864 case PT_NOTE
: return "NOTE";
3865 case PT_SHLIB
: return "SHLIB";
3866 case PT_PHDR
: return "PHDR";
3867 case PT_TLS
: return "TLS";
3868 case PT_GNU_EH_FRAME
: return "GNU_EH_FRAME";
3869 case PT_GNU_STACK
: return "GNU_STACK";
3870 case PT_GNU_RELRO
: return "GNU_RELRO";
3873 if (p_type
>= PT_GNU_MBIND_LO
&& p_type
<= PT_GNU_MBIND_HI
)
3875 sprintf (buff
, "GNU_MBIND+%#lx",
3876 p_type
- PT_GNU_MBIND_LO
);
3878 else if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
3880 const char * result
;
3882 switch (filedata
->file_header
.e_machine
)
3885 result
= get_aarch64_segment_type (p_type
);
3888 result
= get_arm_segment_type (p_type
);
3891 case EM_MIPS_RS3_LE
:
3892 result
= get_mips_segment_type (p_type
);
3895 result
= get_parisc_segment_type (p_type
);
3898 result
= get_ia64_segment_type (p_type
);
3901 result
= get_tic6x_segment_type (p_type
);
3905 result
= get_s390_segment_type (p_type
);
3915 sprintf (buff
, "LOPROC+%#lx", p_type
- PT_LOPROC
);
3917 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
3919 const char * result
;
3921 switch (filedata
->file_header
.e_machine
)
3924 result
= get_parisc_segment_type (p_type
);
3927 result
= get_ia64_segment_type (p_type
);
3930 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
3931 result
= get_solaris_segment_type (p_type
);
3940 sprintf (buff
, "LOOS+%#lx", p_type
- PT_LOOS
);
3943 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
3950 get_arc_section_type_name (unsigned int sh_type
)
3954 case SHT_ARC_ATTRIBUTES
: return "ARC_ATTRIBUTES";
3962 get_mips_section_type_name (unsigned int sh_type
)
3966 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
3967 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
3968 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
3969 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
3970 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
3971 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
3972 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
3973 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
3974 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
3975 case SHT_MIPS_RELD
: return "MIPS_RELD";
3976 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
3977 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
3978 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
3979 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
3980 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
3981 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
3982 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
3983 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
3984 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
3985 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
3986 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
3987 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
3988 case SHT_MIPS_LINE
: return "MIPS_LINE";
3989 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
3990 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
3991 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
3992 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
3993 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
3994 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
3995 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
3996 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
3997 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
3998 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
3999 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
4000 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
4001 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
4002 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
4003 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
4004 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
4005 case SHT_MIPS_ABIFLAGS
: return "MIPS_ABIFLAGS";
4013 get_parisc_section_type_name (unsigned int sh_type
)
4017 case SHT_PARISC_EXT
: return "PARISC_EXT";
4018 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
4019 case SHT_PARISC_DOC
: return "PARISC_DOC";
4020 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
4021 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
4022 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
4023 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
4024 default: return NULL
;
4029 get_ia64_section_type_name (Filedata
* filedata
, unsigned int sh_type
)
4031 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
4032 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
4033 return get_osabi_name (filedata
, (sh_type
& 0x00FF0000) >> 16);
4037 case SHT_IA_64_EXT
: return "IA_64_EXT";
4038 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
4039 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
4040 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
4041 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
4042 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
4043 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
4044 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
4045 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
4046 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
4054 get_x86_64_section_type_name (unsigned int sh_type
)
4058 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
4059 default: return NULL
;
4064 get_aarch64_section_type_name (unsigned int sh_type
)
4068 case SHT_AARCH64_ATTRIBUTES
: return "AARCH64_ATTRIBUTES";
4069 default: return NULL
;
4074 get_arm_section_type_name (unsigned int sh_type
)
4078 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
4079 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
4080 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
4081 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
4082 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
4083 default: return NULL
;
4088 get_tic6x_section_type_name (unsigned int sh_type
)
4092 case SHT_C6000_UNWIND
: return "C6000_UNWIND";
4093 case SHT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
4094 case SHT_C6000_ATTRIBUTES
: return "C6000_ATTRIBUTES";
4095 case SHT_TI_ICODE
: return "TI_ICODE";
4096 case SHT_TI_XREF
: return "TI_XREF";
4097 case SHT_TI_HANDLER
: return "TI_HANDLER";
4098 case SHT_TI_INITINFO
: return "TI_INITINFO";
4099 case SHT_TI_PHATTRS
: return "TI_PHATTRS";
4100 default: return NULL
;
4105 get_msp430x_section_type_name (unsigned int sh_type
)
4109 case SHT_MSP430_SEC_FLAGS
: return "MSP430_SEC_FLAGS";
4110 case SHT_MSP430_SYM_ALIASES
: return "MSP430_SYM_ALIASES";
4111 case SHT_MSP430_ATTRIBUTES
: return "MSP430_ATTRIBUTES";
4112 default: return NULL
;
4117 get_v850_section_type_name (unsigned int sh_type
)
4121 case SHT_V850_SCOMMON
: return "V850 Small Common";
4122 case SHT_V850_TCOMMON
: return "V850 Tiny Common";
4123 case SHT_V850_ZCOMMON
: return "V850 Zero Common";
4124 case SHT_RENESAS_IOP
: return "RENESAS IOP";
4125 case SHT_RENESAS_INFO
: return "RENESAS INFO";
4126 default: return NULL
;
4131 get_section_type_name (Filedata
* filedata
, unsigned int sh_type
)
4133 static char buff
[32];
4134 const char * result
;
4138 case SHT_NULL
: return "NULL";
4139 case SHT_PROGBITS
: return "PROGBITS";
4140 case SHT_SYMTAB
: return "SYMTAB";
4141 case SHT_STRTAB
: return "STRTAB";
4142 case SHT_RELA
: return "RELA";
4143 case SHT_HASH
: return "HASH";
4144 case SHT_DYNAMIC
: return "DYNAMIC";
4145 case SHT_NOTE
: return "NOTE";
4146 case SHT_NOBITS
: return "NOBITS";
4147 case SHT_REL
: return "REL";
4148 case SHT_SHLIB
: return "SHLIB";
4149 case SHT_DYNSYM
: return "DYNSYM";
4150 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
4151 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
4152 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
4153 case SHT_GNU_HASH
: return "GNU_HASH";
4154 case SHT_GROUP
: return "GROUP";
4155 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
4156 case SHT_GNU_verdef
: return "VERDEF";
4157 case SHT_GNU_verneed
: return "VERNEED";
4158 case SHT_GNU_versym
: return "VERSYM";
4159 case 0x6ffffff0: return "VERSYM";
4160 case 0x6ffffffc: return "VERDEF";
4161 case 0x7ffffffd: return "AUXILIARY";
4162 case 0x7fffffff: return "FILTER";
4163 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
4166 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
4168 switch (filedata
->file_header
.e_machine
)
4171 case EM_ARC_COMPACT
:
4172 case EM_ARC_COMPACT2
:
4173 result
= get_arc_section_type_name (sh_type
);
4176 case EM_MIPS_RS3_LE
:
4177 result
= get_mips_section_type_name (sh_type
);
4180 result
= get_parisc_section_type_name (sh_type
);
4183 result
= get_ia64_section_type_name (filedata
, sh_type
);
4188 result
= get_x86_64_section_type_name (sh_type
);
4191 result
= get_aarch64_section_type_name (sh_type
);
4194 result
= get_arm_section_type_name (sh_type
);
4197 result
= get_tic6x_section_type_name (sh_type
);
4200 result
= get_msp430x_section_type_name (sh_type
);
4204 case EM_CYGNUS_V850
:
4205 result
= get_v850_section_type_name (sh_type
);
4215 sprintf (buff
, "LOPROC+%#x", sh_type
- SHT_LOPROC
);
4217 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
4219 switch (filedata
->file_header
.e_machine
)
4222 result
= get_ia64_section_type_name (filedata
, sh_type
);
4225 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
4226 result
= get_solaris_section_type (sh_type
);
4231 case SHT_GNU_INCREMENTAL_INPUTS
: result
= "GNU_INCREMENTAL_INPUTS"; break;
4232 case SHT_GNU_ATTRIBUTES
: result
= "GNU_ATTRIBUTES"; break;
4233 case SHT_GNU_HASH
: result
= "GNU_HASH"; break;
4234 case SHT_GNU_LIBLIST
: result
= "GNU_LIBLIST"; break;
4246 sprintf (buff
, "LOOS+%#x", sh_type
- SHT_LOOS
);
4248 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
4250 switch (filedata
->file_header
.e_machine
)
4254 case EM_CYGNUS_V850
:
4255 result
= get_v850_section_type_name (sh_type
);
4265 sprintf (buff
, "LOUSER+%#x", sh_type
- SHT_LOUSER
);
4268 /* This message is probably going to be displayed in a 15
4269 character wide field, so put the hex value first. */
4270 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
4276 #define OPTION_DEBUG_DUMP 512
4277 #define OPTION_DYN_SYMS 513
4278 #define OPTION_DWARF_DEPTH 514
4279 #define OPTION_DWARF_START 515
4280 #define OPTION_DWARF_CHECK 516
4282 static struct option options
[] =
4284 {"all", no_argument
, 0, 'a'},
4285 {"file-header", no_argument
, 0, 'h'},
4286 {"program-headers", no_argument
, 0, 'l'},
4287 {"headers", no_argument
, 0, 'e'},
4288 {"histogram", no_argument
, 0, 'I'},
4289 {"segments", no_argument
, 0, 'l'},
4290 {"sections", no_argument
, 0, 'S'},
4291 {"section-headers", no_argument
, 0, 'S'},
4292 {"section-groups", no_argument
, 0, 'g'},
4293 {"section-details", no_argument
, 0, 't'},
4294 {"full-section-name",no_argument
, 0, 'N'},
4295 {"symbols", no_argument
, 0, 's'},
4296 {"syms", no_argument
, 0, 's'},
4297 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
4298 {"relocs", no_argument
, 0, 'r'},
4299 {"notes", no_argument
, 0, 'n'},
4300 {"dynamic", no_argument
, 0, 'd'},
4301 {"arch-specific", no_argument
, 0, 'A'},
4302 {"version-info", no_argument
, 0, 'V'},
4303 {"use-dynamic", no_argument
, 0, 'D'},
4304 {"unwind", no_argument
, 0, 'u'},
4305 {"archive-index", no_argument
, 0, 'c'},
4306 {"hex-dump", required_argument
, 0, 'x'},
4307 {"relocated-dump", required_argument
, 0, 'R'},
4308 {"string-dump", required_argument
, 0, 'p'},
4309 {"decompress", no_argument
, 0, 'z'},
4310 #ifdef SUPPORT_DISASSEMBLY
4311 {"instruction-dump", required_argument
, 0, 'i'},
4313 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
4315 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
4316 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
4317 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
4319 {"version", no_argument
, 0, 'v'},
4320 {"wide", no_argument
, 0, 'W'},
4321 {"help", no_argument
, 0, 'H'},
4322 {0, no_argument
, 0, 0}
4326 usage (FILE * stream
)
4328 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
4329 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
4330 fprintf (stream
, _(" Options are:\n\
4331 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4332 -h --file-header Display the ELF file header\n\
4333 -l --program-headers Display the program headers\n\
4334 --segments An alias for --program-headers\n\
4335 -S --section-headers Display the sections' header\n\
4336 --sections An alias for --section-headers\n\
4337 -g --section-groups Display the section groups\n\
4338 -t --section-details Display the section details\n\
4339 -e --headers Equivalent to: -h -l -S\n\
4340 -s --syms Display the symbol table\n\
4341 --symbols An alias for --syms\n\
4342 --dyn-syms Display the dynamic symbol table\n\
4343 -n --notes Display the core notes (if present)\n\
4344 -r --relocs Display the relocations (if present)\n\
4345 -u --unwind Display the unwind info (if present)\n\
4346 -d --dynamic Display the dynamic section (if present)\n\
4347 -V --version-info Display the version sections (if present)\n\
4348 -A --arch-specific Display architecture specific information (if any)\n\
4349 -c --archive-index Display the symbol/file index in an archive\n\
4350 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
4351 -x --hex-dump=<number|name>\n\
4352 Dump the contents of section <number|name> as bytes\n\
4353 -p --string-dump=<number|name>\n\
4354 Dump the contents of section <number|name> as strings\n\
4355 -R --relocated-dump=<number|name>\n\
4356 Dump the contents of section <number|name> as relocated bytes\n\
4357 -z --decompress Decompress section before dumping it\n\
4358 -w[lLiaprmfFsoRtUuTgAckK] or\n\
4359 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4360 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4361 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4362 =addr,=cu_index,=links,=follow-links]\n\
4363 Display the contents of DWARF debug sections\n"));
4364 fprintf (stream
, _("\
4365 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4366 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4368 #ifdef SUPPORT_DISASSEMBLY
4369 fprintf (stream
, _("\
4370 -i --instruction-dump=<number|name>\n\
4371 Disassemble the contents of section <number|name>\n"));
4373 fprintf (stream
, _("\
4374 -I --histogram Display histogram of bucket list lengths\n\
4375 -W --wide Allow output width to exceed 80 characters\n\
4376 @<file> Read options from <file>\n\
4377 -H --help Display this information\n\
4378 -v --version Display the version number of readelf\n"));
4380 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
4381 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
4383 exit (stream
== stdout
? 0 : 1);
4386 /* Record the fact that the user wants the contents of section number
4387 SECTION to be displayed using the method(s) encoded as flags bits
4388 in TYPE. Note, TYPE can be zero if we are creating the array for
4392 request_dump_bynumber (Filedata
* filedata
, unsigned int section
, dump_type type
)
4394 if (section
>= filedata
->num_dump_sects
)
4396 dump_type
* new_dump_sects
;
4398 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
4399 sizeof (* new_dump_sects
));
4401 if (new_dump_sects
== NULL
)
4402 error (_("Out of memory allocating dump request table.\n"));
4405 if (filedata
->dump_sects
)
4407 /* Copy current flag settings. */
4408 memcpy (new_dump_sects
, filedata
->dump_sects
,
4409 filedata
->num_dump_sects
* sizeof (* new_dump_sects
));
4411 free (filedata
->dump_sects
);
4414 filedata
->dump_sects
= new_dump_sects
;
4415 filedata
->num_dump_sects
= section
+ 1;
4419 if (filedata
->dump_sects
)
4420 filedata
->dump_sects
[section
] |= type
;
4423 /* Request a dump by section name. */
4426 request_dump_byname (const char * section
, dump_type type
)
4428 struct dump_list_entry
* new_request
;
4430 new_request
= (struct dump_list_entry
*)
4431 malloc (sizeof (struct dump_list_entry
));
4433 error (_("Out of memory allocating dump request table.\n"));
4435 new_request
->name
= strdup (section
);
4436 if (!new_request
->name
)
4437 error (_("Out of memory allocating dump request table.\n"));
4439 new_request
->type
= type
;
4441 new_request
->next
= dump_sects_byname
;
4442 dump_sects_byname
= new_request
;
4446 request_dump (Filedata
* filedata
, dump_type type
)
4452 section
= strtoul (optarg
, & cp
, 0);
4454 if (! *cp
&& section
>= 0)
4455 request_dump_bynumber (filedata
, section
, type
);
4457 request_dump_byname (optarg
, type
);
4461 parse_args (Filedata
* filedata
, int argc
, char ** argv
)
4468 while ((c
= getopt_long
4469 (argc
, argv
, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options
, NULL
)) != EOF
)
4487 do_section_groups
= TRUE
;
4490 do_histogram
= TRUE
;
4495 do_section_groups
= TRUE
;
4500 do_section_details
= TRUE
;
4511 do_using_dynamic
= TRUE
;
4535 do_histogram
= TRUE
;
4541 do_archive_index
= TRUE
;
4544 request_dump (filedata
, HEX_DUMP
);
4547 request_dump (filedata
, STRING_DUMP
);
4550 request_dump (filedata
, RELOC_DUMP
);
4553 decompress_dumps
= TRUE
;
4559 do_debugging
= TRUE
;
4560 dwarf_select_sections_all ();
4564 do_debugging
= FALSE
;
4565 dwarf_select_sections_by_letters (optarg
);
4568 case OPTION_DEBUG_DUMP
:
4571 do_debugging
= TRUE
;
4574 do_debugging
= FALSE
;
4575 dwarf_select_sections_by_names (optarg
);
4578 case OPTION_DWARF_DEPTH
:
4582 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
4585 case OPTION_DWARF_START
:
4589 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
4592 case OPTION_DWARF_CHECK
:
4595 case OPTION_DYN_SYMS
:
4598 #ifdef SUPPORT_DISASSEMBLY
4600 request_dump (filedata
, DISASS_DUMP
);
4604 print_version (program_name
);
4613 /* xgettext:c-format */
4614 error (_("Invalid option '-%c'\n"), c
);
4621 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
4622 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
4623 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
4624 && !do_section_groups
&& !do_archive_index
4630 get_elf_class (unsigned int elf_class
)
4632 static char buff
[32];
4636 case ELFCLASSNONE
: return _("none");
4637 case ELFCLASS32
: return "ELF32";
4638 case ELFCLASS64
: return "ELF64";
4640 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
4646 get_data_encoding (unsigned int encoding
)
4648 static char buff
[32];
4652 case ELFDATANONE
: return _("none");
4653 case ELFDATA2LSB
: return _("2's complement, little endian");
4654 case ELFDATA2MSB
: return _("2's complement, big endian");
4656 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
4661 /* Decode the data held in 'filedata->file_header'. */
4664 process_file_header (Filedata
* filedata
)
4666 Elf_Internal_Ehdr
* header
= & filedata
->file_header
;
4668 if ( header
->e_ident
[EI_MAG0
] != ELFMAG0
4669 || header
->e_ident
[EI_MAG1
] != ELFMAG1
4670 || header
->e_ident
[EI_MAG2
] != ELFMAG2
4671 || header
->e_ident
[EI_MAG3
] != ELFMAG3
)
4674 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4678 init_dwarf_regnames (header
->e_machine
);
4684 printf (_("ELF Header:\n"));
4685 printf (_(" Magic: "));
4686 for (i
= 0; i
< EI_NIDENT
; i
++)
4687 printf ("%2.2x ", header
->e_ident
[i
]);
4689 printf (_(" Class: %s\n"),
4690 get_elf_class (header
->e_ident
[EI_CLASS
]));
4691 printf (_(" Data: %s\n"),
4692 get_data_encoding (header
->e_ident
[EI_DATA
]));
4693 printf (_(" Version: %d %s\n"),
4694 header
->e_ident
[EI_VERSION
],
4695 (header
->e_ident
[EI_VERSION
] == EV_CURRENT
4697 : (header
->e_ident
[EI_VERSION
] != EV_NONE
4698 ? _("<unknown: %lx>")
4700 printf (_(" OS/ABI: %s\n"),
4701 get_osabi_name (filedata
, header
->e_ident
[EI_OSABI
]));
4702 printf (_(" ABI Version: %d\n"),
4703 header
->e_ident
[EI_ABIVERSION
]);
4704 printf (_(" Type: %s\n"),
4705 get_file_type (header
->e_type
));
4706 printf (_(" Machine: %s\n"),
4707 get_machine_name (header
->e_machine
));
4708 printf (_(" Version: 0x%lx\n"),
4709 (unsigned long) header
->e_version
);
4711 printf (_(" Entry point address: "));
4712 print_vma ((bfd_vma
) header
->e_entry
, PREFIX_HEX
);
4713 printf (_("\n Start of program headers: "));
4714 print_vma ((bfd_vma
) header
->e_phoff
, DEC
);
4715 printf (_(" (bytes into file)\n Start of section headers: "));
4716 print_vma ((bfd_vma
) header
->e_shoff
, DEC
);
4717 printf (_(" (bytes into file)\n"));
4719 printf (_(" Flags: 0x%lx%s\n"),
4720 (unsigned long) header
->e_flags
,
4721 get_machine_flags (filedata
, header
->e_flags
, header
->e_machine
));
4722 printf (_(" Size of this header: %ld (bytes)\n"),
4723 (long) header
->e_ehsize
);
4724 printf (_(" Size of program headers: %ld (bytes)\n"),
4725 (long) header
->e_phentsize
);
4726 printf (_(" Number of program headers: %ld"),
4727 (long) header
->e_phnum
);
4728 if (filedata
->section_headers
!= NULL
4729 && header
->e_phnum
== PN_XNUM
4730 && filedata
->section_headers
[0].sh_info
!= 0)
4731 printf (" (%ld)", (long) filedata
->section_headers
[0].sh_info
);
4732 putc ('\n', stdout
);
4733 printf (_(" Size of section headers: %ld (bytes)\n"),
4734 (long) header
->e_shentsize
);
4735 printf (_(" Number of section headers: %ld"),
4736 (long) header
->e_shnum
);
4737 if (filedata
->section_headers
!= NULL
&& header
->e_shnum
== SHN_UNDEF
)
4738 printf (" (%ld)", (long) filedata
->section_headers
[0].sh_size
);
4739 putc ('\n', stdout
);
4740 printf (_(" Section header string table index: %ld"),
4741 (long) header
->e_shstrndx
);
4742 if (filedata
->section_headers
!= NULL
4743 && header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
4744 printf (" (%u)", filedata
->section_headers
[0].sh_link
);
4745 else if (header
->e_shstrndx
!= SHN_UNDEF
4746 && header
->e_shstrndx
>= header
->e_shnum
)
4747 printf (_(" <corrupt: out of range>"));
4748 putc ('\n', stdout
);
4751 if (filedata
->section_headers
!= NULL
)
4753 if (header
->e_phnum
== PN_XNUM
4754 && filedata
->section_headers
[0].sh_info
!= 0)
4755 header
->e_phnum
= filedata
->section_headers
[0].sh_info
;
4756 if (header
->e_shnum
== SHN_UNDEF
)
4757 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
4758 if (header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
4759 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
4760 if (header
->e_shstrndx
>= header
->e_shnum
)
4761 header
->e_shstrndx
= SHN_UNDEF
;
4762 free (filedata
->section_headers
);
4763 filedata
->section_headers
= NULL
;
4769 /* Read in the program headers from FILEDATA and store them in PHEADERS.
4770 Returns TRUE upon success, FALSE otherwise. Loads 32-bit headers. */
4773 get_32bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
4775 Elf32_External_Phdr
* phdrs
;
4776 Elf32_External_Phdr
* external
;
4777 Elf_Internal_Phdr
* internal
;
4779 unsigned int size
= filedata
->file_header
.e_phentsize
;
4780 unsigned int num
= filedata
->file_header
.e_phnum
;
4782 /* PR binutils/17531: Cope with unexpected section header sizes. */
4783 if (size
== 0 || num
== 0)
4785 if (size
< sizeof * phdrs
)
4787 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4790 if (size
> sizeof * phdrs
)
4791 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4793 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
4794 size
, num
, _("program headers"));
4798 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4799 i
< filedata
->file_header
.e_phnum
;
4800 i
++, internal
++, external
++)
4802 internal
->p_type
= BYTE_GET (external
->p_type
);
4803 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4804 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4805 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4806 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4807 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4808 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4809 internal
->p_align
= BYTE_GET (external
->p_align
);
4816 /* Read in the program headers from FILEDATA and store them in PHEADERS.
4817 Returns TRUE upon success, FALSE otherwise. Loads 64-bit headers. */
4820 get_64bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
4822 Elf64_External_Phdr
* phdrs
;
4823 Elf64_External_Phdr
* external
;
4824 Elf_Internal_Phdr
* internal
;
4826 unsigned int size
= filedata
->file_header
.e_phentsize
;
4827 unsigned int num
= filedata
->file_header
.e_phnum
;
4829 /* PR binutils/17531: Cope with unexpected section header sizes. */
4830 if (size
== 0 || num
== 0)
4832 if (size
< sizeof * phdrs
)
4834 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4837 if (size
> sizeof * phdrs
)
4838 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4840 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
4841 size
, num
, _("program headers"));
4845 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4846 i
< filedata
->file_header
.e_phnum
;
4847 i
++, internal
++, external
++)
4849 internal
->p_type
= BYTE_GET (external
->p_type
);
4850 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4851 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4852 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4853 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4854 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4855 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4856 internal
->p_align
= BYTE_GET (external
->p_align
);
4863 /* Returns TRUE if the program headers were read into `program_headers'. */
4866 get_program_headers (Filedata
* filedata
)
4868 Elf_Internal_Phdr
* phdrs
;
4870 /* Check cache of prior read. */
4871 if (filedata
->program_headers
!= NULL
)
4874 /* Be kind to memory checkers by looking for
4875 e_phnum values which we know must be invalid. */
4876 if (filedata
->file_header
.e_phnum
4877 * (is_32bit_elf
? sizeof (Elf32_External_Phdr
) : sizeof (Elf64_External_Phdr
))
4878 >= filedata
->file_size
)
4880 error (_("Too many program headers - %#x - the file is not that big\n"),
4881 filedata
->file_header
.e_phnum
);
4885 phdrs
= (Elf_Internal_Phdr
*) cmalloc (filedata
->file_header
.e_phnum
,
4886 sizeof (Elf_Internal_Phdr
));
4889 error (_("Out of memory reading %u program headers\n"),
4890 filedata
->file_header
.e_phnum
);
4895 ? get_32bit_program_headers (filedata
, phdrs
)
4896 : get_64bit_program_headers (filedata
, phdrs
))
4898 filedata
->program_headers
= phdrs
;
4906 /* Returns TRUE if the program headers were loaded. */
4909 process_program_headers (Filedata
* filedata
)
4911 Elf_Internal_Phdr
* segment
;
4913 Elf_Internal_Phdr
* previous_load
= NULL
;
4915 if (filedata
->file_header
.e_phnum
== 0)
4917 /* PR binutils/12467. */
4918 if (filedata
->file_header
.e_phoff
!= 0)
4920 warn (_("possibly corrupt ELF header - it has a non-zero program"
4921 " header offset, but no program headers\n"));
4924 else if (do_segments
)
4925 printf (_("\nThere are no program headers in this file.\n"));
4929 if (do_segments
&& !do_header
)
4931 printf (_("\nElf file type is %s\n"), get_file_type (filedata
->file_header
.e_type
));
4932 printf (_("Entry point 0x%s\n"), bfd_vmatoa ("x", filedata
->file_header
.e_entry
));
4933 printf (ngettext ("There is %d program header, starting at offset %s\n",
4934 "There are %d program headers, starting at offset %s\n",
4935 filedata
->file_header
.e_phnum
),
4936 filedata
->file_header
.e_phnum
,
4937 bfd_vmatoa ("u", filedata
->file_header
.e_phoff
));
4940 if (! get_program_headers (filedata
))
4945 if (filedata
->file_header
.e_phnum
> 1)
4946 printf (_("\nProgram Headers:\n"));
4948 printf (_("\nProgram Headers:\n"));
4952 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4955 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4959 (_(" Type Offset VirtAddr PhysAddr\n"));
4961 (_(" FileSiz MemSiz Flags Align\n"));
4968 for (i
= 0, segment
= filedata
->program_headers
;
4969 i
< filedata
->file_header
.e_phnum
;
4974 printf (" %-14.14s ", get_segment_type (filedata
, segment
->p_type
));
4978 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
4979 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
4980 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
4981 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
4982 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
4984 (segment
->p_flags
& PF_R
? 'R' : ' '),
4985 (segment
->p_flags
& PF_W
? 'W' : ' '),
4986 (segment
->p_flags
& PF_X
? 'E' : ' '));
4987 printf ("%#lx", (unsigned long) segment
->p_align
);
4991 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
4992 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
4995 print_vma (segment
->p_offset
, FULL_HEX
);
4999 print_vma (segment
->p_vaddr
, FULL_HEX
);
5001 print_vma (segment
->p_paddr
, FULL_HEX
);
5004 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
5005 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
5008 print_vma (segment
->p_filesz
, FULL_HEX
);
5012 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
5013 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
5016 print_vma (segment
->p_memsz
, FULL_HEX
);
5020 (segment
->p_flags
& PF_R
? 'R' : ' '),
5021 (segment
->p_flags
& PF_W
? 'W' : ' '),
5022 (segment
->p_flags
& PF_X
? 'E' : ' '));
5024 if ((unsigned long) segment
->p_align
== segment
->p_align
)
5025 printf ("%#lx", (unsigned long) segment
->p_align
);
5028 print_vma (segment
->p_align
, PREFIX_HEX
);
5033 print_vma (segment
->p_offset
, FULL_HEX
);
5035 print_vma (segment
->p_vaddr
, FULL_HEX
);
5037 print_vma (segment
->p_paddr
, FULL_HEX
);
5039 print_vma (segment
->p_filesz
, FULL_HEX
);
5041 print_vma (segment
->p_memsz
, FULL_HEX
);
5043 (segment
->p_flags
& PF_R
? 'R' : ' '),
5044 (segment
->p_flags
& PF_W
? 'W' : ' '),
5045 (segment
->p_flags
& PF_X
? 'E' : ' '));
5046 print_vma (segment
->p_align
, PREFIX_HEX
);
5049 putc ('\n', stdout
);
5052 switch (segment
->p_type
)
5055 #if 0 /* Do not warn about out of order PT_LOAD segments. Although officially
5056 required by the ELF standard, several programs, including the Linux
5057 kernel, make use of non-ordered segments. */
5059 && previous_load
->p_vaddr
> segment
->p_vaddr
)
5060 error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
5062 if (segment
->p_memsz
< segment
->p_filesz
)
5063 error (_("the segment's file size is larger than its memory size\n"));
5064 previous_load
= segment
;
5068 /* PR 20815 - Verify that the program header is loaded into memory. */
5069 if (i
> 0 && previous_load
!= NULL
)
5070 error (_("the PHDR segment must occur before any LOAD segment\n"));
5071 if (filedata
->file_header
.e_machine
!= EM_PARISC
)
5075 for (j
= 1; j
< filedata
->file_header
.e_phnum
; j
++)
5076 if (filedata
->program_headers
[j
].p_vaddr
<= segment
->p_vaddr
5077 && (filedata
->program_headers
[j
].p_vaddr
5078 + filedata
->program_headers
[j
].p_memsz
)
5079 >= (segment
->p_vaddr
+ segment
->p_filesz
))
5081 if (j
== filedata
->file_header
.e_phnum
)
5082 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5088 error (_("more than one dynamic segment\n"));
5090 /* By default, assume that the .dynamic section is the first
5091 section in the DYNAMIC segment. */
5092 dynamic_addr
= segment
->p_offset
;
5093 dynamic_size
= segment
->p_filesz
;
5095 /* Try to locate the .dynamic section. If there is
5096 a section header table, we can easily locate it. */
5097 if (filedata
->section_headers
!= NULL
)
5099 Elf_Internal_Shdr
* sec
;
5101 sec
= find_section (filedata
, ".dynamic");
5102 if (sec
== NULL
|| sec
->sh_size
== 0)
5104 /* A corresponding .dynamic section is expected, but on
5105 IA-64/OpenVMS it is OK for it to be missing. */
5106 if (!is_ia64_vms (filedata
))
5107 error (_("no .dynamic section in the dynamic segment\n"));
5111 if (sec
->sh_type
== SHT_NOBITS
)
5117 dynamic_addr
= sec
->sh_offset
;
5118 dynamic_size
= sec
->sh_size
;
5120 if (dynamic_addr
< segment
->p_offset
5121 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
5122 warn (_("the .dynamic section is not contained"
5123 " within the dynamic segment\n"));
5124 else if (dynamic_addr
> segment
->p_offset
)
5125 warn (_("the .dynamic section is not the first section"
5126 " in the dynamic segment.\n"));
5129 /* PR binutils/17512: Avoid corrupt dynamic section info in the
5130 segment. Check this after matching against the section headers
5131 so we don't warn on debuginfo file (which have NOBITS .dynamic
5133 if (dynamic_addr
+ dynamic_size
>= filedata
->file_size
)
5135 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5136 dynamic_addr
= dynamic_size
= 0;
5141 if (fseek (filedata
->handle
, archive_file_offset
+ (long) segment
->p_offset
,
5143 error (_("Unable to find program interpreter name\n"));
5147 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
- 1);
5149 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
5150 error (_("Internal error: failed to create format string to display program interpreter\n"));
5152 program_interpreter
[0] = 0;
5153 if (fscanf (filedata
->handle
, fmt
, program_interpreter
) <= 0)
5154 error (_("Unable to read program interpreter name\n"));
5157 printf (_(" [Requesting program interpreter: %s]\n"),
5158 program_interpreter
);
5165 && filedata
->section_headers
!= NULL
5166 && filedata
->string_table
!= NULL
)
5168 printf (_("\n Section to Segment mapping:\n"));
5169 printf (_(" Segment Sections...\n"));
5171 for (i
= 0; i
< filedata
->file_header
.e_phnum
; i
++)
5174 Elf_Internal_Shdr
* section
;
5176 segment
= filedata
->program_headers
+ i
;
5177 section
= filedata
->section_headers
+ 1;
5179 printf (" %2.2d ", i
);
5181 for (j
= 1; j
< filedata
->file_header
.e_shnum
; j
++, section
++)
5183 if (!ELF_TBSS_SPECIAL (section
, segment
)
5184 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
5185 printf ("%s ", printable_section_name (filedata
, section
));
5196 /* Find the file offset corresponding to VMA by using the program headers. */
5199 offset_from_vma (Filedata
* filedata
, bfd_vma vma
, bfd_size_type size
)
5201 Elf_Internal_Phdr
* seg
;
5203 if (! get_program_headers (filedata
))
5205 warn (_("Cannot interpret virtual addresses without program headers.\n"));
5209 for (seg
= filedata
->program_headers
;
5210 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
5213 if (seg
->p_type
!= PT_LOAD
)
5216 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
5217 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
5218 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
5221 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5222 (unsigned long) vma
);
5227 /* Allocate memory and load the sections headers into FILEDATA->filedata->section_headers.
5228 If PROBE is true, this is just a probe and we do not generate any error
5229 messages if the load fails. */
5232 get_32bit_section_headers (Filedata
* filedata
, bfd_boolean probe
)
5234 Elf32_External_Shdr
* shdrs
;
5235 Elf_Internal_Shdr
* internal
;
5237 unsigned int size
= filedata
->file_header
.e_shentsize
;
5238 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
5240 /* PR binutils/17531: Cope with unexpected section header sizes. */
5241 if (size
== 0 || num
== 0)
5243 if (size
< sizeof * shdrs
)
5246 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5249 if (!probe
&& size
> sizeof * shdrs
)
5250 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5252 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_shoff
,
5254 probe
? NULL
: _("section headers"));
5258 free (filedata
->section_headers
);
5259 filedata
->section_headers
= (Elf_Internal_Shdr
*)
5260 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
5261 if (filedata
->section_headers
== NULL
)
5264 error (_("Out of memory reading %u section headers\n"), num
);
5268 for (i
= 0, internal
= filedata
->section_headers
;
5272 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5273 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5274 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5275 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5276 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5277 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5278 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5279 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5280 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5281 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5282 if (!probe
&& internal
->sh_link
> num
)
5283 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5284 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5285 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5292 /* Like get_32bit_section_headers, except that it fetches 64-bit headers. */
5295 get_64bit_section_headers (Filedata
* filedata
, bfd_boolean probe
)
5297 Elf64_External_Shdr
* shdrs
;
5298 Elf_Internal_Shdr
* internal
;
5300 unsigned int size
= filedata
->file_header
.e_shentsize
;
5301 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
5303 /* PR binutils/17531: Cope with unexpected section header sizes. */
5304 if (size
== 0 || num
== 0)
5307 if (size
< sizeof * shdrs
)
5310 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5314 if (! probe
&& size
> sizeof * shdrs
)
5315 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5317 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, filedata
,
5318 filedata
->file_header
.e_shoff
,
5320 probe
? NULL
: _("section headers"));
5324 free (filedata
->section_headers
);
5325 filedata
->section_headers
= (Elf_Internal_Shdr
*)
5326 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
5327 if (filedata
->section_headers
== NULL
)
5330 error (_("Out of memory reading %u section headers\n"), num
);
5334 for (i
= 0, internal
= filedata
->section_headers
;
5338 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5339 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5340 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5341 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5342 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5343 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5344 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5345 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5346 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5347 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5348 if (!probe
&& internal
->sh_link
> num
)
5349 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5350 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5351 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5358 static Elf_Internal_Sym
*
5359 get_32bit_elf_symbols (Filedata
* filedata
,
5360 Elf_Internal_Shdr
* section
,
5361 unsigned long * num_syms_return
)
5363 unsigned long number
= 0;
5364 Elf32_External_Sym
* esyms
= NULL
;
5365 Elf_External_Sym_Shndx
* shndx
= NULL
;
5366 Elf_Internal_Sym
* isyms
= NULL
;
5367 Elf_Internal_Sym
* psym
;
5370 if (section
->sh_size
== 0)
5372 if (num_syms_return
!= NULL
)
5373 * num_syms_return
= 0;
5377 /* Run some sanity checks first. */
5378 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5380 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5381 printable_section_name (filedata
, section
),
5382 (unsigned long) section
->sh_entsize
);
5386 if (section
->sh_size
> filedata
->file_size
)
5388 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5389 printable_section_name (filedata
, section
),
5390 (unsigned long) section
->sh_size
);
5394 number
= section
->sh_size
/ section
->sh_entsize
;
5396 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
5398 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5399 (unsigned long) section
->sh_size
,
5400 printable_section_name (filedata
, section
),
5401 (unsigned long) section
->sh_entsize
);
5405 esyms
= (Elf32_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
5406 section
->sh_size
, _("symbols"));
5411 elf_section_list
* entry
;
5414 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5415 if (entry
->hdr
->sh_link
== (unsigned long) (section
- filedata
->section_headers
))
5417 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
5418 entry
->hdr
->sh_offset
,
5419 1, entry
->hdr
->sh_size
,
5420 _("symbol table section indicies"));
5423 /* PR17531: file: heap-buffer-overflow */
5424 else if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5426 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5427 printable_section_name (filedata
, entry
->hdr
),
5428 (unsigned long) entry
->hdr
->sh_size
,
5429 (unsigned long) section
->sh_size
);
5435 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5439 error (_("Out of memory reading %lu symbols\n"),
5440 (unsigned long) number
);
5444 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5446 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5447 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5448 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5449 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5450 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5452 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5453 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5454 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5455 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5456 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5465 if (num_syms_return
!= NULL
)
5466 * num_syms_return
= isyms
== NULL
? 0 : number
;
5471 static Elf_Internal_Sym
*
5472 get_64bit_elf_symbols (Filedata
* filedata
,
5473 Elf_Internal_Shdr
* section
,
5474 unsigned long * num_syms_return
)
5476 unsigned long number
= 0;
5477 Elf64_External_Sym
* esyms
= NULL
;
5478 Elf_External_Sym_Shndx
* shndx
= NULL
;
5479 Elf_Internal_Sym
* isyms
= NULL
;
5480 Elf_Internal_Sym
* psym
;
5483 if (section
->sh_size
== 0)
5485 if (num_syms_return
!= NULL
)
5486 * num_syms_return
= 0;
5490 /* Run some sanity checks first. */
5491 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5493 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5494 printable_section_name (filedata
, section
),
5495 (unsigned long) section
->sh_entsize
);
5499 if (section
->sh_size
> filedata
->file_size
)
5501 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5502 printable_section_name (filedata
, section
),
5503 (unsigned long) section
->sh_size
);
5507 number
= section
->sh_size
/ section
->sh_entsize
;
5509 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
5511 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5512 (unsigned long) section
->sh_size
,
5513 printable_section_name (filedata
, section
),
5514 (unsigned long) section
->sh_entsize
);
5518 esyms
= (Elf64_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
5519 section
->sh_size
, _("symbols"));
5524 elf_section_list
* entry
;
5527 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5528 if (entry
->hdr
->sh_link
== (unsigned long) (section
- filedata
->section_headers
))
5530 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
5531 entry
->hdr
->sh_offset
,
5532 1, entry
->hdr
->sh_size
,
5533 _("symbol table section indicies"));
5536 /* PR17531: file: heap-buffer-overflow */
5537 else if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5539 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5540 printable_section_name (filedata
, entry
->hdr
),
5541 (unsigned long) entry
->hdr
->sh_size
,
5542 (unsigned long) section
->sh_size
);
5548 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5552 error (_("Out of memory reading %lu symbols\n"),
5553 (unsigned long) number
);
5557 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5559 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5560 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5561 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5562 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5564 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5566 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5567 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5568 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5570 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5571 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5580 if (num_syms_return
!= NULL
)
5581 * num_syms_return
= isyms
== NULL
? 0 : number
;
5587 get_elf_section_flags (Filedata
* filedata
, bfd_vma sh_flags
)
5589 static char buff
[1024];
5591 unsigned int field_size
= is_32bit_elf
? 8 : 16;
5593 unsigned int size
= sizeof (buff
) - (field_size
+ 4 + 1);
5594 bfd_vma os_flags
= 0;
5595 bfd_vma proc_flags
= 0;
5596 bfd_vma unknown_flags
= 0;
5604 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5605 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5606 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5607 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5608 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5609 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5610 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5611 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5612 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5613 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5614 /* IA-64 specific. */
5615 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5616 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5617 /* IA-64 OpenVMS specific. */
5618 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5619 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5620 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5621 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5622 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5623 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5625 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5626 /* SPARC specific. */
5627 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5628 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5630 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5631 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5632 /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
5634 /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
5636 /* 25 */ { STRING_COMMA_LEN ("VLE") },
5639 if (do_section_details
)
5641 sprintf (buff
, "[%*.*lx]: ",
5642 field_size
, field_size
, (unsigned long) sh_flags
);
5643 p
+= field_size
+ 4;
5650 flag
= sh_flags
& - sh_flags
;
5653 if (do_section_details
)
5657 case SHF_WRITE
: sindex
= 0; break;
5658 case SHF_ALLOC
: sindex
= 1; break;
5659 case SHF_EXECINSTR
: sindex
= 2; break;
5660 case SHF_MERGE
: sindex
= 3; break;
5661 case SHF_STRINGS
: sindex
= 4; break;
5662 case SHF_INFO_LINK
: sindex
= 5; break;
5663 case SHF_LINK_ORDER
: sindex
= 6; break;
5664 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
5665 case SHF_GROUP
: sindex
= 8; break;
5666 case SHF_TLS
: sindex
= 9; break;
5667 case SHF_EXCLUDE
: sindex
= 18; break;
5668 case SHF_COMPRESSED
: sindex
= 20; break;
5669 case SHF_GNU_MBIND
: sindex
= 24; break;
5673 switch (filedata
->file_header
.e_machine
)
5676 if (flag
== SHF_IA_64_SHORT
)
5678 else if (flag
== SHF_IA_64_NORECOV
)
5681 else if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
5684 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
5685 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
5686 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
5687 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
5688 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
5689 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
5700 case EM_OLD_SPARCV9
:
5701 case EM_SPARC32PLUS
:
5704 if (flag
== SHF_ORDERED
)
5711 case SHF_ENTRYSECT
: sindex
= 21; break;
5712 case SHF_ARM_PURECODE
: sindex
= 22; break;
5713 case SHF_COMDEF
: sindex
= 23; break;
5718 if (flag
== SHF_PPC_VLE
)
5729 if (p
!= buff
+ field_size
+ 4)
5731 if (size
< (10 + 2))
5733 warn (_("Internal error: not enough buffer room for section flag info"));
5734 return _("<unknown>");
5741 size
-= flags
[sindex
].len
;
5742 p
= stpcpy (p
, flags
[sindex
].str
);
5744 else if (flag
& SHF_MASKOS
)
5746 else if (flag
& SHF_MASKPROC
)
5749 unknown_flags
|= flag
;
5755 case SHF_WRITE
: *p
= 'W'; break;
5756 case SHF_ALLOC
: *p
= 'A'; break;
5757 case SHF_EXECINSTR
: *p
= 'X'; break;
5758 case SHF_MERGE
: *p
= 'M'; break;
5759 case SHF_STRINGS
: *p
= 'S'; break;
5760 case SHF_INFO_LINK
: *p
= 'I'; break;
5761 case SHF_LINK_ORDER
: *p
= 'L'; break;
5762 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
5763 case SHF_GROUP
: *p
= 'G'; break;
5764 case SHF_TLS
: *p
= 'T'; break;
5765 case SHF_EXCLUDE
: *p
= 'E'; break;
5766 case SHF_COMPRESSED
: *p
= 'C'; break;
5767 case SHF_GNU_MBIND
: *p
= 'D'; break;
5770 if ((filedata
->file_header
.e_machine
== EM_X86_64
5771 || filedata
->file_header
.e_machine
== EM_L1OM
5772 || filedata
->file_header
.e_machine
== EM_K1OM
)
5773 && flag
== SHF_X86_64_LARGE
)
5775 else if (filedata
->file_header
.e_machine
== EM_ARM
5776 && flag
== SHF_ARM_PURECODE
)
5778 else if (filedata
->file_header
.e_machine
== EM_PPC
5779 && flag
== SHF_PPC_VLE
)
5781 else if (flag
& SHF_MASKOS
)
5784 sh_flags
&= ~ SHF_MASKOS
;
5786 else if (flag
& SHF_MASKPROC
)
5789 sh_flags
&= ~ SHF_MASKPROC
;
5799 if (do_section_details
)
5803 size
-= 5 + field_size
;
5804 if (p
!= buff
+ field_size
+ 4)
5808 warn (_("Internal error: not enough buffer room for section flag info"));
5809 return _("<unknown>");
5815 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
5816 (unsigned long) os_flags
);
5817 p
+= 5 + field_size
;
5821 size
-= 7 + field_size
;
5822 if (p
!= buff
+ field_size
+ 4)
5826 warn (_("Internal error: not enough buffer room for section flag info"));
5827 return _("<unknown>");
5833 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
5834 (unsigned long) proc_flags
);
5835 p
+= 7 + field_size
;
5839 size
-= 10 + field_size
;
5840 if (p
!= buff
+ field_size
+ 4)
5844 warn (_("Internal error: not enough buffer room for section flag info"));
5845 return _("<unknown>");
5851 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
5852 (unsigned long) unknown_flags
);
5853 p
+= 10 + field_size
;
5862 get_compression_header (Elf_Internal_Chdr
*chdr
, unsigned char *buf
, bfd_size_type size
)
5866 Elf32_External_Chdr
*echdr
= (Elf32_External_Chdr
*) buf
;
5868 if (size
< sizeof (* echdr
))
5870 error (_("Compressed section is too small even for a compression header\n"));
5874 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
5875 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
5876 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
5877 return sizeof (*echdr
);
5881 Elf64_External_Chdr
*echdr
= (Elf64_External_Chdr
*) buf
;
5883 if (size
< sizeof (* echdr
))
5885 error (_("Compressed section is too small even for a compression header\n"));
5889 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
5890 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
5891 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
5892 return sizeof (*echdr
);
5897 process_section_headers (Filedata
* filedata
)
5899 Elf_Internal_Shdr
* section
;
5902 filedata
->section_headers
= NULL
;
5904 if (filedata
->file_header
.e_shnum
== 0)
5906 /* PR binutils/12467. */
5907 if (filedata
->file_header
.e_shoff
!= 0)
5909 warn (_("possibly corrupt ELF file header - it has a non-zero"
5910 " section header offset, but no section headers\n"));
5913 else if (do_sections
)
5914 printf (_("\nThere are no sections in this file.\n"));
5919 if (do_sections
&& !do_header
)
5920 printf (ngettext ("There is %d section header, "
5921 "starting at offset 0x%lx:\n",
5922 "There are %d section headers, "
5923 "starting at offset 0x%lx:\n",
5924 filedata
->file_header
.e_shnum
),
5925 filedata
->file_header
.e_shnum
,
5926 (unsigned long) filedata
->file_header
.e_shoff
);
5930 if (! get_32bit_section_headers (filedata
, FALSE
))
5935 if (! get_64bit_section_headers (filedata
, FALSE
))
5939 /* Read in the string table, so that we have names to display. */
5940 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
5941 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
5943 section
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
5945 if (section
->sh_size
!= 0)
5947 filedata
->string_table
= (char *) get_data (NULL
, filedata
, section
->sh_offset
,
5948 1, section
->sh_size
,
5951 filedata
->string_table_length
= filedata
->string_table
!= NULL
? section
->sh_size
: 0;
5955 /* Scan the sections for the dynamic symbol table
5956 and dynamic string table and debug sections. */
5957 dynamic_symbols
= NULL
;
5958 dynamic_strings
= NULL
;
5959 dynamic_syminfo
= NULL
;
5960 symtab_shndx_list
= NULL
;
5962 eh_addr_size
= is_32bit_elf
? 4 : 8;
5963 switch (filedata
->file_header
.e_machine
)
5966 case EM_MIPS_RS3_LE
:
5967 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5968 FDE addresses. However, the ABI also has a semi-official ILP32
5969 variant for which the normal FDE address size rules apply.
5971 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5972 section, where XX is the size of longs in bits. Unfortunately,
5973 earlier compilers provided no way of distinguishing ILP32 objects
5974 from LP64 objects, so if there's any doubt, we should assume that
5975 the official LP64 form is being used. */
5976 if ((filedata
->file_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
5977 && find_section (filedata
, ".gcc_compiled_long32") == NULL
)
5983 switch (filedata
->file_header
.e_flags
& EF_H8_MACH
)
5985 case E_H8_MACH_H8300
:
5986 case E_H8_MACH_H8300HN
:
5987 case E_H8_MACH_H8300SN
:
5988 case E_H8_MACH_H8300SXN
:
5991 case E_H8_MACH_H8300H
:
5992 case E_H8_MACH_H8300S
:
5993 case E_H8_MACH_H8300SX
:
6001 switch (filedata
->file_header
.e_flags
& EF_M32C_CPU_MASK
)
6003 case EF_M32C_CPU_M16C
:
6010 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
6013 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
6014 if (section->sh_entsize != expected_entsize) \
6017 sprintf_vma (buf, section->sh_entsize); \
6018 /* Note: coded this way so that there is a single string for \
6020 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
6021 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
6022 (unsigned) expected_entsize); \
6023 section->sh_entsize = expected_entsize; \
6028 #define CHECK_ENTSIZE(section, i, type) \
6029 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
6030 sizeof (Elf64_External_##type))
6032 for (i
= 0, section
= filedata
->section_headers
;
6033 i
< filedata
->file_header
.e_shnum
;
6036 char * name
= SECTION_NAME (section
);
6038 if (section
->sh_type
== SHT_DYNSYM
)
6040 if (dynamic_symbols
!= NULL
)
6042 error (_("File contains multiple dynamic symbol tables\n"));
6046 CHECK_ENTSIZE (section
, i
, Sym
);
6047 dynamic_symbols
= GET_ELF_SYMBOLS (filedata
, section
, & num_dynamic_syms
);
6049 else if (section
->sh_type
== SHT_STRTAB
6050 && streq (name
, ".dynstr"))
6052 if (dynamic_strings
!= NULL
)
6054 error (_("File contains multiple dynamic string tables\n"));
6058 dynamic_strings
= (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6059 1, section
->sh_size
,
6060 _("dynamic strings"));
6061 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : section
->sh_size
;
6063 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
6065 elf_section_list
* entry
= xmalloc (sizeof * entry
);
6067 entry
->hdr
= section
;
6068 entry
->next
= symtab_shndx_list
;
6069 symtab_shndx_list
= entry
;
6071 else if (section
->sh_type
== SHT_SYMTAB
)
6072 CHECK_ENTSIZE (section
, i
, Sym
);
6073 else if (section
->sh_type
== SHT_GROUP
)
6074 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
6075 else if (section
->sh_type
== SHT_REL
)
6076 CHECK_ENTSIZE (section
, i
, Rel
);
6077 else if (section
->sh_type
== SHT_RELA
)
6078 CHECK_ENTSIZE (section
, i
, Rela
);
6079 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
6080 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
6081 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
6082 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
6083 || do_debug_addr
|| do_debug_cu_index
|| do_debug_links
)
6084 && (const_strneq (name
, ".debug_")
6085 || const_strneq (name
, ".zdebug_")))
6088 name
+= sizeof (".zdebug_") - 1;
6090 name
+= sizeof (".debug_") - 1;
6093 || (do_debug_info
&& const_strneq (name
, "info"))
6094 || (do_debug_info
&& const_strneq (name
, "types"))
6095 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
6096 || (do_debug_lines
&& strcmp (name
, "line") == 0)
6097 || (do_debug_lines
&& const_strneq (name
, "line."))
6098 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
6099 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
6100 || (do_debug_pubnames
&& const_strneq (name
, "gnu_pubnames"))
6101 || (do_debug_pubtypes
&& const_strneq (name
, "gnu_pubtypes"))
6102 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
6103 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
6104 || (do_debug_ranges
&& const_strneq (name
, "rnglists"))
6105 || (do_debug_frames
&& const_strneq (name
, "frame"))
6106 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
6107 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
6108 || (do_debug_str
&& const_strneq (name
, "str"))
6109 || (do_debug_loc
&& const_strneq (name
, "loc"))
6110 || (do_debug_loc
&& const_strneq (name
, "loclists"))
6111 || (do_debug_addr
&& const_strneq (name
, "addr"))
6112 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
6113 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
6115 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6117 /* Linkonce section to be combined with .debug_info at link time. */
6118 else if ((do_debugging
|| do_debug_info
)
6119 && const_strneq (name
, ".gnu.linkonce.wi."))
6120 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6121 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
6122 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6123 else if (do_gdb_index
&& (streq (name
, ".gdb_index")
6124 || streq (name
, ".debug_names")))
6125 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6126 /* Trace sections for Itanium VMS. */
6127 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
6128 || do_trace_aranges
)
6129 && const_strneq (name
, ".trace_"))
6131 name
+= sizeof (".trace_") - 1;
6134 || (do_trace_info
&& streq (name
, "info"))
6135 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
6136 || (do_trace_aranges
&& streq (name
, "aranges"))
6138 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6140 else if ((do_debugging
|| do_debug_links
)
6141 && (const_strneq (name
, ".gnu_debuglink")
6142 || const_strneq (name
, ".gnu_debugaltlink")))
6143 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6149 if (filedata
->file_header
.e_shnum
> 1)
6150 printf (_("\nSection Headers:\n"));
6152 printf (_("\nSection Header:\n"));
6156 if (do_section_details
)
6158 printf (_(" [Nr] Name\n"));
6159 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
6163 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
6167 if (do_section_details
)
6169 printf (_(" [Nr] Name\n"));
6170 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
6174 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
6178 if (do_section_details
)
6180 printf (_(" [Nr] Name\n"));
6181 printf (_(" Type Address Offset Link\n"));
6182 printf (_(" Size EntSize Info Align\n"));
6186 printf (_(" [Nr] Name Type Address Offset\n"));
6187 printf (_(" Size EntSize Flags Link Info Align\n"));
6191 if (do_section_details
)
6192 printf (_(" Flags\n"));
6194 for (i
= 0, section
= filedata
->section_headers
;
6195 i
< filedata
->file_header
.e_shnum
;
6198 /* Run some sanity checks on the section header. */
6200 /* Check the sh_link field. */
6201 switch (section
->sh_type
)
6203 case SHT_SYMTAB_SHNDX
:
6207 case SHT_GNU_versym
:
6210 if (section
->sh_link
< 1
6211 || section
->sh_link
>= filedata
->file_header
.e_shnum
6212 || (filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_SYMTAB
6213 && filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_DYNSYM
))
6214 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6215 i
, section
->sh_link
);
6221 case SHT_GNU_verneed
:
6222 case SHT_GNU_verdef
:
6223 case SHT_GNU_LIBLIST
:
6224 if (section
->sh_link
< 1
6225 || section
->sh_link
>= filedata
->file_header
.e_shnum
6226 || filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_STRTAB
)
6227 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6228 i
, section
->sh_link
);
6231 case SHT_INIT_ARRAY
:
6232 case SHT_FINI_ARRAY
:
6233 case SHT_PREINIT_ARRAY
:
6234 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6235 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6236 i
, section
->sh_link
);
6240 /* FIXME: Add support for target specific section types. */
6241 #if 0 /* Currently we do not check other section types as there are too
6242 many special cases. Stab sections for example have a type
6243 of SHT_PROGBITS but an sh_link field that links to the .stabstr
6245 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6246 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6247 i
, section
->sh_link
);
6252 /* Check the sh_info field. */
6253 switch (section
->sh_type
)
6257 if (section
->sh_info
< 1
6258 || section
->sh_info
>= filedata
->file_header
.e_shnum
6259 || (filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PROGBITS
6260 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOBITS
6261 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOTE
6262 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_INIT_ARRAY
6263 /* FIXME: Are other section types valid ? */
6264 && filedata
->section_headers
[section
->sh_info
].sh_type
< SHT_LOOS
))
6266 if (section
->sh_info
== 0
6267 && (filedata
->file_header
.e_type
== ET_EXEC
6268 || filedata
->file_header
.e_type
== ET_DYN
6269 /* These next two tests may be redundant, but
6270 they have been left in for paranoia's sake. */
6271 || streq (SECTION_NAME (section
), ".rel.dyn")
6272 || streq (SECTION_NAME (section
), ".rela.dyn")))
6273 /* Dynamic relocations apply to segments, not sections, so
6274 they do not need an sh_info value. */
6277 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6278 i
, section
->sh_info
);
6284 case SHT_SYMTAB_SHNDX
:
6285 case SHT_INIT_ARRAY
:
6286 case SHT_FINI_ARRAY
:
6287 case SHT_PREINIT_ARRAY
:
6288 if (section
->sh_info
!= 0)
6289 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6290 i
, section
->sh_info
);
6296 /* A symbol index - we assume that it is valid. */
6300 /* FIXME: Add support for target specific section types. */
6301 if (section
->sh_type
== SHT_NOBITS
)
6302 /* NOBITS section headers with non-zero sh_info fields can be
6303 created when a binary is stripped of everything but its debug
6304 information. The stripped sections have their headers
6305 preserved but their types set to SHT_NOBITS. So do not check
6306 this type of section. */
6308 else if (section
->sh_flags
& SHF_INFO_LINK
)
6310 if (section
->sh_info
< 1 || section
->sh_info
>= filedata
->file_header
.e_shnum
)
6311 warn (_("[%2u]: Expected link to another section in info field"), i
);
6313 else if (section
->sh_type
< SHT_LOOS
6314 && (section
->sh_flags
& SHF_GNU_MBIND
) == 0
6315 && section
->sh_info
!= 0)
6316 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6317 i
, section
->sh_info
);
6321 /* Check the sh_size field. */
6322 if (section
->sh_size
> filedata
->file_size
6323 && section
->sh_type
!= SHT_NOBITS
6324 && section
->sh_type
!= SHT_NULL
6325 && section
->sh_type
< SHT_LOOS
)
6326 warn (_("Size of section %u is larger than the entire file!\n"), i
);
6328 printf (" [%2u] ", i
);
6329 if (do_section_details
)
6330 printf ("%s\n ", printable_section_name (filedata
, section
));
6332 print_symbol (-17, SECTION_NAME (section
));
6334 printf (do_wide
? " %-15s " : " %-15.15s ",
6335 get_section_type_name (filedata
, section
->sh_type
));
6339 const char * link_too_big
= NULL
;
6341 print_vma (section
->sh_addr
, LONG_HEX
);
6343 printf ( " %6.6lx %6.6lx %2.2lx",
6344 (unsigned long) section
->sh_offset
,
6345 (unsigned long) section
->sh_size
,
6346 (unsigned long) section
->sh_entsize
);
6348 if (do_section_details
)
6349 fputs (" ", stdout
);
6351 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6353 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
6356 /* The sh_link value is out of range. Normally this indicates
6357 an error but it can have special values in Solaris binaries. */
6358 switch (filedata
->file_header
.e_machine
)
6365 case EM_OLD_SPARCV9
:
6366 case EM_SPARC32PLUS
:
6369 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
6370 link_too_big
= "BEFORE";
6371 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
6372 link_too_big
= "AFTER";
6379 if (do_section_details
)
6381 if (link_too_big
!= NULL
&& * link_too_big
)
6382 printf ("<%s> ", link_too_big
);
6384 printf ("%2u ", section
->sh_link
);
6385 printf ("%3u %2lu\n", section
->sh_info
,
6386 (unsigned long) section
->sh_addralign
);
6389 printf ("%2u %3u %2lu\n",
6392 (unsigned long) section
->sh_addralign
);
6394 if (link_too_big
&& ! * link_too_big
)
6395 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6396 i
, section
->sh_link
);
6400 print_vma (section
->sh_addr
, LONG_HEX
);
6402 if ((long) section
->sh_offset
== section
->sh_offset
)
6403 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
6407 print_vma (section
->sh_offset
, LONG_HEX
);
6410 if ((unsigned long) section
->sh_size
== section
->sh_size
)
6411 printf (" %6.6lx", (unsigned long) section
->sh_size
);
6415 print_vma (section
->sh_size
, LONG_HEX
);
6418 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
6419 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
6423 print_vma (section
->sh_entsize
, LONG_HEX
);
6426 if (do_section_details
)
6427 fputs (" ", stdout
);
6429 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6431 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
6433 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
6434 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
6437 print_vma (section
->sh_addralign
, DEC
);
6441 else if (do_section_details
)
6443 printf (" %-15.15s ",
6444 get_section_type_name (filedata
, section
->sh_type
));
6445 print_vma (section
->sh_addr
, LONG_HEX
);
6446 if ((long) section
->sh_offset
== section
->sh_offset
)
6447 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
6451 print_vma (section
->sh_offset
, LONG_HEX
);
6453 printf (" %u\n ", section
->sh_link
);
6454 print_vma (section
->sh_size
, LONG_HEX
);
6456 print_vma (section
->sh_entsize
, LONG_HEX
);
6458 printf (" %-16u %lu\n",
6460 (unsigned long) section
->sh_addralign
);
6465 print_vma (section
->sh_addr
, LONG_HEX
);
6466 if ((long) section
->sh_offset
== section
->sh_offset
)
6467 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
6471 print_vma (section
->sh_offset
, LONG_HEX
);
6474 print_vma (section
->sh_size
, LONG_HEX
);
6476 print_vma (section
->sh_entsize
, LONG_HEX
);
6478 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6480 printf (" %2u %3u %lu\n",
6483 (unsigned long) section
->sh_addralign
);
6486 if (do_section_details
)
6488 printf (" %s\n", get_elf_section_flags (filedata
, section
->sh_flags
));
6489 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
6491 /* Minimum section size is 12 bytes for 32-bit compression
6492 header + 12 bytes for compressed data header. */
6493 unsigned char buf
[24];
6495 assert (sizeof (buf
) >= sizeof (Elf64_External_Chdr
));
6496 if (get_data (&buf
, filedata
, section
->sh_offset
, 1,
6497 sizeof (buf
), _("compression header")))
6499 Elf_Internal_Chdr chdr
;
6501 (void) get_compression_header (&chdr
, buf
, sizeof (buf
));
6503 if (chdr
.ch_type
== ELFCOMPRESS_ZLIB
)
6506 printf (_(" [<unknown>: 0x%x], "),
6508 print_vma (chdr
.ch_size
, LONG_HEX
);
6509 printf (", %lu\n", (unsigned long) chdr
.ch_addralign
);
6515 if (!do_section_details
)
6517 /* The ordering of the letters shown here matches the ordering of the
6518 corresponding SHF_xxx values, and hence the order in which these
6519 letters will be displayed to the user. */
6520 printf (_("Key to Flags:\n\
6521 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6522 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6523 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
6524 if (filedata
->file_header
.e_machine
== EM_X86_64
6525 || filedata
->file_header
.e_machine
== EM_L1OM
6526 || filedata
->file_header
.e_machine
== EM_K1OM
)
6527 printf (_("l (large), "));
6528 else if (filedata
->file_header
.e_machine
== EM_ARM
)
6529 printf (_("y (purecode), "));
6530 else if (filedata
->file_header
.e_machine
== EM_PPC
)
6531 printf (_("v (VLE), "));
6532 printf ("p (processor specific)\n");
6539 get_group_flags (unsigned int flags
)
6541 static char buff
[128];
6545 else if (flags
== GRP_COMDAT
)
6548 snprintf (buff
, 14, _("[0x%x: "), flags
);
6550 flags
&= ~ GRP_COMDAT
;
6551 if (flags
& GRP_MASKOS
)
6553 strcat (buff
, "<OS specific>");
6554 flags
&= ~ GRP_MASKOS
;
6557 if (flags
& GRP_MASKPROC
)
6559 strcat (buff
, "<PROC specific>");
6560 flags
&= ~ GRP_MASKPROC
;
6564 strcat (buff
, "<unknown>");
6571 process_section_groups (Filedata
* filedata
)
6573 Elf_Internal_Shdr
* section
;
6575 struct group
* group
;
6576 Elf_Internal_Shdr
* symtab_sec
;
6577 Elf_Internal_Shdr
* strtab_sec
;
6578 Elf_Internal_Sym
* symtab
;
6579 unsigned long num_syms
;
6583 /* Don't process section groups unless needed. */
6584 if (!do_unwind
&& !do_section_groups
)
6587 if (filedata
->file_header
.e_shnum
== 0)
6589 if (do_section_groups
)
6590 printf (_("\nThere are no sections to group in this file.\n"));
6595 if (filedata
->section_headers
== NULL
)
6597 error (_("Section headers are not available!\n"));
6598 /* PR 13622: This can happen with a corrupt ELF header. */
6602 section_headers_groups
= (struct group
**) calloc (filedata
->file_header
.e_shnum
,
6603 sizeof (struct group
*));
6605 if (section_headers_groups
== NULL
)
6607 error (_("Out of memory reading %u section group headers\n"),
6608 filedata
->file_header
.e_shnum
);
6612 /* Scan the sections for the group section. */
6614 for (i
= 0, section
= filedata
->section_headers
;
6615 i
< filedata
->file_header
.e_shnum
;
6617 if (section
->sh_type
== SHT_GROUP
)
6620 if (group_count
== 0)
6622 if (do_section_groups
)
6623 printf (_("\nThere are no section groups in this file.\n"));
6628 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
6630 if (section_groups
== NULL
)
6632 error (_("Out of memory reading %lu groups\n"),
6633 (unsigned long) group_count
);
6643 for (i
= 0, section
= filedata
->section_headers
, group
= section_groups
;
6644 i
< filedata
->file_header
.e_shnum
;
6647 if (section
->sh_type
== SHT_GROUP
)
6649 const char * name
= printable_section_name (filedata
, section
);
6650 const char * group_name
;
6651 unsigned char * start
;
6652 unsigned char * indices
;
6653 unsigned int entry
, j
, size
;
6654 Elf_Internal_Shdr
* sec
;
6655 Elf_Internal_Sym
* sym
;
6657 /* Get the symbol table. */
6658 if (section
->sh_link
>= filedata
->file_header
.e_shnum
6659 || ((sec
= filedata
->section_headers
+ section
->sh_link
)->sh_type
6662 error (_("Bad sh_link in group section `%s'\n"), name
);
6666 if (symtab_sec
!= sec
)
6671 symtab
= GET_ELF_SYMBOLS (filedata
, symtab_sec
, & num_syms
);
6676 error (_("Corrupt header in group section `%s'\n"), name
);
6680 if (section
->sh_info
>= num_syms
)
6682 error (_("Bad sh_info in group section `%s'\n"), name
);
6686 sym
= symtab
+ section
->sh_info
;
6688 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
6690 if (sym
->st_shndx
== 0
6691 || sym
->st_shndx
>= filedata
->file_header
.e_shnum
)
6693 error (_("Bad sh_info in group section `%s'\n"), name
);
6697 group_name
= SECTION_NAME (filedata
->section_headers
+ sym
->st_shndx
);
6706 /* Get the string table. */
6707 if (symtab_sec
->sh_link
>= filedata
->file_header
.e_shnum
)
6716 != (sec
= filedata
->section_headers
+ symtab_sec
->sh_link
))
6722 strtab
= (char *) get_data (NULL
, filedata
, strtab_sec
->sh_offset
,
6723 1, strtab_sec
->sh_size
,
6725 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
6727 group_name
= sym
->st_name
< strtab_size
6728 ? strtab
+ sym
->st_name
: _("<corrupt>");
6731 /* PR 17531: file: loop. */
6732 if (section
->sh_entsize
> section
->sh_size
)
6734 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6735 printable_section_name (filedata
, section
),
6736 (unsigned long) section
->sh_entsize
,
6737 (unsigned long) section
->sh_size
);
6741 start
= (unsigned char *) get_data (NULL
, filedata
, section
->sh_offset
,
6742 1, section
->sh_size
,
6748 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
6749 entry
= byte_get (indices
, 4);
6752 if (do_section_groups
)
6754 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6755 get_group_flags (entry
), i
, name
, group_name
, size
);
6757 printf (_(" [Index] Name\n"));
6760 group
->group_index
= i
;
6762 for (j
= 0; j
< size
; j
++)
6764 struct group_list
* g
;
6766 entry
= byte_get (indices
, 4);
6769 if (entry
>= filedata
->file_header
.e_shnum
)
6771 static unsigned num_group_errors
= 0;
6773 if (num_group_errors
++ < 10)
6775 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6776 entry
, i
, filedata
->file_header
.e_shnum
- 1);
6777 if (num_group_errors
== 10)
6778 warn (_("Further error messages about overlarge group section indicies suppressed\n"));
6783 if (section_headers_groups
[entry
] != NULL
)
6787 static unsigned num_errs
= 0;
6789 if (num_errs
++ < 10)
6791 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6793 section_headers_groups
[entry
]->group_index
);
6795 warn (_("Further error messages about already contained group sections suppressed\n"));
6801 /* Intel C/C++ compiler may put section 0 in a
6802 section group. We just warn it the first time
6803 and ignore it afterwards. */
6804 static bfd_boolean warned
= FALSE
;
6807 error (_("section 0 in group section [%5u]\n"),
6808 section_headers_groups
[entry
]->group_index
);
6814 section_headers_groups
[entry
] = group
;
6816 if (do_section_groups
)
6818 sec
= filedata
->section_headers
+ entry
;
6819 printf (" [%5u] %s\n", entry
, printable_section_name (filedata
, sec
));
6822 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
6823 g
->section_index
= entry
;
6824 g
->next
= group
->root
;
6842 /* Data used to display dynamic fixups. */
6844 struct ia64_vms_dynfixup
6846 bfd_vma needed_ident
; /* Library ident number. */
6847 bfd_vma needed
; /* Index in the dstrtab of the library name. */
6848 bfd_vma fixup_needed
; /* Index of the library. */
6849 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
6850 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
6853 /* Data used to display dynamic relocations. */
6855 struct ia64_vms_dynimgrela
6857 bfd_vma img_rela_cnt
; /* Number of relocations. */
6858 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
6861 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6865 dump_ia64_vms_dynamic_fixups (Filedata
* filedata
,
6866 struct ia64_vms_dynfixup
* fixup
,
6867 const char * strtab
,
6868 unsigned int strtab_sz
)
6870 Elf64_External_VMS_IMAGE_FIXUP
* imfs
;
6872 const char * lib_name
;
6874 imfs
= get_data (NULL
, filedata
, dynamic_addr
+ fixup
->fixup_rela_off
,
6875 1, fixup
->fixup_rela_cnt
* sizeof (*imfs
),
6876 _("dynamic section image fixups"));
6880 if (fixup
->needed
< strtab_sz
)
6881 lib_name
= strtab
+ fixup
->needed
;
6884 warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
6885 (unsigned long) fixup
->needed
);
6888 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6889 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
6891 (_("Seg Offset Type SymVec DataType\n"));
6893 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
6898 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
6899 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
6900 type
= BYTE_GET (imfs
[i
].type
);
6901 rtype
= elf_ia64_reloc_type (type
);
6903 printf (" 0x%08x ", type
);
6905 printf (" %-32s ", rtype
);
6906 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
6907 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
6914 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
6917 dump_ia64_vms_dynamic_relocs (Filedata
* filedata
, struct ia64_vms_dynimgrela
*imgrela
)
6919 Elf64_External_VMS_IMAGE_RELA
*imrs
;
6922 imrs
= get_data (NULL
, filedata
, dynamic_addr
+ imgrela
->img_rela_off
,
6923 1, imgrela
->img_rela_cnt
* sizeof (*imrs
),
6924 _("dynamic section image relocations"));
6928 printf (_("\nImage relocs\n"));
6930 (_("Seg Offset Type Addend Seg Sym Off\n"));
6932 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
6937 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
6938 printf ("%08" BFD_VMA_FMT
"x ",
6939 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
6940 type
= BYTE_GET (imrs
[i
].type
);
6941 rtype
= elf_ia64_reloc_type (type
);
6943 printf ("0x%08x ", type
);
6945 printf ("%-31s ", rtype
);
6946 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
6947 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
6948 printf ("%08" BFD_VMA_FMT
"x\n",
6949 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
6956 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
6959 process_ia64_vms_dynamic_relocs (Filedata
* filedata
)
6961 struct ia64_vms_dynfixup fixup
;
6962 struct ia64_vms_dynimgrela imgrela
;
6963 Elf_Internal_Dyn
*entry
;
6964 bfd_vma strtab_off
= 0;
6965 bfd_vma strtab_sz
= 0;
6966 char *strtab
= NULL
;
6967 bfd_boolean res
= TRUE
;
6969 memset (&fixup
, 0, sizeof (fixup
));
6970 memset (&imgrela
, 0, sizeof (imgrela
));
6972 /* Note: the order of the entries is specified by the OpenVMS specs. */
6973 for (entry
= dynamic_section
;
6974 entry
< dynamic_section
+ dynamic_nent
;
6977 switch (entry
->d_tag
)
6979 case DT_IA_64_VMS_STRTAB_OFFSET
:
6980 strtab_off
= entry
->d_un
.d_val
;
6983 strtab_sz
= entry
->d_un
.d_val
;
6985 strtab
= get_data (NULL
, filedata
, dynamic_addr
+ strtab_off
,
6986 1, strtab_sz
, _("dynamic string section"));
6989 case DT_IA_64_VMS_NEEDED_IDENT
:
6990 fixup
.needed_ident
= entry
->d_un
.d_val
;
6993 fixup
.needed
= entry
->d_un
.d_val
;
6995 case DT_IA_64_VMS_FIXUP_NEEDED
:
6996 fixup
.fixup_needed
= entry
->d_un
.d_val
;
6998 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
6999 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
7001 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
7002 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
7003 if (! dump_ia64_vms_dynamic_fixups (filedata
, &fixup
, strtab
, strtab_sz
))
7006 case DT_IA_64_VMS_IMG_RELA_CNT
:
7007 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
7009 case DT_IA_64_VMS_IMG_RELA_OFF
:
7010 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
7011 if (! dump_ia64_vms_dynamic_relocs (filedata
, &imgrela
))
7033 dynamic_relocations
[] =
7035 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
7036 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
7037 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
7040 /* Process the reloc section. */
7043 process_relocs (Filedata
* filedata
)
7045 unsigned long rel_size
;
7046 unsigned long rel_offset
;
7051 if (do_using_dynamic
)
7055 bfd_boolean has_dynamic_reloc
;
7058 has_dynamic_reloc
= FALSE
;
7060 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7062 is_rela
= dynamic_relocations
[i
].rela
;
7063 name
= dynamic_relocations
[i
].name
;
7064 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
7065 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
7068 has_dynamic_reloc
= TRUE
;
7070 if (is_rela
== UNKNOWN
)
7072 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
7073 switch (dynamic_info
[DT_PLTREL
])
7087 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7088 name
, rel_offset
, rel_size
);
7090 dump_relocations (filedata
,
7091 offset_from_vma (filedata
, rel_offset
, rel_size
),
7093 dynamic_symbols
, num_dynamic_syms
,
7094 dynamic_strings
, dynamic_strings_length
,
7095 is_rela
, TRUE
/* is_dynamic */);
7099 if (is_ia64_vms (filedata
))
7100 if (process_ia64_vms_dynamic_relocs (filedata
))
7101 has_dynamic_reloc
= TRUE
;
7103 if (! has_dynamic_reloc
)
7104 printf (_("\nThere are no dynamic relocations in this file.\n"));
7108 Elf_Internal_Shdr
* section
;
7110 bfd_boolean found
= FALSE
;
7112 for (i
= 0, section
= filedata
->section_headers
;
7113 i
< filedata
->file_header
.e_shnum
;
7116 if ( section
->sh_type
!= SHT_RELA
7117 && section
->sh_type
!= SHT_REL
)
7120 rel_offset
= section
->sh_offset
;
7121 rel_size
= section
->sh_size
;
7125 Elf_Internal_Shdr
* strsec
;
7127 unsigned long num_rela
;
7129 printf (_("\nRelocation section "));
7131 if (filedata
->string_table
== NULL
)
7132 printf ("%d", section
->sh_name
);
7134 printf ("'%s'", printable_section_name (filedata
, section
));
7136 num_rela
= rel_size
/ section
->sh_entsize
;
7137 printf (ngettext (" at offset 0x%lx contains %lu entry:\n",
7138 " at offset 0x%lx contains %lu entries:\n",
7140 rel_offset
, num_rela
);
7142 is_rela
= section
->sh_type
== SHT_RELA
;
7144 if (section
->sh_link
!= 0
7145 && section
->sh_link
< filedata
->file_header
.e_shnum
)
7147 Elf_Internal_Shdr
* symsec
;
7148 Elf_Internal_Sym
* symtab
;
7149 unsigned long nsyms
;
7150 unsigned long strtablen
= 0;
7151 char * strtab
= NULL
;
7153 symsec
= filedata
->section_headers
+ section
->sh_link
;
7154 if (symsec
->sh_type
!= SHT_SYMTAB
7155 && symsec
->sh_type
!= SHT_DYNSYM
)
7158 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & nsyms
);
7163 if (symsec
->sh_link
!= 0
7164 && symsec
->sh_link
< filedata
->file_header
.e_shnum
)
7166 strsec
= filedata
->section_headers
+ symsec
->sh_link
;
7168 strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
7171 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
7174 dump_relocations (filedata
, rel_offset
, rel_size
,
7175 symtab
, nsyms
, strtab
, strtablen
,
7177 symsec
->sh_type
== SHT_DYNSYM
);
7183 dump_relocations (filedata
, rel_offset
, rel_size
,
7184 NULL
, 0, NULL
, 0, is_rela
,
7185 FALSE
/* is_dynamic */);
7193 /* Users sometimes forget the -D option, so try to be helpful. */
7194 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7196 if (dynamic_info
[dynamic_relocations
[i
].size
])
7198 printf (_("\nThere are no static relocations in this file."));
7199 printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
7204 if (i
== ARRAY_SIZE (dynamic_relocations
))
7205 printf (_("\nThere are no relocations in this file.\n"));
7212 /* An absolute address consists of a section and an offset. If the
7213 section is NULL, the offset itself is the address, otherwise, the
7214 address equals to LOAD_ADDRESS(section) + offset. */
7218 unsigned short section
;
7222 #define ABSADDR(a) \
7224 ? filedata->section_headers [(a).section].sh_addr + (a).offset \
7227 /* Find the nearest symbol at or below ADDR. Returns the symbol
7228 name, if found, and the offset from the symbol to ADDR. */
7231 find_symbol_for_address (Filedata
* filedata
,
7232 Elf_Internal_Sym
* symtab
,
7233 unsigned long nsyms
,
7234 const char * strtab
,
7235 unsigned long strtab_size
,
7236 struct absaddr addr
,
7237 const char ** symname
,
7240 bfd_vma dist
= 0x100000;
7241 Elf_Internal_Sym
* sym
;
7242 Elf_Internal_Sym
* beg
;
7243 Elf_Internal_Sym
* end
;
7244 Elf_Internal_Sym
* best
= NULL
;
7246 REMOVE_ARCH_BITS (addr
.offset
);
7248 end
= symtab
+ nsyms
;
7254 sym
= beg
+ (end
- beg
) / 2;
7256 value
= sym
->st_value
;
7257 REMOVE_ARCH_BITS (value
);
7259 if (sym
->st_name
!= 0
7260 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
7261 && addr
.offset
>= value
7262 && addr
.offset
- value
< dist
)
7265 dist
= addr
.offset
- value
;
7270 if (addr
.offset
< value
)
7278 *symname
= (best
->st_name
>= strtab_size
7279 ? _("<corrupt>") : strtab
+ best
->st_name
);
7285 *offset
= addr
.offset
;
7288 static /* signed */ int
7289 symcmp (const void *p
, const void *q
)
7291 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
7292 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
7294 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
7297 /* Process the unwind section. */
7299 #include "unwind-ia64.h"
7301 struct ia64_unw_table_entry
7303 struct absaddr start
;
7305 struct absaddr info
;
7308 struct ia64_unw_aux_info
7310 struct ia64_unw_table_entry
* table
; /* Unwind table. */
7311 unsigned long table_len
; /* Length of unwind table. */
7312 unsigned char * info
; /* Unwind info. */
7313 unsigned long info_size
; /* Size of unwind info. */
7314 bfd_vma info_addr
; /* Starting address of unwind info. */
7315 bfd_vma seg_base
; /* Starting address of segment. */
7316 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7317 unsigned long nsyms
; /* Number of symbols. */
7318 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7319 unsigned long nfuns
; /* Number of entries in funtab. */
7320 char * strtab
; /* The string table. */
7321 unsigned long strtab_size
; /* Size of string table. */
7325 dump_ia64_unwind (Filedata
* filedata
, struct ia64_unw_aux_info
* aux
)
7327 struct ia64_unw_table_entry
* tp
;
7328 unsigned long j
, nfuns
;
7330 bfd_boolean res
= TRUE
;
7332 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7333 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7334 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7335 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7337 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7339 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7343 const unsigned char * dp
;
7344 const unsigned char * head
;
7345 const unsigned char * end
;
7346 const char * procname
;
7348 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7349 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
7351 fputs ("\n<", stdout
);
7355 fputs (procname
, stdout
);
7358 printf ("+%lx", (unsigned long) offset
);
7361 fputs (">: [", stdout
);
7362 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7363 fputc ('-', stdout
);
7364 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7365 printf ("], info at +0x%lx\n",
7366 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
7368 /* PR 17531: file: 86232b32. */
7369 if (aux
->info
== NULL
)
7372 /* PR 17531: file: 0997b4d1. */
7373 if ((ABSADDR (tp
->info
) - aux
->info_addr
) >= aux
->info_size
)
7375 warn (_("Invalid offset %lx in table entry %ld\n"),
7376 (long) tp
->info
.offset
, (long) (tp
- aux
->table
));
7381 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
7382 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
7384 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7385 (unsigned) UNW_VER (stamp
),
7386 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
7387 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
7388 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
7389 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
7391 if (UNW_VER (stamp
) != 1)
7393 printf (_("\tUnknown version.\n"));
7398 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
7399 /* PR 17531: file: 16ceda89. */
7400 if (end
> aux
->info
+ aux
->info_size
)
7401 end
= aux
->info
+ aux
->info_size
;
7402 for (dp
= head
+ 8; dp
< end
;)
7403 dp
= unw_decode (dp
, in_body
, & in_body
, end
);
7412 slurp_ia64_unwind_table (Filedata
* filedata
,
7413 struct ia64_unw_aux_info
* aux
,
7414 Elf_Internal_Shdr
* sec
)
7416 unsigned long size
, nrelas
, i
;
7417 Elf_Internal_Phdr
* seg
;
7418 struct ia64_unw_table_entry
* tep
;
7419 Elf_Internal_Shdr
* relsec
;
7420 Elf_Internal_Rela
* rela
;
7421 Elf_Internal_Rela
* rp
;
7422 unsigned char * table
;
7424 Elf_Internal_Sym
* sym
;
7425 const char * relname
;
7429 /* First, find the starting address of the segment that includes
7432 if (filedata
->file_header
.e_phnum
)
7434 if (! get_program_headers (filedata
))
7437 for (seg
= filedata
->program_headers
;
7438 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
7441 if (seg
->p_type
!= PT_LOAD
)
7444 if (sec
->sh_addr
>= seg
->p_vaddr
7445 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7447 aux
->seg_base
= seg
->p_vaddr
;
7453 /* Second, build the unwind table from the contents of the unwind section: */
7454 size
= sec
->sh_size
;
7455 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
7460 aux
->table_len
= size
/ (3 * eh_addr_size
);
7461 aux
->table
= (struct ia64_unw_table_entry
*)
7462 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
7465 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
7467 tep
->start
.section
= SHN_UNDEF
;
7468 tep
->end
.section
= SHN_UNDEF
;
7469 tep
->info
.section
= SHN_UNDEF
;
7470 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7471 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7472 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7473 tep
->start
.offset
+= aux
->seg_base
;
7474 tep
->end
.offset
+= aux
->seg_base
;
7475 tep
->info
.offset
+= aux
->seg_base
;
7479 /* Third, apply any relocations to the unwind table: */
7480 for (relsec
= filedata
->section_headers
;
7481 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
7484 if (relsec
->sh_type
!= SHT_RELA
7485 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
7486 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
7489 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
7498 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7500 relname
= elf_ia64_reloc_type (get_reloc_type (filedata
, rp
->r_info
));
7501 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
7503 /* PR 17531: file: 9fa67536. */
7504 if (relname
== NULL
)
7506 warn (_("Skipping unknown relocation type: %u\n"),
7507 get_reloc_type (filedata
, rp
->r_info
));
7511 if (! const_strneq (relname
, "R_IA64_SEGREL"))
7513 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
7517 i
= rp
->r_offset
/ (3 * eh_addr_size
);
7519 /* PR 17531: file: 5bc8d9bf. */
7520 if (i
>= aux
->table_len
)
7522 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
7526 switch (rp
->r_offset
/ eh_addr_size
% 3)
7529 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7530 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
7533 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7534 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
7537 aux
->table
[i
].info
.section
= sym
->st_shndx
;
7538 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
7552 ia64_process_unwind (Filedata
* filedata
)
7554 Elf_Internal_Shdr
* sec
;
7555 Elf_Internal_Shdr
* unwsec
= NULL
;
7556 Elf_Internal_Shdr
* strsec
;
7557 unsigned long i
, unwcount
= 0, unwstart
= 0;
7558 struct ia64_unw_aux_info aux
;
7559 bfd_boolean res
= TRUE
;
7561 memset (& aux
, 0, sizeof (aux
));
7563 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
7565 if (sec
->sh_type
== SHT_SYMTAB
7566 && sec
->sh_link
< filedata
->file_header
.e_shnum
)
7568 aux
.symtab
= GET_ELF_SYMBOLS (filedata
, sec
, & aux
.nsyms
);
7570 strsec
= filedata
->section_headers
+ sec
->sh_link
;
7571 if (aux
.strtab
!= NULL
)
7573 error (_("Multiple auxillary string tables encountered\n"));
7577 aux
.strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
7580 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7582 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7587 printf (_("\nThere are no unwind sections in this file.\n"));
7589 while (unwcount
-- > 0)
7594 for (i
= unwstart
, sec
= filedata
->section_headers
+ unwstart
, unwsec
= NULL
;
7595 i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
7596 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7601 /* We have already counted the number of SHT_IA64_UNWIND
7602 sections so the loop above should never fail. */
7603 assert (unwsec
!= NULL
);
7606 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
7608 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
7610 /* We need to find which section group it is in. */
7611 struct group_list
* g
;
7613 if (section_headers_groups
== NULL
7614 || section_headers_groups
[i
] == NULL
)
7615 i
= filedata
->file_header
.e_shnum
;
7618 g
= section_headers_groups
[i
]->root
;
7620 for (; g
!= NULL
; g
= g
->next
)
7622 sec
= filedata
->section_headers
+ g
->section_index
;
7624 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
7629 i
= filedata
->file_header
.e_shnum
;
7632 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
7634 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
7635 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
7636 suffix
= SECTION_NAME (unwsec
) + len
;
7637 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
;
7639 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
7640 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7645 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7646 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
7647 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
7648 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
7650 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
7651 suffix
= SECTION_NAME (unwsec
) + len
;
7652 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
;
7654 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
7655 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7659 if (i
== filedata
->file_header
.e_shnum
)
7661 printf (_("\nCould not find unwind info section for "));
7663 if (filedata
->string_table
== NULL
)
7664 printf ("%d", unwsec
->sh_name
);
7666 printf ("'%s'", printable_section_name (filedata
, unwsec
));
7670 aux
.info_addr
= sec
->sh_addr
;
7671 aux
.info
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1,
7674 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
7676 printf (_("\nUnwind section "));
7678 if (filedata
->string_table
== NULL
)
7679 printf ("%d", unwsec
->sh_name
);
7681 printf ("'%s'", printable_section_name (filedata
, unwsec
));
7683 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7684 (unsigned long) unwsec
->sh_offset
,
7685 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
7687 if (slurp_ia64_unwind_table (filedata
, & aux
, unwsec
)
7688 && aux
.table_len
> 0)
7689 dump_ia64_unwind (filedata
, & aux
);
7692 free ((char *) aux
.table
);
7694 free ((char *) aux
.info
);
7703 free ((char *) aux
.strtab
);
7708 struct hppa_unw_table_entry
7710 struct absaddr start
;
7712 unsigned int Cannot_unwind
:1; /* 0 */
7713 unsigned int Millicode
:1; /* 1 */
7714 unsigned int Millicode_save_sr0
:1; /* 2 */
7715 unsigned int Region_description
:2; /* 3..4 */
7716 unsigned int reserved1
:1; /* 5 */
7717 unsigned int Entry_SR
:1; /* 6 */
7718 unsigned int Entry_FR
:4; /* Number saved 7..10 */
7719 unsigned int Entry_GR
:5; /* Number saved 11..15 */
7720 unsigned int Args_stored
:1; /* 16 */
7721 unsigned int Variable_Frame
:1; /* 17 */
7722 unsigned int Separate_Package_Body
:1; /* 18 */
7723 unsigned int Frame_Extension_Millicode
:1; /* 19 */
7724 unsigned int Stack_Overflow_Check
:1; /* 20 */
7725 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
7726 unsigned int Ada_Region
:1; /* 22 */
7727 unsigned int cxx_info
:1; /* 23 */
7728 unsigned int cxx_try_catch
:1; /* 24 */
7729 unsigned int sched_entry_seq
:1; /* 25 */
7730 unsigned int reserved2
:1; /* 26 */
7731 unsigned int Save_SP
:1; /* 27 */
7732 unsigned int Save_RP
:1; /* 28 */
7733 unsigned int Save_MRP_in_frame
:1; /* 29 */
7734 unsigned int extn_ptr_defined
:1; /* 30 */
7735 unsigned int Cleanup_defined
:1; /* 31 */
7737 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
7738 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
7739 unsigned int Large_frame
:1; /* 2 */
7740 unsigned int Pseudo_SP_Set
:1; /* 3 */
7741 unsigned int reserved4
:1; /* 4 */
7742 unsigned int Total_frame_size
:27; /* 5..31 */
7745 struct hppa_unw_aux_info
7747 struct hppa_unw_table_entry
* table
; /* Unwind table. */
7748 unsigned long table_len
; /* Length of unwind table. */
7749 bfd_vma seg_base
; /* Starting address of segment. */
7750 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7751 unsigned long nsyms
; /* Number of symbols. */
7752 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7753 unsigned long nfuns
; /* Number of entries in funtab. */
7754 char * strtab
; /* The string table. */
7755 unsigned long strtab_size
; /* Size of string table. */
7759 dump_hppa_unwind (Filedata
* filedata
, struct hppa_unw_aux_info
* aux
)
7761 struct hppa_unw_table_entry
* tp
;
7762 unsigned long j
, nfuns
;
7763 bfd_boolean res
= TRUE
;
7765 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7766 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7767 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7768 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7770 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7772 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7775 const char * procname
;
7777 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7778 aux
->strtab_size
, tp
->start
, &procname
,
7781 fputs ("\n<", stdout
);
7785 fputs (procname
, stdout
);
7788 printf ("+%lx", (unsigned long) offset
);
7791 fputs (">: [", stdout
);
7792 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7793 fputc ('-', stdout
);
7794 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7797 #define PF(_m) if (tp->_m) printf (#_m " ");
7798 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
7801 PF(Millicode_save_sr0
);
7802 /* PV(Region_description); */
7808 PF(Separate_Package_Body
);
7809 PF(Frame_Extension_Millicode
);
7810 PF(Stack_Overflow_Check
);
7811 PF(Two_Instruction_SP_Increment
);
7815 PF(sched_entry_seq
);
7818 PF(Save_MRP_in_frame
);
7819 PF(extn_ptr_defined
);
7820 PF(Cleanup_defined
);
7821 PF(MPE_XL_interrupt_marker
);
7822 PF(HP_UX_interrupt_marker
);
7825 PV(Total_frame_size
);
7838 slurp_hppa_unwind_table (Filedata
* filedata
,
7839 struct hppa_unw_aux_info
* aux
,
7840 Elf_Internal_Shdr
* sec
)
7842 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
7843 Elf_Internal_Phdr
* seg
;
7844 struct hppa_unw_table_entry
* tep
;
7845 Elf_Internal_Shdr
* relsec
;
7846 Elf_Internal_Rela
* rela
;
7847 Elf_Internal_Rela
* rp
;
7848 unsigned char * table
;
7850 Elf_Internal_Sym
* sym
;
7851 const char * relname
;
7853 /* First, find the starting address of the segment that includes
7855 if (filedata
->file_header
.e_phnum
)
7857 if (! get_program_headers (filedata
))
7860 for (seg
= filedata
->program_headers
;
7861 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
7864 if (seg
->p_type
!= PT_LOAD
)
7867 if (sec
->sh_addr
>= seg
->p_vaddr
7868 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7870 aux
->seg_base
= seg
->p_vaddr
;
7876 /* Second, build the unwind table from the contents of the unwind
7878 size
= sec
->sh_size
;
7879 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
7885 nentries
= size
/ unw_ent_size
;
7886 size
= unw_ent_size
* nentries
;
7888 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
7889 xcmalloc (nentries
, sizeof (aux
->table
[0]));
7891 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
7893 unsigned int tmp1
, tmp2
;
7895 tep
->start
.section
= SHN_UNDEF
;
7896 tep
->end
.section
= SHN_UNDEF
;
7898 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
7899 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
7900 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
7901 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
7903 tep
->start
.offset
+= aux
->seg_base
;
7904 tep
->end
.offset
+= aux
->seg_base
;
7906 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
7907 tep
->Millicode
= (tmp1
>> 30) & 0x1;
7908 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
7909 tep
->Region_description
= (tmp1
>> 27) & 0x3;
7910 tep
->reserved1
= (tmp1
>> 26) & 0x1;
7911 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
7912 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
7913 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
7914 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
7915 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
7916 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
7917 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
7918 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
7919 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
7920 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
7921 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
7922 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
7923 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
7924 tep
->reserved2
= (tmp1
>> 5) & 0x1;
7925 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
7926 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
7927 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
7928 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
7929 tep
->Cleanup_defined
= tmp1
& 0x1;
7931 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
7932 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
7933 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
7934 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
7935 tep
->reserved4
= (tmp2
>> 27) & 0x1;
7936 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
7940 /* Third, apply any relocations to the unwind table. */
7941 for (relsec
= filedata
->section_headers
;
7942 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
7945 if (relsec
->sh_type
!= SHT_RELA
7946 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
7947 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
7950 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
7954 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7956 relname
= elf_hppa_reloc_type (get_reloc_type (filedata
, rp
->r_info
));
7957 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
7959 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
7960 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
7962 warn (_("Skipping unexpected relocation type %s\n"), relname
);
7966 i
= rp
->r_offset
/ unw_ent_size
;
7968 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
7971 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7972 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
7975 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7976 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
7986 aux
->table_len
= nentries
;
7992 hppa_process_unwind (Filedata
* filedata
)
7994 struct hppa_unw_aux_info aux
;
7995 Elf_Internal_Shdr
* unwsec
= NULL
;
7996 Elf_Internal_Shdr
* strsec
;
7997 Elf_Internal_Shdr
* sec
;
7999 bfd_boolean res
= TRUE
;
8001 if (filedata
->string_table
== NULL
)
8004 memset (& aux
, 0, sizeof (aux
));
8006 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8008 if (sec
->sh_type
== SHT_SYMTAB
8009 && sec
->sh_link
< filedata
->file_header
.e_shnum
)
8011 aux
.symtab
= GET_ELF_SYMBOLS (filedata
, sec
, & aux
.nsyms
);
8013 strsec
= filedata
->section_headers
+ sec
->sh_link
;
8014 if (aux
.strtab
!= NULL
)
8016 error (_("Multiple auxillary string tables encountered\n"));
8020 aux
.strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
8023 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
8025 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8030 printf (_("\nThere are no unwind sections in this file.\n"));
8032 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8034 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8036 unsigned long num_unwind
= sec
->sh_size
/ (2 * eh_addr_size
+ 8);
8038 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
8039 "contains %lu entry:\n",
8040 "\nUnwind section '%s' at offset 0x%lx "
8041 "contains %lu entries:\n",
8043 printable_section_name (filedata
, sec
),
8044 (unsigned long) sec
->sh_offset
,
8047 if (! slurp_hppa_unwind_table (filedata
, &aux
, sec
))
8050 if (aux
.table_len
> 0)
8052 if (! dump_hppa_unwind (filedata
, &aux
))
8057 free ((char *) aux
.table
);
8065 free ((char *) aux
.strtab
);
8072 unsigned char * data
; /* The unwind data. */
8073 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
8074 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
8075 unsigned long nrelas
; /* The number of relocations. */
8076 unsigned int rel_type
; /* REL or RELA ? */
8077 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
8080 struct arm_unw_aux_info
8082 Filedata
* filedata
; /* The file containing the unwind sections. */
8083 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
8084 unsigned long nsyms
; /* Number of symbols. */
8085 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8086 unsigned long nfuns
; /* Number of these symbols. */
8087 char * strtab
; /* The file's string table. */
8088 unsigned long strtab_size
; /* Size of string table. */
8092 arm_print_vma_and_name (Filedata
* filedata
,
8093 struct arm_unw_aux_info
* aux
,
8095 struct absaddr addr
)
8097 const char *procname
;
8100 if (addr
.section
== SHN_UNDEF
)
8103 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8104 aux
->strtab_size
, addr
, &procname
,
8107 print_vma (fn
, PREFIX_HEX
);
8111 fputs (" <", stdout
);
8112 fputs (procname
, stdout
);
8115 printf ("+0x%lx", (unsigned long) sym_offset
);
8116 fputc ('>', stdout
);
8123 arm_free_section (struct arm_section
*arm_sec
)
8125 if (arm_sec
->data
!= NULL
)
8126 free (arm_sec
->data
);
8128 if (arm_sec
->rela
!= NULL
)
8129 free (arm_sec
->rela
);
8132 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8133 cached section and install SEC instead.
8134 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8135 and return its valued in * WORDP, relocating if necessary.
8136 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8137 relocation's offset in ADDR.
8138 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8139 into the string table of the symbol associated with the reloc. If no
8140 reloc was applied store -1 there.
8141 5) Return TRUE upon success, FALSE otherwise. */
8144 get_unwind_section_word (Filedata
* filedata
,
8145 struct arm_unw_aux_info
* aux
,
8146 struct arm_section
* arm_sec
,
8147 Elf_Internal_Shdr
* sec
,
8148 bfd_vma word_offset
,
8149 unsigned int * wordp
,
8150 struct absaddr
* addr
,
8153 Elf_Internal_Rela
*rp
;
8154 Elf_Internal_Sym
*sym
;
8155 const char * relname
;
8157 bfd_boolean wrapped
;
8159 if (sec
== NULL
|| arm_sec
== NULL
)
8162 addr
->section
= SHN_UNDEF
;
8165 if (sym_name
!= NULL
)
8166 *sym_name
= (bfd_vma
) -1;
8168 /* If necessary, update the section cache. */
8169 if (sec
!= arm_sec
->sec
)
8171 Elf_Internal_Shdr
*relsec
;
8173 arm_free_section (arm_sec
);
8176 arm_sec
->data
= get_data (NULL
, aux
->filedata
, sec
->sh_offset
, 1,
8177 sec
->sh_size
, _("unwind data"));
8178 arm_sec
->rela
= NULL
;
8179 arm_sec
->nrelas
= 0;
8181 for (relsec
= filedata
->section_headers
;
8182 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8185 if (relsec
->sh_info
>= filedata
->file_header
.e_shnum
8186 || filedata
->section_headers
+ relsec
->sh_info
!= sec
8187 /* PR 15745: Check the section type as well. */
8188 || (relsec
->sh_type
!= SHT_REL
8189 && relsec
->sh_type
!= SHT_RELA
))
8192 arm_sec
->rel_type
= relsec
->sh_type
;
8193 if (relsec
->sh_type
== SHT_REL
)
8195 if (!slurp_rel_relocs (aux
->filedata
, relsec
->sh_offset
,
8197 & arm_sec
->rela
, & arm_sec
->nrelas
))
8200 else /* relsec->sh_type == SHT_RELA */
8202 if (!slurp_rela_relocs (aux
->filedata
, relsec
->sh_offset
,
8204 & arm_sec
->rela
, & arm_sec
->nrelas
))
8210 arm_sec
->next_rela
= arm_sec
->rela
;
8213 /* If there is no unwind data we can do nothing. */
8214 if (arm_sec
->data
== NULL
)
8217 /* If the offset is invalid then fail. */
8218 if (/* PR 21343 *//* PR 18879 */
8220 || word_offset
> (sec
->sh_size
- 4)
8221 || ((bfd_signed_vma
) word_offset
) < 0)
8224 /* Get the word at the required offset. */
8225 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
8227 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
8228 if (arm_sec
->rela
== NULL
)
8234 /* Look through the relocs to find the one that applies to the provided offset. */
8236 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
8238 bfd_vma prelval
, offset
;
8240 if (rp
->r_offset
> word_offset
&& !wrapped
)
8245 if (rp
->r_offset
> word_offset
)
8248 if (rp
->r_offset
& 3)
8250 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8251 (unsigned long) rp
->r_offset
);
8255 if (rp
->r_offset
< word_offset
)
8258 /* PR 17531: file: 027-161405-0.004 */
8259 if (aux
->symtab
== NULL
)
8262 if (arm_sec
->rel_type
== SHT_REL
)
8264 offset
= word
& 0x7fffffff;
8265 if (offset
& 0x40000000)
8266 offset
|= ~ (bfd_vma
) 0x7fffffff;
8268 else if (arm_sec
->rel_type
== SHT_RELA
)
8269 offset
= rp
->r_addend
;
8272 error (_("Unknown section relocation type %d encountered\n"),
8277 /* PR 17531 file: 027-1241568-0.004. */
8278 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
8280 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8281 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
8285 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
8286 offset
+= sym
->st_value
;
8287 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
8289 /* Check that we are processing the expected reloc type. */
8290 if (filedata
->file_header
.e_machine
== EM_ARM
)
8292 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8293 if (relname
== NULL
)
8295 warn (_("Skipping unknown ARM relocation type: %d\n"),
8296 (int) ELF32_R_TYPE (rp
->r_info
));
8300 if (streq (relname
, "R_ARM_NONE"))
8303 if (! streq (relname
, "R_ARM_PREL31"))
8305 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
8309 else if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
8311 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8312 if (relname
== NULL
)
8314 warn (_("Skipping unknown C6000 relocation type: %d\n"),
8315 (int) ELF32_R_TYPE (rp
->r_info
));
8319 if (streq (relname
, "R_C6000_NONE"))
8322 if (! streq (relname
, "R_C6000_PREL31"))
8324 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
8332 /* This function currently only supports ARM and TI unwinders. */
8333 warn (_("Only TI and ARM unwinders are currently supported\n"));
8337 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
8338 addr
->section
= sym
->st_shndx
;
8339 addr
->offset
= offset
;
8342 * sym_name
= sym
->st_name
;
8347 arm_sec
->next_rela
= rp
;
8352 static const char *tic6x_unwind_regnames
[16] =
8354 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8355 "A14", "A13", "A12", "A11", "A10",
8356 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8360 decode_tic6x_unwind_regmask (unsigned int mask
)
8364 for (i
= 12; mask
; mask
>>= 1, i
--)
8368 fputs (tic6x_unwind_regnames
[i
], stdout
);
8370 fputs (", ", stdout
);
8376 if (remaining == 0 && more_words) \
8379 if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, \
8380 data_offset, & word, & addr, NULL)) \
8386 #define GET_OP(OP) \
8391 (OP) = word >> 24; \
8396 printf (_("[Truncated opcode]\n")); \
8399 printf ("0x%02x ", OP)
8402 decode_arm_unwind_bytecode (Filedata
* filedata
,
8403 struct arm_unw_aux_info
* aux
,
8405 unsigned int remaining
,
8406 unsigned int more_words
,
8407 bfd_vma data_offset
,
8408 Elf_Internal_Shdr
* data_sec
,
8409 struct arm_section
* data_arm_sec
)
8411 struct absaddr addr
;
8412 bfd_boolean res
= TRUE
;
8414 /* Decode the unwinding instructions. */
8417 unsigned int op
, op2
;
8426 printf (" 0x%02x ", op
);
8428 if ((op
& 0xc0) == 0x00)
8430 int offset
= ((op
& 0x3f) << 2) + 4;
8432 printf (" vsp = vsp + %d", offset
);
8434 else if ((op
& 0xc0) == 0x40)
8436 int offset
= ((op
& 0x3f) << 2) + 4;
8438 printf (" vsp = vsp - %d", offset
);
8440 else if ((op
& 0xf0) == 0x80)
8443 if (op
== 0x80 && op2
== 0)
8444 printf (_("Refuse to unwind"));
8447 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
8448 bfd_boolean first
= TRUE
;
8452 for (i
= 0; i
< 12; i
++)
8453 if (mask
& (1 << i
))
8459 printf ("r%d", 4 + i
);
8464 else if ((op
& 0xf0) == 0x90)
8466 if (op
== 0x9d || op
== 0x9f)
8467 printf (_(" [Reserved]"));
8469 printf (" vsp = r%d", op
& 0x0f);
8471 else if ((op
& 0xf0) == 0xa0)
8473 int end
= 4 + (op
& 0x07);
8474 bfd_boolean first
= TRUE
;
8478 for (i
= 4; i
<= end
; i
++)
8494 else if (op
== 0xb0)
8495 printf (_(" finish"));
8496 else if (op
== 0xb1)
8499 if (op2
== 0 || (op2
& 0xf0) != 0)
8500 printf (_("[Spare]"));
8503 unsigned int mask
= op2
& 0x0f;
8504 bfd_boolean first
= TRUE
;
8508 for (i
= 0; i
< 12; i
++)
8509 if (mask
& (1 << i
))
8520 else if (op
== 0xb2)
8522 unsigned char buf
[9];
8523 unsigned int i
, len
;
8524 unsigned long offset
;
8526 for (i
= 0; i
< sizeof (buf
); i
++)
8529 if ((buf
[i
] & 0x80) == 0)
8532 if (i
== sizeof (buf
))
8534 error (_("corrupt change to vsp"));
8539 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8540 assert (len
== i
+ 1);
8541 offset
= offset
* 4 + 0x204;
8542 printf ("vsp = vsp + %ld", offset
);
8545 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
8547 unsigned int first
, last
;
8554 printf ("pop {D%d", first
);
8556 printf ("-D%d", first
+ last
);
8559 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
8561 unsigned int count
= op
& 0x07;
8565 printf ("-D%d", 8 + count
);
8568 else if (op
>= 0xc0 && op
<= 0xc5)
8570 unsigned int count
= op
& 0x07;
8572 printf (" pop {wR10");
8574 printf ("-wR%d", 10 + count
);
8577 else if (op
== 0xc6)
8579 unsigned int first
, last
;
8584 printf ("pop {wR%d", first
);
8586 printf ("-wR%d", first
+ last
);
8589 else if (op
== 0xc7)
8592 if (op2
== 0 || (op2
& 0xf0) != 0)
8593 printf (_("[Spare]"));
8596 unsigned int mask
= op2
& 0x0f;
8597 bfd_boolean first
= TRUE
;
8601 for (i
= 0; i
< 4; i
++)
8602 if (mask
& (1 << i
))
8608 printf ("wCGR%d", i
);
8615 printf (_(" [unsupported opcode]"));
8626 decode_tic6x_unwind_bytecode (Filedata
* filedata
,
8627 struct arm_unw_aux_info
* aux
,
8629 unsigned int remaining
,
8630 unsigned int more_words
,
8631 bfd_vma data_offset
,
8632 Elf_Internal_Shdr
* data_sec
,
8633 struct arm_section
* data_arm_sec
)
8635 struct absaddr addr
;
8637 /* Decode the unwinding instructions. */
8640 unsigned int op
, op2
;
8649 printf (" 0x%02x ", op
);
8651 if ((op
& 0xc0) == 0x00)
8653 int offset
= ((op
& 0x3f) << 3) + 8;
8654 printf (" sp = sp + %d", offset
);
8656 else if ((op
& 0xc0) == 0x80)
8659 if (op
== 0x80 && op2
== 0)
8660 printf (_("Refuse to unwind"));
8663 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
8665 printf ("pop compact {");
8669 decode_tic6x_unwind_regmask (mask
);
8673 else if ((op
& 0xf0) == 0xc0)
8681 unsigned int offset
;
8685 /* Scan entire instruction first so that GET_OP output is not
8686 interleaved with disassembly. */
8688 for (i
= 0; nregs
< (op
& 0xf); i
++)
8694 regpos
[nregs
].offset
= i
* 2;
8695 regpos
[nregs
].reg
= reg
;
8702 regpos
[nregs
].offset
= i
* 2 + 1;
8703 regpos
[nregs
].reg
= reg
;
8708 printf (_("pop frame {"));
8710 for (i
= i
* 2; i
> 0; i
--)
8712 if (regpos
[reg
].offset
== i
- 1)
8714 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
8721 fputs (name
, stdout
);
8728 else if (op
== 0xd0)
8729 printf (" MOV FP, SP");
8730 else if (op
== 0xd1)
8731 printf (" __c6xabi_pop_rts");
8732 else if (op
== 0xd2)
8734 unsigned char buf
[9];
8735 unsigned int i
, len
;
8736 unsigned long offset
;
8738 for (i
= 0; i
< sizeof (buf
); i
++)
8741 if ((buf
[i
] & 0x80) == 0)
8744 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
8745 if (i
== sizeof (buf
))
8747 warn (_("Corrupt stack pointer adjustment detected\n"));
8751 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8752 assert (len
== i
+ 1);
8753 offset
= offset
* 8 + 0x408;
8754 printf (_("sp = sp + %ld"), offset
);
8756 else if ((op
& 0xf0) == 0xe0)
8758 if ((op
& 0x0f) == 7)
8761 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
8765 printf (_(" [unsupported opcode]"));
8774 arm_expand_prel31 (Filedata
* filedata
, bfd_vma word
, bfd_vma where
)
8778 offset
= word
& 0x7fffffff;
8779 if (offset
& 0x40000000)
8780 offset
|= ~ (bfd_vma
) 0x7fffffff;
8782 if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
8785 return offset
+ where
;
8789 decode_arm_unwind (Filedata
* filedata
,
8790 struct arm_unw_aux_info
* aux
,
8792 unsigned int remaining
,
8793 bfd_vma data_offset
,
8794 Elf_Internal_Shdr
* data_sec
,
8795 struct arm_section
* data_arm_sec
)
8798 unsigned int more_words
= 0;
8799 struct absaddr addr
;
8800 bfd_vma sym_name
= (bfd_vma
) -1;
8801 bfd_boolean res
= TRUE
;
8805 /* Fetch the first word.
8806 Note - when decoding an object file the address extracted
8807 here will always be 0. So we also pass in the sym_name
8808 parameter so that we can find the symbol associated with
8809 the personality routine. */
8810 if (! get_unwind_section_word (filedata
, aux
, data_arm_sec
, data_sec
, data_offset
,
8811 & word
, & addr
, & sym_name
))
8817 if ((word
& 0x80000000) == 0)
8819 /* Expand prel31 for personality routine. */
8821 const char *procname
;
8823 fn
= arm_expand_prel31 (filedata
, word
, data_sec
->sh_addr
+ data_offset
);
8824 printf (_(" Personality routine: "));
8826 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
8827 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
8829 procname
= aux
->strtab
+ sym_name
;
8830 print_vma (fn
, PREFIX_HEX
);
8833 fputs (" <", stdout
);
8834 fputs (procname
, stdout
);
8835 fputc ('>', stdout
);
8839 procname
= arm_print_vma_and_name (filedata
, aux
, fn
, addr
);
8840 fputc ('\n', stdout
);
8842 /* The GCC personality routines use the standard compact
8843 encoding, starting with one byte giving the number of
8845 if (procname
!= NULL
8846 && (const_strneq (procname
, "__gcc_personality_v0")
8847 || const_strneq (procname
, "__gxx_personality_v0")
8848 || const_strneq (procname
, "__gcj_personality_v0")
8849 || const_strneq (procname
, "__gnu_objc_personality_v0")))
8856 printf (_(" [Truncated data]\n"));
8859 more_words
= word
>> 24;
8869 /* ARM EHABI Section 6.3:
8871 An exception-handling table entry for the compact model looks like:
8875 1 0 index Data for personalityRoutine[index] */
8877 if (filedata
->file_header
.e_machine
== EM_ARM
8878 && (word
& 0x70000000))
8880 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
8884 per_index
= (word
>> 24) & 0x7f;
8885 printf (_(" Compact model index: %d\n"), per_index
);
8892 else if (per_index
< 3)
8894 more_words
= (word
>> 16) & 0xff;
8900 switch (filedata
->file_header
.e_machine
)
8905 if (! decode_arm_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
8906 data_offset
, data_sec
, data_arm_sec
))
8911 warn (_("Unknown ARM compact model index encountered\n"));
8912 printf (_(" [reserved]\n"));
8920 if (! decode_tic6x_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
8921 data_offset
, data_sec
, data_arm_sec
))
8924 else if (per_index
< 5)
8926 if (((word
>> 17) & 0x7f) == 0x7f)
8927 printf (_(" Restore stack from frame pointer\n"));
8929 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
8930 printf (_(" Registers restored: "));
8932 printf (" (compact) ");
8933 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
8935 printf (_(" Return register: %s\n"),
8936 tic6x_unwind_regnames
[word
& 0xf]);
8939 printf (_(" [reserved (%d)]\n"), per_index
);
8943 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
8944 filedata
->file_header
.e_machine
);
8948 /* Decode the descriptors. Not implemented. */
8954 dump_arm_unwind (Filedata
* filedata
,
8955 struct arm_unw_aux_info
* aux
,
8956 Elf_Internal_Shdr
* exidx_sec
)
8958 struct arm_section exidx_arm_sec
, extab_arm_sec
;
8959 unsigned int i
, exidx_len
;
8960 unsigned long j
, nfuns
;
8961 bfd_boolean res
= TRUE
;
8963 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
8964 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
8965 exidx_len
= exidx_sec
->sh_size
/ 8;
8967 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
8968 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
8969 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
8970 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
8972 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
8974 for (i
= 0; i
< exidx_len
; i
++)
8976 unsigned int exidx_fn
, exidx_entry
;
8977 struct absaddr fn_addr
, entry_addr
;
8980 fputc ('\n', stdout
);
8982 if (! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
8983 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
8984 || ! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
8985 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
8988 arm_free_section (& exidx_arm_sec
);
8989 arm_free_section (& extab_arm_sec
);
8993 /* ARM EHABI, Section 5:
8994 An index table entry consists of 2 words.
8995 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
8996 if (exidx_fn
& 0x80000000)
8998 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
9002 fn
= arm_expand_prel31 (filedata
, exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
9004 arm_print_vma_and_name (filedata
, aux
, fn
, fn_addr
);
9005 fputs (": ", stdout
);
9007 if (exidx_entry
== 1)
9009 print_vma (exidx_entry
, PREFIX_HEX
);
9010 fputs (" [cantunwind]\n", stdout
);
9012 else if (exidx_entry
& 0x80000000)
9014 print_vma (exidx_entry
, PREFIX_HEX
);
9015 fputc ('\n', stdout
);
9016 decode_arm_unwind (filedata
, aux
, exidx_entry
, 4, 0, NULL
, NULL
);
9020 bfd_vma table
, table_offset
= 0;
9021 Elf_Internal_Shdr
*table_sec
;
9023 fputs ("@", stdout
);
9024 table
= arm_expand_prel31 (filedata
, exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
9025 print_vma (table
, PREFIX_HEX
);
9028 /* Locate the matching .ARM.extab. */
9029 if (entry_addr
.section
!= SHN_UNDEF
9030 && entry_addr
.section
< filedata
->file_header
.e_shnum
)
9032 table_sec
= filedata
->section_headers
+ entry_addr
.section
;
9033 table_offset
= entry_addr
.offset
;
9035 if (table_offset
> table_sec
->sh_size
9036 || ((bfd_signed_vma
) table_offset
) < 0)
9038 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
9039 (unsigned long) table_offset
,
9040 printable_section_name (filedata
, table_sec
));
9047 table_sec
= find_section_by_address (filedata
, table
);
9048 if (table_sec
!= NULL
)
9049 table_offset
= table
- table_sec
->sh_addr
;
9052 if (table_sec
== NULL
)
9054 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
9055 (unsigned long) table
);
9060 if (! decode_arm_unwind (filedata
, aux
, 0, 0, table_offset
, table_sec
,
9069 arm_free_section (&exidx_arm_sec
);
9070 arm_free_section (&extab_arm_sec
);
9075 /* Used for both ARM and C6X unwinding tables. */
9078 arm_process_unwind (Filedata
* filedata
)
9080 struct arm_unw_aux_info aux
;
9081 Elf_Internal_Shdr
*unwsec
= NULL
;
9082 Elf_Internal_Shdr
*strsec
;
9083 Elf_Internal_Shdr
*sec
;
9085 unsigned int sec_type
;
9086 bfd_boolean res
= TRUE
;
9088 switch (filedata
->file_header
.e_machine
)
9091 sec_type
= SHT_ARM_EXIDX
;
9095 sec_type
= SHT_C6000_UNWIND
;
9099 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9100 filedata
->file_header
.e_machine
);
9104 if (filedata
->string_table
== NULL
)
9107 memset (& aux
, 0, sizeof (aux
));
9108 aux
.filedata
= filedata
;
9110 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9112 if (sec
->sh_type
== SHT_SYMTAB
&& sec
->sh_link
< filedata
->file_header
.e_shnum
)
9114 aux
.symtab
= GET_ELF_SYMBOLS (filedata
, sec
, & aux
.nsyms
);
9116 strsec
= filedata
->section_headers
+ sec
->sh_link
;
9118 /* PR binutils/17531 file: 011-12666-0.004. */
9119 if (aux
.strtab
!= NULL
)
9121 error (_("Multiple string tables found in file.\n"));
9125 aux
.strtab
= get_data (NULL
, filedata
, strsec
->sh_offset
,
9126 1, strsec
->sh_size
, _("string table"));
9127 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
9129 else if (sec
->sh_type
== sec_type
)
9134 printf (_("\nThere are no unwind sections in this file.\n"));
9136 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9138 if (sec
->sh_type
== sec_type
)
9140 unsigned long num_unwind
= sec
->sh_size
/ (2 * eh_addr_size
);
9141 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
9142 "contains %lu entry:\n",
9143 "\nUnwind section '%s' at offset 0x%lx "
9144 "contains %lu entries:\n",
9146 printable_section_name (filedata
, sec
),
9147 (unsigned long) sec
->sh_offset
,
9150 if (! dump_arm_unwind (filedata
, &aux
, sec
))
9158 free ((char *) aux
.strtab
);
9164 process_unwind (Filedata
* filedata
)
9166 struct unwind_handler
9168 unsigned int machtype
;
9169 bfd_boolean (* handler
)(Filedata
*);
9172 { EM_ARM
, arm_process_unwind
},
9173 { EM_IA_64
, ia64_process_unwind
},
9174 { EM_PARISC
, hppa_process_unwind
},
9175 { EM_TI_C6000
, arm_process_unwind
},
9183 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
9184 if (filedata
->file_header
.e_machine
== handlers
[i
].machtype
)
9185 return handlers
[i
].handler (filedata
);
9187 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9188 get_machine_name (filedata
->file_header
.e_machine
));
9193 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
9195 switch (entry
->d_tag
)
9198 if (entry
->d_un
.d_val
== 0)
9202 static const char * opts
[] =
9204 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9205 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9206 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9207 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9211 bfd_boolean first
= TRUE
;
9213 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
9214 if (entry
->d_un
.d_val
& (1 << cnt
))
9216 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
9222 case DT_MIPS_IVERSION
:
9223 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9224 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
9228 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
9229 /* Note: coded this way so that there is a single string for translation. */
9230 printf (_("<corrupt: %s>"), buf
);
9234 case DT_MIPS_TIME_STAMP
:
9238 time_t atime
= entry
->d_un
.d_val
;
9240 tmp
= gmtime (&atime
);
9241 /* PR 17531: file: 6accc532. */
9243 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
9245 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
9246 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9247 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9248 printf (_("Time Stamp: %s"), timebuf
);
9252 case DT_MIPS_RLD_VERSION
:
9253 case DT_MIPS_LOCAL_GOTNO
:
9254 case DT_MIPS_CONFLICTNO
:
9255 case DT_MIPS_LIBLISTNO
:
9256 case DT_MIPS_SYMTABNO
:
9257 case DT_MIPS_UNREFEXTNO
:
9258 case DT_MIPS_HIPAGENO
:
9259 case DT_MIPS_DELTA_CLASS_NO
:
9260 case DT_MIPS_DELTA_INSTANCE_NO
:
9261 case DT_MIPS_DELTA_RELOC_NO
:
9262 case DT_MIPS_DELTA_SYM_NO
:
9263 case DT_MIPS_DELTA_CLASSSYM_NO
:
9264 case DT_MIPS_COMPACT_SIZE
:
9265 print_vma (entry
->d_un
.d_val
, DEC
);
9269 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9275 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
9277 switch (entry
->d_tag
)
9279 case DT_HP_DLD_FLAGS
:
9288 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
9289 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
9290 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
9291 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
9292 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
9293 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
9294 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
9295 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
9296 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
9297 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
9298 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
9299 { DT_HP_GST
, "HP_GST" },
9300 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
9301 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
9302 { DT_HP_NODELETE
, "HP_NODELETE" },
9303 { DT_HP_GROUP
, "HP_GROUP" },
9304 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
9306 bfd_boolean first
= TRUE
;
9308 bfd_vma val
= entry
->d_un
.d_val
;
9310 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
9311 if (val
& flags
[cnt
].bit
)
9315 fputs (flags
[cnt
].str
, stdout
);
9317 val
^= flags
[cnt
].bit
;
9320 if (val
!= 0 || first
)
9324 print_vma (val
, HEX
);
9330 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9338 /* VMS vs Unix time offset and factor. */
9340 #define VMS_EPOCH_OFFSET 35067168000000000LL
9341 #define VMS_GRANULARITY_FACTOR 10000000
9343 /* Display a VMS time in a human readable format. */
9346 print_vms_time (bfd_int64_t vmstime
)
9351 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
9352 tm
= gmtime (&unxtime
);
9353 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9354 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
9355 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
9360 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
9362 switch (entry
->d_tag
)
9364 case DT_IA_64_PLT_RESERVE
:
9365 /* First 3 slots reserved. */
9366 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9368 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
9371 case DT_IA_64_VMS_LINKTIME
:
9373 print_vms_time (entry
->d_un
.d_val
);
9377 case DT_IA_64_VMS_LNKFLAGS
:
9378 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9379 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
9380 printf (" CALL_DEBUG");
9381 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
9382 printf (" NOP0BUFS");
9383 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
9384 printf (" P0IMAGE");
9385 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
9386 printf (" MKTHREADS");
9387 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
9388 printf (" UPCALLS");
9389 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
9391 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
9392 printf (" INITIALIZE");
9393 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
9395 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
9396 printf (" EXE_INIT");
9397 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
9398 printf (" TBK_IN_IMG");
9399 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
9400 printf (" DBG_IN_IMG");
9401 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
9402 printf (" TBK_IN_DSF");
9403 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
9404 printf (" DBG_IN_DSF");
9405 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
9406 printf (" SIGNATURES");
9407 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
9408 printf (" REL_SEG_OFF");
9412 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9419 get_32bit_dynamic_section (Filedata
* filedata
)
9421 Elf32_External_Dyn
* edyn
;
9422 Elf32_External_Dyn
* ext
;
9423 Elf_Internal_Dyn
* entry
;
9425 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, filedata
, dynamic_addr
, 1,
9426 dynamic_size
, _("dynamic section"));
9430 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9431 might not have the luxury of section headers. Look for the DT_NULL
9432 terminator to determine the number of entries. */
9433 for (ext
= edyn
, dynamic_nent
= 0;
9434 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9438 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9442 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9444 if (dynamic_section
== NULL
)
9446 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9447 (unsigned long) dynamic_nent
);
9452 for (ext
= edyn
, entry
= dynamic_section
;
9453 entry
< dynamic_section
+ dynamic_nent
;
9456 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9457 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9466 get_64bit_dynamic_section (Filedata
* filedata
)
9468 Elf64_External_Dyn
* edyn
;
9469 Elf64_External_Dyn
* ext
;
9470 Elf_Internal_Dyn
* entry
;
9472 /* Read in the data. */
9473 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, filedata
, dynamic_addr
, 1,
9474 dynamic_size
, _("dynamic section"));
9478 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9479 might not have the luxury of section headers. Look for the DT_NULL
9480 terminator to determine the number of entries. */
9481 for (ext
= edyn
, dynamic_nent
= 0;
9482 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
9483 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9487 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9491 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9493 if (dynamic_section
== NULL
)
9495 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9496 (unsigned long) dynamic_nent
);
9501 /* Convert from external to internal formats. */
9502 for (ext
= edyn
, entry
= dynamic_section
;
9503 entry
< dynamic_section
+ dynamic_nent
;
9506 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9507 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9516 print_dynamic_flags (bfd_vma flags
)
9518 bfd_boolean first
= TRUE
;
9524 flag
= flags
& - flags
;
9534 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
9535 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
9536 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
9537 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
9538 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
9539 default: fputs (_("unknown"), stdout
); break;
9545 /* Parse and display the contents of the dynamic section. */
9548 process_dynamic_section (Filedata
* filedata
)
9550 Elf_Internal_Dyn
* entry
;
9552 if (dynamic_size
== 0)
9555 printf (_("\nThere is no dynamic section in this file.\n"));
9562 if (! get_32bit_dynamic_section (filedata
))
9567 if (! get_64bit_dynamic_section (filedata
))
9571 /* Find the appropriate symbol table. */
9572 if (dynamic_symbols
== NULL
)
9574 for (entry
= dynamic_section
;
9575 entry
< dynamic_section
+ dynamic_nent
;
9578 Elf_Internal_Shdr section
;
9580 if (entry
->d_tag
!= DT_SYMTAB
)
9583 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
9585 /* Since we do not know how big the symbol table is,
9586 we default to reading in the entire file (!) and
9587 processing that. This is overkill, I know, but it
9589 section
.sh_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
9590 if ((bfd_size_type
) section
.sh_offset
> filedata
->file_size
)
9592 /* See PR 21379 for a reproducer. */
9593 error (_("Invalid DT_SYMTAB entry: %lx"), (long) section
.sh_offset
);
9597 if (archive_file_offset
!= 0)
9598 section
.sh_size
= archive_file_size
- section
.sh_offset
;
9600 section
.sh_size
= filedata
->file_size
- section
.sh_offset
;
9603 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
9605 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
9606 section
.sh_name
= filedata
->string_table_length
;
9608 dynamic_symbols
= GET_ELF_SYMBOLS (filedata
, §ion
, & num_dynamic_syms
);
9609 if (num_dynamic_syms
< 1)
9611 error (_("Unable to determine the number of symbols to load\n"));
9617 /* Similarly find a string table. */
9618 if (dynamic_strings
== NULL
)
9620 for (entry
= dynamic_section
;
9621 entry
< dynamic_section
+ dynamic_nent
;
9624 unsigned long offset
;
9627 if (entry
->d_tag
!= DT_STRTAB
)
9630 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
9632 /* Since we do not know how big the string table is,
9633 we default to reading in the entire file (!) and
9634 processing that. This is overkill, I know, but it
9637 offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
9639 if (archive_file_offset
!= 0)
9640 str_tab_len
= archive_file_size
- offset
;
9642 str_tab_len
= filedata
->file_size
;
9644 if (str_tab_len
< 1)
9647 (_("Unable to determine the length of the dynamic string table\n"));
9651 dynamic_strings
= (char *) get_data (NULL
, filedata
, offset
, 1,
9653 _("dynamic string table"));
9654 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : str_tab_len
;
9659 /* And find the syminfo section if available. */
9660 if (dynamic_syminfo
== NULL
)
9662 unsigned long syminsz
= 0;
9664 for (entry
= dynamic_section
;
9665 entry
< dynamic_section
+ dynamic_nent
;
9668 if (entry
->d_tag
== DT_SYMINENT
)
9670 /* Note: these braces are necessary to avoid a syntax
9671 error from the SunOS4 C compiler. */
9672 /* PR binutils/17531: A corrupt file can trigger this test.
9673 So do not use an assert, instead generate an error message. */
9674 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
9675 error (_("Bad value (%d) for SYMINENT entry\n"),
9676 (int) entry
->d_un
.d_val
);
9678 else if (entry
->d_tag
== DT_SYMINSZ
)
9679 syminsz
= entry
->d_un
.d_val
;
9680 else if (entry
->d_tag
== DT_SYMINFO
)
9681 dynamic_syminfo_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
,
9685 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
9687 Elf_External_Syminfo
* extsyminfo
;
9688 Elf_External_Syminfo
* extsym
;
9689 Elf_Internal_Syminfo
* syminfo
;
9691 /* There is a syminfo section. Read the data. */
9692 extsyminfo
= (Elf_External_Syminfo
*)
9693 get_data (NULL
, filedata
, dynamic_syminfo_offset
, 1, syminsz
,
9694 _("symbol information"));
9698 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
9699 if (dynamic_syminfo
== NULL
)
9701 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9702 (unsigned long) syminsz
);
9706 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
9707 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
9708 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
9709 ++syminfo
, ++extsym
)
9711 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
9712 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
9719 if (do_dynamic
&& dynamic_addr
)
9720 printf (ngettext ("\nDynamic section at offset 0x%lx "
9721 "contains %lu entry:\n",
9722 "\nDynamic section at offset 0x%lx "
9723 "contains %lu entries:\n",
9725 dynamic_addr
, (unsigned long) dynamic_nent
);
9727 printf (_(" Tag Type Name/Value\n"));
9729 for (entry
= dynamic_section
;
9730 entry
< dynamic_section
+ dynamic_nent
;
9738 print_vma (entry
->d_tag
, FULL_HEX
);
9739 dtype
= get_dynamic_type (filedata
, entry
->d_tag
);
9740 printf (" (%s)%*s", dtype
,
9741 ((is_32bit_elf
? 27 : 19) - (int) strlen (dtype
)), " ");
9744 switch (entry
->d_tag
)
9748 print_dynamic_flags (entry
->d_un
.d_val
);
9758 switch (entry
->d_tag
)
9761 printf (_("Auxiliary library"));
9765 printf (_("Filter library"));
9769 printf (_("Configuration file"));
9773 printf (_("Dependency audit library"));
9777 printf (_("Audit library"));
9781 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9782 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
9786 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9795 printf (_("Flags:"));
9797 if (entry
->d_un
.d_val
== 0)
9798 printf (_(" None\n"));
9801 unsigned long int val
= entry
->d_un
.d_val
;
9803 if (val
& DTF_1_PARINIT
)
9805 printf (" PARINIT");
9806 val
^= DTF_1_PARINIT
;
9808 if (val
& DTF_1_CONFEXP
)
9810 printf (" CONFEXP");
9811 val
^= DTF_1_CONFEXP
;
9814 printf (" %lx", val
);
9823 printf (_("Flags:"));
9825 if (entry
->d_un
.d_val
== 0)
9826 printf (_(" None\n"));
9829 unsigned long int val
= entry
->d_un
.d_val
;
9831 if (val
& DF_P1_LAZYLOAD
)
9833 printf (" LAZYLOAD");
9834 val
^= DF_P1_LAZYLOAD
;
9836 if (val
& DF_P1_GROUPPERM
)
9838 printf (" GROUPPERM");
9839 val
^= DF_P1_GROUPPERM
;
9842 printf (" %lx", val
);
9851 printf (_("Flags:"));
9852 if (entry
->d_un
.d_val
== 0)
9853 printf (_(" None\n"));
9856 unsigned long int val
= entry
->d_un
.d_val
;
9863 if (val
& DF_1_GLOBAL
)
9868 if (val
& DF_1_GROUP
)
9873 if (val
& DF_1_NODELETE
)
9875 printf (" NODELETE");
9876 val
^= DF_1_NODELETE
;
9878 if (val
& DF_1_LOADFLTR
)
9880 printf (" LOADFLTR");
9881 val
^= DF_1_LOADFLTR
;
9883 if (val
& DF_1_INITFIRST
)
9885 printf (" INITFIRST");
9886 val
^= DF_1_INITFIRST
;
9888 if (val
& DF_1_NOOPEN
)
9893 if (val
& DF_1_ORIGIN
)
9898 if (val
& DF_1_DIRECT
)
9903 if (val
& DF_1_TRANS
)
9908 if (val
& DF_1_INTERPOSE
)
9910 printf (" INTERPOSE");
9911 val
^= DF_1_INTERPOSE
;
9913 if (val
& DF_1_NODEFLIB
)
9915 printf (" NODEFLIB");
9916 val
^= DF_1_NODEFLIB
;
9918 if (val
& DF_1_NODUMP
)
9923 if (val
& DF_1_CONFALT
)
9925 printf (" CONFALT");
9926 val
^= DF_1_CONFALT
;
9928 if (val
& DF_1_ENDFILTEE
)
9930 printf (" ENDFILTEE");
9931 val
^= DF_1_ENDFILTEE
;
9933 if (val
& DF_1_DISPRELDNE
)
9935 printf (" DISPRELDNE");
9936 val
^= DF_1_DISPRELDNE
;
9938 if (val
& DF_1_DISPRELPND
)
9940 printf (" DISPRELPND");
9941 val
^= DF_1_DISPRELPND
;
9943 if (val
& DF_1_NODIRECT
)
9945 printf (" NODIRECT");
9946 val
^= DF_1_NODIRECT
;
9948 if (val
& DF_1_IGNMULDEF
)
9950 printf (" IGNMULDEF");
9951 val
^= DF_1_IGNMULDEF
;
9953 if (val
& DF_1_NOKSYMS
)
9955 printf (" NOKSYMS");
9956 val
^= DF_1_NOKSYMS
;
9958 if (val
& DF_1_NOHDR
)
9963 if (val
& DF_1_EDITED
)
9968 if (val
& DF_1_NORELOC
)
9970 printf (" NORELOC");
9971 val
^= DF_1_NORELOC
;
9973 if (val
& DF_1_SYMINTPOSE
)
9975 printf (" SYMINTPOSE");
9976 val
^= DF_1_SYMINTPOSE
;
9978 if (val
& DF_1_GLOBAUDIT
)
9980 printf (" GLOBAUDIT");
9981 val
^= DF_1_GLOBAUDIT
;
9983 if (val
& DF_1_SINGLETON
)
9985 printf (" SINGLETON");
9986 val
^= DF_1_SINGLETON
;
9988 if (val
& DF_1_STUB
)
9998 if (val
& DF_1_KMOD
)
10003 if (val
& DF_1_WEAKFILTER
)
10005 printf (" WEAKFILTER");
10006 val
^= DF_1_WEAKFILTER
;
10008 if (val
& DF_1_NOCOMMON
)
10010 printf (" NOCOMMON");
10011 val
^= DF_1_NOCOMMON
;
10014 printf (" %lx", val
);
10021 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10023 puts (get_dynamic_type (filedata
, entry
->d_un
.d_val
));
10043 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10049 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
10050 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
10056 switch (entry
->d_tag
)
10059 printf (_("Shared library: [%s]"), name
);
10061 if (streq (name
, program_interpreter
))
10062 printf (_(" program interpreter"));
10066 printf (_("Library soname: [%s]"), name
);
10070 printf (_("Library rpath: [%s]"), name
);
10074 printf (_("Library runpath: [%s]"), name
);
10078 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10083 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10096 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10097 /* Fall through. */
10101 case DT_INIT_ARRAYSZ
:
10102 case DT_FINI_ARRAYSZ
:
10103 case DT_GNU_CONFLICTSZ
:
10104 case DT_GNU_LIBLISTSZ
:
10107 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10108 printf (_(" (bytes)\n"));
10113 case DT_VERNEEDNUM
:
10118 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10127 case DT_INIT_ARRAY
:
10128 case DT_FINI_ARRAY
:
10131 if (entry
->d_tag
== DT_USED
10132 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
10134 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
10138 printf (_("Not needed object: [%s]\n"), name
);
10143 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10149 /* The value of this entry is ignored. */
10154 case DT_GNU_PRELINKED
:
10158 time_t atime
= entry
->d_un
.d_val
;
10160 tmp
= gmtime (&atime
);
10161 /* PR 17533 file: 041-1244816-0.004. */
10163 printf (_("<corrupt time val: %lx"),
10164 (unsigned long) atime
);
10166 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10167 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
10168 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
10174 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10177 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10183 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
10184 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
10189 switch (filedata
->file_header
.e_machine
)
10192 case EM_MIPS_RS3_LE
:
10193 dynamic_section_mips_val (entry
);
10196 dynamic_section_parisc_val (entry
);
10199 dynamic_section_ia64_val (entry
);
10202 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10214 get_ver_flags (unsigned int flags
)
10216 static char buff
[128];
10223 if (flags
& VER_FLG_BASE
)
10224 strcat (buff
, "BASE");
10226 if (flags
& VER_FLG_WEAK
)
10228 if (flags
& VER_FLG_BASE
)
10229 strcat (buff
, " | ");
10231 strcat (buff
, "WEAK");
10234 if (flags
& VER_FLG_INFO
)
10236 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
10237 strcat (buff
, " | ");
10239 strcat (buff
, "INFO");
10242 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10244 if (flags
& (VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10245 strcat (buff
, " | ");
10247 strcat (buff
, _("<unknown>"));
10253 /* Display the contents of the version sections. */
10256 process_version_sections (Filedata
* filedata
)
10258 Elf_Internal_Shdr
* section
;
10260 bfd_boolean found
= FALSE
;
10265 for (i
= 0, section
= filedata
->section_headers
;
10266 i
< filedata
->file_header
.e_shnum
;
10269 switch (section
->sh_type
)
10271 case SHT_GNU_verdef
:
10273 Elf_External_Verdef
* edefs
;
10280 printf (ngettext ("\nVersion definition section '%s' "
10281 "contains %u entry:\n",
10282 "\nVersion definition section '%s' "
10283 "contains %u entries:\n",
10285 printable_section_name (filedata
, section
),
10288 printf (_(" Addr: 0x"));
10289 printf_vma (section
->sh_addr
);
10290 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10291 (unsigned long) section
->sh_offset
, section
->sh_link
,
10292 printable_section_name_from_index (filedata
, section
->sh_link
));
10294 edefs
= (Elf_External_Verdef
*)
10295 get_data (NULL
, filedata
, section
->sh_offset
, 1,section
->sh_size
,
10296 _("version definition section"));
10299 endbuf
= (char *) edefs
+ section
->sh_size
;
10301 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
10304 Elf_External_Verdef
* edef
;
10305 Elf_Internal_Verdef ent
;
10306 Elf_External_Verdaux
* eaux
;
10307 Elf_Internal_Verdaux aux
;
10308 unsigned long isum
;
10311 vstart
= ((char *) edefs
) + idx
;
10312 if (vstart
+ sizeof (*edef
) > endbuf
)
10315 edef
= (Elf_External_Verdef
*) vstart
;
10317 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
10318 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
10319 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
10320 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
10321 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
10322 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
10323 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
10325 printf (_(" %#06lx: Rev: %d Flags: %s"),
10326 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
10328 printf (_(" Index: %d Cnt: %d "),
10329 ent
.vd_ndx
, ent
.vd_cnt
);
10331 /* Check for overflow. */
10332 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
10335 vstart
+= ent
.vd_aux
;
10337 if (vstart
+ sizeof (*eaux
) > endbuf
)
10339 eaux
= (Elf_External_Verdaux
*) vstart
;
10341 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10342 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10344 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10345 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
10347 printf (_("Name index: %ld\n"), aux
.vda_name
);
10349 isum
= idx
+ ent
.vd_aux
;
10351 for (j
= 1; j
< ent
.vd_cnt
; j
++)
10353 if (aux
.vda_next
< sizeof (*eaux
)
10354 && !(j
== ent
.vd_cnt
- 1 && aux
.vda_next
== 0))
10356 warn (_("Invalid vda_next field of %lx\n"),
10361 /* Check for overflow. */
10362 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
10365 isum
+= aux
.vda_next
;
10366 vstart
+= aux
.vda_next
;
10368 if (vstart
+ sizeof (*eaux
) > endbuf
)
10370 eaux
= (Elf_External_Verdaux
*) vstart
;
10372 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10373 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10375 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10376 printf (_(" %#06lx: Parent %d: %s\n"),
10377 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
10379 printf (_(" %#06lx: Parent %d, name index: %ld\n"),
10380 isum
, j
, aux
.vda_name
);
10383 if (j
< ent
.vd_cnt
)
10384 printf (_(" Version def aux past end of section\n"));
10387 file: id:000001,src:000172+005151,op:splice,rep:2. */
10388 if (ent
.vd_next
< sizeof (*edef
)
10389 && !(cnt
== section
->sh_info
- 1 && ent
.vd_next
== 0))
10391 warn (_("Invalid vd_next field of %lx\n"), ent
.vd_next
);
10392 cnt
= section
->sh_info
;
10395 if (ent
.vd_next
> (size_t) (endbuf
- ((char *) edefs
+ idx
)))
10398 idx
+= ent
.vd_next
;
10401 if (cnt
< section
->sh_info
)
10402 printf (_(" Version definition past end of section\n"));
10408 case SHT_GNU_verneed
:
10410 Elf_External_Verneed
* eneed
;
10417 printf (ngettext ("\nVersion needs section '%s' "
10418 "contains %u entry:\n",
10419 "\nVersion needs section '%s' "
10420 "contains %u entries:\n",
10422 printable_section_name (filedata
, section
), section
->sh_info
);
10424 printf (_(" Addr: 0x"));
10425 printf_vma (section
->sh_addr
);
10426 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10427 (unsigned long) section
->sh_offset
, section
->sh_link
,
10428 printable_section_name_from_index (filedata
, section
->sh_link
));
10430 eneed
= (Elf_External_Verneed
*) get_data (NULL
, filedata
,
10431 section
->sh_offset
, 1,
10433 _("Version Needs section"));
10436 endbuf
= (char *) eneed
+ section
->sh_size
;
10438 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
10440 Elf_External_Verneed
* entry
;
10441 Elf_Internal_Verneed ent
;
10442 unsigned long isum
;
10446 vstart
= ((char *) eneed
) + idx
;
10447 if (vstart
+ sizeof (*entry
) > endbuf
)
10450 entry
= (Elf_External_Verneed
*) vstart
;
10452 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
10453 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
10454 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
10455 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
10456 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
10458 printf (_(" %#06lx: Version: %d"), idx
, ent
.vn_version
);
10460 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
10461 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
10463 printf (_(" File: %lx"), ent
.vn_file
);
10465 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
10467 /* Check for overflow. */
10468 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
10470 vstart
+= ent
.vn_aux
;
10472 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
10474 Elf_External_Vernaux
* eaux
;
10475 Elf_Internal_Vernaux aux
;
10477 if (vstart
+ sizeof (*eaux
) > endbuf
)
10479 eaux
= (Elf_External_Vernaux
*) vstart
;
10481 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
10482 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
10483 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
10484 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
10485 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
10487 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
10488 printf (_(" %#06lx: Name: %s"),
10489 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
10491 printf (_(" %#06lx: Name index: %lx"),
10492 isum
, aux
.vna_name
);
10494 printf (_(" Flags: %s Version: %d\n"),
10495 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
10497 if (aux
.vna_next
< sizeof (*eaux
)
10498 && !(j
== ent
.vn_cnt
- 1 && aux
.vna_next
== 0))
10500 warn (_("Invalid vna_next field of %lx\n"),
10505 /* Check for overflow. */
10506 if (aux
.vna_next
> (size_t) (endbuf
- vstart
))
10508 isum
+= aux
.vna_next
;
10509 vstart
+= aux
.vna_next
;
10512 if (j
< ent
.vn_cnt
)
10513 warn (_("Missing Version Needs auxillary information\n"));
10515 if (ent
.vn_next
< sizeof (*entry
)
10516 && !(cnt
== section
->sh_info
- 1 && ent
.vn_next
== 0))
10518 warn (_("Invalid vn_next field of %lx\n"), ent
.vn_next
);
10519 cnt
= section
->sh_info
;
10522 if (ent
.vn_next
> (size_t) (endbuf
- ((char *) eneed
+ idx
)))
10524 idx
+= ent
.vn_next
;
10527 if (cnt
< section
->sh_info
)
10528 warn (_("Missing Version Needs information\n"));
10534 case SHT_GNU_versym
:
10536 Elf_Internal_Shdr
* link_section
;
10539 unsigned char * edata
;
10540 unsigned short * data
;
10542 Elf_Internal_Sym
* symbols
;
10543 Elf_Internal_Shdr
* string_sec
;
10544 unsigned long num_syms
;
10547 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
10550 link_section
= filedata
->section_headers
+ section
->sh_link
;
10551 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
10553 if (link_section
->sh_link
>= filedata
->file_header
.e_shnum
)
10558 symbols
= GET_ELF_SYMBOLS (filedata
, link_section
, & num_syms
);
10559 if (symbols
== NULL
)
10562 string_sec
= filedata
->section_headers
+ link_section
->sh_link
;
10564 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
10565 string_sec
->sh_size
,
10566 _("version string table"));
10573 printf (ngettext ("\nVersion symbols section '%s' "
10574 "contains %lu entry:\n",
10575 "\nVersion symbols section '%s' "
10576 "contains %lu entries:\n",
10578 printable_section_name (filedata
, section
), (unsigned long) total
);
10580 printf (_(" Addr: "));
10581 printf_vma (section
->sh_addr
);
10582 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10583 (unsigned long) section
->sh_offset
, section
->sh_link
,
10584 printable_section_name (filedata
, link_section
));
10586 off
= offset_from_vma (filedata
,
10587 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
10588 total
* sizeof (short));
10589 edata
= (unsigned char *) get_data (NULL
, filedata
, off
, total
,
10591 _("version symbol data"));
10599 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
10601 for (cnt
= total
; cnt
--;)
10602 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
10607 for (cnt
= 0; cnt
< total
; cnt
+= 4)
10611 char *invalid
= _("*invalid*");
10613 printf (" %03x:", cnt
);
10615 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
10616 switch (data
[cnt
+ j
])
10619 fputs (_(" 0 (*local*) "), stdout
);
10623 fputs (_(" 1 (*global*) "), stdout
);
10627 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
10628 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
10630 /* If this index value is greater than the size of the symbols
10631 array, break to avoid an out-of-bounds read. */
10632 if ((unsigned long)(cnt
+ j
) >= num_syms
)
10634 warn (_("invalid index into symbol array\n"));
10639 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
10641 Elf_Internal_Verneed ivn
;
10642 unsigned long offset
;
10644 offset
= offset_from_vma
10645 (filedata
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
10646 sizeof (Elf_External_Verneed
));
10650 Elf_Internal_Vernaux ivna
;
10651 Elf_External_Verneed evn
;
10652 Elf_External_Vernaux evna
;
10653 unsigned long a_off
;
10655 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
10656 _("version need")) == NULL
)
10659 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
10660 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
10662 a_off
= offset
+ ivn
.vn_aux
;
10666 if (get_data (&evna
, filedata
, a_off
, sizeof (evna
),
10667 1, _("version need aux (2)")) == NULL
)
10670 ivna
.vna_other
= 0;
10674 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
10675 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
10678 a_off
+= ivna
.vna_next
;
10680 while (ivna
.vna_other
!= data
[cnt
+ j
]
10681 && ivna
.vna_next
!= 0);
10683 if (ivna
.vna_other
== data
[cnt
+ j
])
10685 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
10687 if (ivna
.vna_name
>= string_sec
->sh_size
)
10690 name
= strtab
+ ivna
.vna_name
;
10694 offset
+= ivn
.vn_next
;
10696 while (ivn
.vn_next
);
10699 if (data
[cnt
+ j
] != 0x8001
10700 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
10702 Elf_Internal_Verdef ivd
;
10703 Elf_External_Verdef evd
;
10704 unsigned long offset
;
10706 offset
= offset_from_vma
10707 (filedata
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
10712 if (get_data (&evd
, filedata
, offset
, sizeof (evd
), 1,
10713 _("version def")) == NULL
)
10716 /* PR 17531: file: 046-1082287-0.004. */
10717 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
10722 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
10723 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
10726 offset
+= ivd
.vd_next
;
10728 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
10729 && ivd
.vd_next
!= 0);
10731 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
10733 Elf_External_Verdaux evda
;
10734 Elf_Internal_Verdaux ivda
;
10736 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
10738 if (get_data (&evda
, filedata
,
10739 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
10741 _("version def aux")) == NULL
)
10744 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
10746 if (ivda
.vda_name
>= string_sec
->sh_size
)
10748 else if (name
!= NULL
&& name
!= invalid
)
10749 name
= _("*both*");
10751 name
= strtab
+ ivda
.vda_name
;
10755 nn
+= printf ("(%s%-*s",
10757 12 - (int) strlen (name
),
10761 printf ("%*c", 18 - nn
, ' ');
10779 printf (_("\nNo version information found in this file.\n"));
10784 static const char *
10785 get_symbol_binding (Filedata
* filedata
, unsigned int binding
)
10787 static char buff
[32];
10791 case STB_LOCAL
: return "LOCAL";
10792 case STB_GLOBAL
: return "GLOBAL";
10793 case STB_WEAK
: return "WEAK";
10795 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
10796 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
10798 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
10800 if (binding
== STB_GNU_UNIQUE
10801 && (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10802 /* GNU is still using the default value 0. */
10803 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10805 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
10808 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
10813 static const char *
10814 get_symbol_type (Filedata
* filedata
, unsigned int type
)
10816 static char buff
[32];
10820 case STT_NOTYPE
: return "NOTYPE";
10821 case STT_OBJECT
: return "OBJECT";
10822 case STT_FUNC
: return "FUNC";
10823 case STT_SECTION
: return "SECTION";
10824 case STT_FILE
: return "FILE";
10825 case STT_COMMON
: return "COMMON";
10826 case STT_TLS
: return "TLS";
10827 case STT_RELC
: return "RELC";
10828 case STT_SRELC
: return "SRELC";
10830 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
10832 if (filedata
->file_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
10833 return "THUMB_FUNC";
10835 if (filedata
->file_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
10838 if (filedata
->file_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
10839 return "PARISC_MILLI";
10841 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
10843 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
10845 if (filedata
->file_header
.e_machine
== EM_PARISC
)
10847 if (type
== STT_HP_OPAQUE
)
10848 return "HP_OPAQUE";
10849 if (type
== STT_HP_STUB
)
10853 if (type
== STT_GNU_IFUNC
10854 && (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10855 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
10856 /* GNU is still using the default value 0. */
10857 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10860 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
10863 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
10868 static const char *
10869 get_symbol_visibility (unsigned int visibility
)
10871 switch (visibility
)
10873 case STV_DEFAULT
: return "DEFAULT";
10874 case STV_INTERNAL
: return "INTERNAL";
10875 case STV_HIDDEN
: return "HIDDEN";
10876 case STV_PROTECTED
: return "PROTECTED";
10878 error (_("Unrecognized visibility value: %u"), visibility
);
10879 return _("<unknown>");
10883 static const char *
10884 get_solaris_symbol_visibility (unsigned int visibility
)
10886 switch (visibility
)
10888 case 4: return "EXPORTED";
10889 case 5: return "SINGLETON";
10890 case 6: return "ELIMINATE";
10891 default: return get_symbol_visibility (visibility
);
10895 static const char *
10896 get_mips_symbol_other (unsigned int other
)
10900 case STO_OPTIONAL
: return "OPTIONAL";
10901 case STO_MIPS_PLT
: return "MIPS PLT";
10902 case STO_MIPS_PIC
: return "MIPS PIC";
10903 case STO_MICROMIPS
: return "MICROMIPS";
10904 case STO_MICROMIPS
| STO_MIPS_PIC
: return "MICROMIPS, MIPS PIC";
10905 case STO_MIPS16
: return "MIPS16";
10906 default: return NULL
;
10910 static const char *
10911 get_ia64_symbol_other (Filedata
* filedata
, unsigned int other
)
10913 if (is_ia64_vms (filedata
))
10915 static char res
[32];
10919 /* Function types is for images and .STB files only. */
10920 switch (filedata
->file_header
.e_type
)
10924 switch (VMS_ST_FUNC_TYPE (other
))
10926 case VMS_SFT_CODE_ADDR
:
10927 strcat (res
, " CA");
10929 case VMS_SFT_SYMV_IDX
:
10930 strcat (res
, " VEC");
10933 strcat (res
, " FD");
10935 case VMS_SFT_RESERVE
:
10936 strcat (res
, " RSV");
10939 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10940 VMS_ST_FUNC_TYPE (other
));
10941 strcat (res
, " <unknown>");
10948 switch (VMS_ST_LINKAGE (other
))
10950 case VMS_STL_IGNORE
:
10951 strcat (res
, " IGN");
10953 case VMS_STL_RESERVE
:
10954 strcat (res
, " RSV");
10957 strcat (res
, " STD");
10960 strcat (res
, " LNK");
10963 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10964 VMS_ST_LINKAGE (other
));
10965 strcat (res
, " <unknown>");
10977 static const char *
10978 get_ppc64_symbol_other (unsigned int other
)
10980 if (PPC64_LOCAL_ENTRY_OFFSET (other
) != 0)
10982 static char buf
[32];
10983 snprintf (buf
, sizeof buf
, _("<localentry>: %d"),
10984 PPC64_LOCAL_ENTRY_OFFSET (other
));
10990 static const char *
10991 get_symbol_other (Filedata
* filedata
, unsigned int other
)
10993 const char * result
= NULL
;
10994 static char buff
[32];
10999 switch (filedata
->file_header
.e_machine
)
11002 result
= get_mips_symbol_other (other
);
11005 result
= get_ia64_symbol_other (filedata
, other
);
11008 result
= get_ppc64_symbol_other (other
);
11018 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
11022 static const char *
11023 get_symbol_index_type (Filedata
* filedata
, unsigned int type
)
11025 static char buff
[32];
11029 case SHN_UNDEF
: return "UND";
11030 case SHN_ABS
: return "ABS";
11031 case SHN_COMMON
: return "COM";
11033 if (type
== SHN_IA_64_ANSI_COMMON
11034 && filedata
->file_header
.e_machine
== EM_IA_64
11035 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
11037 else if ((filedata
->file_header
.e_machine
== EM_X86_64
11038 || filedata
->file_header
.e_machine
== EM_L1OM
11039 || filedata
->file_header
.e_machine
== EM_K1OM
)
11040 && type
== SHN_X86_64_LCOMMON
)
11041 return "LARGE_COM";
11042 else if ((type
== SHN_MIPS_SCOMMON
11043 && filedata
->file_header
.e_machine
== EM_MIPS
)
11044 || (type
== SHN_TIC6X_SCOMMON
11045 && filedata
->file_header
.e_machine
== EM_TI_C6000
))
11047 else if (type
== SHN_MIPS_SUNDEFINED
11048 && filedata
->file_header
.e_machine
== EM_MIPS
)
11050 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
11051 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
11052 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
11053 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
11054 else if (type
>= SHN_LORESERVE
)
11055 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
11056 else if (type
>= filedata
->file_header
.e_shnum
)
11057 sprintf (buff
, _("bad section index[%3d]"), type
);
11059 sprintf (buff
, "%3d", type
);
11067 get_dynamic_data (Filedata
* filedata
, bfd_size_type number
, unsigned int ent_size
)
11069 unsigned char * e_data
;
11072 /* If the size_t type is smaller than the bfd_size_type, eg because
11073 you are building a 32-bit tool on a 64-bit host, then make sure
11074 that when (number) is cast to (size_t) no information is lost. */
11075 if (sizeof (size_t) < sizeof (bfd_size_type
)
11076 && (bfd_size_type
) ((size_t) number
) != number
)
11078 error (_("Size truncation prevents reading %s elements of size %u\n"),
11079 bfd_vmatoa ("u", number
), ent_size
);
11083 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
11084 attempting to allocate memory when the read is bound to fail. */
11085 if (ent_size
* number
> filedata
->file_size
)
11087 error (_("Invalid number of dynamic entries: %s\n"),
11088 bfd_vmatoa ("u", number
));
11092 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
11093 if (e_data
== NULL
)
11095 error (_("Out of memory reading %s dynamic entries\n"),
11096 bfd_vmatoa ("u", number
));
11100 if (fread (e_data
, ent_size
, (size_t) number
, filedata
->handle
) != number
)
11102 error (_("Unable to read in %s bytes of dynamic data\n"),
11103 bfd_vmatoa ("u", number
* ent_size
));
11108 i_data
= (bfd_vma
*) cmalloc ((size_t) number
, sizeof (*i_data
));
11109 if (i_data
== NULL
)
11111 error (_("Out of memory allocating space for %s dynamic entries\n"),
11112 bfd_vmatoa ("u", number
));
11118 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
11126 print_dynamic_symbol (Filedata
* filedata
, bfd_vma si
, unsigned long hn
)
11128 Elf_Internal_Sym
* psym
;
11131 n
= print_vma (si
, DEC_5
);
11133 fputs (&" "[n
], stdout
);
11134 printf (" %3lu: ", hn
);
11136 if (dynamic_symbols
== NULL
|| si
>= num_dynamic_syms
)
11138 printf (_("<No info available for dynamic symbol number %lu>\n"),
11139 (unsigned long) si
);
11143 psym
= dynamic_symbols
+ si
;
11144 print_vma (psym
->st_value
, LONG_HEX
);
11146 print_vma (psym
->st_size
, DEC_5
);
11148 printf (" %-7s", get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)));
11149 printf (" %-6s", get_symbol_binding (filedata
, ELF_ST_BIND (psym
->st_info
)));
11151 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
11152 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
11155 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
11157 printf (" %-7s", get_symbol_visibility (vis
));
11158 /* Check to see if any other bits in the st_other field are set.
11159 Note - displaying this information disrupts the layout of the
11160 table being generated, but for the moment this case is very
11162 if (psym
->st_other
^ vis
)
11163 printf (" [%s] ", get_symbol_other (filedata
, psym
->st_other
^ vis
));
11166 printf (" %3.3s ", get_symbol_index_type (filedata
, psym
->st_shndx
));
11167 if (VALID_DYNAMIC_NAME (psym
->st_name
))
11168 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
11170 printf (_(" <corrupt: %14ld>"), psym
->st_name
);
11174 static const char *
11175 get_symbol_version_string (Filedata
* filedata
,
11176 bfd_boolean is_dynsym
,
11177 const char * strtab
,
11178 unsigned long int strtab_size
,
11180 Elf_Internal_Sym
* psym
,
11181 enum versioned_symbol_info
* sym_info
,
11182 unsigned short * vna_other
)
11184 unsigned char data
[2];
11185 unsigned short vers_data
;
11186 unsigned long offset
;
11189 || version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
11192 offset
= offset_from_vma (filedata
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
11193 sizeof data
+ si
* sizeof (vers_data
));
11195 if (get_data (&data
, filedata
, offset
+ si
* sizeof (vers_data
),
11196 sizeof (data
), 1, _("version data")) == NULL
)
11199 vers_data
= byte_get (data
, 2);
11201 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
<= 1)
11204 /* Usually we'd only see verdef for defined symbols, and verneed for
11205 undefined symbols. However, symbols defined by the linker in
11206 .dynbss for variables copied from a shared library in order to
11207 avoid text relocations are defined yet have verneed. We could
11208 use a heuristic to detect the special case, for example, check
11209 for verneed first on symbols defined in SHT_NOBITS sections, but
11210 it is simpler and more reliable to just look for both verdef and
11211 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
11213 if (psym
->st_shndx
!= SHN_UNDEF
11214 && vers_data
!= 0x8001
11215 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
11217 Elf_Internal_Verdef ivd
;
11218 Elf_Internal_Verdaux ivda
;
11219 Elf_External_Verdaux evda
;
11222 off
= offset_from_vma (filedata
,
11223 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
11224 sizeof (Elf_External_Verdef
));
11228 Elf_External_Verdef evd
;
11230 if (get_data (&evd
, filedata
, off
, sizeof (evd
), 1,
11231 _("version def")) == NULL
)
11239 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
11240 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
11241 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
11244 off
+= ivd
.vd_next
;
11246 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
11248 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
11250 off
-= ivd
.vd_next
;
11253 if (get_data (&evda
, filedata
, off
, sizeof (evda
), 1,
11254 _("version def aux")) != NULL
)
11256 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
11258 if (psym
->st_name
!= ivda
.vda_name
)
11260 *sym_info
= ((vers_data
& VERSYM_HIDDEN
) != 0
11261 ? symbol_hidden
: symbol_public
);
11262 return (ivda
.vda_name
< strtab_size
11263 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
11269 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
11271 Elf_External_Verneed evn
;
11272 Elf_Internal_Verneed ivn
;
11273 Elf_Internal_Vernaux ivna
;
11275 offset
= offset_from_vma (filedata
,
11276 version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
11280 unsigned long vna_off
;
11282 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
11283 _("version need")) == NULL
)
11286 ivna
.vna_other
= 0;
11291 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
11292 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
11294 vna_off
= offset
+ ivn
.vn_aux
;
11298 Elf_External_Vernaux evna
;
11300 if (get_data (&evna
, filedata
, vna_off
, sizeof (evna
), 1,
11301 _("version need aux (3)")) == NULL
)
11304 ivna
.vna_other
= 0;
11309 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
11310 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
11311 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
11314 vna_off
+= ivna
.vna_next
;
11316 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
11318 if (ivna
.vna_other
== vers_data
)
11321 offset
+= ivn
.vn_next
;
11323 while (ivn
.vn_next
!= 0);
11325 if (ivna
.vna_other
== vers_data
)
11327 *sym_info
= symbol_undefined
;
11328 *vna_other
= ivna
.vna_other
;
11329 return (ivna
.vna_name
< strtab_size
11330 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
11336 /* Dump the symbol table. */
11338 process_symbol_table (Filedata
* filedata
)
11340 Elf_Internal_Shdr
* section
;
11341 bfd_size_type nbuckets
= 0;
11342 bfd_size_type nchains
= 0;
11343 bfd_vma
* buckets
= NULL
;
11344 bfd_vma
* chains
= NULL
;
11345 bfd_vma ngnubuckets
= 0;
11346 bfd_vma
* gnubuckets
= NULL
;
11347 bfd_vma
* gnuchains
= NULL
;
11348 bfd_vma gnusymidx
= 0;
11349 bfd_size_type ngnuchains
= 0;
11351 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
11354 if (dynamic_info
[DT_HASH
]
11356 || (do_using_dynamic
11358 && dynamic_strings
!= NULL
)))
11360 unsigned char nb
[8];
11361 unsigned char nc
[8];
11362 unsigned int hash_ent_size
= 4;
11364 if ((filedata
->file_header
.e_machine
== EM_ALPHA
11365 || filedata
->file_header
.e_machine
== EM_S390
11366 || filedata
->file_header
.e_machine
== EM_S390_OLD
)
11367 && filedata
->file_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
11370 if (fseek (filedata
->handle
,
11371 (archive_file_offset
11372 + offset_from_vma (filedata
, dynamic_info
[DT_HASH
],
11373 sizeof nb
+ sizeof nc
)),
11376 error (_("Unable to seek to start of dynamic information\n"));
11380 if (fread (nb
, hash_ent_size
, 1, filedata
->handle
) != 1)
11382 error (_("Failed to read in number of buckets\n"));
11386 if (fread (nc
, hash_ent_size
, 1, filedata
->handle
) != 1)
11388 error (_("Failed to read in number of chains\n"));
11392 nbuckets
= byte_get (nb
, hash_ent_size
);
11393 nchains
= byte_get (nc
, hash_ent_size
);
11395 buckets
= get_dynamic_data (filedata
, nbuckets
, hash_ent_size
);
11396 chains
= get_dynamic_data (filedata
, nchains
, hash_ent_size
);
11399 if (buckets
== NULL
|| chains
== NULL
)
11401 if (do_using_dynamic
)
11412 if (dynamic_info_DT_GNU_HASH
11414 || (do_using_dynamic
11416 && dynamic_strings
!= NULL
)))
11418 unsigned char nb
[16];
11419 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
11420 bfd_vma buckets_vma
;
11422 if (fseek (filedata
->handle
,
11423 (archive_file_offset
11424 + offset_from_vma (filedata
, dynamic_info_DT_GNU_HASH
,
11428 error (_("Unable to seek to start of dynamic information\n"));
11432 if (fread (nb
, 16, 1, filedata
->handle
) != 1)
11434 error (_("Failed to read in number of buckets\n"));
11438 ngnubuckets
= byte_get (nb
, 4);
11439 gnusymidx
= byte_get (nb
+ 4, 4);
11440 bitmaskwords
= byte_get (nb
+ 8, 4);
11441 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
11443 buckets_vma
+= bitmaskwords
* 4;
11445 buckets_vma
+= bitmaskwords
* 8;
11447 if (fseek (filedata
->handle
,
11448 (archive_file_offset
11449 + offset_from_vma (filedata
, buckets_vma
, 4)),
11452 error (_("Unable to seek to start of dynamic information\n"));
11456 gnubuckets
= get_dynamic_data (filedata
, ngnubuckets
, 4);
11458 if (gnubuckets
== NULL
)
11461 for (i
= 0; i
< ngnubuckets
; i
++)
11462 if (gnubuckets
[i
] != 0)
11464 if (gnubuckets
[i
] < gnusymidx
)
11467 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
11468 maxchain
= gnubuckets
[i
];
11471 if (maxchain
== 0xffffffff)
11474 maxchain
-= gnusymidx
;
11476 if (fseek (filedata
->handle
,
11477 (archive_file_offset
11478 + offset_from_vma (filedata
, buckets_vma
11479 + 4 * (ngnubuckets
+ maxchain
), 4)),
11482 error (_("Unable to seek to start of dynamic information\n"));
11488 if (fread (nb
, 4, 1, filedata
->handle
) != 1)
11490 error (_("Failed to determine last chain length\n"));
11494 if (maxchain
+ 1 == 0)
11499 while ((byte_get (nb
, 4) & 1) == 0);
11501 if (fseek (filedata
->handle
,
11502 (archive_file_offset
11503 + offset_from_vma (filedata
, buckets_vma
+ 4 * ngnubuckets
, 4)),
11506 error (_("Unable to seek to start of dynamic information\n"));
11510 gnuchains
= get_dynamic_data (filedata
, maxchain
, 4);
11511 ngnuchains
= maxchain
;
11514 if (gnuchains
== NULL
)
11519 if (do_using_dynamic
)
11524 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
11526 && do_using_dynamic
11527 && dynamic_strings
!= NULL
11528 && dynamic_symbols
!= NULL
)
11532 if (dynamic_info
[DT_HASH
])
11537 printf (_("\nSymbol table for image:\n"));
11539 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11541 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11543 visited
= xcmalloc (nchains
, 1);
11544 memset (visited
, 0, nchains
);
11545 for (hn
= 0; hn
< nbuckets
; hn
++)
11547 for (si
= buckets
[hn
]; si
> 0; si
= chains
[si
])
11549 print_dynamic_symbol (filedata
, si
, hn
);
11550 if (si
>= nchains
|| visited
[si
])
11552 error (_("histogram chain is corrupt\n"));
11561 if (dynamic_info_DT_GNU_HASH
)
11563 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
11565 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11567 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11569 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11570 if (gnubuckets
[hn
] != 0)
11572 bfd_vma si
= gnubuckets
[hn
];
11573 bfd_vma off
= si
- gnusymidx
;
11577 print_dynamic_symbol (filedata
, si
, hn
);
11580 while (off
< ngnuchains
&& (gnuchains
[off
++] & 1) == 0);
11584 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
11585 && filedata
->section_headers
!= NULL
)
11589 for (i
= 0, section
= filedata
->section_headers
;
11590 i
< filedata
->file_header
.e_shnum
;
11594 char * strtab
= NULL
;
11595 unsigned long int strtab_size
= 0;
11596 Elf_Internal_Sym
* symtab
;
11597 Elf_Internal_Sym
* psym
;
11598 unsigned long num_syms
;
11600 if ((section
->sh_type
!= SHT_SYMTAB
11601 && section
->sh_type
!= SHT_DYNSYM
)
11603 && section
->sh_type
== SHT_SYMTAB
))
11606 if (section
->sh_entsize
== 0)
11608 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
11609 printable_section_name (filedata
, section
));
11613 num_syms
= section
->sh_size
/ section
->sh_entsize
;
11614 printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
11615 "\nSymbol table '%s' contains %lu entries:\n",
11617 printable_section_name (filedata
, section
),
11621 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11623 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11625 symtab
= GET_ELF_SYMBOLS (filedata
, section
, & num_syms
);
11626 if (symtab
== NULL
)
11629 if (section
->sh_link
== filedata
->file_header
.e_shstrndx
)
11631 strtab
= filedata
->string_table
;
11632 strtab_size
= filedata
->string_table_length
;
11634 else if (section
->sh_link
< filedata
->file_header
.e_shnum
)
11636 Elf_Internal_Shdr
* string_sec
;
11638 string_sec
= filedata
->section_headers
+ section
->sh_link
;
11640 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
,
11641 1, string_sec
->sh_size
,
11642 _("string table"));
11643 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
11646 for (si
= 0, psym
= symtab
; si
< num_syms
; si
++, psym
++)
11648 const char *version_string
;
11649 enum versioned_symbol_info sym_info
;
11650 unsigned short vna_other
;
11652 printf ("%6d: ", si
);
11653 print_vma (psym
->st_value
, LONG_HEX
);
11655 print_vma (psym
->st_size
, DEC_5
);
11656 printf (" %-7s", get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)));
11657 printf (" %-6s", get_symbol_binding (filedata
, ELF_ST_BIND (psym
->st_info
)));
11658 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
11659 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
11662 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
11664 printf (" %-7s", get_symbol_visibility (vis
));
11665 /* Check to see if any other bits in the st_other field are set.
11666 Note - displaying this information disrupts the layout of the
11667 table being generated, but for the moment this case is very rare. */
11668 if (psym
->st_other
^ vis
)
11669 printf (" [%s] ", get_symbol_other (filedata
, psym
->st_other
^ vis
));
11671 printf (" %4s ", get_symbol_index_type (filedata
, psym
->st_shndx
));
11672 print_symbol (25, psym
->st_name
< strtab_size
11673 ? strtab
+ psym
->st_name
: _("<corrupt>"));
11676 = get_symbol_version_string (filedata
,
11677 section
->sh_type
== SHT_DYNSYM
,
11678 strtab
, strtab_size
, si
,
11679 psym
, &sym_info
, &vna_other
);
11680 if (version_string
)
11682 if (sym_info
== symbol_undefined
)
11683 printf ("@%s (%d)", version_string
, vna_other
);
11685 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
11691 if (ELF_ST_BIND (psym
->st_info
) == STB_LOCAL
11692 && si
>= section
->sh_info
11693 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
11694 && filedata
->file_header
.e_machine
!= EM_MIPS
11695 /* Solaris binaries have been found to violate this requirement as
11696 well. Not sure if this is a bug or an ABI requirement. */
11697 && filedata
->file_header
.e_ident
[EI_OSABI
] != ELFOSABI_SOLARIS
)
11698 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
11699 si
, printable_section_name (filedata
, section
), section
->sh_info
);
11703 if (strtab
!= filedata
->string_table
)
11709 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
11711 if (do_histogram
&& buckets
!= NULL
)
11713 unsigned long * lengths
;
11714 unsigned long * counts
;
11717 unsigned long maxlength
= 0;
11718 unsigned long nzero_counts
= 0;
11719 unsigned long nsyms
= 0;
11722 printf (ngettext ("\nHistogram for bucket list length "
11723 "(total of %lu bucket):\n",
11724 "\nHistogram for bucket list length "
11725 "(total of %lu buckets):\n",
11726 (unsigned long) nbuckets
),
11727 (unsigned long) nbuckets
);
11729 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
11730 if (lengths
== NULL
)
11732 error (_("Out of memory allocating space for histogram buckets\n"));
11735 visited
= xcmalloc (nchains
, 1);
11736 memset (visited
, 0, nchains
);
11738 printf (_(" Length Number %% of total Coverage\n"));
11739 for (hn
= 0; hn
< nbuckets
; ++hn
)
11741 for (si
= buckets
[hn
]; si
> 0; si
= chains
[si
])
11744 if (maxlength
< ++lengths
[hn
])
11746 if (si
>= nchains
|| visited
[si
])
11748 error (_("histogram chain is corrupt\n"));
11756 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
11757 if (counts
== NULL
)
11760 error (_("Out of memory allocating space for histogram counts\n"));
11764 for (hn
= 0; hn
< nbuckets
; ++hn
)
11765 ++counts
[lengths
[hn
]];
11770 printf (" 0 %-10lu (%5.1f%%)\n",
11771 counts
[0], (counts
[0] * 100.0) / nbuckets
);
11772 for (i
= 1; i
<= maxlength
; ++i
)
11774 nzero_counts
+= counts
[i
] * i
;
11775 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11776 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
11777 (nzero_counts
* 100.0) / nsyms
);
11785 if (buckets
!= NULL
)
11791 if (do_histogram
&& gnubuckets
!= NULL
)
11793 unsigned long * lengths
;
11794 unsigned long * counts
;
11796 unsigned long maxlength
= 0;
11797 unsigned long nzero_counts
= 0;
11798 unsigned long nsyms
= 0;
11800 printf (ngettext ("\nHistogram for `.gnu.hash' bucket list length "
11801 "(total of %lu bucket):\n",
11802 "\nHistogram for `.gnu.hash' bucket list length "
11803 "(total of %lu buckets):\n",
11804 (unsigned long) ngnubuckets
),
11805 (unsigned long) ngnubuckets
);
11807 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
11808 if (lengths
== NULL
)
11810 error (_("Out of memory allocating space for gnu histogram buckets\n"));
11814 printf (_(" Length Number %% of total Coverage\n"));
11816 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11817 if (gnubuckets
[hn
] != 0)
11819 bfd_vma off
, length
= 1;
11821 for (off
= gnubuckets
[hn
] - gnusymidx
;
11822 /* PR 17531 file: 010-77222-0.004. */
11823 off
< ngnuchains
&& (gnuchains
[off
] & 1) == 0;
11826 lengths
[hn
] = length
;
11827 if (length
> maxlength
)
11828 maxlength
= length
;
11832 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
11833 if (counts
== NULL
)
11836 error (_("Out of memory allocating space for gnu histogram counts\n"));
11840 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11841 ++counts
[lengths
[hn
]];
11843 if (ngnubuckets
> 0)
11846 printf (" 0 %-10lu (%5.1f%%)\n",
11847 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
11848 for (j
= 1; j
<= maxlength
; ++j
)
11850 nzero_counts
+= counts
[j
] * j
;
11851 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11852 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
11853 (nzero_counts
* 100.0) / nsyms
);
11867 process_syminfo (Filedata
* filedata ATTRIBUTE_UNUSED
)
11871 if (dynamic_syminfo
== NULL
11873 /* No syminfo, this is ok. */
11876 /* There better should be a dynamic symbol section. */
11877 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
11881 printf (ngettext ("\nDynamic info segment at offset 0x%lx "
11882 "contains %d entry:\n",
11883 "\nDynamic info segment at offset 0x%lx "
11884 "contains %d entries:\n",
11885 dynamic_syminfo_nent
),
11886 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
11888 printf (_(" Num: Name BoundTo Flags\n"));
11889 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
11891 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
11893 printf ("%4d: ", i
);
11894 if (i
>= num_dynamic_syms
)
11895 printf (_("<corrupt index>"));
11896 else if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
11897 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
11899 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
11902 switch (dynamic_syminfo
[i
].si_boundto
)
11904 case SYMINFO_BT_SELF
:
11905 fputs ("SELF ", stdout
);
11907 case SYMINFO_BT_PARENT
:
11908 fputs ("PARENT ", stdout
);
11911 if (dynamic_syminfo
[i
].si_boundto
> 0
11912 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
11913 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
11915 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
11919 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
11923 if (flags
& SYMINFO_FLG_DIRECT
)
11924 printf (" DIRECT");
11925 if (flags
& SYMINFO_FLG_PASSTHRU
)
11926 printf (" PASSTHRU");
11927 if (flags
& SYMINFO_FLG_COPY
)
11929 if (flags
& SYMINFO_FLG_LAZYLOAD
)
11930 printf (" LAZYLOAD");
11938 #define IN_RANGE(START,END,ADDR,OFF) \
11939 (((ADDR) >= (START)) && ((ADDR) + (OFF) < (END)))
11941 /* Check to see if the given reloc needs to be handled in a target specific
11942 manner. If so then process the reloc and return TRUE otherwise return
11945 If called with reloc == NULL, then this is a signal that reloc processing
11946 for the current section has finished, and any saved state should be
11950 target_specific_reloc_handling (Filedata
* filedata
,
11951 Elf_Internal_Rela
* reloc
,
11952 unsigned char * start
,
11953 unsigned char * end
,
11954 Elf_Internal_Sym
* symtab
,
11955 unsigned long num_syms
)
11957 unsigned int reloc_type
= 0;
11958 unsigned long sym_index
= 0;
11962 reloc_type
= get_reloc_type (filedata
, reloc
->r_info
);
11963 sym_index
= get_reloc_symindex (reloc
->r_info
);
11966 switch (filedata
->file_header
.e_machine
)
11969 case EM_MSP430_OLD
:
11971 static Elf_Internal_Sym
* saved_sym
= NULL
;
11979 switch (reloc_type
)
11981 case 10: /* R_MSP430_SYM_DIFF */
11982 if (uses_msp430x_relocs (filedata
))
11984 /* Fall through. */
11985 case 21: /* R_MSP430X_SYM_DIFF */
11987 if (sym_index
>= num_syms
)
11988 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
11991 saved_sym
= symtab
+ sym_index
;
11994 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
11995 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
11996 goto handle_sym_diff
;
11998 case 5: /* R_MSP430_16_BYTE */
11999 case 9: /* R_MSP430_8 */
12000 if (uses_msp430x_relocs (filedata
))
12002 goto handle_sym_diff
;
12004 case 2: /* R_MSP430_ABS16 */
12005 case 15: /* R_MSP430X_ABS16 */
12006 if (! uses_msp430x_relocs (filedata
))
12008 goto handle_sym_diff
;
12011 if (saved_sym
!= NULL
)
12013 int reloc_size
= reloc_type
== 1 ? 4 : 2;
12016 if (sym_index
>= num_syms
)
12017 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
12021 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12022 - saved_sym
->st_value
);
12024 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12025 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12028 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
12029 (long) reloc
->r_offset
);
12038 if (saved_sym
!= NULL
)
12039 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
12046 case EM_CYGNUS_MN10300
:
12048 static Elf_Internal_Sym
* saved_sym
= NULL
;
12056 switch (reloc_type
)
12058 case 34: /* R_MN10300_ALIGN */
12060 case 33: /* R_MN10300_SYM_DIFF */
12061 if (sym_index
>= num_syms
)
12062 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
12065 saved_sym
= symtab
+ sym_index
;
12068 case 1: /* R_MN10300_32 */
12069 case 2: /* R_MN10300_16 */
12070 if (saved_sym
!= NULL
)
12072 int reloc_size
= reloc_type
== 1 ? 4 : 2;
12075 if (sym_index
>= num_syms
)
12076 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
12080 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12081 - saved_sym
->st_value
);
12083 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12084 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12086 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
12087 (long) reloc
->r_offset
);
12095 if (saved_sym
!= NULL
)
12096 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
12104 static bfd_vma saved_sym1
= 0;
12105 static bfd_vma saved_sym2
= 0;
12106 static bfd_vma value
;
12110 saved_sym1
= saved_sym2
= 0;
12114 switch (reloc_type
)
12116 case 0x80: /* R_RL78_SYM. */
12117 saved_sym1
= saved_sym2
;
12118 if (sym_index
>= num_syms
)
12119 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
12123 saved_sym2
= symtab
[sym_index
].st_value
;
12124 saved_sym2
+= reloc
->r_addend
;
12128 case 0x83: /* R_RL78_OPsub. */
12129 value
= saved_sym1
- saved_sym2
;
12130 saved_sym2
= saved_sym1
= 0;
12134 case 0x41: /* R_RL78_ABS32. */
12135 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 4))
12136 byte_put (start
+ reloc
->r_offset
, value
, 4);
12138 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12139 (long) reloc
->r_offset
);
12143 case 0x43: /* R_RL78_ABS16. */
12144 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 2))
12145 byte_put (start
+ reloc
->r_offset
, value
, 2);
12147 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12148 (long) reloc
->r_offset
);
12162 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12163 DWARF debug sections. This is a target specific test. Note - we do not
12164 go through the whole including-target-headers-multiple-times route, (as
12165 we have already done with <elf/h8.h>) because this would become very
12166 messy and even then this function would have to contain target specific
12167 information (the names of the relocs instead of their numeric values).
12168 FIXME: This is not the correct way to solve this problem. The proper way
12169 is to have target specific reloc sizing and typing functions created by
12170 the reloc-macros.h header, in the same way that it already creates the
12171 reloc naming functions. */
12174 is_32bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12176 /* Please keep this table alpha-sorted for ease of visual lookup. */
12177 switch (filedata
->file_header
.e_machine
)
12181 return reloc_type
== 1; /* R_386_32. */
12183 return reloc_type
== 1; /* R_68K_32. */
12185 return (reloc_type
== 258
12186 || reloc_type
== 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12187 case EM_ADAPTEVA_EPIPHANY
:
12188 return reloc_type
== 3;
12190 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
12192 return reloc_type
== 1; /* R_ARC_32. */
12193 case EM_ARC_COMPACT
:
12194 case EM_ARC_COMPACT2
:
12195 return reloc_type
== 4; /* R_ARC_32. */
12197 return reloc_type
== 2; /* R_ARM_ABS32 */
12200 return reloc_type
== 1;
12202 return reloc_type
== 0x12; /* R_byte4_data. */
12204 return reloc_type
== 3; /* R_CRIS_32. */
12206 return reloc_type
== 3; /* R_CR16_NUM32. */
12208 return reloc_type
== 15; /* R_CRX_NUM32. */
12209 case EM_CYGNUS_FRV
:
12210 return reloc_type
== 1;
12211 case EM_CYGNUS_D10V
:
12213 return reloc_type
== 6; /* R_D10V_32. */
12214 case EM_CYGNUS_D30V
:
12216 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
12218 return reloc_type
== 3; /* R_DLX_RELOC_32. */
12219 case EM_CYGNUS_FR30
:
12221 return reloc_type
== 3; /* R_FR30_32. */
12223 return reloc_type
== 1; /* R_FT32_32. */
12227 return reloc_type
== 1; /* R_H8_DIR32. */
12229 return (reloc_type
== 0x64 /* R_IA64_SECREL32MSB. */
12230 || reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
12231 || reloc_type
== 0x24 /* R_IA64_DIR32MSB. */
12232 || reloc_type
== 0x25 /* R_IA64_DIR32LSB. */);
12235 return reloc_type
== 2; /* R_IP2K_32. */
12237 return reloc_type
== 2; /* R_IQ2000_32. */
12238 case EM_LATTICEMICO32
:
12239 return reloc_type
== 3; /* R_LM32_32. */
12242 return reloc_type
== 3; /* R_M32C_32. */
12244 return reloc_type
== 34; /* R_M32R_32_RELA. */
12247 return reloc_type
== 6; /* R_M68HC11_32. */
12249 return reloc_type
== 1; /* R_MCORE_ADDR32. */
12250 case EM_CYGNUS_MEP
:
12251 return reloc_type
== 4; /* R_MEP_32. */
12253 return reloc_type
== 2; /* R_METAG_ADDR32. */
12254 case EM_MICROBLAZE
:
12255 return reloc_type
== 1; /* R_MICROBLAZE_32. */
12257 return reloc_type
== 2; /* R_MIPS_32. */
12259 return reloc_type
== 4; /* R_MMIX_32. */
12260 case EM_CYGNUS_MN10200
:
12262 return reloc_type
== 1; /* R_MN10200_32. */
12263 case EM_CYGNUS_MN10300
:
12265 return reloc_type
== 1; /* R_MN10300_32. */
12267 return reloc_type
== 1; /* R_MOXIE_32. */
12268 case EM_MSP430_OLD
:
12270 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
12272 return reloc_type
== 2; /* R_MT_32. */
12274 return reloc_type
== 20; /* R_NDS32_RELA. */
12275 case EM_ALTERA_NIOS2
:
12276 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
12278 return reloc_type
== 1; /* R_NIOS_32. */
12280 return reloc_type
== 1; /* R_OR1K_32. */
12282 return (reloc_type
== 1 /* R_PARISC_DIR32. */
12283 || reloc_type
== 41); /* R_PARISC_SECREL32. */
12286 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
12288 return reloc_type
== 1; /* R_PPC64_ADDR32. */
12290 return reloc_type
== 1; /* R_PPC_ADDR32. */
12292 return reloc_type
== 11; /* R_PRU_BFD_RELOC_32. */
12294 return reloc_type
== 1; /* R_RISCV_32. */
12296 return reloc_type
== 1; /* R_RL78_DIR32. */
12298 return reloc_type
== 1; /* R_RX_DIR32. */
12300 return reloc_type
== 1; /* R_I370_ADDR31. */
12303 return reloc_type
== 4; /* R_S390_32. */
12305 return reloc_type
== 8; /* R_SCORE_ABS32. */
12307 return reloc_type
== 1; /* R_SH_DIR32. */
12308 case EM_SPARC32PLUS
:
12311 return reloc_type
== 3 /* R_SPARC_32. */
12312 || reloc_type
== 23; /* R_SPARC_UA32. */
12314 return reloc_type
== 6; /* R_SPU_ADDR32 */
12316 return reloc_type
== 1; /* R_C6000_ABS32. */
12318 return reloc_type
== 2; /* R_TILEGX_32. */
12320 return reloc_type
== 1; /* R_TILEPRO_32. */
12321 case EM_CYGNUS_V850
:
12323 return reloc_type
== 6; /* R_V850_ABS32. */
12325 return reloc_type
== 0x33; /* R_V810_WORD. */
12327 return reloc_type
== 1; /* R_VAX_32. */
12329 return reloc_type
== 3; /* R_VISIUM_32. */
12330 case EM_WEBASSEMBLY
:
12331 return reloc_type
== 1; /* R_WASM32_32. */
12335 return reloc_type
== 10; /* R_X86_64_32. */
12338 return reloc_type
== 3; /* R_XC16C_ABS_32. */
12340 return reloc_type
== 4; /* R_XGATE_32. */
12342 return reloc_type
== 1; /* R_XSTROMY16_32. */
12343 case EM_XTENSA_OLD
:
12345 return reloc_type
== 1; /* R_XTENSA_32. */
12348 static unsigned int prev_warn
= 0;
12350 /* Avoid repeating the same warning multiple times. */
12351 if (prev_warn
!= filedata
->file_header
.e_machine
)
12352 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12353 filedata
->file_header
.e_machine
);
12354 prev_warn
= filedata
->file_header
.e_machine
;
12360 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12361 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
12364 is_32bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12366 switch (filedata
->file_header
.e_machine
)
12367 /* Please keep this table alpha-sorted for ease of visual lookup. */
12371 return reloc_type
== 2; /* R_386_PC32. */
12373 return reloc_type
== 4; /* R_68K_PC32. */
12375 return reloc_type
== 261; /* R_AARCH64_PREL32 */
12376 case EM_ADAPTEVA_EPIPHANY
:
12377 return reloc_type
== 6;
12379 return reloc_type
== 10; /* R_ALPHA_SREL32. */
12380 case EM_ARC_COMPACT
:
12381 case EM_ARC_COMPACT2
:
12382 return reloc_type
== 49; /* R_ARC_32_PCREL. */
12384 return reloc_type
== 3; /* R_ARM_REL32 */
12387 return reloc_type
== 36; /* R_AVR_32_PCREL. */
12388 case EM_MICROBLAZE
:
12389 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
12391 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
12393 return reloc_type
== 9; /* R_PARISC_PCREL32. */
12395 return reloc_type
== 26; /* R_PPC_REL32. */
12397 return reloc_type
== 26; /* R_PPC64_REL32. */
12400 return reloc_type
== 5; /* R_390_PC32. */
12402 return reloc_type
== 2; /* R_SH_REL32. */
12403 case EM_SPARC32PLUS
:
12406 return reloc_type
== 6; /* R_SPARC_DISP32. */
12408 return reloc_type
== 13; /* R_SPU_REL32. */
12410 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
12412 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
12414 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
12418 return reloc_type
== 2; /* R_X86_64_PC32. */
12419 case EM_XTENSA_OLD
:
12421 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
12423 /* Do not abort or issue an error message here. Not all targets use
12424 pc-relative 32-bit relocs in their DWARF debug information and we
12425 have already tested for target coverage in is_32bit_abs_reloc. A
12426 more helpful warning message will be generated by apply_relocations
12427 anyway, so just return. */
12432 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12433 a 64-bit absolute RELA relocation used in DWARF debug sections. */
12436 is_64bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12438 switch (filedata
->file_header
.e_machine
)
12441 return reloc_type
== 257; /* R_AARCH64_ABS64. */
12443 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
12445 return (reloc_type
== 0x26 /* R_IA64_DIR64MSB. */
12446 || reloc_type
== 0x27 /* R_IA64_DIR64LSB. */);
12448 return reloc_type
== 80; /* R_PARISC_DIR64. */
12450 return reloc_type
== 38; /* R_PPC64_ADDR64. */
12452 return reloc_type
== 2; /* R_RISCV_64. */
12453 case EM_SPARC32PLUS
:
12456 return reloc_type
== 32 /* R_SPARC_64. */
12457 || reloc_type
== 54; /* R_SPARC_UA64. */
12461 return reloc_type
== 1; /* R_X86_64_64. */
12464 return reloc_type
== 22; /* R_S390_64. */
12466 return reloc_type
== 1; /* R_TILEGX_64. */
12468 return reloc_type
== 18; /* R_MIPS_64. */
12474 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12475 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
12478 is_64bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12480 switch (filedata
->file_header
.e_machine
)
12483 return reloc_type
== 260; /* R_AARCH64_PREL64. */
12485 return reloc_type
== 11; /* R_ALPHA_SREL64. */
12487 return (reloc_type
== 0x4e /* R_IA64_PCREL64MSB. */
12488 || reloc_type
== 0x4f /* R_IA64_PCREL64LSB. */);
12490 return reloc_type
== 72; /* R_PARISC_PCREL64. */
12492 return reloc_type
== 44; /* R_PPC64_REL64. */
12493 case EM_SPARC32PLUS
:
12496 return reloc_type
== 46; /* R_SPARC_DISP64. */
12500 return reloc_type
== 24; /* R_X86_64_PC64. */
12503 return reloc_type
== 23; /* R_S390_PC64. */
12505 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
12511 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12512 a 24-bit absolute RELA relocation used in DWARF debug sections. */
12515 is_24bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12517 switch (filedata
->file_header
.e_machine
)
12519 case EM_CYGNUS_MN10200
:
12521 return reloc_type
== 4; /* R_MN10200_24. */
12523 return reloc_type
== 5; /* R_FT32_20. */
12529 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12530 a 16-bit absolute RELA relocation used in DWARF debug sections. */
12533 is_16bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12535 /* Please keep this table alpha-sorted for ease of visual lookup. */
12536 switch (filedata
->file_header
.e_machine
)
12539 case EM_ARC_COMPACT
:
12540 case EM_ARC_COMPACT2
:
12541 return reloc_type
== 2; /* R_ARC_16. */
12542 case EM_ADAPTEVA_EPIPHANY
:
12543 return reloc_type
== 5;
12546 return reloc_type
== 4; /* R_AVR_16. */
12547 case EM_CYGNUS_D10V
:
12549 return reloc_type
== 3; /* R_D10V_16. */
12551 return reloc_type
== 2; /* R_FT32_16. */
12555 return reloc_type
== R_H8_DIR16
;
12558 return reloc_type
== 1; /* R_IP2K_16. */
12561 return reloc_type
== 1; /* R_M32C_16 */
12562 case EM_CYGNUS_MN10200
:
12564 return reloc_type
== 2; /* R_MN10200_16. */
12565 case EM_CYGNUS_MN10300
:
12567 return reloc_type
== 2; /* R_MN10300_16. */
12569 if (uses_msp430x_relocs (filedata
))
12570 return reloc_type
== 2; /* R_MSP430_ABS16. */
12571 /* Fall through. */
12572 case EM_MSP430_OLD
:
12573 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
12575 return reloc_type
== 19; /* R_NDS32_RELA. */
12576 case EM_ALTERA_NIOS2
:
12577 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
12579 return reloc_type
== 9; /* R_NIOS_16. */
12581 return reloc_type
== 2; /* R_OR1K_16. */
12583 return reloc_type
== 8; /* R_PRU_BFD_RELOC_16. */
12585 return reloc_type
== 2; /* R_C6000_ABS16. */
12587 return reloc_type
== 2; /* R_VISIUM_16. */
12590 return reloc_type
== 2; /* R_XC16C_ABS_16. */
12592 return reloc_type
== 3; /* R_XGATE_16. */
12598 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12599 a 32-bit inplace add RELA relocation used in DWARF debug sections. */
12602 is_32bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12604 /* Please keep this table alpha-sorted for ease of visual lookup. */
12605 switch (filedata
->file_header
.e_machine
)
12608 return reloc_type
== 35; /* R_RISCV_ADD32. */
12614 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12615 a 32-bit inplace sub RELA relocation used in DWARF debug sections. */
12618 is_32bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12620 /* Please keep this table alpha-sorted for ease of visual lookup. */
12621 switch (filedata
->file_header
.e_machine
)
12624 return reloc_type
== 39; /* R_RISCV_SUB32. */
12630 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12631 a 64-bit inplace add RELA relocation used in DWARF debug sections. */
12634 is_64bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12636 /* Please keep this table alpha-sorted for ease of visual lookup. */
12637 switch (filedata
->file_header
.e_machine
)
12640 return reloc_type
== 36; /* R_RISCV_ADD64. */
12646 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12647 a 64-bit inplace sub RELA relocation used in DWARF debug sections. */
12650 is_64bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12652 /* Please keep this table alpha-sorted for ease of visual lookup. */
12653 switch (filedata
->file_header
.e_machine
)
12656 return reloc_type
== 40; /* R_RISCV_SUB64. */
12662 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12663 a 16-bit inplace add RELA relocation used in DWARF debug sections. */
12666 is_16bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12668 /* Please keep this table alpha-sorted for ease of visual lookup. */
12669 switch (filedata
->file_header
.e_machine
)
12672 return reloc_type
== 34; /* R_RISCV_ADD16. */
12678 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12679 a 16-bit inplace sub RELA relocation used in DWARF debug sections. */
12682 is_16bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12684 /* Please keep this table alpha-sorted for ease of visual lookup. */
12685 switch (filedata
->file_header
.e_machine
)
12688 return reloc_type
== 38; /* R_RISCV_SUB16. */
12694 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12695 a 8-bit inplace add RELA relocation used in DWARF debug sections. */
12698 is_8bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12700 /* Please keep this table alpha-sorted for ease of visual lookup. */
12701 switch (filedata
->file_header
.e_machine
)
12704 return reloc_type
== 33; /* R_RISCV_ADD8. */
12710 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12711 a 8-bit inplace sub RELA relocation used in DWARF debug sections. */
12714 is_8bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12716 /* Please keep this table alpha-sorted for ease of visual lookup. */
12717 switch (filedata
->file_header
.e_machine
)
12720 return reloc_type
== 37; /* R_RISCV_SUB8. */
12726 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
12727 relocation entries (possibly formerly used for SHT_GROUP sections). */
12730 is_none_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12732 switch (filedata
->file_header
.e_machine
)
12734 case EM_386
: /* R_386_NONE. */
12735 case EM_68K
: /* R_68K_NONE. */
12736 case EM_ADAPTEVA_EPIPHANY
:
12737 case EM_ALPHA
: /* R_ALPHA_NONE. */
12738 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
12739 case EM_ARC
: /* R_ARC_NONE. */
12740 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
12741 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
12742 case EM_ARM
: /* R_ARM_NONE. */
12743 case EM_C166
: /* R_XC16X_NONE. */
12744 case EM_CRIS
: /* R_CRIS_NONE. */
12745 case EM_FT32
: /* R_FT32_NONE. */
12746 case EM_IA_64
: /* R_IA64_NONE. */
12747 case EM_K1OM
: /* R_X86_64_NONE. */
12748 case EM_L1OM
: /* R_X86_64_NONE. */
12749 case EM_M32R
: /* R_M32R_NONE. */
12750 case EM_MIPS
: /* R_MIPS_NONE. */
12751 case EM_MN10300
: /* R_MN10300_NONE. */
12752 case EM_MOXIE
: /* R_MOXIE_NONE. */
12753 case EM_NIOS32
: /* R_NIOS_NONE. */
12754 case EM_OR1K
: /* R_OR1K_NONE. */
12755 case EM_PARISC
: /* R_PARISC_NONE. */
12756 case EM_PPC64
: /* R_PPC64_NONE. */
12757 case EM_PPC
: /* R_PPC_NONE. */
12758 case EM_RISCV
: /* R_RISCV_NONE. */
12759 case EM_S390
: /* R_390_NONE. */
12761 case EM_SH
: /* R_SH_NONE. */
12762 case EM_SPARC32PLUS
:
12763 case EM_SPARC
: /* R_SPARC_NONE. */
12765 case EM_TILEGX
: /* R_TILEGX_NONE. */
12766 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
12767 case EM_TI_C6000
:/* R_C6000_NONE. */
12768 case EM_X86_64
: /* R_X86_64_NONE. */
12770 case EM_WEBASSEMBLY
: /* R_WASM32_NONE. */
12771 return reloc_type
== 0;
12774 return reloc_type
== 0 || reloc_type
== 256;
12777 return (reloc_type
== 0 /* R_AVR_NONE. */
12778 || reloc_type
== 30 /* R_AVR_DIFF8. */
12779 || reloc_type
== 31 /* R_AVR_DIFF16. */
12780 || reloc_type
== 32 /* R_AVR_DIFF32. */);
12782 return reloc_type
== 3; /* R_METAG_NONE. */
12784 return (reloc_type
== 0 /* R_XTENSA_NONE. */
12785 || reloc_type
== 204 /* R_NDS32_DIFF8. */
12786 || reloc_type
== 205 /* R_NDS32_DIFF16. */
12787 || reloc_type
== 206 /* R_NDS32_DIFF32. */
12788 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
12790 return (reloc_type
== 0 /* R_PRU_NONE. */
12791 || reloc_type
== 65 /* R_PRU_DIFF8. */
12792 || reloc_type
== 66 /* R_PRU_DIFF16. */
12793 || reloc_type
== 67 /* R_PRU_DIFF32. */);
12794 case EM_XTENSA_OLD
:
12796 return (reloc_type
== 0 /* R_XTENSA_NONE. */
12797 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
12798 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
12799 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
12804 /* Returns TRUE if there is a relocation against
12805 section NAME at OFFSET bytes. */
12808 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
12810 Elf_Internal_Rela
* relocs
;
12811 Elf_Internal_Rela
* rp
;
12813 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
12816 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
12818 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
12819 if (rp
->r_offset
== offset
)
12825 /* Apply relocations to a section.
12826 Returns TRUE upon success, FALSE otherwise.
12827 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
12828 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
12829 will be set to the number of relocs loaded.
12831 Note: So far support has been added only for those relocations
12832 which can be found in debug sections. FIXME: Add support for
12833 more relocations ? */
12836 apply_relocations (Filedata
* filedata
,
12837 const Elf_Internal_Shdr
* section
,
12838 unsigned char * start
,
12839 bfd_size_type size
,
12840 void ** relocs_return
,
12841 unsigned long * num_relocs_return
)
12843 Elf_Internal_Shdr
* relsec
;
12844 unsigned char * end
= start
+ size
;
12845 bfd_boolean res
= TRUE
;
12847 if (relocs_return
!= NULL
)
12849 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
12850 * num_relocs_return
= 0;
12853 if (filedata
->file_header
.e_type
!= ET_REL
)
12854 /* No relocs to apply. */
12857 /* Find the reloc section associated with the section. */
12858 for (relsec
= filedata
->section_headers
;
12859 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
12862 bfd_boolean is_rela
;
12863 unsigned long num_relocs
;
12864 Elf_Internal_Rela
* relocs
;
12865 Elf_Internal_Rela
* rp
;
12866 Elf_Internal_Shdr
* symsec
;
12867 Elf_Internal_Sym
* symtab
;
12868 unsigned long num_syms
;
12869 Elf_Internal_Sym
* sym
;
12871 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
12872 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
12873 || filedata
->section_headers
+ relsec
->sh_info
!= section
12874 || relsec
->sh_size
== 0
12875 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
12878 is_rela
= relsec
->sh_type
== SHT_RELA
;
12882 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
,
12883 relsec
->sh_size
, & relocs
, & num_relocs
))
12888 if (!slurp_rel_relocs (filedata
, relsec
->sh_offset
,
12889 relsec
->sh_size
, & relocs
, & num_relocs
))
12893 /* SH uses RELA but uses in place value instead of the addend field. */
12894 if (filedata
->file_header
.e_machine
== EM_SH
)
12897 symsec
= filedata
->section_headers
+ relsec
->sh_link
;
12898 if (symsec
->sh_type
!= SHT_SYMTAB
12899 && symsec
->sh_type
!= SHT_DYNSYM
)
12901 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & num_syms
);
12903 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
12906 unsigned int reloc_type
;
12907 unsigned int reloc_size
;
12908 bfd_boolean reloc_inplace
= FALSE
;
12909 bfd_boolean reloc_subtract
= FALSE
;
12910 unsigned char * rloc
;
12911 unsigned long sym_index
;
12913 reloc_type
= get_reloc_type (filedata
, rp
->r_info
);
12915 if (target_specific_reloc_handling (filedata
, rp
, start
, end
, symtab
, num_syms
))
12917 else if (is_none_reloc (filedata
, reloc_type
))
12919 else if (is_32bit_abs_reloc (filedata
, reloc_type
)
12920 || is_32bit_pcrel_reloc (filedata
, reloc_type
))
12922 else if (is_64bit_abs_reloc (filedata
, reloc_type
)
12923 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
12925 else if (is_24bit_abs_reloc (filedata
, reloc_type
))
12927 else if (is_16bit_abs_reloc (filedata
, reloc_type
))
12929 else if ((reloc_subtract
= is_32bit_inplace_sub_reloc (filedata
,
12931 || is_32bit_inplace_add_reloc (filedata
, reloc_type
))
12934 reloc_inplace
= TRUE
;
12936 else if ((reloc_subtract
= is_64bit_inplace_sub_reloc (filedata
,
12938 || is_64bit_inplace_add_reloc (filedata
, reloc_type
))
12941 reloc_inplace
= TRUE
;
12943 else if ((reloc_subtract
= is_16bit_inplace_sub_reloc (filedata
,
12945 || is_16bit_inplace_add_reloc (filedata
, reloc_type
))
12948 reloc_inplace
= TRUE
;
12950 else if ((reloc_subtract
= is_8bit_inplace_sub_reloc (filedata
,
12952 || is_8bit_inplace_add_reloc (filedata
, reloc_type
))
12955 reloc_inplace
= TRUE
;
12959 static unsigned int prev_reloc
= 0;
12961 if (reloc_type
!= prev_reloc
)
12962 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
12963 reloc_type
, printable_section_name (filedata
, section
));
12964 prev_reloc
= reloc_type
;
12969 rloc
= start
+ rp
->r_offset
;
12970 if ((rloc
+ reloc_size
) > end
|| (rloc
< start
))
12972 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
12973 (unsigned long) rp
->r_offset
,
12974 printable_section_name (filedata
, section
));
12979 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
12980 if (sym_index
>= num_syms
)
12982 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
12983 sym_index
, printable_section_name (filedata
, section
));
12987 sym
= symtab
+ sym_index
;
12989 /* If the reloc has a symbol associated with it,
12990 make sure that it is of an appropriate type.
12992 Relocations against symbols without type can happen.
12993 Gcc -feliminate-dwarf2-dups may generate symbols
12994 without type for debug info.
12996 Icc generates relocations against function symbols
12997 instead of local labels.
12999 Relocations against object symbols can happen, eg when
13000 referencing a global array. For an example of this see
13001 the _clz.o binary in libgcc.a. */
13003 && ELF_ST_TYPE (sym
->st_info
) != STT_COMMON
13004 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
13006 warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
13007 get_symbol_type (filedata
, ELF_ST_TYPE (sym
->st_info
)),
13008 printable_section_name (filedata
, relsec
),
13009 (long int)(rp
- relocs
));
13016 addend
+= rp
->r_addend
;
13017 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
13018 partial_inplace. */
13020 || (filedata
->file_header
.e_machine
== EM_XTENSA
13021 && reloc_type
== 1)
13022 || ((filedata
->file_header
.e_machine
== EM_PJ
13023 || filedata
->file_header
.e_machine
== EM_PJ_OLD
)
13024 && reloc_type
== 1)
13025 || ((filedata
->file_header
.e_machine
== EM_D30V
13026 || filedata
->file_header
.e_machine
== EM_CYGNUS_D30V
)
13027 && reloc_type
== 12)
13029 addend
+= byte_get (rloc
, reloc_size
);
13031 if (is_32bit_pcrel_reloc (filedata
, reloc_type
)
13032 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
13034 /* On HPPA, all pc-relative relocations are biased by 8. */
13035 if (filedata
->file_header
.e_machine
== EM_PARISC
)
13037 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
13040 else if (reloc_subtract
)
13041 byte_put (rloc
, addend
- sym
->st_value
, reloc_size
);
13043 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
13047 /* Let the target specific reloc processing code know that
13048 we have finished with these relocs. */
13049 target_specific_reloc_handling (filedata
, NULL
, NULL
, NULL
, NULL
, 0);
13053 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
13054 * num_relocs_return
= num_relocs
;
13065 #ifdef SUPPORT_DISASSEMBLY
13067 disassemble_section (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13069 printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata
, section
));
13071 /* FIXME: XXX -- to be done --- XXX */
13077 /* Reads in the contents of SECTION from FILE, returning a pointer
13078 to a malloc'ed buffer or NULL if something went wrong. */
13081 get_section_contents (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13083 bfd_size_type num_bytes
= section
->sh_size
;
13085 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
13087 printf (_("Section '%s' has no data to dump.\n"),
13088 printable_section_name (filedata
, section
));
13092 return (char *) get_data (NULL
, filedata
, section
->sh_offset
, 1, num_bytes
,
13093 _("section contents"));
13096 /* Uncompresses a section that was compressed using zlib, in place. */
13099 uncompress_section_contents (unsigned char ** buffer
,
13100 dwarf_size_type uncompressed_size
,
13101 dwarf_size_type
* size
)
13103 dwarf_size_type compressed_size
= *size
;
13104 unsigned char * compressed_buffer
= *buffer
;
13105 unsigned char * uncompressed_buffer
;
13109 /* It is possible the section consists of several compressed
13110 buffers concatenated together, so we uncompress in a loop. */
13111 /* PR 18313: The state field in the z_stream structure is supposed
13112 to be invisible to the user (ie us), but some compilers will
13113 still complain about it being used without initialisation. So
13114 we first zero the entire z_stream structure and then set the fields
13116 memset (& strm
, 0, sizeof strm
);
13117 strm
.avail_in
= compressed_size
;
13118 strm
.next_in
= (Bytef
*) compressed_buffer
;
13119 strm
.avail_out
= uncompressed_size
;
13120 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
13122 rc
= inflateInit (& strm
);
13123 while (strm
.avail_in
> 0)
13127 strm
.next_out
= ((Bytef
*) uncompressed_buffer
13128 + (uncompressed_size
- strm
.avail_out
));
13129 rc
= inflate (&strm
, Z_FINISH
);
13130 if (rc
!= Z_STREAM_END
)
13132 rc
= inflateReset (& strm
);
13134 rc
= inflateEnd (& strm
);
13136 || strm
.avail_out
!= 0)
13139 *buffer
= uncompressed_buffer
;
13140 *size
= uncompressed_size
;
13144 free (uncompressed_buffer
);
13145 /* Indicate decompression failure. */
13151 dump_section_as_strings (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13153 Elf_Internal_Shdr
* relsec
;
13154 bfd_size_type num_bytes
;
13155 unsigned char * data
;
13156 unsigned char * end
;
13157 unsigned char * real_start
;
13158 unsigned char * start
;
13159 bfd_boolean some_strings_shown
;
13161 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
13163 /* PR 21820: Do not fail if the section was empty. */
13164 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
13166 num_bytes
= section
->sh_size
;
13168 printf (_("\nString dump of section '%s':\n"), printable_section_name (filedata
, section
));
13170 if (decompress_dumps
)
13172 dwarf_size_type new_size
= num_bytes
;
13173 dwarf_size_type uncompressed_size
= 0;
13175 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
13177 Elf_Internal_Chdr chdr
;
13178 unsigned int compression_header_size
13179 = get_compression_header (& chdr
, (unsigned char *) start
,
13182 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13184 warn (_("section '%s' has unsupported compress type: %d\n"),
13185 printable_section_name (filedata
, section
), chdr
.ch_type
);
13188 else if (chdr
.ch_addralign
!= section
->sh_addralign
)
13190 warn (_("compressed section '%s' is corrupted\n"),
13191 printable_section_name (filedata
, section
));
13194 uncompressed_size
= chdr
.ch_size
;
13195 start
+= compression_header_size
;
13196 new_size
-= compression_header_size
;
13198 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
13200 /* Read the zlib header. In this case, it should be "ZLIB"
13201 followed by the uncompressed section size, 8 bytes in
13202 big-endian order. */
13203 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13204 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13205 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13206 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13207 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13208 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13209 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13210 uncompressed_size
+= start
[11];
13215 if (uncompressed_size
)
13217 if (uncompress_section_contents (& start
,
13218 uncompressed_size
, & new_size
))
13219 num_bytes
= new_size
;
13222 error (_("Unable to decompress section %s\n"),
13223 printable_section_name (filedata
, section
));
13228 start
= real_start
;
13231 /* If the section being dumped has relocations against it the user might
13232 be expecting these relocations to have been applied. Check for this
13233 case and issue a warning message in order to avoid confusion.
13234 FIXME: Maybe we ought to have an option that dumps a section with
13235 relocs applied ? */
13236 for (relsec
= filedata
->section_headers
;
13237 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13240 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13241 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13242 || filedata
->section_headers
+ relsec
->sh_info
!= section
13243 || relsec
->sh_size
== 0
13244 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13247 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13252 end
= start
+ num_bytes
;
13253 some_strings_shown
= FALSE
;
13257 while (!ISPRINT (* data
))
13258 if (++ data
>= end
)
13263 size_t maxlen
= end
- data
;
13266 /* PR 11128: Use two separate invocations in order to work
13267 around bugs in the Solaris 8 implementation of printf. */
13268 printf (" [%6tx] ", data
- start
);
13270 printf (" [%6Ix] ", (size_t) (data
- start
));
13274 print_symbol ((int) maxlen
, (const char *) data
);
13276 data
+= strnlen ((const char *) data
, maxlen
);
13280 printf (_("<corrupt>\n"));
13283 some_strings_shown
= TRUE
;
13287 if (! some_strings_shown
)
13288 printf (_(" No strings found in this section."));
13297 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
13298 Filedata
* filedata
,
13299 bfd_boolean relocate
)
13301 Elf_Internal_Shdr
* relsec
;
13302 bfd_size_type bytes
;
13303 bfd_size_type section_size
;
13305 unsigned char * data
;
13306 unsigned char * real_start
;
13307 unsigned char * start
;
13309 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
13311 /* PR 21820: Do not fail if the section was empty. */
13312 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
13314 section_size
= section
->sh_size
;
13316 printf (_("\nHex dump of section '%s':\n"), printable_section_name (filedata
, section
));
13318 if (decompress_dumps
)
13320 dwarf_size_type new_size
= section_size
;
13321 dwarf_size_type uncompressed_size
= 0;
13323 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
13325 Elf_Internal_Chdr chdr
;
13326 unsigned int compression_header_size
13327 = get_compression_header (& chdr
, start
, section_size
);
13329 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13331 warn (_("section '%s' has unsupported compress type: %d\n"),
13332 printable_section_name (filedata
, section
), chdr
.ch_type
);
13335 else if (chdr
.ch_addralign
!= section
->sh_addralign
)
13337 warn (_("compressed section '%s' is corrupted\n"),
13338 printable_section_name (filedata
, section
));
13341 uncompressed_size
= chdr
.ch_size
;
13342 start
+= compression_header_size
;
13343 new_size
-= compression_header_size
;
13345 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
13347 /* Read the zlib header. In this case, it should be "ZLIB"
13348 followed by the uncompressed section size, 8 bytes in
13349 big-endian order. */
13350 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13351 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13352 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13353 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13354 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13355 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13356 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13357 uncompressed_size
+= start
[11];
13362 if (uncompressed_size
)
13364 if (uncompress_section_contents (& start
, uncompressed_size
,
13367 section_size
= new_size
;
13371 error (_("Unable to decompress section %s\n"),
13372 printable_section_name (filedata
, section
));
13373 /* FIXME: Print the section anyway ? */
13378 start
= real_start
;
13383 if (! apply_relocations (filedata
, section
, start
, section_size
, NULL
, NULL
))
13388 /* If the section being dumped has relocations against it the user might
13389 be expecting these relocations to have been applied. Check for this
13390 case and issue a warning message in order to avoid confusion.
13391 FIXME: Maybe we ought to have an option that dumps a section with
13392 relocs applied ? */
13393 for (relsec
= filedata
->section_headers
;
13394 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13397 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13398 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13399 || filedata
->section_headers
+ relsec
->sh_info
!= section
13400 || relsec
->sh_size
== 0
13401 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13404 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13409 addr
= section
->sh_addr
;
13410 bytes
= section_size
;
13419 lbytes
= (bytes
> 16 ? 16 : bytes
);
13421 printf (" 0x%8.8lx ", (unsigned long) addr
);
13423 for (j
= 0; j
< 16; j
++)
13426 printf ("%2.2x", data
[j
]);
13434 for (j
= 0; j
< lbytes
; j
++)
13437 if (k
>= ' ' && k
< 0x7f)
13457 load_specific_debug_section (enum dwarf_section_display_enum debug
,
13458 const Elf_Internal_Shdr
* sec
,
13461 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13463 Filedata
* filedata
= (Filedata
*) data
;
13465 if (section
->start
!= NULL
)
13467 /* If it is already loaded, do nothing. */
13468 if (streq (section
->filename
, filedata
->file_name
))
13470 free (section
->start
);
13473 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
13474 section
->address
= sec
->sh_addr
;
13475 section
->user_data
= NULL
;
13476 section
->filename
= filedata
->file_name
;
13477 section
->start
= (unsigned char *) get_data (NULL
, filedata
,
13479 sec
->sh_size
, buf
);
13480 if (section
->start
== NULL
)
13484 unsigned char *start
= section
->start
;
13485 dwarf_size_type size
= sec
->sh_size
;
13486 dwarf_size_type uncompressed_size
= 0;
13488 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
13490 Elf_Internal_Chdr chdr
;
13491 unsigned int compression_header_size
;
13493 if (size
< (is_32bit_elf
13494 ? sizeof (Elf32_External_Chdr
)
13495 : sizeof (Elf64_External_Chdr
)))
13497 warn (_("compressed section %s is too small to contain a compression header"),
13502 compression_header_size
= get_compression_header (&chdr
, start
, size
);
13504 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13506 warn (_("section '%s' has unsupported compress type: %d\n"),
13507 section
->name
, chdr
.ch_type
);
13510 else if (chdr
.ch_addralign
!= sec
->sh_addralign
)
13512 warn (_("compressed section '%s' is corrupted\n"),
13516 uncompressed_size
= chdr
.ch_size
;
13517 start
+= compression_header_size
;
13518 size
-= compression_header_size
;
13520 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
13522 /* Read the zlib header. In this case, it should be "ZLIB"
13523 followed by the uncompressed section size, 8 bytes in
13524 big-endian order. */
13525 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13526 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13527 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13528 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13529 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13530 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13531 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13532 uncompressed_size
+= start
[11];
13537 if (uncompressed_size
)
13539 if (uncompress_section_contents (&start
, uncompressed_size
,
13542 /* Free the compressed buffer, update the section buffer
13543 and the section size if uncompress is successful. */
13544 free (section
->start
);
13545 section
->start
= start
;
13549 error (_("Unable to decompress section %s\n"),
13550 printable_section_name (filedata
, sec
));
13555 section
->size
= size
;
13558 if (section
->start
== NULL
)
13561 if (debug_displays
[debug
].relocate
)
13563 if (! apply_relocations (filedata
, sec
, section
->start
, section
->size
,
13564 & section
->reloc_info
, & section
->num_relocs
))
13569 section
->reloc_info
= NULL
;
13570 section
->num_relocs
= 0;
13576 /* If this is not NULL, load_debug_section will only look for sections
13577 within the list of sections given here. */
13578 static unsigned int * section_subset
= NULL
;
13581 load_debug_section (enum dwarf_section_display_enum debug
, void * data
)
13583 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13584 Elf_Internal_Shdr
* sec
;
13585 Filedata
* filedata
= (Filedata
*) data
;
13587 /* Without section headers we cannot find any sections. */
13588 if (filedata
->section_headers
== NULL
)
13591 if (filedata
->string_table
== NULL
13592 && filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
13593 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
13595 Elf_Internal_Shdr
* strs
;
13597 /* Read in the string table, so that we have section names to scan. */
13598 strs
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
13600 if (strs
!= NULL
&& strs
->sh_size
!= 0)
13602 filedata
->string_table
13603 = (char *) get_data (NULL
, filedata
, strs
->sh_offset
,
13604 1, strs
->sh_size
, _("string table"));
13606 filedata
->string_table_length
13607 = filedata
->string_table
!= NULL
? strs
->sh_size
: 0;
13611 /* Locate the debug section. */
13612 sec
= find_section_in_set (filedata
, section
->uncompressed_name
, section_subset
);
13614 section
->name
= section
->uncompressed_name
;
13617 sec
= find_section_in_set (filedata
, section
->compressed_name
, section_subset
);
13619 section
->name
= section
->compressed_name
;
13624 /* If we're loading from a subset of sections, and we've loaded
13625 a section matching this name before, it's likely that it's a
13627 if (section_subset
!= NULL
)
13628 free_debug_section (debug
);
13630 return load_specific_debug_section (debug
, sec
, data
);
13634 free_debug_section (enum dwarf_section_display_enum debug
)
13636 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13638 if (section
->start
== NULL
)
13641 free ((char *) section
->start
);
13642 section
->start
= NULL
;
13643 section
->address
= 0;
13648 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13650 char * name
= SECTION_NAME (section
);
13651 const char * print_name
= printable_section_name (filedata
, section
);
13652 bfd_size_type length
;
13653 bfd_boolean result
= TRUE
;
13656 length
= section
->sh_size
;
13659 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
13662 if (section
->sh_type
== SHT_NOBITS
)
13664 /* There is no point in dumping the contents of a debugging section
13665 which has the NOBITS type - the bits in the file will be random.
13666 This can happen when a file containing a .eh_frame section is
13667 stripped with the --only-keep-debug command line option. */
13668 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
13673 if (const_strneq (name
, ".gnu.linkonce.wi."))
13674 name
= ".debug_info";
13676 /* See if we know how to display the contents of this section. */
13677 for (i
= 0; i
< max
; i
++)
13679 enum dwarf_section_display_enum id
= (enum dwarf_section_display_enum
) i
;
13680 struct dwarf_section_display
* display
= debug_displays
+ i
;
13681 struct dwarf_section
* sec
= & display
->section
;
13683 if (streq (sec
->uncompressed_name
, name
)
13684 || (id
== line
&& const_strneq (name
, ".debug_line."))
13685 || streq (sec
->compressed_name
, name
))
13687 bfd_boolean secondary
= (section
!= find_section (filedata
, name
));
13690 free_debug_section (id
);
13692 if (i
== line
&& const_strneq (name
, ".debug_line."))
13694 else if (streq (sec
->uncompressed_name
, name
))
13695 sec
->name
= sec
->uncompressed_name
;
13697 sec
->name
= sec
->compressed_name
;
13699 if (load_specific_debug_section (id
, section
, filedata
))
13701 /* If this debug section is part of a CU/TU set in a .dwp file,
13702 restrict load_debug_section to the sections in that set. */
13703 section_subset
= find_cu_tu_set (filedata
, shndx
);
13705 result
&= display
->display (sec
, filedata
);
13707 section_subset
= NULL
;
13709 if (secondary
|| (id
!= info
&& id
!= abbrev
))
13710 free_debug_section (id
);
13718 printf (_("Unrecognized debug section: %s\n"), print_name
);
13725 /* Set DUMP_SECTS for all sections where dumps were requested
13726 based on section name. */
13729 initialise_dumps_byname (Filedata
* filedata
)
13731 struct dump_list_entry
* cur
;
13733 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
13736 bfd_boolean any
= FALSE
;
13738 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
13739 if (streq (SECTION_NAME (filedata
->section_headers
+ i
), cur
->name
))
13741 request_dump_bynumber (filedata
, i
, cur
->type
);
13746 warn (_("Section '%s' was not dumped because it does not exist!\n"),
13752 process_section_contents (Filedata
* filedata
)
13754 Elf_Internal_Shdr
* section
;
13756 bfd_boolean res
= TRUE
;
13761 initialise_dumps_byname (filedata
);
13763 for (i
= 0, section
= filedata
->section_headers
;
13764 i
< filedata
->file_header
.e_shnum
&& i
< filedata
->num_dump_sects
;
13767 dump_type dump
= filedata
->dump_sects
[i
];
13769 #ifdef SUPPORT_DISASSEMBLY
13770 if (dump
& DISASS_DUMP
)
13772 if (! disassemble_section (section
, filedata
))
13776 if (dump
& HEX_DUMP
)
13778 if (! dump_section_as_bytes (section
, filedata
, FALSE
))
13782 if (dump
& RELOC_DUMP
)
13784 if (! dump_section_as_bytes (section
, filedata
, TRUE
))
13788 if (dump
& STRING_DUMP
)
13790 if (! dump_section_as_strings (section
, filedata
))
13794 if (dump
& DEBUG_DUMP
)
13796 if (! display_debug_section (i
, section
, filedata
))
13801 /* Check to see if the user requested a
13802 dump of a section that does not exist. */
13803 while (i
< filedata
->num_dump_sects
)
13805 if (filedata
->dump_sects
[i
])
13807 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
13817 process_mips_fpe_exception (int mask
)
13821 bfd_boolean first
= TRUE
;
13823 if (mask
& OEX_FPU_INEX
)
13824 fputs ("INEX", stdout
), first
= FALSE
;
13825 if (mask
& OEX_FPU_UFLO
)
13826 printf ("%sUFLO", first
? "" : "|"), first
= FALSE
;
13827 if (mask
& OEX_FPU_OFLO
)
13828 printf ("%sOFLO", first
? "" : "|"), first
= FALSE
;
13829 if (mask
& OEX_FPU_DIV0
)
13830 printf ("%sDIV0", first
? "" : "|"), first
= FALSE
;
13831 if (mask
& OEX_FPU_INVAL
)
13832 printf ("%sINVAL", first
? "" : "|");
13835 fputs ("0", stdout
);
13838 /* Display's the value of TAG at location P. If TAG is
13839 greater than 0 it is assumed to be an unknown tag, and
13840 a message is printed to this effect. Otherwise it is
13841 assumed that a message has already been printed.
13843 If the bottom bit of TAG is set it assumed to have a
13844 string value, otherwise it is assumed to have an integer
13847 Returns an updated P pointing to the first unread byte
13848 beyond the end of TAG's value.
13850 Reads at or beyond END will not be made. */
13852 static unsigned char *
13853 display_tag_value (signed int tag
,
13855 const unsigned char * const end
)
13860 printf (" Tag_unknown_%d: ", tag
);
13864 warn (_("<corrupt tag>\n"));
13868 /* PR 17531 file: 027-19978-0.004. */
13869 size_t maxlen
= (end
- p
) - 1;
13874 print_symbol ((int) maxlen
, (const char *) p
);
13875 p
+= strnlen ((char *) p
, maxlen
) + 1;
13879 printf (_("<corrupt string tag>"));
13880 p
= (unsigned char *) end
;
13888 val
= read_uleb128 (p
, &len
, end
);
13890 printf ("%ld (0x%lx)\n", val
, val
);
13897 /* ARC ABI attributes section. */
13899 static unsigned char *
13900 display_arc_attribute (unsigned char * p
,
13901 const unsigned char * const end
)
13907 tag
= read_uleb128 (p
, &len
, end
);
13912 case Tag_ARC_PCS_config
:
13913 val
= read_uleb128 (p
, &len
, end
);
13915 printf (" Tag_ARC_PCS_config: ");
13919 printf (_("Absent/Non standard\n"));
13922 printf (_("Bare metal/mwdt\n"));
13925 printf (_("Bare metal/newlib\n"));
13928 printf (_("Linux/uclibc\n"));
13931 printf (_("Linux/glibc\n"));
13934 printf (_("Unknown\n"));
13939 case Tag_ARC_CPU_base
:
13940 val
= read_uleb128 (p
, &len
, end
);
13942 printf (" Tag_ARC_CPU_base: ");
13947 printf (_("Absent\n"));
13949 case TAG_CPU_ARC6xx
:
13950 printf ("ARC6xx\n");
13952 case TAG_CPU_ARC7xx
:
13953 printf ("ARC7xx\n");
13955 case TAG_CPU_ARCEM
:
13956 printf ("ARCEM\n");
13958 case TAG_CPU_ARCHS
:
13959 printf ("ARCHS\n");
13964 case Tag_ARC_CPU_variation
:
13965 val
= read_uleb128 (p
, &len
, end
);
13967 printf (" Tag_ARC_CPU_variation: ");
13971 if (val
> 0 && val
< 16)
13972 printf ("Core%d\n", val
);
13974 printf ("Unknown\n");
13978 printf (_("Absent\n"));
13983 case Tag_ARC_CPU_name
:
13984 printf (" Tag_ARC_CPU_name: ");
13985 p
= display_tag_value (-1, p
, end
);
13988 case Tag_ARC_ABI_rf16
:
13989 val
= read_uleb128 (p
, &len
, end
);
13991 printf (" Tag_ARC_ABI_rf16: %s\n", val
? _("yes") : _("no"));
13994 case Tag_ARC_ABI_osver
:
13995 val
= read_uleb128 (p
, &len
, end
);
13997 printf (" Tag_ARC_ABI_osver: v%d\n", val
);
14000 case Tag_ARC_ABI_pic
:
14001 case Tag_ARC_ABI_sda
:
14002 val
= read_uleb128 (p
, &len
, end
);
14004 printf (tag
== Tag_ARC_ABI_sda
? " Tag_ARC_ABI_sda: "
14005 : " Tag_ARC_ABI_pic: ");
14009 printf (_("Absent\n"));
14018 printf (_("Unknown\n"));
14023 case Tag_ARC_ABI_tls
:
14024 val
= read_uleb128 (p
, &len
, end
);
14026 printf (" Tag_ARC_ABI_tls: %s\n", val
? "r25": "none");
14029 case Tag_ARC_ABI_enumsize
:
14030 val
= read_uleb128 (p
, &len
, end
);
14032 printf (" Tag_ARC_ABI_enumsize: %s\n", val
? _("default") :
14036 case Tag_ARC_ABI_exceptions
:
14037 val
= read_uleb128 (p
, &len
, end
);
14039 printf (" Tag_ARC_ABI_exceptions: %s\n", val
? _("OPTFP")
14043 case Tag_ARC_ABI_double_size
:
14044 val
= read_uleb128 (p
, &len
, end
);
14046 printf (" Tag_ARC_ABI_double_size: %d\n", val
);
14049 case Tag_ARC_ISA_config
:
14050 printf (" Tag_ARC_ISA_config: ");
14051 p
= display_tag_value (-1, p
, end
);
14054 case Tag_ARC_ISA_apex
:
14055 printf (" Tag_ARC_ISA_apex: ");
14056 p
= display_tag_value (-1, p
, end
);
14059 case Tag_ARC_ISA_mpy_option
:
14060 val
= read_uleb128 (p
, &len
, end
);
14062 printf (" Tag_ARC_ISA_mpy_option: %d\n", val
);
14066 return display_tag_value (tag
& 1, p
, end
);
14072 /* ARM EABI attributes section. */
14077 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
14079 const char ** table
;
14080 } arm_attr_public_tag
;
14082 static const char * arm_attr_tag_CPU_arch
[] =
14083 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
14084 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
14086 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
14087 static const char * arm_attr_tag_THUMB_ISA_use
[] =
14088 {"No", "Thumb-1", "Thumb-2", "Yes"};
14089 static const char * arm_attr_tag_FP_arch
[] =
14090 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
14091 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
14092 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
14093 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
14094 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
14095 "NEON for ARMv8.1"};
14096 static const char * arm_attr_tag_PCS_config
[] =
14097 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
14098 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
14099 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
14100 {"V6", "SB", "TLS", "Unused"};
14101 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
14102 {"Absolute", "PC-relative", "SB-relative", "None"};
14103 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
14104 {"Absolute", "PC-relative", "None"};
14105 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
14106 {"None", "direct", "GOT-indirect"};
14107 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
14108 {"None", "??? 1", "2", "??? 3", "4"};
14109 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
14110 static const char * arm_attr_tag_ABI_FP_denormal
[] =
14111 {"Unused", "Needed", "Sign only"};
14112 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
14113 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
14114 static const char * arm_attr_tag_ABI_FP_number_model
[] =
14115 {"Unused", "Finite", "RTABI", "IEEE 754"};
14116 static const char * arm_attr_tag_ABI_enum_size
[] =
14117 {"Unused", "small", "int", "forced to int"};
14118 static const char * arm_attr_tag_ABI_HardFP_use
[] =
14119 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
14120 static const char * arm_attr_tag_ABI_VFP_args
[] =
14121 {"AAPCS", "VFP registers", "custom", "compatible"};
14122 static const char * arm_attr_tag_ABI_WMMX_args
[] =
14123 {"AAPCS", "WMMX registers", "custom"};
14124 static const char * arm_attr_tag_ABI_optimization_goals
[] =
14125 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14126 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
14127 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
14128 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14129 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
14130 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
14131 static const char * arm_attr_tag_FP_HP_extension
[] =
14132 {"Not Allowed", "Allowed"};
14133 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
14134 {"None", "IEEE 754", "Alternative Format"};
14135 static const char * arm_attr_tag_DSP_extension
[] =
14136 {"Follow architecture", "Allowed"};
14137 static const char * arm_attr_tag_MPextension_use
[] =
14138 {"Not Allowed", "Allowed"};
14139 static const char * arm_attr_tag_DIV_use
[] =
14140 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
14141 "Allowed in v7-A with integer division extension"};
14142 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
14143 static const char * arm_attr_tag_Virtualization_use
[] =
14144 {"Not Allowed", "TrustZone", "Virtualization Extensions",
14145 "TrustZone and Virtualization Extensions"};
14146 static const char * arm_attr_tag_MPextension_use_legacy
[] =
14147 {"Not Allowed", "Allowed"};
14149 #define LOOKUP(id, name) \
14150 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
14151 static arm_attr_public_tag arm_attr_public_tags
[] =
14153 {4, "CPU_raw_name", 1, NULL
},
14154 {5, "CPU_name", 1, NULL
},
14155 LOOKUP(6, CPU_arch
),
14156 {7, "CPU_arch_profile", 0, NULL
},
14157 LOOKUP(8, ARM_ISA_use
),
14158 LOOKUP(9, THUMB_ISA_use
),
14159 LOOKUP(10, FP_arch
),
14160 LOOKUP(11, WMMX_arch
),
14161 LOOKUP(12, Advanced_SIMD_arch
),
14162 LOOKUP(13, PCS_config
),
14163 LOOKUP(14, ABI_PCS_R9_use
),
14164 LOOKUP(15, ABI_PCS_RW_data
),
14165 LOOKUP(16, ABI_PCS_RO_data
),
14166 LOOKUP(17, ABI_PCS_GOT_use
),
14167 LOOKUP(18, ABI_PCS_wchar_t
),
14168 LOOKUP(19, ABI_FP_rounding
),
14169 LOOKUP(20, ABI_FP_denormal
),
14170 LOOKUP(21, ABI_FP_exceptions
),
14171 LOOKUP(22, ABI_FP_user_exceptions
),
14172 LOOKUP(23, ABI_FP_number_model
),
14173 {24, "ABI_align_needed", 0, NULL
},
14174 {25, "ABI_align_preserved", 0, NULL
},
14175 LOOKUP(26, ABI_enum_size
),
14176 LOOKUP(27, ABI_HardFP_use
),
14177 LOOKUP(28, ABI_VFP_args
),
14178 LOOKUP(29, ABI_WMMX_args
),
14179 LOOKUP(30, ABI_optimization_goals
),
14180 LOOKUP(31, ABI_FP_optimization_goals
),
14181 {32, "compatibility", 0, NULL
},
14182 LOOKUP(34, CPU_unaligned_access
),
14183 LOOKUP(36, FP_HP_extension
),
14184 LOOKUP(38, ABI_FP_16bit_format
),
14185 LOOKUP(42, MPextension_use
),
14186 LOOKUP(44, DIV_use
),
14187 LOOKUP(46, DSP_extension
),
14188 {64, "nodefaults", 0, NULL
},
14189 {65, "also_compatible_with", 0, NULL
},
14190 LOOKUP(66, T2EE_use
),
14191 {67, "conformance", 1, NULL
},
14192 LOOKUP(68, Virtualization_use
),
14193 LOOKUP(70, MPextension_use_legacy
)
14197 static unsigned char *
14198 display_arm_attribute (unsigned char * p
,
14199 const unsigned char * const end
)
14204 arm_attr_public_tag
* attr
;
14208 tag
= read_uleb128 (p
, &len
, end
);
14211 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
14213 if (arm_attr_public_tags
[i
].tag
== tag
)
14215 attr
= &arm_attr_public_tags
[i
];
14222 printf (" Tag_%s: ", attr
->name
);
14223 switch (attr
->type
)
14228 case 7: /* Tag_CPU_arch_profile. */
14229 val
= read_uleb128 (p
, &len
, end
);
14233 case 0: printf (_("None\n")); break;
14234 case 'A': printf (_("Application\n")); break;
14235 case 'R': printf (_("Realtime\n")); break;
14236 case 'M': printf (_("Microcontroller\n")); break;
14237 case 'S': printf (_("Application or Realtime\n")); break;
14238 default: printf ("??? (%d)\n", val
); break;
14242 case 24: /* Tag_align_needed. */
14243 val
= read_uleb128 (p
, &len
, end
);
14247 case 0: printf (_("None\n")); break;
14248 case 1: printf (_("8-byte\n")); break;
14249 case 2: printf (_("4-byte\n")); break;
14250 case 3: printf ("??? 3\n"); break;
14253 printf (_("8-byte and up to %d-byte extended\n"),
14256 printf ("??? (%d)\n", val
);
14261 case 25: /* Tag_align_preserved. */
14262 val
= read_uleb128 (p
, &len
, end
);
14266 case 0: printf (_("None\n")); break;
14267 case 1: printf (_("8-byte, except leaf SP\n")); break;
14268 case 2: printf (_("8-byte\n")); break;
14269 case 3: printf ("??? 3\n"); break;
14272 printf (_("8-byte and up to %d-byte extended\n"),
14275 printf ("??? (%d)\n", val
);
14280 case 32: /* Tag_compatibility. */
14282 val
= read_uleb128 (p
, &len
, end
);
14284 printf (_("flag = %d, vendor = "), val
);
14287 size_t maxlen
= (end
- p
) - 1;
14289 print_symbol ((int) maxlen
, (const char *) p
);
14290 p
+= strnlen ((char *) p
, maxlen
) + 1;
14294 printf (_("<corrupt>"));
14295 p
= (unsigned char *) end
;
14301 case 64: /* Tag_nodefaults. */
14302 /* PR 17531: file: 001-505008-0.01. */
14305 printf (_("True\n"));
14308 case 65: /* Tag_also_compatible_with. */
14309 val
= read_uleb128 (p
, &len
, end
);
14311 if (val
== 6 /* Tag_CPU_arch. */)
14313 val
= read_uleb128 (p
, &len
, end
);
14315 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
14316 printf ("??? (%d)\n", val
);
14318 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
14322 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
14327 printf (_("<unknown: %d>\n"), tag
);
14333 return display_tag_value (-1, p
, end
);
14335 return display_tag_value (0, p
, end
);
14338 assert (attr
->type
& 0x80);
14339 val
= read_uleb128 (p
, &len
, end
);
14341 type
= attr
->type
& 0x7f;
14343 printf ("??? (%d)\n", val
);
14345 printf ("%s\n", attr
->table
[val
]);
14350 return display_tag_value (tag
, p
, end
);
14353 static unsigned char *
14354 display_gnu_attribute (unsigned char * p
,
14355 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const),
14356 const unsigned char * const end
)
14362 tag
= read_uleb128 (p
, &len
, end
);
14365 /* Tag_compatibility is the only generic GNU attribute defined at
14369 val
= read_uleb128 (p
, &len
, end
);
14372 printf (_("flag = %d, vendor = "), val
);
14375 printf (_("<corrupt>\n"));
14376 warn (_("corrupt vendor attribute\n"));
14382 size_t maxlen
= (end
- p
) - 1;
14384 print_symbol ((int) maxlen
, (const char *) p
);
14385 p
+= strnlen ((char *) p
, maxlen
) + 1;
14389 printf (_("<corrupt>"));
14390 p
= (unsigned char *) end
;
14397 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
14398 return display_proc_gnu_attribute (p
, tag
, end
);
14400 return display_tag_value (tag
, p
, end
);
14403 static unsigned char *
14404 display_power_gnu_attribute (unsigned char * p
,
14406 const unsigned char * const end
)
14411 if (tag
== Tag_GNU_Power_ABI_FP
)
14413 val
= read_uleb128 (p
, &len
, end
);
14415 printf (" Tag_GNU_Power_ABI_FP: ");
14418 printf (_("<corrupt>\n"));
14423 printf ("(%#x), ", val
);
14428 printf (_("unspecified hard/soft float, "));
14431 printf (_("hard float, "));
14434 printf (_("soft float, "));
14437 printf (_("single-precision hard float, "));
14444 printf (_("unspecified long double\n"));
14447 printf (_("128-bit IBM long double\n"));
14450 printf (_("64-bit long double\n"));
14453 printf (_("128-bit IEEE long double\n"));
14459 if (tag
== Tag_GNU_Power_ABI_Vector
)
14461 val
= read_uleb128 (p
, &len
, end
);
14463 printf (" Tag_GNU_Power_ABI_Vector: ");
14466 printf (_("<corrupt>\n"));
14471 printf ("(%#x), ", val
);
14476 printf (_("unspecified\n"));
14479 printf (_("generic\n"));
14482 printf ("AltiVec\n");
14491 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
14493 val
= read_uleb128 (p
, &len
, end
);
14495 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
14498 printf (_("<corrupt>\n"));
14503 printf ("(%#x), ", val
);
14508 printf (_("unspecified\n"));
14511 printf ("r3/r4\n");
14514 printf (_("memory\n"));
14523 return display_tag_value (tag
& 1, p
, end
);
14526 static unsigned char *
14527 display_s390_gnu_attribute (unsigned char * p
,
14529 const unsigned char * const end
)
14534 if (tag
== Tag_GNU_S390_ABI_Vector
)
14536 val
= read_uleb128 (p
, &len
, end
);
14538 printf (" Tag_GNU_S390_ABI_Vector: ");
14543 printf (_("any\n"));
14546 printf (_("software\n"));
14549 printf (_("hardware\n"));
14552 printf ("??? (%d)\n", val
);
14558 return display_tag_value (tag
& 1, p
, end
);
14562 display_sparc_hwcaps (unsigned int mask
)
14566 bfd_boolean first
= TRUE
;
14568 if (mask
& ELF_SPARC_HWCAP_MUL32
)
14569 fputs ("mul32", stdout
), first
= FALSE
;
14570 if (mask
& ELF_SPARC_HWCAP_DIV32
)
14571 printf ("%sdiv32", first
? "" : "|"), first
= FALSE
;
14572 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
14573 printf ("%sfsmuld", first
? "" : "|"), first
= FALSE
;
14574 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
14575 printf ("%sv8plus", first
? "" : "|"), first
= FALSE
;
14576 if (mask
& ELF_SPARC_HWCAP_POPC
)
14577 printf ("%spopc", first
? "" : "|"), first
= FALSE
;
14578 if (mask
& ELF_SPARC_HWCAP_VIS
)
14579 printf ("%svis", first
? "" : "|"), first
= FALSE
;
14580 if (mask
& ELF_SPARC_HWCAP_VIS2
)
14581 printf ("%svis2", first
? "" : "|"), first
= FALSE
;
14582 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
14583 printf ("%sASIBlkInit", first
? "" : "|"), first
= FALSE
;
14584 if (mask
& ELF_SPARC_HWCAP_FMAF
)
14585 printf ("%sfmaf", first
? "" : "|"), first
= FALSE
;
14586 if (mask
& ELF_SPARC_HWCAP_VIS3
)
14587 printf ("%svis3", first
? "" : "|"), first
= FALSE
;
14588 if (mask
& ELF_SPARC_HWCAP_HPC
)
14589 printf ("%shpc", first
? "" : "|"), first
= FALSE
;
14590 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
14591 printf ("%srandom", first
? "" : "|"), first
= FALSE
;
14592 if (mask
& ELF_SPARC_HWCAP_TRANS
)
14593 printf ("%strans", first
? "" : "|"), first
= FALSE
;
14594 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
14595 printf ("%sfjfmau", first
? "" : "|"), first
= FALSE
;
14596 if (mask
& ELF_SPARC_HWCAP_IMA
)
14597 printf ("%sima", first
? "" : "|"), first
= FALSE
;
14598 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
14599 printf ("%scspare", first
? "" : "|"), first
= FALSE
;
14602 fputc ('0', stdout
);
14603 fputc ('\n', stdout
);
14607 display_sparc_hwcaps2 (unsigned int mask
)
14611 bfd_boolean first
= TRUE
;
14613 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
14614 fputs ("fjathplus", stdout
), first
= FALSE
;
14615 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
14616 printf ("%svis3b", first
? "" : "|"), first
= FALSE
;
14617 if (mask
& ELF_SPARC_HWCAP2_ADP
)
14618 printf ("%sadp", first
? "" : "|"), first
= FALSE
;
14619 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
14620 printf ("%ssparc5", first
? "" : "|"), first
= FALSE
;
14621 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
14622 printf ("%smwait", first
? "" : "|"), first
= FALSE
;
14623 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
14624 printf ("%sxmpmul", first
? "" : "|"), first
= FALSE
;
14625 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
14626 printf ("%sxmont2", first
? "" : "|"), first
= FALSE
;
14627 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
14628 printf ("%snsec", first
? "" : "|"), first
= FALSE
;
14629 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
14630 printf ("%sfjathhpc", first
? "" : "|"), first
= FALSE
;
14631 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
14632 printf ("%sfjdes", first
? "" : "|"), first
= FALSE
;
14633 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
14634 printf ("%sfjaes", first
? "" : "|"), first
= FALSE
;
14637 fputc ('0', stdout
);
14638 fputc ('\n', stdout
);
14641 static unsigned char *
14642 display_sparc_gnu_attribute (unsigned char * p
,
14644 const unsigned char * const end
)
14649 if (tag
== Tag_GNU_Sparc_HWCAPS
)
14651 val
= read_uleb128 (p
, &len
, end
);
14653 printf (" Tag_GNU_Sparc_HWCAPS: ");
14654 display_sparc_hwcaps (val
);
14657 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
14659 val
= read_uleb128 (p
, &len
, end
);
14661 printf (" Tag_GNU_Sparc_HWCAPS2: ");
14662 display_sparc_hwcaps2 (val
);
14666 return display_tag_value (tag
, p
, end
);
14670 print_mips_fp_abi_value (unsigned int val
)
14674 case Val_GNU_MIPS_ABI_FP_ANY
:
14675 printf (_("Hard or soft float\n"));
14677 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
14678 printf (_("Hard float (double precision)\n"));
14680 case Val_GNU_MIPS_ABI_FP_SINGLE
:
14681 printf (_("Hard float (single precision)\n"));
14683 case Val_GNU_MIPS_ABI_FP_SOFT
:
14684 printf (_("Soft float\n"));
14686 case Val_GNU_MIPS_ABI_FP_OLD_64
:
14687 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
14689 case Val_GNU_MIPS_ABI_FP_XX
:
14690 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
14692 case Val_GNU_MIPS_ABI_FP_64
:
14693 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
14695 case Val_GNU_MIPS_ABI_FP_64A
:
14696 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
14698 case Val_GNU_MIPS_ABI_FP_NAN2008
:
14699 printf (_("NaN 2008 compatibility\n"));
14702 printf ("??? (%d)\n", val
);
14707 static unsigned char *
14708 display_mips_gnu_attribute (unsigned char * p
,
14710 const unsigned char * const end
)
14712 if (tag
== Tag_GNU_MIPS_ABI_FP
)
14717 val
= read_uleb128 (p
, &len
, end
);
14719 printf (" Tag_GNU_MIPS_ABI_FP: ");
14721 print_mips_fp_abi_value (val
);
14726 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
14731 val
= read_uleb128 (p
, &len
, end
);
14733 printf (" Tag_GNU_MIPS_ABI_MSA: ");
14737 case Val_GNU_MIPS_ABI_MSA_ANY
:
14738 printf (_("Any MSA or not\n"));
14740 case Val_GNU_MIPS_ABI_MSA_128
:
14741 printf (_("128-bit MSA\n"));
14744 printf ("??? (%d)\n", val
);
14750 return display_tag_value (tag
& 1, p
, end
);
14753 static unsigned char *
14754 display_tic6x_attribute (unsigned char * p
,
14755 const unsigned char * const end
)
14761 tag
= read_uleb128 (p
, &len
, end
);
14767 val
= read_uleb128 (p
, &len
, end
);
14769 printf (" Tag_ISA: ");
14773 case C6XABI_Tag_ISA_none
:
14774 printf (_("None\n"));
14776 case C6XABI_Tag_ISA_C62X
:
14779 case C6XABI_Tag_ISA_C67X
:
14782 case C6XABI_Tag_ISA_C67XP
:
14783 printf ("C67x+\n");
14785 case C6XABI_Tag_ISA_C64X
:
14788 case C6XABI_Tag_ISA_C64XP
:
14789 printf ("C64x+\n");
14791 case C6XABI_Tag_ISA_C674X
:
14792 printf ("C674x\n");
14795 printf ("??? (%d)\n", val
);
14800 case Tag_ABI_wchar_t
:
14801 val
= read_uleb128 (p
, &len
, end
);
14803 printf (" Tag_ABI_wchar_t: ");
14807 printf (_("Not used\n"));
14810 printf (_("2 bytes\n"));
14813 printf (_("4 bytes\n"));
14816 printf ("??? (%d)\n", val
);
14821 case Tag_ABI_stack_align_needed
:
14822 val
= read_uleb128 (p
, &len
, end
);
14824 printf (" Tag_ABI_stack_align_needed: ");
14828 printf (_("8-byte\n"));
14831 printf (_("16-byte\n"));
14834 printf ("??? (%d)\n", val
);
14839 case Tag_ABI_stack_align_preserved
:
14840 val
= read_uleb128 (p
, &len
, end
);
14842 printf (" Tag_ABI_stack_align_preserved: ");
14846 printf (_("8-byte\n"));
14849 printf (_("16-byte\n"));
14852 printf ("??? (%d)\n", val
);
14858 val
= read_uleb128 (p
, &len
, end
);
14860 printf (" Tag_ABI_DSBT: ");
14864 printf (_("DSBT addressing not used\n"));
14867 printf (_("DSBT addressing used\n"));
14870 printf ("??? (%d)\n", val
);
14876 val
= read_uleb128 (p
, &len
, end
);
14878 printf (" Tag_ABI_PID: ");
14882 printf (_("Data addressing position-dependent\n"));
14885 printf (_("Data addressing position-independent, GOT near DP\n"));
14888 printf (_("Data addressing position-independent, GOT far from DP\n"));
14891 printf ("??? (%d)\n", val
);
14897 val
= read_uleb128 (p
, &len
, end
);
14899 printf (" Tag_ABI_PIC: ");
14903 printf (_("Code addressing position-dependent\n"));
14906 printf (_("Code addressing position-independent\n"));
14909 printf ("??? (%d)\n", val
);
14914 case Tag_ABI_array_object_alignment
:
14915 val
= read_uleb128 (p
, &len
, end
);
14917 printf (" Tag_ABI_array_object_alignment: ");
14921 printf (_("8-byte\n"));
14924 printf (_("4-byte\n"));
14927 printf (_("16-byte\n"));
14930 printf ("??? (%d)\n", val
);
14935 case Tag_ABI_array_object_align_expected
:
14936 val
= read_uleb128 (p
, &len
, end
);
14938 printf (" Tag_ABI_array_object_align_expected: ");
14942 printf (_("8-byte\n"));
14945 printf (_("4-byte\n"));
14948 printf (_("16-byte\n"));
14951 printf ("??? (%d)\n", val
);
14956 case Tag_ABI_compatibility
:
14958 val
= read_uleb128 (p
, &len
, end
);
14960 printf (" Tag_ABI_compatibility: ");
14961 printf (_("flag = %d, vendor = "), val
);
14964 size_t maxlen
= (end
- p
) - 1;
14966 print_symbol ((int) maxlen
, (const char *) p
);
14967 p
+= strnlen ((char *) p
, maxlen
) + 1;
14971 printf (_("<corrupt>"));
14972 p
= (unsigned char *) end
;
14978 case Tag_ABI_conformance
:
14980 printf (" Tag_ABI_conformance: \"");
14983 size_t maxlen
= (end
- p
) - 1;
14985 print_symbol ((int) maxlen
, (const char *) p
);
14986 p
+= strnlen ((char *) p
, maxlen
) + 1;
14990 printf (_("<corrupt>"));
14991 p
= (unsigned char *) end
;
14998 return display_tag_value (tag
, p
, end
);
15002 display_raw_attribute (unsigned char * p
, unsigned char const * const end
)
15004 unsigned long addr
= 0;
15005 size_t bytes
= end
- p
;
15012 int lbytes
= (bytes
> 16 ? 16 : bytes
);
15014 printf (" 0x%8.8lx ", addr
);
15016 for (j
= 0; j
< 16; j
++)
15019 printf ("%2.2x", p
[j
]);
15027 for (j
= 0; j
< lbytes
; j
++)
15030 if (k
>= ' ' && k
< 0x7f)
15046 static unsigned char *
15047 display_msp430x_attribute (unsigned char * p
,
15048 const unsigned char * const end
)
15054 tag
= read_uleb128 (p
, & len
, end
);
15059 case OFBA_MSPABI_Tag_ISA
:
15060 val
= read_uleb128 (p
, &len
, end
);
15062 printf (" Tag_ISA: ");
15065 case 0: printf (_("None\n")); break;
15066 case 1: printf (_("MSP430\n")); break;
15067 case 2: printf (_("MSP430X\n")); break;
15068 default: printf ("??? (%d)\n", val
); break;
15072 case OFBA_MSPABI_Tag_Code_Model
:
15073 val
= read_uleb128 (p
, &len
, end
);
15075 printf (" Tag_Code_Model: ");
15078 case 0: printf (_("None\n")); break;
15079 case 1: printf (_("Small\n")); break;
15080 case 2: printf (_("Large\n")); break;
15081 default: printf ("??? (%d)\n", val
); break;
15085 case OFBA_MSPABI_Tag_Data_Model
:
15086 val
= read_uleb128 (p
, &len
, end
);
15088 printf (" Tag_Data_Model: ");
15091 case 0: printf (_("None\n")); break;
15092 case 1: printf (_("Small\n")); break;
15093 case 2: printf (_("Large\n")); break;
15094 case 3: printf (_("Restricted Large\n")); break;
15095 default: printf ("??? (%d)\n", val
); break;
15100 printf (_(" <unknown tag %d>: "), tag
);
15107 size_t maxlen
= (end
- p
) - 1;
15109 print_symbol ((int) maxlen
, (const char *) p
);
15110 p
+= strnlen ((char *) p
, maxlen
) + 1;
15114 printf (_("<corrupt>"));
15115 p
= (unsigned char *) end
;
15121 val
= read_uleb128 (p
, &len
, end
);
15123 printf ("%d (0x%x)\n", val
, val
);
15133 process_attributes (Filedata
* filedata
,
15134 const char * public_name
,
15135 unsigned int proc_type
,
15136 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
15137 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const))
15139 Elf_Internal_Shdr
* sect
;
15141 bfd_boolean res
= TRUE
;
15143 /* Find the section header so that we get the size. */
15144 for (i
= 0, sect
= filedata
->section_headers
;
15145 i
< filedata
->file_header
.e_shnum
;
15148 unsigned char * contents
;
15151 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
15154 contents
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
, 1,
15155 sect
->sh_size
, _("attributes"));
15156 if (contents
== NULL
)
15163 /* The first character is the version of the attributes.
15164 Currently only version 1, (aka 'A') is recognised here. */
15167 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p
, *p
);
15172 bfd_vma section_len
;
15174 section_len
= sect
->sh_size
- 1;
15177 while (section_len
> 0)
15180 unsigned int namelen
;
15181 bfd_boolean public_section
;
15182 bfd_boolean gnu_section
;
15184 if (section_len
<= 4)
15186 error (_("Tag section ends prematurely\n"));
15190 attr_len
= byte_get (p
, 4);
15193 if (attr_len
> section_len
)
15195 error (_("Bad attribute length (%u > %u)\n"),
15196 (unsigned) attr_len
, (unsigned) section_len
);
15197 attr_len
= section_len
;
15200 /* PR 17531: file: 001-101425-0.004 */
15201 else if (attr_len
< 5)
15203 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
15208 section_len
-= attr_len
;
15211 namelen
= strnlen ((char *) p
, attr_len
) + 1;
15212 if (namelen
== 0 || namelen
>= attr_len
)
15214 error (_("Corrupt attribute section name\n"));
15219 printf (_("Attribute Section: "));
15220 print_symbol (INT_MAX
, (const char *) p
);
15223 if (public_name
&& streq ((char *) p
, public_name
))
15224 public_section
= TRUE
;
15226 public_section
= FALSE
;
15228 if (streq ((char *) p
, "gnu"))
15229 gnu_section
= TRUE
;
15231 gnu_section
= FALSE
;
15234 attr_len
-= namelen
;
15236 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
15241 unsigned char * end
;
15243 /* PR binutils/17531: Safe handling of corrupt files. */
15246 error (_("Unused bytes at end of section\n"));
15253 size
= byte_get (p
, 4);
15254 if (size
> attr_len
)
15256 error (_("Bad subsection length (%u > %u)\n"),
15257 (unsigned) size
, (unsigned) attr_len
);
15261 /* PR binutils/17531: Safe handling of corrupt files. */
15264 error (_("Bad subsection length (%u < 6)\n"),
15272 end
= p
+ size
- 1;
15273 assert (end
<= contents
+ sect
->sh_size
);
15279 printf (_("File Attributes\n"));
15282 printf (_("Section Attributes:"));
15285 printf (_("Symbol Attributes:"));
15286 /* Fall through. */
15292 val
= read_uleb128 (p
, &j
, end
);
15296 printf (" %d", val
);
15301 printf (_("Unknown tag: %d\n"), tag
);
15302 public_section
= FALSE
;
15306 if (public_section
&& display_pub_attribute
!= NULL
)
15309 p
= display_pub_attribute (p
, end
);
15312 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
15315 p
= display_gnu_attribute (p
,
15316 display_proc_gnu_attribute
,
15322 printf (_(" Unknown attribute:\n"));
15323 display_raw_attribute (p
, end
);
15338 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
15339 Print the Address, Access and Initial fields of an entry at VMA ADDR
15340 and return the VMA of the next entry, or -1 if there was a problem.
15341 Does not read from DATA_END or beyond. */
15344 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
15345 unsigned char * data_end
)
15348 print_vma (addr
, LONG_HEX
);
15350 if (addr
< pltgot
+ 0xfff0)
15351 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
15353 printf ("%10s", "");
15356 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
15360 unsigned char * from
= data
+ addr
- pltgot
;
15362 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
15364 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
15365 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
15366 return (bfd_vma
) -1;
15370 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
15371 print_vma (entry
, LONG_HEX
);
15374 return addr
+ (is_32bit_elf
? 4 : 8);
15377 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
15378 PLTGOT. Print the Address and Initial fields of an entry at VMA
15379 ADDR and return the VMA of the next entry. */
15382 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
15385 print_vma (addr
, LONG_HEX
);
15388 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
15393 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
15394 print_vma (entry
, LONG_HEX
);
15396 return addr
+ (is_32bit_elf
? 4 : 8);
15400 print_mips_ases (unsigned int mask
)
15402 if (mask
& AFL_ASE_DSP
)
15403 fputs ("\n\tDSP ASE", stdout
);
15404 if (mask
& AFL_ASE_DSPR2
)
15405 fputs ("\n\tDSP R2 ASE", stdout
);
15406 if (mask
& AFL_ASE_DSPR3
)
15407 fputs ("\n\tDSP R3 ASE", stdout
);
15408 if (mask
& AFL_ASE_EVA
)
15409 fputs ("\n\tEnhanced VA Scheme", stdout
);
15410 if (mask
& AFL_ASE_MCU
)
15411 fputs ("\n\tMCU (MicroController) ASE", stdout
);
15412 if (mask
& AFL_ASE_MDMX
)
15413 fputs ("\n\tMDMX ASE", stdout
);
15414 if (mask
& AFL_ASE_MIPS3D
)
15415 fputs ("\n\tMIPS-3D ASE", stdout
);
15416 if (mask
& AFL_ASE_MT
)
15417 fputs ("\n\tMT ASE", stdout
);
15418 if (mask
& AFL_ASE_SMARTMIPS
)
15419 fputs ("\n\tSmartMIPS ASE", stdout
);
15420 if (mask
& AFL_ASE_VIRT
)
15421 fputs ("\n\tVZ ASE", stdout
);
15422 if (mask
& AFL_ASE_MSA
)
15423 fputs ("\n\tMSA ASE", stdout
);
15424 if (mask
& AFL_ASE_MIPS16
)
15425 fputs ("\n\tMIPS16 ASE", stdout
);
15426 if (mask
& AFL_ASE_MICROMIPS
)
15427 fputs ("\n\tMICROMIPS ASE", stdout
);
15428 if (mask
& AFL_ASE_XPA
)
15429 fputs ("\n\tXPA ASE", stdout
);
15430 if (mask
& AFL_ASE_MIPS16E2
)
15431 fputs ("\n\tMIPS16e2 ASE", stdout
);
15433 fprintf (stdout
, "\n\t%s", _("None"));
15434 else if ((mask
& ~AFL_ASE_MASK
) != 0)
15435 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
15439 print_mips_isa_ext (unsigned int isa_ext
)
15444 fputs (_("None"), stdout
);
15447 fputs ("RMI XLR", stdout
);
15449 case AFL_EXT_OCTEON3
:
15450 fputs ("Cavium Networks Octeon3", stdout
);
15452 case AFL_EXT_OCTEON2
:
15453 fputs ("Cavium Networks Octeon2", stdout
);
15455 case AFL_EXT_OCTEONP
:
15456 fputs ("Cavium Networks OcteonP", stdout
);
15458 case AFL_EXT_LOONGSON_3A
:
15459 fputs ("Loongson 3A", stdout
);
15461 case AFL_EXT_OCTEON
:
15462 fputs ("Cavium Networks Octeon", stdout
);
15465 fputs ("Toshiba R5900", stdout
);
15468 fputs ("MIPS R4650", stdout
);
15471 fputs ("LSI R4010", stdout
);
15474 fputs ("NEC VR4100", stdout
);
15477 fputs ("Toshiba R3900", stdout
);
15479 case AFL_EXT_10000
:
15480 fputs ("MIPS R10000", stdout
);
15483 fputs ("Broadcom SB-1", stdout
);
15486 fputs ("NEC VR4111/VR4181", stdout
);
15489 fputs ("NEC VR4120", stdout
);
15492 fputs ("NEC VR5400", stdout
);
15495 fputs ("NEC VR5500", stdout
);
15497 case AFL_EXT_LOONGSON_2E
:
15498 fputs ("ST Microelectronics Loongson 2E", stdout
);
15500 case AFL_EXT_LOONGSON_2F
:
15501 fputs ("ST Microelectronics Loongson 2F", stdout
);
15503 case AFL_EXT_INTERAPTIV_MR2
:
15504 fputs ("Imagination interAptiv MR2", stdout
);
15507 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
15512 get_mips_reg_size (int reg_size
)
15514 return (reg_size
== AFL_REG_NONE
) ? 0
15515 : (reg_size
== AFL_REG_32
) ? 32
15516 : (reg_size
== AFL_REG_64
) ? 64
15517 : (reg_size
== AFL_REG_128
) ? 128
15522 process_mips_specific (Filedata
* filedata
)
15524 Elf_Internal_Dyn
* entry
;
15525 Elf_Internal_Shdr
*sect
= NULL
;
15526 size_t liblist_offset
= 0;
15527 size_t liblistno
= 0;
15528 size_t conflictsno
= 0;
15529 size_t options_offset
= 0;
15530 size_t conflicts_offset
= 0;
15531 size_t pltrelsz
= 0;
15533 bfd_vma pltgot
= 0;
15534 bfd_vma mips_pltgot
= 0;
15535 bfd_vma jmprel
= 0;
15536 bfd_vma local_gotno
= 0;
15537 bfd_vma gotsym
= 0;
15538 bfd_vma symtabno
= 0;
15539 bfd_boolean res
= TRUE
;
15541 if (! process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
15542 display_mips_gnu_attribute
))
15545 sect
= find_section (filedata
, ".MIPS.abiflags");
15549 Elf_External_ABIFlags_v0
*abiflags_ext
;
15550 Elf_Internal_ABIFlags_v0 abiflags_in
;
15552 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
15554 error (_("Corrupt MIPS ABI Flags section.\n"));
15559 abiflags_ext
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
15560 sect
->sh_size
, _("MIPS ABI Flags section"));
15563 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
15564 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
15565 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
15566 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
15567 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
15568 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
15569 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
15570 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
15571 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
15572 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
15573 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
15575 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
15576 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
15577 if (abiflags_in
.isa_rev
> 1)
15578 printf ("r%d", abiflags_in
.isa_rev
);
15579 printf ("\nGPR size: %d",
15580 get_mips_reg_size (abiflags_in
.gpr_size
));
15581 printf ("\nCPR1 size: %d",
15582 get_mips_reg_size (abiflags_in
.cpr1_size
));
15583 printf ("\nCPR2 size: %d",
15584 get_mips_reg_size (abiflags_in
.cpr2_size
));
15585 fputs ("\nFP ABI: ", stdout
);
15586 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
15587 fputs ("ISA Extension: ", stdout
);
15588 print_mips_isa_ext (abiflags_in
.isa_ext
);
15589 fputs ("\nASEs:", stdout
);
15590 print_mips_ases (abiflags_in
.ases
);
15591 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
15592 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
15593 fputc ('\n', stdout
);
15594 free (abiflags_ext
);
15599 /* We have a lot of special sections. Thanks SGI! */
15600 if (dynamic_section
== NULL
)
15602 /* No dynamic information available. See if there is static GOT. */
15603 sect
= find_section (filedata
, ".got");
15606 unsigned char *data_end
;
15607 unsigned char *data
;
15611 pltgot
= sect
->sh_addr
;
15614 addr_size
= (is_32bit_elf
? 4 : 8);
15615 end
= pltgot
+ sect
->sh_size
;
15617 data
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
,
15619 _("Global Offset Table data"));
15620 /* PR 12855: Null data is handled gracefully throughout. */
15621 data_end
= data
+ (end
- pltgot
);
15623 printf (_("\nStatic GOT:\n"));
15624 printf (_(" Canonical gp value: "));
15625 print_vma (ent
+ 0x7ff0, LONG_HEX
);
15628 /* In a dynamic binary GOT[0] is reserved for the dynamic
15629 loader to store the lazy resolver pointer, however in
15630 a static binary it may well have been omitted and GOT
15631 reduced to a table of addresses.
15632 PR 21344: Check for the entry being fully available
15633 before fetching it. */
15635 && data
+ ent
- pltgot
+ addr_size
<= data_end
15636 && byte_get (data
+ ent
- pltgot
, addr_size
) == 0)
15638 printf (_(" Reserved entries:\n"));
15639 printf (_(" %*s %10s %*s\n"),
15640 addr_size
* 2, _("Address"), _("Access"),
15641 addr_size
* 2, _("Value"));
15642 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15644 if (ent
== (bfd_vma
) -1)
15645 goto sgot_print_fail
;
15647 /* Check for the MSB of GOT[1] being set, identifying a
15648 GNU object. This entry will be used by some runtime
15649 loaders, to store the module pointer. Otherwise this
15650 is an ordinary local entry.
15651 PR 21344: Check for the entry being fully available
15652 before fetching it. */
15654 && data
+ ent
- pltgot
+ addr_size
<= data_end
15655 && (byte_get (data
+ ent
- pltgot
, addr_size
)
15656 >> (addr_size
* 8 - 1)) != 0)
15658 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15660 if (ent
== (bfd_vma
) -1)
15661 goto sgot_print_fail
;
15666 if (data
!= NULL
&& ent
< end
)
15668 printf (_(" Local entries:\n"));
15669 printf (" %*s %10s %*s\n",
15670 addr_size
* 2, _("Address"), _("Access"),
15671 addr_size
* 2, _("Value"));
15674 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15676 if (ent
== (bfd_vma
) -1)
15677 goto sgot_print_fail
;
15689 for (entry
= dynamic_section
;
15690 /* PR 17531 file: 012-50589-0.004. */
15691 entry
< dynamic_section
+ dynamic_nent
&& entry
->d_tag
!= DT_NULL
;
15693 switch (entry
->d_tag
)
15695 case DT_MIPS_LIBLIST
:
15697 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
15698 liblistno
* sizeof (Elf32_External_Lib
));
15700 case DT_MIPS_LIBLISTNO
:
15701 liblistno
= entry
->d_un
.d_val
;
15703 case DT_MIPS_OPTIONS
:
15704 options_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
15706 case DT_MIPS_CONFLICT
:
15708 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
15709 conflictsno
* sizeof (Elf32_External_Conflict
));
15711 case DT_MIPS_CONFLICTNO
:
15712 conflictsno
= entry
->d_un
.d_val
;
15715 pltgot
= entry
->d_un
.d_ptr
;
15717 case DT_MIPS_LOCAL_GOTNO
:
15718 local_gotno
= entry
->d_un
.d_val
;
15720 case DT_MIPS_GOTSYM
:
15721 gotsym
= entry
->d_un
.d_val
;
15723 case DT_MIPS_SYMTABNO
:
15724 symtabno
= entry
->d_un
.d_val
;
15726 case DT_MIPS_PLTGOT
:
15727 mips_pltgot
= entry
->d_un
.d_ptr
;
15730 pltrel
= entry
->d_un
.d_val
;
15733 pltrelsz
= entry
->d_un
.d_val
;
15736 jmprel
= entry
->d_un
.d_ptr
;
15742 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
15744 Elf32_External_Lib
* elib
;
15747 elib
= (Elf32_External_Lib
*) get_data (NULL
, filedata
, liblist_offset
,
15749 sizeof (Elf32_External_Lib
),
15750 _("liblist section data"));
15753 printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
15754 "\nSection '.liblist' contains %lu entries:\n",
15755 (unsigned long) liblistno
),
15756 (unsigned long) liblistno
);
15757 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
15760 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
15767 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
15768 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
15769 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
15770 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
15771 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
15773 tmp
= gmtime (&atime
);
15774 snprintf (timebuf
, sizeof (timebuf
),
15775 "%04u-%02u-%02uT%02u:%02u:%02u",
15776 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
15777 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
15779 printf ("%3lu: ", (unsigned long) cnt
);
15780 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
15781 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
15783 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
15784 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
15785 liblist
.l_version
);
15787 if (liblist
.l_flags
== 0)
15791 static const struct
15798 { " EXACT_MATCH", LL_EXACT_MATCH
},
15799 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
15800 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
15801 { " EXPORTS", LL_EXPORTS
},
15802 { " DELAY_LOAD", LL_DELAY_LOAD
},
15803 { " DELTA", LL_DELTA
}
15805 int flags
= liblist
.l_flags
;
15808 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
15809 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
15811 fputs (l_flags_vals
[fcnt
].name
, stdout
);
15812 flags
^= l_flags_vals
[fcnt
].bit
;
15815 printf (" %#x", (unsigned int) flags
);
15827 if (options_offset
!= 0)
15829 Elf_External_Options
* eopt
;
15830 Elf_Internal_Options
* iopt
;
15831 Elf_Internal_Options
* option
;
15834 sect
= filedata
->section_headers
;
15836 /* Find the section header so that we get the size. */
15837 sect
= find_section_by_type (filedata
, SHT_MIPS_OPTIONS
);
15838 /* PR 17533 file: 012-277276-0.004. */
15841 error (_("No MIPS_OPTIONS header found\n"));
15845 eopt
= (Elf_External_Options
*) get_data (NULL
, filedata
, options_offset
, 1,
15846 sect
->sh_size
, _("options"));
15849 iopt
= (Elf_Internal_Options
*)
15850 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
15853 error (_("Out of memory allocating space for MIPS options\n"));
15860 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
15862 Elf_External_Options
* eoption
;
15864 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
15866 option
->kind
= BYTE_GET (eoption
->kind
);
15867 option
->size
= BYTE_GET (eoption
->size
);
15868 option
->section
= BYTE_GET (eoption
->section
);
15869 option
->info
= BYTE_GET (eoption
->info
);
15871 /* PR 17531: file: ffa0fa3b. */
15872 if (option
->size
< sizeof (* eopt
)
15873 || offset
+ option
->size
> sect
->sh_size
)
15875 error (_("Invalid size (%u) for MIPS option\n"), option
->size
);
15878 offset
+= option
->size
;
15884 printf (ngettext ("\nSection '%s' contains %d entry:\n",
15885 "\nSection '%s' contains %d entries:\n",
15887 printable_section_name (filedata
, sect
), cnt
);
15896 switch (option
->kind
)
15899 /* This shouldn't happen. */
15900 printf (" NULL %d %lx", option
->section
, option
->info
);
15903 printf (" REGINFO ");
15904 if (filedata
->file_header
.e_machine
== EM_MIPS
)
15907 Elf32_External_RegInfo
* ereg
;
15908 Elf32_RegInfo reginfo
;
15910 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
15911 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
15912 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
15913 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
15914 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
15915 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
15916 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
15918 printf ("GPR %08lx GP 0x%lx\n",
15919 reginfo
.ri_gprmask
,
15920 (unsigned long) reginfo
.ri_gp_value
);
15921 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
15922 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
15923 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
15928 Elf64_External_RegInfo
* ereg
;
15929 Elf64_Internal_RegInfo reginfo
;
15931 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
15932 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
15933 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
15934 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
15935 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
15936 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
15937 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
15939 printf ("GPR %08lx GP 0x",
15940 reginfo
.ri_gprmask
);
15941 printf_vma (reginfo
.ri_gp_value
);
15944 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
15945 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
15946 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
15950 case ODK_EXCEPTIONS
:
15951 fputs (" EXCEPTIONS fpe_min(", stdout
);
15952 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
15953 fputs (") fpe_max(", stdout
);
15954 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
15955 fputs (")", stdout
);
15957 if (option
->info
& OEX_PAGE0
)
15958 fputs (" PAGE0", stdout
);
15959 if (option
->info
& OEX_SMM
)
15960 fputs (" SMM", stdout
);
15961 if (option
->info
& OEX_FPDBUG
)
15962 fputs (" FPDBUG", stdout
);
15963 if (option
->info
& OEX_DISMISS
)
15964 fputs (" DISMISS", stdout
);
15967 fputs (" PAD ", stdout
);
15968 if (option
->info
& OPAD_PREFIX
)
15969 fputs (" PREFIX", stdout
);
15970 if (option
->info
& OPAD_POSTFIX
)
15971 fputs (" POSTFIX", stdout
);
15972 if (option
->info
& OPAD_SYMBOL
)
15973 fputs (" SYMBOL", stdout
);
15976 fputs (" HWPATCH ", stdout
);
15977 if (option
->info
& OHW_R4KEOP
)
15978 fputs (" R4KEOP", stdout
);
15979 if (option
->info
& OHW_R8KPFETCH
)
15980 fputs (" R8KPFETCH", stdout
);
15981 if (option
->info
& OHW_R5KEOP
)
15982 fputs (" R5KEOP", stdout
);
15983 if (option
->info
& OHW_R5KCVTL
)
15984 fputs (" R5KCVTL", stdout
);
15987 fputs (" FILL ", stdout
);
15988 /* XXX Print content of info word? */
15991 fputs (" TAGS ", stdout
);
15992 /* XXX Print content of info word? */
15995 fputs (" HWAND ", stdout
);
15996 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
15997 fputs (" R4KEOP_CHECKED", stdout
);
15998 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
15999 fputs (" R4KEOP_CLEAN", stdout
);
16002 fputs (" HWOR ", stdout
);
16003 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
16004 fputs (" R4KEOP_CHECKED", stdout
);
16005 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
16006 fputs (" R4KEOP_CLEAN", stdout
);
16009 printf (" GP_GROUP %#06lx self-contained %#06lx",
16010 option
->info
& OGP_GROUP
,
16011 (option
->info
& OGP_SELF
) >> 16);
16014 printf (" IDENT %#06lx self-contained %#06lx",
16015 option
->info
& OGP_GROUP
,
16016 (option
->info
& OGP_SELF
) >> 16);
16019 /* This shouldn't happen. */
16020 printf (" %3d ??? %d %lx",
16021 option
->kind
, option
->section
, option
->info
);
16025 len
= sizeof (* eopt
);
16026 while (len
< option
->size
)
16028 unsigned char datum
= * ((unsigned char *) eopt
+ offset
+ len
);
16030 if (ISPRINT (datum
))
16031 printf ("%c", datum
);
16033 printf ("\\%03o", datum
);
16036 fputs ("\n", stdout
);
16038 offset
+= option
->size
;
16048 if (conflicts_offset
!= 0 && conflictsno
!= 0)
16050 Elf32_Conflict
* iconf
;
16053 if (dynamic_symbols
== NULL
)
16055 error (_("conflict list found without a dynamic symbol table\n"));
16059 /* PR 21345 - print a slightly more helpful error message
16060 if we are sure that the cmalloc will fail. */
16061 if (conflictsno
* sizeof (* iconf
) > filedata
->file_size
)
16063 error (_("Overlarge number of conflicts detected: %lx\n"),
16064 (long) conflictsno
);
16068 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
16071 error (_("Out of memory allocating space for dynamic conflicts\n"));
16077 Elf32_External_Conflict
* econf32
;
16079 econf32
= (Elf32_External_Conflict
*)
16080 get_data (NULL
, filedata
, conflicts_offset
, conflictsno
,
16081 sizeof (* econf32
), _("conflict"));
16085 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
16086 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
16092 Elf64_External_Conflict
* econf64
;
16094 econf64
= (Elf64_External_Conflict
*)
16095 get_data (NULL
, filedata
, conflicts_offset
, conflictsno
,
16096 sizeof (* econf64
), _("conflict"));
16100 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
16101 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
16106 printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
16107 "\nSection '.conflict' contains %lu entries:\n",
16108 (unsigned long) conflictsno
),
16109 (unsigned long) conflictsno
);
16110 puts (_(" Num: Index Value Name"));
16112 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
16114 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
16116 if (iconf
[cnt
] >= num_dynamic_syms
)
16117 printf (_("<corrupt symbol index>"));
16120 Elf_Internal_Sym
* psym
;
16122 psym
= & dynamic_symbols
[iconf
[cnt
]];
16123 print_vma (psym
->st_value
, FULL_HEX
);
16125 if (VALID_DYNAMIC_NAME (psym
->st_name
))
16126 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
16128 printf (_("<corrupt: %14ld>"), psym
->st_name
);
16136 if (pltgot
!= 0 && local_gotno
!= 0)
16138 bfd_vma ent
, local_end
, global_end
;
16140 unsigned char * data
;
16141 unsigned char * data_end
;
16145 addr_size
= (is_32bit_elf
? 4 : 8);
16146 local_end
= pltgot
+ local_gotno
* addr_size
;
16148 /* PR binutils/17533 file: 012-111227-0.004 */
16149 if (symtabno
< gotsym
)
16151 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
16152 (unsigned long) gotsym
, (unsigned long) symtabno
);
16156 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
16157 /* PR 17531: file: 54c91a34. */
16158 if (global_end
< local_end
)
16160 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
16164 offset
= offset_from_vma (filedata
, pltgot
, global_end
- pltgot
);
16165 data
= (unsigned char *) get_data (NULL
, filedata
, offset
,
16166 global_end
- pltgot
, 1,
16167 _("Global Offset Table data"));
16168 /* PR 12855: Null data is handled gracefully throughout. */
16169 data_end
= data
+ (global_end
- pltgot
);
16171 printf (_("\nPrimary GOT:\n"));
16172 printf (_(" Canonical gp value: "));
16173 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
16176 printf (_(" Reserved entries:\n"));
16177 printf (_(" %*s %10s %*s Purpose\n"),
16178 addr_size
* 2, _("Address"), _("Access"),
16179 addr_size
* 2, _("Initial"));
16180 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16181 printf (_(" Lazy resolver\n"));
16182 if (ent
== (bfd_vma
) -1)
16183 goto got_print_fail
;
16185 /* Check for the MSB of GOT[1] being set, denoting a GNU object.
16186 This entry will be used by some runtime loaders, to store the
16187 module pointer. Otherwise this is an ordinary local entry.
16188 PR 21344: Check for the entry being fully available before
16191 && data
+ ent
- pltgot
+ addr_size
<= data_end
16192 && (byte_get (data
+ ent
- pltgot
, addr_size
)
16193 >> (addr_size
* 8 - 1)) != 0)
16195 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16196 printf (_(" Module pointer (GNU extension)\n"));
16197 if (ent
== (bfd_vma
) -1)
16198 goto got_print_fail
;
16202 if (data
!= NULL
&& ent
< local_end
)
16204 printf (_(" Local entries:\n"));
16205 printf (" %*s %10s %*s\n",
16206 addr_size
* 2, _("Address"), _("Access"),
16207 addr_size
* 2, _("Initial"));
16208 while (ent
< local_end
)
16210 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16212 if (ent
== (bfd_vma
) -1)
16213 goto got_print_fail
;
16218 if (data
!= NULL
&& gotsym
< symtabno
)
16222 printf (_(" Global entries:\n"));
16223 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
16224 addr_size
* 2, _("Address"),
16226 addr_size
* 2, _("Initial"),
16227 addr_size
* 2, _("Sym.Val."),
16229 /* Note for translators: "Ndx" = abbreviated form of "Index". */
16230 _("Ndx"), _("Name"));
16232 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
16234 for (i
= gotsym
; i
< symtabno
; i
++)
16236 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16239 if (dynamic_symbols
== NULL
)
16240 printf (_("<no dynamic symbols>"));
16241 else if (i
< num_dynamic_syms
)
16243 Elf_Internal_Sym
* psym
= dynamic_symbols
+ i
;
16245 print_vma (psym
->st_value
, LONG_HEX
);
16246 printf (" %-7s %3s ",
16247 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
16248 get_symbol_index_type (filedata
, psym
->st_shndx
));
16250 if (VALID_DYNAMIC_NAME (psym
->st_name
))
16251 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
16253 printf (_("<corrupt: %14ld>"), psym
->st_name
);
16256 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
16257 (unsigned long) i
);
16260 if (ent
== (bfd_vma
) -1)
16271 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
16274 size_t offset
, rel_offset
;
16275 unsigned long count
, i
;
16276 unsigned char * data
;
16277 int addr_size
, sym_width
;
16278 Elf_Internal_Rela
* rels
;
16280 rel_offset
= offset_from_vma (filedata
, jmprel
, pltrelsz
);
16281 if (pltrel
== DT_RELA
)
16283 if (!slurp_rela_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
16288 if (!slurp_rel_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
16293 addr_size
= (is_32bit_elf
? 4 : 8);
16294 end
= mips_pltgot
+ (2 + count
) * addr_size
;
16296 offset
= offset_from_vma (filedata
, mips_pltgot
, end
- mips_pltgot
);
16297 data
= (unsigned char *) get_data (NULL
, filedata
, offset
, end
- mips_pltgot
,
16298 1, _("Procedure Linkage Table data"));
16302 printf ("\nPLT GOT:\n\n");
16303 printf (_(" Reserved entries:\n"));
16304 printf (_(" %*s %*s Purpose\n"),
16305 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
16306 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
16307 printf (_(" PLT lazy resolver\n"));
16308 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
16309 printf (_(" Module pointer\n"));
16312 printf (_(" Entries:\n"));
16313 printf (" %*s %*s %*s %-7s %3s %s\n",
16314 addr_size
* 2, _("Address"),
16315 addr_size
* 2, _("Initial"),
16316 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
16317 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
16318 for (i
= 0; i
< count
; i
++)
16320 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
16322 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
16325 if (idx
>= num_dynamic_syms
)
16326 printf (_("<corrupt symbol index: %lu>"), idx
);
16329 Elf_Internal_Sym
* psym
= dynamic_symbols
+ idx
;
16331 print_vma (psym
->st_value
, LONG_HEX
);
16332 printf (" %-7s %3s ",
16333 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
16334 get_symbol_index_type (filedata
, psym
->st_shndx
));
16335 if (VALID_DYNAMIC_NAME (psym
->st_name
))
16336 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
16338 printf (_("<corrupt: %14ld>"), psym
->st_name
);
16353 process_nds32_specific (Filedata
* filedata
)
16355 Elf_Internal_Shdr
*sect
= NULL
;
16357 sect
= find_section (filedata
, ".nds32_e_flags");
16360 unsigned int *flag
;
16362 printf ("\nNDS32 elf flags section:\n");
16363 flag
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
16364 sect
->sh_size
, _("NDS32 elf flags section"));
16369 switch ((*flag
) & 0x3)
16372 printf ("(VEC_SIZE):\tNo entry.\n");
16375 printf ("(VEC_SIZE):\t4 bytes\n");
16378 printf ("(VEC_SIZE):\t16 bytes\n");
16381 printf ("(VEC_SIZE):\treserved\n");
16390 process_gnu_liblist (Filedata
* filedata
)
16392 Elf_Internal_Shdr
* section
;
16393 Elf_Internal_Shdr
* string_sec
;
16394 Elf32_External_Lib
* elib
;
16396 size_t strtab_size
;
16398 unsigned long num_liblist
;
16400 bfd_boolean res
= TRUE
;
16405 for (i
= 0, section
= filedata
->section_headers
;
16406 i
< filedata
->file_header
.e_shnum
;
16409 switch (section
->sh_type
)
16411 case SHT_GNU_LIBLIST
:
16412 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
16415 elib
= (Elf32_External_Lib
*)
16416 get_data (NULL
, filedata
, section
->sh_offset
, 1, section
->sh_size
,
16417 _("liblist section data"));
16425 string_sec
= filedata
->section_headers
+ section
->sh_link
;
16426 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
16427 string_sec
->sh_size
,
16428 _("liblist string table"));
16430 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
16437 strtab_size
= string_sec
->sh_size
;
16439 num_liblist
= section
->sh_size
/ sizeof (Elf32_External_Lib
);
16440 printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
16441 "\nLibrary list section '%s' contains %lu entries:\n",
16443 printable_section_name (filedata
, section
),
16446 puts (_(" Library Time Stamp Checksum Version Flags"));
16448 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
16456 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
16457 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
16458 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
16459 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
16460 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
16462 tmp
= gmtime (&atime
);
16463 snprintf (timebuf
, sizeof (timebuf
),
16464 "%04u-%02u-%02uT%02u:%02u:%02u",
16465 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
16466 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
16468 printf ("%3lu: ", (unsigned long) cnt
);
16470 printf ("%-20s", liblist
.l_name
< strtab_size
16471 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
16473 printf ("%-20.20s", liblist
.l_name
< strtab_size
16474 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
16475 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
16476 liblist
.l_version
, liblist
.l_flags
);
16487 static const char *
16488 get_note_type (Filedata
* filedata
, unsigned e_type
)
16490 static char buff
[64];
16492 if (filedata
->file_header
.e_type
== ET_CORE
)
16496 return _("NT_AUXV (auxiliary vector)");
16498 return _("NT_PRSTATUS (prstatus structure)");
16500 return _("NT_FPREGSET (floating point registers)");
16502 return _("NT_PRPSINFO (prpsinfo structure)");
16503 case NT_TASKSTRUCT
:
16504 return _("NT_TASKSTRUCT (task structure)");
16506 return _("NT_PRXFPREG (user_xfpregs structure)");
16508 return _("NT_PPC_VMX (ppc Altivec registers)");
16510 return _("NT_PPC_VSX (ppc VSX registers)");
16512 return _("NT_PPC_TAR (ppc TAR register)");
16514 return _("NT_PPC_PPR (ppc PPR register)");
16516 return _("NT_PPC_DSCR (ppc DSCR register)");
16518 return _("NT_PPC_EBB (ppc EBB registers)");
16520 return _("NT_PPC_PMU (ppc PMU registers)");
16521 case NT_PPC_TM_CGPR
:
16522 return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
16523 case NT_PPC_TM_CFPR
:
16524 return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
16525 case NT_PPC_TM_CVMX
:
16526 return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
16527 case NT_PPC_TM_CVSX
:
16528 return _("NT_PPC_TM_VSX (ppc checkpointed VSX registers)");
16529 case NT_PPC_TM_SPR
:
16530 return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
16531 case NT_PPC_TM_CTAR
:
16532 return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
16533 case NT_PPC_TM_CPPR
:
16534 return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
16535 case NT_PPC_TM_CDSCR
:
16536 return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
16538 return _("NT_386_TLS (x86 TLS information)");
16539 case NT_386_IOPERM
:
16540 return _("NT_386_IOPERM (x86 I/O permissions)");
16541 case NT_X86_XSTATE
:
16542 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
16543 case NT_S390_HIGH_GPRS
:
16544 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
16545 case NT_S390_TIMER
:
16546 return _("NT_S390_TIMER (s390 timer register)");
16547 case NT_S390_TODCMP
:
16548 return _("NT_S390_TODCMP (s390 TOD comparator register)");
16549 case NT_S390_TODPREG
:
16550 return _("NT_S390_TODPREG (s390 TOD programmable register)");
16552 return _("NT_S390_CTRS (s390 control registers)");
16553 case NT_S390_PREFIX
:
16554 return _("NT_S390_PREFIX (s390 prefix register)");
16555 case NT_S390_LAST_BREAK
:
16556 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
16557 case NT_S390_SYSTEM_CALL
:
16558 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
16560 return _("NT_S390_TDB (s390 transaction diagnostic block)");
16561 case NT_S390_VXRS_LOW
:
16562 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
16563 case NT_S390_VXRS_HIGH
:
16564 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
16565 case NT_S390_GS_CB
:
16566 return _("NT_S390_GS_CB (s390 guarded-storage registers)");
16567 case NT_S390_GS_BC
:
16568 return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
16570 return _("NT_ARM_VFP (arm VFP registers)");
16572 return _("NT_ARM_TLS (AArch TLS registers)");
16573 case NT_ARM_HW_BREAK
:
16574 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
16575 case NT_ARM_HW_WATCH
:
16576 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
16578 return _("NT_PSTATUS (pstatus structure)");
16580 return _("NT_FPREGS (floating point registers)");
16582 return _("NT_PSINFO (psinfo structure)");
16584 return _("NT_LWPSTATUS (lwpstatus_t structure)");
16586 return _("NT_LWPSINFO (lwpsinfo_t structure)");
16587 case NT_WIN32PSTATUS
:
16588 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
16590 return _("NT_SIGINFO (siginfo_t data)");
16592 return _("NT_FILE (mapped files)");
16600 return _("NT_VERSION (version)");
16602 return _("NT_ARCH (architecture)");
16603 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
16605 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
16611 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16616 print_core_note (Elf_Internal_Note
*pnote
)
16618 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
16619 bfd_vma count
, page_size
;
16620 unsigned char *descdata
, *filenames
, *descend
;
16622 if (pnote
->type
!= NT_FILE
)
16632 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
16633 /* Still "successful". */
16638 if (pnote
->descsz
< 2 * addr_size
)
16640 error (_(" Malformed note - too short for header\n"));
16644 descdata
= (unsigned char *) pnote
->descdata
;
16645 descend
= descdata
+ pnote
->descsz
;
16647 if (descdata
[pnote
->descsz
- 1] != '\0')
16649 error (_(" Malformed note - does not end with \\0\n"));
16653 count
= byte_get (descdata
, addr_size
);
16654 descdata
+= addr_size
;
16656 page_size
= byte_get (descdata
, addr_size
);
16657 descdata
+= addr_size
;
16659 if (count
> ((bfd_vma
) -1 - 2 * addr_size
) / (3 * addr_size
)
16660 || pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
16662 error (_(" Malformed note - too short for supplied file count\n"));
16666 printf (_(" Page size: "));
16667 print_vma (page_size
, DEC
);
16670 printf (_(" %*s%*s%*s\n"),
16671 (int) (2 + 2 * addr_size
), _("Start"),
16672 (int) (4 + 2 * addr_size
), _("End"),
16673 (int) (4 + 2 * addr_size
), _("Page Offset"));
16674 filenames
= descdata
+ count
* 3 * addr_size
;
16675 while (count
-- > 0)
16677 bfd_vma start
, end
, file_ofs
;
16679 if (filenames
== descend
)
16681 error (_(" Malformed note - filenames end too early\n"));
16685 start
= byte_get (descdata
, addr_size
);
16686 descdata
+= addr_size
;
16687 end
= byte_get (descdata
, addr_size
);
16688 descdata
+= addr_size
;
16689 file_ofs
= byte_get (descdata
, addr_size
);
16690 descdata
+= addr_size
;
16693 print_vma (start
, FULL_HEX
);
16695 print_vma (end
, FULL_HEX
);
16697 print_vma (file_ofs
, FULL_HEX
);
16698 printf ("\n %s\n", filenames
);
16700 filenames
+= 1 + strlen ((char *) filenames
);
16706 static const char *
16707 get_gnu_elf_note_type (unsigned e_type
)
16709 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
16712 case NT_GNU_ABI_TAG
:
16713 return _("NT_GNU_ABI_TAG (ABI version tag)");
16715 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
16716 case NT_GNU_BUILD_ID
:
16717 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
16718 case NT_GNU_GOLD_VERSION
:
16719 return _("NT_GNU_GOLD_VERSION (gold version)");
16720 case NT_GNU_PROPERTY_TYPE_0
:
16721 return _("NT_GNU_PROPERTY_TYPE_0");
16722 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
16723 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
16724 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
16725 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
16728 static char buff
[64];
16730 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16737 decode_x86_isa (unsigned int bitmask
)
16741 unsigned int bit
= bitmask
& (- bitmask
);
16746 case GNU_PROPERTY_X86_ISA_1_486
: printf ("i486"); break;
16747 case GNU_PROPERTY_X86_ISA_1_586
: printf ("586"); break;
16748 case GNU_PROPERTY_X86_ISA_1_686
: printf ("686"); break;
16749 case GNU_PROPERTY_X86_ISA_1_SSE
: printf ("SSE"); break;
16750 case GNU_PROPERTY_X86_ISA_1_SSE2
: printf ("SSE2"); break;
16751 case GNU_PROPERTY_X86_ISA_1_SSE3
: printf ("SSE3"); break;
16752 case GNU_PROPERTY_X86_ISA_1_SSSE3
: printf ("SSSE3"); break;
16753 case GNU_PROPERTY_X86_ISA_1_SSE4_1
: printf ("SSE4_1"); break;
16754 case GNU_PROPERTY_X86_ISA_1_SSE4_2
: printf ("SSE4_2"); break;
16755 case GNU_PROPERTY_X86_ISA_1_AVX
: printf ("AVX"); break;
16756 case GNU_PROPERTY_X86_ISA_1_AVX2
: printf ("AVX2"); break;
16757 case GNU_PROPERTY_X86_ISA_1_AVX512F
: printf ("AVX512F"); break;
16758 case GNU_PROPERTY_X86_ISA_1_AVX512CD
: printf ("AVX512CD"); break;
16759 case GNU_PROPERTY_X86_ISA_1_AVX512ER
: printf ("AVX512ER"); break;
16760 case GNU_PROPERTY_X86_ISA_1_AVX512PF
: printf ("AVX512PF"); break;
16761 case GNU_PROPERTY_X86_ISA_1_AVX512VL
: printf ("AVX512VL"); break;
16762 case GNU_PROPERTY_X86_ISA_1_AVX512DQ
: printf ("AVX512DQ"); break;
16763 case GNU_PROPERTY_X86_ISA_1_AVX512BW
: printf ("AVX512BW"); break;
16764 default: printf (_("<unknown: %x>"), bit
); break;
16772 decode_x86_feature (unsigned int type
, unsigned int bitmask
)
16776 unsigned int bit
= bitmask
& (- bitmask
);
16781 case GNU_PROPERTY_X86_FEATURE_1_IBT
:
16784 case GNU_PROPERTY_X86_FEATURE_1_AND
:
16788 /* This should never happen. */
16792 case GNU_PROPERTY_X86_FEATURE_1_SHSTK
:
16795 case GNU_PROPERTY_X86_FEATURE_1_AND
:
16799 /* This should never happen. */
16804 printf (_("<unknown: %x>"), bit
);
16813 print_gnu_property_note (Filedata
* filedata
, Elf_Internal_Note
* pnote
)
16815 unsigned char * ptr
= (unsigned char *) pnote
->descdata
;
16816 unsigned char * ptr_end
= ptr
+ pnote
->descsz
;
16817 unsigned int size
= is_32bit_elf
? 4 : 8;
16819 printf (_(" Properties: "));
16821 if (pnote
->descsz
< 8 || (pnote
->descsz
% size
) != 0)
16823 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote
->descsz
);
16827 while (ptr
< ptr_end
)
16831 unsigned int datasz
;
16833 if ((size_t) (ptr_end
- ptr
) < 8)
16835 printf (_("<corrupt descsz: %#lx>\n"), pnote
->descsz
);
16839 type
= byte_get (ptr
, 4);
16840 datasz
= byte_get (ptr
+ 4, 4);
16844 if (datasz
> (size_t) (ptr_end
- ptr
))
16846 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
16851 if (type
>= GNU_PROPERTY_LOPROC
&& type
<= GNU_PROPERTY_HIPROC
)
16853 if (filedata
->file_header
.e_machine
== EM_X86_64
16854 || filedata
->file_header
.e_machine
== EM_IAMCU
16855 || filedata
->file_header
.e_machine
== EM_386
)
16859 case GNU_PROPERTY_X86_ISA_1_USED
:
16860 printf ("x86 ISA used: ");
16862 printf (_("<corrupt length: %#x> "), datasz
);
16864 decode_x86_isa (byte_get (ptr
, 4));
16867 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
16868 printf ("x86 ISA needed: ");
16870 printf (_("<corrupt length: %#x> "), datasz
);
16872 decode_x86_isa (byte_get (ptr
, 4));
16875 case GNU_PROPERTY_X86_FEATURE_1_AND
:
16876 printf ("x86 feature: ");
16878 printf (_("<corrupt length: %#x> "), datasz
);
16880 decode_x86_feature (type
, byte_get (ptr
, 4));
16892 case GNU_PROPERTY_STACK_SIZE
:
16893 printf (_("stack size: "));
16894 if (datasz
!= size
)
16895 printf (_("<corrupt length: %#x> "), datasz
);
16897 printf ("%#lx", (unsigned long) byte_get (ptr
, size
));
16900 case GNU_PROPERTY_NO_COPY_ON_PROTECTED
:
16901 printf ("no copy on protected ");
16903 printf (_("<corrupt length: %#x> "), datasz
);
16911 if (type
< GNU_PROPERTY_LOPROC
)
16912 printf (_("<unknown type %#x data: "), type
);
16913 else if (type
< GNU_PROPERTY_LOUSER
)
16914 printf (_("<procesor-specific type %#x data: "), type
);
16916 printf (_("<application-specific type %#x data: "), type
);
16917 for (j
= 0; j
< datasz
; ++j
)
16918 printf ("%02x ", ptr
[j
] & 0xff);
16922 ptr
+= ((datasz
+ (size
- 1)) & ~ (size
- 1));
16923 if (ptr
== ptr_end
)
16936 print_gnu_note (Filedata
* filedata
, Elf_Internal_Note
*pnote
)
16938 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
16939 switch (pnote
->type
)
16941 case NT_GNU_BUILD_ID
:
16945 printf (_(" Build ID: "));
16946 for (i
= 0; i
< pnote
->descsz
; ++i
)
16947 printf ("%02x", pnote
->descdata
[i
] & 0xff);
16952 case NT_GNU_ABI_TAG
:
16954 unsigned long os
, major
, minor
, subminor
;
16955 const char *osname
;
16957 /* PR 17531: file: 030-599401-0.004. */
16958 if (pnote
->descsz
< 16)
16960 printf (_(" <corrupt GNU_ABI_TAG>\n"));
16964 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
16965 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
16966 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
16967 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
16971 case GNU_ABI_TAG_LINUX
:
16974 case GNU_ABI_TAG_HURD
:
16977 case GNU_ABI_TAG_SOLARIS
:
16978 osname
= "Solaris";
16980 case GNU_ABI_TAG_FREEBSD
:
16981 osname
= "FreeBSD";
16983 case GNU_ABI_TAG_NETBSD
:
16986 case GNU_ABI_TAG_SYLLABLE
:
16987 osname
= "Syllable";
16989 case GNU_ABI_TAG_NACL
:
16993 osname
= "Unknown";
16997 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
16998 major
, minor
, subminor
);
17002 case NT_GNU_GOLD_VERSION
:
17006 printf (_(" Version: "));
17007 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
17008 printf ("%c", pnote
->descdata
[i
]);
17015 unsigned long num_entries
, mask
;
17017 /* Hardware capabilities information. Word 0 is the number of entries.
17018 Word 1 is a bitmask of enabled entries. The rest of the descriptor
17019 is a series of entries, where each entry is a single byte followed
17020 by a nul terminated string. The byte gives the bit number to test
17021 if enabled in the bitmask. */
17022 printf (_(" Hardware Capabilities: "));
17023 if (pnote
->descsz
< 8)
17025 error (_("<corrupt GNU_HWCAP>\n"));
17028 num_entries
= byte_get ((unsigned char *) pnote
->descdata
, 4);
17029 mask
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
17030 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries
, mask
);
17031 /* FIXME: Add code to display the entries... */
17035 case NT_GNU_PROPERTY_TYPE_0
:
17036 print_gnu_property_note (filedata
, pnote
);
17040 /* Handle unrecognised types. An error message should have already been
17041 created by get_gnu_elf_note_type(), so all that we need to do is to
17042 display the data. */
17046 printf (_(" Description data: "));
17047 for (i
= 0; i
< pnote
->descsz
; ++i
)
17048 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
17057 static const char *
17058 get_v850_elf_note_type (enum v850_notes n_type
)
17060 static char buff
[64];
17064 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
17065 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
17066 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
17067 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
17068 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
17069 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
17071 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
17077 print_v850_note (Elf_Internal_Note
* pnote
)
17081 if (pnote
->descsz
!= 4)
17084 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
17088 printf (_("not set\n"));
17092 switch (pnote
->type
)
17094 case V850_NOTE_ALIGNMENT
:
17097 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return TRUE
;
17098 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return TRUE
;
17102 case V850_NOTE_DATA_SIZE
:
17105 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return TRUE
;
17106 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return TRUE
;
17110 case V850_NOTE_FPU_INFO
:
17113 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return TRUE
;
17114 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return TRUE
;
17118 case V850_NOTE_MMU_INFO
:
17119 case V850_NOTE_CACHE_INFO
:
17120 case V850_NOTE_SIMD_INFO
:
17121 if (val
== EF_RH850_SIMD
)
17123 printf (_("yes\n"));
17129 /* An 'unknown note type' message will already have been displayed. */
17133 printf (_("unknown value: %x\n"), val
);
17138 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
17140 unsigned int version
;
17142 switch (pnote
->type
)
17144 case NT_NETBSD_IDENT
:
17145 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
17146 if ((version
/ 10000) % 100)
17147 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
17148 version
, version
/ 100000000, (version
/ 1000000) % 100,
17149 (version
/ 10000) % 100 > 26 ? "Z" : "",
17150 'A' + (version
/ 10000) % 26);
17152 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
17153 version
, version
/ 100000000, (version
/ 1000000) % 100,
17154 (version
/ 100) % 100);
17157 case NT_NETBSD_MARCH
:
17158 printf (" NetBSD\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
17163 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote
->descsz
,
17169 static const char *
17170 get_freebsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
17174 case NT_FREEBSD_THRMISC
:
17175 return _("NT_THRMISC (thrmisc structure)");
17176 case NT_FREEBSD_PROCSTAT_PROC
:
17177 return _("NT_PROCSTAT_PROC (proc data)");
17178 case NT_FREEBSD_PROCSTAT_FILES
:
17179 return _("NT_PROCSTAT_FILES (files data)");
17180 case NT_FREEBSD_PROCSTAT_VMMAP
:
17181 return _("NT_PROCSTAT_VMMAP (vmmap data)");
17182 case NT_FREEBSD_PROCSTAT_GROUPS
:
17183 return _("NT_PROCSTAT_GROUPS (groups data)");
17184 case NT_FREEBSD_PROCSTAT_UMASK
:
17185 return _("NT_PROCSTAT_UMASK (umask data)");
17186 case NT_FREEBSD_PROCSTAT_RLIMIT
:
17187 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
17188 case NT_FREEBSD_PROCSTAT_OSREL
:
17189 return _("NT_PROCSTAT_OSREL (osreldate data)");
17190 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
17191 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
17192 case NT_FREEBSD_PROCSTAT_AUXV
:
17193 return _("NT_PROCSTAT_AUXV (auxv data)");
17194 case NT_FREEBSD_PTLWPINFO
:
17195 return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
17197 return get_note_type (filedata
, e_type
);
17200 static const char *
17201 get_netbsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
17203 static char buff
[64];
17205 if (e_type
== NT_NETBSDCORE_PROCINFO
)
17206 return _("NetBSD procinfo structure");
17208 /* As of Jan 2002 there are no other machine-independent notes
17209 defined for NetBSD core files. If the note type is less
17210 than the start of the machine-dependent note types, we don't
17213 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
17215 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17219 switch (filedata
->file_header
.e_machine
)
17221 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
17222 and PT_GETFPREGS == mach+2. */
17227 case EM_SPARC32PLUS
:
17231 case NT_NETBSDCORE_FIRSTMACH
+ 0:
17232 return _("PT_GETREGS (reg structure)");
17233 case NT_NETBSDCORE_FIRSTMACH
+ 2:
17234 return _("PT_GETFPREGS (fpreg structure)");
17240 /* On all other arch's, PT_GETREGS == mach+1 and
17241 PT_GETFPREGS == mach+3. */
17245 case NT_NETBSDCORE_FIRSTMACH
+ 1:
17246 return _("PT_GETREGS (reg structure)");
17247 case NT_NETBSDCORE_FIRSTMACH
+ 3:
17248 return _("PT_GETFPREGS (fpreg structure)");
17254 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
17255 e_type
- NT_NETBSDCORE_FIRSTMACH
);
17259 static const char *
17260 get_stapsdt_note_type (unsigned e_type
)
17262 static char buff
[64];
17267 return _("NT_STAPSDT (SystemTap probe descriptors)");
17273 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17278 print_stapsdt_note (Elf_Internal_Note
*pnote
)
17280 int addr_size
= is_32bit_elf
? 4 : 8;
17281 char *data
= pnote
->descdata
;
17282 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
17283 bfd_vma pc
, base_addr
, semaphore
;
17284 char *provider
, *probe
, *arg_fmt
;
17286 pc
= byte_get ((unsigned char *) data
, addr_size
);
17288 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
17290 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
17294 data
+= strlen (data
) + 1;
17296 data
+= strlen (data
) + 1;
17298 data
+= strlen (data
) + 1;
17300 printf (_(" Provider: %s\n"), provider
);
17301 printf (_(" Name: %s\n"), probe
);
17302 printf (_(" Location: "));
17303 print_vma (pc
, FULL_HEX
);
17304 printf (_(", Base: "));
17305 print_vma (base_addr
, FULL_HEX
);
17306 printf (_(", Semaphore: "));
17307 print_vma (semaphore
, FULL_HEX
);
17309 printf (_(" Arguments: %s\n"), arg_fmt
);
17311 return data
== data_end
;
17314 static const char *
17315 get_ia64_vms_note_type (unsigned e_type
)
17317 static char buff
[64];
17322 return _("NT_VMS_MHD (module header)");
17324 return _("NT_VMS_LNM (language name)");
17326 return _("NT_VMS_SRC (source files)");
17328 return "NT_VMS_TITLE";
17330 return _("NT_VMS_EIDC (consistency check)");
17331 case NT_VMS_FPMODE
:
17332 return _("NT_VMS_FPMODE (FP mode)");
17333 case NT_VMS_LINKTIME
:
17334 return "NT_VMS_LINKTIME";
17335 case NT_VMS_IMGNAM
:
17336 return _("NT_VMS_IMGNAM (image name)");
17338 return _("NT_VMS_IMGID (image id)");
17339 case NT_VMS_LINKID
:
17340 return _("NT_VMS_LINKID (link id)");
17341 case NT_VMS_IMGBID
:
17342 return _("NT_VMS_IMGBID (build id)");
17343 case NT_VMS_GSTNAM
:
17344 return _("NT_VMS_GSTNAM (sym table name)");
17345 case NT_VMS_ORIG_DYN
:
17346 return "NT_VMS_ORIG_DYN";
17347 case NT_VMS_PATCHTIME
:
17348 return "NT_VMS_PATCHTIME";
17350 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17356 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
17358 switch (pnote
->type
)
17361 if (pnote
->descsz
> 36)
17363 size_t l
= strlen (pnote
->descdata
+ 34);
17364 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
17365 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
17366 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
17367 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
17370 printf (_(" Invalid size\n"));
17373 printf (_(" Language: %s\n"), pnote
->descdata
);
17376 case NT_VMS_FPMODE
:
17377 printf (_(" Floating Point mode: "));
17378 printf ("0x%016" BFD_VMA_FMT
"x\n",
17379 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
17381 case NT_VMS_LINKTIME
:
17382 printf (_(" Link time: "));
17384 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
17387 case NT_VMS_PATCHTIME
:
17388 printf (_(" Patch time: "));
17390 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
17393 case NT_VMS_ORIG_DYN
:
17394 printf (_(" Major id: %u, minor id: %u\n"),
17395 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
17396 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
17397 printf (_(" Last modified : "));
17399 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
17400 printf (_("\n Link flags : "));
17401 printf ("0x%016" BFD_VMA_FMT
"x\n",
17402 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
17403 printf (_(" Header flags: 0x%08x\n"),
17404 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
17405 printf (_(" Image id : %s\n"), pnote
->descdata
+ 32);
17408 case NT_VMS_IMGNAM
:
17409 printf (_(" Image name: %s\n"), pnote
->descdata
);
17411 case NT_VMS_GSTNAM
:
17412 printf (_(" Global symbol table name: %s\n"), pnote
->descdata
);
17415 printf (_(" Image id: %s\n"), pnote
->descdata
);
17417 case NT_VMS_LINKID
:
17418 printf (_(" Linker id: %s\n"), pnote
->descdata
);
17426 /* Find the symbol associated with a build attribute that is attached
17427 to address OFFSET. If PNAME is non-NULL then store the name of
17428 the symbol (if found) in the provided pointer, Returns NULL if a
17429 symbol could not be found. */
17431 static Elf_Internal_Sym
*
17432 get_symbol_for_build_attribute (Filedata
* filedata
,
17433 unsigned long offset
,
17434 bfd_boolean is_open_attr
,
17435 const char ** pname
)
17437 static Filedata
* saved_filedata
= NULL
;
17438 static char * strtab
;
17439 static unsigned long strtablen
;
17440 static Elf_Internal_Sym
* symtab
;
17441 static unsigned long nsyms
;
17442 Elf_Internal_Sym
* saved_sym
= NULL
;
17443 Elf_Internal_Sym
* sym
;
17445 if (filedata
->section_headers
!= NULL
17446 && (saved_filedata
== NULL
|| filedata
!= saved_filedata
))
17448 Elf_Internal_Shdr
* symsec
;
17450 /* Load the symbol and string sections. */
17451 for (symsec
= filedata
->section_headers
;
17452 symsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
17455 if (symsec
->sh_type
== SHT_SYMTAB
)
17457 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & nsyms
);
17459 if (symsec
->sh_link
< filedata
->file_header
.e_shnum
)
17461 Elf_Internal_Shdr
* strtab_sec
= filedata
->section_headers
+ symsec
->sh_link
;
17463 strtab
= (char *) get_data (NULL
, filedata
, strtab_sec
->sh_offset
,
17464 1, strtab_sec
->sh_size
,
17465 _("string table"));
17466 strtablen
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
17470 saved_filedata
= filedata
;
17473 if (symtab
== NULL
|| strtab
== NULL
)
17476 /* Find a symbol whose value matches offset. */
17477 for (sym
= symtab
; sym
< symtab
+ nsyms
; sym
++)
17478 if (sym
->st_value
== offset
)
17480 if (sym
->st_name
>= strtablen
)
17481 /* Huh ? This should not happen. */
17484 if (strtab
[sym
->st_name
] == 0)
17487 /* The AArch64 and ARM architectures define mapping symbols
17488 (eg $d, $x, $t) which we want to ignore. */
17489 if (strtab
[sym
->st_name
] == '$'
17490 && strtab
[sym
->st_name
+ 1] != 0
17491 && strtab
[sym
->st_name
+ 2] == 0)
17496 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
17497 and FILE or OBJECT symbols over NOTYPE symbols. We skip
17498 FUNC symbols entirely. */
17499 switch (ELF_ST_TYPE (sym
->st_info
))
17506 /* If the symbol has a size associated
17507 with it then we can stop searching. */
17508 sym
= symtab
+ nsyms
;
17513 /* Ignore function symbols. */
17520 switch (ELF_ST_BIND (sym
->st_info
))
17523 if (saved_sym
== NULL
17524 || ELF_ST_TYPE (saved_sym
->st_info
) != STT_OBJECT
)
17529 if (saved_sym
== NULL
)
17539 if (ELF_ST_TYPE (sym
->st_info
) != STT_FUNC
)
17547 if (saved_sym
&& pname
)
17548 * pname
= strtab
+ saved_sym
->st_name
;
17554 print_gnu_build_attribute_description (Elf_Internal_Note
* pnote
,
17555 Filedata
* filedata
)
17557 static unsigned long global_offset
= 0;
17558 static unsigned long global_end
= 0;
17559 static unsigned long func_offset
= 0;
17560 static unsigned long func_end
= 0;
17562 Elf_Internal_Sym
* sym
;
17564 unsigned long start
;
17566 bfd_boolean is_open_attr
= pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
;
17568 switch (pnote
->descsz
)
17571 /* A zero-length description means that the range of
17572 the previous note of the same type should be used. */
17575 if (global_end
> global_offset
)
17576 printf (_(" Applies to region from %#lx to %#lx\n"),
17577 global_offset
, global_end
);
17579 printf (_(" Applies to region from %#lx\n"), global_offset
);
17583 if (func_end
> func_offset
)
17584 printf (_(" Applies to region from %#lx to %#lx\n"), func_offset
, func_end
);
17586 printf (_(" Applies to region from %#lx\n"), func_offset
);
17591 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
17598 /* FIXME: We should check that version 3+ notes are being used here... */
17599 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
17600 end
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
17604 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
17610 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
17611 end
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 8);
17615 error (_(" <invalid description size: %lx>\n"), pnote
->descsz
);
17616 printf (_(" <invalid descsz>"));
17621 sym
= get_symbol_for_build_attribute (filedata
, start
, is_open_attr
, & name
);
17622 /* As of version 5 of the annobin plugin, filename symbols are biased by 2
17623 in order to avoid them being confused with the start address of the
17624 first function in the file... */
17625 if (sym
== NULL
&& is_open_attr
)
17626 sym
= get_symbol_for_build_attribute (filedata
, start
+ 2, is_open_attr
,
17629 if (end
== 0 && sym
!= NULL
&& sym
->st_size
> 0)
17630 end
= start
+ sym
->st_size
;
17634 /* FIXME: Need to properly allow for section alignment. 16 is just the alignment used on x86_64. */
17635 if (global_end
> 0 && start
> BFD_ALIGN (global_end
, 16))
17636 warn (_("Gap in build notes detected from %#lx to %#lx\n"),
17637 global_end
+ 1, start
- 1);
17639 printf (_(" Applies to region from %#lx"), start
);
17640 global_offset
= start
;
17644 printf (_(" to %#lx"), end
);
17650 printf (_(" Applies to region from %#lx"), start
);
17651 func_offset
= start
;
17655 printf (_(" to %#lx"), end
);
17661 printf (_(" (%s)"), name
);
17668 print_gnu_build_attribute_name (Elf_Internal_Note
* pnote
)
17670 static const char string_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING
, 0 };
17671 static const char number_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
, 0 };
17672 static const char bool_expected
[3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
, 0 };
17674 char name_attribute
;
17675 const char * expected_types
;
17676 const char * name
= pnote
->namedata
;
17680 if (name
== NULL
|| pnote
->namesz
< 2)
17682 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
17683 print_symbol (-20, _(" <corrupt name>"));
17692 /* Version 2 of the spec adds a "GA" prefix to the name field. */
17693 if (name
[0] == 'G' && name
[1] == 'A')
17695 if (pnote
->namesz
< 4)
17697 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
17698 print_symbol (-20, _(" <corrupt name>"));
17707 switch ((name_type
= * name
))
17709 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
17710 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
17711 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
17712 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
17713 printf ("%c", * name
);
17717 error (_("unrecognised attribute type in name field: %d\n"), name_type
);
17718 print_symbol (-20, _("<unknown name type>"));
17725 switch ((name_attribute
= * name
))
17727 case GNU_BUILD_ATTRIBUTE_VERSION
:
17728 text
= _("<version>");
17729 expected_types
= string_expected
;
17732 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
17733 text
= _("<stack prot>");
17734 expected_types
= "!+*";
17737 case GNU_BUILD_ATTRIBUTE_RELRO
:
17738 text
= _("<relro>");
17739 expected_types
= bool_expected
;
17742 case GNU_BUILD_ATTRIBUTE_STACK_SIZE
:
17743 text
= _("<stack size>");
17744 expected_types
= number_expected
;
17747 case GNU_BUILD_ATTRIBUTE_TOOL
:
17748 text
= _("<tool>");
17749 expected_types
= string_expected
;
17752 case GNU_BUILD_ATTRIBUTE_ABI
:
17754 expected_types
= "$*";
17757 case GNU_BUILD_ATTRIBUTE_PIC
:
17759 expected_types
= number_expected
;
17762 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM
:
17763 text
= _("<short enum>");
17764 expected_types
= bool_expected
;
17768 if (ISPRINT (* name
))
17770 int len
= strnlen (name
, pnote
->namesz
- (name
- pnote
->namedata
)) + 1;
17772 if (len
> left
&& ! do_wide
)
17774 printf ("%.*s:", len
, name
);
17780 static char tmpbuf
[128];
17782 error (_("unrecognised byte in name field: %d\n"), * name
);
17783 sprintf (tmpbuf
, _("<unknown:_%d>"), * name
);
17787 expected_types
= "*$!+";
17792 left
-= printf ("%s", text
);
17794 if (strchr (expected_types
, name_type
) == NULL
)
17795 warn (_("attribute does not have an expected type (%c)\n"), name_type
);
17797 if ((unsigned long)(name
- pnote
->namedata
) > pnote
->namesz
)
17799 error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
17800 (unsigned long) pnote
->namesz
,
17801 (long) (name
- pnote
->namedata
));
17805 if (left
< 1 && ! do_wide
)
17810 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
17812 unsigned int bytes
;
17813 unsigned long long val
= 0;
17814 unsigned int shift
= 0;
17815 char * decoded
= NULL
;
17817 bytes
= pnote
->namesz
- (name
- pnote
->namedata
);
17819 /* The -1 is because the name field is always 0 terminated, and we
17820 want to be able to ensure that the shift in the while loop below
17821 will not overflow. */
17824 if (bytes
> sizeof (val
))
17826 error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
17828 bytes
= sizeof (val
);
17830 /* We do not bother to warn if bytes == 0 as this can
17831 happen with some early versions of the gcc plugin. */
17835 unsigned long byte
= (* name
++) & 0xff;
17837 val
|= byte
<< shift
;
17841 switch (name_attribute
)
17843 case GNU_BUILD_ATTRIBUTE_PIC
:
17846 case 0: decoded
= "static"; break;
17847 case 1: decoded
= "pic"; break;
17848 case 2: decoded
= "PIC"; break;
17849 case 3: decoded
= "pie"; break;
17850 case 4: decoded
= "PIE"; break;
17854 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
17857 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
17858 case 0: decoded
= "off"; break;
17859 case 1: decoded
= "on"; break;
17860 case 2: decoded
= "all"; break;
17861 case 3: decoded
= "strong"; break;
17862 case 4: decoded
= "explicit"; break;
17870 if (decoded
!= NULL
)
17872 print_symbol (-left
, decoded
);
17883 left
-= printf ("0x%llx", val
);
17885 left
-= printf ("0x%-.*llx", left
, val
);
17889 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
17890 left
-= print_symbol (- left
, name
);
17892 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
17893 left
-= print_symbol (- left
, "true");
17895 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
17896 left
-= print_symbol (- left
, "false");
17900 if (do_wide
&& left
> 0)
17901 printf ("%-*s", left
, " ");
17906 /* Note that by the ELF standard, the name field is already null byte
17907 terminated, and namesz includes the terminating null byte.
17908 I.E. the value of namesz for the name "FSF" is 4.
17910 If the value of namesz is zero, there is no name present. */
17913 process_note (Elf_Internal_Note
* pnote
,
17914 Filedata
* filedata
)
17916 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
17919 if (pnote
->namesz
== 0)
17920 /* If there is no note name, then use the default set of
17921 note type strings. */
17922 nt
= get_note_type (filedata
, pnote
->type
);
17924 else if (const_strneq (pnote
->namedata
, "GNU"))
17925 /* GNU-specific object file notes. */
17926 nt
= get_gnu_elf_note_type (pnote
->type
);
17928 else if (const_strneq (pnote
->namedata
, "FreeBSD"))
17929 /* FreeBSD-specific core file notes. */
17930 nt
= get_freebsd_elfcore_note_type (filedata
, pnote
->type
);
17932 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
17933 /* NetBSD-specific core file notes. */
17934 nt
= get_netbsd_elfcore_note_type (filedata
, pnote
->type
);
17936 else if (const_strneq (pnote
->namedata
, "NetBSD"))
17937 /* NetBSD-specific core file notes. */
17938 return process_netbsd_elf_note (pnote
);
17940 else if (strneq (pnote
->namedata
, "SPU/", 4))
17942 /* SPU-specific core file notes. */
17943 nt
= pnote
->namedata
+ 4;
17947 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
17948 /* VMS/ia64-specific file notes. */
17949 nt
= get_ia64_vms_note_type (pnote
->type
);
17951 else if (const_strneq (pnote
->namedata
, "stapsdt"))
17952 nt
= get_stapsdt_note_type (pnote
->type
);
17955 /* Don't recognize this note name; just use the default set of
17956 note type strings. */
17957 nt
= get_note_type (filedata
, pnote
->type
);
17961 if (((const_strneq (pnote
->namedata
, "GA")
17962 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
17963 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
17964 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
17965 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
17966 print_gnu_build_attribute_name (pnote
);
17968 print_symbol (-20, name
);
17971 printf (" 0x%08lx\t%s\t", pnote
->descsz
, nt
);
17973 printf (" 0x%08lx\t%s\n", pnote
->descsz
, nt
);
17975 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
17976 return print_ia64_vms_note (pnote
);
17977 else if (const_strneq (pnote
->namedata
, "GNU"))
17978 return print_gnu_note (filedata
, pnote
);
17979 else if (const_strneq (pnote
->namedata
, "stapsdt"))
17980 return print_stapsdt_note (pnote
);
17981 else if (const_strneq (pnote
->namedata
, "CORE"))
17982 return print_core_note (pnote
);
17983 else if (((const_strneq (pnote
->namedata
, "GA")
17984 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
17985 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
17986 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
17987 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
17988 return print_gnu_build_attribute_description (pnote
, filedata
);
17994 printf (_(" description data: "));
17995 for (i
= 0; i
< pnote
->descsz
; i
++)
17996 printf ("%02x ", pnote
->descdata
[i
]);
18008 process_notes_at (Filedata
* filedata
,
18009 Elf_Internal_Shdr
* section
,
18014 Elf_External_Note
* pnotes
;
18015 Elf_External_Note
* external
;
18017 bfd_boolean res
= TRUE
;
18024 pnotes
= (Elf_External_Note
*) get_section_contents (section
, filedata
);
18027 if (! apply_relocations (filedata
, section
, (unsigned char *) pnotes
, length
, NULL
, NULL
))
18032 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
18035 if (pnotes
== NULL
)
18041 printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (filedata
, section
));
18043 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
18044 (unsigned long) offset
, (unsigned long) length
);
18046 /* NB: Some note sections may have alignment value of 0 or 1. gABI
18047 specifies that notes should be aligned to 4 bytes in 32-bit
18048 objects and to 8 bytes in 64-bit objects. As a Linux extension,
18049 we also support 4 byte alignment in 64-bit objects. If section
18050 alignment is less than 4, we treate alignment as 4 bytes. */
18053 else if (align
!= 4 && align
!= 8)
18055 warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
18060 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
18062 end
= (char *) pnotes
+ length
;
18063 while ((char *) external
< end
)
18065 Elf_Internal_Note inote
;
18068 char * temp
= NULL
;
18069 size_t data_remaining
= end
- (char *) external
;
18071 if (!is_ia64_vms (filedata
))
18073 /* PR binutils/15191
18074 Make sure that there is enough data to read. */
18075 min_notesz
= offsetof (Elf_External_Note
, name
);
18076 if (data_remaining
< min_notesz
)
18078 warn (ngettext ("Corrupt note: only %ld byte remains, "
18079 "not enough for a full note\n",
18080 "Corrupt note: only %ld bytes remain, "
18081 "not enough for a full note\n",
18083 (long) data_remaining
);
18086 data_remaining
-= min_notesz
;
18088 inote
.type
= BYTE_GET (external
->type
);
18089 inote
.namesz
= BYTE_GET (external
->namesz
);
18090 inote
.namedata
= external
->name
;
18091 inote
.descsz
= BYTE_GET (external
->descsz
);
18092 inote
.descdata
= ((char *) external
18093 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
18094 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
18095 next
= ((char *) external
18096 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
18100 Elf64_External_VMS_Note
*vms_external
;
18102 /* PR binutils/15191
18103 Make sure that there is enough data to read. */
18104 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
18105 if (data_remaining
< min_notesz
)
18107 warn (ngettext ("Corrupt note: only %ld byte remains, "
18108 "not enough for a full note\n",
18109 "Corrupt note: only %ld bytes remain, "
18110 "not enough for a full note\n",
18112 (long) data_remaining
);
18115 data_remaining
-= min_notesz
;
18117 vms_external
= (Elf64_External_VMS_Note
*) external
;
18118 inote
.type
= BYTE_GET (vms_external
->type
);
18119 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
18120 inote
.namedata
= vms_external
->name
;
18121 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
18122 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
18123 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
18124 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
18127 /* PR 17531: file: 3443835e. */
18128 /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
18129 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
18130 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
18131 || (size_t) (next
- inote
.descdata
) < inote
.descsz
18132 || ((size_t) (next
- inote
.descdata
)
18133 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
18135 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
18136 (unsigned long) ((char *) external
- (char *) pnotes
));
18137 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
18138 inote
.type
, inote
.namesz
, inote
.descsz
, (int) align
);
18142 external
= (Elf_External_Note
*) next
;
18144 /* Verify that name is null terminated. It appears that at least
18145 one version of Linux (RedHat 6.0) generates corefiles that don't
18146 comply with the ELF spec by failing to include the null byte in
18148 if (inote
.namedata
[inote
.namesz
- 1] != '\0')
18150 if ((size_t) (inote
.descdata
- inote
.namedata
) == inote
.namesz
)
18152 temp
= (char *) malloc (inote
.namesz
+ 1);
18155 error (_("Out of memory allocating space for inote name\n"));
18160 memcpy (temp
, inote
.namedata
, inote
.namesz
);
18161 inote
.namedata
= temp
;
18163 inote
.namedata
[inote
.namesz
] = 0;
18166 if (! process_note (& inote
, filedata
))
18182 process_corefile_note_segments (Filedata
* filedata
)
18184 Elf_Internal_Phdr
* segment
;
18186 bfd_boolean res
= TRUE
;
18188 if (! get_program_headers (filedata
))
18191 for (i
= 0, segment
= filedata
->program_headers
;
18192 i
< filedata
->file_header
.e_phnum
;
18195 if (segment
->p_type
== PT_NOTE
)
18196 if (! process_notes_at (filedata
, NULL
,
18197 (bfd_vma
) segment
->p_offset
,
18198 (bfd_vma
) segment
->p_filesz
,
18199 (bfd_vma
) segment
->p_align
))
18207 process_v850_notes (Filedata
* filedata
, bfd_vma offset
, bfd_vma length
)
18209 Elf_External_Note
* pnotes
;
18210 Elf_External_Note
* external
;
18212 bfd_boolean res
= TRUE
;
18217 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
18219 if (pnotes
== NULL
)
18223 end
= (char*) pnotes
+ length
;
18225 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
18226 (unsigned long) offset
, (unsigned long) length
);
18228 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
18230 Elf_External_Note
* next
;
18231 Elf_Internal_Note inote
;
18233 inote
.type
= BYTE_GET (external
->type
);
18234 inote
.namesz
= BYTE_GET (external
->namesz
);
18235 inote
.namedata
= external
->name
;
18236 inote
.descsz
= BYTE_GET (external
->descsz
);
18237 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
18238 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
18240 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
18242 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
18243 inote
.descdata
= inote
.namedata
;
18247 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
18249 if ( ((char *) next
> end
)
18250 || ((char *) next
< (char *) pnotes
))
18252 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
18253 (unsigned long) ((char *) external
- (char *) pnotes
));
18254 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
18255 inote
.type
, inote
.namesz
, inote
.descsz
);
18261 /* Prevent out-of-bounds indexing. */
18262 if ( inote
.namedata
+ inote
.namesz
> end
18263 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
18265 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
18266 (unsigned long) ((char *) external
- (char *) pnotes
));
18267 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
18268 inote
.type
, inote
.namesz
, inote
.descsz
);
18272 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
18274 if (! print_v850_note (& inote
))
18277 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
18278 inote
.namesz
, inote
.descsz
);
18288 process_note_sections (Filedata
* filedata
)
18290 Elf_Internal_Shdr
* section
;
18292 unsigned int n
= 0;
18293 bfd_boolean res
= TRUE
;
18295 for (i
= 0, section
= filedata
->section_headers
;
18296 i
< filedata
->file_header
.e_shnum
&& section
!= NULL
;
18299 if (section
->sh_type
== SHT_NOTE
)
18301 if (! process_notes_at (filedata
, section
,
18302 (bfd_vma
) section
->sh_offset
,
18303 (bfd_vma
) section
->sh_size
,
18304 (bfd_vma
) section
->sh_addralign
))
18309 if (( filedata
->file_header
.e_machine
== EM_V800
18310 || filedata
->file_header
.e_machine
== EM_V850
18311 || filedata
->file_header
.e_machine
== EM_CYGNUS_V850
)
18312 && section
->sh_type
== SHT_RENESAS_INFO
)
18314 if (! process_v850_notes (filedata
,
18315 (bfd_vma
) section
->sh_offset
,
18316 (bfd_vma
) section
->sh_size
))
18323 /* Try processing NOTE segments instead. */
18324 return process_corefile_note_segments (filedata
);
18330 process_notes (Filedata
* filedata
)
18332 /* If we have not been asked to display the notes then do nothing. */
18336 if (filedata
->file_header
.e_type
!= ET_CORE
)
18337 return process_note_sections (filedata
);
18339 /* No program headers means no NOTE segment. */
18340 if (filedata
->file_header
.e_phnum
> 0)
18341 return process_corefile_note_segments (filedata
);
18343 printf (_("No note segments present in the core file.\n"));
18347 static unsigned char *
18348 display_public_gnu_attributes (unsigned char * start
,
18349 const unsigned char * const end
)
18351 printf (_(" Unknown GNU attribute: %s\n"), start
);
18353 start
+= strnlen ((char *) start
, end
- start
);
18354 display_raw_attribute (start
, end
);
18356 return (unsigned char *) end
;
18359 static unsigned char *
18360 display_generic_attribute (unsigned char * start
,
18362 const unsigned char * const end
)
18365 return (unsigned char *) end
;
18367 return display_tag_value (tag
, start
, end
);
18371 process_arch_specific (Filedata
* filedata
)
18376 switch (filedata
->file_header
.e_machine
)
18379 case EM_ARC_COMPACT
:
18380 case EM_ARC_COMPACT2
:
18381 return process_attributes (filedata
, "ARC", SHT_ARC_ATTRIBUTES
,
18382 display_arc_attribute
,
18383 display_generic_attribute
);
18385 return process_attributes (filedata
, "aeabi", SHT_ARM_ATTRIBUTES
,
18386 display_arm_attribute
,
18387 display_generic_attribute
);
18390 case EM_MIPS_RS3_LE
:
18391 return process_mips_specific (filedata
);
18394 return process_attributes (filedata
, "mspabi", SHT_MSP430_ATTRIBUTES
,
18395 display_msp430x_attribute
,
18396 display_generic_attribute
);
18399 return process_nds32_specific (filedata
);
18403 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
18404 display_power_gnu_attribute
);
18408 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
18409 display_s390_gnu_attribute
);
18412 case EM_SPARC32PLUS
:
18414 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
18415 display_sparc_gnu_attribute
);
18418 return process_attributes (filedata
, "c6xabi", SHT_C6000_ATTRIBUTES
,
18419 display_tic6x_attribute
,
18420 display_generic_attribute
);
18423 return process_attributes (filedata
, "gnu", SHT_GNU_ATTRIBUTES
,
18424 display_public_gnu_attributes
,
18425 display_generic_attribute
);
18430 get_file_header (Filedata
* filedata
)
18432 /* Read in the identity array. */
18433 if (fread (filedata
->file_header
.e_ident
, EI_NIDENT
, 1, filedata
->handle
) != 1)
18436 /* Determine how to read the rest of the header. */
18437 switch (filedata
->file_header
.e_ident
[EI_DATA
])
18442 byte_get
= byte_get_little_endian
;
18443 byte_put
= byte_put_little_endian
;
18446 byte_get
= byte_get_big_endian
;
18447 byte_put
= byte_put_big_endian
;
18451 /* For now we only support 32 bit and 64 bit ELF files. */
18452 is_32bit_elf
= (filedata
->file_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
18454 /* Read in the rest of the header. */
18457 Elf32_External_Ehdr ehdr32
;
18459 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
18462 filedata
->file_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
18463 filedata
->file_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
18464 filedata
->file_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
18465 filedata
->file_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
18466 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
18467 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
18468 filedata
->file_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
18469 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
18470 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
18471 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
18472 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
18473 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
18474 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
18478 Elf64_External_Ehdr ehdr64
;
18480 /* If we have been compiled with sizeof (bfd_vma) == 4, then
18481 we will not be able to cope with the 64bit data found in
18482 64 ELF files. Detect this now and abort before we start
18483 overwriting things. */
18484 if (sizeof (bfd_vma
) < 8)
18486 error (_("This instance of readelf has been built without support for a\n\
18487 64 bit data type and so it cannot read 64 bit ELF files.\n"));
18491 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
18494 filedata
->file_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
18495 filedata
->file_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
18496 filedata
->file_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
18497 filedata
->file_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
18498 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
18499 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
18500 filedata
->file_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
18501 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
18502 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
18503 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
18504 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
18505 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
18506 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
18509 if (filedata
->file_header
.e_shoff
)
18511 /* There may be some extensions in the first section header. Don't
18512 bomb if we can't read it. */
18514 get_32bit_section_headers (filedata
, TRUE
);
18516 get_64bit_section_headers (filedata
, TRUE
);
18523 close_file (Filedata
* filedata
)
18527 if (filedata
->handle
)
18528 fclose (filedata
->handle
);
18534 close_debug_file (void * data
)
18536 close_file ((Filedata
*) data
);
18540 open_file (const char * pathname
)
18542 struct stat statbuf
;
18543 Filedata
* filedata
= NULL
;
18545 if (stat (pathname
, & statbuf
) < 0
18546 || ! S_ISREG (statbuf
.st_mode
))
18549 filedata
= calloc (1, sizeof * filedata
);
18550 if (filedata
== NULL
)
18553 filedata
->handle
= fopen (pathname
, "rb");
18554 if (filedata
->handle
== NULL
)
18557 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
18558 filedata
->file_name
= pathname
;
18560 if (! get_file_header (filedata
))
18563 if (filedata
->file_header
.e_shoff
)
18567 /* Read the section headers again, this time for real. */
18569 res
= get_32bit_section_headers (filedata
, FALSE
);
18571 res
= get_64bit_section_headers (filedata
, FALSE
);
18582 if (filedata
->handle
)
18583 fclose (filedata
->handle
);
18590 open_debug_file (const char * pathname
)
18592 return open_file (pathname
);
18595 /* Process one ELF object file according to the command line options.
18596 This file may actually be stored in an archive. The file is
18597 positioned at the start of the ELF object. Returns TRUE if no
18598 problems were encountered, FALSE otherwise. */
18601 process_object (Filedata
* filedata
)
18603 Filedata
* separates
;
18605 bfd_boolean res
= TRUE
;
18607 if (! get_file_header (filedata
))
18609 error (_("%s: Failed to read file header\n"), filedata
->file_name
);
18613 /* Initialise per file variables. */
18614 for (i
= ARRAY_SIZE (version_info
); i
--;)
18615 version_info
[i
] = 0;
18617 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
18618 dynamic_info
[i
] = 0;
18619 dynamic_info_DT_GNU_HASH
= 0;
18621 /* Process the file. */
18623 printf (_("\nFile: %s\n"), filedata
->file_name
);
18625 /* Initialise the dump_sects array from the cmdline_dump_sects array.
18626 Note we do this even if cmdline_dump_sects is empty because we
18627 must make sure that the dump_sets array is zeroed out before each
18628 object file is processed. */
18629 if (filedata
->num_dump_sects
> cmdline
.num_dump_sects
)
18630 memset (filedata
->dump_sects
, 0, filedata
->num_dump_sects
* sizeof (* filedata
->dump_sects
));
18632 if (cmdline
.num_dump_sects
> 0)
18634 if (filedata
->num_dump_sects
== 0)
18635 /* A sneaky way of allocating the dump_sects array. */
18636 request_dump_bynumber (filedata
, cmdline
.num_dump_sects
, 0);
18638 assert (filedata
->num_dump_sects
>= cmdline
.num_dump_sects
);
18639 memcpy (filedata
->dump_sects
, cmdline
.dump_sects
,
18640 cmdline
.num_dump_sects
* sizeof (* filedata
->dump_sects
));
18643 if (! process_file_header (filedata
))
18646 if (! process_section_headers (filedata
))
18648 /* Without loaded section headers we cannot process lots of things. */
18649 do_unwind
= do_version
= do_dump
= do_arch
= FALSE
;
18651 if (! do_using_dynamic
)
18652 do_syms
= do_dyn_syms
= do_reloc
= FALSE
;
18655 if (! process_section_groups (filedata
))
18656 /* Without loaded section groups we cannot process unwind. */
18659 if (process_program_headers (filedata
))
18660 process_dynamic_section (filedata
);
18664 if (! process_relocs (filedata
))
18667 if (! process_unwind (filedata
))
18670 if (! process_symbol_table (filedata
))
18673 if (! process_syminfo (filedata
))
18676 if (! process_version_sections (filedata
))
18679 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
)
18680 separates
= load_separate_debug_file (filedata
, filedata
->file_name
);
18684 if (! process_section_contents (filedata
))
18689 if (! process_section_headers (separates
))
18691 else if (! process_section_contents (separates
))
18695 if (! process_notes (filedata
))
18698 if (! process_gnu_liblist (filedata
))
18701 if (! process_arch_specific (filedata
))
18704 free (filedata
->program_headers
);
18705 filedata
->program_headers
= NULL
;
18707 free (filedata
->section_headers
);
18708 filedata
->section_headers
= NULL
;
18710 free (filedata
->string_table
);
18711 filedata
->string_table
= NULL
;
18712 filedata
->string_table_length
= 0;
18714 if (dynamic_strings
)
18716 free (dynamic_strings
);
18717 dynamic_strings
= NULL
;
18718 dynamic_strings_length
= 0;
18721 if (dynamic_symbols
)
18723 free (dynamic_symbols
);
18724 dynamic_symbols
= NULL
;
18725 num_dynamic_syms
= 0;
18728 if (dynamic_syminfo
)
18730 free (dynamic_syminfo
);
18731 dynamic_syminfo
= NULL
;
18734 if (dynamic_section
)
18736 free (dynamic_section
);
18737 dynamic_section
= NULL
;
18740 if (section_headers_groups
)
18742 free (section_headers_groups
);
18743 section_headers_groups
= NULL
;
18746 if (section_groups
)
18748 struct group_list
* g
;
18749 struct group_list
* next
;
18751 for (i
= 0; i
< group_count
; i
++)
18753 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
18760 free (section_groups
);
18761 section_groups
= NULL
;
18764 free_debug_memory ();
18769 /* Process an ELF archive.
18770 On entry the file is positioned just after the ARMAG string.
18771 Returns TRUE upon success, FALSE otherwise. */
18774 process_archive (Filedata
* filedata
, bfd_boolean is_thin_archive
)
18776 struct archive_info arch
;
18777 struct archive_info nested_arch
;
18779 bfd_boolean ret
= TRUE
;
18783 /* The ARCH structure is used to hold information about this archive. */
18784 arch
.file_name
= NULL
;
18786 arch
.index_array
= NULL
;
18787 arch
.sym_table
= NULL
;
18788 arch
.longnames
= NULL
;
18790 /* The NESTED_ARCH structure is used as a single-item cache of information
18791 about a nested archive (when members of a thin archive reside within
18792 another regular archive file). */
18793 nested_arch
.file_name
= NULL
;
18794 nested_arch
.file
= NULL
;
18795 nested_arch
.index_array
= NULL
;
18796 nested_arch
.sym_table
= NULL
;
18797 nested_arch
.longnames
= NULL
;
18799 if (setup_archive (&arch
, filedata
->file_name
, filedata
->handle
,
18800 is_thin_archive
, do_archive_index
) != 0)
18806 if (do_archive_index
)
18808 if (arch
.sym_table
== NULL
)
18809 error (_("%s: unable to dump the index as none was found\n"), filedata
->file_name
);
18812 unsigned long i
, l
;
18813 unsigned long current_pos
;
18815 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
18816 filedata
->file_name
, (unsigned long) arch
.index_num
, arch
.sym_size
);
18818 current_pos
= ftell (filedata
->handle
);
18820 for (i
= l
= 0; i
< arch
.index_num
; i
++)
18822 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
18824 char * member_name
;
18826 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
18828 if (member_name
!= NULL
)
18830 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
18832 if (qualified_name
!= NULL
)
18834 printf (_("Contents of binary %s at offset "), qualified_name
);
18835 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
18837 free (qualified_name
);
18842 if (l
>= arch
.sym_size
)
18844 error (_("%s: end of the symbol table reached before the end of the index\n"),
18845 filedata
->file_name
);
18849 /* PR 17531: file: 0b6630b2. */
18850 printf ("\t%.*s\n", (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
18851 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
18854 if (arch
.uses_64bit_indicies
)
18859 if (l
< arch
.sym_size
)
18861 error (ngettext ("%s: %ld byte remains in the symbol table, "
18862 "but without corresponding entries in "
18863 "the index table\n",
18864 "%s: %ld bytes remain in the symbol table, "
18865 "but without corresponding entries in "
18866 "the index table\n",
18867 arch
.sym_size
- l
),
18868 filedata
->file_name
, arch
.sym_size
- l
);
18872 if (fseek (filedata
->handle
, current_pos
, SEEK_SET
) != 0)
18874 error (_("%s: failed to seek back to start of object files in the archive\n"),
18875 filedata
->file_name
);
18881 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
18882 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
18883 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
18884 && !do_section_groups
&& !do_dyn_syms
)
18886 ret
= TRUE
; /* Archive index only. */
18895 char * qualified_name
;
18897 /* Read the next archive header. */
18898 if (fseek (filedata
->handle
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
18900 error (_("%s: failed to seek to next archive header\n"), filedata
->file_name
);
18903 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, filedata
->handle
);
18904 if (got
!= sizeof arch
.arhdr
)
18908 error (_("%s: failed to read archive header\n"), filedata
->file_name
);
18912 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
18914 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
18919 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
18921 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
18922 if (archive_file_size
& 01)
18923 ++archive_file_size
;
18925 name
= get_archive_member_name (&arch
, &nested_arch
);
18928 error (_("%s: bad archive file name\n"), filedata
->file_name
);
18932 namelen
= strlen (name
);
18934 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
18935 if (qualified_name
== NULL
)
18937 error (_("%s: bad archive file name\n"), filedata
->file_name
);
18942 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
18944 /* This is a proxy for an external member of a thin archive. */
18945 Filedata
* member_filedata
;
18946 char * member_file_name
= adjust_relative_path
18947 (filedata
->file_name
, name
, namelen
);
18949 if (member_file_name
== NULL
)
18955 member_filedata
= open_file (member_file_name
);
18956 if (member_filedata
== NULL
)
18958 error (_("Input file '%s' is not readable.\n"), member_file_name
);
18959 free (member_file_name
);
18964 archive_file_offset
= arch
.nested_member_origin
;
18965 member_filedata
->file_name
= qualified_name
;
18967 if (! process_object (member_filedata
))
18970 close_file (member_filedata
);
18971 free (member_file_name
);
18973 else if (is_thin_archive
)
18975 Filedata thin_filedata
;
18977 memset (&thin_filedata
, 0, sizeof (thin_filedata
));
18979 /* PR 15140: Allow for corrupt thin archives. */
18980 if (nested_arch
.file
== NULL
)
18982 error (_("%s: contains corrupt thin archive: %s\n"),
18983 filedata
->file_name
, name
);
18988 /* This is a proxy for a member of a nested archive. */
18989 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
18991 /* The nested archive file will have been opened and setup by
18992 get_archive_member_name. */
18993 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
18995 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
19000 thin_filedata
.handle
= nested_arch
.file
;
19001 thin_filedata
.file_name
= qualified_name
;
19003 if (! process_object (& thin_filedata
))
19008 archive_file_offset
= arch
.next_arhdr_offset
;
19009 arch
.next_arhdr_offset
+= archive_file_size
;
19011 filedata
->file_name
= qualified_name
;
19012 if (! process_object (filedata
))
19016 if (filedata
->dump_sects
!= NULL
)
19018 free (filedata
->dump_sects
);
19019 filedata
->dump_sects
= NULL
;
19020 filedata
->num_dump_sects
= 0;
19023 free (qualified_name
);
19027 if (nested_arch
.file
!= NULL
)
19028 fclose (nested_arch
.file
);
19029 release_archive (&nested_arch
);
19030 release_archive (&arch
);
19036 process_file (char * file_name
)
19038 Filedata
* filedata
= NULL
;
19039 struct stat statbuf
;
19040 char armag
[SARMAG
];
19041 bfd_boolean ret
= TRUE
;
19043 if (stat (file_name
, &statbuf
) < 0)
19045 if (errno
== ENOENT
)
19046 error (_("'%s': No such file\n"), file_name
);
19048 error (_("Could not locate '%s'. System error message: %s\n"),
19049 file_name
, strerror (errno
));
19053 if (! S_ISREG (statbuf
.st_mode
))
19055 error (_("'%s' is not an ordinary file\n"), file_name
);
19059 filedata
= calloc (1, sizeof * filedata
);
19060 if (filedata
== NULL
)
19062 error (_("Out of memory allocating file data structure\n"));
19066 filedata
->file_name
= file_name
;
19067 filedata
->handle
= fopen (file_name
, "rb");
19068 if (filedata
->handle
== NULL
)
19070 error (_("Input file '%s' is not readable.\n"), file_name
);
19075 if (fread (armag
, SARMAG
, 1, filedata
->handle
) != 1)
19077 error (_("%s: Failed to read file's magic number\n"), file_name
);
19078 fclose (filedata
->handle
);
19083 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
19085 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
19087 if (! process_archive (filedata
, FALSE
))
19090 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
19092 if ( ! process_archive (filedata
, TRUE
))
19097 if (do_archive_index
)
19098 error (_("File %s is not an archive so its index cannot be displayed.\n"),
19101 rewind (filedata
->handle
);
19102 archive_file_size
= archive_file_offset
= 0;
19104 if (! process_object (filedata
))
19108 fclose (filedata
->handle
);
19114 #ifdef SUPPORT_DISASSEMBLY
19115 /* Needed by the i386 disassembler. For extra credit, someone could
19116 fix this so that we insert symbolic addresses here, esp for GOT/PLT
19120 print_address (unsigned int addr
, FILE * outfile
)
19122 fprintf (outfile
,"0x%8.8x", addr
);
19125 /* Needed by the i386 disassembler. */
19128 db_task_printsym (unsigned int addr
)
19130 print_address (addr
, stderr
);
19135 main (int argc
, char ** argv
)
19139 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
19140 setlocale (LC_MESSAGES
, "");
19142 #if defined (HAVE_SETLOCALE)
19143 setlocale (LC_CTYPE
, "");
19145 bindtextdomain (PACKAGE
, LOCALEDIR
);
19146 textdomain (PACKAGE
);
19148 expandargv (&argc
, &argv
);
19150 cmdline
.file_name
= "<cmdline>";
19151 parse_args (& cmdline
, argc
, argv
);
19153 if (optind
< (argc
- 1))
19155 else if (optind
>= argc
)
19157 warn (_("Nothing to do.\n"));
19162 while (optind
< argc
)
19163 if (! process_file (argv
[optind
++]))
19166 if (cmdline
.dump_sects
!= NULL
)
19167 free (cmdline
.dump_sects
);
19169 return err
? EXIT_FAILURE
: EXIT_SUCCESS
;