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_860
: return "Intel 80860";
2256 case EM_MIPS
: return "MIPS R3000";
2257 case EM_S370
: return "IBM System/370";
2259 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
2260 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
2261 case EM_PARISC
: return "HPPA";
2262 case EM_VPP550
: return "Fujitsu VPP500";
2263 case EM_SPARC32PLUS
: return "Sparc v8+" ;
2264 case EM_960
: return "Intel 90860";
2265 case EM_PPC
: return "PowerPC";
2267 case EM_PPC64
: return "PowerPC64";
2269 case EM_S390
: return "IBM S/390";
2270 case EM_SPU
: return "SPU";
2272 case EM_V800
: return "Renesas V850 (using RH850 ABI)";
2273 case EM_FR20
: return "Fujitsu FR20";
2274 case EM_RH32
: return "TRW RH32";
2275 case EM_MCORE
: return "MCORE";
2277 case EM_ARM
: return "ARM";
2278 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
2279 case EM_SH
: return "Renesas / SuperH SH";
2280 case EM_SPARCV9
: return "Sparc v9";
2281 case EM_TRICORE
: return "Siemens Tricore";
2282 case EM_ARC
: return "ARC";
2283 case EM_H8_300
: return "Renesas H8/300";
2284 case EM_H8_300H
: return "Renesas H8/300H";
2285 case EM_H8S
: return "Renesas H8S";
2286 case EM_H8_500
: return "Renesas H8/500";
2288 case EM_IA_64
: return "Intel IA-64";
2289 case EM_MIPS_X
: return "Stanford MIPS-X";
2290 case EM_COLDFIRE
: return "Motorola Coldfire";
2291 case EM_68HC12
: return "Motorola MC68HC12 Microcontroller";
2292 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
2293 case EM_PCP
: return "Siemens PCP";
2294 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
2295 case EM_NDR1
: return "Denso NDR1 microprocesspr";
2296 case EM_STARCORE
: return "Motorola Star*Core processor";
2297 case EM_ME16
: return "Toyota ME16 processor";
2299 case EM_ST100
: return "STMicroelectronics ST100 processor";
2300 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
2301 case EM_X86_64
: return "Advanced Micro Devices X86-64";
2302 case EM_PDSP
: return "Sony DSP processor";
2303 case EM_PDP10
: return "Digital Equipment Corp. PDP-10";
2304 case EM_PDP11
: return "Digital Equipment Corp. PDP-11";
2305 case EM_FX66
: return "Siemens FX66 microcontroller";
2306 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2307 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
2308 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
2310 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
2311 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
2312 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
2313 case EM_SVX
: return "Silicon Graphics SVx";
2314 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
2315 case EM_VAX
: return "Digital VAX";
2316 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
2317 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
2318 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
2319 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
2321 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
2322 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
2323 case EM_PRISM
: return "Vitesse Prism";
2325 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
2326 case EM_CYGNUS_FR30
:
2327 case EM_FR30
: return "Fujitsu FR30";
2328 case EM_CYGNUS_D10V
:
2329 case EM_D10V
: return "d10v";
2330 case EM_CYGNUS_D30V
:
2331 case EM_D30V
: return "d30v";
2332 case EM_CYGNUS_V850
:
2333 case EM_V850
: return "Renesas V850";
2334 case EM_CYGNUS_M32R
:
2335 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
2336 case EM_CYGNUS_MN10300
:
2337 case EM_MN10300
: return "mn10300";
2339 case EM_CYGNUS_MN10200
:
2340 case EM_MN10200
: return "mn10200";
2341 case EM_PJ
: return "picoJava";
2342 case EM_OR1K
: return "OpenRISC 1000";
2343 case EM_ARC_COMPACT
: return "ARCompact";
2345 case EM_XTENSA
: return "Tensilica Xtensa Processor";
2346 case EM_VIDEOCORE
: return "Alphamosaic VideoCore processor";
2347 case EM_TMM_GPP
: return "Thompson Multimedia General Purpose Processor";
2348 case EM_NS32K
: return "National Semiconductor 32000 series";
2349 case EM_TPC
: return "Tenor Network TPC processor";
2350 case EM_SNP1K
: return "Trebia SNP 1000 processor";
2352 case EM_ST200
: return "STMicroelectronics ST200 microcontroller";
2354 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
2355 case EM_MAX
: return "MAX Processor";
2356 case EM_CR
: return "National Semiconductor CompactRISC";
2357 case EM_F2MC16
: return "Fujitsu F2MC16";
2358 case EM_MSP430
: return "Texas Instruments msp430 microcontroller";
2359 case EM_BLACKFIN
: return "Analog Devices Blackfin";
2360 case EM_SE_C33
: return "S1C33 Family of Seiko Epson processors";
2361 case EM_SEP
: return "Sharp embedded microprocessor";
2362 case EM_ARCA
: return "Arca RISC microprocessor";
2364 case EM_UNICORE
: return "Unicore";
2365 case EM_EXCESS
: return "eXcess 16/32/64-bit configurable embedded CPU";
2366 case EM_DXP
: return "Icera Semiconductor Inc. Deep Execution Processor";
2367 case EM_ALTERA_NIOS2
: return "Altera Nios II";
2368 case EM_CRX
: return "National Semiconductor CRX microprocessor";
2369 case EM_XGATE
: return "Motorola XGATE embedded processor";
2371 case EM_XC16X
: return "Infineon Technologies xc16x";
2372 case EM_M16C
: return "Renesas M16C series microprocessors";
2373 case EM_DSPIC30F
: return "Microchip Technology dsPIC30F Digital Signal Controller";
2374 case EM_CE
: return "Freescale Communication Engine RISC core";
2376 case EM_M32C
: return "Renesas M32c";
2378 case EM_TSK3000
: return "Altium TSK3000 core";
2379 case EM_RS08
: return "Freescale RS08 embedded processor";
2380 case EM_ECOG2
: return "Cyan Technology eCOG2 microprocessor";
2381 case EM_SCORE
: return "SUNPLUS S+Core";
2382 case EM_DSP24
: return "New Japan Radio (NJR) 24-bit DSP Processor";
2383 case EM_VIDEOCORE3
: return "Broadcom VideoCore III processor";
2384 case EM_LATTICEMICO32
: return "Lattice Mico32";
2385 case EM_SE_C17
: return "Seiko Epson C17 family";
2387 case EM_TI_C6000
: return "Texas Instruments TMS320C6000 DSP family";
2388 case EM_TI_C2000
: return "Texas Instruments TMS320C2000 DSP family";
2389 case EM_TI_C5500
: return "Texas Instruments TMS320C55x DSP family";
2390 case EM_TI_PRU
: return "TI PRU I/O processor";
2392 case EM_MMDSP_PLUS
: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2393 case EM_CYPRESS_M8C
: return "Cypress M8C microprocessor";
2394 case EM_R32C
: return "Renesas R32C series microprocessors";
2395 case EM_TRIMEDIA
: return "NXP Semiconductors TriMedia architecture family";
2396 case EM_QDSP6
: return "QUALCOMM DSP6 Processor";
2397 case EM_8051
: return "Intel 8051 and variants";
2398 case EM_STXP7X
: return "STMicroelectronics STxP7x family";
2399 case EM_NDS32
: return "Andes Technology compact code size embedded RISC processor family";
2400 case EM_ECOG1X
: return "Cyan Technology eCOG1X family";
2401 case EM_MAXQ30
: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2403 case EM_XIMO16
: return "New Japan Radio (NJR) 16-bit DSP Processor";
2404 case EM_MANIK
: return "M2000 Reconfigurable RISC Microprocessor";
2405 case EM_CRAYNV2
: return "Cray Inc. NV2 vector architecture";
2406 case EM_RX
: return "Renesas RX";
2407 case EM_METAG
: return "Imagination Technologies Meta processor architecture";
2408 case EM_MCST_ELBRUS
: return "MCST Elbrus general purpose hardware architecture";
2409 case EM_ECOG16
: return "Cyan Technology eCOG16 family";
2412 case EM_MICROBLAZE_OLD
: return "Xilinx MicroBlaze";
2413 case EM_ETPU
: return "Freescale Extended Time Processing Unit";
2414 case EM_SLE9X
: return "Infineon Technologies SLE9X core";
2416 case EM_L1OM
: return "Intel L1OM";
2417 case EM_K1OM
: return "Intel K1OM";
2418 case EM_INTEL182
: return "Intel (reserved)";
2419 case EM_AARCH64
: return "AArch64";
2420 case EM_ARM184
: return "ARM (reserved)";
2421 case EM_AVR32
: return "Atmel Corporation 32-bit microprocessor";
2422 case EM_STM8
: return "STMicroeletronics STM8 8-bit microcontroller";
2423 case EM_TILE64
: return "Tilera TILE64 multicore architecture family";
2424 case EM_TILEPRO
: return "Tilera TILEPro multicore architecture family";
2426 case EM_CUDA
: return "NVIDIA CUDA architecture";
2427 case EM_TILEGX
: return "Tilera TILE-Gx multicore architecture family";
2428 case EM_CLOUDSHIELD
: return "CloudShield architecture family";
2429 case EM_COREA_1ST
: return "KIPO-KAIST Core-A 1st generation processor family";
2430 case EM_COREA_2ND
: return "KIPO-KAIST Core-A 2nd generation processor family";
2431 case EM_ARC_COMPACT2
: return "ARCv2";
2432 case EM_OPEN8
: return "Open8 8-bit RISC soft processor core";
2433 case EM_RL78
: return "Renesas RL78";
2434 case EM_VIDEOCORE5
: return "Broadcom VideoCore V processor";
2435 case EM_78K0R
: return "Renesas 78K0R";
2437 case EM_56800EX
: return "Freescale 56800EX Digital Signal Controller (DSC)";
2438 case EM_BA1
: return "Beyond BA1 CPU architecture";
2439 case EM_BA2
: return "Beyond BA2 CPU architecture";
2440 case EM_XCORE
: return "XMOS xCORE processor family";
2441 case EM_MCHP_PIC
: return "Microchip 8-bit PIC(r) family";
2443 case EM_KM32
: return "KM211 KM32 32-bit processor";
2444 case EM_KMX32
: return "KM211 KMX32 32-bit processor";
2445 case EM_KMX16
: return "KM211 KMX16 16-bit processor";
2446 case EM_KMX8
: return "KM211 KMX8 8-bit processor";
2447 case EM_KVARC
: return "KM211 KVARC processor";
2448 case EM_CDP
: return "Paneve CDP architecture family";
2449 case EM_COGE
: return "Cognitive Smart Memory Processor";
2450 case EM_COOL
: return "Bluechip Systems CoolEngine";
2451 case EM_NORC
: return "Nanoradio Optimized RISC";
2452 case EM_CSR_KALIMBA
: return "CSR Kalimba architecture family";
2454 case EM_Z80
: return "Zilog Z80";
2455 case EM_VISIUM
: return "CDS VISIUMcore processor";
2456 case EM_FT32
: return "FTDI Chip FT32";
2457 case EM_MOXIE
: return "Moxie";
2458 case EM_AMDGPU
: return "AMD GPU";
2459 case EM_RISCV
: return "RISC-V";
2460 case EM_LANAI
: return "Lanai 32-bit processor";
2461 case EM_BPF
: return "Linux BPF";
2463 /* Large numbers... */
2464 case EM_MT
: return "Morpho Techologies MT processor";
2465 case EM_ALPHA
: return "Alpha";
2466 case EM_WEBASSEMBLY
: return "Web Assembly";
2467 case EM_DLX
: return "OpenDLX";
2468 case EM_XSTORMY16
: return "Sanyo XStormy16 CPU core";
2469 case EM_IQ2000
: return "Vitesse IQ2000";
2471 case EM_NIOS32
: return "Altera Nios";
2472 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
2473 case EM_ADAPTEVA_EPIPHANY
: return "Adapteva EPIPHANY";
2474 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
2477 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
2483 decode_ARC_machine_flags (unsigned e_flags
, unsigned e_machine
, char buf
[])
2485 /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2. Some
2486 other compilers don't a specific architecture type in the e_flags, and
2487 instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
2488 architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
2491 Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
2492 but also sets a specific architecture type in the e_flags field.
2494 However, when decoding the flags we don't worry if we see an
2495 unexpected pairing, for example EM_ARC_COMPACT machine type, with
2496 ARCEM architecture type. */
2498 switch (e_flags
& EF_ARC_MACH_MSK
)
2500 /* We only expect these to occur for EM_ARC_COMPACT2. */
2501 case EF_ARC_CPU_ARCV2EM
:
2502 strcat (buf
, ", ARC EM");
2504 case EF_ARC_CPU_ARCV2HS
:
2505 strcat (buf
, ", ARC HS");
2508 /* We only expect these to occur for EM_ARC_COMPACT. */
2509 case E_ARC_MACH_ARC600
:
2510 strcat (buf
, ", ARC600");
2512 case E_ARC_MACH_ARC601
:
2513 strcat (buf
, ", ARC601");
2515 case E_ARC_MACH_ARC700
:
2516 strcat (buf
, ", ARC700");
2519 /* The only times we should end up here are (a) A corrupt ELF, (b) A
2520 new ELF with new architecture being read by an old version of
2521 readelf, or (c) An ELF built with non-GNU compiler that does not
2522 set the architecture in the e_flags. */
2524 if (e_machine
== EM_ARC_COMPACT
)
2525 strcat (buf
, ", Unknown ARCompact");
2527 strcat (buf
, ", Unknown ARC");
2531 switch (e_flags
& EF_ARC_OSABI_MSK
)
2533 case E_ARC_OSABI_ORIG
:
2534 strcat (buf
, ", (ABI:legacy)");
2536 case E_ARC_OSABI_V2
:
2537 strcat (buf
, ", (ABI:v2)");
2539 /* Only upstream 3.9+ kernels will support ARCv2 ISA. */
2540 case E_ARC_OSABI_V3
:
2541 strcat (buf
, ", v3 no-legacy-syscalls ABI");
2543 case E_ARC_OSABI_V4
:
2544 strcat (buf
, ", v4 ABI");
2547 strcat (buf
, ", unrecognised ARC OSABI flag");
2553 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
2556 bfd_boolean unknown
= FALSE
;
2558 eabi
= EF_ARM_EABI_VERSION (e_flags
);
2559 e_flags
&= ~ EF_ARM_EABIMASK
;
2561 /* Handle "generic" ARM flags. */
2562 if (e_flags
& EF_ARM_RELEXEC
)
2564 strcat (buf
, ", relocatable executable");
2565 e_flags
&= ~ EF_ARM_RELEXEC
;
2568 /* Now handle EABI specific flags. */
2572 strcat (buf
, ", <unrecognized EABI>");
2577 case EF_ARM_EABI_VER1
:
2578 strcat (buf
, ", Version1 EABI");
2583 /* Process flags one bit at a time. */
2584 flag
= e_flags
& - e_flags
;
2589 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2590 strcat (buf
, ", sorted symbol tables");
2600 case EF_ARM_EABI_VER2
:
2601 strcat (buf
, ", Version2 EABI");
2606 /* Process flags one bit at a time. */
2607 flag
= e_flags
& - e_flags
;
2612 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2613 strcat (buf
, ", sorted symbol tables");
2616 case EF_ARM_DYNSYMSUSESEGIDX
:
2617 strcat (buf
, ", dynamic symbols use segment index");
2620 case EF_ARM_MAPSYMSFIRST
:
2621 strcat (buf
, ", mapping symbols precede others");
2631 case EF_ARM_EABI_VER3
:
2632 strcat (buf
, ", Version3 EABI");
2635 case EF_ARM_EABI_VER4
:
2636 strcat (buf
, ", Version4 EABI");
2641 /* Process flags one bit at a time. */
2642 flag
= e_flags
& - e_flags
;
2648 strcat (buf
, ", BE8");
2652 strcat (buf
, ", LE8");
2662 case EF_ARM_EABI_VER5
:
2663 strcat (buf
, ", Version5 EABI");
2668 /* Process flags one bit at a time. */
2669 flag
= e_flags
& - e_flags
;
2675 strcat (buf
, ", BE8");
2679 strcat (buf
, ", LE8");
2682 case EF_ARM_ABI_FLOAT_SOFT
: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2683 strcat (buf
, ", soft-float ABI");
2686 case EF_ARM_ABI_FLOAT_HARD
: /* Conflicts with EF_ARM_VFP_FLOAT. */
2687 strcat (buf
, ", hard-float ABI");
2697 case EF_ARM_EABI_UNKNOWN
:
2698 strcat (buf
, ", GNU EABI");
2703 /* Process flags one bit at a time. */
2704 flag
= e_flags
& - e_flags
;
2709 case EF_ARM_INTERWORK
:
2710 strcat (buf
, ", interworking enabled");
2713 case EF_ARM_APCS_26
:
2714 strcat (buf
, ", uses APCS/26");
2717 case EF_ARM_APCS_FLOAT
:
2718 strcat (buf
, ", uses APCS/float");
2722 strcat (buf
, ", position independent");
2726 strcat (buf
, ", 8 bit structure alignment");
2729 case EF_ARM_NEW_ABI
:
2730 strcat (buf
, ", uses new ABI");
2733 case EF_ARM_OLD_ABI
:
2734 strcat (buf
, ", uses old ABI");
2737 case EF_ARM_SOFT_FLOAT
:
2738 strcat (buf
, ", software FP");
2741 case EF_ARM_VFP_FLOAT
:
2742 strcat (buf
, ", VFP");
2745 case EF_ARM_MAVERICK_FLOAT
:
2746 strcat (buf
, ", Maverick FP");
2757 strcat (buf
,_(", <unknown>"));
2761 decode_AVR_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2763 --size
; /* Leave space for null terminator. */
2765 switch (e_flags
& EF_AVR_MACH
)
2767 case E_AVR_MACH_AVR1
:
2768 strncat (buf
, ", avr:1", size
);
2770 case E_AVR_MACH_AVR2
:
2771 strncat (buf
, ", avr:2", size
);
2773 case E_AVR_MACH_AVR25
:
2774 strncat (buf
, ", avr:25", size
);
2776 case E_AVR_MACH_AVR3
:
2777 strncat (buf
, ", avr:3", size
);
2779 case E_AVR_MACH_AVR31
:
2780 strncat (buf
, ", avr:31", size
);
2782 case E_AVR_MACH_AVR35
:
2783 strncat (buf
, ", avr:35", size
);
2785 case E_AVR_MACH_AVR4
:
2786 strncat (buf
, ", avr:4", size
);
2788 case E_AVR_MACH_AVR5
:
2789 strncat (buf
, ", avr:5", size
);
2791 case E_AVR_MACH_AVR51
:
2792 strncat (buf
, ", avr:51", size
);
2794 case E_AVR_MACH_AVR6
:
2795 strncat (buf
, ", avr:6", size
);
2797 case E_AVR_MACH_AVRTINY
:
2798 strncat (buf
, ", avr:100", size
);
2800 case E_AVR_MACH_XMEGA1
:
2801 strncat (buf
, ", avr:101", size
);
2803 case E_AVR_MACH_XMEGA2
:
2804 strncat (buf
, ", avr:102", size
);
2806 case E_AVR_MACH_XMEGA3
:
2807 strncat (buf
, ", avr:103", size
);
2809 case E_AVR_MACH_XMEGA4
:
2810 strncat (buf
, ", avr:104", size
);
2812 case E_AVR_MACH_XMEGA5
:
2813 strncat (buf
, ", avr:105", size
);
2815 case E_AVR_MACH_XMEGA6
:
2816 strncat (buf
, ", avr:106", size
);
2818 case E_AVR_MACH_XMEGA7
:
2819 strncat (buf
, ", avr:107", size
);
2822 strncat (buf
, ", avr:<unknown>", size
);
2826 size
-= strlen (buf
);
2827 if (e_flags
& EF_AVR_LINKRELAX_PREPARED
)
2828 strncat (buf
, ", link-relax", size
);
2832 decode_NDS32_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2838 bfd_boolean has_fpu
= FALSE
;
2841 static const char *ABI_STRINGS
[] =
2843 "ABI v0", /* use r5 as return register; only used in N1213HC */
2844 "ABI v1", /* use r0 as return register */
2845 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2846 "ABI v2fp", /* for FPU */
2850 static const char *VER_STRINGS
[] =
2852 "Andes ELF V1.3 or older",
2856 static const char *ARCH_STRINGS
[] =
2865 abi
= EF_NDS_ABI
& e_flags
;
2866 arch
= EF_NDS_ARCH
& e_flags
;
2867 config
= EF_NDS_INST
& e_flags
;
2868 version
= EF_NDS32_ELF_VERSION
& e_flags
;
2870 memset (buf
, 0, size
);
2877 case E_NDS_ABI_V2FP
:
2878 case E_NDS_ABI_AABI
:
2879 case E_NDS_ABI_V2FP_PLUS
:
2880 /* In case there are holes in the array. */
2881 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ABI_STRINGS
[abi
>> EF_NDS_ABI_SHIFT
]);
2885 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ABI>");
2891 case E_NDS32_ELF_VER_1_2
:
2892 case E_NDS32_ELF_VER_1_3
:
2893 case E_NDS32_ELF_VER_1_4
:
2894 r
+= snprintf (buf
+ r
, size
- r
, ", %s", VER_STRINGS
[version
>> EF_NDS32_ELF_VERSION_SHIFT
]);
2898 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ELF version number>");
2902 if (E_NDS_ABI_V0
== abi
)
2904 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2905 r
+= snprintf (buf
+ r
, size
- r
, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2906 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2907 r
+= snprintf (buf
+ r
, size
-r
, ", 16b"); /* has 16-bit instructions */
2913 case E_NDS_ARCH_STAR_V1_0
:
2914 case E_NDS_ARCH_STAR_V2_0
:
2915 case E_NDS_ARCH_STAR_V3_0
:
2916 case E_NDS_ARCH_STAR_V3_M
:
2917 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ARCH_STRINGS
[arch
>> EF_NDS_ARCH_SHIFT
]);
2921 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized architecture>");
2922 /* ARCH version determines how the e_flags are interpreted.
2923 If it is unknown, we cannot proceed. */
2927 /* Newer ABI; Now handle architecture specific flags. */
2928 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2930 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2931 r
+= snprintf (buf
+ r
, size
-r
, ", MFUSR_PC");
2933 if (!(config
& E_NDS32_HAS_NO_MAC_INST
))
2934 r
+= snprintf (buf
+ r
, size
-r
, ", MAC");
2936 if (config
& E_NDS32_HAS_DIV_INST
)
2937 r
+= snprintf (buf
+ r
, size
-r
, ", DIV");
2939 if (config
& E_NDS32_HAS_16BIT_INST
)
2940 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
2944 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2946 if (version
<= E_NDS32_ELF_VER_1_3
)
2947 r
+= snprintf (buf
+ r
, size
-r
, ", [B8]");
2949 r
+= snprintf (buf
+ r
, size
-r
, ", EX9");
2952 if (config
& E_NDS32_HAS_MAC_DX_INST
)
2953 r
+= snprintf (buf
+ r
, size
-r
, ", MAC_DX");
2955 if (config
& E_NDS32_HAS_DIV_DX_INST
)
2956 r
+= snprintf (buf
+ r
, size
-r
, ", DIV_DX");
2958 if (config
& E_NDS32_HAS_16BIT_INST
)
2960 if (version
<= E_NDS32_ELF_VER_1_3
)
2961 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
2963 r
+= snprintf (buf
+ r
, size
-r
, ", IFC");
2967 if (config
& E_NDS32_HAS_EXT_INST
)
2968 r
+= snprintf (buf
+ r
, size
-r
, ", PERF1");
2970 if (config
& E_NDS32_HAS_EXT2_INST
)
2971 r
+= snprintf (buf
+ r
, size
-r
, ", PERF2");
2973 if (config
& E_NDS32_HAS_FPU_INST
)
2976 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_SP");
2979 if (config
& E_NDS32_HAS_FPU_DP_INST
)
2982 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_DP");
2985 if (config
& E_NDS32_HAS_FPU_MAC_INST
)
2988 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_MAC");
2993 switch ((config
& E_NDS32_FPU_REG_CONF
) >> E_NDS32_FPU_REG_CONF_SHIFT
)
2995 case E_NDS32_FPU_REG_8SP_4DP
:
2996 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:8/4");
2998 case E_NDS32_FPU_REG_16SP_8DP
:
2999 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:16/8");
3001 case E_NDS32_FPU_REG_32SP_16DP
:
3002 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/16");
3004 case E_NDS32_FPU_REG_32SP_32DP
:
3005 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/32");
3010 if (config
& E_NDS32_HAS_AUDIO_INST
)
3011 r
+= snprintf (buf
+ r
, size
-r
, ", AUDIO");
3013 if (config
& E_NDS32_HAS_STRING_INST
)
3014 r
+= snprintf (buf
+ r
, size
-r
, ", STR");
3016 if (config
& E_NDS32_HAS_REDUCED_REGS
)
3017 r
+= snprintf (buf
+ r
, size
-r
, ", 16REG");
3019 if (config
& E_NDS32_HAS_VIDEO_INST
)
3021 if (version
<= E_NDS32_ELF_VER_1_3
)
3022 r
+= snprintf (buf
+ r
, size
-r
, ", VIDEO");
3024 r
+= snprintf (buf
+ r
, size
-r
, ", SATURATION");
3027 if (config
& E_NDS32_HAS_ENCRIPT_INST
)
3028 r
+= snprintf (buf
+ r
, size
-r
, ", ENCRP");
3030 if (config
& E_NDS32_HAS_L2C_INST
)
3031 r
+= snprintf (buf
+ r
, size
-r
, ", L2C");
3035 get_machine_flags (Filedata
* filedata
, unsigned e_flags
, unsigned e_machine
)
3037 static char buf
[1024];
3048 case EM_ARC_COMPACT2
:
3049 case EM_ARC_COMPACT
:
3050 decode_ARC_machine_flags (e_flags
, e_machine
, buf
);
3054 decode_ARM_machine_flags (e_flags
, buf
);
3058 decode_AVR_machine_flags (e_flags
, buf
, sizeof buf
);
3062 if (e_flags
& EF_BFIN_PIC
)
3063 strcat (buf
, ", PIC");
3065 if (e_flags
& EF_BFIN_FDPIC
)
3066 strcat (buf
, ", FDPIC");
3068 if (e_flags
& EF_BFIN_CODE_IN_L1
)
3069 strcat (buf
, ", code in L1");
3071 if (e_flags
& EF_BFIN_DATA_IN_L1
)
3072 strcat (buf
, ", data in L1");
3077 switch (e_flags
& EF_FRV_CPU_MASK
)
3079 case EF_FRV_CPU_GENERIC
:
3083 strcat (buf
, ", fr???");
3086 case EF_FRV_CPU_FR300
:
3087 strcat (buf
, ", fr300");
3090 case EF_FRV_CPU_FR400
:
3091 strcat (buf
, ", fr400");
3093 case EF_FRV_CPU_FR405
:
3094 strcat (buf
, ", fr405");
3097 case EF_FRV_CPU_FR450
:
3098 strcat (buf
, ", fr450");
3101 case EF_FRV_CPU_FR500
:
3102 strcat (buf
, ", fr500");
3104 case EF_FRV_CPU_FR550
:
3105 strcat (buf
, ", fr550");
3108 case EF_FRV_CPU_SIMPLE
:
3109 strcat (buf
, ", simple");
3111 case EF_FRV_CPU_TOMCAT
:
3112 strcat (buf
, ", tomcat");
3118 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
3119 strcat (buf
, ", m68000");
3120 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
3121 strcat (buf
, ", cpu32");
3122 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
3123 strcat (buf
, ", fido_a");
3126 char const * isa
= _("unknown");
3127 char const * mac
= _("unknown mac");
3128 char const * additional
= NULL
;
3130 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
3132 case EF_M68K_CF_ISA_A_NODIV
:
3134 additional
= ", nodiv";
3136 case EF_M68K_CF_ISA_A
:
3139 case EF_M68K_CF_ISA_A_PLUS
:
3142 case EF_M68K_CF_ISA_B_NOUSP
:
3144 additional
= ", nousp";
3146 case EF_M68K_CF_ISA_B
:
3149 case EF_M68K_CF_ISA_C
:
3152 case EF_M68K_CF_ISA_C_NODIV
:
3154 additional
= ", nodiv";
3157 strcat (buf
, ", cf, isa ");
3160 strcat (buf
, additional
);
3161 if (e_flags
& EF_M68K_CF_FLOAT
)
3162 strcat (buf
, ", float");
3163 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
3168 case EF_M68K_CF_MAC
:
3171 case EF_M68K_CF_EMAC
:
3174 case EF_M68K_CF_EMAC_B
:
3187 switch (e_flags
& EF_MEP_CPU_MASK
)
3189 case EF_MEP_CPU_MEP
: strcat (buf
, ", generic MeP"); break;
3190 case EF_MEP_CPU_C2
: strcat (buf
, ", MeP C2"); break;
3191 case EF_MEP_CPU_C3
: strcat (buf
, ", MeP C3"); break;
3192 case EF_MEP_CPU_C4
: strcat (buf
, ", MeP C4"); break;
3193 case EF_MEP_CPU_C5
: strcat (buf
, ", MeP C5"); break;
3194 case EF_MEP_CPU_H1
: strcat (buf
, ", MeP H1"); break;
3195 default: strcat (buf
, _(", <unknown MeP cpu type>")); break;
3198 switch (e_flags
& EF_MEP_COP_MASK
)
3200 case EF_MEP_COP_NONE
: break;
3201 case EF_MEP_COP_AVC
: strcat (buf
, ", AVC coprocessor"); break;
3202 case EF_MEP_COP_AVC2
: strcat (buf
, ", AVC2 coprocessor"); break;
3203 case EF_MEP_COP_FMAX
: strcat (buf
, ", FMAX coprocessor"); break;
3204 case EF_MEP_COP_IVC2
: strcat (buf
, ", IVC2 coprocessor"); break;
3205 default: strcat (buf
, _("<unknown MeP copro type>")); break;
3208 if (e_flags
& EF_MEP_LIBRARY
)
3209 strcat (buf
, ", Built for Library");
3211 if (e_flags
& EF_MEP_INDEX_MASK
)
3212 sprintf (buf
+ strlen (buf
), ", Configuration Index: %#x",
3213 e_flags
& EF_MEP_INDEX_MASK
);
3215 if (e_flags
& ~ EF_MEP_ALL_FLAGS
)
3216 sprintf (buf
+ strlen (buf
), _(", unknown flags bits: %#x"),
3217 e_flags
& ~ EF_MEP_ALL_FLAGS
);
3221 if (e_flags
& EF_PPC_EMB
)
3222 strcat (buf
, ", emb");
3224 if (e_flags
& EF_PPC_RELOCATABLE
)
3225 strcat (buf
, _(", relocatable"));
3227 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
3228 strcat (buf
, _(", relocatable-lib"));
3232 if (e_flags
& EF_PPC64_ABI
)
3234 char abi
[] = ", abiv0";
3236 abi
[6] += e_flags
& EF_PPC64_ABI
;
3242 if ((e_flags
& EF_RH850_ABI
) == EF_RH850_ABI
)
3243 strcat (buf
, ", RH850 ABI");
3245 if (e_flags
& EF_V800_850E3
)
3246 strcat (buf
, ", V3 architecture");
3248 if ((e_flags
& (EF_RH850_FPU_DOUBLE
| EF_RH850_FPU_SINGLE
)) == 0)
3249 strcat (buf
, ", FPU not used");
3251 if ((e_flags
& (EF_RH850_REGMODE22
| EF_RH850_REGMODE32
)) == 0)
3252 strcat (buf
, ", regmode: COMMON");
3254 if ((e_flags
& (EF_RH850_GP_FIX
| EF_RH850_GP_NOFIX
)) == 0)
3255 strcat (buf
, ", r4 not used");
3257 if ((e_flags
& (EF_RH850_EP_FIX
| EF_RH850_EP_NOFIX
)) == 0)
3258 strcat (buf
, ", r30 not used");
3260 if ((e_flags
& (EF_RH850_TP_FIX
| EF_RH850_TP_NOFIX
)) == 0)
3261 strcat (buf
, ", r5 not used");
3263 if ((e_flags
& (EF_RH850_REG2_RESERVE
| EF_RH850_REG2_NORESERVE
)) == 0)
3264 strcat (buf
, ", r2 not used");
3266 for (e_flags
&= 0xFFFF; e_flags
; e_flags
&= ~ (e_flags
& - e_flags
))
3268 switch (e_flags
& - e_flags
)
3270 case EF_RH850_FPU_DOUBLE
: strcat (buf
, ", double precision FPU"); break;
3271 case EF_RH850_FPU_SINGLE
: strcat (buf
, ", single precision FPU"); break;
3272 case EF_RH850_REGMODE22
: strcat (buf
, ", regmode:22"); break;
3273 case EF_RH850_REGMODE32
: strcat (buf
, ", regmode:23"); break;
3274 case EF_RH850_GP_FIX
: strcat (buf
, ", r4 fixed"); break;
3275 case EF_RH850_GP_NOFIX
: strcat (buf
, ", r4 free"); break;
3276 case EF_RH850_EP_FIX
: strcat (buf
, ", r30 fixed"); break;
3277 case EF_RH850_EP_NOFIX
: strcat (buf
, ", r30 free"); break;
3278 case EF_RH850_TP_FIX
: strcat (buf
, ", r5 fixed"); break;
3279 case EF_RH850_TP_NOFIX
: strcat (buf
, ", r5 free"); break;
3280 case EF_RH850_REG2_RESERVE
: strcat (buf
, ", r2 fixed"); break;
3281 case EF_RH850_REG2_NORESERVE
: strcat (buf
, ", r2 free"); break;
3288 case EM_CYGNUS_V850
:
3289 switch (e_flags
& EF_V850_ARCH
)
3291 case E_V850E3V5_ARCH
:
3292 strcat (buf
, ", v850e3v5");
3294 case E_V850E2V3_ARCH
:
3295 strcat (buf
, ", v850e2v3");
3298 strcat (buf
, ", v850e2");
3301 strcat (buf
, ", v850e1");
3304 strcat (buf
, ", v850e");
3307 strcat (buf
, ", v850");
3310 strcat (buf
, _(", unknown v850 architecture variant"));
3316 case EM_CYGNUS_M32R
:
3317 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
3318 strcat (buf
, ", m32r");
3322 case EM_MIPS_RS3_LE
:
3323 if (e_flags
& EF_MIPS_NOREORDER
)
3324 strcat (buf
, ", noreorder");
3326 if (e_flags
& EF_MIPS_PIC
)
3327 strcat (buf
, ", pic");
3329 if (e_flags
& EF_MIPS_CPIC
)
3330 strcat (buf
, ", cpic");
3332 if (e_flags
& EF_MIPS_UCODE
)
3333 strcat (buf
, ", ugen_reserved");
3335 if (e_flags
& EF_MIPS_ABI2
)
3336 strcat (buf
, ", abi2");
3338 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
3339 strcat (buf
, ", odk first");
3341 if (e_flags
& EF_MIPS_32BITMODE
)
3342 strcat (buf
, ", 32bitmode");
3344 if (e_flags
& EF_MIPS_NAN2008
)
3345 strcat (buf
, ", nan2008");
3347 if (e_flags
& EF_MIPS_FP64
)
3348 strcat (buf
, ", fp64");
3350 switch ((e_flags
& EF_MIPS_MACH
))
3352 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
3353 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
3354 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
3355 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
3356 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
3357 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
3358 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
3359 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
3360 case E_MIPS_MACH_5900
: strcat (buf
, ", 5900"); break;
3361 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
3362 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
3363 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
3364 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
3365 case E_MIPS_MACH_LS3A
: strcat (buf
, ", loongson-3a"); break;
3366 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
3367 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
3368 case E_MIPS_MACH_OCTEON3
: strcat (buf
, ", octeon3"); break;
3369 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
3370 case E_MIPS_MACH_IAMR2
: strcat (buf
, ", interaptiv-mr2"); break;
3372 /* We simply ignore the field in this case to avoid confusion:
3373 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3376 default: strcat (buf
, _(", unknown CPU")); break;
3379 switch ((e_flags
& EF_MIPS_ABI
))
3381 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
3382 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
3383 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
3384 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
3386 /* We simply ignore the field in this case to avoid confusion:
3387 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3388 This means it is likely to be an o32 file, but not for
3391 default: strcat (buf
, _(", unknown ABI")); break;
3394 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
3395 strcat (buf
, ", mdmx");
3397 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
3398 strcat (buf
, ", mips16");
3400 if (e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
3401 strcat (buf
, ", micromips");
3403 switch ((e_flags
& EF_MIPS_ARCH
))
3405 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
3406 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
3407 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
3408 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
3409 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
3410 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
3411 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
3412 case E_MIPS_ARCH_32R6
: strcat (buf
, ", mips32r6"); break;
3413 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
3414 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
3415 case E_MIPS_ARCH_64R6
: strcat (buf
, ", mips64r6"); break;
3416 default: strcat (buf
, _(", unknown ISA")); break;
3421 decode_NDS32_machine_flags (e_flags
, buf
, sizeof buf
);
3425 if (e_flags
& EF_RISCV_RVC
)
3426 strcat (buf
, ", RVC");
3428 switch (e_flags
& EF_RISCV_FLOAT_ABI
)
3430 case EF_RISCV_FLOAT_ABI_SOFT
:
3431 strcat (buf
, ", soft-float ABI");
3434 case EF_RISCV_FLOAT_ABI_SINGLE
:
3435 strcat (buf
, ", single-float ABI");
3438 case EF_RISCV_FLOAT_ABI_DOUBLE
:
3439 strcat (buf
, ", double-float ABI");
3442 case EF_RISCV_FLOAT_ABI_QUAD
:
3443 strcat (buf
, ", quad-float ABI");
3449 switch ((e_flags
& EF_SH_MACH_MASK
))
3451 case EF_SH1
: strcat (buf
, ", sh1"); break;
3452 case EF_SH2
: strcat (buf
, ", sh2"); break;
3453 case EF_SH3
: strcat (buf
, ", sh3"); break;
3454 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
3455 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
3456 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
3457 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
3458 case EF_SH4
: strcat (buf
, ", sh4"); break;
3459 case EF_SH5
: strcat (buf
, ", sh5"); break;
3460 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
3461 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
3462 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
3463 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
3464 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
3465 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
3466 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
3467 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
3468 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3469 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
3470 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
3471 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
3472 default: strcat (buf
, _(", unknown ISA")); break;
3475 if (e_flags
& EF_SH_PIC
)
3476 strcat (buf
, ", pic");
3478 if (e_flags
& EF_SH_FDPIC
)
3479 strcat (buf
, ", fdpic");
3483 if (e_flags
& EF_OR1K_NODELAY
)
3484 strcat (buf
, ", no delay");
3488 if (e_flags
& EF_SPARC_32PLUS
)
3489 strcat (buf
, ", v8+");
3491 if (e_flags
& EF_SPARC_SUN_US1
)
3492 strcat (buf
, ", ultrasparcI");
3494 if (e_flags
& EF_SPARC_SUN_US3
)
3495 strcat (buf
, ", ultrasparcIII");
3497 if (e_flags
& EF_SPARC_HAL_R1
)
3498 strcat (buf
, ", halr1");
3500 if (e_flags
& EF_SPARC_LEDATA
)
3501 strcat (buf
, ", ledata");
3503 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
3504 strcat (buf
, ", tso");
3506 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
3507 strcat (buf
, ", pso");
3509 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
3510 strcat (buf
, ", rmo");
3514 switch (e_flags
& EF_PARISC_ARCH
)
3516 case EFA_PARISC_1_0
:
3517 strcpy (buf
, ", PA-RISC 1.0");
3519 case EFA_PARISC_1_1
:
3520 strcpy (buf
, ", PA-RISC 1.1");
3522 case EFA_PARISC_2_0
:
3523 strcpy (buf
, ", PA-RISC 2.0");
3528 if (e_flags
& EF_PARISC_TRAPNIL
)
3529 strcat (buf
, ", trapnil");
3530 if (e_flags
& EF_PARISC_EXT
)
3531 strcat (buf
, ", ext");
3532 if (e_flags
& EF_PARISC_LSB
)
3533 strcat (buf
, ", lsb");
3534 if (e_flags
& EF_PARISC_WIDE
)
3535 strcat (buf
, ", wide");
3536 if (e_flags
& EF_PARISC_NO_KABP
)
3537 strcat (buf
, ", no kabp");
3538 if (e_flags
& EF_PARISC_LAZYSWAP
)
3539 strcat (buf
, ", lazyswap");
3544 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
3545 strcat (buf
, ", new calling convention");
3547 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
3548 strcat (buf
, ", gnu calling convention");
3552 if ((e_flags
& EF_IA_64_ABI64
))
3553 strcat (buf
, ", 64-bit");
3555 strcat (buf
, ", 32-bit");
3556 if ((e_flags
& EF_IA_64_REDUCEDFP
))
3557 strcat (buf
, ", reduced fp model");
3558 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
3559 strcat (buf
, ", no function descriptors, constant gp");
3560 else if ((e_flags
& EF_IA_64_CONS_GP
))
3561 strcat (buf
, ", constant gp");
3562 if ((e_flags
& EF_IA_64_ABSOLUTE
))
3563 strcat (buf
, ", absolute");
3564 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
3566 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
3567 strcat (buf
, ", vms_linkages");
3568 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
3570 case EF_IA_64_VMS_COMCOD_SUCCESS
:
3572 case EF_IA_64_VMS_COMCOD_WARNING
:
3573 strcat (buf
, ", warning");
3575 case EF_IA_64_VMS_COMCOD_ERROR
:
3576 strcat (buf
, ", error");
3578 case EF_IA_64_VMS_COMCOD_ABORT
:
3579 strcat (buf
, ", abort");
3582 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3583 e_flags
& EF_IA_64_VMS_COMCOD
);
3584 strcat (buf
, ", <unknown>");
3590 if ((e_flags
& EF_VAX_NONPIC
))
3591 strcat (buf
, ", non-PIC");
3592 if ((e_flags
& EF_VAX_DFLOAT
))
3593 strcat (buf
, ", D-Float");
3594 if ((e_flags
& EF_VAX_GFLOAT
))
3595 strcat (buf
, ", G-Float");
3599 if (e_flags
& EF_VISIUM_ARCH_MCM
)
3600 strcat (buf
, ", mcm");
3601 else if (e_flags
& EF_VISIUM_ARCH_MCM24
)
3602 strcat (buf
, ", mcm24");
3603 if (e_flags
& EF_VISIUM_ARCH_GR6
)
3604 strcat (buf
, ", gr6");
3608 switch (e_flags
& E_FLAG_RL78_CPU_MASK
)
3610 case E_FLAG_RL78_ANY_CPU
: break;
3611 case E_FLAG_RL78_G10
: strcat (buf
, ", G10"); break;
3612 case E_FLAG_RL78_G13
: strcat (buf
, ", G13"); break;
3613 case E_FLAG_RL78_G14
: strcat (buf
, ", G14"); break;
3615 if (e_flags
& E_FLAG_RL78_64BIT_DOUBLES
)
3616 strcat (buf
, ", 64-bit doubles");
3620 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
3621 strcat (buf
, ", 64-bit doubles");
3622 if (e_flags
& E_FLAG_RX_DSP
)
3623 strcat (buf
, ", dsp");
3624 if (e_flags
& E_FLAG_RX_PID
)
3625 strcat (buf
, ", pid");
3626 if (e_flags
& E_FLAG_RX_ABI
)
3627 strcat (buf
, ", RX ABI");
3628 if (e_flags
& E_FLAG_RX_SINSNS_SET
)
3629 strcat (buf
, e_flags
& E_FLAG_RX_SINSNS_YES
3630 ? ", uses String instructions" : ", bans String instructions");
3631 if (e_flags
& E_FLAG_RX_V2
)
3632 strcat (buf
, ", V2");
3636 if (e_flags
& EF_S390_HIGH_GPRS
)
3637 strcat (buf
, ", highgprs");
3641 if ((e_flags
& EF_C6000_REL
))
3642 strcat (buf
, ", relocatable module");
3646 strcat (buf
, _(": architecture variant: "));
3647 switch (e_flags
& EF_MSP430_MACH
)
3649 case E_MSP430_MACH_MSP430x11
: strcat (buf
, "MSP430x11"); break;
3650 case E_MSP430_MACH_MSP430x11x1
: strcat (buf
, "MSP430x11x1 "); break;
3651 case E_MSP430_MACH_MSP430x12
: strcat (buf
, "MSP430x12"); break;
3652 case E_MSP430_MACH_MSP430x13
: strcat (buf
, "MSP430x13"); break;
3653 case E_MSP430_MACH_MSP430x14
: strcat (buf
, "MSP430x14"); break;
3654 case E_MSP430_MACH_MSP430x15
: strcat (buf
, "MSP430x15"); break;
3655 case E_MSP430_MACH_MSP430x16
: strcat (buf
, "MSP430x16"); break;
3656 case E_MSP430_MACH_MSP430x31
: strcat (buf
, "MSP430x31"); break;
3657 case E_MSP430_MACH_MSP430x32
: strcat (buf
, "MSP430x32"); break;
3658 case E_MSP430_MACH_MSP430x33
: strcat (buf
, "MSP430x33"); break;
3659 case E_MSP430_MACH_MSP430x41
: strcat (buf
, "MSP430x41"); break;
3660 case E_MSP430_MACH_MSP430x42
: strcat (buf
, "MSP430x42"); break;
3661 case E_MSP430_MACH_MSP430x43
: strcat (buf
, "MSP430x43"); break;
3662 case E_MSP430_MACH_MSP430x44
: strcat (buf
, "MSP430x44"); break;
3663 case E_MSP430_MACH_MSP430X
: strcat (buf
, "MSP430X"); break;
3665 strcat (buf
, _(": unknown")); break;
3668 if (e_flags
& ~ EF_MSP430_MACH
)
3669 strcat (buf
, _(": unknown extra flag bits also present"));
3677 get_osabi_name (Filedata
* filedata
, unsigned int osabi
)
3679 static char buff
[32];
3683 case ELFOSABI_NONE
: return "UNIX - System V";
3684 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
3685 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
3686 case ELFOSABI_GNU
: return "UNIX - GNU";
3687 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
3688 case ELFOSABI_AIX
: return "UNIX - AIX";
3689 case ELFOSABI_IRIX
: return "UNIX - IRIX";
3690 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
3691 case ELFOSABI_TRU64
: return "UNIX - TRU64";
3692 case ELFOSABI_MODESTO
: return "Novell - Modesto";
3693 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
3694 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
3695 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
3696 case ELFOSABI_AROS
: return "AROS";
3697 case ELFOSABI_FENIXOS
: return "FenixOS";
3698 case ELFOSABI_CLOUDABI
: return "Nuxi CloudABI";
3699 case ELFOSABI_OPENVOS
: return "Stratus Technologies OpenVOS";
3702 switch (filedata
->file_header
.e_machine
)
3707 case ELFOSABI_ARM
: return "ARM";
3718 case ELFOSABI_STANDALONE
: return _("Standalone App");
3727 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
3728 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
3737 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
3743 get_aarch64_segment_type (unsigned long type
)
3747 case PT_AARCH64_ARCHEXT
: return "AARCH64_ARCHEXT";
3748 default: return NULL
;
3753 get_arm_segment_type (unsigned long type
)
3757 case PT_ARM_EXIDX
: return "EXIDX";
3758 default: return NULL
;
3763 get_s390_segment_type (unsigned long type
)
3767 case PT_S390_PGSTE
: return "S390_PGSTE";
3768 default: return NULL
;
3773 get_mips_segment_type (unsigned long type
)
3777 case PT_MIPS_REGINFO
: return "REGINFO";
3778 case PT_MIPS_RTPROC
: return "RTPROC";
3779 case PT_MIPS_OPTIONS
: return "OPTIONS";
3780 case PT_MIPS_ABIFLAGS
: return "ABIFLAGS";
3781 default: return NULL
;
3786 get_parisc_segment_type (unsigned long type
)
3790 case PT_HP_TLS
: return "HP_TLS";
3791 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
3792 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
3793 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
3794 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
3795 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
3796 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
3797 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
3798 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
3799 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
3800 case PT_HP_PARALLEL
: return "HP_PARALLEL";
3801 case PT_HP_FASTBIND
: return "HP_FASTBIND";
3802 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
3803 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
3804 case PT_HP_STACK
: return "HP_STACK";
3805 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
3806 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
3807 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
3808 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
3809 default: return NULL
;
3814 get_ia64_segment_type (unsigned long type
)
3818 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
3819 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
3820 case PT_HP_TLS
: return "HP_TLS";
3821 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
3822 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
3823 case PT_IA_64_HP_STACK
: return "HP_STACK";
3824 default: return NULL
;
3829 get_tic6x_segment_type (unsigned long type
)
3833 case PT_C6000_PHATTR
: return "C6000_PHATTR";
3834 default: return NULL
;
3839 get_solaris_segment_type (unsigned long type
)
3843 case 0x6464e550: return "PT_SUNW_UNWIND";
3844 case 0x6474e550: return "PT_SUNW_EH_FRAME";
3845 case 0x6ffffff7: return "PT_LOSUNW";
3846 case 0x6ffffffa: return "PT_SUNWBSS";
3847 case 0x6ffffffb: return "PT_SUNWSTACK";
3848 case 0x6ffffffc: return "PT_SUNWDTRACE";
3849 case 0x6ffffffd: return "PT_SUNWCAP";
3850 case 0x6fffffff: return "PT_HISUNW";
3851 default: return NULL
;
3856 get_segment_type (Filedata
* filedata
, unsigned long p_type
)
3858 static char buff
[32];
3862 case PT_NULL
: return "NULL";
3863 case PT_LOAD
: return "LOAD";
3864 case PT_DYNAMIC
: return "DYNAMIC";
3865 case PT_INTERP
: return "INTERP";
3866 case PT_NOTE
: return "NOTE";
3867 case PT_SHLIB
: return "SHLIB";
3868 case PT_PHDR
: return "PHDR";
3869 case PT_TLS
: return "TLS";
3870 case PT_GNU_EH_FRAME
: return "GNU_EH_FRAME";
3871 case PT_GNU_STACK
: return "GNU_STACK";
3872 case PT_GNU_RELRO
: return "GNU_RELRO";
3875 if (p_type
>= PT_GNU_MBIND_LO
&& p_type
<= PT_GNU_MBIND_HI
)
3877 sprintf (buff
, "GNU_MBIND+%#lx",
3878 p_type
- PT_GNU_MBIND_LO
);
3880 else if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
3882 const char * result
;
3884 switch (filedata
->file_header
.e_machine
)
3887 result
= get_aarch64_segment_type (p_type
);
3890 result
= get_arm_segment_type (p_type
);
3893 case EM_MIPS_RS3_LE
:
3894 result
= get_mips_segment_type (p_type
);
3897 result
= get_parisc_segment_type (p_type
);
3900 result
= get_ia64_segment_type (p_type
);
3903 result
= get_tic6x_segment_type (p_type
);
3907 result
= get_s390_segment_type (p_type
);
3917 sprintf (buff
, "LOPROC+%#lx", p_type
- PT_LOPROC
);
3919 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
3921 const char * result
;
3923 switch (filedata
->file_header
.e_machine
)
3926 result
= get_parisc_segment_type (p_type
);
3929 result
= get_ia64_segment_type (p_type
);
3932 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
3933 result
= get_solaris_segment_type (p_type
);
3942 sprintf (buff
, "LOOS+%#lx", p_type
- PT_LOOS
);
3945 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
3952 get_arc_section_type_name (unsigned int sh_type
)
3956 case SHT_ARC_ATTRIBUTES
: return "ARC_ATTRIBUTES";
3964 get_mips_section_type_name (unsigned int sh_type
)
3968 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
3969 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
3970 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
3971 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
3972 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
3973 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
3974 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
3975 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
3976 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
3977 case SHT_MIPS_RELD
: return "MIPS_RELD";
3978 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
3979 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
3980 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
3981 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
3982 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
3983 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
3984 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
3985 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
3986 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
3987 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
3988 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
3989 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
3990 case SHT_MIPS_LINE
: return "MIPS_LINE";
3991 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
3992 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
3993 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
3994 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
3995 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
3996 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
3997 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
3998 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
3999 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
4000 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
4001 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
4002 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
4003 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
4004 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
4005 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
4006 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
4007 case SHT_MIPS_ABIFLAGS
: return "MIPS_ABIFLAGS";
4015 get_parisc_section_type_name (unsigned int sh_type
)
4019 case SHT_PARISC_EXT
: return "PARISC_EXT";
4020 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
4021 case SHT_PARISC_DOC
: return "PARISC_DOC";
4022 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
4023 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
4024 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
4025 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
4026 default: return NULL
;
4031 get_ia64_section_type_name (Filedata
* filedata
, unsigned int sh_type
)
4033 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
4034 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
4035 return get_osabi_name (filedata
, (sh_type
& 0x00FF0000) >> 16);
4039 case SHT_IA_64_EXT
: return "IA_64_EXT";
4040 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
4041 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
4042 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
4043 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
4044 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
4045 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
4046 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
4047 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
4048 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
4056 get_x86_64_section_type_name (unsigned int sh_type
)
4060 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
4061 default: return NULL
;
4066 get_aarch64_section_type_name (unsigned int sh_type
)
4070 case SHT_AARCH64_ATTRIBUTES
: return "AARCH64_ATTRIBUTES";
4071 default: return NULL
;
4076 get_arm_section_type_name (unsigned int sh_type
)
4080 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
4081 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
4082 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
4083 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
4084 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
4085 default: return NULL
;
4090 get_tic6x_section_type_name (unsigned int sh_type
)
4094 case SHT_C6000_UNWIND
: return "C6000_UNWIND";
4095 case SHT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
4096 case SHT_C6000_ATTRIBUTES
: return "C6000_ATTRIBUTES";
4097 case SHT_TI_ICODE
: return "TI_ICODE";
4098 case SHT_TI_XREF
: return "TI_XREF";
4099 case SHT_TI_HANDLER
: return "TI_HANDLER";
4100 case SHT_TI_INITINFO
: return "TI_INITINFO";
4101 case SHT_TI_PHATTRS
: return "TI_PHATTRS";
4102 default: return NULL
;
4107 get_msp430x_section_type_name (unsigned int sh_type
)
4111 case SHT_MSP430_SEC_FLAGS
: return "MSP430_SEC_FLAGS";
4112 case SHT_MSP430_SYM_ALIASES
: return "MSP430_SYM_ALIASES";
4113 case SHT_MSP430_ATTRIBUTES
: return "MSP430_ATTRIBUTES";
4114 default: return NULL
;
4119 get_v850_section_type_name (unsigned int sh_type
)
4123 case SHT_V850_SCOMMON
: return "V850 Small Common";
4124 case SHT_V850_TCOMMON
: return "V850 Tiny Common";
4125 case SHT_V850_ZCOMMON
: return "V850 Zero Common";
4126 case SHT_RENESAS_IOP
: return "RENESAS IOP";
4127 case SHT_RENESAS_INFO
: return "RENESAS INFO";
4128 default: return NULL
;
4133 get_section_type_name (Filedata
* filedata
, unsigned int sh_type
)
4135 static char buff
[32];
4136 const char * result
;
4140 case SHT_NULL
: return "NULL";
4141 case SHT_PROGBITS
: return "PROGBITS";
4142 case SHT_SYMTAB
: return "SYMTAB";
4143 case SHT_STRTAB
: return "STRTAB";
4144 case SHT_RELA
: return "RELA";
4145 case SHT_HASH
: return "HASH";
4146 case SHT_DYNAMIC
: return "DYNAMIC";
4147 case SHT_NOTE
: return "NOTE";
4148 case SHT_NOBITS
: return "NOBITS";
4149 case SHT_REL
: return "REL";
4150 case SHT_SHLIB
: return "SHLIB";
4151 case SHT_DYNSYM
: return "DYNSYM";
4152 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
4153 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
4154 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
4155 case SHT_GNU_HASH
: return "GNU_HASH";
4156 case SHT_GROUP
: return "GROUP";
4157 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
4158 case SHT_GNU_verdef
: return "VERDEF";
4159 case SHT_GNU_verneed
: return "VERNEED";
4160 case SHT_GNU_versym
: return "VERSYM";
4161 case 0x6ffffff0: return "VERSYM";
4162 case 0x6ffffffc: return "VERDEF";
4163 case 0x7ffffffd: return "AUXILIARY";
4164 case 0x7fffffff: return "FILTER";
4165 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
4168 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
4170 switch (filedata
->file_header
.e_machine
)
4173 case EM_ARC_COMPACT
:
4174 case EM_ARC_COMPACT2
:
4175 result
= get_arc_section_type_name (sh_type
);
4178 case EM_MIPS_RS3_LE
:
4179 result
= get_mips_section_type_name (sh_type
);
4182 result
= get_parisc_section_type_name (sh_type
);
4185 result
= get_ia64_section_type_name (filedata
, sh_type
);
4190 result
= get_x86_64_section_type_name (sh_type
);
4193 result
= get_aarch64_section_type_name (sh_type
);
4196 result
= get_arm_section_type_name (sh_type
);
4199 result
= get_tic6x_section_type_name (sh_type
);
4202 result
= get_msp430x_section_type_name (sh_type
);
4206 case EM_CYGNUS_V850
:
4207 result
= get_v850_section_type_name (sh_type
);
4217 sprintf (buff
, "LOPROC+%#x", sh_type
- SHT_LOPROC
);
4219 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
4221 switch (filedata
->file_header
.e_machine
)
4224 result
= get_ia64_section_type_name (filedata
, sh_type
);
4227 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
4228 result
= get_solaris_section_type (sh_type
);
4233 case SHT_GNU_INCREMENTAL_INPUTS
: result
= "GNU_INCREMENTAL_INPUTS"; break;
4234 case SHT_GNU_ATTRIBUTES
: result
= "GNU_ATTRIBUTES"; break;
4235 case SHT_GNU_HASH
: result
= "GNU_HASH"; break;
4236 case SHT_GNU_LIBLIST
: result
= "GNU_LIBLIST"; break;
4248 sprintf (buff
, "LOOS+%#x", sh_type
- SHT_LOOS
);
4250 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
4252 switch (filedata
->file_header
.e_machine
)
4256 case EM_CYGNUS_V850
:
4257 result
= get_v850_section_type_name (sh_type
);
4267 sprintf (buff
, "LOUSER+%#x", sh_type
- SHT_LOUSER
);
4270 /* This message is probably going to be displayed in a 15
4271 character wide field, so put the hex value first. */
4272 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
4278 #define OPTION_DEBUG_DUMP 512
4279 #define OPTION_DYN_SYMS 513
4280 #define OPTION_DWARF_DEPTH 514
4281 #define OPTION_DWARF_START 515
4282 #define OPTION_DWARF_CHECK 516
4284 static struct option options
[] =
4286 {"all", no_argument
, 0, 'a'},
4287 {"file-header", no_argument
, 0, 'h'},
4288 {"program-headers", no_argument
, 0, 'l'},
4289 {"headers", no_argument
, 0, 'e'},
4290 {"histogram", no_argument
, 0, 'I'},
4291 {"segments", no_argument
, 0, 'l'},
4292 {"sections", no_argument
, 0, 'S'},
4293 {"section-headers", no_argument
, 0, 'S'},
4294 {"section-groups", no_argument
, 0, 'g'},
4295 {"section-details", no_argument
, 0, 't'},
4296 {"full-section-name",no_argument
, 0, 'N'},
4297 {"symbols", no_argument
, 0, 's'},
4298 {"syms", no_argument
, 0, 's'},
4299 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
4300 {"relocs", no_argument
, 0, 'r'},
4301 {"notes", no_argument
, 0, 'n'},
4302 {"dynamic", no_argument
, 0, 'd'},
4303 {"arch-specific", no_argument
, 0, 'A'},
4304 {"version-info", no_argument
, 0, 'V'},
4305 {"use-dynamic", no_argument
, 0, 'D'},
4306 {"unwind", no_argument
, 0, 'u'},
4307 {"archive-index", no_argument
, 0, 'c'},
4308 {"hex-dump", required_argument
, 0, 'x'},
4309 {"relocated-dump", required_argument
, 0, 'R'},
4310 {"string-dump", required_argument
, 0, 'p'},
4311 {"decompress", no_argument
, 0, 'z'},
4312 #ifdef SUPPORT_DISASSEMBLY
4313 {"instruction-dump", required_argument
, 0, 'i'},
4315 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
4317 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
4318 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
4319 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
4321 {"version", no_argument
, 0, 'v'},
4322 {"wide", no_argument
, 0, 'W'},
4323 {"help", no_argument
, 0, 'H'},
4324 {0, no_argument
, 0, 0}
4328 usage (FILE * stream
)
4330 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
4331 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
4332 fprintf (stream
, _(" Options are:\n\
4333 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4334 -h --file-header Display the ELF file header\n\
4335 -l --program-headers Display the program headers\n\
4336 --segments An alias for --program-headers\n\
4337 -S --section-headers Display the sections' header\n\
4338 --sections An alias for --section-headers\n\
4339 -g --section-groups Display the section groups\n\
4340 -t --section-details Display the section details\n\
4341 -e --headers Equivalent to: -h -l -S\n\
4342 -s --syms Display the symbol table\n\
4343 --symbols An alias for --syms\n\
4344 --dyn-syms Display the dynamic symbol table\n\
4345 -n --notes Display the core notes (if present)\n\
4346 -r --relocs Display the relocations (if present)\n\
4347 -u --unwind Display the unwind info (if present)\n\
4348 -d --dynamic Display the dynamic section (if present)\n\
4349 -V --version-info Display the version sections (if present)\n\
4350 -A --arch-specific Display architecture specific information (if any)\n\
4351 -c --archive-index Display the symbol/file index in an archive\n\
4352 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
4353 -x --hex-dump=<number|name>\n\
4354 Dump the contents of section <number|name> as bytes\n\
4355 -p --string-dump=<number|name>\n\
4356 Dump the contents of section <number|name> as strings\n\
4357 -R --relocated-dump=<number|name>\n\
4358 Dump the contents of section <number|name> as relocated bytes\n\
4359 -z --decompress Decompress section before dumping it\n\
4360 -w[lLiaprmfFsoRtUuTgAckK] or\n\
4361 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4362 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4363 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4364 =addr,=cu_index,=links,=follow-links]\n\
4365 Display the contents of DWARF debug sections\n"));
4366 fprintf (stream
, _("\
4367 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4368 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4370 #ifdef SUPPORT_DISASSEMBLY
4371 fprintf (stream
, _("\
4372 -i --instruction-dump=<number|name>\n\
4373 Disassemble the contents of section <number|name>\n"));
4375 fprintf (stream
, _("\
4376 -I --histogram Display histogram of bucket list lengths\n\
4377 -W --wide Allow output width to exceed 80 characters\n\
4378 @<file> Read options from <file>\n\
4379 -H --help Display this information\n\
4380 -v --version Display the version number of readelf\n"));
4382 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
4383 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
4385 exit (stream
== stdout
? 0 : 1);
4388 /* Record the fact that the user wants the contents of section number
4389 SECTION to be displayed using the method(s) encoded as flags bits
4390 in TYPE. Note, TYPE can be zero if we are creating the array for
4394 request_dump_bynumber (Filedata
* filedata
, unsigned int section
, dump_type type
)
4396 if (section
>= filedata
->num_dump_sects
)
4398 dump_type
* new_dump_sects
;
4400 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
4401 sizeof (* new_dump_sects
));
4403 if (new_dump_sects
== NULL
)
4404 error (_("Out of memory allocating dump request table.\n"));
4407 if (filedata
->dump_sects
)
4409 /* Copy current flag settings. */
4410 memcpy (new_dump_sects
, filedata
->dump_sects
,
4411 filedata
->num_dump_sects
* sizeof (* new_dump_sects
));
4413 free (filedata
->dump_sects
);
4416 filedata
->dump_sects
= new_dump_sects
;
4417 filedata
->num_dump_sects
= section
+ 1;
4421 if (filedata
->dump_sects
)
4422 filedata
->dump_sects
[section
] |= type
;
4425 /* Request a dump by section name. */
4428 request_dump_byname (const char * section
, dump_type type
)
4430 struct dump_list_entry
* new_request
;
4432 new_request
= (struct dump_list_entry
*)
4433 malloc (sizeof (struct dump_list_entry
));
4435 error (_("Out of memory allocating dump request table.\n"));
4437 new_request
->name
= strdup (section
);
4438 if (!new_request
->name
)
4439 error (_("Out of memory allocating dump request table.\n"));
4441 new_request
->type
= type
;
4443 new_request
->next
= dump_sects_byname
;
4444 dump_sects_byname
= new_request
;
4448 request_dump (Filedata
* filedata
, dump_type type
)
4454 section
= strtoul (optarg
, & cp
, 0);
4456 if (! *cp
&& section
>= 0)
4457 request_dump_bynumber (filedata
, section
, type
);
4459 request_dump_byname (optarg
, type
);
4463 parse_args (Filedata
* filedata
, int argc
, char ** argv
)
4470 while ((c
= getopt_long
4471 (argc
, argv
, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options
, NULL
)) != EOF
)
4489 do_section_groups
= TRUE
;
4492 do_histogram
= TRUE
;
4497 do_section_groups
= TRUE
;
4502 do_section_details
= TRUE
;
4513 do_using_dynamic
= TRUE
;
4537 do_histogram
= TRUE
;
4543 do_archive_index
= TRUE
;
4546 request_dump (filedata
, HEX_DUMP
);
4549 request_dump (filedata
, STRING_DUMP
);
4552 request_dump (filedata
, RELOC_DUMP
);
4555 decompress_dumps
= TRUE
;
4561 do_debugging
= TRUE
;
4562 dwarf_select_sections_all ();
4566 do_debugging
= FALSE
;
4567 dwarf_select_sections_by_letters (optarg
);
4570 case OPTION_DEBUG_DUMP
:
4573 do_debugging
= TRUE
;
4576 do_debugging
= FALSE
;
4577 dwarf_select_sections_by_names (optarg
);
4580 case OPTION_DWARF_DEPTH
:
4584 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
4587 case OPTION_DWARF_START
:
4591 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
4594 case OPTION_DWARF_CHECK
:
4597 case OPTION_DYN_SYMS
:
4600 #ifdef SUPPORT_DISASSEMBLY
4602 request_dump (filedata
, DISASS_DUMP
);
4606 print_version (program_name
);
4615 /* xgettext:c-format */
4616 error (_("Invalid option '-%c'\n"), c
);
4623 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
4624 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
4625 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
4626 && !do_section_groups
&& !do_archive_index
4632 get_elf_class (unsigned int elf_class
)
4634 static char buff
[32];
4638 case ELFCLASSNONE
: return _("none");
4639 case ELFCLASS32
: return "ELF32";
4640 case ELFCLASS64
: return "ELF64";
4642 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
4648 get_data_encoding (unsigned int encoding
)
4650 static char buff
[32];
4654 case ELFDATANONE
: return _("none");
4655 case ELFDATA2LSB
: return _("2's complement, little endian");
4656 case ELFDATA2MSB
: return _("2's complement, big endian");
4658 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
4663 /* Decode the data held in 'filedata->file_header'. */
4666 process_file_header (Filedata
* filedata
)
4668 Elf_Internal_Ehdr
* header
= & filedata
->file_header
;
4670 if ( header
->e_ident
[EI_MAG0
] != ELFMAG0
4671 || header
->e_ident
[EI_MAG1
] != ELFMAG1
4672 || header
->e_ident
[EI_MAG2
] != ELFMAG2
4673 || header
->e_ident
[EI_MAG3
] != ELFMAG3
)
4676 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4680 init_dwarf_regnames (header
->e_machine
);
4686 printf (_("ELF Header:\n"));
4687 printf (_(" Magic: "));
4688 for (i
= 0; i
< EI_NIDENT
; i
++)
4689 printf ("%2.2x ", header
->e_ident
[i
]);
4691 printf (_(" Class: %s\n"),
4692 get_elf_class (header
->e_ident
[EI_CLASS
]));
4693 printf (_(" Data: %s\n"),
4694 get_data_encoding (header
->e_ident
[EI_DATA
]));
4695 printf (_(" Version: %d %s\n"),
4696 header
->e_ident
[EI_VERSION
],
4697 (header
->e_ident
[EI_VERSION
] == EV_CURRENT
4699 : (header
->e_ident
[EI_VERSION
] != EV_NONE
4700 ? _("<unknown: %lx>")
4702 printf (_(" OS/ABI: %s\n"),
4703 get_osabi_name (filedata
, header
->e_ident
[EI_OSABI
]));
4704 printf (_(" ABI Version: %d\n"),
4705 header
->e_ident
[EI_ABIVERSION
]);
4706 printf (_(" Type: %s\n"),
4707 get_file_type (header
->e_type
));
4708 printf (_(" Machine: %s\n"),
4709 get_machine_name (header
->e_machine
));
4710 printf (_(" Version: 0x%lx\n"),
4711 (unsigned long) header
->e_version
);
4713 printf (_(" Entry point address: "));
4714 print_vma ((bfd_vma
) header
->e_entry
, PREFIX_HEX
);
4715 printf (_("\n Start of program headers: "));
4716 print_vma ((bfd_vma
) header
->e_phoff
, DEC
);
4717 printf (_(" (bytes into file)\n Start of section headers: "));
4718 print_vma ((bfd_vma
) header
->e_shoff
, DEC
);
4719 printf (_(" (bytes into file)\n"));
4721 printf (_(" Flags: 0x%lx%s\n"),
4722 (unsigned long) header
->e_flags
,
4723 get_machine_flags (filedata
, header
->e_flags
, header
->e_machine
));
4724 printf (_(" Size of this header: %ld (bytes)\n"),
4725 (long) header
->e_ehsize
);
4726 printf (_(" Size of program headers: %ld (bytes)\n"),
4727 (long) header
->e_phentsize
);
4728 printf (_(" Number of program headers: %ld"),
4729 (long) header
->e_phnum
);
4730 if (filedata
->section_headers
!= NULL
4731 && header
->e_phnum
== PN_XNUM
4732 && filedata
->section_headers
[0].sh_info
!= 0)
4733 printf (" (%ld)", (long) filedata
->section_headers
[0].sh_info
);
4734 putc ('\n', stdout
);
4735 printf (_(" Size of section headers: %ld (bytes)\n"),
4736 (long) header
->e_shentsize
);
4737 printf (_(" Number of section headers: %ld"),
4738 (long) header
->e_shnum
);
4739 if (filedata
->section_headers
!= NULL
&& header
->e_shnum
== SHN_UNDEF
)
4740 printf (" (%ld)", (long) filedata
->section_headers
[0].sh_size
);
4741 putc ('\n', stdout
);
4742 printf (_(" Section header string table index: %ld"),
4743 (long) header
->e_shstrndx
);
4744 if (filedata
->section_headers
!= NULL
4745 && header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
4746 printf (" (%u)", filedata
->section_headers
[0].sh_link
);
4747 else if (header
->e_shstrndx
!= SHN_UNDEF
4748 && header
->e_shstrndx
>= header
->e_shnum
)
4749 printf (_(" <corrupt: out of range>"));
4750 putc ('\n', stdout
);
4753 if (filedata
->section_headers
!= NULL
)
4755 if (header
->e_phnum
== PN_XNUM
4756 && filedata
->section_headers
[0].sh_info
!= 0)
4757 header
->e_phnum
= filedata
->section_headers
[0].sh_info
;
4758 if (header
->e_shnum
== SHN_UNDEF
)
4759 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
4760 if (header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
4761 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
4762 if (header
->e_shstrndx
>= header
->e_shnum
)
4763 header
->e_shstrndx
= SHN_UNDEF
;
4764 free (filedata
->section_headers
);
4765 filedata
->section_headers
= NULL
;
4771 /* Read in the program headers from FILEDATA and store them in PHEADERS.
4772 Returns TRUE upon success, FALSE otherwise. Loads 32-bit headers. */
4775 get_32bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
4777 Elf32_External_Phdr
* phdrs
;
4778 Elf32_External_Phdr
* external
;
4779 Elf_Internal_Phdr
* internal
;
4781 unsigned int size
= filedata
->file_header
.e_phentsize
;
4782 unsigned int num
= filedata
->file_header
.e_phnum
;
4784 /* PR binutils/17531: Cope with unexpected section header sizes. */
4785 if (size
== 0 || num
== 0)
4787 if (size
< sizeof * phdrs
)
4789 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4792 if (size
> sizeof * phdrs
)
4793 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4795 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
4796 size
, num
, _("program headers"));
4800 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4801 i
< filedata
->file_header
.e_phnum
;
4802 i
++, internal
++, external
++)
4804 internal
->p_type
= BYTE_GET (external
->p_type
);
4805 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4806 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4807 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4808 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4809 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4810 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4811 internal
->p_align
= BYTE_GET (external
->p_align
);
4818 /* Read in the program headers from FILEDATA and store them in PHEADERS.
4819 Returns TRUE upon success, FALSE otherwise. Loads 64-bit headers. */
4822 get_64bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
4824 Elf64_External_Phdr
* phdrs
;
4825 Elf64_External_Phdr
* external
;
4826 Elf_Internal_Phdr
* internal
;
4828 unsigned int size
= filedata
->file_header
.e_phentsize
;
4829 unsigned int num
= filedata
->file_header
.e_phnum
;
4831 /* PR binutils/17531: Cope with unexpected section header sizes. */
4832 if (size
== 0 || num
== 0)
4834 if (size
< sizeof * phdrs
)
4836 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4839 if (size
> sizeof * phdrs
)
4840 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4842 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
4843 size
, num
, _("program headers"));
4847 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4848 i
< filedata
->file_header
.e_phnum
;
4849 i
++, internal
++, external
++)
4851 internal
->p_type
= BYTE_GET (external
->p_type
);
4852 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4853 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4854 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4855 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4856 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4857 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4858 internal
->p_align
= BYTE_GET (external
->p_align
);
4865 /* Returns TRUE if the program headers were read into `program_headers'. */
4868 get_program_headers (Filedata
* filedata
)
4870 Elf_Internal_Phdr
* phdrs
;
4872 /* Check cache of prior read. */
4873 if (filedata
->program_headers
!= NULL
)
4876 /* Be kind to memory checkers by looking for
4877 e_phnum values which we know must be invalid. */
4878 if (filedata
->file_header
.e_phnum
4879 * (is_32bit_elf
? sizeof (Elf32_External_Phdr
) : sizeof (Elf64_External_Phdr
))
4880 >= filedata
->file_size
)
4882 error (_("Too many program headers - %#x - the file is not that big\n"),
4883 filedata
->file_header
.e_phnum
);
4887 phdrs
= (Elf_Internal_Phdr
*) cmalloc (filedata
->file_header
.e_phnum
,
4888 sizeof (Elf_Internal_Phdr
));
4891 error (_("Out of memory reading %u program headers\n"),
4892 filedata
->file_header
.e_phnum
);
4897 ? get_32bit_program_headers (filedata
, phdrs
)
4898 : get_64bit_program_headers (filedata
, phdrs
))
4900 filedata
->program_headers
= phdrs
;
4908 /* Returns TRUE if the program headers were loaded. */
4911 process_program_headers (Filedata
* filedata
)
4913 Elf_Internal_Phdr
* segment
;
4915 Elf_Internal_Phdr
* previous_load
= NULL
;
4917 if (filedata
->file_header
.e_phnum
== 0)
4919 /* PR binutils/12467. */
4920 if (filedata
->file_header
.e_phoff
!= 0)
4922 warn (_("possibly corrupt ELF header - it has a non-zero program"
4923 " header offset, but no program headers\n"));
4926 else if (do_segments
)
4927 printf (_("\nThere are no program headers in this file.\n"));
4931 if (do_segments
&& !do_header
)
4933 printf (_("\nElf file type is %s\n"), get_file_type (filedata
->file_header
.e_type
));
4934 printf (_("Entry point 0x%s\n"), bfd_vmatoa ("x", filedata
->file_header
.e_entry
));
4935 printf (ngettext ("There is %d program header, starting at offset %s\n",
4936 "There are %d program headers, starting at offset %s\n",
4937 filedata
->file_header
.e_phnum
),
4938 filedata
->file_header
.e_phnum
,
4939 bfd_vmatoa ("u", filedata
->file_header
.e_phoff
));
4942 if (! get_program_headers (filedata
))
4947 if (filedata
->file_header
.e_phnum
> 1)
4948 printf (_("\nProgram Headers:\n"));
4950 printf (_("\nProgram Headers:\n"));
4954 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4957 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4961 (_(" Type Offset VirtAddr PhysAddr\n"));
4963 (_(" FileSiz MemSiz Flags Align\n"));
4970 for (i
= 0, segment
= filedata
->program_headers
;
4971 i
< filedata
->file_header
.e_phnum
;
4976 printf (" %-14.14s ", get_segment_type (filedata
, segment
->p_type
));
4980 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
4981 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
4982 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
4983 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
4984 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
4986 (segment
->p_flags
& PF_R
? 'R' : ' '),
4987 (segment
->p_flags
& PF_W
? 'W' : ' '),
4988 (segment
->p_flags
& PF_X
? 'E' : ' '));
4989 printf ("%#lx", (unsigned long) segment
->p_align
);
4993 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
4994 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
4997 print_vma (segment
->p_offset
, FULL_HEX
);
5001 print_vma (segment
->p_vaddr
, FULL_HEX
);
5003 print_vma (segment
->p_paddr
, FULL_HEX
);
5006 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
5007 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
5010 print_vma (segment
->p_filesz
, FULL_HEX
);
5014 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
5015 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
5018 print_vma (segment
->p_memsz
, FULL_HEX
);
5022 (segment
->p_flags
& PF_R
? 'R' : ' '),
5023 (segment
->p_flags
& PF_W
? 'W' : ' '),
5024 (segment
->p_flags
& PF_X
? 'E' : ' '));
5026 if ((unsigned long) segment
->p_align
== segment
->p_align
)
5027 printf ("%#lx", (unsigned long) segment
->p_align
);
5030 print_vma (segment
->p_align
, PREFIX_HEX
);
5035 print_vma (segment
->p_offset
, FULL_HEX
);
5037 print_vma (segment
->p_vaddr
, FULL_HEX
);
5039 print_vma (segment
->p_paddr
, FULL_HEX
);
5041 print_vma (segment
->p_filesz
, FULL_HEX
);
5043 print_vma (segment
->p_memsz
, FULL_HEX
);
5045 (segment
->p_flags
& PF_R
? 'R' : ' '),
5046 (segment
->p_flags
& PF_W
? 'W' : ' '),
5047 (segment
->p_flags
& PF_X
? 'E' : ' '));
5048 print_vma (segment
->p_align
, PREFIX_HEX
);
5051 putc ('\n', stdout
);
5054 switch (segment
->p_type
)
5057 #if 0 /* Do not warn about out of order PT_LOAD segments. Although officially
5058 required by the ELF standard, several programs, including the Linux
5059 kernel, make use of non-ordered segments. */
5061 && previous_load
->p_vaddr
> segment
->p_vaddr
)
5062 error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
5064 if (segment
->p_memsz
< segment
->p_filesz
)
5065 error (_("the segment's file size is larger than its memory size\n"));
5066 previous_load
= segment
;
5070 /* PR 20815 - Verify that the program header is loaded into memory. */
5071 if (i
> 0 && previous_load
!= NULL
)
5072 error (_("the PHDR segment must occur before any LOAD segment\n"));
5073 if (filedata
->file_header
.e_machine
!= EM_PARISC
)
5077 for (j
= 1; j
< filedata
->file_header
.e_phnum
; j
++)
5078 if (filedata
->program_headers
[j
].p_vaddr
<= segment
->p_vaddr
5079 && (filedata
->program_headers
[j
].p_vaddr
5080 + filedata
->program_headers
[j
].p_memsz
)
5081 >= (segment
->p_vaddr
+ segment
->p_filesz
))
5083 if (j
== filedata
->file_header
.e_phnum
)
5084 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5090 error (_("more than one dynamic segment\n"));
5092 /* By default, assume that the .dynamic section is the first
5093 section in the DYNAMIC segment. */
5094 dynamic_addr
= segment
->p_offset
;
5095 dynamic_size
= segment
->p_filesz
;
5097 /* Try to locate the .dynamic section. If there is
5098 a section header table, we can easily locate it. */
5099 if (filedata
->section_headers
!= NULL
)
5101 Elf_Internal_Shdr
* sec
;
5103 sec
= find_section (filedata
, ".dynamic");
5104 if (sec
== NULL
|| sec
->sh_size
== 0)
5106 /* A corresponding .dynamic section is expected, but on
5107 IA-64/OpenVMS it is OK for it to be missing. */
5108 if (!is_ia64_vms (filedata
))
5109 error (_("no .dynamic section in the dynamic segment\n"));
5113 if (sec
->sh_type
== SHT_NOBITS
)
5119 dynamic_addr
= sec
->sh_offset
;
5120 dynamic_size
= sec
->sh_size
;
5122 if (dynamic_addr
< segment
->p_offset
5123 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
5124 warn (_("the .dynamic section is not contained"
5125 " within the dynamic segment\n"));
5126 else if (dynamic_addr
> segment
->p_offset
)
5127 warn (_("the .dynamic section is not the first section"
5128 " in the dynamic segment.\n"));
5131 /* PR binutils/17512: Avoid corrupt dynamic section info in the
5132 segment. Check this after matching against the section headers
5133 so we don't warn on debuginfo file (which have NOBITS .dynamic
5135 if (dynamic_addr
+ dynamic_size
>= filedata
->file_size
)
5137 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5138 dynamic_addr
= dynamic_size
= 0;
5143 if (fseek (filedata
->handle
, archive_file_offset
+ (long) segment
->p_offset
,
5145 error (_("Unable to find program interpreter name\n"));
5149 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
- 1);
5151 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
5152 error (_("Internal error: failed to create format string to display program interpreter\n"));
5154 program_interpreter
[0] = 0;
5155 if (fscanf (filedata
->handle
, fmt
, program_interpreter
) <= 0)
5156 error (_("Unable to read program interpreter name\n"));
5159 printf (_(" [Requesting program interpreter: %s]\n"),
5160 program_interpreter
);
5167 && filedata
->section_headers
!= NULL
5168 && filedata
->string_table
!= NULL
)
5170 printf (_("\n Section to Segment mapping:\n"));
5171 printf (_(" Segment Sections...\n"));
5173 for (i
= 0; i
< filedata
->file_header
.e_phnum
; i
++)
5176 Elf_Internal_Shdr
* section
;
5178 segment
= filedata
->program_headers
+ i
;
5179 section
= filedata
->section_headers
+ 1;
5181 printf (" %2.2d ", i
);
5183 for (j
= 1; j
< filedata
->file_header
.e_shnum
; j
++, section
++)
5185 if (!ELF_TBSS_SPECIAL (section
, segment
)
5186 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
5187 printf ("%s ", printable_section_name (filedata
, section
));
5198 /* Find the file offset corresponding to VMA by using the program headers. */
5201 offset_from_vma (Filedata
* filedata
, bfd_vma vma
, bfd_size_type size
)
5203 Elf_Internal_Phdr
* seg
;
5205 if (! get_program_headers (filedata
))
5207 warn (_("Cannot interpret virtual addresses without program headers.\n"));
5211 for (seg
= filedata
->program_headers
;
5212 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
5215 if (seg
->p_type
!= PT_LOAD
)
5218 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
5219 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
5220 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
5223 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5224 (unsigned long) vma
);
5229 /* Allocate memory and load the sections headers into FILEDATA->filedata->section_headers.
5230 If PROBE is true, this is just a probe and we do not generate any error
5231 messages if the load fails. */
5234 get_32bit_section_headers (Filedata
* filedata
, bfd_boolean probe
)
5236 Elf32_External_Shdr
* shdrs
;
5237 Elf_Internal_Shdr
* internal
;
5239 unsigned int size
= filedata
->file_header
.e_shentsize
;
5240 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
5242 /* PR binutils/17531: Cope with unexpected section header sizes. */
5243 if (size
== 0 || num
== 0)
5245 if (size
< sizeof * shdrs
)
5248 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5251 if (!probe
&& size
> sizeof * shdrs
)
5252 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5254 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_shoff
,
5256 probe
? NULL
: _("section headers"));
5260 free (filedata
->section_headers
);
5261 filedata
->section_headers
= (Elf_Internal_Shdr
*)
5262 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
5263 if (filedata
->section_headers
== NULL
)
5266 error (_("Out of memory reading %u section headers\n"), num
);
5270 for (i
= 0, internal
= filedata
->section_headers
;
5274 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5275 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5276 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5277 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5278 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5279 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5280 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5281 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5282 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5283 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5284 if (!probe
&& internal
->sh_link
> num
)
5285 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5286 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5287 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5294 /* Like get_32bit_section_headers, except that it fetches 64-bit headers. */
5297 get_64bit_section_headers (Filedata
* filedata
, bfd_boolean probe
)
5299 Elf64_External_Shdr
* shdrs
;
5300 Elf_Internal_Shdr
* internal
;
5302 unsigned int size
= filedata
->file_header
.e_shentsize
;
5303 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
5305 /* PR binutils/17531: Cope with unexpected section header sizes. */
5306 if (size
== 0 || num
== 0)
5309 if (size
< sizeof * shdrs
)
5312 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5316 if (! probe
&& size
> sizeof * shdrs
)
5317 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5319 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, filedata
,
5320 filedata
->file_header
.e_shoff
,
5322 probe
? NULL
: _("section headers"));
5326 free (filedata
->section_headers
);
5327 filedata
->section_headers
= (Elf_Internal_Shdr
*)
5328 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
5329 if (filedata
->section_headers
== NULL
)
5332 error (_("Out of memory reading %u section headers\n"), num
);
5336 for (i
= 0, internal
= filedata
->section_headers
;
5340 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5341 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5342 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5343 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5344 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5345 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5346 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5347 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5348 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5349 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5350 if (!probe
&& internal
->sh_link
> num
)
5351 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5352 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5353 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5360 static Elf_Internal_Sym
*
5361 get_32bit_elf_symbols (Filedata
* filedata
,
5362 Elf_Internal_Shdr
* section
,
5363 unsigned long * num_syms_return
)
5365 unsigned long number
= 0;
5366 Elf32_External_Sym
* esyms
= NULL
;
5367 Elf_External_Sym_Shndx
* shndx
= NULL
;
5368 Elf_Internal_Sym
* isyms
= NULL
;
5369 Elf_Internal_Sym
* psym
;
5372 if (section
->sh_size
== 0)
5374 if (num_syms_return
!= NULL
)
5375 * num_syms_return
= 0;
5379 /* Run some sanity checks first. */
5380 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5382 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5383 printable_section_name (filedata
, section
),
5384 (unsigned long) section
->sh_entsize
);
5388 if (section
->sh_size
> filedata
->file_size
)
5390 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5391 printable_section_name (filedata
, section
),
5392 (unsigned long) section
->sh_size
);
5396 number
= section
->sh_size
/ section
->sh_entsize
;
5398 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
5400 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5401 (unsigned long) section
->sh_size
,
5402 printable_section_name (filedata
, section
),
5403 (unsigned long) section
->sh_entsize
);
5407 esyms
= (Elf32_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
5408 section
->sh_size
, _("symbols"));
5413 elf_section_list
* entry
;
5416 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5417 if (entry
->hdr
->sh_link
== (unsigned long) (section
- filedata
->section_headers
))
5419 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
5420 entry
->hdr
->sh_offset
,
5421 1, entry
->hdr
->sh_size
,
5422 _("symbol table section indicies"));
5425 /* PR17531: file: heap-buffer-overflow */
5426 else if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5428 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5429 printable_section_name (filedata
, entry
->hdr
),
5430 (unsigned long) entry
->hdr
->sh_size
,
5431 (unsigned long) section
->sh_size
);
5437 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5441 error (_("Out of memory reading %lu symbols\n"),
5442 (unsigned long) number
);
5446 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5448 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5449 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5450 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5451 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5452 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5454 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5455 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5456 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5457 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5458 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5467 if (num_syms_return
!= NULL
)
5468 * num_syms_return
= isyms
== NULL
? 0 : number
;
5473 static Elf_Internal_Sym
*
5474 get_64bit_elf_symbols (Filedata
* filedata
,
5475 Elf_Internal_Shdr
* section
,
5476 unsigned long * num_syms_return
)
5478 unsigned long number
= 0;
5479 Elf64_External_Sym
* esyms
= NULL
;
5480 Elf_External_Sym_Shndx
* shndx
= NULL
;
5481 Elf_Internal_Sym
* isyms
= NULL
;
5482 Elf_Internal_Sym
* psym
;
5485 if (section
->sh_size
== 0)
5487 if (num_syms_return
!= NULL
)
5488 * num_syms_return
= 0;
5492 /* Run some sanity checks first. */
5493 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5495 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5496 printable_section_name (filedata
, section
),
5497 (unsigned long) section
->sh_entsize
);
5501 if (section
->sh_size
> filedata
->file_size
)
5503 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5504 printable_section_name (filedata
, section
),
5505 (unsigned long) section
->sh_size
);
5509 number
= section
->sh_size
/ section
->sh_entsize
;
5511 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
5513 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5514 (unsigned long) section
->sh_size
,
5515 printable_section_name (filedata
, section
),
5516 (unsigned long) section
->sh_entsize
);
5520 esyms
= (Elf64_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
5521 section
->sh_size
, _("symbols"));
5526 elf_section_list
* entry
;
5529 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5530 if (entry
->hdr
->sh_link
== (unsigned long) (section
- filedata
->section_headers
))
5532 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
5533 entry
->hdr
->sh_offset
,
5534 1, entry
->hdr
->sh_size
,
5535 _("symbol table section indicies"));
5538 /* PR17531: file: heap-buffer-overflow */
5539 else if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5541 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5542 printable_section_name (filedata
, entry
->hdr
),
5543 (unsigned long) entry
->hdr
->sh_size
,
5544 (unsigned long) section
->sh_size
);
5550 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5554 error (_("Out of memory reading %lu symbols\n"),
5555 (unsigned long) number
);
5559 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5561 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5562 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5563 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5564 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5566 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5568 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5569 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5570 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5572 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5573 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5582 if (num_syms_return
!= NULL
)
5583 * num_syms_return
= isyms
== NULL
? 0 : number
;
5589 get_elf_section_flags (Filedata
* filedata
, bfd_vma sh_flags
)
5591 static char buff
[1024];
5593 unsigned int field_size
= is_32bit_elf
? 8 : 16;
5595 unsigned int size
= sizeof (buff
) - (field_size
+ 4 + 1);
5596 bfd_vma os_flags
= 0;
5597 bfd_vma proc_flags
= 0;
5598 bfd_vma unknown_flags
= 0;
5606 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5607 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5608 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5609 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5610 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5611 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5612 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5613 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5614 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5615 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5616 /* IA-64 specific. */
5617 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5618 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5619 /* IA-64 OpenVMS specific. */
5620 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5621 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5622 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5623 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5624 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5625 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5627 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5628 /* SPARC specific. */
5629 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5630 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5632 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5633 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5634 /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
5636 /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
5638 /* 25 */ { STRING_COMMA_LEN ("VLE") },
5641 if (do_section_details
)
5643 sprintf (buff
, "[%*.*lx]: ",
5644 field_size
, field_size
, (unsigned long) sh_flags
);
5645 p
+= field_size
+ 4;
5652 flag
= sh_flags
& - sh_flags
;
5655 if (do_section_details
)
5659 case SHF_WRITE
: sindex
= 0; break;
5660 case SHF_ALLOC
: sindex
= 1; break;
5661 case SHF_EXECINSTR
: sindex
= 2; break;
5662 case SHF_MERGE
: sindex
= 3; break;
5663 case SHF_STRINGS
: sindex
= 4; break;
5664 case SHF_INFO_LINK
: sindex
= 5; break;
5665 case SHF_LINK_ORDER
: sindex
= 6; break;
5666 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
5667 case SHF_GROUP
: sindex
= 8; break;
5668 case SHF_TLS
: sindex
= 9; break;
5669 case SHF_EXCLUDE
: sindex
= 18; break;
5670 case SHF_COMPRESSED
: sindex
= 20; break;
5671 case SHF_GNU_MBIND
: sindex
= 24; break;
5675 switch (filedata
->file_header
.e_machine
)
5678 if (flag
== SHF_IA_64_SHORT
)
5680 else if (flag
== SHF_IA_64_NORECOV
)
5683 else if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
5686 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
5687 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
5688 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
5689 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
5690 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
5691 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
5702 case EM_OLD_SPARCV9
:
5703 case EM_SPARC32PLUS
:
5706 if (flag
== SHF_ORDERED
)
5713 case SHF_ENTRYSECT
: sindex
= 21; break;
5714 case SHF_ARM_PURECODE
: sindex
= 22; break;
5715 case SHF_COMDEF
: sindex
= 23; break;
5720 if (flag
== SHF_PPC_VLE
)
5731 if (p
!= buff
+ field_size
+ 4)
5733 if (size
< (10 + 2))
5735 warn (_("Internal error: not enough buffer room for section flag info"));
5736 return _("<unknown>");
5743 size
-= flags
[sindex
].len
;
5744 p
= stpcpy (p
, flags
[sindex
].str
);
5746 else if (flag
& SHF_MASKOS
)
5748 else if (flag
& SHF_MASKPROC
)
5751 unknown_flags
|= flag
;
5757 case SHF_WRITE
: *p
= 'W'; break;
5758 case SHF_ALLOC
: *p
= 'A'; break;
5759 case SHF_EXECINSTR
: *p
= 'X'; break;
5760 case SHF_MERGE
: *p
= 'M'; break;
5761 case SHF_STRINGS
: *p
= 'S'; break;
5762 case SHF_INFO_LINK
: *p
= 'I'; break;
5763 case SHF_LINK_ORDER
: *p
= 'L'; break;
5764 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
5765 case SHF_GROUP
: *p
= 'G'; break;
5766 case SHF_TLS
: *p
= 'T'; break;
5767 case SHF_EXCLUDE
: *p
= 'E'; break;
5768 case SHF_COMPRESSED
: *p
= 'C'; break;
5769 case SHF_GNU_MBIND
: *p
= 'D'; break;
5772 if ((filedata
->file_header
.e_machine
== EM_X86_64
5773 || filedata
->file_header
.e_machine
== EM_L1OM
5774 || filedata
->file_header
.e_machine
== EM_K1OM
)
5775 && flag
== SHF_X86_64_LARGE
)
5777 else if (filedata
->file_header
.e_machine
== EM_ARM
5778 && flag
== SHF_ARM_PURECODE
)
5780 else if (filedata
->file_header
.e_machine
== EM_PPC
5781 && flag
== SHF_PPC_VLE
)
5783 else if (flag
& SHF_MASKOS
)
5786 sh_flags
&= ~ SHF_MASKOS
;
5788 else if (flag
& SHF_MASKPROC
)
5791 sh_flags
&= ~ SHF_MASKPROC
;
5801 if (do_section_details
)
5805 size
-= 5 + field_size
;
5806 if (p
!= buff
+ field_size
+ 4)
5810 warn (_("Internal error: not enough buffer room for section flag info"));
5811 return _("<unknown>");
5817 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
5818 (unsigned long) os_flags
);
5819 p
+= 5 + field_size
;
5823 size
-= 7 + field_size
;
5824 if (p
!= buff
+ field_size
+ 4)
5828 warn (_("Internal error: not enough buffer room for section flag info"));
5829 return _("<unknown>");
5835 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
5836 (unsigned long) proc_flags
);
5837 p
+= 7 + field_size
;
5841 size
-= 10 + field_size
;
5842 if (p
!= buff
+ field_size
+ 4)
5846 warn (_("Internal error: not enough buffer room for section flag info"));
5847 return _("<unknown>");
5853 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
5854 (unsigned long) unknown_flags
);
5855 p
+= 10 + field_size
;
5864 get_compression_header (Elf_Internal_Chdr
*chdr
, unsigned char *buf
, bfd_size_type size
)
5868 Elf32_External_Chdr
*echdr
= (Elf32_External_Chdr
*) buf
;
5870 if (size
< sizeof (* echdr
))
5872 error (_("Compressed section is too small even for a compression header\n"));
5876 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
5877 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
5878 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
5879 return sizeof (*echdr
);
5883 Elf64_External_Chdr
*echdr
= (Elf64_External_Chdr
*) buf
;
5885 if (size
< sizeof (* echdr
))
5887 error (_("Compressed section is too small even for a compression header\n"));
5891 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
5892 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
5893 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
5894 return sizeof (*echdr
);
5899 process_section_headers (Filedata
* filedata
)
5901 Elf_Internal_Shdr
* section
;
5904 filedata
->section_headers
= NULL
;
5906 if (filedata
->file_header
.e_shnum
== 0)
5908 /* PR binutils/12467. */
5909 if (filedata
->file_header
.e_shoff
!= 0)
5911 warn (_("possibly corrupt ELF file header - it has a non-zero"
5912 " section header offset, but no section headers\n"));
5915 else if (do_sections
)
5916 printf (_("\nThere are no sections in this file.\n"));
5921 if (do_sections
&& !do_header
)
5922 printf (ngettext ("There is %d section header, "
5923 "starting at offset 0x%lx:\n",
5924 "There are %d section headers, "
5925 "starting at offset 0x%lx:\n",
5926 filedata
->file_header
.e_shnum
),
5927 filedata
->file_header
.e_shnum
,
5928 (unsigned long) filedata
->file_header
.e_shoff
);
5932 if (! get_32bit_section_headers (filedata
, FALSE
))
5937 if (! get_64bit_section_headers (filedata
, FALSE
))
5941 /* Read in the string table, so that we have names to display. */
5942 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
5943 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
5945 section
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
5947 if (section
->sh_size
!= 0)
5949 filedata
->string_table
= (char *) get_data (NULL
, filedata
, section
->sh_offset
,
5950 1, section
->sh_size
,
5953 filedata
->string_table_length
= filedata
->string_table
!= NULL
? section
->sh_size
: 0;
5957 /* Scan the sections for the dynamic symbol table
5958 and dynamic string table and debug sections. */
5959 dynamic_symbols
= NULL
;
5960 dynamic_strings
= NULL
;
5961 dynamic_syminfo
= NULL
;
5962 symtab_shndx_list
= NULL
;
5964 eh_addr_size
= is_32bit_elf
? 4 : 8;
5965 switch (filedata
->file_header
.e_machine
)
5968 case EM_MIPS_RS3_LE
:
5969 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5970 FDE addresses. However, the ABI also has a semi-official ILP32
5971 variant for which the normal FDE address size rules apply.
5973 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5974 section, where XX is the size of longs in bits. Unfortunately,
5975 earlier compilers provided no way of distinguishing ILP32 objects
5976 from LP64 objects, so if there's any doubt, we should assume that
5977 the official LP64 form is being used. */
5978 if ((filedata
->file_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
5979 && find_section (filedata
, ".gcc_compiled_long32") == NULL
)
5985 switch (filedata
->file_header
.e_flags
& EF_H8_MACH
)
5987 case E_H8_MACH_H8300
:
5988 case E_H8_MACH_H8300HN
:
5989 case E_H8_MACH_H8300SN
:
5990 case E_H8_MACH_H8300SXN
:
5993 case E_H8_MACH_H8300H
:
5994 case E_H8_MACH_H8300S
:
5995 case E_H8_MACH_H8300SX
:
6003 switch (filedata
->file_header
.e_flags
& EF_M32C_CPU_MASK
)
6005 case EF_M32C_CPU_M16C
:
6012 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
6015 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
6016 if (section->sh_entsize != expected_entsize) \
6019 sprintf_vma (buf, section->sh_entsize); \
6020 /* Note: coded this way so that there is a single string for \
6022 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
6023 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
6024 (unsigned) expected_entsize); \
6025 section->sh_entsize = expected_entsize; \
6030 #define CHECK_ENTSIZE(section, i, type) \
6031 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
6032 sizeof (Elf64_External_##type))
6034 for (i
= 0, section
= filedata
->section_headers
;
6035 i
< filedata
->file_header
.e_shnum
;
6038 char * name
= SECTION_NAME (section
);
6040 if (section
->sh_type
== SHT_DYNSYM
)
6042 if (dynamic_symbols
!= NULL
)
6044 error (_("File contains multiple dynamic symbol tables\n"));
6048 CHECK_ENTSIZE (section
, i
, Sym
);
6049 dynamic_symbols
= GET_ELF_SYMBOLS (filedata
, section
, & num_dynamic_syms
);
6051 else if (section
->sh_type
== SHT_STRTAB
6052 && streq (name
, ".dynstr"))
6054 if (dynamic_strings
!= NULL
)
6056 error (_("File contains multiple dynamic string tables\n"));
6060 dynamic_strings
= (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6061 1, section
->sh_size
,
6062 _("dynamic strings"));
6063 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : section
->sh_size
;
6065 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
6067 elf_section_list
* entry
= xmalloc (sizeof * entry
);
6069 entry
->hdr
= section
;
6070 entry
->next
= symtab_shndx_list
;
6071 symtab_shndx_list
= entry
;
6073 else if (section
->sh_type
== SHT_SYMTAB
)
6074 CHECK_ENTSIZE (section
, i
, Sym
);
6075 else if (section
->sh_type
== SHT_GROUP
)
6076 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
6077 else if (section
->sh_type
== SHT_REL
)
6078 CHECK_ENTSIZE (section
, i
, Rel
);
6079 else if (section
->sh_type
== SHT_RELA
)
6080 CHECK_ENTSIZE (section
, i
, Rela
);
6081 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
6082 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
6083 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
6084 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
6085 || do_debug_addr
|| do_debug_cu_index
|| do_debug_links
)
6086 && (const_strneq (name
, ".debug_")
6087 || const_strneq (name
, ".zdebug_")))
6090 name
+= sizeof (".zdebug_") - 1;
6092 name
+= sizeof (".debug_") - 1;
6095 || (do_debug_info
&& const_strneq (name
, "info"))
6096 || (do_debug_info
&& const_strneq (name
, "types"))
6097 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
6098 || (do_debug_lines
&& strcmp (name
, "line") == 0)
6099 || (do_debug_lines
&& const_strneq (name
, "line."))
6100 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
6101 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
6102 || (do_debug_pubnames
&& const_strneq (name
, "gnu_pubnames"))
6103 || (do_debug_pubtypes
&& const_strneq (name
, "gnu_pubtypes"))
6104 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
6105 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
6106 || (do_debug_ranges
&& const_strneq (name
, "rnglists"))
6107 || (do_debug_frames
&& const_strneq (name
, "frame"))
6108 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
6109 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
6110 || (do_debug_str
&& const_strneq (name
, "str"))
6111 || (do_debug_loc
&& const_strneq (name
, "loc"))
6112 || (do_debug_loc
&& const_strneq (name
, "loclists"))
6113 || (do_debug_addr
&& const_strneq (name
, "addr"))
6114 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
6115 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
6117 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6119 /* Linkonce section to be combined with .debug_info at link time. */
6120 else if ((do_debugging
|| do_debug_info
)
6121 && const_strneq (name
, ".gnu.linkonce.wi."))
6122 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6123 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
6124 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6125 else if (do_gdb_index
&& (streq (name
, ".gdb_index")
6126 || streq (name
, ".debug_names")))
6127 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6128 /* Trace sections for Itanium VMS. */
6129 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
6130 || do_trace_aranges
)
6131 && const_strneq (name
, ".trace_"))
6133 name
+= sizeof (".trace_") - 1;
6136 || (do_trace_info
&& streq (name
, "info"))
6137 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
6138 || (do_trace_aranges
&& streq (name
, "aranges"))
6140 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6142 else if ((do_debugging
|| do_debug_links
)
6143 && (const_strneq (name
, ".gnu_debuglink")
6144 || const_strneq (name
, ".gnu_debugaltlink")))
6145 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6151 if (filedata
->file_header
.e_shnum
> 1)
6152 printf (_("\nSection Headers:\n"));
6154 printf (_("\nSection Header:\n"));
6158 if (do_section_details
)
6160 printf (_(" [Nr] Name\n"));
6161 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
6165 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
6169 if (do_section_details
)
6171 printf (_(" [Nr] Name\n"));
6172 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
6176 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
6180 if (do_section_details
)
6182 printf (_(" [Nr] Name\n"));
6183 printf (_(" Type Address Offset Link\n"));
6184 printf (_(" Size EntSize Info Align\n"));
6188 printf (_(" [Nr] Name Type Address Offset\n"));
6189 printf (_(" Size EntSize Flags Link Info Align\n"));
6193 if (do_section_details
)
6194 printf (_(" Flags\n"));
6196 for (i
= 0, section
= filedata
->section_headers
;
6197 i
< filedata
->file_header
.e_shnum
;
6200 /* Run some sanity checks on the section header. */
6202 /* Check the sh_link field. */
6203 switch (section
->sh_type
)
6205 case SHT_SYMTAB_SHNDX
:
6209 case SHT_GNU_versym
:
6212 if (section
->sh_link
< 1
6213 || section
->sh_link
>= filedata
->file_header
.e_shnum
6214 || (filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_SYMTAB
6215 && filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_DYNSYM
))
6216 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6217 i
, section
->sh_link
);
6223 case SHT_GNU_verneed
:
6224 case SHT_GNU_verdef
:
6225 case SHT_GNU_LIBLIST
:
6226 if (section
->sh_link
< 1
6227 || section
->sh_link
>= filedata
->file_header
.e_shnum
6228 || filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_STRTAB
)
6229 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6230 i
, section
->sh_link
);
6233 case SHT_INIT_ARRAY
:
6234 case SHT_FINI_ARRAY
:
6235 case SHT_PREINIT_ARRAY
:
6236 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6237 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6238 i
, section
->sh_link
);
6242 /* FIXME: Add support for target specific section types. */
6243 #if 0 /* Currently we do not check other section types as there are too
6244 many special cases. Stab sections for example have a type
6245 of SHT_PROGBITS but an sh_link field that links to the .stabstr
6247 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6248 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6249 i
, section
->sh_link
);
6254 /* Check the sh_info field. */
6255 switch (section
->sh_type
)
6259 if (section
->sh_info
< 1
6260 || section
->sh_info
>= filedata
->file_header
.e_shnum
6261 || (filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PROGBITS
6262 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOBITS
6263 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOTE
6264 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_INIT_ARRAY
6265 /* FIXME: Are other section types valid ? */
6266 && filedata
->section_headers
[section
->sh_info
].sh_type
< SHT_LOOS
))
6268 if (section
->sh_info
== 0
6269 && (filedata
->file_header
.e_type
== ET_EXEC
6270 || filedata
->file_header
.e_type
== ET_DYN
6271 /* These next two tests may be redundant, but
6272 they have been left in for paranoia's sake. */
6273 || streq (SECTION_NAME (section
), ".rel.dyn")
6274 || streq (SECTION_NAME (section
), ".rela.dyn")))
6275 /* Dynamic relocations apply to segments, not sections, so
6276 they do not need an sh_info value. */
6279 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6280 i
, section
->sh_info
);
6286 case SHT_SYMTAB_SHNDX
:
6287 case SHT_INIT_ARRAY
:
6288 case SHT_FINI_ARRAY
:
6289 case SHT_PREINIT_ARRAY
:
6290 if (section
->sh_info
!= 0)
6291 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6292 i
, section
->sh_info
);
6298 /* A symbol index - we assume that it is valid. */
6302 /* FIXME: Add support for target specific section types. */
6303 if (section
->sh_type
== SHT_NOBITS
)
6304 /* NOBITS section headers with non-zero sh_info fields can be
6305 created when a binary is stripped of everything but its debug
6306 information. The stripped sections have their headers
6307 preserved but their types set to SHT_NOBITS. So do not check
6308 this type of section. */
6310 else if (section
->sh_flags
& SHF_INFO_LINK
)
6312 if (section
->sh_info
< 1 || section
->sh_info
>= filedata
->file_header
.e_shnum
)
6313 warn (_("[%2u]: Expected link to another section in info field"), i
);
6315 else if (section
->sh_type
< SHT_LOOS
6316 && (section
->sh_flags
& SHF_GNU_MBIND
) == 0
6317 && section
->sh_info
!= 0)
6318 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6319 i
, section
->sh_info
);
6323 /* Check the sh_size field. */
6324 if (section
->sh_size
> filedata
->file_size
6325 && section
->sh_type
!= SHT_NOBITS
6326 && section
->sh_type
!= SHT_NULL
6327 && section
->sh_type
< SHT_LOOS
)
6328 warn (_("Size of section %u is larger than the entire file!\n"), i
);
6330 printf (" [%2u] ", i
);
6331 if (do_section_details
)
6332 printf ("%s\n ", printable_section_name (filedata
, section
));
6334 print_symbol (-17, SECTION_NAME (section
));
6336 printf (do_wide
? " %-15s " : " %-15.15s ",
6337 get_section_type_name (filedata
, section
->sh_type
));
6341 const char * link_too_big
= NULL
;
6343 print_vma (section
->sh_addr
, LONG_HEX
);
6345 printf ( " %6.6lx %6.6lx %2.2lx",
6346 (unsigned long) section
->sh_offset
,
6347 (unsigned long) section
->sh_size
,
6348 (unsigned long) section
->sh_entsize
);
6350 if (do_section_details
)
6351 fputs (" ", stdout
);
6353 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6355 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
6358 /* The sh_link value is out of range. Normally this indicates
6359 an error but it can have special values in Solaris binaries. */
6360 switch (filedata
->file_header
.e_machine
)
6367 case EM_OLD_SPARCV9
:
6368 case EM_SPARC32PLUS
:
6371 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
6372 link_too_big
= "BEFORE";
6373 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
6374 link_too_big
= "AFTER";
6381 if (do_section_details
)
6383 if (link_too_big
!= NULL
&& * link_too_big
)
6384 printf ("<%s> ", link_too_big
);
6386 printf ("%2u ", section
->sh_link
);
6387 printf ("%3u %2lu\n", section
->sh_info
,
6388 (unsigned long) section
->sh_addralign
);
6391 printf ("%2u %3u %2lu\n",
6394 (unsigned long) section
->sh_addralign
);
6396 if (link_too_big
&& ! * link_too_big
)
6397 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6398 i
, section
->sh_link
);
6402 print_vma (section
->sh_addr
, LONG_HEX
);
6404 if ((long) section
->sh_offset
== section
->sh_offset
)
6405 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
6409 print_vma (section
->sh_offset
, LONG_HEX
);
6412 if ((unsigned long) section
->sh_size
== section
->sh_size
)
6413 printf (" %6.6lx", (unsigned long) section
->sh_size
);
6417 print_vma (section
->sh_size
, LONG_HEX
);
6420 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
6421 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
6425 print_vma (section
->sh_entsize
, LONG_HEX
);
6428 if (do_section_details
)
6429 fputs (" ", stdout
);
6431 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6433 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
6435 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
6436 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
6439 print_vma (section
->sh_addralign
, DEC
);
6443 else if (do_section_details
)
6445 printf (" %-15.15s ",
6446 get_section_type_name (filedata
, section
->sh_type
));
6447 print_vma (section
->sh_addr
, LONG_HEX
);
6448 if ((long) section
->sh_offset
== section
->sh_offset
)
6449 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
6453 print_vma (section
->sh_offset
, LONG_HEX
);
6455 printf (" %u\n ", section
->sh_link
);
6456 print_vma (section
->sh_size
, LONG_HEX
);
6458 print_vma (section
->sh_entsize
, LONG_HEX
);
6460 printf (" %-16u %lu\n",
6462 (unsigned long) section
->sh_addralign
);
6467 print_vma (section
->sh_addr
, LONG_HEX
);
6468 if ((long) section
->sh_offset
== section
->sh_offset
)
6469 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
6473 print_vma (section
->sh_offset
, LONG_HEX
);
6476 print_vma (section
->sh_size
, LONG_HEX
);
6478 print_vma (section
->sh_entsize
, LONG_HEX
);
6480 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6482 printf (" %2u %3u %lu\n",
6485 (unsigned long) section
->sh_addralign
);
6488 if (do_section_details
)
6490 printf (" %s\n", get_elf_section_flags (filedata
, section
->sh_flags
));
6491 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
6493 /* Minimum section size is 12 bytes for 32-bit compression
6494 header + 12 bytes for compressed data header. */
6495 unsigned char buf
[24];
6497 assert (sizeof (buf
) >= sizeof (Elf64_External_Chdr
));
6498 if (get_data (&buf
, filedata
, section
->sh_offset
, 1,
6499 sizeof (buf
), _("compression header")))
6501 Elf_Internal_Chdr chdr
;
6503 (void) get_compression_header (&chdr
, buf
, sizeof (buf
));
6505 if (chdr
.ch_type
== ELFCOMPRESS_ZLIB
)
6508 printf (_(" [<unknown>: 0x%x], "),
6510 print_vma (chdr
.ch_size
, LONG_HEX
);
6511 printf (", %lu\n", (unsigned long) chdr
.ch_addralign
);
6517 if (!do_section_details
)
6519 /* The ordering of the letters shown here matches the ordering of the
6520 corresponding SHF_xxx values, and hence the order in which these
6521 letters will be displayed to the user. */
6522 printf (_("Key to Flags:\n\
6523 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6524 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6525 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
6526 if (filedata
->file_header
.e_machine
== EM_X86_64
6527 || filedata
->file_header
.e_machine
== EM_L1OM
6528 || filedata
->file_header
.e_machine
== EM_K1OM
)
6529 printf (_("l (large), "));
6530 else if (filedata
->file_header
.e_machine
== EM_ARM
)
6531 printf (_("y (purecode), "));
6532 else if (filedata
->file_header
.e_machine
== EM_PPC
)
6533 printf (_("v (VLE), "));
6534 printf ("p (processor specific)\n");
6541 get_group_flags (unsigned int flags
)
6543 static char buff
[128];
6547 else if (flags
== GRP_COMDAT
)
6550 snprintf (buff
, 14, _("[0x%x: "), flags
);
6552 flags
&= ~ GRP_COMDAT
;
6553 if (flags
& GRP_MASKOS
)
6555 strcat (buff
, "<OS specific>");
6556 flags
&= ~ GRP_MASKOS
;
6559 if (flags
& GRP_MASKPROC
)
6561 strcat (buff
, "<PROC specific>");
6562 flags
&= ~ GRP_MASKPROC
;
6566 strcat (buff
, "<unknown>");
6573 process_section_groups (Filedata
* filedata
)
6575 Elf_Internal_Shdr
* section
;
6577 struct group
* group
;
6578 Elf_Internal_Shdr
* symtab_sec
;
6579 Elf_Internal_Shdr
* strtab_sec
;
6580 Elf_Internal_Sym
* symtab
;
6581 unsigned long num_syms
;
6585 /* Don't process section groups unless needed. */
6586 if (!do_unwind
&& !do_section_groups
)
6589 if (filedata
->file_header
.e_shnum
== 0)
6591 if (do_section_groups
)
6592 printf (_("\nThere are no sections to group in this file.\n"));
6597 if (filedata
->section_headers
== NULL
)
6599 error (_("Section headers are not available!\n"));
6600 /* PR 13622: This can happen with a corrupt ELF header. */
6604 section_headers_groups
= (struct group
**) calloc (filedata
->file_header
.e_shnum
,
6605 sizeof (struct group
*));
6607 if (section_headers_groups
== NULL
)
6609 error (_("Out of memory reading %u section group headers\n"),
6610 filedata
->file_header
.e_shnum
);
6614 /* Scan the sections for the group section. */
6616 for (i
= 0, section
= filedata
->section_headers
;
6617 i
< filedata
->file_header
.e_shnum
;
6619 if (section
->sh_type
== SHT_GROUP
)
6622 if (group_count
== 0)
6624 if (do_section_groups
)
6625 printf (_("\nThere are no section groups in this file.\n"));
6630 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
6632 if (section_groups
== NULL
)
6634 error (_("Out of memory reading %lu groups\n"),
6635 (unsigned long) group_count
);
6645 for (i
= 0, section
= filedata
->section_headers
, group
= section_groups
;
6646 i
< filedata
->file_header
.e_shnum
;
6649 if (section
->sh_type
== SHT_GROUP
)
6651 const char * name
= printable_section_name (filedata
, section
);
6652 const char * group_name
;
6653 unsigned char * start
;
6654 unsigned char * indices
;
6655 unsigned int entry
, j
, size
;
6656 Elf_Internal_Shdr
* sec
;
6657 Elf_Internal_Sym
* sym
;
6659 /* Get the symbol table. */
6660 if (section
->sh_link
>= filedata
->file_header
.e_shnum
6661 || ((sec
= filedata
->section_headers
+ section
->sh_link
)->sh_type
6664 error (_("Bad sh_link in group section `%s'\n"), name
);
6668 if (symtab_sec
!= sec
)
6673 symtab
= GET_ELF_SYMBOLS (filedata
, symtab_sec
, & num_syms
);
6678 error (_("Corrupt header in group section `%s'\n"), name
);
6682 if (section
->sh_info
>= num_syms
)
6684 error (_("Bad sh_info in group section `%s'\n"), name
);
6688 sym
= symtab
+ section
->sh_info
;
6690 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
6692 if (sym
->st_shndx
== 0
6693 || sym
->st_shndx
>= filedata
->file_header
.e_shnum
)
6695 error (_("Bad sh_info in group section `%s'\n"), name
);
6699 group_name
= SECTION_NAME (filedata
->section_headers
+ sym
->st_shndx
);
6708 /* Get the string table. */
6709 if (symtab_sec
->sh_link
>= filedata
->file_header
.e_shnum
)
6718 != (sec
= filedata
->section_headers
+ symtab_sec
->sh_link
))
6724 strtab
= (char *) get_data (NULL
, filedata
, strtab_sec
->sh_offset
,
6725 1, strtab_sec
->sh_size
,
6727 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
6729 group_name
= sym
->st_name
< strtab_size
6730 ? strtab
+ sym
->st_name
: _("<corrupt>");
6733 /* PR 17531: file: loop. */
6734 if (section
->sh_entsize
> section
->sh_size
)
6736 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6737 printable_section_name (filedata
, section
),
6738 (unsigned long) section
->sh_entsize
,
6739 (unsigned long) section
->sh_size
);
6743 start
= (unsigned char *) get_data (NULL
, filedata
, section
->sh_offset
,
6744 1, section
->sh_size
,
6750 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
6751 entry
= byte_get (indices
, 4);
6754 if (do_section_groups
)
6756 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6757 get_group_flags (entry
), i
, name
, group_name
, size
);
6759 printf (_(" [Index] Name\n"));
6762 group
->group_index
= i
;
6764 for (j
= 0; j
< size
; j
++)
6766 struct group_list
* g
;
6768 entry
= byte_get (indices
, 4);
6771 if (entry
>= filedata
->file_header
.e_shnum
)
6773 static unsigned num_group_errors
= 0;
6775 if (num_group_errors
++ < 10)
6777 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6778 entry
, i
, filedata
->file_header
.e_shnum
- 1);
6779 if (num_group_errors
== 10)
6780 warn (_("Further error messages about overlarge group section indicies suppressed\n"));
6785 if (section_headers_groups
[entry
] != NULL
)
6789 static unsigned num_errs
= 0;
6791 if (num_errs
++ < 10)
6793 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6795 section_headers_groups
[entry
]->group_index
);
6797 warn (_("Further error messages about already contained group sections suppressed\n"));
6803 /* Intel C/C++ compiler may put section 0 in a
6804 section group. We just warn it the first time
6805 and ignore it afterwards. */
6806 static bfd_boolean warned
= FALSE
;
6809 error (_("section 0 in group section [%5u]\n"),
6810 section_headers_groups
[entry
]->group_index
);
6816 section_headers_groups
[entry
] = group
;
6818 if (do_section_groups
)
6820 sec
= filedata
->section_headers
+ entry
;
6821 printf (" [%5u] %s\n", entry
, printable_section_name (filedata
, sec
));
6824 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
6825 g
->section_index
= entry
;
6826 g
->next
= group
->root
;
6844 /* Data used to display dynamic fixups. */
6846 struct ia64_vms_dynfixup
6848 bfd_vma needed_ident
; /* Library ident number. */
6849 bfd_vma needed
; /* Index in the dstrtab of the library name. */
6850 bfd_vma fixup_needed
; /* Index of the library. */
6851 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
6852 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
6855 /* Data used to display dynamic relocations. */
6857 struct ia64_vms_dynimgrela
6859 bfd_vma img_rela_cnt
; /* Number of relocations. */
6860 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
6863 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6867 dump_ia64_vms_dynamic_fixups (Filedata
* filedata
,
6868 struct ia64_vms_dynfixup
* fixup
,
6869 const char * strtab
,
6870 unsigned int strtab_sz
)
6872 Elf64_External_VMS_IMAGE_FIXUP
* imfs
;
6874 const char * lib_name
;
6876 imfs
= get_data (NULL
, filedata
, dynamic_addr
+ fixup
->fixup_rela_off
,
6877 1, fixup
->fixup_rela_cnt
* sizeof (*imfs
),
6878 _("dynamic section image fixups"));
6882 if (fixup
->needed
< strtab_sz
)
6883 lib_name
= strtab
+ fixup
->needed
;
6886 warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
6887 (unsigned long) fixup
->needed
);
6890 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6891 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
6893 (_("Seg Offset Type SymVec DataType\n"));
6895 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
6900 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
6901 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
6902 type
= BYTE_GET (imfs
[i
].type
);
6903 rtype
= elf_ia64_reloc_type (type
);
6905 printf (" 0x%08x ", type
);
6907 printf (" %-32s ", rtype
);
6908 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
6909 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
6916 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
6919 dump_ia64_vms_dynamic_relocs (Filedata
* filedata
, struct ia64_vms_dynimgrela
*imgrela
)
6921 Elf64_External_VMS_IMAGE_RELA
*imrs
;
6924 imrs
= get_data (NULL
, filedata
, dynamic_addr
+ imgrela
->img_rela_off
,
6925 1, imgrela
->img_rela_cnt
* sizeof (*imrs
),
6926 _("dynamic section image relocations"));
6930 printf (_("\nImage relocs\n"));
6932 (_("Seg Offset Type Addend Seg Sym Off\n"));
6934 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
6939 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
6940 printf ("%08" BFD_VMA_FMT
"x ",
6941 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
6942 type
= BYTE_GET (imrs
[i
].type
);
6943 rtype
= elf_ia64_reloc_type (type
);
6945 printf ("0x%08x ", type
);
6947 printf ("%-31s ", rtype
);
6948 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
6949 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
6950 printf ("%08" BFD_VMA_FMT
"x\n",
6951 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
6958 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
6961 process_ia64_vms_dynamic_relocs (Filedata
* filedata
)
6963 struct ia64_vms_dynfixup fixup
;
6964 struct ia64_vms_dynimgrela imgrela
;
6965 Elf_Internal_Dyn
*entry
;
6966 bfd_vma strtab_off
= 0;
6967 bfd_vma strtab_sz
= 0;
6968 char *strtab
= NULL
;
6969 bfd_boolean res
= TRUE
;
6971 memset (&fixup
, 0, sizeof (fixup
));
6972 memset (&imgrela
, 0, sizeof (imgrela
));
6974 /* Note: the order of the entries is specified by the OpenVMS specs. */
6975 for (entry
= dynamic_section
;
6976 entry
< dynamic_section
+ dynamic_nent
;
6979 switch (entry
->d_tag
)
6981 case DT_IA_64_VMS_STRTAB_OFFSET
:
6982 strtab_off
= entry
->d_un
.d_val
;
6985 strtab_sz
= entry
->d_un
.d_val
;
6987 strtab
= get_data (NULL
, filedata
, dynamic_addr
+ strtab_off
,
6988 1, strtab_sz
, _("dynamic string section"));
6991 case DT_IA_64_VMS_NEEDED_IDENT
:
6992 fixup
.needed_ident
= entry
->d_un
.d_val
;
6995 fixup
.needed
= entry
->d_un
.d_val
;
6997 case DT_IA_64_VMS_FIXUP_NEEDED
:
6998 fixup
.fixup_needed
= entry
->d_un
.d_val
;
7000 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
7001 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
7003 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
7004 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
7005 if (! dump_ia64_vms_dynamic_fixups (filedata
, &fixup
, strtab
, strtab_sz
))
7008 case DT_IA_64_VMS_IMG_RELA_CNT
:
7009 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
7011 case DT_IA_64_VMS_IMG_RELA_OFF
:
7012 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
7013 if (! dump_ia64_vms_dynamic_relocs (filedata
, &imgrela
))
7035 dynamic_relocations
[] =
7037 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
7038 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
7039 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
7042 /* Process the reloc section. */
7045 process_relocs (Filedata
* filedata
)
7047 unsigned long rel_size
;
7048 unsigned long rel_offset
;
7053 if (do_using_dynamic
)
7057 bfd_boolean has_dynamic_reloc
;
7060 has_dynamic_reloc
= FALSE
;
7062 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7064 is_rela
= dynamic_relocations
[i
].rela
;
7065 name
= dynamic_relocations
[i
].name
;
7066 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
7067 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
7070 has_dynamic_reloc
= TRUE
;
7072 if (is_rela
== UNKNOWN
)
7074 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
7075 switch (dynamic_info
[DT_PLTREL
])
7089 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7090 name
, rel_offset
, rel_size
);
7092 dump_relocations (filedata
,
7093 offset_from_vma (filedata
, rel_offset
, rel_size
),
7095 dynamic_symbols
, num_dynamic_syms
,
7096 dynamic_strings
, dynamic_strings_length
,
7097 is_rela
, TRUE
/* is_dynamic */);
7101 if (is_ia64_vms (filedata
))
7102 if (process_ia64_vms_dynamic_relocs (filedata
))
7103 has_dynamic_reloc
= TRUE
;
7105 if (! has_dynamic_reloc
)
7106 printf (_("\nThere are no dynamic relocations in this file.\n"));
7110 Elf_Internal_Shdr
* section
;
7112 bfd_boolean found
= FALSE
;
7114 for (i
= 0, section
= filedata
->section_headers
;
7115 i
< filedata
->file_header
.e_shnum
;
7118 if ( section
->sh_type
!= SHT_RELA
7119 && section
->sh_type
!= SHT_REL
)
7122 rel_offset
= section
->sh_offset
;
7123 rel_size
= section
->sh_size
;
7127 Elf_Internal_Shdr
* strsec
;
7129 unsigned long num_rela
;
7131 printf (_("\nRelocation section "));
7133 if (filedata
->string_table
== NULL
)
7134 printf ("%d", section
->sh_name
);
7136 printf ("'%s'", printable_section_name (filedata
, section
));
7138 num_rela
= rel_size
/ section
->sh_entsize
;
7139 printf (ngettext (" at offset 0x%lx contains %lu entry:\n",
7140 " at offset 0x%lx contains %lu entries:\n",
7142 rel_offset
, num_rela
);
7144 is_rela
= section
->sh_type
== SHT_RELA
;
7146 if (section
->sh_link
!= 0
7147 && section
->sh_link
< filedata
->file_header
.e_shnum
)
7149 Elf_Internal_Shdr
* symsec
;
7150 Elf_Internal_Sym
* symtab
;
7151 unsigned long nsyms
;
7152 unsigned long strtablen
= 0;
7153 char * strtab
= NULL
;
7155 symsec
= filedata
->section_headers
+ section
->sh_link
;
7156 if (symsec
->sh_type
!= SHT_SYMTAB
7157 && symsec
->sh_type
!= SHT_DYNSYM
)
7160 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & nsyms
);
7165 if (symsec
->sh_link
!= 0
7166 && symsec
->sh_link
< filedata
->file_header
.e_shnum
)
7168 strsec
= filedata
->section_headers
+ symsec
->sh_link
;
7170 strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
7173 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
7176 dump_relocations (filedata
, rel_offset
, rel_size
,
7177 symtab
, nsyms
, strtab
, strtablen
,
7179 symsec
->sh_type
== SHT_DYNSYM
);
7185 dump_relocations (filedata
, rel_offset
, rel_size
,
7186 NULL
, 0, NULL
, 0, is_rela
,
7187 FALSE
/* is_dynamic */);
7195 /* Users sometimes forget the -D option, so try to be helpful. */
7196 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7198 if (dynamic_info
[dynamic_relocations
[i
].size
])
7200 printf (_("\nThere are no static relocations in this file."));
7201 printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
7206 if (i
== ARRAY_SIZE (dynamic_relocations
))
7207 printf (_("\nThere are no relocations in this file.\n"));
7214 /* An absolute address consists of a section and an offset. If the
7215 section is NULL, the offset itself is the address, otherwise, the
7216 address equals to LOAD_ADDRESS(section) + offset. */
7220 unsigned short section
;
7224 #define ABSADDR(a) \
7226 ? filedata->section_headers [(a).section].sh_addr + (a).offset \
7229 /* Find the nearest symbol at or below ADDR. Returns the symbol
7230 name, if found, and the offset from the symbol to ADDR. */
7233 find_symbol_for_address (Filedata
* filedata
,
7234 Elf_Internal_Sym
* symtab
,
7235 unsigned long nsyms
,
7236 const char * strtab
,
7237 unsigned long strtab_size
,
7238 struct absaddr addr
,
7239 const char ** symname
,
7242 bfd_vma dist
= 0x100000;
7243 Elf_Internal_Sym
* sym
;
7244 Elf_Internal_Sym
* beg
;
7245 Elf_Internal_Sym
* end
;
7246 Elf_Internal_Sym
* best
= NULL
;
7248 REMOVE_ARCH_BITS (addr
.offset
);
7250 end
= symtab
+ nsyms
;
7256 sym
= beg
+ (end
- beg
) / 2;
7258 value
= sym
->st_value
;
7259 REMOVE_ARCH_BITS (value
);
7261 if (sym
->st_name
!= 0
7262 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
7263 && addr
.offset
>= value
7264 && addr
.offset
- value
< dist
)
7267 dist
= addr
.offset
- value
;
7272 if (addr
.offset
< value
)
7280 *symname
= (best
->st_name
>= strtab_size
7281 ? _("<corrupt>") : strtab
+ best
->st_name
);
7287 *offset
= addr
.offset
;
7290 static /* signed */ int
7291 symcmp (const void *p
, const void *q
)
7293 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
7294 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
7296 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
7299 /* Process the unwind section. */
7301 #include "unwind-ia64.h"
7303 struct ia64_unw_table_entry
7305 struct absaddr start
;
7307 struct absaddr info
;
7310 struct ia64_unw_aux_info
7312 struct ia64_unw_table_entry
* table
; /* Unwind table. */
7313 unsigned long table_len
; /* Length of unwind table. */
7314 unsigned char * info
; /* Unwind info. */
7315 unsigned long info_size
; /* Size of unwind info. */
7316 bfd_vma info_addr
; /* Starting address of unwind info. */
7317 bfd_vma seg_base
; /* Starting address of segment. */
7318 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7319 unsigned long nsyms
; /* Number of symbols. */
7320 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7321 unsigned long nfuns
; /* Number of entries in funtab. */
7322 char * strtab
; /* The string table. */
7323 unsigned long strtab_size
; /* Size of string table. */
7327 dump_ia64_unwind (Filedata
* filedata
, struct ia64_unw_aux_info
* aux
)
7329 struct ia64_unw_table_entry
* tp
;
7330 unsigned long j
, nfuns
;
7332 bfd_boolean res
= TRUE
;
7334 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7335 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7336 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7337 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7339 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7341 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7345 const unsigned char * dp
;
7346 const unsigned char * head
;
7347 const unsigned char * end
;
7348 const char * procname
;
7350 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7351 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
7353 fputs ("\n<", stdout
);
7357 fputs (procname
, stdout
);
7360 printf ("+%lx", (unsigned long) offset
);
7363 fputs (">: [", stdout
);
7364 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7365 fputc ('-', stdout
);
7366 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7367 printf ("], info at +0x%lx\n",
7368 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
7370 /* PR 17531: file: 86232b32. */
7371 if (aux
->info
== NULL
)
7374 /* PR 17531: file: 0997b4d1. */
7375 if ((ABSADDR (tp
->info
) - aux
->info_addr
) >= aux
->info_size
)
7377 warn (_("Invalid offset %lx in table entry %ld\n"),
7378 (long) tp
->info
.offset
, (long) (tp
- aux
->table
));
7383 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
7384 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
7386 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7387 (unsigned) UNW_VER (stamp
),
7388 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
7389 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
7390 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
7391 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
7393 if (UNW_VER (stamp
) != 1)
7395 printf (_("\tUnknown version.\n"));
7400 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
7401 /* PR 17531: file: 16ceda89. */
7402 if (end
> aux
->info
+ aux
->info_size
)
7403 end
= aux
->info
+ aux
->info_size
;
7404 for (dp
= head
+ 8; dp
< end
;)
7405 dp
= unw_decode (dp
, in_body
, & in_body
, end
);
7414 slurp_ia64_unwind_table (Filedata
* filedata
,
7415 struct ia64_unw_aux_info
* aux
,
7416 Elf_Internal_Shdr
* sec
)
7418 unsigned long size
, nrelas
, i
;
7419 Elf_Internal_Phdr
* seg
;
7420 struct ia64_unw_table_entry
* tep
;
7421 Elf_Internal_Shdr
* relsec
;
7422 Elf_Internal_Rela
* rela
;
7423 Elf_Internal_Rela
* rp
;
7424 unsigned char * table
;
7426 Elf_Internal_Sym
* sym
;
7427 const char * relname
;
7431 /* First, find the starting address of the segment that includes
7434 if (filedata
->file_header
.e_phnum
)
7436 if (! get_program_headers (filedata
))
7439 for (seg
= filedata
->program_headers
;
7440 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
7443 if (seg
->p_type
!= PT_LOAD
)
7446 if (sec
->sh_addr
>= seg
->p_vaddr
7447 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7449 aux
->seg_base
= seg
->p_vaddr
;
7455 /* Second, build the unwind table from the contents of the unwind section: */
7456 size
= sec
->sh_size
;
7457 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
7462 aux
->table_len
= size
/ (3 * eh_addr_size
);
7463 aux
->table
= (struct ia64_unw_table_entry
*)
7464 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
7467 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
7469 tep
->start
.section
= SHN_UNDEF
;
7470 tep
->end
.section
= SHN_UNDEF
;
7471 tep
->info
.section
= SHN_UNDEF
;
7472 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7473 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7474 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7475 tep
->start
.offset
+= aux
->seg_base
;
7476 tep
->end
.offset
+= aux
->seg_base
;
7477 tep
->info
.offset
+= aux
->seg_base
;
7481 /* Third, apply any relocations to the unwind table: */
7482 for (relsec
= filedata
->section_headers
;
7483 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
7486 if (relsec
->sh_type
!= SHT_RELA
7487 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
7488 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
7491 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
7500 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7502 relname
= elf_ia64_reloc_type (get_reloc_type (filedata
, rp
->r_info
));
7503 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
7505 /* PR 17531: file: 9fa67536. */
7506 if (relname
== NULL
)
7508 warn (_("Skipping unknown relocation type: %u\n"),
7509 get_reloc_type (filedata
, rp
->r_info
));
7513 if (! const_strneq (relname
, "R_IA64_SEGREL"))
7515 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
7519 i
= rp
->r_offset
/ (3 * eh_addr_size
);
7521 /* PR 17531: file: 5bc8d9bf. */
7522 if (i
>= aux
->table_len
)
7524 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
7528 switch (rp
->r_offset
/ eh_addr_size
% 3)
7531 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7532 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
7535 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7536 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
7539 aux
->table
[i
].info
.section
= sym
->st_shndx
;
7540 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
7554 ia64_process_unwind (Filedata
* filedata
)
7556 Elf_Internal_Shdr
* sec
;
7557 Elf_Internal_Shdr
* unwsec
= NULL
;
7558 Elf_Internal_Shdr
* strsec
;
7559 unsigned long i
, unwcount
= 0, unwstart
= 0;
7560 struct ia64_unw_aux_info aux
;
7561 bfd_boolean res
= TRUE
;
7563 memset (& aux
, 0, sizeof (aux
));
7565 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
7567 if (sec
->sh_type
== SHT_SYMTAB
7568 && sec
->sh_link
< filedata
->file_header
.e_shnum
)
7570 aux
.symtab
= GET_ELF_SYMBOLS (filedata
, sec
, & aux
.nsyms
);
7572 strsec
= filedata
->section_headers
+ sec
->sh_link
;
7573 if (aux
.strtab
!= NULL
)
7575 error (_("Multiple auxillary string tables encountered\n"));
7579 aux
.strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
7582 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7584 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7589 printf (_("\nThere are no unwind sections in this file.\n"));
7591 while (unwcount
-- > 0)
7596 for (i
= unwstart
, sec
= filedata
->section_headers
+ unwstart
, unwsec
= NULL
;
7597 i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
7598 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7603 /* We have already counted the number of SHT_IA64_UNWIND
7604 sections so the loop above should never fail. */
7605 assert (unwsec
!= NULL
);
7608 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
7610 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
7612 /* We need to find which section group it is in. */
7613 struct group_list
* g
;
7615 if (section_headers_groups
== NULL
7616 || section_headers_groups
[i
] == NULL
)
7617 i
= filedata
->file_header
.e_shnum
;
7620 g
= section_headers_groups
[i
]->root
;
7622 for (; g
!= NULL
; g
= g
->next
)
7624 sec
= filedata
->section_headers
+ g
->section_index
;
7626 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
7631 i
= filedata
->file_header
.e_shnum
;
7634 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
7636 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
7637 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
7638 suffix
= SECTION_NAME (unwsec
) + len
;
7639 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
;
7641 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
7642 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7647 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7648 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
7649 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
7650 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
7652 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
7653 suffix
= SECTION_NAME (unwsec
) + len
;
7654 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
;
7656 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
7657 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7661 if (i
== filedata
->file_header
.e_shnum
)
7663 printf (_("\nCould not find unwind info section for "));
7665 if (filedata
->string_table
== NULL
)
7666 printf ("%d", unwsec
->sh_name
);
7668 printf ("'%s'", printable_section_name (filedata
, unwsec
));
7672 aux
.info_addr
= sec
->sh_addr
;
7673 aux
.info
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1,
7676 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
7678 printf (_("\nUnwind section "));
7680 if (filedata
->string_table
== NULL
)
7681 printf ("%d", unwsec
->sh_name
);
7683 printf ("'%s'", printable_section_name (filedata
, unwsec
));
7685 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7686 (unsigned long) unwsec
->sh_offset
,
7687 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
7689 if (slurp_ia64_unwind_table (filedata
, & aux
, unwsec
)
7690 && aux
.table_len
> 0)
7691 dump_ia64_unwind (filedata
, & aux
);
7694 free ((char *) aux
.table
);
7696 free ((char *) aux
.info
);
7705 free ((char *) aux
.strtab
);
7710 struct hppa_unw_table_entry
7712 struct absaddr start
;
7714 unsigned int Cannot_unwind
:1; /* 0 */
7715 unsigned int Millicode
:1; /* 1 */
7716 unsigned int Millicode_save_sr0
:1; /* 2 */
7717 unsigned int Region_description
:2; /* 3..4 */
7718 unsigned int reserved1
:1; /* 5 */
7719 unsigned int Entry_SR
:1; /* 6 */
7720 unsigned int Entry_FR
:4; /* Number saved 7..10 */
7721 unsigned int Entry_GR
:5; /* Number saved 11..15 */
7722 unsigned int Args_stored
:1; /* 16 */
7723 unsigned int Variable_Frame
:1; /* 17 */
7724 unsigned int Separate_Package_Body
:1; /* 18 */
7725 unsigned int Frame_Extension_Millicode
:1; /* 19 */
7726 unsigned int Stack_Overflow_Check
:1; /* 20 */
7727 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
7728 unsigned int Ada_Region
:1; /* 22 */
7729 unsigned int cxx_info
:1; /* 23 */
7730 unsigned int cxx_try_catch
:1; /* 24 */
7731 unsigned int sched_entry_seq
:1; /* 25 */
7732 unsigned int reserved2
:1; /* 26 */
7733 unsigned int Save_SP
:1; /* 27 */
7734 unsigned int Save_RP
:1; /* 28 */
7735 unsigned int Save_MRP_in_frame
:1; /* 29 */
7736 unsigned int extn_ptr_defined
:1; /* 30 */
7737 unsigned int Cleanup_defined
:1; /* 31 */
7739 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
7740 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
7741 unsigned int Large_frame
:1; /* 2 */
7742 unsigned int Pseudo_SP_Set
:1; /* 3 */
7743 unsigned int reserved4
:1; /* 4 */
7744 unsigned int Total_frame_size
:27; /* 5..31 */
7747 struct hppa_unw_aux_info
7749 struct hppa_unw_table_entry
* table
; /* Unwind table. */
7750 unsigned long table_len
; /* Length of unwind table. */
7751 bfd_vma seg_base
; /* Starting address of segment. */
7752 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7753 unsigned long nsyms
; /* Number of symbols. */
7754 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7755 unsigned long nfuns
; /* Number of entries in funtab. */
7756 char * strtab
; /* The string table. */
7757 unsigned long strtab_size
; /* Size of string table. */
7761 dump_hppa_unwind (Filedata
* filedata
, struct hppa_unw_aux_info
* aux
)
7763 struct hppa_unw_table_entry
* tp
;
7764 unsigned long j
, nfuns
;
7765 bfd_boolean res
= TRUE
;
7767 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7768 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7769 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7770 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7772 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7774 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7777 const char * procname
;
7779 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7780 aux
->strtab_size
, tp
->start
, &procname
,
7783 fputs ("\n<", stdout
);
7787 fputs (procname
, stdout
);
7790 printf ("+%lx", (unsigned long) offset
);
7793 fputs (">: [", stdout
);
7794 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7795 fputc ('-', stdout
);
7796 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7799 #define PF(_m) if (tp->_m) printf (#_m " ");
7800 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
7803 PF(Millicode_save_sr0
);
7804 /* PV(Region_description); */
7810 PF(Separate_Package_Body
);
7811 PF(Frame_Extension_Millicode
);
7812 PF(Stack_Overflow_Check
);
7813 PF(Two_Instruction_SP_Increment
);
7817 PF(sched_entry_seq
);
7820 PF(Save_MRP_in_frame
);
7821 PF(extn_ptr_defined
);
7822 PF(Cleanup_defined
);
7823 PF(MPE_XL_interrupt_marker
);
7824 PF(HP_UX_interrupt_marker
);
7827 PV(Total_frame_size
);
7840 slurp_hppa_unwind_table (Filedata
* filedata
,
7841 struct hppa_unw_aux_info
* aux
,
7842 Elf_Internal_Shdr
* sec
)
7844 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
7845 Elf_Internal_Phdr
* seg
;
7846 struct hppa_unw_table_entry
* tep
;
7847 Elf_Internal_Shdr
* relsec
;
7848 Elf_Internal_Rela
* rela
;
7849 Elf_Internal_Rela
* rp
;
7850 unsigned char * table
;
7852 Elf_Internal_Sym
* sym
;
7853 const char * relname
;
7855 /* First, find the starting address of the segment that includes
7857 if (filedata
->file_header
.e_phnum
)
7859 if (! get_program_headers (filedata
))
7862 for (seg
= filedata
->program_headers
;
7863 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
7866 if (seg
->p_type
!= PT_LOAD
)
7869 if (sec
->sh_addr
>= seg
->p_vaddr
7870 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7872 aux
->seg_base
= seg
->p_vaddr
;
7878 /* Second, build the unwind table from the contents of the unwind
7880 size
= sec
->sh_size
;
7881 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
7887 nentries
= size
/ unw_ent_size
;
7888 size
= unw_ent_size
* nentries
;
7890 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
7891 xcmalloc (nentries
, sizeof (aux
->table
[0]));
7893 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
7895 unsigned int tmp1
, tmp2
;
7897 tep
->start
.section
= SHN_UNDEF
;
7898 tep
->end
.section
= SHN_UNDEF
;
7900 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
7901 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
7902 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
7903 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
7905 tep
->start
.offset
+= aux
->seg_base
;
7906 tep
->end
.offset
+= aux
->seg_base
;
7908 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
7909 tep
->Millicode
= (tmp1
>> 30) & 0x1;
7910 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
7911 tep
->Region_description
= (tmp1
>> 27) & 0x3;
7912 tep
->reserved1
= (tmp1
>> 26) & 0x1;
7913 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
7914 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
7915 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
7916 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
7917 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
7918 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
7919 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
7920 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
7921 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
7922 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
7923 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
7924 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
7925 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
7926 tep
->reserved2
= (tmp1
>> 5) & 0x1;
7927 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
7928 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
7929 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
7930 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
7931 tep
->Cleanup_defined
= tmp1
& 0x1;
7933 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
7934 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
7935 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
7936 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
7937 tep
->reserved4
= (tmp2
>> 27) & 0x1;
7938 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
7942 /* Third, apply any relocations to the unwind table. */
7943 for (relsec
= filedata
->section_headers
;
7944 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
7947 if (relsec
->sh_type
!= SHT_RELA
7948 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
7949 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
7952 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
7956 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7958 relname
= elf_hppa_reloc_type (get_reloc_type (filedata
, rp
->r_info
));
7959 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
7961 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
7962 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
7964 warn (_("Skipping unexpected relocation type %s\n"), relname
);
7968 i
= rp
->r_offset
/ unw_ent_size
;
7970 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
7973 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7974 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
7977 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7978 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
7988 aux
->table_len
= nentries
;
7994 hppa_process_unwind (Filedata
* filedata
)
7996 struct hppa_unw_aux_info aux
;
7997 Elf_Internal_Shdr
* unwsec
= NULL
;
7998 Elf_Internal_Shdr
* strsec
;
7999 Elf_Internal_Shdr
* sec
;
8001 bfd_boolean res
= TRUE
;
8003 if (filedata
->string_table
== NULL
)
8006 memset (& aux
, 0, sizeof (aux
));
8008 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8010 if (sec
->sh_type
== SHT_SYMTAB
8011 && sec
->sh_link
< filedata
->file_header
.e_shnum
)
8013 aux
.symtab
= GET_ELF_SYMBOLS (filedata
, sec
, & aux
.nsyms
);
8015 strsec
= filedata
->section_headers
+ sec
->sh_link
;
8016 if (aux
.strtab
!= NULL
)
8018 error (_("Multiple auxillary string tables encountered\n"));
8022 aux
.strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
8025 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
8027 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8032 printf (_("\nThere are no unwind sections in this file.\n"));
8034 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8036 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8038 unsigned long num_unwind
= sec
->sh_size
/ (2 * eh_addr_size
+ 8);
8040 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
8041 "contains %lu entry:\n",
8042 "\nUnwind section '%s' at offset 0x%lx "
8043 "contains %lu entries:\n",
8045 printable_section_name (filedata
, sec
),
8046 (unsigned long) sec
->sh_offset
,
8049 if (! slurp_hppa_unwind_table (filedata
, &aux
, sec
))
8052 if (aux
.table_len
> 0)
8054 if (! dump_hppa_unwind (filedata
, &aux
))
8059 free ((char *) aux
.table
);
8067 free ((char *) aux
.strtab
);
8074 unsigned char * data
; /* The unwind data. */
8075 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
8076 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
8077 unsigned long nrelas
; /* The number of relocations. */
8078 unsigned int rel_type
; /* REL or RELA ? */
8079 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
8082 struct arm_unw_aux_info
8084 Filedata
* filedata
; /* The file containing the unwind sections. */
8085 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
8086 unsigned long nsyms
; /* Number of symbols. */
8087 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8088 unsigned long nfuns
; /* Number of these symbols. */
8089 char * strtab
; /* The file's string table. */
8090 unsigned long strtab_size
; /* Size of string table. */
8094 arm_print_vma_and_name (Filedata
* filedata
,
8095 struct arm_unw_aux_info
* aux
,
8097 struct absaddr addr
)
8099 const char *procname
;
8102 if (addr
.section
== SHN_UNDEF
)
8105 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8106 aux
->strtab_size
, addr
, &procname
,
8109 print_vma (fn
, PREFIX_HEX
);
8113 fputs (" <", stdout
);
8114 fputs (procname
, stdout
);
8117 printf ("+0x%lx", (unsigned long) sym_offset
);
8118 fputc ('>', stdout
);
8125 arm_free_section (struct arm_section
*arm_sec
)
8127 if (arm_sec
->data
!= NULL
)
8128 free (arm_sec
->data
);
8130 if (arm_sec
->rela
!= NULL
)
8131 free (arm_sec
->rela
);
8134 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8135 cached section and install SEC instead.
8136 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8137 and return its valued in * WORDP, relocating if necessary.
8138 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8139 relocation's offset in ADDR.
8140 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8141 into the string table of the symbol associated with the reloc. If no
8142 reloc was applied store -1 there.
8143 5) Return TRUE upon success, FALSE otherwise. */
8146 get_unwind_section_word (Filedata
* filedata
,
8147 struct arm_unw_aux_info
* aux
,
8148 struct arm_section
* arm_sec
,
8149 Elf_Internal_Shdr
* sec
,
8150 bfd_vma word_offset
,
8151 unsigned int * wordp
,
8152 struct absaddr
* addr
,
8155 Elf_Internal_Rela
*rp
;
8156 Elf_Internal_Sym
*sym
;
8157 const char * relname
;
8159 bfd_boolean wrapped
;
8161 if (sec
== NULL
|| arm_sec
== NULL
)
8164 addr
->section
= SHN_UNDEF
;
8167 if (sym_name
!= NULL
)
8168 *sym_name
= (bfd_vma
) -1;
8170 /* If necessary, update the section cache. */
8171 if (sec
!= arm_sec
->sec
)
8173 Elf_Internal_Shdr
*relsec
;
8175 arm_free_section (arm_sec
);
8178 arm_sec
->data
= get_data (NULL
, aux
->filedata
, sec
->sh_offset
, 1,
8179 sec
->sh_size
, _("unwind data"));
8180 arm_sec
->rela
= NULL
;
8181 arm_sec
->nrelas
= 0;
8183 for (relsec
= filedata
->section_headers
;
8184 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8187 if (relsec
->sh_info
>= filedata
->file_header
.e_shnum
8188 || filedata
->section_headers
+ relsec
->sh_info
!= sec
8189 /* PR 15745: Check the section type as well. */
8190 || (relsec
->sh_type
!= SHT_REL
8191 && relsec
->sh_type
!= SHT_RELA
))
8194 arm_sec
->rel_type
= relsec
->sh_type
;
8195 if (relsec
->sh_type
== SHT_REL
)
8197 if (!slurp_rel_relocs (aux
->filedata
, relsec
->sh_offset
,
8199 & arm_sec
->rela
, & arm_sec
->nrelas
))
8202 else /* relsec->sh_type == SHT_RELA */
8204 if (!slurp_rela_relocs (aux
->filedata
, relsec
->sh_offset
,
8206 & arm_sec
->rela
, & arm_sec
->nrelas
))
8212 arm_sec
->next_rela
= arm_sec
->rela
;
8215 /* If there is no unwind data we can do nothing. */
8216 if (arm_sec
->data
== NULL
)
8219 /* If the offset is invalid then fail. */
8220 if (/* PR 21343 *//* PR 18879 */
8222 || word_offset
> (sec
->sh_size
- 4)
8223 || ((bfd_signed_vma
) word_offset
) < 0)
8226 /* Get the word at the required offset. */
8227 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
8229 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
8230 if (arm_sec
->rela
== NULL
)
8236 /* Look through the relocs to find the one that applies to the provided offset. */
8238 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
8240 bfd_vma prelval
, offset
;
8242 if (rp
->r_offset
> word_offset
&& !wrapped
)
8247 if (rp
->r_offset
> word_offset
)
8250 if (rp
->r_offset
& 3)
8252 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8253 (unsigned long) rp
->r_offset
);
8257 if (rp
->r_offset
< word_offset
)
8260 /* PR 17531: file: 027-161405-0.004 */
8261 if (aux
->symtab
== NULL
)
8264 if (arm_sec
->rel_type
== SHT_REL
)
8266 offset
= word
& 0x7fffffff;
8267 if (offset
& 0x40000000)
8268 offset
|= ~ (bfd_vma
) 0x7fffffff;
8270 else if (arm_sec
->rel_type
== SHT_RELA
)
8271 offset
= rp
->r_addend
;
8274 error (_("Unknown section relocation type %d encountered\n"),
8279 /* PR 17531 file: 027-1241568-0.004. */
8280 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
8282 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8283 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
8287 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
8288 offset
+= sym
->st_value
;
8289 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
8291 /* Check that we are processing the expected reloc type. */
8292 if (filedata
->file_header
.e_machine
== EM_ARM
)
8294 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8295 if (relname
== NULL
)
8297 warn (_("Skipping unknown ARM relocation type: %d\n"),
8298 (int) ELF32_R_TYPE (rp
->r_info
));
8302 if (streq (relname
, "R_ARM_NONE"))
8305 if (! streq (relname
, "R_ARM_PREL31"))
8307 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
8311 else if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
8313 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8314 if (relname
== NULL
)
8316 warn (_("Skipping unknown C6000 relocation type: %d\n"),
8317 (int) ELF32_R_TYPE (rp
->r_info
));
8321 if (streq (relname
, "R_C6000_NONE"))
8324 if (! streq (relname
, "R_C6000_PREL31"))
8326 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
8334 /* This function currently only supports ARM and TI unwinders. */
8335 warn (_("Only TI and ARM unwinders are currently supported\n"));
8339 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
8340 addr
->section
= sym
->st_shndx
;
8341 addr
->offset
= offset
;
8344 * sym_name
= sym
->st_name
;
8349 arm_sec
->next_rela
= rp
;
8354 static const char *tic6x_unwind_regnames
[16] =
8356 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8357 "A14", "A13", "A12", "A11", "A10",
8358 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8362 decode_tic6x_unwind_regmask (unsigned int mask
)
8366 for (i
= 12; mask
; mask
>>= 1, i
--)
8370 fputs (tic6x_unwind_regnames
[i
], stdout
);
8372 fputs (", ", stdout
);
8378 if (remaining == 0 && more_words) \
8381 if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, \
8382 data_offset, & word, & addr, NULL)) \
8388 #define GET_OP(OP) \
8393 (OP) = word >> 24; \
8398 printf (_("[Truncated opcode]\n")); \
8401 printf ("0x%02x ", OP)
8404 decode_arm_unwind_bytecode (Filedata
* filedata
,
8405 struct arm_unw_aux_info
* aux
,
8407 unsigned int remaining
,
8408 unsigned int more_words
,
8409 bfd_vma data_offset
,
8410 Elf_Internal_Shdr
* data_sec
,
8411 struct arm_section
* data_arm_sec
)
8413 struct absaddr addr
;
8414 bfd_boolean res
= TRUE
;
8416 /* Decode the unwinding instructions. */
8419 unsigned int op
, op2
;
8428 printf (" 0x%02x ", op
);
8430 if ((op
& 0xc0) == 0x00)
8432 int offset
= ((op
& 0x3f) << 2) + 4;
8434 printf (" vsp = vsp + %d", offset
);
8436 else if ((op
& 0xc0) == 0x40)
8438 int offset
= ((op
& 0x3f) << 2) + 4;
8440 printf (" vsp = vsp - %d", offset
);
8442 else if ((op
& 0xf0) == 0x80)
8445 if (op
== 0x80 && op2
== 0)
8446 printf (_("Refuse to unwind"));
8449 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
8450 bfd_boolean first
= TRUE
;
8454 for (i
= 0; i
< 12; i
++)
8455 if (mask
& (1 << i
))
8461 printf ("r%d", 4 + i
);
8466 else if ((op
& 0xf0) == 0x90)
8468 if (op
== 0x9d || op
== 0x9f)
8469 printf (_(" [Reserved]"));
8471 printf (" vsp = r%d", op
& 0x0f);
8473 else if ((op
& 0xf0) == 0xa0)
8475 int end
= 4 + (op
& 0x07);
8476 bfd_boolean first
= TRUE
;
8480 for (i
= 4; i
<= end
; i
++)
8496 else if (op
== 0xb0)
8497 printf (_(" finish"));
8498 else if (op
== 0xb1)
8501 if (op2
== 0 || (op2
& 0xf0) != 0)
8502 printf (_("[Spare]"));
8505 unsigned int mask
= op2
& 0x0f;
8506 bfd_boolean first
= TRUE
;
8510 for (i
= 0; i
< 12; i
++)
8511 if (mask
& (1 << i
))
8522 else if (op
== 0xb2)
8524 unsigned char buf
[9];
8525 unsigned int i
, len
;
8526 unsigned long offset
;
8528 for (i
= 0; i
< sizeof (buf
); i
++)
8531 if ((buf
[i
] & 0x80) == 0)
8534 if (i
== sizeof (buf
))
8536 error (_("corrupt change to vsp"));
8541 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8542 assert (len
== i
+ 1);
8543 offset
= offset
* 4 + 0x204;
8544 printf ("vsp = vsp + %ld", offset
);
8547 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
8549 unsigned int first
, last
;
8556 printf ("pop {D%d", first
);
8558 printf ("-D%d", first
+ last
);
8561 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
8563 unsigned int count
= op
& 0x07;
8567 printf ("-D%d", 8 + count
);
8570 else if (op
>= 0xc0 && op
<= 0xc5)
8572 unsigned int count
= op
& 0x07;
8574 printf (" pop {wR10");
8576 printf ("-wR%d", 10 + count
);
8579 else if (op
== 0xc6)
8581 unsigned int first
, last
;
8586 printf ("pop {wR%d", first
);
8588 printf ("-wR%d", first
+ last
);
8591 else if (op
== 0xc7)
8594 if (op2
== 0 || (op2
& 0xf0) != 0)
8595 printf (_("[Spare]"));
8598 unsigned int mask
= op2
& 0x0f;
8599 bfd_boolean first
= TRUE
;
8603 for (i
= 0; i
< 4; i
++)
8604 if (mask
& (1 << i
))
8610 printf ("wCGR%d", i
);
8617 printf (_(" [unsupported opcode]"));
8628 decode_tic6x_unwind_bytecode (Filedata
* filedata
,
8629 struct arm_unw_aux_info
* aux
,
8631 unsigned int remaining
,
8632 unsigned int more_words
,
8633 bfd_vma data_offset
,
8634 Elf_Internal_Shdr
* data_sec
,
8635 struct arm_section
* data_arm_sec
)
8637 struct absaddr addr
;
8639 /* Decode the unwinding instructions. */
8642 unsigned int op
, op2
;
8651 printf (" 0x%02x ", op
);
8653 if ((op
& 0xc0) == 0x00)
8655 int offset
= ((op
& 0x3f) << 3) + 8;
8656 printf (" sp = sp + %d", offset
);
8658 else if ((op
& 0xc0) == 0x80)
8661 if (op
== 0x80 && op2
== 0)
8662 printf (_("Refuse to unwind"));
8665 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
8667 printf ("pop compact {");
8671 decode_tic6x_unwind_regmask (mask
);
8675 else if ((op
& 0xf0) == 0xc0)
8683 unsigned int offset
;
8687 /* Scan entire instruction first so that GET_OP output is not
8688 interleaved with disassembly. */
8690 for (i
= 0; nregs
< (op
& 0xf); i
++)
8696 regpos
[nregs
].offset
= i
* 2;
8697 regpos
[nregs
].reg
= reg
;
8704 regpos
[nregs
].offset
= i
* 2 + 1;
8705 regpos
[nregs
].reg
= reg
;
8710 printf (_("pop frame {"));
8712 for (i
= i
* 2; i
> 0; i
--)
8714 if (regpos
[reg
].offset
== i
- 1)
8716 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
8723 fputs (name
, stdout
);
8730 else if (op
== 0xd0)
8731 printf (" MOV FP, SP");
8732 else if (op
== 0xd1)
8733 printf (" __c6xabi_pop_rts");
8734 else if (op
== 0xd2)
8736 unsigned char buf
[9];
8737 unsigned int i
, len
;
8738 unsigned long offset
;
8740 for (i
= 0; i
< sizeof (buf
); i
++)
8743 if ((buf
[i
] & 0x80) == 0)
8746 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
8747 if (i
== sizeof (buf
))
8749 warn (_("Corrupt stack pointer adjustment detected\n"));
8753 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8754 assert (len
== i
+ 1);
8755 offset
= offset
* 8 + 0x408;
8756 printf (_("sp = sp + %ld"), offset
);
8758 else if ((op
& 0xf0) == 0xe0)
8760 if ((op
& 0x0f) == 7)
8763 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
8767 printf (_(" [unsupported opcode]"));
8776 arm_expand_prel31 (Filedata
* filedata
, bfd_vma word
, bfd_vma where
)
8780 offset
= word
& 0x7fffffff;
8781 if (offset
& 0x40000000)
8782 offset
|= ~ (bfd_vma
) 0x7fffffff;
8784 if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
8787 return offset
+ where
;
8791 decode_arm_unwind (Filedata
* filedata
,
8792 struct arm_unw_aux_info
* aux
,
8794 unsigned int remaining
,
8795 bfd_vma data_offset
,
8796 Elf_Internal_Shdr
* data_sec
,
8797 struct arm_section
* data_arm_sec
)
8800 unsigned int more_words
= 0;
8801 struct absaddr addr
;
8802 bfd_vma sym_name
= (bfd_vma
) -1;
8803 bfd_boolean res
= TRUE
;
8807 /* Fetch the first word.
8808 Note - when decoding an object file the address extracted
8809 here will always be 0. So we also pass in the sym_name
8810 parameter so that we can find the symbol associated with
8811 the personality routine. */
8812 if (! get_unwind_section_word (filedata
, aux
, data_arm_sec
, data_sec
, data_offset
,
8813 & word
, & addr
, & sym_name
))
8819 if ((word
& 0x80000000) == 0)
8821 /* Expand prel31 for personality routine. */
8823 const char *procname
;
8825 fn
= arm_expand_prel31 (filedata
, word
, data_sec
->sh_addr
+ data_offset
);
8826 printf (_(" Personality routine: "));
8828 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
8829 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
8831 procname
= aux
->strtab
+ sym_name
;
8832 print_vma (fn
, PREFIX_HEX
);
8835 fputs (" <", stdout
);
8836 fputs (procname
, stdout
);
8837 fputc ('>', stdout
);
8841 procname
= arm_print_vma_and_name (filedata
, aux
, fn
, addr
);
8842 fputc ('\n', stdout
);
8844 /* The GCC personality routines use the standard compact
8845 encoding, starting with one byte giving the number of
8847 if (procname
!= NULL
8848 && (const_strneq (procname
, "__gcc_personality_v0")
8849 || const_strneq (procname
, "__gxx_personality_v0")
8850 || const_strneq (procname
, "__gcj_personality_v0")
8851 || const_strneq (procname
, "__gnu_objc_personality_v0")))
8858 printf (_(" [Truncated data]\n"));
8861 more_words
= word
>> 24;
8871 /* ARM EHABI Section 6.3:
8873 An exception-handling table entry for the compact model looks like:
8877 1 0 index Data for personalityRoutine[index] */
8879 if (filedata
->file_header
.e_machine
== EM_ARM
8880 && (word
& 0x70000000))
8882 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
8886 per_index
= (word
>> 24) & 0x7f;
8887 printf (_(" Compact model index: %d\n"), per_index
);
8894 else if (per_index
< 3)
8896 more_words
= (word
>> 16) & 0xff;
8902 switch (filedata
->file_header
.e_machine
)
8907 if (! decode_arm_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
8908 data_offset
, data_sec
, data_arm_sec
))
8913 warn (_("Unknown ARM compact model index encountered\n"));
8914 printf (_(" [reserved]\n"));
8922 if (! decode_tic6x_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
8923 data_offset
, data_sec
, data_arm_sec
))
8926 else if (per_index
< 5)
8928 if (((word
>> 17) & 0x7f) == 0x7f)
8929 printf (_(" Restore stack from frame pointer\n"));
8931 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
8932 printf (_(" Registers restored: "));
8934 printf (" (compact) ");
8935 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
8937 printf (_(" Return register: %s\n"),
8938 tic6x_unwind_regnames
[word
& 0xf]);
8941 printf (_(" [reserved (%d)]\n"), per_index
);
8945 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
8946 filedata
->file_header
.e_machine
);
8950 /* Decode the descriptors. Not implemented. */
8956 dump_arm_unwind (Filedata
* filedata
,
8957 struct arm_unw_aux_info
* aux
,
8958 Elf_Internal_Shdr
* exidx_sec
)
8960 struct arm_section exidx_arm_sec
, extab_arm_sec
;
8961 unsigned int i
, exidx_len
;
8962 unsigned long j
, nfuns
;
8963 bfd_boolean res
= TRUE
;
8965 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
8966 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
8967 exidx_len
= exidx_sec
->sh_size
/ 8;
8969 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
8970 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
8971 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
8972 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
8974 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
8976 for (i
= 0; i
< exidx_len
; i
++)
8978 unsigned int exidx_fn
, exidx_entry
;
8979 struct absaddr fn_addr
, entry_addr
;
8982 fputc ('\n', stdout
);
8984 if (! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
8985 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
8986 || ! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
8987 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
8990 arm_free_section (& exidx_arm_sec
);
8991 arm_free_section (& extab_arm_sec
);
8995 /* ARM EHABI, Section 5:
8996 An index table entry consists of 2 words.
8997 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
8998 if (exidx_fn
& 0x80000000)
9000 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
9004 fn
= arm_expand_prel31 (filedata
, exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
9006 arm_print_vma_and_name (filedata
, aux
, fn
, fn_addr
);
9007 fputs (": ", stdout
);
9009 if (exidx_entry
== 1)
9011 print_vma (exidx_entry
, PREFIX_HEX
);
9012 fputs (" [cantunwind]\n", stdout
);
9014 else if (exidx_entry
& 0x80000000)
9016 print_vma (exidx_entry
, PREFIX_HEX
);
9017 fputc ('\n', stdout
);
9018 decode_arm_unwind (filedata
, aux
, exidx_entry
, 4, 0, NULL
, NULL
);
9022 bfd_vma table
, table_offset
= 0;
9023 Elf_Internal_Shdr
*table_sec
;
9025 fputs ("@", stdout
);
9026 table
= arm_expand_prel31 (filedata
, exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
9027 print_vma (table
, PREFIX_HEX
);
9030 /* Locate the matching .ARM.extab. */
9031 if (entry_addr
.section
!= SHN_UNDEF
9032 && entry_addr
.section
< filedata
->file_header
.e_shnum
)
9034 table_sec
= filedata
->section_headers
+ entry_addr
.section
;
9035 table_offset
= entry_addr
.offset
;
9037 if (table_offset
> table_sec
->sh_size
9038 || ((bfd_signed_vma
) table_offset
) < 0)
9040 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
9041 (unsigned long) table_offset
,
9042 printable_section_name (filedata
, table_sec
));
9049 table_sec
= find_section_by_address (filedata
, table
);
9050 if (table_sec
!= NULL
)
9051 table_offset
= table
- table_sec
->sh_addr
;
9054 if (table_sec
== NULL
)
9056 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
9057 (unsigned long) table
);
9062 if (! decode_arm_unwind (filedata
, aux
, 0, 0, table_offset
, table_sec
,
9071 arm_free_section (&exidx_arm_sec
);
9072 arm_free_section (&extab_arm_sec
);
9077 /* Used for both ARM and C6X unwinding tables. */
9080 arm_process_unwind (Filedata
* filedata
)
9082 struct arm_unw_aux_info aux
;
9083 Elf_Internal_Shdr
*unwsec
= NULL
;
9084 Elf_Internal_Shdr
*strsec
;
9085 Elf_Internal_Shdr
*sec
;
9087 unsigned int sec_type
;
9088 bfd_boolean res
= TRUE
;
9090 switch (filedata
->file_header
.e_machine
)
9093 sec_type
= SHT_ARM_EXIDX
;
9097 sec_type
= SHT_C6000_UNWIND
;
9101 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9102 filedata
->file_header
.e_machine
);
9106 if (filedata
->string_table
== NULL
)
9109 memset (& aux
, 0, sizeof (aux
));
9110 aux
.filedata
= filedata
;
9112 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9114 if (sec
->sh_type
== SHT_SYMTAB
&& sec
->sh_link
< filedata
->file_header
.e_shnum
)
9116 aux
.symtab
= GET_ELF_SYMBOLS (filedata
, sec
, & aux
.nsyms
);
9118 strsec
= filedata
->section_headers
+ sec
->sh_link
;
9120 /* PR binutils/17531 file: 011-12666-0.004. */
9121 if (aux
.strtab
!= NULL
)
9123 error (_("Multiple string tables found in file.\n"));
9127 aux
.strtab
= get_data (NULL
, filedata
, strsec
->sh_offset
,
9128 1, strsec
->sh_size
, _("string table"));
9129 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
9131 else if (sec
->sh_type
== sec_type
)
9136 printf (_("\nThere are no unwind sections in this file.\n"));
9138 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9140 if (sec
->sh_type
== sec_type
)
9142 unsigned long num_unwind
= sec
->sh_size
/ (2 * eh_addr_size
);
9143 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
9144 "contains %lu entry:\n",
9145 "\nUnwind section '%s' at offset 0x%lx "
9146 "contains %lu entries:\n",
9148 printable_section_name (filedata
, sec
),
9149 (unsigned long) sec
->sh_offset
,
9152 if (! dump_arm_unwind (filedata
, &aux
, sec
))
9160 free ((char *) aux
.strtab
);
9166 process_unwind (Filedata
* filedata
)
9168 struct unwind_handler
9170 unsigned int machtype
;
9171 bfd_boolean (* handler
)(Filedata
*);
9174 { EM_ARM
, arm_process_unwind
},
9175 { EM_IA_64
, ia64_process_unwind
},
9176 { EM_PARISC
, hppa_process_unwind
},
9177 { EM_TI_C6000
, arm_process_unwind
},
9185 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
9186 if (filedata
->file_header
.e_machine
== handlers
[i
].machtype
)
9187 return handlers
[i
].handler (filedata
);
9189 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9190 get_machine_name (filedata
->file_header
.e_machine
));
9195 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
9197 switch (entry
->d_tag
)
9200 if (entry
->d_un
.d_val
== 0)
9204 static const char * opts
[] =
9206 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9207 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9208 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9209 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9213 bfd_boolean first
= TRUE
;
9215 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
9216 if (entry
->d_un
.d_val
& (1 << cnt
))
9218 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
9224 case DT_MIPS_IVERSION
:
9225 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9226 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
9230 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
9231 /* Note: coded this way so that there is a single string for translation. */
9232 printf (_("<corrupt: %s>"), buf
);
9236 case DT_MIPS_TIME_STAMP
:
9240 time_t atime
= entry
->d_un
.d_val
;
9242 tmp
= gmtime (&atime
);
9243 /* PR 17531: file: 6accc532. */
9245 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
9247 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
9248 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9249 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9250 printf (_("Time Stamp: %s"), timebuf
);
9254 case DT_MIPS_RLD_VERSION
:
9255 case DT_MIPS_LOCAL_GOTNO
:
9256 case DT_MIPS_CONFLICTNO
:
9257 case DT_MIPS_LIBLISTNO
:
9258 case DT_MIPS_SYMTABNO
:
9259 case DT_MIPS_UNREFEXTNO
:
9260 case DT_MIPS_HIPAGENO
:
9261 case DT_MIPS_DELTA_CLASS_NO
:
9262 case DT_MIPS_DELTA_INSTANCE_NO
:
9263 case DT_MIPS_DELTA_RELOC_NO
:
9264 case DT_MIPS_DELTA_SYM_NO
:
9265 case DT_MIPS_DELTA_CLASSSYM_NO
:
9266 case DT_MIPS_COMPACT_SIZE
:
9267 print_vma (entry
->d_un
.d_val
, DEC
);
9271 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9277 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
9279 switch (entry
->d_tag
)
9281 case DT_HP_DLD_FLAGS
:
9290 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
9291 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
9292 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
9293 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
9294 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
9295 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
9296 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
9297 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
9298 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
9299 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
9300 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
9301 { DT_HP_GST
, "HP_GST" },
9302 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
9303 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
9304 { DT_HP_NODELETE
, "HP_NODELETE" },
9305 { DT_HP_GROUP
, "HP_GROUP" },
9306 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
9308 bfd_boolean first
= TRUE
;
9310 bfd_vma val
= entry
->d_un
.d_val
;
9312 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
9313 if (val
& flags
[cnt
].bit
)
9317 fputs (flags
[cnt
].str
, stdout
);
9319 val
^= flags
[cnt
].bit
;
9322 if (val
!= 0 || first
)
9326 print_vma (val
, HEX
);
9332 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9340 /* VMS vs Unix time offset and factor. */
9342 #define VMS_EPOCH_OFFSET 35067168000000000LL
9343 #define VMS_GRANULARITY_FACTOR 10000000
9345 /* Display a VMS time in a human readable format. */
9348 print_vms_time (bfd_int64_t vmstime
)
9353 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
9354 tm
= gmtime (&unxtime
);
9355 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9356 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
9357 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
9362 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
9364 switch (entry
->d_tag
)
9366 case DT_IA_64_PLT_RESERVE
:
9367 /* First 3 slots reserved. */
9368 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9370 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
9373 case DT_IA_64_VMS_LINKTIME
:
9375 print_vms_time (entry
->d_un
.d_val
);
9379 case DT_IA_64_VMS_LNKFLAGS
:
9380 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9381 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
9382 printf (" CALL_DEBUG");
9383 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
9384 printf (" NOP0BUFS");
9385 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
9386 printf (" P0IMAGE");
9387 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
9388 printf (" MKTHREADS");
9389 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
9390 printf (" UPCALLS");
9391 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
9393 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
9394 printf (" INITIALIZE");
9395 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
9397 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
9398 printf (" EXE_INIT");
9399 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
9400 printf (" TBK_IN_IMG");
9401 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
9402 printf (" DBG_IN_IMG");
9403 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
9404 printf (" TBK_IN_DSF");
9405 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
9406 printf (" DBG_IN_DSF");
9407 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
9408 printf (" SIGNATURES");
9409 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
9410 printf (" REL_SEG_OFF");
9414 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9421 get_32bit_dynamic_section (Filedata
* filedata
)
9423 Elf32_External_Dyn
* edyn
;
9424 Elf32_External_Dyn
* ext
;
9425 Elf_Internal_Dyn
* entry
;
9427 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, filedata
, dynamic_addr
, 1,
9428 dynamic_size
, _("dynamic section"));
9432 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9433 might not have the luxury of section headers. Look for the DT_NULL
9434 terminator to determine the number of entries. */
9435 for (ext
= edyn
, dynamic_nent
= 0;
9436 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9440 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9444 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9446 if (dynamic_section
== NULL
)
9448 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9449 (unsigned long) dynamic_nent
);
9454 for (ext
= edyn
, entry
= dynamic_section
;
9455 entry
< dynamic_section
+ dynamic_nent
;
9458 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9459 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9468 get_64bit_dynamic_section (Filedata
* filedata
)
9470 Elf64_External_Dyn
* edyn
;
9471 Elf64_External_Dyn
* ext
;
9472 Elf_Internal_Dyn
* entry
;
9474 /* Read in the data. */
9475 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, filedata
, dynamic_addr
, 1,
9476 dynamic_size
, _("dynamic section"));
9480 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9481 might not have the luxury of section headers. Look for the DT_NULL
9482 terminator to determine the number of entries. */
9483 for (ext
= edyn
, dynamic_nent
= 0;
9484 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
9485 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9489 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9493 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9495 if (dynamic_section
== NULL
)
9497 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9498 (unsigned long) dynamic_nent
);
9503 /* Convert from external to internal formats. */
9504 for (ext
= edyn
, entry
= dynamic_section
;
9505 entry
< dynamic_section
+ dynamic_nent
;
9508 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9509 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9518 print_dynamic_flags (bfd_vma flags
)
9520 bfd_boolean first
= TRUE
;
9526 flag
= flags
& - flags
;
9536 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
9537 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
9538 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
9539 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
9540 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
9541 default: fputs (_("unknown"), stdout
); break;
9547 /* Parse and display the contents of the dynamic section. */
9550 process_dynamic_section (Filedata
* filedata
)
9552 Elf_Internal_Dyn
* entry
;
9554 if (dynamic_size
== 0)
9557 printf (_("\nThere is no dynamic section in this file.\n"));
9564 if (! get_32bit_dynamic_section (filedata
))
9569 if (! get_64bit_dynamic_section (filedata
))
9573 /* Find the appropriate symbol table. */
9574 if (dynamic_symbols
== NULL
)
9576 for (entry
= dynamic_section
;
9577 entry
< dynamic_section
+ dynamic_nent
;
9580 Elf_Internal_Shdr section
;
9582 if (entry
->d_tag
!= DT_SYMTAB
)
9585 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
9587 /* Since we do not know how big the symbol table is,
9588 we default to reading in the entire file (!) and
9589 processing that. This is overkill, I know, but it
9591 section
.sh_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
9592 if ((bfd_size_type
) section
.sh_offset
> filedata
->file_size
)
9594 /* See PR 21379 for a reproducer. */
9595 error (_("Invalid DT_SYMTAB entry: %lx"), (long) section
.sh_offset
);
9599 if (archive_file_offset
!= 0)
9600 section
.sh_size
= archive_file_size
- section
.sh_offset
;
9602 section
.sh_size
= filedata
->file_size
- section
.sh_offset
;
9605 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
9607 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
9608 section
.sh_name
= filedata
->string_table_length
;
9610 dynamic_symbols
= GET_ELF_SYMBOLS (filedata
, §ion
, & num_dynamic_syms
);
9611 if (num_dynamic_syms
< 1)
9613 error (_("Unable to determine the number of symbols to load\n"));
9619 /* Similarly find a string table. */
9620 if (dynamic_strings
== NULL
)
9622 for (entry
= dynamic_section
;
9623 entry
< dynamic_section
+ dynamic_nent
;
9626 unsigned long offset
;
9629 if (entry
->d_tag
!= DT_STRTAB
)
9632 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
9634 /* Since we do not know how big the string table is,
9635 we default to reading in the entire file (!) and
9636 processing that. This is overkill, I know, but it
9639 offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
9641 if (archive_file_offset
!= 0)
9642 str_tab_len
= archive_file_size
- offset
;
9644 str_tab_len
= filedata
->file_size
- offset
;
9646 if (str_tab_len
< 1)
9649 (_("Unable to determine the length of the dynamic string table\n"));
9653 dynamic_strings
= (char *) get_data (NULL
, filedata
, offset
, 1,
9655 _("dynamic string table"));
9656 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : str_tab_len
;
9661 /* And find the syminfo section if available. */
9662 if (dynamic_syminfo
== NULL
)
9664 unsigned long syminsz
= 0;
9666 for (entry
= dynamic_section
;
9667 entry
< dynamic_section
+ dynamic_nent
;
9670 if (entry
->d_tag
== DT_SYMINENT
)
9672 /* Note: these braces are necessary to avoid a syntax
9673 error from the SunOS4 C compiler. */
9674 /* PR binutils/17531: A corrupt file can trigger this test.
9675 So do not use an assert, instead generate an error message. */
9676 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
9677 error (_("Bad value (%d) for SYMINENT entry\n"),
9678 (int) entry
->d_un
.d_val
);
9680 else if (entry
->d_tag
== DT_SYMINSZ
)
9681 syminsz
= entry
->d_un
.d_val
;
9682 else if (entry
->d_tag
== DT_SYMINFO
)
9683 dynamic_syminfo_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
,
9687 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
9689 Elf_External_Syminfo
* extsyminfo
;
9690 Elf_External_Syminfo
* extsym
;
9691 Elf_Internal_Syminfo
* syminfo
;
9693 /* There is a syminfo section. Read the data. */
9694 extsyminfo
= (Elf_External_Syminfo
*)
9695 get_data (NULL
, filedata
, dynamic_syminfo_offset
, 1, syminsz
,
9696 _("symbol information"));
9700 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
9701 if (dynamic_syminfo
== NULL
)
9703 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9704 (unsigned long) syminsz
);
9708 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
9709 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
9710 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
9711 ++syminfo
, ++extsym
)
9713 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
9714 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
9721 if (do_dynamic
&& dynamic_addr
)
9722 printf (ngettext ("\nDynamic section at offset 0x%lx "
9723 "contains %lu entry:\n",
9724 "\nDynamic section at offset 0x%lx "
9725 "contains %lu entries:\n",
9727 dynamic_addr
, (unsigned long) dynamic_nent
);
9729 printf (_(" Tag Type Name/Value\n"));
9731 for (entry
= dynamic_section
;
9732 entry
< dynamic_section
+ dynamic_nent
;
9740 print_vma (entry
->d_tag
, FULL_HEX
);
9741 dtype
= get_dynamic_type (filedata
, entry
->d_tag
);
9742 printf (" (%s)%*s", dtype
,
9743 ((is_32bit_elf
? 27 : 19) - (int) strlen (dtype
)), " ");
9746 switch (entry
->d_tag
)
9750 print_dynamic_flags (entry
->d_un
.d_val
);
9760 switch (entry
->d_tag
)
9763 printf (_("Auxiliary library"));
9767 printf (_("Filter library"));
9771 printf (_("Configuration file"));
9775 printf (_("Dependency audit library"));
9779 printf (_("Audit library"));
9783 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9784 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
9788 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9797 printf (_("Flags:"));
9799 if (entry
->d_un
.d_val
== 0)
9800 printf (_(" None\n"));
9803 unsigned long int val
= entry
->d_un
.d_val
;
9805 if (val
& DTF_1_PARINIT
)
9807 printf (" PARINIT");
9808 val
^= DTF_1_PARINIT
;
9810 if (val
& DTF_1_CONFEXP
)
9812 printf (" CONFEXP");
9813 val
^= DTF_1_CONFEXP
;
9816 printf (" %lx", val
);
9825 printf (_("Flags:"));
9827 if (entry
->d_un
.d_val
== 0)
9828 printf (_(" None\n"));
9831 unsigned long int val
= entry
->d_un
.d_val
;
9833 if (val
& DF_P1_LAZYLOAD
)
9835 printf (" LAZYLOAD");
9836 val
^= DF_P1_LAZYLOAD
;
9838 if (val
& DF_P1_GROUPPERM
)
9840 printf (" GROUPPERM");
9841 val
^= DF_P1_GROUPPERM
;
9844 printf (" %lx", val
);
9853 printf (_("Flags:"));
9854 if (entry
->d_un
.d_val
== 0)
9855 printf (_(" None\n"));
9858 unsigned long int val
= entry
->d_un
.d_val
;
9865 if (val
& DF_1_GLOBAL
)
9870 if (val
& DF_1_GROUP
)
9875 if (val
& DF_1_NODELETE
)
9877 printf (" NODELETE");
9878 val
^= DF_1_NODELETE
;
9880 if (val
& DF_1_LOADFLTR
)
9882 printf (" LOADFLTR");
9883 val
^= DF_1_LOADFLTR
;
9885 if (val
& DF_1_INITFIRST
)
9887 printf (" INITFIRST");
9888 val
^= DF_1_INITFIRST
;
9890 if (val
& DF_1_NOOPEN
)
9895 if (val
& DF_1_ORIGIN
)
9900 if (val
& DF_1_DIRECT
)
9905 if (val
& DF_1_TRANS
)
9910 if (val
& DF_1_INTERPOSE
)
9912 printf (" INTERPOSE");
9913 val
^= DF_1_INTERPOSE
;
9915 if (val
& DF_1_NODEFLIB
)
9917 printf (" NODEFLIB");
9918 val
^= DF_1_NODEFLIB
;
9920 if (val
& DF_1_NODUMP
)
9925 if (val
& DF_1_CONFALT
)
9927 printf (" CONFALT");
9928 val
^= DF_1_CONFALT
;
9930 if (val
& DF_1_ENDFILTEE
)
9932 printf (" ENDFILTEE");
9933 val
^= DF_1_ENDFILTEE
;
9935 if (val
& DF_1_DISPRELDNE
)
9937 printf (" DISPRELDNE");
9938 val
^= DF_1_DISPRELDNE
;
9940 if (val
& DF_1_DISPRELPND
)
9942 printf (" DISPRELPND");
9943 val
^= DF_1_DISPRELPND
;
9945 if (val
& DF_1_NODIRECT
)
9947 printf (" NODIRECT");
9948 val
^= DF_1_NODIRECT
;
9950 if (val
& DF_1_IGNMULDEF
)
9952 printf (" IGNMULDEF");
9953 val
^= DF_1_IGNMULDEF
;
9955 if (val
& DF_1_NOKSYMS
)
9957 printf (" NOKSYMS");
9958 val
^= DF_1_NOKSYMS
;
9960 if (val
& DF_1_NOHDR
)
9965 if (val
& DF_1_EDITED
)
9970 if (val
& DF_1_NORELOC
)
9972 printf (" NORELOC");
9973 val
^= DF_1_NORELOC
;
9975 if (val
& DF_1_SYMINTPOSE
)
9977 printf (" SYMINTPOSE");
9978 val
^= DF_1_SYMINTPOSE
;
9980 if (val
& DF_1_GLOBAUDIT
)
9982 printf (" GLOBAUDIT");
9983 val
^= DF_1_GLOBAUDIT
;
9985 if (val
& DF_1_SINGLETON
)
9987 printf (" SINGLETON");
9988 val
^= DF_1_SINGLETON
;
9990 if (val
& DF_1_STUB
)
10000 if (val
& DF_1_KMOD
)
10005 if (val
& DF_1_WEAKFILTER
)
10007 printf (" WEAKFILTER");
10008 val
^= DF_1_WEAKFILTER
;
10010 if (val
& DF_1_NOCOMMON
)
10012 printf (" NOCOMMON");
10013 val
^= DF_1_NOCOMMON
;
10016 printf (" %lx", val
);
10023 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10025 puts (get_dynamic_type (filedata
, entry
->d_un
.d_val
));
10045 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10051 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
10052 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
10058 switch (entry
->d_tag
)
10061 printf (_("Shared library: [%s]"), name
);
10063 if (streq (name
, program_interpreter
))
10064 printf (_(" program interpreter"));
10068 printf (_("Library soname: [%s]"), name
);
10072 printf (_("Library rpath: [%s]"), name
);
10076 printf (_("Library runpath: [%s]"), name
);
10080 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10085 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10098 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10099 /* Fall through. */
10103 case DT_INIT_ARRAYSZ
:
10104 case DT_FINI_ARRAYSZ
:
10105 case DT_GNU_CONFLICTSZ
:
10106 case DT_GNU_LIBLISTSZ
:
10109 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10110 printf (_(" (bytes)\n"));
10115 case DT_VERNEEDNUM
:
10120 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10129 case DT_INIT_ARRAY
:
10130 case DT_FINI_ARRAY
:
10133 if (entry
->d_tag
== DT_USED
10134 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
10136 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
10140 printf (_("Not needed object: [%s]\n"), name
);
10145 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10151 /* The value of this entry is ignored. */
10156 case DT_GNU_PRELINKED
:
10160 time_t atime
= entry
->d_un
.d_val
;
10162 tmp
= gmtime (&atime
);
10163 /* PR 17533 file: 041-1244816-0.004. */
10165 printf (_("<corrupt time val: %lx"),
10166 (unsigned long) atime
);
10168 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10169 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
10170 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
10176 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10179 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10185 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
10186 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
10191 switch (filedata
->file_header
.e_machine
)
10194 case EM_MIPS_RS3_LE
:
10195 dynamic_section_mips_val (entry
);
10198 dynamic_section_parisc_val (entry
);
10201 dynamic_section_ia64_val (entry
);
10204 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10216 get_ver_flags (unsigned int flags
)
10218 static char buff
[128];
10225 if (flags
& VER_FLG_BASE
)
10226 strcat (buff
, "BASE");
10228 if (flags
& VER_FLG_WEAK
)
10230 if (flags
& VER_FLG_BASE
)
10231 strcat (buff
, " | ");
10233 strcat (buff
, "WEAK");
10236 if (flags
& VER_FLG_INFO
)
10238 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
10239 strcat (buff
, " | ");
10241 strcat (buff
, "INFO");
10244 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10246 if (flags
& (VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10247 strcat (buff
, " | ");
10249 strcat (buff
, _("<unknown>"));
10255 /* Display the contents of the version sections. */
10258 process_version_sections (Filedata
* filedata
)
10260 Elf_Internal_Shdr
* section
;
10262 bfd_boolean found
= FALSE
;
10267 for (i
= 0, section
= filedata
->section_headers
;
10268 i
< filedata
->file_header
.e_shnum
;
10271 switch (section
->sh_type
)
10273 case SHT_GNU_verdef
:
10275 Elf_External_Verdef
* edefs
;
10282 printf (ngettext ("\nVersion definition section '%s' "
10283 "contains %u entry:\n",
10284 "\nVersion definition section '%s' "
10285 "contains %u entries:\n",
10287 printable_section_name (filedata
, section
),
10290 printf (_(" Addr: 0x"));
10291 printf_vma (section
->sh_addr
);
10292 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10293 (unsigned long) section
->sh_offset
, section
->sh_link
,
10294 printable_section_name_from_index (filedata
, section
->sh_link
));
10296 edefs
= (Elf_External_Verdef
*)
10297 get_data (NULL
, filedata
, section
->sh_offset
, 1,section
->sh_size
,
10298 _("version definition section"));
10301 endbuf
= (char *) edefs
+ section
->sh_size
;
10303 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
10306 Elf_External_Verdef
* edef
;
10307 Elf_Internal_Verdef ent
;
10308 Elf_External_Verdaux
* eaux
;
10309 Elf_Internal_Verdaux aux
;
10310 unsigned long isum
;
10313 vstart
= ((char *) edefs
) + idx
;
10314 if (vstart
+ sizeof (*edef
) > endbuf
)
10317 edef
= (Elf_External_Verdef
*) vstart
;
10319 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
10320 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
10321 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
10322 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
10323 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
10324 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
10325 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
10327 printf (_(" %#06lx: Rev: %d Flags: %s"),
10328 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
10330 printf (_(" Index: %d Cnt: %d "),
10331 ent
.vd_ndx
, ent
.vd_cnt
);
10333 /* Check for overflow. */
10334 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
10337 vstart
+= ent
.vd_aux
;
10339 if (vstart
+ sizeof (*eaux
) > endbuf
)
10341 eaux
= (Elf_External_Verdaux
*) vstart
;
10343 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10344 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10346 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10347 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
10349 printf (_("Name index: %ld\n"), aux
.vda_name
);
10351 isum
= idx
+ ent
.vd_aux
;
10353 for (j
= 1; j
< ent
.vd_cnt
; j
++)
10355 if (aux
.vda_next
< sizeof (*eaux
)
10356 && !(j
== ent
.vd_cnt
- 1 && aux
.vda_next
== 0))
10358 warn (_("Invalid vda_next field of %lx\n"),
10363 /* Check for overflow. */
10364 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
10367 isum
+= aux
.vda_next
;
10368 vstart
+= aux
.vda_next
;
10370 if (vstart
+ sizeof (*eaux
) > endbuf
)
10372 eaux
= (Elf_External_Verdaux
*) vstart
;
10374 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10375 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10377 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10378 printf (_(" %#06lx: Parent %d: %s\n"),
10379 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
10381 printf (_(" %#06lx: Parent %d, name index: %ld\n"),
10382 isum
, j
, aux
.vda_name
);
10385 if (j
< ent
.vd_cnt
)
10386 printf (_(" Version def aux past end of section\n"));
10389 file: id:000001,src:000172+005151,op:splice,rep:2. */
10390 if (ent
.vd_next
< sizeof (*edef
)
10391 && !(cnt
== section
->sh_info
- 1 && ent
.vd_next
== 0))
10393 warn (_("Invalid vd_next field of %lx\n"), ent
.vd_next
);
10394 cnt
= section
->sh_info
;
10397 if (ent
.vd_next
> (size_t) (endbuf
- ((char *) edefs
+ idx
)))
10400 idx
+= ent
.vd_next
;
10403 if (cnt
< section
->sh_info
)
10404 printf (_(" Version definition past end of section\n"));
10410 case SHT_GNU_verneed
:
10412 Elf_External_Verneed
* eneed
;
10419 printf (ngettext ("\nVersion needs section '%s' "
10420 "contains %u entry:\n",
10421 "\nVersion needs section '%s' "
10422 "contains %u entries:\n",
10424 printable_section_name (filedata
, section
), section
->sh_info
);
10426 printf (_(" Addr: 0x"));
10427 printf_vma (section
->sh_addr
);
10428 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10429 (unsigned long) section
->sh_offset
, section
->sh_link
,
10430 printable_section_name_from_index (filedata
, section
->sh_link
));
10432 eneed
= (Elf_External_Verneed
*) get_data (NULL
, filedata
,
10433 section
->sh_offset
, 1,
10435 _("Version Needs section"));
10438 endbuf
= (char *) eneed
+ section
->sh_size
;
10440 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
10442 Elf_External_Verneed
* entry
;
10443 Elf_Internal_Verneed ent
;
10444 unsigned long isum
;
10448 vstart
= ((char *) eneed
) + idx
;
10449 if (vstart
+ sizeof (*entry
) > endbuf
)
10452 entry
= (Elf_External_Verneed
*) vstart
;
10454 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
10455 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
10456 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
10457 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
10458 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
10460 printf (_(" %#06lx: Version: %d"), idx
, ent
.vn_version
);
10462 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
10463 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
10465 printf (_(" File: %lx"), ent
.vn_file
);
10467 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
10469 /* Check for overflow. */
10470 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
10472 vstart
+= ent
.vn_aux
;
10474 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
10476 Elf_External_Vernaux
* eaux
;
10477 Elf_Internal_Vernaux aux
;
10479 if (vstart
+ sizeof (*eaux
) > endbuf
)
10481 eaux
= (Elf_External_Vernaux
*) vstart
;
10483 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
10484 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
10485 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
10486 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
10487 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
10489 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
10490 printf (_(" %#06lx: Name: %s"),
10491 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
10493 printf (_(" %#06lx: Name index: %lx"),
10494 isum
, aux
.vna_name
);
10496 printf (_(" Flags: %s Version: %d\n"),
10497 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
10499 if (aux
.vna_next
< sizeof (*eaux
)
10500 && !(j
== ent
.vn_cnt
- 1 && aux
.vna_next
== 0))
10502 warn (_("Invalid vna_next field of %lx\n"),
10507 /* Check for overflow. */
10508 if (aux
.vna_next
> (size_t) (endbuf
- vstart
))
10510 isum
+= aux
.vna_next
;
10511 vstart
+= aux
.vna_next
;
10514 if (j
< ent
.vn_cnt
)
10515 warn (_("Missing Version Needs auxillary information\n"));
10517 if (ent
.vn_next
< sizeof (*entry
)
10518 && !(cnt
== section
->sh_info
- 1 && ent
.vn_next
== 0))
10520 warn (_("Invalid vn_next field of %lx\n"), ent
.vn_next
);
10521 cnt
= section
->sh_info
;
10524 if (ent
.vn_next
> (size_t) (endbuf
- ((char *) eneed
+ idx
)))
10526 idx
+= ent
.vn_next
;
10529 if (cnt
< section
->sh_info
)
10530 warn (_("Missing Version Needs information\n"));
10536 case SHT_GNU_versym
:
10538 Elf_Internal_Shdr
* link_section
;
10541 unsigned char * edata
;
10542 unsigned short * data
;
10544 Elf_Internal_Sym
* symbols
;
10545 Elf_Internal_Shdr
* string_sec
;
10546 unsigned long num_syms
;
10549 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
10552 link_section
= filedata
->section_headers
+ section
->sh_link
;
10553 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
10555 if (link_section
->sh_link
>= filedata
->file_header
.e_shnum
)
10560 symbols
= GET_ELF_SYMBOLS (filedata
, link_section
, & num_syms
);
10561 if (symbols
== NULL
)
10564 string_sec
= filedata
->section_headers
+ link_section
->sh_link
;
10566 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
10567 string_sec
->sh_size
,
10568 _("version string table"));
10575 printf (ngettext ("\nVersion symbols section '%s' "
10576 "contains %lu entry:\n",
10577 "\nVersion symbols section '%s' "
10578 "contains %lu entries:\n",
10580 printable_section_name (filedata
, section
), (unsigned long) total
);
10582 printf (_(" Addr: "));
10583 printf_vma (section
->sh_addr
);
10584 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10585 (unsigned long) section
->sh_offset
, section
->sh_link
,
10586 printable_section_name (filedata
, link_section
));
10588 off
= offset_from_vma (filedata
,
10589 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
10590 total
* sizeof (short));
10591 edata
= (unsigned char *) get_data (NULL
, filedata
, off
, total
,
10593 _("version symbol data"));
10601 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
10603 for (cnt
= total
; cnt
--;)
10604 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
10609 for (cnt
= 0; cnt
< total
; cnt
+= 4)
10613 char *invalid
= _("*invalid*");
10615 printf (" %03x:", cnt
);
10617 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
10618 switch (data
[cnt
+ j
])
10621 fputs (_(" 0 (*local*) "), stdout
);
10625 fputs (_(" 1 (*global*) "), stdout
);
10629 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
10630 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
10632 /* If this index value is greater than the size of the symbols
10633 array, break to avoid an out-of-bounds read. */
10634 if ((unsigned long)(cnt
+ j
) >= num_syms
)
10636 warn (_("invalid index into symbol array\n"));
10641 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
10643 Elf_Internal_Verneed ivn
;
10644 unsigned long offset
;
10646 offset
= offset_from_vma
10647 (filedata
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
10648 sizeof (Elf_External_Verneed
));
10652 Elf_Internal_Vernaux ivna
;
10653 Elf_External_Verneed evn
;
10654 Elf_External_Vernaux evna
;
10655 unsigned long a_off
;
10657 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
10658 _("version need")) == NULL
)
10661 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
10662 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
10664 a_off
= offset
+ ivn
.vn_aux
;
10668 if (get_data (&evna
, filedata
, a_off
, sizeof (evna
),
10669 1, _("version need aux (2)")) == NULL
)
10672 ivna
.vna_other
= 0;
10676 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
10677 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
10680 a_off
+= ivna
.vna_next
;
10682 while (ivna
.vna_other
!= data
[cnt
+ j
]
10683 && ivna
.vna_next
!= 0);
10685 if (ivna
.vna_other
== data
[cnt
+ j
])
10687 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
10689 if (ivna
.vna_name
>= string_sec
->sh_size
)
10692 name
= strtab
+ ivna
.vna_name
;
10696 offset
+= ivn
.vn_next
;
10698 while (ivn
.vn_next
);
10701 if (data
[cnt
+ j
] != 0x8001
10702 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
10704 Elf_Internal_Verdef ivd
;
10705 Elf_External_Verdef evd
;
10706 unsigned long offset
;
10708 offset
= offset_from_vma
10709 (filedata
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
10714 if (get_data (&evd
, filedata
, offset
, sizeof (evd
), 1,
10715 _("version def")) == NULL
)
10718 /* PR 17531: file: 046-1082287-0.004. */
10719 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
10724 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
10725 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
10728 offset
+= ivd
.vd_next
;
10730 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
10731 && ivd
.vd_next
!= 0);
10733 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
10735 Elf_External_Verdaux evda
;
10736 Elf_Internal_Verdaux ivda
;
10738 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
10740 if (get_data (&evda
, filedata
,
10741 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
10743 _("version def aux")) == NULL
)
10746 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
10748 if (ivda
.vda_name
>= string_sec
->sh_size
)
10750 else if (name
!= NULL
&& name
!= invalid
)
10751 name
= _("*both*");
10753 name
= strtab
+ ivda
.vda_name
;
10757 nn
+= printf ("(%s%-*s",
10759 12 - (int) strlen (name
),
10763 printf ("%*c", 18 - nn
, ' ');
10781 printf (_("\nNo version information found in this file.\n"));
10786 static const char *
10787 get_symbol_binding (Filedata
* filedata
, unsigned int binding
)
10789 static char buff
[32];
10793 case STB_LOCAL
: return "LOCAL";
10794 case STB_GLOBAL
: return "GLOBAL";
10795 case STB_WEAK
: return "WEAK";
10797 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
10798 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
10800 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
10802 if (binding
== STB_GNU_UNIQUE
10803 && (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10804 /* GNU is still using the default value 0. */
10805 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10807 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
10810 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
10815 static const char *
10816 get_symbol_type (Filedata
* filedata
, unsigned int type
)
10818 static char buff
[32];
10822 case STT_NOTYPE
: return "NOTYPE";
10823 case STT_OBJECT
: return "OBJECT";
10824 case STT_FUNC
: return "FUNC";
10825 case STT_SECTION
: return "SECTION";
10826 case STT_FILE
: return "FILE";
10827 case STT_COMMON
: return "COMMON";
10828 case STT_TLS
: return "TLS";
10829 case STT_RELC
: return "RELC";
10830 case STT_SRELC
: return "SRELC";
10832 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
10834 if (filedata
->file_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
10835 return "THUMB_FUNC";
10837 if (filedata
->file_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
10840 if (filedata
->file_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
10841 return "PARISC_MILLI";
10843 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
10845 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
10847 if (filedata
->file_header
.e_machine
== EM_PARISC
)
10849 if (type
== STT_HP_OPAQUE
)
10850 return "HP_OPAQUE";
10851 if (type
== STT_HP_STUB
)
10855 if (type
== STT_GNU_IFUNC
10856 && (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10857 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
10858 /* GNU is still using the default value 0. */
10859 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10862 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
10865 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
10870 static const char *
10871 get_symbol_visibility (unsigned int visibility
)
10873 switch (visibility
)
10875 case STV_DEFAULT
: return "DEFAULT";
10876 case STV_INTERNAL
: return "INTERNAL";
10877 case STV_HIDDEN
: return "HIDDEN";
10878 case STV_PROTECTED
: return "PROTECTED";
10880 error (_("Unrecognized visibility value: %u"), visibility
);
10881 return _("<unknown>");
10885 static const char *
10886 get_solaris_symbol_visibility (unsigned int visibility
)
10888 switch (visibility
)
10890 case 4: return "EXPORTED";
10891 case 5: return "SINGLETON";
10892 case 6: return "ELIMINATE";
10893 default: return get_symbol_visibility (visibility
);
10897 static const char *
10898 get_mips_symbol_other (unsigned int other
)
10902 case STO_OPTIONAL
: return "OPTIONAL";
10903 case STO_MIPS_PLT
: return "MIPS PLT";
10904 case STO_MIPS_PIC
: return "MIPS PIC";
10905 case STO_MICROMIPS
: return "MICROMIPS";
10906 case STO_MICROMIPS
| STO_MIPS_PIC
: return "MICROMIPS, MIPS PIC";
10907 case STO_MIPS16
: return "MIPS16";
10908 default: return NULL
;
10912 static const char *
10913 get_ia64_symbol_other (Filedata
* filedata
, unsigned int other
)
10915 if (is_ia64_vms (filedata
))
10917 static char res
[32];
10921 /* Function types is for images and .STB files only. */
10922 switch (filedata
->file_header
.e_type
)
10926 switch (VMS_ST_FUNC_TYPE (other
))
10928 case VMS_SFT_CODE_ADDR
:
10929 strcat (res
, " CA");
10931 case VMS_SFT_SYMV_IDX
:
10932 strcat (res
, " VEC");
10935 strcat (res
, " FD");
10937 case VMS_SFT_RESERVE
:
10938 strcat (res
, " RSV");
10941 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10942 VMS_ST_FUNC_TYPE (other
));
10943 strcat (res
, " <unknown>");
10950 switch (VMS_ST_LINKAGE (other
))
10952 case VMS_STL_IGNORE
:
10953 strcat (res
, " IGN");
10955 case VMS_STL_RESERVE
:
10956 strcat (res
, " RSV");
10959 strcat (res
, " STD");
10962 strcat (res
, " LNK");
10965 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10966 VMS_ST_LINKAGE (other
));
10967 strcat (res
, " <unknown>");
10979 static const char *
10980 get_ppc64_symbol_other (unsigned int other
)
10982 if (PPC64_LOCAL_ENTRY_OFFSET (other
) != 0)
10984 static char buf
[32];
10985 snprintf (buf
, sizeof buf
, _("<localentry>: %d"),
10986 PPC64_LOCAL_ENTRY_OFFSET (other
));
10992 static const char *
10993 get_symbol_other (Filedata
* filedata
, unsigned int other
)
10995 const char * result
= NULL
;
10996 static char buff
[32];
11001 switch (filedata
->file_header
.e_machine
)
11004 result
= get_mips_symbol_other (other
);
11007 result
= get_ia64_symbol_other (filedata
, other
);
11010 result
= get_ppc64_symbol_other (other
);
11020 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
11024 static const char *
11025 get_symbol_index_type (Filedata
* filedata
, unsigned int type
)
11027 static char buff
[32];
11031 case SHN_UNDEF
: return "UND";
11032 case SHN_ABS
: return "ABS";
11033 case SHN_COMMON
: return "COM";
11035 if (type
== SHN_IA_64_ANSI_COMMON
11036 && filedata
->file_header
.e_machine
== EM_IA_64
11037 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
11039 else if ((filedata
->file_header
.e_machine
== EM_X86_64
11040 || filedata
->file_header
.e_machine
== EM_L1OM
11041 || filedata
->file_header
.e_machine
== EM_K1OM
)
11042 && type
== SHN_X86_64_LCOMMON
)
11043 return "LARGE_COM";
11044 else if ((type
== SHN_MIPS_SCOMMON
11045 && filedata
->file_header
.e_machine
== EM_MIPS
)
11046 || (type
== SHN_TIC6X_SCOMMON
11047 && filedata
->file_header
.e_machine
== EM_TI_C6000
))
11049 else if (type
== SHN_MIPS_SUNDEFINED
11050 && filedata
->file_header
.e_machine
== EM_MIPS
)
11052 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
11053 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
11054 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
11055 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
11056 else if (type
>= SHN_LORESERVE
)
11057 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
11058 else if (type
>= filedata
->file_header
.e_shnum
)
11059 sprintf (buff
, _("bad section index[%3d]"), type
);
11061 sprintf (buff
, "%3d", type
);
11069 get_dynamic_data (Filedata
* filedata
, bfd_size_type number
, unsigned int ent_size
)
11071 unsigned char * e_data
;
11074 /* If the size_t type is smaller than the bfd_size_type, eg because
11075 you are building a 32-bit tool on a 64-bit host, then make sure
11076 that when (number) is cast to (size_t) no information is lost. */
11077 if (sizeof (size_t) < sizeof (bfd_size_type
)
11078 && (bfd_size_type
) ((size_t) number
) != number
)
11080 error (_("Size truncation prevents reading %s elements of size %u\n"),
11081 bfd_vmatoa ("u", number
), ent_size
);
11085 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
11086 attempting to allocate memory when the read is bound to fail. */
11087 if (ent_size
* number
> filedata
->file_size
)
11089 error (_("Invalid number of dynamic entries: %s\n"),
11090 bfd_vmatoa ("u", number
));
11094 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
11095 if (e_data
== NULL
)
11097 error (_("Out of memory reading %s dynamic entries\n"),
11098 bfd_vmatoa ("u", number
));
11102 if (fread (e_data
, ent_size
, (size_t) number
, filedata
->handle
) != number
)
11104 error (_("Unable to read in %s bytes of dynamic data\n"),
11105 bfd_vmatoa ("u", number
* ent_size
));
11110 i_data
= (bfd_vma
*) cmalloc ((size_t) number
, sizeof (*i_data
));
11111 if (i_data
== NULL
)
11113 error (_("Out of memory allocating space for %s dynamic entries\n"),
11114 bfd_vmatoa ("u", number
));
11120 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
11128 print_dynamic_symbol (Filedata
* filedata
, bfd_vma si
, unsigned long hn
)
11130 Elf_Internal_Sym
* psym
;
11133 n
= print_vma (si
, DEC_5
);
11135 fputs (&" "[n
], stdout
);
11136 printf (" %3lu: ", hn
);
11138 if (dynamic_symbols
== NULL
|| si
>= num_dynamic_syms
)
11140 printf (_("<No info available for dynamic symbol number %lu>\n"),
11141 (unsigned long) si
);
11145 psym
= dynamic_symbols
+ si
;
11146 print_vma (psym
->st_value
, LONG_HEX
);
11148 print_vma (psym
->st_size
, DEC_5
);
11150 printf (" %-7s", get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)));
11151 printf (" %-6s", get_symbol_binding (filedata
, ELF_ST_BIND (psym
->st_info
)));
11153 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
11154 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
11157 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
11159 printf (" %-7s", get_symbol_visibility (vis
));
11160 /* Check to see if any other bits in the st_other field are set.
11161 Note - displaying this information disrupts the layout of the
11162 table being generated, but for the moment this case is very
11164 if (psym
->st_other
^ vis
)
11165 printf (" [%s] ", get_symbol_other (filedata
, psym
->st_other
^ vis
));
11168 printf (" %3.3s ", get_symbol_index_type (filedata
, psym
->st_shndx
));
11169 if (VALID_DYNAMIC_NAME (psym
->st_name
))
11170 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
11172 printf (_(" <corrupt: %14ld>"), psym
->st_name
);
11176 static const char *
11177 get_symbol_version_string (Filedata
* filedata
,
11178 bfd_boolean is_dynsym
,
11179 const char * strtab
,
11180 unsigned long int strtab_size
,
11182 Elf_Internal_Sym
* psym
,
11183 enum versioned_symbol_info
* sym_info
,
11184 unsigned short * vna_other
)
11186 unsigned char data
[2];
11187 unsigned short vers_data
;
11188 unsigned long offset
;
11191 || version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
11194 offset
= offset_from_vma (filedata
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
11195 sizeof data
+ si
* sizeof (vers_data
));
11197 if (get_data (&data
, filedata
, offset
+ si
* sizeof (vers_data
),
11198 sizeof (data
), 1, _("version data")) == NULL
)
11201 vers_data
= byte_get (data
, 2);
11203 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
<= 1)
11206 /* Usually we'd only see verdef for defined symbols, and verneed for
11207 undefined symbols. However, symbols defined by the linker in
11208 .dynbss for variables copied from a shared library in order to
11209 avoid text relocations are defined yet have verneed. We could
11210 use a heuristic to detect the special case, for example, check
11211 for verneed first on symbols defined in SHT_NOBITS sections, but
11212 it is simpler and more reliable to just look for both verdef and
11213 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
11215 if (psym
->st_shndx
!= SHN_UNDEF
11216 && vers_data
!= 0x8001
11217 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
11219 Elf_Internal_Verdef ivd
;
11220 Elf_Internal_Verdaux ivda
;
11221 Elf_External_Verdaux evda
;
11224 off
= offset_from_vma (filedata
,
11225 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
11226 sizeof (Elf_External_Verdef
));
11230 Elf_External_Verdef evd
;
11232 if (get_data (&evd
, filedata
, off
, sizeof (evd
), 1,
11233 _("version def")) == NULL
)
11241 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
11242 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
11243 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
11246 off
+= ivd
.vd_next
;
11248 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
11250 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
11252 off
-= ivd
.vd_next
;
11255 if (get_data (&evda
, filedata
, off
, sizeof (evda
), 1,
11256 _("version def aux")) != NULL
)
11258 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
11260 if (psym
->st_name
!= ivda
.vda_name
)
11262 *sym_info
= ((vers_data
& VERSYM_HIDDEN
) != 0
11263 ? symbol_hidden
: symbol_public
);
11264 return (ivda
.vda_name
< strtab_size
11265 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
11271 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
11273 Elf_External_Verneed evn
;
11274 Elf_Internal_Verneed ivn
;
11275 Elf_Internal_Vernaux ivna
;
11277 offset
= offset_from_vma (filedata
,
11278 version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
11282 unsigned long vna_off
;
11284 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
11285 _("version need")) == NULL
)
11288 ivna
.vna_other
= 0;
11293 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
11294 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
11296 vna_off
= offset
+ ivn
.vn_aux
;
11300 Elf_External_Vernaux evna
;
11302 if (get_data (&evna
, filedata
, vna_off
, sizeof (evna
), 1,
11303 _("version need aux (3)")) == NULL
)
11306 ivna
.vna_other
= 0;
11311 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
11312 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
11313 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
11316 vna_off
+= ivna
.vna_next
;
11318 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
11320 if (ivna
.vna_other
== vers_data
)
11323 offset
+= ivn
.vn_next
;
11325 while (ivn
.vn_next
!= 0);
11327 if (ivna
.vna_other
== vers_data
)
11329 *sym_info
= symbol_undefined
;
11330 *vna_other
= ivna
.vna_other
;
11331 return (ivna
.vna_name
< strtab_size
11332 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
11338 /* Dump the symbol table. */
11340 process_symbol_table (Filedata
* filedata
)
11342 Elf_Internal_Shdr
* section
;
11343 bfd_size_type nbuckets
= 0;
11344 bfd_size_type nchains
= 0;
11345 bfd_vma
* buckets
= NULL
;
11346 bfd_vma
* chains
= NULL
;
11347 bfd_vma ngnubuckets
= 0;
11348 bfd_vma
* gnubuckets
= NULL
;
11349 bfd_vma
* gnuchains
= NULL
;
11350 bfd_vma gnusymidx
= 0;
11351 bfd_size_type ngnuchains
= 0;
11353 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
11356 if (dynamic_info
[DT_HASH
]
11358 || (do_using_dynamic
11360 && dynamic_strings
!= NULL
)))
11362 unsigned char nb
[8];
11363 unsigned char nc
[8];
11364 unsigned int hash_ent_size
= 4;
11366 if ((filedata
->file_header
.e_machine
== EM_ALPHA
11367 || filedata
->file_header
.e_machine
== EM_S390
11368 || filedata
->file_header
.e_machine
== EM_S390_OLD
)
11369 && filedata
->file_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
11372 if (fseek (filedata
->handle
,
11373 (archive_file_offset
11374 + offset_from_vma (filedata
, dynamic_info
[DT_HASH
],
11375 sizeof nb
+ sizeof nc
)),
11378 error (_("Unable to seek to start of dynamic information\n"));
11382 if (fread (nb
, hash_ent_size
, 1, filedata
->handle
) != 1)
11384 error (_("Failed to read in number of buckets\n"));
11388 if (fread (nc
, hash_ent_size
, 1, filedata
->handle
) != 1)
11390 error (_("Failed to read in number of chains\n"));
11394 nbuckets
= byte_get (nb
, hash_ent_size
);
11395 nchains
= byte_get (nc
, hash_ent_size
);
11397 buckets
= get_dynamic_data (filedata
, nbuckets
, hash_ent_size
);
11398 chains
= get_dynamic_data (filedata
, nchains
, hash_ent_size
);
11401 if (buckets
== NULL
|| chains
== NULL
)
11403 if (do_using_dynamic
)
11414 if (dynamic_info_DT_GNU_HASH
11416 || (do_using_dynamic
11418 && dynamic_strings
!= NULL
)))
11420 unsigned char nb
[16];
11421 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
11422 bfd_vma buckets_vma
;
11424 if (fseek (filedata
->handle
,
11425 (archive_file_offset
11426 + offset_from_vma (filedata
, dynamic_info_DT_GNU_HASH
,
11430 error (_("Unable to seek to start of dynamic information\n"));
11434 if (fread (nb
, 16, 1, filedata
->handle
) != 1)
11436 error (_("Failed to read in number of buckets\n"));
11440 ngnubuckets
= byte_get (nb
, 4);
11441 gnusymidx
= byte_get (nb
+ 4, 4);
11442 bitmaskwords
= byte_get (nb
+ 8, 4);
11443 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
11445 buckets_vma
+= bitmaskwords
* 4;
11447 buckets_vma
+= bitmaskwords
* 8;
11449 if (fseek (filedata
->handle
,
11450 (archive_file_offset
11451 + offset_from_vma (filedata
, buckets_vma
, 4)),
11454 error (_("Unable to seek to start of dynamic information\n"));
11458 gnubuckets
= get_dynamic_data (filedata
, ngnubuckets
, 4);
11460 if (gnubuckets
== NULL
)
11463 for (i
= 0; i
< ngnubuckets
; i
++)
11464 if (gnubuckets
[i
] != 0)
11466 if (gnubuckets
[i
] < gnusymidx
)
11469 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
11470 maxchain
= gnubuckets
[i
];
11473 if (maxchain
== 0xffffffff)
11476 maxchain
-= gnusymidx
;
11478 if (fseek (filedata
->handle
,
11479 (archive_file_offset
11480 + offset_from_vma (filedata
, buckets_vma
11481 + 4 * (ngnubuckets
+ maxchain
), 4)),
11484 error (_("Unable to seek to start of dynamic information\n"));
11490 if (fread (nb
, 4, 1, filedata
->handle
) != 1)
11492 error (_("Failed to determine last chain length\n"));
11496 if (maxchain
+ 1 == 0)
11501 while ((byte_get (nb
, 4) & 1) == 0);
11503 if (fseek (filedata
->handle
,
11504 (archive_file_offset
11505 + offset_from_vma (filedata
, buckets_vma
+ 4 * ngnubuckets
, 4)),
11508 error (_("Unable to seek to start of dynamic information\n"));
11512 gnuchains
= get_dynamic_data (filedata
, maxchain
, 4);
11513 ngnuchains
= maxchain
;
11516 if (gnuchains
== NULL
)
11521 if (do_using_dynamic
)
11526 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
11528 && do_using_dynamic
11529 && dynamic_strings
!= NULL
11530 && dynamic_symbols
!= NULL
)
11534 if (dynamic_info
[DT_HASH
])
11539 printf (_("\nSymbol table for image:\n"));
11541 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11543 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11545 visited
= xcmalloc (nchains
, 1);
11546 memset (visited
, 0, nchains
);
11547 for (hn
= 0; hn
< nbuckets
; hn
++)
11549 for (si
= buckets
[hn
]; si
> 0; si
= chains
[si
])
11551 print_dynamic_symbol (filedata
, si
, hn
);
11552 if (si
>= nchains
|| visited
[si
])
11554 error (_("histogram chain is corrupt\n"));
11563 if (dynamic_info_DT_GNU_HASH
)
11565 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
11567 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11569 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11571 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11572 if (gnubuckets
[hn
] != 0)
11574 bfd_vma si
= gnubuckets
[hn
];
11575 bfd_vma off
= si
- gnusymidx
;
11579 print_dynamic_symbol (filedata
, si
, hn
);
11582 while (off
< ngnuchains
&& (gnuchains
[off
++] & 1) == 0);
11586 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
11587 && filedata
->section_headers
!= NULL
)
11591 for (i
= 0, section
= filedata
->section_headers
;
11592 i
< filedata
->file_header
.e_shnum
;
11596 char * strtab
= NULL
;
11597 unsigned long int strtab_size
= 0;
11598 Elf_Internal_Sym
* symtab
;
11599 Elf_Internal_Sym
* psym
;
11600 unsigned long num_syms
;
11602 if ((section
->sh_type
!= SHT_SYMTAB
11603 && section
->sh_type
!= SHT_DYNSYM
)
11605 && section
->sh_type
== SHT_SYMTAB
))
11608 if (section
->sh_entsize
== 0)
11610 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
11611 printable_section_name (filedata
, section
));
11615 num_syms
= section
->sh_size
/ section
->sh_entsize
;
11616 printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
11617 "\nSymbol table '%s' contains %lu entries:\n",
11619 printable_section_name (filedata
, section
),
11623 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11625 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11627 symtab
= GET_ELF_SYMBOLS (filedata
, section
, & num_syms
);
11628 if (symtab
== NULL
)
11631 if (section
->sh_link
== filedata
->file_header
.e_shstrndx
)
11633 strtab
= filedata
->string_table
;
11634 strtab_size
= filedata
->string_table_length
;
11636 else if (section
->sh_link
< filedata
->file_header
.e_shnum
)
11638 Elf_Internal_Shdr
* string_sec
;
11640 string_sec
= filedata
->section_headers
+ section
->sh_link
;
11642 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
,
11643 1, string_sec
->sh_size
,
11644 _("string table"));
11645 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
11648 for (si
= 0, psym
= symtab
; si
< num_syms
; si
++, psym
++)
11650 const char *version_string
;
11651 enum versioned_symbol_info sym_info
;
11652 unsigned short vna_other
;
11654 printf ("%6d: ", si
);
11655 print_vma (psym
->st_value
, LONG_HEX
);
11657 print_vma (psym
->st_size
, DEC_5
);
11658 printf (" %-7s", get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)));
11659 printf (" %-6s", get_symbol_binding (filedata
, ELF_ST_BIND (psym
->st_info
)));
11660 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
11661 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
11664 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
11666 printf (" %-7s", get_symbol_visibility (vis
));
11667 /* Check to see if any other bits in the st_other field are set.
11668 Note - displaying this information disrupts the layout of the
11669 table being generated, but for the moment this case is very rare. */
11670 if (psym
->st_other
^ vis
)
11671 printf (" [%s] ", get_symbol_other (filedata
, psym
->st_other
^ vis
));
11673 printf (" %4s ", get_symbol_index_type (filedata
, psym
->st_shndx
));
11674 print_symbol (25, psym
->st_name
< strtab_size
11675 ? strtab
+ psym
->st_name
: _("<corrupt>"));
11678 = get_symbol_version_string (filedata
,
11679 section
->sh_type
== SHT_DYNSYM
,
11680 strtab
, strtab_size
, si
,
11681 psym
, &sym_info
, &vna_other
);
11682 if (version_string
)
11684 if (sym_info
== symbol_undefined
)
11685 printf ("@%s (%d)", version_string
, vna_other
);
11687 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
11693 if (ELF_ST_BIND (psym
->st_info
) == STB_LOCAL
11694 && si
>= section
->sh_info
11695 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
11696 && filedata
->file_header
.e_machine
!= EM_MIPS
11697 /* Solaris binaries have been found to violate this requirement as
11698 well. Not sure if this is a bug or an ABI requirement. */
11699 && filedata
->file_header
.e_ident
[EI_OSABI
] != ELFOSABI_SOLARIS
)
11700 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
11701 si
, printable_section_name (filedata
, section
), section
->sh_info
);
11705 if (strtab
!= filedata
->string_table
)
11711 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
11713 if (do_histogram
&& buckets
!= NULL
)
11715 unsigned long * lengths
;
11716 unsigned long * counts
;
11719 unsigned long maxlength
= 0;
11720 unsigned long nzero_counts
= 0;
11721 unsigned long nsyms
= 0;
11724 printf (ngettext ("\nHistogram for bucket list length "
11725 "(total of %lu bucket):\n",
11726 "\nHistogram for bucket list length "
11727 "(total of %lu buckets):\n",
11728 (unsigned long) nbuckets
),
11729 (unsigned long) nbuckets
);
11731 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
11732 if (lengths
== NULL
)
11734 error (_("Out of memory allocating space for histogram buckets\n"));
11737 visited
= xcmalloc (nchains
, 1);
11738 memset (visited
, 0, nchains
);
11740 printf (_(" Length Number %% of total Coverage\n"));
11741 for (hn
= 0; hn
< nbuckets
; ++hn
)
11743 for (si
= buckets
[hn
]; si
> 0; si
= chains
[si
])
11746 if (maxlength
< ++lengths
[hn
])
11748 if (si
>= nchains
|| visited
[si
])
11750 error (_("histogram chain is corrupt\n"));
11758 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
11759 if (counts
== NULL
)
11762 error (_("Out of memory allocating space for histogram counts\n"));
11766 for (hn
= 0; hn
< nbuckets
; ++hn
)
11767 ++counts
[lengths
[hn
]];
11772 printf (" 0 %-10lu (%5.1f%%)\n",
11773 counts
[0], (counts
[0] * 100.0) / nbuckets
);
11774 for (i
= 1; i
<= maxlength
; ++i
)
11776 nzero_counts
+= counts
[i
] * i
;
11777 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11778 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
11779 (nzero_counts
* 100.0) / nsyms
);
11787 if (buckets
!= NULL
)
11793 if (do_histogram
&& gnubuckets
!= NULL
)
11795 unsigned long * lengths
;
11796 unsigned long * counts
;
11798 unsigned long maxlength
= 0;
11799 unsigned long nzero_counts
= 0;
11800 unsigned long nsyms
= 0;
11802 printf (ngettext ("\nHistogram for `.gnu.hash' bucket list length "
11803 "(total of %lu bucket):\n",
11804 "\nHistogram for `.gnu.hash' bucket list length "
11805 "(total of %lu buckets):\n",
11806 (unsigned long) ngnubuckets
),
11807 (unsigned long) ngnubuckets
);
11809 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
11810 if (lengths
== NULL
)
11812 error (_("Out of memory allocating space for gnu histogram buckets\n"));
11816 printf (_(" Length Number %% of total Coverage\n"));
11818 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11819 if (gnubuckets
[hn
] != 0)
11821 bfd_vma off
, length
= 1;
11823 for (off
= gnubuckets
[hn
] - gnusymidx
;
11824 /* PR 17531 file: 010-77222-0.004. */
11825 off
< ngnuchains
&& (gnuchains
[off
] & 1) == 0;
11828 lengths
[hn
] = length
;
11829 if (length
> maxlength
)
11830 maxlength
= length
;
11834 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
11835 if (counts
== NULL
)
11838 error (_("Out of memory allocating space for gnu histogram counts\n"));
11842 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11843 ++counts
[lengths
[hn
]];
11845 if (ngnubuckets
> 0)
11848 printf (" 0 %-10lu (%5.1f%%)\n",
11849 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
11850 for (j
= 1; j
<= maxlength
; ++j
)
11852 nzero_counts
+= counts
[j
] * j
;
11853 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11854 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
11855 (nzero_counts
* 100.0) / nsyms
);
11869 process_syminfo (Filedata
* filedata ATTRIBUTE_UNUSED
)
11873 if (dynamic_syminfo
== NULL
11875 /* No syminfo, this is ok. */
11878 /* There better should be a dynamic symbol section. */
11879 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
11883 printf (ngettext ("\nDynamic info segment at offset 0x%lx "
11884 "contains %d entry:\n",
11885 "\nDynamic info segment at offset 0x%lx "
11886 "contains %d entries:\n",
11887 dynamic_syminfo_nent
),
11888 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
11890 printf (_(" Num: Name BoundTo Flags\n"));
11891 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
11893 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
11895 printf ("%4d: ", i
);
11896 if (i
>= num_dynamic_syms
)
11897 printf (_("<corrupt index>"));
11898 else if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
11899 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
11901 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
11904 switch (dynamic_syminfo
[i
].si_boundto
)
11906 case SYMINFO_BT_SELF
:
11907 fputs ("SELF ", stdout
);
11909 case SYMINFO_BT_PARENT
:
11910 fputs ("PARENT ", stdout
);
11913 if (dynamic_syminfo
[i
].si_boundto
> 0
11914 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
11915 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
11917 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
11921 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
11925 if (flags
& SYMINFO_FLG_DIRECT
)
11926 printf (" DIRECT");
11927 if (flags
& SYMINFO_FLG_PASSTHRU
)
11928 printf (" PASSTHRU");
11929 if (flags
& SYMINFO_FLG_COPY
)
11931 if (flags
& SYMINFO_FLG_LAZYLOAD
)
11932 printf (" LAZYLOAD");
11940 #define IN_RANGE(START,END,ADDR,OFF) \
11941 (((ADDR) >= (START)) && ((ADDR) + (OFF) < (END)))
11943 /* Check to see if the given reloc needs to be handled in a target specific
11944 manner. If so then process the reloc and return TRUE otherwise return
11947 If called with reloc == NULL, then this is a signal that reloc processing
11948 for the current section has finished, and any saved state should be
11952 target_specific_reloc_handling (Filedata
* filedata
,
11953 Elf_Internal_Rela
* reloc
,
11954 unsigned char * start
,
11955 unsigned char * end
,
11956 Elf_Internal_Sym
* symtab
,
11957 unsigned long num_syms
)
11959 unsigned int reloc_type
= 0;
11960 unsigned long sym_index
= 0;
11964 reloc_type
= get_reloc_type (filedata
, reloc
->r_info
);
11965 sym_index
= get_reloc_symindex (reloc
->r_info
);
11968 switch (filedata
->file_header
.e_machine
)
11971 case EM_MSP430_OLD
:
11973 static Elf_Internal_Sym
* saved_sym
= NULL
;
11981 switch (reloc_type
)
11983 case 10: /* R_MSP430_SYM_DIFF */
11984 if (uses_msp430x_relocs (filedata
))
11986 /* Fall through. */
11987 case 21: /* R_MSP430X_SYM_DIFF */
11989 if (sym_index
>= num_syms
)
11990 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
11993 saved_sym
= symtab
+ sym_index
;
11996 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
11997 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
11998 goto handle_sym_diff
;
12000 case 5: /* R_MSP430_16_BYTE */
12001 case 9: /* R_MSP430_8 */
12002 if (uses_msp430x_relocs (filedata
))
12004 goto handle_sym_diff
;
12006 case 2: /* R_MSP430_ABS16 */
12007 case 15: /* R_MSP430X_ABS16 */
12008 if (! uses_msp430x_relocs (filedata
))
12010 goto handle_sym_diff
;
12013 if (saved_sym
!= NULL
)
12015 int reloc_size
= reloc_type
== 1 ? 4 : 2;
12018 if (sym_index
>= num_syms
)
12019 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
12023 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12024 - saved_sym
->st_value
);
12026 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12027 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12030 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
12031 (long) reloc
->r_offset
);
12040 if (saved_sym
!= NULL
)
12041 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
12048 case EM_CYGNUS_MN10300
:
12050 static Elf_Internal_Sym
* saved_sym
= NULL
;
12058 switch (reloc_type
)
12060 case 34: /* R_MN10300_ALIGN */
12062 case 33: /* R_MN10300_SYM_DIFF */
12063 if (sym_index
>= num_syms
)
12064 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
12067 saved_sym
= symtab
+ sym_index
;
12070 case 1: /* R_MN10300_32 */
12071 case 2: /* R_MN10300_16 */
12072 if (saved_sym
!= NULL
)
12074 int reloc_size
= reloc_type
== 1 ? 4 : 2;
12077 if (sym_index
>= num_syms
)
12078 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
12082 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12083 - saved_sym
->st_value
);
12085 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12086 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12088 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
12089 (long) reloc
->r_offset
);
12097 if (saved_sym
!= NULL
)
12098 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
12106 static bfd_vma saved_sym1
= 0;
12107 static bfd_vma saved_sym2
= 0;
12108 static bfd_vma value
;
12112 saved_sym1
= saved_sym2
= 0;
12116 switch (reloc_type
)
12118 case 0x80: /* R_RL78_SYM. */
12119 saved_sym1
= saved_sym2
;
12120 if (sym_index
>= num_syms
)
12121 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
12125 saved_sym2
= symtab
[sym_index
].st_value
;
12126 saved_sym2
+= reloc
->r_addend
;
12130 case 0x83: /* R_RL78_OPsub. */
12131 value
= saved_sym1
- saved_sym2
;
12132 saved_sym2
= saved_sym1
= 0;
12136 case 0x41: /* R_RL78_ABS32. */
12137 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 4))
12138 byte_put (start
+ reloc
->r_offset
, value
, 4);
12140 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12141 (long) reloc
->r_offset
);
12145 case 0x43: /* R_RL78_ABS16. */
12146 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 2))
12147 byte_put (start
+ reloc
->r_offset
, value
, 2);
12149 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12150 (long) reloc
->r_offset
);
12164 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12165 DWARF debug sections. This is a target specific test. Note - we do not
12166 go through the whole including-target-headers-multiple-times route, (as
12167 we have already done with <elf/h8.h>) because this would become very
12168 messy and even then this function would have to contain target specific
12169 information (the names of the relocs instead of their numeric values).
12170 FIXME: This is not the correct way to solve this problem. The proper way
12171 is to have target specific reloc sizing and typing functions created by
12172 the reloc-macros.h header, in the same way that it already creates the
12173 reloc naming functions. */
12176 is_32bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12178 /* Please keep this table alpha-sorted for ease of visual lookup. */
12179 switch (filedata
->file_header
.e_machine
)
12183 return reloc_type
== 1; /* R_386_32. */
12185 return reloc_type
== 1; /* R_68K_32. */
12187 return (reloc_type
== 258
12188 || reloc_type
== 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12189 case EM_ADAPTEVA_EPIPHANY
:
12190 return reloc_type
== 3;
12192 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
12194 return reloc_type
== 1; /* R_ARC_32. */
12195 case EM_ARC_COMPACT
:
12196 case EM_ARC_COMPACT2
:
12197 return reloc_type
== 4; /* R_ARC_32. */
12199 return reloc_type
== 2; /* R_ARM_ABS32 */
12202 return reloc_type
== 1;
12204 return reloc_type
== 0x12; /* R_byte4_data. */
12206 return reloc_type
== 3; /* R_CRIS_32. */
12208 return reloc_type
== 3; /* R_CR16_NUM32. */
12210 return reloc_type
== 15; /* R_CRX_NUM32. */
12211 case EM_CYGNUS_FRV
:
12212 return reloc_type
== 1;
12213 case EM_CYGNUS_D10V
:
12215 return reloc_type
== 6; /* R_D10V_32. */
12216 case EM_CYGNUS_D30V
:
12218 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
12220 return reloc_type
== 3; /* R_DLX_RELOC_32. */
12221 case EM_CYGNUS_FR30
:
12223 return reloc_type
== 3; /* R_FR30_32. */
12225 return reloc_type
== 1; /* R_FT32_32. */
12229 return reloc_type
== 1; /* R_H8_DIR32. */
12231 return (reloc_type
== 0x64 /* R_IA64_SECREL32MSB. */
12232 || reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
12233 || reloc_type
== 0x24 /* R_IA64_DIR32MSB. */
12234 || reloc_type
== 0x25 /* R_IA64_DIR32LSB. */);
12237 return reloc_type
== 2; /* R_IP2K_32. */
12239 return reloc_type
== 2; /* R_IQ2000_32. */
12240 case EM_LATTICEMICO32
:
12241 return reloc_type
== 3; /* R_LM32_32. */
12244 return reloc_type
== 3; /* R_M32C_32. */
12246 return reloc_type
== 34; /* R_M32R_32_RELA. */
12249 return reloc_type
== 6; /* R_M68HC11_32. */
12251 return reloc_type
== 1; /* R_MCORE_ADDR32. */
12252 case EM_CYGNUS_MEP
:
12253 return reloc_type
== 4; /* R_MEP_32. */
12255 return reloc_type
== 2; /* R_METAG_ADDR32. */
12256 case EM_MICROBLAZE
:
12257 return reloc_type
== 1; /* R_MICROBLAZE_32. */
12259 return reloc_type
== 2; /* R_MIPS_32. */
12261 return reloc_type
== 4; /* R_MMIX_32. */
12262 case EM_CYGNUS_MN10200
:
12264 return reloc_type
== 1; /* R_MN10200_32. */
12265 case EM_CYGNUS_MN10300
:
12267 return reloc_type
== 1; /* R_MN10300_32. */
12269 return reloc_type
== 1; /* R_MOXIE_32. */
12270 case EM_MSP430_OLD
:
12272 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
12274 return reloc_type
== 2; /* R_MT_32. */
12276 return reloc_type
== 20; /* R_NDS32_RELA. */
12277 case EM_ALTERA_NIOS2
:
12278 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
12280 return reloc_type
== 1; /* R_NIOS_32. */
12282 return reloc_type
== 1; /* R_OR1K_32. */
12284 return (reloc_type
== 1 /* R_PARISC_DIR32. */
12285 || reloc_type
== 41); /* R_PARISC_SECREL32. */
12288 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
12290 return reloc_type
== 1; /* R_PPC64_ADDR32. */
12292 return reloc_type
== 1; /* R_PPC_ADDR32. */
12294 return reloc_type
== 11; /* R_PRU_BFD_RELOC_32. */
12296 return reloc_type
== 1; /* R_RISCV_32. */
12298 return reloc_type
== 1; /* R_RL78_DIR32. */
12300 return reloc_type
== 1; /* R_RX_DIR32. */
12302 return reloc_type
== 1; /* R_I370_ADDR31. */
12305 return reloc_type
== 4; /* R_S390_32. */
12307 return reloc_type
== 8; /* R_SCORE_ABS32. */
12309 return reloc_type
== 1; /* R_SH_DIR32. */
12310 case EM_SPARC32PLUS
:
12313 return reloc_type
== 3 /* R_SPARC_32. */
12314 || reloc_type
== 23; /* R_SPARC_UA32. */
12316 return reloc_type
== 6; /* R_SPU_ADDR32 */
12318 return reloc_type
== 1; /* R_C6000_ABS32. */
12320 return reloc_type
== 2; /* R_TILEGX_32. */
12322 return reloc_type
== 1; /* R_TILEPRO_32. */
12323 case EM_CYGNUS_V850
:
12325 return reloc_type
== 6; /* R_V850_ABS32. */
12327 return reloc_type
== 0x33; /* R_V810_WORD. */
12329 return reloc_type
== 1; /* R_VAX_32. */
12331 return reloc_type
== 3; /* R_VISIUM_32. */
12332 case EM_WEBASSEMBLY
:
12333 return reloc_type
== 1; /* R_WASM32_32. */
12337 return reloc_type
== 10; /* R_X86_64_32. */
12340 return reloc_type
== 3; /* R_XC16C_ABS_32. */
12342 return reloc_type
== 4; /* R_XGATE_32. */
12344 return reloc_type
== 1; /* R_XSTROMY16_32. */
12345 case EM_XTENSA_OLD
:
12347 return reloc_type
== 1; /* R_XTENSA_32. */
12350 static unsigned int prev_warn
= 0;
12352 /* Avoid repeating the same warning multiple times. */
12353 if (prev_warn
!= filedata
->file_header
.e_machine
)
12354 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12355 filedata
->file_header
.e_machine
);
12356 prev_warn
= filedata
->file_header
.e_machine
;
12362 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12363 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
12366 is_32bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12368 switch (filedata
->file_header
.e_machine
)
12369 /* Please keep this table alpha-sorted for ease of visual lookup. */
12373 return reloc_type
== 2; /* R_386_PC32. */
12375 return reloc_type
== 4; /* R_68K_PC32. */
12377 return reloc_type
== 261; /* R_AARCH64_PREL32 */
12378 case EM_ADAPTEVA_EPIPHANY
:
12379 return reloc_type
== 6;
12381 return reloc_type
== 10; /* R_ALPHA_SREL32. */
12382 case EM_ARC_COMPACT
:
12383 case EM_ARC_COMPACT2
:
12384 return reloc_type
== 49; /* R_ARC_32_PCREL. */
12386 return reloc_type
== 3; /* R_ARM_REL32 */
12389 return reloc_type
== 36; /* R_AVR_32_PCREL. */
12390 case EM_MICROBLAZE
:
12391 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
12393 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
12395 return reloc_type
== 9; /* R_PARISC_PCREL32. */
12397 return reloc_type
== 26; /* R_PPC_REL32. */
12399 return reloc_type
== 26; /* R_PPC64_REL32. */
12402 return reloc_type
== 5; /* R_390_PC32. */
12404 return reloc_type
== 2; /* R_SH_REL32. */
12405 case EM_SPARC32PLUS
:
12408 return reloc_type
== 6; /* R_SPARC_DISP32. */
12410 return reloc_type
== 13; /* R_SPU_REL32. */
12412 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
12414 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
12416 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
12420 return reloc_type
== 2; /* R_X86_64_PC32. */
12421 case EM_XTENSA_OLD
:
12423 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
12425 /* Do not abort or issue an error message here. Not all targets use
12426 pc-relative 32-bit relocs in their DWARF debug information and we
12427 have already tested for target coverage in is_32bit_abs_reloc. A
12428 more helpful warning message will be generated by apply_relocations
12429 anyway, so just return. */
12434 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12435 a 64-bit absolute RELA relocation used in DWARF debug sections. */
12438 is_64bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12440 switch (filedata
->file_header
.e_machine
)
12443 return reloc_type
== 257; /* R_AARCH64_ABS64. */
12445 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
12447 return (reloc_type
== 0x26 /* R_IA64_DIR64MSB. */
12448 || reloc_type
== 0x27 /* R_IA64_DIR64LSB. */);
12450 return reloc_type
== 80; /* R_PARISC_DIR64. */
12452 return reloc_type
== 38; /* R_PPC64_ADDR64. */
12454 return reloc_type
== 2; /* R_RISCV_64. */
12455 case EM_SPARC32PLUS
:
12458 return reloc_type
== 32 /* R_SPARC_64. */
12459 || reloc_type
== 54; /* R_SPARC_UA64. */
12463 return reloc_type
== 1; /* R_X86_64_64. */
12466 return reloc_type
== 22; /* R_S390_64. */
12468 return reloc_type
== 1; /* R_TILEGX_64. */
12470 return reloc_type
== 18; /* R_MIPS_64. */
12476 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12477 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
12480 is_64bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12482 switch (filedata
->file_header
.e_machine
)
12485 return reloc_type
== 260; /* R_AARCH64_PREL64. */
12487 return reloc_type
== 11; /* R_ALPHA_SREL64. */
12489 return (reloc_type
== 0x4e /* R_IA64_PCREL64MSB. */
12490 || reloc_type
== 0x4f /* R_IA64_PCREL64LSB. */);
12492 return reloc_type
== 72; /* R_PARISC_PCREL64. */
12494 return reloc_type
== 44; /* R_PPC64_REL64. */
12495 case EM_SPARC32PLUS
:
12498 return reloc_type
== 46; /* R_SPARC_DISP64. */
12502 return reloc_type
== 24; /* R_X86_64_PC64. */
12505 return reloc_type
== 23; /* R_S390_PC64. */
12507 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
12513 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12514 a 24-bit absolute RELA relocation used in DWARF debug sections. */
12517 is_24bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12519 switch (filedata
->file_header
.e_machine
)
12521 case EM_CYGNUS_MN10200
:
12523 return reloc_type
== 4; /* R_MN10200_24. */
12525 return reloc_type
== 5; /* R_FT32_20. */
12531 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12532 a 16-bit absolute RELA relocation used in DWARF debug sections. */
12535 is_16bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12537 /* Please keep this table alpha-sorted for ease of visual lookup. */
12538 switch (filedata
->file_header
.e_machine
)
12541 case EM_ARC_COMPACT
:
12542 case EM_ARC_COMPACT2
:
12543 return reloc_type
== 2; /* R_ARC_16. */
12544 case EM_ADAPTEVA_EPIPHANY
:
12545 return reloc_type
== 5;
12548 return reloc_type
== 4; /* R_AVR_16. */
12549 case EM_CYGNUS_D10V
:
12551 return reloc_type
== 3; /* R_D10V_16. */
12553 return reloc_type
== 2; /* R_FT32_16. */
12557 return reloc_type
== R_H8_DIR16
;
12560 return reloc_type
== 1; /* R_IP2K_16. */
12563 return reloc_type
== 1; /* R_M32C_16 */
12564 case EM_CYGNUS_MN10200
:
12566 return reloc_type
== 2; /* R_MN10200_16. */
12567 case EM_CYGNUS_MN10300
:
12569 return reloc_type
== 2; /* R_MN10300_16. */
12571 if (uses_msp430x_relocs (filedata
))
12572 return reloc_type
== 2; /* R_MSP430_ABS16. */
12573 /* Fall through. */
12574 case EM_MSP430_OLD
:
12575 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
12577 return reloc_type
== 19; /* R_NDS32_RELA. */
12578 case EM_ALTERA_NIOS2
:
12579 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
12581 return reloc_type
== 9; /* R_NIOS_16. */
12583 return reloc_type
== 2; /* R_OR1K_16. */
12585 return reloc_type
== 8; /* R_PRU_BFD_RELOC_16. */
12587 return reloc_type
== 2; /* R_C6000_ABS16. */
12589 return reloc_type
== 2; /* R_VISIUM_16. */
12592 return reloc_type
== 2; /* R_XC16C_ABS_16. */
12594 return reloc_type
== 3; /* R_XGATE_16. */
12600 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12601 a 32-bit inplace add RELA relocation used in DWARF debug sections. */
12604 is_32bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12606 /* Please keep this table alpha-sorted for ease of visual lookup. */
12607 switch (filedata
->file_header
.e_machine
)
12610 return reloc_type
== 35; /* R_RISCV_ADD32. */
12616 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12617 a 32-bit inplace sub RELA relocation used in DWARF debug sections. */
12620 is_32bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12622 /* Please keep this table alpha-sorted for ease of visual lookup. */
12623 switch (filedata
->file_header
.e_machine
)
12626 return reloc_type
== 39; /* R_RISCV_SUB32. */
12632 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12633 a 64-bit inplace add RELA relocation used in DWARF debug sections. */
12636 is_64bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12638 /* Please keep this table alpha-sorted for ease of visual lookup. */
12639 switch (filedata
->file_header
.e_machine
)
12642 return reloc_type
== 36; /* R_RISCV_ADD64. */
12648 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12649 a 64-bit inplace sub RELA relocation used in DWARF debug sections. */
12652 is_64bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12654 /* Please keep this table alpha-sorted for ease of visual lookup. */
12655 switch (filedata
->file_header
.e_machine
)
12658 return reloc_type
== 40; /* R_RISCV_SUB64. */
12664 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12665 a 16-bit inplace add RELA relocation used in DWARF debug sections. */
12668 is_16bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12670 /* Please keep this table alpha-sorted for ease of visual lookup. */
12671 switch (filedata
->file_header
.e_machine
)
12674 return reloc_type
== 34; /* R_RISCV_ADD16. */
12680 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12681 a 16-bit inplace sub RELA relocation used in DWARF debug sections. */
12684 is_16bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12686 /* Please keep this table alpha-sorted for ease of visual lookup. */
12687 switch (filedata
->file_header
.e_machine
)
12690 return reloc_type
== 38; /* R_RISCV_SUB16. */
12696 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12697 a 8-bit inplace add RELA relocation used in DWARF debug sections. */
12700 is_8bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12702 /* Please keep this table alpha-sorted for ease of visual lookup. */
12703 switch (filedata
->file_header
.e_machine
)
12706 return reloc_type
== 33; /* R_RISCV_ADD8. */
12712 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12713 a 8-bit inplace sub RELA relocation used in DWARF debug sections. */
12716 is_8bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12718 /* Please keep this table alpha-sorted for ease of visual lookup. */
12719 switch (filedata
->file_header
.e_machine
)
12722 return reloc_type
== 37; /* R_RISCV_SUB8. */
12728 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
12729 relocation entries (possibly formerly used for SHT_GROUP sections). */
12732 is_none_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12734 switch (filedata
->file_header
.e_machine
)
12736 case EM_386
: /* R_386_NONE. */
12737 case EM_68K
: /* R_68K_NONE. */
12738 case EM_ADAPTEVA_EPIPHANY
:
12739 case EM_ALPHA
: /* R_ALPHA_NONE. */
12740 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
12741 case EM_ARC
: /* R_ARC_NONE. */
12742 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
12743 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
12744 case EM_ARM
: /* R_ARM_NONE. */
12745 case EM_C166
: /* R_XC16X_NONE. */
12746 case EM_CRIS
: /* R_CRIS_NONE. */
12747 case EM_FT32
: /* R_FT32_NONE. */
12748 case EM_IA_64
: /* R_IA64_NONE. */
12749 case EM_K1OM
: /* R_X86_64_NONE. */
12750 case EM_L1OM
: /* R_X86_64_NONE. */
12751 case EM_M32R
: /* R_M32R_NONE. */
12752 case EM_MIPS
: /* R_MIPS_NONE. */
12753 case EM_MN10300
: /* R_MN10300_NONE. */
12754 case EM_MOXIE
: /* R_MOXIE_NONE. */
12755 case EM_NIOS32
: /* R_NIOS_NONE. */
12756 case EM_OR1K
: /* R_OR1K_NONE. */
12757 case EM_PARISC
: /* R_PARISC_NONE. */
12758 case EM_PPC64
: /* R_PPC64_NONE. */
12759 case EM_PPC
: /* R_PPC_NONE. */
12760 case EM_RISCV
: /* R_RISCV_NONE. */
12761 case EM_S390
: /* R_390_NONE. */
12763 case EM_SH
: /* R_SH_NONE. */
12764 case EM_SPARC32PLUS
:
12765 case EM_SPARC
: /* R_SPARC_NONE. */
12767 case EM_TILEGX
: /* R_TILEGX_NONE. */
12768 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
12769 case EM_TI_C6000
:/* R_C6000_NONE. */
12770 case EM_X86_64
: /* R_X86_64_NONE. */
12772 case EM_WEBASSEMBLY
: /* R_WASM32_NONE. */
12773 return reloc_type
== 0;
12776 return reloc_type
== 0 || reloc_type
== 256;
12779 return (reloc_type
== 0 /* R_AVR_NONE. */
12780 || reloc_type
== 30 /* R_AVR_DIFF8. */
12781 || reloc_type
== 31 /* R_AVR_DIFF16. */
12782 || reloc_type
== 32 /* R_AVR_DIFF32. */);
12784 return reloc_type
== 3; /* R_METAG_NONE. */
12786 return (reloc_type
== 0 /* R_XTENSA_NONE. */
12787 || reloc_type
== 204 /* R_NDS32_DIFF8. */
12788 || reloc_type
== 205 /* R_NDS32_DIFF16. */
12789 || reloc_type
== 206 /* R_NDS32_DIFF32. */
12790 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
12792 return (reloc_type
== 0 /* R_PRU_NONE. */
12793 || reloc_type
== 65 /* R_PRU_DIFF8. */
12794 || reloc_type
== 66 /* R_PRU_DIFF16. */
12795 || reloc_type
== 67 /* R_PRU_DIFF32. */);
12796 case EM_XTENSA_OLD
:
12798 return (reloc_type
== 0 /* R_XTENSA_NONE. */
12799 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
12800 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
12801 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
12806 /* Returns TRUE if there is a relocation against
12807 section NAME at OFFSET bytes. */
12810 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
12812 Elf_Internal_Rela
* relocs
;
12813 Elf_Internal_Rela
* rp
;
12815 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
12818 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
12820 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
12821 if (rp
->r_offset
== offset
)
12827 /* Apply relocations to a section.
12828 Returns TRUE upon success, FALSE otherwise.
12829 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
12830 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
12831 will be set to the number of relocs loaded.
12833 Note: So far support has been added only for those relocations
12834 which can be found in debug sections. FIXME: Add support for
12835 more relocations ? */
12838 apply_relocations (Filedata
* filedata
,
12839 const Elf_Internal_Shdr
* section
,
12840 unsigned char * start
,
12841 bfd_size_type size
,
12842 void ** relocs_return
,
12843 unsigned long * num_relocs_return
)
12845 Elf_Internal_Shdr
* relsec
;
12846 unsigned char * end
= start
+ size
;
12847 bfd_boolean res
= TRUE
;
12849 if (relocs_return
!= NULL
)
12851 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
12852 * num_relocs_return
= 0;
12855 if (filedata
->file_header
.e_type
!= ET_REL
)
12856 /* No relocs to apply. */
12859 /* Find the reloc section associated with the section. */
12860 for (relsec
= filedata
->section_headers
;
12861 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
12864 bfd_boolean is_rela
;
12865 unsigned long num_relocs
;
12866 Elf_Internal_Rela
* relocs
;
12867 Elf_Internal_Rela
* rp
;
12868 Elf_Internal_Shdr
* symsec
;
12869 Elf_Internal_Sym
* symtab
;
12870 unsigned long num_syms
;
12871 Elf_Internal_Sym
* sym
;
12873 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
12874 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
12875 || filedata
->section_headers
+ relsec
->sh_info
!= section
12876 || relsec
->sh_size
== 0
12877 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
12880 is_rela
= relsec
->sh_type
== SHT_RELA
;
12884 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
,
12885 relsec
->sh_size
, & relocs
, & num_relocs
))
12890 if (!slurp_rel_relocs (filedata
, relsec
->sh_offset
,
12891 relsec
->sh_size
, & relocs
, & num_relocs
))
12895 /* SH uses RELA but uses in place value instead of the addend field. */
12896 if (filedata
->file_header
.e_machine
== EM_SH
)
12899 symsec
= filedata
->section_headers
+ relsec
->sh_link
;
12900 if (symsec
->sh_type
!= SHT_SYMTAB
12901 && symsec
->sh_type
!= SHT_DYNSYM
)
12903 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & num_syms
);
12905 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
12908 unsigned int reloc_type
;
12909 unsigned int reloc_size
;
12910 bfd_boolean reloc_inplace
= FALSE
;
12911 bfd_boolean reloc_subtract
= FALSE
;
12912 unsigned char * rloc
;
12913 unsigned long sym_index
;
12915 reloc_type
= get_reloc_type (filedata
, rp
->r_info
);
12917 if (target_specific_reloc_handling (filedata
, rp
, start
, end
, symtab
, num_syms
))
12919 else if (is_none_reloc (filedata
, reloc_type
))
12921 else if (is_32bit_abs_reloc (filedata
, reloc_type
)
12922 || is_32bit_pcrel_reloc (filedata
, reloc_type
))
12924 else if (is_64bit_abs_reloc (filedata
, reloc_type
)
12925 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
12927 else if (is_24bit_abs_reloc (filedata
, reloc_type
))
12929 else if (is_16bit_abs_reloc (filedata
, reloc_type
))
12931 else if ((reloc_subtract
= is_32bit_inplace_sub_reloc (filedata
,
12933 || is_32bit_inplace_add_reloc (filedata
, reloc_type
))
12936 reloc_inplace
= TRUE
;
12938 else if ((reloc_subtract
= is_64bit_inplace_sub_reloc (filedata
,
12940 || is_64bit_inplace_add_reloc (filedata
, reloc_type
))
12943 reloc_inplace
= TRUE
;
12945 else if ((reloc_subtract
= is_16bit_inplace_sub_reloc (filedata
,
12947 || is_16bit_inplace_add_reloc (filedata
, reloc_type
))
12950 reloc_inplace
= TRUE
;
12952 else if ((reloc_subtract
= is_8bit_inplace_sub_reloc (filedata
,
12954 || is_8bit_inplace_add_reloc (filedata
, reloc_type
))
12957 reloc_inplace
= TRUE
;
12961 static unsigned int prev_reloc
= 0;
12963 if (reloc_type
!= prev_reloc
)
12964 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
12965 reloc_type
, printable_section_name (filedata
, section
));
12966 prev_reloc
= reloc_type
;
12971 rloc
= start
+ rp
->r_offset
;
12972 if ((rloc
+ reloc_size
) > end
|| (rloc
< start
))
12974 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
12975 (unsigned long) rp
->r_offset
,
12976 printable_section_name (filedata
, section
));
12981 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
12982 if (sym_index
>= num_syms
)
12984 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
12985 sym_index
, printable_section_name (filedata
, section
));
12989 sym
= symtab
+ sym_index
;
12991 /* If the reloc has a symbol associated with it,
12992 make sure that it is of an appropriate type.
12994 Relocations against symbols without type can happen.
12995 Gcc -feliminate-dwarf2-dups may generate symbols
12996 without type for debug info.
12998 Icc generates relocations against function symbols
12999 instead of local labels.
13001 Relocations against object symbols can happen, eg when
13002 referencing a global array. For an example of this see
13003 the _clz.o binary in libgcc.a. */
13005 && ELF_ST_TYPE (sym
->st_info
) != STT_COMMON
13006 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
13008 warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
13009 get_symbol_type (filedata
, ELF_ST_TYPE (sym
->st_info
)),
13010 printable_section_name (filedata
, relsec
),
13011 (long int)(rp
- relocs
));
13018 addend
+= rp
->r_addend
;
13019 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
13020 partial_inplace. */
13022 || (filedata
->file_header
.e_machine
== EM_XTENSA
13023 && reloc_type
== 1)
13024 || ((filedata
->file_header
.e_machine
== EM_PJ
13025 || filedata
->file_header
.e_machine
== EM_PJ_OLD
)
13026 && reloc_type
== 1)
13027 || ((filedata
->file_header
.e_machine
== EM_D30V
13028 || filedata
->file_header
.e_machine
== EM_CYGNUS_D30V
)
13029 && reloc_type
== 12)
13031 addend
+= byte_get (rloc
, reloc_size
);
13033 if (is_32bit_pcrel_reloc (filedata
, reloc_type
)
13034 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
13036 /* On HPPA, all pc-relative relocations are biased by 8. */
13037 if (filedata
->file_header
.e_machine
== EM_PARISC
)
13039 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
13042 else if (reloc_subtract
)
13043 byte_put (rloc
, addend
- sym
->st_value
, reloc_size
);
13045 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
13049 /* Let the target specific reloc processing code know that
13050 we have finished with these relocs. */
13051 target_specific_reloc_handling (filedata
, NULL
, NULL
, NULL
, NULL
, 0);
13055 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
13056 * num_relocs_return
= num_relocs
;
13067 #ifdef SUPPORT_DISASSEMBLY
13069 disassemble_section (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13071 printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata
, section
));
13073 /* FIXME: XXX -- to be done --- XXX */
13079 /* Reads in the contents of SECTION from FILE, returning a pointer
13080 to a malloc'ed buffer or NULL if something went wrong. */
13083 get_section_contents (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13085 bfd_size_type num_bytes
= section
->sh_size
;
13087 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
13089 printf (_("Section '%s' has no data to dump.\n"),
13090 printable_section_name (filedata
, section
));
13094 return (char *) get_data (NULL
, filedata
, section
->sh_offset
, 1, num_bytes
,
13095 _("section contents"));
13098 /* Uncompresses a section that was compressed using zlib, in place. */
13101 uncompress_section_contents (unsigned char ** buffer
,
13102 dwarf_size_type uncompressed_size
,
13103 dwarf_size_type
* size
)
13105 dwarf_size_type compressed_size
= *size
;
13106 unsigned char * compressed_buffer
= *buffer
;
13107 unsigned char * uncompressed_buffer
;
13111 /* It is possible the section consists of several compressed
13112 buffers concatenated together, so we uncompress in a loop. */
13113 /* PR 18313: The state field in the z_stream structure is supposed
13114 to be invisible to the user (ie us), but some compilers will
13115 still complain about it being used without initialisation. So
13116 we first zero the entire z_stream structure and then set the fields
13118 memset (& strm
, 0, sizeof strm
);
13119 strm
.avail_in
= compressed_size
;
13120 strm
.next_in
= (Bytef
*) compressed_buffer
;
13121 strm
.avail_out
= uncompressed_size
;
13122 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
13124 rc
= inflateInit (& strm
);
13125 while (strm
.avail_in
> 0)
13129 strm
.next_out
= ((Bytef
*) uncompressed_buffer
13130 + (uncompressed_size
- strm
.avail_out
));
13131 rc
= inflate (&strm
, Z_FINISH
);
13132 if (rc
!= Z_STREAM_END
)
13134 rc
= inflateReset (& strm
);
13136 rc
= inflateEnd (& strm
);
13138 || strm
.avail_out
!= 0)
13141 *buffer
= uncompressed_buffer
;
13142 *size
= uncompressed_size
;
13146 free (uncompressed_buffer
);
13147 /* Indicate decompression failure. */
13153 dump_section_as_strings (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13155 Elf_Internal_Shdr
* relsec
;
13156 bfd_size_type num_bytes
;
13157 unsigned char * data
;
13158 unsigned char * end
;
13159 unsigned char * real_start
;
13160 unsigned char * start
;
13161 bfd_boolean some_strings_shown
;
13163 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
13165 /* PR 21820: Do not fail if the section was empty. */
13166 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
13168 num_bytes
= section
->sh_size
;
13170 printf (_("\nString dump of section '%s':\n"), printable_section_name (filedata
, section
));
13172 if (decompress_dumps
)
13174 dwarf_size_type new_size
= num_bytes
;
13175 dwarf_size_type uncompressed_size
= 0;
13177 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
13179 Elf_Internal_Chdr chdr
;
13180 unsigned int compression_header_size
13181 = get_compression_header (& chdr
, (unsigned char *) start
,
13184 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13186 warn (_("section '%s' has unsupported compress type: %d\n"),
13187 printable_section_name (filedata
, section
), chdr
.ch_type
);
13190 else if (chdr
.ch_addralign
!= section
->sh_addralign
)
13192 warn (_("compressed section '%s' is corrupted\n"),
13193 printable_section_name (filedata
, section
));
13196 uncompressed_size
= chdr
.ch_size
;
13197 start
+= compression_header_size
;
13198 new_size
-= compression_header_size
;
13200 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
13202 /* Read the zlib header. In this case, it should be "ZLIB"
13203 followed by the uncompressed section size, 8 bytes in
13204 big-endian order. */
13205 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13206 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13207 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13208 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13209 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13210 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13211 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13212 uncompressed_size
+= start
[11];
13217 if (uncompressed_size
)
13219 if (uncompress_section_contents (& start
,
13220 uncompressed_size
, & new_size
))
13221 num_bytes
= new_size
;
13224 error (_("Unable to decompress section %s\n"),
13225 printable_section_name (filedata
, section
));
13230 start
= real_start
;
13233 /* If the section being dumped has relocations against it the user might
13234 be expecting these relocations to have been applied. Check for this
13235 case and issue a warning message in order to avoid confusion.
13236 FIXME: Maybe we ought to have an option that dumps a section with
13237 relocs applied ? */
13238 for (relsec
= filedata
->section_headers
;
13239 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13242 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13243 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13244 || filedata
->section_headers
+ relsec
->sh_info
!= section
13245 || relsec
->sh_size
== 0
13246 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13249 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13254 end
= start
+ num_bytes
;
13255 some_strings_shown
= FALSE
;
13259 while (!ISPRINT (* data
))
13260 if (++ data
>= end
)
13265 size_t maxlen
= end
- data
;
13268 /* PR 11128: Use two separate invocations in order to work
13269 around bugs in the Solaris 8 implementation of printf. */
13270 printf (" [%6tx] ", data
- start
);
13272 printf (" [%6Ix] ", (size_t) (data
- start
));
13276 print_symbol ((int) maxlen
, (const char *) data
);
13278 data
+= strnlen ((const char *) data
, maxlen
);
13282 printf (_("<corrupt>\n"));
13285 some_strings_shown
= TRUE
;
13289 if (! some_strings_shown
)
13290 printf (_(" No strings found in this section."));
13299 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
13300 Filedata
* filedata
,
13301 bfd_boolean relocate
)
13303 Elf_Internal_Shdr
* relsec
;
13304 bfd_size_type bytes
;
13305 bfd_size_type section_size
;
13307 unsigned char * data
;
13308 unsigned char * real_start
;
13309 unsigned char * start
;
13311 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
13313 /* PR 21820: Do not fail if the section was empty. */
13314 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
13316 section_size
= section
->sh_size
;
13318 printf (_("\nHex dump of section '%s':\n"), printable_section_name (filedata
, section
));
13320 if (decompress_dumps
)
13322 dwarf_size_type new_size
= section_size
;
13323 dwarf_size_type uncompressed_size
= 0;
13325 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
13327 Elf_Internal_Chdr chdr
;
13328 unsigned int compression_header_size
13329 = get_compression_header (& chdr
, start
, section_size
);
13331 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13333 warn (_("section '%s' has unsupported compress type: %d\n"),
13334 printable_section_name (filedata
, section
), chdr
.ch_type
);
13337 else if (chdr
.ch_addralign
!= section
->sh_addralign
)
13339 warn (_("compressed section '%s' is corrupted\n"),
13340 printable_section_name (filedata
, section
));
13343 uncompressed_size
= chdr
.ch_size
;
13344 start
+= compression_header_size
;
13345 new_size
-= compression_header_size
;
13347 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
13349 /* Read the zlib header. In this case, it should be "ZLIB"
13350 followed by the uncompressed section size, 8 bytes in
13351 big-endian order. */
13352 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13353 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13354 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13355 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13356 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13357 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13358 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13359 uncompressed_size
+= start
[11];
13364 if (uncompressed_size
)
13366 if (uncompress_section_contents (& start
, uncompressed_size
,
13369 section_size
= new_size
;
13373 error (_("Unable to decompress section %s\n"),
13374 printable_section_name (filedata
, section
));
13375 /* FIXME: Print the section anyway ? */
13380 start
= real_start
;
13385 if (! apply_relocations (filedata
, section
, start
, section_size
, NULL
, NULL
))
13390 /* If the section being dumped has relocations against it the user might
13391 be expecting these relocations to have been applied. Check for this
13392 case and issue a warning message in order to avoid confusion.
13393 FIXME: Maybe we ought to have an option that dumps a section with
13394 relocs applied ? */
13395 for (relsec
= filedata
->section_headers
;
13396 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13399 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13400 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13401 || filedata
->section_headers
+ relsec
->sh_info
!= section
13402 || relsec
->sh_size
== 0
13403 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13406 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13411 addr
= section
->sh_addr
;
13412 bytes
= section_size
;
13421 lbytes
= (bytes
> 16 ? 16 : bytes
);
13423 printf (" 0x%8.8lx ", (unsigned long) addr
);
13425 for (j
= 0; j
< 16; j
++)
13428 printf ("%2.2x", data
[j
]);
13436 for (j
= 0; j
< lbytes
; j
++)
13439 if (k
>= ' ' && k
< 0x7f)
13459 load_specific_debug_section (enum dwarf_section_display_enum debug
,
13460 const Elf_Internal_Shdr
* sec
,
13463 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13465 Filedata
* filedata
= (Filedata
*) data
;
13467 if (section
->start
!= NULL
)
13469 /* If it is already loaded, do nothing. */
13470 if (streq (section
->filename
, filedata
->file_name
))
13472 free (section
->start
);
13475 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
13476 section
->address
= sec
->sh_addr
;
13477 section
->user_data
= NULL
;
13478 section
->filename
= filedata
->file_name
;
13479 section
->start
= (unsigned char *) get_data (NULL
, filedata
,
13481 sec
->sh_size
, buf
);
13482 if (section
->start
== NULL
)
13486 unsigned char *start
= section
->start
;
13487 dwarf_size_type size
= sec
->sh_size
;
13488 dwarf_size_type uncompressed_size
= 0;
13490 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
13492 Elf_Internal_Chdr chdr
;
13493 unsigned int compression_header_size
;
13495 if (size
< (is_32bit_elf
13496 ? sizeof (Elf32_External_Chdr
)
13497 : sizeof (Elf64_External_Chdr
)))
13499 warn (_("compressed section %s is too small to contain a compression header"),
13504 compression_header_size
= get_compression_header (&chdr
, start
, size
);
13506 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13508 warn (_("section '%s' has unsupported compress type: %d\n"),
13509 section
->name
, chdr
.ch_type
);
13512 else if (chdr
.ch_addralign
!= sec
->sh_addralign
)
13514 warn (_("compressed section '%s' is corrupted\n"),
13518 uncompressed_size
= chdr
.ch_size
;
13519 start
+= compression_header_size
;
13520 size
-= compression_header_size
;
13522 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
13524 /* Read the zlib header. In this case, it should be "ZLIB"
13525 followed by the uncompressed section size, 8 bytes in
13526 big-endian order. */
13527 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13528 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13529 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13530 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13531 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13532 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13533 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13534 uncompressed_size
+= start
[11];
13539 if (uncompressed_size
)
13541 if (uncompress_section_contents (&start
, uncompressed_size
,
13544 /* Free the compressed buffer, update the section buffer
13545 and the section size if uncompress is successful. */
13546 free (section
->start
);
13547 section
->start
= start
;
13551 error (_("Unable to decompress section %s\n"),
13552 printable_section_name (filedata
, sec
));
13557 section
->size
= size
;
13560 if (section
->start
== NULL
)
13563 if (debug_displays
[debug
].relocate
)
13565 if (! apply_relocations (filedata
, sec
, section
->start
, section
->size
,
13566 & section
->reloc_info
, & section
->num_relocs
))
13571 section
->reloc_info
= NULL
;
13572 section
->num_relocs
= 0;
13578 /* If this is not NULL, load_debug_section will only look for sections
13579 within the list of sections given here. */
13580 static unsigned int * section_subset
= NULL
;
13583 load_debug_section (enum dwarf_section_display_enum debug
, void * data
)
13585 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13586 Elf_Internal_Shdr
* sec
;
13587 Filedata
* filedata
= (Filedata
*) data
;
13589 /* Without section headers we cannot find any sections. */
13590 if (filedata
->section_headers
== NULL
)
13593 if (filedata
->string_table
== NULL
13594 && filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
13595 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
13597 Elf_Internal_Shdr
* strs
;
13599 /* Read in the string table, so that we have section names to scan. */
13600 strs
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
13602 if (strs
!= NULL
&& strs
->sh_size
!= 0)
13604 filedata
->string_table
13605 = (char *) get_data (NULL
, filedata
, strs
->sh_offset
,
13606 1, strs
->sh_size
, _("string table"));
13608 filedata
->string_table_length
13609 = filedata
->string_table
!= NULL
? strs
->sh_size
: 0;
13613 /* Locate the debug section. */
13614 sec
= find_section_in_set (filedata
, section
->uncompressed_name
, section_subset
);
13616 section
->name
= section
->uncompressed_name
;
13619 sec
= find_section_in_set (filedata
, section
->compressed_name
, section_subset
);
13621 section
->name
= section
->compressed_name
;
13626 /* If we're loading from a subset of sections, and we've loaded
13627 a section matching this name before, it's likely that it's a
13629 if (section_subset
!= NULL
)
13630 free_debug_section (debug
);
13632 return load_specific_debug_section (debug
, sec
, data
);
13636 free_debug_section (enum dwarf_section_display_enum debug
)
13638 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13640 if (section
->start
== NULL
)
13643 free ((char *) section
->start
);
13644 section
->start
= NULL
;
13645 section
->address
= 0;
13650 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13652 char * name
= SECTION_NAME (section
);
13653 const char * print_name
= printable_section_name (filedata
, section
);
13654 bfd_size_type length
;
13655 bfd_boolean result
= TRUE
;
13658 length
= section
->sh_size
;
13661 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
13664 if (section
->sh_type
== SHT_NOBITS
)
13666 /* There is no point in dumping the contents of a debugging section
13667 which has the NOBITS type - the bits in the file will be random.
13668 This can happen when a file containing a .eh_frame section is
13669 stripped with the --only-keep-debug command line option. */
13670 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
13675 if (const_strneq (name
, ".gnu.linkonce.wi."))
13676 name
= ".debug_info";
13678 /* See if we know how to display the contents of this section. */
13679 for (i
= 0; i
< max
; i
++)
13681 enum dwarf_section_display_enum id
= (enum dwarf_section_display_enum
) i
;
13682 struct dwarf_section_display
* display
= debug_displays
+ i
;
13683 struct dwarf_section
* sec
= & display
->section
;
13685 if (streq (sec
->uncompressed_name
, name
)
13686 || (id
== line
&& const_strneq (name
, ".debug_line."))
13687 || streq (sec
->compressed_name
, name
))
13689 bfd_boolean secondary
= (section
!= find_section (filedata
, name
));
13692 free_debug_section (id
);
13694 if (i
== line
&& const_strneq (name
, ".debug_line."))
13696 else if (streq (sec
->uncompressed_name
, name
))
13697 sec
->name
= sec
->uncompressed_name
;
13699 sec
->name
= sec
->compressed_name
;
13701 if (load_specific_debug_section (id
, section
, filedata
))
13703 /* If this debug section is part of a CU/TU set in a .dwp file,
13704 restrict load_debug_section to the sections in that set. */
13705 section_subset
= find_cu_tu_set (filedata
, shndx
);
13707 result
&= display
->display (sec
, filedata
);
13709 section_subset
= NULL
;
13711 if (secondary
|| (id
!= info
&& id
!= abbrev
))
13712 free_debug_section (id
);
13720 printf (_("Unrecognized debug section: %s\n"), print_name
);
13727 /* Set DUMP_SECTS for all sections where dumps were requested
13728 based on section name. */
13731 initialise_dumps_byname (Filedata
* filedata
)
13733 struct dump_list_entry
* cur
;
13735 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
13738 bfd_boolean any
= FALSE
;
13740 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
13741 if (streq (SECTION_NAME (filedata
->section_headers
+ i
), cur
->name
))
13743 request_dump_bynumber (filedata
, i
, cur
->type
);
13748 warn (_("Section '%s' was not dumped because it does not exist!\n"),
13754 process_section_contents (Filedata
* filedata
)
13756 Elf_Internal_Shdr
* section
;
13758 bfd_boolean res
= TRUE
;
13763 initialise_dumps_byname (filedata
);
13765 for (i
= 0, section
= filedata
->section_headers
;
13766 i
< filedata
->file_header
.e_shnum
&& i
< filedata
->num_dump_sects
;
13769 dump_type dump
= filedata
->dump_sects
[i
];
13771 #ifdef SUPPORT_DISASSEMBLY
13772 if (dump
& DISASS_DUMP
)
13774 if (! disassemble_section (section
, filedata
))
13778 if (dump
& HEX_DUMP
)
13780 if (! dump_section_as_bytes (section
, filedata
, FALSE
))
13784 if (dump
& RELOC_DUMP
)
13786 if (! dump_section_as_bytes (section
, filedata
, TRUE
))
13790 if (dump
& STRING_DUMP
)
13792 if (! dump_section_as_strings (section
, filedata
))
13796 if (dump
& DEBUG_DUMP
)
13798 if (! display_debug_section (i
, section
, filedata
))
13803 /* Check to see if the user requested a
13804 dump of a section that does not exist. */
13805 while (i
< filedata
->num_dump_sects
)
13807 if (filedata
->dump_sects
[i
])
13809 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
13819 process_mips_fpe_exception (int mask
)
13823 bfd_boolean first
= TRUE
;
13825 if (mask
& OEX_FPU_INEX
)
13826 fputs ("INEX", stdout
), first
= FALSE
;
13827 if (mask
& OEX_FPU_UFLO
)
13828 printf ("%sUFLO", first
? "" : "|"), first
= FALSE
;
13829 if (mask
& OEX_FPU_OFLO
)
13830 printf ("%sOFLO", first
? "" : "|"), first
= FALSE
;
13831 if (mask
& OEX_FPU_DIV0
)
13832 printf ("%sDIV0", first
? "" : "|"), first
= FALSE
;
13833 if (mask
& OEX_FPU_INVAL
)
13834 printf ("%sINVAL", first
? "" : "|");
13837 fputs ("0", stdout
);
13840 /* Display's the value of TAG at location P. If TAG is
13841 greater than 0 it is assumed to be an unknown tag, and
13842 a message is printed to this effect. Otherwise it is
13843 assumed that a message has already been printed.
13845 If the bottom bit of TAG is set it assumed to have a
13846 string value, otherwise it is assumed to have an integer
13849 Returns an updated P pointing to the first unread byte
13850 beyond the end of TAG's value.
13852 Reads at or beyond END will not be made. */
13854 static unsigned char *
13855 display_tag_value (signed int tag
,
13857 const unsigned char * const end
)
13862 printf (" Tag_unknown_%d: ", tag
);
13866 warn (_("<corrupt tag>\n"));
13870 /* PR 17531 file: 027-19978-0.004. */
13871 size_t maxlen
= (end
- p
) - 1;
13876 print_symbol ((int) maxlen
, (const char *) p
);
13877 p
+= strnlen ((char *) p
, maxlen
) + 1;
13881 printf (_("<corrupt string tag>"));
13882 p
= (unsigned char *) end
;
13890 val
= read_uleb128 (p
, &len
, end
);
13892 printf ("%ld (0x%lx)\n", val
, val
);
13899 /* ARC ABI attributes section. */
13901 static unsigned char *
13902 display_arc_attribute (unsigned char * p
,
13903 const unsigned char * const end
)
13909 tag
= read_uleb128 (p
, &len
, end
);
13914 case Tag_ARC_PCS_config
:
13915 val
= read_uleb128 (p
, &len
, end
);
13917 printf (" Tag_ARC_PCS_config: ");
13921 printf (_("Absent/Non standard\n"));
13924 printf (_("Bare metal/mwdt\n"));
13927 printf (_("Bare metal/newlib\n"));
13930 printf (_("Linux/uclibc\n"));
13933 printf (_("Linux/glibc\n"));
13936 printf (_("Unknown\n"));
13941 case Tag_ARC_CPU_base
:
13942 val
= read_uleb128 (p
, &len
, end
);
13944 printf (" Tag_ARC_CPU_base: ");
13949 printf (_("Absent\n"));
13951 case TAG_CPU_ARC6xx
:
13952 printf ("ARC6xx\n");
13954 case TAG_CPU_ARC7xx
:
13955 printf ("ARC7xx\n");
13957 case TAG_CPU_ARCEM
:
13958 printf ("ARCEM\n");
13960 case TAG_CPU_ARCHS
:
13961 printf ("ARCHS\n");
13966 case Tag_ARC_CPU_variation
:
13967 val
= read_uleb128 (p
, &len
, end
);
13969 printf (" Tag_ARC_CPU_variation: ");
13973 if (val
> 0 && val
< 16)
13974 printf ("Core%d\n", val
);
13976 printf ("Unknown\n");
13980 printf (_("Absent\n"));
13985 case Tag_ARC_CPU_name
:
13986 printf (" Tag_ARC_CPU_name: ");
13987 p
= display_tag_value (-1, p
, end
);
13990 case Tag_ARC_ABI_rf16
:
13991 val
= read_uleb128 (p
, &len
, end
);
13993 printf (" Tag_ARC_ABI_rf16: %s\n", val
? _("yes") : _("no"));
13996 case Tag_ARC_ABI_osver
:
13997 val
= read_uleb128 (p
, &len
, end
);
13999 printf (" Tag_ARC_ABI_osver: v%d\n", val
);
14002 case Tag_ARC_ABI_pic
:
14003 case Tag_ARC_ABI_sda
:
14004 val
= read_uleb128 (p
, &len
, end
);
14006 printf (tag
== Tag_ARC_ABI_sda
? " Tag_ARC_ABI_sda: "
14007 : " Tag_ARC_ABI_pic: ");
14011 printf (_("Absent\n"));
14020 printf (_("Unknown\n"));
14025 case Tag_ARC_ABI_tls
:
14026 val
= read_uleb128 (p
, &len
, end
);
14028 printf (" Tag_ARC_ABI_tls: %s\n", val
? "r25": "none");
14031 case Tag_ARC_ABI_enumsize
:
14032 val
= read_uleb128 (p
, &len
, end
);
14034 printf (" Tag_ARC_ABI_enumsize: %s\n", val
? _("default") :
14038 case Tag_ARC_ABI_exceptions
:
14039 val
= read_uleb128 (p
, &len
, end
);
14041 printf (" Tag_ARC_ABI_exceptions: %s\n", val
? _("OPTFP")
14045 case Tag_ARC_ABI_double_size
:
14046 val
= read_uleb128 (p
, &len
, end
);
14048 printf (" Tag_ARC_ABI_double_size: %d\n", val
);
14051 case Tag_ARC_ISA_config
:
14052 printf (" Tag_ARC_ISA_config: ");
14053 p
= display_tag_value (-1, p
, end
);
14056 case Tag_ARC_ISA_apex
:
14057 printf (" Tag_ARC_ISA_apex: ");
14058 p
= display_tag_value (-1, p
, end
);
14061 case Tag_ARC_ISA_mpy_option
:
14062 val
= read_uleb128 (p
, &len
, end
);
14064 printf (" Tag_ARC_ISA_mpy_option: %d\n", val
);
14068 return display_tag_value (tag
& 1, p
, end
);
14074 /* ARM EABI attributes section. */
14079 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
14081 const char ** table
;
14082 } arm_attr_public_tag
;
14084 static const char * arm_attr_tag_CPU_arch
[] =
14085 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
14086 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
14088 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
14089 static const char * arm_attr_tag_THUMB_ISA_use
[] =
14090 {"No", "Thumb-1", "Thumb-2", "Yes"};
14091 static const char * arm_attr_tag_FP_arch
[] =
14092 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
14093 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
14094 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
14095 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
14096 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
14097 "NEON for ARMv8.1"};
14098 static const char * arm_attr_tag_PCS_config
[] =
14099 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
14100 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
14101 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
14102 {"V6", "SB", "TLS", "Unused"};
14103 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
14104 {"Absolute", "PC-relative", "SB-relative", "None"};
14105 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
14106 {"Absolute", "PC-relative", "None"};
14107 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
14108 {"None", "direct", "GOT-indirect"};
14109 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
14110 {"None", "??? 1", "2", "??? 3", "4"};
14111 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
14112 static const char * arm_attr_tag_ABI_FP_denormal
[] =
14113 {"Unused", "Needed", "Sign only"};
14114 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
14115 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
14116 static const char * arm_attr_tag_ABI_FP_number_model
[] =
14117 {"Unused", "Finite", "RTABI", "IEEE 754"};
14118 static const char * arm_attr_tag_ABI_enum_size
[] =
14119 {"Unused", "small", "int", "forced to int"};
14120 static const char * arm_attr_tag_ABI_HardFP_use
[] =
14121 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
14122 static const char * arm_attr_tag_ABI_VFP_args
[] =
14123 {"AAPCS", "VFP registers", "custom", "compatible"};
14124 static const char * arm_attr_tag_ABI_WMMX_args
[] =
14125 {"AAPCS", "WMMX registers", "custom"};
14126 static const char * arm_attr_tag_ABI_optimization_goals
[] =
14127 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14128 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
14129 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
14130 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14131 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
14132 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
14133 static const char * arm_attr_tag_FP_HP_extension
[] =
14134 {"Not Allowed", "Allowed"};
14135 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
14136 {"None", "IEEE 754", "Alternative Format"};
14137 static const char * arm_attr_tag_DSP_extension
[] =
14138 {"Follow architecture", "Allowed"};
14139 static const char * arm_attr_tag_MPextension_use
[] =
14140 {"Not Allowed", "Allowed"};
14141 static const char * arm_attr_tag_DIV_use
[] =
14142 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
14143 "Allowed in v7-A with integer division extension"};
14144 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
14145 static const char * arm_attr_tag_Virtualization_use
[] =
14146 {"Not Allowed", "TrustZone", "Virtualization Extensions",
14147 "TrustZone and Virtualization Extensions"};
14148 static const char * arm_attr_tag_MPextension_use_legacy
[] =
14149 {"Not Allowed", "Allowed"};
14151 #define LOOKUP(id, name) \
14152 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
14153 static arm_attr_public_tag arm_attr_public_tags
[] =
14155 {4, "CPU_raw_name", 1, NULL
},
14156 {5, "CPU_name", 1, NULL
},
14157 LOOKUP(6, CPU_arch
),
14158 {7, "CPU_arch_profile", 0, NULL
},
14159 LOOKUP(8, ARM_ISA_use
),
14160 LOOKUP(9, THUMB_ISA_use
),
14161 LOOKUP(10, FP_arch
),
14162 LOOKUP(11, WMMX_arch
),
14163 LOOKUP(12, Advanced_SIMD_arch
),
14164 LOOKUP(13, PCS_config
),
14165 LOOKUP(14, ABI_PCS_R9_use
),
14166 LOOKUP(15, ABI_PCS_RW_data
),
14167 LOOKUP(16, ABI_PCS_RO_data
),
14168 LOOKUP(17, ABI_PCS_GOT_use
),
14169 LOOKUP(18, ABI_PCS_wchar_t
),
14170 LOOKUP(19, ABI_FP_rounding
),
14171 LOOKUP(20, ABI_FP_denormal
),
14172 LOOKUP(21, ABI_FP_exceptions
),
14173 LOOKUP(22, ABI_FP_user_exceptions
),
14174 LOOKUP(23, ABI_FP_number_model
),
14175 {24, "ABI_align_needed", 0, NULL
},
14176 {25, "ABI_align_preserved", 0, NULL
},
14177 LOOKUP(26, ABI_enum_size
),
14178 LOOKUP(27, ABI_HardFP_use
),
14179 LOOKUP(28, ABI_VFP_args
),
14180 LOOKUP(29, ABI_WMMX_args
),
14181 LOOKUP(30, ABI_optimization_goals
),
14182 LOOKUP(31, ABI_FP_optimization_goals
),
14183 {32, "compatibility", 0, NULL
},
14184 LOOKUP(34, CPU_unaligned_access
),
14185 LOOKUP(36, FP_HP_extension
),
14186 LOOKUP(38, ABI_FP_16bit_format
),
14187 LOOKUP(42, MPextension_use
),
14188 LOOKUP(44, DIV_use
),
14189 LOOKUP(46, DSP_extension
),
14190 {64, "nodefaults", 0, NULL
},
14191 {65, "also_compatible_with", 0, NULL
},
14192 LOOKUP(66, T2EE_use
),
14193 {67, "conformance", 1, NULL
},
14194 LOOKUP(68, Virtualization_use
),
14195 LOOKUP(70, MPextension_use_legacy
)
14199 static unsigned char *
14200 display_arm_attribute (unsigned char * p
,
14201 const unsigned char * const end
)
14206 arm_attr_public_tag
* attr
;
14210 tag
= read_uleb128 (p
, &len
, end
);
14213 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
14215 if (arm_attr_public_tags
[i
].tag
== tag
)
14217 attr
= &arm_attr_public_tags
[i
];
14224 printf (" Tag_%s: ", attr
->name
);
14225 switch (attr
->type
)
14230 case 7: /* Tag_CPU_arch_profile. */
14231 val
= read_uleb128 (p
, &len
, end
);
14235 case 0: printf (_("None\n")); break;
14236 case 'A': printf (_("Application\n")); break;
14237 case 'R': printf (_("Realtime\n")); break;
14238 case 'M': printf (_("Microcontroller\n")); break;
14239 case 'S': printf (_("Application or Realtime\n")); break;
14240 default: printf ("??? (%d)\n", val
); break;
14244 case 24: /* Tag_align_needed. */
14245 val
= read_uleb128 (p
, &len
, end
);
14249 case 0: printf (_("None\n")); break;
14250 case 1: printf (_("8-byte\n")); break;
14251 case 2: printf (_("4-byte\n")); break;
14252 case 3: printf ("??? 3\n"); break;
14255 printf (_("8-byte and up to %d-byte extended\n"),
14258 printf ("??? (%d)\n", val
);
14263 case 25: /* Tag_align_preserved. */
14264 val
= read_uleb128 (p
, &len
, end
);
14268 case 0: printf (_("None\n")); break;
14269 case 1: printf (_("8-byte, except leaf SP\n")); break;
14270 case 2: printf (_("8-byte\n")); break;
14271 case 3: printf ("??? 3\n"); break;
14274 printf (_("8-byte and up to %d-byte extended\n"),
14277 printf ("??? (%d)\n", val
);
14282 case 32: /* Tag_compatibility. */
14284 val
= read_uleb128 (p
, &len
, end
);
14286 printf (_("flag = %d, vendor = "), val
);
14289 size_t maxlen
= (end
- p
) - 1;
14291 print_symbol ((int) maxlen
, (const char *) p
);
14292 p
+= strnlen ((char *) p
, maxlen
) + 1;
14296 printf (_("<corrupt>"));
14297 p
= (unsigned char *) end
;
14303 case 64: /* Tag_nodefaults. */
14304 /* PR 17531: file: 001-505008-0.01. */
14307 printf (_("True\n"));
14310 case 65: /* Tag_also_compatible_with. */
14311 val
= read_uleb128 (p
, &len
, end
);
14313 if (val
== 6 /* Tag_CPU_arch. */)
14315 val
= read_uleb128 (p
, &len
, end
);
14317 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
14318 printf ("??? (%d)\n", val
);
14320 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
14324 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
14329 printf (_("<unknown: %d>\n"), tag
);
14335 return display_tag_value (-1, p
, end
);
14337 return display_tag_value (0, p
, end
);
14340 assert (attr
->type
& 0x80);
14341 val
= read_uleb128 (p
, &len
, end
);
14343 type
= attr
->type
& 0x7f;
14345 printf ("??? (%d)\n", val
);
14347 printf ("%s\n", attr
->table
[val
]);
14352 return display_tag_value (tag
, p
, end
);
14355 static unsigned char *
14356 display_gnu_attribute (unsigned char * p
,
14357 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const),
14358 const unsigned char * const end
)
14364 tag
= read_uleb128 (p
, &len
, end
);
14367 /* Tag_compatibility is the only generic GNU attribute defined at
14371 val
= read_uleb128 (p
, &len
, end
);
14374 printf (_("flag = %d, vendor = "), val
);
14377 printf (_("<corrupt>\n"));
14378 warn (_("corrupt vendor attribute\n"));
14384 size_t maxlen
= (end
- p
) - 1;
14386 print_symbol ((int) maxlen
, (const char *) p
);
14387 p
+= strnlen ((char *) p
, maxlen
) + 1;
14391 printf (_("<corrupt>"));
14392 p
= (unsigned char *) end
;
14399 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
14400 return display_proc_gnu_attribute (p
, tag
, end
);
14402 return display_tag_value (tag
, p
, end
);
14405 static unsigned char *
14406 display_power_gnu_attribute (unsigned char * p
,
14408 const unsigned char * const end
)
14413 if (tag
== Tag_GNU_Power_ABI_FP
)
14415 val
= read_uleb128 (p
, &len
, end
);
14417 printf (" Tag_GNU_Power_ABI_FP: ");
14420 printf (_("<corrupt>\n"));
14425 printf ("(%#x), ", val
);
14430 printf (_("unspecified hard/soft float, "));
14433 printf (_("hard float, "));
14436 printf (_("soft float, "));
14439 printf (_("single-precision hard float, "));
14446 printf (_("unspecified long double\n"));
14449 printf (_("128-bit IBM long double\n"));
14452 printf (_("64-bit long double\n"));
14455 printf (_("128-bit IEEE long double\n"));
14461 if (tag
== Tag_GNU_Power_ABI_Vector
)
14463 val
= read_uleb128 (p
, &len
, end
);
14465 printf (" Tag_GNU_Power_ABI_Vector: ");
14468 printf (_("<corrupt>\n"));
14473 printf ("(%#x), ", val
);
14478 printf (_("unspecified\n"));
14481 printf (_("generic\n"));
14484 printf ("AltiVec\n");
14493 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
14495 val
= read_uleb128 (p
, &len
, end
);
14497 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
14500 printf (_("<corrupt>\n"));
14505 printf ("(%#x), ", val
);
14510 printf (_("unspecified\n"));
14513 printf ("r3/r4\n");
14516 printf (_("memory\n"));
14525 return display_tag_value (tag
& 1, p
, end
);
14528 static unsigned char *
14529 display_s390_gnu_attribute (unsigned char * p
,
14531 const unsigned char * const end
)
14536 if (tag
== Tag_GNU_S390_ABI_Vector
)
14538 val
= read_uleb128 (p
, &len
, end
);
14540 printf (" Tag_GNU_S390_ABI_Vector: ");
14545 printf (_("any\n"));
14548 printf (_("software\n"));
14551 printf (_("hardware\n"));
14554 printf ("??? (%d)\n", val
);
14560 return display_tag_value (tag
& 1, p
, end
);
14564 display_sparc_hwcaps (unsigned int mask
)
14568 bfd_boolean first
= TRUE
;
14570 if (mask
& ELF_SPARC_HWCAP_MUL32
)
14571 fputs ("mul32", stdout
), first
= FALSE
;
14572 if (mask
& ELF_SPARC_HWCAP_DIV32
)
14573 printf ("%sdiv32", first
? "" : "|"), first
= FALSE
;
14574 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
14575 printf ("%sfsmuld", first
? "" : "|"), first
= FALSE
;
14576 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
14577 printf ("%sv8plus", first
? "" : "|"), first
= FALSE
;
14578 if (mask
& ELF_SPARC_HWCAP_POPC
)
14579 printf ("%spopc", first
? "" : "|"), first
= FALSE
;
14580 if (mask
& ELF_SPARC_HWCAP_VIS
)
14581 printf ("%svis", first
? "" : "|"), first
= FALSE
;
14582 if (mask
& ELF_SPARC_HWCAP_VIS2
)
14583 printf ("%svis2", first
? "" : "|"), first
= FALSE
;
14584 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
14585 printf ("%sASIBlkInit", first
? "" : "|"), first
= FALSE
;
14586 if (mask
& ELF_SPARC_HWCAP_FMAF
)
14587 printf ("%sfmaf", first
? "" : "|"), first
= FALSE
;
14588 if (mask
& ELF_SPARC_HWCAP_VIS3
)
14589 printf ("%svis3", first
? "" : "|"), first
= FALSE
;
14590 if (mask
& ELF_SPARC_HWCAP_HPC
)
14591 printf ("%shpc", first
? "" : "|"), first
= FALSE
;
14592 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
14593 printf ("%srandom", first
? "" : "|"), first
= FALSE
;
14594 if (mask
& ELF_SPARC_HWCAP_TRANS
)
14595 printf ("%strans", first
? "" : "|"), first
= FALSE
;
14596 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
14597 printf ("%sfjfmau", first
? "" : "|"), first
= FALSE
;
14598 if (mask
& ELF_SPARC_HWCAP_IMA
)
14599 printf ("%sima", first
? "" : "|"), first
= FALSE
;
14600 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
14601 printf ("%scspare", first
? "" : "|"), first
= FALSE
;
14604 fputc ('0', stdout
);
14605 fputc ('\n', stdout
);
14609 display_sparc_hwcaps2 (unsigned int mask
)
14613 bfd_boolean first
= TRUE
;
14615 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
14616 fputs ("fjathplus", stdout
), first
= FALSE
;
14617 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
14618 printf ("%svis3b", first
? "" : "|"), first
= FALSE
;
14619 if (mask
& ELF_SPARC_HWCAP2_ADP
)
14620 printf ("%sadp", first
? "" : "|"), first
= FALSE
;
14621 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
14622 printf ("%ssparc5", first
? "" : "|"), first
= FALSE
;
14623 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
14624 printf ("%smwait", first
? "" : "|"), first
= FALSE
;
14625 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
14626 printf ("%sxmpmul", first
? "" : "|"), first
= FALSE
;
14627 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
14628 printf ("%sxmont2", first
? "" : "|"), first
= FALSE
;
14629 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
14630 printf ("%snsec", first
? "" : "|"), first
= FALSE
;
14631 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
14632 printf ("%sfjathhpc", first
? "" : "|"), first
= FALSE
;
14633 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
14634 printf ("%sfjdes", first
? "" : "|"), first
= FALSE
;
14635 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
14636 printf ("%sfjaes", first
? "" : "|"), first
= FALSE
;
14639 fputc ('0', stdout
);
14640 fputc ('\n', stdout
);
14643 static unsigned char *
14644 display_sparc_gnu_attribute (unsigned char * p
,
14646 const unsigned char * const end
)
14651 if (tag
== Tag_GNU_Sparc_HWCAPS
)
14653 val
= read_uleb128 (p
, &len
, end
);
14655 printf (" Tag_GNU_Sparc_HWCAPS: ");
14656 display_sparc_hwcaps (val
);
14659 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
14661 val
= read_uleb128 (p
, &len
, end
);
14663 printf (" Tag_GNU_Sparc_HWCAPS2: ");
14664 display_sparc_hwcaps2 (val
);
14668 return display_tag_value (tag
, p
, end
);
14672 print_mips_fp_abi_value (unsigned int val
)
14676 case Val_GNU_MIPS_ABI_FP_ANY
:
14677 printf (_("Hard or soft float\n"));
14679 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
14680 printf (_("Hard float (double precision)\n"));
14682 case Val_GNU_MIPS_ABI_FP_SINGLE
:
14683 printf (_("Hard float (single precision)\n"));
14685 case Val_GNU_MIPS_ABI_FP_SOFT
:
14686 printf (_("Soft float\n"));
14688 case Val_GNU_MIPS_ABI_FP_OLD_64
:
14689 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
14691 case Val_GNU_MIPS_ABI_FP_XX
:
14692 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
14694 case Val_GNU_MIPS_ABI_FP_64
:
14695 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
14697 case Val_GNU_MIPS_ABI_FP_64A
:
14698 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
14700 case Val_GNU_MIPS_ABI_FP_NAN2008
:
14701 printf (_("NaN 2008 compatibility\n"));
14704 printf ("??? (%d)\n", val
);
14709 static unsigned char *
14710 display_mips_gnu_attribute (unsigned char * p
,
14712 const unsigned char * const end
)
14714 if (tag
== Tag_GNU_MIPS_ABI_FP
)
14719 val
= read_uleb128 (p
, &len
, end
);
14721 printf (" Tag_GNU_MIPS_ABI_FP: ");
14723 print_mips_fp_abi_value (val
);
14728 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
14733 val
= read_uleb128 (p
, &len
, end
);
14735 printf (" Tag_GNU_MIPS_ABI_MSA: ");
14739 case Val_GNU_MIPS_ABI_MSA_ANY
:
14740 printf (_("Any MSA or not\n"));
14742 case Val_GNU_MIPS_ABI_MSA_128
:
14743 printf (_("128-bit MSA\n"));
14746 printf ("??? (%d)\n", val
);
14752 return display_tag_value (tag
& 1, p
, end
);
14755 static unsigned char *
14756 display_tic6x_attribute (unsigned char * p
,
14757 const unsigned char * const end
)
14763 tag
= read_uleb128 (p
, &len
, end
);
14769 val
= read_uleb128 (p
, &len
, end
);
14771 printf (" Tag_ISA: ");
14775 case C6XABI_Tag_ISA_none
:
14776 printf (_("None\n"));
14778 case C6XABI_Tag_ISA_C62X
:
14781 case C6XABI_Tag_ISA_C67X
:
14784 case C6XABI_Tag_ISA_C67XP
:
14785 printf ("C67x+\n");
14787 case C6XABI_Tag_ISA_C64X
:
14790 case C6XABI_Tag_ISA_C64XP
:
14791 printf ("C64x+\n");
14793 case C6XABI_Tag_ISA_C674X
:
14794 printf ("C674x\n");
14797 printf ("??? (%d)\n", val
);
14802 case Tag_ABI_wchar_t
:
14803 val
= read_uleb128 (p
, &len
, end
);
14805 printf (" Tag_ABI_wchar_t: ");
14809 printf (_("Not used\n"));
14812 printf (_("2 bytes\n"));
14815 printf (_("4 bytes\n"));
14818 printf ("??? (%d)\n", val
);
14823 case Tag_ABI_stack_align_needed
:
14824 val
= read_uleb128 (p
, &len
, end
);
14826 printf (" Tag_ABI_stack_align_needed: ");
14830 printf (_("8-byte\n"));
14833 printf (_("16-byte\n"));
14836 printf ("??? (%d)\n", val
);
14841 case Tag_ABI_stack_align_preserved
:
14842 val
= read_uleb128 (p
, &len
, end
);
14844 printf (" Tag_ABI_stack_align_preserved: ");
14848 printf (_("8-byte\n"));
14851 printf (_("16-byte\n"));
14854 printf ("??? (%d)\n", val
);
14860 val
= read_uleb128 (p
, &len
, end
);
14862 printf (" Tag_ABI_DSBT: ");
14866 printf (_("DSBT addressing not used\n"));
14869 printf (_("DSBT addressing used\n"));
14872 printf ("??? (%d)\n", val
);
14878 val
= read_uleb128 (p
, &len
, end
);
14880 printf (" Tag_ABI_PID: ");
14884 printf (_("Data addressing position-dependent\n"));
14887 printf (_("Data addressing position-independent, GOT near DP\n"));
14890 printf (_("Data addressing position-independent, GOT far from DP\n"));
14893 printf ("??? (%d)\n", val
);
14899 val
= read_uleb128 (p
, &len
, end
);
14901 printf (" Tag_ABI_PIC: ");
14905 printf (_("Code addressing position-dependent\n"));
14908 printf (_("Code addressing position-independent\n"));
14911 printf ("??? (%d)\n", val
);
14916 case Tag_ABI_array_object_alignment
:
14917 val
= read_uleb128 (p
, &len
, end
);
14919 printf (" Tag_ABI_array_object_alignment: ");
14923 printf (_("8-byte\n"));
14926 printf (_("4-byte\n"));
14929 printf (_("16-byte\n"));
14932 printf ("??? (%d)\n", val
);
14937 case Tag_ABI_array_object_align_expected
:
14938 val
= read_uleb128 (p
, &len
, end
);
14940 printf (" Tag_ABI_array_object_align_expected: ");
14944 printf (_("8-byte\n"));
14947 printf (_("4-byte\n"));
14950 printf (_("16-byte\n"));
14953 printf ("??? (%d)\n", val
);
14958 case Tag_ABI_compatibility
:
14960 val
= read_uleb128 (p
, &len
, end
);
14962 printf (" Tag_ABI_compatibility: ");
14963 printf (_("flag = %d, vendor = "), val
);
14966 size_t maxlen
= (end
- p
) - 1;
14968 print_symbol ((int) maxlen
, (const char *) p
);
14969 p
+= strnlen ((char *) p
, maxlen
) + 1;
14973 printf (_("<corrupt>"));
14974 p
= (unsigned char *) end
;
14980 case Tag_ABI_conformance
:
14982 printf (" Tag_ABI_conformance: \"");
14985 size_t maxlen
= (end
- p
) - 1;
14987 print_symbol ((int) maxlen
, (const char *) p
);
14988 p
+= strnlen ((char *) p
, maxlen
) + 1;
14992 printf (_("<corrupt>"));
14993 p
= (unsigned char *) end
;
15000 return display_tag_value (tag
, p
, end
);
15004 display_raw_attribute (unsigned char * p
, unsigned char const * const end
)
15006 unsigned long addr
= 0;
15007 size_t bytes
= end
- p
;
15014 int lbytes
= (bytes
> 16 ? 16 : bytes
);
15016 printf (" 0x%8.8lx ", addr
);
15018 for (j
= 0; j
< 16; j
++)
15021 printf ("%2.2x", p
[j
]);
15029 for (j
= 0; j
< lbytes
; j
++)
15032 if (k
>= ' ' && k
< 0x7f)
15048 static unsigned char *
15049 display_msp430x_attribute (unsigned char * p
,
15050 const unsigned char * const end
)
15056 tag
= read_uleb128 (p
, & len
, end
);
15061 case OFBA_MSPABI_Tag_ISA
:
15062 val
= read_uleb128 (p
, &len
, end
);
15064 printf (" Tag_ISA: ");
15067 case 0: printf (_("None\n")); break;
15068 case 1: printf (_("MSP430\n")); break;
15069 case 2: printf (_("MSP430X\n")); break;
15070 default: printf ("??? (%d)\n", val
); break;
15074 case OFBA_MSPABI_Tag_Code_Model
:
15075 val
= read_uleb128 (p
, &len
, end
);
15077 printf (" Tag_Code_Model: ");
15080 case 0: printf (_("None\n")); break;
15081 case 1: printf (_("Small\n")); break;
15082 case 2: printf (_("Large\n")); break;
15083 default: printf ("??? (%d)\n", val
); break;
15087 case OFBA_MSPABI_Tag_Data_Model
:
15088 val
= read_uleb128 (p
, &len
, end
);
15090 printf (" Tag_Data_Model: ");
15093 case 0: printf (_("None\n")); break;
15094 case 1: printf (_("Small\n")); break;
15095 case 2: printf (_("Large\n")); break;
15096 case 3: printf (_("Restricted Large\n")); break;
15097 default: printf ("??? (%d)\n", val
); break;
15102 printf (_(" <unknown tag %d>: "), tag
);
15109 size_t maxlen
= (end
- p
) - 1;
15111 print_symbol ((int) maxlen
, (const char *) p
);
15112 p
+= strnlen ((char *) p
, maxlen
) + 1;
15116 printf (_("<corrupt>"));
15117 p
= (unsigned char *) end
;
15123 val
= read_uleb128 (p
, &len
, end
);
15125 printf ("%d (0x%x)\n", val
, val
);
15135 process_attributes (Filedata
* filedata
,
15136 const char * public_name
,
15137 unsigned int proc_type
,
15138 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
15139 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const))
15141 Elf_Internal_Shdr
* sect
;
15143 bfd_boolean res
= TRUE
;
15145 /* Find the section header so that we get the size. */
15146 for (i
= 0, sect
= filedata
->section_headers
;
15147 i
< filedata
->file_header
.e_shnum
;
15150 unsigned char * contents
;
15153 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
15156 contents
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
, 1,
15157 sect
->sh_size
, _("attributes"));
15158 if (contents
== NULL
)
15165 /* The first character is the version of the attributes.
15166 Currently only version 1, (aka 'A') is recognised here. */
15169 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p
, *p
);
15174 bfd_vma section_len
;
15176 section_len
= sect
->sh_size
- 1;
15179 while (section_len
> 0)
15182 unsigned int namelen
;
15183 bfd_boolean public_section
;
15184 bfd_boolean gnu_section
;
15186 if (section_len
<= 4)
15188 error (_("Tag section ends prematurely\n"));
15192 attr_len
= byte_get (p
, 4);
15195 if (attr_len
> section_len
)
15197 error (_("Bad attribute length (%u > %u)\n"),
15198 (unsigned) attr_len
, (unsigned) section_len
);
15199 attr_len
= section_len
;
15202 /* PR 17531: file: 001-101425-0.004 */
15203 else if (attr_len
< 5)
15205 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
15210 section_len
-= attr_len
;
15213 namelen
= strnlen ((char *) p
, attr_len
) + 1;
15214 if (namelen
== 0 || namelen
>= attr_len
)
15216 error (_("Corrupt attribute section name\n"));
15221 printf (_("Attribute Section: "));
15222 print_symbol (INT_MAX
, (const char *) p
);
15225 if (public_name
&& streq ((char *) p
, public_name
))
15226 public_section
= TRUE
;
15228 public_section
= FALSE
;
15230 if (streq ((char *) p
, "gnu"))
15231 gnu_section
= TRUE
;
15233 gnu_section
= FALSE
;
15236 attr_len
-= namelen
;
15238 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
15243 unsigned char * end
;
15245 /* PR binutils/17531: Safe handling of corrupt files. */
15248 error (_("Unused bytes at end of section\n"));
15255 size
= byte_get (p
, 4);
15256 if (size
> attr_len
)
15258 error (_("Bad subsection length (%u > %u)\n"),
15259 (unsigned) size
, (unsigned) attr_len
);
15263 /* PR binutils/17531: Safe handling of corrupt files. */
15266 error (_("Bad subsection length (%u < 6)\n"),
15274 end
= p
+ size
- 1;
15275 assert (end
<= contents
+ sect
->sh_size
);
15281 printf (_("File Attributes\n"));
15284 printf (_("Section Attributes:"));
15287 printf (_("Symbol Attributes:"));
15288 /* Fall through. */
15294 val
= read_uleb128 (p
, &j
, end
);
15298 printf (" %d", val
);
15303 printf (_("Unknown tag: %d\n"), tag
);
15304 public_section
= FALSE
;
15308 if (public_section
&& display_pub_attribute
!= NULL
)
15311 p
= display_pub_attribute (p
, end
);
15314 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
15317 p
= display_gnu_attribute (p
,
15318 display_proc_gnu_attribute
,
15324 printf (_(" Unknown attribute:\n"));
15325 display_raw_attribute (p
, end
);
15340 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
15341 Print the Address, Access and Initial fields of an entry at VMA ADDR
15342 and return the VMA of the next entry, or -1 if there was a problem.
15343 Does not read from DATA_END or beyond. */
15346 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
15347 unsigned char * data_end
)
15350 print_vma (addr
, LONG_HEX
);
15352 if (addr
< pltgot
+ 0xfff0)
15353 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
15355 printf ("%10s", "");
15358 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
15362 unsigned char * from
= data
+ addr
- pltgot
;
15364 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
15366 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
15367 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
15368 return (bfd_vma
) -1;
15372 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
15373 print_vma (entry
, LONG_HEX
);
15376 return addr
+ (is_32bit_elf
? 4 : 8);
15379 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
15380 PLTGOT. Print the Address and Initial fields of an entry at VMA
15381 ADDR and return the VMA of the next entry. */
15384 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
15387 print_vma (addr
, LONG_HEX
);
15390 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
15395 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
15396 print_vma (entry
, LONG_HEX
);
15398 return addr
+ (is_32bit_elf
? 4 : 8);
15402 print_mips_ases (unsigned int mask
)
15404 if (mask
& AFL_ASE_DSP
)
15405 fputs ("\n\tDSP ASE", stdout
);
15406 if (mask
& AFL_ASE_DSPR2
)
15407 fputs ("\n\tDSP R2 ASE", stdout
);
15408 if (mask
& AFL_ASE_DSPR3
)
15409 fputs ("\n\tDSP R3 ASE", stdout
);
15410 if (mask
& AFL_ASE_EVA
)
15411 fputs ("\n\tEnhanced VA Scheme", stdout
);
15412 if (mask
& AFL_ASE_MCU
)
15413 fputs ("\n\tMCU (MicroController) ASE", stdout
);
15414 if (mask
& AFL_ASE_MDMX
)
15415 fputs ("\n\tMDMX ASE", stdout
);
15416 if (mask
& AFL_ASE_MIPS3D
)
15417 fputs ("\n\tMIPS-3D ASE", stdout
);
15418 if (mask
& AFL_ASE_MT
)
15419 fputs ("\n\tMT ASE", stdout
);
15420 if (mask
& AFL_ASE_SMARTMIPS
)
15421 fputs ("\n\tSmartMIPS ASE", stdout
);
15422 if (mask
& AFL_ASE_VIRT
)
15423 fputs ("\n\tVZ ASE", stdout
);
15424 if (mask
& AFL_ASE_MSA
)
15425 fputs ("\n\tMSA ASE", stdout
);
15426 if (mask
& AFL_ASE_MIPS16
)
15427 fputs ("\n\tMIPS16 ASE", stdout
);
15428 if (mask
& AFL_ASE_MICROMIPS
)
15429 fputs ("\n\tMICROMIPS ASE", stdout
);
15430 if (mask
& AFL_ASE_XPA
)
15431 fputs ("\n\tXPA ASE", stdout
);
15432 if (mask
& AFL_ASE_MIPS16E2
)
15433 fputs ("\n\tMIPS16e2 ASE", stdout
);
15435 fprintf (stdout
, "\n\t%s", _("None"));
15436 else if ((mask
& ~AFL_ASE_MASK
) != 0)
15437 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
15441 print_mips_isa_ext (unsigned int isa_ext
)
15446 fputs (_("None"), stdout
);
15449 fputs ("RMI XLR", stdout
);
15451 case AFL_EXT_OCTEON3
:
15452 fputs ("Cavium Networks Octeon3", stdout
);
15454 case AFL_EXT_OCTEON2
:
15455 fputs ("Cavium Networks Octeon2", stdout
);
15457 case AFL_EXT_OCTEONP
:
15458 fputs ("Cavium Networks OcteonP", stdout
);
15460 case AFL_EXT_LOONGSON_3A
:
15461 fputs ("Loongson 3A", stdout
);
15463 case AFL_EXT_OCTEON
:
15464 fputs ("Cavium Networks Octeon", stdout
);
15467 fputs ("Toshiba R5900", stdout
);
15470 fputs ("MIPS R4650", stdout
);
15473 fputs ("LSI R4010", stdout
);
15476 fputs ("NEC VR4100", stdout
);
15479 fputs ("Toshiba R3900", stdout
);
15481 case AFL_EXT_10000
:
15482 fputs ("MIPS R10000", stdout
);
15485 fputs ("Broadcom SB-1", stdout
);
15488 fputs ("NEC VR4111/VR4181", stdout
);
15491 fputs ("NEC VR4120", stdout
);
15494 fputs ("NEC VR5400", stdout
);
15497 fputs ("NEC VR5500", stdout
);
15499 case AFL_EXT_LOONGSON_2E
:
15500 fputs ("ST Microelectronics Loongson 2E", stdout
);
15502 case AFL_EXT_LOONGSON_2F
:
15503 fputs ("ST Microelectronics Loongson 2F", stdout
);
15505 case AFL_EXT_INTERAPTIV_MR2
:
15506 fputs ("Imagination interAptiv MR2", stdout
);
15509 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
15514 get_mips_reg_size (int reg_size
)
15516 return (reg_size
== AFL_REG_NONE
) ? 0
15517 : (reg_size
== AFL_REG_32
) ? 32
15518 : (reg_size
== AFL_REG_64
) ? 64
15519 : (reg_size
== AFL_REG_128
) ? 128
15524 process_mips_specific (Filedata
* filedata
)
15526 Elf_Internal_Dyn
* entry
;
15527 Elf_Internal_Shdr
*sect
= NULL
;
15528 size_t liblist_offset
= 0;
15529 size_t liblistno
= 0;
15530 size_t conflictsno
= 0;
15531 size_t options_offset
= 0;
15532 size_t conflicts_offset
= 0;
15533 size_t pltrelsz
= 0;
15535 bfd_vma pltgot
= 0;
15536 bfd_vma mips_pltgot
= 0;
15537 bfd_vma jmprel
= 0;
15538 bfd_vma local_gotno
= 0;
15539 bfd_vma gotsym
= 0;
15540 bfd_vma symtabno
= 0;
15541 bfd_boolean res
= TRUE
;
15543 if (! process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
15544 display_mips_gnu_attribute
))
15547 sect
= find_section (filedata
, ".MIPS.abiflags");
15551 Elf_External_ABIFlags_v0
*abiflags_ext
;
15552 Elf_Internal_ABIFlags_v0 abiflags_in
;
15554 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
15556 error (_("Corrupt MIPS ABI Flags section.\n"));
15561 abiflags_ext
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
15562 sect
->sh_size
, _("MIPS ABI Flags section"));
15565 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
15566 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
15567 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
15568 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
15569 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
15570 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
15571 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
15572 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
15573 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
15574 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
15575 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
15577 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
15578 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
15579 if (abiflags_in
.isa_rev
> 1)
15580 printf ("r%d", abiflags_in
.isa_rev
);
15581 printf ("\nGPR size: %d",
15582 get_mips_reg_size (abiflags_in
.gpr_size
));
15583 printf ("\nCPR1 size: %d",
15584 get_mips_reg_size (abiflags_in
.cpr1_size
));
15585 printf ("\nCPR2 size: %d",
15586 get_mips_reg_size (abiflags_in
.cpr2_size
));
15587 fputs ("\nFP ABI: ", stdout
);
15588 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
15589 fputs ("ISA Extension: ", stdout
);
15590 print_mips_isa_ext (abiflags_in
.isa_ext
);
15591 fputs ("\nASEs:", stdout
);
15592 print_mips_ases (abiflags_in
.ases
);
15593 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
15594 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
15595 fputc ('\n', stdout
);
15596 free (abiflags_ext
);
15601 /* We have a lot of special sections. Thanks SGI! */
15602 if (dynamic_section
== NULL
)
15604 /* No dynamic information available. See if there is static GOT. */
15605 sect
= find_section (filedata
, ".got");
15608 unsigned char *data_end
;
15609 unsigned char *data
;
15613 pltgot
= sect
->sh_addr
;
15616 addr_size
= (is_32bit_elf
? 4 : 8);
15617 end
= pltgot
+ sect
->sh_size
;
15619 data
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
,
15621 _("Global Offset Table data"));
15622 /* PR 12855: Null data is handled gracefully throughout. */
15623 data_end
= data
+ (end
- pltgot
);
15625 printf (_("\nStatic GOT:\n"));
15626 printf (_(" Canonical gp value: "));
15627 print_vma (ent
+ 0x7ff0, LONG_HEX
);
15630 /* In a dynamic binary GOT[0] is reserved for the dynamic
15631 loader to store the lazy resolver pointer, however in
15632 a static binary it may well have been omitted and GOT
15633 reduced to a table of addresses.
15634 PR 21344: Check for the entry being fully available
15635 before fetching it. */
15637 && data
+ ent
- pltgot
+ addr_size
<= data_end
15638 && byte_get (data
+ ent
- pltgot
, addr_size
) == 0)
15640 printf (_(" Reserved entries:\n"));
15641 printf (_(" %*s %10s %*s\n"),
15642 addr_size
* 2, _("Address"), _("Access"),
15643 addr_size
* 2, _("Value"));
15644 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15646 if (ent
== (bfd_vma
) -1)
15647 goto sgot_print_fail
;
15649 /* Check for the MSB of GOT[1] being set, identifying a
15650 GNU object. This entry will be used by some runtime
15651 loaders, to store the module pointer. Otherwise this
15652 is an ordinary local entry.
15653 PR 21344: Check for the entry being fully available
15654 before fetching it. */
15656 && data
+ ent
- pltgot
+ addr_size
<= data_end
15657 && (byte_get (data
+ ent
- pltgot
, addr_size
)
15658 >> (addr_size
* 8 - 1)) != 0)
15660 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15662 if (ent
== (bfd_vma
) -1)
15663 goto sgot_print_fail
;
15668 if (data
!= NULL
&& ent
< end
)
15670 printf (_(" Local entries:\n"));
15671 printf (" %*s %10s %*s\n",
15672 addr_size
* 2, _("Address"), _("Access"),
15673 addr_size
* 2, _("Value"));
15676 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15678 if (ent
== (bfd_vma
) -1)
15679 goto sgot_print_fail
;
15691 for (entry
= dynamic_section
;
15692 /* PR 17531 file: 012-50589-0.004. */
15693 entry
< dynamic_section
+ dynamic_nent
&& entry
->d_tag
!= DT_NULL
;
15695 switch (entry
->d_tag
)
15697 case DT_MIPS_LIBLIST
:
15699 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
15700 liblistno
* sizeof (Elf32_External_Lib
));
15702 case DT_MIPS_LIBLISTNO
:
15703 liblistno
= entry
->d_un
.d_val
;
15705 case DT_MIPS_OPTIONS
:
15706 options_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
15708 case DT_MIPS_CONFLICT
:
15710 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
15711 conflictsno
* sizeof (Elf32_External_Conflict
));
15713 case DT_MIPS_CONFLICTNO
:
15714 conflictsno
= entry
->d_un
.d_val
;
15717 pltgot
= entry
->d_un
.d_ptr
;
15719 case DT_MIPS_LOCAL_GOTNO
:
15720 local_gotno
= entry
->d_un
.d_val
;
15722 case DT_MIPS_GOTSYM
:
15723 gotsym
= entry
->d_un
.d_val
;
15725 case DT_MIPS_SYMTABNO
:
15726 symtabno
= entry
->d_un
.d_val
;
15728 case DT_MIPS_PLTGOT
:
15729 mips_pltgot
= entry
->d_un
.d_ptr
;
15732 pltrel
= entry
->d_un
.d_val
;
15735 pltrelsz
= entry
->d_un
.d_val
;
15738 jmprel
= entry
->d_un
.d_ptr
;
15744 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
15746 Elf32_External_Lib
* elib
;
15749 elib
= (Elf32_External_Lib
*) get_data (NULL
, filedata
, liblist_offset
,
15751 sizeof (Elf32_External_Lib
),
15752 _("liblist section data"));
15755 printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
15756 "\nSection '.liblist' contains %lu entries:\n",
15757 (unsigned long) liblistno
),
15758 (unsigned long) liblistno
);
15759 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
15762 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
15769 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
15770 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
15771 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
15772 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
15773 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
15775 tmp
= gmtime (&atime
);
15776 snprintf (timebuf
, sizeof (timebuf
),
15777 "%04u-%02u-%02uT%02u:%02u:%02u",
15778 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
15779 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
15781 printf ("%3lu: ", (unsigned long) cnt
);
15782 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
15783 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
15785 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
15786 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
15787 liblist
.l_version
);
15789 if (liblist
.l_flags
== 0)
15793 static const struct
15800 { " EXACT_MATCH", LL_EXACT_MATCH
},
15801 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
15802 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
15803 { " EXPORTS", LL_EXPORTS
},
15804 { " DELAY_LOAD", LL_DELAY_LOAD
},
15805 { " DELTA", LL_DELTA
}
15807 int flags
= liblist
.l_flags
;
15810 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
15811 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
15813 fputs (l_flags_vals
[fcnt
].name
, stdout
);
15814 flags
^= l_flags_vals
[fcnt
].bit
;
15817 printf (" %#x", (unsigned int) flags
);
15829 if (options_offset
!= 0)
15831 Elf_External_Options
* eopt
;
15832 Elf_Internal_Options
* iopt
;
15833 Elf_Internal_Options
* option
;
15836 sect
= filedata
->section_headers
;
15838 /* Find the section header so that we get the size. */
15839 sect
= find_section_by_type (filedata
, SHT_MIPS_OPTIONS
);
15840 /* PR 17533 file: 012-277276-0.004. */
15843 error (_("No MIPS_OPTIONS header found\n"));
15847 eopt
= (Elf_External_Options
*) get_data (NULL
, filedata
, options_offset
, 1,
15848 sect
->sh_size
, _("options"));
15851 iopt
= (Elf_Internal_Options
*)
15852 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
15855 error (_("Out of memory allocating space for MIPS options\n"));
15862 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
15864 Elf_External_Options
* eoption
;
15866 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
15868 option
->kind
= BYTE_GET (eoption
->kind
);
15869 option
->size
= BYTE_GET (eoption
->size
);
15870 option
->section
= BYTE_GET (eoption
->section
);
15871 option
->info
= BYTE_GET (eoption
->info
);
15873 /* PR 17531: file: ffa0fa3b. */
15874 if (option
->size
< sizeof (* eopt
)
15875 || offset
+ option
->size
> sect
->sh_size
)
15877 error (_("Invalid size (%u) for MIPS option\n"), option
->size
);
15880 offset
+= option
->size
;
15886 printf (ngettext ("\nSection '%s' contains %d entry:\n",
15887 "\nSection '%s' contains %d entries:\n",
15889 printable_section_name (filedata
, sect
), cnt
);
15898 switch (option
->kind
)
15901 /* This shouldn't happen. */
15902 printf (" NULL %d %lx", option
->section
, option
->info
);
15905 printf (" REGINFO ");
15906 if (filedata
->file_header
.e_machine
== EM_MIPS
)
15909 Elf32_External_RegInfo
* ereg
;
15910 Elf32_RegInfo reginfo
;
15912 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
15913 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
15914 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
15915 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
15916 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
15917 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
15918 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
15920 printf ("GPR %08lx GP 0x%lx\n",
15921 reginfo
.ri_gprmask
,
15922 (unsigned long) reginfo
.ri_gp_value
);
15923 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
15924 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
15925 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
15930 Elf64_External_RegInfo
* ereg
;
15931 Elf64_Internal_RegInfo reginfo
;
15933 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
15934 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
15935 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
15936 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
15937 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
15938 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
15939 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
15941 printf ("GPR %08lx GP 0x",
15942 reginfo
.ri_gprmask
);
15943 printf_vma (reginfo
.ri_gp_value
);
15946 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
15947 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
15948 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
15952 case ODK_EXCEPTIONS
:
15953 fputs (" EXCEPTIONS fpe_min(", stdout
);
15954 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
15955 fputs (") fpe_max(", stdout
);
15956 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
15957 fputs (")", stdout
);
15959 if (option
->info
& OEX_PAGE0
)
15960 fputs (" PAGE0", stdout
);
15961 if (option
->info
& OEX_SMM
)
15962 fputs (" SMM", stdout
);
15963 if (option
->info
& OEX_FPDBUG
)
15964 fputs (" FPDBUG", stdout
);
15965 if (option
->info
& OEX_DISMISS
)
15966 fputs (" DISMISS", stdout
);
15969 fputs (" PAD ", stdout
);
15970 if (option
->info
& OPAD_PREFIX
)
15971 fputs (" PREFIX", stdout
);
15972 if (option
->info
& OPAD_POSTFIX
)
15973 fputs (" POSTFIX", stdout
);
15974 if (option
->info
& OPAD_SYMBOL
)
15975 fputs (" SYMBOL", stdout
);
15978 fputs (" HWPATCH ", stdout
);
15979 if (option
->info
& OHW_R4KEOP
)
15980 fputs (" R4KEOP", stdout
);
15981 if (option
->info
& OHW_R8KPFETCH
)
15982 fputs (" R8KPFETCH", stdout
);
15983 if (option
->info
& OHW_R5KEOP
)
15984 fputs (" R5KEOP", stdout
);
15985 if (option
->info
& OHW_R5KCVTL
)
15986 fputs (" R5KCVTL", stdout
);
15989 fputs (" FILL ", stdout
);
15990 /* XXX Print content of info word? */
15993 fputs (" TAGS ", stdout
);
15994 /* XXX Print content of info word? */
15997 fputs (" HWAND ", stdout
);
15998 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
15999 fputs (" R4KEOP_CHECKED", stdout
);
16000 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
16001 fputs (" R4KEOP_CLEAN", stdout
);
16004 fputs (" HWOR ", stdout
);
16005 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
16006 fputs (" R4KEOP_CHECKED", stdout
);
16007 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
16008 fputs (" R4KEOP_CLEAN", stdout
);
16011 printf (" GP_GROUP %#06lx self-contained %#06lx",
16012 option
->info
& OGP_GROUP
,
16013 (option
->info
& OGP_SELF
) >> 16);
16016 printf (" IDENT %#06lx self-contained %#06lx",
16017 option
->info
& OGP_GROUP
,
16018 (option
->info
& OGP_SELF
) >> 16);
16021 /* This shouldn't happen. */
16022 printf (" %3d ??? %d %lx",
16023 option
->kind
, option
->section
, option
->info
);
16027 len
= sizeof (* eopt
);
16028 while (len
< option
->size
)
16030 unsigned char datum
= * ((unsigned char *) eopt
+ offset
+ len
);
16032 if (ISPRINT (datum
))
16033 printf ("%c", datum
);
16035 printf ("\\%03o", datum
);
16038 fputs ("\n", stdout
);
16040 offset
+= option
->size
;
16050 if (conflicts_offset
!= 0 && conflictsno
!= 0)
16052 Elf32_Conflict
* iconf
;
16055 if (dynamic_symbols
== NULL
)
16057 error (_("conflict list found without a dynamic symbol table\n"));
16061 /* PR 21345 - print a slightly more helpful error message
16062 if we are sure that the cmalloc will fail. */
16063 if (conflictsno
* sizeof (* iconf
) > filedata
->file_size
)
16065 error (_("Overlarge number of conflicts detected: %lx\n"),
16066 (long) conflictsno
);
16070 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
16073 error (_("Out of memory allocating space for dynamic conflicts\n"));
16079 Elf32_External_Conflict
* econf32
;
16081 econf32
= (Elf32_External_Conflict
*)
16082 get_data (NULL
, filedata
, conflicts_offset
, conflictsno
,
16083 sizeof (* econf32
), _("conflict"));
16087 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
16088 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
16094 Elf64_External_Conflict
* econf64
;
16096 econf64
= (Elf64_External_Conflict
*)
16097 get_data (NULL
, filedata
, conflicts_offset
, conflictsno
,
16098 sizeof (* econf64
), _("conflict"));
16102 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
16103 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
16108 printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
16109 "\nSection '.conflict' contains %lu entries:\n",
16110 (unsigned long) conflictsno
),
16111 (unsigned long) conflictsno
);
16112 puts (_(" Num: Index Value Name"));
16114 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
16116 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
16118 if (iconf
[cnt
] >= num_dynamic_syms
)
16119 printf (_("<corrupt symbol index>"));
16122 Elf_Internal_Sym
* psym
;
16124 psym
= & dynamic_symbols
[iconf
[cnt
]];
16125 print_vma (psym
->st_value
, FULL_HEX
);
16127 if (VALID_DYNAMIC_NAME (psym
->st_name
))
16128 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
16130 printf (_("<corrupt: %14ld>"), psym
->st_name
);
16138 if (pltgot
!= 0 && local_gotno
!= 0)
16140 bfd_vma ent
, local_end
, global_end
;
16142 unsigned char * data
;
16143 unsigned char * data_end
;
16147 addr_size
= (is_32bit_elf
? 4 : 8);
16148 local_end
= pltgot
+ local_gotno
* addr_size
;
16150 /* PR binutils/17533 file: 012-111227-0.004 */
16151 if (symtabno
< gotsym
)
16153 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
16154 (unsigned long) gotsym
, (unsigned long) symtabno
);
16158 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
16159 /* PR 17531: file: 54c91a34. */
16160 if (global_end
< local_end
)
16162 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
16166 offset
= offset_from_vma (filedata
, pltgot
, global_end
- pltgot
);
16167 data
= (unsigned char *) get_data (NULL
, filedata
, offset
,
16168 global_end
- pltgot
, 1,
16169 _("Global Offset Table data"));
16170 /* PR 12855: Null data is handled gracefully throughout. */
16171 data_end
= data
+ (global_end
- pltgot
);
16173 printf (_("\nPrimary GOT:\n"));
16174 printf (_(" Canonical gp value: "));
16175 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
16178 printf (_(" Reserved entries:\n"));
16179 printf (_(" %*s %10s %*s Purpose\n"),
16180 addr_size
* 2, _("Address"), _("Access"),
16181 addr_size
* 2, _("Initial"));
16182 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16183 printf (_(" Lazy resolver\n"));
16184 if (ent
== (bfd_vma
) -1)
16185 goto got_print_fail
;
16187 /* Check for the MSB of GOT[1] being set, denoting a GNU object.
16188 This entry will be used by some runtime loaders, to store the
16189 module pointer. Otherwise this is an ordinary local entry.
16190 PR 21344: Check for the entry being fully available before
16193 && data
+ ent
- pltgot
+ addr_size
<= data_end
16194 && (byte_get (data
+ ent
- pltgot
, addr_size
)
16195 >> (addr_size
* 8 - 1)) != 0)
16197 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16198 printf (_(" Module pointer (GNU extension)\n"));
16199 if (ent
== (bfd_vma
) -1)
16200 goto got_print_fail
;
16204 if (data
!= NULL
&& ent
< local_end
)
16206 printf (_(" Local entries:\n"));
16207 printf (" %*s %10s %*s\n",
16208 addr_size
* 2, _("Address"), _("Access"),
16209 addr_size
* 2, _("Initial"));
16210 while (ent
< local_end
)
16212 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16214 if (ent
== (bfd_vma
) -1)
16215 goto got_print_fail
;
16220 if (data
!= NULL
&& gotsym
< symtabno
)
16224 printf (_(" Global entries:\n"));
16225 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
16226 addr_size
* 2, _("Address"),
16228 addr_size
* 2, _("Initial"),
16229 addr_size
* 2, _("Sym.Val."),
16231 /* Note for translators: "Ndx" = abbreviated form of "Index". */
16232 _("Ndx"), _("Name"));
16234 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
16236 for (i
= gotsym
; i
< symtabno
; i
++)
16238 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16241 if (dynamic_symbols
== NULL
)
16242 printf (_("<no dynamic symbols>"));
16243 else if (i
< num_dynamic_syms
)
16245 Elf_Internal_Sym
* psym
= dynamic_symbols
+ i
;
16247 print_vma (psym
->st_value
, LONG_HEX
);
16248 printf (" %-7s %3s ",
16249 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
16250 get_symbol_index_type (filedata
, psym
->st_shndx
));
16252 if (VALID_DYNAMIC_NAME (psym
->st_name
))
16253 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
16255 printf (_("<corrupt: %14ld>"), psym
->st_name
);
16258 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
16259 (unsigned long) i
);
16262 if (ent
== (bfd_vma
) -1)
16273 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
16276 size_t offset
, rel_offset
;
16277 unsigned long count
, i
;
16278 unsigned char * data
;
16279 int addr_size
, sym_width
;
16280 Elf_Internal_Rela
* rels
;
16282 rel_offset
= offset_from_vma (filedata
, jmprel
, pltrelsz
);
16283 if (pltrel
== DT_RELA
)
16285 if (!slurp_rela_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
16290 if (!slurp_rel_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
16295 addr_size
= (is_32bit_elf
? 4 : 8);
16296 end
= mips_pltgot
+ (2 + count
) * addr_size
;
16298 offset
= offset_from_vma (filedata
, mips_pltgot
, end
- mips_pltgot
);
16299 data
= (unsigned char *) get_data (NULL
, filedata
, offset
, end
- mips_pltgot
,
16300 1, _("Procedure Linkage Table data"));
16304 printf ("\nPLT GOT:\n\n");
16305 printf (_(" Reserved entries:\n"));
16306 printf (_(" %*s %*s Purpose\n"),
16307 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
16308 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
16309 printf (_(" PLT lazy resolver\n"));
16310 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
16311 printf (_(" Module pointer\n"));
16314 printf (_(" Entries:\n"));
16315 printf (" %*s %*s %*s %-7s %3s %s\n",
16316 addr_size
* 2, _("Address"),
16317 addr_size
* 2, _("Initial"),
16318 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
16319 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
16320 for (i
= 0; i
< count
; i
++)
16322 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
16324 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
16327 if (idx
>= num_dynamic_syms
)
16328 printf (_("<corrupt symbol index: %lu>"), idx
);
16331 Elf_Internal_Sym
* psym
= dynamic_symbols
+ idx
;
16333 print_vma (psym
->st_value
, LONG_HEX
);
16334 printf (" %-7s %3s ",
16335 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
16336 get_symbol_index_type (filedata
, psym
->st_shndx
));
16337 if (VALID_DYNAMIC_NAME (psym
->st_name
))
16338 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
16340 printf (_("<corrupt: %14ld>"), psym
->st_name
);
16355 process_nds32_specific (Filedata
* filedata
)
16357 Elf_Internal_Shdr
*sect
= NULL
;
16359 sect
= find_section (filedata
, ".nds32_e_flags");
16362 unsigned int *flag
;
16364 printf ("\nNDS32 elf flags section:\n");
16365 flag
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
16366 sect
->sh_size
, _("NDS32 elf flags section"));
16371 switch ((*flag
) & 0x3)
16374 printf ("(VEC_SIZE):\tNo entry.\n");
16377 printf ("(VEC_SIZE):\t4 bytes\n");
16380 printf ("(VEC_SIZE):\t16 bytes\n");
16383 printf ("(VEC_SIZE):\treserved\n");
16392 process_gnu_liblist (Filedata
* filedata
)
16394 Elf_Internal_Shdr
* section
;
16395 Elf_Internal_Shdr
* string_sec
;
16396 Elf32_External_Lib
* elib
;
16398 size_t strtab_size
;
16400 unsigned long num_liblist
;
16402 bfd_boolean res
= TRUE
;
16407 for (i
= 0, section
= filedata
->section_headers
;
16408 i
< filedata
->file_header
.e_shnum
;
16411 switch (section
->sh_type
)
16413 case SHT_GNU_LIBLIST
:
16414 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
16417 elib
= (Elf32_External_Lib
*)
16418 get_data (NULL
, filedata
, section
->sh_offset
, 1, section
->sh_size
,
16419 _("liblist section data"));
16427 string_sec
= filedata
->section_headers
+ section
->sh_link
;
16428 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
16429 string_sec
->sh_size
,
16430 _("liblist string table"));
16432 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
16439 strtab_size
= string_sec
->sh_size
;
16441 num_liblist
= section
->sh_size
/ sizeof (Elf32_External_Lib
);
16442 printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
16443 "\nLibrary list section '%s' contains %lu entries:\n",
16445 printable_section_name (filedata
, section
),
16448 puts (_(" Library Time Stamp Checksum Version Flags"));
16450 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
16458 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
16459 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
16460 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
16461 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
16462 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
16464 tmp
= gmtime (&atime
);
16465 snprintf (timebuf
, sizeof (timebuf
),
16466 "%04u-%02u-%02uT%02u:%02u:%02u",
16467 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
16468 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
16470 printf ("%3lu: ", (unsigned long) cnt
);
16472 printf ("%-20s", liblist
.l_name
< strtab_size
16473 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
16475 printf ("%-20.20s", liblist
.l_name
< strtab_size
16476 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
16477 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
16478 liblist
.l_version
, liblist
.l_flags
);
16489 static const char *
16490 get_note_type (Filedata
* filedata
, unsigned e_type
)
16492 static char buff
[64];
16494 if (filedata
->file_header
.e_type
== ET_CORE
)
16498 return _("NT_AUXV (auxiliary vector)");
16500 return _("NT_PRSTATUS (prstatus structure)");
16502 return _("NT_FPREGSET (floating point registers)");
16504 return _("NT_PRPSINFO (prpsinfo structure)");
16505 case NT_TASKSTRUCT
:
16506 return _("NT_TASKSTRUCT (task structure)");
16508 return _("NT_PRXFPREG (user_xfpregs structure)");
16510 return _("NT_PPC_VMX (ppc Altivec registers)");
16512 return _("NT_PPC_VSX (ppc VSX registers)");
16514 return _("NT_PPC_TAR (ppc TAR register)");
16516 return _("NT_PPC_PPR (ppc PPR register)");
16518 return _("NT_PPC_DSCR (ppc DSCR register)");
16520 return _("NT_PPC_EBB (ppc EBB registers)");
16522 return _("NT_PPC_PMU (ppc PMU registers)");
16523 case NT_PPC_TM_CGPR
:
16524 return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
16525 case NT_PPC_TM_CFPR
:
16526 return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
16527 case NT_PPC_TM_CVMX
:
16528 return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
16529 case NT_PPC_TM_CVSX
:
16530 return _("NT_PPC_TM_VSX (ppc checkpointed VSX registers)");
16531 case NT_PPC_TM_SPR
:
16532 return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
16533 case NT_PPC_TM_CTAR
:
16534 return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
16535 case NT_PPC_TM_CPPR
:
16536 return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
16537 case NT_PPC_TM_CDSCR
:
16538 return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
16540 return _("NT_386_TLS (x86 TLS information)");
16541 case NT_386_IOPERM
:
16542 return _("NT_386_IOPERM (x86 I/O permissions)");
16543 case NT_X86_XSTATE
:
16544 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
16545 case NT_S390_HIGH_GPRS
:
16546 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
16547 case NT_S390_TIMER
:
16548 return _("NT_S390_TIMER (s390 timer register)");
16549 case NT_S390_TODCMP
:
16550 return _("NT_S390_TODCMP (s390 TOD comparator register)");
16551 case NT_S390_TODPREG
:
16552 return _("NT_S390_TODPREG (s390 TOD programmable register)");
16554 return _("NT_S390_CTRS (s390 control registers)");
16555 case NT_S390_PREFIX
:
16556 return _("NT_S390_PREFIX (s390 prefix register)");
16557 case NT_S390_LAST_BREAK
:
16558 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
16559 case NT_S390_SYSTEM_CALL
:
16560 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
16562 return _("NT_S390_TDB (s390 transaction diagnostic block)");
16563 case NT_S390_VXRS_LOW
:
16564 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
16565 case NT_S390_VXRS_HIGH
:
16566 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
16567 case NT_S390_GS_CB
:
16568 return _("NT_S390_GS_CB (s390 guarded-storage registers)");
16569 case NT_S390_GS_BC
:
16570 return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
16572 return _("NT_ARM_VFP (arm VFP registers)");
16574 return _("NT_ARM_TLS (AArch TLS registers)");
16575 case NT_ARM_HW_BREAK
:
16576 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
16577 case NT_ARM_HW_WATCH
:
16578 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
16580 return _("NT_PSTATUS (pstatus structure)");
16582 return _("NT_FPREGS (floating point registers)");
16584 return _("NT_PSINFO (psinfo structure)");
16586 return _("NT_LWPSTATUS (lwpstatus_t structure)");
16588 return _("NT_LWPSINFO (lwpsinfo_t structure)");
16589 case NT_WIN32PSTATUS
:
16590 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
16592 return _("NT_SIGINFO (siginfo_t data)");
16594 return _("NT_FILE (mapped files)");
16602 return _("NT_VERSION (version)");
16604 return _("NT_ARCH (architecture)");
16605 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
16607 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
16613 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16618 print_core_note (Elf_Internal_Note
*pnote
)
16620 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
16621 bfd_vma count
, page_size
;
16622 unsigned char *descdata
, *filenames
, *descend
;
16624 if (pnote
->type
!= NT_FILE
)
16634 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
16635 /* Still "successful". */
16640 if (pnote
->descsz
< 2 * addr_size
)
16642 error (_(" Malformed note - too short for header\n"));
16646 descdata
= (unsigned char *) pnote
->descdata
;
16647 descend
= descdata
+ pnote
->descsz
;
16649 if (descdata
[pnote
->descsz
- 1] != '\0')
16651 error (_(" Malformed note - does not end with \\0\n"));
16655 count
= byte_get (descdata
, addr_size
);
16656 descdata
+= addr_size
;
16658 page_size
= byte_get (descdata
, addr_size
);
16659 descdata
+= addr_size
;
16661 if (count
> ((bfd_vma
) -1 - 2 * addr_size
) / (3 * addr_size
)
16662 || pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
16664 error (_(" Malformed note - too short for supplied file count\n"));
16668 printf (_(" Page size: "));
16669 print_vma (page_size
, DEC
);
16672 printf (_(" %*s%*s%*s\n"),
16673 (int) (2 + 2 * addr_size
), _("Start"),
16674 (int) (4 + 2 * addr_size
), _("End"),
16675 (int) (4 + 2 * addr_size
), _("Page Offset"));
16676 filenames
= descdata
+ count
* 3 * addr_size
;
16677 while (count
-- > 0)
16679 bfd_vma start
, end
, file_ofs
;
16681 if (filenames
== descend
)
16683 error (_(" Malformed note - filenames end too early\n"));
16687 start
= byte_get (descdata
, addr_size
);
16688 descdata
+= addr_size
;
16689 end
= byte_get (descdata
, addr_size
);
16690 descdata
+= addr_size
;
16691 file_ofs
= byte_get (descdata
, addr_size
);
16692 descdata
+= addr_size
;
16695 print_vma (start
, FULL_HEX
);
16697 print_vma (end
, FULL_HEX
);
16699 print_vma (file_ofs
, FULL_HEX
);
16700 printf ("\n %s\n", filenames
);
16702 filenames
+= 1 + strlen ((char *) filenames
);
16708 static const char *
16709 get_gnu_elf_note_type (unsigned e_type
)
16711 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
16714 case NT_GNU_ABI_TAG
:
16715 return _("NT_GNU_ABI_TAG (ABI version tag)");
16717 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
16718 case NT_GNU_BUILD_ID
:
16719 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
16720 case NT_GNU_GOLD_VERSION
:
16721 return _("NT_GNU_GOLD_VERSION (gold version)");
16722 case NT_GNU_PROPERTY_TYPE_0
:
16723 return _("NT_GNU_PROPERTY_TYPE_0");
16724 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
16725 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
16726 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
16727 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
16730 static char buff
[64];
16732 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16739 decode_x86_isa (unsigned int bitmask
)
16743 unsigned int bit
= bitmask
& (- bitmask
);
16748 case GNU_PROPERTY_X86_ISA_1_486
: printf ("i486"); break;
16749 case GNU_PROPERTY_X86_ISA_1_586
: printf ("586"); break;
16750 case GNU_PROPERTY_X86_ISA_1_686
: printf ("686"); break;
16751 case GNU_PROPERTY_X86_ISA_1_SSE
: printf ("SSE"); break;
16752 case GNU_PROPERTY_X86_ISA_1_SSE2
: printf ("SSE2"); break;
16753 case GNU_PROPERTY_X86_ISA_1_SSE3
: printf ("SSE3"); break;
16754 case GNU_PROPERTY_X86_ISA_1_SSSE3
: printf ("SSSE3"); break;
16755 case GNU_PROPERTY_X86_ISA_1_SSE4_1
: printf ("SSE4_1"); break;
16756 case GNU_PROPERTY_X86_ISA_1_SSE4_2
: printf ("SSE4_2"); break;
16757 case GNU_PROPERTY_X86_ISA_1_AVX
: printf ("AVX"); break;
16758 case GNU_PROPERTY_X86_ISA_1_AVX2
: printf ("AVX2"); break;
16759 case GNU_PROPERTY_X86_ISA_1_AVX512F
: printf ("AVX512F"); break;
16760 case GNU_PROPERTY_X86_ISA_1_AVX512CD
: printf ("AVX512CD"); break;
16761 case GNU_PROPERTY_X86_ISA_1_AVX512ER
: printf ("AVX512ER"); break;
16762 case GNU_PROPERTY_X86_ISA_1_AVX512PF
: printf ("AVX512PF"); break;
16763 case GNU_PROPERTY_X86_ISA_1_AVX512VL
: printf ("AVX512VL"); break;
16764 case GNU_PROPERTY_X86_ISA_1_AVX512DQ
: printf ("AVX512DQ"); break;
16765 case GNU_PROPERTY_X86_ISA_1_AVX512BW
: printf ("AVX512BW"); break;
16766 default: printf (_("<unknown: %x>"), bit
); break;
16774 decode_x86_feature (unsigned int type
, unsigned int bitmask
)
16778 unsigned int bit
= bitmask
& (- bitmask
);
16783 case GNU_PROPERTY_X86_FEATURE_1_IBT
:
16786 case GNU_PROPERTY_X86_FEATURE_1_AND
:
16790 /* This should never happen. */
16794 case GNU_PROPERTY_X86_FEATURE_1_SHSTK
:
16797 case GNU_PROPERTY_X86_FEATURE_1_AND
:
16801 /* This should never happen. */
16806 printf (_("<unknown: %x>"), bit
);
16815 print_gnu_property_note (Filedata
* filedata
, Elf_Internal_Note
* pnote
)
16817 unsigned char * ptr
= (unsigned char *) pnote
->descdata
;
16818 unsigned char * ptr_end
= ptr
+ pnote
->descsz
;
16819 unsigned int size
= is_32bit_elf
? 4 : 8;
16821 printf (_(" Properties: "));
16823 if (pnote
->descsz
< 8 || (pnote
->descsz
% size
) != 0)
16825 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote
->descsz
);
16829 while (ptr
< ptr_end
)
16833 unsigned int datasz
;
16835 if ((size_t) (ptr_end
- ptr
) < 8)
16837 printf (_("<corrupt descsz: %#lx>\n"), pnote
->descsz
);
16841 type
= byte_get (ptr
, 4);
16842 datasz
= byte_get (ptr
+ 4, 4);
16846 if (datasz
> (size_t) (ptr_end
- ptr
))
16848 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
16853 if (type
>= GNU_PROPERTY_LOPROC
&& type
<= GNU_PROPERTY_HIPROC
)
16855 if (filedata
->file_header
.e_machine
== EM_X86_64
16856 || filedata
->file_header
.e_machine
== EM_IAMCU
16857 || filedata
->file_header
.e_machine
== EM_386
)
16861 case GNU_PROPERTY_X86_ISA_1_USED
:
16862 printf ("x86 ISA used: ");
16864 printf (_("<corrupt length: %#x> "), datasz
);
16866 decode_x86_isa (byte_get (ptr
, 4));
16869 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
16870 printf ("x86 ISA needed: ");
16872 printf (_("<corrupt length: %#x> "), datasz
);
16874 decode_x86_isa (byte_get (ptr
, 4));
16877 case GNU_PROPERTY_X86_FEATURE_1_AND
:
16878 printf ("x86 feature: ");
16880 printf (_("<corrupt length: %#x> "), datasz
);
16882 decode_x86_feature (type
, byte_get (ptr
, 4));
16894 case GNU_PROPERTY_STACK_SIZE
:
16895 printf (_("stack size: "));
16896 if (datasz
!= size
)
16897 printf (_("<corrupt length: %#x> "), datasz
);
16899 printf ("%#lx", (unsigned long) byte_get (ptr
, size
));
16902 case GNU_PROPERTY_NO_COPY_ON_PROTECTED
:
16903 printf ("no copy on protected ");
16905 printf (_("<corrupt length: %#x> "), datasz
);
16913 if (type
< GNU_PROPERTY_LOPROC
)
16914 printf (_("<unknown type %#x data: "), type
);
16915 else if (type
< GNU_PROPERTY_LOUSER
)
16916 printf (_("<procesor-specific type %#x data: "), type
);
16918 printf (_("<application-specific type %#x data: "), type
);
16919 for (j
= 0; j
< datasz
; ++j
)
16920 printf ("%02x ", ptr
[j
] & 0xff);
16924 ptr
+= ((datasz
+ (size
- 1)) & ~ (size
- 1));
16925 if (ptr
== ptr_end
)
16938 print_gnu_note (Filedata
* filedata
, Elf_Internal_Note
*pnote
)
16940 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
16941 switch (pnote
->type
)
16943 case NT_GNU_BUILD_ID
:
16947 printf (_(" Build ID: "));
16948 for (i
= 0; i
< pnote
->descsz
; ++i
)
16949 printf ("%02x", pnote
->descdata
[i
] & 0xff);
16954 case NT_GNU_ABI_TAG
:
16956 unsigned long os
, major
, minor
, subminor
;
16957 const char *osname
;
16959 /* PR 17531: file: 030-599401-0.004. */
16960 if (pnote
->descsz
< 16)
16962 printf (_(" <corrupt GNU_ABI_TAG>\n"));
16966 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
16967 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
16968 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
16969 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
16973 case GNU_ABI_TAG_LINUX
:
16976 case GNU_ABI_TAG_HURD
:
16979 case GNU_ABI_TAG_SOLARIS
:
16980 osname
= "Solaris";
16982 case GNU_ABI_TAG_FREEBSD
:
16983 osname
= "FreeBSD";
16985 case GNU_ABI_TAG_NETBSD
:
16988 case GNU_ABI_TAG_SYLLABLE
:
16989 osname
= "Syllable";
16991 case GNU_ABI_TAG_NACL
:
16995 osname
= "Unknown";
16999 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
17000 major
, minor
, subminor
);
17004 case NT_GNU_GOLD_VERSION
:
17008 printf (_(" Version: "));
17009 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
17010 printf ("%c", pnote
->descdata
[i
]);
17017 unsigned long num_entries
, mask
;
17019 /* Hardware capabilities information. Word 0 is the number of entries.
17020 Word 1 is a bitmask of enabled entries. The rest of the descriptor
17021 is a series of entries, where each entry is a single byte followed
17022 by a nul terminated string. The byte gives the bit number to test
17023 if enabled in the bitmask. */
17024 printf (_(" Hardware Capabilities: "));
17025 if (pnote
->descsz
< 8)
17027 error (_("<corrupt GNU_HWCAP>\n"));
17030 num_entries
= byte_get ((unsigned char *) pnote
->descdata
, 4);
17031 mask
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
17032 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries
, mask
);
17033 /* FIXME: Add code to display the entries... */
17037 case NT_GNU_PROPERTY_TYPE_0
:
17038 print_gnu_property_note (filedata
, pnote
);
17042 /* Handle unrecognised types. An error message should have already been
17043 created by get_gnu_elf_note_type(), so all that we need to do is to
17044 display the data. */
17048 printf (_(" Description data: "));
17049 for (i
= 0; i
< pnote
->descsz
; ++i
)
17050 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
17059 static const char *
17060 get_v850_elf_note_type (enum v850_notes n_type
)
17062 static char buff
[64];
17066 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
17067 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
17068 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
17069 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
17070 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
17071 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
17073 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
17079 print_v850_note (Elf_Internal_Note
* pnote
)
17083 if (pnote
->descsz
!= 4)
17086 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
17090 printf (_("not set\n"));
17094 switch (pnote
->type
)
17096 case V850_NOTE_ALIGNMENT
:
17099 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return TRUE
;
17100 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return TRUE
;
17104 case V850_NOTE_DATA_SIZE
:
17107 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return TRUE
;
17108 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return TRUE
;
17112 case V850_NOTE_FPU_INFO
:
17115 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return TRUE
;
17116 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return TRUE
;
17120 case V850_NOTE_MMU_INFO
:
17121 case V850_NOTE_CACHE_INFO
:
17122 case V850_NOTE_SIMD_INFO
:
17123 if (val
== EF_RH850_SIMD
)
17125 printf (_("yes\n"));
17131 /* An 'unknown note type' message will already have been displayed. */
17135 printf (_("unknown value: %x\n"), val
);
17140 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
17142 unsigned int version
;
17144 switch (pnote
->type
)
17146 case NT_NETBSD_IDENT
:
17147 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
17148 if ((version
/ 10000) % 100)
17149 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
17150 version
, version
/ 100000000, (version
/ 1000000) % 100,
17151 (version
/ 10000) % 100 > 26 ? "Z" : "",
17152 'A' + (version
/ 10000) % 26);
17154 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
17155 version
, version
/ 100000000, (version
/ 1000000) % 100,
17156 (version
/ 100) % 100);
17159 case NT_NETBSD_MARCH
:
17160 printf (" NetBSD\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
17165 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote
->descsz
,
17171 static const char *
17172 get_freebsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
17176 case NT_FREEBSD_THRMISC
:
17177 return _("NT_THRMISC (thrmisc structure)");
17178 case NT_FREEBSD_PROCSTAT_PROC
:
17179 return _("NT_PROCSTAT_PROC (proc data)");
17180 case NT_FREEBSD_PROCSTAT_FILES
:
17181 return _("NT_PROCSTAT_FILES (files data)");
17182 case NT_FREEBSD_PROCSTAT_VMMAP
:
17183 return _("NT_PROCSTAT_VMMAP (vmmap data)");
17184 case NT_FREEBSD_PROCSTAT_GROUPS
:
17185 return _("NT_PROCSTAT_GROUPS (groups data)");
17186 case NT_FREEBSD_PROCSTAT_UMASK
:
17187 return _("NT_PROCSTAT_UMASK (umask data)");
17188 case NT_FREEBSD_PROCSTAT_RLIMIT
:
17189 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
17190 case NT_FREEBSD_PROCSTAT_OSREL
:
17191 return _("NT_PROCSTAT_OSREL (osreldate data)");
17192 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
17193 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
17194 case NT_FREEBSD_PROCSTAT_AUXV
:
17195 return _("NT_PROCSTAT_AUXV (auxv data)");
17196 case NT_FREEBSD_PTLWPINFO
:
17197 return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
17199 return get_note_type (filedata
, e_type
);
17202 static const char *
17203 get_netbsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
17205 static char buff
[64];
17207 if (e_type
== NT_NETBSDCORE_PROCINFO
)
17208 return _("NetBSD procinfo structure");
17210 /* As of Jan 2002 there are no other machine-independent notes
17211 defined for NetBSD core files. If the note type is less
17212 than the start of the machine-dependent note types, we don't
17215 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
17217 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17221 switch (filedata
->file_header
.e_machine
)
17223 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
17224 and PT_GETFPREGS == mach+2. */
17229 case EM_SPARC32PLUS
:
17233 case NT_NETBSDCORE_FIRSTMACH
+ 0:
17234 return _("PT_GETREGS (reg structure)");
17235 case NT_NETBSDCORE_FIRSTMACH
+ 2:
17236 return _("PT_GETFPREGS (fpreg structure)");
17242 /* On all other arch's, PT_GETREGS == mach+1 and
17243 PT_GETFPREGS == mach+3. */
17247 case NT_NETBSDCORE_FIRSTMACH
+ 1:
17248 return _("PT_GETREGS (reg structure)");
17249 case NT_NETBSDCORE_FIRSTMACH
+ 3:
17250 return _("PT_GETFPREGS (fpreg structure)");
17256 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
17257 e_type
- NT_NETBSDCORE_FIRSTMACH
);
17261 static const char *
17262 get_stapsdt_note_type (unsigned e_type
)
17264 static char buff
[64];
17269 return _("NT_STAPSDT (SystemTap probe descriptors)");
17275 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17280 print_stapsdt_note (Elf_Internal_Note
*pnote
)
17282 int addr_size
= is_32bit_elf
? 4 : 8;
17283 char *data
= pnote
->descdata
;
17284 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
17285 bfd_vma pc
, base_addr
, semaphore
;
17286 char *provider
, *probe
, *arg_fmt
;
17288 pc
= byte_get ((unsigned char *) data
, addr_size
);
17290 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
17292 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
17296 data
+= strlen (data
) + 1;
17298 data
+= strlen (data
) + 1;
17300 data
+= strlen (data
) + 1;
17302 printf (_(" Provider: %s\n"), provider
);
17303 printf (_(" Name: %s\n"), probe
);
17304 printf (_(" Location: "));
17305 print_vma (pc
, FULL_HEX
);
17306 printf (_(", Base: "));
17307 print_vma (base_addr
, FULL_HEX
);
17308 printf (_(", Semaphore: "));
17309 print_vma (semaphore
, FULL_HEX
);
17311 printf (_(" Arguments: %s\n"), arg_fmt
);
17313 return data
== data_end
;
17316 static const char *
17317 get_ia64_vms_note_type (unsigned e_type
)
17319 static char buff
[64];
17324 return _("NT_VMS_MHD (module header)");
17326 return _("NT_VMS_LNM (language name)");
17328 return _("NT_VMS_SRC (source files)");
17330 return "NT_VMS_TITLE";
17332 return _("NT_VMS_EIDC (consistency check)");
17333 case NT_VMS_FPMODE
:
17334 return _("NT_VMS_FPMODE (FP mode)");
17335 case NT_VMS_LINKTIME
:
17336 return "NT_VMS_LINKTIME";
17337 case NT_VMS_IMGNAM
:
17338 return _("NT_VMS_IMGNAM (image name)");
17340 return _("NT_VMS_IMGID (image id)");
17341 case NT_VMS_LINKID
:
17342 return _("NT_VMS_LINKID (link id)");
17343 case NT_VMS_IMGBID
:
17344 return _("NT_VMS_IMGBID (build id)");
17345 case NT_VMS_GSTNAM
:
17346 return _("NT_VMS_GSTNAM (sym table name)");
17347 case NT_VMS_ORIG_DYN
:
17348 return "NT_VMS_ORIG_DYN";
17349 case NT_VMS_PATCHTIME
:
17350 return "NT_VMS_PATCHTIME";
17352 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17358 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
17360 switch (pnote
->type
)
17363 if (pnote
->descsz
> 36)
17365 size_t l
= strlen (pnote
->descdata
+ 34);
17366 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
17367 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
17368 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
17369 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
17372 printf (_(" Invalid size\n"));
17375 printf (_(" Language: %s\n"), pnote
->descdata
);
17378 case NT_VMS_FPMODE
:
17379 printf (_(" Floating Point mode: "));
17380 printf ("0x%016" BFD_VMA_FMT
"x\n",
17381 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
17383 case NT_VMS_LINKTIME
:
17384 printf (_(" Link time: "));
17386 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
17389 case NT_VMS_PATCHTIME
:
17390 printf (_(" Patch time: "));
17392 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
17395 case NT_VMS_ORIG_DYN
:
17396 printf (_(" Major id: %u, minor id: %u\n"),
17397 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
17398 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
17399 printf (_(" Last modified : "));
17401 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
17402 printf (_("\n Link flags : "));
17403 printf ("0x%016" BFD_VMA_FMT
"x\n",
17404 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
17405 printf (_(" Header flags: 0x%08x\n"),
17406 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
17407 printf (_(" Image id : %s\n"), pnote
->descdata
+ 32);
17410 case NT_VMS_IMGNAM
:
17411 printf (_(" Image name: %s\n"), pnote
->descdata
);
17413 case NT_VMS_GSTNAM
:
17414 printf (_(" Global symbol table name: %s\n"), pnote
->descdata
);
17417 printf (_(" Image id: %s\n"), pnote
->descdata
);
17419 case NT_VMS_LINKID
:
17420 printf (_(" Linker id: %s\n"), pnote
->descdata
);
17428 /* Find the symbol associated with a build attribute that is attached
17429 to address OFFSET. If PNAME is non-NULL then store the name of
17430 the symbol (if found) in the provided pointer, Returns NULL if a
17431 symbol could not be found. */
17433 static Elf_Internal_Sym
*
17434 get_symbol_for_build_attribute (Filedata
* filedata
,
17435 unsigned long offset
,
17436 bfd_boolean is_open_attr
,
17437 const char ** pname
)
17439 static Filedata
* saved_filedata
= NULL
;
17440 static char * strtab
;
17441 static unsigned long strtablen
;
17442 static Elf_Internal_Sym
* symtab
;
17443 static unsigned long nsyms
;
17444 Elf_Internal_Sym
* saved_sym
= NULL
;
17445 Elf_Internal_Sym
* sym
;
17447 if (filedata
->section_headers
!= NULL
17448 && (saved_filedata
== NULL
|| filedata
!= saved_filedata
))
17450 Elf_Internal_Shdr
* symsec
;
17452 /* Load the symbol and string sections. */
17453 for (symsec
= filedata
->section_headers
;
17454 symsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
17457 if (symsec
->sh_type
== SHT_SYMTAB
)
17459 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & nsyms
);
17461 if (symsec
->sh_link
< filedata
->file_header
.e_shnum
)
17463 Elf_Internal_Shdr
* strtab_sec
= filedata
->section_headers
+ symsec
->sh_link
;
17465 strtab
= (char *) get_data (NULL
, filedata
, strtab_sec
->sh_offset
,
17466 1, strtab_sec
->sh_size
,
17467 _("string table"));
17468 strtablen
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
17472 saved_filedata
= filedata
;
17475 if (symtab
== NULL
|| strtab
== NULL
)
17478 /* Find a symbol whose value matches offset. */
17479 for (sym
= symtab
; sym
< symtab
+ nsyms
; sym
++)
17480 if (sym
->st_value
== offset
)
17482 if (sym
->st_name
>= strtablen
)
17483 /* Huh ? This should not happen. */
17486 if (strtab
[sym
->st_name
] == 0)
17489 /* The AArch64 and ARM architectures define mapping symbols
17490 (eg $d, $x, $t) which we want to ignore. */
17491 if (strtab
[sym
->st_name
] == '$'
17492 && strtab
[sym
->st_name
+ 1] != 0
17493 && strtab
[sym
->st_name
+ 2] == 0)
17498 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
17499 and FILE or OBJECT symbols over NOTYPE symbols. We skip
17500 FUNC symbols entirely. */
17501 switch (ELF_ST_TYPE (sym
->st_info
))
17508 /* If the symbol has a size associated
17509 with it then we can stop searching. */
17510 sym
= symtab
+ nsyms
;
17515 /* Ignore function symbols. */
17522 switch (ELF_ST_BIND (sym
->st_info
))
17525 if (saved_sym
== NULL
17526 || ELF_ST_TYPE (saved_sym
->st_info
) != STT_OBJECT
)
17531 if (saved_sym
== NULL
)
17541 if (ELF_ST_TYPE (sym
->st_info
) != STT_FUNC
)
17549 if (saved_sym
&& pname
)
17550 * pname
= strtab
+ saved_sym
->st_name
;
17556 print_gnu_build_attribute_description (Elf_Internal_Note
* pnote
,
17557 Filedata
* filedata
)
17559 static unsigned long global_offset
= 0;
17560 static unsigned long global_end
= 0;
17561 static unsigned long func_offset
= 0;
17562 static unsigned long func_end
= 0;
17564 Elf_Internal_Sym
* sym
;
17566 unsigned long start
;
17568 bfd_boolean is_open_attr
= pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
;
17570 switch (pnote
->descsz
)
17573 /* A zero-length description means that the range of
17574 the previous note of the same type should be used. */
17577 if (global_end
> global_offset
)
17578 printf (_(" Applies to region from %#lx to %#lx\n"),
17579 global_offset
, global_end
);
17581 printf (_(" Applies to region from %#lx\n"), global_offset
);
17585 if (func_end
> func_offset
)
17586 printf (_(" Applies to region from %#lx to %#lx\n"), func_offset
, func_end
);
17588 printf (_(" Applies to region from %#lx\n"), func_offset
);
17593 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
17600 /* FIXME: We should check that version 3+ notes are being used here... */
17601 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
17602 end
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
17606 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
17612 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
17613 end
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 8);
17617 error (_(" <invalid description size: %lx>\n"), pnote
->descsz
);
17618 printf (_(" <invalid descsz>"));
17623 sym
= get_symbol_for_build_attribute (filedata
, start
, is_open_attr
, & name
);
17624 /* As of version 5 of the annobin plugin, filename symbols are biased by 2
17625 in order to avoid them being confused with the start address of the
17626 first function in the file... */
17627 if (sym
== NULL
&& is_open_attr
)
17628 sym
= get_symbol_for_build_attribute (filedata
, start
+ 2, is_open_attr
,
17631 if (end
== 0 && sym
!= NULL
&& sym
->st_size
> 0)
17632 end
= start
+ sym
->st_size
;
17636 /* FIXME: Need to properly allow for section alignment. 16 is just the alignment used on x86_64. */
17637 if (global_end
> 0 && start
> BFD_ALIGN (global_end
, 16))
17638 warn (_("Gap in build notes detected from %#lx to %#lx\n"),
17639 global_end
+ 1, start
- 1);
17641 printf (_(" Applies to region from %#lx"), start
);
17642 global_offset
= start
;
17646 printf (_(" to %#lx"), end
);
17652 printf (_(" Applies to region from %#lx"), start
);
17653 func_offset
= start
;
17657 printf (_(" to %#lx"), end
);
17663 printf (_(" (%s)"), name
);
17670 print_gnu_build_attribute_name (Elf_Internal_Note
* pnote
)
17672 static const char string_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING
, 0 };
17673 static const char number_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
, 0 };
17674 static const char bool_expected
[3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
, 0 };
17676 char name_attribute
;
17677 const char * expected_types
;
17678 const char * name
= pnote
->namedata
;
17682 if (name
== NULL
|| pnote
->namesz
< 2)
17684 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
17685 print_symbol (-20, _(" <corrupt name>"));
17694 /* Version 2 of the spec adds a "GA" prefix to the name field. */
17695 if (name
[0] == 'G' && name
[1] == 'A')
17697 if (pnote
->namesz
< 4)
17699 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
17700 print_symbol (-20, _(" <corrupt name>"));
17709 switch ((name_type
= * name
))
17711 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
17712 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
17713 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
17714 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
17715 printf ("%c", * name
);
17719 error (_("unrecognised attribute type in name field: %d\n"), name_type
);
17720 print_symbol (-20, _("<unknown name type>"));
17727 switch ((name_attribute
= * name
))
17729 case GNU_BUILD_ATTRIBUTE_VERSION
:
17730 text
= _("<version>");
17731 expected_types
= string_expected
;
17734 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
17735 text
= _("<stack prot>");
17736 expected_types
= "!+*";
17739 case GNU_BUILD_ATTRIBUTE_RELRO
:
17740 text
= _("<relro>");
17741 expected_types
= bool_expected
;
17744 case GNU_BUILD_ATTRIBUTE_STACK_SIZE
:
17745 text
= _("<stack size>");
17746 expected_types
= number_expected
;
17749 case GNU_BUILD_ATTRIBUTE_TOOL
:
17750 text
= _("<tool>");
17751 expected_types
= string_expected
;
17754 case GNU_BUILD_ATTRIBUTE_ABI
:
17756 expected_types
= "$*";
17759 case GNU_BUILD_ATTRIBUTE_PIC
:
17761 expected_types
= number_expected
;
17764 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM
:
17765 text
= _("<short enum>");
17766 expected_types
= bool_expected
;
17770 if (ISPRINT (* name
))
17772 int len
= strnlen (name
, pnote
->namesz
- (name
- pnote
->namedata
)) + 1;
17774 if (len
> left
&& ! do_wide
)
17776 printf ("%.*s:", len
, name
);
17782 static char tmpbuf
[128];
17784 error (_("unrecognised byte in name field: %d\n"), * name
);
17785 sprintf (tmpbuf
, _("<unknown:_%d>"), * name
);
17789 expected_types
= "*$!+";
17794 left
-= printf ("%s", text
);
17796 if (strchr (expected_types
, name_type
) == NULL
)
17797 warn (_("attribute does not have an expected type (%c)\n"), name_type
);
17799 if ((unsigned long)(name
- pnote
->namedata
) > pnote
->namesz
)
17801 error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
17802 (unsigned long) pnote
->namesz
,
17803 (long) (name
- pnote
->namedata
));
17807 if (left
< 1 && ! do_wide
)
17812 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
17814 unsigned int bytes
;
17815 unsigned long long val
= 0;
17816 unsigned int shift
= 0;
17817 char * decoded
= NULL
;
17819 bytes
= pnote
->namesz
- (name
- pnote
->namedata
);
17821 /* The -1 is because the name field is always 0 terminated, and we
17822 want to be able to ensure that the shift in the while loop below
17823 will not overflow. */
17826 if (bytes
> sizeof (val
))
17828 error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
17830 bytes
= sizeof (val
);
17832 /* We do not bother to warn if bytes == 0 as this can
17833 happen with some early versions of the gcc plugin. */
17837 unsigned long byte
= (* name
++) & 0xff;
17839 val
|= byte
<< shift
;
17843 switch (name_attribute
)
17845 case GNU_BUILD_ATTRIBUTE_PIC
:
17848 case 0: decoded
= "static"; break;
17849 case 1: decoded
= "pic"; break;
17850 case 2: decoded
= "PIC"; break;
17851 case 3: decoded
= "pie"; break;
17852 case 4: decoded
= "PIE"; break;
17856 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
17859 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
17860 case 0: decoded
= "off"; break;
17861 case 1: decoded
= "on"; break;
17862 case 2: decoded
= "all"; break;
17863 case 3: decoded
= "strong"; break;
17864 case 4: decoded
= "explicit"; break;
17872 if (decoded
!= NULL
)
17874 print_symbol (-left
, decoded
);
17885 left
-= printf ("0x%llx", val
);
17887 left
-= printf ("0x%-.*llx", left
, val
);
17891 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
17892 left
-= print_symbol (- left
, name
);
17894 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
17895 left
-= print_symbol (- left
, "true");
17897 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
17898 left
-= print_symbol (- left
, "false");
17902 if (do_wide
&& left
> 0)
17903 printf ("%-*s", left
, " ");
17908 /* Note that by the ELF standard, the name field is already null byte
17909 terminated, and namesz includes the terminating null byte.
17910 I.E. the value of namesz for the name "FSF" is 4.
17912 If the value of namesz is zero, there is no name present. */
17915 process_note (Elf_Internal_Note
* pnote
,
17916 Filedata
* filedata
)
17918 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
17921 if (pnote
->namesz
== 0)
17922 /* If there is no note name, then use the default set of
17923 note type strings. */
17924 nt
= get_note_type (filedata
, pnote
->type
);
17926 else if (const_strneq (pnote
->namedata
, "GNU"))
17927 /* GNU-specific object file notes. */
17928 nt
= get_gnu_elf_note_type (pnote
->type
);
17930 else if (const_strneq (pnote
->namedata
, "FreeBSD"))
17931 /* FreeBSD-specific core file notes. */
17932 nt
= get_freebsd_elfcore_note_type (filedata
, pnote
->type
);
17934 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
17935 /* NetBSD-specific core file notes. */
17936 nt
= get_netbsd_elfcore_note_type (filedata
, pnote
->type
);
17938 else if (const_strneq (pnote
->namedata
, "NetBSD"))
17939 /* NetBSD-specific core file notes. */
17940 return process_netbsd_elf_note (pnote
);
17942 else if (strneq (pnote
->namedata
, "SPU/", 4))
17944 /* SPU-specific core file notes. */
17945 nt
= pnote
->namedata
+ 4;
17949 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
17950 /* VMS/ia64-specific file notes. */
17951 nt
= get_ia64_vms_note_type (pnote
->type
);
17953 else if (const_strneq (pnote
->namedata
, "stapsdt"))
17954 nt
= get_stapsdt_note_type (pnote
->type
);
17957 /* Don't recognize this note name; just use the default set of
17958 note type strings. */
17959 nt
= get_note_type (filedata
, pnote
->type
);
17963 if (((const_strneq (pnote
->namedata
, "GA")
17964 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
17965 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
17966 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
17967 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
17968 print_gnu_build_attribute_name (pnote
);
17970 print_symbol (-20, name
);
17973 printf (" 0x%08lx\t%s\t", pnote
->descsz
, nt
);
17975 printf (" 0x%08lx\t%s\n", pnote
->descsz
, nt
);
17977 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
17978 return print_ia64_vms_note (pnote
);
17979 else if (const_strneq (pnote
->namedata
, "GNU"))
17980 return print_gnu_note (filedata
, pnote
);
17981 else if (const_strneq (pnote
->namedata
, "stapsdt"))
17982 return print_stapsdt_note (pnote
);
17983 else if (const_strneq (pnote
->namedata
, "CORE"))
17984 return print_core_note (pnote
);
17985 else if (((const_strneq (pnote
->namedata
, "GA")
17986 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
17987 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
17988 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
17989 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
17990 return print_gnu_build_attribute_description (pnote
, filedata
);
17996 printf (_(" description data: "));
17997 for (i
= 0; i
< pnote
->descsz
; i
++)
17998 printf ("%02x ", pnote
->descdata
[i
]);
18010 process_notes_at (Filedata
* filedata
,
18011 Elf_Internal_Shdr
* section
,
18016 Elf_External_Note
* pnotes
;
18017 Elf_External_Note
* external
;
18019 bfd_boolean res
= TRUE
;
18026 pnotes
= (Elf_External_Note
*) get_section_contents (section
, filedata
);
18029 if (! apply_relocations (filedata
, section
, (unsigned char *) pnotes
, length
, NULL
, NULL
))
18034 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
18037 if (pnotes
== NULL
)
18043 printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (filedata
, section
));
18045 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
18046 (unsigned long) offset
, (unsigned long) length
);
18048 /* NB: Some note sections may have alignment value of 0 or 1. gABI
18049 specifies that notes should be aligned to 4 bytes in 32-bit
18050 objects and to 8 bytes in 64-bit objects. As a Linux extension,
18051 we also support 4 byte alignment in 64-bit objects. If section
18052 alignment is less than 4, we treate alignment as 4 bytes. */
18055 else if (align
!= 4 && align
!= 8)
18057 warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
18062 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
18064 end
= (char *) pnotes
+ length
;
18065 while ((char *) external
< end
)
18067 Elf_Internal_Note inote
;
18070 char * temp
= NULL
;
18071 size_t data_remaining
= end
- (char *) external
;
18073 if (!is_ia64_vms (filedata
))
18075 /* PR binutils/15191
18076 Make sure that there is enough data to read. */
18077 min_notesz
= offsetof (Elf_External_Note
, name
);
18078 if (data_remaining
< min_notesz
)
18080 warn (ngettext ("Corrupt note: only %ld byte remains, "
18081 "not enough for a full note\n",
18082 "Corrupt note: only %ld bytes remain, "
18083 "not enough for a full note\n",
18085 (long) data_remaining
);
18088 data_remaining
-= min_notesz
;
18090 inote
.type
= BYTE_GET (external
->type
);
18091 inote
.namesz
= BYTE_GET (external
->namesz
);
18092 inote
.namedata
= external
->name
;
18093 inote
.descsz
= BYTE_GET (external
->descsz
);
18094 inote
.descdata
= ((char *) external
18095 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
18096 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
18097 next
= ((char *) external
18098 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
18102 Elf64_External_VMS_Note
*vms_external
;
18104 /* PR binutils/15191
18105 Make sure that there is enough data to read. */
18106 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
18107 if (data_remaining
< min_notesz
)
18109 warn (ngettext ("Corrupt note: only %ld byte remains, "
18110 "not enough for a full note\n",
18111 "Corrupt note: only %ld bytes remain, "
18112 "not enough for a full note\n",
18114 (long) data_remaining
);
18117 data_remaining
-= min_notesz
;
18119 vms_external
= (Elf64_External_VMS_Note
*) external
;
18120 inote
.type
= BYTE_GET (vms_external
->type
);
18121 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
18122 inote
.namedata
= vms_external
->name
;
18123 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
18124 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
18125 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
18126 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
18129 /* PR 17531: file: 3443835e. */
18130 /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
18131 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
18132 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
18133 || (size_t) (next
- inote
.descdata
) < inote
.descsz
18134 || ((size_t) (next
- inote
.descdata
)
18135 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
18137 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
18138 (unsigned long) ((char *) external
- (char *) pnotes
));
18139 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
18140 inote
.type
, inote
.namesz
, inote
.descsz
, (int) align
);
18144 external
= (Elf_External_Note
*) next
;
18146 /* Verify that name is null terminated. It appears that at least
18147 one version of Linux (RedHat 6.0) generates corefiles that don't
18148 comply with the ELF spec by failing to include the null byte in
18150 if (inote
.namedata
[inote
.namesz
- 1] != '\0')
18152 if ((size_t) (inote
.descdata
- inote
.namedata
) == inote
.namesz
)
18154 temp
= (char *) malloc (inote
.namesz
+ 1);
18157 error (_("Out of memory allocating space for inote name\n"));
18162 memcpy (temp
, inote
.namedata
, inote
.namesz
);
18163 inote
.namedata
= temp
;
18165 inote
.namedata
[inote
.namesz
] = 0;
18168 if (! process_note (& inote
, filedata
))
18184 process_corefile_note_segments (Filedata
* filedata
)
18186 Elf_Internal_Phdr
* segment
;
18188 bfd_boolean res
= TRUE
;
18190 if (! get_program_headers (filedata
))
18193 for (i
= 0, segment
= filedata
->program_headers
;
18194 i
< filedata
->file_header
.e_phnum
;
18197 if (segment
->p_type
== PT_NOTE
)
18198 if (! process_notes_at (filedata
, NULL
,
18199 (bfd_vma
) segment
->p_offset
,
18200 (bfd_vma
) segment
->p_filesz
,
18201 (bfd_vma
) segment
->p_align
))
18209 process_v850_notes (Filedata
* filedata
, bfd_vma offset
, bfd_vma length
)
18211 Elf_External_Note
* pnotes
;
18212 Elf_External_Note
* external
;
18214 bfd_boolean res
= TRUE
;
18219 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
18221 if (pnotes
== NULL
)
18225 end
= (char*) pnotes
+ length
;
18227 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
18228 (unsigned long) offset
, (unsigned long) length
);
18230 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
18232 Elf_External_Note
* next
;
18233 Elf_Internal_Note inote
;
18235 inote
.type
= BYTE_GET (external
->type
);
18236 inote
.namesz
= BYTE_GET (external
->namesz
);
18237 inote
.namedata
= external
->name
;
18238 inote
.descsz
= BYTE_GET (external
->descsz
);
18239 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
18240 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
18242 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
18244 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
18245 inote
.descdata
= inote
.namedata
;
18249 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
18251 if ( ((char *) next
> end
)
18252 || ((char *) next
< (char *) pnotes
))
18254 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
18255 (unsigned long) ((char *) external
- (char *) pnotes
));
18256 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
18257 inote
.type
, inote
.namesz
, inote
.descsz
);
18263 /* Prevent out-of-bounds indexing. */
18264 if ( inote
.namedata
+ inote
.namesz
> end
18265 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
18267 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
18268 (unsigned long) ((char *) external
- (char *) pnotes
));
18269 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
18270 inote
.type
, inote
.namesz
, inote
.descsz
);
18274 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
18276 if (! print_v850_note (& inote
))
18279 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
18280 inote
.namesz
, inote
.descsz
);
18290 process_note_sections (Filedata
* filedata
)
18292 Elf_Internal_Shdr
* section
;
18294 unsigned int n
= 0;
18295 bfd_boolean res
= TRUE
;
18297 for (i
= 0, section
= filedata
->section_headers
;
18298 i
< filedata
->file_header
.e_shnum
&& section
!= NULL
;
18301 if (section
->sh_type
== SHT_NOTE
)
18303 if (! process_notes_at (filedata
, section
,
18304 (bfd_vma
) section
->sh_offset
,
18305 (bfd_vma
) section
->sh_size
,
18306 (bfd_vma
) section
->sh_addralign
))
18311 if (( filedata
->file_header
.e_machine
== EM_V800
18312 || filedata
->file_header
.e_machine
== EM_V850
18313 || filedata
->file_header
.e_machine
== EM_CYGNUS_V850
)
18314 && section
->sh_type
== SHT_RENESAS_INFO
)
18316 if (! process_v850_notes (filedata
,
18317 (bfd_vma
) section
->sh_offset
,
18318 (bfd_vma
) section
->sh_size
))
18325 /* Try processing NOTE segments instead. */
18326 return process_corefile_note_segments (filedata
);
18332 process_notes (Filedata
* filedata
)
18334 /* If we have not been asked to display the notes then do nothing. */
18338 if (filedata
->file_header
.e_type
!= ET_CORE
)
18339 return process_note_sections (filedata
);
18341 /* No program headers means no NOTE segment. */
18342 if (filedata
->file_header
.e_phnum
> 0)
18343 return process_corefile_note_segments (filedata
);
18345 printf (_("No note segments present in the core file.\n"));
18349 static unsigned char *
18350 display_public_gnu_attributes (unsigned char * start
,
18351 const unsigned char * const end
)
18353 printf (_(" Unknown GNU attribute: %s\n"), start
);
18355 start
+= strnlen ((char *) start
, end
- start
);
18356 display_raw_attribute (start
, end
);
18358 return (unsigned char *) end
;
18361 static unsigned char *
18362 display_generic_attribute (unsigned char * start
,
18364 const unsigned char * const end
)
18367 return (unsigned char *) end
;
18369 return display_tag_value (tag
, start
, end
);
18373 process_arch_specific (Filedata
* filedata
)
18378 switch (filedata
->file_header
.e_machine
)
18381 case EM_ARC_COMPACT
:
18382 case EM_ARC_COMPACT2
:
18383 return process_attributes (filedata
, "ARC", SHT_ARC_ATTRIBUTES
,
18384 display_arc_attribute
,
18385 display_generic_attribute
);
18387 return process_attributes (filedata
, "aeabi", SHT_ARM_ATTRIBUTES
,
18388 display_arm_attribute
,
18389 display_generic_attribute
);
18392 case EM_MIPS_RS3_LE
:
18393 return process_mips_specific (filedata
);
18396 return process_attributes (filedata
, "mspabi", SHT_MSP430_ATTRIBUTES
,
18397 display_msp430x_attribute
,
18398 display_generic_attribute
);
18401 return process_nds32_specific (filedata
);
18405 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
18406 display_power_gnu_attribute
);
18410 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
18411 display_s390_gnu_attribute
);
18414 case EM_SPARC32PLUS
:
18416 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
18417 display_sparc_gnu_attribute
);
18420 return process_attributes (filedata
, "c6xabi", SHT_C6000_ATTRIBUTES
,
18421 display_tic6x_attribute
,
18422 display_generic_attribute
);
18425 return process_attributes (filedata
, "gnu", SHT_GNU_ATTRIBUTES
,
18426 display_public_gnu_attributes
,
18427 display_generic_attribute
);
18432 get_file_header (Filedata
* filedata
)
18434 /* Read in the identity array. */
18435 if (fread (filedata
->file_header
.e_ident
, EI_NIDENT
, 1, filedata
->handle
) != 1)
18438 /* Determine how to read the rest of the header. */
18439 switch (filedata
->file_header
.e_ident
[EI_DATA
])
18444 byte_get
= byte_get_little_endian
;
18445 byte_put
= byte_put_little_endian
;
18448 byte_get
= byte_get_big_endian
;
18449 byte_put
= byte_put_big_endian
;
18453 /* For now we only support 32 bit and 64 bit ELF files. */
18454 is_32bit_elf
= (filedata
->file_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
18456 /* Read in the rest of the header. */
18459 Elf32_External_Ehdr ehdr32
;
18461 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
18464 filedata
->file_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
18465 filedata
->file_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
18466 filedata
->file_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
18467 filedata
->file_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
18468 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
18469 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
18470 filedata
->file_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
18471 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
18472 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
18473 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
18474 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
18475 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
18476 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
18480 Elf64_External_Ehdr ehdr64
;
18482 /* If we have been compiled with sizeof (bfd_vma) == 4, then
18483 we will not be able to cope with the 64bit data found in
18484 64 ELF files. Detect this now and abort before we start
18485 overwriting things. */
18486 if (sizeof (bfd_vma
) < 8)
18488 error (_("This instance of readelf has been built without support for a\n\
18489 64 bit data type and so it cannot read 64 bit ELF files.\n"));
18493 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
18496 filedata
->file_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
18497 filedata
->file_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
18498 filedata
->file_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
18499 filedata
->file_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
18500 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
18501 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
18502 filedata
->file_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
18503 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
18504 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
18505 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
18506 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
18507 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
18508 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
18511 if (filedata
->file_header
.e_shoff
)
18513 /* There may be some extensions in the first section header. Don't
18514 bomb if we can't read it. */
18516 get_32bit_section_headers (filedata
, TRUE
);
18518 get_64bit_section_headers (filedata
, TRUE
);
18525 close_file (Filedata
* filedata
)
18529 if (filedata
->handle
)
18530 fclose (filedata
->handle
);
18536 close_debug_file (void * data
)
18538 close_file ((Filedata
*) data
);
18542 open_file (const char * pathname
)
18544 struct stat statbuf
;
18545 Filedata
* filedata
= NULL
;
18547 if (stat (pathname
, & statbuf
) < 0
18548 || ! S_ISREG (statbuf
.st_mode
))
18551 filedata
= calloc (1, sizeof * filedata
);
18552 if (filedata
== NULL
)
18555 filedata
->handle
= fopen (pathname
, "rb");
18556 if (filedata
->handle
== NULL
)
18559 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
18560 filedata
->file_name
= pathname
;
18562 if (! get_file_header (filedata
))
18565 if (filedata
->file_header
.e_shoff
)
18569 /* Read the section headers again, this time for real. */
18571 res
= get_32bit_section_headers (filedata
, FALSE
);
18573 res
= get_64bit_section_headers (filedata
, FALSE
);
18584 if (filedata
->handle
)
18585 fclose (filedata
->handle
);
18592 open_debug_file (const char * pathname
)
18594 return open_file (pathname
);
18597 /* Process one ELF object file according to the command line options.
18598 This file may actually be stored in an archive. The file is
18599 positioned at the start of the ELF object. Returns TRUE if no
18600 problems were encountered, FALSE otherwise. */
18603 process_object (Filedata
* filedata
)
18605 Filedata
* separates
;
18607 bfd_boolean res
= TRUE
;
18609 if (! get_file_header (filedata
))
18611 error (_("%s: Failed to read file header\n"), filedata
->file_name
);
18615 /* Initialise per file variables. */
18616 for (i
= ARRAY_SIZE (version_info
); i
--;)
18617 version_info
[i
] = 0;
18619 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
18620 dynamic_info
[i
] = 0;
18621 dynamic_info_DT_GNU_HASH
= 0;
18623 /* Process the file. */
18625 printf (_("\nFile: %s\n"), filedata
->file_name
);
18627 /* Initialise the dump_sects array from the cmdline_dump_sects array.
18628 Note we do this even if cmdline_dump_sects is empty because we
18629 must make sure that the dump_sets array is zeroed out before each
18630 object file is processed. */
18631 if (filedata
->num_dump_sects
> cmdline
.num_dump_sects
)
18632 memset (filedata
->dump_sects
, 0, filedata
->num_dump_sects
* sizeof (* filedata
->dump_sects
));
18634 if (cmdline
.num_dump_sects
> 0)
18636 if (filedata
->num_dump_sects
== 0)
18637 /* A sneaky way of allocating the dump_sects array. */
18638 request_dump_bynumber (filedata
, cmdline
.num_dump_sects
, 0);
18640 assert (filedata
->num_dump_sects
>= cmdline
.num_dump_sects
);
18641 memcpy (filedata
->dump_sects
, cmdline
.dump_sects
,
18642 cmdline
.num_dump_sects
* sizeof (* filedata
->dump_sects
));
18645 if (! process_file_header (filedata
))
18648 if (! process_section_headers (filedata
))
18650 /* Without loaded section headers we cannot process lots of things. */
18651 do_unwind
= do_version
= do_dump
= do_arch
= FALSE
;
18653 if (! do_using_dynamic
)
18654 do_syms
= do_dyn_syms
= do_reloc
= FALSE
;
18657 if (! process_section_groups (filedata
))
18658 /* Without loaded section groups we cannot process unwind. */
18661 if (process_program_headers (filedata
))
18662 process_dynamic_section (filedata
);
18666 if (! process_relocs (filedata
))
18669 if (! process_unwind (filedata
))
18672 if (! process_symbol_table (filedata
))
18675 if (! process_syminfo (filedata
))
18678 if (! process_version_sections (filedata
))
18681 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
)
18682 separates
= load_separate_debug_file (filedata
, filedata
->file_name
);
18686 if (! process_section_contents (filedata
))
18691 if (! process_section_headers (separates
))
18693 else if (! process_section_contents (separates
))
18697 if (! process_notes (filedata
))
18700 if (! process_gnu_liblist (filedata
))
18703 if (! process_arch_specific (filedata
))
18706 free (filedata
->program_headers
);
18707 filedata
->program_headers
= NULL
;
18709 free (filedata
->section_headers
);
18710 filedata
->section_headers
= NULL
;
18712 free (filedata
->string_table
);
18713 filedata
->string_table
= NULL
;
18714 filedata
->string_table_length
= 0;
18716 if (dynamic_strings
)
18718 free (dynamic_strings
);
18719 dynamic_strings
= NULL
;
18720 dynamic_strings_length
= 0;
18723 if (dynamic_symbols
)
18725 free (dynamic_symbols
);
18726 dynamic_symbols
= NULL
;
18727 num_dynamic_syms
= 0;
18730 if (dynamic_syminfo
)
18732 free (dynamic_syminfo
);
18733 dynamic_syminfo
= NULL
;
18736 if (dynamic_section
)
18738 free (dynamic_section
);
18739 dynamic_section
= NULL
;
18742 if (section_headers_groups
)
18744 free (section_headers_groups
);
18745 section_headers_groups
= NULL
;
18748 if (section_groups
)
18750 struct group_list
* g
;
18751 struct group_list
* next
;
18753 for (i
= 0; i
< group_count
; i
++)
18755 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
18762 free (section_groups
);
18763 section_groups
= NULL
;
18766 free_debug_memory ();
18771 /* Process an ELF archive.
18772 On entry the file is positioned just after the ARMAG string.
18773 Returns TRUE upon success, FALSE otherwise. */
18776 process_archive (Filedata
* filedata
, bfd_boolean is_thin_archive
)
18778 struct archive_info arch
;
18779 struct archive_info nested_arch
;
18781 bfd_boolean ret
= TRUE
;
18785 /* The ARCH structure is used to hold information about this archive. */
18786 arch
.file_name
= NULL
;
18788 arch
.index_array
= NULL
;
18789 arch
.sym_table
= NULL
;
18790 arch
.longnames
= NULL
;
18792 /* The NESTED_ARCH structure is used as a single-item cache of information
18793 about a nested archive (when members of a thin archive reside within
18794 another regular archive file). */
18795 nested_arch
.file_name
= NULL
;
18796 nested_arch
.file
= NULL
;
18797 nested_arch
.index_array
= NULL
;
18798 nested_arch
.sym_table
= NULL
;
18799 nested_arch
.longnames
= NULL
;
18801 if (setup_archive (&arch
, filedata
->file_name
, filedata
->handle
,
18802 is_thin_archive
, do_archive_index
) != 0)
18808 if (do_archive_index
)
18810 if (arch
.sym_table
== NULL
)
18811 error (_("%s: unable to dump the index as none was found\n"), filedata
->file_name
);
18814 unsigned long i
, l
;
18815 unsigned long current_pos
;
18817 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
18818 filedata
->file_name
, (unsigned long) arch
.index_num
, arch
.sym_size
);
18820 current_pos
= ftell (filedata
->handle
);
18822 for (i
= l
= 0; i
< arch
.index_num
; i
++)
18824 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
18826 char * member_name
;
18828 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
18830 if (member_name
!= NULL
)
18832 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
18834 if (qualified_name
!= NULL
)
18836 printf (_("Contents of binary %s at offset "), qualified_name
);
18837 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
18839 free (qualified_name
);
18844 if (l
>= arch
.sym_size
)
18846 error (_("%s: end of the symbol table reached before the end of the index\n"),
18847 filedata
->file_name
);
18851 /* PR 17531: file: 0b6630b2. */
18852 printf ("\t%.*s\n", (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
18853 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
18856 if (arch
.uses_64bit_indicies
)
18861 if (l
< arch
.sym_size
)
18863 error (ngettext ("%s: %ld byte remains in the symbol table, "
18864 "but without corresponding entries in "
18865 "the index table\n",
18866 "%s: %ld bytes remain in the symbol table, "
18867 "but without corresponding entries in "
18868 "the index table\n",
18869 arch
.sym_size
- l
),
18870 filedata
->file_name
, arch
.sym_size
- l
);
18874 if (fseek (filedata
->handle
, current_pos
, SEEK_SET
) != 0)
18876 error (_("%s: failed to seek back to start of object files in the archive\n"),
18877 filedata
->file_name
);
18883 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
18884 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
18885 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
18886 && !do_section_groups
&& !do_dyn_syms
)
18888 ret
= TRUE
; /* Archive index only. */
18897 char * qualified_name
;
18899 /* Read the next archive header. */
18900 if (fseek (filedata
->handle
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
18902 error (_("%s: failed to seek to next archive header\n"), filedata
->file_name
);
18905 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, filedata
->handle
);
18906 if (got
!= sizeof arch
.arhdr
)
18910 error (_("%s: failed to read archive header\n"), filedata
->file_name
);
18914 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
18916 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
18921 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
18923 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
18924 if (archive_file_size
& 01)
18925 ++archive_file_size
;
18927 name
= get_archive_member_name (&arch
, &nested_arch
);
18930 error (_("%s: bad archive file name\n"), filedata
->file_name
);
18934 namelen
= strlen (name
);
18936 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
18937 if (qualified_name
== NULL
)
18939 error (_("%s: bad archive file name\n"), filedata
->file_name
);
18944 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
18946 /* This is a proxy for an external member of a thin archive. */
18947 Filedata
* member_filedata
;
18948 char * member_file_name
= adjust_relative_path
18949 (filedata
->file_name
, name
, namelen
);
18951 if (member_file_name
== NULL
)
18957 member_filedata
= open_file (member_file_name
);
18958 if (member_filedata
== NULL
)
18960 error (_("Input file '%s' is not readable.\n"), member_file_name
);
18961 free (member_file_name
);
18966 archive_file_offset
= arch
.nested_member_origin
;
18967 member_filedata
->file_name
= qualified_name
;
18969 if (! process_object (member_filedata
))
18972 close_file (member_filedata
);
18973 free (member_file_name
);
18975 else if (is_thin_archive
)
18977 Filedata thin_filedata
;
18979 memset (&thin_filedata
, 0, sizeof (thin_filedata
));
18981 /* PR 15140: Allow for corrupt thin archives. */
18982 if (nested_arch
.file
== NULL
)
18984 error (_("%s: contains corrupt thin archive: %s\n"),
18985 filedata
->file_name
, name
);
18990 /* This is a proxy for a member of a nested archive. */
18991 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
18993 /* The nested archive file will have been opened and setup by
18994 get_archive_member_name. */
18995 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
18997 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
19002 thin_filedata
.handle
= nested_arch
.file
;
19003 thin_filedata
.file_name
= qualified_name
;
19005 if (! process_object (& thin_filedata
))
19010 archive_file_offset
= arch
.next_arhdr_offset
;
19011 arch
.next_arhdr_offset
+= archive_file_size
;
19013 filedata
->file_name
= qualified_name
;
19014 if (! process_object (filedata
))
19018 if (filedata
->dump_sects
!= NULL
)
19020 free (filedata
->dump_sects
);
19021 filedata
->dump_sects
= NULL
;
19022 filedata
->num_dump_sects
= 0;
19025 free (qualified_name
);
19029 if (nested_arch
.file
!= NULL
)
19030 fclose (nested_arch
.file
);
19031 release_archive (&nested_arch
);
19032 release_archive (&arch
);
19038 process_file (char * file_name
)
19040 Filedata
* filedata
= NULL
;
19041 struct stat statbuf
;
19042 char armag
[SARMAG
];
19043 bfd_boolean ret
= TRUE
;
19045 if (stat (file_name
, &statbuf
) < 0)
19047 if (errno
== ENOENT
)
19048 error (_("'%s': No such file\n"), file_name
);
19050 error (_("Could not locate '%s'. System error message: %s\n"),
19051 file_name
, strerror (errno
));
19055 if (! S_ISREG (statbuf
.st_mode
))
19057 error (_("'%s' is not an ordinary file\n"), file_name
);
19061 filedata
= calloc (1, sizeof * filedata
);
19062 if (filedata
== NULL
)
19064 error (_("Out of memory allocating file data structure\n"));
19068 filedata
->file_name
= file_name
;
19069 filedata
->handle
= fopen (file_name
, "rb");
19070 if (filedata
->handle
== NULL
)
19072 error (_("Input file '%s' is not readable.\n"), file_name
);
19077 if (fread (armag
, SARMAG
, 1, filedata
->handle
) != 1)
19079 error (_("%s: Failed to read file's magic number\n"), file_name
);
19080 fclose (filedata
->handle
);
19085 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
19087 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
19089 if (! process_archive (filedata
, FALSE
))
19092 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
19094 if ( ! process_archive (filedata
, TRUE
))
19099 if (do_archive_index
)
19100 error (_("File %s is not an archive so its index cannot be displayed.\n"),
19103 rewind (filedata
->handle
);
19104 archive_file_size
= archive_file_offset
= 0;
19106 if (! process_object (filedata
))
19110 fclose (filedata
->handle
);
19116 #ifdef SUPPORT_DISASSEMBLY
19117 /* Needed by the i386 disassembler. For extra credit, someone could
19118 fix this so that we insert symbolic addresses here, esp for GOT/PLT
19122 print_address (unsigned int addr
, FILE * outfile
)
19124 fprintf (outfile
,"0x%8.8x", addr
);
19127 /* Needed by the i386 disassembler. */
19130 db_task_printsym (unsigned int addr
)
19132 print_address (addr
, stderr
);
19137 main (int argc
, char ** argv
)
19141 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
19142 setlocale (LC_MESSAGES
, "");
19144 #if defined (HAVE_SETLOCALE)
19145 setlocale (LC_CTYPE
, "");
19147 bindtextdomain (PACKAGE
, LOCALEDIR
);
19148 textdomain (PACKAGE
);
19150 expandargv (&argc
, &argv
);
19152 cmdline
.file_name
= "<cmdline>";
19153 parse_args (& cmdline
, argc
, argv
);
19155 if (optind
< (argc
- 1))
19157 else if (optind
>= argc
)
19159 warn (_("Nothing to do.\n"));
19164 while (optind
< argc
)
19165 if (! process_file (argv
[optind
++]))
19168 if (cmdline
.dump_sects
!= NULL
)
19169 free (cmdline
.dump_sects
);
19171 return err
? EXIT_FAILURE
: EXIT_SUCCESS
;