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 /* Print a BFD_VMA to an internal buffer, for use in error messages.
325 BFD_FMA_FMT can't be used in translated strings. */
328 bfd_vmatoa (char *fmtch
, bfd_vma value
)
330 /* bfd_vmatoa is used more then once in a printf call for output.
331 Cycle through an array of buffers. */
332 static int buf_pos
= 0;
333 static struct bfd_vmatoa_buf
340 ret
= buf
[buf_pos
++].place
;
341 buf_pos
%= ARRAY_SIZE (buf
);
343 sprintf (fmt
, "%%%s%s", BFD_VMA_FMT
, fmtch
);
344 snprintf (ret
, sizeof (buf
[0].place
), fmt
, value
);
348 /* Retrieve NMEMB structures, each SIZE bytes long from FILE starting at OFFSET +
349 the offset of the current archive member, if we are examining an archive.
350 Put the retrieved data into VAR, if it is not NULL. Otherwise allocate a buffer
351 using malloc and fill that. In either case return the pointer to the start of
352 the retrieved data or NULL if something went wrong. If something does go wrong
353 and REASON is not NULL then emit an error message using REASON as part of the
357 get_data (void * var
, FILE * file
, unsigned long offset
, bfd_size_type size
,
358 bfd_size_type nmemb
, const char * reason
)
361 bfd_size_type amt
= size
* nmemb
;
363 if (size
== 0 || nmemb
== 0)
366 /* If the size_t type is smaller than the bfd_size_type, eg because
367 you are building a 32-bit tool on a 64-bit host, then make sure
368 that when the sizes are cast to (size_t) no information is lost. */
369 if (sizeof (size_t) < sizeof (bfd_size_type
)
370 && ( (bfd_size_type
) ((size_t) size
) != size
371 || (bfd_size_type
) ((size_t) nmemb
) != nmemb
))
374 error (_("Size truncation prevents reading %s"
375 " elements of size %s for %s\n"),
376 bfd_vmatoa ("u", nmemb
), bfd_vmatoa ("u", size
), reason
);
380 /* Check for size overflow. */
384 error (_("Size overflow prevents reading %s"
385 " elements of size %s for %s\n"),
386 bfd_vmatoa ("u", nmemb
), bfd_vmatoa ("u", size
), reason
);
390 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
391 attempting to allocate memory when the read is bound to fail. */
392 if (amt
> current_file_size
393 || offset
+ archive_file_offset
+ amt
> current_file_size
)
396 error (_("Reading %s bytes extends past end of file for %s\n"),
397 bfd_vmatoa ("u", amt
), reason
);
401 if (fseek (file
, archive_file_offset
+ offset
, SEEK_SET
))
404 error (_("Unable to seek to 0x%lx for %s\n"),
405 archive_file_offset
+ offset
, reason
);
412 /* Check for overflow. */
413 if (nmemb
< (~(bfd_size_type
) 0 - 1) / size
)
414 /* + 1 so that we can '\0' terminate invalid string table sections. */
415 mvar
= malloc ((size_t) amt
+ 1);
420 error (_("Out of memory allocating %s bytes for %s\n"),
421 bfd_vmatoa ("u", amt
), reason
);
425 ((char *) mvar
)[amt
] = '\0';
428 if (fread (mvar
, (size_t) size
, (size_t) nmemb
, file
) != nmemb
)
431 error (_("Unable to read in %s bytes of %s\n"),
432 bfd_vmatoa ("u", amt
), reason
);
441 /* Print a VMA value in the MODE specified.
442 Returns the number of characters displayed. */
445 print_vma (bfd_vma vma
, print_mode mode
)
457 return nc
+ printf ("%8.8" BFD_VMA_FMT
"x", vma
);
464 return printf ("%5" BFD_VMA_FMT
"d", vma
);
470 return nc
+ printf ("%" BFD_VMA_FMT
"x", vma
);
473 return printf ("%" BFD_VMA_FMT
"d", vma
);
476 return printf ("%" BFD_VMA_FMT
"u", vma
);
479 /* FIXME: Report unrecognised mode ? */
484 /* Display a symbol on stdout. Handles the display of control characters and
485 multibye characters (assuming the host environment supports them).
487 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
489 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
490 padding as necessary.
492 Returns the number of emitted characters. */
495 print_symbol (signed int width
, const char *symbol
)
497 bfd_boolean extra_padding
= FALSE
;
498 signed int num_printed
= 0;
499 #ifdef HAVE_MBSTATE_T
502 unsigned int width_remaining
;
506 /* Keep the width positive. This helps the code below. */
508 extra_padding
= TRUE
;
513 /* Set the remaining width to a very large value.
514 This simplifies the code below. */
515 width_remaining
= INT_MAX
;
517 width_remaining
= width
;
519 #ifdef HAVE_MBSTATE_T
520 /* Initialise the multibyte conversion state. */
521 memset (& state
, 0, sizeof (state
));
524 while (width_remaining
)
527 const char c
= *symbol
++;
532 /* Do not print control characters directly as they can affect terminal
533 settings. Such characters usually appear in the names generated
534 by the assembler for local labels. */
537 if (width_remaining
< 2)
540 printf ("^%c", c
+ 0x40);
541 width_remaining
-= 2;
544 else if (ISPRINT (c
))
552 #ifdef HAVE_MBSTATE_T
555 /* Let printf do the hard work of displaying multibyte characters. */
556 printf ("%.1s", symbol
- 1);
560 #ifdef HAVE_MBSTATE_T
561 /* Try to find out how many bytes made up the character that was
562 just printed. Advance the symbol pointer past the bytes that
564 n
= mbrtowc (& w
, symbol
- 1, MB_CUR_MAX
, & state
);
568 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
573 if (extra_padding
&& num_printed
< width
)
575 /* Fill in the remaining spaces. */
576 printf ("%-*s", width
- num_printed
, " ");
583 /* Returns a pointer to a static buffer containing a printable version of
584 the given section's name. Like print_symbol, except that it does not try
585 to print multibyte characters, it just interprets them as hex values. */
588 printable_section_name (const Elf_Internal_Shdr
* sec
)
590 #define MAX_PRINT_SEC_NAME_LEN 128
591 static char sec_name_buf
[MAX_PRINT_SEC_NAME_LEN
+ 1];
592 const char * name
= SECTION_NAME (sec
);
593 char * buf
= sec_name_buf
;
595 unsigned int remaining
= MAX_PRINT_SEC_NAME_LEN
;
597 while ((c
= * name
++) != 0)
608 else if (ISPRINT (c
))
615 static char hex
[17] = "0123456789ABCDEF";
620 * buf
++ = hex
[(c
& 0xf0) >> 4];
621 * buf
++ = hex
[c
& 0x0f];
635 printable_section_name_from_index (unsigned long ndx
)
637 if (ndx
>= elf_header
.e_shnum
)
638 return _("<corrupt>");
640 return printable_section_name (section_headers
+ ndx
);
643 /* Return a pointer to section NAME, or NULL if no such section exists. */
645 static Elf_Internal_Shdr
*
646 find_section (const char * name
)
650 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
651 if (streq (SECTION_NAME (section_headers
+ i
), name
))
652 return section_headers
+ i
;
657 /* Return a pointer to a section containing ADDR, or NULL if no such
660 static Elf_Internal_Shdr
*
661 find_section_by_address (bfd_vma addr
)
665 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
667 Elf_Internal_Shdr
*sec
= section_headers
+ i
;
668 if (addr
>= sec
->sh_addr
&& addr
< sec
->sh_addr
+ sec
->sh_size
)
675 static Elf_Internal_Shdr
*
676 find_section_by_type (unsigned int type
)
680 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
682 Elf_Internal_Shdr
*sec
= section_headers
+ i
;
683 if (sec
->sh_type
== type
)
690 /* Return a pointer to section NAME, or NULL if no such section exists,
691 restricted to the list of sections given in SET. */
693 static Elf_Internal_Shdr
*
694 find_section_in_set (const char * name
, unsigned int * set
)
700 while ((i
= *set
++) > 0)
702 /* See PR 21156 for a reproducer. */
703 if (i
>= elf_header
.e_shnum
)
704 continue; /* FIXME: Should we issue an error message ? */
706 if (streq (SECTION_NAME (section_headers
+ i
), name
))
707 return section_headers
+ i
;
711 return find_section (name
);
714 /* Read an unsigned LEB128 encoded value from DATA.
715 Set *LENGTH_RETURN to the number of bytes read. */
717 static inline unsigned long
718 read_uleb128 (unsigned char * data
,
719 unsigned int * length_return
,
720 const unsigned char * const end
)
722 return read_leb128 (data
, length_return
, FALSE
, end
);
725 /* Return TRUE if the current file is for IA-64 machine and OpenVMS ABI.
726 This OS has so many departures from the ELF standard that we test it at
729 static inline bfd_boolean
732 return elf_header
.e_machine
== EM_IA_64
733 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
;
736 /* Guess the relocation size commonly used by the specific machines. */
739 guess_is_rela (unsigned int e_machine
)
743 /* Targets that use REL relocations. */
758 /* Targets that use RELA relocations. */
762 case EM_ADAPTEVA_EPIPHANY
:
764 case EM_ALTERA_NIOS2
:
767 case EM_ARC_COMPACT2
:
787 case EM_LATTICEMICO32
:
796 case EM_CYGNUS_MN10200
:
798 case EM_CYGNUS_MN10300
:
834 case EM_MICROBLAZE_OLD
:
856 warn (_("Don't know about relocations on this machine architecture\n"));
861 /* Load RELA type relocations from FILE at REL_OFFSET extending for REL_SIZE bytes.
862 Returns TRUE upon success, FALSE otherwise. If successful then a
863 pointer to a malloc'ed buffer containing the relocs is placed in *RELASP,
864 and the number of relocs loaded is placed in *NRELASP. It is the caller's
865 responsibility to free the allocated buffer. */
868 slurp_rela_relocs (FILE * file
,
869 unsigned long rel_offset
,
870 unsigned long rel_size
,
871 Elf_Internal_Rela
** relasp
,
872 unsigned long * nrelasp
)
874 Elf_Internal_Rela
* relas
;
880 Elf32_External_Rela
* erelas
;
882 erelas
= (Elf32_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
883 rel_size
, _("32-bit relocation data"));
887 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
889 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
890 sizeof (Elf_Internal_Rela
));
895 error (_("out of memory parsing relocs\n"));
899 for (i
= 0; i
< nrelas
; i
++)
901 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
902 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
903 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
910 Elf64_External_Rela
* erelas
;
912 erelas
= (Elf64_External_Rela
*) get_data (NULL
, file
, rel_offset
, 1,
913 rel_size
, _("64-bit relocation data"));
917 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
919 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
920 sizeof (Elf_Internal_Rela
));
925 error (_("out of memory parsing relocs\n"));
929 for (i
= 0; i
< nrelas
; i
++)
931 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
932 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
933 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
935 /* The #ifdef BFD64 below is to prevent a compile time
936 warning. We know that if we do not have a 64 bit data
937 type that we will never execute this code anyway. */
939 if (elf_header
.e_machine
== EM_MIPS
940 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
942 /* In little-endian objects, r_info isn't really a
943 64-bit little-endian value: it has a 32-bit
944 little-endian symbol index followed by four
945 individual byte fields. Reorder INFO
947 bfd_vma inf
= relas
[i
].r_info
;
948 inf
= (((inf
& 0xffffffff) << 32)
949 | ((inf
>> 56) & 0xff)
950 | ((inf
>> 40) & 0xff00)
951 | ((inf
>> 24) & 0xff0000)
952 | ((inf
>> 8) & 0xff000000));
953 relas
[i
].r_info
= inf
;
966 /* Load REL type relocations from FILE at REL_OFFSET extending for REL_SIZE bytes.
967 Returns TRUE upon success, FALSE otherwise. If successful then a
968 pointer to a malloc'ed buffer containing the relocs is placed in *RELSP,
969 and the number of relocs loaded is placed in *NRELSP. It is the caller's
970 responsibility to free the allocated buffer. */
973 slurp_rel_relocs (FILE * file
,
974 unsigned long rel_offset
,
975 unsigned long rel_size
,
976 Elf_Internal_Rela
** relsp
,
977 unsigned long * nrelsp
)
979 Elf_Internal_Rela
* rels
;
985 Elf32_External_Rel
* erels
;
987 erels
= (Elf32_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
988 rel_size
, _("32-bit relocation data"));
992 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
994 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
999 error (_("out of memory parsing relocs\n"));
1003 for (i
= 0; i
< nrels
; i
++)
1005 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
1006 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
1007 rels
[i
].r_addend
= 0;
1014 Elf64_External_Rel
* erels
;
1016 erels
= (Elf64_External_Rel
*) get_data (NULL
, file
, rel_offset
, 1,
1017 rel_size
, _("64-bit relocation data"));
1021 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
1023 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
1028 error (_("out of memory parsing relocs\n"));
1032 for (i
= 0; i
< nrels
; i
++)
1034 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
1035 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
1036 rels
[i
].r_addend
= 0;
1038 /* The #ifdef BFD64 below is to prevent a compile time
1039 warning. We know that if we do not have a 64 bit data
1040 type that we will never execute this code anyway. */
1042 if (elf_header
.e_machine
== EM_MIPS
1043 && elf_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
1045 /* In little-endian objects, r_info isn't really a
1046 64-bit little-endian value: it has a 32-bit
1047 little-endian symbol index followed by four
1048 individual byte fields. Reorder INFO
1050 bfd_vma inf
= rels
[i
].r_info
;
1051 inf
= (((inf
& 0xffffffff) << 32)
1052 | ((inf
>> 56) & 0xff)
1053 | ((inf
>> 40) & 0xff00)
1054 | ((inf
>> 24) & 0xff0000)
1055 | ((inf
>> 8) & 0xff000000));
1056 rels
[i
].r_info
= inf
;
1069 /* Returns the reloc type extracted from the reloc info field. */
1072 get_reloc_type (bfd_vma reloc_info
)
1075 return ELF32_R_TYPE (reloc_info
);
1077 switch (elf_header
.e_machine
)
1080 /* Note: We assume that reloc_info has already been adjusted for us. */
1081 return ELF64_MIPS_R_TYPE (reloc_info
);
1084 return ELF64_R_TYPE_ID (reloc_info
);
1087 return ELF64_R_TYPE (reloc_info
);
1091 /* Return the symbol index extracted from the reloc info field. */
1094 get_reloc_symindex (bfd_vma reloc_info
)
1096 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
1099 static inline bfd_boolean
1100 uses_msp430x_relocs (void)
1103 elf_header
.e_machine
== EM_MSP430
/* Paranoia. */
1104 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1105 && (((elf_header
.e_flags
& EF_MSP430_MACH
) == E_MSP430_MACH_MSP430X
)
1106 /* TI compiler uses ELFOSABI_NONE. */
1107 || (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
));
1110 /* Display the contents of the relocation data found at the specified
1114 dump_relocations (FILE * file
,
1115 unsigned long rel_offset
,
1116 unsigned long rel_size
,
1117 Elf_Internal_Sym
* symtab
,
1118 unsigned long nsyms
,
1120 unsigned long strtablen
,
1122 bfd_boolean is_dynsym
)
1125 Elf_Internal_Rela
* rels
;
1126 bfd_boolean res
= TRUE
;
1128 if (is_rela
== UNKNOWN
)
1129 is_rela
= guess_is_rela (elf_header
.e_machine
);
1133 if (!slurp_rela_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
1138 if (!slurp_rel_relocs (file
, rel_offset
, rel_size
, &rels
, &rel_size
))
1147 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1149 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1154 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1156 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1164 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
1166 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1171 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
1173 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1177 for (i
= 0; i
< rel_size
; i
++)
1182 bfd_vma symtab_index
;
1185 offset
= rels
[i
].r_offset
;
1186 inf
= rels
[i
].r_info
;
1188 type
= get_reloc_type (inf
);
1189 symtab_index
= get_reloc_symindex (inf
);
1193 printf ("%8.8lx %8.8lx ",
1194 (unsigned long) offset
& 0xffffffff,
1195 (unsigned long) inf
& 0xffffffff);
1199 #if BFD_HOST_64BIT_LONG
1201 ? "%16.16lx %16.16lx "
1202 : "%12.12lx %12.12lx ",
1204 #elif BFD_HOST_64BIT_LONG_LONG
1207 ? "%16.16llx %16.16llx "
1208 : "%12.12llx %12.12llx ",
1212 ? "%16.16I64x %16.16I64x "
1213 : "%12.12I64x %12.12I64x ",
1218 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1219 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1220 _bfd_int64_high (offset
),
1221 _bfd_int64_low (offset
),
1222 _bfd_int64_high (inf
),
1223 _bfd_int64_low (inf
));
1227 switch (elf_header
.e_machine
)
1234 rtype
= elf_aarch64_reloc_type (type
);
1238 case EM_CYGNUS_M32R
:
1239 rtype
= elf_m32r_reloc_type (type
);
1244 rtype
= elf_i386_reloc_type (type
);
1249 rtype
= elf_m68hc11_reloc_type (type
);
1253 rtype
= elf_m68k_reloc_type (type
);
1257 rtype
= elf_i960_reloc_type (type
);
1262 rtype
= elf_avr_reloc_type (type
);
1265 case EM_OLD_SPARCV9
:
1266 case EM_SPARC32PLUS
:
1269 rtype
= elf_sparc_reloc_type (type
);
1273 rtype
= elf_spu_reloc_type (type
);
1277 rtype
= v800_reloc_type (type
);
1280 case EM_CYGNUS_V850
:
1281 rtype
= v850_reloc_type (type
);
1285 case EM_CYGNUS_D10V
:
1286 rtype
= elf_d10v_reloc_type (type
);
1290 case EM_CYGNUS_D30V
:
1291 rtype
= elf_d30v_reloc_type (type
);
1295 rtype
= elf_dlx_reloc_type (type
);
1299 rtype
= elf_sh_reloc_type (type
);
1303 case EM_CYGNUS_MN10300
:
1304 rtype
= elf_mn10300_reloc_type (type
);
1308 case EM_CYGNUS_MN10200
:
1309 rtype
= elf_mn10200_reloc_type (type
);
1313 case EM_CYGNUS_FR30
:
1314 rtype
= elf_fr30_reloc_type (type
);
1318 rtype
= elf_frv_reloc_type (type
);
1322 rtype
= elf_ft32_reloc_type (type
);
1326 rtype
= elf_mcore_reloc_type (type
);
1330 rtype
= elf_mmix_reloc_type (type
);
1334 rtype
= elf_moxie_reloc_type (type
);
1338 if (uses_msp430x_relocs ())
1340 rtype
= elf_msp430x_reloc_type (type
);
1345 rtype
= elf_msp430_reloc_type (type
);
1349 rtype
= elf_nds32_reloc_type (type
);
1353 rtype
= elf_ppc_reloc_type (type
);
1357 rtype
= elf_ppc64_reloc_type (type
);
1361 case EM_MIPS_RS3_LE
:
1362 rtype
= elf_mips_reloc_type (type
);
1366 rtype
= elf_riscv_reloc_type (type
);
1370 rtype
= elf_alpha_reloc_type (type
);
1374 rtype
= elf_arm_reloc_type (type
);
1378 case EM_ARC_COMPACT
:
1379 case EM_ARC_COMPACT2
:
1380 rtype
= elf_arc_reloc_type (type
);
1384 rtype
= elf_hppa_reloc_type (type
);
1390 rtype
= elf_h8_reloc_type (type
);
1394 rtype
= elf_or1k_reloc_type (type
);
1399 rtype
= elf_pj_reloc_type (type
);
1402 rtype
= elf_ia64_reloc_type (type
);
1406 rtype
= elf_cris_reloc_type (type
);
1410 rtype
= elf_i860_reloc_type (type
);
1416 rtype
= elf_x86_64_reloc_type (type
);
1420 rtype
= i370_reloc_type (type
);
1425 rtype
= elf_s390_reloc_type (type
);
1429 rtype
= elf_score_reloc_type (type
);
1433 rtype
= elf_xstormy16_reloc_type (type
);
1437 rtype
= elf_crx_reloc_type (type
);
1441 rtype
= elf_vax_reloc_type (type
);
1445 rtype
= elf_visium_reloc_type (type
);
1448 case EM_ADAPTEVA_EPIPHANY
:
1449 rtype
= elf_epiphany_reloc_type (type
);
1454 rtype
= elf_ip2k_reloc_type (type
);
1458 rtype
= elf_iq2000_reloc_type (type
);
1463 rtype
= elf_xtensa_reloc_type (type
);
1466 case EM_LATTICEMICO32
:
1467 rtype
= elf_lm32_reloc_type (type
);
1472 rtype
= elf_m32c_reloc_type (type
);
1476 rtype
= elf_mt_reloc_type (type
);
1480 rtype
= elf_bfin_reloc_type (type
);
1484 rtype
= elf_mep_reloc_type (type
);
1488 rtype
= elf_cr16_reloc_type (type
);
1492 case EM_MICROBLAZE_OLD
:
1493 rtype
= elf_microblaze_reloc_type (type
);
1497 rtype
= elf_rl78_reloc_type (type
);
1501 rtype
= elf_rx_reloc_type (type
);
1505 rtype
= elf_metag_reloc_type (type
);
1510 rtype
= elf_xc16x_reloc_type (type
);
1514 rtype
= elf_tic6x_reloc_type (type
);
1518 rtype
= elf_tilegx_reloc_type (type
);
1522 rtype
= elf_tilepro_reloc_type (type
);
1525 case EM_WEBASSEMBLY
:
1526 rtype
= elf_wasm32_reloc_type (type
);
1530 rtype
= elf_xgate_reloc_type (type
);
1533 case EM_ALTERA_NIOS2
:
1534 rtype
= elf_nios2_reloc_type (type
);
1538 rtype
= elf_pru_reloc_type (type
);
1543 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1545 printf (do_wide
? "%-22s" : "%-17.17s", rtype
);
1547 if (elf_header
.e_machine
== EM_ALPHA
1549 && streq (rtype
, "R_ALPHA_LITUSE")
1552 switch (rels
[i
].r_addend
)
1554 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1555 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1556 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1557 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1558 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1559 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1560 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1561 default: rtype
= NULL
;
1565 printf (" (%s)", rtype
);
1569 printf (_("<unknown addend: %lx>"),
1570 (unsigned long) rels
[i
].r_addend
);
1574 else if (symtab_index
)
1576 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1578 error (_(" bad symbol index: %08lx in reloc"), (unsigned long) symtab_index
);
1583 Elf_Internal_Sym
* psym
;
1584 const char * version_string
;
1585 enum versioned_symbol_info sym_info
;
1586 unsigned short vna_other
;
1588 psym
= symtab
+ symtab_index
;
1591 = get_symbol_version_string (file
, is_dynsym
,
1600 if (ELF_ST_TYPE (psym
->st_info
) == STT_GNU_IFUNC
)
1604 unsigned int width
= is_32bit_elf
? 8 : 14;
1606 /* Relocations against GNU_IFUNC symbols do not use the value
1607 of the symbol as the address to relocate against. Instead
1608 they invoke the function named by the symbol and use its
1609 result as the address for relocation.
1611 To indicate this to the user, do not display the value of
1612 the symbol in the "Symbols's Value" field. Instead show
1613 its name followed by () as a hint that the symbol is
1617 || psym
->st_name
== 0
1618 || psym
->st_name
>= strtablen
)
1621 name
= strtab
+ psym
->st_name
;
1623 len
= print_symbol (width
, name
);
1625 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1627 printf ("()%-*s", len
<= width
? (width
+ 1) - len
: 1, " ");
1631 print_vma (psym
->st_value
, LONG_HEX
);
1633 printf (is_32bit_elf
? " " : " ");
1636 if (psym
->st_name
== 0)
1638 const char * sec_name
= "<null>";
1641 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1643 if (psym
->st_shndx
< elf_header
.e_shnum
)
1644 sec_name
= SECTION_NAME (section_headers
+ psym
->st_shndx
);
1645 else if (psym
->st_shndx
== SHN_ABS
)
1647 else if (psym
->st_shndx
== SHN_COMMON
)
1648 sec_name
= "COMMON";
1649 else if ((elf_header
.e_machine
== EM_MIPS
1650 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1651 || (elf_header
.e_machine
== EM_TI_C6000
1652 && psym
->st_shndx
== SHN_TIC6X_SCOMMON
))
1653 sec_name
= "SCOMMON";
1654 else if (elf_header
.e_machine
== EM_MIPS
1655 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1656 sec_name
= "SUNDEF";
1657 else if ((elf_header
.e_machine
== EM_X86_64
1658 || elf_header
.e_machine
== EM_L1OM
1659 || elf_header
.e_machine
== EM_K1OM
)
1660 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1661 sec_name
= "LARGE_COMMON";
1662 else if (elf_header
.e_machine
== EM_IA_64
1663 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1664 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1665 sec_name
= "ANSI_COM";
1666 else if (is_ia64_vms ()
1667 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
1668 sec_name
= "VMS_SYMVEC";
1671 sprintf (name_buf
, "<section 0x%x>",
1672 (unsigned int) psym
->st_shndx
);
1673 sec_name
= name_buf
;
1676 print_symbol (22, sec_name
);
1678 else if (strtab
== NULL
)
1679 printf (_("<string table index: %3ld>"), psym
->st_name
);
1680 else if (psym
->st_name
>= strtablen
)
1682 error (_("<corrupt string table index: %3ld>"), psym
->st_name
);
1687 print_symbol (22, strtab
+ psym
->st_name
);
1689 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1695 bfd_vma off
= rels
[i
].r_addend
;
1697 if ((bfd_signed_vma
) off
< 0)
1698 printf (" - %" BFD_VMA_FMT
"x", - off
);
1700 printf (" + %" BFD_VMA_FMT
"x", off
);
1706 bfd_vma off
= rels
[i
].r_addend
;
1708 printf ("%*c", is_32bit_elf
? 12 : 20, ' ');
1709 if ((bfd_signed_vma
) off
< 0)
1710 printf ("-%" BFD_VMA_FMT
"x", - off
);
1712 printf ("%" BFD_VMA_FMT
"x", off
);
1715 if (elf_header
.e_machine
== EM_SPARCV9
1717 && streq (rtype
, "R_SPARC_OLO10"))
1718 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf
));
1723 if (! is_32bit_elf
&& elf_header
.e_machine
== EM_MIPS
)
1725 bfd_vma type2
= ELF64_MIPS_R_TYPE2 (inf
);
1726 bfd_vma type3
= ELF64_MIPS_R_TYPE3 (inf
);
1727 const char * rtype2
= elf_mips_reloc_type (type2
);
1728 const char * rtype3
= elf_mips_reloc_type (type3
);
1730 printf (" Type2: ");
1733 printf (_("unrecognized: %-7lx"),
1734 (unsigned long) type2
& 0xffffffff);
1736 printf ("%-17.17s", rtype2
);
1738 printf ("\n Type3: ");
1741 printf (_("unrecognized: %-7lx"),
1742 (unsigned long) type3
& 0xffffffff);
1744 printf ("%-17.17s", rtype3
);
1757 get_mips_dynamic_type (unsigned long type
)
1761 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1762 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1763 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1764 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1765 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1766 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1767 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1768 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1769 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1770 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1771 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1772 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1773 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1774 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1775 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1776 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1777 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1778 case DT_MIPS_RLD_MAP_REL
: return "MIPS_RLD_MAP_REL";
1779 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1780 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1781 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1782 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1783 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1784 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1785 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1786 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1787 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1788 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1789 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1790 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1791 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1792 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1793 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1794 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1795 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1796 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1797 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1798 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1799 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1800 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1801 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1802 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1803 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1804 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1805 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
1806 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
1813 get_sparc64_dynamic_type (unsigned long type
)
1817 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1824 get_ppc_dynamic_type (unsigned long type
)
1828 case DT_PPC_GOT
: return "PPC_GOT";
1829 case DT_PPC_OPT
: return "PPC_OPT";
1836 get_ppc64_dynamic_type (unsigned long type
)
1840 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1841 case DT_PPC64_OPD
: return "PPC64_OPD";
1842 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1843 case DT_PPC64_OPT
: return "PPC64_OPT";
1850 get_parisc_dynamic_type (unsigned long type
)
1854 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1855 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1856 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1857 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1858 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1859 case DT_HP_PREINIT
: return "HP_PREINIT";
1860 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1861 case DT_HP_NEEDED
: return "HP_NEEDED";
1862 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1863 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1864 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1865 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1866 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1867 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1868 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1869 case DT_HP_FILTERED
: return "HP_FILTERED";
1870 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1871 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1872 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1873 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1874 case DT_PLT
: return "PLT";
1875 case DT_PLT_SIZE
: return "PLT_SIZE";
1876 case DT_DLT
: return "DLT";
1877 case DT_DLT_SIZE
: return "DLT_SIZE";
1884 get_ia64_dynamic_type (unsigned long type
)
1888 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1889 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
1890 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
1891 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
1892 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
1893 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
1894 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
1895 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
1896 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
1897 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
1898 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
1899 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
1900 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
1901 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
1902 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
1903 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
1904 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
1905 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
1906 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
1907 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
1908 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
1909 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
1910 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
1911 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
1912 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
1913 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
1914 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
1915 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
1916 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
1917 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
1918 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
1925 get_solaris_section_type (unsigned long type
)
1929 case 0x6fffffee: return "SUNW_ancillary";
1930 case 0x6fffffef: return "SUNW_capchain";
1931 case 0x6ffffff0: return "SUNW_capinfo";
1932 case 0x6ffffff1: return "SUNW_symsort";
1933 case 0x6ffffff2: return "SUNW_tlssort";
1934 case 0x6ffffff3: return "SUNW_LDYNSYM";
1935 case 0x6ffffff4: return "SUNW_dof";
1936 case 0x6ffffff5: return "SUNW_cap";
1937 case 0x6ffffff6: return "SUNW_SIGNATURE";
1938 case 0x6ffffff7: return "SUNW_ANNOTATE";
1939 case 0x6ffffff8: return "SUNW_DEBUGSTR";
1940 case 0x6ffffff9: return "SUNW_DEBUG";
1941 case 0x6ffffffa: return "SUNW_move";
1942 case 0x6ffffffb: return "SUNW_COMDAT";
1943 case 0x6ffffffc: return "SUNW_syminfo";
1944 case 0x6ffffffd: return "SUNW_verdef";
1945 case 0x6ffffffe: return "SUNW_verneed";
1946 case 0x6fffffff: return "SUNW_versym";
1947 case 0x70000000: return "SPARC_GOTDATA";
1948 default: return NULL
;
1953 get_alpha_dynamic_type (unsigned long type
)
1957 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
1958 default: return NULL
;
1963 get_score_dynamic_type (unsigned long type
)
1967 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
1968 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
1969 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
1970 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
1971 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
1972 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
1973 default: return NULL
;
1978 get_tic6x_dynamic_type (unsigned long type
)
1982 case DT_C6000_GSYM_OFFSET
: return "C6000_GSYM_OFFSET";
1983 case DT_C6000_GSTR_OFFSET
: return "C6000_GSTR_OFFSET";
1984 case DT_C6000_DSBT_BASE
: return "C6000_DSBT_BASE";
1985 case DT_C6000_DSBT_SIZE
: return "C6000_DSBT_SIZE";
1986 case DT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
1987 case DT_C6000_DSBT_INDEX
: return "C6000_DSBT_INDEX";
1988 default: return NULL
;
1993 get_nios2_dynamic_type (unsigned long type
)
1997 case DT_NIOS2_GP
: return "NIOS2_GP";
1998 default: return NULL
;
2003 get_solaris_dynamic_type (unsigned long type
)
2007 case 0x6000000d: return "SUNW_AUXILIARY";
2008 case 0x6000000e: return "SUNW_RTLDINF";
2009 case 0x6000000f: return "SUNW_FILTER";
2010 case 0x60000010: return "SUNW_CAP";
2011 case 0x60000011: return "SUNW_SYMTAB";
2012 case 0x60000012: return "SUNW_SYMSZ";
2013 case 0x60000013: return "SUNW_SORTENT";
2014 case 0x60000014: return "SUNW_SYMSORT";
2015 case 0x60000015: return "SUNW_SYMSORTSZ";
2016 case 0x60000016: return "SUNW_TLSSORT";
2017 case 0x60000017: return "SUNW_TLSSORTSZ";
2018 case 0x60000018: return "SUNW_CAPINFO";
2019 case 0x60000019: return "SUNW_STRPAD";
2020 case 0x6000001a: return "SUNW_CAPCHAIN";
2021 case 0x6000001b: return "SUNW_LDMACH";
2022 case 0x6000001d: return "SUNW_CAPCHAINENT";
2023 case 0x6000001f: return "SUNW_CAPCHAINSZ";
2024 case 0x60000021: return "SUNW_PARENT";
2025 case 0x60000023: return "SUNW_ASLR";
2026 case 0x60000025: return "SUNW_RELAX";
2027 case 0x60000029: return "SUNW_NXHEAP";
2028 case 0x6000002b: return "SUNW_NXSTACK";
2030 case 0x70000001: return "SPARC_REGISTER";
2031 case 0x7ffffffd: return "AUXILIARY";
2032 case 0x7ffffffe: return "USED";
2033 case 0x7fffffff: return "FILTER";
2035 default: return NULL
;
2040 get_dynamic_type (unsigned long type
)
2042 static char buff
[64];
2046 case DT_NULL
: return "NULL";
2047 case DT_NEEDED
: return "NEEDED";
2048 case DT_PLTRELSZ
: return "PLTRELSZ";
2049 case DT_PLTGOT
: return "PLTGOT";
2050 case DT_HASH
: return "HASH";
2051 case DT_STRTAB
: return "STRTAB";
2052 case DT_SYMTAB
: return "SYMTAB";
2053 case DT_RELA
: return "RELA";
2054 case DT_RELASZ
: return "RELASZ";
2055 case DT_RELAENT
: return "RELAENT";
2056 case DT_STRSZ
: return "STRSZ";
2057 case DT_SYMENT
: return "SYMENT";
2058 case DT_INIT
: return "INIT";
2059 case DT_FINI
: return "FINI";
2060 case DT_SONAME
: return "SONAME";
2061 case DT_RPATH
: return "RPATH";
2062 case DT_SYMBOLIC
: return "SYMBOLIC";
2063 case DT_REL
: return "REL";
2064 case DT_RELSZ
: return "RELSZ";
2065 case DT_RELENT
: return "RELENT";
2066 case DT_PLTREL
: return "PLTREL";
2067 case DT_DEBUG
: return "DEBUG";
2068 case DT_TEXTREL
: return "TEXTREL";
2069 case DT_JMPREL
: return "JMPREL";
2070 case DT_BIND_NOW
: return "BIND_NOW";
2071 case DT_INIT_ARRAY
: return "INIT_ARRAY";
2072 case DT_FINI_ARRAY
: return "FINI_ARRAY";
2073 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
2074 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
2075 case DT_RUNPATH
: return "RUNPATH";
2076 case DT_FLAGS
: return "FLAGS";
2078 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2079 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
2080 case DT_SYMTAB_SHNDX
: return "SYMTAB_SHNDX";
2082 case DT_CHECKSUM
: return "CHECKSUM";
2083 case DT_PLTPADSZ
: return "PLTPADSZ";
2084 case DT_MOVEENT
: return "MOVEENT";
2085 case DT_MOVESZ
: return "MOVESZ";
2086 case DT_FEATURE
: return "FEATURE";
2087 case DT_POSFLAG_1
: return "POSFLAG_1";
2088 case DT_SYMINSZ
: return "SYMINSZ";
2089 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
2091 case DT_ADDRRNGLO
: return "ADDRRNGLO";
2092 case DT_CONFIG
: return "CONFIG";
2093 case DT_DEPAUDIT
: return "DEPAUDIT";
2094 case DT_AUDIT
: return "AUDIT";
2095 case DT_PLTPAD
: return "PLTPAD";
2096 case DT_MOVETAB
: return "MOVETAB";
2097 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
2099 case DT_VERSYM
: return "VERSYM";
2101 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
2102 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
2103 case DT_RELACOUNT
: return "RELACOUNT";
2104 case DT_RELCOUNT
: return "RELCOUNT";
2105 case DT_FLAGS_1
: return "FLAGS_1";
2106 case DT_VERDEF
: return "VERDEF";
2107 case DT_VERDEFNUM
: return "VERDEFNUM";
2108 case DT_VERNEED
: return "VERNEED";
2109 case DT_VERNEEDNUM
: return "VERNEEDNUM";
2111 case DT_AUXILIARY
: return "AUXILIARY";
2112 case DT_USED
: return "USED";
2113 case DT_FILTER
: return "FILTER";
2115 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
2116 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
2117 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
2118 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
2119 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
2120 case DT_GNU_HASH
: return "GNU_HASH";
2123 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
2125 const char * result
;
2127 switch (elf_header
.e_machine
)
2130 case EM_MIPS_RS3_LE
:
2131 result
= get_mips_dynamic_type (type
);
2134 result
= get_sparc64_dynamic_type (type
);
2137 result
= get_ppc_dynamic_type (type
);
2140 result
= get_ppc64_dynamic_type (type
);
2143 result
= get_ia64_dynamic_type (type
);
2146 result
= get_alpha_dynamic_type (type
);
2149 result
= get_score_dynamic_type (type
);
2152 result
= get_tic6x_dynamic_type (type
);
2154 case EM_ALTERA_NIOS2
:
2155 result
= get_nios2_dynamic_type (type
);
2158 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2159 result
= get_solaris_dynamic_type (type
);
2168 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
2170 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
2171 || (elf_header
.e_machine
== EM_PARISC
2172 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
2174 const char * result
;
2176 switch (elf_header
.e_machine
)
2179 result
= get_parisc_dynamic_type (type
);
2182 result
= get_ia64_dynamic_type (type
);
2185 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2186 result
= get_solaris_dynamic_type (type
);
2195 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
2199 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
2206 get_file_type (unsigned e_type
)
2208 static char buff
[32];
2212 case ET_NONE
: return _("NONE (None)");
2213 case ET_REL
: return _("REL (Relocatable file)");
2214 case ET_EXEC
: return _("EXEC (Executable file)");
2215 case ET_DYN
: return _("DYN (Shared object file)");
2216 case ET_CORE
: return _("CORE (Core file)");
2219 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
2220 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
2221 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
2222 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
2224 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
2230 get_machine_name (unsigned e_machine
)
2232 static char buff
[64]; /* XXX */
2236 /* Please keep this switch table sorted by increasing EM_ value. */
2238 case EM_NONE
: return _("None");
2239 case EM_M32
: return "WE32100";
2240 case EM_SPARC
: return "Sparc";
2241 case EM_386
: return "Intel 80386";
2242 case EM_68K
: return "MC68000";
2243 case EM_88K
: return "MC88000";
2244 case EM_IAMCU
: return "Intel MCU";
2245 case EM_860
: return "Intel 80860";
2246 case EM_MIPS
: return "MIPS R3000";
2247 case EM_S370
: return "IBM System/370";
2249 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
2250 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
2251 case EM_PARISC
: return "HPPA";
2252 case EM_VPP550
: return "Fujitsu VPP500";
2253 case EM_SPARC32PLUS
: return "Sparc v8+" ;
2254 case EM_960
: return "Intel 90860";
2255 case EM_PPC
: return "PowerPC";
2257 case EM_PPC64
: return "PowerPC64";
2259 case EM_S390
: return "IBM S/390";
2260 case EM_SPU
: return "SPU";
2262 case EM_V800
: return "Renesas V850 (using RH850 ABI)";
2263 case EM_FR20
: return "Fujitsu FR20";
2264 case EM_RH32
: return "TRW RH32";
2265 case EM_MCORE
: return "MCORE";
2267 case EM_ARM
: return "ARM";
2268 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
2269 case EM_SH
: return "Renesas / SuperH SH";
2270 case EM_SPARCV9
: return "Sparc v9";
2271 case EM_TRICORE
: return "Siemens Tricore";
2272 case EM_ARC
: return "ARC";
2273 case EM_H8_300
: return "Renesas H8/300";
2274 case EM_H8_300H
: return "Renesas H8/300H";
2275 case EM_H8S
: return "Renesas H8S";
2276 case EM_H8_500
: return "Renesas H8/500";
2278 case EM_IA_64
: return "Intel IA-64";
2279 case EM_MIPS_X
: return "Stanford MIPS-X";
2280 case EM_COLDFIRE
: return "Motorola Coldfire";
2281 case EM_68HC12
: return "Motorola MC68HC12 Microcontroller";
2282 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
2283 case EM_PCP
: return "Siemens PCP";
2284 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
2285 case EM_NDR1
: return "Denso NDR1 microprocesspr";
2286 case EM_STARCORE
: return "Motorola Star*Core processor";
2287 case EM_ME16
: return "Toyota ME16 processor";
2289 case EM_ST100
: return "STMicroelectronics ST100 processor";
2290 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
2291 case EM_X86_64
: return "Advanced Micro Devices X86-64";
2292 case EM_PDSP
: return "Sony DSP processor";
2293 case EM_PDP10
: return "Digital Equipment Corp. PDP-10";
2294 case EM_PDP11
: return "Digital Equipment Corp. PDP-11";
2295 case EM_FX66
: return "Siemens FX66 microcontroller";
2296 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2297 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
2298 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
2300 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
2301 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
2302 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
2303 case EM_SVX
: return "Silicon Graphics SVx";
2304 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
2305 case EM_VAX
: return "Digital VAX";
2306 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
2307 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
2308 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
2309 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
2311 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
2312 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
2313 case EM_PRISM
: return "Vitesse Prism";
2315 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
2316 case EM_CYGNUS_FR30
:
2317 case EM_FR30
: return "Fujitsu FR30";
2318 case EM_CYGNUS_D10V
:
2319 case EM_D10V
: return "d10v";
2320 case EM_CYGNUS_D30V
:
2321 case EM_D30V
: return "d30v";
2322 case EM_CYGNUS_V850
:
2323 case EM_V850
: return "Renesas V850";
2324 case EM_CYGNUS_M32R
:
2325 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
2326 case EM_CYGNUS_MN10300
:
2327 case EM_MN10300
: return "mn10300";
2329 case EM_CYGNUS_MN10200
:
2330 case EM_MN10200
: return "mn10200";
2331 case EM_PJ
: return "picoJava";
2332 case EM_OR1K
: return "OpenRISC 1000";
2333 case EM_ARC_COMPACT
: return "ARCompact";
2335 case EM_XTENSA
: return "Tensilica Xtensa Processor";
2336 case EM_VIDEOCORE
: return "Alphamosaic VideoCore processor";
2337 case EM_TMM_GPP
: return "Thompson Multimedia General Purpose Processor";
2338 case EM_NS32K
: return "National Semiconductor 32000 series";
2339 case EM_TPC
: return "Tenor Network TPC processor";
2340 case EM_SNP1K
: return "Trebia SNP 1000 processor";
2342 case EM_ST200
: return "STMicroelectronics ST200 microcontroller";
2344 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
2345 case EM_MAX
: return "MAX Processor";
2346 case EM_CR
: return "National Semiconductor CompactRISC";
2347 case EM_F2MC16
: return "Fujitsu F2MC16";
2348 case EM_MSP430
: return "Texas Instruments msp430 microcontroller";
2349 case EM_BLACKFIN
: return "Analog Devices Blackfin";
2350 case EM_SE_C33
: return "S1C33 Family of Seiko Epson processors";
2351 case EM_SEP
: return "Sharp embedded microprocessor";
2352 case EM_ARCA
: return "Arca RISC microprocessor";
2354 case EM_UNICORE
: return "Unicore";
2355 case EM_EXCESS
: return "eXcess 16/32/64-bit configurable embedded CPU";
2356 case EM_DXP
: return "Icera Semiconductor Inc. Deep Execution Processor";
2357 case EM_ALTERA_NIOS2
: return "Altera Nios II";
2358 case EM_CRX
: return "National Semiconductor CRX microprocessor";
2359 case EM_XGATE
: return "Motorola XGATE embedded processor";
2361 case EM_XC16X
: return "Infineon Technologies xc16x";
2362 case EM_M16C
: return "Renesas M16C series microprocessors";
2363 case EM_DSPIC30F
: return "Microchip Technology dsPIC30F Digital Signal Controller";
2364 case EM_CE
: return "Freescale Communication Engine RISC core";
2366 case EM_M32C
: return "Renesas M32c";
2368 case EM_TSK3000
: return "Altium TSK3000 core";
2369 case EM_RS08
: return "Freescale RS08 embedded processor";
2370 case EM_ECOG2
: return "Cyan Technology eCOG2 microprocessor";
2371 case EM_SCORE
: return "SUNPLUS S+Core";
2372 case EM_DSP24
: return "New Japan Radio (NJR) 24-bit DSP Processor";
2373 case EM_VIDEOCORE3
: return "Broadcom VideoCore III processor";
2374 case EM_LATTICEMICO32
: return "Lattice Mico32";
2375 case EM_SE_C17
: return "Seiko Epson C17 family";
2377 case EM_TI_C6000
: return "Texas Instruments TMS320C6000 DSP family";
2378 case EM_TI_C2000
: return "Texas Instruments TMS320C2000 DSP family";
2379 case EM_TI_C5500
: return "Texas Instruments TMS320C55x DSP family";
2380 case EM_TI_PRU
: return "TI PRU I/O processor";
2382 case EM_MMDSP_PLUS
: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2383 case EM_CYPRESS_M8C
: return "Cypress M8C microprocessor";
2384 case EM_R32C
: return "Renesas R32C series microprocessors";
2385 case EM_TRIMEDIA
: return "NXP Semiconductors TriMedia architecture family";
2386 case EM_QDSP6
: return "QUALCOMM DSP6 Processor";
2387 case EM_8051
: return "Intel 8051 and variants";
2388 case EM_STXP7X
: return "STMicroelectronics STxP7x family";
2389 case EM_NDS32
: return "Andes Technology compact code size embedded RISC processor family";
2390 case EM_ECOG1X
: return "Cyan Technology eCOG1X family";
2391 case EM_MAXQ30
: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2393 case EM_XIMO16
: return "New Japan Radio (NJR) 16-bit DSP Processor";
2394 case EM_MANIK
: return "M2000 Reconfigurable RISC Microprocessor";
2395 case EM_CRAYNV2
: return "Cray Inc. NV2 vector architecture";
2396 case EM_RX
: return "Renesas RX";
2397 case EM_METAG
: return "Imagination Technologies Meta processor architecture";
2398 case EM_MCST_ELBRUS
: return "MCST Elbrus general purpose hardware architecture";
2399 case EM_ECOG16
: return "Cyan Technology eCOG16 family";
2402 case EM_MICROBLAZE_OLD
: return "Xilinx MicroBlaze";
2403 case EM_ETPU
: return "Freescale Extended Time Processing Unit";
2404 case EM_SLE9X
: return "Infineon Technologies SLE9X core";
2406 case EM_L1OM
: return "Intel L1OM";
2407 case EM_K1OM
: return "Intel K1OM";
2408 case EM_INTEL182
: return "Intel (reserved)";
2409 case EM_AARCH64
: return "AArch64";
2410 case EM_ARM184
: return "ARM (reserved)";
2411 case EM_AVR32
: return "Atmel Corporation 32-bit microprocessor";
2412 case EM_STM8
: return "STMicroeletronics STM8 8-bit microcontroller";
2413 case EM_TILE64
: return "Tilera TILE64 multicore architecture family";
2414 case EM_TILEPRO
: return "Tilera TILEPro multicore architecture family";
2416 case EM_CUDA
: return "NVIDIA CUDA architecture";
2417 case EM_TILEGX
: return "Tilera TILE-Gx multicore architecture family";
2418 case EM_CLOUDSHIELD
: return "CloudShield architecture family";
2419 case EM_COREA_1ST
: return "KIPO-KAIST Core-A 1st generation processor family";
2420 case EM_COREA_2ND
: return "KIPO-KAIST Core-A 2nd generation processor family";
2421 case EM_ARC_COMPACT2
: return "ARCv2";
2422 case EM_OPEN8
: return "Open8 8-bit RISC soft processor core";
2423 case EM_RL78
: return "Renesas RL78";
2424 case EM_VIDEOCORE5
: return "Broadcom VideoCore V processor";
2425 case EM_78K0R
: return "Renesas 78K0R";
2427 case EM_56800EX
: return "Freescale 56800EX Digital Signal Controller (DSC)";
2428 case EM_BA1
: return "Beyond BA1 CPU architecture";
2429 case EM_BA2
: return "Beyond BA2 CPU architecture";
2430 case EM_XCORE
: return "XMOS xCORE processor family";
2431 case EM_MCHP_PIC
: return "Microchip 8-bit PIC(r) family";
2433 case EM_KM32
: return "KM211 KM32 32-bit processor";
2434 case EM_KMX32
: return "KM211 KMX32 32-bit processor";
2435 case EM_KMX16
: return "KM211 KMX16 16-bit processor";
2436 case EM_KMX8
: return "KM211 KMX8 8-bit processor";
2437 case EM_KVARC
: return "KM211 KVARC processor";
2438 case EM_CDP
: return "Paneve CDP architecture family";
2439 case EM_COGE
: return "Cognitive Smart Memory Processor";
2440 case EM_COOL
: return "Bluechip Systems CoolEngine";
2441 case EM_NORC
: return "Nanoradio Optimized RISC";
2442 case EM_CSR_KALIMBA
: return "CSR Kalimba architecture family";
2444 case EM_Z80
: return "Zilog Z80";
2445 case EM_VISIUM
: return "CDS VISIUMcore processor";
2446 case EM_FT32
: return "FTDI Chip FT32";
2447 case EM_MOXIE
: return "Moxie";
2448 case EM_AMDGPU
: return "AMD GPU";
2449 case EM_RISCV
: return "RISC-V";
2450 case EM_LANAI
: return "Lanai 32-bit processor";
2451 case EM_BPF
: return "Linux BPF";
2453 /* Large numbers... */
2454 case EM_MT
: return "Morpho Techologies MT processor";
2455 case EM_ALPHA
: return "Alpha";
2456 case EM_WEBASSEMBLY
: return "Web Assembly";
2457 case EM_DLX
: return "OpenDLX";
2458 case EM_XSTORMY16
: return "Sanyo XStormy16 CPU core";
2459 case EM_IQ2000
: return "Vitesse IQ2000";
2461 case EM_NIOS32
: return "Altera Nios";
2462 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
2463 case EM_ADAPTEVA_EPIPHANY
: return "Adapteva EPIPHANY";
2464 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
2467 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
2473 decode_ARC_machine_flags (unsigned e_flags
, unsigned e_machine
, char buf
[])
2475 /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2. Some
2476 other compilers don't a specific architecture type in the e_flags, and
2477 instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
2478 architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
2481 Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
2482 but also sets a specific architecture type in the e_flags field.
2484 However, when decoding the flags we don't worry if we see an
2485 unexpected pairing, for example EM_ARC_COMPACT machine type, with
2486 ARCEM architecture type. */
2488 switch (e_flags
& EF_ARC_MACH_MSK
)
2490 /* We only expect these to occur for EM_ARC_COMPACT2. */
2491 case EF_ARC_CPU_ARCV2EM
:
2492 strcat (buf
, ", ARC EM");
2494 case EF_ARC_CPU_ARCV2HS
:
2495 strcat (buf
, ", ARC HS");
2498 /* We only expect these to occur for EM_ARC_COMPACT. */
2499 case E_ARC_MACH_ARC600
:
2500 strcat (buf
, ", ARC600");
2502 case E_ARC_MACH_ARC601
:
2503 strcat (buf
, ", ARC601");
2505 case E_ARC_MACH_ARC700
:
2506 strcat (buf
, ", ARC700");
2509 /* The only times we should end up here are (a) A corrupt ELF, (b) A
2510 new ELF with new architecture being read by an old version of
2511 readelf, or (c) An ELF built with non-GNU compiler that does not
2512 set the architecture in the e_flags. */
2514 if (e_machine
== EM_ARC_COMPACT
)
2515 strcat (buf
, ", Unknown ARCompact");
2517 strcat (buf
, ", Unknown ARC");
2521 switch (e_flags
& EF_ARC_OSABI_MSK
)
2523 case E_ARC_OSABI_ORIG
:
2524 strcat (buf
, ", (ABI:legacy)");
2526 case E_ARC_OSABI_V2
:
2527 strcat (buf
, ", (ABI:v2)");
2529 /* Only upstream 3.9+ kernels will support ARCv2 ISA. */
2530 case E_ARC_OSABI_V3
:
2531 strcat (buf
, ", v3 no-legacy-syscalls ABI");
2533 case E_ARC_OSABI_V4
:
2534 strcat (buf
, ", v4 ABI");
2537 strcat (buf
, ", unrecognised ARC OSABI flag");
2543 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
2546 bfd_boolean unknown
= FALSE
;
2548 eabi
= EF_ARM_EABI_VERSION (e_flags
);
2549 e_flags
&= ~ EF_ARM_EABIMASK
;
2551 /* Handle "generic" ARM flags. */
2552 if (e_flags
& EF_ARM_RELEXEC
)
2554 strcat (buf
, ", relocatable executable");
2555 e_flags
&= ~ EF_ARM_RELEXEC
;
2558 /* Now handle EABI specific flags. */
2562 strcat (buf
, ", <unrecognized EABI>");
2567 case EF_ARM_EABI_VER1
:
2568 strcat (buf
, ", Version1 EABI");
2573 /* Process flags one bit at a time. */
2574 flag
= e_flags
& - e_flags
;
2579 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2580 strcat (buf
, ", sorted symbol tables");
2590 case EF_ARM_EABI_VER2
:
2591 strcat (buf
, ", Version2 EABI");
2596 /* Process flags one bit at a time. */
2597 flag
= e_flags
& - e_flags
;
2602 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2603 strcat (buf
, ", sorted symbol tables");
2606 case EF_ARM_DYNSYMSUSESEGIDX
:
2607 strcat (buf
, ", dynamic symbols use segment index");
2610 case EF_ARM_MAPSYMSFIRST
:
2611 strcat (buf
, ", mapping symbols precede others");
2621 case EF_ARM_EABI_VER3
:
2622 strcat (buf
, ", Version3 EABI");
2625 case EF_ARM_EABI_VER4
:
2626 strcat (buf
, ", Version4 EABI");
2631 /* Process flags one bit at a time. */
2632 flag
= e_flags
& - e_flags
;
2638 strcat (buf
, ", BE8");
2642 strcat (buf
, ", LE8");
2652 case EF_ARM_EABI_VER5
:
2653 strcat (buf
, ", Version5 EABI");
2658 /* Process flags one bit at a time. */
2659 flag
= e_flags
& - e_flags
;
2665 strcat (buf
, ", BE8");
2669 strcat (buf
, ", LE8");
2672 case EF_ARM_ABI_FLOAT_SOFT
: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2673 strcat (buf
, ", soft-float ABI");
2676 case EF_ARM_ABI_FLOAT_HARD
: /* Conflicts with EF_ARM_VFP_FLOAT. */
2677 strcat (buf
, ", hard-float ABI");
2687 case EF_ARM_EABI_UNKNOWN
:
2688 strcat (buf
, ", GNU EABI");
2693 /* Process flags one bit at a time. */
2694 flag
= e_flags
& - e_flags
;
2699 case EF_ARM_INTERWORK
:
2700 strcat (buf
, ", interworking enabled");
2703 case EF_ARM_APCS_26
:
2704 strcat (buf
, ", uses APCS/26");
2707 case EF_ARM_APCS_FLOAT
:
2708 strcat (buf
, ", uses APCS/float");
2712 strcat (buf
, ", position independent");
2716 strcat (buf
, ", 8 bit structure alignment");
2719 case EF_ARM_NEW_ABI
:
2720 strcat (buf
, ", uses new ABI");
2723 case EF_ARM_OLD_ABI
:
2724 strcat (buf
, ", uses old ABI");
2727 case EF_ARM_SOFT_FLOAT
:
2728 strcat (buf
, ", software FP");
2731 case EF_ARM_VFP_FLOAT
:
2732 strcat (buf
, ", VFP");
2735 case EF_ARM_MAVERICK_FLOAT
:
2736 strcat (buf
, ", Maverick FP");
2747 strcat (buf
,_(", <unknown>"));
2751 decode_AVR_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2753 --size
; /* Leave space for null terminator. */
2755 switch (e_flags
& EF_AVR_MACH
)
2757 case E_AVR_MACH_AVR1
:
2758 strncat (buf
, ", avr:1", size
);
2760 case E_AVR_MACH_AVR2
:
2761 strncat (buf
, ", avr:2", size
);
2763 case E_AVR_MACH_AVR25
:
2764 strncat (buf
, ", avr:25", size
);
2766 case E_AVR_MACH_AVR3
:
2767 strncat (buf
, ", avr:3", size
);
2769 case E_AVR_MACH_AVR31
:
2770 strncat (buf
, ", avr:31", size
);
2772 case E_AVR_MACH_AVR35
:
2773 strncat (buf
, ", avr:35", size
);
2775 case E_AVR_MACH_AVR4
:
2776 strncat (buf
, ", avr:4", size
);
2778 case E_AVR_MACH_AVR5
:
2779 strncat (buf
, ", avr:5", size
);
2781 case E_AVR_MACH_AVR51
:
2782 strncat (buf
, ", avr:51", size
);
2784 case E_AVR_MACH_AVR6
:
2785 strncat (buf
, ", avr:6", size
);
2787 case E_AVR_MACH_AVRTINY
:
2788 strncat (buf
, ", avr:100", size
);
2790 case E_AVR_MACH_XMEGA1
:
2791 strncat (buf
, ", avr:101", size
);
2793 case E_AVR_MACH_XMEGA2
:
2794 strncat (buf
, ", avr:102", size
);
2796 case E_AVR_MACH_XMEGA3
:
2797 strncat (buf
, ", avr:103", size
);
2799 case E_AVR_MACH_XMEGA4
:
2800 strncat (buf
, ", avr:104", size
);
2802 case E_AVR_MACH_XMEGA5
:
2803 strncat (buf
, ", avr:105", size
);
2805 case E_AVR_MACH_XMEGA6
:
2806 strncat (buf
, ", avr:106", size
);
2808 case E_AVR_MACH_XMEGA7
:
2809 strncat (buf
, ", avr:107", size
);
2812 strncat (buf
, ", avr:<unknown>", size
);
2816 size
-= strlen (buf
);
2817 if (e_flags
& EF_AVR_LINKRELAX_PREPARED
)
2818 strncat (buf
, ", link-relax", size
);
2822 decode_NDS32_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2828 bfd_boolean has_fpu
= FALSE
;
2831 static const char *ABI_STRINGS
[] =
2833 "ABI v0", /* use r5 as return register; only used in N1213HC */
2834 "ABI v1", /* use r0 as return register */
2835 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2836 "ABI v2fp", /* for FPU */
2840 static const char *VER_STRINGS
[] =
2842 "Andes ELF V1.3 or older",
2846 static const char *ARCH_STRINGS
[] =
2855 abi
= EF_NDS_ABI
& e_flags
;
2856 arch
= EF_NDS_ARCH
& e_flags
;
2857 config
= EF_NDS_INST
& e_flags
;
2858 version
= EF_NDS32_ELF_VERSION
& e_flags
;
2860 memset (buf
, 0, size
);
2867 case E_NDS_ABI_V2FP
:
2868 case E_NDS_ABI_AABI
:
2869 case E_NDS_ABI_V2FP_PLUS
:
2870 /* In case there are holes in the array. */
2871 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ABI_STRINGS
[abi
>> EF_NDS_ABI_SHIFT
]);
2875 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ABI>");
2881 case E_NDS32_ELF_VER_1_2
:
2882 case E_NDS32_ELF_VER_1_3
:
2883 case E_NDS32_ELF_VER_1_4
:
2884 r
+= snprintf (buf
+ r
, size
- r
, ", %s", VER_STRINGS
[version
>> EF_NDS32_ELF_VERSION_SHIFT
]);
2888 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ELF version number>");
2892 if (E_NDS_ABI_V0
== abi
)
2894 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2895 r
+= snprintf (buf
+ r
, size
- r
, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2896 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2897 r
+= snprintf (buf
+ r
, size
-r
, ", 16b"); /* has 16-bit instructions */
2903 case E_NDS_ARCH_STAR_V1_0
:
2904 case E_NDS_ARCH_STAR_V2_0
:
2905 case E_NDS_ARCH_STAR_V3_0
:
2906 case E_NDS_ARCH_STAR_V3_M
:
2907 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ARCH_STRINGS
[arch
>> EF_NDS_ARCH_SHIFT
]);
2911 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized architecture>");
2912 /* ARCH version determines how the e_flags are interpreted.
2913 If it is unknown, we cannot proceed. */
2917 /* Newer ABI; Now handle architecture specific flags. */
2918 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2920 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2921 r
+= snprintf (buf
+ r
, size
-r
, ", MFUSR_PC");
2923 if (!(config
& E_NDS32_HAS_NO_MAC_INST
))
2924 r
+= snprintf (buf
+ r
, size
-r
, ", MAC");
2926 if (config
& E_NDS32_HAS_DIV_INST
)
2927 r
+= snprintf (buf
+ r
, size
-r
, ", DIV");
2929 if (config
& E_NDS32_HAS_16BIT_INST
)
2930 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
2934 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2936 if (version
<= E_NDS32_ELF_VER_1_3
)
2937 r
+= snprintf (buf
+ r
, size
-r
, ", [B8]");
2939 r
+= snprintf (buf
+ r
, size
-r
, ", EX9");
2942 if (config
& E_NDS32_HAS_MAC_DX_INST
)
2943 r
+= snprintf (buf
+ r
, size
-r
, ", MAC_DX");
2945 if (config
& E_NDS32_HAS_DIV_DX_INST
)
2946 r
+= snprintf (buf
+ r
, size
-r
, ", DIV_DX");
2948 if (config
& E_NDS32_HAS_16BIT_INST
)
2950 if (version
<= E_NDS32_ELF_VER_1_3
)
2951 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
2953 r
+= snprintf (buf
+ r
, size
-r
, ", IFC");
2957 if (config
& E_NDS32_HAS_EXT_INST
)
2958 r
+= snprintf (buf
+ r
, size
-r
, ", PERF1");
2960 if (config
& E_NDS32_HAS_EXT2_INST
)
2961 r
+= snprintf (buf
+ r
, size
-r
, ", PERF2");
2963 if (config
& E_NDS32_HAS_FPU_INST
)
2966 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_SP");
2969 if (config
& E_NDS32_HAS_FPU_DP_INST
)
2972 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_DP");
2975 if (config
& E_NDS32_HAS_FPU_MAC_INST
)
2978 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_MAC");
2983 switch ((config
& E_NDS32_FPU_REG_CONF
) >> E_NDS32_FPU_REG_CONF_SHIFT
)
2985 case E_NDS32_FPU_REG_8SP_4DP
:
2986 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:8/4");
2988 case E_NDS32_FPU_REG_16SP_8DP
:
2989 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:16/8");
2991 case E_NDS32_FPU_REG_32SP_16DP
:
2992 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/16");
2994 case E_NDS32_FPU_REG_32SP_32DP
:
2995 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/32");
3000 if (config
& E_NDS32_HAS_AUDIO_INST
)
3001 r
+= snprintf (buf
+ r
, size
-r
, ", AUDIO");
3003 if (config
& E_NDS32_HAS_STRING_INST
)
3004 r
+= snprintf (buf
+ r
, size
-r
, ", STR");
3006 if (config
& E_NDS32_HAS_REDUCED_REGS
)
3007 r
+= snprintf (buf
+ r
, size
-r
, ", 16REG");
3009 if (config
& E_NDS32_HAS_VIDEO_INST
)
3011 if (version
<= E_NDS32_ELF_VER_1_3
)
3012 r
+= snprintf (buf
+ r
, size
-r
, ", VIDEO");
3014 r
+= snprintf (buf
+ r
, size
-r
, ", SATURATION");
3017 if (config
& E_NDS32_HAS_ENCRIPT_INST
)
3018 r
+= snprintf (buf
+ r
, size
-r
, ", ENCRP");
3020 if (config
& E_NDS32_HAS_L2C_INST
)
3021 r
+= snprintf (buf
+ r
, size
-r
, ", L2C");
3025 get_machine_flags (unsigned e_flags
, unsigned e_machine
)
3027 static char buf
[1024];
3038 case EM_ARC_COMPACT2
:
3039 case EM_ARC_COMPACT
:
3040 decode_ARC_machine_flags (e_flags
, e_machine
, buf
);
3044 decode_ARM_machine_flags (e_flags
, buf
);
3048 decode_AVR_machine_flags (e_flags
, buf
, sizeof buf
);
3052 if (e_flags
& EF_BFIN_PIC
)
3053 strcat (buf
, ", PIC");
3055 if (e_flags
& EF_BFIN_FDPIC
)
3056 strcat (buf
, ", FDPIC");
3058 if (e_flags
& EF_BFIN_CODE_IN_L1
)
3059 strcat (buf
, ", code in L1");
3061 if (e_flags
& EF_BFIN_DATA_IN_L1
)
3062 strcat (buf
, ", data in L1");
3067 switch (e_flags
& EF_FRV_CPU_MASK
)
3069 case EF_FRV_CPU_GENERIC
:
3073 strcat (buf
, ", fr???");
3076 case EF_FRV_CPU_FR300
:
3077 strcat (buf
, ", fr300");
3080 case EF_FRV_CPU_FR400
:
3081 strcat (buf
, ", fr400");
3083 case EF_FRV_CPU_FR405
:
3084 strcat (buf
, ", fr405");
3087 case EF_FRV_CPU_FR450
:
3088 strcat (buf
, ", fr450");
3091 case EF_FRV_CPU_FR500
:
3092 strcat (buf
, ", fr500");
3094 case EF_FRV_CPU_FR550
:
3095 strcat (buf
, ", fr550");
3098 case EF_FRV_CPU_SIMPLE
:
3099 strcat (buf
, ", simple");
3101 case EF_FRV_CPU_TOMCAT
:
3102 strcat (buf
, ", tomcat");
3108 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
3109 strcat (buf
, ", m68000");
3110 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
3111 strcat (buf
, ", cpu32");
3112 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
3113 strcat (buf
, ", fido_a");
3116 char const * isa
= _("unknown");
3117 char const * mac
= _("unknown mac");
3118 char const * additional
= NULL
;
3120 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
3122 case EF_M68K_CF_ISA_A_NODIV
:
3124 additional
= ", nodiv";
3126 case EF_M68K_CF_ISA_A
:
3129 case EF_M68K_CF_ISA_A_PLUS
:
3132 case EF_M68K_CF_ISA_B_NOUSP
:
3134 additional
= ", nousp";
3136 case EF_M68K_CF_ISA_B
:
3139 case EF_M68K_CF_ISA_C
:
3142 case EF_M68K_CF_ISA_C_NODIV
:
3144 additional
= ", nodiv";
3147 strcat (buf
, ", cf, isa ");
3150 strcat (buf
, additional
);
3151 if (e_flags
& EF_M68K_CF_FLOAT
)
3152 strcat (buf
, ", float");
3153 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
3158 case EF_M68K_CF_MAC
:
3161 case EF_M68K_CF_EMAC
:
3164 case EF_M68K_CF_EMAC_B
:
3177 switch (e_flags
& EF_MEP_CPU_MASK
)
3179 case EF_MEP_CPU_MEP
: strcat (buf
, ", generic MeP"); break;
3180 case EF_MEP_CPU_C2
: strcat (buf
, ", MeP C2"); break;
3181 case EF_MEP_CPU_C3
: strcat (buf
, ", MeP C3"); break;
3182 case EF_MEP_CPU_C4
: strcat (buf
, ", MeP C4"); break;
3183 case EF_MEP_CPU_C5
: strcat (buf
, ", MeP C5"); break;
3184 case EF_MEP_CPU_H1
: strcat (buf
, ", MeP H1"); break;
3185 default: strcat (buf
, _(", <unknown MeP cpu type>")); break;
3188 switch (e_flags
& EF_MEP_COP_MASK
)
3190 case EF_MEP_COP_NONE
: break;
3191 case EF_MEP_COP_AVC
: strcat (buf
, ", AVC coprocessor"); break;
3192 case EF_MEP_COP_AVC2
: strcat (buf
, ", AVC2 coprocessor"); break;
3193 case EF_MEP_COP_FMAX
: strcat (buf
, ", FMAX coprocessor"); break;
3194 case EF_MEP_COP_IVC2
: strcat (buf
, ", IVC2 coprocessor"); break;
3195 default: strcat (buf
, _("<unknown MeP copro type>")); break;
3198 if (e_flags
& EF_MEP_LIBRARY
)
3199 strcat (buf
, ", Built for Library");
3201 if (e_flags
& EF_MEP_INDEX_MASK
)
3202 sprintf (buf
+ strlen (buf
), ", Configuration Index: %#x",
3203 e_flags
& EF_MEP_INDEX_MASK
);
3205 if (e_flags
& ~ EF_MEP_ALL_FLAGS
)
3206 sprintf (buf
+ strlen (buf
), _(", unknown flags bits: %#x"),
3207 e_flags
& ~ EF_MEP_ALL_FLAGS
);
3211 if (e_flags
& EF_PPC_EMB
)
3212 strcat (buf
, ", emb");
3214 if (e_flags
& EF_PPC_RELOCATABLE
)
3215 strcat (buf
, _(", relocatable"));
3217 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
3218 strcat (buf
, _(", relocatable-lib"));
3222 if (e_flags
& EF_PPC64_ABI
)
3224 char abi
[] = ", abiv0";
3226 abi
[6] += e_flags
& EF_PPC64_ABI
;
3232 if ((e_flags
& EF_RH850_ABI
) == EF_RH850_ABI
)
3233 strcat (buf
, ", RH850 ABI");
3235 if (e_flags
& EF_V800_850E3
)
3236 strcat (buf
, ", V3 architecture");
3238 if ((e_flags
& (EF_RH850_FPU_DOUBLE
| EF_RH850_FPU_SINGLE
)) == 0)
3239 strcat (buf
, ", FPU not used");
3241 if ((e_flags
& (EF_RH850_REGMODE22
| EF_RH850_REGMODE32
)) == 0)
3242 strcat (buf
, ", regmode: COMMON");
3244 if ((e_flags
& (EF_RH850_GP_FIX
| EF_RH850_GP_NOFIX
)) == 0)
3245 strcat (buf
, ", r4 not used");
3247 if ((e_flags
& (EF_RH850_EP_FIX
| EF_RH850_EP_NOFIX
)) == 0)
3248 strcat (buf
, ", r30 not used");
3250 if ((e_flags
& (EF_RH850_TP_FIX
| EF_RH850_TP_NOFIX
)) == 0)
3251 strcat (buf
, ", r5 not used");
3253 if ((e_flags
& (EF_RH850_REG2_RESERVE
| EF_RH850_REG2_NORESERVE
)) == 0)
3254 strcat (buf
, ", r2 not used");
3256 for (e_flags
&= 0xFFFF; e_flags
; e_flags
&= ~ (e_flags
& - e_flags
))
3258 switch (e_flags
& - e_flags
)
3260 case EF_RH850_FPU_DOUBLE
: strcat (buf
, ", double precision FPU"); break;
3261 case EF_RH850_FPU_SINGLE
: strcat (buf
, ", single precision FPU"); break;
3262 case EF_RH850_REGMODE22
: strcat (buf
, ", regmode:22"); break;
3263 case EF_RH850_REGMODE32
: strcat (buf
, ", regmode:23"); break;
3264 case EF_RH850_GP_FIX
: strcat (buf
, ", r4 fixed"); break;
3265 case EF_RH850_GP_NOFIX
: strcat (buf
, ", r4 free"); break;
3266 case EF_RH850_EP_FIX
: strcat (buf
, ", r30 fixed"); break;
3267 case EF_RH850_EP_NOFIX
: strcat (buf
, ", r30 free"); break;
3268 case EF_RH850_TP_FIX
: strcat (buf
, ", r5 fixed"); break;
3269 case EF_RH850_TP_NOFIX
: strcat (buf
, ", r5 free"); break;
3270 case EF_RH850_REG2_RESERVE
: strcat (buf
, ", r2 fixed"); break;
3271 case EF_RH850_REG2_NORESERVE
: strcat (buf
, ", r2 free"); break;
3278 case EM_CYGNUS_V850
:
3279 switch (e_flags
& EF_V850_ARCH
)
3281 case E_V850E3V5_ARCH
:
3282 strcat (buf
, ", v850e3v5");
3284 case E_V850E2V3_ARCH
:
3285 strcat (buf
, ", v850e2v3");
3288 strcat (buf
, ", v850e2");
3291 strcat (buf
, ", v850e1");
3294 strcat (buf
, ", v850e");
3297 strcat (buf
, ", v850");
3300 strcat (buf
, _(", unknown v850 architecture variant"));
3306 case EM_CYGNUS_M32R
:
3307 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
3308 strcat (buf
, ", m32r");
3312 case EM_MIPS_RS3_LE
:
3313 if (e_flags
& EF_MIPS_NOREORDER
)
3314 strcat (buf
, ", noreorder");
3316 if (e_flags
& EF_MIPS_PIC
)
3317 strcat (buf
, ", pic");
3319 if (e_flags
& EF_MIPS_CPIC
)
3320 strcat (buf
, ", cpic");
3322 if (e_flags
& EF_MIPS_UCODE
)
3323 strcat (buf
, ", ugen_reserved");
3325 if (e_flags
& EF_MIPS_ABI2
)
3326 strcat (buf
, ", abi2");
3328 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
3329 strcat (buf
, ", odk first");
3331 if (e_flags
& EF_MIPS_32BITMODE
)
3332 strcat (buf
, ", 32bitmode");
3334 if (e_flags
& EF_MIPS_NAN2008
)
3335 strcat (buf
, ", nan2008");
3337 if (e_flags
& EF_MIPS_FP64
)
3338 strcat (buf
, ", fp64");
3340 switch ((e_flags
& EF_MIPS_MACH
))
3342 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
3343 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
3344 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
3345 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
3346 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
3347 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
3348 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
3349 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
3350 case E_MIPS_MACH_5900
: strcat (buf
, ", 5900"); break;
3351 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
3352 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
3353 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
3354 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
3355 case E_MIPS_MACH_LS3A
: strcat (buf
, ", loongson-3a"); break;
3356 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
3357 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
3358 case E_MIPS_MACH_OCTEON3
: strcat (buf
, ", octeon3"); break;
3359 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
3360 case E_MIPS_MACH_IAMR2
: strcat (buf
, ", interaptiv-mr2"); break;
3362 /* We simply ignore the field in this case to avoid confusion:
3363 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3366 default: strcat (buf
, _(", unknown CPU")); break;
3369 switch ((e_flags
& EF_MIPS_ABI
))
3371 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
3372 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
3373 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
3374 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
3376 /* We simply ignore the field in this case to avoid confusion:
3377 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3378 This means it is likely to be an o32 file, but not for
3381 default: strcat (buf
, _(", unknown ABI")); break;
3384 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
3385 strcat (buf
, ", mdmx");
3387 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
3388 strcat (buf
, ", mips16");
3390 if (e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
3391 strcat (buf
, ", micromips");
3393 switch ((e_flags
& EF_MIPS_ARCH
))
3395 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
3396 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
3397 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
3398 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
3399 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
3400 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
3401 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
3402 case E_MIPS_ARCH_32R6
: strcat (buf
, ", mips32r6"); break;
3403 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
3404 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
3405 case E_MIPS_ARCH_64R6
: strcat (buf
, ", mips64r6"); break;
3406 default: strcat (buf
, _(", unknown ISA")); break;
3411 decode_NDS32_machine_flags (e_flags
, buf
, sizeof buf
);
3415 if (e_flags
& EF_RISCV_RVC
)
3416 strcat (buf
, ", RVC");
3418 switch (e_flags
& EF_RISCV_FLOAT_ABI
)
3420 case EF_RISCV_FLOAT_ABI_SOFT
:
3421 strcat (buf
, ", soft-float ABI");
3424 case EF_RISCV_FLOAT_ABI_SINGLE
:
3425 strcat (buf
, ", single-float ABI");
3428 case EF_RISCV_FLOAT_ABI_DOUBLE
:
3429 strcat (buf
, ", double-float ABI");
3432 case EF_RISCV_FLOAT_ABI_QUAD
:
3433 strcat (buf
, ", quad-float ABI");
3439 switch ((e_flags
& EF_SH_MACH_MASK
))
3441 case EF_SH1
: strcat (buf
, ", sh1"); break;
3442 case EF_SH2
: strcat (buf
, ", sh2"); break;
3443 case EF_SH3
: strcat (buf
, ", sh3"); break;
3444 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
3445 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
3446 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
3447 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
3448 case EF_SH4
: strcat (buf
, ", sh4"); break;
3449 case EF_SH5
: strcat (buf
, ", sh5"); break;
3450 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
3451 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
3452 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
3453 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
3454 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
3455 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
3456 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
3457 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
3458 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3459 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
3460 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
3461 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
3462 default: strcat (buf
, _(", unknown ISA")); break;
3465 if (e_flags
& EF_SH_PIC
)
3466 strcat (buf
, ", pic");
3468 if (e_flags
& EF_SH_FDPIC
)
3469 strcat (buf
, ", fdpic");
3473 if (e_flags
& EF_OR1K_NODELAY
)
3474 strcat (buf
, ", no delay");
3478 if (e_flags
& EF_SPARC_32PLUS
)
3479 strcat (buf
, ", v8+");
3481 if (e_flags
& EF_SPARC_SUN_US1
)
3482 strcat (buf
, ", ultrasparcI");
3484 if (e_flags
& EF_SPARC_SUN_US3
)
3485 strcat (buf
, ", ultrasparcIII");
3487 if (e_flags
& EF_SPARC_HAL_R1
)
3488 strcat (buf
, ", halr1");
3490 if (e_flags
& EF_SPARC_LEDATA
)
3491 strcat (buf
, ", ledata");
3493 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
3494 strcat (buf
, ", tso");
3496 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
3497 strcat (buf
, ", pso");
3499 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
3500 strcat (buf
, ", rmo");
3504 switch (e_flags
& EF_PARISC_ARCH
)
3506 case EFA_PARISC_1_0
:
3507 strcpy (buf
, ", PA-RISC 1.0");
3509 case EFA_PARISC_1_1
:
3510 strcpy (buf
, ", PA-RISC 1.1");
3512 case EFA_PARISC_2_0
:
3513 strcpy (buf
, ", PA-RISC 2.0");
3518 if (e_flags
& EF_PARISC_TRAPNIL
)
3519 strcat (buf
, ", trapnil");
3520 if (e_flags
& EF_PARISC_EXT
)
3521 strcat (buf
, ", ext");
3522 if (e_flags
& EF_PARISC_LSB
)
3523 strcat (buf
, ", lsb");
3524 if (e_flags
& EF_PARISC_WIDE
)
3525 strcat (buf
, ", wide");
3526 if (e_flags
& EF_PARISC_NO_KABP
)
3527 strcat (buf
, ", no kabp");
3528 if (e_flags
& EF_PARISC_LAZYSWAP
)
3529 strcat (buf
, ", lazyswap");
3534 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
3535 strcat (buf
, ", new calling convention");
3537 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
3538 strcat (buf
, ", gnu calling convention");
3542 if ((e_flags
& EF_IA_64_ABI64
))
3543 strcat (buf
, ", 64-bit");
3545 strcat (buf
, ", 32-bit");
3546 if ((e_flags
& EF_IA_64_REDUCEDFP
))
3547 strcat (buf
, ", reduced fp model");
3548 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
3549 strcat (buf
, ", no function descriptors, constant gp");
3550 else if ((e_flags
& EF_IA_64_CONS_GP
))
3551 strcat (buf
, ", constant gp");
3552 if ((e_flags
& EF_IA_64_ABSOLUTE
))
3553 strcat (buf
, ", absolute");
3554 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
3556 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
3557 strcat (buf
, ", vms_linkages");
3558 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
3560 case EF_IA_64_VMS_COMCOD_SUCCESS
:
3562 case EF_IA_64_VMS_COMCOD_WARNING
:
3563 strcat (buf
, ", warning");
3565 case EF_IA_64_VMS_COMCOD_ERROR
:
3566 strcat (buf
, ", error");
3568 case EF_IA_64_VMS_COMCOD_ABORT
:
3569 strcat (buf
, ", abort");
3572 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3573 e_flags
& EF_IA_64_VMS_COMCOD
);
3574 strcat (buf
, ", <unknown>");
3580 if ((e_flags
& EF_VAX_NONPIC
))
3581 strcat (buf
, ", non-PIC");
3582 if ((e_flags
& EF_VAX_DFLOAT
))
3583 strcat (buf
, ", D-Float");
3584 if ((e_flags
& EF_VAX_GFLOAT
))
3585 strcat (buf
, ", G-Float");
3589 if (e_flags
& EF_VISIUM_ARCH_MCM
)
3590 strcat (buf
, ", mcm");
3591 else if (e_flags
& EF_VISIUM_ARCH_MCM24
)
3592 strcat (buf
, ", mcm24");
3593 if (e_flags
& EF_VISIUM_ARCH_GR6
)
3594 strcat (buf
, ", gr6");
3598 switch (e_flags
& E_FLAG_RL78_CPU_MASK
)
3600 case E_FLAG_RL78_ANY_CPU
: break;
3601 case E_FLAG_RL78_G10
: strcat (buf
, ", G10"); break;
3602 case E_FLAG_RL78_G13
: strcat (buf
, ", G13"); break;
3603 case E_FLAG_RL78_G14
: strcat (buf
, ", G14"); break;
3605 if (e_flags
& E_FLAG_RL78_64BIT_DOUBLES
)
3606 strcat (buf
, ", 64-bit doubles");
3610 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
3611 strcat (buf
, ", 64-bit doubles");
3612 if (e_flags
& E_FLAG_RX_DSP
)
3613 strcat (buf
, ", dsp");
3614 if (e_flags
& E_FLAG_RX_PID
)
3615 strcat (buf
, ", pid");
3616 if (e_flags
& E_FLAG_RX_ABI
)
3617 strcat (buf
, ", RX ABI");
3618 if (e_flags
& E_FLAG_RX_SINSNS_SET
)
3619 strcat (buf
, e_flags
& E_FLAG_RX_SINSNS_YES
3620 ? ", uses String instructions" : ", bans String instructions");
3621 if (e_flags
& E_FLAG_RX_V2
)
3622 strcat (buf
, ", V2");
3626 if (e_flags
& EF_S390_HIGH_GPRS
)
3627 strcat (buf
, ", highgprs");
3631 if ((e_flags
& EF_C6000_REL
))
3632 strcat (buf
, ", relocatable module");
3636 strcat (buf
, _(": architecture variant: "));
3637 switch (e_flags
& EF_MSP430_MACH
)
3639 case E_MSP430_MACH_MSP430x11
: strcat (buf
, "MSP430x11"); break;
3640 case E_MSP430_MACH_MSP430x11x1
: strcat (buf
, "MSP430x11x1 "); break;
3641 case E_MSP430_MACH_MSP430x12
: strcat (buf
, "MSP430x12"); break;
3642 case E_MSP430_MACH_MSP430x13
: strcat (buf
, "MSP430x13"); break;
3643 case E_MSP430_MACH_MSP430x14
: strcat (buf
, "MSP430x14"); break;
3644 case E_MSP430_MACH_MSP430x15
: strcat (buf
, "MSP430x15"); break;
3645 case E_MSP430_MACH_MSP430x16
: strcat (buf
, "MSP430x16"); break;
3646 case E_MSP430_MACH_MSP430x31
: strcat (buf
, "MSP430x31"); break;
3647 case E_MSP430_MACH_MSP430x32
: strcat (buf
, "MSP430x32"); break;
3648 case E_MSP430_MACH_MSP430x33
: strcat (buf
, "MSP430x33"); break;
3649 case E_MSP430_MACH_MSP430x41
: strcat (buf
, "MSP430x41"); break;
3650 case E_MSP430_MACH_MSP430x42
: strcat (buf
, "MSP430x42"); break;
3651 case E_MSP430_MACH_MSP430x43
: strcat (buf
, "MSP430x43"); break;
3652 case E_MSP430_MACH_MSP430x44
: strcat (buf
, "MSP430x44"); break;
3653 case E_MSP430_MACH_MSP430X
: strcat (buf
, "MSP430X"); break;
3655 strcat (buf
, _(": unknown")); break;
3658 if (e_flags
& ~ EF_MSP430_MACH
)
3659 strcat (buf
, _(": unknown extra flag bits also present"));
3667 get_osabi_name (unsigned int osabi
)
3669 static char buff
[32];
3673 case ELFOSABI_NONE
: return "UNIX - System V";
3674 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
3675 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
3676 case ELFOSABI_GNU
: return "UNIX - GNU";
3677 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
3678 case ELFOSABI_AIX
: return "UNIX - AIX";
3679 case ELFOSABI_IRIX
: return "UNIX - IRIX";
3680 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
3681 case ELFOSABI_TRU64
: return "UNIX - TRU64";
3682 case ELFOSABI_MODESTO
: return "Novell - Modesto";
3683 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
3684 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
3685 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
3686 case ELFOSABI_AROS
: return "AROS";
3687 case ELFOSABI_FENIXOS
: return "FenixOS";
3688 case ELFOSABI_CLOUDABI
: return "Nuxi CloudABI";
3689 case ELFOSABI_OPENVOS
: return "Stratus Technologies OpenVOS";
3692 switch (elf_header
.e_machine
)
3697 case ELFOSABI_ARM
: return "ARM";
3708 case ELFOSABI_STANDALONE
: return _("Standalone App");
3717 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
3718 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
3727 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
3733 get_aarch64_segment_type (unsigned long type
)
3737 case PT_AARCH64_ARCHEXT
: return "AARCH64_ARCHEXT";
3738 default: return NULL
;
3743 get_arm_segment_type (unsigned long type
)
3747 case PT_ARM_EXIDX
: return "EXIDX";
3748 default: return NULL
;
3753 get_s390_segment_type (unsigned long type
)
3757 case PT_S390_PGSTE
: return "S390_PGSTE";
3758 default: return NULL
;
3763 get_mips_segment_type (unsigned long type
)
3767 case PT_MIPS_REGINFO
: return "REGINFO";
3768 case PT_MIPS_RTPROC
: return "RTPROC";
3769 case PT_MIPS_OPTIONS
: return "OPTIONS";
3770 case PT_MIPS_ABIFLAGS
: return "ABIFLAGS";
3771 default: return NULL
;
3776 get_parisc_segment_type (unsigned long type
)
3780 case PT_HP_TLS
: return "HP_TLS";
3781 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
3782 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
3783 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
3784 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
3785 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
3786 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
3787 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
3788 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
3789 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
3790 case PT_HP_PARALLEL
: return "HP_PARALLEL";
3791 case PT_HP_FASTBIND
: return "HP_FASTBIND";
3792 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
3793 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
3794 case PT_HP_STACK
: return "HP_STACK";
3795 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
3796 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
3797 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
3798 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
3799 default: return NULL
;
3804 get_ia64_segment_type (unsigned long type
)
3808 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
3809 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
3810 case PT_HP_TLS
: return "HP_TLS";
3811 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
3812 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
3813 case PT_IA_64_HP_STACK
: return "HP_STACK";
3814 default: return NULL
;
3819 get_tic6x_segment_type (unsigned long type
)
3823 case PT_C6000_PHATTR
: return "C6000_PHATTR";
3824 default: return NULL
;
3829 get_solaris_segment_type (unsigned long type
)
3833 case 0x6464e550: return "PT_SUNW_UNWIND";
3834 case 0x6474e550: return "PT_SUNW_EH_FRAME";
3835 case 0x6ffffff7: return "PT_LOSUNW";
3836 case 0x6ffffffa: return "PT_SUNWBSS";
3837 case 0x6ffffffb: return "PT_SUNWSTACK";
3838 case 0x6ffffffc: return "PT_SUNWDTRACE";
3839 case 0x6ffffffd: return "PT_SUNWCAP";
3840 case 0x6fffffff: return "PT_HISUNW";
3841 default: return NULL
;
3846 get_segment_type (unsigned long p_type
)
3848 static char buff
[32];
3852 case PT_NULL
: return "NULL";
3853 case PT_LOAD
: return "LOAD";
3854 case PT_DYNAMIC
: return "DYNAMIC";
3855 case PT_INTERP
: return "INTERP";
3856 case PT_NOTE
: return "NOTE";
3857 case PT_SHLIB
: return "SHLIB";
3858 case PT_PHDR
: return "PHDR";
3859 case PT_TLS
: return "TLS";
3860 case PT_GNU_EH_FRAME
: return "GNU_EH_FRAME";
3861 case PT_GNU_STACK
: return "GNU_STACK";
3862 case PT_GNU_RELRO
: return "GNU_RELRO";
3865 if (p_type
>= PT_GNU_MBIND_LO
&& p_type
<= PT_GNU_MBIND_HI
)
3867 sprintf (buff
, "GNU_MBIND+%#lx",
3868 p_type
- PT_GNU_MBIND_LO
);
3870 else if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
3872 const char * result
;
3874 switch (elf_header
.e_machine
)
3877 result
= get_aarch64_segment_type (p_type
);
3880 result
= get_arm_segment_type (p_type
);
3883 case EM_MIPS_RS3_LE
:
3884 result
= get_mips_segment_type (p_type
);
3887 result
= get_parisc_segment_type (p_type
);
3890 result
= get_ia64_segment_type (p_type
);
3893 result
= get_tic6x_segment_type (p_type
);
3897 result
= get_s390_segment_type (p_type
);
3907 sprintf (buff
, "LOPROC+%#lx", p_type
- PT_LOPROC
);
3909 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
3911 const char * result
;
3913 switch (elf_header
.e_machine
)
3916 result
= get_parisc_segment_type (p_type
);
3919 result
= get_ia64_segment_type (p_type
);
3922 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
3923 result
= get_solaris_segment_type (p_type
);
3932 sprintf (buff
, "LOOS+%#lx", p_type
- PT_LOOS
);
3935 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
3942 get_arc_section_type_name (unsigned int sh_type
)
3946 case SHT_ARC_ATTRIBUTES
: return "ARC_ATTRIBUTES";
3954 get_mips_section_type_name (unsigned int sh_type
)
3958 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
3959 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
3960 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
3961 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
3962 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
3963 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
3964 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
3965 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
3966 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
3967 case SHT_MIPS_RELD
: return "MIPS_RELD";
3968 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
3969 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
3970 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
3971 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
3972 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
3973 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
3974 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
3975 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
3976 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
3977 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
3978 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
3979 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
3980 case SHT_MIPS_LINE
: return "MIPS_LINE";
3981 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
3982 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
3983 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
3984 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
3985 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
3986 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
3987 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
3988 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
3989 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
3990 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
3991 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
3992 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
3993 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
3994 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
3995 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
3996 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
3997 case SHT_MIPS_ABIFLAGS
: return "MIPS_ABIFLAGS";
4005 get_parisc_section_type_name (unsigned int sh_type
)
4009 case SHT_PARISC_EXT
: return "PARISC_EXT";
4010 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
4011 case SHT_PARISC_DOC
: return "PARISC_DOC";
4012 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
4013 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
4014 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
4015 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
4016 default: return NULL
;
4021 get_ia64_section_type_name (unsigned int sh_type
)
4023 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
4024 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
4025 return get_osabi_name ((sh_type
& 0x00FF0000) >> 16);
4029 case SHT_IA_64_EXT
: return "IA_64_EXT";
4030 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
4031 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
4032 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
4033 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
4034 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
4035 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
4036 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
4037 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
4038 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
4046 get_x86_64_section_type_name (unsigned int sh_type
)
4050 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
4051 default: return NULL
;
4056 get_aarch64_section_type_name (unsigned int sh_type
)
4060 case SHT_AARCH64_ATTRIBUTES
: return "AARCH64_ATTRIBUTES";
4061 default: return NULL
;
4066 get_arm_section_type_name (unsigned int sh_type
)
4070 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
4071 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
4072 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
4073 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
4074 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
4075 default: return NULL
;
4080 get_tic6x_section_type_name (unsigned int sh_type
)
4084 case SHT_C6000_UNWIND
: return "C6000_UNWIND";
4085 case SHT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
4086 case SHT_C6000_ATTRIBUTES
: return "C6000_ATTRIBUTES";
4087 case SHT_TI_ICODE
: return "TI_ICODE";
4088 case SHT_TI_XREF
: return "TI_XREF";
4089 case SHT_TI_HANDLER
: return "TI_HANDLER";
4090 case SHT_TI_INITINFO
: return "TI_INITINFO";
4091 case SHT_TI_PHATTRS
: return "TI_PHATTRS";
4092 default: return NULL
;
4097 get_msp430x_section_type_name (unsigned int sh_type
)
4101 case SHT_MSP430_SEC_FLAGS
: return "MSP430_SEC_FLAGS";
4102 case SHT_MSP430_SYM_ALIASES
: return "MSP430_SYM_ALIASES";
4103 case SHT_MSP430_ATTRIBUTES
: return "MSP430_ATTRIBUTES";
4104 default: return NULL
;
4109 get_v850_section_type_name (unsigned int sh_type
)
4113 case SHT_V850_SCOMMON
: return "V850 Small Common";
4114 case SHT_V850_TCOMMON
: return "V850 Tiny Common";
4115 case SHT_V850_ZCOMMON
: return "V850 Zero Common";
4116 case SHT_RENESAS_IOP
: return "RENESAS IOP";
4117 case SHT_RENESAS_INFO
: return "RENESAS INFO";
4118 default: return NULL
;
4123 get_section_type_name (unsigned int sh_type
)
4125 static char buff
[32];
4126 const char * result
;
4130 case SHT_NULL
: return "NULL";
4131 case SHT_PROGBITS
: return "PROGBITS";
4132 case SHT_SYMTAB
: return "SYMTAB";
4133 case SHT_STRTAB
: return "STRTAB";
4134 case SHT_RELA
: return "RELA";
4135 case SHT_HASH
: return "HASH";
4136 case SHT_DYNAMIC
: return "DYNAMIC";
4137 case SHT_NOTE
: return "NOTE";
4138 case SHT_NOBITS
: return "NOBITS";
4139 case SHT_REL
: return "REL";
4140 case SHT_SHLIB
: return "SHLIB";
4141 case SHT_DYNSYM
: return "DYNSYM";
4142 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
4143 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
4144 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
4145 case SHT_GNU_HASH
: return "GNU_HASH";
4146 case SHT_GROUP
: return "GROUP";
4147 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
4148 case SHT_GNU_verdef
: return "VERDEF";
4149 case SHT_GNU_verneed
: return "VERNEED";
4150 case SHT_GNU_versym
: return "VERSYM";
4151 case 0x6ffffff0: return "VERSYM";
4152 case 0x6ffffffc: return "VERDEF";
4153 case 0x7ffffffd: return "AUXILIARY";
4154 case 0x7fffffff: return "FILTER";
4155 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
4158 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
4160 switch (elf_header
.e_machine
)
4163 case EM_ARC_COMPACT
:
4164 case EM_ARC_COMPACT2
:
4165 result
= get_arc_section_type_name (sh_type
);
4168 case EM_MIPS_RS3_LE
:
4169 result
= get_mips_section_type_name (sh_type
);
4172 result
= get_parisc_section_type_name (sh_type
);
4175 result
= get_ia64_section_type_name (sh_type
);
4180 result
= get_x86_64_section_type_name (sh_type
);
4183 result
= get_aarch64_section_type_name (sh_type
);
4186 result
= get_arm_section_type_name (sh_type
);
4189 result
= get_tic6x_section_type_name (sh_type
);
4192 result
= get_msp430x_section_type_name (sh_type
);
4196 case EM_CYGNUS_V850
:
4197 result
= get_v850_section_type_name (sh_type
);
4207 sprintf (buff
, "LOPROC+%#x", sh_type
- SHT_LOPROC
);
4209 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
4211 switch (elf_header
.e_machine
)
4214 result
= get_ia64_section_type_name (sh_type
);
4217 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
4218 result
= get_solaris_section_type (sh_type
);
4223 case SHT_GNU_INCREMENTAL_INPUTS
: result
= "GNU_INCREMENTAL_INPUTS"; break;
4224 case SHT_GNU_ATTRIBUTES
: result
= "GNU_ATTRIBUTES"; break;
4225 case SHT_GNU_HASH
: result
= "GNU_HASH"; break;
4226 case SHT_GNU_LIBLIST
: result
= "GNU_LIBLIST"; break;
4238 sprintf (buff
, "LOOS+%#x", sh_type
- SHT_LOOS
);
4240 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
4242 switch (elf_header
.e_machine
)
4246 case EM_CYGNUS_V850
:
4247 result
= get_v850_section_type_name (sh_type
);
4257 sprintf (buff
, "LOUSER+%#x", sh_type
- SHT_LOUSER
);
4260 /* This message is probably going to be displayed in a 15
4261 character wide field, so put the hex value first. */
4262 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
4268 #define OPTION_DEBUG_DUMP 512
4269 #define OPTION_DYN_SYMS 513
4270 #define OPTION_DWARF_DEPTH 514
4271 #define OPTION_DWARF_START 515
4272 #define OPTION_DWARF_CHECK 516
4274 static struct option options
[] =
4276 {"all", no_argument
, 0, 'a'},
4277 {"file-header", no_argument
, 0, 'h'},
4278 {"program-headers", no_argument
, 0, 'l'},
4279 {"headers", no_argument
, 0, 'e'},
4280 {"histogram", no_argument
, 0, 'I'},
4281 {"segments", no_argument
, 0, 'l'},
4282 {"sections", no_argument
, 0, 'S'},
4283 {"section-headers", no_argument
, 0, 'S'},
4284 {"section-groups", no_argument
, 0, 'g'},
4285 {"section-details", no_argument
, 0, 't'},
4286 {"full-section-name",no_argument
, 0, 'N'},
4287 {"symbols", no_argument
, 0, 's'},
4288 {"syms", no_argument
, 0, 's'},
4289 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
4290 {"relocs", no_argument
, 0, 'r'},
4291 {"notes", no_argument
, 0, 'n'},
4292 {"dynamic", no_argument
, 0, 'd'},
4293 {"arch-specific", no_argument
, 0, 'A'},
4294 {"version-info", no_argument
, 0, 'V'},
4295 {"use-dynamic", no_argument
, 0, 'D'},
4296 {"unwind", no_argument
, 0, 'u'},
4297 {"archive-index", no_argument
, 0, 'c'},
4298 {"hex-dump", required_argument
, 0, 'x'},
4299 {"relocated-dump", required_argument
, 0, 'R'},
4300 {"string-dump", required_argument
, 0, 'p'},
4301 {"decompress", no_argument
, 0, 'z'},
4302 #ifdef SUPPORT_DISASSEMBLY
4303 {"instruction-dump", required_argument
, 0, 'i'},
4305 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
4307 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
4308 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
4309 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
4311 {"version", no_argument
, 0, 'v'},
4312 {"wide", no_argument
, 0, 'W'},
4313 {"help", no_argument
, 0, 'H'},
4314 {0, no_argument
, 0, 0}
4318 usage (FILE * stream
)
4320 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
4321 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
4322 fprintf (stream
, _(" Options are:\n\
4323 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4324 -h --file-header Display the ELF file header\n\
4325 -l --program-headers Display the program headers\n\
4326 --segments An alias for --program-headers\n\
4327 -S --section-headers Display the sections' header\n\
4328 --sections An alias for --section-headers\n\
4329 -g --section-groups Display the section groups\n\
4330 -t --section-details Display the section details\n\
4331 -e --headers Equivalent to: -h -l -S\n\
4332 -s --syms Display the symbol table\n\
4333 --symbols An alias for --syms\n\
4334 --dyn-syms Display the dynamic symbol table\n\
4335 -n --notes Display the core notes (if present)\n\
4336 -r --relocs Display the relocations (if present)\n\
4337 -u --unwind Display the unwind info (if present)\n\
4338 -d --dynamic Display the dynamic section (if present)\n\
4339 -V --version-info Display the version sections (if present)\n\
4340 -A --arch-specific Display architecture specific information (if any)\n\
4341 -c --archive-index Display the symbol/file index in an archive\n\
4342 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
4343 -x --hex-dump=<number|name>\n\
4344 Dump the contents of section <number|name> as bytes\n\
4345 -p --string-dump=<number|name>\n\
4346 Dump the contents of section <number|name> as strings\n\
4347 -R --relocated-dump=<number|name>\n\
4348 Dump the contents of section <number|name> as relocated bytes\n\
4349 -z --decompress Decompress section before dumping it\n\
4350 -w[lLiaprmfFsoRt] or\n\
4351 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4352 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4353 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4355 Display the contents of DWARF2 debug sections\n"));
4356 fprintf (stream
, _("\
4357 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4358 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4360 #ifdef SUPPORT_DISASSEMBLY
4361 fprintf (stream
, _("\
4362 -i --instruction-dump=<number|name>\n\
4363 Disassemble the contents of section <number|name>\n"));
4365 fprintf (stream
, _("\
4366 -I --histogram Display histogram of bucket list lengths\n\
4367 -W --wide Allow output width to exceed 80 characters\n\
4368 @<file> Read options from <file>\n\
4369 -H --help Display this information\n\
4370 -v --version Display the version number of readelf\n"));
4372 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
4373 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
4375 exit (stream
== stdout
? 0 : 1);
4378 /* Record the fact that the user wants the contents of section number
4379 SECTION to be displayed using the method(s) encoded as flags bits
4380 in TYPE. Note, TYPE can be zero if we are creating the array for
4384 request_dump_bynumber (unsigned int section
, dump_type type
)
4386 if (section
>= num_dump_sects
)
4388 dump_type
* new_dump_sects
;
4390 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
4391 sizeof (* dump_sects
));
4393 if (new_dump_sects
== NULL
)
4394 error (_("Out of memory allocating dump request table.\n"));
4399 /* Copy current flag settings. */
4400 memcpy (new_dump_sects
, dump_sects
, num_dump_sects
* sizeof (* dump_sects
));
4405 dump_sects
= new_dump_sects
;
4406 num_dump_sects
= section
+ 1;
4411 dump_sects
[section
] |= type
;
4416 /* Request a dump by section name. */
4419 request_dump_byname (const char * section
, dump_type type
)
4421 struct dump_list_entry
* new_request
;
4423 new_request
= (struct dump_list_entry
*)
4424 malloc (sizeof (struct dump_list_entry
));
4426 error (_("Out of memory allocating dump request table.\n"));
4428 new_request
->name
= strdup (section
);
4429 if (!new_request
->name
)
4430 error (_("Out of memory allocating dump request table.\n"));
4432 new_request
->type
= type
;
4434 new_request
->next
= dump_sects_byname
;
4435 dump_sects_byname
= new_request
;
4439 request_dump (dump_type type
)
4445 section
= strtoul (optarg
, & cp
, 0);
4447 if (! *cp
&& section
>= 0)
4448 request_dump_bynumber (section
, type
);
4450 request_dump_byname (optarg
, type
);
4455 parse_args (int argc
, char ** argv
)
4462 while ((c
= getopt_long
4463 (argc
, argv
, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options
, NULL
)) != EOF
)
4481 do_section_groups
= TRUE
;
4484 do_histogram
= TRUE
;
4489 do_section_groups
= TRUE
;
4494 do_section_details
= TRUE
;
4505 do_using_dynamic
= TRUE
;
4529 do_histogram
= TRUE
;
4535 do_archive_index
= TRUE
;
4538 request_dump (HEX_DUMP
);
4541 request_dump (STRING_DUMP
);
4544 request_dump (RELOC_DUMP
);
4547 decompress_dumps
= TRUE
;
4553 do_debugging
= TRUE
;
4554 dwarf_select_sections_all ();
4558 do_debugging
= FALSE
;
4559 dwarf_select_sections_by_letters (optarg
);
4562 case OPTION_DEBUG_DUMP
:
4565 do_debugging
= TRUE
;
4568 do_debugging
= FALSE
;
4569 dwarf_select_sections_by_names (optarg
);
4572 case OPTION_DWARF_DEPTH
:
4576 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
4579 case OPTION_DWARF_START
:
4583 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
4586 case OPTION_DWARF_CHECK
:
4589 case OPTION_DYN_SYMS
:
4592 #ifdef SUPPORT_DISASSEMBLY
4594 request_dump (DISASS_DUMP
);
4598 print_version (program_name
);
4607 /* xgettext:c-format */
4608 error (_("Invalid option '-%c'\n"), c
);
4615 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
4616 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
4617 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
4618 && !do_section_groups
&& !do_archive_index
4624 get_elf_class (unsigned int elf_class
)
4626 static char buff
[32];
4630 case ELFCLASSNONE
: return _("none");
4631 case ELFCLASS32
: return "ELF32";
4632 case ELFCLASS64
: return "ELF64";
4634 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
4640 get_data_encoding (unsigned int encoding
)
4642 static char buff
[32];
4646 case ELFDATANONE
: return _("none");
4647 case ELFDATA2LSB
: return _("2's complement, little endian");
4648 case ELFDATA2MSB
: return _("2's complement, big endian");
4650 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
4655 /* Decode the data held in 'elf_header'. */
4658 process_file_header (void)
4660 if ( elf_header
.e_ident
[EI_MAG0
] != ELFMAG0
4661 || elf_header
.e_ident
[EI_MAG1
] != ELFMAG1
4662 || elf_header
.e_ident
[EI_MAG2
] != ELFMAG2
4663 || elf_header
.e_ident
[EI_MAG3
] != ELFMAG3
)
4666 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4670 init_dwarf_regnames (elf_header
.e_machine
);
4676 printf (_("ELF Header:\n"));
4677 printf (_(" Magic: "));
4678 for (i
= 0; i
< EI_NIDENT
; i
++)
4679 printf ("%2.2x ", elf_header
.e_ident
[i
]);
4681 printf (_(" Class: %s\n"),
4682 get_elf_class (elf_header
.e_ident
[EI_CLASS
]));
4683 printf (_(" Data: %s\n"),
4684 get_data_encoding (elf_header
.e_ident
[EI_DATA
]));
4685 printf (_(" Version: %d %s\n"),
4686 elf_header
.e_ident
[EI_VERSION
],
4687 (elf_header
.e_ident
[EI_VERSION
] == EV_CURRENT
4689 : (elf_header
.e_ident
[EI_VERSION
] != EV_NONE
4690 ? _("<unknown: %lx>")
4692 printf (_(" OS/ABI: %s\n"),
4693 get_osabi_name (elf_header
.e_ident
[EI_OSABI
]));
4694 printf (_(" ABI Version: %d\n"),
4695 elf_header
.e_ident
[EI_ABIVERSION
]);
4696 printf (_(" Type: %s\n"),
4697 get_file_type (elf_header
.e_type
));
4698 printf (_(" Machine: %s\n"),
4699 get_machine_name (elf_header
.e_machine
));
4700 printf (_(" Version: 0x%lx\n"),
4701 (unsigned long) elf_header
.e_version
);
4703 printf (_(" Entry point address: "));
4704 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
4705 printf (_("\n Start of program headers: "));
4706 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
4707 printf (_(" (bytes into file)\n Start of section headers: "));
4708 print_vma ((bfd_vma
) elf_header
.e_shoff
, DEC
);
4709 printf (_(" (bytes into file)\n"));
4711 printf (_(" Flags: 0x%lx%s\n"),
4712 (unsigned long) elf_header
.e_flags
,
4713 get_machine_flags (elf_header
.e_flags
, elf_header
.e_machine
));
4714 printf (_(" Size of this header: %ld (bytes)\n"),
4715 (long) elf_header
.e_ehsize
);
4716 printf (_(" Size of program headers: %ld (bytes)\n"),
4717 (long) elf_header
.e_phentsize
);
4718 printf (_(" Number of program headers: %ld"),
4719 (long) elf_header
.e_phnum
);
4720 if (section_headers
!= NULL
4721 && elf_header
.e_phnum
== PN_XNUM
4722 && section_headers
[0].sh_info
!= 0)
4723 printf (" (%ld)", (long) section_headers
[0].sh_info
);
4724 putc ('\n', stdout
);
4725 printf (_(" Size of section headers: %ld (bytes)\n"),
4726 (long) elf_header
.e_shentsize
);
4727 printf (_(" Number of section headers: %ld"),
4728 (long) elf_header
.e_shnum
);
4729 if (section_headers
!= NULL
&& elf_header
.e_shnum
== SHN_UNDEF
)
4730 printf (" (%ld)", (long) section_headers
[0].sh_size
);
4731 putc ('\n', stdout
);
4732 printf (_(" Section header string table index: %ld"),
4733 (long) elf_header
.e_shstrndx
);
4734 if (section_headers
!= NULL
4735 && elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
4736 printf (" (%u)", section_headers
[0].sh_link
);
4737 else if (elf_header
.e_shstrndx
!= SHN_UNDEF
4738 && elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
4739 printf (_(" <corrupt: out of range>"));
4740 putc ('\n', stdout
);
4743 if (section_headers
!= NULL
)
4745 if (elf_header
.e_phnum
== PN_XNUM
4746 && section_headers
[0].sh_info
!= 0)
4747 elf_header
.e_phnum
= section_headers
[0].sh_info
;
4748 if (elf_header
.e_shnum
== SHN_UNDEF
)
4749 elf_header
.e_shnum
= section_headers
[0].sh_size
;
4750 if (elf_header
.e_shstrndx
== (SHN_XINDEX
& 0xffff))
4751 elf_header
.e_shstrndx
= section_headers
[0].sh_link
;
4752 else if (elf_header
.e_shstrndx
>= elf_header
.e_shnum
)
4753 elf_header
.e_shstrndx
= SHN_UNDEF
;
4754 free (section_headers
);
4755 section_headers
= NULL
;
4762 get_32bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
4764 Elf32_External_Phdr
* phdrs
;
4765 Elf32_External_Phdr
* external
;
4766 Elf_Internal_Phdr
* internal
;
4768 unsigned int size
= elf_header
.e_phentsize
;
4769 unsigned int num
= elf_header
.e_phnum
;
4771 /* PR binutils/17531: Cope with unexpected section header sizes. */
4772 if (size
== 0 || num
== 0)
4774 if (size
< sizeof * phdrs
)
4776 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4779 if (size
> sizeof * phdrs
)
4780 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4782 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
4783 size
, num
, _("program headers"));
4787 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4788 i
< elf_header
.e_phnum
;
4789 i
++, internal
++, external
++)
4791 internal
->p_type
= BYTE_GET (external
->p_type
);
4792 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4793 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4794 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4795 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4796 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4797 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4798 internal
->p_align
= BYTE_GET (external
->p_align
);
4806 get_64bit_program_headers (FILE * file
, Elf_Internal_Phdr
* pheaders
)
4808 Elf64_External_Phdr
* phdrs
;
4809 Elf64_External_Phdr
* external
;
4810 Elf_Internal_Phdr
* internal
;
4812 unsigned int size
= elf_header
.e_phentsize
;
4813 unsigned int num
= elf_header
.e_phnum
;
4815 /* PR binutils/17531: Cope with unexpected section header sizes. */
4816 if (size
== 0 || num
== 0)
4818 if (size
< sizeof * phdrs
)
4820 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4823 if (size
> sizeof * phdrs
)
4824 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4826 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, file
, elf_header
.e_phoff
,
4827 size
, num
, _("program headers"));
4831 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4832 i
< elf_header
.e_phnum
;
4833 i
++, internal
++, external
++)
4835 internal
->p_type
= BYTE_GET (external
->p_type
);
4836 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4837 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4838 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4839 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4840 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4841 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4842 internal
->p_align
= BYTE_GET (external
->p_align
);
4849 /* Returns TRUE if the program headers were read into `program_headers'. */
4852 get_program_headers (FILE * file
)
4854 Elf_Internal_Phdr
* phdrs
;
4856 /* Check cache of prior read. */
4857 if (program_headers
!= NULL
)
4860 /* Be kind to memory checkers by looking for
4861 e_phnum values which we know must be invalid. */
4862 if (elf_header
.e_phnum
4863 * (is_32bit_elf
? sizeof (Elf32_External_Phdr
) : sizeof (Elf64_External_Phdr
))
4864 >= current_file_size
)
4866 error (_("Too many program headers - %#x - the file is not that big\n"),
4867 elf_header
.e_phnum
);
4871 phdrs
= (Elf_Internal_Phdr
*) cmalloc (elf_header
.e_phnum
,
4872 sizeof (Elf_Internal_Phdr
));
4875 error (_("Out of memory reading %u program headers\n"),
4876 elf_header
.e_phnum
);
4881 ? get_32bit_program_headers (file
, phdrs
)
4882 : get_64bit_program_headers (file
, phdrs
))
4884 program_headers
= phdrs
;
4892 /* Returns TRUE if the program headers were loaded. */
4895 process_program_headers (FILE * file
)
4897 Elf_Internal_Phdr
* segment
;
4899 Elf_Internal_Phdr
* previous_load
= NULL
;
4901 if (elf_header
.e_phnum
== 0)
4903 /* PR binutils/12467. */
4904 if (elf_header
.e_phoff
!= 0)
4906 warn (_("possibly corrupt ELF header - it has a non-zero program"
4907 " header offset, but no program headers\n"));
4910 else if (do_segments
)
4911 printf (_("\nThere are no program headers in this file.\n"));
4915 if (do_segments
&& !do_header
)
4917 printf (_("\nElf file type is %s\n"), get_file_type (elf_header
.e_type
));
4918 printf (_("Entry point "));
4919 print_vma ((bfd_vma
) elf_header
.e_entry
, PREFIX_HEX
);
4920 printf (_("\nThere are %d program headers, starting at offset "),
4921 elf_header
.e_phnum
);
4922 print_vma ((bfd_vma
) elf_header
.e_phoff
, DEC
);
4926 if (! get_program_headers (file
))
4931 if (elf_header
.e_phnum
> 1)
4932 printf (_("\nProgram Headers:\n"));
4934 printf (_("\nProgram Headers:\n"));
4938 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4941 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4945 (_(" Type Offset VirtAddr PhysAddr\n"));
4947 (_(" FileSiz MemSiz Flags Align\n"));
4954 for (i
= 0, segment
= program_headers
;
4955 i
< elf_header
.e_phnum
;
4960 printf (" %-14.14s ", get_segment_type (segment
->p_type
));
4964 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
4965 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
4966 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
4967 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
4968 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
4970 (segment
->p_flags
& PF_R
? 'R' : ' '),
4971 (segment
->p_flags
& PF_W
? 'W' : ' '),
4972 (segment
->p_flags
& PF_X
? 'E' : ' '));
4973 printf ("%#lx", (unsigned long) segment
->p_align
);
4977 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
4978 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
4981 print_vma (segment
->p_offset
, FULL_HEX
);
4985 print_vma (segment
->p_vaddr
, FULL_HEX
);
4987 print_vma (segment
->p_paddr
, FULL_HEX
);
4990 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
4991 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
4994 print_vma (segment
->p_filesz
, FULL_HEX
);
4998 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
4999 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
5002 print_vma (segment
->p_memsz
, FULL_HEX
);
5006 (segment
->p_flags
& PF_R
? 'R' : ' '),
5007 (segment
->p_flags
& PF_W
? 'W' : ' '),
5008 (segment
->p_flags
& PF_X
? 'E' : ' '));
5010 if ((unsigned long) segment
->p_align
== segment
->p_align
)
5011 printf ("%#lx", (unsigned long) segment
->p_align
);
5014 print_vma (segment
->p_align
, PREFIX_HEX
);
5019 print_vma (segment
->p_offset
, FULL_HEX
);
5021 print_vma (segment
->p_vaddr
, FULL_HEX
);
5023 print_vma (segment
->p_paddr
, FULL_HEX
);
5025 print_vma (segment
->p_filesz
, FULL_HEX
);
5027 print_vma (segment
->p_memsz
, FULL_HEX
);
5029 (segment
->p_flags
& PF_R
? 'R' : ' '),
5030 (segment
->p_flags
& PF_W
? 'W' : ' '),
5031 (segment
->p_flags
& PF_X
? 'E' : ' '));
5032 print_vma (segment
->p_align
, PREFIX_HEX
);
5035 putc ('\n', stdout
);
5038 switch (segment
->p_type
)
5041 #if 0 /* Do not warn about out of order PT_LOAD segments. Although officially
5042 required by the ELF standard, several programs, including the Linux
5043 kernel, make use of non-ordered segments. */
5045 && previous_load
->p_vaddr
> segment
->p_vaddr
)
5046 error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
5048 if (segment
->p_memsz
< segment
->p_filesz
)
5049 error (_("the segment's file size is larger than its memory size\n"));
5050 previous_load
= segment
;
5054 /* PR 20815 - Verify that the program header is loaded into memory. */
5055 if (i
> 0 && previous_load
!= NULL
)
5056 error (_("the PHDR segment must occur before any LOAD segment\n"));
5057 if (elf_header
.e_machine
!= EM_PARISC
)
5061 for (j
= 1; j
< elf_header
.e_phnum
; j
++)
5062 if (program_headers
[j
].p_vaddr
<= segment
->p_vaddr
5063 && (program_headers
[j
].p_vaddr
+ program_headers
[j
].p_memsz
)
5064 >= (segment
->p_vaddr
+ segment
->p_filesz
))
5066 if (j
== elf_header
.e_phnum
)
5067 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5073 error (_("more than one dynamic segment\n"));
5075 /* By default, assume that the .dynamic section is the first
5076 section in the DYNAMIC segment. */
5077 dynamic_addr
= segment
->p_offset
;
5078 dynamic_size
= segment
->p_filesz
;
5080 /* Try to locate the .dynamic section. If there is
5081 a section header table, we can easily locate it. */
5082 if (section_headers
!= NULL
)
5084 Elf_Internal_Shdr
* sec
;
5086 sec
= find_section (".dynamic");
5087 if (sec
== NULL
|| sec
->sh_size
== 0)
5089 /* A corresponding .dynamic section is expected, but on
5090 IA-64/OpenVMS it is OK for it to be missing. */
5091 if (!is_ia64_vms ())
5092 error (_("no .dynamic section in the dynamic segment\n"));
5096 if (sec
->sh_type
== SHT_NOBITS
)
5102 dynamic_addr
= sec
->sh_offset
;
5103 dynamic_size
= sec
->sh_size
;
5105 if (dynamic_addr
< segment
->p_offset
5106 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
5107 warn (_("the .dynamic section is not contained"
5108 " within the dynamic segment\n"));
5109 else if (dynamic_addr
> segment
->p_offset
)
5110 warn (_("the .dynamic section is not the first section"
5111 " in the dynamic segment.\n"));
5114 /* PR binutils/17512: Avoid corrupt dynamic section info in the
5115 segment. Check this after matching against the section headers
5116 so we don't warn on debuginfo file (which have NOBITS .dynamic
5118 if (dynamic_addr
+ dynamic_size
>= current_file_size
)
5120 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5121 dynamic_addr
= dynamic_size
= 0;
5126 if (fseek (file
, archive_file_offset
+ (long) segment
->p_offset
,
5128 error (_("Unable to find program interpreter name\n"));
5132 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
- 1);
5134 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
5135 error (_("Internal error: failed to create format string to display program interpreter\n"));
5137 program_interpreter
[0] = 0;
5138 if (fscanf (file
, fmt
, program_interpreter
) <= 0)
5139 error (_("Unable to read program interpreter name\n"));
5142 printf (_(" [Requesting program interpreter: %s]\n"),
5143 program_interpreter
);
5149 if (do_segments
&& section_headers
!= NULL
&& string_table
!= NULL
)
5151 printf (_("\n Section to Segment mapping:\n"));
5152 printf (_(" Segment Sections...\n"));
5154 for (i
= 0; i
< elf_header
.e_phnum
; i
++)
5157 Elf_Internal_Shdr
* section
;
5159 segment
= program_headers
+ i
;
5160 section
= section_headers
+ 1;
5162 printf (" %2.2d ", i
);
5164 for (j
= 1; j
< elf_header
.e_shnum
; j
++, section
++)
5166 if (!ELF_TBSS_SPECIAL (section
, segment
)
5167 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
5168 printf ("%s ", printable_section_name (section
));
5179 /* Find the file offset corresponding to VMA by using the program headers. */
5182 offset_from_vma (FILE * file
, bfd_vma vma
, bfd_size_type size
)
5184 Elf_Internal_Phdr
* seg
;
5186 if (! get_program_headers (file
))
5188 warn (_("Cannot interpret virtual addresses without program headers.\n"));
5192 for (seg
= program_headers
;
5193 seg
< program_headers
+ elf_header
.e_phnum
;
5196 if (seg
->p_type
!= PT_LOAD
)
5199 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
5200 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
5201 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
5204 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5205 (unsigned long) vma
);
5210 /* Allocate memory and load the sections headers into the global pointer
5211 SECTION_HEADERS. If PROBE is true, this is just a probe and we do not
5212 generate any error messages if the load fails. */
5215 get_32bit_section_headers (FILE * file
, bfd_boolean probe
)
5217 Elf32_External_Shdr
* shdrs
;
5218 Elf_Internal_Shdr
* internal
;
5220 unsigned int size
= elf_header
.e_shentsize
;
5221 unsigned int num
= probe
? 1 : elf_header
.e_shnum
;
5223 /* PR binutils/17531: Cope with unexpected section header sizes. */
5224 if (size
== 0 || num
== 0)
5226 if (size
< sizeof * shdrs
)
5229 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5232 if (!probe
&& size
> sizeof * shdrs
)
5233 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5235 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
5237 probe
? NULL
: _("section headers"));
5241 if (section_headers
!= NULL
)
5242 free (section_headers
);
5243 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
5244 sizeof (Elf_Internal_Shdr
));
5245 if (section_headers
== NULL
)
5248 error (_("Out of memory reading %u section headers\n"), num
);
5252 for (i
= 0, internal
= section_headers
;
5256 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5257 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5258 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5259 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5260 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5261 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5262 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5263 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5264 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5265 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5266 if (!probe
&& internal
->sh_link
> num
)
5267 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5268 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5269 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5277 get_64bit_section_headers (FILE * file
, bfd_boolean probe
)
5279 Elf64_External_Shdr
* shdrs
;
5280 Elf_Internal_Shdr
* internal
;
5282 unsigned int size
= elf_header
.e_shentsize
;
5283 unsigned int num
= probe
? 1 : elf_header
.e_shnum
;
5285 /* PR binutils/17531: Cope with unexpected section header sizes. */
5286 if (size
== 0 || num
== 0)
5288 if (size
< sizeof * shdrs
)
5291 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5294 if (! probe
&& size
> sizeof * shdrs
)
5295 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5297 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, file
, elf_header
.e_shoff
,
5299 probe
? NULL
: _("section headers"));
5303 if (section_headers
!= NULL
)
5304 free (section_headers
);
5305 section_headers
= (Elf_Internal_Shdr
*) cmalloc (num
,
5306 sizeof (Elf_Internal_Shdr
));
5307 if (section_headers
== NULL
)
5310 error (_("Out of memory reading %u section headers\n"), num
);
5314 for (i
= 0, internal
= section_headers
;
5318 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5319 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5320 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5321 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5322 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5323 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5324 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5325 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5326 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5327 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5328 if (!probe
&& internal
->sh_link
> num
)
5329 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5330 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5331 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5338 static Elf_Internal_Sym
*
5339 get_32bit_elf_symbols (FILE * file
,
5340 Elf_Internal_Shdr
* section
,
5341 unsigned long * num_syms_return
)
5343 unsigned long number
= 0;
5344 Elf32_External_Sym
* esyms
= NULL
;
5345 Elf_External_Sym_Shndx
* shndx
= NULL
;
5346 Elf_Internal_Sym
* isyms
= NULL
;
5347 Elf_Internal_Sym
* psym
;
5350 if (section
->sh_size
== 0)
5352 if (num_syms_return
!= NULL
)
5353 * num_syms_return
= 0;
5357 /* Run some sanity checks first. */
5358 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5360 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5361 printable_section_name (section
), (unsigned long) section
->sh_entsize
);
5365 if (section
->sh_size
> current_file_size
)
5367 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5368 printable_section_name (section
), (unsigned long) section
->sh_size
);
5372 number
= section
->sh_size
/ section
->sh_entsize
;
5374 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
5376 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5377 (unsigned long) section
->sh_size
,
5378 printable_section_name (section
),
5379 (unsigned long) section
->sh_entsize
);
5383 esyms
= (Elf32_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
5384 section
->sh_size
, _("symbols"));
5389 elf_section_list
* entry
;
5392 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5393 if (entry
->hdr
->sh_link
== (unsigned long) (section
- section_headers
))
5395 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
5396 entry
->hdr
->sh_offset
,
5397 1, entry
->hdr
->sh_size
,
5398 _("symbol table section indicies"));
5401 /* PR17531: file: heap-buffer-overflow */
5402 else if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5404 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5405 printable_section_name (entry
->hdr
),
5406 (unsigned long) entry
->hdr
->sh_size
,
5407 (unsigned long) section
->sh_size
);
5413 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5417 error (_("Out of memory reading %lu symbols\n"),
5418 (unsigned long) number
);
5422 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5424 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5425 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5426 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5427 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5428 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5430 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5431 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5432 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5433 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5434 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5443 if (num_syms_return
!= NULL
)
5444 * num_syms_return
= isyms
== NULL
? 0 : number
;
5449 static Elf_Internal_Sym
*
5450 get_64bit_elf_symbols (FILE * file
,
5451 Elf_Internal_Shdr
* section
,
5452 unsigned long * num_syms_return
)
5454 unsigned long number
= 0;
5455 Elf64_External_Sym
* esyms
= NULL
;
5456 Elf_External_Sym_Shndx
* shndx
= NULL
;
5457 Elf_Internal_Sym
* isyms
= NULL
;
5458 Elf_Internal_Sym
* psym
;
5461 if (section
->sh_size
== 0)
5463 if (num_syms_return
!= NULL
)
5464 * num_syms_return
= 0;
5468 /* Run some sanity checks first. */
5469 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5471 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5472 printable_section_name (section
),
5473 (unsigned long) section
->sh_entsize
);
5477 if (section
->sh_size
> current_file_size
)
5479 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5480 printable_section_name (section
),
5481 (unsigned long) section
->sh_size
);
5485 number
= section
->sh_size
/ section
->sh_entsize
;
5487 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
5489 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5490 (unsigned long) section
->sh_size
,
5491 printable_section_name (section
),
5492 (unsigned long) section
->sh_entsize
);
5496 esyms
= (Elf64_External_Sym
*) get_data (NULL
, file
, section
->sh_offset
, 1,
5497 section
->sh_size
, _("symbols"));
5502 elf_section_list
* entry
;
5505 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5506 if (entry
->hdr
->sh_link
== (unsigned long) (section
- section_headers
))
5508 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, file
,
5509 entry
->hdr
->sh_offset
,
5510 1, entry
->hdr
->sh_size
,
5511 _("symbol table section indicies"));
5514 /* PR17531: file: heap-buffer-overflow */
5515 else if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5517 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5518 printable_section_name (entry
->hdr
),
5519 (unsigned long) entry
->hdr
->sh_size
,
5520 (unsigned long) section
->sh_size
);
5526 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5530 error (_("Out of memory reading %lu symbols\n"),
5531 (unsigned long) number
);
5535 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5537 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5538 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5539 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5540 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5542 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5544 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5545 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5546 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5548 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5549 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5558 if (num_syms_return
!= NULL
)
5559 * num_syms_return
= isyms
== NULL
? 0 : number
;
5565 get_elf_section_flags (bfd_vma sh_flags
)
5567 static char buff
[1024];
5569 unsigned int field_size
= is_32bit_elf
? 8 : 16;
5571 unsigned int size
= sizeof (buff
) - (field_size
+ 4 + 1);
5572 bfd_vma os_flags
= 0;
5573 bfd_vma proc_flags
= 0;
5574 bfd_vma unknown_flags
= 0;
5582 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5583 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5584 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5585 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5586 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5587 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5588 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5589 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5590 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5591 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5592 /* IA-64 specific. */
5593 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5594 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5595 /* IA-64 OpenVMS specific. */
5596 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5597 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5598 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5599 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5600 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5601 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5603 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5604 /* SPARC specific. */
5605 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5606 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5608 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5609 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5610 /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
5612 /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
5614 /* 25 */ { STRING_COMMA_LEN ("VLE") },
5617 if (do_section_details
)
5619 sprintf (buff
, "[%*.*lx]: ",
5620 field_size
, field_size
, (unsigned long) sh_flags
);
5621 p
+= field_size
+ 4;
5628 flag
= sh_flags
& - sh_flags
;
5631 if (do_section_details
)
5635 case SHF_WRITE
: sindex
= 0; break;
5636 case SHF_ALLOC
: sindex
= 1; break;
5637 case SHF_EXECINSTR
: sindex
= 2; break;
5638 case SHF_MERGE
: sindex
= 3; break;
5639 case SHF_STRINGS
: sindex
= 4; break;
5640 case SHF_INFO_LINK
: sindex
= 5; break;
5641 case SHF_LINK_ORDER
: sindex
= 6; break;
5642 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
5643 case SHF_GROUP
: sindex
= 8; break;
5644 case SHF_TLS
: sindex
= 9; break;
5645 case SHF_EXCLUDE
: sindex
= 18; break;
5646 case SHF_COMPRESSED
: sindex
= 20; break;
5647 case SHF_GNU_MBIND
: sindex
= 24; break;
5651 switch (elf_header
.e_machine
)
5654 if (flag
== SHF_IA_64_SHORT
)
5656 else if (flag
== SHF_IA_64_NORECOV
)
5659 else if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
5662 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
5663 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
5664 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
5665 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
5666 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
5667 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
5678 case EM_OLD_SPARCV9
:
5679 case EM_SPARC32PLUS
:
5682 if (flag
== SHF_ORDERED
)
5689 case SHF_ENTRYSECT
: sindex
= 21; break;
5690 case SHF_ARM_PURECODE
: sindex
= 22; break;
5691 case SHF_COMDEF
: sindex
= 23; break;
5696 if (flag
== SHF_PPC_VLE
)
5707 if (p
!= buff
+ field_size
+ 4)
5709 if (size
< (10 + 2))
5711 warn (_("Internal error: not enough buffer room for section flag info"));
5712 return _("<unknown>");
5719 size
-= flags
[sindex
].len
;
5720 p
= stpcpy (p
, flags
[sindex
].str
);
5722 else if (flag
& SHF_MASKOS
)
5724 else if (flag
& SHF_MASKPROC
)
5727 unknown_flags
|= flag
;
5733 case SHF_WRITE
: *p
= 'W'; break;
5734 case SHF_ALLOC
: *p
= 'A'; break;
5735 case SHF_EXECINSTR
: *p
= 'X'; break;
5736 case SHF_MERGE
: *p
= 'M'; break;
5737 case SHF_STRINGS
: *p
= 'S'; break;
5738 case SHF_INFO_LINK
: *p
= 'I'; break;
5739 case SHF_LINK_ORDER
: *p
= 'L'; break;
5740 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
5741 case SHF_GROUP
: *p
= 'G'; break;
5742 case SHF_TLS
: *p
= 'T'; break;
5743 case SHF_EXCLUDE
: *p
= 'E'; break;
5744 case SHF_COMPRESSED
: *p
= 'C'; break;
5745 case SHF_GNU_MBIND
: *p
= 'D'; break;
5748 if ((elf_header
.e_machine
== EM_X86_64
5749 || elf_header
.e_machine
== EM_L1OM
5750 || elf_header
.e_machine
== EM_K1OM
)
5751 && flag
== SHF_X86_64_LARGE
)
5753 else if (elf_header
.e_machine
== EM_ARM
5754 && flag
== SHF_ARM_PURECODE
)
5756 else if (elf_header
.e_machine
== EM_PPC
5757 && flag
== SHF_PPC_VLE
)
5759 else if (flag
& SHF_MASKOS
)
5762 sh_flags
&= ~ SHF_MASKOS
;
5764 else if (flag
& SHF_MASKPROC
)
5767 sh_flags
&= ~ SHF_MASKPROC
;
5777 if (do_section_details
)
5781 size
-= 5 + field_size
;
5782 if (p
!= buff
+ field_size
+ 4)
5786 warn (_("Internal error: not enough buffer room for section flag info"));
5787 return _("<unknown>");
5793 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
5794 (unsigned long) os_flags
);
5795 p
+= 5 + field_size
;
5799 size
-= 7 + field_size
;
5800 if (p
!= buff
+ field_size
+ 4)
5804 warn (_("Internal error: not enough buffer room for section flag info"));
5805 return _("<unknown>");
5811 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
5812 (unsigned long) proc_flags
);
5813 p
+= 7 + field_size
;
5817 size
-= 10 + field_size
;
5818 if (p
!= buff
+ field_size
+ 4)
5822 warn (_("Internal error: not enough buffer room for section flag info"));
5823 return _("<unknown>");
5829 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
5830 (unsigned long) unknown_flags
);
5831 p
+= 10 + field_size
;
5840 get_compression_header (Elf_Internal_Chdr
*chdr
, unsigned char *buf
, bfd_size_type size
)
5844 Elf32_External_Chdr
*echdr
= (Elf32_External_Chdr
*) buf
;
5846 if (size
< sizeof (* echdr
))
5848 error (_("Compressed section is too small even for a compression header\n"));
5852 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
5853 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
5854 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
5855 return sizeof (*echdr
);
5859 Elf64_External_Chdr
*echdr
= (Elf64_External_Chdr
*) buf
;
5861 if (size
< sizeof (* echdr
))
5863 error (_("Compressed section is too small even for a compression header\n"));
5867 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
5868 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
5869 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
5870 return sizeof (*echdr
);
5875 process_section_headers (FILE * file
)
5877 Elf_Internal_Shdr
* section
;
5880 section_headers
= NULL
;
5882 if (elf_header
.e_shnum
== 0)
5884 /* PR binutils/12467. */
5885 if (elf_header
.e_shoff
!= 0)
5887 warn (_("possibly corrupt ELF file header - it has a non-zero"
5888 " section header offset, but no section headers\n"));
5891 else if (do_sections
)
5892 printf (_("\nThere are no sections in this file.\n"));
5897 if (do_sections
&& !do_header
)
5898 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
5899 elf_header
.e_shnum
, (unsigned long) elf_header
.e_shoff
);
5903 if (! get_32bit_section_headers (file
, FALSE
))
5908 if (! get_64bit_section_headers (file
, FALSE
))
5912 /* Read in the string table, so that we have names to display. */
5913 if (elf_header
.e_shstrndx
!= SHN_UNDEF
5914 && elf_header
.e_shstrndx
< elf_header
.e_shnum
)
5916 section
= section_headers
+ elf_header
.e_shstrndx
;
5918 if (section
->sh_size
!= 0)
5920 string_table
= (char *) get_data (NULL
, file
, section
->sh_offset
,
5921 1, section
->sh_size
,
5924 string_table_length
= string_table
!= NULL
? section
->sh_size
: 0;
5928 /* Scan the sections for the dynamic symbol table
5929 and dynamic string table and debug sections. */
5930 dynamic_symbols
= NULL
;
5931 dynamic_strings
= NULL
;
5932 dynamic_syminfo
= NULL
;
5933 symtab_shndx_list
= NULL
;
5935 eh_addr_size
= is_32bit_elf
? 4 : 8;
5936 switch (elf_header
.e_machine
)
5939 case EM_MIPS_RS3_LE
:
5940 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5941 FDE addresses. However, the ABI also has a semi-official ILP32
5942 variant for which the normal FDE address size rules apply.
5944 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5945 section, where XX is the size of longs in bits. Unfortunately,
5946 earlier compilers provided no way of distinguishing ILP32 objects
5947 from LP64 objects, so if there's any doubt, we should assume that
5948 the official LP64 form is being used. */
5949 if ((elf_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
5950 && find_section (".gcc_compiled_long32") == NULL
)
5956 switch (elf_header
.e_flags
& EF_H8_MACH
)
5958 case E_H8_MACH_H8300
:
5959 case E_H8_MACH_H8300HN
:
5960 case E_H8_MACH_H8300SN
:
5961 case E_H8_MACH_H8300SXN
:
5964 case E_H8_MACH_H8300H
:
5965 case E_H8_MACH_H8300S
:
5966 case E_H8_MACH_H8300SX
:
5974 switch (elf_header
.e_flags
& EF_M32C_CPU_MASK
)
5976 case EF_M32C_CPU_M16C
:
5983 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
5986 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
5987 if (section->sh_entsize != expected_entsize) \
5990 sprintf_vma (buf, section->sh_entsize); \
5991 /* Note: coded this way so that there is a single string for \
5993 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5994 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5995 (unsigned) expected_entsize); \
5996 section->sh_entsize = expected_entsize; \
6001 #define CHECK_ENTSIZE(section, i, type) \
6002 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
6003 sizeof (Elf64_External_##type))
6005 for (i
= 0, section
= section_headers
;
6006 i
< elf_header
.e_shnum
;
6009 char * name
= SECTION_NAME (section
);
6011 if (section
->sh_type
== SHT_DYNSYM
)
6013 if (dynamic_symbols
!= NULL
)
6015 error (_("File contains multiple dynamic symbol tables\n"));
6019 CHECK_ENTSIZE (section
, i
, Sym
);
6020 dynamic_symbols
= GET_ELF_SYMBOLS (file
, section
, & num_dynamic_syms
);
6022 else if (section
->sh_type
== SHT_STRTAB
6023 && streq (name
, ".dynstr"))
6025 if (dynamic_strings
!= NULL
)
6027 error (_("File contains multiple dynamic string tables\n"));
6031 dynamic_strings
= (char *) get_data (NULL
, file
, section
->sh_offset
,
6032 1, section
->sh_size
,
6033 _("dynamic strings"));
6034 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : section
->sh_size
;
6036 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
6038 elf_section_list
* entry
= xmalloc (sizeof * entry
);
6039 entry
->hdr
= section
;
6040 entry
->next
= symtab_shndx_list
;
6041 symtab_shndx_list
= entry
;
6043 else if (section
->sh_type
== SHT_SYMTAB
)
6044 CHECK_ENTSIZE (section
, i
, Sym
);
6045 else if (section
->sh_type
== SHT_GROUP
)
6046 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
6047 else if (section
->sh_type
== SHT_REL
)
6048 CHECK_ENTSIZE (section
, i
, Rel
);
6049 else if (section
->sh_type
== SHT_RELA
)
6050 CHECK_ENTSIZE (section
, i
, Rela
);
6051 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
6052 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
6053 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
6054 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
6055 || do_debug_addr
|| do_debug_cu_index
)
6056 && (const_strneq (name
, ".debug_")
6057 || const_strneq (name
, ".zdebug_")))
6060 name
+= sizeof (".zdebug_") - 1;
6062 name
+= sizeof (".debug_") - 1;
6065 || (do_debug_info
&& const_strneq (name
, "info"))
6066 || (do_debug_info
&& const_strneq (name
, "types"))
6067 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
6068 || (do_debug_lines
&& strcmp (name
, "line") == 0)
6069 || (do_debug_lines
&& const_strneq (name
, "line."))
6070 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
6071 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
6072 || (do_debug_pubnames
&& const_strneq (name
, "gnu_pubnames"))
6073 || (do_debug_pubtypes
&& const_strneq (name
, "gnu_pubtypes"))
6074 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
6075 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
6076 || (do_debug_ranges
&& const_strneq (name
, "rnglists"))
6077 || (do_debug_frames
&& const_strneq (name
, "frame"))
6078 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
6079 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
6080 || (do_debug_str
&& const_strneq (name
, "str"))
6081 || (do_debug_loc
&& const_strneq (name
, "loc"))
6082 || (do_debug_loc
&& const_strneq (name
, "loclists"))
6083 || (do_debug_addr
&& const_strneq (name
, "addr"))
6084 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
6085 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
6087 request_dump_bynumber (i
, DEBUG_DUMP
);
6089 /* Linkonce section to be combined with .debug_info at link time. */
6090 else if ((do_debugging
|| do_debug_info
)
6091 && const_strneq (name
, ".gnu.linkonce.wi."))
6092 request_dump_bynumber (i
, DEBUG_DUMP
);
6093 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
6094 request_dump_bynumber (i
, DEBUG_DUMP
);
6095 else if (do_gdb_index
&& (streq (name
, ".gdb_index")
6096 || streq (name
, ".debug_names")))
6097 request_dump_bynumber (i
, DEBUG_DUMP
);
6098 /* Trace sections for Itanium VMS. */
6099 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
6100 || do_trace_aranges
)
6101 && const_strneq (name
, ".trace_"))
6103 name
+= sizeof (".trace_") - 1;
6106 || (do_trace_info
&& streq (name
, "info"))
6107 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
6108 || (do_trace_aranges
&& streq (name
, "aranges"))
6110 request_dump_bynumber (i
, DEBUG_DUMP
);
6117 if (elf_header
.e_shnum
> 1)
6118 printf (_("\nSection Headers:\n"));
6120 printf (_("\nSection Header:\n"));
6124 if (do_section_details
)
6126 printf (_(" [Nr] Name\n"));
6127 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
6131 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
6135 if (do_section_details
)
6137 printf (_(" [Nr] Name\n"));
6138 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
6142 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
6146 if (do_section_details
)
6148 printf (_(" [Nr] Name\n"));
6149 printf (_(" Type Address Offset Link\n"));
6150 printf (_(" Size EntSize Info Align\n"));
6154 printf (_(" [Nr] Name Type Address Offset\n"));
6155 printf (_(" Size EntSize Flags Link Info Align\n"));
6159 if (do_section_details
)
6160 printf (_(" Flags\n"));
6162 for (i
= 0, section
= section_headers
;
6163 i
< elf_header
.e_shnum
;
6166 /* Run some sanity checks on the section header. */
6168 /* Check the sh_link field. */
6169 switch (section
->sh_type
)
6171 case SHT_SYMTAB_SHNDX
:
6175 case SHT_GNU_versym
:
6178 if (section
->sh_link
< 1
6179 || section
->sh_link
>= elf_header
.e_shnum
6180 || (section_headers
[section
->sh_link
].sh_type
!= SHT_SYMTAB
6181 && section_headers
[section
->sh_link
].sh_type
!= SHT_DYNSYM
))
6182 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6183 i
, section
->sh_link
);
6189 case SHT_GNU_verneed
:
6190 case SHT_GNU_verdef
:
6191 case SHT_GNU_LIBLIST
:
6192 if (section
->sh_link
< 1
6193 || section
->sh_link
>= elf_header
.e_shnum
6194 || section_headers
[section
->sh_link
].sh_type
!= SHT_STRTAB
)
6195 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6196 i
, section
->sh_link
);
6199 case SHT_INIT_ARRAY
:
6200 case SHT_FINI_ARRAY
:
6201 case SHT_PREINIT_ARRAY
:
6202 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6203 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6204 i
, section
->sh_link
);
6208 /* FIXME: Add support for target specific section types. */
6209 #if 0 /* Currently we do not check other section types as there are too
6210 many special cases. Stab sections for example have a type
6211 of SHT_PROGBITS but an sh_link field that links to the .stabstr
6213 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6214 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6215 i
, section
->sh_link
);
6220 /* Check the sh_info field. */
6221 switch (section
->sh_type
)
6225 if (section
->sh_info
< 1
6226 || section
->sh_info
>= elf_header
.e_shnum
6227 || (section_headers
[section
->sh_info
].sh_type
!= SHT_PROGBITS
6228 && section_headers
[section
->sh_info
].sh_type
!= SHT_NOBITS
6229 && section_headers
[section
->sh_info
].sh_type
!= SHT_NOTE
6230 && section_headers
[section
->sh_info
].sh_type
!= SHT_INIT_ARRAY
6231 /* FIXME: Are other section types valid ? */
6232 && section_headers
[section
->sh_info
].sh_type
< SHT_LOOS
))
6234 if (section
->sh_info
== 0
6235 && (streq (SECTION_NAME (section
), ".rel.dyn")
6236 || streq (SECTION_NAME (section
), ".rela.dyn")))
6237 /* The .rel.dyn and .rela.dyn sections have an sh_info field
6238 of zero. The relocations in these sections may apply
6239 to many different sections. */
6242 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6243 i
, section
->sh_info
);
6249 case SHT_SYMTAB_SHNDX
:
6250 case SHT_INIT_ARRAY
:
6251 case SHT_FINI_ARRAY
:
6252 case SHT_PREINIT_ARRAY
:
6253 if (section
->sh_info
!= 0)
6254 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6255 i
, section
->sh_info
);
6261 /* A symbol index - we assume that it is valid. */
6265 /* FIXME: Add support for target specific section types. */
6266 if (section
->sh_type
== SHT_NOBITS
)
6267 /* NOBITS section headers with non-zero sh_info fields can be
6268 created when a binary is stripped of everything but its debug
6269 information. The stripped sections have their headers
6270 preserved but their types set to SHT_NOBITS. So do not check
6271 this type of section. */
6273 else if (section
->sh_flags
& SHF_INFO_LINK
)
6275 if (section
->sh_info
< 1 || section
->sh_info
>= elf_header
.e_shnum
)
6276 warn (_("[%2u]: Expected link to another section in info field"), i
);
6278 else if (section
->sh_type
< SHT_LOOS
6279 && (section
->sh_flags
& SHF_GNU_MBIND
) == 0
6280 && section
->sh_info
!= 0)
6281 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6282 i
, section
->sh_info
);
6286 /* Check the sh_size field. */
6287 if (section
->sh_size
> current_file_size
6288 && section
->sh_type
!= SHT_NOBITS
6289 && section
->sh_type
!= SHT_NULL
6290 && section
->sh_type
< SHT_LOOS
)
6291 warn (_("Size of section %u is larger than the entire file!\n"), i
);
6293 printf (" [%2u] ", i
);
6294 if (do_section_details
)
6295 printf ("%s\n ", printable_section_name (section
));
6297 print_symbol (-17, SECTION_NAME (section
));
6299 printf (do_wide
? " %-15s " : " %-15.15s ",
6300 get_section_type_name (section
->sh_type
));
6304 const char * link_too_big
= NULL
;
6306 print_vma (section
->sh_addr
, LONG_HEX
);
6308 printf ( " %6.6lx %6.6lx %2.2lx",
6309 (unsigned long) section
->sh_offset
,
6310 (unsigned long) section
->sh_size
,
6311 (unsigned long) section
->sh_entsize
);
6313 if (do_section_details
)
6314 fputs (" ", stdout
);
6316 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
6318 if (section
->sh_link
>= elf_header
.e_shnum
)
6321 /* The sh_link value is out of range. Normally this indicates
6322 an error but it can have special values in Solaris binaries. */
6323 switch (elf_header
.e_machine
)
6330 case EM_OLD_SPARCV9
:
6331 case EM_SPARC32PLUS
:
6334 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
6335 link_too_big
= "BEFORE";
6336 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
6337 link_too_big
= "AFTER";
6344 if (do_section_details
)
6346 if (link_too_big
!= NULL
&& * link_too_big
)
6347 printf ("<%s> ", link_too_big
);
6349 printf ("%2u ", section
->sh_link
);
6350 printf ("%3u %2lu\n", section
->sh_info
,
6351 (unsigned long) section
->sh_addralign
);
6354 printf ("%2u %3u %2lu\n",
6357 (unsigned long) section
->sh_addralign
);
6359 if (link_too_big
&& ! * link_too_big
)
6360 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6361 i
, section
->sh_link
);
6365 print_vma (section
->sh_addr
, LONG_HEX
);
6367 if ((long) section
->sh_offset
== section
->sh_offset
)
6368 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
6372 print_vma (section
->sh_offset
, LONG_HEX
);
6375 if ((unsigned long) section
->sh_size
== section
->sh_size
)
6376 printf (" %6.6lx", (unsigned long) section
->sh_size
);
6380 print_vma (section
->sh_size
, LONG_HEX
);
6383 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
6384 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
6388 print_vma (section
->sh_entsize
, LONG_HEX
);
6391 if (do_section_details
)
6392 fputs (" ", stdout
);
6394 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
6396 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
6398 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
6399 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
6402 print_vma (section
->sh_addralign
, DEC
);
6406 else if (do_section_details
)
6408 printf (" %-15.15s ",
6409 get_section_type_name (section
->sh_type
));
6410 print_vma (section
->sh_addr
, LONG_HEX
);
6411 if ((long) section
->sh_offset
== section
->sh_offset
)
6412 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
6416 print_vma (section
->sh_offset
, LONG_HEX
);
6418 printf (" %u\n ", section
->sh_link
);
6419 print_vma (section
->sh_size
, LONG_HEX
);
6421 print_vma (section
->sh_entsize
, LONG_HEX
);
6423 printf (" %-16u %lu\n",
6425 (unsigned long) section
->sh_addralign
);
6430 print_vma (section
->sh_addr
, LONG_HEX
);
6431 if ((long) section
->sh_offset
== section
->sh_offset
)
6432 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
6436 print_vma (section
->sh_offset
, LONG_HEX
);
6439 print_vma (section
->sh_size
, LONG_HEX
);
6441 print_vma (section
->sh_entsize
, LONG_HEX
);
6443 printf (" %3s ", get_elf_section_flags (section
->sh_flags
));
6445 printf (" %2u %3u %lu\n",
6448 (unsigned long) section
->sh_addralign
);
6451 if (do_section_details
)
6453 printf (" %s\n", get_elf_section_flags (section
->sh_flags
));
6454 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
6456 /* Minimum section size is 12 bytes for 32-bit compression
6457 header + 12 bytes for compressed data header. */
6458 unsigned char buf
[24];
6460 assert (sizeof (buf
) >= sizeof (Elf64_External_Chdr
));
6461 if (get_data (&buf
, (FILE *) file
, section
->sh_offset
, 1,
6462 sizeof (buf
), _("compression header")))
6464 Elf_Internal_Chdr chdr
;
6466 (void) get_compression_header (&chdr
, buf
, sizeof (buf
));
6468 if (chdr
.ch_type
== ELFCOMPRESS_ZLIB
)
6471 printf (_(" [<unknown>: 0x%x], "),
6473 print_vma (chdr
.ch_size
, LONG_HEX
);
6474 printf (", %lu\n", (unsigned long) chdr
.ch_addralign
);
6480 if (!do_section_details
)
6482 /* The ordering of the letters shown here matches the ordering of the
6483 corresponding SHF_xxx values, and hence the order in which these
6484 letters will be displayed to the user. */
6485 printf (_("Key to Flags:\n\
6486 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6487 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6488 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
6489 if (elf_header
.e_machine
== EM_X86_64
6490 || elf_header
.e_machine
== EM_L1OM
6491 || elf_header
.e_machine
== EM_K1OM
)
6492 printf (_("l (large), "));
6493 else if (elf_header
.e_machine
== EM_ARM
)
6494 printf (_("y (purecode), "));
6495 else if (elf_header
.e_machine
== EM_PPC
)
6496 printf (_("v (VLE), "));
6497 printf ("p (processor specific)\n");
6504 get_group_flags (unsigned int flags
)
6506 static char buff
[128];
6510 else if (flags
== GRP_COMDAT
)
6513 snprintf (buff
, 14, _("[0x%x: "), flags
);
6515 flags
&= ~ GRP_COMDAT
;
6516 if (flags
& GRP_MASKOS
)
6518 strcat (buff
, "<OS specific>");
6519 flags
&= ~ GRP_MASKOS
;
6522 if (flags
& GRP_MASKPROC
)
6524 strcat (buff
, "<PROC specific>");
6525 flags
&= ~ GRP_MASKPROC
;
6529 strcat (buff
, "<unknown>");
6536 process_section_groups (FILE * file
)
6538 Elf_Internal_Shdr
* section
;
6540 struct group
* group
;
6541 Elf_Internal_Shdr
* symtab_sec
;
6542 Elf_Internal_Shdr
* strtab_sec
;
6543 Elf_Internal_Sym
* symtab
;
6544 unsigned long num_syms
;
6548 /* Don't process section groups unless needed. */
6549 if (!do_unwind
&& !do_section_groups
)
6552 if (elf_header
.e_shnum
== 0)
6554 if (do_section_groups
)
6555 printf (_("\nThere are no sections to group in this file.\n"));
6560 if (section_headers
== NULL
)
6562 error (_("Section headers are not available!\n"));
6563 /* PR 13622: This can happen with a corrupt ELF header. */
6567 section_headers_groups
= (struct group
**) calloc (elf_header
.e_shnum
,
6568 sizeof (struct group
*));
6570 if (section_headers_groups
== NULL
)
6572 error (_("Out of memory reading %u section group headers\n"),
6573 elf_header
.e_shnum
);
6577 /* Scan the sections for the group section. */
6579 for (i
= 0, section
= section_headers
;
6580 i
< elf_header
.e_shnum
;
6582 if (section
->sh_type
== SHT_GROUP
)
6585 if (group_count
== 0)
6587 if (do_section_groups
)
6588 printf (_("\nThere are no section groups in this file.\n"));
6593 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
6595 if (section_groups
== NULL
)
6597 error (_("Out of memory reading %lu groups\n"),
6598 (unsigned long) group_count
);
6608 for (i
= 0, section
= section_headers
, group
= section_groups
;
6609 i
< elf_header
.e_shnum
;
6612 if (section
->sh_type
== SHT_GROUP
)
6614 const char * name
= printable_section_name (section
);
6615 const char * group_name
;
6616 unsigned char * start
;
6617 unsigned char * indices
;
6618 unsigned int entry
, j
, size
;
6619 Elf_Internal_Shdr
* sec
;
6620 Elf_Internal_Sym
* sym
;
6622 /* Get the symbol table. */
6623 if (section
->sh_link
>= elf_header
.e_shnum
6624 || ((sec
= section_headers
+ section
->sh_link
)->sh_type
6627 error (_("Bad sh_link in group section `%s'\n"), name
);
6631 if (symtab_sec
!= sec
)
6636 symtab
= GET_ELF_SYMBOLS (file
, symtab_sec
, & num_syms
);
6641 error (_("Corrupt header in group section `%s'\n"), name
);
6645 if (section
->sh_info
>= num_syms
)
6647 error (_("Bad sh_info in group section `%s'\n"), name
);
6651 sym
= symtab
+ section
->sh_info
;
6653 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
6655 if (sym
->st_shndx
== 0
6656 || sym
->st_shndx
>= elf_header
.e_shnum
)
6658 error (_("Bad sh_info in group section `%s'\n"), name
);
6662 group_name
= SECTION_NAME (section_headers
+ sym
->st_shndx
);
6671 /* Get the string table. */
6672 if (symtab_sec
->sh_link
>= elf_header
.e_shnum
)
6681 != (sec
= section_headers
+ symtab_sec
->sh_link
))
6687 strtab
= (char *) get_data (NULL
, file
, strtab_sec
->sh_offset
,
6688 1, strtab_sec
->sh_size
,
6690 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
6692 group_name
= sym
->st_name
< strtab_size
6693 ? strtab
+ sym
->st_name
: _("<corrupt>");
6696 /* PR 17531: file: loop. */
6697 if (section
->sh_entsize
> section
->sh_size
)
6699 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6700 printable_section_name (section
),
6701 (unsigned long) section
->sh_entsize
,
6702 (unsigned long) section
->sh_size
);
6706 start
= (unsigned char *) get_data (NULL
, file
, section
->sh_offset
,
6707 1, section
->sh_size
,
6713 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
6714 entry
= byte_get (indices
, 4);
6717 if (do_section_groups
)
6719 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6720 get_group_flags (entry
), i
, name
, group_name
, size
);
6722 printf (_(" [Index] Name\n"));
6725 group
->group_index
= i
;
6727 for (j
= 0; j
< size
; j
++)
6729 struct group_list
* g
;
6731 entry
= byte_get (indices
, 4);
6734 if (entry
>= elf_header
.e_shnum
)
6736 static unsigned num_group_errors
= 0;
6738 if (num_group_errors
++ < 10)
6740 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6741 entry
, i
, elf_header
.e_shnum
- 1);
6742 if (num_group_errors
== 10)
6743 warn (_("Further error messages about overlarge group section indicies suppressed\n"));
6748 if (section_headers_groups
[entry
] != NULL
)
6752 static unsigned num_errs
= 0;
6754 if (num_errs
++ < 10)
6756 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6758 section_headers_groups
[entry
]->group_index
);
6760 warn (_("Further error messages about already contained group sections suppressed\n"));
6766 /* Intel C/C++ compiler may put section 0 in a
6767 section group. We just warn it the first time
6768 and ignore it afterwards. */
6769 static bfd_boolean warned
= FALSE
;
6772 error (_("section 0 in group section [%5u]\n"),
6773 section_headers_groups
[entry
]->group_index
);
6779 section_headers_groups
[entry
] = group
;
6781 if (do_section_groups
)
6783 sec
= section_headers
+ entry
;
6784 printf (" [%5u] %s\n", entry
, printable_section_name (sec
));
6787 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
6788 g
->section_index
= entry
;
6789 g
->next
= group
->root
;
6807 /* Data used to display dynamic fixups. */
6809 struct ia64_vms_dynfixup
6811 bfd_vma needed_ident
; /* Library ident number. */
6812 bfd_vma needed
; /* Index in the dstrtab of the library name. */
6813 bfd_vma fixup_needed
; /* Index of the library. */
6814 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
6815 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
6818 /* Data used to display dynamic relocations. */
6820 struct ia64_vms_dynimgrela
6822 bfd_vma img_rela_cnt
; /* Number of relocations. */
6823 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
6826 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6830 dump_ia64_vms_dynamic_fixups (FILE * file
,
6831 struct ia64_vms_dynfixup
* fixup
,
6832 const char * strtab
,
6833 unsigned int strtab_sz
)
6835 Elf64_External_VMS_IMAGE_FIXUP
* imfs
;
6837 const char * lib_name
;
6839 imfs
= get_data (NULL
, file
, dynamic_addr
+ fixup
->fixup_rela_off
,
6840 1, fixup
->fixup_rela_cnt
* sizeof (*imfs
),
6841 _("dynamic section image fixups"));
6845 if (fixup
->needed
< strtab_sz
)
6846 lib_name
= strtab
+ fixup
->needed
;
6849 warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
6850 (unsigned long) fixup
->needed
);
6853 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6854 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
6856 (_("Seg Offset Type SymVec DataType\n"));
6858 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
6863 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
6864 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
6865 type
= BYTE_GET (imfs
[i
].type
);
6866 rtype
= elf_ia64_reloc_type (type
);
6868 printf (" 0x%08x ", type
);
6870 printf (" %-32s ", rtype
);
6871 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
6872 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
6879 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
6882 dump_ia64_vms_dynamic_relocs (FILE *file
, struct ia64_vms_dynimgrela
*imgrela
)
6884 Elf64_External_VMS_IMAGE_RELA
*imrs
;
6887 imrs
= get_data (NULL
, file
, dynamic_addr
+ imgrela
->img_rela_off
,
6888 1, imgrela
->img_rela_cnt
* sizeof (*imrs
),
6889 _("dynamic section image relocations"));
6893 printf (_("\nImage relocs\n"));
6895 (_("Seg Offset Type Addend Seg Sym Off\n"));
6897 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
6902 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
6903 printf ("%08" BFD_VMA_FMT
"x ",
6904 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
6905 type
= BYTE_GET (imrs
[i
].type
);
6906 rtype
= elf_ia64_reloc_type (type
);
6908 printf ("0x%08x ", type
);
6910 printf ("%-31s ", rtype
);
6911 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
6912 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
6913 printf ("%08" BFD_VMA_FMT
"x\n",
6914 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
6921 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
6924 process_ia64_vms_dynamic_relocs (FILE *file
)
6926 struct ia64_vms_dynfixup fixup
;
6927 struct ia64_vms_dynimgrela imgrela
;
6928 Elf_Internal_Dyn
*entry
;
6929 bfd_vma strtab_off
= 0;
6930 bfd_vma strtab_sz
= 0;
6931 char *strtab
= NULL
;
6932 bfd_boolean res
= TRUE
;
6934 memset (&fixup
, 0, sizeof (fixup
));
6935 memset (&imgrela
, 0, sizeof (imgrela
));
6937 /* Note: the order of the entries is specified by the OpenVMS specs. */
6938 for (entry
= dynamic_section
;
6939 entry
< dynamic_section
+ dynamic_nent
;
6942 switch (entry
->d_tag
)
6944 case DT_IA_64_VMS_STRTAB_OFFSET
:
6945 strtab_off
= entry
->d_un
.d_val
;
6948 strtab_sz
= entry
->d_un
.d_val
;
6950 strtab
= get_data (NULL
, file
, dynamic_addr
+ strtab_off
,
6951 1, strtab_sz
, _("dynamic string section"));
6954 case DT_IA_64_VMS_NEEDED_IDENT
:
6955 fixup
.needed_ident
= entry
->d_un
.d_val
;
6958 fixup
.needed
= entry
->d_un
.d_val
;
6960 case DT_IA_64_VMS_FIXUP_NEEDED
:
6961 fixup
.fixup_needed
= entry
->d_un
.d_val
;
6963 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
6964 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
6966 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
6967 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
6968 if (! dump_ia64_vms_dynamic_fixups (file
, &fixup
, strtab
, strtab_sz
))
6971 case DT_IA_64_VMS_IMG_RELA_CNT
:
6972 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
6974 case DT_IA_64_VMS_IMG_RELA_OFF
:
6975 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
6976 if (! dump_ia64_vms_dynamic_relocs (file
, &imgrela
))
6998 dynamic_relocations
[] =
7000 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
7001 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
7002 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
7005 /* Process the reloc section. */
7008 process_relocs (FILE * file
)
7010 unsigned long rel_size
;
7011 unsigned long rel_offset
;
7016 if (do_using_dynamic
)
7020 bfd_boolean has_dynamic_reloc
;
7023 has_dynamic_reloc
= FALSE
;
7025 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7027 is_rela
= dynamic_relocations
[i
].rela
;
7028 name
= dynamic_relocations
[i
].name
;
7029 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
7030 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
7033 has_dynamic_reloc
= TRUE
;
7035 if (is_rela
== UNKNOWN
)
7037 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
7038 switch (dynamic_info
[DT_PLTREL
])
7052 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7053 name
, rel_offset
, rel_size
);
7055 dump_relocations (file
,
7056 offset_from_vma (file
, rel_offset
, rel_size
),
7058 dynamic_symbols
, num_dynamic_syms
,
7059 dynamic_strings
, dynamic_strings_length
,
7060 is_rela
, TRUE
/* is_dynamic */);
7065 if (process_ia64_vms_dynamic_relocs (file
))
7066 has_dynamic_reloc
= TRUE
;
7068 if (! has_dynamic_reloc
)
7069 printf (_("\nThere are no dynamic relocations in this file.\n"));
7073 Elf_Internal_Shdr
* section
;
7075 bfd_boolean found
= FALSE
;
7077 for (i
= 0, section
= section_headers
;
7078 i
< elf_header
.e_shnum
;
7081 if ( section
->sh_type
!= SHT_RELA
7082 && section
->sh_type
!= SHT_REL
)
7085 rel_offset
= section
->sh_offset
;
7086 rel_size
= section
->sh_size
;
7090 Elf_Internal_Shdr
* strsec
;
7093 printf (_("\nRelocation section "));
7095 if (string_table
== NULL
)
7096 printf ("%d", section
->sh_name
);
7098 printf ("'%s'", printable_section_name (section
));
7100 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7101 rel_offset
, (unsigned long) (rel_size
/ section
->sh_entsize
));
7103 is_rela
= section
->sh_type
== SHT_RELA
;
7105 if (section
->sh_link
!= 0
7106 && section
->sh_link
< elf_header
.e_shnum
)
7108 Elf_Internal_Shdr
* symsec
;
7109 Elf_Internal_Sym
* symtab
;
7110 unsigned long nsyms
;
7111 unsigned long strtablen
= 0;
7112 char * strtab
= NULL
;
7114 symsec
= section_headers
+ section
->sh_link
;
7115 if (symsec
->sh_type
!= SHT_SYMTAB
7116 && symsec
->sh_type
!= SHT_DYNSYM
)
7119 symtab
= GET_ELF_SYMBOLS (file
, symsec
, & nsyms
);
7124 if (symsec
->sh_link
!= 0
7125 && symsec
->sh_link
< elf_header
.e_shnum
)
7127 strsec
= section_headers
+ symsec
->sh_link
;
7129 strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
7132 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
7135 dump_relocations (file
, rel_offset
, rel_size
,
7136 symtab
, nsyms
, strtab
, strtablen
,
7138 symsec
->sh_type
== SHT_DYNSYM
);
7144 dump_relocations (file
, rel_offset
, rel_size
,
7145 NULL
, 0, NULL
, 0, is_rela
,
7146 FALSE
/* is_dynamic */);
7154 /* Users sometimes forget the -D option, so try to be helpful. */
7155 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7157 if (dynamic_info
[dynamic_relocations
[i
].size
])
7159 printf (_("\nThere are no static relocations in this file."));
7160 printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
7165 if (i
== ARRAY_SIZE (dynamic_relocations
))
7166 printf (_("\nThere are no relocations in this file.\n"));
7173 /* An absolute address consists of a section and an offset. If the
7174 section is NULL, the offset itself is the address, otherwise, the
7175 address equals to LOAD_ADDRESS(section) + offset. */
7179 unsigned short section
;
7183 #define ABSADDR(a) \
7185 ? section_headers [(a).section].sh_addr + (a).offset \
7188 /* Find the nearest symbol at or below ADDR. Returns the symbol
7189 name, if found, and the offset from the symbol to ADDR. */
7192 find_symbol_for_address (Elf_Internal_Sym
* symtab
,
7193 unsigned long nsyms
,
7194 const char * strtab
,
7195 unsigned long strtab_size
,
7196 struct absaddr addr
,
7197 const char ** symname
,
7200 bfd_vma dist
= 0x100000;
7201 Elf_Internal_Sym
* sym
;
7202 Elf_Internal_Sym
* beg
;
7203 Elf_Internal_Sym
* end
;
7204 Elf_Internal_Sym
* best
= NULL
;
7206 REMOVE_ARCH_BITS (addr
.offset
);
7208 end
= symtab
+ nsyms
;
7214 sym
= beg
+ (end
- beg
) / 2;
7216 value
= sym
->st_value
;
7217 REMOVE_ARCH_BITS (value
);
7219 if (sym
->st_name
!= 0
7220 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
7221 && addr
.offset
>= value
7222 && addr
.offset
- value
< dist
)
7225 dist
= addr
.offset
- value
;
7230 if (addr
.offset
< value
)
7238 *symname
= (best
->st_name
>= strtab_size
7239 ? _("<corrupt>") : strtab
+ best
->st_name
);
7245 *offset
= addr
.offset
;
7248 static /* signed */ int
7249 symcmp (const void *p
, const void *q
)
7251 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
7252 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
7254 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
7257 /* Process the unwind section. */
7259 #include "unwind-ia64.h"
7261 struct ia64_unw_table_entry
7263 struct absaddr start
;
7265 struct absaddr info
;
7268 struct ia64_unw_aux_info
7270 struct ia64_unw_table_entry
* table
; /* Unwind table. */
7271 unsigned long table_len
; /* Length of unwind table. */
7272 unsigned char * info
; /* Unwind info. */
7273 unsigned long info_size
; /* Size of unwind info. */
7274 bfd_vma info_addr
; /* Starting address of unwind info. */
7275 bfd_vma seg_base
; /* Starting address of segment. */
7276 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7277 unsigned long nsyms
; /* Number of symbols. */
7278 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7279 unsigned long nfuns
; /* Number of entries in funtab. */
7280 char * strtab
; /* The string table. */
7281 unsigned long strtab_size
; /* Size of string table. */
7285 dump_ia64_unwind (struct ia64_unw_aux_info
* aux
)
7287 struct ia64_unw_table_entry
* tp
;
7288 unsigned long j
, nfuns
;
7290 bfd_boolean res
= TRUE
;
7292 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7293 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7294 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7295 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7297 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7299 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7303 const unsigned char * dp
;
7304 const unsigned char * head
;
7305 const unsigned char * end
;
7306 const char * procname
;
7308 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7309 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
7311 fputs ("\n<", stdout
);
7315 fputs (procname
, stdout
);
7318 printf ("+%lx", (unsigned long) offset
);
7321 fputs (">: [", stdout
);
7322 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7323 fputc ('-', stdout
);
7324 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7325 printf ("], info at +0x%lx\n",
7326 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
7328 /* PR 17531: file: 86232b32. */
7329 if (aux
->info
== NULL
)
7332 /* PR 17531: file: 0997b4d1. */
7333 if ((ABSADDR (tp
->info
) - aux
->info_addr
) >= aux
->info_size
)
7335 warn (_("Invalid offset %lx in table entry %ld\n"),
7336 (long) tp
->info
.offset
, (long) (tp
- aux
->table
));
7341 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
7342 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
7344 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7345 (unsigned) UNW_VER (stamp
),
7346 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
7347 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
7348 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
7349 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
7351 if (UNW_VER (stamp
) != 1)
7353 printf (_("\tUnknown version.\n"));
7358 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
7359 /* PR 17531: file: 16ceda89. */
7360 if (end
> aux
->info
+ aux
->info_size
)
7361 end
= aux
->info
+ aux
->info_size
;
7362 for (dp
= head
+ 8; dp
< end
;)
7363 dp
= unw_decode (dp
, in_body
, & in_body
, end
);
7372 slurp_ia64_unwind_table (FILE * file
,
7373 struct ia64_unw_aux_info
* aux
,
7374 Elf_Internal_Shdr
* sec
)
7376 unsigned long size
, nrelas
, i
;
7377 Elf_Internal_Phdr
* seg
;
7378 struct ia64_unw_table_entry
* tep
;
7379 Elf_Internal_Shdr
* relsec
;
7380 Elf_Internal_Rela
* rela
;
7381 Elf_Internal_Rela
* rp
;
7382 unsigned char * table
;
7384 Elf_Internal_Sym
* sym
;
7385 const char * relname
;
7389 /* First, find the starting address of the segment that includes
7392 if (elf_header
.e_phnum
)
7394 if (! get_program_headers (file
))
7397 for (seg
= program_headers
;
7398 seg
< program_headers
+ elf_header
.e_phnum
;
7401 if (seg
->p_type
!= PT_LOAD
)
7404 if (sec
->sh_addr
>= seg
->p_vaddr
7405 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7407 aux
->seg_base
= seg
->p_vaddr
;
7413 /* Second, build the unwind table from the contents of the unwind section: */
7414 size
= sec
->sh_size
;
7415 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
7420 aux
->table_len
= size
/ (3 * eh_addr_size
);
7421 aux
->table
= (struct ia64_unw_table_entry
*)
7422 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
7425 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
7427 tep
->start
.section
= SHN_UNDEF
;
7428 tep
->end
.section
= SHN_UNDEF
;
7429 tep
->info
.section
= SHN_UNDEF
;
7430 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7431 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7432 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7433 tep
->start
.offset
+= aux
->seg_base
;
7434 tep
->end
.offset
+= aux
->seg_base
;
7435 tep
->info
.offset
+= aux
->seg_base
;
7439 /* Third, apply any relocations to the unwind table: */
7440 for (relsec
= section_headers
;
7441 relsec
< section_headers
+ elf_header
.e_shnum
;
7444 if (relsec
->sh_type
!= SHT_RELA
7445 || relsec
->sh_info
>= elf_header
.e_shnum
7446 || section_headers
+ relsec
->sh_info
!= sec
)
7449 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7458 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7460 relname
= elf_ia64_reloc_type (get_reloc_type (rp
->r_info
));
7461 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
7463 /* PR 17531: file: 9fa67536. */
7464 if (relname
== NULL
)
7466 warn (_("Skipping unknown relocation type: %u\n"), get_reloc_type (rp
->r_info
));
7470 if (! const_strneq (relname
, "R_IA64_SEGREL"))
7472 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
7476 i
= rp
->r_offset
/ (3 * eh_addr_size
);
7478 /* PR 17531: file: 5bc8d9bf. */
7479 if (i
>= aux
->table_len
)
7481 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
7485 switch (rp
->r_offset
/ eh_addr_size
% 3)
7488 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7489 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
7492 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7493 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
7496 aux
->table
[i
].info
.section
= sym
->st_shndx
;
7497 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
7511 ia64_process_unwind (FILE * file
)
7513 Elf_Internal_Shdr
* sec
;
7514 Elf_Internal_Shdr
* unwsec
= NULL
;
7515 Elf_Internal_Shdr
* strsec
;
7516 unsigned long i
, unwcount
= 0, unwstart
= 0;
7517 struct ia64_unw_aux_info aux
;
7518 bfd_boolean res
= TRUE
;
7520 memset (& aux
, 0, sizeof (aux
));
7522 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7524 if (sec
->sh_type
== SHT_SYMTAB
7525 && sec
->sh_link
< elf_header
.e_shnum
)
7527 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
7529 strsec
= section_headers
+ sec
->sh_link
;
7530 if (aux
.strtab
!= NULL
)
7532 error (_("Multiple auxillary string tables encountered\n"));
7536 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
7539 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7541 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7546 printf (_("\nThere are no unwind sections in this file.\n"));
7548 while (unwcount
-- > 0)
7553 for (i
= unwstart
, sec
= section_headers
+ unwstart
, unwsec
= NULL
;
7554 i
< elf_header
.e_shnum
; ++i
, ++sec
)
7555 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7560 /* We have already counted the number of SHT_IA64_UNWIND
7561 sections so the loop above should never fail. */
7562 assert (unwsec
!= NULL
);
7565 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
7567 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
7569 /* We need to find which section group it is in. */
7570 struct group_list
* g
;
7572 if (section_headers_groups
== NULL
7573 || section_headers_groups
[i
] == NULL
)
7574 i
= elf_header
.e_shnum
;
7577 g
= section_headers_groups
[i
]->root
;
7579 for (; g
!= NULL
; g
= g
->next
)
7581 sec
= section_headers
+ g
->section_index
;
7583 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
7588 i
= elf_header
.e_shnum
;
7591 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
7593 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
7594 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
7595 suffix
= SECTION_NAME (unwsec
) + len
;
7596 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
7598 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
7599 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7604 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7605 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
7606 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
7607 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
7609 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
7610 suffix
= SECTION_NAME (unwsec
) + len
;
7611 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
;
7613 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
7614 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7618 if (i
== elf_header
.e_shnum
)
7620 printf (_("\nCould not find unwind info section for "));
7622 if (string_table
== NULL
)
7623 printf ("%d", unwsec
->sh_name
);
7625 printf ("'%s'", printable_section_name (unwsec
));
7629 aux
.info_addr
= sec
->sh_addr
;
7630 aux
.info
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1,
7633 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
7635 printf (_("\nUnwind section "));
7637 if (string_table
== NULL
)
7638 printf ("%d", unwsec
->sh_name
);
7640 printf ("'%s'", printable_section_name (unwsec
));
7642 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7643 (unsigned long) unwsec
->sh_offset
,
7644 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
7646 if (slurp_ia64_unwind_table (file
, & aux
, unwsec
)
7647 && aux
.table_len
> 0)
7648 dump_ia64_unwind (& aux
);
7651 free ((char *) aux
.table
);
7653 free ((char *) aux
.info
);
7662 free ((char *) aux
.strtab
);
7667 struct hppa_unw_table_entry
7669 struct absaddr start
;
7671 unsigned int Cannot_unwind
:1; /* 0 */
7672 unsigned int Millicode
:1; /* 1 */
7673 unsigned int Millicode_save_sr0
:1; /* 2 */
7674 unsigned int Region_description
:2; /* 3..4 */
7675 unsigned int reserved1
:1; /* 5 */
7676 unsigned int Entry_SR
:1; /* 6 */
7677 unsigned int Entry_FR
:4; /* Number saved 7..10 */
7678 unsigned int Entry_GR
:5; /* Number saved 11..15 */
7679 unsigned int Args_stored
:1; /* 16 */
7680 unsigned int Variable_Frame
:1; /* 17 */
7681 unsigned int Separate_Package_Body
:1; /* 18 */
7682 unsigned int Frame_Extension_Millicode
:1; /* 19 */
7683 unsigned int Stack_Overflow_Check
:1; /* 20 */
7684 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
7685 unsigned int Ada_Region
:1; /* 22 */
7686 unsigned int cxx_info
:1; /* 23 */
7687 unsigned int cxx_try_catch
:1; /* 24 */
7688 unsigned int sched_entry_seq
:1; /* 25 */
7689 unsigned int reserved2
:1; /* 26 */
7690 unsigned int Save_SP
:1; /* 27 */
7691 unsigned int Save_RP
:1; /* 28 */
7692 unsigned int Save_MRP_in_frame
:1; /* 29 */
7693 unsigned int extn_ptr_defined
:1; /* 30 */
7694 unsigned int Cleanup_defined
:1; /* 31 */
7696 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
7697 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
7698 unsigned int Large_frame
:1; /* 2 */
7699 unsigned int Pseudo_SP_Set
:1; /* 3 */
7700 unsigned int reserved4
:1; /* 4 */
7701 unsigned int Total_frame_size
:27; /* 5..31 */
7704 struct hppa_unw_aux_info
7706 struct hppa_unw_table_entry
* table
; /* Unwind table. */
7707 unsigned long table_len
; /* Length of unwind table. */
7708 bfd_vma seg_base
; /* Starting address of segment. */
7709 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7710 unsigned long nsyms
; /* Number of symbols. */
7711 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7712 unsigned long nfuns
; /* Number of entries in funtab. */
7713 char * strtab
; /* The string table. */
7714 unsigned long strtab_size
; /* Size of string table. */
7718 dump_hppa_unwind (struct hppa_unw_aux_info
* aux
)
7720 struct hppa_unw_table_entry
* tp
;
7721 unsigned long j
, nfuns
;
7722 bfd_boolean res
= TRUE
;
7724 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7725 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7726 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7727 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7729 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7731 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7734 const char * procname
;
7736 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7737 aux
->strtab_size
, tp
->start
, &procname
,
7740 fputs ("\n<", stdout
);
7744 fputs (procname
, stdout
);
7747 printf ("+%lx", (unsigned long) offset
);
7750 fputs (">: [", stdout
);
7751 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7752 fputc ('-', stdout
);
7753 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7756 #define PF(_m) if (tp->_m) printf (#_m " ");
7757 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
7760 PF(Millicode_save_sr0
);
7761 /* PV(Region_description); */
7767 PF(Separate_Package_Body
);
7768 PF(Frame_Extension_Millicode
);
7769 PF(Stack_Overflow_Check
);
7770 PF(Two_Instruction_SP_Increment
);
7774 PF(sched_entry_seq
);
7777 PF(Save_MRP_in_frame
);
7778 PF(extn_ptr_defined
);
7779 PF(Cleanup_defined
);
7780 PF(MPE_XL_interrupt_marker
);
7781 PF(HP_UX_interrupt_marker
);
7784 PV(Total_frame_size
);
7797 slurp_hppa_unwind_table (FILE * file
,
7798 struct hppa_unw_aux_info
* aux
,
7799 Elf_Internal_Shdr
* sec
)
7801 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
7802 Elf_Internal_Phdr
* seg
;
7803 struct hppa_unw_table_entry
* tep
;
7804 Elf_Internal_Shdr
* relsec
;
7805 Elf_Internal_Rela
* rela
;
7806 Elf_Internal_Rela
* rp
;
7807 unsigned char * table
;
7809 Elf_Internal_Sym
* sym
;
7810 const char * relname
;
7812 /* First, find the starting address of the segment that includes
7814 if (elf_header
.e_phnum
)
7816 if (! get_program_headers (file
))
7819 for (seg
= program_headers
;
7820 seg
< program_headers
+ elf_header
.e_phnum
;
7823 if (seg
->p_type
!= PT_LOAD
)
7826 if (sec
->sh_addr
>= seg
->p_vaddr
7827 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7829 aux
->seg_base
= seg
->p_vaddr
;
7835 /* Second, build the unwind table from the contents of the unwind
7837 size
= sec
->sh_size
;
7838 table
= (unsigned char *) get_data (NULL
, file
, sec
->sh_offset
, 1, size
,
7844 nentries
= size
/ unw_ent_size
;
7845 size
= unw_ent_size
* nentries
;
7847 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
7848 xcmalloc (nentries
, sizeof (aux
->table
[0]));
7850 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
7852 unsigned int tmp1
, tmp2
;
7854 tep
->start
.section
= SHN_UNDEF
;
7855 tep
->end
.section
= SHN_UNDEF
;
7857 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
7858 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
7859 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
7860 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
7862 tep
->start
.offset
+= aux
->seg_base
;
7863 tep
->end
.offset
+= aux
->seg_base
;
7865 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
7866 tep
->Millicode
= (tmp1
>> 30) & 0x1;
7867 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
7868 tep
->Region_description
= (tmp1
>> 27) & 0x3;
7869 tep
->reserved1
= (tmp1
>> 26) & 0x1;
7870 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
7871 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
7872 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
7873 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
7874 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
7875 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
7876 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
7877 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
7878 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
7879 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
7880 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
7881 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
7882 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
7883 tep
->reserved2
= (tmp1
>> 5) & 0x1;
7884 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
7885 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
7886 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
7887 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
7888 tep
->Cleanup_defined
= tmp1
& 0x1;
7890 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
7891 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
7892 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
7893 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
7894 tep
->reserved4
= (tmp2
>> 27) & 0x1;
7895 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
7899 /* Third, apply any relocations to the unwind table. */
7900 for (relsec
= section_headers
;
7901 relsec
< section_headers
+ elf_header
.e_shnum
;
7904 if (relsec
->sh_type
!= SHT_RELA
7905 || relsec
->sh_info
>= elf_header
.e_shnum
7906 || section_headers
+ relsec
->sh_info
!= sec
)
7909 if (!slurp_rela_relocs (file
, relsec
->sh_offset
, relsec
->sh_size
,
7913 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7915 relname
= elf_hppa_reloc_type (get_reloc_type (rp
->r_info
));
7916 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
7918 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
7919 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
7921 warn (_("Skipping unexpected relocation type %s\n"), relname
);
7925 i
= rp
->r_offset
/ unw_ent_size
;
7927 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
7930 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7931 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
7934 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7935 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
7945 aux
->table_len
= nentries
;
7951 hppa_process_unwind (FILE * file
)
7953 struct hppa_unw_aux_info aux
;
7954 Elf_Internal_Shdr
* unwsec
= NULL
;
7955 Elf_Internal_Shdr
* strsec
;
7956 Elf_Internal_Shdr
* sec
;
7958 bfd_boolean res
= TRUE
;
7960 if (string_table
== NULL
)
7963 memset (& aux
, 0, sizeof (aux
));
7965 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7967 if (sec
->sh_type
== SHT_SYMTAB
7968 && sec
->sh_link
< elf_header
.e_shnum
)
7970 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
7972 strsec
= section_headers
+ sec
->sh_link
;
7973 if (aux
.strtab
!= NULL
)
7975 error (_("Multiple auxillary string tables encountered\n"));
7979 aux
.strtab
= (char *) get_data (NULL
, file
, strsec
->sh_offset
,
7982 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7984 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
7989 printf (_("\nThere are no unwind sections in this file.\n"));
7991 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
7993 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
7995 printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
7996 printable_section_name (sec
),
7997 (unsigned long) sec
->sh_offset
,
7998 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
+ 8)));
8000 if (! slurp_hppa_unwind_table (file
, &aux
, sec
))
8003 if (aux
.table_len
> 0)
8005 if (! dump_hppa_unwind (&aux
))
8010 free ((char *) aux
.table
);
8018 free ((char *) aux
.strtab
);
8025 unsigned char * data
; /* The unwind data. */
8026 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
8027 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
8028 unsigned long nrelas
; /* The number of relocations. */
8029 unsigned int rel_type
; /* REL or RELA ? */
8030 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
8033 struct arm_unw_aux_info
8035 FILE * file
; /* The file containing the unwind sections. */
8036 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
8037 unsigned long nsyms
; /* Number of symbols. */
8038 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8039 unsigned long nfuns
; /* Number of these symbols. */
8040 char * strtab
; /* The file's string table. */
8041 unsigned long strtab_size
; /* Size of string table. */
8045 arm_print_vma_and_name (struct arm_unw_aux_info
*aux
,
8046 bfd_vma fn
, struct absaddr addr
)
8048 const char *procname
;
8051 if (addr
.section
== SHN_UNDEF
)
8054 find_symbol_for_address (aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8055 aux
->strtab_size
, addr
, &procname
,
8058 print_vma (fn
, PREFIX_HEX
);
8062 fputs (" <", stdout
);
8063 fputs (procname
, stdout
);
8066 printf ("+0x%lx", (unsigned long) sym_offset
);
8067 fputc ('>', stdout
);
8074 arm_free_section (struct arm_section
*arm_sec
)
8076 if (arm_sec
->data
!= NULL
)
8077 free (arm_sec
->data
);
8079 if (arm_sec
->rela
!= NULL
)
8080 free (arm_sec
->rela
);
8083 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8084 cached section and install SEC instead.
8085 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8086 and return its valued in * WORDP, relocating if necessary.
8087 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8088 relocation's offset in ADDR.
8089 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8090 into the string table of the symbol associated with the reloc. If no
8091 reloc was applied store -1 there.
8092 5) Return TRUE upon success, FALSE otherwise. */
8095 get_unwind_section_word (struct arm_unw_aux_info
* aux
,
8096 struct arm_section
* arm_sec
,
8097 Elf_Internal_Shdr
* sec
,
8098 bfd_vma word_offset
,
8099 unsigned int * wordp
,
8100 struct absaddr
* addr
,
8103 Elf_Internal_Rela
*rp
;
8104 Elf_Internal_Sym
*sym
;
8105 const char * relname
;
8107 bfd_boolean wrapped
;
8109 if (sec
== NULL
|| arm_sec
== NULL
)
8112 addr
->section
= SHN_UNDEF
;
8115 if (sym_name
!= NULL
)
8116 *sym_name
= (bfd_vma
) -1;
8118 /* If necessary, update the section cache. */
8119 if (sec
!= arm_sec
->sec
)
8121 Elf_Internal_Shdr
*relsec
;
8123 arm_free_section (arm_sec
);
8126 arm_sec
->data
= get_data (NULL
, aux
->file
, sec
->sh_offset
, 1,
8127 sec
->sh_size
, _("unwind data"));
8128 arm_sec
->rela
= NULL
;
8129 arm_sec
->nrelas
= 0;
8131 for (relsec
= section_headers
;
8132 relsec
< section_headers
+ elf_header
.e_shnum
;
8135 if (relsec
->sh_info
>= elf_header
.e_shnum
8136 || section_headers
+ relsec
->sh_info
!= sec
8137 /* PR 15745: Check the section type as well. */
8138 || (relsec
->sh_type
!= SHT_REL
8139 && relsec
->sh_type
!= SHT_RELA
))
8142 arm_sec
->rel_type
= relsec
->sh_type
;
8143 if (relsec
->sh_type
== SHT_REL
)
8145 if (!slurp_rel_relocs (aux
->file
, relsec
->sh_offset
,
8147 & arm_sec
->rela
, & arm_sec
->nrelas
))
8150 else /* relsec->sh_type == SHT_RELA */
8152 if (!slurp_rela_relocs (aux
->file
, relsec
->sh_offset
,
8154 & arm_sec
->rela
, & arm_sec
->nrelas
))
8160 arm_sec
->next_rela
= arm_sec
->rela
;
8163 /* If there is no unwind data we can do nothing. */
8164 if (arm_sec
->data
== NULL
)
8167 /* If the offset is invalid then fail. */
8168 if (/* PR 21343 *//* PR 18879 */
8170 || word_offset
> (sec
->sh_size
- 4)
8171 || ((bfd_signed_vma
) word_offset
) < 0)
8174 /* Get the word at the required offset. */
8175 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
8177 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
8178 if (arm_sec
->rela
== NULL
)
8184 /* Look through the relocs to find the one that applies to the provided offset. */
8186 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
8188 bfd_vma prelval
, offset
;
8190 if (rp
->r_offset
> word_offset
&& !wrapped
)
8195 if (rp
->r_offset
> word_offset
)
8198 if (rp
->r_offset
& 3)
8200 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8201 (unsigned long) rp
->r_offset
);
8205 if (rp
->r_offset
< word_offset
)
8208 /* PR 17531: file: 027-161405-0.004 */
8209 if (aux
->symtab
== NULL
)
8212 if (arm_sec
->rel_type
== SHT_REL
)
8214 offset
= word
& 0x7fffffff;
8215 if (offset
& 0x40000000)
8216 offset
|= ~ (bfd_vma
) 0x7fffffff;
8218 else if (arm_sec
->rel_type
== SHT_RELA
)
8219 offset
= rp
->r_addend
;
8222 error (_("Unknown section relocation type %d encountered\n"),
8227 /* PR 17531 file: 027-1241568-0.004. */
8228 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
8230 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8231 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
8235 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
8236 offset
+= sym
->st_value
;
8237 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
8239 /* Check that we are processing the expected reloc type. */
8240 if (elf_header
.e_machine
== EM_ARM
)
8242 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8243 if (relname
== NULL
)
8245 warn (_("Skipping unknown ARM relocation type: %d\n"),
8246 (int) ELF32_R_TYPE (rp
->r_info
));
8250 if (streq (relname
, "R_ARM_NONE"))
8253 if (! streq (relname
, "R_ARM_PREL31"))
8255 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
8259 else if (elf_header
.e_machine
== EM_TI_C6000
)
8261 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8262 if (relname
== NULL
)
8264 warn (_("Skipping unknown C6000 relocation type: %d\n"),
8265 (int) ELF32_R_TYPE (rp
->r_info
));
8269 if (streq (relname
, "R_C6000_NONE"))
8272 if (! streq (relname
, "R_C6000_PREL31"))
8274 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
8282 /* This function currently only supports ARM and TI unwinders. */
8283 warn (_("Only TI and ARM unwinders are currently supported\n"));
8287 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
8288 addr
->section
= sym
->st_shndx
;
8289 addr
->offset
= offset
;
8292 * sym_name
= sym
->st_name
;
8297 arm_sec
->next_rela
= rp
;
8302 static const char *tic6x_unwind_regnames
[16] =
8304 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8305 "A14", "A13", "A12", "A11", "A10",
8306 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8310 decode_tic6x_unwind_regmask (unsigned int mask
)
8314 for (i
= 12; mask
; mask
>>= 1, i
--)
8318 fputs (tic6x_unwind_regnames
[i
], stdout
);
8320 fputs (", ", stdout
);
8326 if (remaining == 0 && more_words) \
8329 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
8330 data_offset, & word, & addr, NULL)) \
8336 #define GET_OP(OP) \
8341 (OP) = word >> 24; \
8346 printf (_("[Truncated opcode]\n")); \
8349 printf ("0x%02x ", OP)
8352 decode_arm_unwind_bytecode (struct arm_unw_aux_info
* aux
,
8354 unsigned int remaining
,
8355 unsigned int more_words
,
8356 bfd_vma data_offset
,
8357 Elf_Internal_Shdr
* data_sec
,
8358 struct arm_section
* data_arm_sec
)
8360 struct absaddr addr
;
8361 bfd_boolean res
= TRUE
;
8363 /* Decode the unwinding instructions. */
8366 unsigned int op
, op2
;
8375 printf (" 0x%02x ", op
);
8377 if ((op
& 0xc0) == 0x00)
8379 int offset
= ((op
& 0x3f) << 2) + 4;
8381 printf (" vsp = vsp + %d", offset
);
8383 else if ((op
& 0xc0) == 0x40)
8385 int offset
= ((op
& 0x3f) << 2) + 4;
8387 printf (" vsp = vsp - %d", offset
);
8389 else if ((op
& 0xf0) == 0x80)
8392 if (op
== 0x80 && op2
== 0)
8393 printf (_("Refuse to unwind"));
8396 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
8397 bfd_boolean first
= TRUE
;
8401 for (i
= 0; i
< 12; i
++)
8402 if (mask
& (1 << i
))
8408 printf ("r%d", 4 + i
);
8413 else if ((op
& 0xf0) == 0x90)
8415 if (op
== 0x9d || op
== 0x9f)
8416 printf (_(" [Reserved]"));
8418 printf (" vsp = r%d", op
& 0x0f);
8420 else if ((op
& 0xf0) == 0xa0)
8422 int end
= 4 + (op
& 0x07);
8423 bfd_boolean first
= TRUE
;
8427 for (i
= 4; i
<= end
; i
++)
8443 else if (op
== 0xb0)
8444 printf (_(" finish"));
8445 else if (op
== 0xb1)
8448 if (op2
== 0 || (op2
& 0xf0) != 0)
8449 printf (_("[Spare]"));
8452 unsigned int mask
= op2
& 0x0f;
8453 bfd_boolean first
= TRUE
;
8457 for (i
= 0; i
< 12; i
++)
8458 if (mask
& (1 << i
))
8469 else if (op
== 0xb2)
8471 unsigned char buf
[9];
8472 unsigned int i
, len
;
8473 unsigned long offset
;
8475 for (i
= 0; i
< sizeof (buf
); i
++)
8478 if ((buf
[i
] & 0x80) == 0)
8481 if (i
== sizeof (buf
))
8483 error (_("corrupt change to vsp"));
8488 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8489 assert (len
== i
+ 1);
8490 offset
= offset
* 4 + 0x204;
8491 printf ("vsp = vsp + %ld", offset
);
8494 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
8496 unsigned int first
, last
;
8503 printf ("pop {D%d", first
);
8505 printf ("-D%d", first
+ last
);
8508 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
8510 unsigned int count
= op
& 0x07;
8514 printf ("-D%d", 8 + count
);
8517 else if (op
>= 0xc0 && op
<= 0xc5)
8519 unsigned int count
= op
& 0x07;
8521 printf (" pop {wR10");
8523 printf ("-wR%d", 10 + count
);
8526 else if (op
== 0xc6)
8528 unsigned int first
, last
;
8533 printf ("pop {wR%d", first
);
8535 printf ("-wR%d", first
+ last
);
8538 else if (op
== 0xc7)
8541 if (op2
== 0 || (op2
& 0xf0) != 0)
8542 printf (_("[Spare]"));
8545 unsigned int mask
= op2
& 0x0f;
8546 bfd_boolean first
= TRUE
;
8550 for (i
= 0; i
< 4; i
++)
8551 if (mask
& (1 << i
))
8557 printf ("wCGR%d", i
);
8564 printf (_(" [unsupported opcode]"));
8575 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info
* aux
,
8577 unsigned int remaining
,
8578 unsigned int more_words
,
8579 bfd_vma data_offset
,
8580 Elf_Internal_Shdr
* data_sec
,
8581 struct arm_section
* data_arm_sec
)
8583 struct absaddr addr
;
8585 /* Decode the unwinding instructions. */
8588 unsigned int op
, op2
;
8597 printf (" 0x%02x ", op
);
8599 if ((op
& 0xc0) == 0x00)
8601 int offset
= ((op
& 0x3f) << 3) + 8;
8602 printf (" sp = sp + %d", offset
);
8604 else if ((op
& 0xc0) == 0x80)
8607 if (op
== 0x80 && op2
== 0)
8608 printf (_("Refuse to unwind"));
8611 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
8613 printf ("pop compact {");
8617 decode_tic6x_unwind_regmask (mask
);
8621 else if ((op
& 0xf0) == 0xc0)
8629 unsigned int offset
;
8633 /* Scan entire instruction first so that GET_OP output is not
8634 interleaved with disassembly. */
8636 for (i
= 0; nregs
< (op
& 0xf); i
++)
8642 regpos
[nregs
].offset
= i
* 2;
8643 regpos
[nregs
].reg
= reg
;
8650 regpos
[nregs
].offset
= i
* 2 + 1;
8651 regpos
[nregs
].reg
= reg
;
8656 printf (_("pop frame {"));
8658 for (i
= i
* 2; i
> 0; i
--)
8660 if (regpos
[reg
].offset
== i
- 1)
8662 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
8669 fputs (name
, stdout
);
8676 else if (op
== 0xd0)
8677 printf (" MOV FP, SP");
8678 else if (op
== 0xd1)
8679 printf (" __c6xabi_pop_rts");
8680 else if (op
== 0xd2)
8682 unsigned char buf
[9];
8683 unsigned int i
, len
;
8684 unsigned long offset
;
8686 for (i
= 0; i
< sizeof (buf
); i
++)
8689 if ((buf
[i
] & 0x80) == 0)
8692 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
8693 if (i
== sizeof (buf
))
8695 warn (_("Corrupt stack pointer adjustment detected\n"));
8699 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8700 assert (len
== i
+ 1);
8701 offset
= offset
* 8 + 0x408;
8702 printf (_("sp = sp + %ld"), offset
);
8704 else if ((op
& 0xf0) == 0xe0)
8706 if ((op
& 0x0f) == 7)
8709 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
8713 printf (_(" [unsupported opcode]"));
8722 arm_expand_prel31 (bfd_vma word
, bfd_vma where
)
8726 offset
= word
& 0x7fffffff;
8727 if (offset
& 0x40000000)
8728 offset
|= ~ (bfd_vma
) 0x7fffffff;
8730 if (elf_header
.e_machine
== EM_TI_C6000
)
8733 return offset
+ where
;
8737 decode_arm_unwind (struct arm_unw_aux_info
* aux
,
8739 unsigned int remaining
,
8740 bfd_vma data_offset
,
8741 Elf_Internal_Shdr
* data_sec
,
8742 struct arm_section
* data_arm_sec
)
8745 unsigned int more_words
= 0;
8746 struct absaddr addr
;
8747 bfd_vma sym_name
= (bfd_vma
) -1;
8748 bfd_boolean res
= TRUE
;
8752 /* Fetch the first word.
8753 Note - when decoding an object file the address extracted
8754 here will always be 0. So we also pass in the sym_name
8755 parameter so that we can find the symbol associated with
8756 the personality routine. */
8757 if (! get_unwind_section_word (aux
, data_arm_sec
, data_sec
, data_offset
,
8758 & word
, & addr
, & sym_name
))
8764 if ((word
& 0x80000000) == 0)
8766 /* Expand prel31 for personality routine. */
8768 const char *procname
;
8770 fn
= arm_expand_prel31 (word
, data_sec
->sh_addr
+ data_offset
);
8771 printf (_(" Personality routine: "));
8773 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
8774 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
8776 procname
= aux
->strtab
+ sym_name
;
8777 print_vma (fn
, PREFIX_HEX
);
8780 fputs (" <", stdout
);
8781 fputs (procname
, stdout
);
8782 fputc ('>', stdout
);
8786 procname
= arm_print_vma_and_name (aux
, fn
, addr
);
8787 fputc ('\n', stdout
);
8789 /* The GCC personality routines use the standard compact
8790 encoding, starting with one byte giving the number of
8792 if (procname
!= NULL
8793 && (const_strneq (procname
, "__gcc_personality_v0")
8794 || const_strneq (procname
, "__gxx_personality_v0")
8795 || const_strneq (procname
, "__gcj_personality_v0")
8796 || const_strneq (procname
, "__gnu_objc_personality_v0")))
8803 printf (_(" [Truncated data]\n"));
8806 more_words
= word
>> 24;
8816 /* ARM EHABI Section 6.3:
8818 An exception-handling table entry for the compact model looks like:
8822 1 0 index Data for personalityRoutine[index] */
8824 if (elf_header
.e_machine
== EM_ARM
8825 && (word
& 0x70000000))
8827 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
8831 per_index
= (word
>> 24) & 0x7f;
8832 printf (_(" Compact model index: %d\n"), per_index
);
8839 else if (per_index
< 3)
8841 more_words
= (word
>> 16) & 0xff;
8847 switch (elf_header
.e_machine
)
8852 if (! decode_arm_unwind_bytecode (aux
, word
, remaining
, more_words
,
8853 data_offset
, data_sec
, data_arm_sec
))
8858 warn (_("Unknown ARM compact model index encountered\n"));
8859 printf (_(" [reserved]\n"));
8867 if (! decode_tic6x_unwind_bytecode (aux
, word
, remaining
, more_words
,
8868 data_offset
, data_sec
, data_arm_sec
))
8871 else if (per_index
< 5)
8873 if (((word
>> 17) & 0x7f) == 0x7f)
8874 printf (_(" Restore stack from frame pointer\n"));
8876 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
8877 printf (_(" Registers restored: "));
8879 printf (" (compact) ");
8880 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
8882 printf (_(" Return register: %s\n"),
8883 tic6x_unwind_regnames
[word
& 0xf]);
8886 printf (_(" [reserved (%d)]\n"), per_index
);
8890 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
8891 elf_header
.e_machine
);
8895 /* Decode the descriptors. Not implemented. */
8901 dump_arm_unwind (struct arm_unw_aux_info
*aux
, Elf_Internal_Shdr
*exidx_sec
)
8903 struct arm_section exidx_arm_sec
, extab_arm_sec
;
8904 unsigned int i
, exidx_len
;
8905 unsigned long j
, nfuns
;
8906 bfd_boolean res
= TRUE
;
8908 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
8909 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
8910 exidx_len
= exidx_sec
->sh_size
/ 8;
8912 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
8913 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
8914 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
8915 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
8917 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
8919 for (i
= 0; i
< exidx_len
; i
++)
8921 unsigned int exidx_fn
, exidx_entry
;
8922 struct absaddr fn_addr
, entry_addr
;
8925 fputc ('\n', stdout
);
8927 if (! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
8928 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
8929 || ! get_unwind_section_word (aux
, & exidx_arm_sec
, exidx_sec
,
8930 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
8933 arm_free_section (& exidx_arm_sec
);
8934 arm_free_section (& extab_arm_sec
);
8938 /* ARM EHABI, Section 5:
8939 An index table entry consists of 2 words.
8940 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
8941 if (exidx_fn
& 0x80000000)
8943 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
8947 fn
= arm_expand_prel31 (exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
8949 arm_print_vma_and_name (aux
, fn
, fn_addr
);
8950 fputs (": ", stdout
);
8952 if (exidx_entry
== 1)
8954 print_vma (exidx_entry
, PREFIX_HEX
);
8955 fputs (" [cantunwind]\n", stdout
);
8957 else if (exidx_entry
& 0x80000000)
8959 print_vma (exidx_entry
, PREFIX_HEX
);
8960 fputc ('\n', stdout
);
8961 decode_arm_unwind (aux
, exidx_entry
, 4, 0, NULL
, NULL
);
8965 bfd_vma table
, table_offset
= 0;
8966 Elf_Internal_Shdr
*table_sec
;
8968 fputs ("@", stdout
);
8969 table
= arm_expand_prel31 (exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
8970 print_vma (table
, PREFIX_HEX
);
8973 /* Locate the matching .ARM.extab. */
8974 if (entry_addr
.section
!= SHN_UNDEF
8975 && entry_addr
.section
< elf_header
.e_shnum
)
8977 table_sec
= section_headers
+ entry_addr
.section
;
8978 table_offset
= entry_addr
.offset
;
8980 if (table_offset
> table_sec
->sh_size
8981 || ((bfd_signed_vma
) table_offset
) < 0)
8983 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
8984 (unsigned long) table_offset
,
8985 printable_section_name (table_sec
));
8992 table_sec
= find_section_by_address (table
);
8993 if (table_sec
!= NULL
)
8994 table_offset
= table
- table_sec
->sh_addr
;
8997 if (table_sec
== NULL
)
8999 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
9000 (unsigned long) table
);
9005 if (! decode_arm_unwind (aux
, 0, 0, table_offset
, table_sec
,
9014 arm_free_section (&exidx_arm_sec
);
9015 arm_free_section (&extab_arm_sec
);
9020 /* Used for both ARM and C6X unwinding tables. */
9023 arm_process_unwind (FILE *file
)
9025 struct arm_unw_aux_info aux
;
9026 Elf_Internal_Shdr
*unwsec
= NULL
;
9027 Elf_Internal_Shdr
*strsec
;
9028 Elf_Internal_Shdr
*sec
;
9030 unsigned int sec_type
;
9031 bfd_boolean res
= TRUE
;
9033 switch (elf_header
.e_machine
)
9036 sec_type
= SHT_ARM_EXIDX
;
9040 sec_type
= SHT_C6000_UNWIND
;
9044 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9045 elf_header
.e_machine
);
9049 if (string_table
== NULL
)
9052 memset (& aux
, 0, sizeof (aux
));
9055 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
9057 if (sec
->sh_type
== SHT_SYMTAB
&& sec
->sh_link
< elf_header
.e_shnum
)
9059 aux
.symtab
= GET_ELF_SYMBOLS (file
, sec
, & aux
.nsyms
);
9061 strsec
= section_headers
+ sec
->sh_link
;
9063 /* PR binutils/17531 file: 011-12666-0.004. */
9064 if (aux
.strtab
!= NULL
)
9066 error (_("Multiple string tables found in file.\n"));
9070 aux
.strtab
= get_data (NULL
, file
, strsec
->sh_offset
,
9071 1, strsec
->sh_size
, _("string table"));
9072 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
9074 else if (sec
->sh_type
== sec_type
)
9079 printf (_("\nThere are no unwind sections in this file.\n"));
9081 for (i
= 0, sec
= section_headers
; i
< elf_header
.e_shnum
; ++i
, ++sec
)
9083 if (sec
->sh_type
== sec_type
)
9085 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
9086 printable_section_name (sec
),
9087 (unsigned long) sec
->sh_offset
,
9088 (unsigned long) (sec
->sh_size
/ (2 * eh_addr_size
)));
9090 if (! dump_arm_unwind (&aux
, sec
))
9098 free ((char *) aux
.strtab
);
9104 process_unwind (FILE * file
)
9106 struct unwind_handler
9108 unsigned int machtype
;
9109 bfd_boolean (* handler
)(FILE *);
9112 { EM_ARM
, arm_process_unwind
},
9113 { EM_IA_64
, ia64_process_unwind
},
9114 { EM_PARISC
, hppa_process_unwind
},
9115 { EM_TI_C6000
, arm_process_unwind
},
9123 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
9124 if (elf_header
.e_machine
== handlers
[i
].machtype
)
9125 return handlers
[i
].handler (file
);
9127 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9128 get_machine_name (elf_header
.e_machine
));
9133 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
9135 switch (entry
->d_tag
)
9138 if (entry
->d_un
.d_val
== 0)
9142 static const char * opts
[] =
9144 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9145 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9146 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9147 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9151 bfd_boolean first
= TRUE
;
9153 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
9154 if (entry
->d_un
.d_val
& (1 << cnt
))
9156 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
9162 case DT_MIPS_IVERSION
:
9163 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9164 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
9168 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
9169 /* Note: coded this way so that there is a single string for translation. */
9170 printf (_("<corrupt: %s>"), buf
);
9174 case DT_MIPS_TIME_STAMP
:
9178 time_t atime
= entry
->d_un
.d_val
;
9180 tmp
= gmtime (&atime
);
9181 /* PR 17531: file: 6accc532. */
9183 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
9185 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
9186 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9187 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9188 printf (_("Time Stamp: %s"), timebuf
);
9192 case DT_MIPS_RLD_VERSION
:
9193 case DT_MIPS_LOCAL_GOTNO
:
9194 case DT_MIPS_CONFLICTNO
:
9195 case DT_MIPS_LIBLISTNO
:
9196 case DT_MIPS_SYMTABNO
:
9197 case DT_MIPS_UNREFEXTNO
:
9198 case DT_MIPS_HIPAGENO
:
9199 case DT_MIPS_DELTA_CLASS_NO
:
9200 case DT_MIPS_DELTA_INSTANCE_NO
:
9201 case DT_MIPS_DELTA_RELOC_NO
:
9202 case DT_MIPS_DELTA_SYM_NO
:
9203 case DT_MIPS_DELTA_CLASSSYM_NO
:
9204 case DT_MIPS_COMPACT_SIZE
:
9205 print_vma (entry
->d_un
.d_val
, DEC
);
9209 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9215 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
9217 switch (entry
->d_tag
)
9219 case DT_HP_DLD_FLAGS
:
9228 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
9229 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
9230 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
9231 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
9232 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
9233 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
9234 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
9235 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
9236 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
9237 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
9238 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
9239 { DT_HP_GST
, "HP_GST" },
9240 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
9241 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
9242 { DT_HP_NODELETE
, "HP_NODELETE" },
9243 { DT_HP_GROUP
, "HP_GROUP" },
9244 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
9246 bfd_boolean first
= TRUE
;
9248 bfd_vma val
= entry
->d_un
.d_val
;
9250 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
9251 if (val
& flags
[cnt
].bit
)
9255 fputs (flags
[cnt
].str
, stdout
);
9257 val
^= flags
[cnt
].bit
;
9260 if (val
!= 0 || first
)
9264 print_vma (val
, HEX
);
9270 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9278 /* VMS vs Unix time offset and factor. */
9280 #define VMS_EPOCH_OFFSET 35067168000000000LL
9281 #define VMS_GRANULARITY_FACTOR 10000000
9283 /* Display a VMS time in a human readable format. */
9286 print_vms_time (bfd_int64_t vmstime
)
9291 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
9292 tm
= gmtime (&unxtime
);
9293 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9294 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
9295 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
9300 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
9302 switch (entry
->d_tag
)
9304 case DT_IA_64_PLT_RESERVE
:
9305 /* First 3 slots reserved. */
9306 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9308 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
9311 case DT_IA_64_VMS_LINKTIME
:
9313 print_vms_time (entry
->d_un
.d_val
);
9317 case DT_IA_64_VMS_LNKFLAGS
:
9318 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9319 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
9320 printf (" CALL_DEBUG");
9321 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
9322 printf (" NOP0BUFS");
9323 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
9324 printf (" P0IMAGE");
9325 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
9326 printf (" MKTHREADS");
9327 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
9328 printf (" UPCALLS");
9329 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
9331 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
9332 printf (" INITIALIZE");
9333 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
9335 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
9336 printf (" EXE_INIT");
9337 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
9338 printf (" TBK_IN_IMG");
9339 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
9340 printf (" DBG_IN_IMG");
9341 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
9342 printf (" TBK_IN_DSF");
9343 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
9344 printf (" DBG_IN_DSF");
9345 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
9346 printf (" SIGNATURES");
9347 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
9348 printf (" REL_SEG_OFF");
9352 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9359 get_32bit_dynamic_section (FILE * file
)
9361 Elf32_External_Dyn
* edyn
;
9362 Elf32_External_Dyn
* ext
;
9363 Elf_Internal_Dyn
* entry
;
9365 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
9366 dynamic_size
, _("dynamic section"));
9370 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9371 might not have the luxury of section headers. Look for the DT_NULL
9372 terminator to determine the number of entries. */
9373 for (ext
= edyn
, dynamic_nent
= 0;
9374 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9378 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9382 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9384 if (dynamic_section
== NULL
)
9386 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9387 (unsigned long) dynamic_nent
);
9392 for (ext
= edyn
, entry
= dynamic_section
;
9393 entry
< dynamic_section
+ dynamic_nent
;
9396 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9397 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9406 get_64bit_dynamic_section (FILE * file
)
9408 Elf64_External_Dyn
* edyn
;
9409 Elf64_External_Dyn
* ext
;
9410 Elf_Internal_Dyn
* entry
;
9412 /* Read in the data. */
9413 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, file
, dynamic_addr
, 1,
9414 dynamic_size
, _("dynamic section"));
9418 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9419 might not have the luxury of section headers. Look for the DT_NULL
9420 terminator to determine the number of entries. */
9421 for (ext
= edyn
, dynamic_nent
= 0;
9422 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
9423 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9427 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9431 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9433 if (dynamic_section
== NULL
)
9435 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9436 (unsigned long) dynamic_nent
);
9441 /* Convert from external to internal formats. */
9442 for (ext
= edyn
, entry
= dynamic_section
;
9443 entry
< dynamic_section
+ dynamic_nent
;
9446 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9447 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9456 print_dynamic_flags (bfd_vma flags
)
9458 bfd_boolean first
= TRUE
;
9464 flag
= flags
& - flags
;
9474 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
9475 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
9476 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
9477 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
9478 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
9479 default: fputs (_("unknown"), stdout
); break;
9485 /* Parse and display the contents of the dynamic section. */
9488 process_dynamic_section (FILE * file
)
9490 Elf_Internal_Dyn
* entry
;
9492 if (dynamic_size
== 0)
9495 printf (_("\nThere is no dynamic section in this file.\n"));
9502 if (! get_32bit_dynamic_section (file
))
9507 if (! get_64bit_dynamic_section (file
))
9511 /* Find the appropriate symbol table. */
9512 if (dynamic_symbols
== NULL
)
9514 for (entry
= dynamic_section
;
9515 entry
< dynamic_section
+ dynamic_nent
;
9518 Elf_Internal_Shdr section
;
9520 if (entry
->d_tag
!= DT_SYMTAB
)
9523 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
9525 /* Since we do not know how big the symbol table is,
9526 we default to reading in the entire file (!) and
9527 processing that. This is overkill, I know, but it
9529 section
.sh_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
9530 if ((bfd_size_type
) section
.sh_offset
> current_file_size
)
9532 /* See PR 21379 for a reproducer. */
9533 error (_("Invalid DT_SYMTAB entry: %lx"), (long) section
.sh_offset
);
9537 if (archive_file_offset
!= 0)
9538 section
.sh_size
= archive_file_size
- section
.sh_offset
;
9541 if (fseek (file
, 0, SEEK_END
))
9542 error (_("Unable to seek to end of file!\n"));
9544 section
.sh_size
= ftell (file
) - section
.sh_offset
;
9548 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
9550 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
9551 section
.sh_name
= string_table_length
;
9553 dynamic_symbols
= GET_ELF_SYMBOLS (file
, §ion
, & num_dynamic_syms
);
9554 if (num_dynamic_syms
< 1)
9556 error (_("Unable to determine the number of symbols to load\n"));
9562 /* Similarly find a string table. */
9563 if (dynamic_strings
== NULL
)
9565 for (entry
= dynamic_section
;
9566 entry
< dynamic_section
+ dynamic_nent
;
9569 unsigned long offset
;
9572 if (entry
->d_tag
!= DT_STRTAB
)
9575 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
9577 /* Since we do not know how big the string table is,
9578 we default to reading in the entire file (!) and
9579 processing that. This is overkill, I know, but it
9582 offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
9584 if (archive_file_offset
!= 0)
9585 str_tab_len
= archive_file_size
- offset
;
9588 if (fseek (file
, 0, SEEK_END
))
9589 error (_("Unable to seek to end of file\n"));
9590 str_tab_len
= ftell (file
) - offset
;
9593 if (str_tab_len
< 1)
9596 (_("Unable to determine the length of the dynamic string table\n"));
9600 dynamic_strings
= (char *) get_data (NULL
, file
, offset
, 1,
9602 _("dynamic string table"));
9603 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : str_tab_len
;
9608 /* And find the syminfo section if available. */
9609 if (dynamic_syminfo
== NULL
)
9611 unsigned long syminsz
= 0;
9613 for (entry
= dynamic_section
;
9614 entry
< dynamic_section
+ dynamic_nent
;
9617 if (entry
->d_tag
== DT_SYMINENT
)
9619 /* Note: these braces are necessary to avoid a syntax
9620 error from the SunOS4 C compiler. */
9621 /* PR binutils/17531: A corrupt file can trigger this test.
9622 So do not use an assert, instead generate an error message. */
9623 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
9624 error (_("Bad value (%d) for SYMINENT entry\n"),
9625 (int) entry
->d_un
.d_val
);
9627 else if (entry
->d_tag
== DT_SYMINSZ
)
9628 syminsz
= entry
->d_un
.d_val
;
9629 else if (entry
->d_tag
== DT_SYMINFO
)
9630 dynamic_syminfo_offset
= offset_from_vma (file
, entry
->d_un
.d_val
,
9634 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
9636 Elf_External_Syminfo
* extsyminfo
;
9637 Elf_External_Syminfo
* extsym
;
9638 Elf_Internal_Syminfo
* syminfo
;
9640 /* There is a syminfo section. Read the data. */
9641 extsyminfo
= (Elf_External_Syminfo
*)
9642 get_data (NULL
, file
, dynamic_syminfo_offset
, 1, syminsz
,
9643 _("symbol information"));
9647 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
9648 if (dynamic_syminfo
== NULL
)
9650 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9651 (unsigned long) syminsz
);
9655 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
9656 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
9657 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
9658 ++syminfo
, ++extsym
)
9660 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
9661 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
9668 if (do_dynamic
&& dynamic_addr
)
9669 printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
9670 dynamic_addr
, (unsigned long) dynamic_nent
);
9672 printf (_(" Tag Type Name/Value\n"));
9674 for (entry
= dynamic_section
;
9675 entry
< dynamic_section
+ dynamic_nent
;
9683 print_vma (entry
->d_tag
, FULL_HEX
);
9684 dtype
= get_dynamic_type (entry
->d_tag
);
9685 printf (" (%s)%*s", dtype
,
9686 ((is_32bit_elf
? 27 : 19) - (int) strlen (dtype
)), " ");
9689 switch (entry
->d_tag
)
9693 print_dynamic_flags (entry
->d_un
.d_val
);
9703 switch (entry
->d_tag
)
9706 printf (_("Auxiliary library"));
9710 printf (_("Filter library"));
9714 printf (_("Configuration file"));
9718 printf (_("Dependency audit library"));
9722 printf (_("Audit library"));
9726 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9727 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
9731 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9740 printf (_("Flags:"));
9742 if (entry
->d_un
.d_val
== 0)
9743 printf (_(" None\n"));
9746 unsigned long int val
= entry
->d_un
.d_val
;
9748 if (val
& DTF_1_PARINIT
)
9750 printf (" PARINIT");
9751 val
^= DTF_1_PARINIT
;
9753 if (val
& DTF_1_CONFEXP
)
9755 printf (" CONFEXP");
9756 val
^= DTF_1_CONFEXP
;
9759 printf (" %lx", val
);
9768 printf (_("Flags:"));
9770 if (entry
->d_un
.d_val
== 0)
9771 printf (_(" None\n"));
9774 unsigned long int val
= entry
->d_un
.d_val
;
9776 if (val
& DF_P1_LAZYLOAD
)
9778 printf (" LAZYLOAD");
9779 val
^= DF_P1_LAZYLOAD
;
9781 if (val
& DF_P1_GROUPPERM
)
9783 printf (" GROUPPERM");
9784 val
^= DF_P1_GROUPPERM
;
9787 printf (" %lx", val
);
9796 printf (_("Flags:"));
9797 if (entry
->d_un
.d_val
== 0)
9798 printf (_(" None\n"));
9801 unsigned long int val
= entry
->d_un
.d_val
;
9808 if (val
& DF_1_GLOBAL
)
9813 if (val
& DF_1_GROUP
)
9818 if (val
& DF_1_NODELETE
)
9820 printf (" NODELETE");
9821 val
^= DF_1_NODELETE
;
9823 if (val
& DF_1_LOADFLTR
)
9825 printf (" LOADFLTR");
9826 val
^= DF_1_LOADFLTR
;
9828 if (val
& DF_1_INITFIRST
)
9830 printf (" INITFIRST");
9831 val
^= DF_1_INITFIRST
;
9833 if (val
& DF_1_NOOPEN
)
9838 if (val
& DF_1_ORIGIN
)
9843 if (val
& DF_1_DIRECT
)
9848 if (val
& DF_1_TRANS
)
9853 if (val
& DF_1_INTERPOSE
)
9855 printf (" INTERPOSE");
9856 val
^= DF_1_INTERPOSE
;
9858 if (val
& DF_1_NODEFLIB
)
9860 printf (" NODEFLIB");
9861 val
^= DF_1_NODEFLIB
;
9863 if (val
& DF_1_NODUMP
)
9868 if (val
& DF_1_CONFALT
)
9870 printf (" CONFALT");
9871 val
^= DF_1_CONFALT
;
9873 if (val
& DF_1_ENDFILTEE
)
9875 printf (" ENDFILTEE");
9876 val
^= DF_1_ENDFILTEE
;
9878 if (val
& DF_1_DISPRELDNE
)
9880 printf (" DISPRELDNE");
9881 val
^= DF_1_DISPRELDNE
;
9883 if (val
& DF_1_DISPRELPND
)
9885 printf (" DISPRELPND");
9886 val
^= DF_1_DISPRELPND
;
9888 if (val
& DF_1_NODIRECT
)
9890 printf (" NODIRECT");
9891 val
^= DF_1_NODIRECT
;
9893 if (val
& DF_1_IGNMULDEF
)
9895 printf (" IGNMULDEF");
9896 val
^= DF_1_IGNMULDEF
;
9898 if (val
& DF_1_NOKSYMS
)
9900 printf (" NOKSYMS");
9901 val
^= DF_1_NOKSYMS
;
9903 if (val
& DF_1_NOHDR
)
9908 if (val
& DF_1_EDITED
)
9913 if (val
& DF_1_NORELOC
)
9915 printf (" NORELOC");
9916 val
^= DF_1_NORELOC
;
9918 if (val
& DF_1_SYMINTPOSE
)
9920 printf (" SYMINTPOSE");
9921 val
^= DF_1_SYMINTPOSE
;
9923 if (val
& DF_1_GLOBAUDIT
)
9925 printf (" GLOBAUDIT");
9926 val
^= DF_1_GLOBAUDIT
;
9928 if (val
& DF_1_SINGLETON
)
9930 printf (" SINGLETON");
9931 val
^= DF_1_SINGLETON
;
9933 if (val
& DF_1_STUB
)
9944 printf (" %lx", val
);
9951 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9953 puts (get_dynamic_type (entry
->d_un
.d_val
));
9973 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
9979 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9980 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
9986 switch (entry
->d_tag
)
9989 printf (_("Shared library: [%s]"), name
);
9991 if (streq (name
, program_interpreter
))
9992 printf (_(" program interpreter"));
9996 printf (_("Library soname: [%s]"), name
);
10000 printf (_("Library rpath: [%s]"), name
);
10004 printf (_("Library runpath: [%s]"), name
);
10008 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10013 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10026 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10027 /* Fall through. */
10031 case DT_INIT_ARRAYSZ
:
10032 case DT_FINI_ARRAYSZ
:
10033 case DT_GNU_CONFLICTSZ
:
10034 case DT_GNU_LIBLISTSZ
:
10037 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10038 printf (_(" (bytes)\n"));
10043 case DT_VERNEEDNUM
:
10048 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10057 case DT_INIT_ARRAY
:
10058 case DT_FINI_ARRAY
:
10061 if (entry
->d_tag
== DT_USED
10062 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
10064 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
10068 printf (_("Not needed object: [%s]\n"), name
);
10073 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10079 /* The value of this entry is ignored. */
10084 case DT_GNU_PRELINKED
:
10088 time_t atime
= entry
->d_un
.d_val
;
10090 tmp
= gmtime (&atime
);
10091 /* PR 17533 file: 041-1244816-0.004. */
10093 printf (_("<corrupt time val: %lx"),
10094 (unsigned long) atime
);
10096 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10097 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
10098 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
10104 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10107 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10113 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
10114 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
10119 switch (elf_header
.e_machine
)
10122 case EM_MIPS_RS3_LE
:
10123 dynamic_section_mips_val (entry
);
10126 dynamic_section_parisc_val (entry
);
10129 dynamic_section_ia64_val (entry
);
10132 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10144 get_ver_flags (unsigned int flags
)
10146 static char buff
[32];
10153 if (flags
& VER_FLG_BASE
)
10154 strcat (buff
, "BASE");
10156 if (flags
& VER_FLG_WEAK
)
10158 if (flags
& VER_FLG_BASE
)
10159 strcat (buff
, " | ");
10161 strcat (buff
, "WEAK");
10164 if (flags
& VER_FLG_INFO
)
10166 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
10167 strcat (buff
, " | ");
10169 strcat (buff
, "INFO");
10172 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10174 if (flags
& (VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10175 strcat (buff
, " | ");
10177 strcat (buff
, _("<unknown>"));
10183 /* Display the contents of the version sections. */
10186 process_version_sections (FILE * file
)
10188 Elf_Internal_Shdr
* section
;
10190 bfd_boolean found
= FALSE
;
10195 for (i
= 0, section
= section_headers
;
10196 i
< elf_header
.e_shnum
;
10199 switch (section
->sh_type
)
10201 case SHT_GNU_verdef
:
10203 Elf_External_Verdef
* edefs
;
10210 printf (_("\nVersion definition section '%s' contains %u entries:\n"),
10211 printable_section_name (section
),
10214 printf (_(" Addr: 0x"));
10215 printf_vma (section
->sh_addr
);
10216 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10217 (unsigned long) section
->sh_offset
, section
->sh_link
,
10218 printable_section_name_from_index (section
->sh_link
));
10220 edefs
= (Elf_External_Verdef
*)
10221 get_data (NULL
, file
, section
->sh_offset
, 1,section
->sh_size
,
10222 _("version definition section"));
10225 endbuf
= (char *) edefs
+ section
->sh_size
;
10227 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
10230 Elf_External_Verdef
* edef
;
10231 Elf_Internal_Verdef ent
;
10232 Elf_External_Verdaux
* eaux
;
10233 Elf_Internal_Verdaux aux
;
10234 unsigned long isum
;
10237 vstart
= ((char *) edefs
) + idx
;
10238 if (vstart
+ sizeof (*edef
) > endbuf
)
10241 edef
= (Elf_External_Verdef
*) vstart
;
10243 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
10244 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
10245 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
10246 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
10247 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
10248 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
10249 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
10251 printf (_(" %#06lx: Rev: %d Flags: %s"),
10252 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
10254 printf (_(" Index: %d Cnt: %d "),
10255 ent
.vd_ndx
, ent
.vd_cnt
);
10257 /* Check for overflow. */
10258 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
10261 vstart
+= ent
.vd_aux
;
10263 if (vstart
+ sizeof (*eaux
) > endbuf
)
10265 eaux
= (Elf_External_Verdaux
*) vstart
;
10267 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10268 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10270 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10271 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
10273 printf (_("Name index: %ld\n"), aux
.vda_name
);
10275 isum
= idx
+ ent
.vd_aux
;
10277 for (j
= 1; j
< ent
.vd_cnt
; j
++)
10279 if (aux
.vda_next
< sizeof (*eaux
)
10280 && !(j
== ent
.vd_cnt
- 1 && aux
.vda_next
== 0))
10282 warn (_("Invalid vda_next field of %lx\n"),
10287 /* Check for overflow. */
10288 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
10291 isum
+= aux
.vda_next
;
10292 vstart
+= aux
.vda_next
;
10294 if (vstart
+ sizeof (*eaux
) > endbuf
)
10296 eaux
= (Elf_External_Verdaux
*) vstart
;
10298 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10299 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10301 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10302 printf (_(" %#06lx: Parent %d: %s\n"),
10303 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
10305 printf (_(" %#06lx: Parent %d, name index: %ld\n"),
10306 isum
, j
, aux
.vda_name
);
10309 if (j
< ent
.vd_cnt
)
10310 printf (_(" Version def aux past end of section\n"));
10313 file: id:000001,src:000172+005151,op:splice,rep:2. */
10314 if (ent
.vd_next
< sizeof (*edef
)
10315 && !(cnt
== section
->sh_info
- 1 && ent
.vd_next
== 0))
10317 warn (_("Invalid vd_next field of %lx\n"), ent
.vd_next
);
10318 cnt
= section
->sh_info
;
10321 if (ent
.vd_next
> (size_t) (endbuf
- ((char *) edefs
+ idx
)))
10324 idx
+= ent
.vd_next
;
10327 if (cnt
< section
->sh_info
)
10328 printf (_(" Version definition past end of section\n"));
10334 case SHT_GNU_verneed
:
10336 Elf_External_Verneed
* eneed
;
10343 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
10344 printable_section_name (section
), section
->sh_info
);
10346 printf (_(" Addr: 0x"));
10347 printf_vma (section
->sh_addr
);
10348 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10349 (unsigned long) section
->sh_offset
, section
->sh_link
,
10350 printable_section_name_from_index (section
->sh_link
));
10352 eneed
= (Elf_External_Verneed
*) get_data (NULL
, file
,
10353 section
->sh_offset
, 1,
10355 _("Version Needs section"));
10358 endbuf
= (char *) eneed
+ section
->sh_size
;
10360 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
10362 Elf_External_Verneed
* entry
;
10363 Elf_Internal_Verneed ent
;
10364 unsigned long isum
;
10368 vstart
= ((char *) eneed
) + idx
;
10369 if (vstart
+ sizeof (*entry
) > endbuf
)
10372 entry
= (Elf_External_Verneed
*) vstart
;
10374 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
10375 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
10376 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
10377 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
10378 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
10380 printf (_(" %#06lx: Version: %d"), idx
, ent
.vn_version
);
10382 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
10383 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
10385 printf (_(" File: %lx"), ent
.vn_file
);
10387 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
10389 /* Check for overflow. */
10390 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
10392 vstart
+= ent
.vn_aux
;
10394 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
10396 Elf_External_Vernaux
* eaux
;
10397 Elf_Internal_Vernaux aux
;
10399 if (vstart
+ sizeof (*eaux
) > endbuf
)
10401 eaux
= (Elf_External_Vernaux
*) vstart
;
10403 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
10404 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
10405 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
10406 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
10407 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
10409 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
10410 printf (_(" %#06lx: Name: %s"),
10411 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
10413 printf (_(" %#06lx: Name index: %lx"),
10414 isum
, aux
.vna_name
);
10416 printf (_(" Flags: %s Version: %d\n"),
10417 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
10419 if (aux
.vna_next
< sizeof (*eaux
)
10420 && !(j
== ent
.vn_cnt
- 1 && aux
.vna_next
== 0))
10422 warn (_("Invalid vna_next field of %lx\n"),
10427 /* Check for overflow. */
10428 if (aux
.vna_next
> (size_t) (endbuf
- vstart
))
10430 isum
+= aux
.vna_next
;
10431 vstart
+= aux
.vna_next
;
10434 if (j
< ent
.vn_cnt
)
10435 warn (_("Missing Version Needs auxillary information\n"));
10437 if (ent
.vn_next
< sizeof (*entry
)
10438 && !(cnt
== section
->sh_info
- 1 && ent
.vn_next
== 0))
10440 warn (_("Invalid vn_next field of %lx\n"), ent
.vn_next
);
10441 cnt
= section
->sh_info
;
10444 if (ent
.vn_next
> (size_t) (endbuf
- ((char *) eneed
+ idx
)))
10446 idx
+= ent
.vn_next
;
10449 if (cnt
< section
->sh_info
)
10450 warn (_("Missing Version Needs information\n"));
10456 case SHT_GNU_versym
:
10458 Elf_Internal_Shdr
* link_section
;
10461 unsigned char * edata
;
10462 unsigned short * data
;
10464 Elf_Internal_Sym
* symbols
;
10465 Elf_Internal_Shdr
* string_sec
;
10466 unsigned long num_syms
;
10469 if (section
->sh_link
>= elf_header
.e_shnum
)
10472 link_section
= section_headers
+ section
->sh_link
;
10473 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
10475 if (link_section
->sh_link
>= elf_header
.e_shnum
)
10480 symbols
= GET_ELF_SYMBOLS (file
, link_section
, & num_syms
);
10481 if (symbols
== NULL
)
10484 string_sec
= section_headers
+ link_section
->sh_link
;
10486 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
10487 string_sec
->sh_size
,
10488 _("version string table"));
10495 printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
10496 printable_section_name (section
), (unsigned long) total
);
10498 printf (_(" Addr: "));
10499 printf_vma (section
->sh_addr
);
10500 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10501 (unsigned long) section
->sh_offset
, section
->sh_link
,
10502 printable_section_name (link_section
));
10504 off
= offset_from_vma (file
,
10505 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
10506 total
* sizeof (short));
10507 edata
= (unsigned char *) get_data (NULL
, file
, off
, total
,
10509 _("version symbol data"));
10517 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
10519 for (cnt
= total
; cnt
--;)
10520 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
10525 for (cnt
= 0; cnt
< total
; cnt
+= 4)
10529 char *invalid
= _("*invalid*");
10531 printf (" %03x:", cnt
);
10533 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
10534 switch (data
[cnt
+ j
])
10537 fputs (_(" 0 (*local*) "), stdout
);
10541 fputs (_(" 1 (*global*) "), stdout
);
10545 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
10546 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
10548 /* If this index value is greater than the size of the symbols
10549 array, break to avoid an out-of-bounds read. */
10550 if ((unsigned long)(cnt
+ j
) >= num_syms
)
10552 warn (_("invalid index into symbol array\n"));
10557 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
10559 Elf_Internal_Verneed ivn
;
10560 unsigned long offset
;
10562 offset
= offset_from_vma
10563 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
10564 sizeof (Elf_External_Verneed
));
10568 Elf_Internal_Vernaux ivna
;
10569 Elf_External_Verneed evn
;
10570 Elf_External_Vernaux evna
;
10571 unsigned long a_off
;
10573 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
10574 _("version need")) == NULL
)
10577 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
10578 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
10580 a_off
= offset
+ ivn
.vn_aux
;
10584 if (get_data (&evna
, file
, a_off
, sizeof (evna
),
10585 1, _("version need aux (2)")) == NULL
)
10588 ivna
.vna_other
= 0;
10592 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
10593 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
10596 a_off
+= ivna
.vna_next
;
10598 while (ivna
.vna_other
!= data
[cnt
+ j
]
10599 && ivna
.vna_next
!= 0);
10601 if (ivna
.vna_other
== data
[cnt
+ j
])
10603 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
10605 if (ivna
.vna_name
>= string_sec
->sh_size
)
10608 name
= strtab
+ ivna
.vna_name
;
10612 offset
+= ivn
.vn_next
;
10614 while (ivn
.vn_next
);
10617 if (data
[cnt
+ j
] != 0x8001
10618 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
10620 Elf_Internal_Verdef ivd
;
10621 Elf_External_Verdef evd
;
10622 unsigned long offset
;
10624 offset
= offset_from_vma
10625 (file
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
10630 if (get_data (&evd
, file
, offset
, sizeof (evd
), 1,
10631 _("version def")) == NULL
)
10634 /* PR 17531: file: 046-1082287-0.004. */
10635 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
10640 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
10641 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
10644 offset
+= ivd
.vd_next
;
10646 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
10647 && ivd
.vd_next
!= 0);
10649 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
10651 Elf_External_Verdaux evda
;
10652 Elf_Internal_Verdaux ivda
;
10654 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
10656 if (get_data (&evda
, file
,
10657 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
10659 _("version def aux")) == NULL
)
10662 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
10664 if (ivda
.vda_name
>= string_sec
->sh_size
)
10666 else if (name
!= NULL
&& name
!= invalid
)
10667 name
= _("*both*");
10669 name
= strtab
+ ivda
.vda_name
;
10673 nn
+= printf ("(%s%-*s",
10675 12 - (int) strlen (name
),
10679 printf ("%*c", 18 - nn
, ' ');
10697 printf (_("\nNo version information found in this file.\n"));
10702 static const char *
10703 get_symbol_binding (unsigned int binding
)
10705 static char buff
[32];
10709 case STB_LOCAL
: return "LOCAL";
10710 case STB_GLOBAL
: return "GLOBAL";
10711 case STB_WEAK
: return "WEAK";
10713 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
10714 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
10716 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
10718 if (binding
== STB_GNU_UNIQUE
10719 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10720 /* GNU is still using the default value 0. */
10721 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10723 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
10726 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
10731 static const char *
10732 get_symbol_type (unsigned int type
)
10734 static char buff
[32];
10738 case STT_NOTYPE
: return "NOTYPE";
10739 case STT_OBJECT
: return "OBJECT";
10740 case STT_FUNC
: return "FUNC";
10741 case STT_SECTION
: return "SECTION";
10742 case STT_FILE
: return "FILE";
10743 case STT_COMMON
: return "COMMON";
10744 case STT_TLS
: return "TLS";
10745 case STT_RELC
: return "RELC";
10746 case STT_SRELC
: return "SRELC";
10748 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
10750 if (elf_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
10751 return "THUMB_FUNC";
10753 if (elf_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
10756 if (elf_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
10757 return "PARISC_MILLI";
10759 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
10761 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
10763 if (elf_header
.e_machine
== EM_PARISC
)
10765 if (type
== STT_HP_OPAQUE
)
10766 return "HP_OPAQUE";
10767 if (type
== STT_HP_STUB
)
10771 if (type
== STT_GNU_IFUNC
10772 && (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10773 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
10774 /* GNU is still using the default value 0. */
10775 || elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10778 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
10781 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
10786 static const char *
10787 get_symbol_visibility (unsigned int visibility
)
10789 switch (visibility
)
10791 case STV_DEFAULT
: return "DEFAULT";
10792 case STV_INTERNAL
: return "INTERNAL";
10793 case STV_HIDDEN
: return "HIDDEN";
10794 case STV_PROTECTED
: return "PROTECTED";
10796 error (_("Unrecognized visibility value: %u"), visibility
);
10797 return _("<unknown>");
10801 static const char *
10802 get_solaris_symbol_visibility (unsigned int visibility
)
10804 switch (visibility
)
10806 case 4: return "EXPORTED";
10807 case 5: return "SINGLETON";
10808 case 6: return "ELIMINATE";
10809 default: return get_symbol_visibility (visibility
);
10813 static const char *
10814 get_mips_symbol_other (unsigned int other
)
10818 case STO_OPTIONAL
: return "OPTIONAL";
10819 case STO_MIPS_PLT
: return "MIPS PLT";
10820 case STO_MIPS_PIC
: return "MIPS PIC";
10821 case STO_MICROMIPS
: return "MICROMIPS";
10822 case STO_MICROMIPS
| STO_MIPS_PIC
: return "MICROMIPS, MIPS PIC";
10823 case STO_MIPS16
: return "MIPS16";
10824 default: return NULL
;
10828 static const char *
10829 get_ia64_symbol_other (unsigned int other
)
10831 if (is_ia64_vms ())
10833 static char res
[32];
10837 /* Function types is for images and .STB files only. */
10838 switch (elf_header
.e_type
)
10842 switch (VMS_ST_FUNC_TYPE (other
))
10844 case VMS_SFT_CODE_ADDR
:
10845 strcat (res
, " CA");
10847 case VMS_SFT_SYMV_IDX
:
10848 strcat (res
, " VEC");
10851 strcat (res
, " FD");
10853 case VMS_SFT_RESERVE
:
10854 strcat (res
, " RSV");
10857 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10858 VMS_ST_FUNC_TYPE (other
));
10859 strcat (res
, " <unknown>");
10866 switch (VMS_ST_LINKAGE (other
))
10868 case VMS_STL_IGNORE
:
10869 strcat (res
, " IGN");
10871 case VMS_STL_RESERVE
:
10872 strcat (res
, " RSV");
10875 strcat (res
, " STD");
10878 strcat (res
, " LNK");
10881 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10882 VMS_ST_LINKAGE (other
));
10883 strcat (res
, " <unknown>");
10895 static const char *
10896 get_ppc64_symbol_other (unsigned int other
)
10898 if (PPC64_LOCAL_ENTRY_OFFSET (other
) != 0)
10900 static char buf
[32];
10901 snprintf (buf
, sizeof buf
, _("<localentry>: %d"),
10902 PPC64_LOCAL_ENTRY_OFFSET (other
));
10908 static const char *
10909 get_symbol_other (unsigned int other
)
10911 const char * result
= NULL
;
10912 static char buff
[32];
10917 switch (elf_header
.e_machine
)
10920 result
= get_mips_symbol_other (other
);
10923 result
= get_ia64_symbol_other (other
);
10926 result
= get_ppc64_symbol_other (other
);
10936 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
10940 static const char *
10941 get_symbol_index_type (unsigned int type
)
10943 static char buff
[32];
10947 case SHN_UNDEF
: return "UND";
10948 case SHN_ABS
: return "ABS";
10949 case SHN_COMMON
: return "COM";
10951 if (type
== SHN_IA_64_ANSI_COMMON
10952 && elf_header
.e_machine
== EM_IA_64
10953 && elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
10955 else if ((elf_header
.e_machine
== EM_X86_64
10956 || elf_header
.e_machine
== EM_L1OM
10957 || elf_header
.e_machine
== EM_K1OM
)
10958 && type
== SHN_X86_64_LCOMMON
)
10959 return "LARGE_COM";
10960 else if ((type
== SHN_MIPS_SCOMMON
10961 && elf_header
.e_machine
== EM_MIPS
)
10962 || (type
== SHN_TIC6X_SCOMMON
10963 && elf_header
.e_machine
== EM_TI_C6000
))
10965 else if (type
== SHN_MIPS_SUNDEFINED
10966 && elf_header
.e_machine
== EM_MIPS
)
10968 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
10969 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
10970 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
10971 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
10972 else if (type
>= SHN_LORESERVE
)
10973 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
10974 else if (type
>= elf_header
.e_shnum
)
10975 sprintf (buff
, _("bad section index[%3d]"), type
);
10977 sprintf (buff
, "%3d", type
);
10985 get_dynamic_data (FILE * file
, bfd_size_type number
, unsigned int ent_size
)
10987 unsigned char * e_data
;
10990 /* If the size_t type is smaller than the bfd_size_type, eg because
10991 you are building a 32-bit tool on a 64-bit host, then make sure
10992 that when (number) is cast to (size_t) no information is lost. */
10993 if (sizeof (size_t) < sizeof (bfd_size_type
)
10994 && (bfd_size_type
) ((size_t) number
) != number
)
10996 error (_("Size truncation prevents reading %s elements of size %u\n"),
10997 bfd_vmatoa ("u", number
), ent_size
);
11001 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
11002 attempting to allocate memory when the read is bound to fail. */
11003 if (ent_size
* number
> current_file_size
)
11005 error (_("Invalid number of dynamic entries: %s\n"),
11006 bfd_vmatoa ("u", number
));
11010 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
11011 if (e_data
== NULL
)
11013 error (_("Out of memory reading %s dynamic entries\n"),
11014 bfd_vmatoa ("u", number
));
11018 if (fread (e_data
, ent_size
, (size_t) number
, file
) != number
)
11020 error (_("Unable to read in %s bytes of dynamic data\n"),
11021 bfd_vmatoa ("u", number
* ent_size
));
11026 i_data
= (bfd_vma
*) cmalloc ((size_t) number
, sizeof (*i_data
));
11027 if (i_data
== NULL
)
11029 error (_("Out of memory allocating space for %s dynamic entries\n"),
11030 bfd_vmatoa ("u", number
));
11036 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
11044 print_dynamic_symbol (bfd_vma si
, unsigned long hn
)
11046 Elf_Internal_Sym
* psym
;
11049 n
= print_vma (si
, DEC_5
);
11051 fputs (&" "[n
], stdout
);
11052 printf (" %3lu: ", hn
);
11054 if (dynamic_symbols
== NULL
|| si
>= num_dynamic_syms
)
11056 printf (_("<No info available for dynamic symbol number %lu>\n"),
11057 (unsigned long) si
);
11061 psym
= dynamic_symbols
+ si
;
11062 print_vma (psym
->st_value
, LONG_HEX
);
11064 print_vma (psym
->st_size
, DEC_5
);
11066 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
11067 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
11069 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
11070 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
11073 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
11075 printf (" %-7s", get_symbol_visibility (vis
));
11076 /* Check to see if any other bits in the st_other field are set.
11077 Note - displaying this information disrupts the layout of the
11078 table being generated, but for the moment this case is very
11080 if (psym
->st_other
^ vis
)
11081 printf (" [%s] ", get_symbol_other (psym
->st_other
^ vis
));
11084 printf (" %3.3s ", get_symbol_index_type (psym
->st_shndx
));
11085 if (VALID_DYNAMIC_NAME (psym
->st_name
))
11086 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
11088 printf (_(" <corrupt: %14ld>"), psym
->st_name
);
11092 static const char *
11093 get_symbol_version_string (FILE * file
,
11094 bfd_boolean is_dynsym
,
11095 const char * strtab
,
11096 unsigned long int strtab_size
,
11098 Elf_Internal_Sym
* psym
,
11099 enum versioned_symbol_info
* sym_info
,
11100 unsigned short * vna_other
)
11102 unsigned char data
[2];
11103 unsigned short vers_data
;
11104 unsigned long offset
;
11107 || version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
11110 offset
= offset_from_vma (file
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
11111 sizeof data
+ si
* sizeof (vers_data
));
11113 if (get_data (&data
, file
, offset
+ si
* sizeof (vers_data
),
11114 sizeof (data
), 1, _("version data")) == NULL
)
11117 vers_data
= byte_get (data
, 2);
11119 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
<= 1)
11122 /* Usually we'd only see verdef for defined symbols, and verneed for
11123 undefined symbols. However, symbols defined by the linker in
11124 .dynbss for variables copied from a shared library in order to
11125 avoid text relocations are defined yet have verneed. We could
11126 use a heuristic to detect the special case, for example, check
11127 for verneed first on symbols defined in SHT_NOBITS sections, but
11128 it is simpler and more reliable to just look for both verdef and
11129 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
11131 if (psym
->st_shndx
!= SHN_UNDEF
11132 && vers_data
!= 0x8001
11133 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
11135 Elf_Internal_Verdef ivd
;
11136 Elf_Internal_Verdaux ivda
;
11137 Elf_External_Verdaux evda
;
11140 off
= offset_from_vma (file
,
11141 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
11142 sizeof (Elf_External_Verdef
));
11146 Elf_External_Verdef evd
;
11148 if (get_data (&evd
, file
, off
, sizeof (evd
), 1,
11149 _("version def")) == NULL
)
11157 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
11158 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
11159 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
11162 off
+= ivd
.vd_next
;
11164 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
11166 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
11168 off
-= ivd
.vd_next
;
11171 if (get_data (&evda
, file
, off
, sizeof (evda
), 1,
11172 _("version def aux")) != NULL
)
11174 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
11176 if (psym
->st_name
!= ivda
.vda_name
)
11178 *sym_info
= ((vers_data
& VERSYM_HIDDEN
) != 0
11179 ? symbol_hidden
: symbol_public
);
11180 return (ivda
.vda_name
< strtab_size
11181 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
11187 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
11189 Elf_External_Verneed evn
;
11190 Elf_Internal_Verneed ivn
;
11191 Elf_Internal_Vernaux ivna
;
11193 offset
= offset_from_vma (file
,
11194 version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
11198 unsigned long vna_off
;
11200 if (get_data (&evn
, file
, offset
, sizeof (evn
), 1,
11201 _("version need")) == NULL
)
11204 ivna
.vna_other
= 0;
11209 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
11210 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
11212 vna_off
= offset
+ ivn
.vn_aux
;
11216 Elf_External_Vernaux evna
;
11218 if (get_data (&evna
, file
, vna_off
, sizeof (evna
), 1,
11219 _("version need aux (3)")) == NULL
)
11222 ivna
.vna_other
= 0;
11227 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
11228 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
11229 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
11232 vna_off
+= ivna
.vna_next
;
11234 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
11236 if (ivna
.vna_other
== vers_data
)
11239 offset
+= ivn
.vn_next
;
11241 while (ivn
.vn_next
!= 0);
11243 if (ivna
.vna_other
== vers_data
)
11245 *sym_info
= symbol_undefined
;
11246 *vna_other
= ivna
.vna_other
;
11247 return (ivna
.vna_name
< strtab_size
11248 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
11254 /* Dump the symbol table. */
11256 process_symbol_table (FILE * file
)
11258 Elf_Internal_Shdr
* section
;
11259 bfd_size_type nbuckets
= 0;
11260 bfd_size_type nchains
= 0;
11261 bfd_vma
* buckets
= NULL
;
11262 bfd_vma
* chains
= NULL
;
11263 bfd_vma ngnubuckets
= 0;
11264 bfd_vma
* gnubuckets
= NULL
;
11265 bfd_vma
* gnuchains
= NULL
;
11266 bfd_vma gnusymidx
= 0;
11267 bfd_size_type ngnuchains
= 0;
11269 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
11272 if (dynamic_info
[DT_HASH
]
11274 || (do_using_dynamic
11276 && dynamic_strings
!= NULL
)))
11278 unsigned char nb
[8];
11279 unsigned char nc
[8];
11280 unsigned int hash_ent_size
= 4;
11282 if ((elf_header
.e_machine
== EM_ALPHA
11283 || elf_header
.e_machine
== EM_S390
11284 || elf_header
.e_machine
== EM_S390_OLD
)
11285 && elf_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
11289 (archive_file_offset
11290 + offset_from_vma (file
, dynamic_info
[DT_HASH
],
11291 sizeof nb
+ sizeof nc
)),
11294 error (_("Unable to seek to start of dynamic information\n"));
11298 if (fread (nb
, hash_ent_size
, 1, file
) != 1)
11300 error (_("Failed to read in number of buckets\n"));
11304 if (fread (nc
, hash_ent_size
, 1, file
) != 1)
11306 error (_("Failed to read in number of chains\n"));
11310 nbuckets
= byte_get (nb
, hash_ent_size
);
11311 nchains
= byte_get (nc
, hash_ent_size
);
11313 buckets
= get_dynamic_data (file
, nbuckets
, hash_ent_size
);
11314 chains
= get_dynamic_data (file
, nchains
, hash_ent_size
);
11317 if (buckets
== NULL
|| chains
== NULL
)
11319 if (do_using_dynamic
)
11330 if (dynamic_info_DT_GNU_HASH
11332 || (do_using_dynamic
11334 && dynamic_strings
!= NULL
)))
11336 unsigned char nb
[16];
11337 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
11338 bfd_vma buckets_vma
;
11341 (archive_file_offset
11342 + offset_from_vma (file
, dynamic_info_DT_GNU_HASH
,
11346 error (_("Unable to seek to start of dynamic information\n"));
11350 if (fread (nb
, 16, 1, file
) != 1)
11352 error (_("Failed to read in number of buckets\n"));
11356 ngnubuckets
= byte_get (nb
, 4);
11357 gnusymidx
= byte_get (nb
+ 4, 4);
11358 bitmaskwords
= byte_get (nb
+ 8, 4);
11359 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
11361 buckets_vma
+= bitmaskwords
* 4;
11363 buckets_vma
+= bitmaskwords
* 8;
11366 (archive_file_offset
11367 + offset_from_vma (file
, buckets_vma
, 4)),
11370 error (_("Unable to seek to start of dynamic information\n"));
11374 gnubuckets
= get_dynamic_data (file
, ngnubuckets
, 4);
11376 if (gnubuckets
== NULL
)
11379 for (i
= 0; i
< ngnubuckets
; i
++)
11380 if (gnubuckets
[i
] != 0)
11382 if (gnubuckets
[i
] < gnusymidx
)
11385 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
11386 maxchain
= gnubuckets
[i
];
11389 if (maxchain
== 0xffffffff)
11392 maxchain
-= gnusymidx
;
11395 (archive_file_offset
11396 + offset_from_vma (file
, buckets_vma
11397 + 4 * (ngnubuckets
+ maxchain
), 4)),
11400 error (_("Unable to seek to start of dynamic information\n"));
11406 if (fread (nb
, 4, 1, file
) != 1)
11408 error (_("Failed to determine last chain length\n"));
11412 if (maxchain
+ 1 == 0)
11417 while ((byte_get (nb
, 4) & 1) == 0);
11420 (archive_file_offset
11421 + offset_from_vma (file
, buckets_vma
+ 4 * ngnubuckets
, 4)),
11424 error (_("Unable to seek to start of dynamic information\n"));
11428 gnuchains
= get_dynamic_data (file
, maxchain
, 4);
11429 ngnuchains
= maxchain
;
11432 if (gnuchains
== NULL
)
11437 if (do_using_dynamic
)
11442 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
11444 && do_using_dynamic
11445 && dynamic_strings
!= NULL
11446 && dynamic_symbols
!= NULL
)
11450 if (dynamic_info
[DT_HASH
])
11455 printf (_("\nSymbol table for image:\n"));
11457 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11459 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11461 visited
= xcmalloc (nchains
, 1);
11462 memset (visited
, 0, nchains
);
11463 for (hn
= 0; hn
< nbuckets
; hn
++)
11465 for (si
= buckets
[hn
]; si
> 0; si
= chains
[si
])
11467 print_dynamic_symbol (si
, hn
);
11468 if (si
>= nchains
|| visited
[si
])
11470 error (_("histogram chain is corrupt\n"));
11479 if (dynamic_info_DT_GNU_HASH
)
11481 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
11483 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11485 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11487 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11488 if (gnubuckets
[hn
] != 0)
11490 bfd_vma si
= gnubuckets
[hn
];
11491 bfd_vma off
= si
- gnusymidx
;
11495 print_dynamic_symbol (si
, hn
);
11498 while (off
< ngnuchains
&& (gnuchains
[off
++] & 1) == 0);
11502 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
11503 && section_headers
!= NULL
)
11507 for (i
= 0, section
= section_headers
;
11508 i
< elf_header
.e_shnum
;
11512 char * strtab
= NULL
;
11513 unsigned long int strtab_size
= 0;
11514 Elf_Internal_Sym
* symtab
;
11515 Elf_Internal_Sym
* psym
;
11516 unsigned long num_syms
;
11518 if ((section
->sh_type
!= SHT_SYMTAB
11519 && section
->sh_type
!= SHT_DYNSYM
)
11521 && section
->sh_type
== SHT_SYMTAB
))
11524 if (section
->sh_entsize
== 0)
11526 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
11527 printable_section_name (section
));
11531 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
11532 printable_section_name (section
),
11533 (unsigned long) (section
->sh_size
/ section
->sh_entsize
));
11536 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11538 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11540 symtab
= GET_ELF_SYMBOLS (file
, section
, & num_syms
);
11541 if (symtab
== NULL
)
11544 if (section
->sh_link
== elf_header
.e_shstrndx
)
11546 strtab
= string_table
;
11547 strtab_size
= string_table_length
;
11549 else if (section
->sh_link
< elf_header
.e_shnum
)
11551 Elf_Internal_Shdr
* string_sec
;
11553 string_sec
= section_headers
+ section
->sh_link
;
11555 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
,
11556 1, string_sec
->sh_size
,
11557 _("string table"));
11558 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
11561 for (si
= 0, psym
= symtab
; si
< num_syms
; si
++, psym
++)
11563 const char *version_string
;
11564 enum versioned_symbol_info sym_info
;
11565 unsigned short vna_other
;
11567 printf ("%6d: ", si
);
11568 print_vma (psym
->st_value
, LONG_HEX
);
11570 print_vma (psym
->st_size
, DEC_5
);
11571 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym
->st_info
)));
11572 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym
->st_info
)));
11573 if (elf_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
11574 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
11577 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
11579 printf (" %-7s", get_symbol_visibility (vis
));
11580 /* Check to see if any other bits in the st_other field are set.
11581 Note - displaying this information disrupts the layout of the
11582 table being generated, but for the moment this case is very rare. */
11583 if (psym
->st_other
^ vis
)
11584 printf (" [%s] ", get_symbol_other (psym
->st_other
^ vis
));
11586 printf (" %4s ", get_symbol_index_type (psym
->st_shndx
));
11587 print_symbol (25, psym
->st_name
< strtab_size
11588 ? strtab
+ psym
->st_name
: _("<corrupt>"));
11591 = get_symbol_version_string (file
,
11592 section
->sh_type
== SHT_DYNSYM
,
11593 strtab
, strtab_size
, si
,
11594 psym
, &sym_info
, &vna_other
);
11595 if (version_string
)
11597 if (sym_info
== symbol_undefined
)
11598 printf ("@%s (%d)", version_string
, vna_other
);
11600 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
11606 if (ELF_ST_BIND (psym
->st_info
) == STB_LOCAL
11607 && si
>= section
->sh_info
11608 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
11609 && elf_header
.e_machine
!= EM_MIPS
11610 /* Solaris binaries have been found to violate this requirement as
11611 well. Not sure if this is a bug or an ABI requirement. */
11612 && elf_header
.e_ident
[EI_OSABI
] != ELFOSABI_SOLARIS
)
11613 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
11614 si
, printable_section_name (section
), section
->sh_info
);
11618 if (strtab
!= string_table
)
11624 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
11626 if (do_histogram
&& buckets
!= NULL
)
11628 unsigned long * lengths
;
11629 unsigned long * counts
;
11632 unsigned long maxlength
= 0;
11633 unsigned long nzero_counts
= 0;
11634 unsigned long nsyms
= 0;
11637 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
11638 (unsigned long) nbuckets
);
11640 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
11641 if (lengths
== NULL
)
11643 error (_("Out of memory allocating space for histogram buckets\n"));
11646 visited
= xcmalloc (nchains
, 1);
11647 memset (visited
, 0, nchains
);
11649 printf (_(" Length Number %% of total Coverage\n"));
11650 for (hn
= 0; hn
< nbuckets
; ++hn
)
11652 for (si
= buckets
[hn
]; si
> 0; si
= chains
[si
])
11655 if (maxlength
< ++lengths
[hn
])
11657 if (si
>= nchains
|| visited
[si
])
11659 error (_("histogram chain is corrupt\n"));
11667 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
11668 if (counts
== NULL
)
11671 error (_("Out of memory allocating space for histogram counts\n"));
11675 for (hn
= 0; hn
< nbuckets
; ++hn
)
11676 ++counts
[lengths
[hn
]];
11681 printf (" 0 %-10lu (%5.1f%%)\n",
11682 counts
[0], (counts
[0] * 100.0) / nbuckets
);
11683 for (i
= 1; i
<= maxlength
; ++i
)
11685 nzero_counts
+= counts
[i
] * i
;
11686 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11687 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
11688 (nzero_counts
* 100.0) / nsyms
);
11696 if (buckets
!= NULL
)
11702 if (do_histogram
&& gnubuckets
!= NULL
)
11704 unsigned long * lengths
;
11705 unsigned long * counts
;
11707 unsigned long maxlength
= 0;
11708 unsigned long nzero_counts
= 0;
11709 unsigned long nsyms
= 0;
11711 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
11712 (unsigned long) ngnubuckets
);
11714 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
11715 if (lengths
== NULL
)
11717 error (_("Out of memory allocating space for gnu histogram buckets\n"));
11721 printf (_(" Length Number %% of total Coverage\n"));
11723 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11724 if (gnubuckets
[hn
] != 0)
11726 bfd_vma off
, length
= 1;
11728 for (off
= gnubuckets
[hn
] - gnusymidx
;
11729 /* PR 17531 file: 010-77222-0.004. */
11730 off
< ngnuchains
&& (gnuchains
[off
] & 1) == 0;
11733 lengths
[hn
] = length
;
11734 if (length
> maxlength
)
11735 maxlength
= length
;
11739 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
11740 if (counts
== NULL
)
11743 error (_("Out of memory allocating space for gnu histogram counts\n"));
11747 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11748 ++counts
[lengths
[hn
]];
11750 if (ngnubuckets
> 0)
11753 printf (" 0 %-10lu (%5.1f%%)\n",
11754 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
11755 for (j
= 1; j
<= maxlength
; ++j
)
11757 nzero_counts
+= counts
[j
] * j
;
11758 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11759 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
11760 (nzero_counts
* 100.0) / nsyms
);
11774 process_syminfo (FILE * file ATTRIBUTE_UNUSED
)
11778 if (dynamic_syminfo
== NULL
11780 /* No syminfo, this is ok. */
11783 /* There better should be a dynamic symbol section. */
11784 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
11788 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
11789 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
11791 printf (_(" Num: Name BoundTo Flags\n"));
11792 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
11794 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
11796 printf ("%4d: ", i
);
11797 if (i
>= num_dynamic_syms
)
11798 printf (_("<corrupt index>"));
11799 else if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
11800 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
11802 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
11805 switch (dynamic_syminfo
[i
].si_boundto
)
11807 case SYMINFO_BT_SELF
:
11808 fputs ("SELF ", stdout
);
11810 case SYMINFO_BT_PARENT
:
11811 fputs ("PARENT ", stdout
);
11814 if (dynamic_syminfo
[i
].si_boundto
> 0
11815 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
11816 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
11818 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
11822 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
11826 if (flags
& SYMINFO_FLG_DIRECT
)
11827 printf (" DIRECT");
11828 if (flags
& SYMINFO_FLG_PASSTHRU
)
11829 printf (" PASSTHRU");
11830 if (flags
& SYMINFO_FLG_COPY
)
11832 if (flags
& SYMINFO_FLG_LAZYLOAD
)
11833 printf (" LAZYLOAD");
11841 #define IN_RANGE(START,END,ADDR,OFF) \
11842 (((ADDR) >= (START)) && ((ADDR) + (OFF) < (END)))
11844 /* Check to see if the given reloc needs to be handled in a target specific
11845 manner. If so then process the reloc and return TRUE otherwise return
11848 If called with reloc == NULL, then this is a signal that reloc processing
11849 for the current section has finished, and any saved state should be
11853 target_specific_reloc_handling (Elf_Internal_Rela
* reloc
,
11854 unsigned char * start
,
11855 unsigned char * end
,
11856 Elf_Internal_Sym
* symtab
,
11857 unsigned long num_syms
)
11859 unsigned int reloc_type
= 0;
11860 unsigned long sym_index
= 0;
11864 reloc_type
= get_reloc_type (reloc
->r_info
);
11865 sym_index
= get_reloc_symindex (reloc
->r_info
);
11868 switch (elf_header
.e_machine
)
11871 case EM_MSP430_OLD
:
11873 static Elf_Internal_Sym
* saved_sym
= NULL
;
11881 switch (reloc_type
)
11883 case 10: /* R_MSP430_SYM_DIFF */
11884 if (uses_msp430x_relocs ())
11886 /* Fall through. */
11887 case 21: /* R_MSP430X_SYM_DIFF */
11889 if (sym_index
>= num_syms
)
11890 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
11893 saved_sym
= symtab
+ sym_index
;
11896 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
11897 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
11898 goto handle_sym_diff
;
11900 case 5: /* R_MSP430_16_BYTE */
11901 case 9: /* R_MSP430_8 */
11902 if (uses_msp430x_relocs ())
11904 goto handle_sym_diff
;
11906 case 2: /* R_MSP430_ABS16 */
11907 case 15: /* R_MSP430X_ABS16 */
11908 if (! uses_msp430x_relocs ())
11910 goto handle_sym_diff
;
11913 if (saved_sym
!= NULL
)
11915 int reloc_size
= reloc_type
== 1 ? 4 : 2;
11918 if (sym_index
>= num_syms
)
11919 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
11923 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
11924 - saved_sym
->st_value
);
11926 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
11927 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
11930 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
11931 (long) reloc
->r_offset
);
11940 if (saved_sym
!= NULL
)
11941 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
11948 case EM_CYGNUS_MN10300
:
11950 static Elf_Internal_Sym
* saved_sym
= NULL
;
11958 switch (reloc_type
)
11960 case 34: /* R_MN10300_ALIGN */
11962 case 33: /* R_MN10300_SYM_DIFF */
11963 if (sym_index
>= num_syms
)
11964 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
11967 saved_sym
= symtab
+ sym_index
;
11970 case 1: /* R_MN10300_32 */
11971 case 2: /* R_MN10300_16 */
11972 if (saved_sym
!= NULL
)
11974 int reloc_size
= reloc_type
== 1 ? 4 : 2;
11977 if (sym_index
>= num_syms
)
11978 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
11982 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
11983 - saved_sym
->st_value
);
11985 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
11986 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
11988 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
11989 (long) reloc
->r_offset
);
11997 if (saved_sym
!= NULL
)
11998 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
12006 static bfd_vma saved_sym1
= 0;
12007 static bfd_vma saved_sym2
= 0;
12008 static bfd_vma value
;
12012 saved_sym1
= saved_sym2
= 0;
12016 switch (reloc_type
)
12018 case 0x80: /* R_RL78_SYM. */
12019 saved_sym1
= saved_sym2
;
12020 if (sym_index
>= num_syms
)
12021 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
12025 saved_sym2
= symtab
[sym_index
].st_value
;
12026 saved_sym2
+= reloc
->r_addend
;
12030 case 0x83: /* R_RL78_OPsub. */
12031 value
= saved_sym1
- saved_sym2
;
12032 saved_sym2
= saved_sym1
= 0;
12036 case 0x41: /* R_RL78_ABS32. */
12037 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 4))
12038 byte_put (start
+ reloc
->r_offset
, value
, 4);
12040 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12041 (long) reloc
->r_offset
);
12045 case 0x43: /* R_RL78_ABS16. */
12046 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 2))
12047 byte_put (start
+ reloc
->r_offset
, value
, 2);
12049 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12050 (long) reloc
->r_offset
);
12064 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12065 DWARF debug sections. This is a target specific test. Note - we do not
12066 go through the whole including-target-headers-multiple-times route, (as
12067 we have already done with <elf/h8.h>) because this would become very
12068 messy and even then this function would have to contain target specific
12069 information (the names of the relocs instead of their numeric values).
12070 FIXME: This is not the correct way to solve this problem. The proper way
12071 is to have target specific reloc sizing and typing functions created by
12072 the reloc-macros.h header, in the same way that it already creates the
12073 reloc naming functions. */
12076 is_32bit_abs_reloc (unsigned int reloc_type
)
12078 /* Please keep this table alpha-sorted for ease of visual lookup. */
12079 switch (elf_header
.e_machine
)
12083 return reloc_type
== 1; /* R_386_32. */
12085 return reloc_type
== 1; /* R_68K_32. */
12087 return reloc_type
== 1; /* R_860_32. */
12089 return reloc_type
== 2; /* R_960_32. */
12091 return (reloc_type
== 258
12092 || reloc_type
== 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12093 case EM_ADAPTEVA_EPIPHANY
:
12094 return reloc_type
== 3;
12096 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
12098 return reloc_type
== 1; /* R_ARC_32. */
12099 case EM_ARC_COMPACT
:
12100 case EM_ARC_COMPACT2
:
12101 return reloc_type
== 4; /* R_ARC_32. */
12103 return reloc_type
== 2; /* R_ARM_ABS32 */
12106 return reloc_type
== 1;
12108 return reloc_type
== 0x12; /* R_byte4_data. */
12110 return reloc_type
== 3; /* R_CRIS_32. */
12112 return reloc_type
== 3; /* R_CR16_NUM32. */
12114 return reloc_type
== 15; /* R_CRX_NUM32. */
12115 case EM_CYGNUS_FRV
:
12116 return reloc_type
== 1;
12117 case EM_CYGNUS_D10V
:
12119 return reloc_type
== 6; /* R_D10V_32. */
12120 case EM_CYGNUS_D30V
:
12122 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
12124 return reloc_type
== 3; /* R_DLX_RELOC_32. */
12125 case EM_CYGNUS_FR30
:
12127 return reloc_type
== 3; /* R_FR30_32. */
12129 return reloc_type
== 1; /* R_FT32_32. */
12133 return reloc_type
== 1; /* R_H8_DIR32. */
12135 return (reloc_type
== 0x64 /* R_IA64_SECREL32MSB. */
12136 || reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
12137 || reloc_type
== 0x24 /* R_IA64_DIR32MSB. */
12138 || reloc_type
== 0x25 /* R_IA64_DIR32LSB. */);
12141 return reloc_type
== 2; /* R_IP2K_32. */
12143 return reloc_type
== 2; /* R_IQ2000_32. */
12144 case EM_LATTICEMICO32
:
12145 return reloc_type
== 3; /* R_LM32_32. */
12148 return reloc_type
== 3; /* R_M32C_32. */
12150 return reloc_type
== 34; /* R_M32R_32_RELA. */
12153 return reloc_type
== 6; /* R_M68HC11_32. */
12155 return reloc_type
== 1; /* R_MCORE_ADDR32. */
12156 case EM_CYGNUS_MEP
:
12157 return reloc_type
== 4; /* R_MEP_32. */
12159 return reloc_type
== 2; /* R_METAG_ADDR32. */
12160 case EM_MICROBLAZE
:
12161 return reloc_type
== 1; /* R_MICROBLAZE_32. */
12163 return reloc_type
== 2; /* R_MIPS_32. */
12165 return reloc_type
== 4; /* R_MMIX_32. */
12166 case EM_CYGNUS_MN10200
:
12168 return reloc_type
== 1; /* R_MN10200_32. */
12169 case EM_CYGNUS_MN10300
:
12171 return reloc_type
== 1; /* R_MN10300_32. */
12173 return reloc_type
== 1; /* R_MOXIE_32. */
12174 case EM_MSP430_OLD
:
12176 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
12178 return reloc_type
== 2; /* R_MT_32. */
12180 return reloc_type
== 20; /* R_NDS32_RELA. */
12181 case EM_ALTERA_NIOS2
:
12182 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
12184 return reloc_type
== 1; /* R_NIOS_32. */
12186 return reloc_type
== 1; /* R_OR1K_32. */
12188 return (reloc_type
== 1 /* R_PARISC_DIR32. */
12189 || reloc_type
== 41); /* R_PARISC_SECREL32. */
12192 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
12194 return reloc_type
== 1; /* R_PPC64_ADDR32. */
12196 return reloc_type
== 1; /* R_PPC_ADDR32. */
12198 return reloc_type
== 11; /* R_PRU_BFD_RELOC_32. */
12200 return reloc_type
== 1; /* R_RISCV_32. */
12202 return reloc_type
== 1; /* R_RL78_DIR32. */
12204 return reloc_type
== 1; /* R_RX_DIR32. */
12206 return reloc_type
== 1; /* R_I370_ADDR31. */
12209 return reloc_type
== 4; /* R_S390_32. */
12211 return reloc_type
== 8; /* R_SCORE_ABS32. */
12213 return reloc_type
== 1; /* R_SH_DIR32. */
12214 case EM_SPARC32PLUS
:
12217 return reloc_type
== 3 /* R_SPARC_32. */
12218 || reloc_type
== 23; /* R_SPARC_UA32. */
12220 return reloc_type
== 6; /* R_SPU_ADDR32 */
12222 return reloc_type
== 1; /* R_C6000_ABS32. */
12224 return reloc_type
== 2; /* R_TILEGX_32. */
12226 return reloc_type
== 1; /* R_TILEPRO_32. */
12227 case EM_CYGNUS_V850
:
12229 return reloc_type
== 6; /* R_V850_ABS32. */
12231 return reloc_type
== 0x33; /* R_V810_WORD. */
12233 return reloc_type
== 1; /* R_VAX_32. */
12235 return reloc_type
== 3; /* R_VISIUM_32. */
12236 case EM_WEBASSEMBLY
:
12237 return reloc_type
== 1; /* R_WASM32_32. */
12241 return reloc_type
== 10; /* R_X86_64_32. */
12244 return reloc_type
== 3; /* R_XC16C_ABS_32. */
12246 return reloc_type
== 4; /* R_XGATE_32. */
12248 return reloc_type
== 1; /* R_XSTROMY16_32. */
12249 case EM_XTENSA_OLD
:
12251 return reloc_type
== 1; /* R_XTENSA_32. */
12254 static unsigned int prev_warn
= 0;
12256 /* Avoid repeating the same warning multiple times. */
12257 if (prev_warn
!= elf_header
.e_machine
)
12258 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12259 elf_header
.e_machine
);
12260 prev_warn
= elf_header
.e_machine
;
12266 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12267 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
12270 is_32bit_pcrel_reloc (unsigned int reloc_type
)
12272 switch (elf_header
.e_machine
)
12273 /* Please keep this table alpha-sorted for ease of visual lookup. */
12277 return reloc_type
== 2; /* R_386_PC32. */
12279 return reloc_type
== 4; /* R_68K_PC32. */
12281 return reloc_type
== 261; /* R_AARCH64_PREL32 */
12282 case EM_ADAPTEVA_EPIPHANY
:
12283 return reloc_type
== 6;
12285 return reloc_type
== 10; /* R_ALPHA_SREL32. */
12286 case EM_ARC_COMPACT
:
12287 case EM_ARC_COMPACT2
:
12288 return reloc_type
== 49; /* R_ARC_32_PCREL. */
12290 return reloc_type
== 3; /* R_ARM_REL32 */
12293 return reloc_type
== 36; /* R_AVR_32_PCREL. */
12294 case EM_MICROBLAZE
:
12295 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
12297 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
12299 return reloc_type
== 9; /* R_PARISC_PCREL32. */
12301 return reloc_type
== 26; /* R_PPC_REL32. */
12303 return reloc_type
== 26; /* R_PPC64_REL32. */
12306 return reloc_type
== 5; /* R_390_PC32. */
12308 return reloc_type
== 2; /* R_SH_REL32. */
12309 case EM_SPARC32PLUS
:
12312 return reloc_type
== 6; /* R_SPARC_DISP32. */
12314 return reloc_type
== 13; /* R_SPU_REL32. */
12316 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
12318 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
12320 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
12324 return reloc_type
== 2; /* R_X86_64_PC32. */
12325 case EM_XTENSA_OLD
:
12327 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
12329 /* Do not abort or issue an error message here. Not all targets use
12330 pc-relative 32-bit relocs in their DWARF debug information and we
12331 have already tested for target coverage in is_32bit_abs_reloc. A
12332 more helpful warning message will be generated by apply_relocations
12333 anyway, so just return. */
12338 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12339 a 64-bit absolute RELA relocation used in DWARF debug sections. */
12342 is_64bit_abs_reloc (unsigned int reloc_type
)
12344 switch (elf_header
.e_machine
)
12347 return reloc_type
== 257; /* R_AARCH64_ABS64. */
12349 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
12351 return (reloc_type
== 0x26 /* R_IA64_DIR64MSB. */
12352 || reloc_type
== 0x27 /* R_IA64_DIR64LSB. */);
12354 return reloc_type
== 80; /* R_PARISC_DIR64. */
12356 return reloc_type
== 38; /* R_PPC64_ADDR64. */
12358 return reloc_type
== 2; /* R_RISCV_64. */
12359 case EM_SPARC32PLUS
:
12362 return reloc_type
== 32 /* R_SPARC_64. */
12363 || reloc_type
== 54; /* R_SPARC_UA64. */
12367 return reloc_type
== 1; /* R_X86_64_64. */
12370 return reloc_type
== 22; /* R_S390_64. */
12372 return reloc_type
== 1; /* R_TILEGX_64. */
12374 return reloc_type
== 18; /* R_MIPS_64. */
12380 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12381 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
12384 is_64bit_pcrel_reloc (unsigned int reloc_type
)
12386 switch (elf_header
.e_machine
)
12389 return reloc_type
== 260; /* R_AARCH64_PREL64. */
12391 return reloc_type
== 11; /* R_ALPHA_SREL64. */
12393 return (reloc_type
== 0x4e /* R_IA64_PCREL64MSB. */
12394 || reloc_type
== 0x4f /* R_IA64_PCREL64LSB. */);
12396 return reloc_type
== 72; /* R_PARISC_PCREL64. */
12398 return reloc_type
== 44; /* R_PPC64_REL64. */
12399 case EM_SPARC32PLUS
:
12402 return reloc_type
== 46; /* R_SPARC_DISP64. */
12406 return reloc_type
== 24; /* R_X86_64_PC64. */
12409 return reloc_type
== 23; /* R_S390_PC64. */
12411 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
12417 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12418 a 24-bit absolute RELA relocation used in DWARF debug sections. */
12421 is_24bit_abs_reloc (unsigned int reloc_type
)
12423 switch (elf_header
.e_machine
)
12425 case EM_CYGNUS_MN10200
:
12427 return reloc_type
== 4; /* R_MN10200_24. */
12429 return reloc_type
== 5; /* R_FT32_20. */
12435 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12436 a 16-bit absolute RELA relocation used in DWARF debug sections. */
12439 is_16bit_abs_reloc (unsigned int reloc_type
)
12441 /* Please keep this table alpha-sorted for ease of visual lookup. */
12442 switch (elf_header
.e_machine
)
12445 case EM_ARC_COMPACT
:
12446 case EM_ARC_COMPACT2
:
12447 return reloc_type
== 2; /* R_ARC_16. */
12448 case EM_ADAPTEVA_EPIPHANY
:
12449 return reloc_type
== 5;
12452 return reloc_type
== 4; /* R_AVR_16. */
12453 case EM_CYGNUS_D10V
:
12455 return reloc_type
== 3; /* R_D10V_16. */
12459 return reloc_type
== R_H8_DIR16
;
12462 return reloc_type
== 1; /* R_IP2K_16. */
12465 return reloc_type
== 1; /* R_M32C_16 */
12466 case EM_CYGNUS_MN10200
:
12468 return reloc_type
== 2; /* R_MN10200_16. */
12469 case EM_CYGNUS_MN10300
:
12471 return reloc_type
== 2; /* R_MN10300_16. */
12473 if (uses_msp430x_relocs ())
12474 return reloc_type
== 2; /* R_MSP430_ABS16. */
12475 /* Fall through. */
12476 case EM_MSP430_OLD
:
12477 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
12479 return reloc_type
== 19; /* R_NDS32_RELA. */
12480 case EM_ALTERA_NIOS2
:
12481 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
12483 return reloc_type
== 9; /* R_NIOS_16. */
12485 return reloc_type
== 2; /* R_OR1K_16. */
12487 return reloc_type
== 8; /* R_PRU_BFD_RELOC_16. */
12489 return reloc_type
== 2; /* R_C6000_ABS16. */
12491 return reloc_type
== 2; /* R_VISIUM_16. */
12494 return reloc_type
== 2; /* R_XC16C_ABS_16. */
12496 return reloc_type
== 3; /* R_XGATE_16. */
12502 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
12503 relocation entries (possibly formerly used for SHT_GROUP sections). */
12506 is_none_reloc (unsigned int reloc_type
)
12508 switch (elf_header
.e_machine
)
12510 case EM_386
: /* R_386_NONE. */
12511 case EM_68K
: /* R_68K_NONE. */
12512 case EM_ADAPTEVA_EPIPHANY
:
12513 case EM_ALPHA
: /* R_ALPHA_NONE. */
12514 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
12515 case EM_ARC
: /* R_ARC_NONE. */
12516 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
12517 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
12518 case EM_ARM
: /* R_ARM_NONE. */
12519 case EM_C166
: /* R_XC16X_NONE. */
12520 case EM_CRIS
: /* R_CRIS_NONE. */
12521 case EM_FT32
: /* R_FT32_NONE. */
12522 case EM_IA_64
: /* R_IA64_NONE. */
12523 case EM_K1OM
: /* R_X86_64_NONE. */
12524 case EM_L1OM
: /* R_X86_64_NONE. */
12525 case EM_M32R
: /* R_M32R_NONE. */
12526 case EM_MIPS
: /* R_MIPS_NONE. */
12527 case EM_MN10300
: /* R_MN10300_NONE. */
12528 case EM_MOXIE
: /* R_MOXIE_NONE. */
12529 case EM_NIOS32
: /* R_NIOS_NONE. */
12530 case EM_OR1K
: /* R_OR1K_NONE. */
12531 case EM_PARISC
: /* R_PARISC_NONE. */
12532 case EM_PPC64
: /* R_PPC64_NONE. */
12533 case EM_PPC
: /* R_PPC_NONE. */
12534 case EM_RISCV
: /* R_RISCV_NONE. */
12535 case EM_S390
: /* R_390_NONE. */
12537 case EM_SH
: /* R_SH_NONE. */
12538 case EM_SPARC32PLUS
:
12539 case EM_SPARC
: /* R_SPARC_NONE. */
12541 case EM_TILEGX
: /* R_TILEGX_NONE. */
12542 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
12543 case EM_TI_C6000
:/* R_C6000_NONE. */
12544 case EM_X86_64
: /* R_X86_64_NONE. */
12546 case EM_WEBASSEMBLY
: /* R_WASM32_NONE. */
12547 return reloc_type
== 0;
12550 return reloc_type
== 0 || reloc_type
== 256;
12553 return (reloc_type
== 0 /* R_AVR_NONE. */
12554 || reloc_type
== 30 /* R_AVR_DIFF8. */
12555 || reloc_type
== 31 /* R_AVR_DIFF16. */
12556 || reloc_type
== 32 /* R_AVR_DIFF32. */);
12558 return reloc_type
== 3; /* R_METAG_NONE. */
12560 return (reloc_type
== 0 /* R_XTENSA_NONE. */
12561 || reloc_type
== 204 /* R_NDS32_DIFF8. */
12562 || reloc_type
== 205 /* R_NDS32_DIFF16. */
12563 || reloc_type
== 206 /* R_NDS32_DIFF32. */
12564 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
12566 return (reloc_type
== 0 /* R_PRU_NONE. */
12567 || reloc_type
== 65 /* R_PRU_DIFF8. */
12568 || reloc_type
== 66 /* R_PRU_DIFF16. */
12569 || reloc_type
== 67 /* R_PRU_DIFF32. */);
12570 case EM_XTENSA_OLD
:
12572 return (reloc_type
== 0 /* R_XTENSA_NONE. */
12573 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
12574 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
12575 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
12580 /* Returns TRUE if there is a relocation against
12581 section NAME at OFFSET bytes. */
12584 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
12586 Elf_Internal_Rela
* relocs
;
12587 Elf_Internal_Rela
* rp
;
12589 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
12592 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
12594 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
12595 if (rp
->r_offset
== offset
)
12601 /* Apply relocations to a section.
12602 Returns TRUE upon success, FALSE otherwise.
12603 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
12604 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
12605 will be set to the number of relocs loaded.
12607 Note: So far support has been added only for those relocations
12608 which can be found in debug sections. FIXME: Add support for
12609 more relocations ? */
12612 apply_relocations (void * file
,
12613 const Elf_Internal_Shdr
* section
,
12614 unsigned char * start
,
12615 bfd_size_type size
,
12616 void ** relocs_return
,
12617 unsigned long * num_relocs_return
)
12619 Elf_Internal_Shdr
* relsec
;
12620 unsigned char * end
= start
+ size
;
12621 bfd_boolean res
= TRUE
;
12623 if (relocs_return
!= NULL
)
12625 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
12626 * num_relocs_return
= 0;
12629 if (elf_header
.e_type
!= ET_REL
)
12630 /* No relocs to apply. */
12633 /* Find the reloc section associated with the section. */
12634 for (relsec
= section_headers
;
12635 relsec
< section_headers
+ elf_header
.e_shnum
;
12638 bfd_boolean is_rela
;
12639 unsigned long num_relocs
;
12640 Elf_Internal_Rela
* relocs
;
12641 Elf_Internal_Rela
* rp
;
12642 Elf_Internal_Shdr
* symsec
;
12643 Elf_Internal_Sym
* symtab
;
12644 unsigned long num_syms
;
12645 Elf_Internal_Sym
* sym
;
12647 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
12648 || relsec
->sh_info
>= elf_header
.e_shnum
12649 || section_headers
+ relsec
->sh_info
!= section
12650 || relsec
->sh_size
== 0
12651 || relsec
->sh_link
>= elf_header
.e_shnum
)
12654 is_rela
= relsec
->sh_type
== SHT_RELA
;
12658 if (!slurp_rela_relocs ((FILE *) file
, relsec
->sh_offset
,
12659 relsec
->sh_size
, & relocs
, & num_relocs
))
12664 if (!slurp_rel_relocs ((FILE *) file
, relsec
->sh_offset
,
12665 relsec
->sh_size
, & relocs
, & num_relocs
))
12669 /* SH uses RELA but uses in place value instead of the addend field. */
12670 if (elf_header
.e_machine
== EM_SH
)
12673 symsec
= section_headers
+ relsec
->sh_link
;
12674 if (symsec
->sh_type
!= SHT_SYMTAB
12675 && symsec
->sh_type
!= SHT_DYNSYM
)
12677 symtab
= GET_ELF_SYMBOLS ((FILE *) file
, symsec
, & num_syms
);
12679 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
12682 unsigned int reloc_type
;
12683 unsigned int reloc_size
;
12684 unsigned char * rloc
;
12685 unsigned long sym_index
;
12687 reloc_type
= get_reloc_type (rp
->r_info
);
12689 if (target_specific_reloc_handling (rp
, start
, end
, symtab
, num_syms
))
12691 else if (is_none_reloc (reloc_type
))
12693 else if (is_32bit_abs_reloc (reloc_type
)
12694 || is_32bit_pcrel_reloc (reloc_type
))
12696 else if (is_64bit_abs_reloc (reloc_type
)
12697 || is_64bit_pcrel_reloc (reloc_type
))
12699 else if (is_24bit_abs_reloc (reloc_type
))
12701 else if (is_16bit_abs_reloc (reloc_type
))
12705 static unsigned int prev_reloc
= 0;
12706 if (reloc_type
!= prev_reloc
)
12707 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
12708 reloc_type
, printable_section_name (section
));
12709 prev_reloc
= reloc_type
;
12714 rloc
= start
+ rp
->r_offset
;
12715 if ((rloc
+ reloc_size
) > end
|| (rloc
< start
))
12717 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
12718 (unsigned long) rp
->r_offset
,
12719 printable_section_name (section
));
12724 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
12725 if (sym_index
>= num_syms
)
12727 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
12728 sym_index
, printable_section_name (section
));
12732 sym
= symtab
+ sym_index
;
12734 /* If the reloc has a symbol associated with it,
12735 make sure that it is of an appropriate type.
12737 Relocations against symbols without type can happen.
12738 Gcc -feliminate-dwarf2-dups may generate symbols
12739 without type for debug info.
12741 Icc generates relocations against function symbols
12742 instead of local labels.
12744 Relocations against object symbols can happen, eg when
12745 referencing a global array. For an example of this see
12746 the _clz.o binary in libgcc.a. */
12748 && ELF_ST_TYPE (sym
->st_info
) != STT_COMMON
12749 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
12751 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
12752 get_symbol_type (ELF_ST_TYPE (sym
->st_info
)),
12753 (long int)(rp
- relocs
),
12754 printable_section_name (relsec
));
12761 addend
+= rp
->r_addend
;
12762 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
12763 partial_inplace. */
12765 || (elf_header
.e_machine
== EM_XTENSA
12766 && reloc_type
== 1)
12767 || ((elf_header
.e_machine
== EM_PJ
12768 || elf_header
.e_machine
== EM_PJ_OLD
)
12769 && reloc_type
== 1)
12770 || ((elf_header
.e_machine
== EM_D30V
12771 || elf_header
.e_machine
== EM_CYGNUS_D30V
)
12772 && reloc_type
== 12))
12773 addend
+= byte_get (rloc
, reloc_size
);
12775 if (is_32bit_pcrel_reloc (reloc_type
)
12776 || is_64bit_pcrel_reloc (reloc_type
))
12778 /* On HPPA, all pc-relative relocations are biased by 8. */
12779 if (elf_header
.e_machine
== EM_PARISC
)
12781 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
12785 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
12789 /* Let the target specific reloc processing code know that
12790 we have finished with these relocs. */
12791 target_specific_reloc_handling (NULL
, NULL
, NULL
, NULL
, 0);
12795 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
12796 * num_relocs_return
= num_relocs
;
12807 #ifdef SUPPORT_DISASSEMBLY
12809 disassemble_section (Elf_Internal_Shdr
* section
, FILE * file
)
12811 printf (_("\nAssembly dump of section %s\n"), printable_section_name (section
));
12813 /* FIXME: XXX -- to be done --- XXX */
12819 /* Reads in the contents of SECTION from FILE, returning a pointer
12820 to a malloc'ed buffer or NULL if something went wrong. */
12823 get_section_contents (Elf_Internal_Shdr
* section
, FILE * file
)
12825 bfd_size_type num_bytes
;
12827 num_bytes
= section
->sh_size
;
12829 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
12831 printf (_("Section '%s' has no data to dump.\n"),
12832 printable_section_name (section
));
12836 return (char *) get_data (NULL
, file
, section
->sh_offset
, 1, num_bytes
,
12837 _("section contents"));
12840 /* Uncompresses a section that was compressed using zlib, in place. */
12843 uncompress_section_contents (unsigned char **buffer
,
12844 dwarf_size_type uncompressed_size
,
12845 dwarf_size_type
*size
)
12847 dwarf_size_type compressed_size
= *size
;
12848 unsigned char * compressed_buffer
= *buffer
;
12849 unsigned char * uncompressed_buffer
;
12853 /* It is possible the section consists of several compressed
12854 buffers concatenated together, so we uncompress in a loop. */
12855 /* PR 18313: The state field in the z_stream structure is supposed
12856 to be invisible to the user (ie us), but some compilers will
12857 still complain about it being used without initialisation. So
12858 we first zero the entire z_stream structure and then set the fields
12860 memset (& strm
, 0, sizeof strm
);
12861 strm
.avail_in
= compressed_size
;
12862 strm
.next_in
= (Bytef
*) compressed_buffer
;
12863 strm
.avail_out
= uncompressed_size
;
12864 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
12866 rc
= inflateInit (& strm
);
12867 while (strm
.avail_in
> 0)
12871 strm
.next_out
= ((Bytef
*) uncompressed_buffer
12872 + (uncompressed_size
- strm
.avail_out
));
12873 rc
= inflate (&strm
, Z_FINISH
);
12874 if (rc
!= Z_STREAM_END
)
12876 rc
= inflateReset (& strm
);
12878 rc
= inflateEnd (& strm
);
12880 || strm
.avail_out
!= 0)
12883 *buffer
= uncompressed_buffer
;
12884 *size
= uncompressed_size
;
12888 free (uncompressed_buffer
);
12889 /* Indicate decompression failure. */
12895 dump_section_as_strings (Elf_Internal_Shdr
* section
, FILE * file
)
12897 Elf_Internal_Shdr
* relsec
;
12898 bfd_size_type num_bytes
;
12899 unsigned char * data
;
12900 unsigned char * end
;
12901 unsigned char * real_start
;
12902 unsigned char * start
;
12903 bfd_boolean some_strings_shown
;
12905 real_start
= start
= (unsigned char *) get_section_contents (section
, file
);
12907 /* PR 21820: Do not fail if the section was empty. */
12908 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
12910 num_bytes
= section
->sh_size
;
12912 printf (_("\nString dump of section '%s':\n"), printable_section_name (section
));
12914 if (decompress_dumps
)
12916 dwarf_size_type new_size
= num_bytes
;
12917 dwarf_size_type uncompressed_size
= 0;
12919 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
12921 Elf_Internal_Chdr chdr
;
12922 unsigned int compression_header_size
12923 = get_compression_header (& chdr
, (unsigned char *) start
,
12926 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
12928 warn (_("section '%s' has unsupported compress type: %d\n"),
12929 printable_section_name (section
), chdr
.ch_type
);
12932 else if (chdr
.ch_addralign
!= section
->sh_addralign
)
12934 warn (_("compressed section '%s' is corrupted\n"),
12935 printable_section_name (section
));
12938 uncompressed_size
= chdr
.ch_size
;
12939 start
+= compression_header_size
;
12940 new_size
-= compression_header_size
;
12942 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
12944 /* Read the zlib header. In this case, it should be "ZLIB"
12945 followed by the uncompressed section size, 8 bytes in
12946 big-endian order. */
12947 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
12948 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
12949 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
12950 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
12951 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
12952 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
12953 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
12954 uncompressed_size
+= start
[11];
12959 if (uncompressed_size
)
12961 if (uncompress_section_contents (& start
,
12962 uncompressed_size
, & new_size
))
12963 num_bytes
= new_size
;
12966 error (_("Unable to decompress section %s\n"),
12967 printable_section_name (section
));
12972 start
= real_start
;
12975 /* If the section being dumped has relocations against it the user might
12976 be expecting these relocations to have been applied. Check for this
12977 case and issue a warning message in order to avoid confusion.
12978 FIXME: Maybe we ought to have an option that dumps a section with
12979 relocs applied ? */
12980 for (relsec
= section_headers
;
12981 relsec
< section_headers
+ elf_header
.e_shnum
;
12984 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
12985 || relsec
->sh_info
>= elf_header
.e_shnum
12986 || section_headers
+ relsec
->sh_info
!= section
12987 || relsec
->sh_size
== 0
12988 || relsec
->sh_link
>= elf_header
.e_shnum
)
12991 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12996 end
= start
+ num_bytes
;
12997 some_strings_shown
= FALSE
;
13001 while (!ISPRINT (* data
))
13002 if (++ data
>= end
)
13007 size_t maxlen
= end
- data
;
13010 /* PR 11128: Use two separate invocations in order to work
13011 around bugs in the Solaris 8 implementation of printf. */
13012 printf (" [%6tx] ", data
- start
);
13014 printf (" [%6Ix] ", (size_t) (data
- start
));
13018 print_symbol ((int) maxlen
, (const char *) data
);
13020 data
+= strnlen ((const char *) data
, maxlen
);
13024 printf (_("<corrupt>\n"));
13027 some_strings_shown
= TRUE
;
13031 if (! some_strings_shown
)
13032 printf (_(" No strings found in this section."));
13041 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
13043 bfd_boolean relocate
)
13045 Elf_Internal_Shdr
* relsec
;
13046 bfd_size_type bytes
;
13047 bfd_size_type section_size
;
13049 unsigned char * data
;
13050 unsigned char * real_start
;
13051 unsigned char * start
;
13053 real_start
= start
= (unsigned char *) get_section_contents (section
, file
);
13055 /* PR 21820: Do not fail if the section was empty. */
13056 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
13058 section_size
= section
->sh_size
;
13060 printf (_("\nHex dump of section '%s':\n"), printable_section_name (section
));
13062 if (decompress_dumps
)
13064 dwarf_size_type new_size
= section_size
;
13065 dwarf_size_type uncompressed_size
= 0;
13067 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
13069 Elf_Internal_Chdr chdr
;
13070 unsigned int compression_header_size
13071 = get_compression_header (& chdr
, start
, section_size
);
13073 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13075 warn (_("section '%s' has unsupported compress type: %d\n"),
13076 printable_section_name (section
), chdr
.ch_type
);
13079 else if (chdr
.ch_addralign
!= section
->sh_addralign
)
13081 warn (_("compressed section '%s' is corrupted\n"),
13082 printable_section_name (section
));
13085 uncompressed_size
= chdr
.ch_size
;
13086 start
+= compression_header_size
;
13087 new_size
-= compression_header_size
;
13089 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
13091 /* Read the zlib header. In this case, it should be "ZLIB"
13092 followed by the uncompressed section size, 8 bytes in
13093 big-endian order. */
13094 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13095 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13096 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13097 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13098 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13099 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13100 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13101 uncompressed_size
+= start
[11];
13106 if (uncompressed_size
)
13108 if (uncompress_section_contents (& start
, uncompressed_size
,
13111 section_size
= new_size
;
13115 error (_("Unable to decompress section %s\n"),
13116 printable_section_name (section
));
13117 /* FIXME: Print the section anyway ? */
13122 start
= real_start
;
13127 if (! apply_relocations (file
, section
, start
, section_size
, NULL
, NULL
))
13132 /* If the section being dumped has relocations against it the user might
13133 be expecting these relocations to have been applied. Check for this
13134 case and issue a warning message in order to avoid confusion.
13135 FIXME: Maybe we ought to have an option that dumps a section with
13136 relocs applied ? */
13137 for (relsec
= section_headers
;
13138 relsec
< section_headers
+ elf_header
.e_shnum
;
13141 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13142 || relsec
->sh_info
>= elf_header
.e_shnum
13143 || section_headers
+ relsec
->sh_info
!= section
13144 || relsec
->sh_size
== 0
13145 || relsec
->sh_link
>= elf_header
.e_shnum
)
13148 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13153 addr
= section
->sh_addr
;
13154 bytes
= section_size
;
13163 lbytes
= (bytes
> 16 ? 16 : bytes
);
13165 printf (" 0x%8.8lx ", (unsigned long) addr
);
13167 for (j
= 0; j
< 16; j
++)
13170 printf ("%2.2x", data
[j
]);
13178 for (j
= 0; j
< lbytes
; j
++)
13181 if (k
>= ' ' && k
< 0x7f)
13201 load_specific_debug_section (enum dwarf_section_display_enum debug
,
13202 const Elf_Internal_Shdr
* sec
, void * file
)
13204 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13207 /* If it is already loaded, do nothing. */
13208 if (section
->start
!= NULL
)
13211 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
13212 section
->address
= sec
->sh_addr
;
13213 section
->user_data
= NULL
;
13214 section
->start
= (unsigned char *) get_data (NULL
, (FILE *) file
,
13216 sec
->sh_size
, buf
);
13217 if (section
->start
== NULL
)
13221 unsigned char *start
= section
->start
;
13222 dwarf_size_type size
= sec
->sh_size
;
13223 dwarf_size_type uncompressed_size
= 0;
13225 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
13227 Elf_Internal_Chdr chdr
;
13228 unsigned int compression_header_size
;
13230 if (size
< (is_32bit_elf
13231 ? sizeof (Elf32_External_Chdr
)
13232 : sizeof (Elf64_External_Chdr
)))
13234 warn (_("compressed section %s is too small to contain a compression header"),
13239 compression_header_size
= get_compression_header (&chdr
, start
, size
);
13241 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13243 warn (_("section '%s' has unsupported compress type: %d\n"),
13244 section
->name
, chdr
.ch_type
);
13247 else if (chdr
.ch_addralign
!= sec
->sh_addralign
)
13249 warn (_("compressed section '%s' is corrupted\n"),
13253 uncompressed_size
= chdr
.ch_size
;
13254 start
+= compression_header_size
;
13255 size
-= compression_header_size
;
13257 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
13259 /* Read the zlib header. In this case, it should be "ZLIB"
13260 followed by the uncompressed section size, 8 bytes in
13261 big-endian order. */
13262 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13263 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13264 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13265 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13266 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13267 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13268 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13269 uncompressed_size
+= start
[11];
13274 if (uncompressed_size
)
13276 if (uncompress_section_contents (&start
, uncompressed_size
,
13279 /* Free the compressed buffer, update the section buffer
13280 and the section size if uncompress is successful. */
13281 free (section
->start
);
13282 section
->start
= start
;
13286 error (_("Unable to decompress section %s\n"),
13287 printable_section_name (sec
));
13292 section
->size
= size
;
13295 if (section
->start
== NULL
)
13298 if (debug_displays
[debug
].relocate
)
13300 if (! apply_relocations ((FILE *) file
, sec
, section
->start
, section
->size
,
13301 & section
->reloc_info
, & section
->num_relocs
))
13306 section
->reloc_info
= NULL
;
13307 section
->num_relocs
= 0;
13313 /* If this is not NULL, load_debug_section will only look for sections
13314 within the list of sections given here. */
13315 static unsigned int * section_subset
= NULL
;
13318 load_debug_section (enum dwarf_section_display_enum debug
, void * file
)
13320 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13321 Elf_Internal_Shdr
* sec
;
13323 /* Locate the debug section. */
13324 sec
= find_section_in_set (section
->uncompressed_name
, section_subset
);
13326 section
->name
= section
->uncompressed_name
;
13329 sec
= find_section_in_set (section
->compressed_name
, section_subset
);
13331 section
->name
= section
->compressed_name
;
13336 /* If we're loading from a subset of sections, and we've loaded
13337 a section matching this name before, it's likely that it's a
13339 if (section_subset
!= NULL
)
13340 free_debug_section (debug
);
13342 return load_specific_debug_section (debug
, sec
, (FILE *) file
);
13346 free_debug_section (enum dwarf_section_display_enum debug
)
13348 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13350 if (section
->start
== NULL
)
13353 free ((char *) section
->start
);
13354 section
->start
= NULL
;
13355 section
->address
= 0;
13360 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, FILE * file
)
13362 char * name
= SECTION_NAME (section
);
13363 const char * print_name
= printable_section_name (section
);
13364 bfd_size_type length
;
13365 bfd_boolean result
= TRUE
;
13368 length
= section
->sh_size
;
13371 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
13374 if (section
->sh_type
== SHT_NOBITS
)
13376 /* There is no point in dumping the contents of a debugging section
13377 which has the NOBITS type - the bits in the file will be random.
13378 This can happen when a file containing a .eh_frame section is
13379 stripped with the --only-keep-debug command line option. */
13380 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
13385 if (const_strneq (name
, ".gnu.linkonce.wi."))
13386 name
= ".debug_info";
13388 /* See if we know how to display the contents of this section. */
13389 for (i
= 0; i
< max
; i
++)
13390 if (streq (debug_displays
[i
].section
.uncompressed_name
, name
)
13391 || (i
== line
&& const_strneq (name
, ".debug_line."))
13392 || streq (debug_displays
[i
].section
.compressed_name
, name
))
13394 struct dwarf_section
* sec
= &debug_displays
[i
].section
;
13395 int secondary
= (section
!= find_section (name
));
13398 free_debug_section ((enum dwarf_section_display_enum
) i
);
13400 if (i
== line
&& const_strneq (name
, ".debug_line."))
13402 else if (streq (sec
->uncompressed_name
, name
))
13403 sec
->name
= sec
->uncompressed_name
;
13405 sec
->name
= sec
->compressed_name
;
13406 if (load_specific_debug_section ((enum dwarf_section_display_enum
) i
,
13409 /* If this debug section is part of a CU/TU set in a .dwp file,
13410 restrict load_debug_section to the sections in that set. */
13411 section_subset
= find_cu_tu_set (file
, shndx
);
13413 result
&= debug_displays
[i
].display (sec
, file
);
13415 section_subset
= NULL
;
13417 if (secondary
|| (i
!= info
&& i
!= abbrev
))
13418 free_debug_section ((enum dwarf_section_display_enum
) i
);
13426 printf (_("Unrecognized debug section: %s\n"), print_name
);
13433 /* Set DUMP_SECTS for all sections where dumps were requested
13434 based on section name. */
13437 initialise_dumps_byname (void)
13439 struct dump_list_entry
* cur
;
13441 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
13444 bfd_boolean any
= FALSE
;
13446 for (i
= 0; i
< elf_header
.e_shnum
; i
++)
13447 if (streq (SECTION_NAME (section_headers
+ i
), cur
->name
))
13449 request_dump_bynumber (i
, cur
->type
);
13454 warn (_("Section '%s' was not dumped because it does not exist!\n"),
13460 process_section_contents (FILE * file
)
13462 Elf_Internal_Shdr
* section
;
13464 bfd_boolean res
= TRUE
;
13469 initialise_dumps_byname ();
13471 for (i
= 0, section
= section_headers
;
13472 i
< elf_header
.e_shnum
&& i
< num_dump_sects
;
13475 #ifdef SUPPORT_DISASSEMBLY
13476 if (dump_sects
[i
] & DISASS_DUMP
)
13477 disassemble_section (section
, file
);
13479 if (dump_sects
[i
] & HEX_DUMP
)
13481 if (! dump_section_as_bytes (section
, file
, FALSE
))
13485 if (dump_sects
[i
] & RELOC_DUMP
)
13487 if (! dump_section_as_bytes (section
, file
, TRUE
))
13491 if (dump_sects
[i
] & STRING_DUMP
)
13493 if (! dump_section_as_strings (section
, file
))
13497 if (dump_sects
[i
] & DEBUG_DUMP
)
13499 if (! display_debug_section (i
, section
, file
))
13504 /* Check to see if the user requested a
13505 dump of a section that does not exist. */
13506 while (i
< num_dump_sects
)
13510 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
13520 process_mips_fpe_exception (int mask
)
13524 bfd_boolean first
= TRUE
;
13526 if (mask
& OEX_FPU_INEX
)
13527 fputs ("INEX", stdout
), first
= FALSE
;
13528 if (mask
& OEX_FPU_UFLO
)
13529 printf ("%sUFLO", first
? "" : "|"), first
= FALSE
;
13530 if (mask
& OEX_FPU_OFLO
)
13531 printf ("%sOFLO", first
? "" : "|"), first
= FALSE
;
13532 if (mask
& OEX_FPU_DIV0
)
13533 printf ("%sDIV0", first
? "" : "|"), first
= FALSE
;
13534 if (mask
& OEX_FPU_INVAL
)
13535 printf ("%sINVAL", first
? "" : "|");
13538 fputs ("0", stdout
);
13541 /* Display's the value of TAG at location P. If TAG is
13542 greater than 0 it is assumed to be an unknown tag, and
13543 a message is printed to this effect. Otherwise it is
13544 assumed that a message has already been printed.
13546 If the bottom bit of TAG is set it assumed to have a
13547 string value, otherwise it is assumed to have an integer
13550 Returns an updated P pointing to the first unread byte
13551 beyond the end of TAG's value.
13553 Reads at or beyond END will not be made. */
13555 static unsigned char *
13556 display_tag_value (signed int tag
,
13558 const unsigned char * const end
)
13563 printf (" Tag_unknown_%d: ", tag
);
13567 warn (_("<corrupt tag>\n"));
13571 /* PR 17531 file: 027-19978-0.004. */
13572 size_t maxlen
= (end
- p
) - 1;
13577 print_symbol ((int) maxlen
, (const char *) p
);
13578 p
+= strnlen ((char *) p
, maxlen
) + 1;
13582 printf (_("<corrupt string tag>"));
13583 p
= (unsigned char *) end
;
13591 val
= read_uleb128 (p
, &len
, end
);
13593 printf ("%ld (0x%lx)\n", val
, val
);
13600 /* ARC ABI attributes section. */
13602 static unsigned char *
13603 display_arc_attribute (unsigned char * p
,
13604 const unsigned char * const end
)
13610 tag
= read_uleb128 (p
, &len
, end
);
13615 case Tag_ARC_PCS_config
:
13616 val
= read_uleb128 (p
, &len
, end
);
13618 printf (" Tag_ARC_PCS_config: ");
13622 printf (_("Absent/Non standard\n"));
13625 printf (_("Bare metal/mwdt\n"));
13628 printf (_("Bare metal/newlib\n"));
13631 printf (_("Linux/uclibc\n"));
13634 printf (_("Linux/glibc\n"));
13637 printf (_("Unknown\n"));
13642 case Tag_ARC_CPU_base
:
13643 val
= read_uleb128 (p
, &len
, end
);
13645 printf (" Tag_ARC_CPU_base: ");
13650 printf (_("Absent\n"));
13652 case TAG_CPU_ARC6xx
:
13653 printf ("ARC6xx\n");
13655 case TAG_CPU_ARC7xx
:
13656 printf ("ARC7xx\n");
13658 case TAG_CPU_ARCEM
:
13659 printf ("ARCEM\n");
13661 case TAG_CPU_ARCHS
:
13662 printf ("ARCHS\n");
13667 case Tag_ARC_CPU_variation
:
13668 val
= read_uleb128 (p
, &len
, end
);
13670 printf (" Tag_ARC_CPU_variation: ");
13674 if (val
> 0 && val
< 16)
13675 printf ("Core%d\n", val
);
13677 printf ("Unknown\n");
13681 printf (_("Absent\n"));
13686 case Tag_ARC_CPU_name
:
13687 printf (" Tag_ARC_CPU_name: ");
13688 p
= display_tag_value (-1, p
, end
);
13691 case Tag_ARC_ABI_rf16
:
13692 val
= read_uleb128 (p
, &len
, end
);
13694 printf (" Tag_ARC_ABI_rf16: %s\n", val
? _("yes") : _("no"));
13697 case Tag_ARC_ABI_osver
:
13698 val
= read_uleb128 (p
, &len
, end
);
13700 printf (" Tag_ARC_ABI_osver: v%d\n", val
);
13703 case Tag_ARC_ABI_pic
:
13704 case Tag_ARC_ABI_sda
:
13705 val
= read_uleb128 (p
, &len
, end
);
13707 printf (tag
== Tag_ARC_ABI_sda
? " Tag_ARC_ABI_sda: "
13708 : " Tag_ARC_ABI_pic: ");
13712 printf (_("Absent\n"));
13721 printf (_("Unknown\n"));
13726 case Tag_ARC_ABI_tls
:
13727 val
= read_uleb128 (p
, &len
, end
);
13729 printf (" Tag_ARC_ABI_tls: %s\n", val
? "r25": "none");
13732 case Tag_ARC_ABI_enumsize
:
13733 val
= read_uleb128 (p
, &len
, end
);
13735 printf (" Tag_ARC_ABI_enumsize: %s\n", val
? _("default") :
13739 case Tag_ARC_ABI_exceptions
:
13740 val
= read_uleb128 (p
, &len
, end
);
13742 printf (" Tag_ARC_ABI_exceptions: %s\n", val
? _("OPTFP")
13746 case Tag_ARC_ABI_double_size
:
13747 val
= read_uleb128 (p
, &len
, end
);
13749 printf (" Tag_ARC_ABI_double_size: %d\n", val
);
13752 case Tag_ARC_ISA_config
:
13753 printf (" Tag_ARC_ISA_config: ");
13754 p
= display_tag_value (-1, p
, end
);
13757 case Tag_ARC_ISA_apex
:
13758 printf (" Tag_ARC_ISA_apex: ");
13759 p
= display_tag_value (-1, p
, end
);
13762 case Tag_ARC_ISA_mpy_option
:
13763 val
= read_uleb128 (p
, &len
, end
);
13765 printf (" Tag_ARC_ISA_mpy_option: %d\n", val
);
13769 return display_tag_value (tag
& 1, p
, end
);
13775 /* ARM EABI attributes section. */
13780 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
13782 const char ** table
;
13783 } arm_attr_public_tag
;
13785 static const char * arm_attr_tag_CPU_arch
[] =
13786 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
13787 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
13789 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
13790 static const char * arm_attr_tag_THUMB_ISA_use
[] =
13791 {"No", "Thumb-1", "Thumb-2", "Yes"};
13792 static const char * arm_attr_tag_FP_arch
[] =
13793 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
13794 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
13795 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
13796 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
13797 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
13798 "NEON for ARMv8.1"};
13799 static const char * arm_attr_tag_PCS_config
[] =
13800 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
13801 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
13802 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
13803 {"V6", "SB", "TLS", "Unused"};
13804 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
13805 {"Absolute", "PC-relative", "SB-relative", "None"};
13806 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
13807 {"Absolute", "PC-relative", "None"};
13808 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
13809 {"None", "direct", "GOT-indirect"};
13810 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
13811 {"None", "??? 1", "2", "??? 3", "4"};
13812 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
13813 static const char * arm_attr_tag_ABI_FP_denormal
[] =
13814 {"Unused", "Needed", "Sign only"};
13815 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
13816 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
13817 static const char * arm_attr_tag_ABI_FP_number_model
[] =
13818 {"Unused", "Finite", "RTABI", "IEEE 754"};
13819 static const char * arm_attr_tag_ABI_enum_size
[] =
13820 {"Unused", "small", "int", "forced to int"};
13821 static const char * arm_attr_tag_ABI_HardFP_use
[] =
13822 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
13823 static const char * arm_attr_tag_ABI_VFP_args
[] =
13824 {"AAPCS", "VFP registers", "custom", "compatible"};
13825 static const char * arm_attr_tag_ABI_WMMX_args
[] =
13826 {"AAPCS", "WMMX registers", "custom"};
13827 static const char * arm_attr_tag_ABI_optimization_goals
[] =
13828 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
13829 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
13830 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
13831 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
13832 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
13833 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
13834 static const char * arm_attr_tag_FP_HP_extension
[] =
13835 {"Not Allowed", "Allowed"};
13836 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
13837 {"None", "IEEE 754", "Alternative Format"};
13838 static const char * arm_attr_tag_DSP_extension
[] =
13839 {"Follow architecture", "Allowed"};
13840 static const char * arm_attr_tag_MPextension_use
[] =
13841 {"Not Allowed", "Allowed"};
13842 static const char * arm_attr_tag_DIV_use
[] =
13843 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
13844 "Allowed in v7-A with integer division extension"};
13845 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
13846 static const char * arm_attr_tag_Virtualization_use
[] =
13847 {"Not Allowed", "TrustZone", "Virtualization Extensions",
13848 "TrustZone and Virtualization Extensions"};
13849 static const char * arm_attr_tag_MPextension_use_legacy
[] =
13850 {"Not Allowed", "Allowed"};
13852 #define LOOKUP(id, name) \
13853 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
13854 static arm_attr_public_tag arm_attr_public_tags
[] =
13856 {4, "CPU_raw_name", 1, NULL
},
13857 {5, "CPU_name", 1, NULL
},
13858 LOOKUP(6, CPU_arch
),
13859 {7, "CPU_arch_profile", 0, NULL
},
13860 LOOKUP(8, ARM_ISA_use
),
13861 LOOKUP(9, THUMB_ISA_use
),
13862 LOOKUP(10, FP_arch
),
13863 LOOKUP(11, WMMX_arch
),
13864 LOOKUP(12, Advanced_SIMD_arch
),
13865 LOOKUP(13, PCS_config
),
13866 LOOKUP(14, ABI_PCS_R9_use
),
13867 LOOKUP(15, ABI_PCS_RW_data
),
13868 LOOKUP(16, ABI_PCS_RO_data
),
13869 LOOKUP(17, ABI_PCS_GOT_use
),
13870 LOOKUP(18, ABI_PCS_wchar_t
),
13871 LOOKUP(19, ABI_FP_rounding
),
13872 LOOKUP(20, ABI_FP_denormal
),
13873 LOOKUP(21, ABI_FP_exceptions
),
13874 LOOKUP(22, ABI_FP_user_exceptions
),
13875 LOOKUP(23, ABI_FP_number_model
),
13876 {24, "ABI_align_needed", 0, NULL
},
13877 {25, "ABI_align_preserved", 0, NULL
},
13878 LOOKUP(26, ABI_enum_size
),
13879 LOOKUP(27, ABI_HardFP_use
),
13880 LOOKUP(28, ABI_VFP_args
),
13881 LOOKUP(29, ABI_WMMX_args
),
13882 LOOKUP(30, ABI_optimization_goals
),
13883 LOOKUP(31, ABI_FP_optimization_goals
),
13884 {32, "compatibility", 0, NULL
},
13885 LOOKUP(34, CPU_unaligned_access
),
13886 LOOKUP(36, FP_HP_extension
),
13887 LOOKUP(38, ABI_FP_16bit_format
),
13888 LOOKUP(42, MPextension_use
),
13889 LOOKUP(44, DIV_use
),
13890 LOOKUP(46, DSP_extension
),
13891 {64, "nodefaults", 0, NULL
},
13892 {65, "also_compatible_with", 0, NULL
},
13893 LOOKUP(66, T2EE_use
),
13894 {67, "conformance", 1, NULL
},
13895 LOOKUP(68, Virtualization_use
),
13896 LOOKUP(70, MPextension_use_legacy
)
13900 static unsigned char *
13901 display_arm_attribute (unsigned char * p
,
13902 const unsigned char * const end
)
13907 arm_attr_public_tag
* attr
;
13911 tag
= read_uleb128 (p
, &len
, end
);
13914 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
13916 if (arm_attr_public_tags
[i
].tag
== tag
)
13918 attr
= &arm_attr_public_tags
[i
];
13925 printf (" Tag_%s: ", attr
->name
);
13926 switch (attr
->type
)
13931 case 7: /* Tag_CPU_arch_profile. */
13932 val
= read_uleb128 (p
, &len
, end
);
13936 case 0: printf (_("None\n")); break;
13937 case 'A': printf (_("Application\n")); break;
13938 case 'R': printf (_("Realtime\n")); break;
13939 case 'M': printf (_("Microcontroller\n")); break;
13940 case 'S': printf (_("Application or Realtime\n")); break;
13941 default: printf ("??? (%d)\n", val
); break;
13945 case 24: /* Tag_align_needed. */
13946 val
= read_uleb128 (p
, &len
, end
);
13950 case 0: printf (_("None\n")); break;
13951 case 1: printf (_("8-byte\n")); break;
13952 case 2: printf (_("4-byte\n")); break;
13953 case 3: printf ("??? 3\n"); break;
13956 printf (_("8-byte and up to %d-byte extended\n"),
13959 printf ("??? (%d)\n", val
);
13964 case 25: /* Tag_align_preserved. */
13965 val
= read_uleb128 (p
, &len
, end
);
13969 case 0: printf (_("None\n")); break;
13970 case 1: printf (_("8-byte, except leaf SP\n")); break;
13971 case 2: printf (_("8-byte\n")); break;
13972 case 3: printf ("??? 3\n"); break;
13975 printf (_("8-byte and up to %d-byte extended\n"),
13978 printf ("??? (%d)\n", val
);
13983 case 32: /* Tag_compatibility. */
13985 val
= read_uleb128 (p
, &len
, end
);
13987 printf (_("flag = %d, vendor = "), val
);
13990 size_t maxlen
= (end
- p
) - 1;
13992 print_symbol ((int) maxlen
, (const char *) p
);
13993 p
+= strnlen ((char *) p
, maxlen
) + 1;
13997 printf (_("<corrupt>"));
13998 p
= (unsigned char *) end
;
14004 case 64: /* Tag_nodefaults. */
14005 /* PR 17531: file: 001-505008-0.01. */
14008 printf (_("True\n"));
14011 case 65: /* Tag_also_compatible_with. */
14012 val
= read_uleb128 (p
, &len
, end
);
14014 if (val
== 6 /* Tag_CPU_arch. */)
14016 val
= read_uleb128 (p
, &len
, end
);
14018 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
14019 printf ("??? (%d)\n", val
);
14021 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
14025 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
14030 printf (_("<unknown: %d>\n"), tag
);
14036 return display_tag_value (-1, p
, end
);
14038 return display_tag_value (0, p
, end
);
14041 assert (attr
->type
& 0x80);
14042 val
= read_uleb128 (p
, &len
, end
);
14044 type
= attr
->type
& 0x7f;
14046 printf ("??? (%d)\n", val
);
14048 printf ("%s\n", attr
->table
[val
]);
14053 return display_tag_value (tag
, p
, end
);
14056 static unsigned char *
14057 display_gnu_attribute (unsigned char * p
,
14058 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const),
14059 const unsigned char * const end
)
14065 tag
= read_uleb128 (p
, &len
, end
);
14068 /* Tag_compatibility is the only generic GNU attribute defined at
14072 val
= read_uleb128 (p
, &len
, end
);
14075 printf (_("flag = %d, vendor = "), val
);
14078 printf (_("<corrupt>\n"));
14079 warn (_("corrupt vendor attribute\n"));
14085 size_t maxlen
= (end
- p
) - 1;
14087 print_symbol ((int) maxlen
, (const char *) p
);
14088 p
+= strnlen ((char *) p
, maxlen
) + 1;
14092 printf (_("<corrupt>"));
14093 p
= (unsigned char *) end
;
14100 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
14101 return display_proc_gnu_attribute (p
, tag
, end
);
14103 return display_tag_value (tag
, p
, end
);
14106 static unsigned char *
14107 display_power_gnu_attribute (unsigned char * p
,
14109 const unsigned char * const end
)
14114 if (tag
== Tag_GNU_Power_ABI_FP
)
14116 val
= read_uleb128 (p
, &len
, end
);
14118 printf (" Tag_GNU_Power_ABI_FP: ");
14121 printf (_("<corrupt>\n"));
14126 printf ("(%#x), ", val
);
14131 printf (_("unspecified hard/soft float, "));
14134 printf (_("hard float, "));
14137 printf (_("soft float, "));
14140 printf (_("single-precision hard float, "));
14147 printf (_("unspecified long double\n"));
14150 printf (_("128-bit IBM long double\n"));
14153 printf (_("64-bit long double\n"));
14156 printf (_("128-bit IEEE long double\n"));
14162 if (tag
== Tag_GNU_Power_ABI_Vector
)
14164 val
= read_uleb128 (p
, &len
, end
);
14166 printf (" Tag_GNU_Power_ABI_Vector: ");
14169 printf (_("<corrupt>\n"));
14174 printf ("(%#x), ", val
);
14179 printf (_("unspecified\n"));
14182 printf (_("generic\n"));
14185 printf ("AltiVec\n");
14194 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
14196 val
= read_uleb128 (p
, &len
, end
);
14198 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
14201 printf (_("<corrupt>\n"));
14206 printf ("(%#x), ", val
);
14211 printf (_("unspecified\n"));
14214 printf ("r3/r4\n");
14217 printf (_("memory\n"));
14226 return display_tag_value (tag
& 1, p
, end
);
14229 static unsigned char *
14230 display_s390_gnu_attribute (unsigned char * p
,
14232 const unsigned char * const end
)
14237 if (tag
== Tag_GNU_S390_ABI_Vector
)
14239 val
= read_uleb128 (p
, &len
, end
);
14241 printf (" Tag_GNU_S390_ABI_Vector: ");
14246 printf (_("any\n"));
14249 printf (_("software\n"));
14252 printf (_("hardware\n"));
14255 printf ("??? (%d)\n", val
);
14261 return display_tag_value (tag
& 1, p
, end
);
14265 display_sparc_hwcaps (unsigned int mask
)
14269 bfd_boolean first
= TRUE
;
14271 if (mask
& ELF_SPARC_HWCAP_MUL32
)
14272 fputs ("mul32", stdout
), first
= FALSE
;
14273 if (mask
& ELF_SPARC_HWCAP_DIV32
)
14274 printf ("%sdiv32", first
? "" : "|"), first
= FALSE
;
14275 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
14276 printf ("%sfsmuld", first
? "" : "|"), first
= FALSE
;
14277 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
14278 printf ("%sv8plus", first
? "" : "|"), first
= FALSE
;
14279 if (mask
& ELF_SPARC_HWCAP_POPC
)
14280 printf ("%spopc", first
? "" : "|"), first
= FALSE
;
14281 if (mask
& ELF_SPARC_HWCAP_VIS
)
14282 printf ("%svis", first
? "" : "|"), first
= FALSE
;
14283 if (mask
& ELF_SPARC_HWCAP_VIS2
)
14284 printf ("%svis2", first
? "" : "|"), first
= FALSE
;
14285 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
14286 printf ("%sASIBlkInit", first
? "" : "|"), first
= FALSE
;
14287 if (mask
& ELF_SPARC_HWCAP_FMAF
)
14288 printf ("%sfmaf", first
? "" : "|"), first
= FALSE
;
14289 if (mask
& ELF_SPARC_HWCAP_VIS3
)
14290 printf ("%svis3", first
? "" : "|"), first
= FALSE
;
14291 if (mask
& ELF_SPARC_HWCAP_HPC
)
14292 printf ("%shpc", first
? "" : "|"), first
= FALSE
;
14293 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
14294 printf ("%srandom", first
? "" : "|"), first
= FALSE
;
14295 if (mask
& ELF_SPARC_HWCAP_TRANS
)
14296 printf ("%strans", first
? "" : "|"), first
= FALSE
;
14297 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
14298 printf ("%sfjfmau", first
? "" : "|"), first
= FALSE
;
14299 if (mask
& ELF_SPARC_HWCAP_IMA
)
14300 printf ("%sima", first
? "" : "|"), first
= FALSE
;
14301 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
14302 printf ("%scspare", first
? "" : "|"), first
= FALSE
;
14305 fputc ('0', stdout
);
14306 fputc ('\n', stdout
);
14310 display_sparc_hwcaps2 (unsigned int mask
)
14314 bfd_boolean first
= TRUE
;
14316 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
14317 fputs ("fjathplus", stdout
), first
= FALSE
;
14318 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
14319 printf ("%svis3b", first
? "" : "|"), first
= FALSE
;
14320 if (mask
& ELF_SPARC_HWCAP2_ADP
)
14321 printf ("%sadp", first
? "" : "|"), first
= FALSE
;
14322 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
14323 printf ("%ssparc5", first
? "" : "|"), first
= FALSE
;
14324 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
14325 printf ("%smwait", first
? "" : "|"), first
= FALSE
;
14326 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
14327 printf ("%sxmpmul", first
? "" : "|"), first
= FALSE
;
14328 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
14329 printf ("%sxmont2", first
? "" : "|"), first
= FALSE
;
14330 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
14331 printf ("%snsec", first
? "" : "|"), first
= FALSE
;
14332 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
14333 printf ("%sfjathhpc", first
? "" : "|"), first
= FALSE
;
14334 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
14335 printf ("%sfjdes", first
? "" : "|"), first
= FALSE
;
14336 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
14337 printf ("%sfjaes", first
? "" : "|"), first
= FALSE
;
14340 fputc ('0', stdout
);
14341 fputc ('\n', stdout
);
14344 static unsigned char *
14345 display_sparc_gnu_attribute (unsigned char * p
,
14347 const unsigned char * const end
)
14352 if (tag
== Tag_GNU_Sparc_HWCAPS
)
14354 val
= read_uleb128 (p
, &len
, end
);
14356 printf (" Tag_GNU_Sparc_HWCAPS: ");
14357 display_sparc_hwcaps (val
);
14360 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
14362 val
= read_uleb128 (p
, &len
, end
);
14364 printf (" Tag_GNU_Sparc_HWCAPS2: ");
14365 display_sparc_hwcaps2 (val
);
14369 return display_tag_value (tag
, p
, end
);
14373 print_mips_fp_abi_value (unsigned int val
)
14377 case Val_GNU_MIPS_ABI_FP_ANY
:
14378 printf (_("Hard or soft float\n"));
14380 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
14381 printf (_("Hard float (double precision)\n"));
14383 case Val_GNU_MIPS_ABI_FP_SINGLE
:
14384 printf (_("Hard float (single precision)\n"));
14386 case Val_GNU_MIPS_ABI_FP_SOFT
:
14387 printf (_("Soft float\n"));
14389 case Val_GNU_MIPS_ABI_FP_OLD_64
:
14390 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
14392 case Val_GNU_MIPS_ABI_FP_XX
:
14393 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
14395 case Val_GNU_MIPS_ABI_FP_64
:
14396 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
14398 case Val_GNU_MIPS_ABI_FP_64A
:
14399 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
14401 case Val_GNU_MIPS_ABI_FP_NAN2008
:
14402 printf (_("NaN 2008 compatibility\n"));
14405 printf ("??? (%d)\n", val
);
14410 static unsigned char *
14411 display_mips_gnu_attribute (unsigned char * p
,
14413 const unsigned char * const end
)
14415 if (tag
== Tag_GNU_MIPS_ABI_FP
)
14420 val
= read_uleb128 (p
, &len
, end
);
14422 printf (" Tag_GNU_MIPS_ABI_FP: ");
14424 print_mips_fp_abi_value (val
);
14429 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
14434 val
= read_uleb128 (p
, &len
, end
);
14436 printf (" Tag_GNU_MIPS_ABI_MSA: ");
14440 case Val_GNU_MIPS_ABI_MSA_ANY
:
14441 printf (_("Any MSA or not\n"));
14443 case Val_GNU_MIPS_ABI_MSA_128
:
14444 printf (_("128-bit MSA\n"));
14447 printf ("??? (%d)\n", val
);
14453 return display_tag_value (tag
& 1, p
, end
);
14456 static unsigned char *
14457 display_tic6x_attribute (unsigned char * p
,
14458 const unsigned char * const end
)
14464 tag
= read_uleb128 (p
, &len
, end
);
14470 val
= read_uleb128 (p
, &len
, end
);
14472 printf (" Tag_ISA: ");
14476 case C6XABI_Tag_ISA_none
:
14477 printf (_("None\n"));
14479 case C6XABI_Tag_ISA_C62X
:
14482 case C6XABI_Tag_ISA_C67X
:
14485 case C6XABI_Tag_ISA_C67XP
:
14486 printf ("C67x+\n");
14488 case C6XABI_Tag_ISA_C64X
:
14491 case C6XABI_Tag_ISA_C64XP
:
14492 printf ("C64x+\n");
14494 case C6XABI_Tag_ISA_C674X
:
14495 printf ("C674x\n");
14498 printf ("??? (%d)\n", val
);
14503 case Tag_ABI_wchar_t
:
14504 val
= read_uleb128 (p
, &len
, end
);
14506 printf (" Tag_ABI_wchar_t: ");
14510 printf (_("Not used\n"));
14513 printf (_("2 bytes\n"));
14516 printf (_("4 bytes\n"));
14519 printf ("??? (%d)\n", val
);
14524 case Tag_ABI_stack_align_needed
:
14525 val
= read_uleb128 (p
, &len
, end
);
14527 printf (" Tag_ABI_stack_align_needed: ");
14531 printf (_("8-byte\n"));
14534 printf (_("16-byte\n"));
14537 printf ("??? (%d)\n", val
);
14542 case Tag_ABI_stack_align_preserved
:
14543 val
= read_uleb128 (p
, &len
, end
);
14545 printf (" Tag_ABI_stack_align_preserved: ");
14549 printf (_("8-byte\n"));
14552 printf (_("16-byte\n"));
14555 printf ("??? (%d)\n", val
);
14561 val
= read_uleb128 (p
, &len
, end
);
14563 printf (" Tag_ABI_DSBT: ");
14567 printf (_("DSBT addressing not used\n"));
14570 printf (_("DSBT addressing used\n"));
14573 printf ("??? (%d)\n", val
);
14579 val
= read_uleb128 (p
, &len
, end
);
14581 printf (" Tag_ABI_PID: ");
14585 printf (_("Data addressing position-dependent\n"));
14588 printf (_("Data addressing position-independent, GOT near DP\n"));
14591 printf (_("Data addressing position-independent, GOT far from DP\n"));
14594 printf ("??? (%d)\n", val
);
14600 val
= read_uleb128 (p
, &len
, end
);
14602 printf (" Tag_ABI_PIC: ");
14606 printf (_("Code addressing position-dependent\n"));
14609 printf (_("Code addressing position-independent\n"));
14612 printf ("??? (%d)\n", val
);
14617 case Tag_ABI_array_object_alignment
:
14618 val
= read_uleb128 (p
, &len
, end
);
14620 printf (" Tag_ABI_array_object_alignment: ");
14624 printf (_("8-byte\n"));
14627 printf (_("4-byte\n"));
14630 printf (_("16-byte\n"));
14633 printf ("??? (%d)\n", val
);
14638 case Tag_ABI_array_object_align_expected
:
14639 val
= read_uleb128 (p
, &len
, end
);
14641 printf (" Tag_ABI_array_object_align_expected: ");
14645 printf (_("8-byte\n"));
14648 printf (_("4-byte\n"));
14651 printf (_("16-byte\n"));
14654 printf ("??? (%d)\n", val
);
14659 case Tag_ABI_compatibility
:
14661 val
= read_uleb128 (p
, &len
, end
);
14663 printf (" Tag_ABI_compatibility: ");
14664 printf (_("flag = %d, vendor = "), val
);
14667 size_t maxlen
= (end
- p
) - 1;
14669 print_symbol ((int) maxlen
, (const char *) p
);
14670 p
+= strnlen ((char *) p
, maxlen
) + 1;
14674 printf (_("<corrupt>"));
14675 p
= (unsigned char *) end
;
14681 case Tag_ABI_conformance
:
14683 printf (" Tag_ABI_conformance: \"");
14686 size_t maxlen
= (end
- p
) - 1;
14688 print_symbol ((int) maxlen
, (const char *) p
);
14689 p
+= strnlen ((char *) p
, maxlen
) + 1;
14693 printf (_("<corrupt>"));
14694 p
= (unsigned char *) end
;
14701 return display_tag_value (tag
, p
, end
);
14705 display_raw_attribute (unsigned char * p
, unsigned char const * const end
)
14707 unsigned long addr
= 0;
14708 size_t bytes
= end
- p
;
14715 int lbytes
= (bytes
> 16 ? 16 : bytes
);
14717 printf (" 0x%8.8lx ", addr
);
14719 for (j
= 0; j
< 16; j
++)
14722 printf ("%2.2x", p
[j
]);
14730 for (j
= 0; j
< lbytes
; j
++)
14733 if (k
>= ' ' && k
< 0x7f)
14749 static unsigned char *
14750 display_msp430x_attribute (unsigned char * p
,
14751 const unsigned char * const end
)
14757 tag
= read_uleb128 (p
, & len
, end
);
14762 case OFBA_MSPABI_Tag_ISA
:
14763 val
= read_uleb128 (p
, &len
, end
);
14765 printf (" Tag_ISA: ");
14768 case 0: printf (_("None\n")); break;
14769 case 1: printf (_("MSP430\n")); break;
14770 case 2: printf (_("MSP430X\n")); break;
14771 default: printf ("??? (%d)\n", val
); break;
14775 case OFBA_MSPABI_Tag_Code_Model
:
14776 val
= read_uleb128 (p
, &len
, end
);
14778 printf (" Tag_Code_Model: ");
14781 case 0: printf (_("None\n")); break;
14782 case 1: printf (_("Small\n")); break;
14783 case 2: printf (_("Large\n")); break;
14784 default: printf ("??? (%d)\n", val
); break;
14788 case OFBA_MSPABI_Tag_Data_Model
:
14789 val
= read_uleb128 (p
, &len
, end
);
14791 printf (" Tag_Data_Model: ");
14794 case 0: printf (_("None\n")); break;
14795 case 1: printf (_("Small\n")); break;
14796 case 2: printf (_("Large\n")); break;
14797 case 3: printf (_("Restricted Large\n")); break;
14798 default: printf ("??? (%d)\n", val
); break;
14803 printf (_(" <unknown tag %d>: "), tag
);
14810 size_t maxlen
= (end
- p
) - 1;
14812 print_symbol ((int) maxlen
, (const char *) p
);
14813 p
+= strnlen ((char *) p
, maxlen
) + 1;
14817 printf (_("<corrupt>"));
14818 p
= (unsigned char *) end
;
14824 val
= read_uleb128 (p
, &len
, end
);
14826 printf ("%d (0x%x)\n", val
, val
);
14836 process_attributes (FILE * file
,
14837 const char * public_name
,
14838 unsigned int proc_type
,
14839 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
14840 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const))
14842 Elf_Internal_Shdr
* sect
;
14844 bfd_boolean res
= TRUE
;
14846 /* Find the section header so that we get the size. */
14847 for (i
= 0, sect
= section_headers
;
14848 i
< elf_header
.e_shnum
;
14851 unsigned char * contents
;
14854 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
14857 contents
= (unsigned char *) get_data (NULL
, file
, sect
->sh_offset
, 1,
14858 sect
->sh_size
, _("attributes"));
14859 if (contents
== NULL
)
14866 /* The first character is the version of the attributes.
14867 Currently only version 1, (aka 'A') is recognised here. */
14870 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p
, *p
);
14875 bfd_vma section_len
;
14877 section_len
= sect
->sh_size
- 1;
14880 while (section_len
> 0)
14883 unsigned int namelen
;
14884 bfd_boolean public_section
;
14885 bfd_boolean gnu_section
;
14887 if (section_len
<= 4)
14889 error (_("Tag section ends prematurely\n"));
14893 attr_len
= byte_get (p
, 4);
14896 if (attr_len
> section_len
)
14898 error (_("Bad attribute length (%u > %u)\n"),
14899 (unsigned) attr_len
, (unsigned) section_len
);
14900 attr_len
= section_len
;
14903 /* PR 17531: file: 001-101425-0.004 */
14904 else if (attr_len
< 5)
14906 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
14911 section_len
-= attr_len
;
14914 namelen
= strnlen ((char *) p
, attr_len
) + 1;
14915 if (namelen
== 0 || namelen
>= attr_len
)
14917 error (_("Corrupt attribute section name\n"));
14922 printf (_("Attribute Section: "));
14923 print_symbol (INT_MAX
, (const char *) p
);
14926 if (public_name
&& streq ((char *) p
, public_name
))
14927 public_section
= TRUE
;
14929 public_section
= FALSE
;
14931 if (streq ((char *) p
, "gnu"))
14932 gnu_section
= TRUE
;
14934 gnu_section
= FALSE
;
14937 attr_len
-= namelen
;
14939 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
14944 unsigned char * end
;
14946 /* PR binutils/17531: Safe handling of corrupt files. */
14949 error (_("Unused bytes at end of section\n"));
14956 size
= byte_get (p
, 4);
14957 if (size
> attr_len
)
14959 error (_("Bad subsection length (%u > %u)\n"),
14960 (unsigned) size
, (unsigned) attr_len
);
14964 /* PR binutils/17531: Safe handling of corrupt files. */
14967 error (_("Bad subsection length (%u < 6)\n"),
14975 end
= p
+ size
- 1;
14976 assert (end
<= contents
+ sect
->sh_size
);
14982 printf (_("File Attributes\n"));
14985 printf (_("Section Attributes:"));
14988 printf (_("Symbol Attributes:"));
14989 /* Fall through. */
14995 val
= read_uleb128 (p
, &j
, end
);
14999 printf (" %d", val
);
15004 printf (_("Unknown tag: %d\n"), tag
);
15005 public_section
= FALSE
;
15009 if (public_section
&& display_pub_attribute
!= NULL
)
15012 p
= display_pub_attribute (p
, end
);
15015 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
15018 p
= display_gnu_attribute (p
,
15019 display_proc_gnu_attribute
,
15025 printf (_(" Unknown attribute:\n"));
15026 display_raw_attribute (p
, end
);
15041 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
15042 Print the Address, Access and Initial fields of an entry at VMA ADDR
15043 and return the VMA of the next entry, or -1 if there was a problem.
15044 Does not read from DATA_END or beyond. */
15047 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
15048 unsigned char * data_end
)
15051 print_vma (addr
, LONG_HEX
);
15053 if (addr
< pltgot
+ 0xfff0)
15054 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
15056 printf ("%10s", "");
15059 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
15063 unsigned char * from
= data
+ addr
- pltgot
;
15065 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
15067 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
15068 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
15069 return (bfd_vma
) -1;
15073 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
15074 print_vma (entry
, LONG_HEX
);
15077 return addr
+ (is_32bit_elf
? 4 : 8);
15080 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
15081 PLTGOT. Print the Address and Initial fields of an entry at VMA
15082 ADDR and return the VMA of the next entry. */
15085 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
15088 print_vma (addr
, LONG_HEX
);
15091 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
15096 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
15097 print_vma (entry
, LONG_HEX
);
15099 return addr
+ (is_32bit_elf
? 4 : 8);
15103 print_mips_ases (unsigned int mask
)
15105 if (mask
& AFL_ASE_DSP
)
15106 fputs ("\n\tDSP ASE", stdout
);
15107 if (mask
& AFL_ASE_DSPR2
)
15108 fputs ("\n\tDSP R2 ASE", stdout
);
15109 if (mask
& AFL_ASE_DSPR3
)
15110 fputs ("\n\tDSP R3 ASE", stdout
);
15111 if (mask
& AFL_ASE_EVA
)
15112 fputs ("\n\tEnhanced VA Scheme", stdout
);
15113 if (mask
& AFL_ASE_MCU
)
15114 fputs ("\n\tMCU (MicroController) ASE", stdout
);
15115 if (mask
& AFL_ASE_MDMX
)
15116 fputs ("\n\tMDMX ASE", stdout
);
15117 if (mask
& AFL_ASE_MIPS3D
)
15118 fputs ("\n\tMIPS-3D ASE", stdout
);
15119 if (mask
& AFL_ASE_MT
)
15120 fputs ("\n\tMT ASE", stdout
);
15121 if (mask
& AFL_ASE_SMARTMIPS
)
15122 fputs ("\n\tSmartMIPS ASE", stdout
);
15123 if (mask
& AFL_ASE_VIRT
)
15124 fputs ("\n\tVZ ASE", stdout
);
15125 if (mask
& AFL_ASE_MSA
)
15126 fputs ("\n\tMSA ASE", stdout
);
15127 if (mask
& AFL_ASE_MIPS16
)
15128 fputs ("\n\tMIPS16 ASE", stdout
);
15129 if (mask
& AFL_ASE_MICROMIPS
)
15130 fputs ("\n\tMICROMIPS ASE", stdout
);
15131 if (mask
& AFL_ASE_XPA
)
15132 fputs ("\n\tXPA ASE", stdout
);
15133 if (mask
& AFL_ASE_MIPS16E2
)
15134 fputs ("\n\tMIPS16e2 ASE", stdout
);
15136 fprintf (stdout
, "\n\t%s", _("None"));
15137 else if ((mask
& ~AFL_ASE_MASK
) != 0)
15138 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
15142 print_mips_isa_ext (unsigned int isa_ext
)
15147 fputs (_("None"), stdout
);
15150 fputs ("RMI XLR", stdout
);
15152 case AFL_EXT_OCTEON3
:
15153 fputs ("Cavium Networks Octeon3", stdout
);
15155 case AFL_EXT_OCTEON2
:
15156 fputs ("Cavium Networks Octeon2", stdout
);
15158 case AFL_EXT_OCTEONP
:
15159 fputs ("Cavium Networks OcteonP", stdout
);
15161 case AFL_EXT_LOONGSON_3A
:
15162 fputs ("Loongson 3A", stdout
);
15164 case AFL_EXT_OCTEON
:
15165 fputs ("Cavium Networks Octeon", stdout
);
15168 fputs ("Toshiba R5900", stdout
);
15171 fputs ("MIPS R4650", stdout
);
15174 fputs ("LSI R4010", stdout
);
15177 fputs ("NEC VR4100", stdout
);
15180 fputs ("Toshiba R3900", stdout
);
15182 case AFL_EXT_10000
:
15183 fputs ("MIPS R10000", stdout
);
15186 fputs ("Broadcom SB-1", stdout
);
15189 fputs ("NEC VR4111/VR4181", stdout
);
15192 fputs ("NEC VR4120", stdout
);
15195 fputs ("NEC VR5400", stdout
);
15198 fputs ("NEC VR5500", stdout
);
15200 case AFL_EXT_LOONGSON_2E
:
15201 fputs ("ST Microelectronics Loongson 2E", stdout
);
15203 case AFL_EXT_LOONGSON_2F
:
15204 fputs ("ST Microelectronics Loongson 2F", stdout
);
15206 case AFL_EXT_INTERAPTIV_MR2
:
15207 fputs ("Imagination interAptiv MR2", stdout
);
15210 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
15215 get_mips_reg_size (int reg_size
)
15217 return (reg_size
== AFL_REG_NONE
) ? 0
15218 : (reg_size
== AFL_REG_32
) ? 32
15219 : (reg_size
== AFL_REG_64
) ? 64
15220 : (reg_size
== AFL_REG_128
) ? 128
15225 process_mips_specific (FILE * file
)
15227 Elf_Internal_Dyn
* entry
;
15228 Elf_Internal_Shdr
*sect
= NULL
;
15229 size_t liblist_offset
= 0;
15230 size_t liblistno
= 0;
15231 size_t conflictsno
= 0;
15232 size_t options_offset
= 0;
15233 size_t conflicts_offset
= 0;
15234 size_t pltrelsz
= 0;
15236 bfd_vma pltgot
= 0;
15237 bfd_vma mips_pltgot
= 0;
15238 bfd_vma jmprel
= 0;
15239 bfd_vma local_gotno
= 0;
15240 bfd_vma gotsym
= 0;
15241 bfd_vma symtabno
= 0;
15242 bfd_boolean res
= TRUE
;
15244 if (! process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
15245 display_mips_gnu_attribute
))
15248 sect
= find_section (".MIPS.abiflags");
15252 Elf_External_ABIFlags_v0
*abiflags_ext
;
15253 Elf_Internal_ABIFlags_v0 abiflags_in
;
15255 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
15257 error (_("Corrupt MIPS ABI Flags section.\n"));
15262 abiflags_ext
= get_data (NULL
, file
, sect
->sh_offset
, 1,
15263 sect
->sh_size
, _("MIPS ABI Flags section"));
15266 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
15267 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
15268 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
15269 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
15270 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
15271 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
15272 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
15273 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
15274 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
15275 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
15276 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
15278 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
15279 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
15280 if (abiflags_in
.isa_rev
> 1)
15281 printf ("r%d", abiflags_in
.isa_rev
);
15282 printf ("\nGPR size: %d",
15283 get_mips_reg_size (abiflags_in
.gpr_size
));
15284 printf ("\nCPR1 size: %d",
15285 get_mips_reg_size (abiflags_in
.cpr1_size
));
15286 printf ("\nCPR2 size: %d",
15287 get_mips_reg_size (abiflags_in
.cpr2_size
));
15288 fputs ("\nFP ABI: ", stdout
);
15289 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
15290 fputs ("ISA Extension: ", stdout
);
15291 print_mips_isa_ext (abiflags_in
.isa_ext
);
15292 fputs ("\nASEs:", stdout
);
15293 print_mips_ases (abiflags_in
.ases
);
15294 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
15295 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
15296 fputc ('\n', stdout
);
15297 free (abiflags_ext
);
15302 /* We have a lot of special sections. Thanks SGI! */
15303 if (dynamic_section
== NULL
)
15305 /* No dynamic information available. See if there is static GOT. */
15306 sect
= find_section (".got");
15309 unsigned char *data_end
;
15310 unsigned char *data
;
15314 pltgot
= sect
->sh_addr
;
15317 addr_size
= (is_32bit_elf
? 4 : 8);
15318 end
= pltgot
+ sect
->sh_size
;
15320 data
= (unsigned char *) get_data (NULL
, file
, sect
->sh_offset
,
15322 _("Global Offset Table data"));
15323 /* PR 12855: Null data is handled gracefully throughout. */
15324 data_end
= data
+ (end
- pltgot
);
15326 printf (_("\nStatic GOT:\n"));
15327 printf (_(" Canonical gp value: "));
15328 print_vma (ent
+ 0x7ff0, LONG_HEX
);
15331 /* In a dynamic binary GOT[0] is reserved for the dynamic
15332 loader to store the lazy resolver pointer, however in
15333 a static binary it may well have been omitted and GOT
15334 reduced to a table of addresses.
15335 PR 21344: Check for the entry being fully available
15336 before fetching it. */
15338 && data
+ ent
- pltgot
+ addr_size
<= data_end
15339 && byte_get (data
+ ent
- pltgot
, addr_size
) == 0)
15341 printf (_(" Reserved entries:\n"));
15342 printf (_(" %*s %10s %*s\n"),
15343 addr_size
* 2, _("Address"), _("Access"),
15344 addr_size
* 2, _("Value"));
15345 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15347 if (ent
== (bfd_vma
) -1)
15348 goto sgot_print_fail
;
15350 /* Check for the MSB of GOT[1] being set, identifying a
15351 GNU object. This entry will be used by some runtime
15352 loaders, to store the module pointer. Otherwise this
15353 is an ordinary local entry.
15354 PR 21344: Check for the entry being fully available
15355 before fetching it. */
15357 && data
+ ent
- pltgot
+ addr_size
<= data_end
15358 && (byte_get (data
+ ent
- pltgot
, addr_size
)
15359 >> (addr_size
* 8 - 1)) != 0)
15361 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15363 if (ent
== (bfd_vma
) -1)
15364 goto sgot_print_fail
;
15369 if (data
!= NULL
&& ent
< end
)
15371 printf (_(" Local entries:\n"));
15372 printf (" %*s %10s %*s\n",
15373 addr_size
* 2, _("Address"), _("Access"),
15374 addr_size
* 2, _("Value"));
15377 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15379 if (ent
== (bfd_vma
) -1)
15380 goto sgot_print_fail
;
15392 for (entry
= dynamic_section
;
15393 /* PR 17531 file: 012-50589-0.004. */
15394 entry
< dynamic_section
+ dynamic_nent
&& entry
->d_tag
!= DT_NULL
;
15396 switch (entry
->d_tag
)
15398 case DT_MIPS_LIBLIST
:
15400 = offset_from_vma (file
, entry
->d_un
.d_val
,
15401 liblistno
* sizeof (Elf32_External_Lib
));
15403 case DT_MIPS_LIBLISTNO
:
15404 liblistno
= entry
->d_un
.d_val
;
15406 case DT_MIPS_OPTIONS
:
15407 options_offset
= offset_from_vma (file
, entry
->d_un
.d_val
, 0);
15409 case DT_MIPS_CONFLICT
:
15411 = offset_from_vma (file
, entry
->d_un
.d_val
,
15412 conflictsno
* sizeof (Elf32_External_Conflict
));
15414 case DT_MIPS_CONFLICTNO
:
15415 conflictsno
= entry
->d_un
.d_val
;
15418 pltgot
= entry
->d_un
.d_ptr
;
15420 case DT_MIPS_LOCAL_GOTNO
:
15421 local_gotno
= entry
->d_un
.d_val
;
15423 case DT_MIPS_GOTSYM
:
15424 gotsym
= entry
->d_un
.d_val
;
15426 case DT_MIPS_SYMTABNO
:
15427 symtabno
= entry
->d_un
.d_val
;
15429 case DT_MIPS_PLTGOT
:
15430 mips_pltgot
= entry
->d_un
.d_ptr
;
15433 pltrel
= entry
->d_un
.d_val
;
15436 pltrelsz
= entry
->d_un
.d_val
;
15439 jmprel
= entry
->d_un
.d_ptr
;
15445 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
15447 Elf32_External_Lib
* elib
;
15450 elib
= (Elf32_External_Lib
*) get_data (NULL
, file
, liblist_offset
,
15452 sizeof (Elf32_External_Lib
),
15453 _("liblist section data"));
15456 printf (_("\nSection '.liblist' contains %lu entries:\n"),
15457 (unsigned long) liblistno
);
15458 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
15461 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
15468 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
15469 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
15470 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
15471 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
15472 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
15474 tmp
= gmtime (&atime
);
15475 snprintf (timebuf
, sizeof (timebuf
),
15476 "%04u-%02u-%02uT%02u:%02u:%02u",
15477 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
15478 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
15480 printf ("%3lu: ", (unsigned long) cnt
);
15481 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
15482 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
15484 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
15485 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
15486 liblist
.l_version
);
15488 if (liblist
.l_flags
== 0)
15492 static const struct
15499 { " EXACT_MATCH", LL_EXACT_MATCH
},
15500 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
15501 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
15502 { " EXPORTS", LL_EXPORTS
},
15503 { " DELAY_LOAD", LL_DELAY_LOAD
},
15504 { " DELTA", LL_DELTA
}
15506 int flags
= liblist
.l_flags
;
15509 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
15510 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
15512 fputs (l_flags_vals
[fcnt
].name
, stdout
);
15513 flags
^= l_flags_vals
[fcnt
].bit
;
15516 printf (" %#x", (unsigned int) flags
);
15528 if (options_offset
!= 0)
15530 Elf_External_Options
* eopt
;
15531 Elf_Internal_Options
* iopt
;
15532 Elf_Internal_Options
* option
;
15535 sect
= section_headers
;
15537 /* Find the section header so that we get the size. */
15538 sect
= find_section_by_type (SHT_MIPS_OPTIONS
);
15539 /* PR 17533 file: 012-277276-0.004. */
15542 error (_("No MIPS_OPTIONS header found\n"));
15546 eopt
= (Elf_External_Options
*) get_data (NULL
, file
, options_offset
, 1,
15547 sect
->sh_size
, _("options"));
15550 iopt
= (Elf_Internal_Options
*)
15551 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
15554 error (_("Out of memory allocating space for MIPS options\n"));
15561 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
15563 Elf_External_Options
* eoption
;
15565 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
15567 option
->kind
= BYTE_GET (eoption
->kind
);
15568 option
->size
= BYTE_GET (eoption
->size
);
15569 option
->section
= BYTE_GET (eoption
->section
);
15570 option
->info
= BYTE_GET (eoption
->info
);
15572 /* PR 17531: file: ffa0fa3b. */
15573 if (option
->size
< sizeof (* eopt
)
15574 || offset
+ option
->size
> sect
->sh_size
)
15576 error (_("Invalid size (%u) for MIPS option\n"), option
->size
);
15579 offset
+= option
->size
;
15585 printf (_("\nSection '%s' contains %d entries:\n"),
15586 printable_section_name (sect
), cnt
);
15595 switch (option
->kind
)
15598 /* This shouldn't happen. */
15599 printf (" NULL %d %lx", option
->section
, option
->info
);
15602 printf (" REGINFO ");
15603 if (elf_header
.e_machine
== EM_MIPS
)
15606 Elf32_External_RegInfo
* ereg
;
15607 Elf32_RegInfo reginfo
;
15609 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
15610 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
15611 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
15612 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
15613 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
15614 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
15615 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
15617 printf ("GPR %08lx GP 0x%lx\n",
15618 reginfo
.ri_gprmask
,
15619 (unsigned long) reginfo
.ri_gp_value
);
15620 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
15621 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
15622 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
15627 Elf64_External_RegInfo
* ereg
;
15628 Elf64_Internal_RegInfo reginfo
;
15630 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
15631 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
15632 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
15633 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
15634 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
15635 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
15636 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
15638 printf ("GPR %08lx GP 0x",
15639 reginfo
.ri_gprmask
);
15640 printf_vma (reginfo
.ri_gp_value
);
15643 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
15644 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
15645 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
15649 case ODK_EXCEPTIONS
:
15650 fputs (" EXCEPTIONS fpe_min(", stdout
);
15651 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
15652 fputs (") fpe_max(", stdout
);
15653 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
15654 fputs (")", stdout
);
15656 if (option
->info
& OEX_PAGE0
)
15657 fputs (" PAGE0", stdout
);
15658 if (option
->info
& OEX_SMM
)
15659 fputs (" SMM", stdout
);
15660 if (option
->info
& OEX_FPDBUG
)
15661 fputs (" FPDBUG", stdout
);
15662 if (option
->info
& OEX_DISMISS
)
15663 fputs (" DISMISS", stdout
);
15666 fputs (" PAD ", stdout
);
15667 if (option
->info
& OPAD_PREFIX
)
15668 fputs (" PREFIX", stdout
);
15669 if (option
->info
& OPAD_POSTFIX
)
15670 fputs (" POSTFIX", stdout
);
15671 if (option
->info
& OPAD_SYMBOL
)
15672 fputs (" SYMBOL", stdout
);
15675 fputs (" HWPATCH ", stdout
);
15676 if (option
->info
& OHW_R4KEOP
)
15677 fputs (" R4KEOP", stdout
);
15678 if (option
->info
& OHW_R8KPFETCH
)
15679 fputs (" R8KPFETCH", stdout
);
15680 if (option
->info
& OHW_R5KEOP
)
15681 fputs (" R5KEOP", stdout
);
15682 if (option
->info
& OHW_R5KCVTL
)
15683 fputs (" R5KCVTL", stdout
);
15686 fputs (" FILL ", stdout
);
15687 /* XXX Print content of info word? */
15690 fputs (" TAGS ", stdout
);
15691 /* XXX Print content of info word? */
15694 fputs (" HWAND ", stdout
);
15695 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
15696 fputs (" R4KEOP_CHECKED", stdout
);
15697 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
15698 fputs (" R4KEOP_CLEAN", stdout
);
15701 fputs (" HWOR ", stdout
);
15702 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
15703 fputs (" R4KEOP_CHECKED", stdout
);
15704 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
15705 fputs (" R4KEOP_CLEAN", stdout
);
15708 printf (" GP_GROUP %#06lx self-contained %#06lx",
15709 option
->info
& OGP_GROUP
,
15710 (option
->info
& OGP_SELF
) >> 16);
15713 printf (" IDENT %#06lx self-contained %#06lx",
15714 option
->info
& OGP_GROUP
,
15715 (option
->info
& OGP_SELF
) >> 16);
15718 /* This shouldn't happen. */
15719 printf (" %3d ??? %d %lx",
15720 option
->kind
, option
->section
, option
->info
);
15724 len
= sizeof (* eopt
);
15725 while (len
< option
->size
)
15727 unsigned char datum
= * ((unsigned char *) eopt
+ offset
+ len
);
15729 if (ISPRINT (datum
))
15730 printf ("%c", datum
);
15732 printf ("\\%03o", datum
);
15735 fputs ("\n", stdout
);
15737 offset
+= option
->size
;
15747 if (conflicts_offset
!= 0 && conflictsno
!= 0)
15749 Elf32_Conflict
* iconf
;
15752 if (dynamic_symbols
== NULL
)
15754 error (_("conflict list found without a dynamic symbol table\n"));
15758 /* PR 21345 - print a slightly more helpful error message
15759 if we are sure that the cmalloc will fail. */
15760 if (conflictsno
* sizeof (* iconf
) > current_file_size
)
15762 error (_("Overlarge number of conflicts detected: %lx\n"),
15763 (long) conflictsno
);
15767 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
15770 error (_("Out of memory allocating space for dynamic conflicts\n"));
15776 Elf32_External_Conflict
* econf32
;
15778 econf32
= (Elf32_External_Conflict
*)
15779 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
15780 sizeof (* econf32
), _("conflict"));
15784 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
15785 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
15791 Elf64_External_Conflict
* econf64
;
15793 econf64
= (Elf64_External_Conflict
*)
15794 get_data (NULL
, file
, conflicts_offset
, conflictsno
,
15795 sizeof (* econf64
), _("conflict"));
15799 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
15800 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
15805 printf (_("\nSection '.conflict' contains %lu entries:\n"),
15806 (unsigned long) conflictsno
);
15807 puts (_(" Num: Index Value Name"));
15809 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
15811 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
15813 if (iconf
[cnt
] >= num_dynamic_syms
)
15814 printf (_("<corrupt symbol index>"));
15817 Elf_Internal_Sym
* psym
;
15819 psym
= & dynamic_symbols
[iconf
[cnt
]];
15820 print_vma (psym
->st_value
, FULL_HEX
);
15822 if (VALID_DYNAMIC_NAME (psym
->st_name
))
15823 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
15825 printf (_("<corrupt: %14ld>"), psym
->st_name
);
15833 if (pltgot
!= 0 && local_gotno
!= 0)
15835 bfd_vma ent
, local_end
, global_end
;
15837 unsigned char * data
;
15838 unsigned char * data_end
;
15842 addr_size
= (is_32bit_elf
? 4 : 8);
15843 local_end
= pltgot
+ local_gotno
* addr_size
;
15845 /* PR binutils/17533 file: 012-111227-0.004 */
15846 if (symtabno
< gotsym
)
15848 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
15849 (unsigned long) gotsym
, (unsigned long) symtabno
);
15853 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
15854 /* PR 17531: file: 54c91a34. */
15855 if (global_end
< local_end
)
15857 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
15861 offset
= offset_from_vma (file
, pltgot
, global_end
- pltgot
);
15862 data
= (unsigned char *) get_data (NULL
, file
, offset
,
15863 global_end
- pltgot
, 1,
15864 _("Global Offset Table data"));
15865 /* PR 12855: Null data is handled gracefully throughout. */
15866 data_end
= data
+ (global_end
- pltgot
);
15868 printf (_("\nPrimary GOT:\n"));
15869 printf (_(" Canonical gp value: "));
15870 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
15873 printf (_(" Reserved entries:\n"));
15874 printf (_(" %*s %10s %*s Purpose\n"),
15875 addr_size
* 2, _("Address"), _("Access"),
15876 addr_size
* 2, _("Initial"));
15877 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15878 printf (_(" Lazy resolver\n"));
15879 if (ent
== (bfd_vma
) -1)
15880 goto got_print_fail
;
15882 /* Check for the MSB of GOT[1] being set, denoting a GNU object.
15883 This entry will be used by some runtime loaders, to store the
15884 module pointer. Otherwise this is an ordinary local entry.
15885 PR 21344: Check for the entry being fully available before
15888 && data
+ ent
- pltgot
+ addr_size
<= data_end
15889 && (byte_get (data
+ ent
- pltgot
, addr_size
)
15890 >> (addr_size
* 8 - 1)) != 0)
15892 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15893 printf (_(" Module pointer (GNU extension)\n"));
15894 if (ent
== (bfd_vma
) -1)
15895 goto got_print_fail
;
15899 if (data
!= NULL
&& ent
< local_end
)
15901 printf (_(" Local entries:\n"));
15902 printf (" %*s %10s %*s\n",
15903 addr_size
* 2, _("Address"), _("Access"),
15904 addr_size
* 2, _("Initial"));
15905 while (ent
< local_end
)
15907 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15909 if (ent
== (bfd_vma
) -1)
15910 goto got_print_fail
;
15915 if (data
!= NULL
&& gotsym
< symtabno
)
15919 printf (_(" Global entries:\n"));
15920 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
15921 addr_size
* 2, _("Address"),
15923 addr_size
* 2, _("Initial"),
15924 addr_size
* 2, _("Sym.Val."),
15926 /* Note for translators: "Ndx" = abbreviated form of "Index". */
15927 _("Ndx"), _("Name"));
15929 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
15931 for (i
= gotsym
; i
< symtabno
; i
++)
15933 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15936 if (dynamic_symbols
== NULL
)
15937 printf (_("<no dynamic symbols>"));
15938 else if (i
< num_dynamic_syms
)
15940 Elf_Internal_Sym
* psym
= dynamic_symbols
+ i
;
15942 print_vma (psym
->st_value
, LONG_HEX
);
15943 printf (" %-7s %3s ",
15944 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
15945 get_symbol_index_type (psym
->st_shndx
));
15947 if (VALID_DYNAMIC_NAME (psym
->st_name
))
15948 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
15950 printf (_("<corrupt: %14ld>"), psym
->st_name
);
15953 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
15954 (unsigned long) i
);
15957 if (ent
== (bfd_vma
) -1)
15968 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
15971 size_t offset
, rel_offset
;
15972 unsigned long count
, i
;
15973 unsigned char * data
;
15974 int addr_size
, sym_width
;
15975 Elf_Internal_Rela
* rels
;
15977 rel_offset
= offset_from_vma (file
, jmprel
, pltrelsz
);
15978 if (pltrel
== DT_RELA
)
15980 if (!slurp_rela_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
15985 if (!slurp_rel_relocs (file
, rel_offset
, pltrelsz
, &rels
, &count
))
15990 addr_size
= (is_32bit_elf
? 4 : 8);
15991 end
= mips_pltgot
+ (2 + count
) * addr_size
;
15993 offset
= offset_from_vma (file
, mips_pltgot
, end
- mips_pltgot
);
15994 data
= (unsigned char *) get_data (NULL
, file
, offset
, end
- mips_pltgot
,
15995 1, _("Procedure Linkage Table data"));
15999 printf ("\nPLT GOT:\n\n");
16000 printf (_(" Reserved entries:\n"));
16001 printf (_(" %*s %*s Purpose\n"),
16002 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
16003 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
16004 printf (_(" PLT lazy resolver\n"));
16005 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
16006 printf (_(" Module pointer\n"));
16009 printf (_(" Entries:\n"));
16010 printf (" %*s %*s %*s %-7s %3s %s\n",
16011 addr_size
* 2, _("Address"),
16012 addr_size
* 2, _("Initial"),
16013 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
16014 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
16015 for (i
= 0; i
< count
; i
++)
16017 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
16019 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
16022 if (idx
>= num_dynamic_syms
)
16023 printf (_("<corrupt symbol index: %lu>"), idx
);
16026 Elf_Internal_Sym
* psym
= dynamic_symbols
+ idx
;
16028 print_vma (psym
->st_value
, LONG_HEX
);
16029 printf (" %-7s %3s ",
16030 get_symbol_type (ELF_ST_TYPE (psym
->st_info
)),
16031 get_symbol_index_type (psym
->st_shndx
));
16032 if (VALID_DYNAMIC_NAME (psym
->st_name
))
16033 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
16035 printf (_("<corrupt: %14ld>"), psym
->st_name
);
16050 process_nds32_specific (FILE * file
)
16052 Elf_Internal_Shdr
*sect
= NULL
;
16054 sect
= find_section (".nds32_e_flags");
16057 unsigned int *flag
;
16059 printf ("\nNDS32 elf flags section:\n");
16060 flag
= get_data (NULL
, file
, sect
->sh_offset
, 1,
16061 sect
->sh_size
, _("NDS32 elf flags section"));
16066 switch ((*flag
) & 0x3)
16069 printf ("(VEC_SIZE):\tNo entry.\n");
16072 printf ("(VEC_SIZE):\t4 bytes\n");
16075 printf ("(VEC_SIZE):\t16 bytes\n");
16078 printf ("(VEC_SIZE):\treserved\n");
16087 process_gnu_liblist (FILE * file
)
16089 Elf_Internal_Shdr
* section
;
16090 Elf_Internal_Shdr
* string_sec
;
16091 Elf32_External_Lib
* elib
;
16093 size_t strtab_size
;
16096 bfd_boolean res
= TRUE
;
16101 for (i
= 0, section
= section_headers
;
16102 i
< elf_header
.e_shnum
;
16105 switch (section
->sh_type
)
16107 case SHT_GNU_LIBLIST
:
16108 if (section
->sh_link
>= elf_header
.e_shnum
)
16111 elib
= (Elf32_External_Lib
*)
16112 get_data (NULL
, file
, section
->sh_offset
, 1, section
->sh_size
,
16113 _("liblist section data"));
16121 string_sec
= section_headers
+ section
->sh_link
;
16122 strtab
= (char *) get_data (NULL
, file
, string_sec
->sh_offset
, 1,
16123 string_sec
->sh_size
,
16124 _("liblist string table"));
16126 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
16133 strtab_size
= string_sec
->sh_size
;
16135 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
16136 printable_section_name (section
),
16137 (unsigned long) (section
->sh_size
/ sizeof (Elf32_External_Lib
)));
16139 puts (_(" Library Time Stamp Checksum Version Flags"));
16141 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
16149 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
16150 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
16151 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
16152 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
16153 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
16155 tmp
= gmtime (&atime
);
16156 snprintf (timebuf
, sizeof (timebuf
),
16157 "%04u-%02u-%02uT%02u:%02u:%02u",
16158 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
16159 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
16161 printf ("%3lu: ", (unsigned long) cnt
);
16163 printf ("%-20s", liblist
.l_name
< strtab_size
16164 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
16166 printf ("%-20.20s", liblist
.l_name
< strtab_size
16167 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
16168 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
16169 liblist
.l_version
, liblist
.l_flags
);
16180 static const char *
16181 get_note_type (unsigned e_type
)
16183 static char buff
[64];
16185 if (elf_header
.e_type
== ET_CORE
)
16189 return _("NT_AUXV (auxiliary vector)");
16191 return _("NT_PRSTATUS (prstatus structure)");
16193 return _("NT_FPREGSET (floating point registers)");
16195 return _("NT_PRPSINFO (prpsinfo structure)");
16196 case NT_TASKSTRUCT
:
16197 return _("NT_TASKSTRUCT (task structure)");
16199 return _("NT_PRXFPREG (user_xfpregs structure)");
16201 return _("NT_PPC_VMX (ppc Altivec registers)");
16203 return _("NT_PPC_VSX (ppc VSX registers)");
16205 return _("NT_PPC_TAR (ppc TAR register)");
16207 return _("NT_PPC_PPR (ppc PPR register)");
16209 return _("NT_PPC_DSCR (ppc DSCR register)");
16211 return _("NT_PPC_EBB (ppc EBB registers)");
16213 return _("NT_PPC_PMU (ppc PMU registers)");
16214 case NT_PPC_TM_CGPR
:
16215 return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
16216 case NT_PPC_TM_CFPR
:
16217 return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
16218 case NT_PPC_TM_CVMX
:
16219 return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
16220 case NT_PPC_TM_CVSX
:
16221 return _("NT_PPC_TM_VSX (ppc checkpointed VSX registers)");
16222 case NT_PPC_TM_SPR
:
16223 return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
16224 case NT_PPC_TM_CTAR
:
16225 return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
16226 case NT_PPC_TM_CPPR
:
16227 return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
16228 case NT_PPC_TM_CDSCR
:
16229 return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
16231 return _("NT_386_TLS (x86 TLS information)");
16232 case NT_386_IOPERM
:
16233 return _("NT_386_IOPERM (x86 I/O permissions)");
16234 case NT_X86_XSTATE
:
16235 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
16236 case NT_S390_HIGH_GPRS
:
16237 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
16238 case NT_S390_TIMER
:
16239 return _("NT_S390_TIMER (s390 timer register)");
16240 case NT_S390_TODCMP
:
16241 return _("NT_S390_TODCMP (s390 TOD comparator register)");
16242 case NT_S390_TODPREG
:
16243 return _("NT_S390_TODPREG (s390 TOD programmable register)");
16245 return _("NT_S390_CTRS (s390 control registers)");
16246 case NT_S390_PREFIX
:
16247 return _("NT_S390_PREFIX (s390 prefix register)");
16248 case NT_S390_LAST_BREAK
:
16249 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
16250 case NT_S390_SYSTEM_CALL
:
16251 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
16253 return _("NT_S390_TDB (s390 transaction diagnostic block)");
16254 case NT_S390_VXRS_LOW
:
16255 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
16256 case NT_S390_VXRS_HIGH
:
16257 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
16258 case NT_S390_GS_CB
:
16259 return _("NT_S390_GS_CB (s390 guarded-storage registers)");
16260 case NT_S390_GS_BC
:
16261 return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
16263 return _("NT_ARM_VFP (arm VFP registers)");
16265 return _("NT_ARM_TLS (AArch TLS registers)");
16266 case NT_ARM_HW_BREAK
:
16267 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
16268 case NT_ARM_HW_WATCH
:
16269 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
16271 return _("NT_PSTATUS (pstatus structure)");
16273 return _("NT_FPREGS (floating point registers)");
16275 return _("NT_PSINFO (psinfo structure)");
16277 return _("NT_LWPSTATUS (lwpstatus_t structure)");
16279 return _("NT_LWPSINFO (lwpsinfo_t structure)");
16280 case NT_WIN32PSTATUS
:
16281 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
16283 return _("NT_SIGINFO (siginfo_t data)");
16285 return _("NT_FILE (mapped files)");
16293 return _("NT_VERSION (version)");
16295 return _("NT_ARCH (architecture)");
16296 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
16297 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
16298 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
16299 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
16304 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16309 print_core_note (Elf_Internal_Note
*pnote
)
16311 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
16312 bfd_vma count
, page_size
;
16313 unsigned char *descdata
, *filenames
, *descend
;
16315 if (pnote
->type
!= NT_FILE
)
16325 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
16326 /* Still "successful". */
16331 if (pnote
->descsz
< 2 * addr_size
)
16333 error (_(" Malformed note - too short for header\n"));
16337 descdata
= (unsigned char *) pnote
->descdata
;
16338 descend
= descdata
+ pnote
->descsz
;
16340 if (descdata
[pnote
->descsz
- 1] != '\0')
16342 error (_(" Malformed note - does not end with \\0\n"));
16346 count
= byte_get (descdata
, addr_size
);
16347 descdata
+= addr_size
;
16349 page_size
= byte_get (descdata
, addr_size
);
16350 descdata
+= addr_size
;
16352 if (count
> ((bfd_vma
) -1 - 2 * addr_size
) / (3 * addr_size
)
16353 || pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
16355 error (_(" Malformed note - too short for supplied file count\n"));
16359 printf (_(" Page size: "));
16360 print_vma (page_size
, DEC
);
16363 printf (_(" %*s%*s%*s\n"),
16364 (int) (2 + 2 * addr_size
), _("Start"),
16365 (int) (4 + 2 * addr_size
), _("End"),
16366 (int) (4 + 2 * addr_size
), _("Page Offset"));
16367 filenames
= descdata
+ count
* 3 * addr_size
;
16368 while (count
-- > 0)
16370 bfd_vma start
, end
, file_ofs
;
16372 if (filenames
== descend
)
16374 error (_(" Malformed note - filenames end too early\n"));
16378 start
= byte_get (descdata
, addr_size
);
16379 descdata
+= addr_size
;
16380 end
= byte_get (descdata
, addr_size
);
16381 descdata
+= addr_size
;
16382 file_ofs
= byte_get (descdata
, addr_size
);
16383 descdata
+= addr_size
;
16386 print_vma (start
, FULL_HEX
);
16388 print_vma (end
, FULL_HEX
);
16390 print_vma (file_ofs
, FULL_HEX
);
16391 printf ("\n %s\n", filenames
);
16393 filenames
+= 1 + strlen ((char *) filenames
);
16399 static const char *
16400 get_gnu_elf_note_type (unsigned e_type
)
16402 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
16405 case NT_GNU_ABI_TAG
:
16406 return _("NT_GNU_ABI_TAG (ABI version tag)");
16408 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
16409 case NT_GNU_BUILD_ID
:
16410 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
16411 case NT_GNU_GOLD_VERSION
:
16412 return _("NT_GNU_GOLD_VERSION (gold version)");
16413 case NT_GNU_PROPERTY_TYPE_0
:
16414 return _("NT_GNU_PROPERTY_TYPE_0");
16415 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
16416 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
16417 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
16418 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
16421 static char buff
[64];
16423 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16430 decode_x86_isa (unsigned int bitmask
)
16434 unsigned int bit
= bitmask
& (- bitmask
);
16439 case GNU_PROPERTY_X86_ISA_1_486
: printf ("i486"); break;
16440 case GNU_PROPERTY_X86_ISA_1_586
: printf ("586"); break;
16441 case GNU_PROPERTY_X86_ISA_1_686
: printf ("686"); break;
16442 case GNU_PROPERTY_X86_ISA_1_SSE
: printf ("SSE"); break;
16443 case GNU_PROPERTY_X86_ISA_1_SSE2
: printf ("SSE2"); break;
16444 case GNU_PROPERTY_X86_ISA_1_SSE3
: printf ("SSE3"); break;
16445 case GNU_PROPERTY_X86_ISA_1_SSSE3
: printf ("SSSE3"); break;
16446 case GNU_PROPERTY_X86_ISA_1_SSE4_1
: printf ("SSE4_1"); break;
16447 case GNU_PROPERTY_X86_ISA_1_SSE4_2
: printf ("SSE4_2"); break;
16448 case GNU_PROPERTY_X86_ISA_1_AVX
: printf ("AVX"); break;
16449 case GNU_PROPERTY_X86_ISA_1_AVX2
: printf ("AVX2"); break;
16450 case GNU_PROPERTY_X86_ISA_1_AVX512F
: printf ("AVX512F"); break;
16451 case GNU_PROPERTY_X86_ISA_1_AVX512CD
: printf ("AVX512CD"); break;
16452 case GNU_PROPERTY_X86_ISA_1_AVX512ER
: printf ("AVX512ER"); break;
16453 case GNU_PROPERTY_X86_ISA_1_AVX512PF
: printf ("AVX512PF"); break;
16454 case GNU_PROPERTY_X86_ISA_1_AVX512VL
: printf ("AVX512VL"); break;
16455 case GNU_PROPERTY_X86_ISA_1_AVX512DQ
: printf ("AVX512DQ"); break;
16456 case GNU_PROPERTY_X86_ISA_1_AVX512BW
: printf ("AVX512BW"); break;
16457 default: printf (_("<unknown: %x>"), bit
); break;
16465 decode_x86_feature (unsigned int type
, unsigned int bitmask
)
16469 unsigned int bit
= bitmask
& (- bitmask
);
16474 case GNU_PROPERTY_X86_FEATURE_1_IBT
:
16477 case GNU_PROPERTY_X86_FEATURE_1_AND
:
16481 /* This should never happen. */
16485 case GNU_PROPERTY_X86_FEATURE_1_SHSTK
:
16488 case GNU_PROPERTY_X86_FEATURE_1_AND
:
16492 /* This should never happen. */
16497 printf (_("<unknown: %x>"), bit
);
16506 print_gnu_property_note (Elf_Internal_Note
* pnote
)
16508 unsigned char * ptr
= (unsigned char *) pnote
->descdata
;
16509 unsigned char * ptr_end
= ptr
+ pnote
->descsz
;
16510 unsigned int size
= is_32bit_elf
? 4 : 8;
16512 printf (_(" Properties: "));
16514 if (pnote
->descsz
< 8 || (pnote
->descsz
% size
) != 0)
16516 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote
->descsz
);
16523 unsigned int type
= byte_get (ptr
, 4);
16524 unsigned int datasz
= byte_get (ptr
+ 4, 4);
16528 if ((ptr
+ datasz
) > ptr_end
)
16530 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
16535 if (type
>= GNU_PROPERTY_LOPROC
&& type
<= GNU_PROPERTY_HIPROC
)
16537 if (elf_header
.e_machine
== EM_X86_64
16538 || elf_header
.e_machine
== EM_IAMCU
16539 || elf_header
.e_machine
== EM_386
)
16543 case GNU_PROPERTY_X86_ISA_1_USED
:
16544 printf ("x86 ISA used: ");
16546 printf (_("<corrupt length: %#x> "), datasz
);
16548 decode_x86_isa (byte_get (ptr
, 4));
16551 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
16552 printf ("x86 ISA needed: ");
16554 printf (_("<corrupt length: %#x> "), datasz
);
16556 decode_x86_isa (byte_get (ptr
, 4));
16559 case GNU_PROPERTY_X86_FEATURE_1_AND
:
16560 printf ("x86 feature: ");
16562 printf (_("<corrupt length: %#x> "), datasz
);
16564 decode_x86_feature (type
, byte_get (ptr
, 4));
16576 case GNU_PROPERTY_STACK_SIZE
:
16577 printf (_("stack size: "));
16578 if (datasz
!= size
)
16579 printf (_("<corrupt length: %#x> "), datasz
);
16581 printf ("%#lx", (unsigned long) byte_get (ptr
, size
));
16584 case GNU_PROPERTY_NO_COPY_ON_PROTECTED
:
16585 printf ("no copy on protected ");
16587 printf (_("<corrupt length: %#x> "), datasz
);
16595 if (type
< GNU_PROPERTY_LOPROC
)
16596 printf (_("<unknown type %#x data: "), type
);
16597 else if (type
< GNU_PROPERTY_LOUSER
)
16598 printf (_("<procesor-specific type %#x data: "), type
);
16600 printf (_("<application-specific type %#x data: "), type
);
16601 for (j
= 0; j
< datasz
; ++j
)
16602 printf ("%02x ", ptr
[j
] & 0xff);
16606 ptr
+= ((datasz
+ (size
- 1)) & ~ (size
- 1));
16607 if (ptr
== ptr_end
)
16617 if (ptr
> (ptr_end
- 8))
16619 printf (_("<corrupt descsz: %#lx>\n"), pnote
->descsz
);
16628 print_gnu_note (Elf_Internal_Note
*pnote
)
16630 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
16631 switch (pnote
->type
)
16633 case NT_GNU_BUILD_ID
:
16637 printf (_(" Build ID: "));
16638 for (i
= 0; i
< pnote
->descsz
; ++i
)
16639 printf ("%02x", pnote
->descdata
[i
] & 0xff);
16644 case NT_GNU_ABI_TAG
:
16646 unsigned long os
, major
, minor
, subminor
;
16647 const char *osname
;
16649 /* PR 17531: file: 030-599401-0.004. */
16650 if (pnote
->descsz
< 16)
16652 printf (_(" <corrupt GNU_ABI_TAG>\n"));
16656 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
16657 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
16658 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
16659 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
16663 case GNU_ABI_TAG_LINUX
:
16666 case GNU_ABI_TAG_HURD
:
16669 case GNU_ABI_TAG_SOLARIS
:
16670 osname
= "Solaris";
16672 case GNU_ABI_TAG_FREEBSD
:
16673 osname
= "FreeBSD";
16675 case GNU_ABI_TAG_NETBSD
:
16678 case GNU_ABI_TAG_SYLLABLE
:
16679 osname
= "Syllable";
16681 case GNU_ABI_TAG_NACL
:
16685 osname
= "Unknown";
16689 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
16690 major
, minor
, subminor
);
16694 case NT_GNU_GOLD_VERSION
:
16698 printf (_(" Version: "));
16699 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
16700 printf ("%c", pnote
->descdata
[i
]);
16707 unsigned long num_entries
, mask
;
16709 /* Hardware capabilities information. Word 0 is the number of entries.
16710 Word 1 is a bitmask of enabled entries. The rest of the descriptor
16711 is a series of entries, where each entry is a single byte followed
16712 by a nul terminated string. The byte gives the bit number to test
16713 if enabled in the bitmask. */
16714 printf (_(" Hardware Capabilities: "));
16715 if (pnote
->descsz
< 8)
16717 error (_("<corrupt GNU_HWCAP>\n"));
16720 num_entries
= byte_get ((unsigned char *) pnote
->descdata
, 4);
16721 mask
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
16722 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries
, mask
);
16723 /* FIXME: Add code to display the entries... */
16727 case NT_GNU_PROPERTY_TYPE_0
:
16728 print_gnu_property_note (pnote
);
16732 /* Handle unrecognised types. An error message should have already been
16733 created by get_gnu_elf_note_type(), so all that we need to do is to
16734 display the data. */
16738 printf (_(" Description data: "));
16739 for (i
= 0; i
< pnote
->descsz
; ++i
)
16740 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
16749 static const char *
16750 get_v850_elf_note_type (enum v850_notes n_type
)
16752 static char buff
[64];
16756 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
16757 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
16758 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
16759 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
16760 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
16761 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
16763 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
16769 print_v850_note (Elf_Internal_Note
* pnote
)
16773 if (pnote
->descsz
!= 4)
16776 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
16780 printf (_("not set\n"));
16784 switch (pnote
->type
)
16786 case V850_NOTE_ALIGNMENT
:
16789 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return TRUE
;
16790 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return TRUE
;
16794 case V850_NOTE_DATA_SIZE
:
16797 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return TRUE
;
16798 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return TRUE
;
16802 case V850_NOTE_FPU_INFO
:
16805 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return TRUE
;
16806 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return TRUE
;
16810 case V850_NOTE_MMU_INFO
:
16811 case V850_NOTE_CACHE_INFO
:
16812 case V850_NOTE_SIMD_INFO
:
16813 if (val
== EF_RH850_SIMD
)
16815 printf (_("yes\n"));
16821 /* An 'unknown note type' message will already have been displayed. */
16825 printf (_("unknown value: %x\n"), val
);
16830 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
16832 unsigned int version
;
16834 switch (pnote
->type
)
16836 case NT_NETBSD_IDENT
:
16837 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
16838 if ((version
/ 10000) % 100)
16839 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
16840 version
, version
/ 100000000, (version
/ 1000000) % 100,
16841 (version
/ 10000) % 100 > 26 ? "Z" : "",
16842 'A' + (version
/ 10000) % 26);
16844 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
16845 version
, version
/ 100000000, (version
/ 1000000) % 100,
16846 (version
/ 100) % 100);
16849 case NT_NETBSD_MARCH
:
16850 printf (" NetBSD\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
16855 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote
->descsz
,
16861 static const char *
16862 get_freebsd_elfcore_note_type (unsigned e_type
)
16866 case NT_FREEBSD_THRMISC
:
16867 return _("NT_THRMISC (thrmisc structure)");
16868 case NT_FREEBSD_PROCSTAT_PROC
:
16869 return _("NT_PROCSTAT_PROC (proc data)");
16870 case NT_FREEBSD_PROCSTAT_FILES
:
16871 return _("NT_PROCSTAT_FILES (files data)");
16872 case NT_FREEBSD_PROCSTAT_VMMAP
:
16873 return _("NT_PROCSTAT_VMMAP (vmmap data)");
16874 case NT_FREEBSD_PROCSTAT_GROUPS
:
16875 return _("NT_PROCSTAT_GROUPS (groups data)");
16876 case NT_FREEBSD_PROCSTAT_UMASK
:
16877 return _("NT_PROCSTAT_UMASK (umask data)");
16878 case NT_FREEBSD_PROCSTAT_RLIMIT
:
16879 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
16880 case NT_FREEBSD_PROCSTAT_OSREL
:
16881 return _("NT_PROCSTAT_OSREL (osreldate data)");
16882 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
16883 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
16884 case NT_FREEBSD_PROCSTAT_AUXV
:
16885 return _("NT_PROCSTAT_AUXV (auxv data)");
16886 case NT_FREEBSD_PTLWPINFO
:
16887 return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
16889 return get_note_type (e_type
);
16892 static const char *
16893 get_netbsd_elfcore_note_type (unsigned e_type
)
16895 static char buff
[64];
16897 if (e_type
== NT_NETBSDCORE_PROCINFO
)
16899 /* NetBSD core "procinfo" structure. */
16900 return _("NetBSD procinfo structure");
16903 /* As of Jan 2002 there are no other machine-independent notes
16904 defined for NetBSD core files. If the note type is less
16905 than the start of the machine-dependent note types, we don't
16908 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
16910 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16914 switch (elf_header
.e_machine
)
16916 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
16917 and PT_GETFPREGS == mach+2. */
16922 case EM_SPARC32PLUS
:
16926 case NT_NETBSDCORE_FIRSTMACH
+ 0:
16927 return _("PT_GETREGS (reg structure)");
16928 case NT_NETBSDCORE_FIRSTMACH
+ 2:
16929 return _("PT_GETFPREGS (fpreg structure)");
16935 /* On all other arch's, PT_GETREGS == mach+1 and
16936 PT_GETFPREGS == mach+3. */
16940 case NT_NETBSDCORE_FIRSTMACH
+ 1:
16941 return _("PT_GETREGS (reg structure)");
16942 case NT_NETBSDCORE_FIRSTMACH
+ 3:
16943 return _("PT_GETFPREGS (fpreg structure)");
16949 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
16950 e_type
- NT_NETBSDCORE_FIRSTMACH
);
16954 static const char *
16955 get_stapsdt_note_type (unsigned e_type
)
16957 static char buff
[64];
16962 return _("NT_STAPSDT (SystemTap probe descriptors)");
16968 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16973 print_stapsdt_note (Elf_Internal_Note
*pnote
)
16975 int addr_size
= is_32bit_elf
? 4 : 8;
16976 char *data
= pnote
->descdata
;
16977 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
16978 bfd_vma pc
, base_addr
, semaphore
;
16979 char *provider
, *probe
, *arg_fmt
;
16981 pc
= byte_get ((unsigned char *) data
, addr_size
);
16983 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
16985 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
16989 data
+= strlen (data
) + 1;
16991 data
+= strlen (data
) + 1;
16993 data
+= strlen (data
) + 1;
16995 printf (_(" Provider: %s\n"), provider
);
16996 printf (_(" Name: %s\n"), probe
);
16997 printf (_(" Location: "));
16998 print_vma (pc
, FULL_HEX
);
16999 printf (_(", Base: "));
17000 print_vma (base_addr
, FULL_HEX
);
17001 printf (_(", Semaphore: "));
17002 print_vma (semaphore
, FULL_HEX
);
17004 printf (_(" Arguments: %s\n"), arg_fmt
);
17006 return data
== data_end
;
17009 static const char *
17010 get_ia64_vms_note_type (unsigned e_type
)
17012 static char buff
[64];
17017 return _("NT_VMS_MHD (module header)");
17019 return _("NT_VMS_LNM (language name)");
17021 return _("NT_VMS_SRC (source files)");
17023 return "NT_VMS_TITLE";
17025 return _("NT_VMS_EIDC (consistency check)");
17026 case NT_VMS_FPMODE
:
17027 return _("NT_VMS_FPMODE (FP mode)");
17028 case NT_VMS_LINKTIME
:
17029 return "NT_VMS_LINKTIME";
17030 case NT_VMS_IMGNAM
:
17031 return _("NT_VMS_IMGNAM (image name)");
17033 return _("NT_VMS_IMGID (image id)");
17034 case NT_VMS_LINKID
:
17035 return _("NT_VMS_LINKID (link id)");
17036 case NT_VMS_IMGBID
:
17037 return _("NT_VMS_IMGBID (build id)");
17038 case NT_VMS_GSTNAM
:
17039 return _("NT_VMS_GSTNAM (sym table name)");
17040 case NT_VMS_ORIG_DYN
:
17041 return "NT_VMS_ORIG_DYN";
17042 case NT_VMS_PATCHTIME
:
17043 return "NT_VMS_PATCHTIME";
17045 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17051 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
17053 switch (pnote
->type
)
17056 if (pnote
->descsz
> 36)
17058 size_t l
= strlen (pnote
->descdata
+ 34);
17059 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
17060 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
17061 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
17062 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
17065 printf (_(" Invalid size\n"));
17068 printf (_(" Language: %s\n"), pnote
->descdata
);
17071 case NT_VMS_FPMODE
:
17072 printf (_(" Floating Point mode: "));
17073 printf ("0x%016" BFD_VMA_FMT
"x\n",
17074 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
17076 case NT_VMS_LINKTIME
:
17077 printf (_(" Link time: "));
17079 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
17082 case NT_VMS_PATCHTIME
:
17083 printf (_(" Patch time: "));
17085 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
17088 case NT_VMS_ORIG_DYN
:
17089 printf (_(" Major id: %u, minor id: %u\n"),
17090 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
17091 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
17092 printf (_(" Last modified : "));
17094 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
17095 printf (_("\n Link flags : "));
17096 printf ("0x%016" BFD_VMA_FMT
"x\n",
17097 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
17098 printf (_(" Header flags: 0x%08x\n"),
17099 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
17100 printf (_(" Image id : %s\n"), pnote
->descdata
+ 32);
17103 case NT_VMS_IMGNAM
:
17104 printf (_(" Image name: %s\n"), pnote
->descdata
);
17106 case NT_VMS_GSTNAM
:
17107 printf (_(" Global symbol table name: %s\n"), pnote
->descdata
);
17110 printf (_(" Image id: %s\n"), pnote
->descdata
);
17112 case NT_VMS_LINKID
:
17113 printf (_(" Linker id: %s\n"), pnote
->descdata
);
17121 /* Print the name of the symbol associated with a build attribute
17122 that is attached to address OFFSET. */
17125 print_symbol_for_build_attribute (FILE * file
,
17126 unsigned long offset
,
17127 bfd_boolean is_open_attr
)
17129 static FILE * saved_file
= NULL
;
17130 static char * strtab
;
17131 static unsigned long strtablen
;
17132 static Elf_Internal_Sym
* symtab
;
17133 static unsigned long nsyms
;
17134 Elf_Internal_Sym
* saved_sym
= NULL
;
17135 Elf_Internal_Sym
* sym
;
17137 if (section_headers
!= NULL
17138 && (saved_file
== NULL
|| file
!= saved_file
))
17140 Elf_Internal_Shdr
* symsec
;
17142 /* Load the symbol and string sections. */
17143 for (symsec
= section_headers
;
17144 symsec
< section_headers
+ elf_header
.e_shnum
;
17147 if (symsec
->sh_type
== SHT_SYMTAB
)
17149 symtab
= GET_ELF_SYMBOLS (file
, symsec
, & nsyms
);
17151 if (symsec
->sh_link
< elf_header
.e_shnum
)
17153 Elf_Internal_Shdr
* strtab_sec
= section_headers
+ symsec
->sh_link
;
17155 strtab
= (char *) get_data (NULL
, file
, strtab_sec
->sh_offset
,
17156 1, strtab_sec
->sh_size
,
17157 _("string table"));
17158 strtablen
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
17165 if (symtab
== NULL
|| strtab
== NULL
)
17171 /* Find a symbol whose value matches offset. */
17172 for (sym
= symtab
; sym
< symtab
+ nsyms
; sym
++)
17173 if (sym
->st_value
== offset
)
17175 if (sym
->st_name
>= strtablen
)
17176 /* Huh ? This should not happen. */
17179 if (strtab
[sym
->st_name
] == 0)
17184 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
17185 and FILE or OBJECT symbols over NOTYPE symbols. We skip
17186 FUNC symbols entirely. */
17187 switch (ELF_ST_TYPE (sym
->st_info
))
17191 /* We can stop searching now. */
17192 sym
= symtab
+ nsyms
;
17200 /* Ignore function symbols. */
17207 switch (ELF_ST_BIND (sym
->st_info
))
17210 if (saved_sym
== NULL
17211 || ELF_ST_TYPE (saved_sym
->st_info
) != STT_OBJECT
)
17216 if (saved_sym
== NULL
)
17226 if (ELF_ST_TYPE (sym
->st_info
) != STT_FUNC
)
17234 printf (" (%s: %s)\n",
17235 is_open_attr
? _("file") : _("func"),
17236 saved_sym
? strtab
+ saved_sym
->st_name
: _("<no symbol found>)"));
17241 print_gnu_build_attribute_description (Elf_Internal_Note
* pnote
,
17244 static unsigned long global_offset
= 0;
17245 unsigned long offset
;
17246 unsigned int desc_size
= is_32bit_elf
? 4 : 8;
17247 bfd_boolean is_open_attr
= pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
;
17249 if (pnote
->descsz
== 0)
17253 printf (_(" Applies from offset %#lx\n"), global_offset
);
17258 printf (_(" Applies to func at %#lx"), global_offset
);
17259 return print_symbol_for_build_attribute (file
, global_offset
, is_open_attr
);
17263 if (pnote
->descsz
!= desc_size
)
17265 error (_(" <invalid description size: %lx>\n"), pnote
->descsz
);
17266 printf (_(" <invalid descsz>"));
17270 offset
= byte_get ((unsigned char *) pnote
->descdata
, desc_size
);
17274 printf (_(" Applies from offset %#lx"), offset
);
17275 global_offset
= offset
;
17279 printf (_(" Applies to func at %#lx"), offset
);
17282 return print_symbol_for_build_attribute (file
, offset
, is_open_attr
);
17286 print_gnu_build_attribute_name (Elf_Internal_Note
* pnote
)
17288 static const char string_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING
, 0 };
17289 static const char number_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
, 0 };
17290 static const char bool_expected
[3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
, 0 };
17292 char name_attribute
;
17293 const char * expected_types
;
17294 const char * name
= pnote
->namedata
;
17298 if (name
== NULL
|| pnote
->namesz
< 2)
17300 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
17301 print_symbol (-20, _(" <corrupt name>"));
17307 /* Version 2 of the spec adds a "GA" prefix to the name field. */
17308 if (name
[0] == 'G' && name
[1] == 'A')
17315 switch ((name_type
= * name
))
17317 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
17318 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
17319 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
17320 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
17321 printf ("%c", * name
);
17325 error (_("unrecognised attribute type in name field: %d\n"), name_type
);
17326 print_symbol (-20, _("<unknown name type>"));
17333 switch ((name_attribute
= * name
))
17335 case GNU_BUILD_ATTRIBUTE_VERSION
:
17336 text
= _("<version>");
17337 expected_types
= string_expected
;
17340 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
17341 text
= _("<stack prot>");
17342 expected_types
= "!+*";
17345 case GNU_BUILD_ATTRIBUTE_RELRO
:
17346 text
= _("<relro>");
17347 expected_types
= bool_expected
;
17350 case GNU_BUILD_ATTRIBUTE_STACK_SIZE
:
17351 text
= _("<stack size>");
17352 expected_types
= number_expected
;
17355 case GNU_BUILD_ATTRIBUTE_TOOL
:
17356 text
= _("<tool>");
17357 expected_types
= string_expected
;
17360 case GNU_BUILD_ATTRIBUTE_ABI
:
17362 expected_types
= "$*";
17365 case GNU_BUILD_ATTRIBUTE_PIC
:
17367 expected_types
= number_expected
;
17370 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM
:
17371 text
= _("<short enum>");
17372 expected_types
= bool_expected
;
17376 if (ISPRINT (* name
))
17378 int len
= strnlen (name
, pnote
->namesz
- (name
- pnote
->namedata
)) + 1;
17380 if (len
> left
&& ! do_wide
)
17382 printf ("%.*s:", len
, name
);
17388 static char tmpbuf
[128];
17390 error (_("unrecognised byte in name field: %d\n"), * name
);
17391 sprintf (tmpbuf
, _("<unknown:_%d>"), * name
);
17395 expected_types
= "*$!+";
17400 left
-= printf ("%s", text
);
17402 if (strchr (expected_types
, name_type
) == NULL
)
17403 warn (_("attribute does not have an expected type (%c)\n"), name_type
);
17405 if ((unsigned long)(name
- pnote
->namedata
) > pnote
->namesz
)
17407 error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
17408 (unsigned long) pnote
->namesz
,
17409 (long) (name
- pnote
->namedata
));
17413 if (left
< 1 && ! do_wide
)
17418 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
17420 unsigned int bytes
;
17421 unsigned long long val
= 0;
17422 unsigned int shift
= 0;
17423 char * decoded
= NULL
;
17425 bytes
= pnote
->namesz
- (name
- pnote
->namedata
);
17427 /* The -1 is because the name field is always 0 terminated, and we
17428 want to be able to ensure that the shift in the while loop below
17429 will not overflow. */
17432 if (bytes
> sizeof (val
))
17434 fprintf (stderr
, "namesz %lx name %p namedata %p\n",
17435 pnote
->namesz
, name
, pnote
->namedata
);
17436 error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
17438 bytes
= sizeof (val
);
17440 /* We do not bother to warn if bytes == 0 as this can
17441 happen with some early versions of the gcc plugin. */
17445 unsigned long byte
= (* name
++) & 0xff;
17447 val
|= byte
<< shift
;
17451 switch (name_attribute
)
17453 case GNU_BUILD_ATTRIBUTE_PIC
:
17456 case 0: decoded
= "static"; break;
17457 case 1: decoded
= "pic"; break;
17458 case 2: decoded
= "PIC"; break;
17459 case 3: decoded
= "pie"; break;
17460 case 4: decoded
= "PIE"; break;
17464 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
17467 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
17468 case 0: decoded
= "off"; break;
17469 case 1: decoded
= "on"; break;
17470 case 2: decoded
= "all"; break;
17471 case 3: decoded
= "strong"; break;
17472 case 4: decoded
= "explicit"; break;
17480 if (decoded
!= NULL
)
17482 print_symbol (-left
, decoded
);
17493 left
-= printf ("0x%llx", val
);
17495 left
-= printf ("0x%-.*llx", left
, val
);
17499 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
17500 left
-= print_symbol (- left
, name
);
17502 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
17503 left
-= print_symbol (- left
, "true");
17505 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
17506 left
-= print_symbol (- left
, "false");
17510 if (do_wide
&& left
> 0)
17511 printf ("%-*s", left
, " ");
17516 /* Note that by the ELF standard, the name field is already null byte
17517 terminated, and namesz includes the terminating null byte.
17518 I.E. the value of namesz for the name "FSF" is 4.
17520 If the value of namesz is zero, there is no name present. */
17523 process_note (Elf_Internal_Note
* pnote
,
17526 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
17529 if (pnote
->namesz
== 0)
17530 /* If there is no note name, then use the default set of
17531 note type strings. */
17532 nt
= get_note_type (pnote
->type
);
17534 else if (const_strneq (pnote
->namedata
, "GNU"))
17535 /* GNU-specific object file notes. */
17536 nt
= get_gnu_elf_note_type (pnote
->type
);
17538 else if (const_strneq (pnote
->namedata
, "FreeBSD"))
17539 /* FreeBSD-specific core file notes. */
17540 nt
= get_freebsd_elfcore_note_type (pnote
->type
);
17542 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
17543 /* NetBSD-specific core file notes. */
17544 nt
= get_netbsd_elfcore_note_type (pnote
->type
);
17546 else if (const_strneq (pnote
->namedata
, "NetBSD"))
17547 /* NetBSD-specific core file notes. */
17548 return process_netbsd_elf_note (pnote
);
17550 else if (strneq (pnote
->namedata
, "SPU/", 4))
17552 /* SPU-specific core file notes. */
17553 nt
= pnote
->namedata
+ 4;
17557 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
17558 /* VMS/ia64-specific file notes. */
17559 nt
= get_ia64_vms_note_type (pnote
->type
);
17561 else if (const_strneq (pnote
->namedata
, "stapsdt"))
17562 nt
= get_stapsdt_note_type (pnote
->type
);
17565 /* Don't recognize this note name; just use the default set of
17566 note type strings. */
17567 nt
= get_note_type (pnote
->type
);
17571 if (((const_strneq (pnote
->namedata
, "GA")
17572 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
17573 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
17574 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
17575 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
17576 print_gnu_build_attribute_name (pnote
);
17578 print_symbol (-20, name
);
17581 printf (" 0x%08lx\t%s\t", pnote
->descsz
, nt
);
17583 printf (" 0x%08lx\t%s\n", pnote
->descsz
, nt
);
17585 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
17586 return print_ia64_vms_note (pnote
);
17587 else if (const_strneq (pnote
->namedata
, "GNU"))
17588 return print_gnu_note (pnote
);
17589 else if (const_strneq (pnote
->namedata
, "stapsdt"))
17590 return print_stapsdt_note (pnote
);
17591 else if (const_strneq (pnote
->namedata
, "CORE"))
17592 return print_core_note (pnote
);
17593 else if (((const_strneq (pnote
->namedata
, "GA")
17594 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
17595 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
17596 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
17597 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
17598 return print_gnu_build_attribute_description (pnote
, file
);
17604 printf (_(" description data: "));
17605 for (i
= 0; i
< pnote
->descsz
; i
++)
17606 printf ("%02x ", pnote
->descdata
[i
]);
17618 process_notes_at (FILE * file
,
17619 Elf_Internal_Shdr
* section
,
17623 Elf_External_Note
* pnotes
;
17624 Elf_External_Note
* external
;
17626 bfd_boolean res
= TRUE
;
17633 pnotes
= (Elf_External_Note
*) get_section_contents (section
, file
);
17636 if (! apply_relocations (file
, section
, (unsigned char *) pnotes
, length
, NULL
, NULL
))
17641 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
17643 if (pnotes
== NULL
)
17649 printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (section
));
17651 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
17652 (unsigned long) offset
, (unsigned long) length
);
17654 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
17656 end
= (char *) pnotes
+ length
;
17657 while ((char *) external
< end
)
17659 Elf_Internal_Note inote
;
17662 char * temp
= NULL
;
17663 size_t data_remaining
= end
- (char *) external
;
17665 if (!is_ia64_vms ())
17667 /* PR binutils/15191
17668 Make sure that there is enough data to read. */
17669 min_notesz
= offsetof (Elf_External_Note
, name
);
17670 if (data_remaining
< min_notesz
)
17672 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
17673 (int) data_remaining
);
17676 data_remaining
-= min_notesz
;
17678 inote
.type
= BYTE_GET (external
->type
);
17679 inote
.namesz
= BYTE_GET (external
->namesz
);
17680 inote
.namedata
= external
->name
;
17681 inote
.descsz
= BYTE_GET (external
->descsz
);
17682 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
17683 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
17684 next
= inote
.descdata
+ align_power (inote
.descsz
, 2);
17688 Elf64_External_VMS_Note
*vms_external
;
17690 /* PR binutils/15191
17691 Make sure that there is enough data to read. */
17692 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
17693 if (data_remaining
< min_notesz
)
17695 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
17696 (int) data_remaining
);
17699 data_remaining
-= min_notesz
;
17701 vms_external
= (Elf64_External_VMS_Note
*) external
;
17702 inote
.type
= BYTE_GET (vms_external
->type
);
17703 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
17704 inote
.namedata
= vms_external
->name
;
17705 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
17706 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
17707 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
17708 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
17711 /* PR 17531: file: 3443835e. */
17712 /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
17713 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
17714 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
17715 || (size_t) (next
- inote
.descdata
) < inote
.descsz
17716 || ((size_t) (next
- inote
.descdata
)
17717 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
17719 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
17720 (unsigned long) ((char *) external
- (char *) pnotes
));
17721 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
17722 inote
.type
, inote
.namesz
, inote
.descsz
);
17726 external
= (Elf_External_Note
*) next
;
17728 /* Verify that name is null terminated. It appears that at least
17729 one version of Linux (RedHat 6.0) generates corefiles that don't
17730 comply with the ELF spec by failing to include the null byte in
17732 if (inote
.namedata
[inote
.namesz
- 1] != '\0')
17734 if ((size_t) (inote
.descdata
- inote
.namedata
) == inote
.namesz
)
17736 temp
= (char *) malloc (inote
.namesz
+ 1);
17739 error (_("Out of memory allocating space for inote name\n"));
17744 memcpy (temp
, inote
.namedata
, inote
.namesz
);
17745 inote
.namedata
= temp
;
17747 inote
.namedata
[inote
.namesz
] = 0;
17750 if (! process_note (& inote
, file
))
17766 process_corefile_note_segments (FILE * file
)
17768 Elf_Internal_Phdr
* segment
;
17770 bfd_boolean res
= TRUE
;
17772 if (! get_program_headers (file
))
17775 for (i
= 0, segment
= program_headers
;
17776 i
< elf_header
.e_phnum
;
17779 if (segment
->p_type
== PT_NOTE
)
17780 if (! process_notes_at (file
, NULL
,
17781 (bfd_vma
) segment
->p_offset
,
17782 (bfd_vma
) segment
->p_filesz
))
17790 process_v850_notes (FILE * file
, bfd_vma offset
, bfd_vma length
)
17792 Elf_External_Note
* pnotes
;
17793 Elf_External_Note
* external
;
17795 bfd_boolean res
= TRUE
;
17800 pnotes
= (Elf_External_Note
*) get_data (NULL
, file
, offset
, 1, length
,
17802 if (pnotes
== NULL
)
17806 end
= (char*) pnotes
+ length
;
17808 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
17809 (unsigned long) offset
, (unsigned long) length
);
17811 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
17813 Elf_External_Note
* next
;
17814 Elf_Internal_Note inote
;
17816 inote
.type
= BYTE_GET (external
->type
);
17817 inote
.namesz
= BYTE_GET (external
->namesz
);
17818 inote
.namedata
= external
->name
;
17819 inote
.descsz
= BYTE_GET (external
->descsz
);
17820 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
17821 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
17823 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
17825 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
17826 inote
.descdata
= inote
.namedata
;
17830 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
17832 if ( ((char *) next
> end
)
17833 || ((char *) next
< (char *) pnotes
))
17835 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
17836 (unsigned long) ((char *) external
- (char *) pnotes
));
17837 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
17838 inote
.type
, inote
.namesz
, inote
.descsz
);
17844 /* Prevent out-of-bounds indexing. */
17845 if ( inote
.namedata
+ inote
.namesz
> end
17846 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
17848 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
17849 (unsigned long) ((char *) external
- (char *) pnotes
));
17850 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
17851 inote
.type
, inote
.namesz
, inote
.descsz
);
17855 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
17857 if (! print_v850_note (& inote
))
17860 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
17861 inote
.namesz
, inote
.descsz
);
17871 process_note_sections (FILE * file
)
17873 Elf_Internal_Shdr
* section
;
17875 unsigned int n
= 0;
17876 bfd_boolean res
= TRUE
;
17878 for (i
= 0, section
= section_headers
;
17879 i
< elf_header
.e_shnum
&& section
!= NULL
;
17882 if (section
->sh_type
== SHT_NOTE
)
17884 if (! process_notes_at (file
, section
,
17885 (bfd_vma
) section
->sh_offset
,
17886 (bfd_vma
) section
->sh_size
))
17891 if (( elf_header
.e_machine
== EM_V800
17892 || elf_header
.e_machine
== EM_V850
17893 || elf_header
.e_machine
== EM_CYGNUS_V850
)
17894 && section
->sh_type
== SHT_RENESAS_INFO
)
17896 if (! process_v850_notes (file
,
17897 (bfd_vma
) section
->sh_offset
,
17898 (bfd_vma
) section
->sh_size
))
17905 /* Try processing NOTE segments instead. */
17906 return process_corefile_note_segments (file
);
17912 process_notes (FILE * file
)
17914 /* If we have not been asked to display the notes then do nothing. */
17918 if (elf_header
.e_type
!= ET_CORE
)
17919 return process_note_sections (file
);
17921 /* No program headers means no NOTE segment. */
17922 if (elf_header
.e_phnum
> 0)
17923 return process_corefile_note_segments (file
);
17925 printf (_("No note segments present in the core file.\n"));
17929 static unsigned char *
17930 display_public_gnu_attributes (unsigned char * start
,
17931 const unsigned char * const end
)
17933 printf (_(" Unknown GNU attribute: %s\n"), start
);
17935 start
+= strnlen ((char *) start
, end
- start
);
17936 display_raw_attribute (start
, end
);
17938 return (unsigned char *) end
;
17941 static unsigned char *
17942 display_generic_attribute (unsigned char * start
,
17944 const unsigned char * const end
)
17947 return (unsigned char *) end
;
17949 return display_tag_value (tag
, start
, end
);
17953 process_arch_specific (FILE * file
)
17958 switch (elf_header
.e_machine
)
17961 case EM_ARC_COMPACT
:
17962 case EM_ARC_COMPACT2
:
17963 return process_attributes (file
, "ARC", SHT_ARC_ATTRIBUTES
,
17964 display_arc_attribute
,
17965 display_generic_attribute
);
17967 return process_attributes (file
, "aeabi", SHT_ARM_ATTRIBUTES
,
17968 display_arm_attribute
,
17969 display_generic_attribute
);
17972 case EM_MIPS_RS3_LE
:
17973 return process_mips_specific (file
);
17976 return process_attributes (file
, "mspabi", SHT_MSP430_ATTRIBUTES
,
17977 display_msp430x_attribute
,
17978 display_generic_attribute
);
17981 return process_nds32_specific (file
);
17985 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
17986 display_power_gnu_attribute
);
17990 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
17991 display_s390_gnu_attribute
);
17994 case EM_SPARC32PLUS
:
17996 return process_attributes (file
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
17997 display_sparc_gnu_attribute
);
18000 return process_attributes (file
, "c6xabi", SHT_C6000_ATTRIBUTES
,
18001 display_tic6x_attribute
,
18002 display_generic_attribute
);
18005 return process_attributes (file
, "gnu", SHT_GNU_ATTRIBUTES
,
18006 display_public_gnu_attributes
,
18007 display_generic_attribute
);
18012 get_file_header (FILE * file
)
18014 /* Read in the identity array. */
18015 if (fread (elf_header
.e_ident
, EI_NIDENT
, 1, file
) != 1)
18018 /* Determine how to read the rest of the header. */
18019 switch (elf_header
.e_ident
[EI_DATA
])
18024 byte_get
= byte_get_little_endian
;
18025 byte_put
= byte_put_little_endian
;
18028 byte_get
= byte_get_big_endian
;
18029 byte_put
= byte_put_big_endian
;
18033 /* For now we only support 32 bit and 64 bit ELF files. */
18034 is_32bit_elf
= (elf_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
18036 /* Read in the rest of the header. */
18039 Elf32_External_Ehdr ehdr32
;
18041 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, file
) != 1)
18044 elf_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
18045 elf_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
18046 elf_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
18047 elf_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
18048 elf_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
18049 elf_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
18050 elf_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
18051 elf_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
18052 elf_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
18053 elf_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
18054 elf_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
18055 elf_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
18056 elf_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
18060 Elf64_External_Ehdr ehdr64
;
18062 /* If we have been compiled with sizeof (bfd_vma) == 4, then
18063 we will not be able to cope with the 64bit data found in
18064 64 ELF files. Detect this now and abort before we start
18065 overwriting things. */
18066 if (sizeof (bfd_vma
) < 8)
18068 error (_("This instance of readelf has been built without support for a\n\
18069 64 bit data type and so it cannot read 64 bit ELF files.\n"));
18073 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, file
) != 1)
18076 elf_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
18077 elf_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
18078 elf_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
18079 elf_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
18080 elf_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
18081 elf_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
18082 elf_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
18083 elf_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
18084 elf_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
18085 elf_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
18086 elf_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
18087 elf_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
18088 elf_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
18091 if (elf_header
.e_shoff
)
18093 /* There may be some extensions in the first section header. Don't
18094 bomb if we can't read it. */
18096 get_32bit_section_headers (file
, TRUE
);
18098 get_64bit_section_headers (file
, TRUE
);
18104 /* Process one ELF object file according to the command line options.
18105 This file may actually be stored in an archive. The file is
18106 positioned at the start of the ELF object. Returns TRUE if no
18107 problems were encountered, FALSE otherwise. */
18110 process_object (char * file_name
, FILE * file
)
18113 bfd_boolean res
= TRUE
;
18115 if (! get_file_header (file
))
18117 error (_("%s: Failed to read file header\n"), file_name
);
18121 /* Initialise per file variables. */
18122 for (i
= ARRAY_SIZE (version_info
); i
--;)
18123 version_info
[i
] = 0;
18125 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
18126 dynamic_info
[i
] = 0;
18127 dynamic_info_DT_GNU_HASH
= 0;
18129 /* Process the file. */
18131 printf (_("\nFile: %s\n"), file_name
);
18133 /* Initialise the dump_sects array from the cmdline_dump_sects array.
18134 Note we do this even if cmdline_dump_sects is empty because we
18135 must make sure that the dump_sets array is zeroed out before each
18136 object file is processed. */
18137 if (num_dump_sects
> num_cmdline_dump_sects
)
18138 memset (dump_sects
, 0, num_dump_sects
* sizeof (* dump_sects
));
18140 if (num_cmdline_dump_sects
> 0)
18142 if (num_dump_sects
== 0)
18143 /* A sneaky way of allocating the dump_sects array. */
18144 request_dump_bynumber (num_cmdline_dump_sects
, 0);
18146 assert (num_dump_sects
>= num_cmdline_dump_sects
);
18147 memcpy (dump_sects
, cmdline_dump_sects
,
18148 num_cmdline_dump_sects
* sizeof (* dump_sects
));
18151 if (! process_file_header ())
18154 if (! process_section_headers (file
))
18156 /* Without loaded section headers we cannot process lots of things. */
18157 do_unwind
= do_version
= do_dump
= do_arch
= FALSE
;
18159 if (! do_using_dynamic
)
18160 do_syms
= do_dyn_syms
= do_reloc
= FALSE
;
18163 if (! process_section_groups (file
))
18164 /* Without loaded section groups we cannot process unwind. */
18167 if (process_program_headers (file
))
18168 process_dynamic_section (file
);
18172 if (! process_relocs (file
))
18175 if (! process_unwind (file
))
18178 if (! process_symbol_table (file
))
18181 if (! process_syminfo (file
))
18184 if (! process_version_sections (file
))
18187 if (! process_section_contents (file
))
18190 if (! process_notes (file
))
18193 if (! process_gnu_liblist (file
))
18196 if (! process_arch_specific (file
))
18199 if (program_headers
)
18201 free (program_headers
);
18202 program_headers
= NULL
;
18205 if (section_headers
)
18207 free (section_headers
);
18208 section_headers
= NULL
;
18213 free (string_table
);
18214 string_table
= NULL
;
18215 string_table_length
= 0;
18218 if (dynamic_strings
)
18220 free (dynamic_strings
);
18221 dynamic_strings
= NULL
;
18222 dynamic_strings_length
= 0;
18225 if (dynamic_symbols
)
18227 free (dynamic_symbols
);
18228 dynamic_symbols
= NULL
;
18229 num_dynamic_syms
= 0;
18232 if (dynamic_syminfo
)
18234 free (dynamic_syminfo
);
18235 dynamic_syminfo
= NULL
;
18238 if (dynamic_section
)
18240 free (dynamic_section
);
18241 dynamic_section
= NULL
;
18244 if (section_headers_groups
)
18246 free (section_headers_groups
);
18247 section_headers_groups
= NULL
;
18250 if (section_groups
)
18252 struct group_list
* g
;
18253 struct group_list
* next
;
18255 for (i
= 0; i
< group_count
; i
++)
18257 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
18264 free (section_groups
);
18265 section_groups
= NULL
;
18268 free_debug_memory ();
18273 /* Process an ELF archive.
18274 On entry the file is positioned just after the ARMAG string.
18275 Returns TRUE upon success, FALSE otherwise. */
18278 process_archive (char * file_name
, FILE * file
, bfd_boolean is_thin_archive
)
18280 struct archive_info arch
;
18281 struct archive_info nested_arch
;
18283 bfd_boolean ret
= TRUE
;
18287 /* The ARCH structure is used to hold information about this archive. */
18288 arch
.file_name
= NULL
;
18290 arch
.index_array
= NULL
;
18291 arch
.sym_table
= NULL
;
18292 arch
.longnames
= NULL
;
18294 /* The NESTED_ARCH structure is used as a single-item cache of information
18295 about a nested archive (when members of a thin archive reside within
18296 another regular archive file). */
18297 nested_arch
.file_name
= NULL
;
18298 nested_arch
.file
= NULL
;
18299 nested_arch
.index_array
= NULL
;
18300 nested_arch
.sym_table
= NULL
;
18301 nested_arch
.longnames
= NULL
;
18303 if (setup_archive (&arch
, file_name
, file
, is_thin_archive
, do_archive_index
) != 0)
18309 if (do_archive_index
)
18311 if (arch
.sym_table
== NULL
)
18312 error (_("%s: unable to dump the index as none was found\n"), file_name
);
18315 unsigned long i
, l
;
18316 unsigned long current_pos
;
18318 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
18319 file_name
, (unsigned long) arch
.index_num
, arch
.sym_size
);
18320 current_pos
= ftell (file
);
18322 for (i
= l
= 0; i
< arch
.index_num
; i
++)
18324 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
18326 char * member_name
;
18328 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
18330 if (member_name
!= NULL
)
18332 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
18334 if (qualified_name
!= NULL
)
18336 printf (_("Contents of binary %s at offset "), qualified_name
);
18337 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
18339 free (qualified_name
);
18344 if (l
>= arch
.sym_size
)
18346 error (_("%s: end of the symbol table reached before the end of the index\n"),
18351 /* PR 17531: file: 0b6630b2. */
18352 printf ("\t%.*s\n", (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
18353 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
18356 if (arch
.uses_64bit_indicies
)
18361 if (l
< arch
.sym_size
)
18363 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
18364 file_name
, arch
.sym_size
- l
);
18368 if (fseek (file
, current_pos
, SEEK_SET
) != 0)
18370 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name
);
18376 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
18377 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
18378 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
18379 && !do_section_groups
&& !do_dyn_syms
)
18381 ret
= TRUE
; /* Archive index only. */
18390 char * qualified_name
;
18392 /* Read the next archive header. */
18393 if (fseek (file
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
18395 error (_("%s: failed to seek to next archive header\n"), file_name
);
18398 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, file
);
18399 if (got
!= sizeof arch
.arhdr
)
18403 error (_("%s: failed to read archive header\n"), file_name
);
18407 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
18409 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
18414 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
18416 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
18417 if (archive_file_size
& 01)
18418 ++archive_file_size
;
18420 name
= get_archive_member_name (&arch
, &nested_arch
);
18423 error (_("%s: bad archive file name\n"), file_name
);
18427 namelen
= strlen (name
);
18429 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
18430 if (qualified_name
== NULL
)
18432 error (_("%s: bad archive file name\n"), file_name
);
18437 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
18439 /* This is a proxy for an external member of a thin archive. */
18440 FILE * member_file
;
18441 char * member_file_name
= adjust_relative_path (file_name
, name
, namelen
);
18443 if (member_file_name
== NULL
)
18449 member_file
= fopen (member_file_name
, "rb");
18450 if (member_file
== NULL
)
18452 error (_("Input file '%s' is not readable.\n"), member_file_name
);
18453 free (member_file_name
);
18458 archive_file_offset
= arch
.nested_member_origin
;
18460 if (! process_object (qualified_name
, member_file
))
18463 fclose (member_file
);
18464 free (member_file_name
);
18466 else if (is_thin_archive
)
18468 /* PR 15140: Allow for corrupt thin archives. */
18469 if (nested_arch
.file
== NULL
)
18471 error (_("%s: contains corrupt thin archive: %s\n"),
18477 /* This is a proxy for a member of a nested archive. */
18478 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
18480 /* The nested archive file will have been opened and setup by
18481 get_archive_member_name. */
18482 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
18484 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
18489 if (! process_object (qualified_name
, nested_arch
.file
))
18494 archive_file_offset
= arch
.next_arhdr_offset
;
18495 arch
.next_arhdr_offset
+= archive_file_size
;
18497 if (! process_object (qualified_name
, file
))
18501 if (dump_sects
!= NULL
)
18505 num_dump_sects
= 0;
18508 free (qualified_name
);
18512 if (nested_arch
.file
!= NULL
)
18513 fclose (nested_arch
.file
);
18514 release_archive (&nested_arch
);
18515 release_archive (&arch
);
18521 process_file (char * file_name
)
18524 struct stat statbuf
;
18525 char armag
[SARMAG
];
18526 bfd_boolean ret
= TRUE
;
18528 if (stat (file_name
, &statbuf
) < 0)
18530 if (errno
== ENOENT
)
18531 error (_("'%s': No such file\n"), file_name
);
18533 error (_("Could not locate '%s'. System error message: %s\n"),
18534 file_name
, strerror (errno
));
18538 if (! S_ISREG (statbuf
.st_mode
))
18540 error (_("'%s' is not an ordinary file\n"), file_name
);
18544 file
= fopen (file_name
, "rb");
18547 error (_("Input file '%s' is not readable.\n"), file_name
);
18551 if (fread (armag
, SARMAG
, 1, file
) != 1)
18553 error (_("%s: Failed to read file's magic number\n"), file_name
);
18558 current_file_size
= (bfd_size_type
) statbuf
.st_size
;
18560 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
18562 if (! process_archive (file_name
, file
, FALSE
))
18565 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
18567 if ( ! process_archive (file_name
, file
, TRUE
))
18572 if (do_archive_index
)
18573 error (_("File %s is not an archive so its index cannot be displayed.\n"),
18577 archive_file_size
= archive_file_offset
= 0;
18579 if (! process_object (file_name
, file
))
18584 current_file_size
= 0;
18589 #ifdef SUPPORT_DISASSEMBLY
18590 /* Needed by the i386 disassembler. For extra credit, someone could
18591 fix this so that we insert symbolic addresses here, esp for GOT/PLT
18595 print_address (unsigned int addr
, FILE * outfile
)
18597 fprintf (outfile
,"0x%8.8x", addr
);
18600 /* Needed by the i386 disassembler. */
18602 db_task_printsym (unsigned int addr
)
18604 print_address (addr
, stderr
);
18609 main (int argc
, char ** argv
)
18613 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
18614 setlocale (LC_MESSAGES
, "");
18616 #if defined (HAVE_SETLOCALE)
18617 setlocale (LC_CTYPE
, "");
18619 bindtextdomain (PACKAGE
, LOCALEDIR
);
18620 textdomain (PACKAGE
);
18622 expandargv (&argc
, &argv
);
18624 parse_args (argc
, argv
);
18626 if (num_dump_sects
> 0)
18628 /* Make a copy of the dump_sects array. */
18629 cmdline_dump_sects
= (dump_type
*)
18630 malloc (num_dump_sects
* sizeof (* dump_sects
));
18631 if (cmdline_dump_sects
== NULL
)
18632 error (_("Out of memory allocating dump request table.\n"));
18635 memcpy (cmdline_dump_sects
, dump_sects
,
18636 num_dump_sects
* sizeof (* dump_sects
));
18637 num_cmdline_dump_sects
= num_dump_sects
;
18641 if (optind
< (argc
- 1))
18643 else if (optind
>= argc
)
18645 warn (_("Nothing to do.\n"));
18650 while (optind
< argc
)
18651 if (! process_file (argv
[optind
++]))
18654 if (dump_sects
!= NULL
)
18656 if (cmdline_dump_sects
!= NULL
)
18657 free (cmdline_dump_sects
);
18659 return err
? EXIT_FAILURE
: EXIT_SUCCESS
;