1 /* readelf.c -- display contents of an ELF format file
2 Copyright (C) 1998-2017 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/i860.h"
113 #include "elf/i960.h"
114 #include "elf/ia64.h"
115 #include "elf/ip2k.h"
116 #include "elf/lm32.h"
117 #include "elf/iq2000.h"
118 #include "elf/m32c.h"
119 #include "elf/m32r.h"
120 #include "elf/m68k.h"
121 #include "elf/m68hc11.h"
122 #include "elf/mcore.h"
124 #include "elf/metag.h"
125 #include "elf/microblaze.h"
126 #include "elf/mips.h"
127 #include "elf/riscv.h"
128 #include "elf/mmix.h"
129 #include "elf/mn10200.h"
130 #include "elf/mn10300.h"
131 #include "elf/moxie.h"
133 #include "elf/msp430.h"
134 #include "elf/nds32.h"
135 #include "elf/nios2.h"
136 #include "elf/or1k.h"
139 #include "elf/ppc64.h"
141 #include "elf/rl78.h"
143 #include "elf/s390.h"
144 #include "elf/score.h"
146 #include "elf/sparc.h"
148 #include "elf/tic6x.h"
149 #include "elf/tilegx.h"
150 #include "elf/tilepro.h"
151 #include "elf/v850.h"
153 #include "elf/visium.h"
154 #include "elf/wasm32.h"
155 #include "elf/x86-64.h"
156 #include "elf/xc16x.h"
157 #include "elf/xgate.h"
158 #include "elf/xstormy16.h"
159 #include "elf/xtensa.h"
162 #include "libiberty.h"
163 #include "safe-ctype.h"
164 #include "filenames.h"
167 #define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
170 typedef struct elf_section_list
172 Elf_Internal_Shdr
* hdr
;
173 struct elf_section_list
* next
;
176 char * program_name
= "readelf";
177 static unsigned long archive_file_offset
;
178 static unsigned long archive_file_size
;
179 static bfd_size_type current_file_size
;
180 static unsigned long dynamic_addr
;
181 static bfd_size_type dynamic_size
;
182 static size_t dynamic_nent
;
183 static char * dynamic_strings
;
184 static unsigned long dynamic_strings_length
;
185 static char * string_table
;
186 static unsigned long string_table_length
;
187 static unsigned long num_dynamic_syms
;
188 static Elf_Internal_Sym
* dynamic_symbols
;
189 static Elf_Internal_Syminfo
* dynamic_syminfo
;
190 static unsigned long dynamic_syminfo_offset
;
191 static unsigned int dynamic_syminfo_nent
;
192 static char program_interpreter
[PATH_MAX
];
193 static bfd_vma dynamic_info
[DT_ENCODING
];
194 static bfd_vma dynamic_info_DT_GNU_HASH
;
195 static bfd_vma version_info
[16];
196 static Elf_Internal_Ehdr elf_header
;
197 static Elf_Internal_Shdr
* section_headers
;
198 static Elf_Internal_Phdr
* program_headers
;
199 static Elf_Internal_Dyn
* dynamic_section
;
200 static elf_section_list
* symtab_shndx_list
;
201 static bfd_boolean show_name
= FALSE
;
202 static bfd_boolean do_dynamic
= FALSE
;
203 static bfd_boolean do_syms
= FALSE
;
204 static bfd_boolean do_dyn_syms
= FALSE
;
205 static bfd_boolean do_reloc
= FALSE
;
206 static bfd_boolean do_sections
= FALSE
;
207 static bfd_boolean do_section_groups
= FALSE
;
208 static bfd_boolean do_section_details
= FALSE
;
209 static bfd_boolean do_segments
= FALSE
;
210 static bfd_boolean do_unwind
= FALSE
;
211 static bfd_boolean do_using_dynamic
= FALSE
;
212 static bfd_boolean do_header
= FALSE
;
213 static bfd_boolean do_dump
= FALSE
;
214 static bfd_boolean do_version
= FALSE
;
215 static bfd_boolean do_histogram
= FALSE
;
216 static bfd_boolean do_debugging
= FALSE
;
217 static bfd_boolean do_arch
= FALSE
;
218 static bfd_boolean do_notes
= FALSE
;
219 static bfd_boolean do_archive_index
= FALSE
;
220 static bfd_boolean is_32bit_elf
= FALSE
;
221 static bfd_boolean decompress_dumps
= FALSE
;
225 struct group_list
* next
;
226 unsigned int section_index
;
231 struct group_list
* root
;
232 unsigned int group_index
;
235 static size_t group_count
;
236 static struct group
* section_groups
;
237 static struct group
** section_headers_groups
;
240 /* Flag bits indicating particular types of dump. */
241 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
242 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
243 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
244 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
245 #define RELOC_DUMP (1 << 4) /* The -R command line switch. */
247 typedef unsigned char dump_type
;
249 /* A linked list of the section names for which dumps were requested. */
250 struct dump_list_entry
254 struct dump_list_entry
* next
;
256 static struct dump_list_entry
* dump_sects_byname
;
258 /* A dynamic array of flags indicating for which sections a dump
259 has been requested via command line switches. */
260 static dump_type
* cmdline_dump_sects
= NULL
;
261 static unsigned int num_cmdline_dump_sects
= 0;
263 /* A dynamic array of flags indicating for which sections a dump of
264 some kind has been requested. It is reset on a per-object file
265 basis and then initialised from the cmdline_dump_sects array,
266 the results of interpreting the -w switch, and the
267 dump_sects_byname list. */
268 static dump_type
* dump_sects
= NULL
;
269 static unsigned int num_dump_sects
= 0;
272 /* How to print a vma value. */
273 typedef enum print_mode
285 /* Versioned symbol info. */
286 enum versioned_symbol_info
293 static const char * get_symbol_version_string
294 (FILE *, bfd_boolean
, const char *, unsigned long, unsigned,
295 Elf_Internal_Sym
*, enum versioned_symbol_info
*, unsigned short *);
299 #define SECTION_NAME(X) \
300 ((X) == NULL ? _("<none>") \
301 : string_table == NULL ? _("<no-name>") \
302 : ((X)->sh_name >= string_table_length ? _("<corrupt>") \
303 : string_table + (X)->sh_name))
305 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
307 #define GET_ELF_SYMBOLS(file, section, sym_count) \
308 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
309 : get_64bit_elf_symbols (file, section, sym_count))
311 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
312 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
313 already been called and verified that the string exists. */
314 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
316 #define REMOVE_ARCH_BITS(ADDR) \
319 if (elf_header.e_machine == EM_ARM) \
324 /* Retrieve NMEMB structures, each SIZE bytes long from FILE starting at OFFSET +
325 the offset of the current archive member, if we are examining an archive.
326 Put the retrieved data into VAR, if it is not NULL. Otherwise allocate a buffer
327 using malloc and fill that. In either case return the pointer to the start of
328 the retrieved data or NULL if something went wrong. If something does go wrong
329 and REASON is not NULL then emit an error message using REASON as part of the
333 get_data (void * var
, FILE * file
, unsigned long offset
, bfd_size_type size
,
334 bfd_size_type nmemb
, const char * reason
)
337 bfd_size_type amt
= size
* nmemb
;
339 if (size
== 0 || nmemb
== 0)
342 /* If the size_t type is smaller than the bfd_size_type, eg because
343 you are building a 32-bit tool on a 64-bit host, then make sure
344 that when the sizes are cast to (size_t) no information is lost. */
345 if (sizeof (size_t) < sizeof (bfd_size_type
)
346 && ( (bfd_size_type
) ((size_t) size
) != size
347 || (bfd_size_type
) ((size_t) nmemb
) != nmemb
))
350 error (_("Size truncation prevents reading 0x%" BFD_VMA_FMT
"x"
351 " elements of size 0x%" BFD_VMA_FMT
"x for %s\n"),
352 nmemb
, size
, reason
);
356 /* Check for size overflow. */
360 error (_("Size overflow prevents reading 0x%" BFD_VMA_FMT
"x"
361 " elements of size 0x%" BFD_VMA_FMT
"x for %s\n"),
362 nmemb
, size
, reason
);
366 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
367 attempting to allocate memory when the read is bound to fail. */
368 if (amt
> current_file_size
369 || offset
+ archive_file_offset
+ amt
> current_file_size
)
372 error (_("Reading 0x%" BFD_VMA_FMT
"x"
373 " bytes extends past end of file for %s\n"),
378 if (fseek (file
, archive_file_offset
+ offset
, SEEK_SET
))
381 error (_("Unable to seek to 0x%lx for %s\n"),
382 archive_file_offset
+ offset
, reason
);
389 /* Check for overflow. */
390 if (nmemb
< (~(bfd_size_type
) 0 - 1) / size
)
391 /* + 1 so that we can '\0' terminate invalid string table sections. */
392 mvar
= malloc ((size_t) amt
+ 1);
397 error (_("Out of memory allocating 0x%" BFD_VMA_FMT
"x"
403 ((char *) mvar
)[amt
] = '\0';
406 if (fread (mvar
, (size_t) size
, (size_t) nmemb
, file
) != nmemb
)
409 error (_("Unable to read in 0x%" BFD_VMA_FMT
"x bytes of %s\n"),
419 /* Print a VMA value in the MODE specified.
420 Returns the number of characters displayed. */
423 print_vma (bfd_vma vma
, print_mode mode
)
435 return nc
+ printf ("%8.8" BFD_VMA_FMT
"x", vma
);
442 return printf ("%5" BFD_VMA_FMT
"d", vma
);
448 return nc
+ printf ("%" BFD_VMA_FMT
"x", vma
);
451 return printf ("%" BFD_VMA_FMT
"d", vma
);
454 return printf ("%" BFD_VMA_FMT
"u", vma
);
457 /* FIXME: Report unrecognised mode ? */
462 /* Display a symbol on stdout. Handles the display of control characters and
463 multibye characters (assuming the host environment supports them).
465 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
467 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
468 padding as necessary.
470 Returns the number of emitted characters. */
473 print_symbol (signed int width
, const char *symbol
)
475 bfd_boolean extra_padding
= FALSE
;
476 signed int num_printed
= 0;
477 #ifdef HAVE_MBSTATE_T
480 unsigned int width_remaining
;
484 /* Keep the width positive. This helps the code below. */
486 extra_padding
= TRUE
;
491 /* Set the remaining width to a very large value.
492 This simplifies the code below. */
493 width_remaining
= INT_MAX
;
495 width_remaining
= width
;
497 #ifdef HAVE_MBSTATE_T
498 /* Initialise the multibyte conversion state. */
499 memset (& state
, 0, sizeof (state
));
502 while (width_remaining
)
505 const char c
= *symbol
++;
510 /* Do not print control characters directly as they can affect terminal
511 settings. Such characters usually appear in the names generated
512 by the assembler for local labels. */
515 if (width_remaining
< 2)
518 printf ("^%c", c
+ 0x40);
519 width_remaining
-= 2;
522 else if (ISPRINT (c
))
530 #ifdef HAVE_MBSTATE_T
533 /* Let printf do the hard work of displaying multibyte characters. */
534 printf ("%.1s", symbol
- 1);
538 #ifdef HAVE_MBSTATE_T
539 /* Try to find out how many bytes made up the character that was
540 just printed. Advance the symbol pointer past the bytes that
542 n
= mbrtowc (& w
, symbol
- 1, MB_CUR_MAX
, & state
);
546 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
551 if (extra_padding
&& num_printed
< width
)
553 /* Fill in the remaining spaces. */
554 printf ("%-*s", width
- num_printed
, " ");
561 /* Returns a pointer to a static buffer containing a printable version of
562 the given section's name. Like print_symbol, except that it does not try
563 to print multibyte characters, it just interprets them as hex values. */
566 printable_section_name (const Elf_Internal_Shdr
* sec
)
568 #define MAX_PRINT_SEC_NAME_LEN 128
569 static char sec_name_buf
[MAX_PRINT_SEC_NAME_LEN
+ 1];
570 const char * name
= SECTION_NAME (sec
);
571 char * buf
= sec_name_buf
;
573 unsigned int remaining
= MAX_PRINT_SEC_NAME_LEN
;
575 while ((c
= * name
++) != 0)
586 else if (ISPRINT (c
))
593 static char hex
[17] = "0123456789ABCDEF";
598 * buf
++ = hex
[(c
& 0xf0) >> 4];
599 * buf
++ = hex
[c
& 0x0f];
613 printable_section_name_from_index (unsigned long ndx
)
615 if (ndx
>= elf_header
.e_shnum
)
616 return _("<corrupt>");
618 return printable_section_name (section_headers
+ ndx
);
621 /* Return a pointer to section NAME, or NULL if no such section exists. */
623 static Elf_Internal_Shdr
*
624 find_section (const char * name
)
628 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
629 if (streq (SECTION_NAME (section_headers
+ i
), name
))
630 return section_headers
+ i
;
635 /* Return a pointer to a section containing ADDR, or NULL if no such
638 static Elf_Internal_Shdr
*
639 find_section_by_address (bfd_vma addr
)
643 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
645 Elf_Internal_Shdr
*sec
= section_headers
+ i
;
646 if (addr
>= sec
->sh_addr
&& addr
< sec
->sh_addr
+ sec
->sh_size
)
653 static Elf_Internal_Shdr
*
654 find_section_by_type (unsigned int type
)
658 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
660 Elf_Internal_Shdr
*sec
= section_headers
+ i
;
661 if (sec
->sh_type
== type
)
668 /* Return a pointer to section NAME, or NULL if no such section exists,
669 restricted to the list of sections given in SET. */
671 static Elf_Internal_Shdr
*
672 find_section_in_set (const char * name
, unsigned int * set
)
678 while ((i
= *set
++) > 0)
680 /* See PR 21156 for a reproducer. */
681 if (i
>= elf_header
.e_shnum
)
682 continue; /* FIXME: Should we issue an error message ? */
684 if (streq (SECTION_NAME (section_headers
+ i
), name
))
685 return section_headers
+ i
;
689 return find_section (name
);
692 /* Read an unsigned LEB128 encoded value from DATA.
693 Set *LENGTH_RETURN to the number of bytes read. */
695 static inline unsigned long
696 read_uleb128 (unsigned char * data
,
697 unsigned int * length_return
,
698 const unsigned char * const end
)
700 return read_leb128 (data
, length_return
, FALSE
, end
);
703 /* Return TRUE if the current file is for IA-64 machine and OpenVMS ABI.
704 This OS has so many departures from the ELF standard that we test it at
707 static inline bfd_boolean
710 return elf_header
.e_machine
== EM_IA_64
711 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
;
714 /* Guess the relocation size commonly used by the specific machines. */
717 guess_is_rela (unsigned int e_machine
)
721 /* Targets that use REL relocations. */
736 /* Targets that use RELA relocations. */
740 case EM_ADAPTEVA_EPIPHANY
:
742 case EM_ALTERA_NIOS2
:
745 case EM_ARC_COMPACT2
:
765 case EM_LATTICEMICO32
:
774 case EM_CYGNUS_MN10200
:
776 case EM_CYGNUS_MN10300
:
812 case EM_MICROBLAZE_OLD
:
834 warn (_("Don't know about relocations on this machine architecture\n"));
839 /* Load RELA type relocations from FILE at REL_OFFSET extending for REL_SIZE bytes.
840 Returns TRUE upon success, FALSE otherwise. If successful then a
841 pointer to a malloc'ed buffer containing the relocs is placed in *RELASP,
842 and the number of relocs loaded is placed in *NRELASP. It is the caller's
843 responsibility to free the allocated buffer. */
846 slurp_rela_relocs (FILE * file
,
847 unsigned long rel_offset
,
848 unsigned long rel_size
,
849 Elf_Internal_Rela
** relasp
,
850 unsigned long * nrelasp
)
852 Elf_Internal_Rela
* relas
;
858 Elf32_External_Rela
* erelas
;
860 erelas
= (Elf32_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
861 rel_size
, _("32-bit relocation data"));
865 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
867 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
868 sizeof (Elf_Internal_Rela
));
873 error (_("out of memory parsing relocs\n"));
877 for (i
= 0; i
< nrelas
; i
++)
879 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
880 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
881 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
888 Elf64_External_Rela
* erelas
;
890 erelas
= (Elf64_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
891 rel_size
, _("64-bit relocation data"));
895 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
897 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
898 sizeof (Elf_Internal_Rela
));
903 error (_("out of memory parsing relocs\n"));
907 for (i
= 0; i
< nrelas
; i
++)
909 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
910 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
911 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
913 /* The #ifdef BFD64 below is to prevent a compile time
914 warning. We know that if we do not have a 64 bit data
915 type that we will never execute this code anyway. */
917 if (elf_header
.e_machine
== EM_MIPS
918 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
920 /* In little-endian objects, r_info isn't really a
921 64-bit little-endian value: it has a 32-bit
922 little-endian symbol index followed by four
923 individual byte fields. Reorder INFO
925 bfd_vma inf
= relas
[i
].r_info
;
926 inf
= (((inf
& 0xffffffff) << 32)
927 | ((inf
>> 56) & 0xff)
928 | ((inf
>> 40) & 0xff00)
929 | ((inf
>> 24) & 0xff0000)
930 | ((inf
>> 8) & 0xff000000));
931 relas
[i
].r_info
= inf
;
944 /* Load REL type relocations from FILE at REL_OFFSET extending for REL_SIZE bytes.
945 Returns TRUE upon success, FALSE otherwise. If successful then a
946 pointer to a malloc'ed buffer containing the relocs is placed in *RELSP,
947 and the number of relocs loaded is placed in *NRELSP. It is the caller's
948 responsibility to free the allocated buffer. */
951 slurp_rel_relocs (FILE * file
,
952 unsigned long rel_offset
,
953 unsigned long rel_size
,
954 Elf_Internal_Rela
** relsp
,
955 unsigned long * nrelsp
)
957 Elf_Internal_Rela
* rels
;
963 Elf32_External_Rel
* erels
;
965 erels
= (Elf32_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
966 rel_size
, _("32-bit relocation data"));
970 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
972 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
977 error (_("out of memory parsing relocs\n"));
981 for (i
= 0; i
< nrels
; i
++)
983 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
984 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
985 rels
[i
].r_addend
= 0;
992 Elf64_External_Rel
* erels
;
994 erels
= (Elf64_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
995 rel_size
, _("64-bit relocation data"));
999 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
1001 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
1006 error (_("out of memory parsing relocs\n"));
1010 for (i
= 0; i
< nrels
; i
++)
1012 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
1013 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
1014 rels
[i
].r_addend
= 0;
1016 /* The #ifdef BFD64 below is to prevent a compile time
1017 warning. We know that if we do not have a 64 bit data
1018 type that we will never execute this code anyway. */
1020 if (elf_header
.e_machine
== EM_MIPS
1021 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
1023 /* In little-endian objects, r_info isn't really a
1024 64-bit little-endian value: it has a 32-bit
1025 little-endian symbol index followed by four
1026 individual byte fields. Reorder INFO
1028 bfd_vma inf
= rels
[i
].r_info
;
1029 inf
= (((inf
& 0xffffffff) << 32)
1030 | ((inf
>> 56) & 0xff)
1031 | ((inf
>> 40) & 0xff00)
1032 | ((inf
>> 24) & 0xff0000)
1033 | ((inf
>> 8) & 0xff000000));
1034 rels
[i
].r_info
= inf
;
1047 /* Returns the reloc type extracted from the reloc info field. */
1050 get_reloc_type (bfd_vma reloc_info
)
1053 return ELF32_R_TYPE (reloc_info
);
1055 switch (elf_header
.e_machine
)
1058 /* Note: We assume that reloc_info has already been adjusted for us. */
1059 return ELF64_MIPS_R_TYPE (reloc_info
);
1062 return ELF64_R_TYPE_ID (reloc_info
);
1065 return ELF64_R_TYPE (reloc_info
);
1069 /* Return the symbol index extracted from the reloc info field. */
1072 get_reloc_symindex (bfd_vma reloc_info
)
1074 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
1077 static inline bfd_boolean
1078 uses_msp430x_relocs (void)
1081 elf_header
.e_machine
== EM_MSP430
/* Paranoia. */
1082 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1083 && (((elf_header
.e_flags
& EF_MSP430_MACH
) == E_MSP430_MACH_MSP430X
)
1084 /* TI compiler uses ELFOSABI_NONE. */
1085 || (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
));
1088 /* Display the contents of the relocation data found at the specified
1092 dump_relocations (FILE * file
,
1093 unsigned long rel_offset
,
1094 unsigned long rel_size
,
1095 Elf_Internal_Sym
* symtab
,
1096 unsigned long nsyms
,
1098 unsigned long strtablen
,
1100 bfd_boolean is_dynsym
)
1103 Elf_Internal_Rela
* rels
;
1104 bfd_boolean res
= TRUE
;
1106 if (is_rela
== UNKNOWN
)
1107 is_rela
= guess_is_rela (elf_header
.e_machine
);
1111 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
1116 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
1125 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1127 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1132 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1134 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1142 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
1144 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1149 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
1151 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1155 for (i
= 0; i
< rel_size
; i
++)
1160 bfd_vma symtab_index
;
1163 offset
= rels
[i
].r_offset
;
1164 inf
= rels
[i
].r_info
;
1166 type
= get_reloc_type (inf
);
1167 symtab_index
= get_reloc_symindex (inf
);
1171 printf ("%8.8lx %8.8lx ",
1172 (unsigned long) offset
& 0xffffffff,
1173 (unsigned long) inf
& 0xffffffff);
1177 #if BFD_HOST_64BIT_LONG
1179 ? "%16.16lx %16.16lx "
1180 : "%12.12lx %12.12lx ",
1182 #elif BFD_HOST_64BIT_LONG_LONG
1185 ? "%16.16llx %16.16llx "
1186 : "%12.12llx %12.12llx ",
1190 ? "%16.16I64x %16.16I64x "
1191 : "%12.12I64x %12.12I64x ",
1196 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1197 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1198 _bfd_int64_high (offset
),
1199 _bfd_int64_low (offset
),
1200 _bfd_int64_high (inf
),
1201 _bfd_int64_low (inf
));
1205 switch (elf_header
.e_machine
)
1212 rtype
= elf_aarch64_reloc_type (type
);
1216 case EM_CYGNUS_M32R
:
1217 rtype
= elf_m32r_reloc_type (type
);
1222 rtype
= elf_i386_reloc_type (type
);
1227 rtype
= elf_m68hc11_reloc_type (type
);
1231 rtype
= elf_m68k_reloc_type (type
);
1235 rtype
= elf_i960_reloc_type (type
);
1240 rtype
= elf_avr_reloc_type (type
);
1243 case EM_OLD_SPARCV9
:
1244 case EM_SPARC32PLUS
:
1247 rtype
= elf_sparc_reloc_type (type
);
1251 rtype
= elf_spu_reloc_type (type
);
1255 rtype
= v800_reloc_type (type
);
1258 case EM_CYGNUS_V850
:
1259 rtype
= v850_reloc_type (type
);
1263 case EM_CYGNUS_D10V
:
1264 rtype
= elf_d10v_reloc_type (type
);
1268 case EM_CYGNUS_D30V
:
1269 rtype
= elf_d30v_reloc_type (type
);
1273 rtype
= elf_dlx_reloc_type (type
);
1277 rtype
= elf_sh_reloc_type (type
);
1281 case EM_CYGNUS_MN10300
:
1282 rtype
= elf_mn10300_reloc_type (type
);
1286 case EM_CYGNUS_MN10200
:
1287 rtype
= elf_mn10200_reloc_type (type
);
1291 case EM_CYGNUS_FR30
:
1292 rtype
= elf_fr30_reloc_type (type
);
1296 rtype
= elf_frv_reloc_type (type
);
1300 rtype
= elf_ft32_reloc_type (type
);
1304 rtype
= elf_mcore_reloc_type (type
);
1308 rtype
= elf_mmix_reloc_type (type
);
1312 rtype
= elf_moxie_reloc_type (type
);
1316 if (uses_msp430x_relocs ())
1318 rtype
= elf_msp430x_reloc_type (type
);
1323 rtype
= elf_msp430_reloc_type (type
);
1327 rtype
= elf_nds32_reloc_type (type
);
1331 rtype
= elf_ppc_reloc_type (type
);
1335 rtype
= elf_ppc64_reloc_type (type
);
1339 case EM_MIPS_RS3_LE
:
1340 rtype
= elf_mips_reloc_type (type
);
1344 rtype
= elf_riscv_reloc_type (type
);
1348 rtype
= elf_alpha_reloc_type (type
);
1352 rtype
= elf_arm_reloc_type (type
);
1356 case EM_ARC_COMPACT
:
1357 case EM_ARC_COMPACT2
:
1358 rtype
= elf_arc_reloc_type (type
);
1362 rtype
= elf_hppa_reloc_type (type
);
1368 rtype
= elf_h8_reloc_type (type
);
1372 rtype
= elf_or1k_reloc_type (type
);
1377 rtype
= elf_pj_reloc_type (type
);
1380 rtype
= elf_ia64_reloc_type (type
);
1384 rtype
= elf_cris_reloc_type (type
);
1388 rtype
= elf_i860_reloc_type (type
);
1394 rtype
= elf_x86_64_reloc_type (type
);
1398 rtype
= i370_reloc_type (type
);
1403 rtype
= elf_s390_reloc_type (type
);
1407 rtype
= elf_score_reloc_type (type
);
1411 rtype
= elf_xstormy16_reloc_type (type
);
1415 rtype
= elf_crx_reloc_type (type
);
1419 rtype
= elf_vax_reloc_type (type
);
1423 rtype
= elf_visium_reloc_type (type
);
1426 case EM_ADAPTEVA_EPIPHANY
:
1427 rtype
= elf_epiphany_reloc_type (type
);
1432 rtype
= elf_ip2k_reloc_type (type
);
1436 rtype
= elf_iq2000_reloc_type (type
);
1441 rtype
= elf_xtensa_reloc_type (type
);
1444 case EM_LATTICEMICO32
:
1445 rtype
= elf_lm32_reloc_type (type
);
1450 rtype
= elf_m32c_reloc_type (type
);
1454 rtype
= elf_mt_reloc_type (type
);
1458 rtype
= elf_bfin_reloc_type (type
);
1462 rtype
= elf_mep_reloc_type (type
);
1466 rtype
= elf_cr16_reloc_type (type
);
1470 case EM_MICROBLAZE_OLD
:
1471 rtype
= elf_microblaze_reloc_type (type
);
1475 rtype
= elf_rl78_reloc_type (type
);
1479 rtype
= elf_rx_reloc_type (type
);
1483 rtype
= elf_metag_reloc_type (type
);
1488 rtype
= elf_xc16x_reloc_type (type
);
1492 rtype
= elf_tic6x_reloc_type (type
);
1496 rtype
= elf_tilegx_reloc_type (type
);
1500 rtype
= elf_tilepro_reloc_type (type
);
1503 case EM_WEBASSEMBLY
:
1504 rtype
= elf_wasm32_reloc_type (type
);
1508 rtype
= elf_xgate_reloc_type (type
);
1511 case EM_ALTERA_NIOS2
:
1512 rtype
= elf_nios2_reloc_type (type
);
1516 rtype
= elf_pru_reloc_type (type
);
1521 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1523 printf (do_wide
? "%-22.22s" : "%-17.17s", rtype
);
1525 if (elf_header
.e_machine
== EM_ALPHA
1527 && streq (rtype
, "R_ALPHA_LITUSE")
1530 switch (rels
[i
].r_addend
)
1532 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1533 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1534 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1535 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1536 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1537 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1538 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1539 default: rtype
= NULL
;
1543 printf (" (%s)", rtype
);
1547 printf (_("<unknown addend: %lx>"),
1548 (unsigned long) rels
[i
].r_addend
);
1552 else if (symtab_index
)
1554 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1556 error (_(" bad symbol index: %08lx in reloc"), (unsigned long) symtab_index
);
1561 Elf_Internal_Sym
* psym
;
1562 const char * version_string
;
1563 enum versioned_symbol_info sym_info
;
1564 unsigned short vna_other
;
1566 psym
= symtab
+ symtab_index
;
1569 = get_symbol_version_string (file
, is_dynsym
,
1578 if (ELF_ST_TYPE (psym
->st_info
) == STT_GNU_IFUNC
)
1582 unsigned int width
= is_32bit_elf
? 8 : 14;
1584 /* Relocations against GNU_IFUNC symbols do not use the value
1585 of the symbol as the address to relocate against. Instead
1586 they invoke the function named by the symbol and use its
1587 result as the address for relocation.
1589 To indicate this to the user, do not display the value of
1590 the symbol in the "Symbols's Value" field. Instead show
1591 its name followed by () as a hint that the symbol is
1595 || psym
->st_name
== 0
1596 || psym
->st_name
>= strtablen
)
1599 name
= strtab
+ psym
->st_name
;
1601 len
= print_symbol (width
, name
);
1603 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1605 printf ("()%-*s", len
<= width
? (width
+ 1) - len
: 1, " ");
1609 print_vma (psym
->st_value
, LONG_HEX
);
1611 printf (is_32bit_elf
? " " : " ");
1614 if (psym
->st_name
== 0)
1616 const char * sec_name
= "<null>";
1619 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1621 if (psym
->st_shndx
< elf_header
.e_shnum
)
1622 sec_name
= SECTION_NAME (section_headers
+ psym
->st_shndx
);
1623 else if (psym
->st_shndx
== SHN_ABS
)
1625 else if (psym
->st_shndx
== SHN_COMMON
)
1626 sec_name
= "COMMON";
1627 else if ((elf_header
.e_machine
== EM_MIPS
1628 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1629 || (elf_header
.e_machine
== EM_TI_C6000
1630 && psym
->st_shndx
== SHN_TIC6X_SCOMMON
))
1631 sec_name
= "SCOMMON";
1632 else if (elf_header
.e_machine
== EM_MIPS
1633 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1634 sec_name
= "SUNDEF";
1635 else if ((elf_header
.e_machine
== EM_X86_64
1636 || elf_header
.e_machine
== EM_L1OM
1637 || elf_header
.e_machine
== EM_K1OM
)
1638 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1639 sec_name
= "LARGE_COMMON";
1640 else if (elf_header
.e_machine
== EM_IA_64
1641 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1642 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1643 sec_name
= "ANSI_COM";
1644 else if (is_ia64_vms ()
1645 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
1646 sec_name
= "VMS_SYMVEC";
1649 sprintf (name_buf
, "<section 0x%x>",
1650 (unsigned int) psym
->st_shndx
);
1651 sec_name
= name_buf
;
1654 print_symbol (22, sec_name
);
1656 else if (strtab
== NULL
)
1657 printf (_("<string table index: %3ld>"), psym
->st_name
);
1658 else if (psym
->st_name
>= strtablen
)
1660 error (_("<corrupt string table index: %3ld>"), psym
->st_name
);
1665 print_symbol (22, strtab
+ psym
->st_name
);
1667 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1673 bfd_vma off
= rels
[i
].r_addend
;
1675 if ((bfd_signed_vma
) off
< 0)
1676 printf (" - %" BFD_VMA_FMT
"x", - off
);
1678 printf (" + %" BFD_VMA_FMT
"x", off
);
1684 bfd_vma off
= rels
[i
].r_addend
;
1686 printf ("%*c", is_32bit_elf
? 12 : 20, ' ');
1687 if ((bfd_signed_vma
) off
< 0)
1688 printf ("-%" BFD_VMA_FMT
"x", - off
);
1690 printf ("%" BFD_VMA_FMT
"x", off
);
1693 if (elf_header
.e_machine
== EM_SPARCV9
1695 && streq (rtype
, "R_SPARC_OLO10"))
1696 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf
));
1701 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1703 bfd_vma type2
= ELF64_MIPS_R_TYPE2 (inf
);
1704 bfd_vma type3
= ELF64_MIPS_R_TYPE3 (inf
);
1705 const char * rtype2
= elf_mips_reloc_type (type2
);
1706 const char * rtype3
= elf_mips_reloc_type (type3
);
1708 printf (" Type2: ");
1711 printf (_("unrecognized: %-7lx"),
1712 (unsigned long) type2
& 0xffffffff);
1714 printf ("%-17.17s", rtype2
);
1716 printf ("\n Type3: ");
1719 printf (_("unrecognized: %-7lx"),
1720 (unsigned long) type3
& 0xffffffff);
1722 printf ("%-17.17s", rtype3
);
1735 get_mips_dynamic_type (unsigned long type
)
1739 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1740 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1741 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1742 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1743 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1744 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1745 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1746 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1747 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1748 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1749 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1750 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1751 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1752 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1753 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1754 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1755 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1756 case DT_MIPS_RLD_MAP_REL
: return "MIPS_RLD_MAP_REL";
1757 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1758 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1759 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1760 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1761 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1762 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1763 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1764 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1765 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1766 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1767 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1768 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1769 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1770 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1771 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1772 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1773 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1774 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1775 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1776 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1777 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1778 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1779 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1780 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1781 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1782 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1783 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
1784 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
1791 get_sparc64_dynamic_type (unsigned long type
)
1795 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1802 get_ppc_dynamic_type (unsigned long type
)
1806 case DT_PPC_GOT
: return "PPC_GOT";
1807 case DT_PPC_OPT
: return "PPC_OPT";
1814 get_ppc64_dynamic_type (unsigned long type
)
1818 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1819 case DT_PPC64_OPD
: return "PPC64_OPD";
1820 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1821 case DT_PPC64_OPT
: return "PPC64_OPT";
1828 get_parisc_dynamic_type (unsigned long type
)
1832 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1833 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1834 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1835 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1836 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1837 case DT_HP_PREINIT
: return "HP_PREINIT";
1838 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1839 case DT_HP_NEEDED
: return "HP_NEEDED";
1840 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1841 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1842 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1843 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1844 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1845 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1846 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1847 case DT_HP_FILTERED
: return "HP_FILTERED";
1848 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1849 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1850 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1851 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1852 case DT_PLT
: return "PLT";
1853 case DT_PLT_SIZE
: return "PLT_SIZE";
1854 case DT_DLT
: return "DLT";
1855 case DT_DLT_SIZE
: return "DLT_SIZE";
1862 get_ia64_dynamic_type (unsigned long type
)
1866 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1867 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
1868 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
1869 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
1870 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
1871 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
1872 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
1873 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
1874 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
1875 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
1876 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
1877 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
1878 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
1879 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
1880 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
1881 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
1882 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
1883 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
1884 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
1885 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
1886 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
1887 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
1888 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
1889 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
1890 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
1891 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
1892 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
1893 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
1894 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
1895 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
1896 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
1903 get_solaris_section_type (unsigned long type
)
1907 case 0x6fffffee: return "SUNW_ancillary";
1908 case 0x6fffffef: return "SUNW_capchain";
1909 case 0x6ffffff0: return "SUNW_capinfo";
1910 case 0x6ffffff1: return "SUNW_symsort";
1911 case 0x6ffffff2: return "SUNW_tlssort";
1912 case 0x6ffffff3: return "SUNW_LDYNSYM";
1913 case 0x6ffffff4: return "SUNW_dof";
1914 case 0x6ffffff5: return "SUNW_cap";
1915 case 0x6ffffff6: return "SUNW_SIGNATURE";
1916 case 0x6ffffff7: return "SUNW_ANNOTATE";
1917 case 0x6ffffff8: return "SUNW_DEBUGSTR";
1918 case 0x6ffffff9: return "SUNW_DEBUG";
1919 case 0x6ffffffa: return "SUNW_move";
1920 case 0x6ffffffb: return "SUNW_COMDAT";
1921 case 0x6ffffffc: return "SUNW_syminfo";
1922 case 0x6ffffffd: return "SUNW_verdef";
1923 case 0x6ffffffe: return "SUNW_verneed";
1924 case 0x6fffffff: return "SUNW_versym";
1925 case 0x70000000: return "SPARC_GOTDATA";
1926 default: return NULL
;
1931 get_alpha_dynamic_type (unsigned long type
)
1935 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
1936 default: return NULL
;
1941 get_score_dynamic_type (unsigned long type
)
1945 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
1946 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
1947 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
1948 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
1949 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
1950 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
1951 default: return NULL
;
1956 get_tic6x_dynamic_type (unsigned long type
)
1960 case DT_C6000_GSYM_OFFSET
: return "C6000_GSYM_OFFSET";
1961 case DT_C6000_GSTR_OFFSET
: return "C6000_GSTR_OFFSET";
1962 case DT_C6000_DSBT_BASE
: return "C6000_DSBT_BASE";
1963 case DT_C6000_DSBT_SIZE
: return "C6000_DSBT_SIZE";
1964 case DT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
1965 case DT_C6000_DSBT_INDEX
: return "C6000_DSBT_INDEX";
1966 default: return NULL
;
1971 get_nios2_dynamic_type (unsigned long type
)
1975 case DT_NIOS2_GP
: return "NIOS2_GP";
1976 default: return NULL
;
1981 get_solaris_dynamic_type (unsigned long type
)
1985 case 0x6000000d: return "SUNW_AUXILIARY";
1986 case 0x6000000e: return "SUNW_RTLDINF";
1987 case 0x6000000f: return "SUNW_FILTER";
1988 case 0x60000010: return "SUNW_CAP";
1989 case 0x60000011: return "SUNW_SYMTAB";
1990 case 0x60000012: return "SUNW_SYMSZ";
1991 case 0x60000013: return "SUNW_SORTENT";
1992 case 0x60000014: return "SUNW_SYMSORT";
1993 case 0x60000015: return "SUNW_SYMSORTSZ";
1994 case 0x60000016: return "SUNW_TLSSORT";
1995 case 0x60000017: return "SUNW_TLSSORTSZ";
1996 case 0x60000018: return "SUNW_CAPINFO";
1997 case 0x60000019: return "SUNW_STRPAD";
1998 case 0x6000001a: return "SUNW_CAPCHAIN";
1999 case 0x6000001b: return "SUNW_LDMACH";
2000 case 0x6000001d: return "SUNW_CAPCHAINENT";
2001 case 0x6000001f: return "SUNW_CAPCHAINSZ";
2002 case 0x60000021: return "SUNW_PARENT";
2003 case 0x60000023: return "SUNW_ASLR";
2004 case 0x60000025: return "SUNW_RELAX";
2005 case 0x60000029: return "SUNW_NXHEAP";
2006 case 0x6000002b: return "SUNW_NXSTACK";
2008 case 0x70000001: return "SPARC_REGISTER";
2009 case 0x7ffffffd: return "AUXILIARY";
2010 case 0x7ffffffe: return "USED";
2011 case 0x7fffffff: return "FILTER";
2013 default: return NULL
;
2018 get_dynamic_type (unsigned long type
)
2020 static char buff
[64];
2024 case DT_NULL
: return "NULL";
2025 case DT_NEEDED
: return "NEEDED";
2026 case DT_PLTRELSZ
: return "PLTRELSZ";
2027 case DT_PLTGOT
: return "PLTGOT";
2028 case DT_HASH
: return "HASH";
2029 case DT_STRTAB
: return "STRTAB";
2030 case DT_SYMTAB
: return "SYMTAB";
2031 case DT_RELA
: return "RELA";
2032 case DT_RELASZ
: return "RELASZ";
2033 case DT_RELAENT
: return "RELAENT";
2034 case DT_STRSZ
: return "STRSZ";
2035 case DT_SYMENT
: return "SYMENT";
2036 case DT_INIT
: return "INIT";
2037 case DT_FINI
: return "FINI";
2038 case DT_SONAME
: return "SONAME";
2039 case DT_RPATH
: return "RPATH";
2040 case DT_SYMBOLIC
: return "SYMBOLIC";
2041 case DT_REL
: return "REL";
2042 case DT_RELSZ
: return "RELSZ";
2043 case DT_RELENT
: return "RELENT";
2044 case DT_PLTREL
: return "PLTREL";
2045 case DT_DEBUG
: return "DEBUG";
2046 case DT_TEXTREL
: return "TEXTREL";
2047 case DT_JMPREL
: return "JMPREL";
2048 case DT_BIND_NOW
: return "BIND_NOW";
2049 case DT_INIT_ARRAY
: return "INIT_ARRAY";
2050 case DT_FINI_ARRAY
: return "FINI_ARRAY";
2051 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
2052 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
2053 case DT_RUNPATH
: return "RUNPATH";
2054 case DT_FLAGS
: return "FLAGS";
2056 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2057 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
2058 case DT_SYMTAB_SHNDX
: return "SYMTAB_SHNDX";
2060 case DT_CHECKSUM
: return "CHECKSUM";
2061 case DT_PLTPADSZ
: return "PLTPADSZ";
2062 case DT_MOVEENT
: return "MOVEENT";
2063 case DT_MOVESZ
: return "MOVESZ";
2064 case DT_FEATURE
: return "FEATURE";
2065 case DT_POSFLAG_1
: return "POSFLAG_1";
2066 case DT_SYMINSZ
: return "SYMINSZ";
2067 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
2069 case DT_ADDRRNGLO
: return "ADDRRNGLO";
2070 case DT_CONFIG
: return "CONFIG";
2071 case DT_DEPAUDIT
: return "DEPAUDIT";
2072 case DT_AUDIT
: return "AUDIT";
2073 case DT_PLTPAD
: return "PLTPAD";
2074 case DT_MOVETAB
: return "MOVETAB";
2075 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
2077 case DT_VERSYM
: return "VERSYM";
2079 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
2080 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
2081 case DT_RELACOUNT
: return "RELACOUNT";
2082 case DT_RELCOUNT
: return "RELCOUNT";
2083 case DT_FLAGS_1
: return "FLAGS_1";
2084 case DT_VERDEF
: return "VERDEF";
2085 case DT_VERDEFNUM
: return "VERDEFNUM";
2086 case DT_VERNEED
: return "VERNEED";
2087 case DT_VERNEEDNUM
: return "VERNEEDNUM";
2089 case DT_AUXILIARY
: return "AUXILIARY";
2090 case DT_USED
: return "USED";
2091 case DT_FILTER
: return "FILTER";
2093 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
2094 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
2095 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
2096 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
2097 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
2098 case DT_GNU_HASH
: return "GNU_HASH";
2101 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
2103 const char * result
;
2105 switch (elf_header
.e_machine
)
2108 case EM_MIPS_RS3_LE
:
2109 result
= get_mips_dynamic_type (type
);
2112 result
= get_sparc64_dynamic_type (type
);
2115 result
= get_ppc_dynamic_type (type
);
2118 result
= get_ppc64_dynamic_type (type
);
2121 result
= get_ia64_dynamic_type (type
);
2124 result
= get_alpha_dynamic_type (type
);
2127 result
= get_score_dynamic_type (type
);
2130 result
= get_tic6x_dynamic_type (type
);
2132 case EM_ALTERA_NIOS2
:
2133 result
= get_nios2_dynamic_type (type
);
2136 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2137 result
= get_solaris_dynamic_type (type
);
2146 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
2148 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
2149 || (elf_header
.e_machine
== EM_PARISC
2150 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
2152 const char * result
;
2154 switch (elf_header
.e_machine
)
2157 result
= get_parisc_dynamic_type (type
);
2160 result
= get_ia64_dynamic_type (type
);
2163 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2164 result
= get_solaris_dynamic_type (type
);
2173 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
2177 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
2184 get_file_type (unsigned e_type
)
2186 static char buff
[32];
2190 case ET_NONE
: return _("NONE (None)");
2191 case ET_REL
: return _("REL (Relocatable file)");
2192 case ET_EXEC
: return _("EXEC (Executable file)");
2193 case ET_DYN
: return _("DYN (Shared object file)");
2194 case ET_CORE
: return _("CORE (Core file)");
2197 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
2198 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
2199 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
2200 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
2202 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
2208 get_machine_name (unsigned e_machine
)
2210 static char buff
[64]; /* XXX */
2214 /* Please keep this switch table sorted by increasing EM_ value. */
2216 case EM_NONE
: return _("None");
2217 case EM_M32
: return "WE32100";
2218 case EM_SPARC
: return "Sparc";
2219 case EM_386
: return "Intel 80386";
2220 case EM_68K
: return "MC68000";
2221 case EM_88K
: return "MC88000";
2222 case EM_IAMCU
: return "Intel MCU";
2223 case EM_860
: return "Intel 80860";
2224 case EM_MIPS
: return "MIPS R3000";
2225 case EM_S370
: return "IBM System/370";
2227 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
2228 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
2229 case EM_PARISC
: return "HPPA";
2230 case EM_VPP550
: return "Fujitsu VPP500";
2231 case EM_SPARC32PLUS
: return "Sparc v8+" ;
2232 case EM_960
: return "Intel 90860";
2233 case EM_PPC
: return "PowerPC";
2235 case EM_PPC64
: return "PowerPC64";
2237 case EM_S390
: return "IBM S/390";
2238 case EM_SPU
: return "SPU";
2240 case EM_V800
: return "Renesas V850 (using RH850 ABI)";
2241 case EM_FR20
: return "Fujitsu FR20";
2242 case EM_RH32
: return "TRW RH32";
2243 case EM_MCORE
: return "MCORE";
2245 case EM_ARM
: return "ARM";
2246 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
2247 case EM_SH
: return "Renesas / SuperH SH";
2248 case EM_SPARCV9
: return "Sparc v9";
2249 case EM_TRICORE
: return "Siemens Tricore";
2250 case EM_ARC
: return "ARC";
2251 case EM_H8_300
: return "Renesas H8/300";
2252 case EM_H8_300H
: return "Renesas H8/300H";
2253 case EM_H8S
: return "Renesas H8S";
2254 case EM_H8_500
: return "Renesas H8/500";
2256 case EM_IA_64
: return "Intel IA-64";
2257 case EM_MIPS_X
: return "Stanford MIPS-X";
2258 case EM_COLDFIRE
: return "Motorola Coldfire";
2259 case EM_68HC12
: return "Motorola MC68HC12 Microcontroller";
2260 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
2261 case EM_PCP
: return "Siemens PCP";
2262 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
2263 case EM_NDR1
: return "Denso NDR1 microprocesspr";
2264 case EM_STARCORE
: return "Motorola Star*Core processor";
2265 case EM_ME16
: return "Toyota ME16 processor";
2267 case EM_ST100
: return "STMicroelectronics ST100 processor";
2268 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
2269 case EM_X86_64
: return "Advanced Micro Devices X86-64";
2270 case EM_PDSP
: return "Sony DSP processor";
2271 case EM_PDP10
: return "Digital Equipment Corp. PDP-10";
2272 case EM_PDP11
: return "Digital Equipment Corp. PDP-11";
2273 case EM_FX66
: return "Siemens FX66 microcontroller";
2274 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2275 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
2276 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
2278 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
2279 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
2280 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
2281 case EM_SVX
: return "Silicon Graphics SVx";
2282 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
2283 case EM_VAX
: return "Digital VAX";
2284 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
2285 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
2286 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
2287 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
2289 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
2290 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
2291 case EM_PRISM
: return "Vitesse Prism";
2293 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
2294 case EM_CYGNUS_FR30
:
2295 case EM_FR30
: return "Fujitsu FR30";
2296 case EM_CYGNUS_D10V
:
2297 case EM_D10V
: return "d10v";
2298 case EM_CYGNUS_D30V
:
2299 case EM_D30V
: return "d30v";
2300 case EM_CYGNUS_V850
:
2301 case EM_V850
: return "Renesas V850";
2302 case EM_CYGNUS_M32R
:
2303 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
2304 case EM_CYGNUS_MN10300
:
2305 case EM_MN10300
: return "mn10300";
2307 case EM_CYGNUS_MN10200
:
2308 case EM_MN10200
: return "mn10200";
2309 case EM_PJ
: return "picoJava";
2310 case EM_OR1K
: return "OpenRISC 1000";
2311 case EM_ARC_COMPACT
: return "ARCompact";
2313 case EM_XTENSA
: return "Tensilica Xtensa Processor";
2314 case EM_VIDEOCORE
: return "Alphamosaic VideoCore processor";
2315 case EM_TMM_GPP
: return "Thompson Multimedia General Purpose Processor";
2316 case EM_NS32K
: return "National Semiconductor 32000 series";
2317 case EM_TPC
: return "Tenor Network TPC processor";
2318 case EM_SNP1K
: return "Trebia SNP 1000 processor";
2320 case EM_ST200
: return "STMicroelectronics ST200 microcontroller";
2322 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
2323 case EM_MAX
: return "MAX Processor";
2324 case EM_CR
: return "National Semiconductor CompactRISC";
2325 case EM_F2MC16
: return "Fujitsu F2MC16";
2326 case EM_MSP430
: return "Texas Instruments msp430 microcontroller";
2327 case EM_BLACKFIN
: return "Analog Devices Blackfin";
2328 case EM_SE_C33
: return "S1C33 Family of Seiko Epson processors";
2329 case EM_SEP
: return "Sharp embedded microprocessor";
2330 case EM_ARCA
: return "Arca RISC microprocessor";
2332 case EM_UNICORE
: return "Unicore";
2333 case EM_EXCESS
: return "eXcess 16/32/64-bit configurable embedded CPU";
2334 case EM_DXP
: return "Icera Semiconductor Inc. Deep Execution Processor";
2335 case EM_ALTERA_NIOS2
: return "Altera Nios II";
2336 case EM_CRX
: return "National Semiconductor CRX microprocessor";
2337 case EM_XGATE
: return "Motorola XGATE embedded processor";
2339 case EM_XC16X
: return "Infineon Technologies xc16x";
2340 case EM_M16C
: return "Renesas M16C series microprocessors";
2341 case EM_DSPIC30F
: return "Microchip Technology dsPIC30F Digital Signal Controller";
2342 case EM_CE
: return "Freescale Communication Engine RISC core";
2344 case EM_M32C
: return "Renesas M32c";
2346 case EM_TSK3000
: return "Altium TSK3000 core";
2347 case EM_RS08
: return "Freescale RS08 embedded processor";
2348 case EM_ECOG2
: return "Cyan Technology eCOG2 microprocessor";
2349 case EM_SCORE
: return "SUNPLUS S+Core";
2350 case EM_DSP24
: return "New Japan Radio (NJR) 24-bit DSP Processor";
2351 case EM_VIDEOCORE3
: return "Broadcom VideoCore III processor";
2352 case EM_LATTICEMICO32
: return "Lattice Mico32";
2353 case EM_SE_C17
: return "Seiko Epson C17 family";
2355 case EM_TI_C6000
: return "Texas Instruments TMS320C6000 DSP family";
2356 case EM_TI_C2000
: return "Texas Instruments TMS320C2000 DSP family";
2357 case EM_TI_C5500
: return "Texas Instruments TMS320C55x DSP family";
2358 case EM_TI_PRU
: return "TI PRU I/O processor";
2360 case EM_MMDSP_PLUS
: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2361 case EM_CYPRESS_M8C
: return "Cypress M8C microprocessor";
2362 case EM_R32C
: return "Renesas R32C series microprocessors";
2363 case EM_TRIMEDIA
: return "NXP Semiconductors TriMedia architecture family";
2364 case EM_QDSP6
: return "QUALCOMM DSP6 Processor";
2365 case EM_8051
: return "Intel 8051 and variants";
2366 case EM_STXP7X
: return "STMicroelectronics STxP7x family";
2367 case EM_NDS32
: return "Andes Technology compact code size embedded RISC processor family";
2368 case EM_ECOG1X
: return "Cyan Technology eCOG1X family";
2369 case EM_MAXQ30
: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2371 case EM_XIMO16
: return "New Japan Radio (NJR) 16-bit DSP Processor";
2372 case EM_MANIK
: return "M2000 Reconfigurable RISC Microprocessor";
2373 case EM_CRAYNV2
: return "Cray Inc. NV2 vector architecture";
2374 case EM_RX
: return "Renesas RX";
2375 case EM_METAG
: return "Imagination Technologies Meta processor architecture";
2376 case EM_MCST_ELBRUS
: return "MCST Elbrus general purpose hardware architecture";
2377 case EM_ECOG16
: return "Cyan Technology eCOG16 family";
2380 case EM_MICROBLAZE_OLD
: return "Xilinx MicroBlaze";
2381 case EM_ETPU
: return "Freescale Extended Time Processing Unit";
2382 case EM_SLE9X
: return "Infineon Technologies SLE9X core";
2384 case EM_L1OM
: return "Intel L1OM";
2385 case EM_K1OM
: return "Intel K1OM";
2386 case EM_INTEL182
: return "Intel (reserved)";
2387 case EM_AARCH64
: return "AArch64";
2388 case EM_ARM184
: return "ARM (reserved)";
2389 case EM_AVR32
: return "Atmel Corporation 32-bit microprocessor";
2390 case EM_STM8
: return "STMicroeletronics STM8 8-bit microcontroller";
2391 case EM_TILE64
: return "Tilera TILE64 multicore architecture family";
2392 case EM_TILEPRO
: return "Tilera TILEPro multicore architecture family";
2394 case EM_CUDA
: return "NVIDIA CUDA architecture";
2395 case EM_TILEGX
: return "Tilera TILE-Gx multicore architecture family";
2396 case EM_CLOUDSHIELD
: return "CloudShield architecture family";
2397 case EM_COREA_1ST
: return "KIPO-KAIST Core-A 1st generation processor family";
2398 case EM_COREA_2ND
: return "KIPO-KAIST Core-A 2nd generation processor family";
2399 case EM_ARC_COMPACT2
: return "ARCv2";
2400 case EM_OPEN8
: return "Open8 8-bit RISC soft processor core";
2401 case EM_RL78
: return "Renesas RL78";
2402 case EM_VIDEOCORE5
: return "Broadcom VideoCore V processor";
2403 case EM_78K0R
: return "Renesas 78K0R";
2405 case EM_56800EX
: return "Freescale 56800EX Digital Signal Controller (DSC)";
2406 case EM_BA1
: return "Beyond BA1 CPU architecture";
2407 case EM_BA2
: return "Beyond BA2 CPU architecture";
2408 case EM_XCORE
: return "XMOS xCORE processor family";
2409 case EM_MCHP_PIC
: return "Microchip 8-bit PIC(r) family";
2411 case EM_KM32
: return "KM211 KM32 32-bit processor";
2412 case EM_KMX32
: return "KM211 KMX32 32-bit processor";
2413 case EM_KMX16
: return "KM211 KMX16 16-bit processor";
2414 case EM_KMX8
: return "KM211 KMX8 8-bit processor";
2415 case EM_KVARC
: return "KM211 KVARC processor";
2416 case EM_CDP
: return "Paneve CDP architecture family";
2417 case EM_COGE
: return "Cognitive Smart Memory Processor";
2418 case EM_COOL
: return "Bluechip Systems CoolEngine";
2419 case EM_NORC
: return "Nanoradio Optimized RISC";
2420 case EM_CSR_KALIMBA
: return "CSR Kalimba architecture family";
2422 case EM_Z80
: return "Zilog Z80";
2423 case EM_VISIUM
: return "CDS VISIUMcore processor";
2424 case EM_FT32
: return "FTDI Chip FT32";
2425 case EM_MOXIE
: return "Moxie";
2426 case EM_AMDGPU
: return "AMD GPU";
2427 case EM_RISCV
: return "RISC-V";
2428 case EM_LANAI
: return "Lanai 32-bit processor";
2429 case EM_BPF
: return "Linux BPF";
2431 /* Large numbers... */
2432 case EM_MT
: return "Morpho Techologies MT processor";
2433 case EM_ALPHA
: return "Alpha";
2434 case EM_WEBASSEMBLY
: return "Web Assembly";
2435 case EM_DLX
: return "OpenDLX";
2436 case EM_XSTORMY16
: return "Sanyo XStormy16 CPU core";
2437 case EM_IQ2000
: return "Vitesse IQ2000";
2439 case EM_NIOS32
: return "Altera Nios";
2440 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
2441 case EM_ADAPTEVA_EPIPHANY
: return "Adapteva EPIPHANY";
2442 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
2445 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
2451 decode_ARC_machine_flags (unsigned e_flags
, unsigned e_machine
, char buf
[])
2453 /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2. Some
2454 other compilers don't a specific architecture type in the e_flags, and
2455 instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
2456 architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
2459 Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
2460 but also sets a specific architecture type in the e_flags field.
2462 However, when decoding the flags we don't worry if we see an
2463 unexpected pairing, for example EM_ARC_COMPACT machine type, with
2464 ARCEM architecture type. */
2466 switch (e_flags
& EF_ARC_MACH_MSK
)
2468 /* We only expect these to occur for EM_ARC_COMPACT2. */
2469 case EF_ARC_CPU_ARCV2EM
:
2470 strcat (buf
, ", ARC EM");
2472 case EF_ARC_CPU_ARCV2HS
:
2473 strcat (buf
, ", ARC HS");
2476 /* We only expect these to occur for EM_ARC_COMPACT. */
2477 case E_ARC_MACH_ARC600
:
2478 strcat (buf
, ", ARC600");
2480 case E_ARC_MACH_ARC601
:
2481 strcat (buf
, ", ARC601");
2483 case E_ARC_MACH_ARC700
:
2484 strcat (buf
, ", ARC700");
2487 /* The only times we should end up here are (a) A corrupt ELF, (b) A
2488 new ELF with new architecture being read by an old version of
2489 readelf, or (c) An ELF built with non-GNU compiler that does not
2490 set the architecture in the e_flags. */
2492 if (e_machine
== EM_ARC_COMPACT
)
2493 strcat (buf
, ", Unknown ARCompact");
2495 strcat (buf
, ", Unknown ARC");
2499 switch (e_flags
& EF_ARC_OSABI_MSK
)
2501 case E_ARC_OSABI_ORIG
:
2502 strcat (buf
, ", (ABI:legacy)");
2504 case E_ARC_OSABI_V2
:
2505 strcat (buf
, ", (ABI:v2)");
2507 /* Only upstream 3.9+ kernels will support ARCv2 ISA. */
2508 case E_ARC_OSABI_V3
:
2509 strcat (buf
, ", v3 no-legacy-syscalls ABI");
2511 case E_ARC_OSABI_V4
:
2512 strcat (buf
, ", v4 ABI");
2515 strcat (buf
, ", unrecognised ARC OSABI flag");
2521 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
2524 bfd_boolean unknown
= FALSE
;
2526 eabi
= EF_ARM_EABI_VERSION (e_flags
);
2527 e_flags
&= ~ EF_ARM_EABIMASK
;
2529 /* Handle "generic" ARM flags. */
2530 if (e_flags
& EF_ARM_RELEXEC
)
2532 strcat (buf
, ", relocatable executable");
2533 e_flags
&= ~ EF_ARM_RELEXEC
;
2536 /* Now handle EABI specific flags. */
2540 strcat (buf
, ", <unrecognized EABI>");
2545 case EF_ARM_EABI_VER1
:
2546 strcat (buf
, ", Version1 EABI");
2551 /* Process flags one bit at a time. */
2552 flag
= e_flags
& - e_flags
;
2557 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2558 strcat (buf
, ", sorted symbol tables");
2568 case EF_ARM_EABI_VER2
:
2569 strcat (buf
, ", Version2 EABI");
2574 /* Process flags one bit at a time. */
2575 flag
= e_flags
& - e_flags
;
2580 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2581 strcat (buf
, ", sorted symbol tables");
2584 case EF_ARM_DYNSYMSUSESEGIDX
:
2585 strcat (buf
, ", dynamic symbols use segment index");
2588 case EF_ARM_MAPSYMSFIRST
:
2589 strcat (buf
, ", mapping symbols precede others");
2599 case EF_ARM_EABI_VER3
:
2600 strcat (buf
, ", Version3 EABI");
2603 case EF_ARM_EABI_VER4
:
2604 strcat (buf
, ", Version4 EABI");
2609 /* Process flags one bit at a time. */
2610 flag
= e_flags
& - e_flags
;
2616 strcat (buf
, ", BE8");
2620 strcat (buf
, ", LE8");
2630 case EF_ARM_EABI_VER5
:
2631 strcat (buf
, ", Version5 EABI");
2636 /* Process flags one bit at a time. */
2637 flag
= e_flags
& - e_flags
;
2643 strcat (buf
, ", BE8");
2647 strcat (buf
, ", LE8");
2650 case EF_ARM_ABI_FLOAT_SOFT
: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2651 strcat (buf
, ", soft-float ABI");
2654 case EF_ARM_ABI_FLOAT_HARD
: /* Conflicts with EF_ARM_VFP_FLOAT. */
2655 strcat (buf
, ", hard-float ABI");
2665 case EF_ARM_EABI_UNKNOWN
:
2666 strcat (buf
, ", GNU EABI");
2671 /* Process flags one bit at a time. */
2672 flag
= e_flags
& - e_flags
;
2677 case EF_ARM_INTERWORK
:
2678 strcat (buf
, ", interworking enabled");
2681 case EF_ARM_APCS_26
:
2682 strcat (buf
, ", uses APCS/26");
2685 case EF_ARM_APCS_FLOAT
:
2686 strcat (buf
, ", uses APCS/float");
2690 strcat (buf
, ", position independent");
2694 strcat (buf
, ", 8 bit structure alignment");
2697 case EF_ARM_NEW_ABI
:
2698 strcat (buf
, ", uses new ABI");
2701 case EF_ARM_OLD_ABI
:
2702 strcat (buf
, ", uses old ABI");
2705 case EF_ARM_SOFT_FLOAT
:
2706 strcat (buf
, ", software FP");
2709 case EF_ARM_VFP_FLOAT
:
2710 strcat (buf
, ", VFP");
2713 case EF_ARM_MAVERICK_FLOAT
:
2714 strcat (buf
, ", Maverick FP");
2725 strcat (buf
,_(", <unknown>"));
2729 decode_AVR_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2731 --size
; /* Leave space for null terminator. */
2733 switch (e_flags
& EF_AVR_MACH
)
2735 case E_AVR_MACH_AVR1
:
2736 strncat (buf
, ", avr:1", size
);
2738 case E_AVR_MACH_AVR2
:
2739 strncat (buf
, ", avr:2", size
);
2741 case E_AVR_MACH_AVR25
:
2742 strncat (buf
, ", avr:25", size
);
2744 case E_AVR_MACH_AVR3
:
2745 strncat (buf
, ", avr:3", size
);
2747 case E_AVR_MACH_AVR31
:
2748 strncat (buf
, ", avr:31", size
);
2750 case E_AVR_MACH_AVR35
:
2751 strncat (buf
, ", avr:35", size
);
2753 case E_AVR_MACH_AVR4
:
2754 strncat (buf
, ", avr:4", size
);
2756 case E_AVR_MACH_AVR5
:
2757 strncat (buf
, ", avr:5", size
);
2759 case E_AVR_MACH_AVR51
:
2760 strncat (buf
, ", avr:51", size
);
2762 case E_AVR_MACH_AVR6
:
2763 strncat (buf
, ", avr:6", size
);
2765 case E_AVR_MACH_AVRTINY
:
2766 strncat (buf
, ", avr:100", size
);
2768 case E_AVR_MACH_XMEGA1
:
2769 strncat (buf
, ", avr:101", size
);
2771 case E_AVR_MACH_XMEGA2
:
2772 strncat (buf
, ", avr:102", size
);
2774 case E_AVR_MACH_XMEGA3
:
2775 strncat (buf
, ", avr:103", size
);
2777 case E_AVR_MACH_XMEGA4
:
2778 strncat (buf
, ", avr:104", size
);
2780 case E_AVR_MACH_XMEGA5
:
2781 strncat (buf
, ", avr:105", size
);
2783 case E_AVR_MACH_XMEGA6
:
2784 strncat (buf
, ", avr:106", size
);
2786 case E_AVR_MACH_XMEGA7
:
2787 strncat (buf
, ", avr:107", size
);
2790 strncat (buf
, ", avr:<unknown>", size
);
2794 size
-= strlen (buf
);
2795 if (e_flags
& EF_AVR_LINKRELAX_PREPARED
)
2796 strncat (buf
, ", link-relax", size
);
2800 decode_NDS32_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2806 bfd_boolean has_fpu
= FALSE
;
2809 static const char *ABI_STRINGS
[] =
2811 "ABI v0", /* use r5 as return register; only used in N1213HC */
2812 "ABI v1", /* use r0 as return register */
2813 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2814 "ABI v2fp", /* for FPU */
2818 static const char *VER_STRINGS
[] =
2820 "Andes ELF V1.3 or older",
2824 static const char *ARCH_STRINGS
[] =
2833 abi
= EF_NDS_ABI
& e_flags
;
2834 arch
= EF_NDS_ARCH
& e_flags
;
2835 config
= EF_NDS_INST
& e_flags
;
2836 version
= EF_NDS32_ELF_VERSION
& e_flags
;
2838 memset (buf
, 0, size
);
2845 case E_NDS_ABI_V2FP
:
2846 case E_NDS_ABI_AABI
:
2847 case E_NDS_ABI_V2FP_PLUS
:
2848 /* In case there are holes in the array. */
2849 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ABI_STRINGS
[abi
>> EF_NDS_ABI_SHIFT
]);
2853 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ABI>");
2859 case E_NDS32_ELF_VER_1_2
:
2860 case E_NDS32_ELF_VER_1_3
:
2861 case E_NDS32_ELF_VER_1_4
:
2862 r
+= snprintf (buf
+ r
, size
- r
, ", %s", VER_STRINGS
[version
>> EF_NDS32_ELF_VERSION_SHIFT
]);
2866 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ELF version number>");
2870 if (E_NDS_ABI_V0
== abi
)
2872 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2873 r
+= snprintf (buf
+ r
, size
- r
, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2874 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2875 r
+= snprintf (buf
+ r
, size
-r
, ", 16b"); /* has 16-bit instructions */
2881 case E_NDS_ARCH_STAR_V1_0
:
2882 case E_NDS_ARCH_STAR_V2_0
:
2883 case E_NDS_ARCH_STAR_V3_0
:
2884 case E_NDS_ARCH_STAR_V3_M
:
2885 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ARCH_STRINGS
[arch
>> EF_NDS_ARCH_SHIFT
]);
2889 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized architecture>");
2890 /* ARCH version determines how the e_flags are interpreted.
2891 If it is unknown, we cannot proceed. */
2895 /* Newer ABI; Now handle architecture specific flags. */
2896 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2898 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2899 r
+= snprintf (buf
+ r
, size
-r
, ", MFUSR_PC");
2901 if (!(config
& E_NDS32_HAS_NO_MAC_INST
))
2902 r
+= snprintf (buf
+ r
, size
-r
, ", MAC");
2904 if (config
& E_NDS32_HAS_DIV_INST
)
2905 r
+= snprintf (buf
+ r
, size
-r
, ", DIV");
2907 if (config
& E_NDS32_HAS_16BIT_INST
)
2908 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
2912 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2914 if (version
<= E_NDS32_ELF_VER_1_3
)
2915 r
+= snprintf (buf
+ r
, size
-r
, ", [B8]");
2917 r
+= snprintf (buf
+ r
, size
-r
, ", EX9");
2920 if (config
& E_NDS32_HAS_MAC_DX_INST
)
2921 r
+= snprintf (buf
+ r
, size
-r
, ", MAC_DX");
2923 if (config
& E_NDS32_HAS_DIV_DX_INST
)
2924 r
+= snprintf (buf
+ r
, size
-r
, ", DIV_DX");
2926 if (config
& E_NDS32_HAS_16BIT_INST
)
2928 if (version
<= E_NDS32_ELF_VER_1_3
)
2929 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
2931 r
+= snprintf (buf
+ r
, size
-r
, ", IFC");
2935 if (config
& E_NDS32_HAS_EXT_INST
)
2936 r
+= snprintf (buf
+ r
, size
-r
, ", PERF1");
2938 if (config
& E_NDS32_HAS_EXT2_INST
)
2939 r
+= snprintf (buf
+ r
, size
-r
, ", PERF2");
2941 if (config
& E_NDS32_HAS_FPU_INST
)
2944 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_SP");
2947 if (config
& E_NDS32_HAS_FPU_DP_INST
)
2950 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_DP");
2953 if (config
& E_NDS32_HAS_FPU_MAC_INST
)
2956 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_MAC");
2961 switch ((config
& E_NDS32_FPU_REG_CONF
) >> E_NDS32_FPU_REG_CONF_SHIFT
)
2963 case E_NDS32_FPU_REG_8SP_4DP
:
2964 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:8/4");
2966 case E_NDS32_FPU_REG_16SP_8DP
:
2967 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:16/8");
2969 case E_NDS32_FPU_REG_32SP_16DP
:
2970 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/16");
2972 case E_NDS32_FPU_REG_32SP_32DP
:
2973 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/32");
2978 if (config
& E_NDS32_HAS_AUDIO_INST
)
2979 r
+= snprintf (buf
+ r
, size
-r
, ", AUDIO");
2981 if (config
& E_NDS32_HAS_STRING_INST
)
2982 r
+= snprintf (buf
+ r
, size
-r
, ", STR");
2984 if (config
& E_NDS32_HAS_REDUCED_REGS
)
2985 r
+= snprintf (buf
+ r
, size
-r
, ", 16REG");
2987 if (config
& E_NDS32_HAS_VIDEO_INST
)
2989 if (version
<= E_NDS32_ELF_VER_1_3
)
2990 r
+= snprintf (buf
+ r
, size
-r
, ", VIDEO");
2992 r
+= snprintf (buf
+ r
, size
-r
, ", SATURATION");
2995 if (config
& E_NDS32_HAS_ENCRIPT_INST
)
2996 r
+= snprintf (buf
+ r
, size
-r
, ", ENCRP");
2998 if (config
& E_NDS32_HAS_L2C_INST
)
2999 r
+= snprintf (buf
+ r
, size
-r
, ", L2C");
3003 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
3005 static char buf
[1024];
3016 case EM_ARC_COMPACT2
:
3017 case EM_ARC_COMPACT
:
3018 decode_ARC_machine_flags (e_flags
, e_machine
, buf
);
3022 decode_ARM_machine_flags (e_flags
, buf
);
3026 decode_AVR_machine_flags (e_flags
, buf
, sizeof buf
);
3030 if (e_flags
& EF_BFIN_PIC
)
3031 strcat (buf
, ", PIC");
3033 if (e_flags
& EF_BFIN_FDPIC
)
3034 strcat (buf
, ", FDPIC");
3036 if (e_flags
& EF_BFIN_CODE_IN_L1
)
3037 strcat (buf
, ", code in L1");
3039 if (e_flags
& EF_BFIN_DATA_IN_L1
)
3040 strcat (buf
, ", data in L1");
3045 switch (e_flags
& EF_FRV_CPU_MASK
)
3047 case EF_FRV_CPU_GENERIC
:
3051 strcat (buf
, ", fr???");
3054 case EF_FRV_CPU_FR300
:
3055 strcat (buf
, ", fr300");
3058 case EF_FRV_CPU_FR400
:
3059 strcat (buf
, ", fr400");
3061 case EF_FRV_CPU_FR405
:
3062 strcat (buf
, ", fr405");
3065 case EF_FRV_CPU_FR450
:
3066 strcat (buf
, ", fr450");
3069 case EF_FRV_CPU_FR500
:
3070 strcat (buf
, ", fr500");
3072 case EF_FRV_CPU_FR550
:
3073 strcat (buf
, ", fr550");
3076 case EF_FRV_CPU_SIMPLE
:
3077 strcat (buf
, ", simple");
3079 case EF_FRV_CPU_TOMCAT
:
3080 strcat (buf
, ", tomcat");
3086 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
3087 strcat (buf
, ", m68000");
3088 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
3089 strcat (buf
, ", cpu32");
3090 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
3091 strcat (buf
, ", fido_a");
3094 char const * isa
= _("unknown");
3095 char const * mac
= _("unknown mac");
3096 char const * additional
= NULL
;
3098 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
3100 case EF_M68K_CF_ISA_A_NODIV
:
3102 additional
= ", nodiv";
3104 case EF_M68K_CF_ISA_A
:
3107 case EF_M68K_CF_ISA_A_PLUS
:
3110 case EF_M68K_CF_ISA_B_NOUSP
:
3112 additional
= ", nousp";
3114 case EF_M68K_CF_ISA_B
:
3117 case EF_M68K_CF_ISA_C
:
3120 case EF_M68K_CF_ISA_C_NODIV
:
3122 additional
= ", nodiv";
3125 strcat (buf
, ", cf, isa ");
3128 strcat (buf
, additional
);
3129 if (e_flags
& EF_M68K_CF_FLOAT
)
3130 strcat (buf
, ", float");
3131 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
3136 case EF_M68K_CF_MAC
:
3139 case EF_M68K_CF_EMAC
:
3142 case EF_M68K_CF_EMAC_B
:
3155 switch (e_flags
& EF_MEP_CPU_MASK
)
3157 case EF_MEP_CPU_MEP
: strcat (buf
, ", generic MeP"); break;
3158 case EF_MEP_CPU_C2
: strcat (buf
, ", MeP C2"); break;
3159 case EF_MEP_CPU_C3
: strcat (buf
, ", MeP C3"); break;
3160 case EF_MEP_CPU_C4
: strcat (buf
, ", MeP C4"); break;
3161 case EF_MEP_CPU_C5
: strcat (buf
, ", MeP C5"); break;
3162 case EF_MEP_CPU_H1
: strcat (buf
, ", MeP H1"); break;
3163 default: strcat (buf
, _(", <unknown MeP cpu type>")); break;
3166 switch (e_flags
& EF_MEP_COP_MASK
)
3168 case EF_MEP_COP_NONE
: break;
3169 case EF_MEP_COP_AVC
: strcat (buf
, ", AVC coprocessor"); break;
3170 case EF_MEP_COP_AVC2
: strcat (buf
, ", AVC2 coprocessor"); break;
3171 case EF_MEP_COP_FMAX
: strcat (buf
, ", FMAX coprocessor"); break;
3172 case EF_MEP_COP_IVC2
: strcat (buf
, ", IVC2 coprocessor"); break;
3173 default: strcat (buf
, _("<unknown MeP copro type>")); break;
3176 if (e_flags
& EF_MEP_LIBRARY
)
3177 strcat (buf
, ", Built for Library");
3179 if (e_flags
& EF_MEP_INDEX_MASK
)
3180 sprintf (buf
+ strlen (buf
), ", Configuration Index: %#x",
3181 e_flags
& EF_MEP_INDEX_MASK
);
3183 if (e_flags
& ~ EF_MEP_ALL_FLAGS
)
3184 sprintf (buf
+ strlen (buf
), _(", unknown flags bits: %#x"),
3185 e_flags
& ~ EF_MEP_ALL_FLAGS
);
3189 if (e_flags
& EF_PPC_EMB
)
3190 strcat (buf
, ", emb");
3192 if (e_flags
& EF_PPC_RELOCATABLE
)
3193 strcat (buf
, _(", relocatable"));
3195 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
3196 strcat (buf
, _(", relocatable-lib"));
3200 if (e_flags
& EF_PPC64_ABI
)
3202 char abi
[] = ", abiv0";
3204 abi
[6] += e_flags
& EF_PPC64_ABI
;
3210 if ((e_flags
& EF_RH850_ABI
) == EF_RH850_ABI
)
3211 strcat (buf
, ", RH850 ABI");
3213 if (e_flags
& EF_V800_850E3
)
3214 strcat (buf
, ", V3 architecture");
3216 if ((e_flags
& (EF_RH850_FPU_DOUBLE
| EF_RH850_FPU_SINGLE
)) == 0)
3217 strcat (buf
, ", FPU not used");
3219 if ((e_flags
& (EF_RH850_REGMODE22
| EF_RH850_REGMODE32
)) == 0)
3220 strcat (buf
, ", regmode: COMMON");
3222 if ((e_flags
& (EF_RH850_GP_FIX
| EF_RH850_GP_NOFIX
)) == 0)
3223 strcat (buf
, ", r4 not used");
3225 if ((e_flags
& (EF_RH850_EP_FIX
| EF_RH850_EP_NOFIX
)) == 0)
3226 strcat (buf
, ", r30 not used");
3228 if ((e_flags
& (EF_RH850_TP_FIX
| EF_RH850_TP_NOFIX
)) == 0)
3229 strcat (buf
, ", r5 not used");
3231 if ((e_flags
& (EF_RH850_REG2_RESERVE
| EF_RH850_REG2_NORESERVE
)) == 0)
3232 strcat (buf
, ", r2 not used");
3234 for (e_flags
&= 0xFFFF; e_flags
; e_flags
&= ~ (e_flags
& - e_flags
))
3236 switch (e_flags
& - e_flags
)
3238 case EF_RH850_FPU_DOUBLE
: strcat (buf
, ", double precision FPU"); break;
3239 case EF_RH850_FPU_SINGLE
: strcat (buf
, ", single precision FPU"); break;
3240 case EF_RH850_REGMODE22
: strcat (buf
, ", regmode:22"); break;
3241 case EF_RH850_REGMODE32
: strcat (buf
, ", regmode:23"); break;
3242 case EF_RH850_GP_FIX
: strcat (buf
, ", r4 fixed"); break;
3243 case EF_RH850_GP_NOFIX
: strcat (buf
, ", r4 free"); break;
3244 case EF_RH850_EP_FIX
: strcat (buf
, ", r30 fixed"); break;
3245 case EF_RH850_EP_NOFIX
: strcat (buf
, ", r30 free"); break;
3246 case EF_RH850_TP_FIX
: strcat (buf
, ", r5 fixed"); break;
3247 case EF_RH850_TP_NOFIX
: strcat (buf
, ", r5 free"); break;
3248 case EF_RH850_REG2_RESERVE
: strcat (buf
, ", r2 fixed"); break;
3249 case EF_RH850_REG2_NORESERVE
: strcat (buf
, ", r2 free"); break;
3256 case EM_CYGNUS_V850
:
3257 switch (e_flags
& EF_V850_ARCH
)
3259 case E_V850E3V5_ARCH
:
3260 strcat (buf
, ", v850e3v5");
3262 case E_V850E2V3_ARCH
:
3263 strcat (buf
, ", v850e2v3");
3266 strcat (buf
, ", v850e2");
3269 strcat (buf
, ", v850e1");
3272 strcat (buf
, ", v850e");
3275 strcat (buf
, ", v850");
3278 strcat (buf
, _(", unknown v850 architecture variant"));
3284 case EM_CYGNUS_M32R
:
3285 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
3286 strcat (buf
, ", m32r");
3290 case EM_MIPS_RS3_LE
:
3291 if (e_flags
& EF_MIPS_NOREORDER
)
3292 strcat (buf
, ", noreorder");
3294 if (e_flags
& EF_MIPS_PIC
)
3295 strcat (buf
, ", pic");
3297 if (e_flags
& EF_MIPS_CPIC
)
3298 strcat (buf
, ", cpic");
3300 if (e_flags
& EF_MIPS_UCODE
)
3301 strcat (buf
, ", ugen_reserved");
3303 if (e_flags
& EF_MIPS_ABI2
)
3304 strcat (buf
, ", abi2");
3306 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
3307 strcat (buf
, ", odk first");
3309 if (e_flags
& EF_MIPS_32BITMODE
)
3310 strcat (buf
, ", 32bitmode");
3312 if (e_flags
& EF_MIPS_NAN2008
)
3313 strcat (buf
, ", nan2008");
3315 if (e_flags
& EF_MIPS_FP64
)
3316 strcat (buf
, ", fp64");
3318 switch ((e_flags
& EF_MIPS_MACH
))
3320 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
3321 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
3322 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
3323 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
3324 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
3325 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
3326 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
3327 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
3328 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
3329 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
3330 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
3331 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
3332 case E_MIPS_MACH_LS3A
: strcat (buf
, ", loongson-3a"); break;
3333 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
3334 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
3335 case E_MIPS_MACH_OCTEON3
: strcat (buf
, ", octeon3"); break;
3336 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
3337 case E_MIPS_MACH_IAMR2
: strcat (buf
, ", interaptiv-mr2"); break;
3339 /* We simply ignore the field in this case to avoid confusion:
3340 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3343 default: strcat (buf
, _(", unknown CPU")); break;
3346 switch ((e_flags
& EF_MIPS_ABI
))
3348 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
3349 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
3350 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
3351 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
3353 /* We simply ignore the field in this case to avoid confusion:
3354 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3355 This means it is likely to be an o32 file, but not for
3358 default: strcat (buf
, _(", unknown ABI")); break;
3361 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
3362 strcat (buf
, ", mdmx");
3364 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
3365 strcat (buf
, ", mips16");
3367 if (e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
3368 strcat (buf
, ", micromips");
3370 switch ((e_flags
& EF_MIPS_ARCH
))
3372 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
3373 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
3374 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
3375 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
3376 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
3377 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
3378 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
3379 case E_MIPS_ARCH_32R6
: strcat (buf
, ", mips32r6"); break;
3380 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
3381 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
3382 case E_MIPS_ARCH_64R6
: strcat (buf
, ", mips64r6"); break;
3383 default: strcat (buf
, _(", unknown ISA")); break;
3388 decode_NDS32_machine_flags (e_flags
, buf
, sizeof buf
);
3392 if (e_flags
& EF_RISCV_RVC
)
3393 strcat (buf
, ", RVC");
3395 switch (e_flags
& EF_RISCV_FLOAT_ABI
)
3397 case EF_RISCV_FLOAT_ABI_SOFT
:
3398 strcat (buf
, ", soft-float ABI");
3401 case EF_RISCV_FLOAT_ABI_SINGLE
:
3402 strcat (buf
, ", single-float ABI");
3405 case EF_RISCV_FLOAT_ABI_DOUBLE
:
3406 strcat (buf
, ", double-float ABI");
3409 case EF_RISCV_FLOAT_ABI_QUAD
:
3410 strcat (buf
, ", quad-float ABI");
3416 switch ((e_flags
& EF_SH_MACH_MASK
))
3418 case EF_SH1
: strcat (buf
, ", sh1"); break;
3419 case EF_SH2
: strcat (buf
, ", sh2"); break;
3420 case EF_SH3
: strcat (buf
, ", sh3"); break;
3421 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
3422 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
3423 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
3424 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
3425 case EF_SH4
: strcat (buf
, ", sh4"); break;
3426 case EF_SH5
: strcat (buf
, ", sh5"); break;
3427 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
3428 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
3429 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
3430 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
3431 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
3432 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
3433 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
3434 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
3435 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3436 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
3437 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
3438 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
3439 default: strcat (buf
, _(", unknown ISA")); break;
3442 if (e_flags
& EF_SH_PIC
)
3443 strcat (buf
, ", pic");
3445 if (e_flags
& EF_SH_FDPIC
)
3446 strcat (buf
, ", fdpic");
3450 if (e_flags
& EF_OR1K_NODELAY
)
3451 strcat (buf
, ", no delay");
3455 if (e_flags
& EF_SPARC_32PLUS
)
3456 strcat (buf
, ", v8+");
3458 if (e_flags
& EF_SPARC_SUN_US1
)
3459 strcat (buf
, ", ultrasparcI");
3461 if (e_flags
& EF_SPARC_SUN_US3
)
3462 strcat (buf
, ", ultrasparcIII");
3464 if (e_flags
& EF_SPARC_HAL_R1
)
3465 strcat (buf
, ", halr1");
3467 if (e_flags
& EF_SPARC_LEDATA
)
3468 strcat (buf
, ", ledata");
3470 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
3471 strcat (buf
, ", tso");
3473 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
3474 strcat (buf
, ", pso");
3476 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
3477 strcat (buf
, ", rmo");
3481 switch (e_flags
& EF_PARISC_ARCH
)
3483 case EFA_PARISC_1_0
:
3484 strcpy (buf
, ", PA-RISC 1.0");
3486 case EFA_PARISC_1_1
:
3487 strcpy (buf
, ", PA-RISC 1.1");
3489 case EFA_PARISC_2_0
:
3490 strcpy (buf
, ", PA-RISC 2.0");
3495 if (e_flags
& EF_PARISC_TRAPNIL
)
3496 strcat (buf
, ", trapnil");
3497 if (e_flags
& EF_PARISC_EXT
)
3498 strcat (buf
, ", ext");
3499 if (e_flags
& EF_PARISC_LSB
)
3500 strcat (buf
, ", lsb");
3501 if (e_flags
& EF_PARISC_WIDE
)
3502 strcat (buf
, ", wide");
3503 if (e_flags
& EF_PARISC_NO_KABP
)
3504 strcat (buf
, ", no kabp");
3505 if (e_flags
& EF_PARISC_LAZYSWAP
)
3506 strcat (buf
, ", lazyswap");
3511 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
3512 strcat (buf
, ", new calling convention");
3514 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
3515 strcat (buf
, ", gnu calling convention");
3519 if ((e_flags
& EF_IA_64_ABI64
))
3520 strcat (buf
, ", 64-bit");
3522 strcat (buf
, ", 32-bit");
3523 if ((e_flags
& EF_IA_64_REDUCEDFP
))
3524 strcat (buf
, ", reduced fp model");
3525 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
3526 strcat (buf
, ", no function descriptors, constant gp");
3527 else if ((e_flags
& EF_IA_64_CONS_GP
))
3528 strcat (buf
, ", constant gp");
3529 if ((e_flags
& EF_IA_64_ABSOLUTE
))
3530 strcat (buf
, ", absolute");
3531 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
3533 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
3534 strcat (buf
, ", vms_linkages");
3535 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
3537 case EF_IA_64_VMS_COMCOD_SUCCESS
:
3539 case EF_IA_64_VMS_COMCOD_WARNING
:
3540 strcat (buf
, ", warning");
3542 case EF_IA_64_VMS_COMCOD_ERROR
:
3543 strcat (buf
, ", error");
3545 case EF_IA_64_VMS_COMCOD_ABORT
:
3546 strcat (buf
, ", abort");
3549 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3550 e_flags
& EF_IA_64_VMS_COMCOD
);
3551 strcat (buf
, ", <unknown>");
3557 if ((e_flags
& EF_VAX_NONPIC
))
3558 strcat (buf
, ", non-PIC");
3559 if ((e_flags
& EF_VAX_DFLOAT
))
3560 strcat (buf
, ", D-Float");
3561 if ((e_flags
& EF_VAX_GFLOAT
))
3562 strcat (buf
, ", G-Float");
3566 if (e_flags
& EF_VISIUM_ARCH_MCM
)
3567 strcat (buf
, ", mcm");
3568 else if (e_flags
& EF_VISIUM_ARCH_MCM24
)
3569 strcat (buf
, ", mcm24");
3570 if (e_flags
& EF_VISIUM_ARCH_GR6
)
3571 strcat (buf
, ", gr6");
3575 switch (e_flags
& E_FLAG_RL78_CPU_MASK
)
3577 case E_FLAG_RL78_ANY_CPU
: break;
3578 case E_FLAG_RL78_G10
: strcat (buf
, ", G10"); break;
3579 case E_FLAG_RL78_G13
: strcat (buf
, ", G13"); break;
3580 case E_FLAG_RL78_G14
: strcat (buf
, ", G14"); break;
3582 if (e_flags
& E_FLAG_RL78_64BIT_DOUBLES
)
3583 strcat (buf
, ", 64-bit doubles");
3587 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
3588 strcat (buf
, ", 64-bit doubles");
3589 if (e_flags
& E_FLAG_RX_DSP
)
3590 strcat (buf
, ", dsp");
3591 if (e_flags
& E_FLAG_RX_PID
)
3592 strcat (buf
, ", pid");
3593 if (e_flags
& E_FLAG_RX_ABI
)
3594 strcat (buf
, ", RX ABI");
3595 if (e_flags
& E_FLAG_RX_SINSNS_SET
)
3596 strcat (buf
, e_flags
& E_FLAG_RX_SINSNS_YES
3597 ? ", uses String instructions" : ", bans String instructions");
3598 if (e_flags
& E_FLAG_RX_V2
)
3599 strcat (buf
, ", V2");
3603 if (e_flags
& EF_S390_HIGH_GPRS
)
3604 strcat (buf
, ", highgprs");
3608 if ((e_flags
& EF_C6000_REL
))
3609 strcat (buf
, ", relocatable module");
3613 strcat (buf
, _(": architecture variant: "));
3614 switch (e_flags
& EF_MSP430_MACH
)
3616 case E_MSP430_MACH_MSP430x11
: strcat (buf
, "MSP430x11"); break;
3617 case E_MSP430_MACH_MSP430x11x1
: strcat (buf
, "MSP430x11x1 "); break;
3618 case E_MSP430_MACH_MSP430x12
: strcat (buf
, "MSP430x12"); break;
3619 case E_MSP430_MACH_MSP430x13
: strcat (buf
, "MSP430x13"); break;
3620 case E_MSP430_MACH_MSP430x14
: strcat (buf
, "MSP430x14"); break;
3621 case E_MSP430_MACH_MSP430x15
: strcat (buf
, "MSP430x15"); break;
3622 case E_MSP430_MACH_MSP430x16
: strcat (buf
, "MSP430x16"); break;
3623 case E_MSP430_MACH_MSP430x31
: strcat (buf
, "MSP430x31"); break;
3624 case E_MSP430_MACH_MSP430x32
: strcat (buf
, "MSP430x32"); break;
3625 case E_MSP430_MACH_MSP430x33
: strcat (buf
, "MSP430x33"); break;
3626 case E_MSP430_MACH_MSP430x41
: strcat (buf
, "MSP430x41"); break;
3627 case E_MSP430_MACH_MSP430x42
: strcat (buf
, "MSP430x42"); break;
3628 case E_MSP430_MACH_MSP430x43
: strcat (buf
, "MSP430x43"); break;
3629 case E_MSP430_MACH_MSP430x44
: strcat (buf
, "MSP430x44"); break;
3630 case E_MSP430_MACH_MSP430X
: strcat (buf
, "MSP430X"); break;
3632 strcat (buf
, _(": unknown")); break;
3635 if (e_flags
& ~ EF_MSP430_MACH
)
3636 strcat (buf
, _(": unknown extra flag bits also present"));
3644 get_osabi_name (unsigned int osabi
)
3646 static char buff
[32];
3650 case ELFOSABI_NONE
: return "UNIX - System V";
3651 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
3652 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
3653 case ELFOSABI_GNU
: return "UNIX - GNU";
3654 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
3655 case ELFOSABI_AIX
: return "UNIX - AIX";
3656 case ELFOSABI_IRIX
: return "UNIX - IRIX";
3657 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
3658 case ELFOSABI_TRU64
: return "UNIX - TRU64";
3659 case ELFOSABI_MODESTO
: return "Novell - Modesto";
3660 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
3661 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
3662 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
3663 case ELFOSABI_AROS
: return "AROS";
3664 case ELFOSABI_FENIXOS
: return "FenixOS";
3665 case ELFOSABI_CLOUDABI
: return "Nuxi CloudABI";
3666 case ELFOSABI_OPENVOS
: return "Stratus Technologies OpenVOS";
3669 switch (elf_header
.e_machine
)
3674 case ELFOSABI_ARM
: return "ARM";
3685 case ELFOSABI_STANDALONE
: return _("Standalone App");
3694 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
3695 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
3704 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
3710 get_aarch64_segment_type (unsigned long type
)
3714 case PT_AARCH64_ARCHEXT
: return "AARCH64_ARCHEXT";
3715 default: return NULL
;
3720 get_arm_segment_type (unsigned long type
)
3724 case PT_ARM_EXIDX
: return "EXIDX";
3725 default: return NULL
;
3730 get_s390_segment_type (unsigned long type
)
3734 case PT_S390_PGSTE
: return "S390_PGSTE";
3735 default: return NULL
;
3740 get_mips_segment_type (unsigned long type
)
3744 case PT_MIPS_REGINFO
: return "REGINFO";
3745 case PT_MIPS_RTPROC
: return "RTPROC";
3746 case PT_MIPS_OPTIONS
: return "OPTIONS";
3747 case PT_MIPS_ABIFLAGS
: return "ABIFLAGS";
3748 default: return NULL
;
3753 get_parisc_segment_type (unsigned long type
)
3757 case PT_HP_TLS
: return "HP_TLS";
3758 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
3759 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
3760 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
3761 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
3762 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
3763 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
3764 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
3765 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
3766 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
3767 case PT_HP_PARALLEL
: return "HP_PARALLEL";
3768 case PT_HP_FASTBIND
: return "HP_FASTBIND";
3769 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
3770 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
3771 case PT_HP_STACK
: return "HP_STACK";
3772 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
3773 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
3774 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
3775 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
3776 default: return NULL
;
3781 get_ia64_segment_type (unsigned long type
)
3785 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
3786 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
3787 case PT_HP_TLS
: return "HP_TLS";
3788 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
3789 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
3790 case PT_IA_64_HP_STACK
: return "HP_STACK";
3791 default: return NULL
;
3796 get_tic6x_segment_type (unsigned long type
)
3800 case PT_C6000_PHATTR
: return "C6000_PHATTR";
3801 default: return NULL
;
3806 get_solaris_segment_type (unsigned long type
)
3810 case 0x6464e550: return "PT_SUNW_UNWIND";
3811 case 0x6474e550: return "PT_SUNW_EH_FRAME";
3812 case 0x6ffffff7: return "PT_LOSUNW";
3813 case 0x6ffffffa: return "PT_SUNWBSS";
3814 case 0x6ffffffb: return "PT_SUNWSTACK";
3815 case 0x6ffffffc: return "PT_SUNWDTRACE";
3816 case 0x6ffffffd: return "PT_SUNWCAP";
3817 case 0x6fffffff: return "PT_HISUNW";
3818 default: return NULL
;
3823 get_segment_type (unsigned long p_type
)
3825 static char buff
[32];
3829 case PT_NULL
: return "NULL";
3830 case PT_LOAD
: return "LOAD";
3831 case PT_DYNAMIC
: return "DYNAMIC";
3832 case PT_INTERP
: return "INTERP";
3833 case PT_NOTE
: return "NOTE";
3834 case PT_SHLIB
: return "SHLIB";
3835 case PT_PHDR
: return "PHDR";
3836 case PT_TLS
: return "TLS";
3837 case PT_GNU_EH_FRAME
: return "GNU_EH_FRAME";
3838 case PT_GNU_STACK
: return "GNU_STACK";
3839 case PT_GNU_RELRO
: return "GNU_RELRO";
3842 if (p_type
>= PT_GNU_MBIND_LO
&& p_type
<= PT_GNU_MBIND_HI
)
3844 sprintf (buff
, "GNU_MBIND+%#lx",
3845 p_type
- PT_GNU_MBIND_LO
);
3847 else if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
3849 const char * result
;
3851 switch (elf_header
.e_machine
)
3854 result
= get_aarch64_segment_type (p_type
);
3857 result
= get_arm_segment_type (p_type
);
3860 case EM_MIPS_RS3_LE
:
3861 result
= get_mips_segment_type (p_type
);
3864 result
= get_parisc_segment_type (p_type
);
3867 result
= get_ia64_segment_type (p_type
);
3870 result
= get_tic6x_segment_type (p_type
);
3874 result
= get_s390_segment_type (p_type
);
3884 sprintf (buff
, "LOPROC+%#lx", p_type
- PT_LOPROC
);
3886 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
3888 const char * result
;
3890 switch (elf_header
.e_machine
)
3893 result
= get_parisc_segment_type (p_type
);
3896 result
= get_ia64_segment_type (p_type
);
3899 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
3900 result
= get_solaris_segment_type (p_type
);
3909 sprintf (buff
, "LOOS+%#lx", p_type
- PT_LOOS
);
3912 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
3919 get_arc_section_type_name (unsigned int sh_type
)
3923 case SHT_ARC_ATTRIBUTES
: return "ARC_ATTRIBUTES";
3931 get_mips_section_type_name (unsigned int sh_type
)
3935 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
3936 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
3937 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
3938 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
3939 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
3940 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
3941 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
3942 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
3943 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
3944 case SHT_MIPS_RELD
: return "MIPS_RELD";
3945 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
3946 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
3947 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
3948 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
3949 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
3950 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
3951 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
3952 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
3953 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
3954 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
3955 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
3956 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
3957 case SHT_MIPS_LINE
: return "MIPS_LINE";
3958 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
3959 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
3960 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
3961 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
3962 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
3963 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
3964 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
3965 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
3966 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
3967 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
3968 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
3969 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
3970 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
3971 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
3972 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
3973 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
3974 case SHT_MIPS_ABIFLAGS
: return "MIPS_ABIFLAGS";
3982 get_parisc_section_type_name (unsigned int sh_type
)
3986 case SHT_PARISC_EXT
: return "PARISC_EXT";
3987 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
3988 case SHT_PARISC_DOC
: return "PARISC_DOC";
3989 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
3990 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
3991 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
3992 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
3993 default: return NULL
;
3998 get_ia64_section_type_name (unsigned int sh_type
)
4000 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
4001 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
4002 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
4006 case SHT_IA_64_EXT
: return "IA_64_EXT";
4007 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
4008 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
4009 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
4010 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
4011 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
4012 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
4013 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
4014 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
4015 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
4023 get_x86_64_section_type_name (unsigned int sh_type
)
4027 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
4028 default: return NULL
;
4033 get_aarch64_section_type_name (unsigned int sh_type
)
4037 case SHT_AARCH64_ATTRIBUTES
: return "AARCH64_ATTRIBUTES";
4038 default: return NULL
;
4043 get_arm_section_type_name (unsigned int sh_type
)
4047 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
4048 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
4049 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
4050 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
4051 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
4052 default: return NULL
;
4057 get_tic6x_section_type_name (unsigned int sh_type
)
4061 case SHT_C6000_UNWIND
: return "C6000_UNWIND";
4062 case SHT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
4063 case SHT_C6000_ATTRIBUTES
: return "C6000_ATTRIBUTES";
4064 case SHT_TI_ICODE
: return "TI_ICODE";
4065 case SHT_TI_XREF
: return "TI_XREF";
4066 case SHT_TI_HANDLER
: return "TI_HANDLER";
4067 case SHT_TI_INITINFO
: return "TI_INITINFO";
4068 case SHT_TI_PHATTRS
: return "TI_PHATTRS";
4069 default: return NULL
;
4074 get_msp430x_section_type_name (unsigned int sh_type
)
4078 case SHT_MSP430_SEC_FLAGS
: return "MSP430_SEC_FLAGS";
4079 case SHT_MSP430_SYM_ALIASES
: return "MSP430_SYM_ALIASES";
4080 case SHT_MSP430_ATTRIBUTES
: return "MSP430_ATTRIBUTES";
4081 default: return NULL
;
4086 get_v850_section_type_name (unsigned int sh_type
)
4090 case SHT_V850_SCOMMON
: return "V850 Small Common";
4091 case SHT_V850_TCOMMON
: return "V850 Tiny Common";
4092 case SHT_V850_ZCOMMON
: return "V850 Zero Common";
4093 case SHT_RENESAS_IOP
: return "RENESAS IOP";
4094 case SHT_RENESAS_INFO
: return "RENESAS INFO";
4095 default: return NULL
;
4100 get_section_type_name (unsigned int sh_type
)
4102 static char buff
[32];
4103 const char * result
;
4107 case SHT_NULL
: return "NULL";
4108 case SHT_PROGBITS
: return "PROGBITS";
4109 case SHT_SYMTAB
: return "SYMTAB";
4110 case SHT_STRTAB
: return "STRTAB";
4111 case SHT_RELA
: return "RELA";
4112 case SHT_HASH
: return "HASH";
4113 case SHT_DYNAMIC
: return "DYNAMIC";
4114 case SHT_NOTE
: return "NOTE";
4115 case SHT_NOBITS
: return "NOBITS";
4116 case SHT_REL
: return "REL";
4117 case SHT_SHLIB
: return "SHLIB";
4118 case SHT_DYNSYM
: return "DYNSYM";
4119 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
4120 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
4121 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
4122 case SHT_GNU_HASH
: return "GNU_HASH";
4123 case SHT_GROUP
: return "GROUP";
4124 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
4125 case SHT_GNU_verdef
: return "VERDEF";
4126 case SHT_GNU_verneed
: return "VERNEED";
4127 case SHT_GNU_versym
: return "VERSYM";
4128 case 0x6ffffff0: return "VERSYM";
4129 case 0x6ffffffc: return "VERDEF";
4130 case 0x7ffffffd: return "AUXILIARY";
4131 case 0x7fffffff: return "FILTER";
4132 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
4135 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
4137 switch (elf_header
.e_machine
)
4140 case EM_ARC_COMPACT
:
4141 case EM_ARC_COMPACT2
:
4142 result
= get_arc_section_type_name (sh_type
);
4145 case EM_MIPS_RS3_LE
:
4146 result
= get_mips_section_type_name (sh_type
);
4149 result
= get_parisc_section_type_name (sh_type
);
4152 result
= get_ia64_section_type_name (sh_type
);
4157 result
= get_x86_64_section_type_name (sh_type
);
4160 result
= get_aarch64_section_type_name (sh_type
);
4163 result
= get_arm_section_type_name (sh_type
);
4166 result
= get_tic6x_section_type_name (sh_type
);
4169 result
= get_msp430x_section_type_name (sh_type
);
4173 case EM_CYGNUS_V850
:
4174 result
= get_v850_section_type_name (sh_type
);
4184 sprintf (buff
, "LOPROC+%#x", sh_type
- SHT_LOPROC
);
4186 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
4188 switch (elf_header
.e_machine
)
4191 result
= get_ia64_section_type_name (sh_type
);
4194 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
4195 result
= get_solaris_section_type (sh_type
);
4200 case SHT_GNU_INCREMENTAL_INPUTS
: result
= "GNU_INCREMENTAL_INPUTS"; break;
4201 case SHT_GNU_ATTRIBUTES
: result
= "GNU_ATTRIBUTES"; break;
4202 case SHT_GNU_HASH
: result
= "GNU_HASH"; break;
4203 case SHT_GNU_LIBLIST
: result
= "GNU_LIBLIST"; break;
4215 sprintf (buff
, "LOOS+%#x", sh_type
- SHT_LOOS
);
4217 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
4219 switch (elf_header
.e_machine
)
4223 case EM_CYGNUS_V850
:
4224 result
= get_v850_section_type_name (sh_type
);
4234 sprintf (buff
, "LOUSER+%#x", sh_type
- SHT_LOUSER
);
4237 /* This message is probably going to be displayed in a 15
4238 character wide field, so put the hex value first. */
4239 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
4245 #define OPTION_DEBUG_DUMP 512
4246 #define OPTION_DYN_SYMS 513
4247 #define OPTION_DWARF_DEPTH 514
4248 #define OPTION_DWARF_START 515
4249 #define OPTION_DWARF_CHECK 516
4251 static struct option options
[] =
4253 {"all", no_argument
, 0, 'a'},
4254 {"file-header", no_argument
, 0, 'h'},
4255 {"program-headers", no_argument
, 0, 'l'},
4256 {"headers", no_argument
, 0, 'e'},
4257 {"histogram", no_argument
, 0, 'I'},
4258 {"segments", no_argument
, 0, 'l'},
4259 {"sections", no_argument
, 0, 'S'},
4260 {"section-headers", no_argument
, 0, 'S'},
4261 {"section-groups", no_argument
, 0, 'g'},
4262 {"section-details", no_argument
, 0, 't'},
4263 {"full-section-name",no_argument
, 0, 'N'},
4264 {"symbols", no_argument
, 0, 's'},
4265 {"syms", no_argument
, 0, 's'},
4266 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
4267 {"relocs", no_argument
, 0, 'r'},
4268 {"notes", no_argument
, 0, 'n'},
4269 {"dynamic", no_argument
, 0, 'd'},
4270 {"arch-specific", no_argument
, 0, 'A'},
4271 {"version-info", no_argument
, 0, 'V'},
4272 {"use-dynamic", no_argument
, 0, 'D'},
4273 {"unwind", no_argument
, 0, 'u'},
4274 {"archive-index", no_argument
, 0, 'c'},
4275 {"hex-dump", required_argument
, 0, 'x'},
4276 {"relocated-dump", required_argument
, 0, 'R'},
4277 {"string-dump", required_argument
, 0, 'p'},
4278 {"decompress", no_argument
, 0, 'z'},
4279 #ifdef SUPPORT_DISASSEMBLY
4280 {"instruction-dump", required_argument
, 0, 'i'},
4282 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
4284 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
4285 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
4286 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
4288 {"version", no_argument
, 0, 'v'},
4289 {"wide", no_argument
, 0, 'W'},
4290 {"help", no_argument
, 0, 'H'},
4291 {0, no_argument
, 0, 0}
4295 usage (FILE * stream
)
4297 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
4298 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
4299 fprintf (stream
, _(" Options are:\n\
4300 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4301 -h --file-header Display the ELF file header\n\
4302 -l --program-headers Display the program headers\n\
4303 --segments An alias for --program-headers\n\
4304 -S --section-headers Display the sections' header\n\
4305 --sections An alias for --section-headers\n\
4306 -g --section-groups Display the section groups\n\
4307 -t --section-details Display the section details\n\
4308 -e --headers Equivalent to: -h -l -S\n\
4309 -s --syms Display the symbol table\n\
4310 --symbols An alias for --syms\n\
4311 --dyn-syms Display the dynamic symbol table\n\
4312 -n --notes Display the core notes (if present)\n\
4313 -r --relocs Display the relocations (if present)\n\
4314 -u --unwind Display the unwind info (if present)\n\
4315 -d --dynamic Display the dynamic section (if present)\n\
4316 -V --version-info Display the version sections (if present)\n\
4317 -A --arch-specific Display architecture specific information (if any)\n\
4318 -c --archive-index Display the symbol/file index in an archive\n\
4319 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
4320 -x --hex-dump=<number|name>\n\
4321 Dump the contents of section <number|name> as bytes\n\
4322 -p --string-dump=<number|name>\n\
4323 Dump the contents of section <number|name> as strings\n\
4324 -R --relocated-dump=<number|name>\n\
4325 Dump the contents of section <number|name> as relocated bytes\n\
4326 -z --decompress Decompress section before dumping it\n\
4327 -w[lLiaprmfFsoRt] or\n\
4328 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4329 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4330 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4332 Display the contents of DWARF2 debug sections\n"));
4333 fprintf (stream
, _("\
4334 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4335 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4337 #ifdef SUPPORT_DISASSEMBLY
4338 fprintf (stream
, _("\
4339 -i --instruction-dump=<number|name>\n\
4340 Disassemble the contents of section <number|name>\n"));
4342 fprintf (stream
, _("\
4343 -I --histogram Display histogram of bucket list lengths\n\
4344 -W --wide Allow output width to exceed 80 characters\n\
4345 @<file> Read options from <file>\n\
4346 -H --help Display this information\n\
4347 -v --version Display the version number of readelf\n"));
4349 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
4350 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
4352 exit (stream
== stdout
? 0 : 1);
4355 /* Record the fact that the user wants the contents of section number
4356 SECTION to be displayed using the method(s) encoded as flags bits
4357 in TYPE. Note, TYPE can be zero if we are creating the array for
4361 request_dump_bynumber (unsigned int section
, dump_type type
)
4363 if (section
>= num_dump_sects
)
4365 dump_type
* new_dump_sects
;
4367 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
4368 sizeof (* dump_sects
));
4370 if (new_dump_sects
== NULL
)
4371 error (_("Out of memory allocating dump request table.\n"));
4376 /* Copy current flag settings. */
4377 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
* sizeof (* dump_sects
));
4382 dump_sects
= new_dump_sects
;
4383 num_dump_sects
= section
+ 1;
4388 dump_sects
[section
] |= type
;
4393 /* Request a dump by section name. */
4396 request_dump_byname (const char * section
, dump_type type
)
4398 struct dump_list_entry
* new_request
;
4400 new_request
= (struct dump_list_entry
*)
4401 malloc (sizeof (struct dump_list_entry
));
4403 error (_("Out of memory allocating dump request table.\n"));
4405 new_request
->name
= strdup (section
);
4406 if (!new_request
->name
)
4407 error (_("Out of memory allocating dump request table.\n"));
4409 new_request
->type
= type
;
4411 new_request
->next
= dump_sects_byname
;
4412 dump_sects_byname
= new_request
;
4416 request_dump (dump_type type
)
4422 section
= strtoul (optarg
, & cp
, 0);
4424 if (! *cp
&& section
>= 0)
4425 request_dump_bynumber (section
, type
);
4427 request_dump_byname (optarg
, type
);
4432 parse_args (int argc
, char ** argv
)
4439 while ((c
= getopt_long
4440 (argc
, argv
, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options
, NULL
)) != EOF
)
4458 do_section_groups
= TRUE
;
4461 do_histogram
= TRUE
;
4466 do_section_groups
= TRUE
;
4471 do_section_details
= TRUE
;
4482 do_using_dynamic
= TRUE
;
4506 do_histogram
= TRUE
;
4512 do_archive_index
= TRUE
;
4515 request_dump (HEX_DUMP
);
4518 request_dump (STRING_DUMP
);
4521 request_dump (RELOC_DUMP
);
4524 decompress_dumps
= TRUE
;
4530 do_debugging
= TRUE
;
4531 dwarf_select_sections_all ();
4535 do_debugging
= FALSE
;
4536 dwarf_select_sections_by_letters (optarg
);
4539 case OPTION_DEBUG_DUMP
:
4542 do_debugging
= TRUE
;
4545 do_debugging
= FALSE
;
4546 dwarf_select_sections_by_names (optarg
);
4549 case OPTION_DWARF_DEPTH
:
4553 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
4556 case OPTION_DWARF_START
:
4560 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
4563 case OPTION_DWARF_CHECK
:
4566 case OPTION_DYN_SYMS
:
4569 #ifdef SUPPORT_DISASSEMBLY
4571 request_dump (DISASS_DUMP
);
4575 print_version (program_name
);
4584 /* xgettext:c-format */
4585 error (_("Invalid option '-%c'\n"), c
);
4592 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
4593 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
4594 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
4595 && !do_section_groups
&& !do_archive_index
4601 get_elf_class (unsigned int elf_class
)
4603 static char buff
[32];
4607 case ELFCLASSNONE
: return _("none");
4608 case ELFCLASS32
: return "ELF32";
4609 case ELFCLASS64
: return "ELF64";
4611 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
4617 get_data_encoding (unsigned int encoding
)
4619 static char buff
[32];
4623 case ELFDATANONE
: return _("none");
4624 case ELFDATA2LSB
: return _("2's complement, little endian");
4625 case ELFDATA2MSB
: return _("2's complement, big endian");
4627 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
4632 /* Decode the data held in 'elf_header'. */
4635 process_file_header (void)
4637 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
4638 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
4639 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
4640 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
4643 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4647 init_dwarf_regnames (elf_header
.e_machine
);
4653 printf (_("ELF Header:\n"));
4654 printf (_(" Magic: "));
4655 for (i
= 0; i
< EI_NIDENT
; i
++)
4656 printf ("%2.2x ", elf_header
.e_ident
[i
]);
4658 printf (_(" Class: %s\n"),
4659 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
4660 printf (_(" Data: %s\n"),
4661 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
4662 printf (_(" Version: %d %s\n"),
4663 elf_header
.e_ident
[EI_VERSION
],
4664 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
4666 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
4667 ? _("<unknown: %lx>")
4669 printf (_(" OS/ABI: %s\n"),
4670 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
4671 printf (_(" ABI Version: %d\n"),
4672 elf_header
.e_ident
[EI_ABIVERSION
]);
4673 printf (_(" Type: %s\n"),
4674 get_file_type (elf_header
.e_type
));
4675 printf (_(" Machine: %s\n"),
4676 get_machine_name (elf_header
.e_machine
));
4677 printf (_(" Version: 0x%lx\n"),
4678 (unsigned long) elf_header
.e_version
);
4680 printf (_(" Entry point address: "));
4681 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
4682 printf (_("\n Start of program headers: "));
4683 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
4684 printf (_(" (bytes into file)\n Start of section headers: "));
4685 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
4686 printf (_(" (bytes into file)\n"));
4688 printf (_(" Flags: 0x%lx%s\n"),
4689 (unsigned long) elf_header
.e_flags
,
4690 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
4691 printf (_(" Size of this header: %ld (bytes)\n"),
4692 (long) elf_header
.e_ehsize
);
4693 printf (_(" Size of program headers: %ld (bytes)\n"),
4694 (long) elf_header
.e_phentsize
);
4695 printf (_(" Number of program headers: %ld"),
4696 (long) elf_header
.e_phnum
);
4697 if (section_headers
!= NULL
4698 && elf_header
.e_phnum
== PN_XNUM
4699 && section_headers
[0].sh_info
!= 0)
4700 printf (" (%ld)", (long) section_headers
[0].sh_info
);
4701 putc ('\n', stdout
);
4702 printf (_(" Size of section headers: %ld (bytes)\n"),
4703 (long) elf_header
.e_shentsize
);
4704 printf (_(" Number of section headers: %ld"),
4705 (long) elf_header
.e_shnum
);
4706 if (section_headers
!= NULL
&& elf_header
.e_shnum
== SHN_UNDEF
)
4707 printf (" (%ld)", (long) section_headers
[0].sh_size
);
4708 putc ('\n', stdout
);
4709 printf (_(" Section header string table index: %ld"),
4710 (long) elf_header
.e_shstrndx
);
4711 if (section_headers
!= NULL
4712 && elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
4713 printf (" (%u)", section_headers
[0].sh_link
);
4714 else if (elf_header
.e_shstrndx
!= SHN_UNDEF
4715 && elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
4716 printf (_(" <corrupt: out of range>"));
4717 putc ('\n', stdout
);
4720 if (section_headers
!= NULL
)
4722 if (elf_header
.e_phnum
== PN_XNUM
4723 && section_headers
[0].sh_info
!= 0)
4724 elf_header
.e_phnum
= section_headers
[0].sh_info
;
4725 if (elf_header
.e_shnum
== SHN_UNDEF
)
4726 elf_header
.e_shnum
= section_headers
[0].sh_size
;
4727 if (elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
4728 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
4729 else if (elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
4730 elf_header
.e_shstrndx
= SHN_UNDEF
;
4731 free (section_headers
);
4732 section_headers
= NULL
;
4739 get_32bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
4741 Elf32_External_Phdr
* phdrs
;
4742 Elf32_External_Phdr
* external
;
4743 Elf_Internal_Phdr
* internal
;
4745 unsigned int size
= elf_header
.e_phentsize
;
4746 unsigned int num
= elf_header
.e_phnum
;
4748 /* PR binutils/17531: Cope with unexpected section header sizes. */
4749 if (size
== 0 || num
== 0)
4751 if (size
< sizeof * phdrs
)
4753 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4756 if (size
> sizeof * phdrs
)
4757 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4759 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
4760 size
, num
, _("program headers"));
4764 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4765 i
< elf_header
.e_phnum
;
4766 i
++, internal
++, external
++)
4768 internal
->p_type
= BYTE_GET (external
->p_type
);
4769 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4770 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4771 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4772 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4773 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4774 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4775 internal
->p_align
= BYTE_GET (external
->p_align
);
4783 get_64bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
4785 Elf64_External_Phdr
* phdrs
;
4786 Elf64_External_Phdr
* external
;
4787 Elf_Internal_Phdr
* internal
;
4789 unsigned int size
= elf_header
.e_phentsize
;
4790 unsigned int num
= elf_header
.e_phnum
;
4792 /* PR binutils/17531: Cope with unexpected section header sizes. */
4793 if (size
== 0 || num
== 0)
4795 if (size
< sizeof * phdrs
)
4797 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4800 if (size
> sizeof * phdrs
)
4801 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4803 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
4804 size
, num
, _("program headers"));
4808 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4809 i
< elf_header
.e_phnum
;
4810 i
++, internal
++, external
++)
4812 internal
->p_type
= BYTE_GET (external
->p_type
);
4813 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4814 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4815 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4816 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4817 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4818 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4819 internal
->p_align
= BYTE_GET (external
->p_align
);
4826 /* Returns TRUE if the program headers were read into `program_headers'. */
4829 get_program_headers (FILE * file
)
4831 Elf_Internal_Phdr
* phdrs
;
4833 /* Check cache of prior read. */
4834 if (program_headers
!= NULL
)
4837 /* Be kind to memory checkers by looking for
4838 e_phnum values which we know must be invalid. */
4839 if (elf_header
.e_phnum
4840 * (is_32bit_elf
? sizeof (Elf32_External_Phdr
) : sizeof (Elf64_External_Phdr
))
4841 >= current_file_size
)
4843 error (_("Too many program headers - %#x - the file is not that big\n"),
4844 elf_header
.e_phnum
);
4848 phdrs
= (Elf_Internal_Phdr
*) cmalloc (elf_header
.e_phnum
,
4849 sizeof (Elf_Internal_Phdr
));
4852 error (_("Out of memory reading %u program headers\n"),
4853 elf_header
.e_phnum
);
4858 ? get_32bit_program_headers (file
, phdrs
)
4859 : get_64bit_program_headers (file
, phdrs
))
4861 program_headers
= phdrs
;
4869 /* Returns TRUE if the program headers were loaded. */
4872 process_program_headers (FILE * file
)
4874 Elf_Internal_Phdr
* segment
;
4876 Elf_Internal_Phdr
* previous_load
= NULL
;
4878 if (elf_header
.e_phnum
== 0)
4880 /* PR binutils/12467. */
4881 if (elf_header
.e_phoff
!= 0)
4883 warn (_("possibly corrupt ELF header - it has a non-zero program"
4884 " header offset, but no program headers\n"));
4887 else if (do_segments
)
4888 printf (_("\nThere are no program headers in this file.\n"));
4892 if (do_segments
&& !do_header
)
4894 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
4895 printf (_("Entry point "));
4896 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
4897 printf (_("\nThere are %d program headers, starting at offset "),
4898 elf_header
.e_phnum
);
4899 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
4903 if (! get_program_headers (file
))
4908 if (elf_header
.e_phnum
> 1)
4909 printf (_("\nProgram Headers:\n"));
4911 printf (_("\nProgram Headers:\n"));
4915 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4918 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4922 (_(" Type Offset VirtAddr PhysAddr\n"));
4924 (_(" FileSiz MemSiz Flags Align\n"));
4931 for (i
= 0, segment
= program_headers
;
4932 i
< elf_header
.e_phnum
;
4937 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
4941 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
4942 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
4943 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
4944 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
4945 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
4947 (segment
->p_flags
& PF_R
? 'R' : ' '),
4948 (segment
->p_flags
& PF_W
? 'W' : ' '),
4949 (segment
->p_flags
& PF_X
? 'E' : ' '));
4950 printf ("%#lx", (unsigned long) segment
->p_align
);
4954 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
4955 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
4958 print_vma (segment
->p_offset
, FULL_HEX
);
4962 print_vma (segment
->p_vaddr
, FULL_HEX
);
4964 print_vma (segment
->p_paddr
, FULL_HEX
);
4967 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
4968 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
4971 print_vma (segment
->p_filesz
, FULL_HEX
);
4975 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
4976 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
4979 print_vma (segment
->p_memsz
, FULL_HEX
);
4983 (segment
->p_flags
& PF_R
? 'R' : ' '),
4984 (segment
->p_flags
& PF_W
? 'W' : ' '),
4985 (segment
->p_flags
& PF_X
? 'E' : ' '));
4987 if ((unsigned long) segment
->p_align
== segment
->p_align
)
4988 printf ("%#lx", (unsigned long) segment
->p_align
);
4991 print_vma (segment
->p_align
, PREFIX_HEX
);
4996 print_vma (segment
->p_offset
, FULL_HEX
);
4998 print_vma (segment
->p_vaddr
, FULL_HEX
);
5000 print_vma (segment
->p_paddr
, FULL_HEX
);
5002 print_vma (segment
->p_filesz
, FULL_HEX
);
5004 print_vma (segment
->p_memsz
, FULL_HEX
);
5006 (segment
->p_flags
& PF_R
? 'R' : ' '),
5007 (segment
->p_flags
& PF_W
? 'W' : ' '),
5008 (segment
->p_flags
& PF_X
? 'E' : ' '));
5009 print_vma (segment
->p_align
, PREFIX_HEX
);
5012 putc ('\n', stdout
);
5015 switch (segment
->p_type
)
5018 #if 0 /* Do not warn about out of order PT_LOAD segments. Although officially
5019 required by the ELF standard, several programs, including the Linux
5020 kernel, make use of non-ordered segments. */
5022 && previous_load
->p_vaddr
> segment
->p_vaddr
)
5023 error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
5025 if (segment
->p_memsz
< segment
->p_filesz
)
5026 error (_("the segment's file size is larger than its memory size\n"));
5027 previous_load
= segment
;
5031 /* PR 20815 - Verify that the program header is loaded into memory. */
5032 if (i
> 0 && previous_load
!= NULL
)
5033 error (_("the PHDR segment must occur before any LOAD segment\n"));
5034 if (elf_header
.e_machine
!= EM_PARISC
)
5038 for (j
= 1; j
< elf_header
.e_phnum
; j
++)
5039 if (program_headers
[j
].p_vaddr
<= segment
->p_vaddr
5040 && (program_headers
[j
].p_vaddr
+ program_headers
[j
].p_memsz
)
5041 >= (segment
->p_vaddr
+ segment
->p_filesz
))
5043 if (j
== elf_header
.e_phnum
)
5044 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5050 error (_("more than one dynamic segment\n"));
5052 /* By default, assume that the .dynamic section is the first
5053 section in the DYNAMIC segment. */
5054 dynamic_addr
= segment
->p_offset
;
5055 dynamic_size
= segment
->p_filesz
;
5057 /* Try to locate the .dynamic section. If there is
5058 a section header table, we can easily locate it. */
5059 if (section_headers
!= NULL
)
5061 Elf_Internal_Shdr
* sec
;
5063 sec
= find_section (".dynamic");
5064 if (sec
== NULL
|| sec
->sh_size
== 0)
5066 /* A corresponding .dynamic section is expected, but on
5067 IA-64/OpenVMS it is OK for it to be missing. */
5068 if (!is_ia64_vms ())
5069 error (_("no .dynamic section in the dynamic segment\n"));
5073 if (sec
->sh_type
== SHT_NOBITS
)
5079 dynamic_addr
= sec
->sh_offset
;
5080 dynamic_size
= sec
->sh_size
;
5082 if (dynamic_addr
< segment
->p_offset
5083 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
5084 warn (_("the .dynamic section is not contained"
5085 " within the dynamic segment\n"));
5086 else if (dynamic_addr
> segment
->p_offset
)
5087 warn (_("the .dynamic section is not the first section"
5088 " in the dynamic segment.\n"));
5091 /* PR binutils/17512: Avoid corrupt dynamic section info in the
5092 segment. Check this after matching against the section headers
5093 so we don't warn on debuginfo file (which have NOBITS .dynamic
5095 if (dynamic_addr
+ dynamic_size
>= current_file_size
)
5097 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5098 dynamic_addr
= dynamic_size
= 0;
5103 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
5105 error (_("Unable to find program interpreter name\n"));
5109 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
- 1);
5111 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
5112 error (_("Internal error: failed to create format string to display program interpreter\n"));
5114 program_interpreter
[0] = 0;
5115 if (fscanf (file
, fmt
, program_interpreter
) <= 0)
5116 error (_("Unable to read program interpreter name\n"));
5119 printf (_(" [Requesting program interpreter: %s]\n"),
5120 program_interpreter
);
5126 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
5128 printf (_("\n Section to Segment mapping:\n"));
5129 printf (_(" Segment Sections...\n"));
5131 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
5134 Elf_Internal_Shdr
* section
;
5136 segment
= program_headers
+ i
;
5137 section
= section_headers
+ 1;
5139 printf (" %2.2d ", i
);
5141 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
5143 if (!ELF_TBSS_SPECIAL (section
, segment
)
5144 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
5145 printf ("%s ", printable_section_name (section
));
5156 /* Find the file offset corresponding to VMA by using the program headers. */
5159 offset_from_vma (FILE * file
, bfd_vma vma
, bfd_size_type size
)
5161 Elf_Internal_Phdr
* seg
;
5163 if (! get_program_headers (file
))
5165 warn (_("Cannot interpret virtual addresses without program headers.\n"));
5169 for (seg
= program_headers
;
5170 seg
< program_headers
+ elf_header
.e_phnum
;
5173 if (seg
->p_type
!= PT_LOAD
)
5176 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
5177 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
5178 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
5181 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5182 (unsigned long) vma
);
5187 /* Allocate memory and load the sections headers into the global pointer
5188 SECTION_HEADERS. If PROBE is true, this is just a probe and we do not
5189 generate any error messages if the load fails. */
5192 get_32bit_section_headers (FILE * file
, bfd_boolean probe
)
5194 Elf32_External_Shdr
* shdrs
;
5195 Elf_Internal_Shdr
* internal
;
5197 unsigned int size
= elf_header
.e_shentsize
;
5198 unsigned int num
= probe
? 1 : elf_header
.e_shnum
;
5200 /* PR binutils/17531: Cope with unexpected section header sizes. */
5201 if (size
== 0 || num
== 0)
5203 if (size
< sizeof * shdrs
)
5206 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5209 if (!probe
&& size
> sizeof * shdrs
)
5210 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5212 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
5214 probe
? NULL
: _("section headers"));
5218 if (section_headers
!= NULL
)
5219 free (section_headers
);
5220 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
5221 sizeof (Elf_Internal_Shdr
));
5222 if (section_headers
== NULL
)
5225 error (_("Out of memory reading %u section headers\n"), num
);
5229 for (i
= 0, internal
= section_headers
;
5233 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5234 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5235 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5236 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5237 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5238 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5239 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5240 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5241 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5242 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5243 if (!probe
&& internal
->sh_link
> num
)
5244 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5245 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5246 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5254 get_64bit_section_headers (FILE * file
, bfd_boolean probe
)
5256 Elf64_External_Shdr
* shdrs
;
5257 Elf_Internal_Shdr
* internal
;
5259 unsigned int size
= elf_header
.e_shentsize
;
5260 unsigned int num
= probe
? 1 : elf_header
.e_shnum
;
5262 /* PR binutils/17531: Cope with unexpected section header sizes. */
5263 if (size
== 0 || num
== 0)
5265 if (size
< sizeof * shdrs
)
5268 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5271 if (! probe
&& size
> sizeof * shdrs
)
5272 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5274 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
5276 probe
? NULL
: _("section headers"));
5280 if (section_headers
!= NULL
)
5281 free (section_headers
);
5282 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
5283 sizeof (Elf_Internal_Shdr
));
5284 if (section_headers
== NULL
)
5287 error (_("Out of memory reading %u section headers\n"), num
);
5291 for (i
= 0, internal
= section_headers
;
5295 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5296 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5297 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5298 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5299 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5300 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5301 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5302 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5303 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5304 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5305 if (!probe
&& internal
->sh_link
> num
)
5306 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5307 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5308 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5315 static Elf_Internal_Sym
*
5316 get_32bit_elf_symbols (FILE * file
,
5317 Elf_Internal_Shdr
* section
,
5318 unsigned long * num_syms_return
)
5320 unsigned long number
= 0;
5321 Elf32_External_Sym
* esyms
= NULL
;
5322 Elf_External_Sym_Shndx
* shndx
= NULL
;
5323 Elf_Internal_Sym
* isyms
= NULL
;
5324 Elf_Internal_Sym
* psym
;
5327 if (section
->sh_size
== 0)
5329 if (num_syms_return
!= NULL
)
5330 * num_syms_return
= 0;
5334 /* Run some sanity checks first. */
5335 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5337 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5338 printable_section_name (section
), (unsigned long) section
->sh_entsize
);
5342 if (section
->sh_size
> current_file_size
)
5344 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5345 printable_section_name (section
), (unsigned long) section
->sh_size
);
5349 number
= section
->sh_size
/ section
->sh_entsize
;
5351 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
5353 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5354 (unsigned long) section
->sh_size
,
5355 printable_section_name (section
),
5356 (unsigned long) section
->sh_entsize
);
5360 esyms
= (Elf32_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
5361 section
->sh_size
, _("symbols"));
5366 elf_section_list
* entry
;
5369 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5370 if (entry
->hdr
->sh_link
== (unsigned long) (section
- section_headers
))
5372 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
5373 entry
->hdr
->sh_offset
,
5374 1, entry
->hdr
->sh_size
,
5375 _("symbol table section indicies"));
5378 /* PR17531: file: heap-buffer-overflow */
5379 else if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5381 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5382 printable_section_name (entry
->hdr
),
5383 (unsigned long) entry
->hdr
->sh_size
,
5384 (unsigned long) section
->sh_size
);
5390 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5394 error (_("Out of memory reading %lu symbols\n"),
5395 (unsigned long) number
);
5399 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5401 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5402 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5403 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5404 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5405 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5407 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5408 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5409 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5410 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5411 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5420 if (num_syms_return
!= NULL
)
5421 * num_syms_return
= isyms
== NULL
? 0 : number
;
5426 static Elf_Internal_Sym
*
5427 get_64bit_elf_symbols (FILE * file
,
5428 Elf_Internal_Shdr
* section
,
5429 unsigned long * num_syms_return
)
5431 unsigned long number
= 0;
5432 Elf64_External_Sym
* esyms
= NULL
;
5433 Elf_External_Sym_Shndx
* shndx
= NULL
;
5434 Elf_Internal_Sym
* isyms
= NULL
;
5435 Elf_Internal_Sym
* psym
;
5438 if (section
->sh_size
== 0)
5440 if (num_syms_return
!= NULL
)
5441 * num_syms_return
= 0;
5445 /* Run some sanity checks first. */
5446 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5448 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5449 printable_section_name (section
),
5450 (unsigned long) section
->sh_entsize
);
5454 if (section
->sh_size
> current_file_size
)
5456 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5457 printable_section_name (section
),
5458 (unsigned long) section
->sh_size
);
5462 number
= section
->sh_size
/ section
->sh_entsize
;
5464 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
5466 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5467 (unsigned long) section
->sh_size
,
5468 printable_section_name (section
),
5469 (unsigned long) section
->sh_entsize
);
5473 esyms
= (Elf64_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
5474 section
->sh_size
, _("symbols"));
5479 elf_section_list
* entry
;
5482 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5483 if (entry
->hdr
->sh_link
== (unsigned long) (section
- section_headers
))
5485 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
5486 entry
->hdr
->sh_offset
,
5487 1, entry
->hdr
->sh_size
,
5488 _("symbol table section indicies"));
5491 /* PR17531: file: heap-buffer-overflow */
5492 else if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5494 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5495 printable_section_name (entry
->hdr
),
5496 (unsigned long) entry
->hdr
->sh_size
,
5497 (unsigned long) section
->sh_size
);
5503 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5507 error (_("Out of memory reading %lu symbols\n"),
5508 (unsigned long) number
);
5512 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5514 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5515 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5516 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5517 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5519 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5521 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5522 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5523 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5525 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5526 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5535 if (num_syms_return
!= NULL
)
5536 * num_syms_return
= isyms
== NULL
? 0 : number
;
5542 get_elf_section_flags (bfd_vma sh_flags
)
5544 static char buff
[1024];
5546 unsigned int field_size
= is_32bit_elf
? 8 : 16;
5548 unsigned int size
= sizeof (buff
) - (field_size
+ 4 + 1);
5549 bfd_vma os_flags
= 0;
5550 bfd_vma proc_flags
= 0;
5551 bfd_vma unknown_flags
= 0;
5559 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5560 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5561 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5562 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5563 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5564 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5565 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5566 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5567 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5568 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5569 /* IA-64 specific. */
5570 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5571 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5572 /* IA-64 OpenVMS specific. */
5573 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5574 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5575 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5576 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5577 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5578 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5580 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5581 /* SPARC specific. */
5582 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5583 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5585 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5586 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5587 /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
5589 /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
5591 /* 25 */ { STRING_COMMA_LEN ("VLE") },
5594 if (do_section_details
)
5596 sprintf (buff
, "[%*.*lx]: ",
5597 field_size
, field_size
, (unsigned long) sh_flags
);
5598 p
+= field_size
+ 4;
5605 flag
= sh_flags
& - sh_flags
;
5608 if (do_section_details
)
5612 case SHF_WRITE
: sindex
= 0; break;
5613 case SHF_ALLOC
: sindex
= 1; break;
5614 case SHF_EXECINSTR
: sindex
= 2; break;
5615 case SHF_MERGE
: sindex
= 3; break;
5616 case SHF_STRINGS
: sindex
= 4; break;
5617 case SHF_INFO_LINK
: sindex
= 5; break;
5618 case SHF_LINK_ORDER
: sindex
= 6; break;
5619 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
5620 case SHF_GROUP
: sindex
= 8; break;
5621 case SHF_TLS
: sindex
= 9; break;
5622 case SHF_EXCLUDE
: sindex
= 18; break;
5623 case SHF_COMPRESSED
: sindex
= 20; break;
5624 case SHF_GNU_MBIND
: sindex
= 24; break;
5628 switch (elf_header
.e_machine
)
5631 if (flag
== SHF_IA_64_SHORT
)
5633 else if (flag
== SHF_IA_64_NORECOV
)
5636 else if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
5639 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
5640 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
5641 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
5642 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
5643 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
5644 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
5655 case EM_OLD_SPARCV9
:
5656 case EM_SPARC32PLUS
:
5659 if (flag
== SHF_ORDERED
)
5666 case SHF_ENTRYSECT
: sindex
= 21; break;
5667 case SHF_ARM_PURECODE
: sindex
= 22; break;
5668 case SHF_COMDEF
: sindex
= 23; break;
5673 if (flag
== SHF_PPC_VLE
)
5684 if (p
!= buff
+ field_size
+ 4)
5686 if (size
< (10 + 2))
5688 warn (_("Internal error: not enough buffer room for section flag info"));
5689 return _("<unknown>");
5696 size
-= flags
[sindex
].len
;
5697 p
= stpcpy (p
, flags
[sindex
].str
);
5699 else if (flag
& SHF_MASKOS
)
5701 else if (flag
& SHF_MASKPROC
)
5704 unknown_flags
|= flag
;
5710 case SHF_WRITE
: *p
= 'W'; break;
5711 case SHF_ALLOC
: *p
= 'A'; break;
5712 case SHF_EXECINSTR
: *p
= 'X'; break;
5713 case SHF_MERGE
: *p
= 'M'; break;
5714 case SHF_STRINGS
: *p
= 'S'; break;
5715 case SHF_INFO_LINK
: *p
= 'I'; break;
5716 case SHF_LINK_ORDER
: *p
= 'L'; break;
5717 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
5718 case SHF_GROUP
: *p
= 'G'; break;
5719 case SHF_TLS
: *p
= 'T'; break;
5720 case SHF_EXCLUDE
: *p
= 'E'; break;
5721 case SHF_COMPRESSED
: *p
= 'C'; break;
5722 case SHF_GNU_MBIND
: *p
= 'D'; break;
5725 if ((elf_header
.e_machine
== EM_X86_64
5726 || elf_header
.e_machine
== EM_L1OM
5727 || elf_header
.e_machine
== EM_K1OM
)
5728 && flag
== SHF_X86_64_LARGE
)
5730 else if (elf_header
.e_machine
== EM_ARM
5731 && flag
== SHF_ARM_PURECODE
)
5733 else if (elf_header
.e_machine
== EM_PPC
5734 && flag
== SHF_PPC_VLE
)
5736 else if (flag
& SHF_MASKOS
)
5739 sh_flags
&= ~ SHF_MASKOS
;
5741 else if (flag
& SHF_MASKPROC
)
5744 sh_flags
&= ~ SHF_MASKPROC
;
5754 if (do_section_details
)
5758 size
-= 5 + field_size
;
5759 if (p
!= buff
+ field_size
+ 4)
5763 warn (_("Internal error: not enough buffer room for section flag info"));
5764 return _("<unknown>");
5770 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
5771 (unsigned long) os_flags
);
5772 p
+= 5 + field_size
;
5776 size
-= 7 + field_size
;
5777 if (p
!= buff
+ field_size
+ 4)
5781 warn (_("Internal error: not enough buffer room for section flag info"));
5782 return _("<unknown>");
5788 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
5789 (unsigned long) proc_flags
);
5790 p
+= 7 + field_size
;
5794 size
-= 10 + field_size
;
5795 if (p
!= buff
+ field_size
+ 4)
5799 warn (_("Internal error: not enough buffer room for section flag info"));
5800 return _("<unknown>");
5806 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
5807 (unsigned long) unknown_flags
);
5808 p
+= 10 + field_size
;
5817 get_compression_header (Elf_Internal_Chdr
*chdr
, unsigned char *buf
, bfd_size_type size
)
5821 Elf32_External_Chdr
*echdr
= (Elf32_External_Chdr
*) buf
;
5823 if (size
< sizeof (* echdr
))
5825 error (_("Compressed section is too small even for a compression header\n"));
5829 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
5830 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
5831 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
5832 return sizeof (*echdr
);
5836 Elf64_External_Chdr
*echdr
= (Elf64_External_Chdr
*) buf
;
5838 if (size
< sizeof (* echdr
))
5840 error (_("Compressed section is too small even for a compression header\n"));
5844 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
5845 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
5846 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
5847 return sizeof (*echdr
);
5852 process_section_headers (FILE * file
)
5854 Elf_Internal_Shdr
* section
;
5857 section_headers
= NULL
;
5859 if (elf_header
.e_shnum
== 0)
5861 /* PR binutils/12467. */
5862 if (elf_header
.e_shoff
!= 0)
5864 warn (_("possibly corrupt ELF file header - it has a non-zero"
5865 " section header offset, but no section headers\n"));
5868 else if (do_sections
)
5869 printf (_("\nThere are no sections in this file.\n"));
5874 if (do_sections
&& !do_header
)
5875 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
5876 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
5880 if (! get_32bit_section_headers (file
, FALSE
))
5885 if (! get_64bit_section_headers (file
, FALSE
))
5889 /* Read in the string table, so that we have names to display. */
5890 if (elf_header
.e_shstrndx
!= SHN_UNDEF
5891 && elf_header
.e_shstrndx
< elf_header
.e_shnum
)
5893 section
= section_headers
+ elf_header
.e_shstrndx
;
5895 if (section
->sh_size
!= 0)
5897 string_table
= (char *) get_data (NULL
, file
, section
->sh_offset
,
5898 1, section
->sh_size
,
5901 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
5905 /* Scan the sections for the dynamic symbol table
5906 and dynamic string table and debug sections. */
5907 dynamic_symbols
= NULL
;
5908 dynamic_strings
= NULL
;
5909 dynamic_syminfo
= NULL
;
5910 symtab_shndx_list
= NULL
;
5912 eh_addr_size
= is_32bit_elf
? 4 : 8;
5913 switch (elf_header
.e_machine
)
5916 case EM_MIPS_RS3_LE
:
5917 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5918 FDE addresses. However, the ABI also has a semi-official ILP32
5919 variant for which the normal FDE address size rules apply.
5921 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5922 section, where XX is the size of longs in bits. Unfortunately,
5923 earlier compilers provided no way of distinguishing ILP32 objects
5924 from LP64 objects, so if there's any doubt, we should assume that
5925 the official LP64 form is being used. */
5926 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
5927 && find_section (".gcc_compiled_long32") == NULL
)
5933 switch (elf_header
.e_flags
& EF_H8_MACH
)
5935 case E_H8_MACH_H8300
:
5936 case E_H8_MACH_H8300HN
:
5937 case E_H8_MACH_H8300SN
:
5938 case E_H8_MACH_H8300SXN
:
5941 case E_H8_MACH_H8300H
:
5942 case E_H8_MACH_H8300S
:
5943 case E_H8_MACH_H8300SX
:
5951 switch (elf_header
.e_flags
& EF_M32C_CPU_MASK
)
5953 case EF_M32C_CPU_M16C
:
5960 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
5963 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
5964 if (section->sh_entsize != expected_entsize) \
5967 sprintf_vma (buf, section->sh_entsize); \
5968 /* Note: coded this way so that there is a single string for \
5970 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5971 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5972 (unsigned) expected_entsize); \
5973 section->sh_entsize = expected_entsize; \
5978 #define CHECK_ENTSIZE(section, i, type) \
5979 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
5980 sizeof (Elf64_External_##type))
5982 for (i
= 0, section
= section_headers
;
5983 i
< elf_header
.e_shnum
;
5986 char * name
= SECTION_NAME (section
);
5988 if (section
->sh_type
== SHT_DYNSYM
)
5990 if (dynamic_symbols
!= NULL
)
5992 error (_("File contains multiple dynamic symbol tables\n"));
5996 CHECK_ENTSIZE (section
, i
, Sym
);
5997 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
, & num_dynamic_syms
);
5999 else if (section
->sh_type
== SHT_STRTAB
6000 && streq (name
, ".dynstr"))
6002 if (dynamic_strings
!= NULL
)
6004 error (_("File contains multiple dynamic string tables\n"));
6008 dynamic_strings
= (char *) get_data (NULL
, file
, section
->sh_offset
,
6009 1, section
->sh_size
,
6010 _("dynamic strings"));
6011 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : section
->sh_size
;
6013 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
6015 elf_section_list
* entry
= xmalloc (sizeof * entry
);
6016 entry
->hdr
= section
;
6017 entry
->next
= symtab_shndx_list
;
6018 symtab_shndx_list
= entry
;
6020 else if (section
->sh_type
== SHT_SYMTAB
)
6021 CHECK_ENTSIZE (section
, i
, Sym
);
6022 else if (section
->sh_type
== SHT_GROUP
)
6023 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
6024 else if (section
->sh_type
== SHT_REL
)
6025 CHECK_ENTSIZE (section
, i
, Rel
);
6026 else if (section
->sh_type
== SHT_RELA
)
6027 CHECK_ENTSIZE (section
, i
, Rela
);
6028 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
6029 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
6030 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
6031 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
6032 || do_debug_addr
|| do_debug_cu_index
)
6033 && (const_strneq (name
, ".debug_")
6034 || const_strneq (name
, ".zdebug_")))
6037 name
+= sizeof (".zdebug_") - 1;
6039 name
+= sizeof (".debug_") - 1;
6042 || (do_debug_info
&& const_strneq (name
, "info"))
6043 || (do_debug_info
&& const_strneq (name
, "types"))
6044 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
6045 || (do_debug_lines
&& strcmp (name
, "line") == 0)
6046 || (do_debug_lines
&& const_strneq (name
, "line."))
6047 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
6048 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
6049 || (do_debug_pubnames
&& const_strneq (name
, "gnu_pubnames"))
6050 || (do_debug_pubtypes
&& const_strneq (name
, "gnu_pubtypes"))
6051 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
6052 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
6053 || (do_debug_ranges
&& const_strneq (name
, "rnglists"))
6054 || (do_debug_frames
&& const_strneq (name
, "frame"))
6055 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
6056 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
6057 || (do_debug_str
&& const_strneq (name
, "str"))
6058 || (do_debug_loc
&& const_strneq (name
, "loc"))
6059 || (do_debug_loc
&& const_strneq (name
, "loclists"))
6060 || (do_debug_addr
&& const_strneq (name
, "addr"))
6061 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
6062 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
6064 request_dump_bynumber (i
, DEBUG_DUMP
);
6066 /* Linkonce section to be combined with .debug_info at link time. */
6067 else if ((do_debugging
|| do_debug_info
)
6068 && const_strneq (name
, ".gnu.linkonce.wi."))
6069 request_dump_bynumber (i
, DEBUG_DUMP
);
6070 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
6071 request_dump_bynumber (i
, DEBUG_DUMP
);
6072 else if (do_gdb_index
&& (streq (name
, ".gdb_index")
6073 || streq (name
, ".debug_names")))
6074 request_dump_bynumber (i
, DEBUG_DUMP
);
6075 /* Trace sections for Itanium VMS. */
6076 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
6077 || do_trace_aranges
)
6078 && const_strneq (name
, ".trace_"))
6080 name
+= sizeof (".trace_") - 1;
6083 || (do_trace_info
&& streq (name
, "info"))
6084 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
6085 || (do_trace_aranges
&& streq (name
, "aranges"))
6087 request_dump_bynumber (i
, DEBUG_DUMP
);
6094 if (elf_header
.e_shnum
> 1)
6095 printf (_("\nSection Headers:\n"));
6097 printf (_("\nSection Header:\n"));
6101 if (do_section_details
)
6103 printf (_(" [Nr] Name\n"));
6104 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
6108 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
6112 if (do_section_details
)
6114 printf (_(" [Nr] Name\n"));
6115 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
6119 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
6123 if (do_section_details
)
6125 printf (_(" [Nr] Name\n"));
6126 printf (_(" Type Address Offset Link\n"));
6127 printf (_(" Size EntSize Info Align\n"));
6131 printf (_(" [Nr] Name Type Address Offset\n"));
6132 printf (_(" Size EntSize Flags Link Info Align\n"));
6136 if (do_section_details
)
6137 printf (_(" Flags\n"));
6139 for (i
= 0, section
= section_headers
;
6140 i
< elf_header
.e_shnum
;
6143 /* Run some sanity checks on the section header. */
6145 /* Check the sh_link field. */
6146 switch (section
->sh_type
)
6148 case SHT_SYMTAB_SHNDX
:
6152 case SHT_GNU_versym
:
6155 if (section
->sh_link
< 1
6156 || section
->sh_link
>= elf_header
.e_shnum
6157 || (section_headers
[section
->sh_link
].sh_type
!= SHT_SYMTAB
6158 && section_headers
[section
->sh_link
].sh_type
!= SHT_DYNSYM
))
6159 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6160 i
, section
->sh_link
);
6166 case SHT_GNU_verneed
:
6167 case SHT_GNU_verdef
:
6168 case SHT_GNU_LIBLIST
:
6169 if (section
->sh_link
< 1
6170 || section
->sh_link
>= elf_header
.e_shnum
6171 || section_headers
[section
->sh_link
].sh_type
!= SHT_STRTAB
)
6172 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6173 i
, section
->sh_link
);
6176 case SHT_INIT_ARRAY
:
6177 case SHT_FINI_ARRAY
:
6178 case SHT_PREINIT_ARRAY
:
6179 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6180 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6181 i
, section
->sh_link
);
6185 /* FIXME: Add support for target specific section types. */
6186 #if 0 /* Currently we do not check other section types as there are too
6187 many special cases. Stab sections for example have a type
6188 of SHT_PROGBITS but an sh_link field that links to the .stabstr
6190 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6191 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6192 i
, section
->sh_link
);
6197 /* Check the sh_info field. */
6198 switch (section
->sh_type
)
6202 if (section
->sh_info
< 1
6203 || section
->sh_info
>= elf_header
.e_shnum
6204 || (section_headers
[section
->sh_info
].sh_type
!= SHT_PROGBITS
6205 && section_headers
[section
->sh_info
].sh_type
!= SHT_NOBITS
6206 && section_headers
[section
->sh_info
].sh_type
!= SHT_NOTE
6207 && section_headers
[section
->sh_info
].sh_type
!= SHT_INIT_ARRAY
6208 /* FIXME: Are other section types valid ? */
6209 && section_headers
[section
->sh_info
].sh_type
< SHT_LOOS
))
6211 if (section
->sh_info
== 0
6212 && (streq (SECTION_NAME (section
), ".rel.dyn")
6213 || streq (SECTION_NAME (section
), ".rela.dyn")))
6214 /* The .rel.dyn and .rela.dyn sections have an sh_info field
6215 of zero. The relocations in these sections may apply
6216 to many different sections. */
6219 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6220 i
, section
->sh_info
);
6226 case SHT_SYMTAB_SHNDX
:
6227 case SHT_INIT_ARRAY
:
6228 case SHT_FINI_ARRAY
:
6229 case SHT_PREINIT_ARRAY
:
6230 if (section
->sh_info
!= 0)
6231 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6232 i
, section
->sh_info
);
6238 /* A symbol index - we assume that it is valid. */
6242 /* FIXME: Add support for target specific section types. */
6243 if (section
->sh_type
== SHT_NOBITS
)
6244 /* NOBITS section headers with non-zero sh_info fields can be
6245 created when a binary is stripped of everything but its debug
6246 information. The stripped sections have their headers
6247 preserved but their types set to SHT_NOBITS. So do not check
6248 this type of section. */
6250 else if (section
->sh_flags
& SHF_INFO_LINK
)
6252 if (section
->sh_info
< 1 || section
->sh_info
>= elf_header
.e_shnum
)
6253 warn (_("[%2u]: Expected link to another section in info field"), i
);
6255 else if (section
->sh_type
< SHT_LOOS
6256 && (section
->sh_flags
& SHF_GNU_MBIND
) == 0
6257 && section
->sh_info
!= 0)
6258 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6259 i
, section
->sh_info
);
6263 /* Check the sh_size field. */
6264 if (section
->sh_size
> current_file_size
6265 && section
->sh_type
!= SHT_NOBITS
6266 && section
->sh_type
!= SHT_NULL
6267 && section
->sh_type
< SHT_LOOS
)
6268 warn (_("Size of section %u is larger than the entire file!\n"), i
);
6270 printf (" [%2u] ", i
);
6271 if (do_section_details
)
6272 printf ("%s\n ", printable_section_name (section
));
6274 print_symbol (-17, SECTION_NAME (section
));
6276 printf (do_wide
? " %-15s " : " %-15.15s ",
6277 get_section_type_name (section
->sh_type
));
6281 const char * link_too_big
= NULL
;
6283 print_vma (section
->sh_addr
, LONG_HEX
);
6285 printf ( " %6.6lx %6.6lx %2.2lx",
6286 (unsigned long) section
->sh_offset
,
6287 (unsigned long) section
->sh_size
,
6288 (unsigned long) section
->sh_entsize
);
6290 if (do_section_details
)
6291 fputs (" ", stdout
);
6293 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
6295 if (section
->sh_link
>= elf_header
.e_shnum
)
6298 /* The sh_link value is out of range. Normally this indicates
6299 an error but it can have special values in Solaris binaries. */
6300 switch (elf_header
.e_machine
)
6307 case EM_OLD_SPARCV9
:
6308 case EM_SPARC32PLUS
:
6311 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
6312 link_too_big
= "BEFORE";
6313 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
6314 link_too_big
= "AFTER";
6321 if (do_section_details
)
6323 if (link_too_big
!= NULL
&& * link_too_big
)
6324 printf ("<%s> ", link_too_big
);
6326 printf ("%2u ", section
->sh_link
);
6327 printf ("%3u %2lu\n", section
->sh_info
,
6328 (unsigned long) section
->sh_addralign
);
6331 printf ("%2u %3u %2lu\n",
6334 (unsigned long) section
->sh_addralign
);
6336 if (link_too_big
&& ! * link_too_big
)
6337 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6338 i
, section
->sh_link
);
6342 print_vma (section
->sh_addr
, LONG_HEX
);
6344 if ((long) section
->sh_offset
== section
->sh_offset
)
6345 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
6349 print_vma (section
->sh_offset
, LONG_HEX
);
6352 if ((unsigned long) section
->sh_size
== section
->sh_size
)
6353 printf (" %6.6lx", (unsigned long) section
->sh_size
);
6357 print_vma (section
->sh_size
, LONG_HEX
);
6360 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
6361 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
6365 print_vma (section
->sh_entsize
, LONG_HEX
);
6368 if (do_section_details
)
6369 fputs (" ", stdout
);
6371 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
6373 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
6375 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
6376 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
6379 print_vma (section
->sh_addralign
, DEC
);
6383 else if (do_section_details
)
6385 printf (" %-15.15s ",
6386 get_section_type_name (section
->sh_type
));
6387 print_vma (section
->sh_addr
, LONG_HEX
);
6388 if ((long) section
->sh_offset
== section
->sh_offset
)
6389 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
6393 print_vma (section
->sh_offset
, LONG_HEX
);
6395 printf (" %u\n ", section
->sh_link
);
6396 print_vma (section
->sh_size
, LONG_HEX
);
6398 print_vma (section
->sh_entsize
, LONG_HEX
);
6400 printf (" %-16u %lu\n",
6402 (unsigned long) section
->sh_addralign
);
6407 print_vma (section
->sh_addr
, LONG_HEX
);
6408 if ((long) section
->sh_offset
== section
->sh_offset
)
6409 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
6413 print_vma (section
->sh_offset
, LONG_HEX
);
6416 print_vma (section
->sh_size
, LONG_HEX
);
6418 print_vma (section
->sh_entsize
, LONG_HEX
);
6420 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
6422 printf (" %2u %3u %lu\n",
6425 (unsigned long) section
->sh_addralign
);
6428 if (do_section_details
)
6430 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
6431 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
6433 /* Minimum section size is 12 bytes for 32-bit compression
6434 header + 12 bytes for compressed data header. */
6435 unsigned char buf
[24];
6437 assert (sizeof (buf
) >= sizeof (Elf64_External_Chdr
));
6438 if (get_data (&buf
, (FILE *) file
, section
->sh_offset
, 1,
6439 sizeof (buf
), _("compression header")))
6441 Elf_Internal_Chdr chdr
;
6443 (void) get_compression_header (&chdr
, buf
, sizeof (buf
));
6445 if (chdr
.ch_type
== ELFCOMPRESS_ZLIB
)
6448 printf (_(" [<unknown>: 0x%x], "),
6450 print_vma (chdr
.ch_size
, LONG_HEX
);
6451 printf (", %lu\n", (unsigned long) chdr
.ch_addralign
);
6457 if (!do_section_details
)
6459 /* The ordering of the letters shown here matches the ordering of the
6460 corresponding SHF_xxx values, and hence the order in which these
6461 letters will be displayed to the user. */
6462 printf (_("Key to Flags:\n\
6463 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6464 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6465 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
6466 if (elf_header
.e_machine
== EM_X86_64
6467 || elf_header
.e_machine
== EM_L1OM
6468 || elf_header
.e_machine
== EM_K1OM
)
6469 printf (_("l (large), "));
6470 else if (elf_header
.e_machine
== EM_ARM
)
6471 printf (_("y (purecode), "));
6472 else if (elf_header
.e_machine
== EM_PPC
)
6473 printf (_("v (VLE), "));
6474 printf ("p (processor specific)\n");
6481 get_group_flags (unsigned int flags
)
6483 static char buff
[128];
6487 else if (flags
== GRP_COMDAT
)
6490 snprintf (buff
, 14, _("[0x%x: "), flags
);
6492 flags
&= ~ GRP_COMDAT
;
6493 if (flags
& GRP_MASKOS
)
6495 strcat (buff
, "<OS specific>");
6496 flags
&= ~ GRP_MASKOS
;
6499 if (flags
& GRP_MASKPROC
)
6501 strcat (buff
, "<PROC specific>");
6502 flags
&= ~ GRP_MASKPROC
;
6506 strcat (buff
, "<unknown>");
6513 process_section_groups (FILE * file
)
6515 Elf_Internal_Shdr
* section
;
6517 struct group
* group
;
6518 Elf_Internal_Shdr
* symtab_sec
;
6519 Elf_Internal_Shdr
* strtab_sec
;
6520 Elf_Internal_Sym
* symtab
;
6521 unsigned long num_syms
;
6525 /* Don't process section groups unless needed. */
6526 if (!do_unwind
&& !do_section_groups
)
6529 if (elf_header
.e_shnum
== 0)
6531 if (do_section_groups
)
6532 printf (_("\nThere are no sections to group in this file.\n"));
6537 if (section_headers
== NULL
)
6539 error (_("Section headers are not available!\n"));
6540 /* PR 13622: This can happen with a corrupt ELF header. */
6544 section_headers_groups
= (struct group
**) calloc (elf_header
.e_shnum
,
6545 sizeof (struct group
*));
6547 if (section_headers_groups
== NULL
)
6549 error (_("Out of memory reading %u section group headers\n"),
6550 elf_header
.e_shnum
);
6554 /* Scan the sections for the group section. */
6556 for (i
= 0, section
= section_headers
;
6557 i
< elf_header
.e_shnum
;
6559 if (section
->sh_type
== SHT_GROUP
)
6562 if (group_count
== 0)
6564 if (do_section_groups
)
6565 printf (_("\nThere are no section groups in this file.\n"));
6570 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
6572 if (section_groups
== NULL
)
6574 error (_("Out of memory reading %lu groups\n"),
6575 (unsigned long) group_count
);
6585 for (i
= 0, section
= section_headers
, group
= section_groups
;
6586 i
< elf_header
.e_shnum
;
6589 if (section
->sh_type
== SHT_GROUP
)
6591 const char * name
= printable_section_name (section
);
6592 const char * group_name
;
6593 unsigned char * start
;
6594 unsigned char * indices
;
6595 unsigned int entry
, j
, size
;
6596 Elf_Internal_Shdr
* sec
;
6597 Elf_Internal_Sym
* sym
;
6599 /* Get the symbol table. */
6600 if (section
->sh_link
>= elf_header
.e_shnum
6601 || ((sec
= section_headers
+ section
->sh_link
)->sh_type
6604 error (_("Bad sh_link in group section `%s'\n"), name
);
6608 if (symtab_sec
!= sec
)
6613 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
, & num_syms
);
6618 error (_("Corrupt header in group section `%s'\n"), name
);
6622 if (section
->sh_info
>= num_syms
)
6624 error (_("Bad sh_info in group section `%s'\n"), name
);
6628 sym
= symtab
+ section
->sh_info
;
6630 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
6632 if (sym
->st_shndx
== 0
6633 || sym
->st_shndx
>= elf_header
.e_shnum
)
6635 error (_("Bad sh_info in group section `%s'\n"), name
);
6639 group_name
= SECTION_NAME (section_headers
+ sym
->st_shndx
);
6648 /* Get the string table. */
6649 if (symtab_sec
->sh_link
>= elf_header
.e_shnum
)
6658 != (sec
= section_headers
+ symtab_sec
->sh_link
))
6664 strtab
= (char *) get_data (NULL
, file
, strtab_sec
->sh_offset
,
6665 1, strtab_sec
->sh_size
,
6667 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
6669 group_name
= sym
->st_name
< strtab_size
6670 ? strtab
+ sym
->st_name
: _("<corrupt>");
6673 /* PR 17531: file: loop. */
6674 if (section
->sh_entsize
> section
->sh_size
)
6676 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6677 printable_section_name (section
),
6678 (unsigned long) section
->sh_entsize
,
6679 (unsigned long) section
->sh_size
);
6683 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
,
6684 1, section
->sh_size
,
6690 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
6691 entry
= byte_get (indices
, 4);
6694 if (do_section_groups
)
6696 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6697 get_group_flags (entry
), i
, name
, group_name
, size
);
6699 printf (_(" [Index] Name\n"));
6702 group
->group_index
= i
;
6704 for (j
= 0; j
< size
; j
++)
6706 struct group_list
* g
;
6708 entry
= byte_get (indices
, 4);
6711 if (entry
>= elf_header
.e_shnum
)
6713 static unsigned num_group_errors
= 0;
6715 if (num_group_errors
++ < 10)
6717 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6718 entry
, i
, elf_header
.e_shnum
- 1);
6719 if (num_group_errors
== 10)
6720 warn (_("Further error messages about overlarge group section indicies suppressed\n"));
6725 if (section_headers_groups
[entry
] != NULL
)
6729 static unsigned num_errs
= 0;
6731 if (num_errs
++ < 10)
6733 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6735 section_headers_groups
[entry
]->group_index
);
6737 warn (_("Further error messages about already contained group sections suppressed\n"));
6743 /* Intel C/C++ compiler may put section 0 in a
6744 section group. We just warn it the first time
6745 and ignore it afterwards. */
6746 static bfd_boolean warned
= FALSE
;
6749 error (_("section 0 in group section [%5u]\n"),
6750 section_headers_groups
[entry
]->group_index
);
6756 section_headers_groups
[entry
] = group
;
6758 if (do_section_groups
)
6760 sec
= section_headers
+ entry
;
6761 printf (" [%5u] %s\n", entry
, printable_section_name (sec
));
6764 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
6765 g
->section_index
= entry
;
6766 g
->next
= group
->root
;
6784 /* Data used to display dynamic fixups. */
6786 struct ia64_vms_dynfixup
6788 bfd_vma needed_ident
; /* Library ident number. */
6789 bfd_vma needed
; /* Index in the dstrtab of the library name. */
6790 bfd_vma fixup_needed
; /* Index of the library. */
6791 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
6792 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
6795 /* Data used to display dynamic relocations. */
6797 struct ia64_vms_dynimgrela
6799 bfd_vma img_rela_cnt
; /* Number of relocations. */
6800 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
6803 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6807 dump_ia64_vms_dynamic_fixups (FILE * file
,
6808 struct ia64_vms_dynfixup
* fixup
,
6809 const char * strtab
,
6810 unsigned int strtab_sz
)
6812 Elf64_External_VMS_IMAGE_FIXUP
* imfs
;
6814 const char * lib_name
;
6816 imfs
= get_data (NULL
, file
, dynamic_addr
+ fixup
->fixup_rela_off
,
6817 1, fixup
->fixup_rela_cnt
* sizeof (*imfs
),
6818 _("dynamic section image fixups"));
6822 if (fixup
->needed
< strtab_sz
)
6823 lib_name
= strtab
+ fixup
->needed
;
6826 warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
6827 (unsigned long) fixup
->needed
);
6830 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6831 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
6833 (_("Seg Offset Type SymVec DataType\n"));
6835 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
6840 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
6841 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
6842 type
= BYTE_GET (imfs
[i
].type
);
6843 rtype
= elf_ia64_reloc_type (type
);
6845 printf (" 0x%08x ", type
);
6847 printf (" %-32s ", rtype
);
6848 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
6849 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
6856 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
6859 dump_ia64_vms_dynamic_relocs (FILE *file
, struct ia64_vms_dynimgrela
*imgrela
)
6861 Elf64_External_VMS_IMAGE_RELA
*imrs
;
6864 imrs
= get_data (NULL
, file
, dynamic_addr
+ imgrela
->img_rela_off
,
6865 1, imgrela
->img_rela_cnt
* sizeof (*imrs
),
6866 _("dynamic section image relocations"));
6870 printf (_("\nImage relocs\n"));
6872 (_("Seg Offset Type Addend Seg Sym Off\n"));
6874 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
6879 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
6880 printf ("%08" BFD_VMA_FMT
"x ",
6881 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
6882 type
= BYTE_GET (imrs
[i
].type
);
6883 rtype
= elf_ia64_reloc_type (type
);
6885 printf ("0x%08x ", type
);
6887 printf ("%-31s ", rtype
);
6888 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
6889 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
6890 printf ("%08" BFD_VMA_FMT
"x\n",
6891 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
6898 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
6901 process_ia64_vms_dynamic_relocs (FILE *file
)
6903 struct ia64_vms_dynfixup fixup
;
6904 struct ia64_vms_dynimgrela imgrela
;
6905 Elf_Internal_Dyn
*entry
;
6906 bfd_vma strtab_off
= 0;
6907 bfd_vma strtab_sz
= 0;
6908 char *strtab
= NULL
;
6909 bfd_boolean res
= TRUE
;
6911 memset (&fixup
, 0, sizeof (fixup
));
6912 memset (&imgrela
, 0, sizeof (imgrela
));
6914 /* Note: the order of the entries is specified by the OpenVMS specs. */
6915 for (entry
= dynamic_section
;
6916 entry
< dynamic_section
+ dynamic_nent
;
6919 switch (entry
->d_tag
)
6921 case DT_IA_64_VMS_STRTAB_OFFSET
:
6922 strtab_off
= entry
->d_un
.d_val
;
6925 strtab_sz
= entry
->d_un
.d_val
;
6927 strtab
= get_data (NULL
, file
, dynamic_addr
+ strtab_off
,
6928 1, strtab_sz
, _("dynamic string section"));
6931 case DT_IA_64_VMS_NEEDED_IDENT
:
6932 fixup
.needed_ident
= entry
->d_un
.d_val
;
6935 fixup
.needed
= entry
->d_un
.d_val
;
6937 case DT_IA_64_VMS_FIXUP_NEEDED
:
6938 fixup
.fixup_needed
= entry
->d_un
.d_val
;
6940 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
6941 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
6943 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
6944 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
6945 if (! dump_ia64_vms_dynamic_fixups (file
, &fixup
, strtab
, strtab_sz
))
6948 case DT_IA_64_VMS_IMG_RELA_CNT
:
6949 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
6951 case DT_IA_64_VMS_IMG_RELA_OFF
:
6952 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
6953 if (! dump_ia64_vms_dynamic_relocs (file
, &imgrela
))
6975 dynamic_relocations
[] =
6977 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
6978 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
6979 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
6982 /* Process the reloc section. */
6985 process_relocs (FILE * file
)
6987 unsigned long rel_size
;
6988 unsigned long rel_offset
;
6993 if (do_using_dynamic
)
6997 bfd_boolean has_dynamic_reloc
;
7000 has_dynamic_reloc
= FALSE
;
7002 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7004 is_rela
= dynamic_relocations
[i
].rela
;
7005 name
= dynamic_relocations
[i
].name
;
7006 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
7007 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
7010 has_dynamic_reloc
= TRUE
;
7012 if (is_rela
== UNKNOWN
)
7014 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
7015 switch (dynamic_info
[DT_PLTREL
])
7029 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7030 name
, rel_offset
, rel_size
);
7032 dump_relocations (file
,
7033 offset_from_vma (file
, rel_offset
, rel_size
),
7035 dynamic_symbols
, num_dynamic_syms
,
7036 dynamic_strings
, dynamic_strings_length
,
7037 is_rela
, TRUE
/* is_dynamic */);
7042 if (process_ia64_vms_dynamic_relocs (file
))
7043 has_dynamic_reloc
= TRUE
;
7045 if (! has_dynamic_reloc
)
7046 printf (_("\nThere are no dynamic relocations in this file.\n"));
7050 Elf_Internal_Shdr
* section
;
7052 bfd_boolean found
= FALSE
;
7054 for (i
= 0, section
= section_headers
;
7055 i
< elf_header
.e_shnum
;
7058 if ( section
->sh_type
!= SHT_RELA
7059 && section
->sh_type
!= SHT_REL
)
7062 rel_offset
= section
->sh_offset
;
7063 rel_size
= section
->sh_size
;
7067 Elf_Internal_Shdr
* strsec
;
7070 printf (_("\nRelocation section "));
7072 if (string_table
== NULL
)
7073 printf ("%d", section
->sh_name
);
7075 printf ("'%s'", printable_section_name (section
));
7077 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7078 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
7080 is_rela
= section
->sh_type
== SHT_RELA
;
7082 if (section
->sh_link
!= 0
7083 && section
->sh_link
< elf_header
.e_shnum
)
7085 Elf_Internal_Shdr
* symsec
;
7086 Elf_Internal_Sym
* symtab
;
7087 unsigned long nsyms
;
7088 unsigned long strtablen
= 0;
7089 char * strtab
= NULL
;
7091 symsec
= section_headers
+ section
->sh_link
;
7092 if (symsec
->sh_type
!= SHT_SYMTAB
7093 && symsec
->sh_type
!= SHT_DYNSYM
)
7096 symtab
= GET_ELF_SYMBOLS (file
, symsec
, & nsyms
);
7101 if (symsec
->sh_link
!= 0
7102 && symsec
->sh_link
< elf_header
.e_shnum
)
7104 strsec
= section_headers
+ symsec
->sh_link
;
7106 strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
7109 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
7112 dump_relocations (file
, rel_offset
, rel_size
,
7113 symtab
, nsyms
, strtab
, strtablen
,
7115 symsec
->sh_type
== SHT_DYNSYM
);
7121 dump_relocations (file
, rel_offset
, rel_size
,
7122 NULL
, 0, NULL
, 0, is_rela
,
7123 FALSE
/* is_dynamic */);
7130 printf (_("\nThere are no relocations in this file.\n"));
7136 /* An absolute address consists of a section and an offset. If the
7137 section is NULL, the offset itself is the address, otherwise, the
7138 address equals to LOAD_ADDRESS(section) + offset. */
7142 unsigned short section
;
7146 #define ABSADDR(a) \
7148 ? section_headers [(a).section].sh_addr + (a).offset \
7151 /* Find the nearest symbol at or below ADDR. Returns the symbol
7152 name, if found, and the offset from the symbol to ADDR. */
7155 find_symbol_for_address (Elf_Internal_Sym
* symtab
,
7156 unsigned long nsyms
,
7157 const char * strtab
,
7158 unsigned long strtab_size
,
7159 struct absaddr addr
,
7160 const char ** symname
,
7163 bfd_vma dist
= 0x100000;
7164 Elf_Internal_Sym
* sym
;
7165 Elf_Internal_Sym
* beg
;
7166 Elf_Internal_Sym
* end
;
7167 Elf_Internal_Sym
* best
= NULL
;
7169 REMOVE_ARCH_BITS (addr
.offset
);
7171 end
= symtab
+ nsyms
;
7177 sym
= beg
+ (end
- beg
) / 2;
7179 value
= sym
->st_value
;
7180 REMOVE_ARCH_BITS (value
);
7182 if (sym
->st_name
!= 0
7183 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
7184 && addr
.offset
>= value
7185 && addr
.offset
- value
< dist
)
7188 dist
= addr
.offset
- value
;
7193 if (addr
.offset
< value
)
7201 *symname
= (best
->st_name
>= strtab_size
7202 ? _("<corrupt>") : strtab
+ best
->st_name
);
7208 *offset
= addr
.offset
;
7211 static /* signed */ int
7212 symcmp (const void *p
, const void *q
)
7214 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
7215 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
7217 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
7220 /* Process the unwind section. */
7222 #include "unwind-ia64.h"
7224 struct ia64_unw_table_entry
7226 struct absaddr start
;
7228 struct absaddr info
;
7231 struct ia64_unw_aux_info
7233 struct ia64_unw_table_entry
* table
; /* Unwind table. */
7234 unsigned long table_len
; /* Length of unwind table. */
7235 unsigned char * info
; /* Unwind info. */
7236 unsigned long info_size
; /* Size of unwind info. */
7237 bfd_vma info_addr
; /* Starting address of unwind info. */
7238 bfd_vma seg_base
; /* Starting address of segment. */
7239 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7240 unsigned long nsyms
; /* Number of symbols. */
7241 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7242 unsigned long nfuns
; /* Number of entries in funtab. */
7243 char * strtab
; /* The string table. */
7244 unsigned long strtab_size
; /* Size of string table. */
7248 dump_ia64_unwind (struct ia64_unw_aux_info
* aux
)
7250 struct ia64_unw_table_entry
* tp
;
7251 unsigned long j
, nfuns
;
7253 bfd_boolean res
= TRUE
;
7255 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7256 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7257 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7258 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7260 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7262 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7266 const unsigned char * dp
;
7267 const unsigned char * head
;
7268 const unsigned char * end
;
7269 const char * procname
;
7271 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7272 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
7274 fputs ("\n<", stdout
);
7278 fputs (procname
, stdout
);
7281 printf ("+%lx", (unsigned long) offset
);
7284 fputs (">: [", stdout
);
7285 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7286 fputc ('-', stdout
);
7287 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7288 printf ("], info at +0x%lx\n",
7289 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
7291 /* PR 17531: file: 86232b32. */
7292 if (aux
->info
== NULL
)
7295 /* PR 17531: file: 0997b4d1. */
7296 if ((ABSADDR (tp
->info
) - aux
->info_addr
) >= aux
->info_size
)
7298 warn (_("Invalid offset %lx in table entry %ld\n"),
7299 (long) tp
->info
.offset
, (long) (tp
- aux
->table
));
7304 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
7305 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
7307 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7308 (unsigned) UNW_VER (stamp
),
7309 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
7310 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
7311 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
7312 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
7314 if (UNW_VER (stamp
) != 1)
7316 printf (_("\tUnknown version.\n"));
7321 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
7322 /* PR 17531: file: 16ceda89. */
7323 if (end
> aux
->info
+ aux
->info_size
)
7324 end
= aux
->info
+ aux
->info_size
;
7325 for (dp
= head
+ 8; dp
< end
;)
7326 dp
= unw_decode (dp
, in_body
, & in_body
, end
);
7335 slurp_ia64_unwind_table (FILE * file
,
7336 struct ia64_unw_aux_info
* aux
,
7337 Elf_Internal_Shdr
* sec
)
7339 unsigned long size
, nrelas
, i
;
7340 Elf_Internal_Phdr
* seg
;
7341 struct ia64_unw_table_entry
* tep
;
7342 Elf_Internal_Shdr
* relsec
;
7343 Elf_Internal_Rela
* rela
;
7344 Elf_Internal_Rela
* rp
;
7345 unsigned char * table
;
7347 Elf_Internal_Sym
* sym
;
7348 const char * relname
;
7352 /* First, find the starting address of the segment that includes
7355 if (elf_header
.e_phnum
)
7357 if (! get_program_headers (file
))
7360 for (seg
= program_headers
;
7361 seg
< program_headers
+ elf_header
.e_phnum
;
7364 if (seg
->p_type
!= PT_LOAD
)
7367 if (sec
->sh_addr
>= seg
->p_vaddr
7368 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7370 aux
->seg_base
= seg
->p_vaddr
;
7376 /* Second, build the unwind table from the contents of the unwind section: */
7377 size
= sec
->sh_size
;
7378 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
7383 aux
->table_len
= size
/ (3 * eh_addr_size
);
7384 aux
->table
= (struct ia64_unw_table_entry
*)
7385 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
7388 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
7390 tep
->start
.section
= SHN_UNDEF
;
7391 tep
->end
.section
= SHN_UNDEF
;
7392 tep
->info
.section
= SHN_UNDEF
;
7393 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7394 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7395 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7396 tep
->start
.offset
+= aux
->seg_base
;
7397 tep
->end
.offset
+= aux
->seg_base
;
7398 tep
->info
.offset
+= aux
->seg_base
;
7402 /* Third, apply any relocations to the unwind table: */
7403 for (relsec
= section_headers
;
7404 relsec
< section_headers
+ elf_header
.e_shnum
;
7407 if (relsec
->sh_type
!= SHT_RELA
7408 || relsec
->sh_info
>= elf_header
.e_shnum
7409 || section_headers
+ relsec
->sh_info
!= sec
)
7412 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7421 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7423 relname
= elf_ia64_reloc_type (get_reloc_type (rp
->r_info
));
7424 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
7426 /* PR 17531: file: 9fa67536. */
7427 if (relname
== NULL
)
7429 warn (_("Skipping unknown relocation type: %u\n"), get_reloc_type (rp
->r_info
));
7433 if (! const_strneq (relname
, "R_IA64_SEGREL"))
7435 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
7439 i
= rp
->r_offset
/ (3 * eh_addr_size
);
7441 /* PR 17531: file: 5bc8d9bf. */
7442 if (i
>= aux
->table_len
)
7444 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
7448 switch (rp
->r_offset
/ eh_addr_size
% 3)
7451 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7452 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
7455 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7456 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
7459 aux
->table
[i
].info
.section
= sym
->st_shndx
;
7460 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
7474 ia64_process_unwind (FILE * file
)
7476 Elf_Internal_Shdr
* sec
;
7477 Elf_Internal_Shdr
* unwsec
= NULL
;
7478 Elf_Internal_Shdr
* strsec
;
7479 unsigned long i
, unwcount
= 0, unwstart
= 0;
7480 struct ia64_unw_aux_info aux
;
7481 bfd_boolean res
= TRUE
;
7483 memset (& aux
, 0, sizeof (aux
));
7485 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7487 if (sec
->sh_type
== SHT_SYMTAB
7488 && sec
->sh_link
< elf_header
.e_shnum
)
7490 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
7492 strsec
= section_headers
+ sec
->sh_link
;
7493 if (aux
.strtab
!= NULL
)
7495 error (_("Multiple auxillary string tables encountered\n"));
7499 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
7502 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7504 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7509 printf (_("\nThere are no unwind sections in this file.\n"));
7511 while (unwcount
-- > 0)
7516 for (i
= unwstart
, sec
= section_headers
+ unwstart
, unwsec
= NULL
;
7517 i
< elf_header
.e_shnum
; ++i
, ++sec
)
7518 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7523 /* We have already counted the number of SHT_IA64_UNWIND
7524 sections so the loop above should never fail. */
7525 assert (unwsec
!= NULL
);
7528 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
7530 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
7532 /* We need to find which section group it is in. */
7533 struct group_list
* g
;
7535 if (section_headers_groups
== NULL
7536 || section_headers_groups
[i
] == NULL
)
7537 i
= elf_header
.e_shnum
;
7540 g
= section_headers_groups
[i
]->root
;
7542 for (; g
!= NULL
; g
= g
->next
)
7544 sec
= section_headers
+ g
->section_index
;
7546 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
7551 i
= elf_header
.e_shnum
;
7554 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
7556 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
7557 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
7558 suffix
= SECTION_NAME (unwsec
) + len
;
7559 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
7561 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
7562 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7567 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7568 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
7569 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
7570 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
7572 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
7573 suffix
= SECTION_NAME (unwsec
) + len
;
7574 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
7576 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
7577 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7581 if (i
== elf_header
.e_shnum
)
7583 printf (_("\nCould not find unwind info section for "));
7585 if (string_table
== NULL
)
7586 printf ("%d", unwsec
->sh_name
);
7588 printf ("'%s'", printable_section_name (unwsec
));
7592 aux
.info_addr
= sec
->sh_addr
;
7593 aux
.info
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1,
7596 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
7598 printf (_("\nUnwind section "));
7600 if (string_table
== NULL
)
7601 printf ("%d", unwsec
->sh_name
);
7603 printf ("'%s'", printable_section_name (unwsec
));
7605 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7606 (unsigned long) unwsec
->sh_offset
,
7607 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
7609 if (slurp_ia64_unwind_table (file
, & aux
, unwsec
)
7610 && aux
.table_len
> 0)
7611 dump_ia64_unwind (& aux
);
7614 free ((char *) aux
.table
);
7616 free ((char *) aux
.info
);
7625 free ((char *) aux
.strtab
);
7630 struct hppa_unw_table_entry
7632 struct absaddr start
;
7634 unsigned int Cannot_unwind
:1; /* 0 */
7635 unsigned int Millicode
:1; /* 1 */
7636 unsigned int Millicode_save_sr0
:1; /* 2 */
7637 unsigned int Region_description
:2; /* 3..4 */
7638 unsigned int reserved1
:1; /* 5 */
7639 unsigned int Entry_SR
:1; /* 6 */
7640 unsigned int Entry_FR
:4; /* Number saved 7..10 */
7641 unsigned int Entry_GR
:5; /* Number saved 11..15 */
7642 unsigned int Args_stored
:1; /* 16 */
7643 unsigned int Variable_Frame
:1; /* 17 */
7644 unsigned int Separate_Package_Body
:1; /* 18 */
7645 unsigned int Frame_Extension_Millicode
:1; /* 19 */
7646 unsigned int Stack_Overflow_Check
:1; /* 20 */
7647 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
7648 unsigned int Ada_Region
:1; /* 22 */
7649 unsigned int cxx_info
:1; /* 23 */
7650 unsigned int cxx_try_catch
:1; /* 24 */
7651 unsigned int sched_entry_seq
:1; /* 25 */
7652 unsigned int reserved2
:1; /* 26 */
7653 unsigned int Save_SP
:1; /* 27 */
7654 unsigned int Save_RP
:1; /* 28 */
7655 unsigned int Save_MRP_in_frame
:1; /* 29 */
7656 unsigned int extn_ptr_defined
:1; /* 30 */
7657 unsigned int Cleanup_defined
:1; /* 31 */
7659 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
7660 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
7661 unsigned int Large_frame
:1; /* 2 */
7662 unsigned int Pseudo_SP_Set
:1; /* 3 */
7663 unsigned int reserved4
:1; /* 4 */
7664 unsigned int Total_frame_size
:27; /* 5..31 */
7667 struct hppa_unw_aux_info
7669 struct hppa_unw_table_entry
* table
; /* Unwind table. */
7670 unsigned long table_len
; /* Length of unwind table. */
7671 bfd_vma seg_base
; /* Starting address of segment. */
7672 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7673 unsigned long nsyms
; /* Number of symbols. */
7674 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7675 unsigned long nfuns
; /* Number of entries in funtab. */
7676 char * strtab
; /* The string table. */
7677 unsigned long strtab_size
; /* Size of string table. */
7681 dump_hppa_unwind (struct hppa_unw_aux_info
* aux
)
7683 struct hppa_unw_table_entry
* tp
;
7684 unsigned long j
, nfuns
;
7685 bfd_boolean res
= TRUE
;
7687 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7688 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7689 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7690 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7692 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7694 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7697 const char * procname
;
7699 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7700 aux
->strtab_size
, tp
->start
, &procname
,
7703 fputs ("\n<", stdout
);
7707 fputs (procname
, stdout
);
7710 printf ("+%lx", (unsigned long) offset
);
7713 fputs (">: [", stdout
);
7714 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7715 fputc ('-', stdout
);
7716 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7719 #define PF(_m) if (tp->_m) printf (#_m " ");
7720 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
7723 PF(Millicode_save_sr0
);
7724 /* PV(Region_description); */
7730 PF(Separate_Package_Body
);
7731 PF(Frame_Extension_Millicode
);
7732 PF(Stack_Overflow_Check
);
7733 PF(Two_Instruction_SP_Increment
);
7737 PF(sched_entry_seq
);
7740 PF(Save_MRP_in_frame
);
7741 PF(extn_ptr_defined
);
7742 PF(Cleanup_defined
);
7743 PF(MPE_XL_interrupt_marker
);
7744 PF(HP_UX_interrupt_marker
);
7747 PV(Total_frame_size
);
7760 slurp_hppa_unwind_table (FILE * file
,
7761 struct hppa_unw_aux_info
* aux
,
7762 Elf_Internal_Shdr
* sec
)
7764 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
7765 Elf_Internal_Phdr
* seg
;
7766 struct hppa_unw_table_entry
* tep
;
7767 Elf_Internal_Shdr
* relsec
;
7768 Elf_Internal_Rela
* rela
;
7769 Elf_Internal_Rela
* rp
;
7770 unsigned char * table
;
7772 Elf_Internal_Sym
* sym
;
7773 const char * relname
;
7775 /* First, find the starting address of the segment that includes
7777 if (elf_header
.e_phnum
)
7779 if (! get_program_headers (file
))
7782 for (seg
= program_headers
;
7783 seg
< program_headers
+ elf_header
.e_phnum
;
7786 if (seg
->p_type
!= PT_LOAD
)
7789 if (sec
->sh_addr
>= seg
->p_vaddr
7790 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7792 aux
->seg_base
= seg
->p_vaddr
;
7798 /* Second, build the unwind table from the contents of the unwind
7800 size
= sec
->sh_size
;
7801 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
7807 nentries
= size
/ unw_ent_size
;
7808 size
= unw_ent_size
* nentries
;
7810 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
7811 xcmalloc (nentries
, sizeof (aux
->table
[0]));
7813 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
7815 unsigned int tmp1
, tmp2
;
7817 tep
->start
.section
= SHN_UNDEF
;
7818 tep
->end
.section
= SHN_UNDEF
;
7820 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
7821 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
7822 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
7823 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
7825 tep
->start
.offset
+= aux
->seg_base
;
7826 tep
->end
.offset
+= aux
->seg_base
;
7828 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
7829 tep
->Millicode
= (tmp1
>> 30) & 0x1;
7830 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
7831 tep
->Region_description
= (tmp1
>> 27) & 0x3;
7832 tep
->reserved1
= (tmp1
>> 26) & 0x1;
7833 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
7834 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
7835 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
7836 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
7837 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
7838 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
7839 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
7840 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
7841 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
7842 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
7843 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
7844 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
7845 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
7846 tep
->reserved2
= (tmp1
>> 5) & 0x1;
7847 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
7848 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
7849 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
7850 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
7851 tep
->Cleanup_defined
= tmp1
& 0x1;
7853 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
7854 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
7855 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
7856 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
7857 tep
->reserved4
= (tmp2
>> 27) & 0x1;
7858 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
7862 /* Third, apply any relocations to the unwind table. */
7863 for (relsec
= section_headers
;
7864 relsec
< section_headers
+ elf_header
.e_shnum
;
7867 if (relsec
->sh_type
!= SHT_RELA
7868 || relsec
->sh_info
>= elf_header
.e_shnum
7869 || section_headers
+ relsec
->sh_info
!= sec
)
7872 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7876 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7878 relname
= elf_hppa_reloc_type (get_reloc_type (rp
->r_info
));
7879 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
7881 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
7882 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
7884 warn (_("Skipping unexpected relocation type %s\n"), relname
);
7888 i
= rp
->r_offset
/ unw_ent_size
;
7890 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
7893 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7894 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
7897 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7898 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
7908 aux
->table_len
= nentries
;
7914 hppa_process_unwind (FILE * file
)
7916 struct hppa_unw_aux_info aux
;
7917 Elf_Internal_Shdr
* unwsec
= NULL
;
7918 Elf_Internal_Shdr
* strsec
;
7919 Elf_Internal_Shdr
* sec
;
7921 bfd_boolean res
= TRUE
;
7923 if (string_table
== NULL
)
7926 memset (& aux
, 0, sizeof (aux
));
7928 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7930 if (sec
->sh_type
== SHT_SYMTAB
7931 && sec
->sh_link
< elf_header
.e_shnum
)
7933 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
7935 strsec
= section_headers
+ sec
->sh_link
;
7936 if (aux
.strtab
!= NULL
)
7938 error (_("Multiple auxillary string tables encountered\n"));
7942 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
7945 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7947 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
7952 printf (_("\nThere are no unwind sections in this file.\n"));
7954 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7956 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
7958 printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
7959 printable_section_name (sec
),
7960 (unsigned long) sec
->sh_offset
,
7961 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
7963 if (! slurp_hppa_unwind_table (file
, &aux
, sec
))
7966 if (aux
.table_len
> 0)
7968 if (! dump_hppa_unwind (&aux
))
7973 free ((char *) aux
.table
);
7981 free ((char *) aux
.strtab
);
7988 unsigned char * data
; /* The unwind data. */
7989 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
7990 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
7991 unsigned long nrelas
; /* The number of relocations. */
7992 unsigned int rel_type
; /* REL or RELA ? */
7993 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
7996 struct arm_unw_aux_info
7998 FILE * file
; /* The file containing the unwind sections. */
7999 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
8000 unsigned long nsyms
; /* Number of symbols. */
8001 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8002 unsigned long nfuns
; /* Number of these symbols. */
8003 char * strtab
; /* The file's string table. */
8004 unsigned long strtab_size
; /* Size of string table. */
8008 arm_print_vma_and_name (struct arm_unw_aux_info
*aux
,
8009 bfd_vma fn
, struct absaddr addr
)
8011 const char *procname
;
8014 if (addr
.section
== SHN_UNDEF
)
8017 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8018 aux
->strtab_size
, addr
, &procname
,
8021 print_vma (fn
, PREFIX_HEX
);
8025 fputs (" <", stdout
);
8026 fputs (procname
, stdout
);
8029 printf ("+0x%lx", (unsigned long) sym_offset
);
8030 fputc ('>', stdout
);
8037 arm_free_section (struct arm_section
*arm_sec
)
8039 if (arm_sec
->data
!= NULL
)
8040 free (arm_sec
->data
);
8042 if (arm_sec
->rela
!= NULL
)
8043 free (arm_sec
->rela
);
8046 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8047 cached section and install SEC instead.
8048 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8049 and return its valued in * WORDP, relocating if necessary.
8050 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8051 relocation's offset in ADDR.
8052 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8053 into the string table of the symbol associated with the reloc. If no
8054 reloc was applied store -1 there.
8055 5) Return TRUE upon success, FALSE otherwise. */
8058 get_unwind_section_word (struct arm_unw_aux_info
* aux
,
8059 struct arm_section
* arm_sec
,
8060 Elf_Internal_Shdr
* sec
,
8061 bfd_vma word_offset
,
8062 unsigned int * wordp
,
8063 struct absaddr
* addr
,
8066 Elf_Internal_Rela
*rp
;
8067 Elf_Internal_Sym
*sym
;
8068 const char * relname
;
8070 bfd_boolean wrapped
;
8072 if (sec
== NULL
|| arm_sec
== NULL
)
8075 addr
->section
= SHN_UNDEF
;
8078 if (sym_name
!= NULL
)
8079 *sym_name
= (bfd_vma
) -1;
8081 /* If necessary, update the section cache. */
8082 if (sec
!= arm_sec
->sec
)
8084 Elf_Internal_Shdr
*relsec
;
8086 arm_free_section (arm_sec
);
8089 arm_sec
->data
= get_data (NULL
, aux
->file
, sec
->sh_offset
, 1,
8090 sec
->sh_size
, _("unwind data"));
8091 arm_sec
->rela
= NULL
;
8092 arm_sec
->nrelas
= 0;
8094 for (relsec
= section_headers
;
8095 relsec
< section_headers
+ elf_header
.e_shnum
;
8098 if (relsec
->sh_info
>= elf_header
.e_shnum
8099 || section_headers
+ relsec
->sh_info
!= sec
8100 /* PR 15745: Check the section type as well. */
8101 || (relsec
->sh_type
!= SHT_REL
8102 && relsec
->sh_type
!= SHT_RELA
))
8105 arm_sec
->rel_type
= relsec
->sh_type
;
8106 if (relsec
->sh_type
== SHT_REL
)
8108 if (!slurp_rel_relocs (aux
->file
, relsec
->sh_offset
,
8110 & arm_sec
->rela
, & arm_sec
->nrelas
))
8113 else /* relsec->sh_type == SHT_RELA */
8115 if (!slurp_rela_relocs (aux
->file
, relsec
->sh_offset
,
8117 & arm_sec
->rela
, & arm_sec
->nrelas
))
8123 arm_sec
->next_rela
= arm_sec
->rela
;
8126 /* If there is no unwind data we can do nothing. */
8127 if (arm_sec
->data
== NULL
)
8130 /* If the offset is invalid then fail. */
8131 if (/* PR 21343 *//* PR 18879 */
8133 || word_offset
> (sec
->sh_size
- 4)
8134 || ((bfd_signed_vma
) word_offset
) < 0)
8137 /* Get the word at the required offset. */
8138 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
8140 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
8141 if (arm_sec
->rela
== NULL
)
8147 /* Look through the relocs to find the one that applies to the provided offset. */
8149 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
8151 bfd_vma prelval
, offset
;
8153 if (rp
->r_offset
> word_offset
&& !wrapped
)
8158 if (rp
->r_offset
> word_offset
)
8161 if (rp
->r_offset
& 3)
8163 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8164 (unsigned long) rp
->r_offset
);
8168 if (rp
->r_offset
< word_offset
)
8171 /* PR 17531: file: 027-161405-0.004 */
8172 if (aux
->symtab
== NULL
)
8175 if (arm_sec
->rel_type
== SHT_REL
)
8177 offset
= word
& 0x7fffffff;
8178 if (offset
& 0x40000000)
8179 offset
|= ~ (bfd_vma
) 0x7fffffff;
8181 else if (arm_sec
->rel_type
== SHT_RELA
)
8182 offset
= rp
->r_addend
;
8185 error (_("Unknown section relocation type %d encountered\n"),
8190 /* PR 17531 file: 027-1241568-0.004. */
8191 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
8193 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8194 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
8198 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
8199 offset
+= sym
->st_value
;
8200 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
8202 /* Check that we are processing the expected reloc type. */
8203 if (elf_header
.e_machine
== EM_ARM
)
8205 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8206 if (relname
== NULL
)
8208 warn (_("Skipping unknown ARM relocation type: %d\n"),
8209 (int) ELF32_R_TYPE (rp
->r_info
));
8213 if (streq (relname
, "R_ARM_NONE"))
8216 if (! streq (relname
, "R_ARM_PREL31"))
8218 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
8222 else if (elf_header
.e_machine
== EM_TI_C6000
)
8224 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8225 if (relname
== NULL
)
8227 warn (_("Skipping unknown C6000 relocation type: %d\n"),
8228 (int) ELF32_R_TYPE (rp
->r_info
));
8232 if (streq (relname
, "R_C6000_NONE"))
8235 if (! streq (relname
, "R_C6000_PREL31"))
8237 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
8245 /* This function currently only supports ARM and TI unwinders. */
8246 warn (_("Only TI and ARM unwinders are currently supported\n"));
8250 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
8251 addr
->section
= sym
->st_shndx
;
8252 addr
->offset
= offset
;
8255 * sym_name
= sym
->st_name
;
8260 arm_sec
->next_rela
= rp
;
8265 static const char *tic6x_unwind_regnames
[16] =
8267 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8268 "A14", "A13", "A12", "A11", "A10",
8269 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8273 decode_tic6x_unwind_regmask (unsigned int mask
)
8277 for (i
= 12; mask
; mask
>>= 1, i
--)
8281 fputs (tic6x_unwind_regnames
[i
], stdout
);
8283 fputs (", ", stdout
);
8289 if (remaining == 0 && more_words) \
8292 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
8293 data_offset, & word, & addr, NULL)) \
8299 #define GET_OP(OP) \
8304 (OP) = word >> 24; \
8309 printf (_("[Truncated opcode]\n")); \
8312 printf ("0x%02x ", OP)
8315 decode_arm_unwind_bytecode (struct arm_unw_aux_info
* aux
,
8317 unsigned int remaining
,
8318 unsigned int more_words
,
8319 bfd_vma data_offset
,
8320 Elf_Internal_Shdr
* data_sec
,
8321 struct arm_section
* data_arm_sec
)
8323 struct absaddr addr
;
8324 bfd_boolean res
= TRUE
;
8326 /* Decode the unwinding instructions. */
8329 unsigned int op
, op2
;
8338 printf (" 0x%02x ", op
);
8340 if ((op
& 0xc0) == 0x00)
8342 int offset
= ((op
& 0x3f) << 2) + 4;
8344 printf (" vsp = vsp + %d", offset
);
8346 else if ((op
& 0xc0) == 0x40)
8348 int offset
= ((op
& 0x3f) << 2) + 4;
8350 printf (" vsp = vsp - %d", offset
);
8352 else if ((op
& 0xf0) == 0x80)
8355 if (op
== 0x80 && op2
== 0)
8356 printf (_("Refuse to unwind"));
8359 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
8360 bfd_boolean first
= TRUE
;
8364 for (i
= 0; i
< 12; i
++)
8365 if (mask
& (1 << i
))
8371 printf ("r%d", 4 + i
);
8376 else if ((op
& 0xf0) == 0x90)
8378 if (op
== 0x9d || op
== 0x9f)
8379 printf (_(" [Reserved]"));
8381 printf (" vsp = r%d", op
& 0x0f);
8383 else if ((op
& 0xf0) == 0xa0)
8385 int end
= 4 + (op
& 0x07);
8386 bfd_boolean first
= TRUE
;
8390 for (i
= 4; i
<= end
; i
++)
8406 else if (op
== 0xb0)
8407 printf (_(" finish"));
8408 else if (op
== 0xb1)
8411 if (op2
== 0 || (op2
& 0xf0) != 0)
8412 printf (_("[Spare]"));
8415 unsigned int mask
= op2
& 0x0f;
8416 bfd_boolean first
= TRUE
;
8420 for (i
= 0; i
< 12; i
++)
8421 if (mask
& (1 << i
))
8432 else if (op
== 0xb2)
8434 unsigned char buf
[9];
8435 unsigned int i
, len
;
8436 unsigned long offset
;
8438 for (i
= 0; i
< sizeof (buf
); i
++)
8441 if ((buf
[i
] & 0x80) == 0)
8444 if (i
== sizeof (buf
))
8446 error (_("corrupt change to vsp"));
8451 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8452 assert (len
== i
+ 1);
8453 offset
= offset
* 4 + 0x204;
8454 printf ("vsp = vsp + %ld", offset
);
8457 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
8459 unsigned int first
, last
;
8466 printf ("pop {D%d", first
);
8468 printf ("-D%d", first
+ last
);
8471 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
8473 unsigned int count
= op
& 0x07;
8477 printf ("-D%d", 8 + count
);
8480 else if (op
>= 0xc0 && op
<= 0xc5)
8482 unsigned int count
= op
& 0x07;
8484 printf (" pop {wR10");
8486 printf ("-wR%d", 10 + count
);
8489 else if (op
== 0xc6)
8491 unsigned int first
, last
;
8496 printf ("pop {wR%d", first
);
8498 printf ("-wR%d", first
+ last
);
8501 else if (op
== 0xc7)
8504 if (op2
== 0 || (op2
& 0xf0) != 0)
8505 printf (_("[Spare]"));
8508 unsigned int mask
= op2
& 0x0f;
8509 bfd_boolean first
= TRUE
;
8513 for (i
= 0; i
< 4; i
++)
8514 if (mask
& (1 << i
))
8520 printf ("wCGR%d", i
);
8527 printf (_(" [unsupported opcode]"));
8538 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info
* aux
,
8540 unsigned int remaining
,
8541 unsigned int more_words
,
8542 bfd_vma data_offset
,
8543 Elf_Internal_Shdr
* data_sec
,
8544 struct arm_section
* data_arm_sec
)
8546 struct absaddr addr
;
8548 /* Decode the unwinding instructions. */
8551 unsigned int op
, op2
;
8560 printf (" 0x%02x ", op
);
8562 if ((op
& 0xc0) == 0x00)
8564 int offset
= ((op
& 0x3f) << 3) + 8;
8565 printf (" sp = sp + %d", offset
);
8567 else if ((op
& 0xc0) == 0x80)
8570 if (op
== 0x80 && op2
== 0)
8571 printf (_("Refuse to unwind"));
8574 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
8576 printf ("pop compact {");
8580 decode_tic6x_unwind_regmask (mask
);
8584 else if ((op
& 0xf0) == 0xc0)
8592 unsigned int offset
;
8596 /* Scan entire instruction first so that GET_OP output is not
8597 interleaved with disassembly. */
8599 for (i
= 0; nregs
< (op
& 0xf); i
++)
8605 regpos
[nregs
].offset
= i
* 2;
8606 regpos
[nregs
].reg
= reg
;
8613 regpos
[nregs
].offset
= i
* 2 + 1;
8614 regpos
[nregs
].reg
= reg
;
8619 printf (_("pop frame {"));
8621 for (i
= i
* 2; i
> 0; i
--)
8623 if (regpos
[reg
].offset
== i
- 1)
8625 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
8632 fputs (name
, stdout
);
8639 else if (op
== 0xd0)
8640 printf (" MOV FP, SP");
8641 else if (op
== 0xd1)
8642 printf (" __c6xabi_pop_rts");
8643 else if (op
== 0xd2)
8645 unsigned char buf
[9];
8646 unsigned int i
, len
;
8647 unsigned long offset
;
8649 for (i
= 0; i
< sizeof (buf
); i
++)
8652 if ((buf
[i
] & 0x80) == 0)
8655 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
8656 if (i
== sizeof (buf
))
8658 warn (_("Corrupt stack pointer adjustment detected\n"));
8662 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8663 assert (len
== i
+ 1);
8664 offset
= offset
* 8 + 0x408;
8665 printf (_("sp = sp + %ld"), offset
);
8667 else if ((op
& 0xf0) == 0xe0)
8669 if ((op
& 0x0f) == 7)
8672 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
8676 printf (_(" [unsupported opcode]"));
8685 arm_expand_prel31 (bfd_vma word
, bfd_vma where
)
8689 offset
= word
& 0x7fffffff;
8690 if (offset
& 0x40000000)
8691 offset
|= ~ (bfd_vma
) 0x7fffffff;
8693 if (elf_header
.e_machine
== EM_TI_C6000
)
8696 return offset
+ where
;
8700 decode_arm_unwind (struct arm_unw_aux_info
* aux
,
8702 unsigned int remaining
,
8703 bfd_vma data_offset
,
8704 Elf_Internal_Shdr
* data_sec
,
8705 struct arm_section
* data_arm_sec
)
8708 unsigned int more_words
= 0;
8709 struct absaddr addr
;
8710 bfd_vma sym_name
= (bfd_vma
) -1;
8711 bfd_boolean res
= FALSE
;
8715 /* Fetch the first word.
8716 Note - when decoding an object file the address extracted
8717 here will always be 0. So we also pass in the sym_name
8718 parameter so that we can find the symbol associated with
8719 the personality routine. */
8720 if (! get_unwind_section_word (aux
, data_arm_sec
, data_sec
, data_offset
,
8721 & word
, & addr
, & sym_name
))
8727 if ((word
& 0x80000000) == 0)
8729 /* Expand prel31 for personality routine. */
8731 const char *procname
;
8733 fn
= arm_expand_prel31 (word
, data_sec
->sh_addr
+ data_offset
);
8734 printf (_(" Personality routine: "));
8736 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
8737 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
8739 procname
= aux
->strtab
+ sym_name
;
8740 print_vma (fn
, PREFIX_HEX
);
8743 fputs (" <", stdout
);
8744 fputs (procname
, stdout
);
8745 fputc ('>', stdout
);
8749 procname
= arm_print_vma_and_name (aux
, fn
, addr
);
8750 fputc ('\n', stdout
);
8752 /* The GCC personality routines use the standard compact
8753 encoding, starting with one byte giving the number of
8755 if (procname
!= NULL
8756 && (const_strneq (procname
, "__gcc_personality_v0")
8757 || const_strneq (procname
, "__gxx_personality_v0")
8758 || const_strneq (procname
, "__gcj_personality_v0")
8759 || const_strneq (procname
, "__gnu_objc_personality_v0")))
8766 printf (_(" [Truncated data]\n"));
8769 more_words
= word
>> 24;
8779 /* ARM EHABI Section 6.3:
8781 An exception-handling table entry for the compact model looks like:
8785 1 0 index Data for personalityRoutine[index] */
8787 if (elf_header
.e_machine
== EM_ARM
8788 && (word
& 0x70000000))
8790 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
8794 per_index
= (word
>> 24) & 0x7f;
8795 printf (_(" Compact model index: %d\n"), per_index
);
8802 else if (per_index
< 3)
8804 more_words
= (word
>> 16) & 0xff;
8810 switch (elf_header
.e_machine
)
8815 if (! decode_arm_unwind_bytecode (aux
, word
, remaining
, more_words
,
8816 data_offset
, data_sec
, data_arm_sec
))
8821 warn (_("Unknown ARM compact model index encountered\n"));
8822 printf (_(" [reserved]\n"));
8830 if (! decode_tic6x_unwind_bytecode (aux
, word
, remaining
, more_words
,
8831 data_offset
, data_sec
, data_arm_sec
))
8834 else if (per_index
< 5)
8836 if (((word
>> 17) & 0x7f) == 0x7f)
8837 printf (_(" Restore stack from frame pointer\n"));
8839 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
8840 printf (_(" Registers restored: "));
8842 printf (" (compact) ");
8843 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
8845 printf (_(" Return register: %s\n"),
8846 tic6x_unwind_regnames
[word
& 0xf]);
8849 printf (_(" [reserved (%d)]\n"), per_index
);
8853 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
8854 elf_header
.e_machine
);
8858 /* Decode the descriptors. Not implemented. */
8864 dump_arm_unwind (struct arm_unw_aux_info
*aux
, Elf_Internal_Shdr
*exidx_sec
)
8866 struct arm_section exidx_arm_sec
, extab_arm_sec
;
8867 unsigned int i
, exidx_len
;
8868 unsigned long j
, nfuns
;
8869 bfd_boolean res
= TRUE
;
8871 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
8872 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
8873 exidx_len
= exidx_sec
->sh_size
/ 8;
8875 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
8876 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
8877 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
8878 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
8880 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
8882 for (i
= 0; i
< exidx_len
; i
++)
8884 unsigned int exidx_fn
, exidx_entry
;
8885 struct absaddr fn_addr
, entry_addr
;
8888 fputc ('\n', stdout
);
8890 if (! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
8891 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
8892 || ! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
8893 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
8896 arm_free_section (& exidx_arm_sec
);
8897 arm_free_section (& extab_arm_sec
);
8901 /* ARM EHABI, Section 5:
8902 An index table entry consists of 2 words.
8903 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
8904 if (exidx_fn
& 0x80000000)
8906 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
8910 fn
= arm_expand_prel31 (exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
8912 arm_print_vma_and_name (aux
, fn
, fn_addr
);
8913 fputs (": ", stdout
);
8915 if (exidx_entry
== 1)
8917 print_vma (exidx_entry
, PREFIX_HEX
);
8918 fputs (" [cantunwind]\n", stdout
);
8920 else if (exidx_entry
& 0x80000000)
8922 print_vma (exidx_entry
, PREFIX_HEX
);
8923 fputc ('\n', stdout
);
8924 decode_arm_unwind (aux
, exidx_entry
, 4, 0, NULL
, NULL
);
8928 bfd_vma table
, table_offset
= 0;
8929 Elf_Internal_Shdr
*table_sec
;
8931 fputs ("@", stdout
);
8932 table
= arm_expand_prel31 (exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
8933 print_vma (table
, PREFIX_HEX
);
8936 /* Locate the matching .ARM.extab. */
8937 if (entry_addr
.section
!= SHN_UNDEF
8938 && entry_addr
.section
< elf_header
.e_shnum
)
8940 table_sec
= section_headers
+ entry_addr
.section
;
8941 table_offset
= entry_addr
.offset
;
8943 if (table_offset
> table_sec
->sh_size
8944 || ((bfd_signed_vma
) table_offset
) < 0)
8946 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
8947 (unsigned long) table_offset
,
8948 printable_section_name (table_sec
));
8955 table_sec
= find_section_by_address (table
);
8956 if (table_sec
!= NULL
)
8957 table_offset
= table
- table_sec
->sh_addr
;
8960 if (table_sec
== NULL
)
8962 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
8963 (unsigned long) table
);
8968 if (! decode_arm_unwind (aux
, 0, 0, table_offset
, table_sec
,
8977 arm_free_section (&exidx_arm_sec
);
8978 arm_free_section (&extab_arm_sec
);
8983 /* Used for both ARM and C6X unwinding tables. */
8986 arm_process_unwind (FILE *file
)
8988 struct arm_unw_aux_info aux
;
8989 Elf_Internal_Shdr
*unwsec
= NULL
;
8990 Elf_Internal_Shdr
*strsec
;
8991 Elf_Internal_Shdr
*sec
;
8993 unsigned int sec_type
;
8994 bfd_boolean res
= TRUE
;
8996 switch (elf_header
.e_machine
)
8999 sec_type
= SHT_ARM_EXIDX
;
9003 sec_type
= SHT_C6000_UNWIND
;
9007 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9008 elf_header
.e_machine
);
9012 if (string_table
== NULL
)
9015 memset (& aux
, 0, sizeof (aux
));
9018 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
9020 if (sec
->sh_type
== SHT_SYMTAB
&& sec
->sh_link
< elf_header
.e_shnum
)
9022 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
9024 strsec
= section_headers
+ sec
->sh_link
;
9026 /* PR binutils/17531 file: 011-12666-0.004. */
9027 if (aux
.strtab
!= NULL
)
9029 error (_("Multiple string tables found in file.\n"));
9033 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
9034 1, strsec
->sh_size
, _("string table"));
9035 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
9037 else if (sec
->sh_type
== sec_type
)
9042 printf (_("\nThere are no unwind sections in this file.\n"));
9044 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
9046 if (sec
->sh_type
== sec_type
)
9048 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
9049 printable_section_name (sec
),
9050 (unsigned long) sec
->sh_offset
,
9051 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
)));
9053 if (! dump_arm_unwind (&aux
, sec
))
9061 free ((char *) aux
.strtab
);
9067 process_unwind (FILE * file
)
9069 struct unwind_handler
9071 unsigned int machtype
;
9072 bfd_boolean (* handler
)(FILE *);
9075 { EM_ARM
, arm_process_unwind
},
9076 { EM_IA_64
, ia64_process_unwind
},
9077 { EM_PARISC
, hppa_process_unwind
},
9078 { EM_TI_C6000
, arm_process_unwind
},
9086 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
9087 if (elf_header
.e_machine
== handlers
[i
].machtype
)
9088 return handlers
[i
].handler (file
);
9090 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9091 get_machine_name (elf_header
.e_machine
));
9096 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
9098 switch (entry
->d_tag
)
9101 if (entry
->d_un
.d_val
== 0)
9105 static const char * opts
[] =
9107 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9108 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9109 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9110 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9114 bfd_boolean first
= TRUE
;
9116 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
9117 if (entry
->d_un
.d_val
& (1 << cnt
))
9119 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
9125 case DT_MIPS_IVERSION
:
9126 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9127 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
9131 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
9132 /* Note: coded this way so that there is a single string for translation. */
9133 printf (_("<corrupt: %s>"), buf
);
9137 case DT_MIPS_TIME_STAMP
:
9141 time_t atime
= entry
->d_un
.d_val
;
9143 tmp
= gmtime (&atime
);
9144 /* PR 17531: file: 6accc532. */
9146 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
9148 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
9149 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9150 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9151 printf (_("Time Stamp: %s"), timebuf
);
9155 case DT_MIPS_RLD_VERSION
:
9156 case DT_MIPS_LOCAL_GOTNO
:
9157 case DT_MIPS_CONFLICTNO
:
9158 case DT_MIPS_LIBLISTNO
:
9159 case DT_MIPS_SYMTABNO
:
9160 case DT_MIPS_UNREFEXTNO
:
9161 case DT_MIPS_HIPAGENO
:
9162 case DT_MIPS_DELTA_CLASS_NO
:
9163 case DT_MIPS_DELTA_INSTANCE_NO
:
9164 case DT_MIPS_DELTA_RELOC_NO
:
9165 case DT_MIPS_DELTA_SYM_NO
:
9166 case DT_MIPS_DELTA_CLASSSYM_NO
:
9167 case DT_MIPS_COMPACT_SIZE
:
9168 print_vma (entry
->d_un
.d_val
, DEC
);
9172 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9178 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
9180 switch (entry
->d_tag
)
9182 case DT_HP_DLD_FLAGS
:
9191 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
9192 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
9193 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
9194 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
9195 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
9196 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
9197 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
9198 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
9199 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
9200 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
9201 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
9202 { DT_HP_GST
, "HP_GST" },
9203 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
9204 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
9205 { DT_HP_NODELETE
, "HP_NODELETE" },
9206 { DT_HP_GROUP
, "HP_GROUP" },
9207 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
9209 bfd_boolean first
= TRUE
;
9211 bfd_vma val
= entry
->d_un
.d_val
;
9213 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
9214 if (val
& flags
[cnt
].bit
)
9218 fputs (flags
[cnt
].str
, stdout
);
9220 val
^= flags
[cnt
].bit
;
9223 if (val
!= 0 || first
)
9227 print_vma (val
, HEX
);
9233 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9241 /* VMS vs Unix time offset and factor. */
9243 #define VMS_EPOCH_OFFSET 35067168000000000LL
9244 #define VMS_GRANULARITY_FACTOR 10000000
9246 /* Display a VMS time in a human readable format. */
9249 print_vms_time (bfd_int64_t vmstime
)
9254 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
9255 tm
= gmtime (&unxtime
);
9256 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9257 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
9258 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
9263 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
9265 switch (entry
->d_tag
)
9267 case DT_IA_64_PLT_RESERVE
:
9268 /* First 3 slots reserved. */
9269 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9271 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
9274 case DT_IA_64_VMS_LINKTIME
:
9276 print_vms_time (entry
->d_un
.d_val
);
9280 case DT_IA_64_VMS_LNKFLAGS
:
9281 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9282 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
9283 printf (" CALL_DEBUG");
9284 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
9285 printf (" NOP0BUFS");
9286 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
9287 printf (" P0IMAGE");
9288 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
9289 printf (" MKTHREADS");
9290 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
9291 printf (" UPCALLS");
9292 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
9294 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
9295 printf (" INITIALIZE");
9296 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
9298 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
9299 printf (" EXE_INIT");
9300 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
9301 printf (" TBK_IN_IMG");
9302 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
9303 printf (" DBG_IN_IMG");
9304 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
9305 printf (" TBK_IN_DSF");
9306 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
9307 printf (" DBG_IN_DSF");
9308 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
9309 printf (" SIGNATURES");
9310 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
9311 printf (" REL_SEG_OFF");
9315 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9322 get_32bit_dynamic_section (FILE * file
)
9324 Elf32_External_Dyn
* edyn
;
9325 Elf32_External_Dyn
* ext
;
9326 Elf_Internal_Dyn
* entry
;
9328 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
9329 dynamic_size
, _("dynamic section"));
9333 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9334 might not have the luxury of section headers. Look for the DT_NULL
9335 terminator to determine the number of entries. */
9336 for (ext
= edyn
, dynamic_nent
= 0;
9337 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9341 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9345 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9347 if (dynamic_section
== NULL
)
9349 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9350 (unsigned long) dynamic_nent
);
9355 for (ext
= edyn
, entry
= dynamic_section
;
9356 entry
< dynamic_section
+ dynamic_nent
;
9359 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9360 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9369 get_64bit_dynamic_section (FILE * file
)
9371 Elf64_External_Dyn
* edyn
;
9372 Elf64_External_Dyn
* ext
;
9373 Elf_Internal_Dyn
* entry
;
9375 /* Read in the data. */
9376 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
9377 dynamic_size
, _("dynamic section"));
9381 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9382 might not have the luxury of section headers. Look for the DT_NULL
9383 terminator to determine the number of entries. */
9384 for (ext
= edyn
, dynamic_nent
= 0;
9385 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
9386 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9390 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9394 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9396 if (dynamic_section
== NULL
)
9398 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9399 (unsigned long) dynamic_nent
);
9404 /* Convert from external to internal formats. */
9405 for (ext
= edyn
, entry
= dynamic_section
;
9406 entry
< dynamic_section
+ dynamic_nent
;
9409 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9410 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9419 print_dynamic_flags (bfd_vma flags
)
9421 bfd_boolean first
= TRUE
;
9427 flag
= flags
& - flags
;
9437 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
9438 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
9439 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
9440 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
9441 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
9442 default: fputs (_("unknown"), stdout
); break;
9448 /* Parse and display the contents of the dynamic section. */
9451 process_dynamic_section (FILE * file
)
9453 Elf_Internal_Dyn
* entry
;
9455 if (dynamic_size
== 0)
9458 printf (_("\nThere is no dynamic section in this file.\n"));
9465 if (! get_32bit_dynamic_section (file
))
9470 if (! get_64bit_dynamic_section (file
))
9474 /* Find the appropriate symbol table. */
9475 if (dynamic_symbols
== NULL
)
9477 for (entry
= dynamic_section
;
9478 entry
< dynamic_section
+ dynamic_nent
;
9481 Elf_Internal_Shdr section
;
9483 if (entry
->d_tag
!= DT_SYMTAB
)
9486 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
9488 /* Since we do not know how big the symbol table is,
9489 we default to reading in the entire file (!) and
9490 processing that. This is overkill, I know, but it
9492 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
9493 if ((bfd_size_type
) section
.sh_offset
> current_file_size
)
9495 /* See PR 21379 for a reproducer. */
9496 error (_("Invalid DT_SYMTAB entry: %lx"), (long) section
.sh_offset
);
9500 if (archive_file_offset
!= 0)
9501 section
.sh_size
= archive_file_size
- section
.sh_offset
;
9504 if (fseek (file
, 0, SEEK_END
))
9505 error (_("Unable to seek to end of file!\n"));
9507 section
.sh_size
= ftell (file
) - section
.sh_offset
;
9511 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
9513 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
9514 section
.sh_name
= string_table_length
;
9516 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
, & num_dynamic_syms
);
9517 if (num_dynamic_syms
< 1)
9519 error (_("Unable to determine the number of symbols to load\n"));
9525 /* Similarly find a string table. */
9526 if (dynamic_strings
== NULL
)
9528 for (entry
= dynamic_section
;
9529 entry
< dynamic_section
+ dynamic_nent
;
9532 unsigned long offset
;
9535 if (entry
->d_tag
!= DT_STRTAB
)
9538 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
9540 /* Since we do not know how big the string table is,
9541 we default to reading in the entire file (!) and
9542 processing that. This is overkill, I know, but it
9545 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
9547 if (archive_file_offset
!= 0)
9548 str_tab_len
= archive_file_size
- offset
;
9551 if (fseek (file
, 0, SEEK_END
))
9552 error (_("Unable to seek to end of file\n"));
9553 str_tab_len
= ftell (file
) - offset
;
9556 if (str_tab_len
< 1)
9559 (_("Unable to determine the length of the dynamic string table\n"));
9563 dynamic_strings
= (char *) get_data (NULL
, file
, offset
, 1,
9565 _("dynamic string table"));
9566 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : str_tab_len
;
9571 /* And find the syminfo section if available. */
9572 if (dynamic_syminfo
== NULL
)
9574 unsigned long syminsz
= 0;
9576 for (entry
= dynamic_section
;
9577 entry
< dynamic_section
+ dynamic_nent
;
9580 if (entry
->d_tag
== DT_SYMINENT
)
9582 /* Note: these braces are necessary to avoid a syntax
9583 error from the SunOS4 C compiler. */
9584 /* PR binutils/17531: A corrupt file can trigger this test.
9585 So do not use an assert, instead generate an error message. */
9586 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
9587 error (_("Bad value (%d) for SYMINENT entry\n"),
9588 (int) entry
->d_un
.d_val
);
9590 else if (entry
->d_tag
== DT_SYMINSZ
)
9591 syminsz
= entry
->d_un
.d_val
;
9592 else if (entry
->d_tag
== DT_SYMINFO
)
9593 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
9597 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
9599 Elf_External_Syminfo
* extsyminfo
;
9600 Elf_External_Syminfo
* extsym
;
9601 Elf_Internal_Syminfo
* syminfo
;
9603 /* There is a syminfo section. Read the data. */
9604 extsyminfo
= (Elf_External_Syminfo
*)
9605 get_data (NULL
, file
, dynamic_syminfo_offset
, 1, syminsz
,
9606 _("symbol information"));
9610 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
9611 if (dynamic_syminfo
== NULL
)
9613 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9614 (unsigned long) syminsz
);
9618 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
9619 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
9620 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
9621 ++syminfo
, ++extsym
)
9623 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
9624 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
9631 if (do_dynamic
&& dynamic_addr
)
9632 printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
9633 dynamic_addr
, (unsigned long) dynamic_nent
);
9635 printf (_(" Tag Type Name/Value\n"));
9637 for (entry
= dynamic_section
;
9638 entry
< dynamic_section
+ dynamic_nent
;
9646 print_vma (entry
->d_tag
, FULL_HEX
);
9647 dtype
= get_dynamic_type (entry
->d_tag
);
9648 printf (" (%s)%*s", dtype
,
9649 ((is_32bit_elf
? 27 : 19) - (int) strlen (dtype
)), " ");
9652 switch (entry
->d_tag
)
9656 print_dynamic_flags (entry
->d_un
.d_val
);
9666 switch (entry
->d_tag
)
9669 printf (_("Auxiliary library"));
9673 printf (_("Filter library"));
9677 printf (_("Configuration file"));
9681 printf (_("Dependency audit library"));
9685 printf (_("Audit library"));
9689 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9690 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
9694 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9703 printf (_("Flags:"));
9705 if (entry
->d_un
.d_val
== 0)
9706 printf (_(" None\n"));
9709 unsigned long int val
= entry
->d_un
.d_val
;
9711 if (val
& DTF_1_PARINIT
)
9713 printf (" PARINIT");
9714 val
^= DTF_1_PARINIT
;
9716 if (val
& DTF_1_CONFEXP
)
9718 printf (" CONFEXP");
9719 val
^= DTF_1_CONFEXP
;
9722 printf (" %lx", val
);
9731 printf (_("Flags:"));
9733 if (entry
->d_un
.d_val
== 0)
9734 printf (_(" None\n"));
9737 unsigned long int val
= entry
->d_un
.d_val
;
9739 if (val
& DF_P1_LAZYLOAD
)
9741 printf (" LAZYLOAD");
9742 val
^= DF_P1_LAZYLOAD
;
9744 if (val
& DF_P1_GROUPPERM
)
9746 printf (" GROUPPERM");
9747 val
^= DF_P1_GROUPPERM
;
9750 printf (" %lx", val
);
9759 printf (_("Flags:"));
9760 if (entry
->d_un
.d_val
== 0)
9761 printf (_(" None\n"));
9764 unsigned long int val
= entry
->d_un
.d_val
;
9771 if (val
& DF_1_GLOBAL
)
9776 if (val
& DF_1_GROUP
)
9781 if (val
& DF_1_NODELETE
)
9783 printf (" NODELETE");
9784 val
^= DF_1_NODELETE
;
9786 if (val
& DF_1_LOADFLTR
)
9788 printf (" LOADFLTR");
9789 val
^= DF_1_LOADFLTR
;
9791 if (val
& DF_1_INITFIRST
)
9793 printf (" INITFIRST");
9794 val
^= DF_1_INITFIRST
;
9796 if (val
& DF_1_NOOPEN
)
9801 if (val
& DF_1_ORIGIN
)
9806 if (val
& DF_1_DIRECT
)
9811 if (val
& DF_1_TRANS
)
9816 if (val
& DF_1_INTERPOSE
)
9818 printf (" INTERPOSE");
9819 val
^= DF_1_INTERPOSE
;
9821 if (val
& DF_1_NODEFLIB
)
9823 printf (" NODEFLIB");
9824 val
^= DF_1_NODEFLIB
;
9826 if (val
& DF_1_NODUMP
)
9831 if (val
& DF_1_CONFALT
)
9833 printf (" CONFALT");
9834 val
^= DF_1_CONFALT
;
9836 if (val
& DF_1_ENDFILTEE
)
9838 printf (" ENDFILTEE");
9839 val
^= DF_1_ENDFILTEE
;
9841 if (val
& DF_1_DISPRELDNE
)
9843 printf (" DISPRELDNE");
9844 val
^= DF_1_DISPRELDNE
;
9846 if (val
& DF_1_DISPRELPND
)
9848 printf (" DISPRELPND");
9849 val
^= DF_1_DISPRELPND
;
9851 if (val
& DF_1_NODIRECT
)
9853 printf (" NODIRECT");
9854 val
^= DF_1_NODIRECT
;
9856 if (val
& DF_1_IGNMULDEF
)
9858 printf (" IGNMULDEF");
9859 val
^= DF_1_IGNMULDEF
;
9861 if (val
& DF_1_NOKSYMS
)
9863 printf (" NOKSYMS");
9864 val
^= DF_1_NOKSYMS
;
9866 if (val
& DF_1_NOHDR
)
9871 if (val
& DF_1_EDITED
)
9876 if (val
& DF_1_NORELOC
)
9878 printf (" NORELOC");
9879 val
^= DF_1_NORELOC
;
9881 if (val
& DF_1_SYMINTPOSE
)
9883 printf (" SYMINTPOSE");
9884 val
^= DF_1_SYMINTPOSE
;
9886 if (val
& DF_1_GLOBAUDIT
)
9888 printf (" GLOBAUDIT");
9889 val
^= DF_1_GLOBAUDIT
;
9891 if (val
& DF_1_SINGLETON
)
9893 printf (" SINGLETON");
9894 val
^= DF_1_SINGLETON
;
9896 if (val
& DF_1_STUB
)
9907 printf (" %lx", val
);
9914 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9916 puts (get_dynamic_type (entry
->d_un
.d_val
));
9936 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9942 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9943 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
9949 switch (entry
->d_tag
)
9952 printf (_("Shared library: [%s]"), name
);
9954 if (streq (name
, program_interpreter
))
9955 printf (_(" program interpreter"));
9959 printf (_("Library soname: [%s]"), name
);
9963 printf (_("Library rpath: [%s]"), name
);
9967 printf (_("Library runpath: [%s]"), name
);
9971 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9976 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9989 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9994 case DT_INIT_ARRAYSZ
:
9995 case DT_FINI_ARRAYSZ
:
9996 case DT_GNU_CONFLICTSZ
:
9997 case DT_GNU_LIBLISTSZ
:
10000 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10001 printf (_(" (bytes)\n"));
10006 case DT_VERNEEDNUM
:
10011 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10020 case DT_INIT_ARRAY
:
10021 case DT_FINI_ARRAY
:
10024 if (entry
->d_tag
== DT_USED
10025 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
10027 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
10031 printf (_("Not needed object: [%s]\n"), name
);
10036 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10042 /* The value of this entry is ignored. */
10047 case DT_GNU_PRELINKED
:
10051 time_t atime
= entry
->d_un
.d_val
;
10053 tmp
= gmtime (&atime
);
10054 /* PR 17533 file: 041-1244816-0.004. */
10056 printf (_("<corrupt time val: %lx"),
10057 (unsigned long) atime
);
10059 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10060 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
10061 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
10067 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10070 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10076 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
10077 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
10082 switch (elf_header
.e_machine
)
10085 case EM_MIPS_RS3_LE
:
10086 dynamic_section_mips_val (entry
);
10089 dynamic_section_parisc_val (entry
);
10092 dynamic_section_ia64_val (entry
);
10095 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10107 get_ver_flags (unsigned int flags
)
10109 static char buff
[32];
10116 if (flags
& VER_FLG_BASE
)
10117 strcat (buff
, "BASE");
10119 if (flags
& VER_FLG_WEAK
)
10121 if (flags
& VER_FLG_BASE
)
10122 strcat (buff
, " | ");
10124 strcat (buff
, "WEAK");
10127 if (flags
& VER_FLG_INFO
)
10129 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
10130 strcat (buff
, " | ");
10132 strcat (buff
, "INFO");
10135 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10137 if (flags
& (VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10138 strcat (buff
, " | ");
10140 strcat (buff
, _("<unknown>"));
10146 /* Display the contents of the version sections. */
10149 process_version_sections (FILE * file
)
10151 Elf_Internal_Shdr
* section
;
10153 bfd_boolean found
= FALSE
;
10158 for (i
= 0, section
= section_headers
;
10159 i
< elf_header
.e_shnum
;
10162 switch (section
->sh_type
)
10164 case SHT_GNU_verdef
:
10166 Elf_External_Verdef
* edefs
;
10173 printf (_("\nVersion definition section '%s' contains %u entries:\n"),
10174 printable_section_name (section
),
10177 printf (_(" Addr: 0x"));
10178 printf_vma (section
->sh_addr
);
10179 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10180 (unsigned long) section
->sh_offset
, section
->sh_link
,
10181 printable_section_name_from_index (section
->sh_link
));
10183 edefs
= (Elf_External_Verdef
*)
10184 get_data (NULL
, file
, section
->sh_offset
, 1,section
->sh_size
,
10185 _("version definition section"));
10188 endbuf
= (char *) edefs
+ section
->sh_size
;
10190 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
10193 Elf_External_Verdef
* edef
;
10194 Elf_Internal_Verdef ent
;
10195 Elf_External_Verdaux
* eaux
;
10196 Elf_Internal_Verdaux aux
;
10197 unsigned long isum
;
10200 vstart
= ((char *) edefs
) + idx
;
10201 if (vstart
+ sizeof (*edef
) > endbuf
)
10204 edef
= (Elf_External_Verdef
*) vstart
;
10206 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
10207 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
10208 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
10209 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
10210 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
10211 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
10212 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
10214 printf (_(" %#06lx: Rev: %d Flags: %s"),
10215 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
10217 printf (_(" Index: %d Cnt: %d "),
10218 ent
.vd_ndx
, ent
.vd_cnt
);
10220 /* Check for overflow. */
10221 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
10224 vstart
+= ent
.vd_aux
;
10226 if (vstart
+ sizeof (*eaux
) > endbuf
)
10228 eaux
= (Elf_External_Verdaux
*) vstart
;
10230 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10231 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10233 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10234 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
10236 printf (_("Name index: %ld\n"), aux
.vda_name
);
10238 isum
= idx
+ ent
.vd_aux
;
10240 for (j
= 1; j
< ent
.vd_cnt
; j
++)
10242 if (aux
.vda_next
< sizeof (*eaux
)
10243 && !(j
== ent
.vd_cnt
- 1 && aux
.vda_next
== 0))
10245 warn (_("Invalid vda_next field of %lx\n"),
10250 /* Check for overflow. */
10251 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
10254 isum
+= aux
.vda_next
;
10255 vstart
+= aux
.vda_next
;
10257 if (vstart
+ sizeof (*eaux
) > endbuf
)
10259 eaux
= (Elf_External_Verdaux
*) vstart
;
10261 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10262 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10264 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10265 printf (_(" %#06lx: Parent %d: %s\n"),
10266 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
10268 printf (_(" %#06lx: Parent %d, name index: %ld\n"),
10269 isum
, j
, aux
.vda_name
);
10272 if (j
< ent
.vd_cnt
)
10273 printf (_(" Version def aux past end of section\n"));
10276 file: id:000001,src:000172+005151,op:splice,rep:2. */
10277 if (ent
.vd_next
< sizeof (*edef
)
10278 && !(cnt
== section
->sh_info
- 1 && ent
.vd_next
== 0))
10280 warn (_("Invalid vd_next field of %lx\n"), ent
.vd_next
);
10281 cnt
= section
->sh_info
;
10284 if (ent
.vd_next
> (size_t) (endbuf
- ((char *) edefs
+ idx
)))
10287 idx
+= ent
.vd_next
;
10290 if (cnt
< section
->sh_info
)
10291 printf (_(" Version definition past end of section\n"));
10297 case SHT_GNU_verneed
:
10299 Elf_External_Verneed
* eneed
;
10306 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
10307 printable_section_name (section
), section
->sh_info
);
10309 printf (_(" Addr: 0x"));
10310 printf_vma (section
->sh_addr
);
10311 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10312 (unsigned long) section
->sh_offset
, section
->sh_link
,
10313 printable_section_name_from_index (section
->sh_link
));
10315 eneed
= (Elf_External_Verneed
*) get_data (NULL
, file
,
10316 section
->sh_offset
, 1,
10318 _("Version Needs section"));
10321 endbuf
= (char *) eneed
+ section
->sh_size
;
10323 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
10325 Elf_External_Verneed
* entry
;
10326 Elf_Internal_Verneed ent
;
10327 unsigned long isum
;
10331 vstart
= ((char *) eneed
) + idx
;
10332 if (vstart
+ sizeof (*entry
) > endbuf
)
10335 entry
= (Elf_External_Verneed
*) vstart
;
10337 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
10338 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
10339 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
10340 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
10341 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
10343 printf (_(" %#06lx: Version: %d"), idx
, ent
.vn_version
);
10345 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
10346 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
10348 printf (_(" File: %lx"), ent
.vn_file
);
10350 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
10352 /* Check for overflow. */
10353 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
10355 vstart
+= ent
.vn_aux
;
10357 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
10359 Elf_External_Vernaux
* eaux
;
10360 Elf_Internal_Vernaux aux
;
10362 if (vstart
+ sizeof (*eaux
) > endbuf
)
10364 eaux
= (Elf_External_Vernaux
*) vstart
;
10366 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
10367 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
10368 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
10369 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
10370 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
10372 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
10373 printf (_(" %#06lx: Name: %s"),
10374 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
10376 printf (_(" %#06lx: Name index: %lx"),
10377 isum
, aux
.vna_name
);
10379 printf (_(" Flags: %s Version: %d\n"),
10380 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
10382 if (aux
.vna_next
< sizeof (*eaux
)
10383 && !(j
== ent
.vn_cnt
- 1 && aux
.vna_next
== 0))
10385 warn (_("Invalid vna_next field of %lx\n"),
10390 /* Check for overflow. */
10391 if (aux
.vna_next
> (size_t) (endbuf
- vstart
))
10393 isum
+= aux
.vna_next
;
10394 vstart
+= aux
.vna_next
;
10397 if (j
< ent
.vn_cnt
)
10398 warn (_("Missing Version Needs auxillary information\n"));
10400 if (ent
.vn_next
< sizeof (*entry
)
10401 && !(cnt
== section
->sh_info
- 1 && ent
.vn_next
== 0))
10403 warn (_("Invalid vn_next field of %lx\n"), ent
.vn_next
);
10404 cnt
= section
->sh_info
;
10407 if (ent
.vn_next
> (size_t) (endbuf
- ((char *) eneed
+ idx
)))
10409 idx
+= ent
.vn_next
;
10412 if (cnt
< section
->sh_info
)
10413 warn (_("Missing Version Needs information\n"));
10419 case SHT_GNU_versym
:
10421 Elf_Internal_Shdr
* link_section
;
10424 unsigned char * edata
;
10425 unsigned short * data
;
10427 Elf_Internal_Sym
* symbols
;
10428 Elf_Internal_Shdr
* string_sec
;
10429 unsigned long num_syms
;
10432 if (section
->sh_link
>= elf_header
.e_shnum
)
10435 link_section
= section_headers
+ section
->sh_link
;
10436 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
10438 if (link_section
->sh_link
>= elf_header
.e_shnum
)
10443 symbols
= GET_ELF_SYMBOLS (file
, link_section
, & num_syms
);
10444 if (symbols
== NULL
)
10447 string_sec
= section_headers
+ link_section
->sh_link
;
10449 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
10450 string_sec
->sh_size
,
10451 _("version string table"));
10458 printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
10459 printable_section_name (section
), (unsigned long) total
);
10461 printf (_(" Addr: "));
10462 printf_vma (section
->sh_addr
);
10463 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10464 (unsigned long) section
->sh_offset
, section
->sh_link
,
10465 printable_section_name (link_section
));
10467 off
= offset_from_vma (file
,
10468 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
10469 total
* sizeof (short));
10470 edata
= (unsigned char *) get_data (NULL
, file
, off
, total
,
10472 _("version symbol data"));
10480 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
10482 for (cnt
= total
; cnt
--;)
10483 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
10488 for (cnt
= 0; cnt
< total
; cnt
+= 4)
10492 char *invalid
= _("*invalid*");
10494 printf (" %03x:", cnt
);
10496 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
10497 switch (data
[cnt
+ j
])
10500 fputs (_(" 0 (*local*) "), stdout
);
10504 fputs (_(" 1 (*global*) "), stdout
);
10508 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
10509 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
10511 /* If this index value is greater than the size of the symbols
10512 array, break to avoid an out-of-bounds read. */
10513 if ((unsigned long)(cnt
+ j
) >= num_syms
)
10515 warn (_("invalid index into symbol array\n"));
10520 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
10522 Elf_Internal_Verneed ivn
;
10523 unsigned long offset
;
10525 offset
= offset_from_vma
10526 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
10527 sizeof (Elf_External_Verneed
));
10531 Elf_Internal_Vernaux ivna
;
10532 Elf_External_Verneed evn
;
10533 Elf_External_Vernaux evna
;
10534 unsigned long a_off
;
10536 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
10537 _("version need")) == NULL
)
10540 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
10541 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
10543 a_off
= offset
+ ivn
.vn_aux
;
10547 if (get_data (&evna
, file
, a_off
, sizeof (evna
),
10548 1, _("version need aux (2)")) == NULL
)
10551 ivna
.vna_other
= 0;
10555 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
10556 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
10559 a_off
+= ivna
.vna_next
;
10561 while (ivna
.vna_other
!= data
[cnt
+ j
]
10562 && ivna
.vna_next
!= 0);
10564 if (ivna
.vna_other
== data
[cnt
+ j
])
10566 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
10568 if (ivna
.vna_name
>= string_sec
->sh_size
)
10571 name
= strtab
+ ivna
.vna_name
;
10575 offset
+= ivn
.vn_next
;
10577 while (ivn
.vn_next
);
10580 if (data
[cnt
+ j
] != 0x8001
10581 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
10583 Elf_Internal_Verdef ivd
;
10584 Elf_External_Verdef evd
;
10585 unsigned long offset
;
10587 offset
= offset_from_vma
10588 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
10593 if (get_data (&evd
, file
, offset
, sizeof (evd
), 1,
10594 _("version def")) == NULL
)
10597 /* PR 17531: file: 046-1082287-0.004. */
10598 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
10603 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
10604 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
10607 offset
+= ivd
.vd_next
;
10609 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
10610 && ivd
.vd_next
!= 0);
10612 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
10614 Elf_External_Verdaux evda
;
10615 Elf_Internal_Verdaux ivda
;
10617 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
10619 if (get_data (&evda
, file
,
10620 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
10622 _("version def aux")) == NULL
)
10625 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
10627 if (ivda
.vda_name
>= string_sec
->sh_size
)
10629 else if (name
!= NULL
&& name
!= invalid
)
10630 name
= _("*both*");
10632 name
= strtab
+ ivda
.vda_name
;
10636 nn
+= printf ("(%s%-*s",
10638 12 - (int) strlen (name
),
10642 printf ("%*c", 18 - nn
, ' ');
10660 printf (_("\nNo version information found in this file.\n"));
10665 static const char *
10666 get_symbol_binding (unsigned int binding
)
10668 static char buff
[32];
10672 case STB_LOCAL
: return "LOCAL";
10673 case STB_GLOBAL
: return "GLOBAL";
10674 case STB_WEAK
: return "WEAK";
10676 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
10677 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
10679 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
10681 if (binding
== STB_GNU_UNIQUE
10682 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10683 /* GNU is still using the default value 0. */
10684 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10686 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
10689 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
10694 static const char *
10695 get_symbol_type (unsigned int type
)
10697 static char buff
[32];
10701 case STT_NOTYPE
: return "NOTYPE";
10702 case STT_OBJECT
: return "OBJECT";
10703 case STT_FUNC
: return "FUNC";
10704 case STT_SECTION
: return "SECTION";
10705 case STT_FILE
: return "FILE";
10706 case STT_COMMON
: return "COMMON";
10707 case STT_TLS
: return "TLS";
10708 case STT_RELC
: return "RELC";
10709 case STT_SRELC
: return "SRELC";
10711 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
10713 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
10714 return "THUMB_FUNC";
10716 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
10719 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
10720 return "PARISC_MILLI";
10722 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
10724 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
10726 if (elf_header
.e_machine
== EM_PARISC
)
10728 if (type
== STT_HP_OPAQUE
)
10729 return "HP_OPAQUE";
10730 if (type
== STT_HP_STUB
)
10734 if (type
== STT_GNU_IFUNC
10735 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10736 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
10737 /* GNU is still using the default value 0. */
10738 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10741 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
10744 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
10749 static const char *
10750 get_symbol_visibility (unsigned int visibility
)
10752 switch (visibility
)
10754 case STV_DEFAULT
: return "DEFAULT";
10755 case STV_INTERNAL
: return "INTERNAL";
10756 case STV_HIDDEN
: return "HIDDEN";
10757 case STV_PROTECTED
: return "PROTECTED";
10759 error (_("Unrecognized visibility value: %u"), visibility
);
10760 return _("<unknown>");
10764 static const char *
10765 get_solaris_symbol_visibility (unsigned int visibility
)
10767 switch (visibility
)
10769 case 4: return "EXPORTED";
10770 case 5: return "SINGLETON";
10771 case 6: return "ELIMINATE";
10772 default: return get_symbol_visibility (visibility
);
10776 static const char *
10777 get_mips_symbol_other (unsigned int other
)
10781 case STO_OPTIONAL
: return "OPTIONAL";
10782 case STO_MIPS_PLT
: return "MIPS PLT";
10783 case STO_MIPS_PIC
: return "MIPS PIC";
10784 case STO_MICROMIPS
: return "MICROMIPS";
10785 case STO_MICROMIPS
| STO_MIPS_PIC
: return "MICROMIPS, MIPS PIC";
10786 case STO_MIPS16
: return "MIPS16";
10787 default: return NULL
;
10791 static const char *
10792 get_ia64_symbol_other (unsigned int other
)
10794 if (is_ia64_vms ())
10796 static char res
[32];
10800 /* Function types is for images and .STB files only. */
10801 switch (elf_header
.e_type
)
10805 switch (VMS_ST_FUNC_TYPE (other
))
10807 case VMS_SFT_CODE_ADDR
:
10808 strcat (res
, " CA");
10810 case VMS_SFT_SYMV_IDX
:
10811 strcat (res
, " VEC");
10814 strcat (res
, " FD");
10816 case VMS_SFT_RESERVE
:
10817 strcat (res
, " RSV");
10820 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10821 VMS_ST_FUNC_TYPE (other
));
10822 strcat (res
, " <unknown>");
10829 switch (VMS_ST_LINKAGE (other
))
10831 case VMS_STL_IGNORE
:
10832 strcat (res
, " IGN");
10834 case VMS_STL_RESERVE
:
10835 strcat (res
, " RSV");
10838 strcat (res
, " STD");
10841 strcat (res
, " LNK");
10844 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10845 VMS_ST_LINKAGE (other
));
10846 strcat (res
, " <unknown>");
10858 static const char *
10859 get_ppc64_symbol_other (unsigned int other
)
10861 if (PPC64_LOCAL_ENTRY_OFFSET (other
) != 0)
10863 static char buf
[32];
10864 snprintf (buf
, sizeof buf
, _("<localentry>: %d"),
10865 PPC64_LOCAL_ENTRY_OFFSET (other
));
10871 static const char *
10872 get_symbol_other (unsigned int other
)
10874 const char * result
= NULL
;
10875 static char buff
[32];
10880 switch (elf_header
.e_machine
)
10883 result
= get_mips_symbol_other (other
);
10886 result
= get_ia64_symbol_other (other
);
10889 result
= get_ppc64_symbol_other (other
);
10899 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
10903 static const char *
10904 get_symbol_index_type (unsigned int type
)
10906 static char buff
[32];
10910 case SHN_UNDEF
: return "UND";
10911 case SHN_ABS
: return "ABS";
10912 case SHN_COMMON
: return "COM";
10914 if (type
== SHN_IA_64_ANSI_COMMON
10915 && elf_header
.e_machine
== EM_IA_64
10916 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
10918 else if ((elf_header
.e_machine
== EM_X86_64
10919 || elf_header
.e_machine
== EM_L1OM
10920 || elf_header
.e_machine
== EM_K1OM
)
10921 && type
== SHN_X86_64_LCOMMON
)
10922 return "LARGE_COM";
10923 else if ((type
== SHN_MIPS_SCOMMON
10924 && elf_header
.e_machine
== EM_MIPS
)
10925 || (type
== SHN_TIC6X_SCOMMON
10926 && elf_header
.e_machine
== EM_TI_C6000
))
10928 else if (type
== SHN_MIPS_SUNDEFINED
10929 && elf_header
.e_machine
== EM_MIPS
)
10931 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
10932 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
10933 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
10934 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
10935 else if (type
>= SHN_LORESERVE
)
10936 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
10937 else if (type
>= elf_header
.e_shnum
)
10938 sprintf (buff
, _("bad section index[%3d]"), type
);
10940 sprintf (buff
, "%3d", type
);
10948 get_dynamic_data (FILE * file
, bfd_size_type number
, unsigned int ent_size
)
10950 unsigned char * e_data
;
10953 /* If the size_t type is smaller than the bfd_size_type, eg because
10954 you are building a 32-bit tool on a 64-bit host, then make sure
10955 that when (number) is cast to (size_t) no information is lost. */
10956 if (sizeof (size_t) < sizeof (bfd_size_type
)
10957 && (bfd_size_type
) ((size_t) number
) != number
)
10959 error (_("Size truncation prevents reading %" BFD_VMA_FMT
"u"
10960 " elements of size %u\n"),
10965 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
10966 attempting to allocate memory when the read is bound to fail. */
10967 if (ent_size
* number
> current_file_size
)
10969 error (_("Invalid number of dynamic entries: %" BFD_VMA_FMT
"u\n"),
10974 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
10975 if (e_data
== NULL
)
10977 error (_("Out of memory reading %" BFD_VMA_FMT
"u dynamic entries\n"),
10982 if (fread (e_data
, ent_size
, (size_t) number
, file
) != number
)
10984 error (_("Unable to read in %" BFD_VMA_FMT
"u bytes of dynamic data\n"),
10985 number
* ent_size
);
10990 i_data
= (bfd_vma
*) cmalloc ((size_t) number
, sizeof (*i_data
));
10991 if (i_data
== NULL
)
10993 error (_("Out of memory allocating space for %" BFD_VMA_FMT
"u"
10994 " dynamic entries\n"),
11001 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
11009 print_dynamic_symbol (bfd_vma si
, unsigned long hn
)
11011 Elf_Internal_Sym
* psym
;
11014 n
= print_vma (si
, DEC_5
);
11016 fputs (&" "[n
], stdout
);
11017 printf (" %3lu: ", hn
);
11019 if (dynamic_symbols
== NULL
|| si
>= num_dynamic_syms
)
11021 printf (_("<No info available for dynamic symbol number %lu>\n"),
11022 (unsigned long) si
);
11026 psym
= dynamic_symbols
+ si
;
11027 print_vma (psym
->st_value
, LONG_HEX
);
11029 print_vma (psym
->st_size
, DEC_5
);
11031 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
11032 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
11034 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
11035 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
11038 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
11040 printf (" %-7s", get_symbol_visibility (vis
));
11041 /* Check to see if any other bits in the st_other field are set.
11042 Note - displaying this information disrupts the layout of the
11043 table being generated, but for the moment this case is very
11045 if (psym
->st_other
^ vis
)
11046 printf (" [%s] ", get_symbol_other (psym
->st_other
^ vis
));
11049 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
11050 if (VALID_DYNAMIC_NAME (psym
->st_name
))
11051 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
11053 printf (_(" <corrupt: %14ld>"), psym
->st_name
);
11057 static const char *
11058 get_symbol_version_string (FILE * file
,
11059 bfd_boolean is_dynsym
,
11060 const char * strtab
,
11061 unsigned long int strtab_size
,
11063 Elf_Internal_Sym
* psym
,
11064 enum versioned_symbol_info
* sym_info
,
11065 unsigned short * vna_other
)
11067 unsigned char data
[2];
11068 unsigned short vers_data
;
11069 unsigned long offset
;
11072 || version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
11075 offset
= offset_from_vma (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
11076 sizeof data
+ si
* sizeof (vers_data
));
11078 if (get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
11079 sizeof (data
), 1, _("version data")) == NULL
)
11082 vers_data
= byte_get (data
, 2);
11084 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
<= 1)
11087 /* Usually we'd only see verdef for defined symbols, and verneed for
11088 undefined symbols. However, symbols defined by the linker in
11089 .dynbss for variables copied from a shared library in order to
11090 avoid text relocations are defined yet have verneed. We could
11091 use a heuristic to detect the special case, for example, check
11092 for verneed first on symbols defined in SHT_NOBITS sections, but
11093 it is simpler and more reliable to just look for both verdef and
11094 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
11096 if (psym
->st_shndx
!= SHN_UNDEF
11097 && vers_data
!= 0x8001
11098 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
11100 Elf_Internal_Verdef ivd
;
11101 Elf_Internal_Verdaux ivda
;
11102 Elf_External_Verdaux evda
;
11105 off
= offset_from_vma (file
,
11106 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
11107 sizeof (Elf_External_Verdef
));
11111 Elf_External_Verdef evd
;
11113 if (get_data (&evd
, file
, off
, sizeof (evd
), 1,
11114 _("version def")) == NULL
)
11122 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
11123 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
11124 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
11127 off
+= ivd
.vd_next
;
11129 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
11131 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
11133 off
-= ivd
.vd_next
;
11136 if (get_data (&evda
, file
, off
, sizeof (evda
), 1,
11137 _("version def aux")) != NULL
)
11139 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
11141 if (psym
->st_name
!= ivda
.vda_name
)
11143 *sym_info
= ((vers_data
& VERSYM_HIDDEN
) != 0
11144 ? symbol_hidden
: symbol_public
);
11145 return (ivda
.vda_name
< strtab_size
11146 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
11152 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
11154 Elf_External_Verneed evn
;
11155 Elf_Internal_Verneed ivn
;
11156 Elf_Internal_Vernaux ivna
;
11158 offset
= offset_from_vma (file
,
11159 version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
11163 unsigned long vna_off
;
11165 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
11166 _("version need")) == NULL
)
11169 ivna
.vna_other
= 0;
11174 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
11175 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
11177 vna_off
= offset
+ ivn
.vn_aux
;
11181 Elf_External_Vernaux evna
;
11183 if (get_data (&evna
, file
, vna_off
, sizeof (evna
), 1,
11184 _("version need aux (3)")) == NULL
)
11187 ivna
.vna_other
= 0;
11192 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
11193 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
11194 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
11197 vna_off
+= ivna
.vna_next
;
11199 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
11201 if (ivna
.vna_other
== vers_data
)
11204 offset
+= ivn
.vn_next
;
11206 while (ivn
.vn_next
!= 0);
11208 if (ivna
.vna_other
== vers_data
)
11210 *sym_info
= symbol_undefined
;
11211 *vna_other
= ivna
.vna_other
;
11212 return (ivna
.vna_name
< strtab_size
11213 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
11219 /* Dump the symbol table. */
11221 process_symbol_table (FILE * file
)
11223 Elf_Internal_Shdr
* section
;
11224 bfd_size_type nbuckets
= 0;
11225 bfd_size_type nchains
= 0;
11226 bfd_vma
* buckets
= NULL
;
11227 bfd_vma
* chains
= NULL
;
11228 bfd_vma ngnubuckets
= 0;
11229 bfd_vma
* gnubuckets
= NULL
;
11230 bfd_vma
* gnuchains
= NULL
;
11231 bfd_vma gnusymidx
= 0;
11232 bfd_size_type ngnuchains
= 0;
11234 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
11237 if (dynamic_info
[DT_HASH
]
11239 || (do_using_dynamic
11241 && dynamic_strings
!= NULL
)))
11243 unsigned char nb
[8];
11244 unsigned char nc
[8];
11245 unsigned int hash_ent_size
= 4;
11247 if ((elf_header
.e_machine
== EM_ALPHA
11248 || elf_header
.e_machine
== EM_S390
11249 || elf_header
.e_machine
== EM_S390_OLD
)
11250 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
11254 (archive_file_offset
11255 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
11256 sizeof nb
+ sizeof nc
)),
11259 error (_("Unable to seek to start of dynamic information\n"));
11263 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
11265 error (_("Failed to read in number of buckets\n"));
11269 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
11271 error (_("Failed to read in number of chains\n"));
11275 nbuckets
= byte_get (nb
, hash_ent_size
);
11276 nchains
= byte_get (nc
, hash_ent_size
);
11278 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
11279 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
11282 if (buckets
== NULL
|| chains
== NULL
)
11284 if (do_using_dynamic
)
11295 if (dynamic_info_DT_GNU_HASH
11297 || (do_using_dynamic
11299 && dynamic_strings
!= NULL
)))
11301 unsigned char nb
[16];
11302 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
11303 bfd_vma buckets_vma
;
11306 (archive_file_offset
11307 + offset_from_vma (file
, dynamic_info_DT_GNU_HASH
,
11311 error (_("Unable to seek to start of dynamic information\n"));
11315 if (fread (nb
, 16, 1, file
) != 1)
11317 error (_("Failed to read in number of buckets\n"));
11321 ngnubuckets
= byte_get (nb
, 4);
11322 gnusymidx
= byte_get (nb
+ 4, 4);
11323 bitmaskwords
= byte_get (nb
+ 8, 4);
11324 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
11326 buckets_vma
+= bitmaskwords
* 4;
11328 buckets_vma
+= bitmaskwords
* 8;
11331 (archive_file_offset
11332 + offset_from_vma (file
, buckets_vma
, 4)),
11335 error (_("Unable to seek to start of dynamic information\n"));
11339 gnubuckets
= get_dynamic_data (file
, ngnubuckets
, 4);
11341 if (gnubuckets
== NULL
)
11344 for (i
= 0; i
< ngnubuckets
; i
++)
11345 if (gnubuckets
[i
] != 0)
11347 if (gnubuckets
[i
] < gnusymidx
)
11350 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
11351 maxchain
= gnubuckets
[i
];
11354 if (maxchain
== 0xffffffff)
11357 maxchain
-= gnusymidx
;
11360 (archive_file_offset
11361 + offset_from_vma (file
, buckets_vma
11362 + 4 * (ngnubuckets
+ maxchain
), 4)),
11365 error (_("Unable to seek to start of dynamic information\n"));
11371 if (fread (nb
, 4, 1, file
) != 1)
11373 error (_("Failed to determine last chain length\n"));
11377 if (maxchain
+ 1 == 0)
11382 while ((byte_get (nb
, 4) & 1) == 0);
11385 (archive_file_offset
11386 + offset_from_vma (file
, buckets_vma
+ 4 * ngnubuckets
, 4)),
11389 error (_("Unable to seek to start of dynamic information\n"));
11393 gnuchains
= get_dynamic_data (file
, maxchain
, 4);
11394 ngnuchains
= maxchain
;
11397 if (gnuchains
== NULL
)
11402 if (do_using_dynamic
)
11407 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
11409 && do_using_dynamic
11410 && dynamic_strings
!= NULL
11411 && dynamic_symbols
!= NULL
)
11415 if (dynamic_info
[DT_HASH
])
11419 printf (_("\nSymbol table for image:\n"));
11421 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11423 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11425 for (hn
= 0; hn
< nbuckets
; hn
++)
11430 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
11431 print_dynamic_symbol (si
, hn
);
11435 if (dynamic_info_DT_GNU_HASH
)
11437 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
11439 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11441 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11443 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11444 if (gnubuckets
[hn
] != 0)
11446 bfd_vma si
= gnubuckets
[hn
];
11447 bfd_vma off
= si
- gnusymidx
;
11451 print_dynamic_symbol (si
, hn
);
11454 while (off
< ngnuchains
&& (gnuchains
[off
++] & 1) == 0);
11458 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
11459 && section_headers
!= NULL
)
11463 for (i
= 0, section
= section_headers
;
11464 i
< elf_header
.e_shnum
;
11468 char * strtab
= NULL
;
11469 unsigned long int strtab_size
= 0;
11470 Elf_Internal_Sym
* symtab
;
11471 Elf_Internal_Sym
* psym
;
11472 unsigned long num_syms
;
11474 if ((section
->sh_type
!= SHT_SYMTAB
11475 && section
->sh_type
!= SHT_DYNSYM
)
11477 && section
->sh_type
== SHT_SYMTAB
))
11480 if (section
->sh_entsize
== 0)
11482 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
11483 printable_section_name (section
));
11487 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
11488 printable_section_name (section
),
11489 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
11492 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11494 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11496 symtab
= GET_ELF_SYMBOLS (file
, section
, & num_syms
);
11497 if (symtab
== NULL
)
11500 if (section
->sh_link
== elf_header
.e_shstrndx
)
11502 strtab
= string_table
;
11503 strtab_size
= string_table_length
;
11505 else if (section
->sh_link
< elf_header
.e_shnum
)
11507 Elf_Internal_Shdr
* string_sec
;
11509 string_sec
= section_headers
+ section
->sh_link
;
11511 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
11512 1, string_sec
->sh_size
,
11513 _("string table"));
11514 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
11517 for (si
= 0, psym
= symtab
; si
< num_syms
; si
++, psym
++)
11519 const char *version_string
;
11520 enum versioned_symbol_info sym_info
;
11521 unsigned short vna_other
;
11523 printf ("%6d: ", si
);
11524 print_vma (psym
->st_value
, LONG_HEX
);
11526 print_vma (psym
->st_size
, DEC_5
);
11527 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
11528 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
11529 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
11530 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
11533 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
11535 printf (" %-7s", get_symbol_visibility (vis
));
11536 /* Check to see if any other bits in the st_other field are set.
11537 Note - displaying this information disrupts the layout of the
11538 table being generated, but for the moment this case is very rare. */
11539 if (psym
->st_other
^ vis
)
11540 printf (" [%s] ", get_symbol_other (psym
->st_other
^ vis
));
11542 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
11543 print_symbol (25, psym
->st_name
< strtab_size
11544 ? strtab
+ psym
->st_name
: _("<corrupt>"));
11547 = get_symbol_version_string (file
,
11548 section
->sh_type
== SHT_DYNSYM
,
11549 strtab
, strtab_size
, si
,
11550 psym
, &sym_info
, &vna_other
);
11551 if (version_string
)
11553 if (sym_info
== symbol_undefined
)
11554 printf ("@%s (%d)", version_string
, vna_other
);
11556 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
11562 if (ELF_ST_BIND (psym
->st_info
) == STB_LOCAL
11563 && si
>= section
->sh_info
11564 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
11565 && elf_header
.e_machine
!= EM_MIPS
11566 /* Solaris binaries have been found to violate this requirement as
11567 well. Not sure if this is a bug or an ABI requirement. */
11568 && elf_header
.e_ident
[EI_OSABI
] != ELFOSABI_SOLARIS
)
11569 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
11570 si
, printable_section_name (section
), section
->sh_info
);
11574 if (strtab
!= string_table
)
11580 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
11582 if (do_histogram
&& buckets
!= NULL
)
11584 unsigned long * lengths
;
11585 unsigned long * counts
;
11588 unsigned long maxlength
= 0;
11589 unsigned long nzero_counts
= 0;
11590 unsigned long nsyms
= 0;
11591 unsigned long chained
;
11593 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
11594 (unsigned long) nbuckets
);
11596 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
11597 if (lengths
== NULL
)
11599 error (_("Out of memory allocating space for histogram buckets\n"));
11603 printf (_(" Length Number %% of total Coverage\n"));
11604 for (hn
= 0; hn
< nbuckets
; ++hn
)
11606 for (si
= buckets
[hn
], chained
= 0;
11607 si
> 0 && si
< nchains
&& si
< nbuckets
&& chained
<= nchains
;
11608 si
= chains
[si
], ++chained
)
11611 if (maxlength
< ++lengths
[hn
])
11615 /* PR binutils/17531: A corrupt binary could contain broken
11616 histogram data. Do not go into an infinite loop trying
11618 if (chained
> nchains
)
11620 error (_("histogram chain is corrupt\n"));
11625 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
11626 if (counts
== NULL
)
11629 error (_("Out of memory allocating space for histogram counts\n"));
11633 for (hn
= 0; hn
< nbuckets
; ++hn
)
11634 ++counts
[lengths
[hn
]];
11639 printf (" 0 %-10lu (%5.1f%%)\n",
11640 counts
[0], (counts
[0] * 100.0) / nbuckets
);
11641 for (i
= 1; i
<= maxlength
; ++i
)
11643 nzero_counts
+= counts
[i
] * i
;
11644 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11645 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
11646 (nzero_counts
* 100.0) / nsyms
);
11654 if (buckets
!= NULL
)
11660 if (do_histogram
&& gnubuckets
!= NULL
)
11662 unsigned long * lengths
;
11663 unsigned long * counts
;
11665 unsigned long maxlength
= 0;
11666 unsigned long nzero_counts
= 0;
11667 unsigned long nsyms
= 0;
11669 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
11670 (unsigned long) ngnubuckets
);
11672 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
11673 if (lengths
== NULL
)
11675 error (_("Out of memory allocating space for gnu histogram buckets\n"));
11679 printf (_(" Length Number %% of total Coverage\n"));
11681 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11682 if (gnubuckets
[hn
] != 0)
11684 bfd_vma off
, length
= 1;
11686 for (off
= gnubuckets
[hn
] - gnusymidx
;
11687 /* PR 17531 file: 010-77222-0.004. */
11688 off
< ngnuchains
&& (gnuchains
[off
] & 1) == 0;
11691 lengths
[hn
] = length
;
11692 if (length
> maxlength
)
11693 maxlength
= length
;
11697 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
11698 if (counts
== NULL
)
11701 error (_("Out of memory allocating space for gnu histogram counts\n"));
11705 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11706 ++counts
[lengths
[hn
]];
11708 if (ngnubuckets
> 0)
11711 printf (" 0 %-10lu (%5.1f%%)\n",
11712 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
11713 for (j
= 1; j
<= maxlength
; ++j
)
11715 nzero_counts
+= counts
[j
] * j
;
11716 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11717 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
11718 (nzero_counts
* 100.0) / nsyms
);
11732 process_syminfo (FILE * file ATTRIBUTE_UNUSED
)
11736 if (dynamic_syminfo
== NULL
11738 /* No syminfo, this is ok. */
11741 /* There better should be a dynamic symbol section. */
11742 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
11746 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
11747 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
11749 printf (_(" Num: Name BoundTo Flags\n"));
11750 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
11752 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
11754 printf ("%4d: ", i
);
11755 if (i
>= num_dynamic_syms
)
11756 printf (_("<corrupt index>"));
11757 else if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
11758 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
11760 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
11763 switch (dynamic_syminfo
[i
].si_boundto
)
11765 case SYMINFO_BT_SELF
:
11766 fputs ("SELF ", stdout
);
11768 case SYMINFO_BT_PARENT
:
11769 fputs ("PARENT ", stdout
);
11772 if (dynamic_syminfo
[i
].si_boundto
> 0
11773 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
11774 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
11776 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
11780 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
11784 if (flags
& SYMINFO_FLG_DIRECT
)
11785 printf (" DIRECT");
11786 if (flags
& SYMINFO_FLG_PASSTHRU
)
11787 printf (" PASSTHRU");
11788 if (flags
& SYMINFO_FLG_COPY
)
11790 if (flags
& SYMINFO_FLG_LAZYLOAD
)
11791 printf (" LAZYLOAD");
11799 #define IN_RANGE(START,END,ADDR,OFF) \
11800 (((ADDR) >= (START)) && ((ADDR) + (OFF) < (END)))
11802 /* Check to see if the given reloc needs to be handled in a target specific
11803 manner. If so then process the reloc and return TRUE otherwise return
11806 If called with reloc == NULL, then this is a signal that reloc processing
11807 for the current section has finished, and any saved state should be
11811 target_specific_reloc_handling (Elf_Internal_Rela
* reloc
,
11812 unsigned char * start
,
11813 unsigned char * end
,
11814 Elf_Internal_Sym
* symtab
,
11815 unsigned long num_syms
)
11817 unsigned int reloc_type
= 0;
11818 unsigned long sym_index
= 0;
11822 reloc_type
= get_reloc_type (reloc
->r_info
);
11823 sym_index
= get_reloc_symindex (reloc
->r_info
);
11826 switch (elf_header
.e_machine
)
11829 case EM_MSP430_OLD
:
11831 static Elf_Internal_Sym
* saved_sym
= NULL
;
11839 switch (reloc_type
)
11841 case 10: /* R_MSP430_SYM_DIFF */
11842 if (uses_msp430x_relocs ())
11844 /* Fall through. */
11845 case 21: /* R_MSP430X_SYM_DIFF */
11847 if (sym_index
>= num_syms
)
11848 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
11851 saved_sym
= symtab
+ sym_index
;
11854 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
11855 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
11856 goto handle_sym_diff
;
11858 case 5: /* R_MSP430_16_BYTE */
11859 case 9: /* R_MSP430_8 */
11860 if (uses_msp430x_relocs ())
11862 goto handle_sym_diff
;
11864 case 2: /* R_MSP430_ABS16 */
11865 case 15: /* R_MSP430X_ABS16 */
11866 if (! uses_msp430x_relocs ())
11868 goto handle_sym_diff
;
11871 if (saved_sym
!= NULL
)
11873 int reloc_size
= reloc_type
== 1 ? 4 : 2;
11876 if (sym_index
>= num_syms
)
11877 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
11881 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
11882 - saved_sym
->st_value
);
11884 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
11885 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
11888 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
11889 (long) reloc
->r_offset
);
11898 if (saved_sym
!= NULL
)
11899 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
11906 case EM_CYGNUS_MN10300
:
11908 static Elf_Internal_Sym
* saved_sym
= NULL
;
11916 switch (reloc_type
)
11918 case 34: /* R_MN10300_ALIGN */
11920 case 33: /* R_MN10300_SYM_DIFF */
11921 if (sym_index
>= num_syms
)
11922 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
11925 saved_sym
= symtab
+ sym_index
;
11928 case 1: /* R_MN10300_32 */
11929 case 2: /* R_MN10300_16 */
11930 if (saved_sym
!= NULL
)
11932 int reloc_size
= reloc_type
== 1 ? 4 : 2;
11935 if (sym_index
>= num_syms
)
11936 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
11940 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
11941 - saved_sym
->st_value
);
11943 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
11944 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
11946 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
11947 (long) reloc
->r_offset
);
11955 if (saved_sym
!= NULL
)
11956 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
11964 static bfd_vma saved_sym1
= 0;
11965 static bfd_vma saved_sym2
= 0;
11966 static bfd_vma value
;
11970 saved_sym1
= saved_sym2
= 0;
11974 switch (reloc_type
)
11976 case 0x80: /* R_RL78_SYM. */
11977 saved_sym1
= saved_sym2
;
11978 if (sym_index
>= num_syms
)
11979 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
11983 saved_sym2
= symtab
[sym_index
].st_value
;
11984 saved_sym2
+= reloc
->r_addend
;
11988 case 0x83: /* R_RL78_OPsub. */
11989 value
= saved_sym1
- saved_sym2
;
11990 saved_sym2
= saved_sym1
= 0;
11994 case 0x41: /* R_RL78_ABS32. */
11995 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 4))
11996 byte_put (start
+ reloc
->r_offset
, value
, 4);
11998 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
11999 (long) reloc
->r_offset
);
12003 case 0x43: /* R_RL78_ABS16. */
12004 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 2))
12005 byte_put (start
+ reloc
->r_offset
, value
, 2);
12007 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12008 (long) reloc
->r_offset
);
12022 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12023 DWARF debug sections. This is a target specific test. Note - we do not
12024 go through the whole including-target-headers-multiple-times route, (as
12025 we have already done with <elf/h8.h>) because this would become very
12026 messy and even then this function would have to contain target specific
12027 information (the names of the relocs instead of their numeric values).
12028 FIXME: This is not the correct way to solve this problem. The proper way
12029 is to have target specific reloc sizing and typing functions created by
12030 the reloc-macros.h header, in the same way that it already creates the
12031 reloc naming functions. */
12034 is_32bit_abs_reloc (unsigned int reloc_type
)
12036 /* Please keep this table alpha-sorted for ease of visual lookup. */
12037 switch (elf_header
.e_machine
)
12041 return reloc_type
== 1; /* R_386_32. */
12043 return reloc_type
== 1; /* R_68K_32. */
12045 return reloc_type
== 1; /* R_860_32. */
12047 return reloc_type
== 2; /* R_960_32. */
12049 return (reloc_type
== 258
12050 || reloc_type
== 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12051 case EM_ADAPTEVA_EPIPHANY
:
12052 return reloc_type
== 3;
12054 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
12056 return reloc_type
== 1; /* R_ARC_32. */
12057 case EM_ARC_COMPACT
:
12058 case EM_ARC_COMPACT2
:
12059 return reloc_type
== 4; /* R_ARC_32. */
12061 return reloc_type
== 2; /* R_ARM_ABS32 */
12064 return reloc_type
== 1;
12066 return reloc_type
== 0x12; /* R_byte4_data. */
12068 return reloc_type
== 3; /* R_CRIS_32. */
12070 return reloc_type
== 3; /* R_CR16_NUM32. */
12072 return reloc_type
== 15; /* R_CRX_NUM32. */
12073 case EM_CYGNUS_FRV
:
12074 return reloc_type
== 1;
12075 case EM_CYGNUS_D10V
:
12077 return reloc_type
== 6; /* R_D10V_32. */
12078 case EM_CYGNUS_D30V
:
12080 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
12082 return reloc_type
== 3; /* R_DLX_RELOC_32. */
12083 case EM_CYGNUS_FR30
:
12085 return reloc_type
== 3; /* R_FR30_32. */
12087 return reloc_type
== 1; /* R_FT32_32. */
12091 return reloc_type
== 1; /* R_H8_DIR32. */
12093 return (reloc_type
== 0x64 /* R_IA64_SECREL32MSB. */
12094 || reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
12095 || reloc_type
== 0x24 /* R_IA64_DIR32MSB. */
12096 || reloc_type
== 0x25 /* R_IA64_DIR32LSB. */);
12099 return reloc_type
== 2; /* R_IP2K_32. */
12101 return reloc_type
== 2; /* R_IQ2000_32. */
12102 case EM_LATTICEMICO32
:
12103 return reloc_type
== 3; /* R_LM32_32. */
12106 return reloc_type
== 3; /* R_M32C_32. */
12108 return reloc_type
== 34; /* R_M32R_32_RELA. */
12111 return reloc_type
== 6; /* R_M68HC11_32. */
12113 return reloc_type
== 1; /* R_MCORE_ADDR32. */
12114 case EM_CYGNUS_MEP
:
12115 return reloc_type
== 4; /* R_MEP_32. */
12117 return reloc_type
== 2; /* R_METAG_ADDR32. */
12118 case EM_MICROBLAZE
:
12119 return reloc_type
== 1; /* R_MICROBLAZE_32. */
12121 return reloc_type
== 2; /* R_MIPS_32. */
12123 return reloc_type
== 4; /* R_MMIX_32. */
12124 case EM_CYGNUS_MN10200
:
12126 return reloc_type
== 1; /* R_MN10200_32. */
12127 case EM_CYGNUS_MN10300
:
12129 return reloc_type
== 1; /* R_MN10300_32. */
12131 return reloc_type
== 1; /* R_MOXIE_32. */
12132 case EM_MSP430_OLD
:
12134 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
12136 return reloc_type
== 2; /* R_MT_32. */
12138 return reloc_type
== 20; /* R_NDS32_RELA. */
12139 case EM_ALTERA_NIOS2
:
12140 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
12142 return reloc_type
== 1; /* R_NIOS_32. */
12144 return reloc_type
== 1; /* R_OR1K_32. */
12146 return (reloc_type
== 1 /* R_PARISC_DIR32. */
12147 || reloc_type
== 41); /* R_PARISC_SECREL32. */
12150 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
12152 return reloc_type
== 1; /* R_PPC64_ADDR32. */
12154 return reloc_type
== 1; /* R_PPC_ADDR32. */
12156 return reloc_type
== 11; /* R_PRU_BFD_RELOC_32. */
12158 return reloc_type
== 1; /* R_RISCV_32. */
12160 return reloc_type
== 1; /* R_RL78_DIR32. */
12162 return reloc_type
== 1; /* R_RX_DIR32. */
12164 return reloc_type
== 1; /* R_I370_ADDR31. */
12167 return reloc_type
== 4; /* R_S390_32. */
12169 return reloc_type
== 8; /* R_SCORE_ABS32. */
12171 return reloc_type
== 1; /* R_SH_DIR32. */
12172 case EM_SPARC32PLUS
:
12175 return reloc_type
== 3 /* R_SPARC_32. */
12176 || reloc_type
== 23; /* R_SPARC_UA32. */
12178 return reloc_type
== 6; /* R_SPU_ADDR32 */
12180 return reloc_type
== 1; /* R_C6000_ABS32. */
12182 return reloc_type
== 2; /* R_TILEGX_32. */
12184 return reloc_type
== 1; /* R_TILEPRO_32. */
12185 case EM_CYGNUS_V850
:
12187 return reloc_type
== 6; /* R_V850_ABS32. */
12189 return reloc_type
== 0x33; /* R_V810_WORD. */
12191 return reloc_type
== 1; /* R_VAX_32. */
12193 return reloc_type
== 3; /* R_VISIUM_32. */
12194 case EM_WEBASSEMBLY
:
12195 return reloc_type
== 1; /* R_WASM32_32. */
12199 return reloc_type
== 10; /* R_X86_64_32. */
12202 return reloc_type
== 3; /* R_XC16C_ABS_32. */
12204 return reloc_type
== 4; /* R_XGATE_32. */
12206 return reloc_type
== 1; /* R_XSTROMY16_32. */
12207 case EM_XTENSA_OLD
:
12209 return reloc_type
== 1; /* R_XTENSA_32. */
12212 static unsigned int prev_warn
= 0;
12214 /* Avoid repeating the same warning multiple times. */
12215 if (prev_warn
!= elf_header
.e_machine
)
12216 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12217 elf_header
.e_machine
);
12218 prev_warn
= elf_header
.e_machine
;
12224 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12225 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
12228 is_32bit_pcrel_reloc (unsigned int reloc_type
)
12230 switch (elf_header
.e_machine
)
12231 /* Please keep this table alpha-sorted for ease of visual lookup. */
12235 return reloc_type
== 2; /* R_386_PC32. */
12237 return reloc_type
== 4; /* R_68K_PC32. */
12239 return reloc_type
== 261; /* R_AARCH64_PREL32 */
12240 case EM_ADAPTEVA_EPIPHANY
:
12241 return reloc_type
== 6;
12243 return reloc_type
== 10; /* R_ALPHA_SREL32. */
12244 case EM_ARC_COMPACT
:
12245 case EM_ARC_COMPACT2
:
12246 return reloc_type
== 49; /* R_ARC_32_PCREL. */
12248 return reloc_type
== 3; /* R_ARM_REL32 */
12251 return reloc_type
== 36; /* R_AVR_32_PCREL. */
12252 case EM_MICROBLAZE
:
12253 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
12255 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
12257 return reloc_type
== 9; /* R_PARISC_PCREL32. */
12259 return reloc_type
== 26; /* R_PPC_REL32. */
12261 return reloc_type
== 26; /* R_PPC64_REL32. */
12264 return reloc_type
== 5; /* R_390_PC32. */
12266 return reloc_type
== 2; /* R_SH_REL32. */
12267 case EM_SPARC32PLUS
:
12270 return reloc_type
== 6; /* R_SPARC_DISP32. */
12272 return reloc_type
== 13; /* R_SPU_REL32. */
12274 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
12276 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
12278 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
12282 return reloc_type
== 2; /* R_X86_64_PC32. */
12283 case EM_XTENSA_OLD
:
12285 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
12287 /* Do not abort or issue an error message here. Not all targets use
12288 pc-relative 32-bit relocs in their DWARF debug information and we
12289 have already tested for target coverage in is_32bit_abs_reloc. A
12290 more helpful warning message will be generated by apply_relocations
12291 anyway, so just return. */
12296 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12297 a 64-bit absolute RELA relocation used in DWARF debug sections. */
12300 is_64bit_abs_reloc (unsigned int reloc_type
)
12302 switch (elf_header
.e_machine
)
12305 return reloc_type
== 257; /* R_AARCH64_ABS64. */
12307 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
12309 return (reloc_type
== 0x26 /* R_IA64_DIR64MSB. */
12310 || reloc_type
== 0x27 /* R_IA64_DIR64LSB. */);
12312 return reloc_type
== 80; /* R_PARISC_DIR64. */
12314 return reloc_type
== 38; /* R_PPC64_ADDR64. */
12316 return reloc_type
== 2; /* R_RISCV_64. */
12317 case EM_SPARC32PLUS
:
12320 return reloc_type
== 32 /* R_SPARC_64. */
12321 || reloc_type
== 54; /* R_SPARC_UA64. */
12325 return reloc_type
== 1; /* R_X86_64_64. */
12328 return reloc_type
== 22; /* R_S390_64. */
12330 return reloc_type
== 1; /* R_TILEGX_64. */
12332 return reloc_type
== 18; /* R_MIPS_64. */
12338 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12339 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
12342 is_64bit_pcrel_reloc (unsigned int reloc_type
)
12344 switch (elf_header
.e_machine
)
12347 return reloc_type
== 260; /* R_AARCH64_PREL64. */
12349 return reloc_type
== 11; /* R_ALPHA_SREL64. */
12351 return (reloc_type
== 0x4e /* R_IA64_PCREL64MSB. */
12352 || reloc_type
== 0x4f /* R_IA64_PCREL64LSB. */);
12354 return reloc_type
== 72; /* R_PARISC_PCREL64. */
12356 return reloc_type
== 44; /* R_PPC64_REL64. */
12357 case EM_SPARC32PLUS
:
12360 return reloc_type
== 46; /* R_SPARC_DISP64. */
12364 return reloc_type
== 24; /* R_X86_64_PC64. */
12367 return reloc_type
== 23; /* R_S390_PC64. */
12369 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
12375 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12376 a 24-bit absolute RELA relocation used in DWARF debug sections. */
12379 is_24bit_abs_reloc (unsigned int reloc_type
)
12381 switch (elf_header
.e_machine
)
12383 case EM_CYGNUS_MN10200
:
12385 return reloc_type
== 4; /* R_MN10200_24. */
12387 return reloc_type
== 5; /* R_FT32_20. */
12393 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12394 a 16-bit absolute RELA relocation used in DWARF debug sections. */
12397 is_16bit_abs_reloc (unsigned int reloc_type
)
12399 /* Please keep this table alpha-sorted for ease of visual lookup. */
12400 switch (elf_header
.e_machine
)
12403 case EM_ARC_COMPACT
:
12404 case EM_ARC_COMPACT2
:
12405 return reloc_type
== 2; /* R_ARC_16. */
12406 case EM_ADAPTEVA_EPIPHANY
:
12407 return reloc_type
== 5;
12410 return reloc_type
== 4; /* R_AVR_16. */
12411 case EM_CYGNUS_D10V
:
12413 return reloc_type
== 3; /* R_D10V_16. */
12417 return reloc_type
== R_H8_DIR16
;
12420 return reloc_type
== 1; /* R_IP2K_16. */
12423 return reloc_type
== 1; /* R_M32C_16 */
12424 case EM_CYGNUS_MN10200
:
12426 return reloc_type
== 2; /* R_MN10200_16. */
12427 case EM_CYGNUS_MN10300
:
12429 return reloc_type
== 2; /* R_MN10300_16. */
12431 if (uses_msp430x_relocs ())
12432 return reloc_type
== 2; /* R_MSP430_ABS16. */
12433 /* Fall through. */
12434 case EM_MSP430_OLD
:
12435 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
12437 return reloc_type
== 19; /* R_NDS32_RELA. */
12438 case EM_ALTERA_NIOS2
:
12439 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
12441 return reloc_type
== 9; /* R_NIOS_16. */
12443 return reloc_type
== 2; /* R_OR1K_16. */
12445 return reloc_type
== 8; /* R_PRU_BFD_RELOC_16. */
12447 return reloc_type
== 2; /* R_C6000_ABS16. */
12449 return reloc_type
== 2; /* R_VISIUM_16. */
12452 return reloc_type
== 2; /* R_XC16C_ABS_16. */
12454 return reloc_type
== 3; /* R_XGATE_16. */
12460 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
12461 relocation entries (possibly formerly used for SHT_GROUP sections). */
12464 is_none_reloc (unsigned int reloc_type
)
12466 switch (elf_header
.e_machine
)
12468 case EM_386
: /* R_386_NONE. */
12469 case EM_68K
: /* R_68K_NONE. */
12470 case EM_ADAPTEVA_EPIPHANY
:
12471 case EM_ALPHA
: /* R_ALPHA_NONE. */
12472 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
12473 case EM_ARC
: /* R_ARC_NONE. */
12474 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
12475 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
12476 case EM_ARM
: /* R_ARM_NONE. */
12477 case EM_C166
: /* R_XC16X_NONE. */
12478 case EM_CRIS
: /* R_CRIS_NONE. */
12479 case EM_FT32
: /* R_FT32_NONE. */
12480 case EM_IA_64
: /* R_IA64_NONE. */
12481 case EM_K1OM
: /* R_X86_64_NONE. */
12482 case EM_L1OM
: /* R_X86_64_NONE. */
12483 case EM_M32R
: /* R_M32R_NONE. */
12484 case EM_MIPS
: /* R_MIPS_NONE. */
12485 case EM_MN10300
: /* R_MN10300_NONE. */
12486 case EM_MOXIE
: /* R_MOXIE_NONE. */
12487 case EM_NIOS32
: /* R_NIOS_NONE. */
12488 case EM_OR1K
: /* R_OR1K_NONE. */
12489 case EM_PARISC
: /* R_PARISC_NONE. */
12490 case EM_PPC64
: /* R_PPC64_NONE. */
12491 case EM_PPC
: /* R_PPC_NONE. */
12492 case EM_RISCV
: /* R_RISCV_NONE. */
12493 case EM_S390
: /* R_390_NONE. */
12495 case EM_SH
: /* R_SH_NONE. */
12496 case EM_SPARC32PLUS
:
12497 case EM_SPARC
: /* R_SPARC_NONE. */
12499 case EM_TILEGX
: /* R_TILEGX_NONE. */
12500 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
12501 case EM_TI_C6000
:/* R_C6000_NONE. */
12502 case EM_X86_64
: /* R_X86_64_NONE. */
12504 case EM_WEBASSEMBLY
: /* R_WASM32_NONE. */
12505 return reloc_type
== 0;
12508 return reloc_type
== 0 || reloc_type
== 256;
12511 return (reloc_type
== 0 /* R_AVR_NONE. */
12512 || reloc_type
== 30 /* R_AVR_DIFF8. */
12513 || reloc_type
== 31 /* R_AVR_DIFF16. */
12514 || reloc_type
== 32 /* R_AVR_DIFF32. */);
12516 return reloc_type
== 3; /* R_METAG_NONE. */
12518 return (reloc_type
== 0 /* R_XTENSA_NONE. */
12519 || reloc_type
== 204 /* R_NDS32_DIFF8. */
12520 || reloc_type
== 205 /* R_NDS32_DIFF16. */
12521 || reloc_type
== 206 /* R_NDS32_DIFF32. */
12522 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
12524 return (reloc_type
== 0 /* R_PRU_NONE. */
12525 || reloc_type
== 65 /* R_PRU_DIFF8. */
12526 || reloc_type
== 66 /* R_PRU_DIFF16. */
12527 || reloc_type
== 67 /* R_PRU_DIFF32. */);
12528 case EM_XTENSA_OLD
:
12530 return (reloc_type
== 0 /* R_XTENSA_NONE. */
12531 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
12532 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
12533 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
12538 /* Returns TRUE if there is a relocation against
12539 section NAME at OFFSET bytes. */
12542 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
12544 Elf_Internal_Rela
* relocs
;
12545 Elf_Internal_Rela
* rp
;
12547 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
12550 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
12552 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
12553 if (rp
->r_offset
== offset
)
12559 /* Apply relocations to a section.
12560 Returns TRUE upon success, FALSE otherwise.
12561 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
12562 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
12563 will be set to the number of relocs loaded.
12565 Note: So far support has been added only for those relocations
12566 which can be found in debug sections. FIXME: Add support for
12567 more relocations ? */
12570 apply_relocations (void * file
,
12571 const Elf_Internal_Shdr
* section
,
12572 unsigned char * start
,
12573 bfd_size_type size
,
12574 void ** relocs_return
,
12575 unsigned long * num_relocs_return
)
12577 Elf_Internal_Shdr
* relsec
;
12578 unsigned char * end
= start
+ size
;
12579 bfd_boolean res
= TRUE
;
12581 if (relocs_return
!= NULL
)
12583 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
12584 * num_relocs_return
= 0;
12587 if (elf_header
.e_type
!= ET_REL
)
12588 /* No relocs to apply. */
12591 /* Find the reloc section associated with the section. */
12592 for (relsec
= section_headers
;
12593 relsec
< section_headers
+ elf_header
.e_shnum
;
12596 bfd_boolean is_rela
;
12597 unsigned long num_relocs
;
12598 Elf_Internal_Rela
* relocs
;
12599 Elf_Internal_Rela
* rp
;
12600 Elf_Internal_Shdr
* symsec
;
12601 Elf_Internal_Sym
* symtab
;
12602 unsigned long num_syms
;
12603 Elf_Internal_Sym
* sym
;
12605 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
12606 || relsec
->sh_info
>= elf_header
.e_shnum
12607 || section_headers
+ relsec
->sh_info
!= section
12608 || relsec
->sh_size
== 0
12609 || relsec
->sh_link
>= elf_header
.e_shnum
)
12612 is_rela
= relsec
->sh_type
== SHT_RELA
;
12616 if (!slurp_rela_relocs ((FILE *) file
, relsec
->sh_offset
,
12617 relsec
->sh_size
, & relocs
, & num_relocs
))
12622 if (!slurp_rel_relocs ((FILE *) file
, relsec
->sh_offset
,
12623 relsec
->sh_size
, & relocs
, & num_relocs
))
12627 /* SH uses RELA but uses in place value instead of the addend field. */
12628 if (elf_header
.e_machine
== EM_SH
)
12631 symsec
= section_headers
+ relsec
->sh_link
;
12632 if (symsec
->sh_type
!= SHT_SYMTAB
12633 && symsec
->sh_type
!= SHT_DYNSYM
)
12635 symtab
= GET_ELF_SYMBOLS ((FILE *) file
, symsec
, & num_syms
);
12637 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
12640 unsigned int reloc_type
;
12641 unsigned int reloc_size
;
12642 unsigned char * rloc
;
12643 unsigned long sym_index
;
12645 reloc_type
= get_reloc_type (rp
->r_info
);
12647 if (target_specific_reloc_handling (rp
, start
, end
, symtab
, num_syms
))
12649 else if (is_none_reloc (reloc_type
))
12651 else if (is_32bit_abs_reloc (reloc_type
)
12652 || is_32bit_pcrel_reloc (reloc_type
))
12654 else if (is_64bit_abs_reloc (reloc_type
)
12655 || is_64bit_pcrel_reloc (reloc_type
))
12657 else if (is_24bit_abs_reloc (reloc_type
))
12659 else if (is_16bit_abs_reloc (reloc_type
))
12663 static unsigned int prev_reloc
= 0;
12664 if (reloc_type
!= prev_reloc
)
12665 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
12666 reloc_type
, printable_section_name (section
));
12667 prev_reloc
= reloc_type
;
12672 rloc
= start
+ rp
->r_offset
;
12673 if ((rloc
+ reloc_size
) > end
|| (rloc
< start
))
12675 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
12676 (unsigned long) rp
->r_offset
,
12677 printable_section_name (section
));
12682 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
12683 if (sym_index
>= num_syms
)
12685 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
12686 sym_index
, printable_section_name (section
));
12690 sym
= symtab
+ sym_index
;
12692 /* If the reloc has a symbol associated with it,
12693 make sure that it is of an appropriate type.
12695 Relocations against symbols without type can happen.
12696 Gcc -feliminate-dwarf2-dups may generate symbols
12697 without type for debug info.
12699 Icc generates relocations against function symbols
12700 instead of local labels.
12702 Relocations against object symbols can happen, eg when
12703 referencing a global array. For an example of this see
12704 the _clz.o binary in libgcc.a. */
12706 && ELF_ST_TYPE (sym
->st_info
) != STT_COMMON
12707 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
12709 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
12710 get_symbol_type (ELF_ST_TYPE (sym
->st_info
)),
12711 (long int)(rp
- relocs
),
12712 printable_section_name (relsec
));
12719 addend
+= rp
->r_addend
;
12720 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
12721 partial_inplace. */
12723 || (elf_header
.e_machine
== EM_XTENSA
12724 && reloc_type
== 1)
12725 || ((elf_header
.e_machine
== EM_PJ
12726 || elf_header
.e_machine
== EM_PJ_OLD
)
12727 && reloc_type
== 1)
12728 || ((elf_header
.e_machine
== EM_D30V
12729 || elf_header
.e_machine
== EM_CYGNUS_D30V
)
12730 && reloc_type
== 12))
12731 addend
+= byte_get (rloc
, reloc_size
);
12733 if (is_32bit_pcrel_reloc (reloc_type
)
12734 || is_64bit_pcrel_reloc (reloc_type
))
12736 /* On HPPA, all pc-relative relocations are biased by 8. */
12737 if (elf_header
.e_machine
== EM_PARISC
)
12739 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
12743 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
12747 /* Let the target specific reloc processing code know that
12748 we have finished with these relocs. */
12749 target_specific_reloc_handling (NULL
, NULL
, NULL
, NULL
, 0);
12753 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
12754 * num_relocs_return
= num_relocs
;
12765 #ifdef SUPPORT_DISASSEMBLY
12767 disassemble_section (Elf_Internal_Shdr
* section
, FILE * file
)
12769 printf (_("\nAssembly dump of section %s\n"), printable_section_name (section
));
12771 /* FIXME: XXX -- to be done --- XXX */
12777 /* Reads in the contents of SECTION from FILE, returning a pointer
12778 to a malloc'ed buffer or NULL if something went wrong. */
12781 get_section_contents (Elf_Internal_Shdr
* section
, FILE * file
)
12783 bfd_size_type num_bytes
;
12785 num_bytes
= section
->sh_size
;
12787 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
12789 printf (_("Section '%s' has no data to dump.\n"),
12790 printable_section_name (section
));
12794 return (char *) get_data (NULL
, file
, section
->sh_offset
, 1, num_bytes
,
12795 _("section contents"));
12798 /* Uncompresses a section that was compressed using zlib, in place. */
12801 uncompress_section_contents (unsigned char **buffer
,
12802 dwarf_size_type uncompressed_size
,
12803 dwarf_size_type
*size
)
12805 dwarf_size_type compressed_size
= *size
;
12806 unsigned char * compressed_buffer
= *buffer
;
12807 unsigned char * uncompressed_buffer
;
12811 /* It is possible the section consists of several compressed
12812 buffers concatenated together, so we uncompress in a loop. */
12813 /* PR 18313: The state field in the z_stream structure is supposed
12814 to be invisible to the user (ie us), but some compilers will
12815 still complain about it being used without initialisation. So
12816 we first zero the entire z_stream structure and then set the fields
12818 memset (& strm
, 0, sizeof strm
);
12819 strm
.avail_in
= compressed_size
;
12820 strm
.next_in
= (Bytef
*) compressed_buffer
;
12821 strm
.avail_out
= uncompressed_size
;
12822 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
12824 rc
= inflateInit (& strm
);
12825 while (strm
.avail_in
> 0)
12829 strm
.next_out
= ((Bytef
*) uncompressed_buffer
12830 + (uncompressed_size
- strm
.avail_out
));
12831 rc
= inflate (&strm
, Z_FINISH
);
12832 if (rc
!= Z_STREAM_END
)
12834 rc
= inflateReset (& strm
);
12836 rc
= inflateEnd (& strm
);
12838 || strm
.avail_out
!= 0)
12841 *buffer
= uncompressed_buffer
;
12842 *size
= uncompressed_size
;
12846 free (uncompressed_buffer
);
12847 /* Indicate decompression failure. */
12853 dump_section_as_strings (Elf_Internal_Shdr
* section
, FILE * file
)
12855 Elf_Internal_Shdr
* relsec
;
12856 bfd_size_type num_bytes
;
12857 unsigned char * data
;
12858 unsigned char * end
;
12859 unsigned char * real_start
;
12860 unsigned char * start
;
12861 bfd_boolean some_strings_shown
;
12863 real_start
= start
= (unsigned char *) get_section_contents (section
, file
);
12865 /* PR 21820: Do not fail if the section was empty. */
12866 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
12868 num_bytes
= section
->sh_size
;
12870 printf (_("\nString dump of section '%s':\n"), printable_section_name (section
));
12872 if (decompress_dumps
)
12874 dwarf_size_type new_size
= num_bytes
;
12875 dwarf_size_type uncompressed_size
= 0;
12877 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
12879 Elf_Internal_Chdr chdr
;
12880 unsigned int compression_header_size
12881 = get_compression_header (& chdr
, (unsigned char *) start
,
12884 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
12886 warn (_("section '%s' has unsupported compress type: %d\n"),
12887 printable_section_name (section
), chdr
.ch_type
);
12890 else if (chdr
.ch_addralign
!= section
->sh_addralign
)
12892 warn (_("compressed section '%s' is corrupted\n"),
12893 printable_section_name (section
));
12896 uncompressed_size
= chdr
.ch_size
;
12897 start
+= compression_header_size
;
12898 new_size
-= compression_header_size
;
12900 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
12902 /* Read the zlib header. In this case, it should be "ZLIB"
12903 followed by the uncompressed section size, 8 bytes in
12904 big-endian order. */
12905 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
12906 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
12907 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
12908 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
12909 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
12910 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
12911 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
12912 uncompressed_size
+= start
[11];
12917 if (uncompressed_size
)
12919 if (uncompress_section_contents (& start
,
12920 uncompressed_size
, & new_size
))
12921 num_bytes
= new_size
;
12924 error (_("Unable to decompress section %s\n"),
12925 printable_section_name (section
));
12930 start
= real_start
;
12933 /* If the section being dumped has relocations against it the user might
12934 be expecting these relocations to have been applied. Check for this
12935 case and issue a warning message in order to avoid confusion.
12936 FIXME: Maybe we ought to have an option that dumps a section with
12937 relocs applied ? */
12938 for (relsec
= section_headers
;
12939 relsec
< section_headers
+ elf_header
.e_shnum
;
12942 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
12943 || relsec
->sh_info
>= elf_header
.e_shnum
12944 || section_headers
+ relsec
->sh_info
!= section
12945 || relsec
->sh_size
== 0
12946 || relsec
->sh_link
>= elf_header
.e_shnum
)
12949 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12954 end
= start
+ num_bytes
;
12955 some_strings_shown
= FALSE
;
12959 while (!ISPRINT (* data
))
12960 if (++ data
>= end
)
12965 size_t maxlen
= end
- data
;
12968 /* PR 11128: Use two separate invocations in order to work
12969 around bugs in the Solaris 8 implementation of printf. */
12970 printf (" [%6tx] ", data
- start
);
12972 printf (" [%6Ix] ", (size_t) (data
- start
));
12976 print_symbol ((int) maxlen
, (const char *) data
);
12978 data
+= strnlen ((const char *) data
, maxlen
);
12982 printf (_("<corrupt>\n"));
12985 some_strings_shown
= TRUE
;
12989 if (! some_strings_shown
)
12990 printf (_(" No strings found in this section."));
12999 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
13001 bfd_boolean relocate
)
13003 Elf_Internal_Shdr
* relsec
;
13004 bfd_size_type bytes
;
13005 bfd_size_type section_size
;
13007 unsigned char * data
;
13008 unsigned char * real_start
;
13009 unsigned char * start
;
13011 real_start
= start
= (unsigned char *) get_section_contents (section
, file
);
13013 /* PR 21820: Do not fail if the section was empty. */
13014 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
13016 section_size
= section
->sh_size
;
13018 printf (_("\nHex dump of section '%s':\n"), printable_section_name (section
));
13020 if (decompress_dumps
)
13022 dwarf_size_type new_size
= section_size
;
13023 dwarf_size_type uncompressed_size
= 0;
13025 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
13027 Elf_Internal_Chdr chdr
;
13028 unsigned int compression_header_size
13029 = get_compression_header (& chdr
, start
, section_size
);
13031 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13033 warn (_("section '%s' has unsupported compress type: %d\n"),
13034 printable_section_name (section
), chdr
.ch_type
);
13037 else if (chdr
.ch_addralign
!= section
->sh_addralign
)
13039 warn (_("compressed section '%s' is corrupted\n"),
13040 printable_section_name (section
));
13043 uncompressed_size
= chdr
.ch_size
;
13044 start
+= compression_header_size
;
13045 new_size
-= compression_header_size
;
13047 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
13049 /* Read the zlib header. In this case, it should be "ZLIB"
13050 followed by the uncompressed section size, 8 bytes in
13051 big-endian order. */
13052 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13053 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13054 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13055 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13056 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13057 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13058 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13059 uncompressed_size
+= start
[11];
13064 if (uncompressed_size
)
13066 if (uncompress_section_contents (& start
, uncompressed_size
,
13069 section_size
= new_size
;
13073 error (_("Unable to decompress section %s\n"),
13074 printable_section_name (section
));
13075 /* FIXME: Print the section anyway ? */
13080 start
= real_start
;
13085 if (! apply_relocations (file
, section
, start
, section_size
, NULL
, NULL
))
13090 /* If the section being dumped has relocations against it the user might
13091 be expecting these relocations to have been applied. Check for this
13092 case and issue a warning message in order to avoid confusion.
13093 FIXME: Maybe we ought to have an option that dumps a section with
13094 relocs applied ? */
13095 for (relsec
= section_headers
;
13096 relsec
< section_headers
+ elf_header
.e_shnum
;
13099 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13100 || relsec
->sh_info
>= elf_header
.e_shnum
13101 || section_headers
+ relsec
->sh_info
!= section
13102 || relsec
->sh_size
== 0
13103 || relsec
->sh_link
>= elf_header
.e_shnum
)
13106 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13111 addr
= section
->sh_addr
;
13112 bytes
= section_size
;
13121 lbytes
= (bytes
> 16 ? 16 : bytes
);
13123 printf (" 0x%8.8lx ", (unsigned long) addr
);
13125 for (j
= 0; j
< 16; j
++)
13128 printf ("%2.2x", data
[j
]);
13136 for (j
= 0; j
< lbytes
; j
++)
13139 if (k
>= ' ' && k
< 0x7f)
13159 load_specific_debug_section (enum dwarf_section_display_enum debug
,
13160 const Elf_Internal_Shdr
* sec
, void * file
)
13162 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13165 /* If it is already loaded, do nothing. */
13166 if (section
->start
!= NULL
)
13169 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
13170 section
->address
= sec
->sh_addr
;
13171 section
->user_data
= NULL
;
13172 section
->start
= (unsigned char *) get_data (NULL
, (FILE *) file
,
13174 sec
->sh_size
, buf
);
13175 if (section
->start
== NULL
)
13179 unsigned char *start
= section
->start
;
13180 dwarf_size_type size
= sec
->sh_size
;
13181 dwarf_size_type uncompressed_size
= 0;
13183 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
13185 Elf_Internal_Chdr chdr
;
13186 unsigned int compression_header_size
;
13188 if (size
< (is_32bit_elf
13189 ? sizeof (Elf32_External_Chdr
)
13190 : sizeof (Elf64_External_Chdr
)))
13192 warn (_("compressed section %s is too small to contain a compression header"),
13197 compression_header_size
= get_compression_header (&chdr
, start
, size
);
13199 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13201 warn (_("section '%s' has unsupported compress type: %d\n"),
13202 section
->name
, chdr
.ch_type
);
13205 else if (chdr
.ch_addralign
!= sec
->sh_addralign
)
13207 warn (_("compressed section '%s' is corrupted\n"),
13211 uncompressed_size
= chdr
.ch_size
;
13212 start
+= compression_header_size
;
13213 size
-= compression_header_size
;
13215 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
13217 /* Read the zlib header. In this case, it should be "ZLIB"
13218 followed by the uncompressed section size, 8 bytes in
13219 big-endian order. */
13220 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13221 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13222 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13223 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13224 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13225 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13226 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13227 uncompressed_size
+= start
[11];
13232 if (uncompressed_size
)
13234 if (uncompress_section_contents (&start
, uncompressed_size
,
13237 /* Free the compressed buffer, update the section buffer
13238 and the section size if uncompress is successful. */
13239 free (section
->start
);
13240 section
->start
= start
;
13244 error (_("Unable to decompress section %s\n"),
13245 printable_section_name (sec
));
13250 section
->size
= size
;
13253 if (section
->start
== NULL
)
13256 if (debug_displays
[debug
].relocate
)
13258 if (! apply_relocations ((FILE *) file
, sec
, section
->start
, section
->size
,
13259 & section
->reloc_info
, & section
->num_relocs
))
13264 section
->reloc_info
= NULL
;
13265 section
->num_relocs
= 0;
13271 /* If this is not NULL, load_debug_section will only look for sections
13272 within the list of sections given here. */
13273 static unsigned int * section_subset
= NULL
;
13276 load_debug_section (enum dwarf_section_display_enum debug
, void * file
)
13278 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13279 Elf_Internal_Shdr
* sec
;
13281 /* Locate the debug section. */
13282 sec
= find_section_in_set (section
->uncompressed_name
, section_subset
);
13284 section
->name
= section
->uncompressed_name
;
13287 sec
= find_section_in_set (section
->compressed_name
, section_subset
);
13289 section
->name
= section
->compressed_name
;
13294 /* If we're loading from a subset of sections, and we've loaded
13295 a section matching this name before, it's likely that it's a
13297 if (section_subset
!= NULL
)
13298 free_debug_section (debug
);
13300 return load_specific_debug_section (debug
, sec
, (FILE *) file
);
13304 free_debug_section (enum dwarf_section_display_enum debug
)
13306 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13308 if (section
->start
== NULL
)
13311 free ((char *) section
->start
);
13312 section
->start
= NULL
;
13313 section
->address
= 0;
13318 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, FILE * file
)
13320 char * name
= SECTION_NAME (section
);
13321 const char * print_name
= printable_section_name (section
);
13322 bfd_size_type length
;
13323 bfd_boolean result
= TRUE
;
13326 length
= section
->sh_size
;
13329 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
13332 if (section
->sh_type
== SHT_NOBITS
)
13334 /* There is no point in dumping the contents of a debugging section
13335 which has the NOBITS type - the bits in the file will be random.
13336 This can happen when a file containing a .eh_frame section is
13337 stripped with the --only-keep-debug command line option. */
13338 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
13343 if (const_strneq (name
, ".gnu.linkonce.wi."))
13344 name
= ".debug_info";
13346 /* See if we know how to display the contents of this section. */
13347 for (i
= 0; i
< max
; i
++)
13348 if (streq (debug_displays
[i
].section
.uncompressed_name
, name
)
13349 || (i
== line
&& const_strneq (name
, ".debug_line."))
13350 || streq (debug_displays
[i
].section
.compressed_name
, name
))
13352 struct dwarf_section
* sec
= &debug_displays
[i
].section
;
13353 int secondary
= (section
!= find_section (name
));
13356 free_debug_section ((enum dwarf_section_display_enum
) i
);
13358 if (i
== line
&& const_strneq (name
, ".debug_line."))
13360 else if (streq (sec
->uncompressed_name
, name
))
13361 sec
->name
= sec
->uncompressed_name
;
13363 sec
->name
= sec
->compressed_name
;
13364 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
13367 /* If this debug section is part of a CU/TU set in a .dwp file,
13368 restrict load_debug_section to the sections in that set. */
13369 section_subset
= find_cu_tu_set (file
, shndx
);
13371 result
&= debug_displays
[i
].display (sec
, file
);
13373 section_subset
= NULL
;
13375 if (secondary
|| (i
!= info
&& i
!= abbrev
))
13376 free_debug_section ((enum dwarf_section_display_enum
) i
);
13384 printf (_("Unrecognized debug section: %s\n"), print_name
);
13391 /* Set DUMP_SECTS for all sections where dumps were requested
13392 based on section name. */
13395 initialise_dumps_byname (void)
13397 struct dump_list_entry
* cur
;
13399 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
13402 bfd_boolean any
= FALSE
;
13404 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
13405 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
13407 request_dump_bynumber (i
, cur
->type
);
13412 warn (_("Section '%s' was not dumped because it does not exist!\n"),
13418 process_section_contents (FILE * file
)
13420 Elf_Internal_Shdr
* section
;
13422 bfd_boolean res
= TRUE
;
13427 initialise_dumps_byname ();
13429 for (i
= 0, section
= section_headers
;
13430 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
13433 #ifdef SUPPORT_DISASSEMBLY
13434 if (dump_sects
[i
] & DISASS_DUMP
)
13435 disassemble_section (section
, file
);
13437 if (dump_sects
[i
] & HEX_DUMP
)
13439 if (! dump_section_as_bytes (section
, file
, FALSE
))
13443 if (dump_sects
[i
] & RELOC_DUMP
)
13445 if (! dump_section_as_bytes (section
, file
, TRUE
))
13449 if (dump_sects
[i
] & STRING_DUMP
)
13451 if (! dump_section_as_strings (section
, file
))
13455 if (dump_sects
[i
] & DEBUG_DUMP
)
13457 if (! display_debug_section (i
, section
, file
))
13462 /* Check to see if the user requested a
13463 dump of a section that does not exist. */
13464 while (i
< num_dump_sects
)
13468 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
13478 process_mips_fpe_exception (int mask
)
13482 bfd_boolean first
= TRUE
;
13484 if (mask
& OEX_FPU_INEX
)
13485 fputs ("INEX", stdout
), first
= FALSE
;
13486 if (mask
& OEX_FPU_UFLO
)
13487 printf ("%sUFLO", first
? "" : "|"), first
= FALSE
;
13488 if (mask
& OEX_FPU_OFLO
)
13489 printf ("%sOFLO", first
? "" : "|"), first
= FALSE
;
13490 if (mask
& OEX_FPU_DIV0
)
13491 printf ("%sDIV0", first
? "" : "|"), first
= FALSE
;
13492 if (mask
& OEX_FPU_INVAL
)
13493 printf ("%sINVAL", first
? "" : "|");
13496 fputs ("0", stdout
);
13499 /* Display's the value of TAG at location P. If TAG is
13500 greater than 0 it is assumed to be an unknown tag, and
13501 a message is printed to this effect. Otherwise it is
13502 assumed that a message has already been printed.
13504 If the bottom bit of TAG is set it assumed to have a
13505 string value, otherwise it is assumed to have an integer
13508 Returns an updated P pointing to the first unread byte
13509 beyond the end of TAG's value.
13511 Reads at or beyond END will not be made. */
13513 static unsigned char *
13514 display_tag_value (signed int tag
,
13516 const unsigned char * const end
)
13521 printf (" Tag_unknown_%d: ", tag
);
13525 warn (_("<corrupt tag>\n"));
13529 /* PR 17531 file: 027-19978-0.004. */
13530 size_t maxlen
= (end
- p
) - 1;
13535 print_symbol ((int) maxlen
, (const char *) p
);
13536 p
+= strnlen ((char *) p
, maxlen
) + 1;
13540 printf (_("<corrupt string tag>"));
13541 p
= (unsigned char *) end
;
13549 val
= read_uleb128 (p
, &len
, end
);
13551 printf ("%ld (0x%lx)\n", val
, val
);
13558 /* ARC ABI attributes section. */
13560 static unsigned char *
13561 display_arc_attribute (unsigned char * p
,
13562 const unsigned char * const end
)
13568 tag
= read_uleb128 (p
, &len
, end
);
13573 case Tag_ARC_PCS_config
:
13574 val
= read_uleb128 (p
, &len
, end
);
13576 printf (" Tag_ARC_PCS_config: ");
13580 printf (_("Absent/Non standard\n"));
13583 printf (_("Bare metal/mwdt\n"));
13586 printf (_("Bare metal/newlib\n"));
13589 printf (_("Linux/uclibc\n"));
13592 printf (_("Linux/glibc\n"));
13595 printf (_("Unknown\n"));
13600 case Tag_ARC_CPU_base
:
13601 val
= read_uleb128 (p
, &len
, end
);
13603 printf (" Tag_ARC_CPU_base: ");
13608 printf (_("Absent\n"));
13610 case TAG_CPU_ARC6xx
:
13611 printf ("ARC6xx\n");
13613 case TAG_CPU_ARC7xx
:
13614 printf ("ARC7xx\n");
13616 case TAG_CPU_ARCEM
:
13617 printf ("ARCEM\n");
13619 case TAG_CPU_ARCHS
:
13620 printf ("ARCHS\n");
13625 case Tag_ARC_CPU_variation
:
13626 val
= read_uleb128 (p
, &len
, end
);
13628 printf (" Tag_ARC_CPU_variation: ");
13632 if (val
> 0 && val
< 16)
13633 printf ("Core%d\n", val
);
13635 printf ("Unknown\n");
13639 printf (_("Absent\n"));
13644 case Tag_ARC_CPU_name
:
13645 printf (" Tag_ARC_CPU_name: ");
13646 p
= display_tag_value (-1, p
, end
);
13649 case Tag_ARC_ABI_rf16
:
13650 val
= read_uleb128 (p
, &len
, end
);
13652 printf (" Tag_ARC_ABI_rf16: %s\n", val
? _("yes") : _("no"));
13655 case Tag_ARC_ABI_osver
:
13656 val
= read_uleb128 (p
, &len
, end
);
13658 printf (" Tag_ARC_ABI_osver: v%d\n", val
);
13661 case Tag_ARC_ABI_pic
:
13662 case Tag_ARC_ABI_sda
:
13663 val
= read_uleb128 (p
, &len
, end
);
13665 printf (tag
== Tag_ARC_ABI_sda
? " Tag_ARC_ABI_sda: "
13666 : " Tag_ARC_ABI_pic: ");
13670 printf (_("Absent\n"));
13679 printf (_("Unknown\n"));
13684 case Tag_ARC_ABI_tls
:
13685 val
= read_uleb128 (p
, &len
, end
);
13687 printf (" Tag_ARC_ABI_tls: %s\n", val
? "r25": "none");
13690 case Tag_ARC_ABI_enumsize
:
13691 val
= read_uleb128 (p
, &len
, end
);
13693 printf (" Tag_ARC_ABI_enumsize: %s\n", val
? _("default") :
13697 case Tag_ARC_ABI_exceptions
:
13698 val
= read_uleb128 (p
, &len
, end
);
13700 printf (" Tag_ARC_ABI_exceptions: %s\n", val
? _("OPTFP")
13704 case Tag_ARC_ABI_double_size
:
13705 val
= read_uleb128 (p
, &len
, end
);
13707 printf (" Tag_ARC_ABI_double_size: %d\n", val
);
13710 case Tag_ARC_ISA_config
:
13711 printf (" Tag_ARC_ISA_config: ");
13712 p
= display_tag_value (-1, p
, end
);
13715 case Tag_ARC_ISA_apex
:
13716 printf (" Tag_ARC_ISA_apex: ");
13717 p
= display_tag_value (-1, p
, end
);
13720 case Tag_ARC_ISA_mpy_option
:
13721 val
= read_uleb128 (p
, &len
, end
);
13723 printf (" Tag_ARC_ISA_mpy_option: %d\n", val
);
13727 return display_tag_value (tag
& 1, p
, end
);
13733 /* ARM EABI attributes section. */
13738 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
13740 const char ** table
;
13741 } arm_attr_public_tag
;
13743 static const char * arm_attr_tag_CPU_arch
[] =
13744 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
13745 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
13747 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
13748 static const char * arm_attr_tag_THUMB_ISA_use
[] =
13749 {"No", "Thumb-1", "Thumb-2", "Yes"};
13750 static const char * arm_attr_tag_FP_arch
[] =
13751 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
13752 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
13753 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
13754 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
13755 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
13756 "NEON for ARMv8.1"};
13757 static const char * arm_attr_tag_PCS_config
[] =
13758 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
13759 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
13760 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
13761 {"V6", "SB", "TLS", "Unused"};
13762 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
13763 {"Absolute", "PC-relative", "SB-relative", "None"};
13764 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
13765 {"Absolute", "PC-relative", "None"};
13766 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
13767 {"None", "direct", "GOT-indirect"};
13768 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
13769 {"None", "??? 1", "2", "??? 3", "4"};
13770 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
13771 static const char * arm_attr_tag_ABI_FP_denormal
[] =
13772 {"Unused", "Needed", "Sign only"};
13773 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
13774 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
13775 static const char * arm_attr_tag_ABI_FP_number_model
[] =
13776 {"Unused", "Finite", "RTABI", "IEEE 754"};
13777 static const char * arm_attr_tag_ABI_enum_size
[] =
13778 {"Unused", "small", "int", "forced to int"};
13779 static const char * arm_attr_tag_ABI_HardFP_use
[] =
13780 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
13781 static const char * arm_attr_tag_ABI_VFP_args
[] =
13782 {"AAPCS", "VFP registers", "custom", "compatible"};
13783 static const char * arm_attr_tag_ABI_WMMX_args
[] =
13784 {"AAPCS", "WMMX registers", "custom"};
13785 static const char * arm_attr_tag_ABI_optimization_goals
[] =
13786 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
13787 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
13788 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
13789 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
13790 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
13791 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
13792 static const char * arm_attr_tag_FP_HP_extension
[] =
13793 {"Not Allowed", "Allowed"};
13794 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
13795 {"None", "IEEE 754", "Alternative Format"};
13796 static const char * arm_attr_tag_DSP_extension
[] =
13797 {"Follow architecture", "Allowed"};
13798 static const char * arm_attr_tag_MPextension_use
[] =
13799 {"Not Allowed", "Allowed"};
13800 static const char * arm_attr_tag_DIV_use
[] =
13801 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
13802 "Allowed in v7-A with integer division extension"};
13803 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
13804 static const char * arm_attr_tag_Virtualization_use
[] =
13805 {"Not Allowed", "TrustZone", "Virtualization Extensions",
13806 "TrustZone and Virtualization Extensions"};
13807 static const char * arm_attr_tag_MPextension_use_legacy
[] =
13808 {"Not Allowed", "Allowed"};
13810 #define LOOKUP(id, name) \
13811 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
13812 static arm_attr_public_tag arm_attr_public_tags
[] =
13814 {4, "CPU_raw_name", 1, NULL
},
13815 {5, "CPU_name", 1, NULL
},
13816 LOOKUP(6, CPU_arch
),
13817 {7, "CPU_arch_profile", 0, NULL
},
13818 LOOKUP(8, ARM_ISA_use
),
13819 LOOKUP(9, THUMB_ISA_use
),
13820 LOOKUP(10, FP_arch
),
13821 LOOKUP(11, WMMX_arch
),
13822 LOOKUP(12, Advanced_SIMD_arch
),
13823 LOOKUP(13, PCS_config
),
13824 LOOKUP(14, ABI_PCS_R9_use
),
13825 LOOKUP(15, ABI_PCS_RW_data
),
13826 LOOKUP(16, ABI_PCS_RO_data
),
13827 LOOKUP(17, ABI_PCS_GOT_use
),
13828 LOOKUP(18, ABI_PCS_wchar_t
),
13829 LOOKUP(19, ABI_FP_rounding
),
13830 LOOKUP(20, ABI_FP_denormal
),
13831 LOOKUP(21, ABI_FP_exceptions
),
13832 LOOKUP(22, ABI_FP_user_exceptions
),
13833 LOOKUP(23, ABI_FP_number_model
),
13834 {24, "ABI_align_needed", 0, NULL
},
13835 {25, "ABI_align_preserved", 0, NULL
},
13836 LOOKUP(26, ABI_enum_size
),
13837 LOOKUP(27, ABI_HardFP_use
),
13838 LOOKUP(28, ABI_VFP_args
),
13839 LOOKUP(29, ABI_WMMX_args
),
13840 LOOKUP(30, ABI_optimization_goals
),
13841 LOOKUP(31, ABI_FP_optimization_goals
),
13842 {32, "compatibility", 0, NULL
},
13843 LOOKUP(34, CPU_unaligned_access
),
13844 LOOKUP(36, FP_HP_extension
),
13845 LOOKUP(38, ABI_FP_16bit_format
),
13846 LOOKUP(42, MPextension_use
),
13847 LOOKUP(44, DIV_use
),
13848 LOOKUP(46, DSP_extension
),
13849 {64, "nodefaults", 0, NULL
},
13850 {65, "also_compatible_with", 0, NULL
},
13851 LOOKUP(66, T2EE_use
),
13852 {67, "conformance", 1, NULL
},
13853 LOOKUP(68, Virtualization_use
),
13854 LOOKUP(70, MPextension_use_legacy
)
13858 static unsigned char *
13859 display_arm_attribute (unsigned char * p
,
13860 const unsigned char * const end
)
13865 arm_attr_public_tag
* attr
;
13869 tag
= read_uleb128 (p
, &len
, end
);
13872 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
13874 if (arm_attr_public_tags
[i
].tag
== tag
)
13876 attr
= &arm_attr_public_tags
[i
];
13883 printf (" Tag_%s: ", attr
->name
);
13884 switch (attr
->type
)
13889 case 7: /* Tag_CPU_arch_profile. */
13890 val
= read_uleb128 (p
, &len
, end
);
13894 case 0: printf (_("None\n")); break;
13895 case 'A': printf (_("Application\n")); break;
13896 case 'R': printf (_("Realtime\n")); break;
13897 case 'M': printf (_("Microcontroller\n")); break;
13898 case 'S': printf (_("Application or Realtime\n")); break;
13899 default: printf ("??? (%d)\n", val
); break;
13903 case 24: /* Tag_align_needed. */
13904 val
= read_uleb128 (p
, &len
, end
);
13908 case 0: printf (_("None\n")); break;
13909 case 1: printf (_("8-byte\n")); break;
13910 case 2: printf (_("4-byte\n")); break;
13911 case 3: printf ("??? 3\n"); break;
13914 printf (_("8-byte and up to %d-byte extended\n"),
13917 printf ("??? (%d)\n", val
);
13922 case 25: /* Tag_align_preserved. */
13923 val
= read_uleb128 (p
, &len
, end
);
13927 case 0: printf (_("None\n")); break;
13928 case 1: printf (_("8-byte, except leaf SP\n")); break;
13929 case 2: printf (_("8-byte\n")); break;
13930 case 3: printf ("??? 3\n"); break;
13933 printf (_("8-byte and up to %d-byte extended\n"),
13936 printf ("??? (%d)\n", val
);
13941 case 32: /* Tag_compatibility. */
13943 val
= read_uleb128 (p
, &len
, end
);
13945 printf (_("flag = %d, vendor = "), val
);
13948 size_t maxlen
= (end
- p
) - 1;
13950 print_symbol ((int) maxlen
, (const char *) p
);
13951 p
+= strnlen ((char *) p
, maxlen
) + 1;
13955 printf (_("<corrupt>"));
13956 p
= (unsigned char *) end
;
13962 case 64: /* Tag_nodefaults. */
13963 /* PR 17531: file: 001-505008-0.01. */
13966 printf (_("True\n"));
13969 case 65: /* Tag_also_compatible_with. */
13970 val
= read_uleb128 (p
, &len
, end
);
13972 if (val
== 6 /* Tag_CPU_arch. */)
13974 val
= read_uleb128 (p
, &len
, end
);
13976 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
13977 printf ("??? (%d)\n", val
);
13979 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
13983 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
13988 printf (_("<unknown: %d>\n"), tag
);
13994 return display_tag_value (-1, p
, end
);
13996 return display_tag_value (0, p
, end
);
13999 assert (attr
->type
& 0x80);
14000 val
= read_uleb128 (p
, &len
, end
);
14002 type
= attr
->type
& 0x7f;
14004 printf ("??? (%d)\n", val
);
14006 printf ("%s\n", attr
->table
[val
]);
14011 return display_tag_value (tag
, p
, end
);
14014 static unsigned char *
14015 display_gnu_attribute (unsigned char * p
,
14016 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const),
14017 const unsigned char * const end
)
14023 tag
= read_uleb128 (p
, &len
, end
);
14026 /* Tag_compatibility is the only generic GNU attribute defined at
14030 val
= read_uleb128 (p
, &len
, end
);
14033 printf (_("flag = %d, vendor = "), val
);
14036 printf (_("<corrupt>\n"));
14037 warn (_("corrupt vendor attribute\n"));
14043 size_t maxlen
= (end
- p
) - 1;
14045 print_symbol ((int) maxlen
, (const char *) p
);
14046 p
+= strnlen ((char *) p
, maxlen
) + 1;
14050 printf (_("<corrupt>"));
14051 p
= (unsigned char *) end
;
14058 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
14059 return display_proc_gnu_attribute (p
, tag
, end
);
14061 return display_tag_value (tag
, p
, end
);
14064 static unsigned char *
14065 display_power_gnu_attribute (unsigned char * p
,
14067 const unsigned char * const end
)
14072 if (tag
== Tag_GNU_Power_ABI_FP
)
14074 val
= read_uleb128 (p
, &len
, end
);
14076 printf (" Tag_GNU_Power_ABI_FP: ");
14079 printf (_("<corrupt>\n"));
14084 printf ("(%#x), ", val
);
14089 printf (_("unspecified hard/soft float, "));
14092 printf (_("hard float, "));
14095 printf (_("soft float, "));
14098 printf (_("single-precision hard float, "));
14105 printf (_("unspecified long double\n"));
14108 printf (_("128-bit IBM long double\n"));
14111 printf (_("64-bit long double\n"));
14114 printf (_("128-bit IEEE long double\n"));
14120 if (tag
== Tag_GNU_Power_ABI_Vector
)
14122 val
= read_uleb128 (p
, &len
, end
);
14124 printf (" Tag_GNU_Power_ABI_Vector: ");
14127 printf (_("<corrupt>\n"));
14132 printf ("(%#x), ", val
);
14137 printf (_("unspecified\n"));
14140 printf (_("generic\n"));
14143 printf ("AltiVec\n");
14152 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
14154 val
= read_uleb128 (p
, &len
, end
);
14156 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
14159 printf (_("<corrupt>\n"));
14164 printf ("(%#x), ", val
);
14169 printf (_("unspecified\n"));
14172 printf ("r3/r4\n");
14175 printf (_("memory\n"));
14184 return display_tag_value (tag
& 1, p
, end
);
14187 static unsigned char *
14188 display_s390_gnu_attribute (unsigned char * p
,
14190 const unsigned char * const end
)
14195 if (tag
== Tag_GNU_S390_ABI_Vector
)
14197 val
= read_uleb128 (p
, &len
, end
);
14199 printf (" Tag_GNU_S390_ABI_Vector: ");
14204 printf (_("any\n"));
14207 printf (_("software\n"));
14210 printf (_("hardware\n"));
14213 printf ("??? (%d)\n", val
);
14219 return display_tag_value (tag
& 1, p
, end
);
14223 display_sparc_hwcaps (unsigned int mask
)
14227 bfd_boolean first
= TRUE
;
14229 if (mask
& ELF_SPARC_HWCAP_MUL32
)
14230 fputs ("mul32", stdout
), first
= FALSE
;
14231 if (mask
& ELF_SPARC_HWCAP_DIV32
)
14232 printf ("%sdiv32", first
? "" : "|"), first
= FALSE
;
14233 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
14234 printf ("%sfsmuld", first
? "" : "|"), first
= FALSE
;
14235 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
14236 printf ("%sv8plus", first
? "" : "|"), first
= FALSE
;
14237 if (mask
& ELF_SPARC_HWCAP_POPC
)
14238 printf ("%spopc", first
? "" : "|"), first
= FALSE
;
14239 if (mask
& ELF_SPARC_HWCAP_VIS
)
14240 printf ("%svis", first
? "" : "|"), first
= FALSE
;
14241 if (mask
& ELF_SPARC_HWCAP_VIS2
)
14242 printf ("%svis2", first
? "" : "|"), first
= FALSE
;
14243 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
14244 printf ("%sASIBlkInit", first
? "" : "|"), first
= FALSE
;
14245 if (mask
& ELF_SPARC_HWCAP_FMAF
)
14246 printf ("%sfmaf", first
? "" : "|"), first
= FALSE
;
14247 if (mask
& ELF_SPARC_HWCAP_VIS3
)
14248 printf ("%svis3", first
? "" : "|"), first
= FALSE
;
14249 if (mask
& ELF_SPARC_HWCAP_HPC
)
14250 printf ("%shpc", first
? "" : "|"), first
= FALSE
;
14251 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
14252 printf ("%srandom", first
? "" : "|"), first
= FALSE
;
14253 if (mask
& ELF_SPARC_HWCAP_TRANS
)
14254 printf ("%strans", first
? "" : "|"), first
= FALSE
;
14255 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
14256 printf ("%sfjfmau", first
? "" : "|"), first
= FALSE
;
14257 if (mask
& ELF_SPARC_HWCAP_IMA
)
14258 printf ("%sima", first
? "" : "|"), first
= FALSE
;
14259 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
14260 printf ("%scspare", first
? "" : "|"), first
= FALSE
;
14263 fputc ('0', stdout
);
14264 fputc ('\n', stdout
);
14268 display_sparc_hwcaps2 (unsigned int mask
)
14272 bfd_boolean first
= TRUE
;
14274 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
14275 fputs ("fjathplus", stdout
), first
= FALSE
;
14276 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
14277 printf ("%svis3b", first
? "" : "|"), first
= FALSE
;
14278 if (mask
& ELF_SPARC_HWCAP2_ADP
)
14279 printf ("%sadp", first
? "" : "|"), first
= FALSE
;
14280 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
14281 printf ("%ssparc5", first
? "" : "|"), first
= FALSE
;
14282 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
14283 printf ("%smwait", first
? "" : "|"), first
= FALSE
;
14284 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
14285 printf ("%sxmpmul", first
? "" : "|"), first
= FALSE
;
14286 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
14287 printf ("%sxmont2", first
? "" : "|"), first
= FALSE
;
14288 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
14289 printf ("%snsec", first
? "" : "|"), first
= FALSE
;
14290 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
14291 printf ("%sfjathhpc", first
? "" : "|"), first
= FALSE
;
14292 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
14293 printf ("%sfjdes", first
? "" : "|"), first
= FALSE
;
14294 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
14295 printf ("%sfjaes", first
? "" : "|"), first
= FALSE
;
14298 fputc ('0', stdout
);
14299 fputc ('\n', stdout
);
14302 static unsigned char *
14303 display_sparc_gnu_attribute (unsigned char * p
,
14305 const unsigned char * const end
)
14310 if (tag
== Tag_GNU_Sparc_HWCAPS
)
14312 val
= read_uleb128 (p
, &len
, end
);
14314 printf (" Tag_GNU_Sparc_HWCAPS: ");
14315 display_sparc_hwcaps (val
);
14318 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
14320 val
= read_uleb128 (p
, &len
, end
);
14322 printf (" Tag_GNU_Sparc_HWCAPS2: ");
14323 display_sparc_hwcaps2 (val
);
14327 return display_tag_value (tag
, p
, end
);
14331 print_mips_fp_abi_value (unsigned int val
)
14335 case Val_GNU_MIPS_ABI_FP_ANY
:
14336 printf (_("Hard or soft float\n"));
14338 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
14339 printf (_("Hard float (double precision)\n"));
14341 case Val_GNU_MIPS_ABI_FP_SINGLE
:
14342 printf (_("Hard float (single precision)\n"));
14344 case Val_GNU_MIPS_ABI_FP_SOFT
:
14345 printf (_("Soft float\n"));
14347 case Val_GNU_MIPS_ABI_FP_OLD_64
:
14348 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
14350 case Val_GNU_MIPS_ABI_FP_XX
:
14351 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
14353 case Val_GNU_MIPS_ABI_FP_64
:
14354 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
14356 case Val_GNU_MIPS_ABI_FP_64A
:
14357 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
14359 case Val_GNU_MIPS_ABI_FP_NAN2008
:
14360 printf (_("NaN 2008 compatibility\n"));
14363 printf ("??? (%d)\n", val
);
14368 static unsigned char *
14369 display_mips_gnu_attribute (unsigned char * p
,
14371 const unsigned char * const end
)
14373 if (tag
== Tag_GNU_MIPS_ABI_FP
)
14378 val
= read_uleb128 (p
, &len
, end
);
14380 printf (" Tag_GNU_MIPS_ABI_FP: ");
14382 print_mips_fp_abi_value (val
);
14387 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
14392 val
= read_uleb128 (p
, &len
, end
);
14394 printf (" Tag_GNU_MIPS_ABI_MSA: ");
14398 case Val_GNU_MIPS_ABI_MSA_ANY
:
14399 printf (_("Any MSA or not\n"));
14401 case Val_GNU_MIPS_ABI_MSA_128
:
14402 printf (_("128-bit MSA\n"));
14405 printf ("??? (%d)\n", val
);
14411 return display_tag_value (tag
& 1, p
, end
);
14414 static unsigned char *
14415 display_tic6x_attribute (unsigned char * p
,
14416 const unsigned char * const end
)
14422 tag
= read_uleb128 (p
, &len
, end
);
14428 val
= read_uleb128 (p
, &len
, end
);
14430 printf (" Tag_ISA: ");
14434 case C6XABI_Tag_ISA_none
:
14435 printf (_("None\n"));
14437 case C6XABI_Tag_ISA_C62X
:
14440 case C6XABI_Tag_ISA_C67X
:
14443 case C6XABI_Tag_ISA_C67XP
:
14444 printf ("C67x+\n");
14446 case C6XABI_Tag_ISA_C64X
:
14449 case C6XABI_Tag_ISA_C64XP
:
14450 printf ("C64x+\n");
14452 case C6XABI_Tag_ISA_C674X
:
14453 printf ("C674x\n");
14456 printf ("??? (%d)\n", val
);
14461 case Tag_ABI_wchar_t
:
14462 val
= read_uleb128 (p
, &len
, end
);
14464 printf (" Tag_ABI_wchar_t: ");
14468 printf (_("Not used\n"));
14471 printf (_("2 bytes\n"));
14474 printf (_("4 bytes\n"));
14477 printf ("??? (%d)\n", val
);
14482 case Tag_ABI_stack_align_needed
:
14483 val
= read_uleb128 (p
, &len
, end
);
14485 printf (" Tag_ABI_stack_align_needed: ");
14489 printf (_("8-byte\n"));
14492 printf (_("16-byte\n"));
14495 printf ("??? (%d)\n", val
);
14500 case Tag_ABI_stack_align_preserved
:
14501 val
= read_uleb128 (p
, &len
, end
);
14503 printf (" Tag_ABI_stack_align_preserved: ");
14507 printf (_("8-byte\n"));
14510 printf (_("16-byte\n"));
14513 printf ("??? (%d)\n", val
);
14519 val
= read_uleb128 (p
, &len
, end
);
14521 printf (" Tag_ABI_DSBT: ");
14525 printf (_("DSBT addressing not used\n"));
14528 printf (_("DSBT addressing used\n"));
14531 printf ("??? (%d)\n", val
);
14537 val
= read_uleb128 (p
, &len
, end
);
14539 printf (" Tag_ABI_PID: ");
14543 printf (_("Data addressing position-dependent\n"));
14546 printf (_("Data addressing position-independent, GOT near DP\n"));
14549 printf (_("Data addressing position-independent, GOT far from DP\n"));
14552 printf ("??? (%d)\n", val
);
14558 val
= read_uleb128 (p
, &len
, end
);
14560 printf (" Tag_ABI_PIC: ");
14564 printf (_("Code addressing position-dependent\n"));
14567 printf (_("Code addressing position-independent\n"));
14570 printf ("??? (%d)\n", val
);
14575 case Tag_ABI_array_object_alignment
:
14576 val
= read_uleb128 (p
, &len
, end
);
14578 printf (" Tag_ABI_array_object_alignment: ");
14582 printf (_("8-byte\n"));
14585 printf (_("4-byte\n"));
14588 printf (_("16-byte\n"));
14591 printf ("??? (%d)\n", val
);
14596 case Tag_ABI_array_object_align_expected
:
14597 val
= read_uleb128 (p
, &len
, end
);
14599 printf (" Tag_ABI_array_object_align_expected: ");
14603 printf (_("8-byte\n"));
14606 printf (_("4-byte\n"));
14609 printf (_("16-byte\n"));
14612 printf ("??? (%d)\n", val
);
14617 case Tag_ABI_compatibility
:
14619 val
= read_uleb128 (p
, &len
, end
);
14621 printf (" Tag_ABI_compatibility: ");
14622 printf (_("flag = %d, vendor = "), val
);
14625 size_t maxlen
= (end
- p
) - 1;
14627 print_symbol ((int) maxlen
, (const char *) p
);
14628 p
+= strnlen ((char *) p
, maxlen
) + 1;
14632 printf (_("<corrupt>"));
14633 p
= (unsigned char *) end
;
14639 case Tag_ABI_conformance
:
14641 printf (" Tag_ABI_conformance: \"");
14644 size_t maxlen
= (end
- p
) - 1;
14646 print_symbol ((int) maxlen
, (const char *) p
);
14647 p
+= strnlen ((char *) p
, maxlen
) + 1;
14651 printf (_("<corrupt>"));
14652 p
= (unsigned char *) end
;
14659 return display_tag_value (tag
, p
, end
);
14663 display_raw_attribute (unsigned char * p
, unsigned char const * const end
)
14665 unsigned long addr
= 0;
14666 size_t bytes
= end
- p
;
14673 int lbytes
= (bytes
> 16 ? 16 : bytes
);
14675 printf (" 0x%8.8lx ", addr
);
14677 for (j
= 0; j
< 16; j
++)
14680 printf ("%2.2x", p
[j
]);
14688 for (j
= 0; j
< lbytes
; j
++)
14691 if (k
>= ' ' && k
< 0x7f)
14707 static unsigned char *
14708 display_msp430x_attribute (unsigned char * p
,
14709 const unsigned char * const end
)
14715 tag
= read_uleb128 (p
, & len
, end
);
14720 case OFBA_MSPABI_Tag_ISA
:
14721 val
= read_uleb128 (p
, &len
, end
);
14723 printf (" Tag_ISA: ");
14726 case 0: printf (_("None\n")); break;
14727 case 1: printf (_("MSP430\n")); break;
14728 case 2: printf (_("MSP430X\n")); break;
14729 default: printf ("??? (%d)\n", val
); break;
14733 case OFBA_MSPABI_Tag_Code_Model
:
14734 val
= read_uleb128 (p
, &len
, end
);
14736 printf (" Tag_Code_Model: ");
14739 case 0: printf (_("None\n")); break;
14740 case 1: printf (_("Small\n")); break;
14741 case 2: printf (_("Large\n")); break;
14742 default: printf ("??? (%d)\n", val
); break;
14746 case OFBA_MSPABI_Tag_Data_Model
:
14747 val
= read_uleb128 (p
, &len
, end
);
14749 printf (" Tag_Data_Model: ");
14752 case 0: printf (_("None\n")); break;
14753 case 1: printf (_("Small\n")); break;
14754 case 2: printf (_("Large\n")); break;
14755 case 3: printf (_("Restricted Large\n")); break;
14756 default: printf ("??? (%d)\n", val
); break;
14761 printf (_(" <unknown tag %d>: "), tag
);
14768 size_t maxlen
= (end
- p
) - 1;
14770 print_symbol ((int) maxlen
, (const char *) p
);
14771 p
+= strnlen ((char *) p
, maxlen
) + 1;
14775 printf (_("<corrupt>"));
14776 p
= (unsigned char *) end
;
14782 val
= read_uleb128 (p
, &len
, end
);
14784 printf ("%d (0x%x)\n", val
, val
);
14794 process_attributes (FILE * file
,
14795 const char * public_name
,
14796 unsigned int proc_type
,
14797 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
14798 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const))
14800 Elf_Internal_Shdr
* sect
;
14802 bfd_boolean res
= TRUE
;
14804 /* Find the section header so that we get the size. */
14805 for (i
= 0, sect
= section_headers
;
14806 i
< elf_header
.e_shnum
;
14809 unsigned char * contents
;
14812 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
14815 contents
= (unsigned char *) get_data (NULL
, file
, sect
->sh_offset
, 1,
14816 sect
->sh_size
, _("attributes"));
14817 if (contents
== NULL
)
14824 /* The first character is the version of the attributes.
14825 Currently only version 1, (aka 'A') is recognised here. */
14828 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p
, *p
);
14833 bfd_vma section_len
;
14835 section_len
= sect
->sh_size
- 1;
14838 while (section_len
> 0)
14841 unsigned int namelen
;
14842 bfd_boolean public_section
;
14843 bfd_boolean gnu_section
;
14845 if (section_len
<= 4)
14847 error (_("Tag section ends prematurely\n"));
14851 attr_len
= byte_get (p
, 4);
14854 if (attr_len
> section_len
)
14856 error (_("Bad attribute length (%u > %u)\n"),
14857 (unsigned) attr_len
, (unsigned) section_len
);
14858 attr_len
= section_len
;
14861 /* PR 17531: file: 001-101425-0.004 */
14862 else if (attr_len
< 5)
14864 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
14869 section_len
-= attr_len
;
14872 namelen
= strnlen ((char *) p
, attr_len
) + 1;
14873 if (namelen
== 0 || namelen
>= attr_len
)
14875 error (_("Corrupt attribute section name\n"));
14880 printf (_("Attribute Section: "));
14881 print_symbol (INT_MAX
, (const char *) p
);
14884 if (public_name
&& streq ((char *) p
, public_name
))
14885 public_section
= TRUE
;
14887 public_section
= FALSE
;
14889 if (streq ((char *) p
, "gnu"))
14890 gnu_section
= TRUE
;
14892 gnu_section
= FALSE
;
14895 attr_len
-= namelen
;
14897 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
14902 unsigned char * end
;
14904 /* PR binutils/17531: Safe handling of corrupt files. */
14907 error (_("Unused bytes at end of section\n"));
14914 size
= byte_get (p
, 4);
14915 if (size
> attr_len
)
14917 error (_("Bad subsection length (%u > %u)\n"),
14918 (unsigned) size
, (unsigned) attr_len
);
14922 /* PR binutils/17531: Safe handling of corrupt files. */
14925 error (_("Bad subsection length (%u < 6)\n"),
14933 end
= p
+ size
- 1;
14934 assert (end
<= contents
+ sect
->sh_size
);
14940 printf (_("File Attributes\n"));
14943 printf (_("Section Attributes:"));
14946 printf (_("Symbol Attributes:"));
14947 /* Fall through. */
14953 val
= read_uleb128 (p
, &j
, end
);
14957 printf (" %d", val
);
14962 printf (_("Unknown tag: %d\n"), tag
);
14963 public_section
= FALSE
;
14967 if (public_section
&& display_pub_attribute
!= NULL
)
14970 p
= display_pub_attribute (p
, end
);
14973 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
14976 p
= display_gnu_attribute (p
,
14977 display_proc_gnu_attribute
,
14983 printf (_(" Unknown attribute:\n"));
14984 display_raw_attribute (p
, end
);
14999 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
15000 Print the Address, Access and Initial fields of an entry at VMA ADDR
15001 and return the VMA of the next entry, or -1 if there was a problem.
15002 Does not read from DATA_END or beyond. */
15005 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
15006 unsigned char * data_end
)
15009 print_vma (addr
, LONG_HEX
);
15011 if (addr
< pltgot
+ 0xfff0)
15012 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
15014 printf ("%10s", "");
15017 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
15021 unsigned char * from
= data
+ addr
- pltgot
;
15023 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
15025 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
15026 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
15027 return (bfd_vma
) -1;
15031 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
15032 print_vma (entry
, LONG_HEX
);
15035 return addr
+ (is_32bit_elf
? 4 : 8);
15038 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
15039 PLTGOT. Print the Address and Initial fields of an entry at VMA
15040 ADDR and return the VMA of the next entry. */
15043 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
15046 print_vma (addr
, LONG_HEX
);
15049 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
15054 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
15055 print_vma (entry
, LONG_HEX
);
15057 return addr
+ (is_32bit_elf
? 4 : 8);
15061 print_mips_ases (unsigned int mask
)
15063 if (mask
& AFL_ASE_DSP
)
15064 fputs ("\n\tDSP ASE", stdout
);
15065 if (mask
& AFL_ASE_DSPR2
)
15066 fputs ("\n\tDSP R2 ASE", stdout
);
15067 if (mask
& AFL_ASE_DSPR3
)
15068 fputs ("\n\tDSP R3 ASE", stdout
);
15069 if (mask
& AFL_ASE_EVA
)
15070 fputs ("\n\tEnhanced VA Scheme", stdout
);
15071 if (mask
& AFL_ASE_MCU
)
15072 fputs ("\n\tMCU (MicroController) ASE", stdout
);
15073 if (mask
& AFL_ASE_MDMX
)
15074 fputs ("\n\tMDMX ASE", stdout
);
15075 if (mask
& AFL_ASE_MIPS3D
)
15076 fputs ("\n\tMIPS-3D ASE", stdout
);
15077 if (mask
& AFL_ASE_MT
)
15078 fputs ("\n\tMT ASE", stdout
);
15079 if (mask
& AFL_ASE_SMARTMIPS
)
15080 fputs ("\n\tSmartMIPS ASE", stdout
);
15081 if (mask
& AFL_ASE_VIRT
)
15082 fputs ("\n\tVZ ASE", stdout
);
15083 if (mask
& AFL_ASE_MSA
)
15084 fputs ("\n\tMSA ASE", stdout
);
15085 if (mask
& AFL_ASE_MIPS16
)
15086 fputs ("\n\tMIPS16 ASE", stdout
);
15087 if (mask
& AFL_ASE_MICROMIPS
)
15088 fputs ("\n\tMICROMIPS ASE", stdout
);
15089 if (mask
& AFL_ASE_XPA
)
15090 fputs ("\n\tXPA ASE", stdout
);
15091 if (mask
& AFL_ASE_MIPS16E2
)
15092 fputs ("\n\tMIPS16e2 ASE", stdout
);
15094 fprintf (stdout
, "\n\t%s", _("None"));
15095 else if ((mask
& ~AFL_ASE_MASK
) != 0)
15096 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
15100 print_mips_isa_ext (unsigned int isa_ext
)
15105 fputs (_("None"), stdout
);
15108 fputs ("RMI XLR", stdout
);
15110 case AFL_EXT_OCTEON3
:
15111 fputs ("Cavium Networks Octeon3", stdout
);
15113 case AFL_EXT_OCTEON2
:
15114 fputs ("Cavium Networks Octeon2", stdout
);
15116 case AFL_EXT_OCTEONP
:
15117 fputs ("Cavium Networks OcteonP", stdout
);
15119 case AFL_EXT_LOONGSON_3A
:
15120 fputs ("Loongson 3A", stdout
);
15122 case AFL_EXT_OCTEON
:
15123 fputs ("Cavium Networks Octeon", stdout
);
15126 fputs ("Toshiba R5900", stdout
);
15129 fputs ("MIPS R4650", stdout
);
15132 fputs ("LSI R4010", stdout
);
15135 fputs ("NEC VR4100", stdout
);
15138 fputs ("Toshiba R3900", stdout
);
15140 case AFL_EXT_10000
:
15141 fputs ("MIPS R10000", stdout
);
15144 fputs ("Broadcom SB-1", stdout
);
15147 fputs ("NEC VR4111/VR4181", stdout
);
15150 fputs ("NEC VR4120", stdout
);
15153 fputs ("NEC VR5400", stdout
);
15156 fputs ("NEC VR5500", stdout
);
15158 case AFL_EXT_LOONGSON_2E
:
15159 fputs ("ST Microelectronics Loongson 2E", stdout
);
15161 case AFL_EXT_LOONGSON_2F
:
15162 fputs ("ST Microelectronics Loongson 2F", stdout
);
15164 case AFL_EXT_INTERAPTIV_MR2
:
15165 fputs ("Imagination interAptiv MR2", stdout
);
15168 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
15173 get_mips_reg_size (int reg_size
)
15175 return (reg_size
== AFL_REG_NONE
) ? 0
15176 : (reg_size
== AFL_REG_32
) ? 32
15177 : (reg_size
== AFL_REG_64
) ? 64
15178 : (reg_size
== AFL_REG_128
) ? 128
15183 process_mips_specific (FILE * file
)
15185 Elf_Internal_Dyn
* entry
;
15186 Elf_Internal_Shdr
*sect
= NULL
;
15187 size_t liblist_offset
= 0;
15188 size_t liblistno
= 0;
15189 size_t conflictsno
= 0;
15190 size_t options_offset
= 0;
15191 size_t conflicts_offset
= 0;
15192 size_t pltrelsz
= 0;
15194 bfd_vma pltgot
= 0;
15195 bfd_vma mips_pltgot
= 0;
15196 bfd_vma jmprel
= 0;
15197 bfd_vma local_gotno
= 0;
15198 bfd_vma gotsym
= 0;
15199 bfd_vma symtabno
= 0;
15200 bfd_boolean res
= TRUE
;
15202 if (! process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
15203 display_mips_gnu_attribute
))
15206 sect
= find_section (".MIPS.abiflags");
15210 Elf_External_ABIFlags_v0
*abiflags_ext
;
15211 Elf_Internal_ABIFlags_v0 abiflags_in
;
15213 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
15215 error (_("Corrupt MIPS ABI Flags section.\n"));
15220 abiflags_ext
= get_data (NULL
, file
, sect
->sh_offset
, 1,
15221 sect
->sh_size
, _("MIPS ABI Flags section"));
15224 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
15225 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
15226 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
15227 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
15228 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
15229 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
15230 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
15231 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
15232 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
15233 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
15234 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
15236 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
15237 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
15238 if (abiflags_in
.isa_rev
> 1)
15239 printf ("r%d", abiflags_in
.isa_rev
);
15240 printf ("\nGPR size: %d",
15241 get_mips_reg_size (abiflags_in
.gpr_size
));
15242 printf ("\nCPR1 size: %d",
15243 get_mips_reg_size (abiflags_in
.cpr1_size
));
15244 printf ("\nCPR2 size: %d",
15245 get_mips_reg_size (abiflags_in
.cpr2_size
));
15246 fputs ("\nFP ABI: ", stdout
);
15247 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
15248 fputs ("ISA Extension: ", stdout
);
15249 print_mips_isa_ext (abiflags_in
.isa_ext
);
15250 fputs ("\nASEs:", stdout
);
15251 print_mips_ases (abiflags_in
.ases
);
15252 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
15253 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
15254 fputc ('\n', stdout
);
15255 free (abiflags_ext
);
15260 /* We have a lot of special sections. Thanks SGI! */
15261 if (dynamic_section
== NULL
)
15263 /* No dynamic information available. See if there is static GOT. */
15264 sect
= find_section (".got");
15267 unsigned char *data_end
;
15268 unsigned char *data
;
15272 pltgot
= sect
->sh_addr
;
15275 addr_size
= (is_32bit_elf
? 4 : 8);
15276 end
= pltgot
+ sect
->sh_size
;
15278 data
= (unsigned char *) get_data (NULL
, file
, sect
->sh_offset
,
15280 _("Global Offset Table data"));
15281 /* PR 12855: Null data is handled gracefully throughout. */
15282 data_end
= data
+ (end
- pltgot
);
15284 printf (_("\nStatic GOT:\n"));
15285 printf (_(" Canonical gp value: "));
15286 print_vma (ent
+ 0x7ff0, LONG_HEX
);
15289 /* In a dynamic binary GOT[0] is reserved for the dynamic
15290 loader to store the lazy resolver pointer, however in
15291 a static binary it may well have been omitted and GOT
15292 reduced to a table of addresses.
15293 PR 21344: Check for the entry being fully available
15294 before fetching it. */
15296 && data
+ ent
- pltgot
+ addr_size
<= data_end
15297 && byte_get (data
+ ent
- pltgot
, addr_size
) == 0)
15299 printf (_(" Reserved entries:\n"));
15300 printf (_(" %*s %10s %*s\n"),
15301 addr_size
* 2, _("Address"), _("Access"),
15302 addr_size
* 2, _("Value"));
15303 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15305 if (ent
== (bfd_vma
) -1)
15306 goto sgot_print_fail
;
15308 /* Check for the MSB of GOT[1] being set, identifying a
15309 GNU object. This entry will be used by some runtime
15310 loaders, to store the module pointer. Otherwise this
15311 is an ordinary local entry.
15312 PR 21344: Check for the entry being fully available
15313 before fetching it. */
15315 && data
+ ent
- pltgot
+ addr_size
<= data_end
15316 && (byte_get (data
+ ent
- pltgot
, addr_size
)
15317 >> (addr_size
* 8 - 1)) != 0)
15319 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15321 if (ent
== (bfd_vma
) -1)
15322 goto sgot_print_fail
;
15329 printf (_(" Local entries:\n"));
15330 printf (" %*s %10s %*s\n",
15331 addr_size
* 2, _("Address"), _("Access"),
15332 addr_size
* 2, _("Value"));
15335 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15337 if (ent
== (bfd_vma
) -1)
15338 goto sgot_print_fail
;
15350 for (entry
= dynamic_section
;
15351 /* PR 17531 file: 012-50589-0.004. */
15352 entry
< dynamic_section
+ dynamic_nent
&& entry
->d_tag
!= DT_NULL
;
15354 switch (entry
->d_tag
)
15356 case DT_MIPS_LIBLIST
:
15358 = offset_from_vma (file
, entry
->d_un
.d_val
,
15359 liblistno
* sizeof (Elf32_External_Lib
));
15361 case DT_MIPS_LIBLISTNO
:
15362 liblistno
= entry
->d_un
.d_val
;
15364 case DT_MIPS_OPTIONS
:
15365 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
15367 case DT_MIPS_CONFLICT
:
15369 = offset_from_vma (file
, entry
->d_un
.d_val
,
15370 conflictsno
* sizeof (Elf32_External_Conflict
));
15372 case DT_MIPS_CONFLICTNO
:
15373 conflictsno
= entry
->d_un
.d_val
;
15376 pltgot
= entry
->d_un
.d_ptr
;
15378 case DT_MIPS_LOCAL_GOTNO
:
15379 local_gotno
= entry
->d_un
.d_val
;
15381 case DT_MIPS_GOTSYM
:
15382 gotsym
= entry
->d_un
.d_val
;
15384 case DT_MIPS_SYMTABNO
:
15385 symtabno
= entry
->d_un
.d_val
;
15387 case DT_MIPS_PLTGOT
:
15388 mips_pltgot
= entry
->d_un
.d_ptr
;
15391 pltrel
= entry
->d_un
.d_val
;
15394 pltrelsz
= entry
->d_un
.d_val
;
15397 jmprel
= entry
->d_un
.d_ptr
;
15403 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
15405 Elf32_External_Lib
* elib
;
15408 elib
= (Elf32_External_Lib
*) get_data (NULL
, file
, liblist_offset
,
15410 sizeof (Elf32_External_Lib
),
15411 _("liblist section data"));
15414 printf (_("\nSection '.liblist' contains %lu entries:\n"),
15415 (unsigned long) liblistno
);
15416 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
15419 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
15426 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
15427 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
15428 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
15429 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
15430 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
15432 tmp
= gmtime (&atime
);
15433 snprintf (timebuf
, sizeof (timebuf
),
15434 "%04u-%02u-%02uT%02u:%02u:%02u",
15435 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
15436 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
15438 printf ("%3lu: ", (unsigned long) cnt
);
15439 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
15440 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
15442 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
15443 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
15444 liblist
.l_version
);
15446 if (liblist
.l_flags
== 0)
15450 static const struct
15457 { " EXACT_MATCH", LL_EXACT_MATCH
},
15458 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
15459 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
15460 { " EXPORTS", LL_EXPORTS
},
15461 { " DELAY_LOAD", LL_DELAY_LOAD
},
15462 { " DELTA", LL_DELTA
}
15464 int flags
= liblist
.l_flags
;
15467 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
15468 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
15470 fputs (l_flags_vals
[fcnt
].name
, stdout
);
15471 flags
^= l_flags_vals
[fcnt
].bit
;
15474 printf (" %#x", (unsigned int) flags
);
15486 if (options_offset
!= 0)
15488 Elf_External_Options
* eopt
;
15489 Elf_Internal_Options
* iopt
;
15490 Elf_Internal_Options
* option
;
15493 sect
= section_headers
;
15495 /* Find the section header so that we get the size. */
15496 sect
= find_section_by_type (SHT_MIPS_OPTIONS
);
15497 /* PR 17533 file: 012-277276-0.004. */
15500 error (_("No MIPS_OPTIONS header found\n"));
15504 eopt
= (Elf_External_Options
*) get_data (NULL
, file
, options_offset
, 1,
15505 sect
->sh_size
, _("options"));
15508 iopt
= (Elf_Internal_Options
*)
15509 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
15512 error (_("Out of memory allocating space for MIPS options\n"));
15519 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
15521 Elf_External_Options
* eoption
;
15523 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
15525 option
->kind
= BYTE_GET (eoption
->kind
);
15526 option
->size
= BYTE_GET (eoption
->size
);
15527 option
->section
= BYTE_GET (eoption
->section
);
15528 option
->info
= BYTE_GET (eoption
->info
);
15530 /* PR 17531: file: ffa0fa3b. */
15531 if (option
->size
< sizeof (* eopt
)
15532 || offset
+ option
->size
> sect
->sh_size
)
15534 error (_("Invalid size (%u) for MIPS option\n"), option
->size
);
15537 offset
+= option
->size
;
15543 printf (_("\nSection '%s' contains %d entries:\n"),
15544 printable_section_name (sect
), cnt
);
15553 switch (option
->kind
)
15556 /* This shouldn't happen. */
15557 printf (" NULL %d %lx", option
->section
, option
->info
);
15560 printf (" REGINFO ");
15561 if (elf_header
.e_machine
== EM_MIPS
)
15564 Elf32_External_RegInfo
* ereg
;
15565 Elf32_RegInfo reginfo
;
15567 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
15568 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
15569 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
15570 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
15571 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
15572 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
15573 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
15575 printf ("GPR %08lx GP 0x%lx\n",
15576 reginfo
.ri_gprmask
,
15577 (unsigned long) reginfo
.ri_gp_value
);
15578 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
15579 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
15580 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
15585 Elf64_External_RegInfo
* ereg
;
15586 Elf64_Internal_RegInfo reginfo
;
15588 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
15589 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
15590 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
15591 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
15592 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
15593 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
15594 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
15596 printf ("GPR %08lx GP 0x",
15597 reginfo
.ri_gprmask
);
15598 printf_vma (reginfo
.ri_gp_value
);
15601 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
15602 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
15603 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
15607 case ODK_EXCEPTIONS
:
15608 fputs (" EXCEPTIONS fpe_min(", stdout
);
15609 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
15610 fputs (") fpe_max(", stdout
);
15611 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
15612 fputs (")", stdout
);
15614 if (option
->info
& OEX_PAGE0
)
15615 fputs (" PAGE0", stdout
);
15616 if (option
->info
& OEX_SMM
)
15617 fputs (" SMM", stdout
);
15618 if (option
->info
& OEX_FPDBUG
)
15619 fputs (" FPDBUG", stdout
);
15620 if (option
->info
& OEX_DISMISS
)
15621 fputs (" DISMISS", stdout
);
15624 fputs (" PAD ", stdout
);
15625 if (option
->info
& OPAD_PREFIX
)
15626 fputs (" PREFIX", stdout
);
15627 if (option
->info
& OPAD_POSTFIX
)
15628 fputs (" POSTFIX", stdout
);
15629 if (option
->info
& OPAD_SYMBOL
)
15630 fputs (" SYMBOL", stdout
);
15633 fputs (" HWPATCH ", stdout
);
15634 if (option
->info
& OHW_R4KEOP
)
15635 fputs (" R4KEOP", stdout
);
15636 if (option
->info
& OHW_R8KPFETCH
)
15637 fputs (" R8KPFETCH", stdout
);
15638 if (option
->info
& OHW_R5KEOP
)
15639 fputs (" R5KEOP", stdout
);
15640 if (option
->info
& OHW_R5KCVTL
)
15641 fputs (" R5KCVTL", stdout
);
15644 fputs (" FILL ", stdout
);
15645 /* XXX Print content of info word? */
15648 fputs (" TAGS ", stdout
);
15649 /* XXX Print content of info word? */
15652 fputs (" HWAND ", stdout
);
15653 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
15654 fputs (" R4KEOP_CHECKED", stdout
);
15655 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
15656 fputs (" R4KEOP_CLEAN", stdout
);
15659 fputs (" HWOR ", stdout
);
15660 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
15661 fputs (" R4KEOP_CHECKED", stdout
);
15662 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
15663 fputs (" R4KEOP_CLEAN", stdout
);
15666 printf (" GP_GROUP %#06lx self-contained %#06lx",
15667 option
->info
& OGP_GROUP
,
15668 (option
->info
& OGP_SELF
) >> 16);
15671 printf (" IDENT %#06lx self-contained %#06lx",
15672 option
->info
& OGP_GROUP
,
15673 (option
->info
& OGP_SELF
) >> 16);
15676 /* This shouldn't happen. */
15677 printf (" %3d ??? %d %lx",
15678 option
->kind
, option
->section
, option
->info
);
15682 len
= sizeof (* eopt
);
15683 while (len
< option
->size
)
15685 unsigned char datum
= * ((unsigned char *) eopt
+ offset
+ len
);
15687 if (ISPRINT (datum
))
15688 printf ("%c", datum
);
15690 printf ("\\%03o", datum
);
15693 fputs ("\n", stdout
);
15695 offset
+= option
->size
;
15705 if (conflicts_offset
!= 0 && conflictsno
!= 0)
15707 Elf32_Conflict
* iconf
;
15710 if (dynamic_symbols
== NULL
)
15712 error (_("conflict list found without a dynamic symbol table\n"));
15716 /* PR 21345 - print a slightly more helpful error message
15717 if we are sure that the cmalloc will fail. */
15718 if (conflictsno
* sizeof (* iconf
) > current_file_size
)
15720 error (_("Overlarge number of conflicts detected: %lx\n"),
15721 (long) conflictsno
);
15725 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
15728 error (_("Out of memory allocating space for dynamic conflicts\n"));
15734 Elf32_External_Conflict
* econf32
;
15736 econf32
= (Elf32_External_Conflict
*)
15737 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
15738 sizeof (* econf32
), _("conflict"));
15742 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
15743 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
15749 Elf64_External_Conflict
* econf64
;
15751 econf64
= (Elf64_External_Conflict
*)
15752 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
15753 sizeof (* econf64
), _("conflict"));
15757 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
15758 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
15763 printf (_("\nSection '.conflict' contains %lu entries:\n"),
15764 (unsigned long) conflictsno
);
15765 puts (_(" Num: Index Value Name"));
15767 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
15769 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
15771 if (iconf
[cnt
] >= num_dynamic_syms
)
15772 printf (_("<corrupt symbol index>"));
15775 Elf_Internal_Sym
* psym
;
15777 psym
= & dynamic_symbols
[iconf
[cnt
]];
15778 print_vma (psym
->st_value
, FULL_HEX
);
15780 if (VALID_DYNAMIC_NAME (psym
->st_name
))
15781 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
15783 printf (_("<corrupt: %14ld>"), psym
->st_name
);
15791 if (pltgot
!= 0 && local_gotno
!= 0)
15793 bfd_vma ent
, local_end
, global_end
;
15795 unsigned char * data
;
15796 unsigned char * data_end
;
15800 addr_size
= (is_32bit_elf
? 4 : 8);
15801 local_end
= pltgot
+ local_gotno
* addr_size
;
15803 /* PR binutils/17533 file: 012-111227-0.004 */
15804 if (symtabno
< gotsym
)
15806 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
15807 (unsigned long) gotsym
, (unsigned long) symtabno
);
15811 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
15812 /* PR 17531: file: 54c91a34. */
15813 if (global_end
< local_end
)
15815 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
15819 offset
= offset_from_vma (file
, pltgot
, global_end
- pltgot
);
15820 data
= (unsigned char *) get_data (NULL
, file
, offset
,
15821 global_end
- pltgot
, 1,
15822 _("Global Offset Table data"));
15823 /* PR 12855: Null data is handled gracefully throughout. */
15824 data_end
= data
+ (global_end
- pltgot
);
15826 printf (_("\nPrimary GOT:\n"));
15827 printf (_(" Canonical gp value: "));
15828 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
15831 printf (_(" Reserved entries:\n"));
15832 printf (_(" %*s %10s %*s Purpose\n"),
15833 addr_size
* 2, _("Address"), _("Access"),
15834 addr_size
* 2, _("Initial"));
15835 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15836 printf (_(" Lazy resolver\n"));
15837 if (ent
== (bfd_vma
) -1)
15838 goto got_print_fail
;
15840 /* Check for the MSB of GOT[1] being set, denoting a GNU object.
15841 This entry will be used by some runtime loaders, to store the
15842 module pointer. Otherwise this is an ordinary local entry.
15843 PR 21344: Check for the entry being fully available before
15846 && data
+ ent
- pltgot
+ addr_size
<= data_end
15847 && (byte_get (data
+ ent
- pltgot
, addr_size
)
15848 >> (addr_size
* 8 - 1)) != 0)
15850 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15851 printf (_(" Module pointer (GNU extension)\n"));
15852 if (ent
== (bfd_vma
) -1)
15853 goto got_print_fail
;
15857 if (ent
< local_end
)
15859 printf (_(" Local entries:\n"));
15860 printf (" %*s %10s %*s\n",
15861 addr_size
* 2, _("Address"), _("Access"),
15862 addr_size
* 2, _("Initial"));
15863 while (ent
< local_end
)
15865 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15867 if (ent
== (bfd_vma
) -1)
15868 goto got_print_fail
;
15873 if (gotsym
< symtabno
)
15877 printf (_(" Global entries:\n"));
15878 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
15879 addr_size
* 2, _("Address"),
15881 addr_size
* 2, _("Initial"),
15882 addr_size
* 2, _("Sym.Val."),
15884 /* Note for translators: "Ndx" = abbreviated form of "Index". */
15885 _("Ndx"), _("Name"));
15887 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
15889 for (i
= gotsym
; i
< symtabno
; i
++)
15891 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15894 if (dynamic_symbols
== NULL
)
15895 printf (_("<no dynamic symbols>"));
15896 else if (i
< num_dynamic_syms
)
15898 Elf_Internal_Sym
* psym
= dynamic_symbols
+ i
;
15900 print_vma (psym
->st_value
, LONG_HEX
);
15901 printf (" %-7s %3s ",
15902 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
15903 get_symbol_index_type (psym
->st_shndx
));
15905 if (VALID_DYNAMIC_NAME (psym
->st_name
))
15906 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
15908 printf (_("<corrupt: %14ld>"), psym
->st_name
);
15911 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
15912 (unsigned long) i
);
15915 if (ent
== (bfd_vma
) -1)
15926 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
15929 size_t offset
, rel_offset
;
15930 unsigned long count
, i
;
15931 unsigned char * data
;
15932 int addr_size
, sym_width
;
15933 Elf_Internal_Rela
* rels
;
15935 rel_offset
= offset_from_vma (file
, jmprel
, pltrelsz
);
15936 if (pltrel
== DT_RELA
)
15938 if (!slurp_rela_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
15943 if (!slurp_rel_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
15948 addr_size
= (is_32bit_elf
? 4 : 8);
15949 end
= mips_pltgot
+ (2 + count
) * addr_size
;
15951 offset
= offset_from_vma (file
, mips_pltgot
, end
- mips_pltgot
);
15952 data
= (unsigned char *) get_data (NULL
, file
, offset
, end
- mips_pltgot
,
15953 1, _("Procedure Linkage Table data"));
15957 printf ("\nPLT GOT:\n\n");
15958 printf (_(" Reserved entries:\n"));
15959 printf (_(" %*s %*s Purpose\n"),
15960 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
15961 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
15962 printf (_(" PLT lazy resolver\n"));
15963 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
15964 printf (_(" Module pointer\n"));
15967 printf (_(" Entries:\n"));
15968 printf (" %*s %*s %*s %-7s %3s %s\n",
15969 addr_size
* 2, _("Address"),
15970 addr_size
* 2, _("Initial"),
15971 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
15972 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
15973 for (i
= 0; i
< count
; i
++)
15975 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
15977 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
15980 if (idx
>= num_dynamic_syms
)
15981 printf (_("<corrupt symbol index: %lu>"), idx
);
15984 Elf_Internal_Sym
* psym
= dynamic_symbols
+ idx
;
15986 print_vma (psym
->st_value
, LONG_HEX
);
15987 printf (" %-7s %3s ",
15988 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
15989 get_symbol_index_type (psym
->st_shndx
));
15990 if (VALID_DYNAMIC_NAME (psym
->st_name
))
15991 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
15993 printf (_("<corrupt: %14ld>"), psym
->st_name
);
16008 process_nds32_specific (FILE * file
)
16010 Elf_Internal_Shdr
*sect
= NULL
;
16012 sect
= find_section (".nds32_e_flags");
16015 unsigned int *flag
;
16017 printf ("\nNDS32 elf flags section:\n");
16018 flag
= get_data (NULL
, file
, sect
->sh_offset
, 1,
16019 sect
->sh_size
, _("NDS32 elf flags section"));
16024 switch ((*flag
) & 0x3)
16027 printf ("(VEC_SIZE):\tNo entry.\n");
16030 printf ("(VEC_SIZE):\t4 bytes\n");
16033 printf ("(VEC_SIZE):\t16 bytes\n");
16036 printf ("(VEC_SIZE):\treserved\n");
16045 process_gnu_liblist (FILE * file
)
16047 Elf_Internal_Shdr
* section
;
16048 Elf_Internal_Shdr
* string_sec
;
16049 Elf32_External_Lib
* elib
;
16051 size_t strtab_size
;
16054 bfd_boolean res
= TRUE
;
16059 for (i
= 0, section
= section_headers
;
16060 i
< elf_header
.e_shnum
;
16063 switch (section
->sh_type
)
16065 case SHT_GNU_LIBLIST
:
16066 if (section
->sh_link
>= elf_header
.e_shnum
)
16069 elib
= (Elf32_External_Lib
*)
16070 get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
16071 _("liblist section data"));
16079 string_sec
= section_headers
+ section
->sh_link
;
16080 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
16081 string_sec
->sh_size
,
16082 _("liblist string table"));
16084 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
16091 strtab_size
= string_sec
->sh_size
;
16093 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
16094 printable_section_name (section
),
16095 (unsigned long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
16097 puts (_(" Library Time Stamp Checksum Version Flags"));
16099 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
16107 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
16108 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
16109 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
16110 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
16111 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
16113 tmp
= gmtime (&atime
);
16114 snprintf (timebuf
, sizeof (timebuf
),
16115 "%04u-%02u-%02uT%02u:%02u:%02u",
16116 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
16117 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
16119 printf ("%3lu: ", (unsigned long) cnt
);
16121 printf ("%-20s", liblist
.l_name
< strtab_size
16122 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
16124 printf ("%-20.20s", liblist
.l_name
< strtab_size
16125 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
16126 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
16127 liblist
.l_version
, liblist
.l_flags
);
16138 static const char *
16139 get_note_type (unsigned e_type
)
16141 static char buff
[64];
16143 if (elf_header
.e_type
== ET_CORE
)
16147 return _("NT_AUXV (auxiliary vector)");
16149 return _("NT_PRSTATUS (prstatus structure)");
16151 return _("NT_FPREGSET (floating point registers)");
16153 return _("NT_PRPSINFO (prpsinfo structure)");
16154 case NT_TASKSTRUCT
:
16155 return _("NT_TASKSTRUCT (task structure)");
16157 return _("NT_PRXFPREG (user_xfpregs structure)");
16159 return _("NT_PPC_VMX (ppc Altivec registers)");
16161 return _("NT_PPC_VSX (ppc VSX registers)");
16163 return _("NT_PPC_TAR (ppc TAR register)");
16165 return _("NT_PPC_PPR (ppc PPR register)");
16167 return _("NT_PPC_DSCR (ppc DSCR register)");
16169 return _("NT_PPC_EBB (ppc EBB registers)");
16171 return _("NT_PPC_PMU (ppc PMU registers)");
16172 case NT_PPC_TM_CGPR
:
16173 return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
16174 case NT_PPC_TM_CFPR
:
16175 return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
16176 case NT_PPC_TM_CVMX
:
16177 return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
16178 case NT_PPC_TM_CVSX
:
16179 return _("NT_PPC_TM_VSX (ppc checkpointed VSX registers)");
16180 case NT_PPC_TM_SPR
:
16181 return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
16182 case NT_PPC_TM_CTAR
:
16183 return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
16184 case NT_PPC_TM_CPPR
:
16185 return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
16186 case NT_PPC_TM_CDSCR
:
16187 return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
16189 return _("NT_386_TLS (x86 TLS information)");
16190 case NT_386_IOPERM
:
16191 return _("NT_386_IOPERM (x86 I/O permissions)");
16192 case NT_X86_XSTATE
:
16193 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
16194 case NT_S390_HIGH_GPRS
:
16195 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
16196 case NT_S390_TIMER
:
16197 return _("NT_S390_TIMER (s390 timer register)");
16198 case NT_S390_TODCMP
:
16199 return _("NT_S390_TODCMP (s390 TOD comparator register)");
16200 case NT_S390_TODPREG
:
16201 return _("NT_S390_TODPREG (s390 TOD programmable register)");
16203 return _("NT_S390_CTRS (s390 control registers)");
16204 case NT_S390_PREFIX
:
16205 return _("NT_S390_PREFIX (s390 prefix register)");
16206 case NT_S390_LAST_BREAK
:
16207 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
16208 case NT_S390_SYSTEM_CALL
:
16209 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
16211 return _("NT_S390_TDB (s390 transaction diagnostic block)");
16212 case NT_S390_VXRS_LOW
:
16213 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
16214 case NT_S390_VXRS_HIGH
:
16215 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
16216 case NT_S390_GS_CB
:
16217 return _("NT_S390_GS_CB (s390 guarded-storage registers)");
16218 case NT_S390_GS_BC
:
16219 return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
16221 return _("NT_ARM_VFP (arm VFP registers)");
16223 return _("NT_ARM_TLS (AArch TLS registers)");
16224 case NT_ARM_HW_BREAK
:
16225 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
16226 case NT_ARM_HW_WATCH
:
16227 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
16229 return _("NT_PSTATUS (pstatus structure)");
16231 return _("NT_FPREGS (floating point registers)");
16233 return _("NT_PSINFO (psinfo structure)");
16235 return _("NT_LWPSTATUS (lwpstatus_t structure)");
16237 return _("NT_LWPSINFO (lwpsinfo_t structure)");
16238 case NT_WIN32PSTATUS
:
16239 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
16241 return _("NT_SIGINFO (siginfo_t data)");
16243 return _("NT_FILE (mapped files)");
16251 return _("NT_VERSION (version)");
16253 return _("NT_ARCH (architecture)");
16254 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
16255 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
16256 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
16257 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
16262 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16267 print_core_note (Elf_Internal_Note
*pnote
)
16269 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
16270 bfd_vma count
, page_size
;
16271 unsigned char *descdata
, *filenames
, *descend
;
16273 if (pnote
->type
!= NT_FILE
)
16283 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
16284 /* Still "successful". */
16289 if (pnote
->descsz
< 2 * addr_size
)
16291 error (_(" Malformed note - too short for header\n"));
16295 descdata
= (unsigned char *) pnote
->descdata
;
16296 descend
= descdata
+ pnote
->descsz
;
16298 if (descdata
[pnote
->descsz
- 1] != '\0')
16300 error (_(" Malformed note - does not end with \\0\n"));
16304 count
= byte_get (descdata
, addr_size
);
16305 descdata
+= addr_size
;
16307 page_size
= byte_get (descdata
, addr_size
);
16308 descdata
+= addr_size
;
16310 if (pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
16312 error (_(" Malformed note - too short for supplied file count\n"));
16316 printf (_(" Page size: "));
16317 print_vma (page_size
, DEC
);
16320 printf (_(" %*s%*s%*s\n"),
16321 (int) (2 + 2 * addr_size
), _("Start"),
16322 (int) (4 + 2 * addr_size
), _("End"),
16323 (int) (4 + 2 * addr_size
), _("Page Offset"));
16324 filenames
= descdata
+ count
* 3 * addr_size
;
16325 while (count
-- > 0)
16327 bfd_vma start
, end
, file_ofs
;
16329 if (filenames
== descend
)
16331 error (_(" Malformed note - filenames end too early\n"));
16335 start
= byte_get (descdata
, addr_size
);
16336 descdata
+= addr_size
;
16337 end
= byte_get (descdata
, addr_size
);
16338 descdata
+= addr_size
;
16339 file_ofs
= byte_get (descdata
, addr_size
);
16340 descdata
+= addr_size
;
16343 print_vma (start
, FULL_HEX
);
16345 print_vma (end
, FULL_HEX
);
16347 print_vma (file_ofs
, FULL_HEX
);
16348 printf ("\n %s\n", filenames
);
16350 filenames
+= 1 + strlen ((char *) filenames
);
16356 static const char *
16357 get_gnu_elf_note_type (unsigned e_type
)
16359 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
16362 case NT_GNU_ABI_TAG
:
16363 return _("NT_GNU_ABI_TAG (ABI version tag)");
16365 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
16366 case NT_GNU_BUILD_ID
:
16367 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
16368 case NT_GNU_GOLD_VERSION
:
16369 return _("NT_GNU_GOLD_VERSION (gold version)");
16370 case NT_GNU_PROPERTY_TYPE_0
:
16371 return _("NT_GNU_PROPERTY_TYPE_0");
16372 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
16373 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
16374 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
16375 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
16378 static char buff
[64];
16380 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16387 decode_x86_isa (unsigned int bitmask
)
16391 unsigned int bit
= bitmask
& (- bitmask
);
16396 case GNU_PROPERTY_X86_ISA_1_486
: printf ("i486"); break;
16397 case GNU_PROPERTY_X86_ISA_1_586
: printf ("586"); break;
16398 case GNU_PROPERTY_X86_ISA_1_686
: printf ("686"); break;
16399 case GNU_PROPERTY_X86_ISA_1_SSE
: printf ("SSE"); break;
16400 case GNU_PROPERTY_X86_ISA_1_SSE2
: printf ("SSE2"); break;
16401 case GNU_PROPERTY_X86_ISA_1_SSE3
: printf ("SSE3"); break;
16402 case GNU_PROPERTY_X86_ISA_1_SSSE3
: printf ("SSSE3"); break;
16403 case GNU_PROPERTY_X86_ISA_1_SSE4_1
: printf ("SSE4_1"); break;
16404 case GNU_PROPERTY_X86_ISA_1_SSE4_2
: printf ("SSE4_2"); break;
16405 case GNU_PROPERTY_X86_ISA_1_AVX
: printf ("AVX"); break;
16406 case GNU_PROPERTY_X86_ISA_1_AVX2
: printf ("AVX2"); break;
16407 case GNU_PROPERTY_X86_ISA_1_AVX512F
: printf ("AVX512F"); break;
16408 case GNU_PROPERTY_X86_ISA_1_AVX512CD
: printf ("AVX512CD"); break;
16409 case GNU_PROPERTY_X86_ISA_1_AVX512ER
: printf ("AVX512ER"); break;
16410 case GNU_PROPERTY_X86_ISA_1_AVX512PF
: printf ("AVX512PF"); break;
16411 case GNU_PROPERTY_X86_ISA_1_AVX512VL
: printf ("AVX512VL"); break;
16412 case GNU_PROPERTY_X86_ISA_1_AVX512DQ
: printf ("AVX512DQ"); break;
16413 case GNU_PROPERTY_X86_ISA_1_AVX512BW
: printf ("AVX512BW"); break;
16414 default: printf (_("<unknown: %x>"), bit
); break;
16422 decode_x86_feature (unsigned int type
, unsigned int bitmask
)
16426 unsigned int bit
= bitmask
& (- bitmask
);
16431 case GNU_PROPERTY_X86_FEATURE_1_IBT
:
16434 case GNU_PROPERTY_X86_FEATURE_1_AND
:
16438 /* This should never happen. */
16442 case GNU_PROPERTY_X86_FEATURE_1_SHSTK
:
16445 case GNU_PROPERTY_X86_FEATURE_1_AND
:
16449 /* This should never happen. */
16454 printf (_("<unknown: %x>"), bit
);
16463 print_gnu_property_note (Elf_Internal_Note
* pnote
)
16465 unsigned char * ptr
= (unsigned char *) pnote
->descdata
;
16466 unsigned char * ptr_end
= ptr
+ pnote
->descsz
;
16467 unsigned int size
= is_32bit_elf
? 4 : 8;
16469 printf (_(" Properties: "));
16471 if (pnote
->descsz
< 8 || (pnote
->descsz
% size
) != 0)
16473 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote
->descsz
);
16480 unsigned int type
= byte_get (ptr
, 4);
16481 unsigned int datasz
= byte_get (ptr
+ 4, 4);
16485 if ((ptr
+ datasz
) > ptr_end
)
16487 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
16492 if (type
>= GNU_PROPERTY_LOPROC
&& type
<= GNU_PROPERTY_HIPROC
)
16494 if (elf_header
.e_machine
== EM_X86_64
16495 || elf_header
.e_machine
== EM_IAMCU
16496 || elf_header
.e_machine
== EM_386
)
16500 case GNU_PROPERTY_X86_ISA_1_USED
:
16501 printf ("x86 ISA used: ");
16503 printf (_("<corrupt length: %#x> "), datasz
);
16505 decode_x86_isa (byte_get (ptr
, 4));
16508 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
16509 printf ("x86 ISA needed: ");
16511 printf (_("<corrupt length: %#x> "), datasz
);
16513 decode_x86_isa (byte_get (ptr
, 4));
16516 case GNU_PROPERTY_X86_FEATURE_1_AND
:
16517 printf ("x86 feature: ");
16519 printf (_("<corrupt length: %#x> "), datasz
);
16521 decode_x86_feature (type
, byte_get (ptr
, 4));
16533 case GNU_PROPERTY_STACK_SIZE
:
16534 printf (_("stack size: "));
16535 if (datasz
!= size
)
16536 printf (_("<corrupt length: %#x> "), datasz
);
16538 printf ("%#lx", (unsigned long) byte_get (ptr
, size
));
16541 case GNU_PROPERTY_NO_COPY_ON_PROTECTED
:
16542 printf ("no copy on protected ");
16544 printf (_("<corrupt length: %#x> "), datasz
);
16552 if (type
< GNU_PROPERTY_LOPROC
)
16553 printf (_("<unknown type %#x data: "), type
);
16554 else if (type
< GNU_PROPERTY_LOUSER
)
16555 printf (_("<procesor-specific type %#x data: "), type
);
16557 printf (_("<application-specific type %#x data: "), type
);
16558 for (j
= 0; j
< datasz
; ++j
)
16559 printf ("%02x ", ptr
[j
] & 0xff);
16563 ptr
+= ((datasz
+ (size
- 1)) & ~ (size
- 1));
16564 if (ptr
== ptr_end
)
16574 if (ptr
> (ptr_end
- 8))
16576 printf (_("<corrupt descsz: %#lx>\n"), pnote
->descsz
);
16585 print_gnu_note (Elf_Internal_Note
*pnote
)
16587 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
16588 switch (pnote
->type
)
16590 case NT_GNU_BUILD_ID
:
16594 printf (_(" Build ID: "));
16595 for (i
= 0; i
< pnote
->descsz
; ++i
)
16596 printf ("%02x", pnote
->descdata
[i
] & 0xff);
16601 case NT_GNU_ABI_TAG
:
16603 unsigned long os
, major
, minor
, subminor
;
16604 const char *osname
;
16606 /* PR 17531: file: 030-599401-0.004. */
16607 if (pnote
->descsz
< 16)
16609 printf (_(" <corrupt GNU_ABI_TAG>\n"));
16613 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
16614 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
16615 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
16616 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
16620 case GNU_ABI_TAG_LINUX
:
16623 case GNU_ABI_TAG_HURD
:
16626 case GNU_ABI_TAG_SOLARIS
:
16627 osname
= "Solaris";
16629 case GNU_ABI_TAG_FREEBSD
:
16630 osname
= "FreeBSD";
16632 case GNU_ABI_TAG_NETBSD
:
16635 case GNU_ABI_TAG_SYLLABLE
:
16636 osname
= "Syllable";
16638 case GNU_ABI_TAG_NACL
:
16642 osname
= "Unknown";
16646 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
16647 major
, minor
, subminor
);
16651 case NT_GNU_GOLD_VERSION
:
16655 printf (_(" Version: "));
16656 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
16657 printf ("%c", pnote
->descdata
[i
]);
16664 unsigned long num_entries
, mask
;
16666 /* Hardware capabilities information. Word 0 is the number of entries.
16667 Word 1 is a bitmask of enabled entries. The rest of the descriptor
16668 is a series of entries, where each entry is a single byte followed
16669 by a nul terminated string. The byte gives the bit number to test
16670 if enabled in the bitmask. */
16671 printf (_(" Hardware Capabilities: "));
16672 if (pnote
->descsz
< 8)
16674 error (_("<corrupt GNU_HWCAP>\n"));
16677 num_entries
= byte_get ((unsigned char *) pnote
->descdata
, 4);
16678 mask
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
16679 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries
, mask
);
16680 /* FIXME: Add code to display the entries... */
16684 case NT_GNU_PROPERTY_TYPE_0
:
16685 print_gnu_property_note (pnote
);
16689 /* Handle unrecognised types. An error message should have already been
16690 created by get_gnu_elf_note_type(), so all that we need to do is to
16691 display the data. */
16695 printf (_(" Description data: "));
16696 for (i
= 0; i
< pnote
->descsz
; ++i
)
16697 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
16706 static const char *
16707 get_v850_elf_note_type (enum v850_notes n_type
)
16709 static char buff
[64];
16713 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
16714 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
16715 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
16716 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
16717 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
16718 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
16720 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
16726 print_v850_note (Elf_Internal_Note
* pnote
)
16730 if (pnote
->descsz
!= 4)
16733 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
16737 printf (_("not set\n"));
16741 switch (pnote
->type
)
16743 case V850_NOTE_ALIGNMENT
:
16746 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return TRUE
;
16747 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return TRUE
;
16751 case V850_NOTE_DATA_SIZE
:
16754 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return TRUE
;
16755 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return TRUE
;
16759 case V850_NOTE_FPU_INFO
:
16762 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return TRUE
;
16763 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return TRUE
;
16767 case V850_NOTE_MMU_INFO
:
16768 case V850_NOTE_CACHE_INFO
:
16769 case V850_NOTE_SIMD_INFO
:
16770 if (val
== EF_RH850_SIMD
)
16772 printf (_("yes\n"));
16778 /* An 'unknown note type' message will already have been displayed. */
16782 printf (_("unknown value: %x\n"), val
);
16787 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
16789 unsigned int version
;
16791 switch (pnote
->type
)
16793 case NT_NETBSD_IDENT
:
16794 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
16795 if ((version
/ 10000) % 100)
16796 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
16797 version
, version
/ 100000000, (version
/ 1000000) % 100,
16798 (version
/ 10000) % 100 > 26 ? "Z" : "",
16799 'A' + (version
/ 10000) % 26);
16801 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
16802 version
, version
/ 100000000, (version
/ 1000000) % 100,
16803 (version
/ 100) % 100);
16806 case NT_NETBSD_MARCH
:
16807 printf (" NetBSD\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
16812 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote
->descsz
,
16818 static const char *
16819 get_freebsd_elfcore_note_type (unsigned e_type
)
16823 case NT_FREEBSD_THRMISC
:
16824 return _("NT_THRMISC (thrmisc structure)");
16825 case NT_FREEBSD_PROCSTAT_PROC
:
16826 return _("NT_PROCSTAT_PROC (proc data)");
16827 case NT_FREEBSD_PROCSTAT_FILES
:
16828 return _("NT_PROCSTAT_FILES (files data)");
16829 case NT_FREEBSD_PROCSTAT_VMMAP
:
16830 return _("NT_PROCSTAT_VMMAP (vmmap data)");
16831 case NT_FREEBSD_PROCSTAT_GROUPS
:
16832 return _("NT_PROCSTAT_GROUPS (groups data)");
16833 case NT_FREEBSD_PROCSTAT_UMASK
:
16834 return _("NT_PROCSTAT_UMASK (umask data)");
16835 case NT_FREEBSD_PROCSTAT_RLIMIT
:
16836 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
16837 case NT_FREEBSD_PROCSTAT_OSREL
:
16838 return _("NT_PROCSTAT_OSREL (osreldate data)");
16839 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
16840 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
16841 case NT_FREEBSD_PROCSTAT_AUXV
:
16842 return _("NT_PROCSTAT_AUXV (auxv data)");
16843 case NT_FREEBSD_PTLWPINFO
:
16844 return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
16846 return get_note_type (e_type
);
16849 static const char *
16850 get_netbsd_elfcore_note_type (unsigned e_type
)
16852 static char buff
[64];
16854 if (e_type
== NT_NETBSDCORE_PROCINFO
)
16856 /* NetBSD core "procinfo" structure. */
16857 return _("NetBSD procinfo structure");
16860 /* As of Jan 2002 there are no other machine-independent notes
16861 defined for NetBSD core files. If the note type is less
16862 than the start of the machine-dependent note types, we don't
16865 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
16867 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16871 switch (elf_header
.e_machine
)
16873 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
16874 and PT_GETFPREGS == mach+2. */
16879 case EM_SPARC32PLUS
:
16883 case NT_NETBSDCORE_FIRSTMACH
+ 0:
16884 return _("PT_GETREGS (reg structure)");
16885 case NT_NETBSDCORE_FIRSTMACH
+ 2:
16886 return _("PT_GETFPREGS (fpreg structure)");
16892 /* On all other arch's, PT_GETREGS == mach+1 and
16893 PT_GETFPREGS == mach+3. */
16897 case NT_NETBSDCORE_FIRSTMACH
+ 1:
16898 return _("PT_GETREGS (reg structure)");
16899 case NT_NETBSDCORE_FIRSTMACH
+ 3:
16900 return _("PT_GETFPREGS (fpreg structure)");
16906 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
16907 e_type
- NT_NETBSDCORE_FIRSTMACH
);
16911 static const char *
16912 get_stapsdt_note_type (unsigned e_type
)
16914 static char buff
[64];
16919 return _("NT_STAPSDT (SystemTap probe descriptors)");
16925 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16930 print_stapsdt_note (Elf_Internal_Note
*pnote
)
16932 int addr_size
= is_32bit_elf
? 4 : 8;
16933 char *data
= pnote
->descdata
;
16934 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
16935 bfd_vma pc
, base_addr
, semaphore
;
16936 char *provider
, *probe
, *arg_fmt
;
16938 pc
= byte_get ((unsigned char *) data
, addr_size
);
16940 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
16942 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
16946 data
+= strlen (data
) + 1;
16948 data
+= strlen (data
) + 1;
16950 data
+= strlen (data
) + 1;
16952 printf (_(" Provider: %s\n"), provider
);
16953 printf (_(" Name: %s\n"), probe
);
16954 printf (_(" Location: "));
16955 print_vma (pc
, FULL_HEX
);
16956 printf (_(", Base: "));
16957 print_vma (base_addr
, FULL_HEX
);
16958 printf (_(", Semaphore: "));
16959 print_vma (semaphore
, FULL_HEX
);
16961 printf (_(" Arguments: %s\n"), arg_fmt
);
16963 return data
== data_end
;
16966 static const char *
16967 get_ia64_vms_note_type (unsigned e_type
)
16969 static char buff
[64];
16974 return _("NT_VMS_MHD (module header)");
16976 return _("NT_VMS_LNM (language name)");
16978 return _("NT_VMS_SRC (source files)");
16980 return "NT_VMS_TITLE";
16982 return _("NT_VMS_EIDC (consistency check)");
16983 case NT_VMS_FPMODE
:
16984 return _("NT_VMS_FPMODE (FP mode)");
16985 case NT_VMS_LINKTIME
:
16986 return "NT_VMS_LINKTIME";
16987 case NT_VMS_IMGNAM
:
16988 return _("NT_VMS_IMGNAM (image name)");
16990 return _("NT_VMS_IMGID (image id)");
16991 case NT_VMS_LINKID
:
16992 return _("NT_VMS_LINKID (link id)");
16993 case NT_VMS_IMGBID
:
16994 return _("NT_VMS_IMGBID (build id)");
16995 case NT_VMS_GSTNAM
:
16996 return _("NT_VMS_GSTNAM (sym table name)");
16997 case NT_VMS_ORIG_DYN
:
16998 return "NT_VMS_ORIG_DYN";
16999 case NT_VMS_PATCHTIME
:
17000 return "NT_VMS_PATCHTIME";
17002 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17008 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
17010 switch (pnote
->type
)
17013 if (pnote
->descsz
> 36)
17015 size_t l
= strlen (pnote
->descdata
+ 34);
17016 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
17017 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
17018 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
17019 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
17022 printf (_(" Invalid size\n"));
17025 printf (_(" Language: %s\n"), pnote
->descdata
);
17028 case NT_VMS_FPMODE
:
17029 printf (_(" Floating Point mode: "));
17030 printf ("0x%016" BFD_VMA_FMT
"x\n",
17031 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
17033 case NT_VMS_LINKTIME
:
17034 printf (_(" Link time: "));
17036 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
17039 case NT_VMS_PATCHTIME
:
17040 printf (_(" Patch time: "));
17042 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
17045 case NT_VMS_ORIG_DYN
:
17046 printf (_(" Major id: %u, minor id: %u\n"),
17047 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
17048 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
17049 printf (_(" Last modified : "));
17051 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
17052 printf (_("\n Link flags : "));
17053 printf ("0x%016" BFD_VMA_FMT
"x\n",
17054 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
17055 printf (_(" Header flags: 0x%08x\n"),
17056 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
17057 printf (_(" Image id : %s\n"), pnote
->descdata
+ 32);
17060 case NT_VMS_IMGNAM
:
17061 printf (_(" Image name: %s\n"), pnote
->descdata
);
17063 case NT_VMS_GSTNAM
:
17064 printf (_(" Global symbol table name: %s\n"), pnote
->descdata
);
17067 printf (_(" Image id: %s\n"), pnote
->descdata
);
17069 case NT_VMS_LINKID
:
17070 printf (_(" Linker id: %s\n"), pnote
->descdata
);
17078 /* Print the name of the symbol associated with a build attribute
17079 that is attached to address OFFSET. */
17082 print_symbol_for_build_attribute (FILE * file
,
17083 unsigned long offset
,
17084 bfd_boolean is_open_attr
)
17086 static FILE * saved_file
= NULL
;
17087 static char * strtab
;
17088 static unsigned long strtablen
;
17089 static Elf_Internal_Sym
* symtab
;
17090 static unsigned long nsyms
;
17091 Elf_Internal_Sym
* saved_sym
= NULL
;
17092 Elf_Internal_Sym
* sym
;
17094 if (section_headers
!= NULL
17095 && (saved_file
== NULL
|| file
!= saved_file
))
17097 Elf_Internal_Shdr
* symsec
;
17099 /* Load the symbol and string sections. */
17100 for (symsec
= section_headers
;
17101 symsec
< section_headers
+ elf_header
.e_shnum
;
17104 if (symsec
->sh_type
== SHT_SYMTAB
)
17106 symtab
= GET_ELF_SYMBOLS (file
, symsec
, & nsyms
);
17108 if (symsec
->sh_link
< elf_header
.e_shnum
)
17110 Elf_Internal_Shdr
* strtab_sec
= section_headers
+ symsec
->sh_link
;
17112 strtab
= (char *) get_data (NULL
, file
, strtab_sec
->sh_offset
,
17113 1, strtab_sec
->sh_size
,
17114 _("string table"));
17115 strtablen
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
17122 if (symtab
== NULL
|| strtab
== NULL
)
17128 /* Find a symbol whose value matches offset. */
17129 for (sym
= symtab
; sym
< symtab
+ nsyms
; sym
++)
17130 if (sym
->st_value
== offset
)
17132 if (sym
->st_name
>= strtablen
)
17133 /* Huh ? This should not happen. */
17136 if (strtab
[sym
->st_name
] == 0)
17141 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
17142 and FILE or OBJECT symbols over NOTYPE symbols. We skip
17143 FUNC symbols entirely. */
17144 switch (ELF_ST_TYPE (sym
->st_info
))
17148 /* We can stop searching now. */
17149 sym
= symtab
+ nsyms
;
17157 /* Ignore function symbols. */
17164 switch (ELF_ST_BIND (sym
->st_info
))
17167 if (saved_sym
== NULL
17168 || ELF_ST_TYPE (saved_sym
->st_info
) != STT_OBJECT
)
17173 if (saved_sym
== NULL
)
17183 if (ELF_ST_TYPE (sym
->st_info
) != STT_FUNC
)
17191 printf (" (%s: %s)\n",
17192 is_open_attr
? _("file") : _("func"),
17193 saved_sym
? strtab
+ saved_sym
->st_name
: _("<no symbol found>)"));
17198 print_gnu_build_attribute_description (Elf_Internal_Note
* pnote
,
17201 static unsigned long global_offset
= 0;
17202 unsigned long offset
;
17203 unsigned int desc_size
= is_32bit_elf
? 4 : 8;
17204 bfd_boolean is_open_attr
= pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
;
17206 if (pnote
->descsz
== 0)
17210 printf (_(" Applies from offset %#lx\n"), global_offset
);
17215 printf (_(" Applies to func at %#lx"), global_offset
);
17216 return print_symbol_for_build_attribute (file
, global_offset
, is_open_attr
);
17220 if (pnote
->descsz
!= desc_size
)
17222 error (_(" <invalid description size: %lx>\n"), pnote
->descsz
);
17223 printf (_(" <invalid descsz>"));
17227 offset
= byte_get ((unsigned char *) pnote
->descdata
, desc_size
);
17231 printf (_(" Applies from offset %#lx"), offset
);
17232 global_offset
= offset
;
17236 printf (_(" Applies to func at %#lx"), offset
);
17239 return print_symbol_for_build_attribute (file
, offset
, is_open_attr
);
17243 print_gnu_build_attribute_name (Elf_Internal_Note
* pnote
)
17245 static const char string_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING
, 0 };
17246 static const char number_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
, 0 };
17247 static const char bool_expected
[3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
, 0 };
17249 char name_attribute
;
17250 const char * expected_types
;
17251 const char * name
= pnote
->namedata
;
17255 if (name
== NULL
|| pnote
->namesz
< 2)
17257 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
17258 print_symbol (-20, _(" <corrupt name>"));
17264 /* Version 2 of the spec adds a "GA" prefix to the name field. */
17265 if (name
[0] == 'G' && name
[1] == 'A')
17272 switch ((name_type
= * name
))
17274 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
17275 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
17276 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
17277 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
17278 printf ("%c", * name
);
17282 error (_("unrecognised attribute type in name field: %d\n"), name_type
);
17283 print_symbol (-20, _("<unknown name type>"));
17290 switch ((name_attribute
= * name
))
17292 case GNU_BUILD_ATTRIBUTE_VERSION
:
17293 text
= _("<version>");
17294 expected_types
= string_expected
;
17297 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
17298 text
= _("<stack prot>");
17299 expected_types
= "!+*";
17302 case GNU_BUILD_ATTRIBUTE_RELRO
:
17303 text
= _("<relro>");
17304 expected_types
= bool_expected
;
17307 case GNU_BUILD_ATTRIBUTE_STACK_SIZE
:
17308 text
= _("<stack size>");
17309 expected_types
= number_expected
;
17312 case GNU_BUILD_ATTRIBUTE_TOOL
:
17313 text
= _("<tool>");
17314 expected_types
= string_expected
;
17317 case GNU_BUILD_ATTRIBUTE_ABI
:
17319 expected_types
= "$*";
17322 case GNU_BUILD_ATTRIBUTE_PIC
:
17324 expected_types
= number_expected
;
17327 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM
:
17328 text
= _("<short enum>");
17329 expected_types
= bool_expected
;
17333 if (ISPRINT (* name
))
17335 int len
= strnlen (name
, pnote
->namesz
- (name
- pnote
->namedata
)) + 1;
17337 if (len
> left
&& ! do_wide
)
17339 printf ("%.*s:", len
, name
);
17345 static char tmpbuf
[128];
17347 error (_("unrecognised byte in name field: %d\n"), * name
);
17348 sprintf (tmpbuf
, _("<unknown:_%d>"), * name
);
17352 expected_types
= "*$!+";
17357 left
-= printf ("%s", text
);
17359 if (strchr (expected_types
, name_type
) == NULL
)
17360 warn (_("attribute does not have an expected type (%c)\n"), name_type
);
17362 if ((unsigned long)(name
- pnote
->namedata
) > pnote
->namesz
)
17364 error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
17365 (unsigned long) pnote
->namesz
,
17366 (long) (name
- pnote
->namedata
));
17370 if (left
< 1 && ! do_wide
)
17375 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
17377 unsigned int bytes
;
17378 unsigned long long val
= 0;
17379 unsigned int shift
= 0;
17380 char * decoded
= NULL
;
17382 bytes
= pnote
->namesz
- (name
- pnote
->namedata
);
17384 /* The -1 is because the name field is always 0 terminated, and we
17385 want to be able to ensure that the shift in the while loop below
17386 will not overflow. */
17389 if (bytes
> sizeof (val
))
17391 fprintf (stderr
, "namesz %lx name %p namedata %p\n",
17392 pnote
->namesz
, name
, pnote
->namedata
);
17393 error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
17395 bytes
= sizeof (val
);
17397 /* We do not bother to warn if bytes == 0 as this can
17398 happen with some early versions of the gcc plugin. */
17402 unsigned long byte
= (* name
++) & 0xff;
17404 val
|= byte
<< shift
;
17408 switch (name_attribute
)
17410 case GNU_BUILD_ATTRIBUTE_PIC
:
17413 case 0: decoded
= "static"; break;
17414 case 1: decoded
= "pic"; break;
17415 case 2: decoded
= "PIC"; break;
17416 case 3: decoded
= "pie"; break;
17417 case 4: decoded
= "PIE"; break;
17421 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
17424 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
17425 case 0: decoded
= "off"; break;
17426 case 1: decoded
= "on"; break;
17427 case 2: decoded
= "all"; break;
17428 case 3: decoded
= "strong"; break;
17429 case 4: decoded
= "explicit"; break;
17437 if (decoded
!= NULL
)
17439 print_symbol (-left
, decoded
);
17450 left
-= printf ("0x%llx", val
);
17452 left
-= printf ("0x%-.*llx", left
, val
);
17456 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
17457 left
-= print_symbol (- left
, name
);
17459 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
17460 left
-= print_symbol (- left
, "true");
17462 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
17463 left
-= print_symbol (- left
, "false");
17467 if (do_wide
&& left
> 0)
17468 printf ("%-*s", left
, " ");
17473 /* Note that by the ELF standard, the name field is already null byte
17474 terminated, and namesz includes the terminating null byte.
17475 I.E. the value of namesz for the name "FSF" is 4.
17477 If the value of namesz is zero, there is no name present. */
17480 process_note (Elf_Internal_Note
* pnote
,
17483 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
17486 if (pnote
->namesz
== 0)
17487 /* If there is no note name, then use the default set of
17488 note type strings. */
17489 nt
= get_note_type (pnote
->type
);
17491 else if (const_strneq (pnote
->namedata
, "GNU"))
17492 /* GNU-specific object file notes. */
17493 nt
= get_gnu_elf_note_type (pnote
->type
);
17495 else if (const_strneq (pnote
->namedata
, "FreeBSD"))
17496 /* FreeBSD-specific core file notes. */
17497 nt
= get_freebsd_elfcore_note_type (pnote
->type
);
17499 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
17500 /* NetBSD-specific core file notes. */
17501 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
17503 else if (const_strneq (pnote
->namedata
, "NetBSD"))
17504 /* NetBSD-specific core file notes. */
17505 return process_netbsd_elf_note (pnote
);
17507 else if (strneq (pnote
->namedata
, "SPU/", 4))
17509 /* SPU-specific core file notes. */
17510 nt
= pnote
->namedata
+ 4;
17514 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
17515 /* VMS/ia64-specific file notes. */
17516 nt
= get_ia64_vms_note_type (pnote
->type
);
17518 else if (const_strneq (pnote
->namedata
, "stapsdt"))
17519 nt
= get_stapsdt_note_type (pnote
->type
);
17522 /* Don't recognize this note name; just use the default set of
17523 note type strings. */
17524 nt
= get_note_type (pnote
->type
);
17528 if (((const_strneq (pnote
->namedata
, "GA")
17529 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
17530 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
17531 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
17532 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
17533 print_gnu_build_attribute_name (pnote
);
17535 print_symbol (-20, name
);
17538 printf (" 0x%08lx\t%s\t", pnote
->descsz
, nt
);
17540 printf (" 0x%08lx\t%s\n", pnote
->descsz
, nt
);
17542 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
17543 return print_ia64_vms_note (pnote
);
17544 else if (const_strneq (pnote
->namedata
, "GNU"))
17545 return print_gnu_note (pnote
);
17546 else if (const_strneq (pnote
->namedata
, "stapsdt"))
17547 return print_stapsdt_note (pnote
);
17548 else if (const_strneq (pnote
->namedata
, "CORE"))
17549 return print_core_note (pnote
);
17550 else if (((const_strneq (pnote
->namedata
, "GA")
17551 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
17552 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
17553 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
17554 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
17555 return print_gnu_build_attribute_description (pnote
, file
);
17561 printf (_(" description data: "));
17562 for (i
= 0; i
< pnote
->descsz
; i
++)
17563 printf ("%02x ", pnote
->descdata
[i
]);
17575 process_notes_at (FILE * file
,
17576 Elf_Internal_Shdr
* section
,
17580 Elf_External_Note
* pnotes
;
17581 Elf_External_Note
* external
;
17583 bfd_boolean res
= TRUE
;
17590 pnotes
= (Elf_External_Note
*) get_section_contents (section
, file
);
17593 if (! apply_relocations (file
, section
, (unsigned char *) pnotes
, length
, NULL
, NULL
))
17598 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
17600 if (pnotes
== NULL
)
17606 printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (section
));
17608 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
17609 (unsigned long) offset
, (unsigned long) length
);
17611 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
17613 end
= (char *) pnotes
+ length
;
17614 while ((char *) external
< end
)
17616 Elf_Internal_Note inote
;
17619 char * temp
= NULL
;
17620 size_t data_remaining
= end
- (char *) external
;
17622 if (!is_ia64_vms ())
17624 /* PR binutils/15191
17625 Make sure that there is enough data to read. */
17626 min_notesz
= offsetof (Elf_External_Note
, name
);
17627 if (data_remaining
< min_notesz
)
17629 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
17630 (int) data_remaining
);
17633 inote
.type
= BYTE_GET (external
->type
);
17634 inote
.namesz
= BYTE_GET (external
->namesz
);
17635 inote
.namedata
= external
->name
;
17636 inote
.descsz
= BYTE_GET (external
->descsz
);
17637 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
17638 /* PR 17531: file: 3443835e. */
17639 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
> end
)
17641 warn (_("Corrupt note: name size is too big: (got: %lx, expected no more than: %lx)\n"),
17642 inote
.namesz
, (long)(end
- inote
.namedata
));
17643 inote
.descdata
= inote
.namedata
;
17647 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
17648 next
= inote
.descdata
+ align_power (inote
.descsz
, 2);
17652 Elf64_External_VMS_Note
*vms_external
;
17654 /* PR binutils/15191
17655 Make sure that there is enough data to read. */
17656 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
17657 if (data_remaining
< min_notesz
)
17659 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
17660 (int) data_remaining
);
17664 vms_external
= (Elf64_External_VMS_Note
*) external
;
17665 inote
.type
= BYTE_GET (vms_external
->type
);
17666 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
17667 inote
.namedata
= vms_external
->name
;
17668 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
17669 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
17670 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
17671 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
17674 if (inote
.descdata
< (char *) external
+ min_notesz
17675 || next
< (char *) external
+ min_notesz
17676 /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
17677 || inote
.namedata
+ inote
.namesz
< inote
.namedata
17678 || inote
.descdata
+ inote
.descsz
< inote
.descdata
17679 || data_remaining
< (size_t)(next
- (char *) external
))
17681 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
17682 (unsigned long) ((char *) external
- (char *) pnotes
));
17683 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
17684 inote
.type
, inote
.namesz
, inote
.descsz
);
17688 external
= (Elf_External_Note
*) next
;
17690 /* Verify that name is null terminated. It appears that at least
17691 one version of Linux (RedHat 6.0) generates corefiles that don't
17692 comply with the ELF spec by failing to include the null byte in
17694 if (inote
.namedata
[inote
.namesz
- 1] != '\0')
17696 temp
= (char *) malloc (inote
.namesz
+ 1);
17699 error (_("Out of memory allocating space for inote name\n"));
17704 memcpy (temp
, inote
.namedata
, inote
.namesz
);
17705 temp
[inote
.namesz
] = 0;
17707 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
17708 inote
.namedata
= temp
;
17711 if (! process_note (& inote
, file
))
17727 process_corefile_note_segments (FILE * file
)
17729 Elf_Internal_Phdr
* segment
;
17731 bfd_boolean res
= TRUE
;
17733 if (! get_program_headers (file
))
17736 for (i
= 0, segment
= program_headers
;
17737 i
< elf_header
.e_phnum
;
17740 if (segment
->p_type
== PT_NOTE
)
17741 if (! process_notes_at (file
, NULL
,
17742 (bfd_vma
) segment
->p_offset
,
17743 (bfd_vma
) segment
->p_filesz
))
17751 process_v850_notes (FILE * file
, bfd_vma offset
, bfd_vma length
)
17753 Elf_External_Note
* pnotes
;
17754 Elf_External_Note
* external
;
17756 bfd_boolean res
= TRUE
;
17761 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
17763 if (pnotes
== NULL
)
17767 end
= (char*) pnotes
+ length
;
17769 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
17770 (unsigned long) offset
, (unsigned long) length
);
17772 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
17774 Elf_External_Note
* next
;
17775 Elf_Internal_Note inote
;
17777 inote
.type
= BYTE_GET (external
->type
);
17778 inote
.namesz
= BYTE_GET (external
->namesz
);
17779 inote
.namedata
= external
->name
;
17780 inote
.descsz
= BYTE_GET (external
->descsz
);
17781 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
17782 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
17784 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
17786 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
17787 inote
.descdata
= inote
.namedata
;
17791 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
17793 if ( ((char *) next
> end
)
17794 || ((char *) next
< (char *) pnotes
))
17796 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
17797 (unsigned long) ((char *) external
- (char *) pnotes
));
17798 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
17799 inote
.type
, inote
.namesz
, inote
.descsz
);
17805 /* Prevent out-of-bounds indexing. */
17806 if ( inote
.namedata
+ inote
.namesz
> end
17807 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
17809 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
17810 (unsigned long) ((char *) external
- (char *) pnotes
));
17811 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
17812 inote
.type
, inote
.namesz
, inote
.descsz
);
17816 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
17818 if (! print_v850_note (& inote
))
17821 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
17822 inote
.namesz
, inote
.descsz
);
17832 process_note_sections (FILE * file
)
17834 Elf_Internal_Shdr
* section
;
17836 unsigned int n
= 0;
17837 bfd_boolean res
= TRUE
;
17839 for (i
= 0, section
= section_headers
;
17840 i
< elf_header
.e_shnum
&& section
!= NULL
;
17843 if (section
->sh_type
== SHT_NOTE
)
17845 if (! process_notes_at (file
, section
,
17846 (bfd_vma
) section
->sh_offset
,
17847 (bfd_vma
) section
->sh_size
))
17852 if (( elf_header
.e_machine
== EM_V800
17853 || elf_header
.e_machine
== EM_V850
17854 || elf_header
.e_machine
== EM_CYGNUS_V850
)
17855 && section
->sh_type
== SHT_RENESAS_INFO
)
17857 if (! process_v850_notes (file
,
17858 (bfd_vma
) section
->sh_offset
,
17859 (bfd_vma
) section
->sh_size
))
17866 /* Try processing NOTE segments instead. */
17867 return process_corefile_note_segments (file
);
17873 process_notes (FILE * file
)
17875 /* If we have not been asked to display the notes then do nothing. */
17879 if (elf_header
.e_type
!= ET_CORE
)
17880 return process_note_sections (file
);
17882 /* No program headers means no NOTE segment. */
17883 if (elf_header
.e_phnum
> 0)
17884 return process_corefile_note_segments (file
);
17886 printf (_("No note segments present in the core file.\n"));
17890 static unsigned char *
17891 display_public_gnu_attributes (unsigned char * start
,
17892 const unsigned char * const end
)
17894 printf (_(" Unknown GNU attribute: %s\n"), start
);
17896 start
+= strnlen ((char *) start
, end
- start
);
17897 display_raw_attribute (start
, end
);
17899 return (unsigned char *) end
;
17902 static unsigned char *
17903 display_generic_attribute (unsigned char * start
,
17905 const unsigned char * const end
)
17908 return (unsigned char *) end
;
17910 return display_tag_value (tag
, start
, end
);
17914 process_arch_specific (FILE * file
)
17919 switch (elf_header
.e_machine
)
17922 case EM_ARC_COMPACT
:
17923 case EM_ARC_COMPACT2
:
17924 return process_attributes (file
, "ARC", SHT_ARC_ATTRIBUTES
,
17925 display_arc_attribute
,
17926 display_generic_attribute
);
17928 return process_attributes (file
, "aeabi", SHT_ARM_ATTRIBUTES
,
17929 display_arm_attribute
,
17930 display_generic_attribute
);
17933 case EM_MIPS_RS3_LE
:
17934 return process_mips_specific (file
);
17937 return process_attributes (file
, "mspabi", SHT_MSP430_ATTRIBUTES
,
17938 display_msp430x_attribute
,
17939 display_generic_attribute
);
17942 return process_nds32_specific (file
);
17946 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
17947 display_power_gnu_attribute
);
17951 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
17952 display_s390_gnu_attribute
);
17955 case EM_SPARC32PLUS
:
17957 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
17958 display_sparc_gnu_attribute
);
17961 return process_attributes (file
, "c6xabi", SHT_C6000_ATTRIBUTES
,
17962 display_tic6x_attribute
,
17963 display_generic_attribute
);
17966 return process_attributes (file
, "gnu", SHT_GNU_ATTRIBUTES
,
17967 display_public_gnu_attributes
,
17968 display_generic_attribute
);
17973 get_file_header (FILE * file
)
17975 /* Read in the identity array. */
17976 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
17979 /* Determine how to read the rest of the header. */
17980 switch (elf_header
.e_ident
[EI_DATA
])
17985 byte_get
= byte_get_little_endian
;
17986 byte_put
= byte_put_little_endian
;
17989 byte_get
= byte_get_big_endian
;
17990 byte_put
= byte_put_big_endian
;
17994 /* For now we only support 32 bit and 64 bit ELF files. */
17995 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
17997 /* Read in the rest of the header. */
18000 Elf32_External_Ehdr ehdr32
;
18002 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
18005 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
18006 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
18007 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
18008 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
18009 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
18010 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
18011 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
18012 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
18013 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
18014 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
18015 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
18016 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
18017 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
18021 Elf64_External_Ehdr ehdr64
;
18023 /* If we have been compiled with sizeof (bfd_vma) == 4, then
18024 we will not be able to cope with the 64bit data found in
18025 64 ELF files. Detect this now and abort before we start
18026 overwriting things. */
18027 if (sizeof (bfd_vma
) < 8)
18029 error (_("This instance of readelf has been built without support for a\n\
18030 64 bit data type and so it cannot read 64 bit ELF files.\n"));
18034 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
18037 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
18038 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
18039 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
18040 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
18041 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
18042 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
18043 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
18044 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
18045 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
18046 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
18047 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
18048 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
18049 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
18052 if (elf_header
.e_shoff
)
18054 /* There may be some extensions in the first section header. Don't
18055 bomb if we can't read it. */
18057 get_32bit_section_headers (file
, TRUE
);
18059 get_64bit_section_headers (file
, TRUE
);
18065 /* Process one ELF object file according to the command line options.
18066 This file may actually be stored in an archive. The file is
18067 positioned at the start of the ELF object. Returns TRUE if no
18068 problems were encountered, FALSE otherwise. */
18071 process_object (char * file_name
, FILE * file
)
18074 bfd_boolean res
= TRUE
;
18076 if (! get_file_header (file
))
18078 error (_("%s: Failed to read file header\n"), file_name
);
18082 /* Initialise per file variables. */
18083 for (i
= ARRAY_SIZE (version_info
); i
--;)
18084 version_info
[i
] = 0;
18086 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
18087 dynamic_info
[i
] = 0;
18088 dynamic_info_DT_GNU_HASH
= 0;
18090 /* Process the file. */
18092 printf (_("\nFile: %s\n"), file_name
);
18094 /* Initialise the dump_sects array from the cmdline_dump_sects array.
18095 Note we do this even if cmdline_dump_sects is empty because we
18096 must make sure that the dump_sets array is zeroed out before each
18097 object file is processed. */
18098 if (num_dump_sects
> num_cmdline_dump_sects
)
18099 memset (dump_sects
, 0, num_dump_sects
* sizeof (* dump_sects
));
18101 if (num_cmdline_dump_sects
> 0)
18103 if (num_dump_sects
== 0)
18104 /* A sneaky way of allocating the dump_sects array. */
18105 request_dump_bynumber (num_cmdline_dump_sects
, 0);
18107 assert (num_dump_sects
>= num_cmdline_dump_sects
);
18108 memcpy (dump_sects
, cmdline_dump_sects
,
18109 num_cmdline_dump_sects
* sizeof (* dump_sects
));
18112 if (! process_file_header ())
18115 if (! process_section_headers (file
))
18117 /* Without loaded section headers we cannot process lots of things. */
18118 do_unwind
= do_version
= do_dump
= do_arch
= FALSE
;
18120 if (! do_using_dynamic
)
18121 do_syms
= do_dyn_syms
= do_reloc
= FALSE
;
18124 if (! process_section_groups (file
))
18125 /* Without loaded section groups we cannot process unwind. */
18128 if (process_program_headers (file
))
18129 process_dynamic_section (file
);
18133 if (! process_relocs (file
))
18136 if (! process_unwind (file
))
18139 if (! process_symbol_table (file
))
18142 if (! process_syminfo (file
))
18145 if (! process_version_sections (file
))
18148 if (! process_section_contents (file
))
18151 if (! process_notes (file
))
18154 if (! process_gnu_liblist (file
))
18157 if (! process_arch_specific (file
))
18160 if (program_headers
)
18162 free (program_headers
);
18163 program_headers
= NULL
;
18166 if (section_headers
)
18168 free (section_headers
);
18169 section_headers
= NULL
;
18174 free (string_table
);
18175 string_table
= NULL
;
18176 string_table_length
= 0;
18179 if (dynamic_strings
)
18181 free (dynamic_strings
);
18182 dynamic_strings
= NULL
;
18183 dynamic_strings_length
= 0;
18186 if (dynamic_symbols
)
18188 free (dynamic_symbols
);
18189 dynamic_symbols
= NULL
;
18190 num_dynamic_syms
= 0;
18193 if (dynamic_syminfo
)
18195 free (dynamic_syminfo
);
18196 dynamic_syminfo
= NULL
;
18199 if (dynamic_section
)
18201 free (dynamic_section
);
18202 dynamic_section
= NULL
;
18205 if (section_headers_groups
)
18207 free (section_headers_groups
);
18208 section_headers_groups
= NULL
;
18211 if (section_groups
)
18213 struct group_list
* g
;
18214 struct group_list
* next
;
18216 for (i
= 0; i
< group_count
; i
++)
18218 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
18225 free (section_groups
);
18226 section_groups
= NULL
;
18229 free_debug_memory ();
18234 /* Process an ELF archive.
18235 On entry the file is positioned just after the ARMAG string.
18236 Returns TRUE upon success, FALSE otherwise. */
18239 process_archive (char * file_name
, FILE * file
, bfd_boolean is_thin_archive
)
18241 struct archive_info arch
;
18242 struct archive_info nested_arch
;
18244 bfd_boolean ret
= TRUE
;
18248 /* The ARCH structure is used to hold information about this archive. */
18249 arch
.file_name
= NULL
;
18251 arch
.index_array
= NULL
;
18252 arch
.sym_table
= NULL
;
18253 arch
.longnames
= NULL
;
18255 /* The NESTED_ARCH structure is used as a single-item cache of information
18256 about a nested archive (when members of a thin archive reside within
18257 another regular archive file). */
18258 nested_arch
.file_name
= NULL
;
18259 nested_arch
.file
= NULL
;
18260 nested_arch
.index_array
= NULL
;
18261 nested_arch
.sym_table
= NULL
;
18262 nested_arch
.longnames
= NULL
;
18264 if (setup_archive (&arch
, file_name
, file
, is_thin_archive
, do_archive_index
) != 0)
18270 if (do_archive_index
)
18272 if (arch
.sym_table
== NULL
)
18273 error (_("%s: unable to dump the index as none was found\n"), file_name
);
18276 unsigned long i
, l
;
18277 unsigned long current_pos
;
18279 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
18280 file_name
, (unsigned long) arch
.index_num
, arch
.sym_size
);
18281 current_pos
= ftell (file
);
18283 for (i
= l
= 0; i
< arch
.index_num
; i
++)
18285 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
18287 char * member_name
;
18289 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
18291 if (member_name
!= NULL
)
18293 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
18295 if (qualified_name
!= NULL
)
18297 printf (_("Contents of binary %s at offset "), qualified_name
);
18298 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
18300 free (qualified_name
);
18305 if (l
>= arch
.sym_size
)
18307 error (_("%s: end of the symbol table reached before the end of the index\n"),
18312 /* PR 17531: file: 0b6630b2. */
18313 printf ("\t%.*s\n", (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
18314 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
18317 if (arch
.uses_64bit_indicies
)
18322 if (l
< arch
.sym_size
)
18324 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
18325 file_name
, arch
.sym_size
- l
);
18329 if (fseek (file
, current_pos
, SEEK_SET
) != 0)
18331 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name
);
18337 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
18338 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
18339 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
18340 && !do_section_groups
&& !do_dyn_syms
)
18342 ret
= TRUE
; /* Archive index only. */
18351 char * qualified_name
;
18353 /* Read the next archive header. */
18354 if (fseek (file
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
18356 error (_("%s: failed to seek to next archive header\n"), file_name
);
18359 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, file
);
18360 if (got
!= sizeof arch
.arhdr
)
18364 error (_("%s: failed to read archive header\n"), file_name
);
18368 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
18370 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
18375 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
18377 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
18378 if (archive_file_size
& 01)
18379 ++archive_file_size
;
18381 name
= get_archive_member_name (&arch
, &nested_arch
);
18384 error (_("%s: bad archive file name\n"), file_name
);
18388 namelen
= strlen (name
);
18390 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
18391 if (qualified_name
== NULL
)
18393 error (_("%s: bad archive file name\n"), file_name
);
18398 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
18400 /* This is a proxy for an external member of a thin archive. */
18401 FILE * member_file
;
18402 char * member_file_name
= adjust_relative_path (file_name
, name
, namelen
);
18404 if (member_file_name
== NULL
)
18410 member_file
= fopen (member_file_name
, "rb");
18411 if (member_file
== NULL
)
18413 error (_("Input file '%s' is not readable.\n"), member_file_name
);
18414 free (member_file_name
);
18419 archive_file_offset
= arch
.nested_member_origin
;
18421 if (! process_object (qualified_name
, member_file
))
18424 fclose (member_file
);
18425 free (member_file_name
);
18427 else if (is_thin_archive
)
18429 /* PR 15140: Allow for corrupt thin archives. */
18430 if (nested_arch
.file
== NULL
)
18432 error (_("%s: contains corrupt thin archive: %s\n"),
18438 /* This is a proxy for a member of a nested archive. */
18439 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
18441 /* The nested archive file will have been opened and setup by
18442 get_archive_member_name. */
18443 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
18445 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
18450 if (! process_object (qualified_name
, nested_arch
.file
))
18455 archive_file_offset
= arch
.next_arhdr_offset
;
18456 arch
.next_arhdr_offset
+= archive_file_size
;
18458 if (! process_object (qualified_name
, file
))
18462 if (dump_sects
!= NULL
)
18466 num_dump_sects
= 0;
18469 free (qualified_name
);
18473 if (nested_arch
.file
!= NULL
)
18474 fclose (nested_arch
.file
);
18475 release_archive (&nested_arch
);
18476 release_archive (&arch
);
18482 process_file (char * file_name
)
18485 struct stat statbuf
;
18486 char armag
[SARMAG
];
18487 bfd_boolean ret
= TRUE
;
18489 if (stat (file_name
, &statbuf
) < 0)
18491 if (errno
== ENOENT
)
18492 error (_("'%s': No such file\n"), file_name
);
18494 error (_("Could not locate '%s'. System error message: %s\n"),
18495 file_name
, strerror (errno
));
18499 if (! S_ISREG (statbuf
.st_mode
))
18501 error (_("'%s' is not an ordinary file\n"), file_name
);
18505 file
= fopen (file_name
, "rb");
18508 error (_("Input file '%s' is not readable.\n"), file_name
);
18512 if (fread (armag
, SARMAG
, 1, file
) != 1)
18514 error (_("%s: Failed to read file's magic number\n"), file_name
);
18519 current_file_size
= (bfd_size_type
) statbuf
.st_size
;
18521 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
18523 if (! process_archive (file_name
, file
, FALSE
))
18526 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
18528 if ( ! process_archive (file_name
, file
, TRUE
))
18533 if (do_archive_index
)
18534 error (_("File %s is not an archive so its index cannot be displayed.\n"),
18538 archive_file_size
= archive_file_offset
= 0;
18540 if (! process_object (file_name
, file
))
18545 current_file_size
= 0;
18550 #ifdef SUPPORT_DISASSEMBLY
18551 /* Needed by the i386 disassembler. For extra credit, someone could
18552 fix this so that we insert symbolic addresses here, esp for GOT/PLT
18556 print_address (unsigned int addr
, FILE * outfile
)
18558 fprintf (outfile
,"0x%8.8x", addr
);
18561 /* Needed by the i386 disassembler. */
18563 db_task_printsym (unsigned int addr
)
18565 print_address (addr
, stderr
);
18570 main (int argc
, char ** argv
)
18574 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
18575 setlocale (LC_MESSAGES
, "");
18577 #if defined (HAVE_SETLOCALE)
18578 setlocale (LC_CTYPE
, "");
18580 bindtextdomain (PACKAGE
, LOCALEDIR
);
18581 textdomain (PACKAGE
);
18583 expandargv (&argc
, &argv
);
18585 parse_args (argc
, argv
);
18587 if (num_dump_sects
> 0)
18589 /* Make a copy of the dump_sects array. */
18590 cmdline_dump_sects
= (dump_type
*)
18591 malloc (num_dump_sects
* sizeof (* dump_sects
));
18592 if (cmdline_dump_sects
== NULL
)
18593 error (_("Out of memory allocating dump request table.\n"));
18596 memcpy (cmdline_dump_sects
, dump_sects
,
18597 num_dump_sects
* sizeof (* dump_sects
));
18598 num_cmdline_dump_sects
= num_dump_sects
;
18602 if (optind
< (argc
- 1))
18604 else if (optind
>= argc
)
18606 warn (_("Nothing to do.\n"));
18611 while (optind
< argc
)
18612 if (! process_file (argv
[optind
++]))
18615 if (dump_sects
!= NULL
)
18617 if (cmdline_dump_sects
!= NULL
)
18618 free (cmdline_dump_sects
);
18620 return err
? EXIT_FAILURE
: EXIT_SUCCESS
;