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_5900
: strcat (buf
, ", 5900"); break;
3329 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
3330 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
3331 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
3332 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
3333 case E_MIPS_MACH_LS3A
: strcat (buf
, ", loongson-3a"); break;
3334 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
3335 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
3336 case E_MIPS_MACH_OCTEON3
: strcat (buf
, ", octeon3"); break;
3337 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
3338 case E_MIPS_MACH_IAMR2
: strcat (buf
, ", interaptiv-mr2"); break;
3340 /* We simply ignore the field in this case to avoid confusion:
3341 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3344 default: strcat (buf
, _(", unknown CPU")); break;
3347 switch ((e_flags
& EF_MIPS_ABI
))
3349 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
3350 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
3351 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
3352 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
3354 /* We simply ignore the field in this case to avoid confusion:
3355 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3356 This means it is likely to be an o32 file, but not for
3359 default: strcat (buf
, _(", unknown ABI")); break;
3362 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
3363 strcat (buf
, ", mdmx");
3365 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
3366 strcat (buf
, ", mips16");
3368 if (e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
3369 strcat (buf
, ", micromips");
3371 switch ((e_flags
& EF_MIPS_ARCH
))
3373 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
3374 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
3375 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
3376 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
3377 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
3378 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
3379 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
3380 case E_MIPS_ARCH_32R6
: strcat (buf
, ", mips32r6"); break;
3381 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
3382 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
3383 case E_MIPS_ARCH_64R6
: strcat (buf
, ", mips64r6"); break;
3384 default: strcat (buf
, _(", unknown ISA")); break;
3389 decode_NDS32_machine_flags (e_flags
, buf
, sizeof buf
);
3393 if (e_flags
& EF_RISCV_RVC
)
3394 strcat (buf
, ", RVC");
3396 switch (e_flags
& EF_RISCV_FLOAT_ABI
)
3398 case EF_RISCV_FLOAT_ABI_SOFT
:
3399 strcat (buf
, ", soft-float ABI");
3402 case EF_RISCV_FLOAT_ABI_SINGLE
:
3403 strcat (buf
, ", single-float ABI");
3406 case EF_RISCV_FLOAT_ABI_DOUBLE
:
3407 strcat (buf
, ", double-float ABI");
3410 case EF_RISCV_FLOAT_ABI_QUAD
:
3411 strcat (buf
, ", quad-float ABI");
3417 switch ((e_flags
& EF_SH_MACH_MASK
))
3419 case EF_SH1
: strcat (buf
, ", sh1"); break;
3420 case EF_SH2
: strcat (buf
, ", sh2"); break;
3421 case EF_SH3
: strcat (buf
, ", sh3"); break;
3422 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
3423 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
3424 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
3425 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
3426 case EF_SH4
: strcat (buf
, ", sh4"); break;
3427 case EF_SH5
: strcat (buf
, ", sh5"); break;
3428 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
3429 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
3430 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
3431 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
3432 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
3433 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
3434 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
3435 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
3436 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3437 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
3438 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
3439 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
3440 default: strcat (buf
, _(", unknown ISA")); break;
3443 if (e_flags
& EF_SH_PIC
)
3444 strcat (buf
, ", pic");
3446 if (e_flags
& EF_SH_FDPIC
)
3447 strcat (buf
, ", fdpic");
3451 if (e_flags
& EF_OR1K_NODELAY
)
3452 strcat (buf
, ", no delay");
3456 if (e_flags
& EF_SPARC_32PLUS
)
3457 strcat (buf
, ", v8+");
3459 if (e_flags
& EF_SPARC_SUN_US1
)
3460 strcat (buf
, ", ultrasparcI");
3462 if (e_flags
& EF_SPARC_SUN_US3
)
3463 strcat (buf
, ", ultrasparcIII");
3465 if (e_flags
& EF_SPARC_HAL_R1
)
3466 strcat (buf
, ", halr1");
3468 if (e_flags
& EF_SPARC_LEDATA
)
3469 strcat (buf
, ", ledata");
3471 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
3472 strcat (buf
, ", tso");
3474 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
3475 strcat (buf
, ", pso");
3477 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
3478 strcat (buf
, ", rmo");
3482 switch (e_flags
& EF_PARISC_ARCH
)
3484 case EFA_PARISC_1_0
:
3485 strcpy (buf
, ", PA-RISC 1.0");
3487 case EFA_PARISC_1_1
:
3488 strcpy (buf
, ", PA-RISC 1.1");
3490 case EFA_PARISC_2_0
:
3491 strcpy (buf
, ", PA-RISC 2.0");
3496 if (e_flags
& EF_PARISC_TRAPNIL
)
3497 strcat (buf
, ", trapnil");
3498 if (e_flags
& EF_PARISC_EXT
)
3499 strcat (buf
, ", ext");
3500 if (e_flags
& EF_PARISC_LSB
)
3501 strcat (buf
, ", lsb");
3502 if (e_flags
& EF_PARISC_WIDE
)
3503 strcat (buf
, ", wide");
3504 if (e_flags
& EF_PARISC_NO_KABP
)
3505 strcat (buf
, ", no kabp");
3506 if (e_flags
& EF_PARISC_LAZYSWAP
)
3507 strcat (buf
, ", lazyswap");
3512 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
3513 strcat (buf
, ", new calling convention");
3515 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
3516 strcat (buf
, ", gnu calling convention");
3520 if ((e_flags
& EF_IA_64_ABI64
))
3521 strcat (buf
, ", 64-bit");
3523 strcat (buf
, ", 32-bit");
3524 if ((e_flags
& EF_IA_64_REDUCEDFP
))
3525 strcat (buf
, ", reduced fp model");
3526 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
3527 strcat (buf
, ", no function descriptors, constant gp");
3528 else if ((e_flags
& EF_IA_64_CONS_GP
))
3529 strcat (buf
, ", constant gp");
3530 if ((e_flags
& EF_IA_64_ABSOLUTE
))
3531 strcat (buf
, ", absolute");
3532 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
3534 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
3535 strcat (buf
, ", vms_linkages");
3536 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
3538 case EF_IA_64_VMS_COMCOD_SUCCESS
:
3540 case EF_IA_64_VMS_COMCOD_WARNING
:
3541 strcat (buf
, ", warning");
3543 case EF_IA_64_VMS_COMCOD_ERROR
:
3544 strcat (buf
, ", error");
3546 case EF_IA_64_VMS_COMCOD_ABORT
:
3547 strcat (buf
, ", abort");
3550 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3551 e_flags
& EF_IA_64_VMS_COMCOD
);
3552 strcat (buf
, ", <unknown>");
3558 if ((e_flags
& EF_VAX_NONPIC
))
3559 strcat (buf
, ", non-PIC");
3560 if ((e_flags
& EF_VAX_DFLOAT
))
3561 strcat (buf
, ", D-Float");
3562 if ((e_flags
& EF_VAX_GFLOAT
))
3563 strcat (buf
, ", G-Float");
3567 if (e_flags
& EF_VISIUM_ARCH_MCM
)
3568 strcat (buf
, ", mcm");
3569 else if (e_flags
& EF_VISIUM_ARCH_MCM24
)
3570 strcat (buf
, ", mcm24");
3571 if (e_flags
& EF_VISIUM_ARCH_GR6
)
3572 strcat (buf
, ", gr6");
3576 switch (e_flags
& E_FLAG_RL78_CPU_MASK
)
3578 case E_FLAG_RL78_ANY_CPU
: break;
3579 case E_FLAG_RL78_G10
: strcat (buf
, ", G10"); break;
3580 case E_FLAG_RL78_G13
: strcat (buf
, ", G13"); break;
3581 case E_FLAG_RL78_G14
: strcat (buf
, ", G14"); break;
3583 if (e_flags
& E_FLAG_RL78_64BIT_DOUBLES
)
3584 strcat (buf
, ", 64-bit doubles");
3588 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
3589 strcat (buf
, ", 64-bit doubles");
3590 if (e_flags
& E_FLAG_RX_DSP
)
3591 strcat (buf
, ", dsp");
3592 if (e_flags
& E_FLAG_RX_PID
)
3593 strcat (buf
, ", pid");
3594 if (e_flags
& E_FLAG_RX_ABI
)
3595 strcat (buf
, ", RX ABI");
3596 if (e_flags
& E_FLAG_RX_SINSNS_SET
)
3597 strcat (buf
, e_flags
& E_FLAG_RX_SINSNS_YES
3598 ? ", uses String instructions" : ", bans String instructions");
3599 if (e_flags
& E_FLAG_RX_V2
)
3600 strcat (buf
, ", V2");
3604 if (e_flags
& EF_S390_HIGH_GPRS
)
3605 strcat (buf
, ", highgprs");
3609 if ((e_flags
& EF_C6000_REL
))
3610 strcat (buf
, ", relocatable module");
3614 strcat (buf
, _(": architecture variant: "));
3615 switch (e_flags
& EF_MSP430_MACH
)
3617 case E_MSP430_MACH_MSP430x11
: strcat (buf
, "MSP430x11"); break;
3618 case E_MSP430_MACH_MSP430x11x1
: strcat (buf
, "MSP430x11x1 "); break;
3619 case E_MSP430_MACH_MSP430x12
: strcat (buf
, "MSP430x12"); break;
3620 case E_MSP430_MACH_MSP430x13
: strcat (buf
, "MSP430x13"); break;
3621 case E_MSP430_MACH_MSP430x14
: strcat (buf
, "MSP430x14"); break;
3622 case E_MSP430_MACH_MSP430x15
: strcat (buf
, "MSP430x15"); break;
3623 case E_MSP430_MACH_MSP430x16
: strcat (buf
, "MSP430x16"); break;
3624 case E_MSP430_MACH_MSP430x31
: strcat (buf
, "MSP430x31"); break;
3625 case E_MSP430_MACH_MSP430x32
: strcat (buf
, "MSP430x32"); break;
3626 case E_MSP430_MACH_MSP430x33
: strcat (buf
, "MSP430x33"); break;
3627 case E_MSP430_MACH_MSP430x41
: strcat (buf
, "MSP430x41"); break;
3628 case E_MSP430_MACH_MSP430x42
: strcat (buf
, "MSP430x42"); break;
3629 case E_MSP430_MACH_MSP430x43
: strcat (buf
, "MSP430x43"); break;
3630 case E_MSP430_MACH_MSP430x44
: strcat (buf
, "MSP430x44"); break;
3631 case E_MSP430_MACH_MSP430X
: strcat (buf
, "MSP430X"); break;
3633 strcat (buf
, _(": unknown")); break;
3636 if (e_flags
& ~ EF_MSP430_MACH
)
3637 strcat (buf
, _(": unknown extra flag bits also present"));
3645 get_osabi_name (unsigned int osabi
)
3647 static char buff
[32];
3651 case ELFOSABI_NONE
: return "UNIX - System V";
3652 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
3653 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
3654 case ELFOSABI_GNU
: return "UNIX - GNU";
3655 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
3656 case ELFOSABI_AIX
: return "UNIX - AIX";
3657 case ELFOSABI_IRIX
: return "UNIX - IRIX";
3658 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
3659 case ELFOSABI_TRU64
: return "UNIX - TRU64";
3660 case ELFOSABI_MODESTO
: return "Novell - Modesto";
3661 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
3662 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
3663 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
3664 case ELFOSABI_AROS
: return "AROS";
3665 case ELFOSABI_FENIXOS
: return "FenixOS";
3666 case ELFOSABI_CLOUDABI
: return "Nuxi CloudABI";
3667 case ELFOSABI_OPENVOS
: return "Stratus Technologies OpenVOS";
3670 switch (elf_header
.e_machine
)
3675 case ELFOSABI_ARM
: return "ARM";
3686 case ELFOSABI_STANDALONE
: return _("Standalone App");
3695 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
3696 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
3705 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
3711 get_aarch64_segment_type (unsigned long type
)
3715 case PT_AARCH64_ARCHEXT
: return "AARCH64_ARCHEXT";
3716 default: return NULL
;
3721 get_arm_segment_type (unsigned long type
)
3725 case PT_ARM_EXIDX
: return "EXIDX";
3726 default: return NULL
;
3731 get_s390_segment_type (unsigned long type
)
3735 case PT_S390_PGSTE
: return "S390_PGSTE";
3736 default: return NULL
;
3741 get_mips_segment_type (unsigned long type
)
3745 case PT_MIPS_REGINFO
: return "REGINFO";
3746 case PT_MIPS_RTPROC
: return "RTPROC";
3747 case PT_MIPS_OPTIONS
: return "OPTIONS";
3748 case PT_MIPS_ABIFLAGS
: return "ABIFLAGS";
3749 default: return NULL
;
3754 get_parisc_segment_type (unsigned long type
)
3758 case PT_HP_TLS
: return "HP_TLS";
3759 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
3760 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
3761 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
3762 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
3763 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
3764 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
3765 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
3766 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
3767 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
3768 case PT_HP_PARALLEL
: return "HP_PARALLEL";
3769 case PT_HP_FASTBIND
: return "HP_FASTBIND";
3770 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
3771 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
3772 case PT_HP_STACK
: return "HP_STACK";
3773 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
3774 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
3775 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
3776 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
3777 default: return NULL
;
3782 get_ia64_segment_type (unsigned long type
)
3786 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
3787 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
3788 case PT_HP_TLS
: return "HP_TLS";
3789 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
3790 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
3791 case PT_IA_64_HP_STACK
: return "HP_STACK";
3792 default: return NULL
;
3797 get_tic6x_segment_type (unsigned long type
)
3801 case PT_C6000_PHATTR
: return "C6000_PHATTR";
3802 default: return NULL
;
3807 get_solaris_segment_type (unsigned long type
)
3811 case 0x6464e550: return "PT_SUNW_UNWIND";
3812 case 0x6474e550: return "PT_SUNW_EH_FRAME";
3813 case 0x6ffffff7: return "PT_LOSUNW";
3814 case 0x6ffffffa: return "PT_SUNWBSS";
3815 case 0x6ffffffb: return "PT_SUNWSTACK";
3816 case 0x6ffffffc: return "PT_SUNWDTRACE";
3817 case 0x6ffffffd: return "PT_SUNWCAP";
3818 case 0x6fffffff: return "PT_HISUNW";
3819 default: return NULL
;
3824 get_segment_type (unsigned long p_type
)
3826 static char buff
[32];
3830 case PT_NULL
: return "NULL";
3831 case PT_LOAD
: return "LOAD";
3832 case PT_DYNAMIC
: return "DYNAMIC";
3833 case PT_INTERP
: return "INTERP";
3834 case PT_NOTE
: return "NOTE";
3835 case PT_SHLIB
: return "SHLIB";
3836 case PT_PHDR
: return "PHDR";
3837 case PT_TLS
: return "TLS";
3838 case PT_GNU_EH_FRAME
: return "GNU_EH_FRAME";
3839 case PT_GNU_STACK
: return "GNU_STACK";
3840 case PT_GNU_RELRO
: return "GNU_RELRO";
3843 if (p_type
>= PT_GNU_MBIND_LO
&& p_type
<= PT_GNU_MBIND_HI
)
3845 sprintf (buff
, "GNU_MBIND+%#lx",
3846 p_type
- PT_GNU_MBIND_LO
);
3848 else if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
3850 const char * result
;
3852 switch (elf_header
.e_machine
)
3855 result
= get_aarch64_segment_type (p_type
);
3858 result
= get_arm_segment_type (p_type
);
3861 case EM_MIPS_RS3_LE
:
3862 result
= get_mips_segment_type (p_type
);
3865 result
= get_parisc_segment_type (p_type
);
3868 result
= get_ia64_segment_type (p_type
);
3871 result
= get_tic6x_segment_type (p_type
);
3875 result
= get_s390_segment_type (p_type
);
3885 sprintf (buff
, "LOPROC+%#lx", p_type
- PT_LOPROC
);
3887 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
3889 const char * result
;
3891 switch (elf_header
.e_machine
)
3894 result
= get_parisc_segment_type (p_type
);
3897 result
= get_ia64_segment_type (p_type
);
3900 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
3901 result
= get_solaris_segment_type (p_type
);
3910 sprintf (buff
, "LOOS+%#lx", p_type
- PT_LOOS
);
3913 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
3920 get_arc_section_type_name (unsigned int sh_type
)
3924 case SHT_ARC_ATTRIBUTES
: return "ARC_ATTRIBUTES";
3932 get_mips_section_type_name (unsigned int sh_type
)
3936 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
3937 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
3938 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
3939 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
3940 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
3941 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
3942 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
3943 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
3944 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
3945 case SHT_MIPS_RELD
: return "MIPS_RELD";
3946 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
3947 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
3948 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
3949 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
3950 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
3951 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
3952 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
3953 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
3954 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
3955 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
3956 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
3957 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
3958 case SHT_MIPS_LINE
: return "MIPS_LINE";
3959 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
3960 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
3961 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
3962 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
3963 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
3964 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
3965 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
3966 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
3967 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
3968 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
3969 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
3970 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
3971 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
3972 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
3973 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
3974 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
3975 case SHT_MIPS_ABIFLAGS
: return "MIPS_ABIFLAGS";
3983 get_parisc_section_type_name (unsigned int sh_type
)
3987 case SHT_PARISC_EXT
: return "PARISC_EXT";
3988 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
3989 case SHT_PARISC_DOC
: return "PARISC_DOC";
3990 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
3991 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
3992 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
3993 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
3994 default: return NULL
;
3999 get_ia64_section_type_name (unsigned int sh_type
)
4001 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
4002 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
4003 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
4007 case SHT_IA_64_EXT
: return "IA_64_EXT";
4008 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
4009 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
4010 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
4011 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
4012 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
4013 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
4014 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
4015 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
4016 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
4024 get_x86_64_section_type_name (unsigned int sh_type
)
4028 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
4029 default: return NULL
;
4034 get_aarch64_section_type_name (unsigned int sh_type
)
4038 case SHT_AARCH64_ATTRIBUTES
: return "AARCH64_ATTRIBUTES";
4039 default: return NULL
;
4044 get_arm_section_type_name (unsigned int sh_type
)
4048 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
4049 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
4050 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
4051 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
4052 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
4053 default: return NULL
;
4058 get_tic6x_section_type_name (unsigned int sh_type
)
4062 case SHT_C6000_UNWIND
: return "C6000_UNWIND";
4063 case SHT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
4064 case SHT_C6000_ATTRIBUTES
: return "C6000_ATTRIBUTES";
4065 case SHT_TI_ICODE
: return "TI_ICODE";
4066 case SHT_TI_XREF
: return "TI_XREF";
4067 case SHT_TI_HANDLER
: return "TI_HANDLER";
4068 case SHT_TI_INITINFO
: return "TI_INITINFO";
4069 case SHT_TI_PHATTRS
: return "TI_PHATTRS";
4070 default: return NULL
;
4075 get_msp430x_section_type_name (unsigned int sh_type
)
4079 case SHT_MSP430_SEC_FLAGS
: return "MSP430_SEC_FLAGS";
4080 case SHT_MSP430_SYM_ALIASES
: return "MSP430_SYM_ALIASES";
4081 case SHT_MSP430_ATTRIBUTES
: return "MSP430_ATTRIBUTES";
4082 default: return NULL
;
4087 get_v850_section_type_name (unsigned int sh_type
)
4091 case SHT_V850_SCOMMON
: return "V850 Small Common";
4092 case SHT_V850_TCOMMON
: return "V850 Tiny Common";
4093 case SHT_V850_ZCOMMON
: return "V850 Zero Common";
4094 case SHT_RENESAS_IOP
: return "RENESAS IOP";
4095 case SHT_RENESAS_INFO
: return "RENESAS INFO";
4096 default: return NULL
;
4101 get_section_type_name (unsigned int sh_type
)
4103 static char buff
[32];
4104 const char * result
;
4108 case SHT_NULL
: return "NULL";
4109 case SHT_PROGBITS
: return "PROGBITS";
4110 case SHT_SYMTAB
: return "SYMTAB";
4111 case SHT_STRTAB
: return "STRTAB";
4112 case SHT_RELA
: return "RELA";
4113 case SHT_HASH
: return "HASH";
4114 case SHT_DYNAMIC
: return "DYNAMIC";
4115 case SHT_NOTE
: return "NOTE";
4116 case SHT_NOBITS
: return "NOBITS";
4117 case SHT_REL
: return "REL";
4118 case SHT_SHLIB
: return "SHLIB";
4119 case SHT_DYNSYM
: return "DYNSYM";
4120 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
4121 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
4122 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
4123 case SHT_GNU_HASH
: return "GNU_HASH";
4124 case SHT_GROUP
: return "GROUP";
4125 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
4126 case SHT_GNU_verdef
: return "VERDEF";
4127 case SHT_GNU_verneed
: return "VERNEED";
4128 case SHT_GNU_versym
: return "VERSYM";
4129 case 0x6ffffff0: return "VERSYM";
4130 case 0x6ffffffc: return "VERDEF";
4131 case 0x7ffffffd: return "AUXILIARY";
4132 case 0x7fffffff: return "FILTER";
4133 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
4136 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
4138 switch (elf_header
.e_machine
)
4141 case EM_ARC_COMPACT
:
4142 case EM_ARC_COMPACT2
:
4143 result
= get_arc_section_type_name (sh_type
);
4146 case EM_MIPS_RS3_LE
:
4147 result
= get_mips_section_type_name (sh_type
);
4150 result
= get_parisc_section_type_name (sh_type
);
4153 result
= get_ia64_section_type_name (sh_type
);
4158 result
= get_x86_64_section_type_name (sh_type
);
4161 result
= get_aarch64_section_type_name (sh_type
);
4164 result
= get_arm_section_type_name (sh_type
);
4167 result
= get_tic6x_section_type_name (sh_type
);
4170 result
= get_msp430x_section_type_name (sh_type
);
4174 case EM_CYGNUS_V850
:
4175 result
= get_v850_section_type_name (sh_type
);
4185 sprintf (buff
, "LOPROC+%#x", sh_type
- SHT_LOPROC
);
4187 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
4189 switch (elf_header
.e_machine
)
4192 result
= get_ia64_section_type_name (sh_type
);
4195 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
4196 result
= get_solaris_section_type (sh_type
);
4201 case SHT_GNU_INCREMENTAL_INPUTS
: result
= "GNU_INCREMENTAL_INPUTS"; break;
4202 case SHT_GNU_ATTRIBUTES
: result
= "GNU_ATTRIBUTES"; break;
4203 case SHT_GNU_HASH
: result
= "GNU_HASH"; break;
4204 case SHT_GNU_LIBLIST
: result
= "GNU_LIBLIST"; break;
4216 sprintf (buff
, "LOOS+%#x", sh_type
- SHT_LOOS
);
4218 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
4220 switch (elf_header
.e_machine
)
4224 case EM_CYGNUS_V850
:
4225 result
= get_v850_section_type_name (sh_type
);
4235 sprintf (buff
, "LOUSER+%#x", sh_type
- SHT_LOUSER
);
4238 /* This message is probably going to be displayed in a 15
4239 character wide field, so put the hex value first. */
4240 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
4246 #define OPTION_DEBUG_DUMP 512
4247 #define OPTION_DYN_SYMS 513
4248 #define OPTION_DWARF_DEPTH 514
4249 #define OPTION_DWARF_START 515
4250 #define OPTION_DWARF_CHECK 516
4252 static struct option options
[] =
4254 {"all", no_argument
, 0, 'a'},
4255 {"file-header", no_argument
, 0, 'h'},
4256 {"program-headers", no_argument
, 0, 'l'},
4257 {"headers", no_argument
, 0, 'e'},
4258 {"histogram", no_argument
, 0, 'I'},
4259 {"segments", no_argument
, 0, 'l'},
4260 {"sections", no_argument
, 0, 'S'},
4261 {"section-headers", no_argument
, 0, 'S'},
4262 {"section-groups", no_argument
, 0, 'g'},
4263 {"section-details", no_argument
, 0, 't'},
4264 {"full-section-name",no_argument
, 0, 'N'},
4265 {"symbols", no_argument
, 0, 's'},
4266 {"syms", no_argument
, 0, 's'},
4267 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
4268 {"relocs", no_argument
, 0, 'r'},
4269 {"notes", no_argument
, 0, 'n'},
4270 {"dynamic", no_argument
, 0, 'd'},
4271 {"arch-specific", no_argument
, 0, 'A'},
4272 {"version-info", no_argument
, 0, 'V'},
4273 {"use-dynamic", no_argument
, 0, 'D'},
4274 {"unwind", no_argument
, 0, 'u'},
4275 {"archive-index", no_argument
, 0, 'c'},
4276 {"hex-dump", required_argument
, 0, 'x'},
4277 {"relocated-dump", required_argument
, 0, 'R'},
4278 {"string-dump", required_argument
, 0, 'p'},
4279 {"decompress", no_argument
, 0, 'z'},
4280 #ifdef SUPPORT_DISASSEMBLY
4281 {"instruction-dump", required_argument
, 0, 'i'},
4283 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
4285 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
4286 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
4287 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
4289 {"version", no_argument
, 0, 'v'},
4290 {"wide", no_argument
, 0, 'W'},
4291 {"help", no_argument
, 0, 'H'},
4292 {0, no_argument
, 0, 0}
4296 usage (FILE * stream
)
4298 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
4299 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
4300 fprintf (stream
, _(" Options are:\n\
4301 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4302 -h --file-header Display the ELF file header\n\
4303 -l --program-headers Display the program headers\n\
4304 --segments An alias for --program-headers\n\
4305 -S --section-headers Display the sections' header\n\
4306 --sections An alias for --section-headers\n\
4307 -g --section-groups Display the section groups\n\
4308 -t --section-details Display the section details\n\
4309 -e --headers Equivalent to: -h -l -S\n\
4310 -s --syms Display the symbol table\n\
4311 --symbols An alias for --syms\n\
4312 --dyn-syms Display the dynamic symbol table\n\
4313 -n --notes Display the core notes (if present)\n\
4314 -r --relocs Display the relocations (if present)\n\
4315 -u --unwind Display the unwind info (if present)\n\
4316 -d --dynamic Display the dynamic section (if present)\n\
4317 -V --version-info Display the version sections (if present)\n\
4318 -A --arch-specific Display architecture specific information (if any)\n\
4319 -c --archive-index Display the symbol/file index in an archive\n\
4320 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
4321 -x --hex-dump=<number|name>\n\
4322 Dump the contents of section <number|name> as bytes\n\
4323 -p --string-dump=<number|name>\n\
4324 Dump the contents of section <number|name> as strings\n\
4325 -R --relocated-dump=<number|name>\n\
4326 Dump the contents of section <number|name> as relocated bytes\n\
4327 -z --decompress Decompress section before dumping it\n\
4328 -w[lLiaprmfFsoRt] or\n\
4329 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4330 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4331 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4333 Display the contents of DWARF2 debug sections\n"));
4334 fprintf (stream
, _("\
4335 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4336 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4338 #ifdef SUPPORT_DISASSEMBLY
4339 fprintf (stream
, _("\
4340 -i --instruction-dump=<number|name>\n\
4341 Disassemble the contents of section <number|name>\n"));
4343 fprintf (stream
, _("\
4344 -I --histogram Display histogram of bucket list lengths\n\
4345 -W --wide Allow output width to exceed 80 characters\n\
4346 @<file> Read options from <file>\n\
4347 -H --help Display this information\n\
4348 -v --version Display the version number of readelf\n"));
4350 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
4351 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
4353 exit (stream
== stdout
? 0 : 1);
4356 /* Record the fact that the user wants the contents of section number
4357 SECTION to be displayed using the method(s) encoded as flags bits
4358 in TYPE. Note, TYPE can be zero if we are creating the array for
4362 request_dump_bynumber (unsigned int section
, dump_type type
)
4364 if (section
>= num_dump_sects
)
4366 dump_type
* new_dump_sects
;
4368 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
4369 sizeof (* dump_sects
));
4371 if (new_dump_sects
== NULL
)
4372 error (_("Out of memory allocating dump request table.\n"));
4377 /* Copy current flag settings. */
4378 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
* sizeof (* dump_sects
));
4383 dump_sects
= new_dump_sects
;
4384 num_dump_sects
= section
+ 1;
4389 dump_sects
[section
] |= type
;
4394 /* Request a dump by section name. */
4397 request_dump_byname (const char * section
, dump_type type
)
4399 struct dump_list_entry
* new_request
;
4401 new_request
= (struct dump_list_entry
*)
4402 malloc (sizeof (struct dump_list_entry
));
4404 error (_("Out of memory allocating dump request table.\n"));
4406 new_request
->name
= strdup (section
);
4407 if (!new_request
->name
)
4408 error (_("Out of memory allocating dump request table.\n"));
4410 new_request
->type
= type
;
4412 new_request
->next
= dump_sects_byname
;
4413 dump_sects_byname
= new_request
;
4417 request_dump (dump_type type
)
4423 section
= strtoul (optarg
, & cp
, 0);
4425 if (! *cp
&& section
>= 0)
4426 request_dump_bynumber (section
, type
);
4428 request_dump_byname (optarg
, type
);
4433 parse_args (int argc
, char ** argv
)
4440 while ((c
= getopt_long
4441 (argc
, argv
, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options
, NULL
)) != EOF
)
4459 do_section_groups
= TRUE
;
4462 do_histogram
= TRUE
;
4467 do_section_groups
= TRUE
;
4472 do_section_details
= TRUE
;
4483 do_using_dynamic
= TRUE
;
4507 do_histogram
= TRUE
;
4513 do_archive_index
= TRUE
;
4516 request_dump (HEX_DUMP
);
4519 request_dump (STRING_DUMP
);
4522 request_dump (RELOC_DUMP
);
4525 decompress_dumps
= TRUE
;
4531 do_debugging
= TRUE
;
4532 dwarf_select_sections_all ();
4536 do_debugging
= FALSE
;
4537 dwarf_select_sections_by_letters (optarg
);
4540 case OPTION_DEBUG_DUMP
:
4543 do_debugging
= TRUE
;
4546 do_debugging
= FALSE
;
4547 dwarf_select_sections_by_names (optarg
);
4550 case OPTION_DWARF_DEPTH
:
4554 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
4557 case OPTION_DWARF_START
:
4561 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
4564 case OPTION_DWARF_CHECK
:
4567 case OPTION_DYN_SYMS
:
4570 #ifdef SUPPORT_DISASSEMBLY
4572 request_dump (DISASS_DUMP
);
4576 print_version (program_name
);
4585 /* xgettext:c-format */
4586 error (_("Invalid option '-%c'\n"), c
);
4593 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
4594 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
4595 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
4596 && !do_section_groups
&& !do_archive_index
4602 get_elf_class (unsigned int elf_class
)
4604 static char buff
[32];
4608 case ELFCLASSNONE
: return _("none");
4609 case ELFCLASS32
: return "ELF32";
4610 case ELFCLASS64
: return "ELF64";
4612 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
4618 get_data_encoding (unsigned int encoding
)
4620 static char buff
[32];
4624 case ELFDATANONE
: return _("none");
4625 case ELFDATA2LSB
: return _("2's complement, little endian");
4626 case ELFDATA2MSB
: return _("2's complement, big endian");
4628 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
4633 /* Decode the data held in 'elf_header'. */
4636 process_file_header (void)
4638 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
4639 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
4640 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
4641 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
4644 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4648 init_dwarf_regnames (elf_header
.e_machine
);
4654 printf (_("ELF Header:\n"));
4655 printf (_(" Magic: "));
4656 for (i
= 0; i
< EI_NIDENT
; i
++)
4657 printf ("%2.2x ", elf_header
.e_ident
[i
]);
4659 printf (_(" Class: %s\n"),
4660 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
4661 printf (_(" Data: %s\n"),
4662 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
4663 printf (_(" Version: %d %s\n"),
4664 elf_header
.e_ident
[EI_VERSION
],
4665 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
4667 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
4668 ? _("<unknown: %lx>")
4670 printf (_(" OS/ABI: %s\n"),
4671 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
4672 printf (_(" ABI Version: %d\n"),
4673 elf_header
.e_ident
[EI_ABIVERSION
]);
4674 printf (_(" Type: %s\n"),
4675 get_file_type (elf_header
.e_type
));
4676 printf (_(" Machine: %s\n"),
4677 get_machine_name (elf_header
.e_machine
));
4678 printf (_(" Version: 0x%lx\n"),
4679 (unsigned long) elf_header
.e_version
);
4681 printf (_(" Entry point address: "));
4682 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
4683 printf (_("\n Start of program headers: "));
4684 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
4685 printf (_(" (bytes into file)\n Start of section headers: "));
4686 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
4687 printf (_(" (bytes into file)\n"));
4689 printf (_(" Flags: 0x%lx%s\n"),
4690 (unsigned long) elf_header
.e_flags
,
4691 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
4692 printf (_(" Size of this header: %ld (bytes)\n"),
4693 (long) elf_header
.e_ehsize
);
4694 printf (_(" Size of program headers: %ld (bytes)\n"),
4695 (long) elf_header
.e_phentsize
);
4696 printf (_(" Number of program headers: %ld"),
4697 (long) elf_header
.e_phnum
);
4698 if (section_headers
!= NULL
4699 && elf_header
.e_phnum
== PN_XNUM
4700 && section_headers
[0].sh_info
!= 0)
4701 printf (" (%ld)", (long) section_headers
[0].sh_info
);
4702 putc ('\n', stdout
);
4703 printf (_(" Size of section headers: %ld (bytes)\n"),
4704 (long) elf_header
.e_shentsize
);
4705 printf (_(" Number of section headers: %ld"),
4706 (long) elf_header
.e_shnum
);
4707 if (section_headers
!= NULL
&& elf_header
.e_shnum
== SHN_UNDEF
)
4708 printf (" (%ld)", (long) section_headers
[0].sh_size
);
4709 putc ('\n', stdout
);
4710 printf (_(" Section header string table index: %ld"),
4711 (long) elf_header
.e_shstrndx
);
4712 if (section_headers
!= NULL
4713 && elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
4714 printf (" (%u)", section_headers
[0].sh_link
);
4715 else if (elf_header
.e_shstrndx
!= SHN_UNDEF
4716 && elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
4717 printf (_(" <corrupt: out of range>"));
4718 putc ('\n', stdout
);
4721 if (section_headers
!= NULL
)
4723 if (elf_header
.e_phnum
== PN_XNUM
4724 && section_headers
[0].sh_info
!= 0)
4725 elf_header
.e_phnum
= section_headers
[0].sh_info
;
4726 if (elf_header
.e_shnum
== SHN_UNDEF
)
4727 elf_header
.e_shnum
= section_headers
[0].sh_size
;
4728 if (elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
4729 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
4730 else if (elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
4731 elf_header
.e_shstrndx
= SHN_UNDEF
;
4732 free (section_headers
);
4733 section_headers
= NULL
;
4740 get_32bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
4742 Elf32_External_Phdr
* phdrs
;
4743 Elf32_External_Phdr
* external
;
4744 Elf_Internal_Phdr
* internal
;
4746 unsigned int size
= elf_header
.e_phentsize
;
4747 unsigned int num
= elf_header
.e_phnum
;
4749 /* PR binutils/17531: Cope with unexpected section header sizes. */
4750 if (size
== 0 || num
== 0)
4752 if (size
< sizeof * phdrs
)
4754 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4757 if (size
> sizeof * phdrs
)
4758 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4760 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
4761 size
, num
, _("program headers"));
4765 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4766 i
< elf_header
.e_phnum
;
4767 i
++, internal
++, external
++)
4769 internal
->p_type
= BYTE_GET (external
->p_type
);
4770 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4771 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4772 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4773 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4774 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4775 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4776 internal
->p_align
= BYTE_GET (external
->p_align
);
4784 get_64bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
4786 Elf64_External_Phdr
* phdrs
;
4787 Elf64_External_Phdr
* external
;
4788 Elf_Internal_Phdr
* internal
;
4790 unsigned int size
= elf_header
.e_phentsize
;
4791 unsigned int num
= elf_header
.e_phnum
;
4793 /* PR binutils/17531: Cope with unexpected section header sizes. */
4794 if (size
== 0 || num
== 0)
4796 if (size
< sizeof * phdrs
)
4798 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4801 if (size
> sizeof * phdrs
)
4802 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4804 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
4805 size
, num
, _("program headers"));
4809 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4810 i
< elf_header
.e_phnum
;
4811 i
++, internal
++, external
++)
4813 internal
->p_type
= BYTE_GET (external
->p_type
);
4814 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4815 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4816 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4817 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4818 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4819 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4820 internal
->p_align
= BYTE_GET (external
->p_align
);
4827 /* Returns TRUE if the program headers were read into `program_headers'. */
4830 get_program_headers (FILE * file
)
4832 Elf_Internal_Phdr
* phdrs
;
4834 /* Check cache of prior read. */
4835 if (program_headers
!= NULL
)
4838 /* Be kind to memory checkers by looking for
4839 e_phnum values which we know must be invalid. */
4840 if (elf_header
.e_phnum
4841 * (is_32bit_elf
? sizeof (Elf32_External_Phdr
) : sizeof (Elf64_External_Phdr
))
4842 >= current_file_size
)
4844 error (_("Too many program headers - %#x - the file is not that big\n"),
4845 elf_header
.e_phnum
);
4849 phdrs
= (Elf_Internal_Phdr
*) cmalloc (elf_header
.e_phnum
,
4850 sizeof (Elf_Internal_Phdr
));
4853 error (_("Out of memory reading %u program headers\n"),
4854 elf_header
.e_phnum
);
4859 ? get_32bit_program_headers (file
, phdrs
)
4860 : get_64bit_program_headers (file
, phdrs
))
4862 program_headers
= phdrs
;
4870 /* Returns TRUE if the program headers were loaded. */
4873 process_program_headers (FILE * file
)
4875 Elf_Internal_Phdr
* segment
;
4877 Elf_Internal_Phdr
* previous_load
= NULL
;
4879 if (elf_header
.e_phnum
== 0)
4881 /* PR binutils/12467. */
4882 if (elf_header
.e_phoff
!= 0)
4884 warn (_("possibly corrupt ELF header - it has a non-zero program"
4885 " header offset, but no program headers\n"));
4888 else if (do_segments
)
4889 printf (_("\nThere are no program headers in this file.\n"));
4893 if (do_segments
&& !do_header
)
4895 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
4896 printf (_("Entry point "));
4897 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
4898 printf (_("\nThere are %d program headers, starting at offset "),
4899 elf_header
.e_phnum
);
4900 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
4904 if (! get_program_headers (file
))
4909 if (elf_header
.e_phnum
> 1)
4910 printf (_("\nProgram Headers:\n"));
4912 printf (_("\nProgram Headers:\n"));
4916 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4919 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4923 (_(" Type Offset VirtAddr PhysAddr\n"));
4925 (_(" FileSiz MemSiz Flags Align\n"));
4932 for (i
= 0, segment
= program_headers
;
4933 i
< elf_header
.e_phnum
;
4938 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
4942 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
4943 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
4944 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
4945 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
4946 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
4948 (segment
->p_flags
& PF_R
? 'R' : ' '),
4949 (segment
->p_flags
& PF_W
? 'W' : ' '),
4950 (segment
->p_flags
& PF_X
? 'E' : ' '));
4951 printf ("%#lx", (unsigned long) segment
->p_align
);
4955 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
4956 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
4959 print_vma (segment
->p_offset
, FULL_HEX
);
4963 print_vma (segment
->p_vaddr
, FULL_HEX
);
4965 print_vma (segment
->p_paddr
, FULL_HEX
);
4968 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
4969 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
4972 print_vma (segment
->p_filesz
, FULL_HEX
);
4976 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
4977 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
4980 print_vma (segment
->p_memsz
, FULL_HEX
);
4984 (segment
->p_flags
& PF_R
? 'R' : ' '),
4985 (segment
->p_flags
& PF_W
? 'W' : ' '),
4986 (segment
->p_flags
& PF_X
? 'E' : ' '));
4988 if ((unsigned long) segment
->p_align
== segment
->p_align
)
4989 printf ("%#lx", (unsigned long) segment
->p_align
);
4992 print_vma (segment
->p_align
, PREFIX_HEX
);
4997 print_vma (segment
->p_offset
, FULL_HEX
);
4999 print_vma (segment
->p_vaddr
, FULL_HEX
);
5001 print_vma (segment
->p_paddr
, FULL_HEX
);
5003 print_vma (segment
->p_filesz
, FULL_HEX
);
5005 print_vma (segment
->p_memsz
, FULL_HEX
);
5007 (segment
->p_flags
& PF_R
? 'R' : ' '),
5008 (segment
->p_flags
& PF_W
? 'W' : ' '),
5009 (segment
->p_flags
& PF_X
? 'E' : ' '));
5010 print_vma (segment
->p_align
, PREFIX_HEX
);
5013 putc ('\n', stdout
);
5016 switch (segment
->p_type
)
5019 #if 0 /* Do not warn about out of order PT_LOAD segments. Although officially
5020 required by the ELF standard, several programs, including the Linux
5021 kernel, make use of non-ordered segments. */
5023 && previous_load
->p_vaddr
> segment
->p_vaddr
)
5024 error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
5026 if (segment
->p_memsz
< segment
->p_filesz
)
5027 error (_("the segment's file size is larger than its memory size\n"));
5028 previous_load
= segment
;
5032 /* PR 20815 - Verify that the program header is loaded into memory. */
5033 if (i
> 0 && previous_load
!= NULL
)
5034 error (_("the PHDR segment must occur before any LOAD segment\n"));
5035 if (elf_header
.e_machine
!= EM_PARISC
)
5039 for (j
= 1; j
< elf_header
.e_phnum
; j
++)
5040 if (program_headers
[j
].p_vaddr
<= segment
->p_vaddr
5041 && (program_headers
[j
].p_vaddr
+ program_headers
[j
].p_memsz
)
5042 >= (segment
->p_vaddr
+ segment
->p_filesz
))
5044 if (j
== elf_header
.e_phnum
)
5045 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5051 error (_("more than one dynamic segment\n"));
5053 /* By default, assume that the .dynamic section is the first
5054 section in the DYNAMIC segment. */
5055 dynamic_addr
= segment
->p_offset
;
5056 dynamic_size
= segment
->p_filesz
;
5058 /* Try to locate the .dynamic section. If there is
5059 a section header table, we can easily locate it. */
5060 if (section_headers
!= NULL
)
5062 Elf_Internal_Shdr
* sec
;
5064 sec
= find_section (".dynamic");
5065 if (sec
== NULL
|| sec
->sh_size
== 0)
5067 /* A corresponding .dynamic section is expected, but on
5068 IA-64/OpenVMS it is OK for it to be missing. */
5069 if (!is_ia64_vms ())
5070 error (_("no .dynamic section in the dynamic segment\n"));
5074 if (sec
->sh_type
== SHT_NOBITS
)
5080 dynamic_addr
= sec
->sh_offset
;
5081 dynamic_size
= sec
->sh_size
;
5083 if (dynamic_addr
< segment
->p_offset
5084 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
5085 warn (_("the .dynamic section is not contained"
5086 " within the dynamic segment\n"));
5087 else if (dynamic_addr
> segment
->p_offset
)
5088 warn (_("the .dynamic section is not the first section"
5089 " in the dynamic segment.\n"));
5092 /* PR binutils/17512: Avoid corrupt dynamic section info in the
5093 segment. Check this after matching against the section headers
5094 so we don't warn on debuginfo file (which have NOBITS .dynamic
5096 if (dynamic_addr
+ dynamic_size
>= current_file_size
)
5098 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5099 dynamic_addr
= dynamic_size
= 0;
5104 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
5106 error (_("Unable to find program interpreter name\n"));
5110 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
- 1);
5112 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
5113 error (_("Internal error: failed to create format string to display program interpreter\n"));
5115 program_interpreter
[0] = 0;
5116 if (fscanf (file
, fmt
, program_interpreter
) <= 0)
5117 error (_("Unable to read program interpreter name\n"));
5120 printf (_(" [Requesting program interpreter: %s]\n"),
5121 program_interpreter
);
5127 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
5129 printf (_("\n Section to Segment mapping:\n"));
5130 printf (_(" Segment Sections...\n"));
5132 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
5135 Elf_Internal_Shdr
* section
;
5137 segment
= program_headers
+ i
;
5138 section
= section_headers
+ 1;
5140 printf (" %2.2d ", i
);
5142 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
5144 if (!ELF_TBSS_SPECIAL (section
, segment
)
5145 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
5146 printf ("%s ", printable_section_name (section
));
5157 /* Find the file offset corresponding to VMA by using the program headers. */
5160 offset_from_vma (FILE * file
, bfd_vma vma
, bfd_size_type size
)
5162 Elf_Internal_Phdr
* seg
;
5164 if (! get_program_headers (file
))
5166 warn (_("Cannot interpret virtual addresses without program headers.\n"));
5170 for (seg
= program_headers
;
5171 seg
< program_headers
+ elf_header
.e_phnum
;
5174 if (seg
->p_type
!= PT_LOAD
)
5177 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
5178 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
5179 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
5182 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5183 (unsigned long) vma
);
5188 /* Allocate memory and load the sections headers into the global pointer
5189 SECTION_HEADERS. If PROBE is true, this is just a probe and we do not
5190 generate any error messages if the load fails. */
5193 get_32bit_section_headers (FILE * file
, bfd_boolean probe
)
5195 Elf32_External_Shdr
* shdrs
;
5196 Elf_Internal_Shdr
* internal
;
5198 unsigned int size
= elf_header
.e_shentsize
;
5199 unsigned int num
= probe
? 1 : elf_header
.e_shnum
;
5201 /* PR binutils/17531: Cope with unexpected section header sizes. */
5202 if (size
== 0 || num
== 0)
5204 if (size
< sizeof * shdrs
)
5207 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5210 if (!probe
&& size
> sizeof * shdrs
)
5211 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5213 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
5215 probe
? NULL
: _("section headers"));
5219 if (section_headers
!= NULL
)
5220 free (section_headers
);
5221 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
5222 sizeof (Elf_Internal_Shdr
));
5223 if (section_headers
== NULL
)
5226 error (_("Out of memory reading %u section headers\n"), num
);
5230 for (i
= 0, internal
= section_headers
;
5234 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5235 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5236 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5237 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5238 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5239 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5240 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5241 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5242 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5243 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5244 if (!probe
&& internal
->sh_link
> num
)
5245 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5246 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5247 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5255 get_64bit_section_headers (FILE * file
, bfd_boolean probe
)
5257 Elf64_External_Shdr
* shdrs
;
5258 Elf_Internal_Shdr
* internal
;
5260 unsigned int size
= elf_header
.e_shentsize
;
5261 unsigned int num
= probe
? 1 : elf_header
.e_shnum
;
5263 /* PR binutils/17531: Cope with unexpected section header sizes. */
5264 if (size
== 0 || num
== 0)
5266 if (size
< sizeof * shdrs
)
5269 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5272 if (! probe
&& size
> sizeof * shdrs
)
5273 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5275 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
5277 probe
? NULL
: _("section headers"));
5281 if (section_headers
!= NULL
)
5282 free (section_headers
);
5283 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
5284 sizeof (Elf_Internal_Shdr
));
5285 if (section_headers
== NULL
)
5288 error (_("Out of memory reading %u section headers\n"), num
);
5292 for (i
= 0, internal
= section_headers
;
5296 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5297 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5298 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5299 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5300 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5301 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5302 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5303 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5304 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5305 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5306 if (!probe
&& internal
->sh_link
> num
)
5307 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5308 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5309 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5316 static Elf_Internal_Sym
*
5317 get_32bit_elf_symbols (FILE * file
,
5318 Elf_Internal_Shdr
* section
,
5319 unsigned long * num_syms_return
)
5321 unsigned long number
= 0;
5322 Elf32_External_Sym
* esyms
= NULL
;
5323 Elf_External_Sym_Shndx
* shndx
= NULL
;
5324 Elf_Internal_Sym
* isyms
= NULL
;
5325 Elf_Internal_Sym
* psym
;
5328 if (section
->sh_size
== 0)
5330 if (num_syms_return
!= NULL
)
5331 * num_syms_return
= 0;
5335 /* Run some sanity checks first. */
5336 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5338 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5339 printable_section_name (section
), (unsigned long) section
->sh_entsize
);
5343 if (section
->sh_size
> current_file_size
)
5345 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5346 printable_section_name (section
), (unsigned long) section
->sh_size
);
5350 number
= section
->sh_size
/ section
->sh_entsize
;
5352 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
5354 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5355 (unsigned long) section
->sh_size
,
5356 printable_section_name (section
),
5357 (unsigned long) section
->sh_entsize
);
5361 esyms
= (Elf32_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
5362 section
->sh_size
, _("symbols"));
5367 elf_section_list
* entry
;
5370 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5371 if (entry
->hdr
->sh_link
== (unsigned long) (section
- section_headers
))
5373 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
5374 entry
->hdr
->sh_offset
,
5375 1, entry
->hdr
->sh_size
,
5376 _("symbol table section indicies"));
5379 /* PR17531: file: heap-buffer-overflow */
5380 else if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5382 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5383 printable_section_name (entry
->hdr
),
5384 (unsigned long) entry
->hdr
->sh_size
,
5385 (unsigned long) section
->sh_size
);
5391 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5395 error (_("Out of memory reading %lu symbols\n"),
5396 (unsigned long) number
);
5400 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5402 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5403 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5404 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5405 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5406 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5408 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5409 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5410 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5411 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5412 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5421 if (num_syms_return
!= NULL
)
5422 * num_syms_return
= isyms
== NULL
? 0 : number
;
5427 static Elf_Internal_Sym
*
5428 get_64bit_elf_symbols (FILE * file
,
5429 Elf_Internal_Shdr
* section
,
5430 unsigned long * num_syms_return
)
5432 unsigned long number
= 0;
5433 Elf64_External_Sym
* esyms
= NULL
;
5434 Elf_External_Sym_Shndx
* shndx
= NULL
;
5435 Elf_Internal_Sym
* isyms
= NULL
;
5436 Elf_Internal_Sym
* psym
;
5439 if (section
->sh_size
== 0)
5441 if (num_syms_return
!= NULL
)
5442 * num_syms_return
= 0;
5446 /* Run some sanity checks first. */
5447 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5449 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5450 printable_section_name (section
),
5451 (unsigned long) section
->sh_entsize
);
5455 if (section
->sh_size
> current_file_size
)
5457 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5458 printable_section_name (section
),
5459 (unsigned long) section
->sh_size
);
5463 number
= section
->sh_size
/ section
->sh_entsize
;
5465 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
5467 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5468 (unsigned long) section
->sh_size
,
5469 printable_section_name (section
),
5470 (unsigned long) section
->sh_entsize
);
5474 esyms
= (Elf64_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
5475 section
->sh_size
, _("symbols"));
5480 elf_section_list
* entry
;
5483 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5484 if (entry
->hdr
->sh_link
== (unsigned long) (section
- section_headers
))
5486 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
5487 entry
->hdr
->sh_offset
,
5488 1, entry
->hdr
->sh_size
,
5489 _("symbol table section indicies"));
5492 /* PR17531: file: heap-buffer-overflow */
5493 else if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5495 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5496 printable_section_name (entry
->hdr
),
5497 (unsigned long) entry
->hdr
->sh_size
,
5498 (unsigned long) section
->sh_size
);
5504 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5508 error (_("Out of memory reading %lu symbols\n"),
5509 (unsigned long) number
);
5513 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5515 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5516 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5517 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5518 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5520 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5522 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5523 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5524 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5526 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5527 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5536 if (num_syms_return
!= NULL
)
5537 * num_syms_return
= isyms
== NULL
? 0 : number
;
5543 get_elf_section_flags (bfd_vma sh_flags
)
5545 static char buff
[1024];
5547 unsigned int field_size
= is_32bit_elf
? 8 : 16;
5549 unsigned int size
= sizeof (buff
) - (field_size
+ 4 + 1);
5550 bfd_vma os_flags
= 0;
5551 bfd_vma proc_flags
= 0;
5552 bfd_vma unknown_flags
= 0;
5560 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5561 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5562 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5563 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5564 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5565 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5566 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5567 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5568 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5569 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5570 /* IA-64 specific. */
5571 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5572 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5573 /* IA-64 OpenVMS specific. */
5574 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5575 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5576 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5577 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5578 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5579 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5581 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5582 /* SPARC specific. */
5583 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5584 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5586 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5587 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5588 /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
5590 /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
5592 /* 25 */ { STRING_COMMA_LEN ("VLE") },
5595 if (do_section_details
)
5597 sprintf (buff
, "[%*.*lx]: ",
5598 field_size
, field_size
, (unsigned long) sh_flags
);
5599 p
+= field_size
+ 4;
5606 flag
= sh_flags
& - sh_flags
;
5609 if (do_section_details
)
5613 case SHF_WRITE
: sindex
= 0; break;
5614 case SHF_ALLOC
: sindex
= 1; break;
5615 case SHF_EXECINSTR
: sindex
= 2; break;
5616 case SHF_MERGE
: sindex
= 3; break;
5617 case SHF_STRINGS
: sindex
= 4; break;
5618 case SHF_INFO_LINK
: sindex
= 5; break;
5619 case SHF_LINK_ORDER
: sindex
= 6; break;
5620 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
5621 case SHF_GROUP
: sindex
= 8; break;
5622 case SHF_TLS
: sindex
= 9; break;
5623 case SHF_EXCLUDE
: sindex
= 18; break;
5624 case SHF_COMPRESSED
: sindex
= 20; break;
5625 case SHF_GNU_MBIND
: sindex
= 24; break;
5629 switch (elf_header
.e_machine
)
5632 if (flag
== SHF_IA_64_SHORT
)
5634 else if (flag
== SHF_IA_64_NORECOV
)
5637 else if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
5640 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
5641 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
5642 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
5643 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
5644 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
5645 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
5656 case EM_OLD_SPARCV9
:
5657 case EM_SPARC32PLUS
:
5660 if (flag
== SHF_ORDERED
)
5667 case SHF_ENTRYSECT
: sindex
= 21; break;
5668 case SHF_ARM_PURECODE
: sindex
= 22; break;
5669 case SHF_COMDEF
: sindex
= 23; break;
5674 if (flag
== SHF_PPC_VLE
)
5685 if (p
!= buff
+ field_size
+ 4)
5687 if (size
< (10 + 2))
5689 warn (_("Internal error: not enough buffer room for section flag info"));
5690 return _("<unknown>");
5697 size
-= flags
[sindex
].len
;
5698 p
= stpcpy (p
, flags
[sindex
].str
);
5700 else if (flag
& SHF_MASKOS
)
5702 else if (flag
& SHF_MASKPROC
)
5705 unknown_flags
|= flag
;
5711 case SHF_WRITE
: *p
= 'W'; break;
5712 case SHF_ALLOC
: *p
= 'A'; break;
5713 case SHF_EXECINSTR
: *p
= 'X'; break;
5714 case SHF_MERGE
: *p
= 'M'; break;
5715 case SHF_STRINGS
: *p
= 'S'; break;
5716 case SHF_INFO_LINK
: *p
= 'I'; break;
5717 case SHF_LINK_ORDER
: *p
= 'L'; break;
5718 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
5719 case SHF_GROUP
: *p
= 'G'; break;
5720 case SHF_TLS
: *p
= 'T'; break;
5721 case SHF_EXCLUDE
: *p
= 'E'; break;
5722 case SHF_COMPRESSED
: *p
= 'C'; break;
5723 case SHF_GNU_MBIND
: *p
= 'D'; break;
5726 if ((elf_header
.e_machine
== EM_X86_64
5727 || elf_header
.e_machine
== EM_L1OM
5728 || elf_header
.e_machine
== EM_K1OM
)
5729 && flag
== SHF_X86_64_LARGE
)
5731 else if (elf_header
.e_machine
== EM_ARM
5732 && flag
== SHF_ARM_PURECODE
)
5734 else if (elf_header
.e_machine
== EM_PPC
5735 && flag
== SHF_PPC_VLE
)
5737 else if (flag
& SHF_MASKOS
)
5740 sh_flags
&= ~ SHF_MASKOS
;
5742 else if (flag
& SHF_MASKPROC
)
5745 sh_flags
&= ~ SHF_MASKPROC
;
5755 if (do_section_details
)
5759 size
-= 5 + field_size
;
5760 if (p
!= buff
+ field_size
+ 4)
5764 warn (_("Internal error: not enough buffer room for section flag info"));
5765 return _("<unknown>");
5771 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
5772 (unsigned long) os_flags
);
5773 p
+= 5 + field_size
;
5777 size
-= 7 + field_size
;
5778 if (p
!= buff
+ field_size
+ 4)
5782 warn (_("Internal error: not enough buffer room for section flag info"));
5783 return _("<unknown>");
5789 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
5790 (unsigned long) proc_flags
);
5791 p
+= 7 + field_size
;
5795 size
-= 10 + field_size
;
5796 if (p
!= buff
+ field_size
+ 4)
5800 warn (_("Internal error: not enough buffer room for section flag info"));
5801 return _("<unknown>");
5807 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
5808 (unsigned long) unknown_flags
);
5809 p
+= 10 + field_size
;
5818 get_compression_header (Elf_Internal_Chdr
*chdr
, unsigned char *buf
, bfd_size_type size
)
5822 Elf32_External_Chdr
*echdr
= (Elf32_External_Chdr
*) buf
;
5824 if (size
< sizeof (* echdr
))
5826 error (_("Compressed section is too small even for a compression header\n"));
5830 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
5831 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
5832 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
5833 return sizeof (*echdr
);
5837 Elf64_External_Chdr
*echdr
= (Elf64_External_Chdr
*) buf
;
5839 if (size
< sizeof (* echdr
))
5841 error (_("Compressed section is too small even for a compression header\n"));
5845 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
5846 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
5847 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
5848 return sizeof (*echdr
);
5853 process_section_headers (FILE * file
)
5855 Elf_Internal_Shdr
* section
;
5858 section_headers
= NULL
;
5860 if (elf_header
.e_shnum
== 0)
5862 /* PR binutils/12467. */
5863 if (elf_header
.e_shoff
!= 0)
5865 warn (_("possibly corrupt ELF file header - it has a non-zero"
5866 " section header offset, but no section headers\n"));
5869 else if (do_sections
)
5870 printf (_("\nThere are no sections in this file.\n"));
5875 if (do_sections
&& !do_header
)
5876 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
5877 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
5881 if (! get_32bit_section_headers (file
, FALSE
))
5886 if (! get_64bit_section_headers (file
, FALSE
))
5890 /* Read in the string table, so that we have names to display. */
5891 if (elf_header
.e_shstrndx
!= SHN_UNDEF
5892 && elf_header
.e_shstrndx
< elf_header
.e_shnum
)
5894 section
= section_headers
+ elf_header
.e_shstrndx
;
5896 if (section
->sh_size
!= 0)
5898 string_table
= (char *) get_data (NULL
, file
, section
->sh_offset
,
5899 1, section
->sh_size
,
5902 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
5906 /* Scan the sections for the dynamic symbol table
5907 and dynamic string table and debug sections. */
5908 dynamic_symbols
= NULL
;
5909 dynamic_strings
= NULL
;
5910 dynamic_syminfo
= NULL
;
5911 symtab_shndx_list
= NULL
;
5913 eh_addr_size
= is_32bit_elf
? 4 : 8;
5914 switch (elf_header
.e_machine
)
5917 case EM_MIPS_RS3_LE
:
5918 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5919 FDE addresses. However, the ABI also has a semi-official ILP32
5920 variant for which the normal FDE address size rules apply.
5922 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5923 section, where XX is the size of longs in bits. Unfortunately,
5924 earlier compilers provided no way of distinguishing ILP32 objects
5925 from LP64 objects, so if there's any doubt, we should assume that
5926 the official LP64 form is being used. */
5927 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
5928 && find_section (".gcc_compiled_long32") == NULL
)
5934 switch (elf_header
.e_flags
& EF_H8_MACH
)
5936 case E_H8_MACH_H8300
:
5937 case E_H8_MACH_H8300HN
:
5938 case E_H8_MACH_H8300SN
:
5939 case E_H8_MACH_H8300SXN
:
5942 case E_H8_MACH_H8300H
:
5943 case E_H8_MACH_H8300S
:
5944 case E_H8_MACH_H8300SX
:
5952 switch (elf_header
.e_flags
& EF_M32C_CPU_MASK
)
5954 case EF_M32C_CPU_M16C
:
5961 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
5964 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
5965 if (section->sh_entsize != expected_entsize) \
5968 sprintf_vma (buf, section->sh_entsize); \
5969 /* Note: coded this way so that there is a single string for \
5971 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5972 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5973 (unsigned) expected_entsize); \
5974 section->sh_entsize = expected_entsize; \
5979 #define CHECK_ENTSIZE(section, i, type) \
5980 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
5981 sizeof (Elf64_External_##type))
5983 for (i
= 0, section
= section_headers
;
5984 i
< elf_header
.e_shnum
;
5987 char * name
= SECTION_NAME (section
);
5989 if (section
->sh_type
== SHT_DYNSYM
)
5991 if (dynamic_symbols
!= NULL
)
5993 error (_("File contains multiple dynamic symbol tables\n"));
5997 CHECK_ENTSIZE (section
, i
, Sym
);
5998 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
, & num_dynamic_syms
);
6000 else if (section
->sh_type
== SHT_STRTAB
6001 && streq (name
, ".dynstr"))
6003 if (dynamic_strings
!= NULL
)
6005 error (_("File contains multiple dynamic string tables\n"));
6009 dynamic_strings
= (char *) get_data (NULL
, file
, section
->sh_offset
,
6010 1, section
->sh_size
,
6011 _("dynamic strings"));
6012 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : section
->sh_size
;
6014 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
6016 elf_section_list
* entry
= xmalloc (sizeof * entry
);
6017 entry
->hdr
= section
;
6018 entry
->next
= symtab_shndx_list
;
6019 symtab_shndx_list
= entry
;
6021 else if (section
->sh_type
== SHT_SYMTAB
)
6022 CHECK_ENTSIZE (section
, i
, Sym
);
6023 else if (section
->sh_type
== SHT_GROUP
)
6024 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
6025 else if (section
->sh_type
== SHT_REL
)
6026 CHECK_ENTSIZE (section
, i
, Rel
);
6027 else if (section
->sh_type
== SHT_RELA
)
6028 CHECK_ENTSIZE (section
, i
, Rela
);
6029 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
6030 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
6031 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
6032 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
6033 || do_debug_addr
|| do_debug_cu_index
)
6034 && (const_strneq (name
, ".debug_")
6035 || const_strneq (name
, ".zdebug_")))
6038 name
+= sizeof (".zdebug_") - 1;
6040 name
+= sizeof (".debug_") - 1;
6043 || (do_debug_info
&& const_strneq (name
, "info"))
6044 || (do_debug_info
&& const_strneq (name
, "types"))
6045 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
6046 || (do_debug_lines
&& strcmp (name
, "line") == 0)
6047 || (do_debug_lines
&& const_strneq (name
, "line."))
6048 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
6049 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
6050 || (do_debug_pubnames
&& const_strneq (name
, "gnu_pubnames"))
6051 || (do_debug_pubtypes
&& const_strneq (name
, "gnu_pubtypes"))
6052 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
6053 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
6054 || (do_debug_ranges
&& const_strneq (name
, "rnglists"))
6055 || (do_debug_frames
&& const_strneq (name
, "frame"))
6056 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
6057 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
6058 || (do_debug_str
&& const_strneq (name
, "str"))
6059 || (do_debug_loc
&& const_strneq (name
, "loc"))
6060 || (do_debug_loc
&& const_strneq (name
, "loclists"))
6061 || (do_debug_addr
&& const_strneq (name
, "addr"))
6062 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
6063 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
6065 request_dump_bynumber (i
, DEBUG_DUMP
);
6067 /* Linkonce section to be combined with .debug_info at link time. */
6068 else if ((do_debugging
|| do_debug_info
)
6069 && const_strneq (name
, ".gnu.linkonce.wi."))
6070 request_dump_bynumber (i
, DEBUG_DUMP
);
6071 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
6072 request_dump_bynumber (i
, DEBUG_DUMP
);
6073 else if (do_gdb_index
&& (streq (name
, ".gdb_index")
6074 || streq (name
, ".debug_names")))
6075 request_dump_bynumber (i
, DEBUG_DUMP
);
6076 /* Trace sections for Itanium VMS. */
6077 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
6078 || do_trace_aranges
)
6079 && const_strneq (name
, ".trace_"))
6081 name
+= sizeof (".trace_") - 1;
6084 || (do_trace_info
&& streq (name
, "info"))
6085 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
6086 || (do_trace_aranges
&& streq (name
, "aranges"))
6088 request_dump_bynumber (i
, DEBUG_DUMP
);
6095 if (elf_header
.e_shnum
> 1)
6096 printf (_("\nSection Headers:\n"));
6098 printf (_("\nSection Header:\n"));
6102 if (do_section_details
)
6104 printf (_(" [Nr] Name\n"));
6105 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
6109 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
6113 if (do_section_details
)
6115 printf (_(" [Nr] Name\n"));
6116 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
6120 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
6124 if (do_section_details
)
6126 printf (_(" [Nr] Name\n"));
6127 printf (_(" Type Address Offset Link\n"));
6128 printf (_(" Size EntSize Info Align\n"));
6132 printf (_(" [Nr] Name Type Address Offset\n"));
6133 printf (_(" Size EntSize Flags Link Info Align\n"));
6137 if (do_section_details
)
6138 printf (_(" Flags\n"));
6140 for (i
= 0, section
= section_headers
;
6141 i
< elf_header
.e_shnum
;
6144 /* Run some sanity checks on the section header. */
6146 /* Check the sh_link field. */
6147 switch (section
->sh_type
)
6149 case SHT_SYMTAB_SHNDX
:
6153 case SHT_GNU_versym
:
6156 if (section
->sh_link
< 1
6157 || section
->sh_link
>= elf_header
.e_shnum
6158 || (section_headers
[section
->sh_link
].sh_type
!= SHT_SYMTAB
6159 && section_headers
[section
->sh_link
].sh_type
!= SHT_DYNSYM
))
6160 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6161 i
, section
->sh_link
);
6167 case SHT_GNU_verneed
:
6168 case SHT_GNU_verdef
:
6169 case SHT_GNU_LIBLIST
:
6170 if (section
->sh_link
< 1
6171 || section
->sh_link
>= elf_header
.e_shnum
6172 || section_headers
[section
->sh_link
].sh_type
!= SHT_STRTAB
)
6173 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6174 i
, section
->sh_link
);
6177 case SHT_INIT_ARRAY
:
6178 case SHT_FINI_ARRAY
:
6179 case SHT_PREINIT_ARRAY
:
6180 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6181 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6182 i
, section
->sh_link
);
6186 /* FIXME: Add support for target specific section types. */
6187 #if 0 /* Currently we do not check other section types as there are too
6188 many special cases. Stab sections for example have a type
6189 of SHT_PROGBITS but an sh_link field that links to the .stabstr
6191 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6192 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6193 i
, section
->sh_link
);
6198 /* Check the sh_info field. */
6199 switch (section
->sh_type
)
6203 if (section
->sh_info
< 1
6204 || section
->sh_info
>= elf_header
.e_shnum
6205 || (section_headers
[section
->sh_info
].sh_type
!= SHT_PROGBITS
6206 && section_headers
[section
->sh_info
].sh_type
!= SHT_NOBITS
6207 && section_headers
[section
->sh_info
].sh_type
!= SHT_NOTE
6208 && section_headers
[section
->sh_info
].sh_type
!= SHT_INIT_ARRAY
6209 /* FIXME: Are other section types valid ? */
6210 && section_headers
[section
->sh_info
].sh_type
< SHT_LOOS
))
6212 if (section
->sh_info
== 0
6213 && (streq (SECTION_NAME (section
), ".rel.dyn")
6214 || streq (SECTION_NAME (section
), ".rela.dyn")))
6215 /* The .rel.dyn and .rela.dyn sections have an sh_info field
6216 of zero. The relocations in these sections may apply
6217 to many different sections. */
6220 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6221 i
, section
->sh_info
);
6227 case SHT_SYMTAB_SHNDX
:
6228 case SHT_INIT_ARRAY
:
6229 case SHT_FINI_ARRAY
:
6230 case SHT_PREINIT_ARRAY
:
6231 if (section
->sh_info
!= 0)
6232 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6233 i
, section
->sh_info
);
6239 /* A symbol index - we assume that it is valid. */
6243 /* FIXME: Add support for target specific section types. */
6244 if (section
->sh_type
== SHT_NOBITS
)
6245 /* NOBITS section headers with non-zero sh_info fields can be
6246 created when a binary is stripped of everything but its debug
6247 information. The stripped sections have their headers
6248 preserved but their types set to SHT_NOBITS. So do not check
6249 this type of section. */
6251 else if (section
->sh_flags
& SHF_INFO_LINK
)
6253 if (section
->sh_info
< 1 || section
->sh_info
>= elf_header
.e_shnum
)
6254 warn (_("[%2u]: Expected link to another section in info field"), i
);
6256 else if (section
->sh_type
< SHT_LOOS
6257 && (section
->sh_flags
& SHF_GNU_MBIND
) == 0
6258 && section
->sh_info
!= 0)
6259 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6260 i
, section
->sh_info
);
6264 /* Check the sh_size field. */
6265 if (section
->sh_size
> current_file_size
6266 && section
->sh_type
!= SHT_NOBITS
6267 && section
->sh_type
!= SHT_NULL
6268 && section
->sh_type
< SHT_LOOS
)
6269 warn (_("Size of section %u is larger than the entire file!\n"), i
);
6271 printf (" [%2u] ", i
);
6272 if (do_section_details
)
6273 printf ("%s\n ", printable_section_name (section
));
6275 print_symbol (-17, SECTION_NAME (section
));
6277 printf (do_wide
? " %-15s " : " %-15.15s ",
6278 get_section_type_name (section
->sh_type
));
6282 const char * link_too_big
= NULL
;
6284 print_vma (section
->sh_addr
, LONG_HEX
);
6286 printf ( " %6.6lx %6.6lx %2.2lx",
6287 (unsigned long) section
->sh_offset
,
6288 (unsigned long) section
->sh_size
,
6289 (unsigned long) section
->sh_entsize
);
6291 if (do_section_details
)
6292 fputs (" ", stdout
);
6294 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
6296 if (section
->sh_link
>= elf_header
.e_shnum
)
6299 /* The sh_link value is out of range. Normally this indicates
6300 an error but it can have special values in Solaris binaries. */
6301 switch (elf_header
.e_machine
)
6308 case EM_OLD_SPARCV9
:
6309 case EM_SPARC32PLUS
:
6312 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
6313 link_too_big
= "BEFORE";
6314 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
6315 link_too_big
= "AFTER";
6322 if (do_section_details
)
6324 if (link_too_big
!= NULL
&& * link_too_big
)
6325 printf ("<%s> ", link_too_big
);
6327 printf ("%2u ", section
->sh_link
);
6328 printf ("%3u %2lu\n", section
->sh_info
,
6329 (unsigned long) section
->sh_addralign
);
6332 printf ("%2u %3u %2lu\n",
6335 (unsigned long) section
->sh_addralign
);
6337 if (link_too_big
&& ! * link_too_big
)
6338 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6339 i
, section
->sh_link
);
6343 print_vma (section
->sh_addr
, LONG_HEX
);
6345 if ((long) section
->sh_offset
== section
->sh_offset
)
6346 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
6350 print_vma (section
->sh_offset
, LONG_HEX
);
6353 if ((unsigned long) section
->sh_size
== section
->sh_size
)
6354 printf (" %6.6lx", (unsigned long) section
->sh_size
);
6358 print_vma (section
->sh_size
, LONG_HEX
);
6361 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
6362 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
6366 print_vma (section
->sh_entsize
, LONG_HEX
);
6369 if (do_section_details
)
6370 fputs (" ", stdout
);
6372 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
6374 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
6376 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
6377 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
6380 print_vma (section
->sh_addralign
, DEC
);
6384 else if (do_section_details
)
6386 printf (" %-15.15s ",
6387 get_section_type_name (section
->sh_type
));
6388 print_vma (section
->sh_addr
, LONG_HEX
);
6389 if ((long) section
->sh_offset
== section
->sh_offset
)
6390 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
6394 print_vma (section
->sh_offset
, LONG_HEX
);
6396 printf (" %u\n ", section
->sh_link
);
6397 print_vma (section
->sh_size
, LONG_HEX
);
6399 print_vma (section
->sh_entsize
, LONG_HEX
);
6401 printf (" %-16u %lu\n",
6403 (unsigned long) section
->sh_addralign
);
6408 print_vma (section
->sh_addr
, LONG_HEX
);
6409 if ((long) section
->sh_offset
== section
->sh_offset
)
6410 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
6414 print_vma (section
->sh_offset
, LONG_HEX
);
6417 print_vma (section
->sh_size
, LONG_HEX
);
6419 print_vma (section
->sh_entsize
, LONG_HEX
);
6421 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
6423 printf (" %2u %3u %lu\n",
6426 (unsigned long) section
->sh_addralign
);
6429 if (do_section_details
)
6431 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
6432 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
6434 /* Minimum section size is 12 bytes for 32-bit compression
6435 header + 12 bytes for compressed data header. */
6436 unsigned char buf
[24];
6438 assert (sizeof (buf
) >= sizeof (Elf64_External_Chdr
));
6439 if (get_data (&buf
, (FILE *) file
, section
->sh_offset
, 1,
6440 sizeof (buf
), _("compression header")))
6442 Elf_Internal_Chdr chdr
;
6444 (void) get_compression_header (&chdr
, buf
, sizeof (buf
));
6446 if (chdr
.ch_type
== ELFCOMPRESS_ZLIB
)
6449 printf (_(" [<unknown>: 0x%x], "),
6451 print_vma (chdr
.ch_size
, LONG_HEX
);
6452 printf (", %lu\n", (unsigned long) chdr
.ch_addralign
);
6458 if (!do_section_details
)
6460 /* The ordering of the letters shown here matches the ordering of the
6461 corresponding SHF_xxx values, and hence the order in which these
6462 letters will be displayed to the user. */
6463 printf (_("Key to Flags:\n\
6464 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6465 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6466 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
6467 if (elf_header
.e_machine
== EM_X86_64
6468 || elf_header
.e_machine
== EM_L1OM
6469 || elf_header
.e_machine
== EM_K1OM
)
6470 printf (_("l (large), "));
6471 else if (elf_header
.e_machine
== EM_ARM
)
6472 printf (_("y (purecode), "));
6473 else if (elf_header
.e_machine
== EM_PPC
)
6474 printf (_("v (VLE), "));
6475 printf ("p (processor specific)\n");
6482 get_group_flags (unsigned int flags
)
6484 static char buff
[128];
6488 else if (flags
== GRP_COMDAT
)
6491 snprintf (buff
, 14, _("[0x%x: "), flags
);
6493 flags
&= ~ GRP_COMDAT
;
6494 if (flags
& GRP_MASKOS
)
6496 strcat (buff
, "<OS specific>");
6497 flags
&= ~ GRP_MASKOS
;
6500 if (flags
& GRP_MASKPROC
)
6502 strcat (buff
, "<PROC specific>");
6503 flags
&= ~ GRP_MASKPROC
;
6507 strcat (buff
, "<unknown>");
6514 process_section_groups (FILE * file
)
6516 Elf_Internal_Shdr
* section
;
6518 struct group
* group
;
6519 Elf_Internal_Shdr
* symtab_sec
;
6520 Elf_Internal_Shdr
* strtab_sec
;
6521 Elf_Internal_Sym
* symtab
;
6522 unsigned long num_syms
;
6526 /* Don't process section groups unless needed. */
6527 if (!do_unwind
&& !do_section_groups
)
6530 if (elf_header
.e_shnum
== 0)
6532 if (do_section_groups
)
6533 printf (_("\nThere are no sections to group in this file.\n"));
6538 if (section_headers
== NULL
)
6540 error (_("Section headers are not available!\n"));
6541 /* PR 13622: This can happen with a corrupt ELF header. */
6545 section_headers_groups
= (struct group
**) calloc (elf_header
.e_shnum
,
6546 sizeof (struct group
*));
6548 if (section_headers_groups
== NULL
)
6550 error (_("Out of memory reading %u section group headers\n"),
6551 elf_header
.e_shnum
);
6555 /* Scan the sections for the group section. */
6557 for (i
= 0, section
= section_headers
;
6558 i
< elf_header
.e_shnum
;
6560 if (section
->sh_type
== SHT_GROUP
)
6563 if (group_count
== 0)
6565 if (do_section_groups
)
6566 printf (_("\nThere are no section groups in this file.\n"));
6571 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
6573 if (section_groups
== NULL
)
6575 error (_("Out of memory reading %lu groups\n"),
6576 (unsigned long) group_count
);
6586 for (i
= 0, section
= section_headers
, group
= section_groups
;
6587 i
< elf_header
.e_shnum
;
6590 if (section
->sh_type
== SHT_GROUP
)
6592 const char * name
= printable_section_name (section
);
6593 const char * group_name
;
6594 unsigned char * start
;
6595 unsigned char * indices
;
6596 unsigned int entry
, j
, size
;
6597 Elf_Internal_Shdr
* sec
;
6598 Elf_Internal_Sym
* sym
;
6600 /* Get the symbol table. */
6601 if (section
->sh_link
>= elf_header
.e_shnum
6602 || ((sec
= section_headers
+ section
->sh_link
)->sh_type
6605 error (_("Bad sh_link in group section `%s'\n"), name
);
6609 if (symtab_sec
!= sec
)
6614 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
, & num_syms
);
6619 error (_("Corrupt header in group section `%s'\n"), name
);
6623 if (section
->sh_info
>= num_syms
)
6625 error (_("Bad sh_info in group section `%s'\n"), name
);
6629 sym
= symtab
+ section
->sh_info
;
6631 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
6633 if (sym
->st_shndx
== 0
6634 || sym
->st_shndx
>= elf_header
.e_shnum
)
6636 error (_("Bad sh_info in group section `%s'\n"), name
);
6640 group_name
= SECTION_NAME (section_headers
+ sym
->st_shndx
);
6649 /* Get the string table. */
6650 if (symtab_sec
->sh_link
>= elf_header
.e_shnum
)
6659 != (sec
= section_headers
+ symtab_sec
->sh_link
))
6665 strtab
= (char *) get_data (NULL
, file
, strtab_sec
->sh_offset
,
6666 1, strtab_sec
->sh_size
,
6668 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
6670 group_name
= sym
->st_name
< strtab_size
6671 ? strtab
+ sym
->st_name
: _("<corrupt>");
6674 /* PR 17531: file: loop. */
6675 if (section
->sh_entsize
> section
->sh_size
)
6677 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6678 printable_section_name (section
),
6679 (unsigned long) section
->sh_entsize
,
6680 (unsigned long) section
->sh_size
);
6684 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
,
6685 1, section
->sh_size
,
6691 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
6692 entry
= byte_get (indices
, 4);
6695 if (do_section_groups
)
6697 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6698 get_group_flags (entry
), i
, name
, group_name
, size
);
6700 printf (_(" [Index] Name\n"));
6703 group
->group_index
= i
;
6705 for (j
= 0; j
< size
; j
++)
6707 struct group_list
* g
;
6709 entry
= byte_get (indices
, 4);
6712 if (entry
>= elf_header
.e_shnum
)
6714 static unsigned num_group_errors
= 0;
6716 if (num_group_errors
++ < 10)
6718 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6719 entry
, i
, elf_header
.e_shnum
- 1);
6720 if (num_group_errors
== 10)
6721 warn (_("Further error messages about overlarge group section indicies suppressed\n"));
6726 if (section_headers_groups
[entry
] != NULL
)
6730 static unsigned num_errs
= 0;
6732 if (num_errs
++ < 10)
6734 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6736 section_headers_groups
[entry
]->group_index
);
6738 warn (_("Further error messages about already contained group sections suppressed\n"));
6744 /* Intel C/C++ compiler may put section 0 in a
6745 section group. We just warn it the first time
6746 and ignore it afterwards. */
6747 static bfd_boolean warned
= FALSE
;
6750 error (_("section 0 in group section [%5u]\n"),
6751 section_headers_groups
[entry
]->group_index
);
6757 section_headers_groups
[entry
] = group
;
6759 if (do_section_groups
)
6761 sec
= section_headers
+ entry
;
6762 printf (" [%5u] %s\n", entry
, printable_section_name (sec
));
6765 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
6766 g
->section_index
= entry
;
6767 g
->next
= group
->root
;
6785 /* Data used to display dynamic fixups. */
6787 struct ia64_vms_dynfixup
6789 bfd_vma needed_ident
; /* Library ident number. */
6790 bfd_vma needed
; /* Index in the dstrtab of the library name. */
6791 bfd_vma fixup_needed
; /* Index of the library. */
6792 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
6793 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
6796 /* Data used to display dynamic relocations. */
6798 struct ia64_vms_dynimgrela
6800 bfd_vma img_rela_cnt
; /* Number of relocations. */
6801 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
6804 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6808 dump_ia64_vms_dynamic_fixups (FILE * file
,
6809 struct ia64_vms_dynfixup
* fixup
,
6810 const char * strtab
,
6811 unsigned int strtab_sz
)
6813 Elf64_External_VMS_IMAGE_FIXUP
* imfs
;
6815 const char * lib_name
;
6817 imfs
= get_data (NULL
, file
, dynamic_addr
+ fixup
->fixup_rela_off
,
6818 1, fixup
->fixup_rela_cnt
* sizeof (*imfs
),
6819 _("dynamic section image fixups"));
6823 if (fixup
->needed
< strtab_sz
)
6824 lib_name
= strtab
+ fixup
->needed
;
6827 warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
6828 (unsigned long) fixup
->needed
);
6831 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6832 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
6834 (_("Seg Offset Type SymVec DataType\n"));
6836 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
6841 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
6842 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
6843 type
= BYTE_GET (imfs
[i
].type
);
6844 rtype
= elf_ia64_reloc_type (type
);
6846 printf (" 0x%08x ", type
);
6848 printf (" %-32s ", rtype
);
6849 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
6850 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
6857 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
6860 dump_ia64_vms_dynamic_relocs (FILE *file
, struct ia64_vms_dynimgrela
*imgrela
)
6862 Elf64_External_VMS_IMAGE_RELA
*imrs
;
6865 imrs
= get_data (NULL
, file
, dynamic_addr
+ imgrela
->img_rela_off
,
6866 1, imgrela
->img_rela_cnt
* sizeof (*imrs
),
6867 _("dynamic section image relocations"));
6871 printf (_("\nImage relocs\n"));
6873 (_("Seg Offset Type Addend Seg Sym Off\n"));
6875 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
6880 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
6881 printf ("%08" BFD_VMA_FMT
"x ",
6882 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
6883 type
= BYTE_GET (imrs
[i
].type
);
6884 rtype
= elf_ia64_reloc_type (type
);
6886 printf ("0x%08x ", type
);
6888 printf ("%-31s ", rtype
);
6889 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
6890 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
6891 printf ("%08" BFD_VMA_FMT
"x\n",
6892 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
6899 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
6902 process_ia64_vms_dynamic_relocs (FILE *file
)
6904 struct ia64_vms_dynfixup fixup
;
6905 struct ia64_vms_dynimgrela imgrela
;
6906 Elf_Internal_Dyn
*entry
;
6907 bfd_vma strtab_off
= 0;
6908 bfd_vma strtab_sz
= 0;
6909 char *strtab
= NULL
;
6910 bfd_boolean res
= TRUE
;
6912 memset (&fixup
, 0, sizeof (fixup
));
6913 memset (&imgrela
, 0, sizeof (imgrela
));
6915 /* Note: the order of the entries is specified by the OpenVMS specs. */
6916 for (entry
= dynamic_section
;
6917 entry
< dynamic_section
+ dynamic_nent
;
6920 switch (entry
->d_tag
)
6922 case DT_IA_64_VMS_STRTAB_OFFSET
:
6923 strtab_off
= entry
->d_un
.d_val
;
6926 strtab_sz
= entry
->d_un
.d_val
;
6928 strtab
= get_data (NULL
, file
, dynamic_addr
+ strtab_off
,
6929 1, strtab_sz
, _("dynamic string section"));
6932 case DT_IA_64_VMS_NEEDED_IDENT
:
6933 fixup
.needed_ident
= entry
->d_un
.d_val
;
6936 fixup
.needed
= entry
->d_un
.d_val
;
6938 case DT_IA_64_VMS_FIXUP_NEEDED
:
6939 fixup
.fixup_needed
= entry
->d_un
.d_val
;
6941 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
6942 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
6944 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
6945 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
6946 if (! dump_ia64_vms_dynamic_fixups (file
, &fixup
, strtab
, strtab_sz
))
6949 case DT_IA_64_VMS_IMG_RELA_CNT
:
6950 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
6952 case DT_IA_64_VMS_IMG_RELA_OFF
:
6953 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
6954 if (! dump_ia64_vms_dynamic_relocs (file
, &imgrela
))
6976 dynamic_relocations
[] =
6978 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
6979 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
6980 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
6983 /* Process the reloc section. */
6986 process_relocs (FILE * file
)
6988 unsigned long rel_size
;
6989 unsigned long rel_offset
;
6994 if (do_using_dynamic
)
6998 bfd_boolean has_dynamic_reloc
;
7001 has_dynamic_reloc
= FALSE
;
7003 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7005 is_rela
= dynamic_relocations
[i
].rela
;
7006 name
= dynamic_relocations
[i
].name
;
7007 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
7008 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
7011 has_dynamic_reloc
= TRUE
;
7013 if (is_rela
== UNKNOWN
)
7015 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
7016 switch (dynamic_info
[DT_PLTREL
])
7030 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7031 name
, rel_offset
, rel_size
);
7033 dump_relocations (file
,
7034 offset_from_vma (file
, rel_offset
, rel_size
),
7036 dynamic_symbols
, num_dynamic_syms
,
7037 dynamic_strings
, dynamic_strings_length
,
7038 is_rela
, TRUE
/* is_dynamic */);
7043 if (process_ia64_vms_dynamic_relocs (file
))
7044 has_dynamic_reloc
= TRUE
;
7046 if (! has_dynamic_reloc
)
7047 printf (_("\nThere are no dynamic relocations in this file.\n"));
7051 Elf_Internal_Shdr
* section
;
7053 bfd_boolean found
= FALSE
;
7055 for (i
= 0, section
= section_headers
;
7056 i
< elf_header
.e_shnum
;
7059 if ( section
->sh_type
!= SHT_RELA
7060 && section
->sh_type
!= SHT_REL
)
7063 rel_offset
= section
->sh_offset
;
7064 rel_size
= section
->sh_size
;
7068 Elf_Internal_Shdr
* strsec
;
7071 printf (_("\nRelocation section "));
7073 if (string_table
== NULL
)
7074 printf ("%d", section
->sh_name
);
7076 printf ("'%s'", printable_section_name (section
));
7078 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7079 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
7081 is_rela
= section
->sh_type
== SHT_RELA
;
7083 if (section
->sh_link
!= 0
7084 && section
->sh_link
< elf_header
.e_shnum
)
7086 Elf_Internal_Shdr
* symsec
;
7087 Elf_Internal_Sym
* symtab
;
7088 unsigned long nsyms
;
7089 unsigned long strtablen
= 0;
7090 char * strtab
= NULL
;
7092 symsec
= section_headers
+ section
->sh_link
;
7093 if (symsec
->sh_type
!= SHT_SYMTAB
7094 && symsec
->sh_type
!= SHT_DYNSYM
)
7097 symtab
= GET_ELF_SYMBOLS (file
, symsec
, & nsyms
);
7102 if (symsec
->sh_link
!= 0
7103 && symsec
->sh_link
< elf_header
.e_shnum
)
7105 strsec
= section_headers
+ symsec
->sh_link
;
7107 strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
7110 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
7113 dump_relocations (file
, rel_offset
, rel_size
,
7114 symtab
, nsyms
, strtab
, strtablen
,
7116 symsec
->sh_type
== SHT_DYNSYM
);
7122 dump_relocations (file
, rel_offset
, rel_size
,
7123 NULL
, 0, NULL
, 0, is_rela
,
7124 FALSE
/* is_dynamic */);
7131 printf (_("\nThere are no relocations in this file.\n"));
7137 /* An absolute address consists of a section and an offset. If the
7138 section is NULL, the offset itself is the address, otherwise, the
7139 address equals to LOAD_ADDRESS(section) + offset. */
7143 unsigned short section
;
7147 #define ABSADDR(a) \
7149 ? section_headers [(a).section].sh_addr + (a).offset \
7152 /* Find the nearest symbol at or below ADDR. Returns the symbol
7153 name, if found, and the offset from the symbol to ADDR. */
7156 find_symbol_for_address (Elf_Internal_Sym
* symtab
,
7157 unsigned long nsyms
,
7158 const char * strtab
,
7159 unsigned long strtab_size
,
7160 struct absaddr addr
,
7161 const char ** symname
,
7164 bfd_vma dist
= 0x100000;
7165 Elf_Internal_Sym
* sym
;
7166 Elf_Internal_Sym
* beg
;
7167 Elf_Internal_Sym
* end
;
7168 Elf_Internal_Sym
* best
= NULL
;
7170 REMOVE_ARCH_BITS (addr
.offset
);
7172 end
= symtab
+ nsyms
;
7178 sym
= beg
+ (end
- beg
) / 2;
7180 value
= sym
->st_value
;
7181 REMOVE_ARCH_BITS (value
);
7183 if (sym
->st_name
!= 0
7184 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
7185 && addr
.offset
>= value
7186 && addr
.offset
- value
< dist
)
7189 dist
= addr
.offset
- value
;
7194 if (addr
.offset
< value
)
7202 *symname
= (best
->st_name
>= strtab_size
7203 ? _("<corrupt>") : strtab
+ best
->st_name
);
7209 *offset
= addr
.offset
;
7212 static /* signed */ int
7213 symcmp (const void *p
, const void *q
)
7215 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
7216 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
7218 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
7221 /* Process the unwind section. */
7223 #include "unwind-ia64.h"
7225 struct ia64_unw_table_entry
7227 struct absaddr start
;
7229 struct absaddr info
;
7232 struct ia64_unw_aux_info
7234 struct ia64_unw_table_entry
* table
; /* Unwind table. */
7235 unsigned long table_len
; /* Length of unwind table. */
7236 unsigned char * info
; /* Unwind info. */
7237 unsigned long info_size
; /* Size of unwind info. */
7238 bfd_vma info_addr
; /* Starting address of unwind info. */
7239 bfd_vma seg_base
; /* Starting address of segment. */
7240 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7241 unsigned long nsyms
; /* Number of symbols. */
7242 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7243 unsigned long nfuns
; /* Number of entries in funtab. */
7244 char * strtab
; /* The string table. */
7245 unsigned long strtab_size
; /* Size of string table. */
7249 dump_ia64_unwind (struct ia64_unw_aux_info
* aux
)
7251 struct ia64_unw_table_entry
* tp
;
7252 unsigned long j
, nfuns
;
7254 bfd_boolean res
= TRUE
;
7256 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7257 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7258 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7259 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7261 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7263 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7267 const unsigned char * dp
;
7268 const unsigned char * head
;
7269 const unsigned char * end
;
7270 const char * procname
;
7272 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7273 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
7275 fputs ("\n<", stdout
);
7279 fputs (procname
, stdout
);
7282 printf ("+%lx", (unsigned long) offset
);
7285 fputs (">: [", stdout
);
7286 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7287 fputc ('-', stdout
);
7288 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7289 printf ("], info at +0x%lx\n",
7290 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
7292 /* PR 17531: file: 86232b32. */
7293 if (aux
->info
== NULL
)
7296 /* PR 17531: file: 0997b4d1. */
7297 if ((ABSADDR (tp
->info
) - aux
->info_addr
) >= aux
->info_size
)
7299 warn (_("Invalid offset %lx in table entry %ld\n"),
7300 (long) tp
->info
.offset
, (long) (tp
- aux
->table
));
7305 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
7306 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
7308 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7309 (unsigned) UNW_VER (stamp
),
7310 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
7311 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
7312 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
7313 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
7315 if (UNW_VER (stamp
) != 1)
7317 printf (_("\tUnknown version.\n"));
7322 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
7323 /* PR 17531: file: 16ceda89. */
7324 if (end
> aux
->info
+ aux
->info_size
)
7325 end
= aux
->info
+ aux
->info_size
;
7326 for (dp
= head
+ 8; dp
< end
;)
7327 dp
= unw_decode (dp
, in_body
, & in_body
, end
);
7336 slurp_ia64_unwind_table (FILE * file
,
7337 struct ia64_unw_aux_info
* aux
,
7338 Elf_Internal_Shdr
* sec
)
7340 unsigned long size
, nrelas
, i
;
7341 Elf_Internal_Phdr
* seg
;
7342 struct ia64_unw_table_entry
* tep
;
7343 Elf_Internal_Shdr
* relsec
;
7344 Elf_Internal_Rela
* rela
;
7345 Elf_Internal_Rela
* rp
;
7346 unsigned char * table
;
7348 Elf_Internal_Sym
* sym
;
7349 const char * relname
;
7353 /* First, find the starting address of the segment that includes
7356 if (elf_header
.e_phnum
)
7358 if (! get_program_headers (file
))
7361 for (seg
= program_headers
;
7362 seg
< program_headers
+ elf_header
.e_phnum
;
7365 if (seg
->p_type
!= PT_LOAD
)
7368 if (sec
->sh_addr
>= seg
->p_vaddr
7369 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7371 aux
->seg_base
= seg
->p_vaddr
;
7377 /* Second, build the unwind table from the contents of the unwind section: */
7378 size
= sec
->sh_size
;
7379 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
7384 aux
->table_len
= size
/ (3 * eh_addr_size
);
7385 aux
->table
= (struct ia64_unw_table_entry
*)
7386 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
7389 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
7391 tep
->start
.section
= SHN_UNDEF
;
7392 tep
->end
.section
= SHN_UNDEF
;
7393 tep
->info
.section
= SHN_UNDEF
;
7394 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7395 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7396 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7397 tep
->start
.offset
+= aux
->seg_base
;
7398 tep
->end
.offset
+= aux
->seg_base
;
7399 tep
->info
.offset
+= aux
->seg_base
;
7403 /* Third, apply any relocations to the unwind table: */
7404 for (relsec
= section_headers
;
7405 relsec
< section_headers
+ elf_header
.e_shnum
;
7408 if (relsec
->sh_type
!= SHT_RELA
7409 || relsec
->sh_info
>= elf_header
.e_shnum
7410 || section_headers
+ relsec
->sh_info
!= sec
)
7413 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7422 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7424 relname
= elf_ia64_reloc_type (get_reloc_type (rp
->r_info
));
7425 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
7427 /* PR 17531: file: 9fa67536. */
7428 if (relname
== NULL
)
7430 warn (_("Skipping unknown relocation type: %u\n"), get_reloc_type (rp
->r_info
));
7434 if (! const_strneq (relname
, "R_IA64_SEGREL"))
7436 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
7440 i
= rp
->r_offset
/ (3 * eh_addr_size
);
7442 /* PR 17531: file: 5bc8d9bf. */
7443 if (i
>= aux
->table_len
)
7445 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
7449 switch (rp
->r_offset
/ eh_addr_size
% 3)
7452 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7453 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
7456 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7457 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
7460 aux
->table
[i
].info
.section
= sym
->st_shndx
;
7461 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
7475 ia64_process_unwind (FILE * file
)
7477 Elf_Internal_Shdr
* sec
;
7478 Elf_Internal_Shdr
* unwsec
= NULL
;
7479 Elf_Internal_Shdr
* strsec
;
7480 unsigned long i
, unwcount
= 0, unwstart
= 0;
7481 struct ia64_unw_aux_info aux
;
7482 bfd_boolean res
= TRUE
;
7484 memset (& aux
, 0, sizeof (aux
));
7486 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7488 if (sec
->sh_type
== SHT_SYMTAB
7489 && sec
->sh_link
< elf_header
.e_shnum
)
7491 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
7493 strsec
= section_headers
+ sec
->sh_link
;
7494 if (aux
.strtab
!= NULL
)
7496 error (_("Multiple auxillary string tables encountered\n"));
7500 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
7503 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7505 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7510 printf (_("\nThere are no unwind sections in this file.\n"));
7512 while (unwcount
-- > 0)
7517 for (i
= unwstart
, sec
= section_headers
+ unwstart
, unwsec
= NULL
;
7518 i
< elf_header
.e_shnum
; ++i
, ++sec
)
7519 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7524 /* We have already counted the number of SHT_IA64_UNWIND
7525 sections so the loop above should never fail. */
7526 assert (unwsec
!= NULL
);
7529 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
7531 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
7533 /* We need to find which section group it is in. */
7534 struct group_list
* g
;
7536 if (section_headers_groups
== NULL
7537 || section_headers_groups
[i
] == NULL
)
7538 i
= elf_header
.e_shnum
;
7541 g
= section_headers_groups
[i
]->root
;
7543 for (; g
!= NULL
; g
= g
->next
)
7545 sec
= section_headers
+ g
->section_index
;
7547 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
7552 i
= elf_header
.e_shnum
;
7555 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
7557 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
7558 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
7559 suffix
= SECTION_NAME (unwsec
) + len
;
7560 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
7562 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
7563 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7568 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7569 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
7570 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
7571 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
7573 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
7574 suffix
= SECTION_NAME (unwsec
) + len
;
7575 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
7577 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
7578 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7582 if (i
== elf_header
.e_shnum
)
7584 printf (_("\nCould not find unwind info section for "));
7586 if (string_table
== NULL
)
7587 printf ("%d", unwsec
->sh_name
);
7589 printf ("'%s'", printable_section_name (unwsec
));
7593 aux
.info_addr
= sec
->sh_addr
;
7594 aux
.info
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1,
7597 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
7599 printf (_("\nUnwind section "));
7601 if (string_table
== NULL
)
7602 printf ("%d", unwsec
->sh_name
);
7604 printf ("'%s'", printable_section_name (unwsec
));
7606 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7607 (unsigned long) unwsec
->sh_offset
,
7608 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
7610 if (slurp_ia64_unwind_table (file
, & aux
, unwsec
)
7611 && aux
.table_len
> 0)
7612 dump_ia64_unwind (& aux
);
7615 free ((char *) aux
.table
);
7617 free ((char *) aux
.info
);
7626 free ((char *) aux
.strtab
);
7631 struct hppa_unw_table_entry
7633 struct absaddr start
;
7635 unsigned int Cannot_unwind
:1; /* 0 */
7636 unsigned int Millicode
:1; /* 1 */
7637 unsigned int Millicode_save_sr0
:1; /* 2 */
7638 unsigned int Region_description
:2; /* 3..4 */
7639 unsigned int reserved1
:1; /* 5 */
7640 unsigned int Entry_SR
:1; /* 6 */
7641 unsigned int Entry_FR
:4; /* Number saved 7..10 */
7642 unsigned int Entry_GR
:5; /* Number saved 11..15 */
7643 unsigned int Args_stored
:1; /* 16 */
7644 unsigned int Variable_Frame
:1; /* 17 */
7645 unsigned int Separate_Package_Body
:1; /* 18 */
7646 unsigned int Frame_Extension_Millicode
:1; /* 19 */
7647 unsigned int Stack_Overflow_Check
:1; /* 20 */
7648 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
7649 unsigned int Ada_Region
:1; /* 22 */
7650 unsigned int cxx_info
:1; /* 23 */
7651 unsigned int cxx_try_catch
:1; /* 24 */
7652 unsigned int sched_entry_seq
:1; /* 25 */
7653 unsigned int reserved2
:1; /* 26 */
7654 unsigned int Save_SP
:1; /* 27 */
7655 unsigned int Save_RP
:1; /* 28 */
7656 unsigned int Save_MRP_in_frame
:1; /* 29 */
7657 unsigned int extn_ptr_defined
:1; /* 30 */
7658 unsigned int Cleanup_defined
:1; /* 31 */
7660 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
7661 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
7662 unsigned int Large_frame
:1; /* 2 */
7663 unsigned int Pseudo_SP_Set
:1; /* 3 */
7664 unsigned int reserved4
:1; /* 4 */
7665 unsigned int Total_frame_size
:27; /* 5..31 */
7668 struct hppa_unw_aux_info
7670 struct hppa_unw_table_entry
* table
; /* Unwind table. */
7671 unsigned long table_len
; /* Length of unwind table. */
7672 bfd_vma seg_base
; /* Starting address of segment. */
7673 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7674 unsigned long nsyms
; /* Number of symbols. */
7675 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7676 unsigned long nfuns
; /* Number of entries in funtab. */
7677 char * strtab
; /* The string table. */
7678 unsigned long strtab_size
; /* Size of string table. */
7682 dump_hppa_unwind (struct hppa_unw_aux_info
* aux
)
7684 struct hppa_unw_table_entry
* tp
;
7685 unsigned long j
, nfuns
;
7686 bfd_boolean res
= TRUE
;
7688 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7689 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7690 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7691 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7693 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7695 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7698 const char * procname
;
7700 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7701 aux
->strtab_size
, tp
->start
, &procname
,
7704 fputs ("\n<", stdout
);
7708 fputs (procname
, stdout
);
7711 printf ("+%lx", (unsigned long) offset
);
7714 fputs (">: [", stdout
);
7715 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7716 fputc ('-', stdout
);
7717 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7720 #define PF(_m) if (tp->_m) printf (#_m " ");
7721 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
7724 PF(Millicode_save_sr0
);
7725 /* PV(Region_description); */
7731 PF(Separate_Package_Body
);
7732 PF(Frame_Extension_Millicode
);
7733 PF(Stack_Overflow_Check
);
7734 PF(Two_Instruction_SP_Increment
);
7738 PF(sched_entry_seq
);
7741 PF(Save_MRP_in_frame
);
7742 PF(extn_ptr_defined
);
7743 PF(Cleanup_defined
);
7744 PF(MPE_XL_interrupt_marker
);
7745 PF(HP_UX_interrupt_marker
);
7748 PV(Total_frame_size
);
7761 slurp_hppa_unwind_table (FILE * file
,
7762 struct hppa_unw_aux_info
* aux
,
7763 Elf_Internal_Shdr
* sec
)
7765 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
7766 Elf_Internal_Phdr
* seg
;
7767 struct hppa_unw_table_entry
* tep
;
7768 Elf_Internal_Shdr
* relsec
;
7769 Elf_Internal_Rela
* rela
;
7770 Elf_Internal_Rela
* rp
;
7771 unsigned char * table
;
7773 Elf_Internal_Sym
* sym
;
7774 const char * relname
;
7776 /* First, find the starting address of the segment that includes
7778 if (elf_header
.e_phnum
)
7780 if (! get_program_headers (file
))
7783 for (seg
= program_headers
;
7784 seg
< program_headers
+ elf_header
.e_phnum
;
7787 if (seg
->p_type
!= PT_LOAD
)
7790 if (sec
->sh_addr
>= seg
->p_vaddr
7791 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7793 aux
->seg_base
= seg
->p_vaddr
;
7799 /* Second, build the unwind table from the contents of the unwind
7801 size
= sec
->sh_size
;
7802 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
7808 nentries
= size
/ unw_ent_size
;
7809 size
= unw_ent_size
* nentries
;
7811 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
7812 xcmalloc (nentries
, sizeof (aux
->table
[0]));
7814 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
7816 unsigned int tmp1
, tmp2
;
7818 tep
->start
.section
= SHN_UNDEF
;
7819 tep
->end
.section
= SHN_UNDEF
;
7821 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
7822 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
7823 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
7824 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
7826 tep
->start
.offset
+= aux
->seg_base
;
7827 tep
->end
.offset
+= aux
->seg_base
;
7829 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
7830 tep
->Millicode
= (tmp1
>> 30) & 0x1;
7831 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
7832 tep
->Region_description
= (tmp1
>> 27) & 0x3;
7833 tep
->reserved1
= (tmp1
>> 26) & 0x1;
7834 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
7835 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
7836 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
7837 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
7838 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
7839 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
7840 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
7841 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
7842 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
7843 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
7844 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
7845 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
7846 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
7847 tep
->reserved2
= (tmp1
>> 5) & 0x1;
7848 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
7849 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
7850 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
7851 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
7852 tep
->Cleanup_defined
= tmp1
& 0x1;
7854 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
7855 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
7856 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
7857 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
7858 tep
->reserved4
= (tmp2
>> 27) & 0x1;
7859 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
7863 /* Third, apply any relocations to the unwind table. */
7864 for (relsec
= section_headers
;
7865 relsec
< section_headers
+ elf_header
.e_shnum
;
7868 if (relsec
->sh_type
!= SHT_RELA
7869 || relsec
->sh_info
>= elf_header
.e_shnum
7870 || section_headers
+ relsec
->sh_info
!= sec
)
7873 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7877 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7879 relname
= elf_hppa_reloc_type (get_reloc_type (rp
->r_info
));
7880 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
7882 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
7883 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
7885 warn (_("Skipping unexpected relocation type %s\n"), relname
);
7889 i
= rp
->r_offset
/ unw_ent_size
;
7891 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
7894 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7895 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
7898 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7899 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
7909 aux
->table_len
= nentries
;
7915 hppa_process_unwind (FILE * file
)
7917 struct hppa_unw_aux_info aux
;
7918 Elf_Internal_Shdr
* unwsec
= NULL
;
7919 Elf_Internal_Shdr
* strsec
;
7920 Elf_Internal_Shdr
* sec
;
7922 bfd_boolean res
= TRUE
;
7924 if (string_table
== NULL
)
7927 memset (& aux
, 0, sizeof (aux
));
7929 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7931 if (sec
->sh_type
== SHT_SYMTAB
7932 && sec
->sh_link
< elf_header
.e_shnum
)
7934 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
7936 strsec
= section_headers
+ sec
->sh_link
;
7937 if (aux
.strtab
!= NULL
)
7939 error (_("Multiple auxillary string tables encountered\n"));
7943 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
7946 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7948 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
7953 printf (_("\nThere are no unwind sections in this file.\n"));
7955 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7957 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
7959 printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
7960 printable_section_name (sec
),
7961 (unsigned long) sec
->sh_offset
,
7962 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
7964 if (! slurp_hppa_unwind_table (file
, &aux
, sec
))
7967 if (aux
.table_len
> 0)
7969 if (! dump_hppa_unwind (&aux
))
7974 free ((char *) aux
.table
);
7982 free ((char *) aux
.strtab
);
7989 unsigned char * data
; /* The unwind data. */
7990 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
7991 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
7992 unsigned long nrelas
; /* The number of relocations. */
7993 unsigned int rel_type
; /* REL or RELA ? */
7994 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
7997 struct arm_unw_aux_info
7999 FILE * file
; /* The file containing the unwind sections. */
8000 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
8001 unsigned long nsyms
; /* Number of symbols. */
8002 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8003 unsigned long nfuns
; /* Number of these symbols. */
8004 char * strtab
; /* The file's string table. */
8005 unsigned long strtab_size
; /* Size of string table. */
8009 arm_print_vma_and_name (struct arm_unw_aux_info
*aux
,
8010 bfd_vma fn
, struct absaddr addr
)
8012 const char *procname
;
8015 if (addr
.section
== SHN_UNDEF
)
8018 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8019 aux
->strtab_size
, addr
, &procname
,
8022 print_vma (fn
, PREFIX_HEX
);
8026 fputs (" <", stdout
);
8027 fputs (procname
, stdout
);
8030 printf ("+0x%lx", (unsigned long) sym_offset
);
8031 fputc ('>', stdout
);
8038 arm_free_section (struct arm_section
*arm_sec
)
8040 if (arm_sec
->data
!= NULL
)
8041 free (arm_sec
->data
);
8043 if (arm_sec
->rela
!= NULL
)
8044 free (arm_sec
->rela
);
8047 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8048 cached section and install SEC instead.
8049 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8050 and return its valued in * WORDP, relocating if necessary.
8051 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8052 relocation's offset in ADDR.
8053 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8054 into the string table of the symbol associated with the reloc. If no
8055 reloc was applied store -1 there.
8056 5) Return TRUE upon success, FALSE otherwise. */
8059 get_unwind_section_word (struct arm_unw_aux_info
* aux
,
8060 struct arm_section
* arm_sec
,
8061 Elf_Internal_Shdr
* sec
,
8062 bfd_vma word_offset
,
8063 unsigned int * wordp
,
8064 struct absaddr
* addr
,
8067 Elf_Internal_Rela
*rp
;
8068 Elf_Internal_Sym
*sym
;
8069 const char * relname
;
8071 bfd_boolean wrapped
;
8073 if (sec
== NULL
|| arm_sec
== NULL
)
8076 addr
->section
= SHN_UNDEF
;
8079 if (sym_name
!= NULL
)
8080 *sym_name
= (bfd_vma
) -1;
8082 /* If necessary, update the section cache. */
8083 if (sec
!= arm_sec
->sec
)
8085 Elf_Internal_Shdr
*relsec
;
8087 arm_free_section (arm_sec
);
8090 arm_sec
->data
= get_data (NULL
, aux
->file
, sec
->sh_offset
, 1,
8091 sec
->sh_size
, _("unwind data"));
8092 arm_sec
->rela
= NULL
;
8093 arm_sec
->nrelas
= 0;
8095 for (relsec
= section_headers
;
8096 relsec
< section_headers
+ elf_header
.e_shnum
;
8099 if (relsec
->sh_info
>= elf_header
.e_shnum
8100 || section_headers
+ relsec
->sh_info
!= sec
8101 /* PR 15745: Check the section type as well. */
8102 || (relsec
->sh_type
!= SHT_REL
8103 && relsec
->sh_type
!= SHT_RELA
))
8106 arm_sec
->rel_type
= relsec
->sh_type
;
8107 if (relsec
->sh_type
== SHT_REL
)
8109 if (!slurp_rel_relocs (aux
->file
, relsec
->sh_offset
,
8111 & arm_sec
->rela
, & arm_sec
->nrelas
))
8114 else /* relsec->sh_type == SHT_RELA */
8116 if (!slurp_rela_relocs (aux
->file
, relsec
->sh_offset
,
8118 & arm_sec
->rela
, & arm_sec
->nrelas
))
8124 arm_sec
->next_rela
= arm_sec
->rela
;
8127 /* If there is no unwind data we can do nothing. */
8128 if (arm_sec
->data
== NULL
)
8131 /* If the offset is invalid then fail. */
8132 if (/* PR 21343 *//* PR 18879 */
8134 || word_offset
> (sec
->sh_size
- 4)
8135 || ((bfd_signed_vma
) word_offset
) < 0)
8138 /* Get the word at the required offset. */
8139 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
8141 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
8142 if (arm_sec
->rela
== NULL
)
8148 /* Look through the relocs to find the one that applies to the provided offset. */
8150 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
8152 bfd_vma prelval
, offset
;
8154 if (rp
->r_offset
> word_offset
&& !wrapped
)
8159 if (rp
->r_offset
> word_offset
)
8162 if (rp
->r_offset
& 3)
8164 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8165 (unsigned long) rp
->r_offset
);
8169 if (rp
->r_offset
< word_offset
)
8172 /* PR 17531: file: 027-161405-0.004 */
8173 if (aux
->symtab
== NULL
)
8176 if (arm_sec
->rel_type
== SHT_REL
)
8178 offset
= word
& 0x7fffffff;
8179 if (offset
& 0x40000000)
8180 offset
|= ~ (bfd_vma
) 0x7fffffff;
8182 else if (arm_sec
->rel_type
== SHT_RELA
)
8183 offset
= rp
->r_addend
;
8186 error (_("Unknown section relocation type %d encountered\n"),
8191 /* PR 17531 file: 027-1241568-0.004. */
8192 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
8194 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8195 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
8199 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
8200 offset
+= sym
->st_value
;
8201 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
8203 /* Check that we are processing the expected reloc type. */
8204 if (elf_header
.e_machine
== EM_ARM
)
8206 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8207 if (relname
== NULL
)
8209 warn (_("Skipping unknown ARM relocation type: %d\n"),
8210 (int) ELF32_R_TYPE (rp
->r_info
));
8214 if (streq (relname
, "R_ARM_NONE"))
8217 if (! streq (relname
, "R_ARM_PREL31"))
8219 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
8223 else if (elf_header
.e_machine
== EM_TI_C6000
)
8225 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8226 if (relname
== NULL
)
8228 warn (_("Skipping unknown C6000 relocation type: %d\n"),
8229 (int) ELF32_R_TYPE (rp
->r_info
));
8233 if (streq (relname
, "R_C6000_NONE"))
8236 if (! streq (relname
, "R_C6000_PREL31"))
8238 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
8246 /* This function currently only supports ARM and TI unwinders. */
8247 warn (_("Only TI and ARM unwinders are currently supported\n"));
8251 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
8252 addr
->section
= sym
->st_shndx
;
8253 addr
->offset
= offset
;
8256 * sym_name
= sym
->st_name
;
8261 arm_sec
->next_rela
= rp
;
8266 static const char *tic6x_unwind_regnames
[16] =
8268 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8269 "A14", "A13", "A12", "A11", "A10",
8270 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8274 decode_tic6x_unwind_regmask (unsigned int mask
)
8278 for (i
= 12; mask
; mask
>>= 1, i
--)
8282 fputs (tic6x_unwind_regnames
[i
], stdout
);
8284 fputs (", ", stdout
);
8290 if (remaining == 0 && more_words) \
8293 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
8294 data_offset, & word, & addr, NULL)) \
8300 #define GET_OP(OP) \
8305 (OP) = word >> 24; \
8310 printf (_("[Truncated opcode]\n")); \
8313 printf ("0x%02x ", OP)
8316 decode_arm_unwind_bytecode (struct arm_unw_aux_info
* aux
,
8318 unsigned int remaining
,
8319 unsigned int more_words
,
8320 bfd_vma data_offset
,
8321 Elf_Internal_Shdr
* data_sec
,
8322 struct arm_section
* data_arm_sec
)
8324 struct absaddr addr
;
8325 bfd_boolean res
= TRUE
;
8327 /* Decode the unwinding instructions. */
8330 unsigned int op
, op2
;
8339 printf (" 0x%02x ", op
);
8341 if ((op
& 0xc0) == 0x00)
8343 int offset
= ((op
& 0x3f) << 2) + 4;
8345 printf (" vsp = vsp + %d", offset
);
8347 else if ((op
& 0xc0) == 0x40)
8349 int offset
= ((op
& 0x3f) << 2) + 4;
8351 printf (" vsp = vsp - %d", offset
);
8353 else if ((op
& 0xf0) == 0x80)
8356 if (op
== 0x80 && op2
== 0)
8357 printf (_("Refuse to unwind"));
8360 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
8361 bfd_boolean first
= TRUE
;
8365 for (i
= 0; i
< 12; i
++)
8366 if (mask
& (1 << i
))
8372 printf ("r%d", 4 + i
);
8377 else if ((op
& 0xf0) == 0x90)
8379 if (op
== 0x9d || op
== 0x9f)
8380 printf (_(" [Reserved]"));
8382 printf (" vsp = r%d", op
& 0x0f);
8384 else if ((op
& 0xf0) == 0xa0)
8386 int end
= 4 + (op
& 0x07);
8387 bfd_boolean first
= TRUE
;
8391 for (i
= 4; i
<= end
; i
++)
8407 else if (op
== 0xb0)
8408 printf (_(" finish"));
8409 else if (op
== 0xb1)
8412 if (op2
== 0 || (op2
& 0xf0) != 0)
8413 printf (_("[Spare]"));
8416 unsigned int mask
= op2
& 0x0f;
8417 bfd_boolean first
= TRUE
;
8421 for (i
= 0; i
< 12; i
++)
8422 if (mask
& (1 << i
))
8433 else if (op
== 0xb2)
8435 unsigned char buf
[9];
8436 unsigned int i
, len
;
8437 unsigned long offset
;
8439 for (i
= 0; i
< sizeof (buf
); i
++)
8442 if ((buf
[i
] & 0x80) == 0)
8445 if (i
== sizeof (buf
))
8447 error (_("corrupt change to vsp"));
8452 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8453 assert (len
== i
+ 1);
8454 offset
= offset
* 4 + 0x204;
8455 printf ("vsp = vsp + %ld", offset
);
8458 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
8460 unsigned int first
, last
;
8467 printf ("pop {D%d", first
);
8469 printf ("-D%d", first
+ last
);
8472 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
8474 unsigned int count
= op
& 0x07;
8478 printf ("-D%d", 8 + count
);
8481 else if (op
>= 0xc0 && op
<= 0xc5)
8483 unsigned int count
= op
& 0x07;
8485 printf (" pop {wR10");
8487 printf ("-wR%d", 10 + count
);
8490 else if (op
== 0xc6)
8492 unsigned int first
, last
;
8497 printf ("pop {wR%d", first
);
8499 printf ("-wR%d", first
+ last
);
8502 else if (op
== 0xc7)
8505 if (op2
== 0 || (op2
& 0xf0) != 0)
8506 printf (_("[Spare]"));
8509 unsigned int mask
= op2
& 0x0f;
8510 bfd_boolean first
= TRUE
;
8514 for (i
= 0; i
< 4; i
++)
8515 if (mask
& (1 << i
))
8521 printf ("wCGR%d", i
);
8528 printf (_(" [unsupported opcode]"));
8539 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info
* aux
,
8541 unsigned int remaining
,
8542 unsigned int more_words
,
8543 bfd_vma data_offset
,
8544 Elf_Internal_Shdr
* data_sec
,
8545 struct arm_section
* data_arm_sec
)
8547 struct absaddr addr
;
8549 /* Decode the unwinding instructions. */
8552 unsigned int op
, op2
;
8561 printf (" 0x%02x ", op
);
8563 if ((op
& 0xc0) == 0x00)
8565 int offset
= ((op
& 0x3f) << 3) + 8;
8566 printf (" sp = sp + %d", offset
);
8568 else if ((op
& 0xc0) == 0x80)
8571 if (op
== 0x80 && op2
== 0)
8572 printf (_("Refuse to unwind"));
8575 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
8577 printf ("pop compact {");
8581 decode_tic6x_unwind_regmask (mask
);
8585 else if ((op
& 0xf0) == 0xc0)
8593 unsigned int offset
;
8597 /* Scan entire instruction first so that GET_OP output is not
8598 interleaved with disassembly. */
8600 for (i
= 0; nregs
< (op
& 0xf); i
++)
8606 regpos
[nregs
].offset
= i
* 2;
8607 regpos
[nregs
].reg
= reg
;
8614 regpos
[nregs
].offset
= i
* 2 + 1;
8615 regpos
[nregs
].reg
= reg
;
8620 printf (_("pop frame {"));
8622 for (i
= i
* 2; i
> 0; i
--)
8624 if (regpos
[reg
].offset
== i
- 1)
8626 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
8633 fputs (name
, stdout
);
8640 else if (op
== 0xd0)
8641 printf (" MOV FP, SP");
8642 else if (op
== 0xd1)
8643 printf (" __c6xabi_pop_rts");
8644 else if (op
== 0xd2)
8646 unsigned char buf
[9];
8647 unsigned int i
, len
;
8648 unsigned long offset
;
8650 for (i
= 0; i
< sizeof (buf
); i
++)
8653 if ((buf
[i
] & 0x80) == 0)
8656 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
8657 if (i
== sizeof (buf
))
8659 warn (_("Corrupt stack pointer adjustment detected\n"));
8663 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8664 assert (len
== i
+ 1);
8665 offset
= offset
* 8 + 0x408;
8666 printf (_("sp = sp + %ld"), offset
);
8668 else if ((op
& 0xf0) == 0xe0)
8670 if ((op
& 0x0f) == 7)
8673 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
8677 printf (_(" [unsupported opcode]"));
8686 arm_expand_prel31 (bfd_vma word
, bfd_vma where
)
8690 offset
= word
& 0x7fffffff;
8691 if (offset
& 0x40000000)
8692 offset
|= ~ (bfd_vma
) 0x7fffffff;
8694 if (elf_header
.e_machine
== EM_TI_C6000
)
8697 return offset
+ where
;
8701 decode_arm_unwind (struct arm_unw_aux_info
* aux
,
8703 unsigned int remaining
,
8704 bfd_vma data_offset
,
8705 Elf_Internal_Shdr
* data_sec
,
8706 struct arm_section
* data_arm_sec
)
8709 unsigned int more_words
= 0;
8710 struct absaddr addr
;
8711 bfd_vma sym_name
= (bfd_vma
) -1;
8712 bfd_boolean res
= FALSE
;
8716 /* Fetch the first word.
8717 Note - when decoding an object file the address extracted
8718 here will always be 0. So we also pass in the sym_name
8719 parameter so that we can find the symbol associated with
8720 the personality routine. */
8721 if (! get_unwind_section_word (aux
, data_arm_sec
, data_sec
, data_offset
,
8722 & word
, & addr
, & sym_name
))
8728 if ((word
& 0x80000000) == 0)
8730 /* Expand prel31 for personality routine. */
8732 const char *procname
;
8734 fn
= arm_expand_prel31 (word
, data_sec
->sh_addr
+ data_offset
);
8735 printf (_(" Personality routine: "));
8737 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
8738 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
8740 procname
= aux
->strtab
+ sym_name
;
8741 print_vma (fn
, PREFIX_HEX
);
8744 fputs (" <", stdout
);
8745 fputs (procname
, stdout
);
8746 fputc ('>', stdout
);
8750 procname
= arm_print_vma_and_name (aux
, fn
, addr
);
8751 fputc ('\n', stdout
);
8753 /* The GCC personality routines use the standard compact
8754 encoding, starting with one byte giving the number of
8756 if (procname
!= NULL
8757 && (const_strneq (procname
, "__gcc_personality_v0")
8758 || const_strneq (procname
, "__gxx_personality_v0")
8759 || const_strneq (procname
, "__gcj_personality_v0")
8760 || const_strneq (procname
, "__gnu_objc_personality_v0")))
8767 printf (_(" [Truncated data]\n"));
8770 more_words
= word
>> 24;
8780 /* ARM EHABI Section 6.3:
8782 An exception-handling table entry for the compact model looks like:
8786 1 0 index Data for personalityRoutine[index] */
8788 if (elf_header
.e_machine
== EM_ARM
8789 && (word
& 0x70000000))
8791 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
8795 per_index
= (word
>> 24) & 0x7f;
8796 printf (_(" Compact model index: %d\n"), per_index
);
8803 else if (per_index
< 3)
8805 more_words
= (word
>> 16) & 0xff;
8811 switch (elf_header
.e_machine
)
8816 if (! decode_arm_unwind_bytecode (aux
, word
, remaining
, more_words
,
8817 data_offset
, data_sec
, data_arm_sec
))
8822 warn (_("Unknown ARM compact model index encountered\n"));
8823 printf (_(" [reserved]\n"));
8831 if (! decode_tic6x_unwind_bytecode (aux
, word
, remaining
, more_words
,
8832 data_offset
, data_sec
, data_arm_sec
))
8835 else if (per_index
< 5)
8837 if (((word
>> 17) & 0x7f) == 0x7f)
8838 printf (_(" Restore stack from frame pointer\n"));
8840 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
8841 printf (_(" Registers restored: "));
8843 printf (" (compact) ");
8844 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
8846 printf (_(" Return register: %s\n"),
8847 tic6x_unwind_regnames
[word
& 0xf]);
8850 printf (_(" [reserved (%d)]\n"), per_index
);
8854 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
8855 elf_header
.e_machine
);
8859 /* Decode the descriptors. Not implemented. */
8865 dump_arm_unwind (struct arm_unw_aux_info
*aux
, Elf_Internal_Shdr
*exidx_sec
)
8867 struct arm_section exidx_arm_sec
, extab_arm_sec
;
8868 unsigned int i
, exidx_len
;
8869 unsigned long j
, nfuns
;
8870 bfd_boolean res
= TRUE
;
8872 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
8873 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
8874 exidx_len
= exidx_sec
->sh_size
/ 8;
8876 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
8877 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
8878 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
8879 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
8881 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
8883 for (i
= 0; i
< exidx_len
; i
++)
8885 unsigned int exidx_fn
, exidx_entry
;
8886 struct absaddr fn_addr
, entry_addr
;
8889 fputc ('\n', stdout
);
8891 if (! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
8892 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
8893 || ! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
8894 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
8897 arm_free_section (& exidx_arm_sec
);
8898 arm_free_section (& extab_arm_sec
);
8902 /* ARM EHABI, Section 5:
8903 An index table entry consists of 2 words.
8904 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
8905 if (exidx_fn
& 0x80000000)
8907 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
8911 fn
= arm_expand_prel31 (exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
8913 arm_print_vma_and_name (aux
, fn
, fn_addr
);
8914 fputs (": ", stdout
);
8916 if (exidx_entry
== 1)
8918 print_vma (exidx_entry
, PREFIX_HEX
);
8919 fputs (" [cantunwind]\n", stdout
);
8921 else if (exidx_entry
& 0x80000000)
8923 print_vma (exidx_entry
, PREFIX_HEX
);
8924 fputc ('\n', stdout
);
8925 decode_arm_unwind (aux
, exidx_entry
, 4, 0, NULL
, NULL
);
8929 bfd_vma table
, table_offset
= 0;
8930 Elf_Internal_Shdr
*table_sec
;
8932 fputs ("@", stdout
);
8933 table
= arm_expand_prel31 (exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
8934 print_vma (table
, PREFIX_HEX
);
8937 /* Locate the matching .ARM.extab. */
8938 if (entry_addr
.section
!= SHN_UNDEF
8939 && entry_addr
.section
< elf_header
.e_shnum
)
8941 table_sec
= section_headers
+ entry_addr
.section
;
8942 table_offset
= entry_addr
.offset
;
8944 if (table_offset
> table_sec
->sh_size
8945 || ((bfd_signed_vma
) table_offset
) < 0)
8947 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
8948 (unsigned long) table_offset
,
8949 printable_section_name (table_sec
));
8956 table_sec
= find_section_by_address (table
);
8957 if (table_sec
!= NULL
)
8958 table_offset
= table
- table_sec
->sh_addr
;
8961 if (table_sec
== NULL
)
8963 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
8964 (unsigned long) table
);
8969 if (! decode_arm_unwind (aux
, 0, 0, table_offset
, table_sec
,
8978 arm_free_section (&exidx_arm_sec
);
8979 arm_free_section (&extab_arm_sec
);
8984 /* Used for both ARM and C6X unwinding tables. */
8987 arm_process_unwind (FILE *file
)
8989 struct arm_unw_aux_info aux
;
8990 Elf_Internal_Shdr
*unwsec
= NULL
;
8991 Elf_Internal_Shdr
*strsec
;
8992 Elf_Internal_Shdr
*sec
;
8994 unsigned int sec_type
;
8995 bfd_boolean res
= TRUE
;
8997 switch (elf_header
.e_machine
)
9000 sec_type
= SHT_ARM_EXIDX
;
9004 sec_type
= SHT_C6000_UNWIND
;
9008 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9009 elf_header
.e_machine
);
9013 if (string_table
== NULL
)
9016 memset (& aux
, 0, sizeof (aux
));
9019 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
9021 if (sec
->sh_type
== SHT_SYMTAB
&& sec
->sh_link
< elf_header
.e_shnum
)
9023 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
9025 strsec
= section_headers
+ sec
->sh_link
;
9027 /* PR binutils/17531 file: 011-12666-0.004. */
9028 if (aux
.strtab
!= NULL
)
9030 error (_("Multiple string tables found in file.\n"));
9034 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
9035 1, strsec
->sh_size
, _("string table"));
9036 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
9038 else if (sec
->sh_type
== sec_type
)
9043 printf (_("\nThere are no unwind sections in this file.\n"));
9045 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
9047 if (sec
->sh_type
== sec_type
)
9049 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
9050 printable_section_name (sec
),
9051 (unsigned long) sec
->sh_offset
,
9052 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
)));
9054 if (! dump_arm_unwind (&aux
, sec
))
9062 free ((char *) aux
.strtab
);
9068 process_unwind (FILE * file
)
9070 struct unwind_handler
9072 unsigned int machtype
;
9073 bfd_boolean (* handler
)(FILE *);
9076 { EM_ARM
, arm_process_unwind
},
9077 { EM_IA_64
, ia64_process_unwind
},
9078 { EM_PARISC
, hppa_process_unwind
},
9079 { EM_TI_C6000
, arm_process_unwind
},
9087 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
9088 if (elf_header
.e_machine
== handlers
[i
].machtype
)
9089 return handlers
[i
].handler (file
);
9091 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9092 get_machine_name (elf_header
.e_machine
));
9097 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
9099 switch (entry
->d_tag
)
9102 if (entry
->d_un
.d_val
== 0)
9106 static const char * opts
[] =
9108 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9109 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9110 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9111 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9115 bfd_boolean first
= TRUE
;
9117 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
9118 if (entry
->d_un
.d_val
& (1 << cnt
))
9120 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
9126 case DT_MIPS_IVERSION
:
9127 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9128 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
9132 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
9133 /* Note: coded this way so that there is a single string for translation. */
9134 printf (_("<corrupt: %s>"), buf
);
9138 case DT_MIPS_TIME_STAMP
:
9142 time_t atime
= entry
->d_un
.d_val
;
9144 tmp
= gmtime (&atime
);
9145 /* PR 17531: file: 6accc532. */
9147 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
9149 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
9150 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9151 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9152 printf (_("Time Stamp: %s"), timebuf
);
9156 case DT_MIPS_RLD_VERSION
:
9157 case DT_MIPS_LOCAL_GOTNO
:
9158 case DT_MIPS_CONFLICTNO
:
9159 case DT_MIPS_LIBLISTNO
:
9160 case DT_MIPS_SYMTABNO
:
9161 case DT_MIPS_UNREFEXTNO
:
9162 case DT_MIPS_HIPAGENO
:
9163 case DT_MIPS_DELTA_CLASS_NO
:
9164 case DT_MIPS_DELTA_INSTANCE_NO
:
9165 case DT_MIPS_DELTA_RELOC_NO
:
9166 case DT_MIPS_DELTA_SYM_NO
:
9167 case DT_MIPS_DELTA_CLASSSYM_NO
:
9168 case DT_MIPS_COMPACT_SIZE
:
9169 print_vma (entry
->d_un
.d_val
, DEC
);
9173 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9179 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
9181 switch (entry
->d_tag
)
9183 case DT_HP_DLD_FLAGS
:
9192 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
9193 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
9194 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
9195 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
9196 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
9197 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
9198 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
9199 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
9200 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
9201 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
9202 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
9203 { DT_HP_GST
, "HP_GST" },
9204 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
9205 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
9206 { DT_HP_NODELETE
, "HP_NODELETE" },
9207 { DT_HP_GROUP
, "HP_GROUP" },
9208 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
9210 bfd_boolean first
= TRUE
;
9212 bfd_vma val
= entry
->d_un
.d_val
;
9214 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
9215 if (val
& flags
[cnt
].bit
)
9219 fputs (flags
[cnt
].str
, stdout
);
9221 val
^= flags
[cnt
].bit
;
9224 if (val
!= 0 || first
)
9228 print_vma (val
, HEX
);
9234 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9242 /* VMS vs Unix time offset and factor. */
9244 #define VMS_EPOCH_OFFSET 35067168000000000LL
9245 #define VMS_GRANULARITY_FACTOR 10000000
9247 /* Display a VMS time in a human readable format. */
9250 print_vms_time (bfd_int64_t vmstime
)
9255 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
9256 tm
= gmtime (&unxtime
);
9257 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9258 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
9259 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
9264 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
9266 switch (entry
->d_tag
)
9268 case DT_IA_64_PLT_RESERVE
:
9269 /* First 3 slots reserved. */
9270 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9272 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
9275 case DT_IA_64_VMS_LINKTIME
:
9277 print_vms_time (entry
->d_un
.d_val
);
9281 case DT_IA_64_VMS_LNKFLAGS
:
9282 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9283 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
9284 printf (" CALL_DEBUG");
9285 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
9286 printf (" NOP0BUFS");
9287 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
9288 printf (" P0IMAGE");
9289 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
9290 printf (" MKTHREADS");
9291 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
9292 printf (" UPCALLS");
9293 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
9295 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
9296 printf (" INITIALIZE");
9297 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
9299 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
9300 printf (" EXE_INIT");
9301 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
9302 printf (" TBK_IN_IMG");
9303 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
9304 printf (" DBG_IN_IMG");
9305 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
9306 printf (" TBK_IN_DSF");
9307 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
9308 printf (" DBG_IN_DSF");
9309 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
9310 printf (" SIGNATURES");
9311 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
9312 printf (" REL_SEG_OFF");
9316 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9323 get_32bit_dynamic_section (FILE * file
)
9325 Elf32_External_Dyn
* edyn
;
9326 Elf32_External_Dyn
* ext
;
9327 Elf_Internal_Dyn
* entry
;
9329 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
9330 dynamic_size
, _("dynamic section"));
9334 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9335 might not have the luxury of section headers. Look for the DT_NULL
9336 terminator to determine the number of entries. */
9337 for (ext
= edyn
, dynamic_nent
= 0;
9338 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9342 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9346 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9348 if (dynamic_section
== NULL
)
9350 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9351 (unsigned long) dynamic_nent
);
9356 for (ext
= edyn
, entry
= dynamic_section
;
9357 entry
< dynamic_section
+ dynamic_nent
;
9360 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9361 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9370 get_64bit_dynamic_section (FILE * file
)
9372 Elf64_External_Dyn
* edyn
;
9373 Elf64_External_Dyn
* ext
;
9374 Elf_Internal_Dyn
* entry
;
9376 /* Read in the data. */
9377 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
9378 dynamic_size
, _("dynamic section"));
9382 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9383 might not have the luxury of section headers. Look for the DT_NULL
9384 terminator to determine the number of entries. */
9385 for (ext
= edyn
, dynamic_nent
= 0;
9386 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
9387 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9391 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9395 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9397 if (dynamic_section
== NULL
)
9399 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9400 (unsigned long) dynamic_nent
);
9405 /* Convert from external to internal formats. */
9406 for (ext
= edyn
, entry
= dynamic_section
;
9407 entry
< dynamic_section
+ dynamic_nent
;
9410 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9411 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9420 print_dynamic_flags (bfd_vma flags
)
9422 bfd_boolean first
= TRUE
;
9428 flag
= flags
& - flags
;
9438 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
9439 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
9440 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
9441 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
9442 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
9443 default: fputs (_("unknown"), stdout
); break;
9449 /* Parse and display the contents of the dynamic section. */
9452 process_dynamic_section (FILE * file
)
9454 Elf_Internal_Dyn
* entry
;
9456 if (dynamic_size
== 0)
9459 printf (_("\nThere is no dynamic section in this file.\n"));
9466 if (! get_32bit_dynamic_section (file
))
9471 if (! get_64bit_dynamic_section (file
))
9475 /* Find the appropriate symbol table. */
9476 if (dynamic_symbols
== NULL
)
9478 for (entry
= dynamic_section
;
9479 entry
< dynamic_section
+ dynamic_nent
;
9482 Elf_Internal_Shdr section
;
9484 if (entry
->d_tag
!= DT_SYMTAB
)
9487 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
9489 /* Since we do not know how big the symbol table is,
9490 we default to reading in the entire file (!) and
9491 processing that. This is overkill, I know, but it
9493 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
9494 if ((bfd_size_type
) section
.sh_offset
> current_file_size
)
9496 /* See PR 21379 for a reproducer. */
9497 error (_("Invalid DT_SYMTAB entry: %lx"), (long) section
.sh_offset
);
9501 if (archive_file_offset
!= 0)
9502 section
.sh_size
= archive_file_size
- section
.sh_offset
;
9505 if (fseek (file
, 0, SEEK_END
))
9506 error (_("Unable to seek to end of file!\n"));
9508 section
.sh_size
= ftell (file
) - section
.sh_offset
;
9512 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
9514 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
9515 section
.sh_name
= string_table_length
;
9517 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
, & num_dynamic_syms
);
9518 if (num_dynamic_syms
< 1)
9520 error (_("Unable to determine the number of symbols to load\n"));
9526 /* Similarly find a string table. */
9527 if (dynamic_strings
== NULL
)
9529 for (entry
= dynamic_section
;
9530 entry
< dynamic_section
+ dynamic_nent
;
9533 unsigned long offset
;
9536 if (entry
->d_tag
!= DT_STRTAB
)
9539 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
9541 /* Since we do not know how big the string table is,
9542 we default to reading in the entire file (!) and
9543 processing that. This is overkill, I know, but it
9546 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
9548 if (archive_file_offset
!= 0)
9549 str_tab_len
= archive_file_size
- offset
;
9552 if (fseek (file
, 0, SEEK_END
))
9553 error (_("Unable to seek to end of file\n"));
9554 str_tab_len
= ftell (file
) - offset
;
9557 if (str_tab_len
< 1)
9560 (_("Unable to determine the length of the dynamic string table\n"));
9564 dynamic_strings
= (char *) get_data (NULL
, file
, offset
, 1,
9566 _("dynamic string table"));
9567 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : str_tab_len
;
9572 /* And find the syminfo section if available. */
9573 if (dynamic_syminfo
== NULL
)
9575 unsigned long syminsz
= 0;
9577 for (entry
= dynamic_section
;
9578 entry
< dynamic_section
+ dynamic_nent
;
9581 if (entry
->d_tag
== DT_SYMINENT
)
9583 /* Note: these braces are necessary to avoid a syntax
9584 error from the SunOS4 C compiler. */
9585 /* PR binutils/17531: A corrupt file can trigger this test.
9586 So do not use an assert, instead generate an error message. */
9587 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
9588 error (_("Bad value (%d) for SYMINENT entry\n"),
9589 (int) entry
->d_un
.d_val
);
9591 else if (entry
->d_tag
== DT_SYMINSZ
)
9592 syminsz
= entry
->d_un
.d_val
;
9593 else if (entry
->d_tag
== DT_SYMINFO
)
9594 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
9598 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
9600 Elf_External_Syminfo
* extsyminfo
;
9601 Elf_External_Syminfo
* extsym
;
9602 Elf_Internal_Syminfo
* syminfo
;
9604 /* There is a syminfo section. Read the data. */
9605 extsyminfo
= (Elf_External_Syminfo
*)
9606 get_data (NULL
, file
, dynamic_syminfo_offset
, 1, syminsz
,
9607 _("symbol information"));
9611 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
9612 if (dynamic_syminfo
== NULL
)
9614 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9615 (unsigned long) syminsz
);
9619 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
9620 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
9621 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
9622 ++syminfo
, ++extsym
)
9624 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
9625 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
9632 if (do_dynamic
&& dynamic_addr
)
9633 printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
9634 dynamic_addr
, (unsigned long) dynamic_nent
);
9636 printf (_(" Tag Type Name/Value\n"));
9638 for (entry
= dynamic_section
;
9639 entry
< dynamic_section
+ dynamic_nent
;
9647 print_vma (entry
->d_tag
, FULL_HEX
);
9648 dtype
= get_dynamic_type (entry
->d_tag
);
9649 printf (" (%s)%*s", dtype
,
9650 ((is_32bit_elf
? 27 : 19) - (int) strlen (dtype
)), " ");
9653 switch (entry
->d_tag
)
9657 print_dynamic_flags (entry
->d_un
.d_val
);
9667 switch (entry
->d_tag
)
9670 printf (_("Auxiliary library"));
9674 printf (_("Filter library"));
9678 printf (_("Configuration file"));
9682 printf (_("Dependency audit library"));
9686 printf (_("Audit library"));
9690 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9691 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
9695 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9704 printf (_("Flags:"));
9706 if (entry
->d_un
.d_val
== 0)
9707 printf (_(" None\n"));
9710 unsigned long int val
= entry
->d_un
.d_val
;
9712 if (val
& DTF_1_PARINIT
)
9714 printf (" PARINIT");
9715 val
^= DTF_1_PARINIT
;
9717 if (val
& DTF_1_CONFEXP
)
9719 printf (" CONFEXP");
9720 val
^= DTF_1_CONFEXP
;
9723 printf (" %lx", val
);
9732 printf (_("Flags:"));
9734 if (entry
->d_un
.d_val
== 0)
9735 printf (_(" None\n"));
9738 unsigned long int val
= entry
->d_un
.d_val
;
9740 if (val
& DF_P1_LAZYLOAD
)
9742 printf (" LAZYLOAD");
9743 val
^= DF_P1_LAZYLOAD
;
9745 if (val
& DF_P1_GROUPPERM
)
9747 printf (" GROUPPERM");
9748 val
^= DF_P1_GROUPPERM
;
9751 printf (" %lx", val
);
9760 printf (_("Flags:"));
9761 if (entry
->d_un
.d_val
== 0)
9762 printf (_(" None\n"));
9765 unsigned long int val
= entry
->d_un
.d_val
;
9772 if (val
& DF_1_GLOBAL
)
9777 if (val
& DF_1_GROUP
)
9782 if (val
& DF_1_NODELETE
)
9784 printf (" NODELETE");
9785 val
^= DF_1_NODELETE
;
9787 if (val
& DF_1_LOADFLTR
)
9789 printf (" LOADFLTR");
9790 val
^= DF_1_LOADFLTR
;
9792 if (val
& DF_1_INITFIRST
)
9794 printf (" INITFIRST");
9795 val
^= DF_1_INITFIRST
;
9797 if (val
& DF_1_NOOPEN
)
9802 if (val
& DF_1_ORIGIN
)
9807 if (val
& DF_1_DIRECT
)
9812 if (val
& DF_1_TRANS
)
9817 if (val
& DF_1_INTERPOSE
)
9819 printf (" INTERPOSE");
9820 val
^= DF_1_INTERPOSE
;
9822 if (val
& DF_1_NODEFLIB
)
9824 printf (" NODEFLIB");
9825 val
^= DF_1_NODEFLIB
;
9827 if (val
& DF_1_NODUMP
)
9832 if (val
& DF_1_CONFALT
)
9834 printf (" CONFALT");
9835 val
^= DF_1_CONFALT
;
9837 if (val
& DF_1_ENDFILTEE
)
9839 printf (" ENDFILTEE");
9840 val
^= DF_1_ENDFILTEE
;
9842 if (val
& DF_1_DISPRELDNE
)
9844 printf (" DISPRELDNE");
9845 val
^= DF_1_DISPRELDNE
;
9847 if (val
& DF_1_DISPRELPND
)
9849 printf (" DISPRELPND");
9850 val
^= DF_1_DISPRELPND
;
9852 if (val
& DF_1_NODIRECT
)
9854 printf (" NODIRECT");
9855 val
^= DF_1_NODIRECT
;
9857 if (val
& DF_1_IGNMULDEF
)
9859 printf (" IGNMULDEF");
9860 val
^= DF_1_IGNMULDEF
;
9862 if (val
& DF_1_NOKSYMS
)
9864 printf (" NOKSYMS");
9865 val
^= DF_1_NOKSYMS
;
9867 if (val
& DF_1_NOHDR
)
9872 if (val
& DF_1_EDITED
)
9877 if (val
& DF_1_NORELOC
)
9879 printf (" NORELOC");
9880 val
^= DF_1_NORELOC
;
9882 if (val
& DF_1_SYMINTPOSE
)
9884 printf (" SYMINTPOSE");
9885 val
^= DF_1_SYMINTPOSE
;
9887 if (val
& DF_1_GLOBAUDIT
)
9889 printf (" GLOBAUDIT");
9890 val
^= DF_1_GLOBAUDIT
;
9892 if (val
& DF_1_SINGLETON
)
9894 printf (" SINGLETON");
9895 val
^= DF_1_SINGLETON
;
9897 if (val
& DF_1_STUB
)
9908 printf (" %lx", val
);
9915 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9917 puts (get_dynamic_type (entry
->d_un
.d_val
));
9937 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9943 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9944 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
9950 switch (entry
->d_tag
)
9953 printf (_("Shared library: [%s]"), name
);
9955 if (streq (name
, program_interpreter
))
9956 printf (_(" program interpreter"));
9960 printf (_("Library soname: [%s]"), name
);
9964 printf (_("Library rpath: [%s]"), name
);
9968 printf (_("Library runpath: [%s]"), name
);
9972 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9977 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9990 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9995 case DT_INIT_ARRAYSZ
:
9996 case DT_FINI_ARRAYSZ
:
9997 case DT_GNU_CONFLICTSZ
:
9998 case DT_GNU_LIBLISTSZ
:
10001 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10002 printf (_(" (bytes)\n"));
10007 case DT_VERNEEDNUM
:
10012 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10021 case DT_INIT_ARRAY
:
10022 case DT_FINI_ARRAY
:
10025 if (entry
->d_tag
== DT_USED
10026 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
10028 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
10032 printf (_("Not needed object: [%s]\n"), name
);
10037 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10043 /* The value of this entry is ignored. */
10048 case DT_GNU_PRELINKED
:
10052 time_t atime
= entry
->d_un
.d_val
;
10054 tmp
= gmtime (&atime
);
10055 /* PR 17533 file: 041-1244816-0.004. */
10057 printf (_("<corrupt time val: %lx"),
10058 (unsigned long) atime
);
10060 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10061 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
10062 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
10068 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10071 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10077 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
10078 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
10083 switch (elf_header
.e_machine
)
10086 case EM_MIPS_RS3_LE
:
10087 dynamic_section_mips_val (entry
);
10090 dynamic_section_parisc_val (entry
);
10093 dynamic_section_ia64_val (entry
);
10096 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10108 get_ver_flags (unsigned int flags
)
10110 static char buff
[32];
10117 if (flags
& VER_FLG_BASE
)
10118 strcat (buff
, "BASE");
10120 if (flags
& VER_FLG_WEAK
)
10122 if (flags
& VER_FLG_BASE
)
10123 strcat (buff
, " | ");
10125 strcat (buff
, "WEAK");
10128 if (flags
& VER_FLG_INFO
)
10130 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
10131 strcat (buff
, " | ");
10133 strcat (buff
, "INFO");
10136 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10138 if (flags
& (VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10139 strcat (buff
, " | ");
10141 strcat (buff
, _("<unknown>"));
10147 /* Display the contents of the version sections. */
10150 process_version_sections (FILE * file
)
10152 Elf_Internal_Shdr
* section
;
10154 bfd_boolean found
= FALSE
;
10159 for (i
= 0, section
= section_headers
;
10160 i
< elf_header
.e_shnum
;
10163 switch (section
->sh_type
)
10165 case SHT_GNU_verdef
:
10167 Elf_External_Verdef
* edefs
;
10174 printf (_("\nVersion definition section '%s' contains %u entries:\n"),
10175 printable_section_name (section
),
10178 printf (_(" Addr: 0x"));
10179 printf_vma (section
->sh_addr
);
10180 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10181 (unsigned long) section
->sh_offset
, section
->sh_link
,
10182 printable_section_name_from_index (section
->sh_link
));
10184 edefs
= (Elf_External_Verdef
*)
10185 get_data (NULL
, file
, section
->sh_offset
, 1,section
->sh_size
,
10186 _("version definition section"));
10189 endbuf
= (char *) edefs
+ section
->sh_size
;
10191 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
10194 Elf_External_Verdef
* edef
;
10195 Elf_Internal_Verdef ent
;
10196 Elf_External_Verdaux
* eaux
;
10197 Elf_Internal_Verdaux aux
;
10198 unsigned long isum
;
10201 vstart
= ((char *) edefs
) + idx
;
10202 if (vstart
+ sizeof (*edef
) > endbuf
)
10205 edef
= (Elf_External_Verdef
*) vstart
;
10207 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
10208 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
10209 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
10210 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
10211 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
10212 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
10213 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
10215 printf (_(" %#06lx: Rev: %d Flags: %s"),
10216 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
10218 printf (_(" Index: %d Cnt: %d "),
10219 ent
.vd_ndx
, ent
.vd_cnt
);
10221 /* Check for overflow. */
10222 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
10225 vstart
+= ent
.vd_aux
;
10227 if (vstart
+ sizeof (*eaux
) > endbuf
)
10229 eaux
= (Elf_External_Verdaux
*) vstart
;
10231 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10232 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10234 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10235 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
10237 printf (_("Name index: %ld\n"), aux
.vda_name
);
10239 isum
= idx
+ ent
.vd_aux
;
10241 for (j
= 1; j
< ent
.vd_cnt
; j
++)
10243 if (aux
.vda_next
< sizeof (*eaux
)
10244 && !(j
== ent
.vd_cnt
- 1 && aux
.vda_next
== 0))
10246 warn (_("Invalid vda_next field of %lx\n"),
10251 /* Check for overflow. */
10252 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
10255 isum
+= aux
.vda_next
;
10256 vstart
+= aux
.vda_next
;
10258 if (vstart
+ sizeof (*eaux
) > endbuf
)
10260 eaux
= (Elf_External_Verdaux
*) vstart
;
10262 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10263 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10265 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10266 printf (_(" %#06lx: Parent %d: %s\n"),
10267 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
10269 printf (_(" %#06lx: Parent %d, name index: %ld\n"),
10270 isum
, j
, aux
.vda_name
);
10273 if (j
< ent
.vd_cnt
)
10274 printf (_(" Version def aux past end of section\n"));
10277 file: id:000001,src:000172+005151,op:splice,rep:2. */
10278 if (ent
.vd_next
< sizeof (*edef
)
10279 && !(cnt
== section
->sh_info
- 1 && ent
.vd_next
== 0))
10281 warn (_("Invalid vd_next field of %lx\n"), ent
.vd_next
);
10282 cnt
= section
->sh_info
;
10285 if (ent
.vd_next
> (size_t) (endbuf
- ((char *) edefs
+ idx
)))
10288 idx
+= ent
.vd_next
;
10291 if (cnt
< section
->sh_info
)
10292 printf (_(" Version definition past end of section\n"));
10298 case SHT_GNU_verneed
:
10300 Elf_External_Verneed
* eneed
;
10307 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
10308 printable_section_name (section
), section
->sh_info
);
10310 printf (_(" Addr: 0x"));
10311 printf_vma (section
->sh_addr
);
10312 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10313 (unsigned long) section
->sh_offset
, section
->sh_link
,
10314 printable_section_name_from_index (section
->sh_link
));
10316 eneed
= (Elf_External_Verneed
*) get_data (NULL
, file
,
10317 section
->sh_offset
, 1,
10319 _("Version Needs section"));
10322 endbuf
= (char *) eneed
+ section
->sh_size
;
10324 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
10326 Elf_External_Verneed
* entry
;
10327 Elf_Internal_Verneed ent
;
10328 unsigned long isum
;
10332 vstart
= ((char *) eneed
) + idx
;
10333 if (vstart
+ sizeof (*entry
) > endbuf
)
10336 entry
= (Elf_External_Verneed
*) vstart
;
10338 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
10339 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
10340 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
10341 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
10342 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
10344 printf (_(" %#06lx: Version: %d"), idx
, ent
.vn_version
);
10346 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
10347 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
10349 printf (_(" File: %lx"), ent
.vn_file
);
10351 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
10353 /* Check for overflow. */
10354 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
10356 vstart
+= ent
.vn_aux
;
10358 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
10360 Elf_External_Vernaux
* eaux
;
10361 Elf_Internal_Vernaux aux
;
10363 if (vstart
+ sizeof (*eaux
) > endbuf
)
10365 eaux
= (Elf_External_Vernaux
*) vstart
;
10367 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
10368 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
10369 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
10370 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
10371 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
10373 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
10374 printf (_(" %#06lx: Name: %s"),
10375 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
10377 printf (_(" %#06lx: Name index: %lx"),
10378 isum
, aux
.vna_name
);
10380 printf (_(" Flags: %s Version: %d\n"),
10381 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
10383 if (aux
.vna_next
< sizeof (*eaux
)
10384 && !(j
== ent
.vn_cnt
- 1 && aux
.vna_next
== 0))
10386 warn (_("Invalid vna_next field of %lx\n"),
10391 /* Check for overflow. */
10392 if (aux
.vna_next
> (size_t) (endbuf
- vstart
))
10394 isum
+= aux
.vna_next
;
10395 vstart
+= aux
.vna_next
;
10398 if (j
< ent
.vn_cnt
)
10399 warn (_("Missing Version Needs auxillary information\n"));
10401 if (ent
.vn_next
< sizeof (*entry
)
10402 && !(cnt
== section
->sh_info
- 1 && ent
.vn_next
== 0))
10404 warn (_("Invalid vn_next field of %lx\n"), ent
.vn_next
);
10405 cnt
= section
->sh_info
;
10408 if (ent
.vn_next
> (size_t) (endbuf
- ((char *) eneed
+ idx
)))
10410 idx
+= ent
.vn_next
;
10413 if (cnt
< section
->sh_info
)
10414 warn (_("Missing Version Needs information\n"));
10420 case SHT_GNU_versym
:
10422 Elf_Internal_Shdr
* link_section
;
10425 unsigned char * edata
;
10426 unsigned short * data
;
10428 Elf_Internal_Sym
* symbols
;
10429 Elf_Internal_Shdr
* string_sec
;
10430 unsigned long num_syms
;
10433 if (section
->sh_link
>= elf_header
.e_shnum
)
10436 link_section
= section_headers
+ section
->sh_link
;
10437 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
10439 if (link_section
->sh_link
>= elf_header
.e_shnum
)
10444 symbols
= GET_ELF_SYMBOLS (file
, link_section
, & num_syms
);
10445 if (symbols
== NULL
)
10448 string_sec
= section_headers
+ link_section
->sh_link
;
10450 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
10451 string_sec
->sh_size
,
10452 _("version string table"));
10459 printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
10460 printable_section_name (section
), (unsigned long) total
);
10462 printf (_(" Addr: "));
10463 printf_vma (section
->sh_addr
);
10464 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10465 (unsigned long) section
->sh_offset
, section
->sh_link
,
10466 printable_section_name (link_section
));
10468 off
= offset_from_vma (file
,
10469 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
10470 total
* sizeof (short));
10471 edata
= (unsigned char *) get_data (NULL
, file
, off
, total
,
10473 _("version symbol data"));
10481 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
10483 for (cnt
= total
; cnt
--;)
10484 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
10489 for (cnt
= 0; cnt
< total
; cnt
+= 4)
10493 char *invalid
= _("*invalid*");
10495 printf (" %03x:", cnt
);
10497 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
10498 switch (data
[cnt
+ j
])
10501 fputs (_(" 0 (*local*) "), stdout
);
10505 fputs (_(" 1 (*global*) "), stdout
);
10509 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
10510 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
10512 /* If this index value is greater than the size of the symbols
10513 array, break to avoid an out-of-bounds read. */
10514 if ((unsigned long)(cnt
+ j
) >= num_syms
)
10516 warn (_("invalid index into symbol array\n"));
10521 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
10523 Elf_Internal_Verneed ivn
;
10524 unsigned long offset
;
10526 offset
= offset_from_vma
10527 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
10528 sizeof (Elf_External_Verneed
));
10532 Elf_Internal_Vernaux ivna
;
10533 Elf_External_Verneed evn
;
10534 Elf_External_Vernaux evna
;
10535 unsigned long a_off
;
10537 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
10538 _("version need")) == NULL
)
10541 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
10542 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
10544 a_off
= offset
+ ivn
.vn_aux
;
10548 if (get_data (&evna
, file
, a_off
, sizeof (evna
),
10549 1, _("version need aux (2)")) == NULL
)
10552 ivna
.vna_other
= 0;
10556 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
10557 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
10560 a_off
+= ivna
.vna_next
;
10562 while (ivna
.vna_other
!= data
[cnt
+ j
]
10563 && ivna
.vna_next
!= 0);
10565 if (ivna
.vna_other
== data
[cnt
+ j
])
10567 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
10569 if (ivna
.vna_name
>= string_sec
->sh_size
)
10572 name
= strtab
+ ivna
.vna_name
;
10576 offset
+= ivn
.vn_next
;
10578 while (ivn
.vn_next
);
10581 if (data
[cnt
+ j
] != 0x8001
10582 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
10584 Elf_Internal_Verdef ivd
;
10585 Elf_External_Verdef evd
;
10586 unsigned long offset
;
10588 offset
= offset_from_vma
10589 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
10594 if (get_data (&evd
, file
, offset
, sizeof (evd
), 1,
10595 _("version def")) == NULL
)
10598 /* PR 17531: file: 046-1082287-0.004. */
10599 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
10604 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
10605 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
10608 offset
+= ivd
.vd_next
;
10610 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
10611 && ivd
.vd_next
!= 0);
10613 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
10615 Elf_External_Verdaux evda
;
10616 Elf_Internal_Verdaux ivda
;
10618 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
10620 if (get_data (&evda
, file
,
10621 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
10623 _("version def aux")) == NULL
)
10626 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
10628 if (ivda
.vda_name
>= string_sec
->sh_size
)
10630 else if (name
!= NULL
&& name
!= invalid
)
10631 name
= _("*both*");
10633 name
= strtab
+ ivda
.vda_name
;
10637 nn
+= printf ("(%s%-*s",
10639 12 - (int) strlen (name
),
10643 printf ("%*c", 18 - nn
, ' ');
10661 printf (_("\nNo version information found in this file.\n"));
10666 static const char *
10667 get_symbol_binding (unsigned int binding
)
10669 static char buff
[32];
10673 case STB_LOCAL
: return "LOCAL";
10674 case STB_GLOBAL
: return "GLOBAL";
10675 case STB_WEAK
: return "WEAK";
10677 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
10678 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
10680 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
10682 if (binding
== STB_GNU_UNIQUE
10683 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10684 /* GNU is still using the default value 0. */
10685 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10687 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
10690 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
10695 static const char *
10696 get_symbol_type (unsigned int type
)
10698 static char buff
[32];
10702 case STT_NOTYPE
: return "NOTYPE";
10703 case STT_OBJECT
: return "OBJECT";
10704 case STT_FUNC
: return "FUNC";
10705 case STT_SECTION
: return "SECTION";
10706 case STT_FILE
: return "FILE";
10707 case STT_COMMON
: return "COMMON";
10708 case STT_TLS
: return "TLS";
10709 case STT_RELC
: return "RELC";
10710 case STT_SRELC
: return "SRELC";
10712 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
10714 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
10715 return "THUMB_FUNC";
10717 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
10720 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
10721 return "PARISC_MILLI";
10723 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
10725 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
10727 if (elf_header
.e_machine
== EM_PARISC
)
10729 if (type
== STT_HP_OPAQUE
)
10730 return "HP_OPAQUE";
10731 if (type
== STT_HP_STUB
)
10735 if (type
== STT_GNU_IFUNC
10736 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10737 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
10738 /* GNU is still using the default value 0. */
10739 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10742 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
10745 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
10750 static const char *
10751 get_symbol_visibility (unsigned int visibility
)
10753 switch (visibility
)
10755 case STV_DEFAULT
: return "DEFAULT";
10756 case STV_INTERNAL
: return "INTERNAL";
10757 case STV_HIDDEN
: return "HIDDEN";
10758 case STV_PROTECTED
: return "PROTECTED";
10760 error (_("Unrecognized visibility value: %u"), visibility
);
10761 return _("<unknown>");
10765 static const char *
10766 get_solaris_symbol_visibility (unsigned int visibility
)
10768 switch (visibility
)
10770 case 4: return "EXPORTED";
10771 case 5: return "SINGLETON";
10772 case 6: return "ELIMINATE";
10773 default: return get_symbol_visibility (visibility
);
10777 static const char *
10778 get_mips_symbol_other (unsigned int other
)
10782 case STO_OPTIONAL
: return "OPTIONAL";
10783 case STO_MIPS_PLT
: return "MIPS PLT";
10784 case STO_MIPS_PIC
: return "MIPS PIC";
10785 case STO_MICROMIPS
: return "MICROMIPS";
10786 case STO_MICROMIPS
| STO_MIPS_PIC
: return "MICROMIPS, MIPS PIC";
10787 case STO_MIPS16
: return "MIPS16";
10788 default: return NULL
;
10792 static const char *
10793 get_ia64_symbol_other (unsigned int other
)
10795 if (is_ia64_vms ())
10797 static char res
[32];
10801 /* Function types is for images and .STB files only. */
10802 switch (elf_header
.e_type
)
10806 switch (VMS_ST_FUNC_TYPE (other
))
10808 case VMS_SFT_CODE_ADDR
:
10809 strcat (res
, " CA");
10811 case VMS_SFT_SYMV_IDX
:
10812 strcat (res
, " VEC");
10815 strcat (res
, " FD");
10817 case VMS_SFT_RESERVE
:
10818 strcat (res
, " RSV");
10821 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10822 VMS_ST_FUNC_TYPE (other
));
10823 strcat (res
, " <unknown>");
10830 switch (VMS_ST_LINKAGE (other
))
10832 case VMS_STL_IGNORE
:
10833 strcat (res
, " IGN");
10835 case VMS_STL_RESERVE
:
10836 strcat (res
, " RSV");
10839 strcat (res
, " STD");
10842 strcat (res
, " LNK");
10845 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10846 VMS_ST_LINKAGE (other
));
10847 strcat (res
, " <unknown>");
10859 static const char *
10860 get_ppc64_symbol_other (unsigned int other
)
10862 if (PPC64_LOCAL_ENTRY_OFFSET (other
) != 0)
10864 static char buf
[32];
10865 snprintf (buf
, sizeof buf
, _("<localentry>: %d"),
10866 PPC64_LOCAL_ENTRY_OFFSET (other
));
10872 static const char *
10873 get_symbol_other (unsigned int other
)
10875 const char * result
= NULL
;
10876 static char buff
[32];
10881 switch (elf_header
.e_machine
)
10884 result
= get_mips_symbol_other (other
);
10887 result
= get_ia64_symbol_other (other
);
10890 result
= get_ppc64_symbol_other (other
);
10900 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
10904 static const char *
10905 get_symbol_index_type (unsigned int type
)
10907 static char buff
[32];
10911 case SHN_UNDEF
: return "UND";
10912 case SHN_ABS
: return "ABS";
10913 case SHN_COMMON
: return "COM";
10915 if (type
== SHN_IA_64_ANSI_COMMON
10916 && elf_header
.e_machine
== EM_IA_64
10917 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
10919 else if ((elf_header
.e_machine
== EM_X86_64
10920 || elf_header
.e_machine
== EM_L1OM
10921 || elf_header
.e_machine
== EM_K1OM
)
10922 && type
== SHN_X86_64_LCOMMON
)
10923 return "LARGE_COM";
10924 else if ((type
== SHN_MIPS_SCOMMON
10925 && elf_header
.e_machine
== EM_MIPS
)
10926 || (type
== SHN_TIC6X_SCOMMON
10927 && elf_header
.e_machine
== EM_TI_C6000
))
10929 else if (type
== SHN_MIPS_SUNDEFINED
10930 && elf_header
.e_machine
== EM_MIPS
)
10932 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
10933 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
10934 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
10935 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
10936 else if (type
>= SHN_LORESERVE
)
10937 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
10938 else if (type
>= elf_header
.e_shnum
)
10939 sprintf (buff
, _("bad section index[%3d]"), type
);
10941 sprintf (buff
, "%3d", type
);
10949 get_dynamic_data (FILE * file
, bfd_size_type number
, unsigned int ent_size
)
10951 unsigned char * e_data
;
10954 /* If the size_t type is smaller than the bfd_size_type, eg because
10955 you are building a 32-bit tool on a 64-bit host, then make sure
10956 that when (number) is cast to (size_t) no information is lost. */
10957 if (sizeof (size_t) < sizeof (bfd_size_type
)
10958 && (bfd_size_type
) ((size_t) number
) != number
)
10960 error (_("Size truncation prevents reading %" BFD_VMA_FMT
"u"
10961 " elements of size %u\n"),
10966 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
10967 attempting to allocate memory when the read is bound to fail. */
10968 if (ent_size
* number
> current_file_size
)
10970 error (_("Invalid number of dynamic entries: %" BFD_VMA_FMT
"u\n"),
10975 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
10976 if (e_data
== NULL
)
10978 error (_("Out of memory reading %" BFD_VMA_FMT
"u dynamic entries\n"),
10983 if (fread (e_data
, ent_size
, (size_t) number
, file
) != number
)
10985 error (_("Unable to read in %" BFD_VMA_FMT
"u bytes of dynamic data\n"),
10986 number
* ent_size
);
10991 i_data
= (bfd_vma
*) cmalloc ((size_t) number
, sizeof (*i_data
));
10992 if (i_data
== NULL
)
10994 error (_("Out of memory allocating space for %" BFD_VMA_FMT
"u"
10995 " dynamic entries\n"),
11002 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
11010 print_dynamic_symbol (bfd_vma si
, unsigned long hn
)
11012 Elf_Internal_Sym
* psym
;
11015 n
= print_vma (si
, DEC_5
);
11017 fputs (&" "[n
], stdout
);
11018 printf (" %3lu: ", hn
);
11020 if (dynamic_symbols
== NULL
|| si
>= num_dynamic_syms
)
11022 printf (_("<No info available for dynamic symbol number %lu>\n"),
11023 (unsigned long) si
);
11027 psym
= dynamic_symbols
+ si
;
11028 print_vma (psym
->st_value
, LONG_HEX
);
11030 print_vma (psym
->st_size
, DEC_5
);
11032 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
11033 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
11035 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
11036 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
11039 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
11041 printf (" %-7s", get_symbol_visibility (vis
));
11042 /* Check to see if any other bits in the st_other field are set.
11043 Note - displaying this information disrupts the layout of the
11044 table being generated, but for the moment this case is very
11046 if (psym
->st_other
^ vis
)
11047 printf (" [%s] ", get_symbol_other (psym
->st_other
^ vis
));
11050 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
11051 if (VALID_DYNAMIC_NAME (psym
->st_name
))
11052 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
11054 printf (_(" <corrupt: %14ld>"), psym
->st_name
);
11058 static const char *
11059 get_symbol_version_string (FILE * file
,
11060 bfd_boolean is_dynsym
,
11061 const char * strtab
,
11062 unsigned long int strtab_size
,
11064 Elf_Internal_Sym
* psym
,
11065 enum versioned_symbol_info
* sym_info
,
11066 unsigned short * vna_other
)
11068 unsigned char data
[2];
11069 unsigned short vers_data
;
11070 unsigned long offset
;
11073 || version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
11076 offset
= offset_from_vma (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
11077 sizeof data
+ si
* sizeof (vers_data
));
11079 if (get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
11080 sizeof (data
), 1, _("version data")) == NULL
)
11083 vers_data
= byte_get (data
, 2);
11085 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
<= 1)
11088 /* Usually we'd only see verdef for defined symbols, and verneed for
11089 undefined symbols. However, symbols defined by the linker in
11090 .dynbss for variables copied from a shared library in order to
11091 avoid text relocations are defined yet have verneed. We could
11092 use a heuristic to detect the special case, for example, check
11093 for verneed first on symbols defined in SHT_NOBITS sections, but
11094 it is simpler and more reliable to just look for both verdef and
11095 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
11097 if (psym
->st_shndx
!= SHN_UNDEF
11098 && vers_data
!= 0x8001
11099 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
11101 Elf_Internal_Verdef ivd
;
11102 Elf_Internal_Verdaux ivda
;
11103 Elf_External_Verdaux evda
;
11106 off
= offset_from_vma (file
,
11107 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
11108 sizeof (Elf_External_Verdef
));
11112 Elf_External_Verdef evd
;
11114 if (get_data (&evd
, file
, off
, sizeof (evd
), 1,
11115 _("version def")) == NULL
)
11123 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
11124 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
11125 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
11128 off
+= ivd
.vd_next
;
11130 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
11132 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
11134 off
-= ivd
.vd_next
;
11137 if (get_data (&evda
, file
, off
, sizeof (evda
), 1,
11138 _("version def aux")) != NULL
)
11140 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
11142 if (psym
->st_name
!= ivda
.vda_name
)
11144 *sym_info
= ((vers_data
& VERSYM_HIDDEN
) != 0
11145 ? symbol_hidden
: symbol_public
);
11146 return (ivda
.vda_name
< strtab_size
11147 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
11153 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
11155 Elf_External_Verneed evn
;
11156 Elf_Internal_Verneed ivn
;
11157 Elf_Internal_Vernaux ivna
;
11159 offset
= offset_from_vma (file
,
11160 version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
11164 unsigned long vna_off
;
11166 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
11167 _("version need")) == NULL
)
11170 ivna
.vna_other
= 0;
11175 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
11176 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
11178 vna_off
= offset
+ ivn
.vn_aux
;
11182 Elf_External_Vernaux evna
;
11184 if (get_data (&evna
, file
, vna_off
, sizeof (evna
), 1,
11185 _("version need aux (3)")) == NULL
)
11188 ivna
.vna_other
= 0;
11193 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
11194 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
11195 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
11198 vna_off
+= ivna
.vna_next
;
11200 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
11202 if (ivna
.vna_other
== vers_data
)
11205 offset
+= ivn
.vn_next
;
11207 while (ivn
.vn_next
!= 0);
11209 if (ivna
.vna_other
== vers_data
)
11211 *sym_info
= symbol_undefined
;
11212 *vna_other
= ivna
.vna_other
;
11213 return (ivna
.vna_name
< strtab_size
11214 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
11220 /* Dump the symbol table. */
11222 process_symbol_table (FILE * file
)
11224 Elf_Internal_Shdr
* section
;
11225 bfd_size_type nbuckets
= 0;
11226 bfd_size_type nchains
= 0;
11227 bfd_vma
* buckets
= NULL
;
11228 bfd_vma
* chains
= NULL
;
11229 bfd_vma ngnubuckets
= 0;
11230 bfd_vma
* gnubuckets
= NULL
;
11231 bfd_vma
* gnuchains
= NULL
;
11232 bfd_vma gnusymidx
= 0;
11233 bfd_size_type ngnuchains
= 0;
11235 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
11238 if (dynamic_info
[DT_HASH
]
11240 || (do_using_dynamic
11242 && dynamic_strings
!= NULL
)))
11244 unsigned char nb
[8];
11245 unsigned char nc
[8];
11246 unsigned int hash_ent_size
= 4;
11248 if ((elf_header
.e_machine
== EM_ALPHA
11249 || elf_header
.e_machine
== EM_S390
11250 || elf_header
.e_machine
== EM_S390_OLD
)
11251 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
11255 (archive_file_offset
11256 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
11257 sizeof nb
+ sizeof nc
)),
11260 error (_("Unable to seek to start of dynamic information\n"));
11264 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
11266 error (_("Failed to read in number of buckets\n"));
11270 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
11272 error (_("Failed to read in number of chains\n"));
11276 nbuckets
= byte_get (nb
, hash_ent_size
);
11277 nchains
= byte_get (nc
, hash_ent_size
);
11279 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
11280 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
11283 if (buckets
== NULL
|| chains
== NULL
)
11285 if (do_using_dynamic
)
11296 if (dynamic_info_DT_GNU_HASH
11298 || (do_using_dynamic
11300 && dynamic_strings
!= NULL
)))
11302 unsigned char nb
[16];
11303 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
11304 bfd_vma buckets_vma
;
11307 (archive_file_offset
11308 + offset_from_vma (file
, dynamic_info_DT_GNU_HASH
,
11312 error (_("Unable to seek to start of dynamic information\n"));
11316 if (fread (nb
, 16, 1, file
) != 1)
11318 error (_("Failed to read in number of buckets\n"));
11322 ngnubuckets
= byte_get (nb
, 4);
11323 gnusymidx
= byte_get (nb
+ 4, 4);
11324 bitmaskwords
= byte_get (nb
+ 8, 4);
11325 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
11327 buckets_vma
+= bitmaskwords
* 4;
11329 buckets_vma
+= bitmaskwords
* 8;
11332 (archive_file_offset
11333 + offset_from_vma (file
, buckets_vma
, 4)),
11336 error (_("Unable to seek to start of dynamic information\n"));
11340 gnubuckets
= get_dynamic_data (file
, ngnubuckets
, 4);
11342 if (gnubuckets
== NULL
)
11345 for (i
= 0; i
< ngnubuckets
; i
++)
11346 if (gnubuckets
[i
] != 0)
11348 if (gnubuckets
[i
] < gnusymidx
)
11351 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
11352 maxchain
= gnubuckets
[i
];
11355 if (maxchain
== 0xffffffff)
11358 maxchain
-= gnusymidx
;
11361 (archive_file_offset
11362 + offset_from_vma (file
, buckets_vma
11363 + 4 * (ngnubuckets
+ maxchain
), 4)),
11366 error (_("Unable to seek to start of dynamic information\n"));
11372 if (fread (nb
, 4, 1, file
) != 1)
11374 error (_("Failed to determine last chain length\n"));
11378 if (maxchain
+ 1 == 0)
11383 while ((byte_get (nb
, 4) & 1) == 0);
11386 (archive_file_offset
11387 + offset_from_vma (file
, buckets_vma
+ 4 * ngnubuckets
, 4)),
11390 error (_("Unable to seek to start of dynamic information\n"));
11394 gnuchains
= get_dynamic_data (file
, maxchain
, 4);
11395 ngnuchains
= maxchain
;
11398 if (gnuchains
== NULL
)
11403 if (do_using_dynamic
)
11408 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
11410 && do_using_dynamic
11411 && dynamic_strings
!= NULL
11412 && dynamic_symbols
!= NULL
)
11416 if (dynamic_info
[DT_HASH
])
11420 printf (_("\nSymbol table for image:\n"));
11422 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11424 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11426 for (hn
= 0; hn
< nbuckets
; hn
++)
11431 for (si
= buckets
[hn
]; si
< nchains
&& si
> 0; si
= chains
[si
])
11432 print_dynamic_symbol (si
, hn
);
11436 if (dynamic_info_DT_GNU_HASH
)
11438 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
11440 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11442 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11444 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11445 if (gnubuckets
[hn
] != 0)
11447 bfd_vma si
= gnubuckets
[hn
];
11448 bfd_vma off
= si
- gnusymidx
;
11452 print_dynamic_symbol (si
, hn
);
11455 while (off
< ngnuchains
&& (gnuchains
[off
++] & 1) == 0);
11459 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
11460 && section_headers
!= NULL
)
11464 for (i
= 0, section
= section_headers
;
11465 i
< elf_header
.e_shnum
;
11469 char * strtab
= NULL
;
11470 unsigned long int strtab_size
= 0;
11471 Elf_Internal_Sym
* symtab
;
11472 Elf_Internal_Sym
* psym
;
11473 unsigned long num_syms
;
11475 if ((section
->sh_type
!= SHT_SYMTAB
11476 && section
->sh_type
!= SHT_DYNSYM
)
11478 && section
->sh_type
== SHT_SYMTAB
))
11481 if (section
->sh_entsize
== 0)
11483 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
11484 printable_section_name (section
));
11488 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
11489 printable_section_name (section
),
11490 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
11493 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11495 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11497 symtab
= GET_ELF_SYMBOLS (file
, section
, & num_syms
);
11498 if (symtab
== NULL
)
11501 if (section
->sh_link
== elf_header
.e_shstrndx
)
11503 strtab
= string_table
;
11504 strtab_size
= string_table_length
;
11506 else if (section
->sh_link
< elf_header
.e_shnum
)
11508 Elf_Internal_Shdr
* string_sec
;
11510 string_sec
= section_headers
+ section
->sh_link
;
11512 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
11513 1, string_sec
->sh_size
,
11514 _("string table"));
11515 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
11518 for (si
= 0, psym
= symtab
; si
< num_syms
; si
++, psym
++)
11520 const char *version_string
;
11521 enum versioned_symbol_info sym_info
;
11522 unsigned short vna_other
;
11524 printf ("%6d: ", si
);
11525 print_vma (psym
->st_value
, LONG_HEX
);
11527 print_vma (psym
->st_size
, DEC_5
);
11528 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
11529 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
11530 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
11531 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
11534 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
11536 printf (" %-7s", get_symbol_visibility (vis
));
11537 /* Check to see if any other bits in the st_other field are set.
11538 Note - displaying this information disrupts the layout of the
11539 table being generated, but for the moment this case is very rare. */
11540 if (psym
->st_other
^ vis
)
11541 printf (" [%s] ", get_symbol_other (psym
->st_other
^ vis
));
11543 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
11544 print_symbol (25, psym
->st_name
< strtab_size
11545 ? strtab
+ psym
->st_name
: _("<corrupt>"));
11548 = get_symbol_version_string (file
,
11549 section
->sh_type
== SHT_DYNSYM
,
11550 strtab
, strtab_size
, si
,
11551 psym
, &sym_info
, &vna_other
);
11552 if (version_string
)
11554 if (sym_info
== symbol_undefined
)
11555 printf ("@%s (%d)", version_string
, vna_other
);
11557 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
11563 if (ELF_ST_BIND (psym
->st_info
) == STB_LOCAL
11564 && si
>= section
->sh_info
11565 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
11566 && elf_header
.e_machine
!= EM_MIPS
11567 /* Solaris binaries have been found to violate this requirement as
11568 well. Not sure if this is a bug or an ABI requirement. */
11569 && elf_header
.e_ident
[EI_OSABI
] != ELFOSABI_SOLARIS
)
11570 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
11571 si
, printable_section_name (section
), section
->sh_info
);
11575 if (strtab
!= string_table
)
11581 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
11583 if (do_histogram
&& buckets
!= NULL
)
11585 unsigned long * lengths
;
11586 unsigned long * counts
;
11589 unsigned long maxlength
= 0;
11590 unsigned long nzero_counts
= 0;
11591 unsigned long nsyms
= 0;
11592 unsigned long chained
;
11594 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
11595 (unsigned long) nbuckets
);
11597 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
11598 if (lengths
== NULL
)
11600 error (_("Out of memory allocating space for histogram buckets\n"));
11604 printf (_(" Length Number %% of total Coverage\n"));
11605 for (hn
= 0; hn
< nbuckets
; ++hn
)
11607 for (si
= buckets
[hn
], chained
= 0;
11608 si
> 0 && si
< nchains
&& si
< nbuckets
&& chained
<= nchains
;
11609 si
= chains
[si
], ++chained
)
11612 if (maxlength
< ++lengths
[hn
])
11616 /* PR binutils/17531: A corrupt binary could contain broken
11617 histogram data. Do not go into an infinite loop trying
11619 if (chained
> nchains
)
11621 error (_("histogram chain is corrupt\n"));
11626 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
11627 if (counts
== NULL
)
11630 error (_("Out of memory allocating space for histogram counts\n"));
11634 for (hn
= 0; hn
< nbuckets
; ++hn
)
11635 ++counts
[lengths
[hn
]];
11640 printf (" 0 %-10lu (%5.1f%%)\n",
11641 counts
[0], (counts
[0] * 100.0) / nbuckets
);
11642 for (i
= 1; i
<= maxlength
; ++i
)
11644 nzero_counts
+= counts
[i
] * i
;
11645 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11646 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
11647 (nzero_counts
* 100.0) / nsyms
);
11655 if (buckets
!= NULL
)
11661 if (do_histogram
&& gnubuckets
!= NULL
)
11663 unsigned long * lengths
;
11664 unsigned long * counts
;
11666 unsigned long maxlength
= 0;
11667 unsigned long nzero_counts
= 0;
11668 unsigned long nsyms
= 0;
11670 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
11671 (unsigned long) ngnubuckets
);
11673 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
11674 if (lengths
== NULL
)
11676 error (_("Out of memory allocating space for gnu histogram buckets\n"));
11680 printf (_(" Length Number %% of total Coverage\n"));
11682 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11683 if (gnubuckets
[hn
] != 0)
11685 bfd_vma off
, length
= 1;
11687 for (off
= gnubuckets
[hn
] - gnusymidx
;
11688 /* PR 17531 file: 010-77222-0.004. */
11689 off
< ngnuchains
&& (gnuchains
[off
] & 1) == 0;
11692 lengths
[hn
] = length
;
11693 if (length
> maxlength
)
11694 maxlength
= length
;
11698 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
11699 if (counts
== NULL
)
11702 error (_("Out of memory allocating space for gnu histogram counts\n"));
11706 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11707 ++counts
[lengths
[hn
]];
11709 if (ngnubuckets
> 0)
11712 printf (" 0 %-10lu (%5.1f%%)\n",
11713 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
11714 for (j
= 1; j
<= maxlength
; ++j
)
11716 nzero_counts
+= counts
[j
] * j
;
11717 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11718 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
11719 (nzero_counts
* 100.0) / nsyms
);
11733 process_syminfo (FILE * file ATTRIBUTE_UNUSED
)
11737 if (dynamic_syminfo
== NULL
11739 /* No syminfo, this is ok. */
11742 /* There better should be a dynamic symbol section. */
11743 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
11747 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
11748 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
11750 printf (_(" Num: Name BoundTo Flags\n"));
11751 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
11753 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
11755 printf ("%4d: ", i
);
11756 if (i
>= num_dynamic_syms
)
11757 printf (_("<corrupt index>"));
11758 else if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
11759 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
11761 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
11764 switch (dynamic_syminfo
[i
].si_boundto
)
11766 case SYMINFO_BT_SELF
:
11767 fputs ("SELF ", stdout
);
11769 case SYMINFO_BT_PARENT
:
11770 fputs ("PARENT ", stdout
);
11773 if (dynamic_syminfo
[i
].si_boundto
> 0
11774 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
11775 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
11777 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
11781 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
11785 if (flags
& SYMINFO_FLG_DIRECT
)
11786 printf (" DIRECT");
11787 if (flags
& SYMINFO_FLG_PASSTHRU
)
11788 printf (" PASSTHRU");
11789 if (flags
& SYMINFO_FLG_COPY
)
11791 if (flags
& SYMINFO_FLG_LAZYLOAD
)
11792 printf (" LAZYLOAD");
11800 #define IN_RANGE(START,END,ADDR,OFF) \
11801 (((ADDR) >= (START)) && ((ADDR) + (OFF) < (END)))
11803 /* Check to see if the given reloc needs to be handled in a target specific
11804 manner. If so then process the reloc and return TRUE otherwise return
11807 If called with reloc == NULL, then this is a signal that reloc processing
11808 for the current section has finished, and any saved state should be
11812 target_specific_reloc_handling (Elf_Internal_Rela
* reloc
,
11813 unsigned char * start
,
11814 unsigned char * end
,
11815 Elf_Internal_Sym
* symtab
,
11816 unsigned long num_syms
)
11818 unsigned int reloc_type
= 0;
11819 unsigned long sym_index
= 0;
11823 reloc_type
= get_reloc_type (reloc
->r_info
);
11824 sym_index
= get_reloc_symindex (reloc
->r_info
);
11827 switch (elf_header
.e_machine
)
11830 case EM_MSP430_OLD
:
11832 static Elf_Internal_Sym
* saved_sym
= NULL
;
11840 switch (reloc_type
)
11842 case 10: /* R_MSP430_SYM_DIFF */
11843 if (uses_msp430x_relocs ())
11845 /* Fall through. */
11846 case 21: /* R_MSP430X_SYM_DIFF */
11848 if (sym_index
>= num_syms
)
11849 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
11852 saved_sym
= symtab
+ sym_index
;
11855 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
11856 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
11857 goto handle_sym_diff
;
11859 case 5: /* R_MSP430_16_BYTE */
11860 case 9: /* R_MSP430_8 */
11861 if (uses_msp430x_relocs ())
11863 goto handle_sym_diff
;
11865 case 2: /* R_MSP430_ABS16 */
11866 case 15: /* R_MSP430X_ABS16 */
11867 if (! uses_msp430x_relocs ())
11869 goto handle_sym_diff
;
11872 if (saved_sym
!= NULL
)
11874 int reloc_size
= reloc_type
== 1 ? 4 : 2;
11877 if (sym_index
>= num_syms
)
11878 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
11882 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
11883 - saved_sym
->st_value
);
11885 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
11886 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
11889 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
11890 (long) reloc
->r_offset
);
11899 if (saved_sym
!= NULL
)
11900 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
11907 case EM_CYGNUS_MN10300
:
11909 static Elf_Internal_Sym
* saved_sym
= NULL
;
11917 switch (reloc_type
)
11919 case 34: /* R_MN10300_ALIGN */
11921 case 33: /* R_MN10300_SYM_DIFF */
11922 if (sym_index
>= num_syms
)
11923 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
11926 saved_sym
= symtab
+ sym_index
;
11929 case 1: /* R_MN10300_32 */
11930 case 2: /* R_MN10300_16 */
11931 if (saved_sym
!= NULL
)
11933 int reloc_size
= reloc_type
== 1 ? 4 : 2;
11936 if (sym_index
>= num_syms
)
11937 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
11941 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
11942 - saved_sym
->st_value
);
11944 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
11945 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
11947 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
11948 (long) reloc
->r_offset
);
11956 if (saved_sym
!= NULL
)
11957 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
11965 static bfd_vma saved_sym1
= 0;
11966 static bfd_vma saved_sym2
= 0;
11967 static bfd_vma value
;
11971 saved_sym1
= saved_sym2
= 0;
11975 switch (reloc_type
)
11977 case 0x80: /* R_RL78_SYM. */
11978 saved_sym1
= saved_sym2
;
11979 if (sym_index
>= num_syms
)
11980 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
11984 saved_sym2
= symtab
[sym_index
].st_value
;
11985 saved_sym2
+= reloc
->r_addend
;
11989 case 0x83: /* R_RL78_OPsub. */
11990 value
= saved_sym1
- saved_sym2
;
11991 saved_sym2
= saved_sym1
= 0;
11995 case 0x41: /* R_RL78_ABS32. */
11996 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 4))
11997 byte_put (start
+ reloc
->r_offset
, value
, 4);
11999 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12000 (long) reloc
->r_offset
);
12004 case 0x43: /* R_RL78_ABS16. */
12005 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 2))
12006 byte_put (start
+ reloc
->r_offset
, value
, 2);
12008 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12009 (long) reloc
->r_offset
);
12023 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12024 DWARF debug sections. This is a target specific test. Note - we do not
12025 go through the whole including-target-headers-multiple-times route, (as
12026 we have already done with <elf/h8.h>) because this would become very
12027 messy and even then this function would have to contain target specific
12028 information (the names of the relocs instead of their numeric values).
12029 FIXME: This is not the correct way to solve this problem. The proper way
12030 is to have target specific reloc sizing and typing functions created by
12031 the reloc-macros.h header, in the same way that it already creates the
12032 reloc naming functions. */
12035 is_32bit_abs_reloc (unsigned int reloc_type
)
12037 /* Please keep this table alpha-sorted for ease of visual lookup. */
12038 switch (elf_header
.e_machine
)
12042 return reloc_type
== 1; /* R_386_32. */
12044 return reloc_type
== 1; /* R_68K_32. */
12046 return reloc_type
== 1; /* R_860_32. */
12048 return reloc_type
== 2; /* R_960_32. */
12050 return (reloc_type
== 258
12051 || reloc_type
== 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12052 case EM_ADAPTEVA_EPIPHANY
:
12053 return reloc_type
== 3;
12055 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
12057 return reloc_type
== 1; /* R_ARC_32. */
12058 case EM_ARC_COMPACT
:
12059 case EM_ARC_COMPACT2
:
12060 return reloc_type
== 4; /* R_ARC_32. */
12062 return reloc_type
== 2; /* R_ARM_ABS32 */
12065 return reloc_type
== 1;
12067 return reloc_type
== 0x12; /* R_byte4_data. */
12069 return reloc_type
== 3; /* R_CRIS_32. */
12071 return reloc_type
== 3; /* R_CR16_NUM32. */
12073 return reloc_type
== 15; /* R_CRX_NUM32. */
12074 case EM_CYGNUS_FRV
:
12075 return reloc_type
== 1;
12076 case EM_CYGNUS_D10V
:
12078 return reloc_type
== 6; /* R_D10V_32. */
12079 case EM_CYGNUS_D30V
:
12081 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
12083 return reloc_type
== 3; /* R_DLX_RELOC_32. */
12084 case EM_CYGNUS_FR30
:
12086 return reloc_type
== 3; /* R_FR30_32. */
12088 return reloc_type
== 1; /* R_FT32_32. */
12092 return reloc_type
== 1; /* R_H8_DIR32. */
12094 return (reloc_type
== 0x64 /* R_IA64_SECREL32MSB. */
12095 || reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
12096 || reloc_type
== 0x24 /* R_IA64_DIR32MSB. */
12097 || reloc_type
== 0x25 /* R_IA64_DIR32LSB. */);
12100 return reloc_type
== 2; /* R_IP2K_32. */
12102 return reloc_type
== 2; /* R_IQ2000_32. */
12103 case EM_LATTICEMICO32
:
12104 return reloc_type
== 3; /* R_LM32_32. */
12107 return reloc_type
== 3; /* R_M32C_32. */
12109 return reloc_type
== 34; /* R_M32R_32_RELA. */
12112 return reloc_type
== 6; /* R_M68HC11_32. */
12114 return reloc_type
== 1; /* R_MCORE_ADDR32. */
12115 case EM_CYGNUS_MEP
:
12116 return reloc_type
== 4; /* R_MEP_32. */
12118 return reloc_type
== 2; /* R_METAG_ADDR32. */
12119 case EM_MICROBLAZE
:
12120 return reloc_type
== 1; /* R_MICROBLAZE_32. */
12122 return reloc_type
== 2; /* R_MIPS_32. */
12124 return reloc_type
== 4; /* R_MMIX_32. */
12125 case EM_CYGNUS_MN10200
:
12127 return reloc_type
== 1; /* R_MN10200_32. */
12128 case EM_CYGNUS_MN10300
:
12130 return reloc_type
== 1; /* R_MN10300_32. */
12132 return reloc_type
== 1; /* R_MOXIE_32. */
12133 case EM_MSP430_OLD
:
12135 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
12137 return reloc_type
== 2; /* R_MT_32. */
12139 return reloc_type
== 20; /* R_NDS32_RELA. */
12140 case EM_ALTERA_NIOS2
:
12141 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
12143 return reloc_type
== 1; /* R_NIOS_32. */
12145 return reloc_type
== 1; /* R_OR1K_32. */
12147 return (reloc_type
== 1 /* R_PARISC_DIR32. */
12148 || reloc_type
== 41); /* R_PARISC_SECREL32. */
12151 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
12153 return reloc_type
== 1; /* R_PPC64_ADDR32. */
12155 return reloc_type
== 1; /* R_PPC_ADDR32. */
12157 return reloc_type
== 11; /* R_PRU_BFD_RELOC_32. */
12159 return reloc_type
== 1; /* R_RISCV_32. */
12161 return reloc_type
== 1; /* R_RL78_DIR32. */
12163 return reloc_type
== 1; /* R_RX_DIR32. */
12165 return reloc_type
== 1; /* R_I370_ADDR31. */
12168 return reloc_type
== 4; /* R_S390_32. */
12170 return reloc_type
== 8; /* R_SCORE_ABS32. */
12172 return reloc_type
== 1; /* R_SH_DIR32. */
12173 case EM_SPARC32PLUS
:
12176 return reloc_type
== 3 /* R_SPARC_32. */
12177 || reloc_type
== 23; /* R_SPARC_UA32. */
12179 return reloc_type
== 6; /* R_SPU_ADDR32 */
12181 return reloc_type
== 1; /* R_C6000_ABS32. */
12183 return reloc_type
== 2; /* R_TILEGX_32. */
12185 return reloc_type
== 1; /* R_TILEPRO_32. */
12186 case EM_CYGNUS_V850
:
12188 return reloc_type
== 6; /* R_V850_ABS32. */
12190 return reloc_type
== 0x33; /* R_V810_WORD. */
12192 return reloc_type
== 1; /* R_VAX_32. */
12194 return reloc_type
== 3; /* R_VISIUM_32. */
12195 case EM_WEBASSEMBLY
:
12196 return reloc_type
== 1; /* R_WASM32_32. */
12200 return reloc_type
== 10; /* R_X86_64_32. */
12203 return reloc_type
== 3; /* R_XC16C_ABS_32. */
12205 return reloc_type
== 4; /* R_XGATE_32. */
12207 return reloc_type
== 1; /* R_XSTROMY16_32. */
12208 case EM_XTENSA_OLD
:
12210 return reloc_type
== 1; /* R_XTENSA_32. */
12213 static unsigned int prev_warn
= 0;
12215 /* Avoid repeating the same warning multiple times. */
12216 if (prev_warn
!= elf_header
.e_machine
)
12217 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12218 elf_header
.e_machine
);
12219 prev_warn
= elf_header
.e_machine
;
12225 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12226 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
12229 is_32bit_pcrel_reloc (unsigned int reloc_type
)
12231 switch (elf_header
.e_machine
)
12232 /* Please keep this table alpha-sorted for ease of visual lookup. */
12236 return reloc_type
== 2; /* R_386_PC32. */
12238 return reloc_type
== 4; /* R_68K_PC32. */
12240 return reloc_type
== 261; /* R_AARCH64_PREL32 */
12241 case EM_ADAPTEVA_EPIPHANY
:
12242 return reloc_type
== 6;
12244 return reloc_type
== 10; /* R_ALPHA_SREL32. */
12245 case EM_ARC_COMPACT
:
12246 case EM_ARC_COMPACT2
:
12247 return reloc_type
== 49; /* R_ARC_32_PCREL. */
12249 return reloc_type
== 3; /* R_ARM_REL32 */
12252 return reloc_type
== 36; /* R_AVR_32_PCREL. */
12253 case EM_MICROBLAZE
:
12254 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
12256 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
12258 return reloc_type
== 9; /* R_PARISC_PCREL32. */
12260 return reloc_type
== 26; /* R_PPC_REL32. */
12262 return reloc_type
== 26; /* R_PPC64_REL32. */
12265 return reloc_type
== 5; /* R_390_PC32. */
12267 return reloc_type
== 2; /* R_SH_REL32. */
12268 case EM_SPARC32PLUS
:
12271 return reloc_type
== 6; /* R_SPARC_DISP32. */
12273 return reloc_type
== 13; /* R_SPU_REL32. */
12275 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
12277 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
12279 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
12283 return reloc_type
== 2; /* R_X86_64_PC32. */
12284 case EM_XTENSA_OLD
:
12286 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
12288 /* Do not abort or issue an error message here. Not all targets use
12289 pc-relative 32-bit relocs in their DWARF debug information and we
12290 have already tested for target coverage in is_32bit_abs_reloc. A
12291 more helpful warning message will be generated by apply_relocations
12292 anyway, so just return. */
12297 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12298 a 64-bit absolute RELA relocation used in DWARF debug sections. */
12301 is_64bit_abs_reloc (unsigned int reloc_type
)
12303 switch (elf_header
.e_machine
)
12306 return reloc_type
== 257; /* R_AARCH64_ABS64. */
12308 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
12310 return (reloc_type
== 0x26 /* R_IA64_DIR64MSB. */
12311 || reloc_type
== 0x27 /* R_IA64_DIR64LSB. */);
12313 return reloc_type
== 80; /* R_PARISC_DIR64. */
12315 return reloc_type
== 38; /* R_PPC64_ADDR64. */
12317 return reloc_type
== 2; /* R_RISCV_64. */
12318 case EM_SPARC32PLUS
:
12321 return reloc_type
== 32 /* R_SPARC_64. */
12322 || reloc_type
== 54; /* R_SPARC_UA64. */
12326 return reloc_type
== 1; /* R_X86_64_64. */
12329 return reloc_type
== 22; /* R_S390_64. */
12331 return reloc_type
== 1; /* R_TILEGX_64. */
12333 return reloc_type
== 18; /* R_MIPS_64. */
12339 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12340 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
12343 is_64bit_pcrel_reloc (unsigned int reloc_type
)
12345 switch (elf_header
.e_machine
)
12348 return reloc_type
== 260; /* R_AARCH64_PREL64. */
12350 return reloc_type
== 11; /* R_ALPHA_SREL64. */
12352 return (reloc_type
== 0x4e /* R_IA64_PCREL64MSB. */
12353 || reloc_type
== 0x4f /* R_IA64_PCREL64LSB. */);
12355 return reloc_type
== 72; /* R_PARISC_PCREL64. */
12357 return reloc_type
== 44; /* R_PPC64_REL64. */
12358 case EM_SPARC32PLUS
:
12361 return reloc_type
== 46; /* R_SPARC_DISP64. */
12365 return reloc_type
== 24; /* R_X86_64_PC64. */
12368 return reloc_type
== 23; /* R_S390_PC64. */
12370 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
12376 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12377 a 24-bit absolute RELA relocation used in DWARF debug sections. */
12380 is_24bit_abs_reloc (unsigned int reloc_type
)
12382 switch (elf_header
.e_machine
)
12384 case EM_CYGNUS_MN10200
:
12386 return reloc_type
== 4; /* R_MN10200_24. */
12388 return reloc_type
== 5; /* R_FT32_20. */
12394 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12395 a 16-bit absolute RELA relocation used in DWARF debug sections. */
12398 is_16bit_abs_reloc (unsigned int reloc_type
)
12400 /* Please keep this table alpha-sorted for ease of visual lookup. */
12401 switch (elf_header
.e_machine
)
12404 case EM_ARC_COMPACT
:
12405 case EM_ARC_COMPACT2
:
12406 return reloc_type
== 2; /* R_ARC_16. */
12407 case EM_ADAPTEVA_EPIPHANY
:
12408 return reloc_type
== 5;
12411 return reloc_type
== 4; /* R_AVR_16. */
12412 case EM_CYGNUS_D10V
:
12414 return reloc_type
== 3; /* R_D10V_16. */
12418 return reloc_type
== R_H8_DIR16
;
12421 return reloc_type
== 1; /* R_IP2K_16. */
12424 return reloc_type
== 1; /* R_M32C_16 */
12425 case EM_CYGNUS_MN10200
:
12427 return reloc_type
== 2; /* R_MN10200_16. */
12428 case EM_CYGNUS_MN10300
:
12430 return reloc_type
== 2; /* R_MN10300_16. */
12432 if (uses_msp430x_relocs ())
12433 return reloc_type
== 2; /* R_MSP430_ABS16. */
12434 /* Fall through. */
12435 case EM_MSP430_OLD
:
12436 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
12438 return reloc_type
== 19; /* R_NDS32_RELA. */
12439 case EM_ALTERA_NIOS2
:
12440 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
12442 return reloc_type
== 9; /* R_NIOS_16. */
12444 return reloc_type
== 2; /* R_OR1K_16. */
12446 return reloc_type
== 8; /* R_PRU_BFD_RELOC_16. */
12448 return reloc_type
== 2; /* R_C6000_ABS16. */
12450 return reloc_type
== 2; /* R_VISIUM_16. */
12453 return reloc_type
== 2; /* R_XC16C_ABS_16. */
12455 return reloc_type
== 3; /* R_XGATE_16. */
12461 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
12462 relocation entries (possibly formerly used for SHT_GROUP sections). */
12465 is_none_reloc (unsigned int reloc_type
)
12467 switch (elf_header
.e_machine
)
12469 case EM_386
: /* R_386_NONE. */
12470 case EM_68K
: /* R_68K_NONE. */
12471 case EM_ADAPTEVA_EPIPHANY
:
12472 case EM_ALPHA
: /* R_ALPHA_NONE. */
12473 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
12474 case EM_ARC
: /* R_ARC_NONE. */
12475 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
12476 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
12477 case EM_ARM
: /* R_ARM_NONE. */
12478 case EM_C166
: /* R_XC16X_NONE. */
12479 case EM_CRIS
: /* R_CRIS_NONE. */
12480 case EM_FT32
: /* R_FT32_NONE. */
12481 case EM_IA_64
: /* R_IA64_NONE. */
12482 case EM_K1OM
: /* R_X86_64_NONE. */
12483 case EM_L1OM
: /* R_X86_64_NONE. */
12484 case EM_M32R
: /* R_M32R_NONE. */
12485 case EM_MIPS
: /* R_MIPS_NONE. */
12486 case EM_MN10300
: /* R_MN10300_NONE. */
12487 case EM_MOXIE
: /* R_MOXIE_NONE. */
12488 case EM_NIOS32
: /* R_NIOS_NONE. */
12489 case EM_OR1K
: /* R_OR1K_NONE. */
12490 case EM_PARISC
: /* R_PARISC_NONE. */
12491 case EM_PPC64
: /* R_PPC64_NONE. */
12492 case EM_PPC
: /* R_PPC_NONE. */
12493 case EM_RISCV
: /* R_RISCV_NONE. */
12494 case EM_S390
: /* R_390_NONE. */
12496 case EM_SH
: /* R_SH_NONE. */
12497 case EM_SPARC32PLUS
:
12498 case EM_SPARC
: /* R_SPARC_NONE. */
12500 case EM_TILEGX
: /* R_TILEGX_NONE. */
12501 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
12502 case EM_TI_C6000
:/* R_C6000_NONE. */
12503 case EM_X86_64
: /* R_X86_64_NONE. */
12505 case EM_WEBASSEMBLY
: /* R_WASM32_NONE. */
12506 return reloc_type
== 0;
12509 return reloc_type
== 0 || reloc_type
== 256;
12512 return (reloc_type
== 0 /* R_AVR_NONE. */
12513 || reloc_type
== 30 /* R_AVR_DIFF8. */
12514 || reloc_type
== 31 /* R_AVR_DIFF16. */
12515 || reloc_type
== 32 /* R_AVR_DIFF32. */);
12517 return reloc_type
== 3; /* R_METAG_NONE. */
12519 return (reloc_type
== 0 /* R_XTENSA_NONE. */
12520 || reloc_type
== 204 /* R_NDS32_DIFF8. */
12521 || reloc_type
== 205 /* R_NDS32_DIFF16. */
12522 || reloc_type
== 206 /* R_NDS32_DIFF32. */
12523 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
12525 return (reloc_type
== 0 /* R_PRU_NONE. */
12526 || reloc_type
== 65 /* R_PRU_DIFF8. */
12527 || reloc_type
== 66 /* R_PRU_DIFF16. */
12528 || reloc_type
== 67 /* R_PRU_DIFF32. */);
12529 case EM_XTENSA_OLD
:
12531 return (reloc_type
== 0 /* R_XTENSA_NONE. */
12532 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
12533 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
12534 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
12539 /* Returns TRUE if there is a relocation against
12540 section NAME at OFFSET bytes. */
12543 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
12545 Elf_Internal_Rela
* relocs
;
12546 Elf_Internal_Rela
* rp
;
12548 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
12551 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
12553 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
12554 if (rp
->r_offset
== offset
)
12560 /* Apply relocations to a section.
12561 Returns TRUE upon success, FALSE otherwise.
12562 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
12563 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
12564 will be set to the number of relocs loaded.
12566 Note: So far support has been added only for those relocations
12567 which can be found in debug sections. FIXME: Add support for
12568 more relocations ? */
12571 apply_relocations (void * file
,
12572 const Elf_Internal_Shdr
* section
,
12573 unsigned char * start
,
12574 bfd_size_type size
,
12575 void ** relocs_return
,
12576 unsigned long * num_relocs_return
)
12578 Elf_Internal_Shdr
* relsec
;
12579 unsigned char * end
= start
+ size
;
12580 bfd_boolean res
= TRUE
;
12582 if (relocs_return
!= NULL
)
12584 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
12585 * num_relocs_return
= 0;
12588 if (elf_header
.e_type
!= ET_REL
)
12589 /* No relocs to apply. */
12592 /* Find the reloc section associated with the section. */
12593 for (relsec
= section_headers
;
12594 relsec
< section_headers
+ elf_header
.e_shnum
;
12597 bfd_boolean is_rela
;
12598 unsigned long num_relocs
;
12599 Elf_Internal_Rela
* relocs
;
12600 Elf_Internal_Rela
* rp
;
12601 Elf_Internal_Shdr
* symsec
;
12602 Elf_Internal_Sym
* symtab
;
12603 unsigned long num_syms
;
12604 Elf_Internal_Sym
* sym
;
12606 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
12607 || relsec
->sh_info
>= elf_header
.e_shnum
12608 || section_headers
+ relsec
->sh_info
!= section
12609 || relsec
->sh_size
== 0
12610 || relsec
->sh_link
>= elf_header
.e_shnum
)
12613 is_rela
= relsec
->sh_type
== SHT_RELA
;
12617 if (!slurp_rela_relocs ((FILE *) file
, relsec
->sh_offset
,
12618 relsec
->sh_size
, & relocs
, & num_relocs
))
12623 if (!slurp_rel_relocs ((FILE *) file
, relsec
->sh_offset
,
12624 relsec
->sh_size
, & relocs
, & num_relocs
))
12628 /* SH uses RELA but uses in place value instead of the addend field. */
12629 if (elf_header
.e_machine
== EM_SH
)
12632 symsec
= section_headers
+ relsec
->sh_link
;
12633 if (symsec
->sh_type
!= SHT_SYMTAB
12634 && symsec
->sh_type
!= SHT_DYNSYM
)
12636 symtab
= GET_ELF_SYMBOLS ((FILE *) file
, symsec
, & num_syms
);
12638 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
12641 unsigned int reloc_type
;
12642 unsigned int reloc_size
;
12643 unsigned char * rloc
;
12644 unsigned long sym_index
;
12646 reloc_type
= get_reloc_type (rp
->r_info
);
12648 if (target_specific_reloc_handling (rp
, start
, end
, symtab
, num_syms
))
12650 else if (is_none_reloc (reloc_type
))
12652 else if (is_32bit_abs_reloc (reloc_type
)
12653 || is_32bit_pcrel_reloc (reloc_type
))
12655 else if (is_64bit_abs_reloc (reloc_type
)
12656 || is_64bit_pcrel_reloc (reloc_type
))
12658 else if (is_24bit_abs_reloc (reloc_type
))
12660 else if (is_16bit_abs_reloc (reloc_type
))
12664 static unsigned int prev_reloc
= 0;
12665 if (reloc_type
!= prev_reloc
)
12666 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
12667 reloc_type
, printable_section_name (section
));
12668 prev_reloc
= reloc_type
;
12673 rloc
= start
+ rp
->r_offset
;
12674 if ((rloc
+ reloc_size
) > end
|| (rloc
< start
))
12676 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
12677 (unsigned long) rp
->r_offset
,
12678 printable_section_name (section
));
12683 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
12684 if (sym_index
>= num_syms
)
12686 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
12687 sym_index
, printable_section_name (section
));
12691 sym
= symtab
+ sym_index
;
12693 /* If the reloc has a symbol associated with it,
12694 make sure that it is of an appropriate type.
12696 Relocations against symbols without type can happen.
12697 Gcc -feliminate-dwarf2-dups may generate symbols
12698 without type for debug info.
12700 Icc generates relocations against function symbols
12701 instead of local labels.
12703 Relocations against object symbols can happen, eg when
12704 referencing a global array. For an example of this see
12705 the _clz.o binary in libgcc.a. */
12707 && ELF_ST_TYPE (sym
->st_info
) != STT_COMMON
12708 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
12710 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
12711 get_symbol_type (ELF_ST_TYPE (sym
->st_info
)),
12712 (long int)(rp
- relocs
),
12713 printable_section_name (relsec
));
12720 addend
+= rp
->r_addend
;
12721 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
12722 partial_inplace. */
12724 || (elf_header
.e_machine
== EM_XTENSA
12725 && reloc_type
== 1)
12726 || ((elf_header
.e_machine
== EM_PJ
12727 || elf_header
.e_machine
== EM_PJ_OLD
)
12728 && reloc_type
== 1)
12729 || ((elf_header
.e_machine
== EM_D30V
12730 || elf_header
.e_machine
== EM_CYGNUS_D30V
)
12731 && reloc_type
== 12))
12732 addend
+= byte_get (rloc
, reloc_size
);
12734 if (is_32bit_pcrel_reloc (reloc_type
)
12735 || is_64bit_pcrel_reloc (reloc_type
))
12737 /* On HPPA, all pc-relative relocations are biased by 8. */
12738 if (elf_header
.e_machine
== EM_PARISC
)
12740 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
12744 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
12748 /* Let the target specific reloc processing code know that
12749 we have finished with these relocs. */
12750 target_specific_reloc_handling (NULL
, NULL
, NULL
, NULL
, 0);
12754 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
12755 * num_relocs_return
= num_relocs
;
12766 #ifdef SUPPORT_DISASSEMBLY
12768 disassemble_section (Elf_Internal_Shdr
* section
, FILE * file
)
12770 printf (_("\nAssembly dump of section %s\n"), printable_section_name (section
));
12772 /* FIXME: XXX -- to be done --- XXX */
12778 /* Reads in the contents of SECTION from FILE, returning a pointer
12779 to a malloc'ed buffer or NULL if something went wrong. */
12782 get_section_contents (Elf_Internal_Shdr
* section
, FILE * file
)
12784 bfd_size_type num_bytes
;
12786 num_bytes
= section
->sh_size
;
12788 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
12790 printf (_("Section '%s' has no data to dump.\n"),
12791 printable_section_name (section
));
12795 return (char *) get_data (NULL
, file
, section
->sh_offset
, 1, num_bytes
,
12796 _("section contents"));
12799 /* Uncompresses a section that was compressed using zlib, in place. */
12802 uncompress_section_contents (unsigned char **buffer
,
12803 dwarf_size_type uncompressed_size
,
12804 dwarf_size_type
*size
)
12806 dwarf_size_type compressed_size
= *size
;
12807 unsigned char * compressed_buffer
= *buffer
;
12808 unsigned char * uncompressed_buffer
;
12812 /* It is possible the section consists of several compressed
12813 buffers concatenated together, so we uncompress in a loop. */
12814 /* PR 18313: The state field in the z_stream structure is supposed
12815 to be invisible to the user (ie us), but some compilers will
12816 still complain about it being used without initialisation. So
12817 we first zero the entire z_stream structure and then set the fields
12819 memset (& strm
, 0, sizeof strm
);
12820 strm
.avail_in
= compressed_size
;
12821 strm
.next_in
= (Bytef
*) compressed_buffer
;
12822 strm
.avail_out
= uncompressed_size
;
12823 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
12825 rc
= inflateInit (& strm
);
12826 while (strm
.avail_in
> 0)
12830 strm
.next_out
= ((Bytef
*) uncompressed_buffer
12831 + (uncompressed_size
- strm
.avail_out
));
12832 rc
= inflate (&strm
, Z_FINISH
);
12833 if (rc
!= Z_STREAM_END
)
12835 rc
= inflateReset (& strm
);
12837 rc
= inflateEnd (& strm
);
12839 || strm
.avail_out
!= 0)
12842 *buffer
= uncompressed_buffer
;
12843 *size
= uncompressed_size
;
12847 free (uncompressed_buffer
);
12848 /* Indicate decompression failure. */
12854 dump_section_as_strings (Elf_Internal_Shdr
* section
, FILE * file
)
12856 Elf_Internal_Shdr
* relsec
;
12857 bfd_size_type num_bytes
;
12858 unsigned char * data
;
12859 unsigned char * end
;
12860 unsigned char * real_start
;
12861 unsigned char * start
;
12862 bfd_boolean some_strings_shown
;
12864 real_start
= start
= (unsigned char *) get_section_contents (section
, file
);
12866 /* PR 21820: Do not fail if the section was empty. */
12867 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
12869 num_bytes
= section
->sh_size
;
12871 printf (_("\nString dump of section '%s':\n"), printable_section_name (section
));
12873 if (decompress_dumps
)
12875 dwarf_size_type new_size
= num_bytes
;
12876 dwarf_size_type uncompressed_size
= 0;
12878 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
12880 Elf_Internal_Chdr chdr
;
12881 unsigned int compression_header_size
12882 = get_compression_header (& chdr
, (unsigned char *) start
,
12885 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
12887 warn (_("section '%s' has unsupported compress type: %d\n"),
12888 printable_section_name (section
), chdr
.ch_type
);
12891 else if (chdr
.ch_addralign
!= section
->sh_addralign
)
12893 warn (_("compressed section '%s' is corrupted\n"),
12894 printable_section_name (section
));
12897 uncompressed_size
= chdr
.ch_size
;
12898 start
+= compression_header_size
;
12899 new_size
-= compression_header_size
;
12901 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
12903 /* Read the zlib header. In this case, it should be "ZLIB"
12904 followed by the uncompressed section size, 8 bytes in
12905 big-endian order. */
12906 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
12907 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
12908 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
12909 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
12910 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
12911 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
12912 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
12913 uncompressed_size
+= start
[11];
12918 if (uncompressed_size
)
12920 if (uncompress_section_contents (& start
,
12921 uncompressed_size
, & new_size
))
12922 num_bytes
= new_size
;
12925 error (_("Unable to decompress section %s\n"),
12926 printable_section_name (section
));
12931 start
= real_start
;
12934 /* If the section being dumped has relocations against it the user might
12935 be expecting these relocations to have been applied. Check for this
12936 case and issue a warning message in order to avoid confusion.
12937 FIXME: Maybe we ought to have an option that dumps a section with
12938 relocs applied ? */
12939 for (relsec
= section_headers
;
12940 relsec
< section_headers
+ elf_header
.e_shnum
;
12943 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
12944 || relsec
->sh_info
>= elf_header
.e_shnum
12945 || section_headers
+ relsec
->sh_info
!= section
12946 || relsec
->sh_size
== 0
12947 || relsec
->sh_link
>= elf_header
.e_shnum
)
12950 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12955 end
= start
+ num_bytes
;
12956 some_strings_shown
= FALSE
;
12960 while (!ISPRINT (* data
))
12961 if (++ data
>= end
)
12966 size_t maxlen
= end
- data
;
12969 /* PR 11128: Use two separate invocations in order to work
12970 around bugs in the Solaris 8 implementation of printf. */
12971 printf (" [%6tx] ", data
- start
);
12973 printf (" [%6Ix] ", (size_t) (data
- start
));
12977 print_symbol ((int) maxlen
, (const char *) data
);
12979 data
+= strnlen ((const char *) data
, maxlen
);
12983 printf (_("<corrupt>\n"));
12986 some_strings_shown
= TRUE
;
12990 if (! some_strings_shown
)
12991 printf (_(" No strings found in this section."));
13000 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
13002 bfd_boolean relocate
)
13004 Elf_Internal_Shdr
* relsec
;
13005 bfd_size_type bytes
;
13006 bfd_size_type section_size
;
13008 unsigned char * data
;
13009 unsigned char * real_start
;
13010 unsigned char * start
;
13012 real_start
= start
= (unsigned char *) get_section_contents (section
, file
);
13014 /* PR 21820: Do not fail if the section was empty. */
13015 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
13017 section_size
= section
->sh_size
;
13019 printf (_("\nHex dump of section '%s':\n"), printable_section_name (section
));
13021 if (decompress_dumps
)
13023 dwarf_size_type new_size
= section_size
;
13024 dwarf_size_type uncompressed_size
= 0;
13026 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
13028 Elf_Internal_Chdr chdr
;
13029 unsigned int compression_header_size
13030 = get_compression_header (& chdr
, start
, section_size
);
13032 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13034 warn (_("section '%s' has unsupported compress type: %d\n"),
13035 printable_section_name (section
), chdr
.ch_type
);
13038 else if (chdr
.ch_addralign
!= section
->sh_addralign
)
13040 warn (_("compressed section '%s' is corrupted\n"),
13041 printable_section_name (section
));
13044 uncompressed_size
= chdr
.ch_size
;
13045 start
+= compression_header_size
;
13046 new_size
-= compression_header_size
;
13048 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
13050 /* Read the zlib header. In this case, it should be "ZLIB"
13051 followed by the uncompressed section size, 8 bytes in
13052 big-endian order. */
13053 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13054 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13055 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13056 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13057 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13058 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13059 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13060 uncompressed_size
+= start
[11];
13065 if (uncompressed_size
)
13067 if (uncompress_section_contents (& start
, uncompressed_size
,
13070 section_size
= new_size
;
13074 error (_("Unable to decompress section %s\n"),
13075 printable_section_name (section
));
13076 /* FIXME: Print the section anyway ? */
13081 start
= real_start
;
13086 if (! apply_relocations (file
, section
, start
, section_size
, NULL
, NULL
))
13091 /* If the section being dumped has relocations against it the user might
13092 be expecting these relocations to have been applied. Check for this
13093 case and issue a warning message in order to avoid confusion.
13094 FIXME: Maybe we ought to have an option that dumps a section with
13095 relocs applied ? */
13096 for (relsec
= section_headers
;
13097 relsec
< section_headers
+ elf_header
.e_shnum
;
13100 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13101 || relsec
->sh_info
>= elf_header
.e_shnum
13102 || section_headers
+ relsec
->sh_info
!= section
13103 || relsec
->sh_size
== 0
13104 || relsec
->sh_link
>= elf_header
.e_shnum
)
13107 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13112 addr
= section
->sh_addr
;
13113 bytes
= section_size
;
13122 lbytes
= (bytes
> 16 ? 16 : bytes
);
13124 printf (" 0x%8.8lx ", (unsigned long) addr
);
13126 for (j
= 0; j
< 16; j
++)
13129 printf ("%2.2x", data
[j
]);
13137 for (j
= 0; j
< lbytes
; j
++)
13140 if (k
>= ' ' && k
< 0x7f)
13160 load_specific_debug_section (enum dwarf_section_display_enum debug
,
13161 const Elf_Internal_Shdr
* sec
, void * file
)
13163 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13166 /* If it is already loaded, do nothing. */
13167 if (section
->start
!= NULL
)
13170 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
13171 section
->address
= sec
->sh_addr
;
13172 section
->user_data
= NULL
;
13173 section
->start
= (unsigned char *) get_data (NULL
, (FILE *) file
,
13175 sec
->sh_size
, buf
);
13176 if (section
->start
== NULL
)
13180 unsigned char *start
= section
->start
;
13181 dwarf_size_type size
= sec
->sh_size
;
13182 dwarf_size_type uncompressed_size
= 0;
13184 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
13186 Elf_Internal_Chdr chdr
;
13187 unsigned int compression_header_size
;
13189 if (size
< (is_32bit_elf
13190 ? sizeof (Elf32_External_Chdr
)
13191 : sizeof (Elf64_External_Chdr
)))
13193 warn (_("compressed section %s is too small to contain a compression header"),
13198 compression_header_size
= get_compression_header (&chdr
, start
, size
);
13200 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13202 warn (_("section '%s' has unsupported compress type: %d\n"),
13203 section
->name
, chdr
.ch_type
);
13206 else if (chdr
.ch_addralign
!= sec
->sh_addralign
)
13208 warn (_("compressed section '%s' is corrupted\n"),
13212 uncompressed_size
= chdr
.ch_size
;
13213 start
+= compression_header_size
;
13214 size
-= compression_header_size
;
13216 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
13218 /* Read the zlib header. In this case, it should be "ZLIB"
13219 followed by the uncompressed section size, 8 bytes in
13220 big-endian order. */
13221 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13222 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13223 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13224 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13225 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13226 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13227 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13228 uncompressed_size
+= start
[11];
13233 if (uncompressed_size
)
13235 if (uncompress_section_contents (&start
, uncompressed_size
,
13238 /* Free the compressed buffer, update the section buffer
13239 and the section size if uncompress is successful. */
13240 free (section
->start
);
13241 section
->start
= start
;
13245 error (_("Unable to decompress section %s\n"),
13246 printable_section_name (sec
));
13251 section
->size
= size
;
13254 if (section
->start
== NULL
)
13257 if (debug_displays
[debug
].relocate
)
13259 if (! apply_relocations ((FILE *) file
, sec
, section
->start
, section
->size
,
13260 & section
->reloc_info
, & section
->num_relocs
))
13265 section
->reloc_info
= NULL
;
13266 section
->num_relocs
= 0;
13272 /* If this is not NULL, load_debug_section will only look for sections
13273 within the list of sections given here. */
13274 static unsigned int * section_subset
= NULL
;
13277 load_debug_section (enum dwarf_section_display_enum debug
, void * file
)
13279 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13280 Elf_Internal_Shdr
* sec
;
13282 /* Locate the debug section. */
13283 sec
= find_section_in_set (section
->uncompressed_name
, section_subset
);
13285 section
->name
= section
->uncompressed_name
;
13288 sec
= find_section_in_set (section
->compressed_name
, section_subset
);
13290 section
->name
= section
->compressed_name
;
13295 /* If we're loading from a subset of sections, and we've loaded
13296 a section matching this name before, it's likely that it's a
13298 if (section_subset
!= NULL
)
13299 free_debug_section (debug
);
13301 return load_specific_debug_section (debug
, sec
, (FILE *) file
);
13305 free_debug_section (enum dwarf_section_display_enum debug
)
13307 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13309 if (section
->start
== NULL
)
13312 free ((char *) section
->start
);
13313 section
->start
= NULL
;
13314 section
->address
= 0;
13319 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, FILE * file
)
13321 char * name
= SECTION_NAME (section
);
13322 const char * print_name
= printable_section_name (section
);
13323 bfd_size_type length
;
13324 bfd_boolean result
= TRUE
;
13327 length
= section
->sh_size
;
13330 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
13333 if (section
->sh_type
== SHT_NOBITS
)
13335 /* There is no point in dumping the contents of a debugging section
13336 which has the NOBITS type - the bits in the file will be random.
13337 This can happen when a file containing a .eh_frame section is
13338 stripped with the --only-keep-debug command line option. */
13339 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
13344 if (const_strneq (name
, ".gnu.linkonce.wi."))
13345 name
= ".debug_info";
13347 /* See if we know how to display the contents of this section. */
13348 for (i
= 0; i
< max
; i
++)
13349 if (streq (debug_displays
[i
].section
.uncompressed_name
, name
)
13350 || (i
== line
&& const_strneq (name
, ".debug_line."))
13351 || streq (debug_displays
[i
].section
.compressed_name
, name
))
13353 struct dwarf_section
* sec
= &debug_displays
[i
].section
;
13354 int secondary
= (section
!= find_section (name
));
13357 free_debug_section ((enum dwarf_section_display_enum
) i
);
13359 if (i
== line
&& const_strneq (name
, ".debug_line."))
13361 else if (streq (sec
->uncompressed_name
, name
))
13362 sec
->name
= sec
->uncompressed_name
;
13364 sec
->name
= sec
->compressed_name
;
13365 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
13368 /* If this debug section is part of a CU/TU set in a .dwp file,
13369 restrict load_debug_section to the sections in that set. */
13370 section_subset
= find_cu_tu_set (file
, shndx
);
13372 result
&= debug_displays
[i
].display (sec
, file
);
13374 section_subset
= NULL
;
13376 if (secondary
|| (i
!= info
&& i
!= abbrev
))
13377 free_debug_section ((enum dwarf_section_display_enum
) i
);
13385 printf (_("Unrecognized debug section: %s\n"), print_name
);
13392 /* Set DUMP_SECTS for all sections where dumps were requested
13393 based on section name. */
13396 initialise_dumps_byname (void)
13398 struct dump_list_entry
* cur
;
13400 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
13403 bfd_boolean any
= FALSE
;
13405 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
13406 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
13408 request_dump_bynumber (i
, cur
->type
);
13413 warn (_("Section '%s' was not dumped because it does not exist!\n"),
13419 process_section_contents (FILE * file
)
13421 Elf_Internal_Shdr
* section
;
13423 bfd_boolean res
= TRUE
;
13428 initialise_dumps_byname ();
13430 for (i
= 0, section
= section_headers
;
13431 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
13434 #ifdef SUPPORT_DISASSEMBLY
13435 if (dump_sects
[i
] & DISASS_DUMP
)
13436 disassemble_section (section
, file
);
13438 if (dump_sects
[i
] & HEX_DUMP
)
13440 if (! dump_section_as_bytes (section
, file
, FALSE
))
13444 if (dump_sects
[i
] & RELOC_DUMP
)
13446 if (! dump_section_as_bytes (section
, file
, TRUE
))
13450 if (dump_sects
[i
] & STRING_DUMP
)
13452 if (! dump_section_as_strings (section
, file
))
13456 if (dump_sects
[i
] & DEBUG_DUMP
)
13458 if (! display_debug_section (i
, section
, file
))
13463 /* Check to see if the user requested a
13464 dump of a section that does not exist. */
13465 while (i
< num_dump_sects
)
13469 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
13479 process_mips_fpe_exception (int mask
)
13483 bfd_boolean first
= TRUE
;
13485 if (mask
& OEX_FPU_INEX
)
13486 fputs ("INEX", stdout
), first
= FALSE
;
13487 if (mask
& OEX_FPU_UFLO
)
13488 printf ("%sUFLO", first
? "" : "|"), first
= FALSE
;
13489 if (mask
& OEX_FPU_OFLO
)
13490 printf ("%sOFLO", first
? "" : "|"), first
= FALSE
;
13491 if (mask
& OEX_FPU_DIV0
)
13492 printf ("%sDIV0", first
? "" : "|"), first
= FALSE
;
13493 if (mask
& OEX_FPU_INVAL
)
13494 printf ("%sINVAL", first
? "" : "|");
13497 fputs ("0", stdout
);
13500 /* Display's the value of TAG at location P. If TAG is
13501 greater than 0 it is assumed to be an unknown tag, and
13502 a message is printed to this effect. Otherwise it is
13503 assumed that a message has already been printed.
13505 If the bottom bit of TAG is set it assumed to have a
13506 string value, otherwise it is assumed to have an integer
13509 Returns an updated P pointing to the first unread byte
13510 beyond the end of TAG's value.
13512 Reads at or beyond END will not be made. */
13514 static unsigned char *
13515 display_tag_value (signed int tag
,
13517 const unsigned char * const end
)
13522 printf (" Tag_unknown_%d: ", tag
);
13526 warn (_("<corrupt tag>\n"));
13530 /* PR 17531 file: 027-19978-0.004. */
13531 size_t maxlen
= (end
- p
) - 1;
13536 print_symbol ((int) maxlen
, (const char *) p
);
13537 p
+= strnlen ((char *) p
, maxlen
) + 1;
13541 printf (_("<corrupt string tag>"));
13542 p
= (unsigned char *) end
;
13550 val
= read_uleb128 (p
, &len
, end
);
13552 printf ("%ld (0x%lx)\n", val
, val
);
13559 /* ARC ABI attributes section. */
13561 static unsigned char *
13562 display_arc_attribute (unsigned char * p
,
13563 const unsigned char * const end
)
13569 tag
= read_uleb128 (p
, &len
, end
);
13574 case Tag_ARC_PCS_config
:
13575 val
= read_uleb128 (p
, &len
, end
);
13577 printf (" Tag_ARC_PCS_config: ");
13581 printf (_("Absent/Non standard\n"));
13584 printf (_("Bare metal/mwdt\n"));
13587 printf (_("Bare metal/newlib\n"));
13590 printf (_("Linux/uclibc\n"));
13593 printf (_("Linux/glibc\n"));
13596 printf (_("Unknown\n"));
13601 case Tag_ARC_CPU_base
:
13602 val
= read_uleb128 (p
, &len
, end
);
13604 printf (" Tag_ARC_CPU_base: ");
13609 printf (_("Absent\n"));
13611 case TAG_CPU_ARC6xx
:
13612 printf ("ARC6xx\n");
13614 case TAG_CPU_ARC7xx
:
13615 printf ("ARC7xx\n");
13617 case TAG_CPU_ARCEM
:
13618 printf ("ARCEM\n");
13620 case TAG_CPU_ARCHS
:
13621 printf ("ARCHS\n");
13626 case Tag_ARC_CPU_variation
:
13627 val
= read_uleb128 (p
, &len
, end
);
13629 printf (" Tag_ARC_CPU_variation: ");
13633 if (val
> 0 && val
< 16)
13634 printf ("Core%d\n", val
);
13636 printf ("Unknown\n");
13640 printf (_("Absent\n"));
13645 case Tag_ARC_CPU_name
:
13646 printf (" Tag_ARC_CPU_name: ");
13647 p
= display_tag_value (-1, p
, end
);
13650 case Tag_ARC_ABI_rf16
:
13651 val
= read_uleb128 (p
, &len
, end
);
13653 printf (" Tag_ARC_ABI_rf16: %s\n", val
? _("yes") : _("no"));
13656 case Tag_ARC_ABI_osver
:
13657 val
= read_uleb128 (p
, &len
, end
);
13659 printf (" Tag_ARC_ABI_osver: v%d\n", val
);
13662 case Tag_ARC_ABI_pic
:
13663 case Tag_ARC_ABI_sda
:
13664 val
= read_uleb128 (p
, &len
, end
);
13666 printf (tag
== Tag_ARC_ABI_sda
? " Tag_ARC_ABI_sda: "
13667 : " Tag_ARC_ABI_pic: ");
13671 printf (_("Absent\n"));
13680 printf (_("Unknown\n"));
13685 case Tag_ARC_ABI_tls
:
13686 val
= read_uleb128 (p
, &len
, end
);
13688 printf (" Tag_ARC_ABI_tls: %s\n", val
? "r25": "none");
13691 case Tag_ARC_ABI_enumsize
:
13692 val
= read_uleb128 (p
, &len
, end
);
13694 printf (" Tag_ARC_ABI_enumsize: %s\n", val
? _("default") :
13698 case Tag_ARC_ABI_exceptions
:
13699 val
= read_uleb128 (p
, &len
, end
);
13701 printf (" Tag_ARC_ABI_exceptions: %s\n", val
? _("OPTFP")
13705 case Tag_ARC_ABI_double_size
:
13706 val
= read_uleb128 (p
, &len
, end
);
13708 printf (" Tag_ARC_ABI_double_size: %d\n", val
);
13711 case Tag_ARC_ISA_config
:
13712 printf (" Tag_ARC_ISA_config: ");
13713 p
= display_tag_value (-1, p
, end
);
13716 case Tag_ARC_ISA_apex
:
13717 printf (" Tag_ARC_ISA_apex: ");
13718 p
= display_tag_value (-1, p
, end
);
13721 case Tag_ARC_ISA_mpy_option
:
13722 val
= read_uleb128 (p
, &len
, end
);
13724 printf (" Tag_ARC_ISA_mpy_option: %d\n", val
);
13728 return display_tag_value (tag
& 1, p
, end
);
13734 /* ARM EABI attributes section. */
13739 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
13741 const char ** table
;
13742 } arm_attr_public_tag
;
13744 static const char * arm_attr_tag_CPU_arch
[] =
13745 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
13746 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
13748 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
13749 static const char * arm_attr_tag_THUMB_ISA_use
[] =
13750 {"No", "Thumb-1", "Thumb-2", "Yes"};
13751 static const char * arm_attr_tag_FP_arch
[] =
13752 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
13753 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
13754 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
13755 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
13756 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
13757 "NEON for ARMv8.1"};
13758 static const char * arm_attr_tag_PCS_config
[] =
13759 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
13760 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
13761 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
13762 {"V6", "SB", "TLS", "Unused"};
13763 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
13764 {"Absolute", "PC-relative", "SB-relative", "None"};
13765 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
13766 {"Absolute", "PC-relative", "None"};
13767 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
13768 {"None", "direct", "GOT-indirect"};
13769 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
13770 {"None", "??? 1", "2", "??? 3", "4"};
13771 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
13772 static const char * arm_attr_tag_ABI_FP_denormal
[] =
13773 {"Unused", "Needed", "Sign only"};
13774 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
13775 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
13776 static const char * arm_attr_tag_ABI_FP_number_model
[] =
13777 {"Unused", "Finite", "RTABI", "IEEE 754"};
13778 static const char * arm_attr_tag_ABI_enum_size
[] =
13779 {"Unused", "small", "int", "forced to int"};
13780 static const char * arm_attr_tag_ABI_HardFP_use
[] =
13781 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
13782 static const char * arm_attr_tag_ABI_VFP_args
[] =
13783 {"AAPCS", "VFP registers", "custom", "compatible"};
13784 static const char * arm_attr_tag_ABI_WMMX_args
[] =
13785 {"AAPCS", "WMMX registers", "custom"};
13786 static const char * arm_attr_tag_ABI_optimization_goals
[] =
13787 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
13788 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
13789 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
13790 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
13791 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
13792 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
13793 static const char * arm_attr_tag_FP_HP_extension
[] =
13794 {"Not Allowed", "Allowed"};
13795 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
13796 {"None", "IEEE 754", "Alternative Format"};
13797 static const char * arm_attr_tag_DSP_extension
[] =
13798 {"Follow architecture", "Allowed"};
13799 static const char * arm_attr_tag_MPextension_use
[] =
13800 {"Not Allowed", "Allowed"};
13801 static const char * arm_attr_tag_DIV_use
[] =
13802 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
13803 "Allowed in v7-A with integer division extension"};
13804 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
13805 static const char * arm_attr_tag_Virtualization_use
[] =
13806 {"Not Allowed", "TrustZone", "Virtualization Extensions",
13807 "TrustZone and Virtualization Extensions"};
13808 static const char * arm_attr_tag_MPextension_use_legacy
[] =
13809 {"Not Allowed", "Allowed"};
13811 #define LOOKUP(id, name) \
13812 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
13813 static arm_attr_public_tag arm_attr_public_tags
[] =
13815 {4, "CPU_raw_name", 1, NULL
},
13816 {5, "CPU_name", 1, NULL
},
13817 LOOKUP(6, CPU_arch
),
13818 {7, "CPU_arch_profile", 0, NULL
},
13819 LOOKUP(8, ARM_ISA_use
),
13820 LOOKUP(9, THUMB_ISA_use
),
13821 LOOKUP(10, FP_arch
),
13822 LOOKUP(11, WMMX_arch
),
13823 LOOKUP(12, Advanced_SIMD_arch
),
13824 LOOKUP(13, PCS_config
),
13825 LOOKUP(14, ABI_PCS_R9_use
),
13826 LOOKUP(15, ABI_PCS_RW_data
),
13827 LOOKUP(16, ABI_PCS_RO_data
),
13828 LOOKUP(17, ABI_PCS_GOT_use
),
13829 LOOKUP(18, ABI_PCS_wchar_t
),
13830 LOOKUP(19, ABI_FP_rounding
),
13831 LOOKUP(20, ABI_FP_denormal
),
13832 LOOKUP(21, ABI_FP_exceptions
),
13833 LOOKUP(22, ABI_FP_user_exceptions
),
13834 LOOKUP(23, ABI_FP_number_model
),
13835 {24, "ABI_align_needed", 0, NULL
},
13836 {25, "ABI_align_preserved", 0, NULL
},
13837 LOOKUP(26, ABI_enum_size
),
13838 LOOKUP(27, ABI_HardFP_use
),
13839 LOOKUP(28, ABI_VFP_args
),
13840 LOOKUP(29, ABI_WMMX_args
),
13841 LOOKUP(30, ABI_optimization_goals
),
13842 LOOKUP(31, ABI_FP_optimization_goals
),
13843 {32, "compatibility", 0, NULL
},
13844 LOOKUP(34, CPU_unaligned_access
),
13845 LOOKUP(36, FP_HP_extension
),
13846 LOOKUP(38, ABI_FP_16bit_format
),
13847 LOOKUP(42, MPextension_use
),
13848 LOOKUP(44, DIV_use
),
13849 LOOKUP(46, DSP_extension
),
13850 {64, "nodefaults", 0, NULL
},
13851 {65, "also_compatible_with", 0, NULL
},
13852 LOOKUP(66, T2EE_use
),
13853 {67, "conformance", 1, NULL
},
13854 LOOKUP(68, Virtualization_use
),
13855 LOOKUP(70, MPextension_use_legacy
)
13859 static unsigned char *
13860 display_arm_attribute (unsigned char * p
,
13861 const unsigned char * const end
)
13866 arm_attr_public_tag
* attr
;
13870 tag
= read_uleb128 (p
, &len
, end
);
13873 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
13875 if (arm_attr_public_tags
[i
].tag
== tag
)
13877 attr
= &arm_attr_public_tags
[i
];
13884 printf (" Tag_%s: ", attr
->name
);
13885 switch (attr
->type
)
13890 case 7: /* Tag_CPU_arch_profile. */
13891 val
= read_uleb128 (p
, &len
, end
);
13895 case 0: printf (_("None\n")); break;
13896 case 'A': printf (_("Application\n")); break;
13897 case 'R': printf (_("Realtime\n")); break;
13898 case 'M': printf (_("Microcontroller\n")); break;
13899 case 'S': printf (_("Application or Realtime\n")); break;
13900 default: printf ("??? (%d)\n", val
); break;
13904 case 24: /* Tag_align_needed. */
13905 val
= read_uleb128 (p
, &len
, end
);
13909 case 0: printf (_("None\n")); break;
13910 case 1: printf (_("8-byte\n")); break;
13911 case 2: printf (_("4-byte\n")); break;
13912 case 3: printf ("??? 3\n"); break;
13915 printf (_("8-byte and up to %d-byte extended\n"),
13918 printf ("??? (%d)\n", val
);
13923 case 25: /* Tag_align_preserved. */
13924 val
= read_uleb128 (p
, &len
, end
);
13928 case 0: printf (_("None\n")); break;
13929 case 1: printf (_("8-byte, except leaf SP\n")); break;
13930 case 2: printf (_("8-byte\n")); break;
13931 case 3: printf ("??? 3\n"); break;
13934 printf (_("8-byte and up to %d-byte extended\n"),
13937 printf ("??? (%d)\n", val
);
13942 case 32: /* Tag_compatibility. */
13944 val
= read_uleb128 (p
, &len
, end
);
13946 printf (_("flag = %d, vendor = "), val
);
13949 size_t maxlen
= (end
- p
) - 1;
13951 print_symbol ((int) maxlen
, (const char *) p
);
13952 p
+= strnlen ((char *) p
, maxlen
) + 1;
13956 printf (_("<corrupt>"));
13957 p
= (unsigned char *) end
;
13963 case 64: /* Tag_nodefaults. */
13964 /* PR 17531: file: 001-505008-0.01. */
13967 printf (_("True\n"));
13970 case 65: /* Tag_also_compatible_with. */
13971 val
= read_uleb128 (p
, &len
, end
);
13973 if (val
== 6 /* Tag_CPU_arch. */)
13975 val
= read_uleb128 (p
, &len
, end
);
13977 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
13978 printf ("??? (%d)\n", val
);
13980 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
13984 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
13989 printf (_("<unknown: %d>\n"), tag
);
13995 return display_tag_value (-1, p
, end
);
13997 return display_tag_value (0, p
, end
);
14000 assert (attr
->type
& 0x80);
14001 val
= read_uleb128 (p
, &len
, end
);
14003 type
= attr
->type
& 0x7f;
14005 printf ("??? (%d)\n", val
);
14007 printf ("%s\n", attr
->table
[val
]);
14012 return display_tag_value (tag
, p
, end
);
14015 static unsigned char *
14016 display_gnu_attribute (unsigned char * p
,
14017 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const),
14018 const unsigned char * const end
)
14024 tag
= read_uleb128 (p
, &len
, end
);
14027 /* Tag_compatibility is the only generic GNU attribute defined at
14031 val
= read_uleb128 (p
, &len
, end
);
14034 printf (_("flag = %d, vendor = "), val
);
14037 printf (_("<corrupt>\n"));
14038 warn (_("corrupt vendor attribute\n"));
14044 size_t maxlen
= (end
- p
) - 1;
14046 print_symbol ((int) maxlen
, (const char *) p
);
14047 p
+= strnlen ((char *) p
, maxlen
) + 1;
14051 printf (_("<corrupt>"));
14052 p
= (unsigned char *) end
;
14059 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
14060 return display_proc_gnu_attribute (p
, tag
, end
);
14062 return display_tag_value (tag
, p
, end
);
14065 static unsigned char *
14066 display_power_gnu_attribute (unsigned char * p
,
14068 const unsigned char * const end
)
14073 if (tag
== Tag_GNU_Power_ABI_FP
)
14075 val
= read_uleb128 (p
, &len
, end
);
14077 printf (" Tag_GNU_Power_ABI_FP: ");
14080 printf (_("<corrupt>\n"));
14085 printf ("(%#x), ", val
);
14090 printf (_("unspecified hard/soft float, "));
14093 printf (_("hard float, "));
14096 printf (_("soft float, "));
14099 printf (_("single-precision hard float, "));
14106 printf (_("unspecified long double\n"));
14109 printf (_("128-bit IBM long double\n"));
14112 printf (_("64-bit long double\n"));
14115 printf (_("128-bit IEEE long double\n"));
14121 if (tag
== Tag_GNU_Power_ABI_Vector
)
14123 val
= read_uleb128 (p
, &len
, end
);
14125 printf (" Tag_GNU_Power_ABI_Vector: ");
14128 printf (_("<corrupt>\n"));
14133 printf ("(%#x), ", val
);
14138 printf (_("unspecified\n"));
14141 printf (_("generic\n"));
14144 printf ("AltiVec\n");
14153 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
14155 val
= read_uleb128 (p
, &len
, end
);
14157 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
14160 printf (_("<corrupt>\n"));
14165 printf ("(%#x), ", val
);
14170 printf (_("unspecified\n"));
14173 printf ("r3/r4\n");
14176 printf (_("memory\n"));
14185 return display_tag_value (tag
& 1, p
, end
);
14188 static unsigned char *
14189 display_s390_gnu_attribute (unsigned char * p
,
14191 const unsigned char * const end
)
14196 if (tag
== Tag_GNU_S390_ABI_Vector
)
14198 val
= read_uleb128 (p
, &len
, end
);
14200 printf (" Tag_GNU_S390_ABI_Vector: ");
14205 printf (_("any\n"));
14208 printf (_("software\n"));
14211 printf (_("hardware\n"));
14214 printf ("??? (%d)\n", val
);
14220 return display_tag_value (tag
& 1, p
, end
);
14224 display_sparc_hwcaps (unsigned int mask
)
14228 bfd_boolean first
= TRUE
;
14230 if (mask
& ELF_SPARC_HWCAP_MUL32
)
14231 fputs ("mul32", stdout
), first
= FALSE
;
14232 if (mask
& ELF_SPARC_HWCAP_DIV32
)
14233 printf ("%sdiv32", first
? "" : "|"), first
= FALSE
;
14234 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
14235 printf ("%sfsmuld", first
? "" : "|"), first
= FALSE
;
14236 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
14237 printf ("%sv8plus", first
? "" : "|"), first
= FALSE
;
14238 if (mask
& ELF_SPARC_HWCAP_POPC
)
14239 printf ("%spopc", first
? "" : "|"), first
= FALSE
;
14240 if (mask
& ELF_SPARC_HWCAP_VIS
)
14241 printf ("%svis", first
? "" : "|"), first
= FALSE
;
14242 if (mask
& ELF_SPARC_HWCAP_VIS2
)
14243 printf ("%svis2", first
? "" : "|"), first
= FALSE
;
14244 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
14245 printf ("%sASIBlkInit", first
? "" : "|"), first
= FALSE
;
14246 if (mask
& ELF_SPARC_HWCAP_FMAF
)
14247 printf ("%sfmaf", first
? "" : "|"), first
= FALSE
;
14248 if (mask
& ELF_SPARC_HWCAP_VIS3
)
14249 printf ("%svis3", first
? "" : "|"), first
= FALSE
;
14250 if (mask
& ELF_SPARC_HWCAP_HPC
)
14251 printf ("%shpc", first
? "" : "|"), first
= FALSE
;
14252 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
14253 printf ("%srandom", first
? "" : "|"), first
= FALSE
;
14254 if (mask
& ELF_SPARC_HWCAP_TRANS
)
14255 printf ("%strans", first
? "" : "|"), first
= FALSE
;
14256 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
14257 printf ("%sfjfmau", first
? "" : "|"), first
= FALSE
;
14258 if (mask
& ELF_SPARC_HWCAP_IMA
)
14259 printf ("%sima", first
? "" : "|"), first
= FALSE
;
14260 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
14261 printf ("%scspare", first
? "" : "|"), first
= FALSE
;
14264 fputc ('0', stdout
);
14265 fputc ('\n', stdout
);
14269 display_sparc_hwcaps2 (unsigned int mask
)
14273 bfd_boolean first
= TRUE
;
14275 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
14276 fputs ("fjathplus", stdout
), first
= FALSE
;
14277 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
14278 printf ("%svis3b", first
? "" : "|"), first
= FALSE
;
14279 if (mask
& ELF_SPARC_HWCAP2_ADP
)
14280 printf ("%sadp", first
? "" : "|"), first
= FALSE
;
14281 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
14282 printf ("%ssparc5", first
? "" : "|"), first
= FALSE
;
14283 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
14284 printf ("%smwait", first
? "" : "|"), first
= FALSE
;
14285 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
14286 printf ("%sxmpmul", first
? "" : "|"), first
= FALSE
;
14287 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
14288 printf ("%sxmont2", first
? "" : "|"), first
= FALSE
;
14289 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
14290 printf ("%snsec", first
? "" : "|"), first
= FALSE
;
14291 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
14292 printf ("%sfjathhpc", first
? "" : "|"), first
= FALSE
;
14293 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
14294 printf ("%sfjdes", first
? "" : "|"), first
= FALSE
;
14295 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
14296 printf ("%sfjaes", first
? "" : "|"), first
= FALSE
;
14299 fputc ('0', stdout
);
14300 fputc ('\n', stdout
);
14303 static unsigned char *
14304 display_sparc_gnu_attribute (unsigned char * p
,
14306 const unsigned char * const end
)
14311 if (tag
== Tag_GNU_Sparc_HWCAPS
)
14313 val
= read_uleb128 (p
, &len
, end
);
14315 printf (" Tag_GNU_Sparc_HWCAPS: ");
14316 display_sparc_hwcaps (val
);
14319 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
14321 val
= read_uleb128 (p
, &len
, end
);
14323 printf (" Tag_GNU_Sparc_HWCAPS2: ");
14324 display_sparc_hwcaps2 (val
);
14328 return display_tag_value (tag
, p
, end
);
14332 print_mips_fp_abi_value (unsigned int val
)
14336 case Val_GNU_MIPS_ABI_FP_ANY
:
14337 printf (_("Hard or soft float\n"));
14339 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
14340 printf (_("Hard float (double precision)\n"));
14342 case Val_GNU_MIPS_ABI_FP_SINGLE
:
14343 printf (_("Hard float (single precision)\n"));
14345 case Val_GNU_MIPS_ABI_FP_SOFT
:
14346 printf (_("Soft float\n"));
14348 case Val_GNU_MIPS_ABI_FP_OLD_64
:
14349 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
14351 case Val_GNU_MIPS_ABI_FP_XX
:
14352 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
14354 case Val_GNU_MIPS_ABI_FP_64
:
14355 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
14357 case Val_GNU_MIPS_ABI_FP_64A
:
14358 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
14360 case Val_GNU_MIPS_ABI_FP_NAN2008
:
14361 printf (_("NaN 2008 compatibility\n"));
14364 printf ("??? (%d)\n", val
);
14369 static unsigned char *
14370 display_mips_gnu_attribute (unsigned char * p
,
14372 const unsigned char * const end
)
14374 if (tag
== Tag_GNU_MIPS_ABI_FP
)
14379 val
= read_uleb128 (p
, &len
, end
);
14381 printf (" Tag_GNU_MIPS_ABI_FP: ");
14383 print_mips_fp_abi_value (val
);
14388 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
14393 val
= read_uleb128 (p
, &len
, end
);
14395 printf (" Tag_GNU_MIPS_ABI_MSA: ");
14399 case Val_GNU_MIPS_ABI_MSA_ANY
:
14400 printf (_("Any MSA or not\n"));
14402 case Val_GNU_MIPS_ABI_MSA_128
:
14403 printf (_("128-bit MSA\n"));
14406 printf ("??? (%d)\n", val
);
14412 return display_tag_value (tag
& 1, p
, end
);
14415 static unsigned char *
14416 display_tic6x_attribute (unsigned char * p
,
14417 const unsigned char * const end
)
14423 tag
= read_uleb128 (p
, &len
, end
);
14429 val
= read_uleb128 (p
, &len
, end
);
14431 printf (" Tag_ISA: ");
14435 case C6XABI_Tag_ISA_none
:
14436 printf (_("None\n"));
14438 case C6XABI_Tag_ISA_C62X
:
14441 case C6XABI_Tag_ISA_C67X
:
14444 case C6XABI_Tag_ISA_C67XP
:
14445 printf ("C67x+\n");
14447 case C6XABI_Tag_ISA_C64X
:
14450 case C6XABI_Tag_ISA_C64XP
:
14451 printf ("C64x+\n");
14453 case C6XABI_Tag_ISA_C674X
:
14454 printf ("C674x\n");
14457 printf ("??? (%d)\n", val
);
14462 case Tag_ABI_wchar_t
:
14463 val
= read_uleb128 (p
, &len
, end
);
14465 printf (" Tag_ABI_wchar_t: ");
14469 printf (_("Not used\n"));
14472 printf (_("2 bytes\n"));
14475 printf (_("4 bytes\n"));
14478 printf ("??? (%d)\n", val
);
14483 case Tag_ABI_stack_align_needed
:
14484 val
= read_uleb128 (p
, &len
, end
);
14486 printf (" Tag_ABI_stack_align_needed: ");
14490 printf (_("8-byte\n"));
14493 printf (_("16-byte\n"));
14496 printf ("??? (%d)\n", val
);
14501 case Tag_ABI_stack_align_preserved
:
14502 val
= read_uleb128 (p
, &len
, end
);
14504 printf (" Tag_ABI_stack_align_preserved: ");
14508 printf (_("8-byte\n"));
14511 printf (_("16-byte\n"));
14514 printf ("??? (%d)\n", val
);
14520 val
= read_uleb128 (p
, &len
, end
);
14522 printf (" Tag_ABI_DSBT: ");
14526 printf (_("DSBT addressing not used\n"));
14529 printf (_("DSBT addressing used\n"));
14532 printf ("??? (%d)\n", val
);
14538 val
= read_uleb128 (p
, &len
, end
);
14540 printf (" Tag_ABI_PID: ");
14544 printf (_("Data addressing position-dependent\n"));
14547 printf (_("Data addressing position-independent, GOT near DP\n"));
14550 printf (_("Data addressing position-independent, GOT far from DP\n"));
14553 printf ("??? (%d)\n", val
);
14559 val
= read_uleb128 (p
, &len
, end
);
14561 printf (" Tag_ABI_PIC: ");
14565 printf (_("Code addressing position-dependent\n"));
14568 printf (_("Code addressing position-independent\n"));
14571 printf ("??? (%d)\n", val
);
14576 case Tag_ABI_array_object_alignment
:
14577 val
= read_uleb128 (p
, &len
, end
);
14579 printf (" Tag_ABI_array_object_alignment: ");
14583 printf (_("8-byte\n"));
14586 printf (_("4-byte\n"));
14589 printf (_("16-byte\n"));
14592 printf ("??? (%d)\n", val
);
14597 case Tag_ABI_array_object_align_expected
:
14598 val
= read_uleb128 (p
, &len
, end
);
14600 printf (" Tag_ABI_array_object_align_expected: ");
14604 printf (_("8-byte\n"));
14607 printf (_("4-byte\n"));
14610 printf (_("16-byte\n"));
14613 printf ("??? (%d)\n", val
);
14618 case Tag_ABI_compatibility
:
14620 val
= read_uleb128 (p
, &len
, end
);
14622 printf (" Tag_ABI_compatibility: ");
14623 printf (_("flag = %d, vendor = "), val
);
14626 size_t maxlen
= (end
- p
) - 1;
14628 print_symbol ((int) maxlen
, (const char *) p
);
14629 p
+= strnlen ((char *) p
, maxlen
) + 1;
14633 printf (_("<corrupt>"));
14634 p
= (unsigned char *) end
;
14640 case Tag_ABI_conformance
:
14642 printf (" Tag_ABI_conformance: \"");
14645 size_t maxlen
= (end
- p
) - 1;
14647 print_symbol ((int) maxlen
, (const char *) p
);
14648 p
+= strnlen ((char *) p
, maxlen
) + 1;
14652 printf (_("<corrupt>"));
14653 p
= (unsigned char *) end
;
14660 return display_tag_value (tag
, p
, end
);
14664 display_raw_attribute (unsigned char * p
, unsigned char const * const end
)
14666 unsigned long addr
= 0;
14667 size_t bytes
= end
- p
;
14674 int lbytes
= (bytes
> 16 ? 16 : bytes
);
14676 printf (" 0x%8.8lx ", addr
);
14678 for (j
= 0; j
< 16; j
++)
14681 printf ("%2.2x", p
[j
]);
14689 for (j
= 0; j
< lbytes
; j
++)
14692 if (k
>= ' ' && k
< 0x7f)
14708 static unsigned char *
14709 display_msp430x_attribute (unsigned char * p
,
14710 const unsigned char * const end
)
14716 tag
= read_uleb128 (p
, & len
, end
);
14721 case OFBA_MSPABI_Tag_ISA
:
14722 val
= read_uleb128 (p
, &len
, end
);
14724 printf (" Tag_ISA: ");
14727 case 0: printf (_("None\n")); break;
14728 case 1: printf (_("MSP430\n")); break;
14729 case 2: printf (_("MSP430X\n")); break;
14730 default: printf ("??? (%d)\n", val
); break;
14734 case OFBA_MSPABI_Tag_Code_Model
:
14735 val
= read_uleb128 (p
, &len
, end
);
14737 printf (" Tag_Code_Model: ");
14740 case 0: printf (_("None\n")); break;
14741 case 1: printf (_("Small\n")); break;
14742 case 2: printf (_("Large\n")); break;
14743 default: printf ("??? (%d)\n", val
); break;
14747 case OFBA_MSPABI_Tag_Data_Model
:
14748 val
= read_uleb128 (p
, &len
, end
);
14750 printf (" Tag_Data_Model: ");
14753 case 0: printf (_("None\n")); break;
14754 case 1: printf (_("Small\n")); break;
14755 case 2: printf (_("Large\n")); break;
14756 case 3: printf (_("Restricted Large\n")); break;
14757 default: printf ("??? (%d)\n", val
); break;
14762 printf (_(" <unknown tag %d>: "), tag
);
14769 size_t maxlen
= (end
- p
) - 1;
14771 print_symbol ((int) maxlen
, (const char *) p
);
14772 p
+= strnlen ((char *) p
, maxlen
) + 1;
14776 printf (_("<corrupt>"));
14777 p
= (unsigned char *) end
;
14783 val
= read_uleb128 (p
, &len
, end
);
14785 printf ("%d (0x%x)\n", val
, val
);
14795 process_attributes (FILE * file
,
14796 const char * public_name
,
14797 unsigned int proc_type
,
14798 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
14799 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const))
14801 Elf_Internal_Shdr
* sect
;
14803 bfd_boolean res
= TRUE
;
14805 /* Find the section header so that we get the size. */
14806 for (i
= 0, sect
= section_headers
;
14807 i
< elf_header
.e_shnum
;
14810 unsigned char * contents
;
14813 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
14816 contents
= (unsigned char *) get_data (NULL
, file
, sect
->sh_offset
, 1,
14817 sect
->sh_size
, _("attributes"));
14818 if (contents
== NULL
)
14825 /* The first character is the version of the attributes.
14826 Currently only version 1, (aka 'A') is recognised here. */
14829 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p
, *p
);
14834 bfd_vma section_len
;
14836 section_len
= sect
->sh_size
- 1;
14839 while (section_len
> 0)
14842 unsigned int namelen
;
14843 bfd_boolean public_section
;
14844 bfd_boolean gnu_section
;
14846 if (section_len
<= 4)
14848 error (_("Tag section ends prematurely\n"));
14852 attr_len
= byte_get (p
, 4);
14855 if (attr_len
> section_len
)
14857 error (_("Bad attribute length (%u > %u)\n"),
14858 (unsigned) attr_len
, (unsigned) section_len
);
14859 attr_len
= section_len
;
14862 /* PR 17531: file: 001-101425-0.004 */
14863 else if (attr_len
< 5)
14865 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
14870 section_len
-= attr_len
;
14873 namelen
= strnlen ((char *) p
, attr_len
) + 1;
14874 if (namelen
== 0 || namelen
>= attr_len
)
14876 error (_("Corrupt attribute section name\n"));
14881 printf (_("Attribute Section: "));
14882 print_symbol (INT_MAX
, (const char *) p
);
14885 if (public_name
&& streq ((char *) p
, public_name
))
14886 public_section
= TRUE
;
14888 public_section
= FALSE
;
14890 if (streq ((char *) p
, "gnu"))
14891 gnu_section
= TRUE
;
14893 gnu_section
= FALSE
;
14896 attr_len
-= namelen
;
14898 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
14903 unsigned char * end
;
14905 /* PR binutils/17531: Safe handling of corrupt files. */
14908 error (_("Unused bytes at end of section\n"));
14915 size
= byte_get (p
, 4);
14916 if (size
> attr_len
)
14918 error (_("Bad subsection length (%u > %u)\n"),
14919 (unsigned) size
, (unsigned) attr_len
);
14923 /* PR binutils/17531: Safe handling of corrupt files. */
14926 error (_("Bad subsection length (%u < 6)\n"),
14934 end
= p
+ size
- 1;
14935 assert (end
<= contents
+ sect
->sh_size
);
14941 printf (_("File Attributes\n"));
14944 printf (_("Section Attributes:"));
14947 printf (_("Symbol Attributes:"));
14948 /* Fall through. */
14954 val
= read_uleb128 (p
, &j
, end
);
14958 printf (" %d", val
);
14963 printf (_("Unknown tag: %d\n"), tag
);
14964 public_section
= FALSE
;
14968 if (public_section
&& display_pub_attribute
!= NULL
)
14971 p
= display_pub_attribute (p
, end
);
14974 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
14977 p
= display_gnu_attribute (p
,
14978 display_proc_gnu_attribute
,
14984 printf (_(" Unknown attribute:\n"));
14985 display_raw_attribute (p
, end
);
15000 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
15001 Print the Address, Access and Initial fields of an entry at VMA ADDR
15002 and return the VMA of the next entry, or -1 if there was a problem.
15003 Does not read from DATA_END or beyond. */
15006 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
15007 unsigned char * data_end
)
15010 print_vma (addr
, LONG_HEX
);
15012 if (addr
< pltgot
+ 0xfff0)
15013 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
15015 printf ("%10s", "");
15018 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
15022 unsigned char * from
= data
+ addr
- pltgot
;
15024 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
15026 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
15027 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
15028 return (bfd_vma
) -1;
15032 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
15033 print_vma (entry
, LONG_HEX
);
15036 return addr
+ (is_32bit_elf
? 4 : 8);
15039 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
15040 PLTGOT. Print the Address and Initial fields of an entry at VMA
15041 ADDR and return the VMA of the next entry. */
15044 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
15047 print_vma (addr
, LONG_HEX
);
15050 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
15055 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
15056 print_vma (entry
, LONG_HEX
);
15058 return addr
+ (is_32bit_elf
? 4 : 8);
15062 print_mips_ases (unsigned int mask
)
15064 if (mask
& AFL_ASE_DSP
)
15065 fputs ("\n\tDSP ASE", stdout
);
15066 if (mask
& AFL_ASE_DSPR2
)
15067 fputs ("\n\tDSP R2 ASE", stdout
);
15068 if (mask
& AFL_ASE_DSPR3
)
15069 fputs ("\n\tDSP R3 ASE", stdout
);
15070 if (mask
& AFL_ASE_EVA
)
15071 fputs ("\n\tEnhanced VA Scheme", stdout
);
15072 if (mask
& AFL_ASE_MCU
)
15073 fputs ("\n\tMCU (MicroController) ASE", stdout
);
15074 if (mask
& AFL_ASE_MDMX
)
15075 fputs ("\n\tMDMX ASE", stdout
);
15076 if (mask
& AFL_ASE_MIPS3D
)
15077 fputs ("\n\tMIPS-3D ASE", stdout
);
15078 if (mask
& AFL_ASE_MT
)
15079 fputs ("\n\tMT ASE", stdout
);
15080 if (mask
& AFL_ASE_SMARTMIPS
)
15081 fputs ("\n\tSmartMIPS ASE", stdout
);
15082 if (mask
& AFL_ASE_VIRT
)
15083 fputs ("\n\tVZ ASE", stdout
);
15084 if (mask
& AFL_ASE_MSA
)
15085 fputs ("\n\tMSA ASE", stdout
);
15086 if (mask
& AFL_ASE_MIPS16
)
15087 fputs ("\n\tMIPS16 ASE", stdout
);
15088 if (mask
& AFL_ASE_MICROMIPS
)
15089 fputs ("\n\tMICROMIPS ASE", stdout
);
15090 if (mask
& AFL_ASE_XPA
)
15091 fputs ("\n\tXPA ASE", stdout
);
15092 if (mask
& AFL_ASE_MIPS16E2
)
15093 fputs ("\n\tMIPS16e2 ASE", stdout
);
15095 fprintf (stdout
, "\n\t%s", _("None"));
15096 else if ((mask
& ~AFL_ASE_MASK
) != 0)
15097 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
15101 print_mips_isa_ext (unsigned int isa_ext
)
15106 fputs (_("None"), stdout
);
15109 fputs ("RMI XLR", stdout
);
15111 case AFL_EXT_OCTEON3
:
15112 fputs ("Cavium Networks Octeon3", stdout
);
15114 case AFL_EXT_OCTEON2
:
15115 fputs ("Cavium Networks Octeon2", stdout
);
15117 case AFL_EXT_OCTEONP
:
15118 fputs ("Cavium Networks OcteonP", stdout
);
15120 case AFL_EXT_LOONGSON_3A
:
15121 fputs ("Loongson 3A", stdout
);
15123 case AFL_EXT_OCTEON
:
15124 fputs ("Cavium Networks Octeon", stdout
);
15127 fputs ("Toshiba R5900", stdout
);
15130 fputs ("MIPS R4650", stdout
);
15133 fputs ("LSI R4010", stdout
);
15136 fputs ("NEC VR4100", stdout
);
15139 fputs ("Toshiba R3900", stdout
);
15141 case AFL_EXT_10000
:
15142 fputs ("MIPS R10000", stdout
);
15145 fputs ("Broadcom SB-1", stdout
);
15148 fputs ("NEC VR4111/VR4181", stdout
);
15151 fputs ("NEC VR4120", stdout
);
15154 fputs ("NEC VR5400", stdout
);
15157 fputs ("NEC VR5500", stdout
);
15159 case AFL_EXT_LOONGSON_2E
:
15160 fputs ("ST Microelectronics Loongson 2E", stdout
);
15162 case AFL_EXT_LOONGSON_2F
:
15163 fputs ("ST Microelectronics Loongson 2F", stdout
);
15165 case AFL_EXT_INTERAPTIV_MR2
:
15166 fputs ("Imagination interAptiv MR2", stdout
);
15169 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
15174 get_mips_reg_size (int reg_size
)
15176 return (reg_size
== AFL_REG_NONE
) ? 0
15177 : (reg_size
== AFL_REG_32
) ? 32
15178 : (reg_size
== AFL_REG_64
) ? 64
15179 : (reg_size
== AFL_REG_128
) ? 128
15184 process_mips_specific (FILE * file
)
15186 Elf_Internal_Dyn
* entry
;
15187 Elf_Internal_Shdr
*sect
= NULL
;
15188 size_t liblist_offset
= 0;
15189 size_t liblistno
= 0;
15190 size_t conflictsno
= 0;
15191 size_t options_offset
= 0;
15192 size_t conflicts_offset
= 0;
15193 size_t pltrelsz
= 0;
15195 bfd_vma pltgot
= 0;
15196 bfd_vma mips_pltgot
= 0;
15197 bfd_vma jmprel
= 0;
15198 bfd_vma local_gotno
= 0;
15199 bfd_vma gotsym
= 0;
15200 bfd_vma symtabno
= 0;
15201 bfd_boolean res
= TRUE
;
15203 if (! process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
15204 display_mips_gnu_attribute
))
15207 sect
= find_section (".MIPS.abiflags");
15211 Elf_External_ABIFlags_v0
*abiflags_ext
;
15212 Elf_Internal_ABIFlags_v0 abiflags_in
;
15214 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
15216 error (_("Corrupt MIPS ABI Flags section.\n"));
15221 abiflags_ext
= get_data (NULL
, file
, sect
->sh_offset
, 1,
15222 sect
->sh_size
, _("MIPS ABI Flags section"));
15225 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
15226 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
15227 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
15228 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
15229 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
15230 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
15231 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
15232 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
15233 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
15234 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
15235 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
15237 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
15238 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
15239 if (abiflags_in
.isa_rev
> 1)
15240 printf ("r%d", abiflags_in
.isa_rev
);
15241 printf ("\nGPR size: %d",
15242 get_mips_reg_size (abiflags_in
.gpr_size
));
15243 printf ("\nCPR1 size: %d",
15244 get_mips_reg_size (abiflags_in
.cpr1_size
));
15245 printf ("\nCPR2 size: %d",
15246 get_mips_reg_size (abiflags_in
.cpr2_size
));
15247 fputs ("\nFP ABI: ", stdout
);
15248 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
15249 fputs ("ISA Extension: ", stdout
);
15250 print_mips_isa_ext (abiflags_in
.isa_ext
);
15251 fputs ("\nASEs:", stdout
);
15252 print_mips_ases (abiflags_in
.ases
);
15253 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
15254 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
15255 fputc ('\n', stdout
);
15256 free (abiflags_ext
);
15261 /* We have a lot of special sections. Thanks SGI! */
15262 if (dynamic_section
== NULL
)
15264 /* No dynamic information available. See if there is static GOT. */
15265 sect
= find_section (".got");
15268 unsigned char *data_end
;
15269 unsigned char *data
;
15273 pltgot
= sect
->sh_addr
;
15276 addr_size
= (is_32bit_elf
? 4 : 8);
15277 end
= pltgot
+ sect
->sh_size
;
15279 data
= (unsigned char *) get_data (NULL
, file
, sect
->sh_offset
,
15281 _("Global Offset Table data"));
15282 /* PR 12855: Null data is handled gracefully throughout. */
15283 data_end
= data
+ (end
- pltgot
);
15285 printf (_("\nStatic GOT:\n"));
15286 printf (_(" Canonical gp value: "));
15287 print_vma (ent
+ 0x7ff0, LONG_HEX
);
15290 /* In a dynamic binary GOT[0] is reserved for the dynamic
15291 loader to store the lazy resolver pointer, however in
15292 a static binary it may well have been omitted and GOT
15293 reduced to a table of addresses.
15294 PR 21344: Check for the entry being fully available
15295 before fetching it. */
15297 && data
+ ent
- pltgot
+ addr_size
<= data_end
15298 && byte_get (data
+ ent
- pltgot
, addr_size
) == 0)
15300 printf (_(" Reserved entries:\n"));
15301 printf (_(" %*s %10s %*s\n"),
15302 addr_size
* 2, _("Address"), _("Access"),
15303 addr_size
* 2, _("Value"));
15304 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15306 if (ent
== (bfd_vma
) -1)
15307 goto sgot_print_fail
;
15309 /* Check for the MSB of GOT[1] being set, identifying a
15310 GNU object. This entry will be used by some runtime
15311 loaders, to store the module pointer. Otherwise this
15312 is an ordinary local entry.
15313 PR 21344: Check for the entry being fully available
15314 before fetching it. */
15316 && data
+ ent
- pltgot
+ addr_size
<= data_end
15317 && (byte_get (data
+ ent
- pltgot
, addr_size
)
15318 >> (addr_size
* 8 - 1)) != 0)
15320 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15322 if (ent
== (bfd_vma
) -1)
15323 goto sgot_print_fail
;
15328 if (data
!= NULL
&& ent
< end
)
15330 printf (_(" Local entries:\n"));
15331 printf (" %*s %10s %*s\n",
15332 addr_size
* 2, _("Address"), _("Access"),
15333 addr_size
* 2, _("Value"));
15336 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15338 if (ent
== (bfd_vma
) -1)
15339 goto sgot_print_fail
;
15351 for (entry
= dynamic_section
;
15352 /* PR 17531 file: 012-50589-0.004. */
15353 entry
< dynamic_section
+ dynamic_nent
&& entry
->d_tag
!= DT_NULL
;
15355 switch (entry
->d_tag
)
15357 case DT_MIPS_LIBLIST
:
15359 = offset_from_vma (file
, entry
->d_un
.d_val
,
15360 liblistno
* sizeof (Elf32_External_Lib
));
15362 case DT_MIPS_LIBLISTNO
:
15363 liblistno
= entry
->d_un
.d_val
;
15365 case DT_MIPS_OPTIONS
:
15366 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
15368 case DT_MIPS_CONFLICT
:
15370 = offset_from_vma (file
, entry
->d_un
.d_val
,
15371 conflictsno
* sizeof (Elf32_External_Conflict
));
15373 case DT_MIPS_CONFLICTNO
:
15374 conflictsno
= entry
->d_un
.d_val
;
15377 pltgot
= entry
->d_un
.d_ptr
;
15379 case DT_MIPS_LOCAL_GOTNO
:
15380 local_gotno
= entry
->d_un
.d_val
;
15382 case DT_MIPS_GOTSYM
:
15383 gotsym
= entry
->d_un
.d_val
;
15385 case DT_MIPS_SYMTABNO
:
15386 symtabno
= entry
->d_un
.d_val
;
15388 case DT_MIPS_PLTGOT
:
15389 mips_pltgot
= entry
->d_un
.d_ptr
;
15392 pltrel
= entry
->d_un
.d_val
;
15395 pltrelsz
= entry
->d_un
.d_val
;
15398 jmprel
= entry
->d_un
.d_ptr
;
15404 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
15406 Elf32_External_Lib
* elib
;
15409 elib
= (Elf32_External_Lib
*) get_data (NULL
, file
, liblist_offset
,
15411 sizeof (Elf32_External_Lib
),
15412 _("liblist section data"));
15415 printf (_("\nSection '.liblist' contains %lu entries:\n"),
15416 (unsigned long) liblistno
);
15417 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
15420 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
15427 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
15428 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
15429 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
15430 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
15431 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
15433 tmp
= gmtime (&atime
);
15434 snprintf (timebuf
, sizeof (timebuf
),
15435 "%04u-%02u-%02uT%02u:%02u:%02u",
15436 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
15437 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
15439 printf ("%3lu: ", (unsigned long) cnt
);
15440 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
15441 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
15443 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
15444 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
15445 liblist
.l_version
);
15447 if (liblist
.l_flags
== 0)
15451 static const struct
15458 { " EXACT_MATCH", LL_EXACT_MATCH
},
15459 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
15460 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
15461 { " EXPORTS", LL_EXPORTS
},
15462 { " DELAY_LOAD", LL_DELAY_LOAD
},
15463 { " DELTA", LL_DELTA
}
15465 int flags
= liblist
.l_flags
;
15468 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
15469 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
15471 fputs (l_flags_vals
[fcnt
].name
, stdout
);
15472 flags
^= l_flags_vals
[fcnt
].bit
;
15475 printf (" %#x", (unsigned int) flags
);
15487 if (options_offset
!= 0)
15489 Elf_External_Options
* eopt
;
15490 Elf_Internal_Options
* iopt
;
15491 Elf_Internal_Options
* option
;
15494 sect
= section_headers
;
15496 /* Find the section header so that we get the size. */
15497 sect
= find_section_by_type (SHT_MIPS_OPTIONS
);
15498 /* PR 17533 file: 012-277276-0.004. */
15501 error (_("No MIPS_OPTIONS header found\n"));
15505 eopt
= (Elf_External_Options
*) get_data (NULL
, file
, options_offset
, 1,
15506 sect
->sh_size
, _("options"));
15509 iopt
= (Elf_Internal_Options
*)
15510 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
15513 error (_("Out of memory allocating space for MIPS options\n"));
15520 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
15522 Elf_External_Options
* eoption
;
15524 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
15526 option
->kind
= BYTE_GET (eoption
->kind
);
15527 option
->size
= BYTE_GET (eoption
->size
);
15528 option
->section
= BYTE_GET (eoption
->section
);
15529 option
->info
= BYTE_GET (eoption
->info
);
15531 /* PR 17531: file: ffa0fa3b. */
15532 if (option
->size
< sizeof (* eopt
)
15533 || offset
+ option
->size
> sect
->sh_size
)
15535 error (_("Invalid size (%u) for MIPS option\n"), option
->size
);
15538 offset
+= option
->size
;
15544 printf (_("\nSection '%s' contains %d entries:\n"),
15545 printable_section_name (sect
), cnt
);
15554 switch (option
->kind
)
15557 /* This shouldn't happen. */
15558 printf (" NULL %d %lx", option
->section
, option
->info
);
15561 printf (" REGINFO ");
15562 if (elf_header
.e_machine
== EM_MIPS
)
15565 Elf32_External_RegInfo
* ereg
;
15566 Elf32_RegInfo reginfo
;
15568 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
15569 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
15570 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
15571 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
15572 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
15573 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
15574 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
15576 printf ("GPR %08lx GP 0x%lx\n",
15577 reginfo
.ri_gprmask
,
15578 (unsigned long) reginfo
.ri_gp_value
);
15579 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
15580 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
15581 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
15586 Elf64_External_RegInfo
* ereg
;
15587 Elf64_Internal_RegInfo reginfo
;
15589 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
15590 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
15591 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
15592 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
15593 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
15594 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
15595 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
15597 printf ("GPR %08lx GP 0x",
15598 reginfo
.ri_gprmask
);
15599 printf_vma (reginfo
.ri_gp_value
);
15602 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
15603 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
15604 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
15608 case ODK_EXCEPTIONS
:
15609 fputs (" EXCEPTIONS fpe_min(", stdout
);
15610 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
15611 fputs (") fpe_max(", stdout
);
15612 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
15613 fputs (")", stdout
);
15615 if (option
->info
& OEX_PAGE0
)
15616 fputs (" PAGE0", stdout
);
15617 if (option
->info
& OEX_SMM
)
15618 fputs (" SMM", stdout
);
15619 if (option
->info
& OEX_FPDBUG
)
15620 fputs (" FPDBUG", stdout
);
15621 if (option
->info
& OEX_DISMISS
)
15622 fputs (" DISMISS", stdout
);
15625 fputs (" PAD ", stdout
);
15626 if (option
->info
& OPAD_PREFIX
)
15627 fputs (" PREFIX", stdout
);
15628 if (option
->info
& OPAD_POSTFIX
)
15629 fputs (" POSTFIX", stdout
);
15630 if (option
->info
& OPAD_SYMBOL
)
15631 fputs (" SYMBOL", stdout
);
15634 fputs (" HWPATCH ", stdout
);
15635 if (option
->info
& OHW_R4KEOP
)
15636 fputs (" R4KEOP", stdout
);
15637 if (option
->info
& OHW_R8KPFETCH
)
15638 fputs (" R8KPFETCH", stdout
);
15639 if (option
->info
& OHW_R5KEOP
)
15640 fputs (" R5KEOP", stdout
);
15641 if (option
->info
& OHW_R5KCVTL
)
15642 fputs (" R5KCVTL", stdout
);
15645 fputs (" FILL ", stdout
);
15646 /* XXX Print content of info word? */
15649 fputs (" TAGS ", stdout
);
15650 /* XXX Print content of info word? */
15653 fputs (" HWAND ", stdout
);
15654 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
15655 fputs (" R4KEOP_CHECKED", stdout
);
15656 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
15657 fputs (" R4KEOP_CLEAN", stdout
);
15660 fputs (" HWOR ", stdout
);
15661 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
15662 fputs (" R4KEOP_CHECKED", stdout
);
15663 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
15664 fputs (" R4KEOP_CLEAN", stdout
);
15667 printf (" GP_GROUP %#06lx self-contained %#06lx",
15668 option
->info
& OGP_GROUP
,
15669 (option
->info
& OGP_SELF
) >> 16);
15672 printf (" IDENT %#06lx self-contained %#06lx",
15673 option
->info
& OGP_GROUP
,
15674 (option
->info
& OGP_SELF
) >> 16);
15677 /* This shouldn't happen. */
15678 printf (" %3d ??? %d %lx",
15679 option
->kind
, option
->section
, option
->info
);
15683 len
= sizeof (* eopt
);
15684 while (len
< option
->size
)
15686 unsigned char datum
= * ((unsigned char *) eopt
+ offset
+ len
);
15688 if (ISPRINT (datum
))
15689 printf ("%c", datum
);
15691 printf ("\\%03o", datum
);
15694 fputs ("\n", stdout
);
15696 offset
+= option
->size
;
15706 if (conflicts_offset
!= 0 && conflictsno
!= 0)
15708 Elf32_Conflict
* iconf
;
15711 if (dynamic_symbols
== NULL
)
15713 error (_("conflict list found without a dynamic symbol table\n"));
15717 /* PR 21345 - print a slightly more helpful error message
15718 if we are sure that the cmalloc will fail. */
15719 if (conflictsno
* sizeof (* iconf
) > current_file_size
)
15721 error (_("Overlarge number of conflicts detected: %lx\n"),
15722 (long) conflictsno
);
15726 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
15729 error (_("Out of memory allocating space for dynamic conflicts\n"));
15735 Elf32_External_Conflict
* econf32
;
15737 econf32
= (Elf32_External_Conflict
*)
15738 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
15739 sizeof (* econf32
), _("conflict"));
15743 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
15744 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
15750 Elf64_External_Conflict
* econf64
;
15752 econf64
= (Elf64_External_Conflict
*)
15753 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
15754 sizeof (* econf64
), _("conflict"));
15758 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
15759 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
15764 printf (_("\nSection '.conflict' contains %lu entries:\n"),
15765 (unsigned long) conflictsno
);
15766 puts (_(" Num: Index Value Name"));
15768 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
15770 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
15772 if (iconf
[cnt
] >= num_dynamic_syms
)
15773 printf (_("<corrupt symbol index>"));
15776 Elf_Internal_Sym
* psym
;
15778 psym
= & dynamic_symbols
[iconf
[cnt
]];
15779 print_vma (psym
->st_value
, FULL_HEX
);
15781 if (VALID_DYNAMIC_NAME (psym
->st_name
))
15782 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
15784 printf (_("<corrupt: %14ld>"), psym
->st_name
);
15792 if (pltgot
!= 0 && local_gotno
!= 0)
15794 bfd_vma ent
, local_end
, global_end
;
15796 unsigned char * data
;
15797 unsigned char * data_end
;
15801 addr_size
= (is_32bit_elf
? 4 : 8);
15802 local_end
= pltgot
+ local_gotno
* addr_size
;
15804 /* PR binutils/17533 file: 012-111227-0.004 */
15805 if (symtabno
< gotsym
)
15807 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
15808 (unsigned long) gotsym
, (unsigned long) symtabno
);
15812 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
15813 /* PR 17531: file: 54c91a34. */
15814 if (global_end
< local_end
)
15816 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
15820 offset
= offset_from_vma (file
, pltgot
, global_end
- pltgot
);
15821 data
= (unsigned char *) get_data (NULL
, file
, offset
,
15822 global_end
- pltgot
, 1,
15823 _("Global Offset Table data"));
15824 /* PR 12855: Null data is handled gracefully throughout. */
15825 data_end
= data
+ (global_end
- pltgot
);
15827 printf (_("\nPrimary GOT:\n"));
15828 printf (_(" Canonical gp value: "));
15829 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
15832 printf (_(" Reserved entries:\n"));
15833 printf (_(" %*s %10s %*s Purpose\n"),
15834 addr_size
* 2, _("Address"), _("Access"),
15835 addr_size
* 2, _("Initial"));
15836 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15837 printf (_(" Lazy resolver\n"));
15838 if (ent
== (bfd_vma
) -1)
15839 goto got_print_fail
;
15841 /* Check for the MSB of GOT[1] being set, denoting a GNU object.
15842 This entry will be used by some runtime loaders, to store the
15843 module pointer. Otherwise this is an ordinary local entry.
15844 PR 21344: Check for the entry being fully available before
15847 && data
+ ent
- pltgot
+ addr_size
<= data_end
15848 && (byte_get (data
+ ent
- pltgot
, addr_size
)
15849 >> (addr_size
* 8 - 1)) != 0)
15851 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15852 printf (_(" Module pointer (GNU extension)\n"));
15853 if (ent
== (bfd_vma
) -1)
15854 goto got_print_fail
;
15858 if (data
!= NULL
&& ent
< local_end
)
15860 printf (_(" Local entries:\n"));
15861 printf (" %*s %10s %*s\n",
15862 addr_size
* 2, _("Address"), _("Access"),
15863 addr_size
* 2, _("Initial"));
15864 while (ent
< local_end
)
15866 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15868 if (ent
== (bfd_vma
) -1)
15869 goto got_print_fail
;
15874 if (data
!= NULL
&& gotsym
< symtabno
)
15878 printf (_(" Global entries:\n"));
15879 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
15880 addr_size
* 2, _("Address"),
15882 addr_size
* 2, _("Initial"),
15883 addr_size
* 2, _("Sym.Val."),
15885 /* Note for translators: "Ndx" = abbreviated form of "Index". */
15886 _("Ndx"), _("Name"));
15888 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
15890 for (i
= gotsym
; i
< symtabno
; i
++)
15892 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15895 if (dynamic_symbols
== NULL
)
15896 printf (_("<no dynamic symbols>"));
15897 else if (i
< num_dynamic_syms
)
15899 Elf_Internal_Sym
* psym
= dynamic_symbols
+ i
;
15901 print_vma (psym
->st_value
, LONG_HEX
);
15902 printf (" %-7s %3s ",
15903 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
15904 get_symbol_index_type (psym
->st_shndx
));
15906 if (VALID_DYNAMIC_NAME (psym
->st_name
))
15907 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
15909 printf (_("<corrupt: %14ld>"), psym
->st_name
);
15912 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
15913 (unsigned long) i
);
15916 if (ent
== (bfd_vma
) -1)
15927 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
15930 size_t offset
, rel_offset
;
15931 unsigned long count
, i
;
15932 unsigned char * data
;
15933 int addr_size
, sym_width
;
15934 Elf_Internal_Rela
* rels
;
15936 rel_offset
= offset_from_vma (file
, jmprel
, pltrelsz
);
15937 if (pltrel
== DT_RELA
)
15939 if (!slurp_rela_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
15944 if (!slurp_rel_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
15949 addr_size
= (is_32bit_elf
? 4 : 8);
15950 end
= mips_pltgot
+ (2 + count
) * addr_size
;
15952 offset
= offset_from_vma (file
, mips_pltgot
, end
- mips_pltgot
);
15953 data
= (unsigned char *) get_data (NULL
, file
, offset
, end
- mips_pltgot
,
15954 1, _("Procedure Linkage Table data"));
15958 printf ("\nPLT GOT:\n\n");
15959 printf (_(" Reserved entries:\n"));
15960 printf (_(" %*s %*s Purpose\n"),
15961 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
15962 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
15963 printf (_(" PLT lazy resolver\n"));
15964 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
15965 printf (_(" Module pointer\n"));
15968 printf (_(" Entries:\n"));
15969 printf (" %*s %*s %*s %-7s %3s %s\n",
15970 addr_size
* 2, _("Address"),
15971 addr_size
* 2, _("Initial"),
15972 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
15973 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
15974 for (i
= 0; i
< count
; i
++)
15976 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
15978 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
15981 if (idx
>= num_dynamic_syms
)
15982 printf (_("<corrupt symbol index: %lu>"), idx
);
15985 Elf_Internal_Sym
* psym
= dynamic_symbols
+ idx
;
15987 print_vma (psym
->st_value
, LONG_HEX
);
15988 printf (" %-7s %3s ",
15989 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
15990 get_symbol_index_type (psym
->st_shndx
));
15991 if (VALID_DYNAMIC_NAME (psym
->st_name
))
15992 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
15994 printf (_("<corrupt: %14ld>"), psym
->st_name
);
16009 process_nds32_specific (FILE * file
)
16011 Elf_Internal_Shdr
*sect
= NULL
;
16013 sect
= find_section (".nds32_e_flags");
16016 unsigned int *flag
;
16018 printf ("\nNDS32 elf flags section:\n");
16019 flag
= get_data (NULL
, file
, sect
->sh_offset
, 1,
16020 sect
->sh_size
, _("NDS32 elf flags section"));
16025 switch ((*flag
) & 0x3)
16028 printf ("(VEC_SIZE):\tNo entry.\n");
16031 printf ("(VEC_SIZE):\t4 bytes\n");
16034 printf ("(VEC_SIZE):\t16 bytes\n");
16037 printf ("(VEC_SIZE):\treserved\n");
16046 process_gnu_liblist (FILE * file
)
16048 Elf_Internal_Shdr
* section
;
16049 Elf_Internal_Shdr
* string_sec
;
16050 Elf32_External_Lib
* elib
;
16052 size_t strtab_size
;
16055 bfd_boolean res
= TRUE
;
16060 for (i
= 0, section
= section_headers
;
16061 i
< elf_header
.e_shnum
;
16064 switch (section
->sh_type
)
16066 case SHT_GNU_LIBLIST
:
16067 if (section
->sh_link
>= elf_header
.e_shnum
)
16070 elib
= (Elf32_External_Lib
*)
16071 get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
16072 _("liblist section data"));
16080 string_sec
= section_headers
+ section
->sh_link
;
16081 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
16082 string_sec
->sh_size
,
16083 _("liblist string table"));
16085 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
16092 strtab_size
= string_sec
->sh_size
;
16094 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
16095 printable_section_name (section
),
16096 (unsigned long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
16098 puts (_(" Library Time Stamp Checksum Version Flags"));
16100 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
16108 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
16109 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
16110 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
16111 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
16112 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
16114 tmp
= gmtime (&atime
);
16115 snprintf (timebuf
, sizeof (timebuf
),
16116 "%04u-%02u-%02uT%02u:%02u:%02u",
16117 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
16118 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
16120 printf ("%3lu: ", (unsigned long) cnt
);
16122 printf ("%-20s", liblist
.l_name
< strtab_size
16123 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
16125 printf ("%-20.20s", liblist
.l_name
< strtab_size
16126 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
16127 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
16128 liblist
.l_version
, liblist
.l_flags
);
16139 static const char *
16140 get_note_type (unsigned e_type
)
16142 static char buff
[64];
16144 if (elf_header
.e_type
== ET_CORE
)
16148 return _("NT_AUXV (auxiliary vector)");
16150 return _("NT_PRSTATUS (prstatus structure)");
16152 return _("NT_FPREGSET (floating point registers)");
16154 return _("NT_PRPSINFO (prpsinfo structure)");
16155 case NT_TASKSTRUCT
:
16156 return _("NT_TASKSTRUCT (task structure)");
16158 return _("NT_PRXFPREG (user_xfpregs structure)");
16160 return _("NT_PPC_VMX (ppc Altivec registers)");
16162 return _("NT_PPC_VSX (ppc VSX registers)");
16164 return _("NT_PPC_TAR (ppc TAR register)");
16166 return _("NT_PPC_PPR (ppc PPR register)");
16168 return _("NT_PPC_DSCR (ppc DSCR register)");
16170 return _("NT_PPC_EBB (ppc EBB registers)");
16172 return _("NT_PPC_PMU (ppc PMU registers)");
16173 case NT_PPC_TM_CGPR
:
16174 return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
16175 case NT_PPC_TM_CFPR
:
16176 return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
16177 case NT_PPC_TM_CVMX
:
16178 return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
16179 case NT_PPC_TM_CVSX
:
16180 return _("NT_PPC_TM_VSX (ppc checkpointed VSX registers)");
16181 case NT_PPC_TM_SPR
:
16182 return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
16183 case NT_PPC_TM_CTAR
:
16184 return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
16185 case NT_PPC_TM_CPPR
:
16186 return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
16187 case NT_PPC_TM_CDSCR
:
16188 return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
16190 return _("NT_386_TLS (x86 TLS information)");
16191 case NT_386_IOPERM
:
16192 return _("NT_386_IOPERM (x86 I/O permissions)");
16193 case NT_X86_XSTATE
:
16194 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
16195 case NT_S390_HIGH_GPRS
:
16196 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
16197 case NT_S390_TIMER
:
16198 return _("NT_S390_TIMER (s390 timer register)");
16199 case NT_S390_TODCMP
:
16200 return _("NT_S390_TODCMP (s390 TOD comparator register)");
16201 case NT_S390_TODPREG
:
16202 return _("NT_S390_TODPREG (s390 TOD programmable register)");
16204 return _("NT_S390_CTRS (s390 control registers)");
16205 case NT_S390_PREFIX
:
16206 return _("NT_S390_PREFIX (s390 prefix register)");
16207 case NT_S390_LAST_BREAK
:
16208 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
16209 case NT_S390_SYSTEM_CALL
:
16210 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
16212 return _("NT_S390_TDB (s390 transaction diagnostic block)");
16213 case NT_S390_VXRS_LOW
:
16214 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
16215 case NT_S390_VXRS_HIGH
:
16216 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
16217 case NT_S390_GS_CB
:
16218 return _("NT_S390_GS_CB (s390 guarded-storage registers)");
16219 case NT_S390_GS_BC
:
16220 return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
16222 return _("NT_ARM_VFP (arm VFP registers)");
16224 return _("NT_ARM_TLS (AArch TLS registers)");
16225 case NT_ARM_HW_BREAK
:
16226 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
16227 case NT_ARM_HW_WATCH
:
16228 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
16230 return _("NT_PSTATUS (pstatus structure)");
16232 return _("NT_FPREGS (floating point registers)");
16234 return _("NT_PSINFO (psinfo structure)");
16236 return _("NT_LWPSTATUS (lwpstatus_t structure)");
16238 return _("NT_LWPSINFO (lwpsinfo_t structure)");
16239 case NT_WIN32PSTATUS
:
16240 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
16242 return _("NT_SIGINFO (siginfo_t data)");
16244 return _("NT_FILE (mapped files)");
16252 return _("NT_VERSION (version)");
16254 return _("NT_ARCH (architecture)");
16255 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
16256 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
16257 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
16258 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
16263 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16268 print_core_note (Elf_Internal_Note
*pnote
)
16270 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
16271 bfd_vma count
, page_size
;
16272 unsigned char *descdata
, *filenames
, *descend
;
16274 if (pnote
->type
!= NT_FILE
)
16284 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
16285 /* Still "successful". */
16290 if (pnote
->descsz
< 2 * addr_size
)
16292 error (_(" Malformed note - too short for header\n"));
16296 descdata
= (unsigned char *) pnote
->descdata
;
16297 descend
= descdata
+ pnote
->descsz
;
16299 if (descdata
[pnote
->descsz
- 1] != '\0')
16301 error (_(" Malformed note - does not end with \\0\n"));
16305 count
= byte_get (descdata
, addr_size
);
16306 descdata
+= addr_size
;
16308 page_size
= byte_get (descdata
, addr_size
);
16309 descdata
+= addr_size
;
16311 if (pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
16313 error (_(" Malformed note - too short for supplied file count\n"));
16317 printf (_(" Page size: "));
16318 print_vma (page_size
, DEC
);
16321 printf (_(" %*s%*s%*s\n"),
16322 (int) (2 + 2 * addr_size
), _("Start"),
16323 (int) (4 + 2 * addr_size
), _("End"),
16324 (int) (4 + 2 * addr_size
), _("Page Offset"));
16325 filenames
= descdata
+ count
* 3 * addr_size
;
16326 while (count
-- > 0)
16328 bfd_vma start
, end
, file_ofs
;
16330 if (filenames
== descend
)
16332 error (_(" Malformed note - filenames end too early\n"));
16336 start
= byte_get (descdata
, addr_size
);
16337 descdata
+= addr_size
;
16338 end
= byte_get (descdata
, addr_size
);
16339 descdata
+= addr_size
;
16340 file_ofs
= byte_get (descdata
, addr_size
);
16341 descdata
+= addr_size
;
16344 print_vma (start
, FULL_HEX
);
16346 print_vma (end
, FULL_HEX
);
16348 print_vma (file_ofs
, FULL_HEX
);
16349 printf ("\n %s\n", filenames
);
16351 filenames
+= 1 + strlen ((char *) filenames
);
16357 static const char *
16358 get_gnu_elf_note_type (unsigned e_type
)
16360 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
16363 case NT_GNU_ABI_TAG
:
16364 return _("NT_GNU_ABI_TAG (ABI version tag)");
16366 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
16367 case NT_GNU_BUILD_ID
:
16368 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
16369 case NT_GNU_GOLD_VERSION
:
16370 return _("NT_GNU_GOLD_VERSION (gold version)");
16371 case NT_GNU_PROPERTY_TYPE_0
:
16372 return _("NT_GNU_PROPERTY_TYPE_0");
16373 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
16374 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
16375 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
16376 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
16379 static char buff
[64];
16381 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16388 decode_x86_isa (unsigned int bitmask
)
16392 unsigned int bit
= bitmask
& (- bitmask
);
16397 case GNU_PROPERTY_X86_ISA_1_486
: printf ("i486"); break;
16398 case GNU_PROPERTY_X86_ISA_1_586
: printf ("586"); break;
16399 case GNU_PROPERTY_X86_ISA_1_686
: printf ("686"); break;
16400 case GNU_PROPERTY_X86_ISA_1_SSE
: printf ("SSE"); break;
16401 case GNU_PROPERTY_X86_ISA_1_SSE2
: printf ("SSE2"); break;
16402 case GNU_PROPERTY_X86_ISA_1_SSE3
: printf ("SSE3"); break;
16403 case GNU_PROPERTY_X86_ISA_1_SSSE3
: printf ("SSSE3"); break;
16404 case GNU_PROPERTY_X86_ISA_1_SSE4_1
: printf ("SSE4_1"); break;
16405 case GNU_PROPERTY_X86_ISA_1_SSE4_2
: printf ("SSE4_2"); break;
16406 case GNU_PROPERTY_X86_ISA_1_AVX
: printf ("AVX"); break;
16407 case GNU_PROPERTY_X86_ISA_1_AVX2
: printf ("AVX2"); break;
16408 case GNU_PROPERTY_X86_ISA_1_AVX512F
: printf ("AVX512F"); break;
16409 case GNU_PROPERTY_X86_ISA_1_AVX512CD
: printf ("AVX512CD"); break;
16410 case GNU_PROPERTY_X86_ISA_1_AVX512ER
: printf ("AVX512ER"); break;
16411 case GNU_PROPERTY_X86_ISA_1_AVX512PF
: printf ("AVX512PF"); break;
16412 case GNU_PROPERTY_X86_ISA_1_AVX512VL
: printf ("AVX512VL"); break;
16413 case GNU_PROPERTY_X86_ISA_1_AVX512DQ
: printf ("AVX512DQ"); break;
16414 case GNU_PROPERTY_X86_ISA_1_AVX512BW
: printf ("AVX512BW"); break;
16415 default: printf (_("<unknown: %x>"), bit
); break;
16423 decode_x86_feature (unsigned int type
, unsigned int bitmask
)
16427 unsigned int bit
= bitmask
& (- bitmask
);
16432 case GNU_PROPERTY_X86_FEATURE_1_IBT
:
16435 case GNU_PROPERTY_X86_FEATURE_1_AND
:
16439 /* This should never happen. */
16443 case GNU_PROPERTY_X86_FEATURE_1_SHSTK
:
16446 case GNU_PROPERTY_X86_FEATURE_1_AND
:
16450 /* This should never happen. */
16455 printf (_("<unknown: %x>"), bit
);
16464 print_gnu_property_note (Elf_Internal_Note
* pnote
)
16466 unsigned char * ptr
= (unsigned char *) pnote
->descdata
;
16467 unsigned char * ptr_end
= ptr
+ pnote
->descsz
;
16468 unsigned int size
= is_32bit_elf
? 4 : 8;
16470 printf (_(" Properties: "));
16472 if (pnote
->descsz
< 8 || (pnote
->descsz
% size
) != 0)
16474 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote
->descsz
);
16481 unsigned int type
= byte_get (ptr
, 4);
16482 unsigned int datasz
= byte_get (ptr
+ 4, 4);
16486 if ((ptr
+ datasz
) > ptr_end
)
16488 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
16493 if (type
>= GNU_PROPERTY_LOPROC
&& type
<= GNU_PROPERTY_HIPROC
)
16495 if (elf_header
.e_machine
== EM_X86_64
16496 || elf_header
.e_machine
== EM_IAMCU
16497 || elf_header
.e_machine
== EM_386
)
16501 case GNU_PROPERTY_X86_ISA_1_USED
:
16502 printf ("x86 ISA used: ");
16504 printf (_("<corrupt length: %#x> "), datasz
);
16506 decode_x86_isa (byte_get (ptr
, 4));
16509 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
16510 printf ("x86 ISA needed: ");
16512 printf (_("<corrupt length: %#x> "), datasz
);
16514 decode_x86_isa (byte_get (ptr
, 4));
16517 case GNU_PROPERTY_X86_FEATURE_1_AND
:
16518 printf ("x86 feature: ");
16520 printf (_("<corrupt length: %#x> "), datasz
);
16522 decode_x86_feature (type
, byte_get (ptr
, 4));
16534 case GNU_PROPERTY_STACK_SIZE
:
16535 printf (_("stack size: "));
16536 if (datasz
!= size
)
16537 printf (_("<corrupt length: %#x> "), datasz
);
16539 printf ("%#lx", (unsigned long) byte_get (ptr
, size
));
16542 case GNU_PROPERTY_NO_COPY_ON_PROTECTED
:
16543 printf ("no copy on protected ");
16545 printf (_("<corrupt length: %#x> "), datasz
);
16553 if (type
< GNU_PROPERTY_LOPROC
)
16554 printf (_("<unknown type %#x data: "), type
);
16555 else if (type
< GNU_PROPERTY_LOUSER
)
16556 printf (_("<procesor-specific type %#x data: "), type
);
16558 printf (_("<application-specific type %#x data: "), type
);
16559 for (j
= 0; j
< datasz
; ++j
)
16560 printf ("%02x ", ptr
[j
] & 0xff);
16564 ptr
+= ((datasz
+ (size
- 1)) & ~ (size
- 1));
16565 if (ptr
== ptr_end
)
16575 if (ptr
> (ptr_end
- 8))
16577 printf (_("<corrupt descsz: %#lx>\n"), pnote
->descsz
);
16586 print_gnu_note (Elf_Internal_Note
*pnote
)
16588 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
16589 switch (pnote
->type
)
16591 case NT_GNU_BUILD_ID
:
16595 printf (_(" Build ID: "));
16596 for (i
= 0; i
< pnote
->descsz
; ++i
)
16597 printf ("%02x", pnote
->descdata
[i
] & 0xff);
16602 case NT_GNU_ABI_TAG
:
16604 unsigned long os
, major
, minor
, subminor
;
16605 const char *osname
;
16607 /* PR 17531: file: 030-599401-0.004. */
16608 if (pnote
->descsz
< 16)
16610 printf (_(" <corrupt GNU_ABI_TAG>\n"));
16614 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
16615 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
16616 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
16617 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
16621 case GNU_ABI_TAG_LINUX
:
16624 case GNU_ABI_TAG_HURD
:
16627 case GNU_ABI_TAG_SOLARIS
:
16628 osname
= "Solaris";
16630 case GNU_ABI_TAG_FREEBSD
:
16631 osname
= "FreeBSD";
16633 case GNU_ABI_TAG_NETBSD
:
16636 case GNU_ABI_TAG_SYLLABLE
:
16637 osname
= "Syllable";
16639 case GNU_ABI_TAG_NACL
:
16643 osname
= "Unknown";
16647 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
16648 major
, minor
, subminor
);
16652 case NT_GNU_GOLD_VERSION
:
16656 printf (_(" Version: "));
16657 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
16658 printf ("%c", pnote
->descdata
[i
]);
16665 unsigned long num_entries
, mask
;
16667 /* Hardware capabilities information. Word 0 is the number of entries.
16668 Word 1 is a bitmask of enabled entries. The rest of the descriptor
16669 is a series of entries, where each entry is a single byte followed
16670 by a nul terminated string. The byte gives the bit number to test
16671 if enabled in the bitmask. */
16672 printf (_(" Hardware Capabilities: "));
16673 if (pnote
->descsz
< 8)
16675 error (_("<corrupt GNU_HWCAP>\n"));
16678 num_entries
= byte_get ((unsigned char *) pnote
->descdata
, 4);
16679 mask
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
16680 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries
, mask
);
16681 /* FIXME: Add code to display the entries... */
16685 case NT_GNU_PROPERTY_TYPE_0
:
16686 print_gnu_property_note (pnote
);
16690 /* Handle unrecognised types. An error message should have already been
16691 created by get_gnu_elf_note_type(), so all that we need to do is to
16692 display the data. */
16696 printf (_(" Description data: "));
16697 for (i
= 0; i
< pnote
->descsz
; ++i
)
16698 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
16707 static const char *
16708 get_v850_elf_note_type (enum v850_notes n_type
)
16710 static char buff
[64];
16714 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
16715 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
16716 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
16717 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
16718 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
16719 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
16721 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
16727 print_v850_note (Elf_Internal_Note
* pnote
)
16731 if (pnote
->descsz
!= 4)
16734 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
16738 printf (_("not set\n"));
16742 switch (pnote
->type
)
16744 case V850_NOTE_ALIGNMENT
:
16747 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return TRUE
;
16748 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return TRUE
;
16752 case V850_NOTE_DATA_SIZE
:
16755 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return TRUE
;
16756 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return TRUE
;
16760 case V850_NOTE_FPU_INFO
:
16763 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return TRUE
;
16764 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return TRUE
;
16768 case V850_NOTE_MMU_INFO
:
16769 case V850_NOTE_CACHE_INFO
:
16770 case V850_NOTE_SIMD_INFO
:
16771 if (val
== EF_RH850_SIMD
)
16773 printf (_("yes\n"));
16779 /* An 'unknown note type' message will already have been displayed. */
16783 printf (_("unknown value: %x\n"), val
);
16788 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
16790 unsigned int version
;
16792 switch (pnote
->type
)
16794 case NT_NETBSD_IDENT
:
16795 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
16796 if ((version
/ 10000) % 100)
16797 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
16798 version
, version
/ 100000000, (version
/ 1000000) % 100,
16799 (version
/ 10000) % 100 > 26 ? "Z" : "",
16800 'A' + (version
/ 10000) % 26);
16802 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
16803 version
, version
/ 100000000, (version
/ 1000000) % 100,
16804 (version
/ 100) % 100);
16807 case NT_NETBSD_MARCH
:
16808 printf (" NetBSD\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
16813 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote
->descsz
,
16819 static const char *
16820 get_freebsd_elfcore_note_type (unsigned e_type
)
16824 case NT_FREEBSD_THRMISC
:
16825 return _("NT_THRMISC (thrmisc structure)");
16826 case NT_FREEBSD_PROCSTAT_PROC
:
16827 return _("NT_PROCSTAT_PROC (proc data)");
16828 case NT_FREEBSD_PROCSTAT_FILES
:
16829 return _("NT_PROCSTAT_FILES (files data)");
16830 case NT_FREEBSD_PROCSTAT_VMMAP
:
16831 return _("NT_PROCSTAT_VMMAP (vmmap data)");
16832 case NT_FREEBSD_PROCSTAT_GROUPS
:
16833 return _("NT_PROCSTAT_GROUPS (groups data)");
16834 case NT_FREEBSD_PROCSTAT_UMASK
:
16835 return _("NT_PROCSTAT_UMASK (umask data)");
16836 case NT_FREEBSD_PROCSTAT_RLIMIT
:
16837 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
16838 case NT_FREEBSD_PROCSTAT_OSREL
:
16839 return _("NT_PROCSTAT_OSREL (osreldate data)");
16840 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
16841 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
16842 case NT_FREEBSD_PROCSTAT_AUXV
:
16843 return _("NT_PROCSTAT_AUXV (auxv data)");
16844 case NT_FREEBSD_PTLWPINFO
:
16845 return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
16847 return get_note_type (e_type
);
16850 static const char *
16851 get_netbsd_elfcore_note_type (unsigned e_type
)
16853 static char buff
[64];
16855 if (e_type
== NT_NETBSDCORE_PROCINFO
)
16857 /* NetBSD core "procinfo" structure. */
16858 return _("NetBSD procinfo structure");
16861 /* As of Jan 2002 there are no other machine-independent notes
16862 defined for NetBSD core files. If the note type is less
16863 than the start of the machine-dependent note types, we don't
16866 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
16868 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16872 switch (elf_header
.e_machine
)
16874 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
16875 and PT_GETFPREGS == mach+2. */
16880 case EM_SPARC32PLUS
:
16884 case NT_NETBSDCORE_FIRSTMACH
+ 0:
16885 return _("PT_GETREGS (reg structure)");
16886 case NT_NETBSDCORE_FIRSTMACH
+ 2:
16887 return _("PT_GETFPREGS (fpreg structure)");
16893 /* On all other arch's, PT_GETREGS == mach+1 and
16894 PT_GETFPREGS == mach+3. */
16898 case NT_NETBSDCORE_FIRSTMACH
+ 1:
16899 return _("PT_GETREGS (reg structure)");
16900 case NT_NETBSDCORE_FIRSTMACH
+ 3:
16901 return _("PT_GETFPREGS (fpreg structure)");
16907 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
16908 e_type
- NT_NETBSDCORE_FIRSTMACH
);
16912 static const char *
16913 get_stapsdt_note_type (unsigned e_type
)
16915 static char buff
[64];
16920 return _("NT_STAPSDT (SystemTap probe descriptors)");
16926 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16931 print_stapsdt_note (Elf_Internal_Note
*pnote
)
16933 int addr_size
= is_32bit_elf
? 4 : 8;
16934 char *data
= pnote
->descdata
;
16935 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
16936 bfd_vma pc
, base_addr
, semaphore
;
16937 char *provider
, *probe
, *arg_fmt
;
16939 pc
= byte_get ((unsigned char *) data
, addr_size
);
16941 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
16943 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
16947 data
+= strlen (data
) + 1;
16949 data
+= strlen (data
) + 1;
16951 data
+= strlen (data
) + 1;
16953 printf (_(" Provider: %s\n"), provider
);
16954 printf (_(" Name: %s\n"), probe
);
16955 printf (_(" Location: "));
16956 print_vma (pc
, FULL_HEX
);
16957 printf (_(", Base: "));
16958 print_vma (base_addr
, FULL_HEX
);
16959 printf (_(", Semaphore: "));
16960 print_vma (semaphore
, FULL_HEX
);
16962 printf (_(" Arguments: %s\n"), arg_fmt
);
16964 return data
== data_end
;
16967 static const char *
16968 get_ia64_vms_note_type (unsigned e_type
)
16970 static char buff
[64];
16975 return _("NT_VMS_MHD (module header)");
16977 return _("NT_VMS_LNM (language name)");
16979 return _("NT_VMS_SRC (source files)");
16981 return "NT_VMS_TITLE";
16983 return _("NT_VMS_EIDC (consistency check)");
16984 case NT_VMS_FPMODE
:
16985 return _("NT_VMS_FPMODE (FP mode)");
16986 case NT_VMS_LINKTIME
:
16987 return "NT_VMS_LINKTIME";
16988 case NT_VMS_IMGNAM
:
16989 return _("NT_VMS_IMGNAM (image name)");
16991 return _("NT_VMS_IMGID (image id)");
16992 case NT_VMS_LINKID
:
16993 return _("NT_VMS_LINKID (link id)");
16994 case NT_VMS_IMGBID
:
16995 return _("NT_VMS_IMGBID (build id)");
16996 case NT_VMS_GSTNAM
:
16997 return _("NT_VMS_GSTNAM (sym table name)");
16998 case NT_VMS_ORIG_DYN
:
16999 return "NT_VMS_ORIG_DYN";
17000 case NT_VMS_PATCHTIME
:
17001 return "NT_VMS_PATCHTIME";
17003 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17009 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
17011 switch (pnote
->type
)
17014 if (pnote
->descsz
> 36)
17016 size_t l
= strlen (pnote
->descdata
+ 34);
17017 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
17018 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
17019 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
17020 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
17023 printf (_(" Invalid size\n"));
17026 printf (_(" Language: %s\n"), pnote
->descdata
);
17029 case NT_VMS_FPMODE
:
17030 printf (_(" Floating Point mode: "));
17031 printf ("0x%016" BFD_VMA_FMT
"x\n",
17032 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
17034 case NT_VMS_LINKTIME
:
17035 printf (_(" Link time: "));
17037 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
17040 case NT_VMS_PATCHTIME
:
17041 printf (_(" Patch time: "));
17043 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
17046 case NT_VMS_ORIG_DYN
:
17047 printf (_(" Major id: %u, minor id: %u\n"),
17048 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
17049 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
17050 printf (_(" Last modified : "));
17052 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
17053 printf (_("\n Link flags : "));
17054 printf ("0x%016" BFD_VMA_FMT
"x\n",
17055 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
17056 printf (_(" Header flags: 0x%08x\n"),
17057 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
17058 printf (_(" Image id : %s\n"), pnote
->descdata
+ 32);
17061 case NT_VMS_IMGNAM
:
17062 printf (_(" Image name: %s\n"), pnote
->descdata
);
17064 case NT_VMS_GSTNAM
:
17065 printf (_(" Global symbol table name: %s\n"), pnote
->descdata
);
17068 printf (_(" Image id: %s\n"), pnote
->descdata
);
17070 case NT_VMS_LINKID
:
17071 printf (_(" Linker id: %s\n"), pnote
->descdata
);
17079 /* Print the name of the symbol associated with a build attribute
17080 that is attached to address OFFSET. */
17083 print_symbol_for_build_attribute (FILE * file
,
17084 unsigned long offset
,
17085 bfd_boolean is_open_attr
)
17087 static FILE * saved_file
= NULL
;
17088 static char * strtab
;
17089 static unsigned long strtablen
;
17090 static Elf_Internal_Sym
* symtab
;
17091 static unsigned long nsyms
;
17092 Elf_Internal_Sym
* saved_sym
= NULL
;
17093 Elf_Internal_Sym
* sym
;
17095 if (section_headers
!= NULL
17096 && (saved_file
== NULL
|| file
!= saved_file
))
17098 Elf_Internal_Shdr
* symsec
;
17100 /* Load the symbol and string sections. */
17101 for (symsec
= section_headers
;
17102 symsec
< section_headers
+ elf_header
.e_shnum
;
17105 if (symsec
->sh_type
== SHT_SYMTAB
)
17107 symtab
= GET_ELF_SYMBOLS (file
, symsec
, & nsyms
);
17109 if (symsec
->sh_link
< elf_header
.e_shnum
)
17111 Elf_Internal_Shdr
* strtab_sec
= section_headers
+ symsec
->sh_link
;
17113 strtab
= (char *) get_data (NULL
, file
, strtab_sec
->sh_offset
,
17114 1, strtab_sec
->sh_size
,
17115 _("string table"));
17116 strtablen
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
17123 if (symtab
== NULL
|| strtab
== NULL
)
17129 /* Find a symbol whose value matches offset. */
17130 for (sym
= symtab
; sym
< symtab
+ nsyms
; sym
++)
17131 if (sym
->st_value
== offset
)
17133 if (sym
->st_name
>= strtablen
)
17134 /* Huh ? This should not happen. */
17137 if (strtab
[sym
->st_name
] == 0)
17142 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
17143 and FILE or OBJECT symbols over NOTYPE symbols. We skip
17144 FUNC symbols entirely. */
17145 switch (ELF_ST_TYPE (sym
->st_info
))
17149 /* We can stop searching now. */
17150 sym
= symtab
+ nsyms
;
17158 /* Ignore function symbols. */
17165 switch (ELF_ST_BIND (sym
->st_info
))
17168 if (saved_sym
== NULL
17169 || ELF_ST_TYPE (saved_sym
->st_info
) != STT_OBJECT
)
17174 if (saved_sym
== NULL
)
17184 if (ELF_ST_TYPE (sym
->st_info
) != STT_FUNC
)
17192 printf (" (%s: %s)\n",
17193 is_open_attr
? _("file") : _("func"),
17194 saved_sym
? strtab
+ saved_sym
->st_name
: _("<no symbol found>)"));
17199 print_gnu_build_attribute_description (Elf_Internal_Note
* pnote
,
17202 static unsigned long global_offset
= 0;
17203 unsigned long offset
;
17204 unsigned int desc_size
= is_32bit_elf
? 4 : 8;
17205 bfd_boolean is_open_attr
= pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
;
17207 if (pnote
->descsz
== 0)
17211 printf (_(" Applies from offset %#lx\n"), global_offset
);
17216 printf (_(" Applies to func at %#lx"), global_offset
);
17217 return print_symbol_for_build_attribute (file
, global_offset
, is_open_attr
);
17221 if (pnote
->descsz
!= desc_size
)
17223 error (_(" <invalid description size: %lx>\n"), pnote
->descsz
);
17224 printf (_(" <invalid descsz>"));
17228 offset
= byte_get ((unsigned char *) pnote
->descdata
, desc_size
);
17232 printf (_(" Applies from offset %#lx"), offset
);
17233 global_offset
= offset
;
17237 printf (_(" Applies to func at %#lx"), offset
);
17240 return print_symbol_for_build_attribute (file
, offset
, is_open_attr
);
17244 print_gnu_build_attribute_name (Elf_Internal_Note
* pnote
)
17246 static const char string_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING
, 0 };
17247 static const char number_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
, 0 };
17248 static const char bool_expected
[3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
, 0 };
17250 char name_attribute
;
17251 const char * expected_types
;
17252 const char * name
= pnote
->namedata
;
17256 if (name
== NULL
|| pnote
->namesz
< 2)
17258 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
17259 print_symbol (-20, _(" <corrupt name>"));
17265 /* Version 2 of the spec adds a "GA" prefix to the name field. */
17266 if (name
[0] == 'G' && name
[1] == 'A')
17273 switch ((name_type
= * name
))
17275 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
17276 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
17277 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
17278 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
17279 printf ("%c", * name
);
17283 error (_("unrecognised attribute type in name field: %d\n"), name_type
);
17284 print_symbol (-20, _("<unknown name type>"));
17291 switch ((name_attribute
= * name
))
17293 case GNU_BUILD_ATTRIBUTE_VERSION
:
17294 text
= _("<version>");
17295 expected_types
= string_expected
;
17298 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
17299 text
= _("<stack prot>");
17300 expected_types
= "!+*";
17303 case GNU_BUILD_ATTRIBUTE_RELRO
:
17304 text
= _("<relro>");
17305 expected_types
= bool_expected
;
17308 case GNU_BUILD_ATTRIBUTE_STACK_SIZE
:
17309 text
= _("<stack size>");
17310 expected_types
= number_expected
;
17313 case GNU_BUILD_ATTRIBUTE_TOOL
:
17314 text
= _("<tool>");
17315 expected_types
= string_expected
;
17318 case GNU_BUILD_ATTRIBUTE_ABI
:
17320 expected_types
= "$*";
17323 case GNU_BUILD_ATTRIBUTE_PIC
:
17325 expected_types
= number_expected
;
17328 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM
:
17329 text
= _("<short enum>");
17330 expected_types
= bool_expected
;
17334 if (ISPRINT (* name
))
17336 int len
= strnlen (name
, pnote
->namesz
- (name
- pnote
->namedata
)) + 1;
17338 if (len
> left
&& ! do_wide
)
17340 printf ("%.*s:", len
, name
);
17346 static char tmpbuf
[128];
17348 error (_("unrecognised byte in name field: %d\n"), * name
);
17349 sprintf (tmpbuf
, _("<unknown:_%d>"), * name
);
17353 expected_types
= "*$!+";
17358 left
-= printf ("%s", text
);
17360 if (strchr (expected_types
, name_type
) == NULL
)
17361 warn (_("attribute does not have an expected type (%c)\n"), name_type
);
17363 if ((unsigned long)(name
- pnote
->namedata
) > pnote
->namesz
)
17365 error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
17366 (unsigned long) pnote
->namesz
,
17367 (long) (name
- pnote
->namedata
));
17371 if (left
< 1 && ! do_wide
)
17376 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
17378 unsigned int bytes
;
17379 unsigned long long val
= 0;
17380 unsigned int shift
= 0;
17381 char * decoded
= NULL
;
17383 bytes
= pnote
->namesz
- (name
- pnote
->namedata
);
17385 /* The -1 is because the name field is always 0 terminated, and we
17386 want to be able to ensure that the shift in the while loop below
17387 will not overflow. */
17390 if (bytes
> sizeof (val
))
17392 fprintf (stderr
, "namesz %lx name %p namedata %p\n",
17393 pnote
->namesz
, name
, pnote
->namedata
);
17394 error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
17396 bytes
= sizeof (val
);
17398 /* We do not bother to warn if bytes == 0 as this can
17399 happen with some early versions of the gcc plugin. */
17403 unsigned long byte
= (* name
++) & 0xff;
17405 val
|= byte
<< shift
;
17409 switch (name_attribute
)
17411 case GNU_BUILD_ATTRIBUTE_PIC
:
17414 case 0: decoded
= "static"; break;
17415 case 1: decoded
= "pic"; break;
17416 case 2: decoded
= "PIC"; break;
17417 case 3: decoded
= "pie"; break;
17418 case 4: decoded
= "PIE"; break;
17422 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
17425 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
17426 case 0: decoded
= "off"; break;
17427 case 1: decoded
= "on"; break;
17428 case 2: decoded
= "all"; break;
17429 case 3: decoded
= "strong"; break;
17430 case 4: decoded
= "explicit"; break;
17438 if (decoded
!= NULL
)
17440 print_symbol (-left
, decoded
);
17451 left
-= printf ("0x%llx", val
);
17453 left
-= printf ("0x%-.*llx", left
, val
);
17457 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
17458 left
-= print_symbol (- left
, name
);
17460 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
17461 left
-= print_symbol (- left
, "true");
17463 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
17464 left
-= print_symbol (- left
, "false");
17468 if (do_wide
&& left
> 0)
17469 printf ("%-*s", left
, " ");
17474 /* Note that by the ELF standard, the name field is already null byte
17475 terminated, and namesz includes the terminating null byte.
17476 I.E. the value of namesz for the name "FSF" is 4.
17478 If the value of namesz is zero, there is no name present. */
17481 process_note (Elf_Internal_Note
* pnote
,
17484 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
17487 if (pnote
->namesz
== 0)
17488 /* If there is no note name, then use the default set of
17489 note type strings. */
17490 nt
= get_note_type (pnote
->type
);
17492 else if (const_strneq (pnote
->namedata
, "GNU"))
17493 /* GNU-specific object file notes. */
17494 nt
= get_gnu_elf_note_type (pnote
->type
);
17496 else if (const_strneq (pnote
->namedata
, "FreeBSD"))
17497 /* FreeBSD-specific core file notes. */
17498 nt
= get_freebsd_elfcore_note_type (pnote
->type
);
17500 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
17501 /* NetBSD-specific core file notes. */
17502 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
17504 else if (const_strneq (pnote
->namedata
, "NetBSD"))
17505 /* NetBSD-specific core file notes. */
17506 return process_netbsd_elf_note (pnote
);
17508 else if (strneq (pnote
->namedata
, "SPU/", 4))
17510 /* SPU-specific core file notes. */
17511 nt
= pnote
->namedata
+ 4;
17515 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
17516 /* VMS/ia64-specific file notes. */
17517 nt
= get_ia64_vms_note_type (pnote
->type
);
17519 else if (const_strneq (pnote
->namedata
, "stapsdt"))
17520 nt
= get_stapsdt_note_type (pnote
->type
);
17523 /* Don't recognize this note name; just use the default set of
17524 note type strings. */
17525 nt
= get_note_type (pnote
->type
);
17529 if (((const_strneq (pnote
->namedata
, "GA")
17530 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
17531 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
17532 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
17533 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
17534 print_gnu_build_attribute_name (pnote
);
17536 print_symbol (-20, name
);
17539 printf (" 0x%08lx\t%s\t", pnote
->descsz
, nt
);
17541 printf (" 0x%08lx\t%s\n", pnote
->descsz
, nt
);
17543 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
17544 return print_ia64_vms_note (pnote
);
17545 else if (const_strneq (pnote
->namedata
, "GNU"))
17546 return print_gnu_note (pnote
);
17547 else if (const_strneq (pnote
->namedata
, "stapsdt"))
17548 return print_stapsdt_note (pnote
);
17549 else if (const_strneq (pnote
->namedata
, "CORE"))
17550 return print_core_note (pnote
);
17551 else if (((const_strneq (pnote
->namedata
, "GA")
17552 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
17553 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
17554 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
17555 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
17556 return print_gnu_build_attribute_description (pnote
, file
);
17562 printf (_(" description data: "));
17563 for (i
= 0; i
< pnote
->descsz
; i
++)
17564 printf ("%02x ", pnote
->descdata
[i
]);
17576 process_notes_at (FILE * file
,
17577 Elf_Internal_Shdr
* section
,
17581 Elf_External_Note
* pnotes
;
17582 Elf_External_Note
* external
;
17584 bfd_boolean res
= TRUE
;
17591 pnotes
= (Elf_External_Note
*) get_section_contents (section
, file
);
17594 if (! apply_relocations (file
, section
, (unsigned char *) pnotes
, length
, NULL
, NULL
))
17599 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
17601 if (pnotes
== NULL
)
17607 printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (section
));
17609 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
17610 (unsigned long) offset
, (unsigned long) length
);
17612 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
17614 end
= (char *) pnotes
+ length
;
17615 while ((char *) external
< end
)
17617 Elf_Internal_Note inote
;
17620 char * temp
= NULL
;
17621 size_t data_remaining
= end
- (char *) external
;
17623 if (!is_ia64_vms ())
17625 /* PR binutils/15191
17626 Make sure that there is enough data to read. */
17627 min_notesz
= offsetof (Elf_External_Note
, name
);
17628 if (data_remaining
< min_notesz
)
17630 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
17631 (int) data_remaining
);
17634 inote
.type
= BYTE_GET (external
->type
);
17635 inote
.namesz
= BYTE_GET (external
->namesz
);
17636 inote
.namedata
= external
->name
;
17637 inote
.descsz
= BYTE_GET (external
->descsz
);
17638 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
17639 /* PR 17531: file: 3443835e. */
17640 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
> end
)
17642 warn (_("Corrupt note: name size is too big: (got: %lx, expected no more than: %lx)\n"),
17643 inote
.namesz
, (long)(end
- inote
.namedata
));
17644 inote
.descdata
= inote
.namedata
;
17648 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
17649 next
= inote
.descdata
+ align_power (inote
.descsz
, 2);
17653 Elf64_External_VMS_Note
*vms_external
;
17655 /* PR binutils/15191
17656 Make sure that there is enough data to read. */
17657 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
17658 if (data_remaining
< min_notesz
)
17660 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
17661 (int) data_remaining
);
17665 vms_external
= (Elf64_External_VMS_Note
*) external
;
17666 inote
.type
= BYTE_GET (vms_external
->type
);
17667 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
17668 inote
.namedata
= vms_external
->name
;
17669 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
17670 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
17671 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
17672 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
17675 if (inote
.descdata
< (char *) external
+ min_notesz
17676 || next
< (char *) external
+ min_notesz
17677 /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
17678 || inote
.namedata
+ inote
.namesz
< inote
.namedata
17679 || inote
.descdata
+ inote
.descsz
< inote
.descdata
17680 || data_remaining
< (size_t)(next
- (char *) external
))
17682 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
17683 (unsigned long) ((char *) external
- (char *) pnotes
));
17684 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
17685 inote
.type
, inote
.namesz
, inote
.descsz
);
17689 external
= (Elf_External_Note
*) next
;
17691 /* Verify that name is null terminated. It appears that at least
17692 one version of Linux (RedHat 6.0) generates corefiles that don't
17693 comply with the ELF spec by failing to include the null byte in
17695 if (inote
.namedata
[inote
.namesz
- 1] != '\0')
17697 temp
= (char *) malloc (inote
.namesz
+ 1);
17700 error (_("Out of memory allocating space for inote name\n"));
17705 memcpy (temp
, inote
.namedata
, inote
.namesz
);
17706 temp
[inote
.namesz
] = 0;
17708 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
17709 inote
.namedata
= temp
;
17712 if (! process_note (& inote
, file
))
17728 process_corefile_note_segments (FILE * file
)
17730 Elf_Internal_Phdr
* segment
;
17732 bfd_boolean res
= TRUE
;
17734 if (! get_program_headers (file
))
17737 for (i
= 0, segment
= program_headers
;
17738 i
< elf_header
.e_phnum
;
17741 if (segment
->p_type
== PT_NOTE
)
17742 if (! process_notes_at (file
, NULL
,
17743 (bfd_vma
) segment
->p_offset
,
17744 (bfd_vma
) segment
->p_filesz
))
17752 process_v850_notes (FILE * file
, bfd_vma offset
, bfd_vma length
)
17754 Elf_External_Note
* pnotes
;
17755 Elf_External_Note
* external
;
17757 bfd_boolean res
= TRUE
;
17762 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
17764 if (pnotes
== NULL
)
17768 end
= (char*) pnotes
+ length
;
17770 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
17771 (unsigned long) offset
, (unsigned long) length
);
17773 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
17775 Elf_External_Note
* next
;
17776 Elf_Internal_Note inote
;
17778 inote
.type
= BYTE_GET (external
->type
);
17779 inote
.namesz
= BYTE_GET (external
->namesz
);
17780 inote
.namedata
= external
->name
;
17781 inote
.descsz
= BYTE_GET (external
->descsz
);
17782 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
17783 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
17785 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
17787 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
17788 inote
.descdata
= inote
.namedata
;
17792 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
17794 if ( ((char *) next
> end
)
17795 || ((char *) next
< (char *) pnotes
))
17797 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
17798 (unsigned long) ((char *) external
- (char *) pnotes
));
17799 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
17800 inote
.type
, inote
.namesz
, inote
.descsz
);
17806 /* Prevent out-of-bounds indexing. */
17807 if ( inote
.namedata
+ inote
.namesz
> end
17808 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
17810 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
17811 (unsigned long) ((char *) external
- (char *) pnotes
));
17812 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
17813 inote
.type
, inote
.namesz
, inote
.descsz
);
17817 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
17819 if (! print_v850_note (& inote
))
17822 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
17823 inote
.namesz
, inote
.descsz
);
17833 process_note_sections (FILE * file
)
17835 Elf_Internal_Shdr
* section
;
17837 unsigned int n
= 0;
17838 bfd_boolean res
= TRUE
;
17840 for (i
= 0, section
= section_headers
;
17841 i
< elf_header
.e_shnum
&& section
!= NULL
;
17844 if (section
->sh_type
== SHT_NOTE
)
17846 if (! process_notes_at (file
, section
,
17847 (bfd_vma
) section
->sh_offset
,
17848 (bfd_vma
) section
->sh_size
))
17853 if (( elf_header
.e_machine
== EM_V800
17854 || elf_header
.e_machine
== EM_V850
17855 || elf_header
.e_machine
== EM_CYGNUS_V850
)
17856 && section
->sh_type
== SHT_RENESAS_INFO
)
17858 if (! process_v850_notes (file
,
17859 (bfd_vma
) section
->sh_offset
,
17860 (bfd_vma
) section
->sh_size
))
17867 /* Try processing NOTE segments instead. */
17868 return process_corefile_note_segments (file
);
17874 process_notes (FILE * file
)
17876 /* If we have not been asked to display the notes then do nothing. */
17880 if (elf_header
.e_type
!= ET_CORE
)
17881 return process_note_sections (file
);
17883 /* No program headers means no NOTE segment. */
17884 if (elf_header
.e_phnum
> 0)
17885 return process_corefile_note_segments (file
);
17887 printf (_("No note segments present in the core file.\n"));
17891 static unsigned char *
17892 display_public_gnu_attributes (unsigned char * start
,
17893 const unsigned char * const end
)
17895 printf (_(" Unknown GNU attribute: %s\n"), start
);
17897 start
+= strnlen ((char *) start
, end
- start
);
17898 display_raw_attribute (start
, end
);
17900 return (unsigned char *) end
;
17903 static unsigned char *
17904 display_generic_attribute (unsigned char * start
,
17906 const unsigned char * const end
)
17909 return (unsigned char *) end
;
17911 return display_tag_value (tag
, start
, end
);
17915 process_arch_specific (FILE * file
)
17920 switch (elf_header
.e_machine
)
17923 case EM_ARC_COMPACT
:
17924 case EM_ARC_COMPACT2
:
17925 return process_attributes (file
, "ARC", SHT_ARC_ATTRIBUTES
,
17926 display_arc_attribute
,
17927 display_generic_attribute
);
17929 return process_attributes (file
, "aeabi", SHT_ARM_ATTRIBUTES
,
17930 display_arm_attribute
,
17931 display_generic_attribute
);
17934 case EM_MIPS_RS3_LE
:
17935 return process_mips_specific (file
);
17938 return process_attributes (file
, "mspabi", SHT_MSP430_ATTRIBUTES
,
17939 display_msp430x_attribute
,
17940 display_generic_attribute
);
17943 return process_nds32_specific (file
);
17947 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
17948 display_power_gnu_attribute
);
17952 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
17953 display_s390_gnu_attribute
);
17956 case EM_SPARC32PLUS
:
17958 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
17959 display_sparc_gnu_attribute
);
17962 return process_attributes (file
, "c6xabi", SHT_C6000_ATTRIBUTES
,
17963 display_tic6x_attribute
,
17964 display_generic_attribute
);
17967 return process_attributes (file
, "gnu", SHT_GNU_ATTRIBUTES
,
17968 display_public_gnu_attributes
,
17969 display_generic_attribute
);
17974 get_file_header (FILE * file
)
17976 /* Read in the identity array. */
17977 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
17980 /* Determine how to read the rest of the header. */
17981 switch (elf_header
.e_ident
[EI_DATA
])
17986 byte_get
= byte_get_little_endian
;
17987 byte_put
= byte_put_little_endian
;
17990 byte_get
= byte_get_big_endian
;
17991 byte_put
= byte_put_big_endian
;
17995 /* For now we only support 32 bit and 64 bit ELF files. */
17996 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
17998 /* Read in the rest of the header. */
18001 Elf32_External_Ehdr ehdr32
;
18003 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
18006 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
18007 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
18008 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
18009 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
18010 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
18011 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
18012 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
18013 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
18014 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
18015 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
18016 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
18017 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
18018 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
18022 Elf64_External_Ehdr ehdr64
;
18024 /* If we have been compiled with sizeof (bfd_vma) == 4, then
18025 we will not be able to cope with the 64bit data found in
18026 64 ELF files. Detect this now and abort before we start
18027 overwriting things. */
18028 if (sizeof (bfd_vma
) < 8)
18030 error (_("This instance of readelf has been built without support for a\n\
18031 64 bit data type and so it cannot read 64 bit ELF files.\n"));
18035 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
18038 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
18039 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
18040 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
18041 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
18042 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
18043 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
18044 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
18045 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
18046 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
18047 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
18048 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
18049 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
18050 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
18053 if (elf_header
.e_shoff
)
18055 /* There may be some extensions in the first section header. Don't
18056 bomb if we can't read it. */
18058 get_32bit_section_headers (file
, TRUE
);
18060 get_64bit_section_headers (file
, TRUE
);
18066 /* Process one ELF object file according to the command line options.
18067 This file may actually be stored in an archive. The file is
18068 positioned at the start of the ELF object. Returns TRUE if no
18069 problems were encountered, FALSE otherwise. */
18072 process_object (char * file_name
, FILE * file
)
18075 bfd_boolean res
= TRUE
;
18077 if (! get_file_header (file
))
18079 error (_("%s: Failed to read file header\n"), file_name
);
18083 /* Initialise per file variables. */
18084 for (i
= ARRAY_SIZE (version_info
); i
--;)
18085 version_info
[i
] = 0;
18087 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
18088 dynamic_info
[i
] = 0;
18089 dynamic_info_DT_GNU_HASH
= 0;
18091 /* Process the file. */
18093 printf (_("\nFile: %s\n"), file_name
);
18095 /* Initialise the dump_sects array from the cmdline_dump_sects array.
18096 Note we do this even if cmdline_dump_sects is empty because we
18097 must make sure that the dump_sets array is zeroed out before each
18098 object file is processed. */
18099 if (num_dump_sects
> num_cmdline_dump_sects
)
18100 memset (dump_sects
, 0, num_dump_sects
* sizeof (* dump_sects
));
18102 if (num_cmdline_dump_sects
> 0)
18104 if (num_dump_sects
== 0)
18105 /* A sneaky way of allocating the dump_sects array. */
18106 request_dump_bynumber (num_cmdline_dump_sects
, 0);
18108 assert (num_dump_sects
>= num_cmdline_dump_sects
);
18109 memcpy (dump_sects
, cmdline_dump_sects
,
18110 num_cmdline_dump_sects
* sizeof (* dump_sects
));
18113 if (! process_file_header ())
18116 if (! process_section_headers (file
))
18118 /* Without loaded section headers we cannot process lots of things. */
18119 do_unwind
= do_version
= do_dump
= do_arch
= FALSE
;
18121 if (! do_using_dynamic
)
18122 do_syms
= do_dyn_syms
= do_reloc
= FALSE
;
18125 if (! process_section_groups (file
))
18126 /* Without loaded section groups we cannot process unwind. */
18129 if (process_program_headers (file
))
18130 process_dynamic_section (file
);
18134 if (! process_relocs (file
))
18137 if (! process_unwind (file
))
18140 if (! process_symbol_table (file
))
18143 if (! process_syminfo (file
))
18146 if (! process_version_sections (file
))
18149 if (! process_section_contents (file
))
18152 if (! process_notes (file
))
18155 if (! process_gnu_liblist (file
))
18158 if (! process_arch_specific (file
))
18161 if (program_headers
)
18163 free (program_headers
);
18164 program_headers
= NULL
;
18167 if (section_headers
)
18169 free (section_headers
);
18170 section_headers
= NULL
;
18175 free (string_table
);
18176 string_table
= NULL
;
18177 string_table_length
= 0;
18180 if (dynamic_strings
)
18182 free (dynamic_strings
);
18183 dynamic_strings
= NULL
;
18184 dynamic_strings_length
= 0;
18187 if (dynamic_symbols
)
18189 free (dynamic_symbols
);
18190 dynamic_symbols
= NULL
;
18191 num_dynamic_syms
= 0;
18194 if (dynamic_syminfo
)
18196 free (dynamic_syminfo
);
18197 dynamic_syminfo
= NULL
;
18200 if (dynamic_section
)
18202 free (dynamic_section
);
18203 dynamic_section
= NULL
;
18206 if (section_headers_groups
)
18208 free (section_headers_groups
);
18209 section_headers_groups
= NULL
;
18212 if (section_groups
)
18214 struct group_list
* g
;
18215 struct group_list
* next
;
18217 for (i
= 0; i
< group_count
; i
++)
18219 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
18226 free (section_groups
);
18227 section_groups
= NULL
;
18230 free_debug_memory ();
18235 /* Process an ELF archive.
18236 On entry the file is positioned just after the ARMAG string.
18237 Returns TRUE upon success, FALSE otherwise. */
18240 process_archive (char * file_name
, FILE * file
, bfd_boolean is_thin_archive
)
18242 struct archive_info arch
;
18243 struct archive_info nested_arch
;
18245 bfd_boolean ret
= TRUE
;
18249 /* The ARCH structure is used to hold information about this archive. */
18250 arch
.file_name
= NULL
;
18252 arch
.index_array
= NULL
;
18253 arch
.sym_table
= NULL
;
18254 arch
.longnames
= NULL
;
18256 /* The NESTED_ARCH structure is used as a single-item cache of information
18257 about a nested archive (when members of a thin archive reside within
18258 another regular archive file). */
18259 nested_arch
.file_name
= NULL
;
18260 nested_arch
.file
= NULL
;
18261 nested_arch
.index_array
= NULL
;
18262 nested_arch
.sym_table
= NULL
;
18263 nested_arch
.longnames
= NULL
;
18265 if (setup_archive (&arch
, file_name
, file
, is_thin_archive
, do_archive_index
) != 0)
18271 if (do_archive_index
)
18273 if (arch
.sym_table
== NULL
)
18274 error (_("%s: unable to dump the index as none was found\n"), file_name
);
18277 unsigned long i
, l
;
18278 unsigned long current_pos
;
18280 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
18281 file_name
, (unsigned long) arch
.index_num
, arch
.sym_size
);
18282 current_pos
= ftell (file
);
18284 for (i
= l
= 0; i
< arch
.index_num
; i
++)
18286 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
18288 char * member_name
;
18290 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
18292 if (member_name
!= NULL
)
18294 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
18296 if (qualified_name
!= NULL
)
18298 printf (_("Contents of binary %s at offset "), qualified_name
);
18299 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
18301 free (qualified_name
);
18306 if (l
>= arch
.sym_size
)
18308 error (_("%s: end of the symbol table reached before the end of the index\n"),
18313 /* PR 17531: file: 0b6630b2. */
18314 printf ("\t%.*s\n", (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
18315 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
18318 if (arch
.uses_64bit_indicies
)
18323 if (l
< arch
.sym_size
)
18325 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
18326 file_name
, arch
.sym_size
- l
);
18330 if (fseek (file
, current_pos
, SEEK_SET
) != 0)
18332 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name
);
18338 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
18339 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
18340 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
18341 && !do_section_groups
&& !do_dyn_syms
)
18343 ret
= TRUE
; /* Archive index only. */
18352 char * qualified_name
;
18354 /* Read the next archive header. */
18355 if (fseek (file
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
18357 error (_("%s: failed to seek to next archive header\n"), file_name
);
18360 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, file
);
18361 if (got
!= sizeof arch
.arhdr
)
18365 error (_("%s: failed to read archive header\n"), file_name
);
18369 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
18371 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
18376 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
18378 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
18379 if (archive_file_size
& 01)
18380 ++archive_file_size
;
18382 name
= get_archive_member_name (&arch
, &nested_arch
);
18385 error (_("%s: bad archive file name\n"), file_name
);
18389 namelen
= strlen (name
);
18391 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
18392 if (qualified_name
== NULL
)
18394 error (_("%s: bad archive file name\n"), file_name
);
18399 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
18401 /* This is a proxy for an external member of a thin archive. */
18402 FILE * member_file
;
18403 char * member_file_name
= adjust_relative_path (file_name
, name
, namelen
);
18405 if (member_file_name
== NULL
)
18411 member_file
= fopen (member_file_name
, "rb");
18412 if (member_file
== NULL
)
18414 error (_("Input file '%s' is not readable.\n"), member_file_name
);
18415 free (member_file_name
);
18420 archive_file_offset
= arch
.nested_member_origin
;
18422 if (! process_object (qualified_name
, member_file
))
18425 fclose (member_file
);
18426 free (member_file_name
);
18428 else if (is_thin_archive
)
18430 /* PR 15140: Allow for corrupt thin archives. */
18431 if (nested_arch
.file
== NULL
)
18433 error (_("%s: contains corrupt thin archive: %s\n"),
18439 /* This is a proxy for a member of a nested archive. */
18440 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
18442 /* The nested archive file will have been opened and setup by
18443 get_archive_member_name. */
18444 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
18446 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
18451 if (! process_object (qualified_name
, nested_arch
.file
))
18456 archive_file_offset
= arch
.next_arhdr_offset
;
18457 arch
.next_arhdr_offset
+= archive_file_size
;
18459 if (! process_object (qualified_name
, file
))
18463 if (dump_sects
!= NULL
)
18467 num_dump_sects
= 0;
18470 free (qualified_name
);
18474 if (nested_arch
.file
!= NULL
)
18475 fclose (nested_arch
.file
);
18476 release_archive (&nested_arch
);
18477 release_archive (&arch
);
18483 process_file (char * file_name
)
18486 struct stat statbuf
;
18487 char armag
[SARMAG
];
18488 bfd_boolean ret
= TRUE
;
18490 if (stat (file_name
, &statbuf
) < 0)
18492 if (errno
== ENOENT
)
18493 error (_("'%s': No such file\n"), file_name
);
18495 error (_("Could not locate '%s'. System error message: %s\n"),
18496 file_name
, strerror (errno
));
18500 if (! S_ISREG (statbuf
.st_mode
))
18502 error (_("'%s' is not an ordinary file\n"), file_name
);
18506 file
= fopen (file_name
, "rb");
18509 error (_("Input file '%s' is not readable.\n"), file_name
);
18513 if (fread (armag
, SARMAG
, 1, file
) != 1)
18515 error (_("%s: Failed to read file's magic number\n"), file_name
);
18520 current_file_size
= (bfd_size_type
) statbuf
.st_size
;
18522 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
18524 if (! process_archive (file_name
, file
, FALSE
))
18527 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
18529 if ( ! process_archive (file_name
, file
, TRUE
))
18534 if (do_archive_index
)
18535 error (_("File %s is not an archive so its index cannot be displayed.\n"),
18539 archive_file_size
= archive_file_offset
= 0;
18541 if (! process_object (file_name
, file
))
18546 current_file_size
= 0;
18551 #ifdef SUPPORT_DISASSEMBLY
18552 /* Needed by the i386 disassembler. For extra credit, someone could
18553 fix this so that we insert symbolic addresses here, esp for GOT/PLT
18557 print_address (unsigned int addr
, FILE * outfile
)
18559 fprintf (outfile
,"0x%8.8x", addr
);
18562 /* Needed by the i386 disassembler. */
18564 db_task_printsym (unsigned int addr
)
18566 print_address (addr
, stderr
);
18571 main (int argc
, char ** argv
)
18575 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
18576 setlocale (LC_MESSAGES
, "");
18578 #if defined (HAVE_SETLOCALE)
18579 setlocale (LC_CTYPE
, "");
18581 bindtextdomain (PACKAGE
, LOCALEDIR
);
18582 textdomain (PACKAGE
);
18584 expandargv (&argc
, &argv
);
18586 parse_args (argc
, argv
);
18588 if (num_dump_sects
> 0)
18590 /* Make a copy of the dump_sects array. */
18591 cmdline_dump_sects
= (dump_type
*)
18592 malloc (num_dump_sects
* sizeof (* dump_sects
));
18593 if (cmdline_dump_sects
== NULL
)
18594 error (_("Out of memory allocating dump request table.\n"));
18597 memcpy (cmdline_dump_sects
, dump_sects
,
18598 num_dump_sects
* sizeof (* dump_sects
));
18599 num_cmdline_dump_sects
= num_dump_sects
;
18603 if (optind
< (argc
- 1))
18605 else if (optind
>= argc
)
18607 warn (_("Nothing to do.\n"));
18612 while (optind
< argc
)
18613 if (! process_file (argv
[optind
++]))
18616 if (dump_sects
!= NULL
)
18618 if (cmdline_dump_sects
!= NULL
)
18619 free (cmdline_dump_sects
);
18621 return err
? EXIT_FAILURE
: EXIT_SUCCESS
;