1 /* readelf.c -- display contents of an ELF format file
2 Copyright (C) 1998-2018 Free Software Foundation, Inc.
4 Originally developed by Eric Youngdale <eric@andante.jic.com>
5 Modifications by Nick Clifton <nickc@redhat.com>
7 This file is part of GNU Binutils.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
24 /* The difference between readelf and objdump:
26 Both programs are capable of displaying the contents of ELF format files,
27 so why does the binutils project have two file dumpers ?
29 The reason is that objdump sees an ELF file through a BFD filter of the
30 world; if BFD has a bug where, say, it disagrees about a machine constant
31 in e_flags, then the odds are good that it will remain internally
32 consistent. The linker sees it the BFD way, objdump sees it the BFD way,
33 GAS sees it the BFD way. There was need for a tool to go find out what
34 the file actually says.
36 This is why the readelf program does not link against the BFD library - it
37 exists as an independent program to help verify the correct working of BFD.
39 There is also the case that readelf can provide more information about an
40 ELF file than is provided by objdump. In particular it can display DWARF
41 debugging information which (at the moment) objdump cannot. */
52 /* Define BFD64 here, even if our default architecture is 32 bit ELF
53 as this will allow us to read in and parse 64bit and 32bit ELF files.
54 Only do this if we believe that the compiler can support a 64 bit
55 data type. For now we only rely on GCC being able to do this. */
64 #include "elf/common.h"
65 #include "elf/external.h"
66 #include "elf/internal.h"
69 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
70 we can obtain the H8 reloc numbers. We need these for the
71 get_reloc_size() function. We include h8.h again after defining
72 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
77 /* Undo the effects of #including reloc-macros.h. */
79 #undef START_RELOC_NUMBERS
83 #undef END_RELOC_NUMBERS
84 #undef _RELOC_MACROS_H
86 /* The following headers use the elf/reloc-macros.h file to
87 automatically generate relocation recognition functions
88 such as elf_mips_reloc_type() */
90 #define RELOC_MACROS_GEN_FUNC
92 #include "elf/aarch64.h"
93 #include "elf/alpha.h"
101 #include "elf/d10v.h"
102 #include "elf/d30v.h"
104 #include "elf/epiphany.h"
105 #include "elf/fr30.h"
107 #include "elf/ft32.h"
109 #include "elf/hppa.h"
110 #include "elf/i386.h"
111 #include "elf/i370.h"
112 #include "elf/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/mmix.h"
128 #include "elf/mn10200.h"
129 #include "elf/mn10300.h"
130 #include "elf/moxie.h"
132 #include "elf/msp430.h"
133 #include "elf/nds32.h"
135 #include "elf/nios2.h"
136 #include "elf/or1k.h"
139 #include "elf/ppc64.h"
141 #include "elf/riscv.h"
142 #include "elf/rl78.h"
144 #include "elf/s390.h"
145 #include "elf/score.h"
147 #include "elf/sparc.h"
149 #include "elf/tic6x.h"
150 #include "elf/tilegx.h"
151 #include "elf/tilepro.h"
152 #include "elf/v850.h"
154 #include "elf/visium.h"
155 #include "elf/wasm32.h"
156 #include "elf/x86-64.h"
157 #include "elf/xc16x.h"
158 #include "elf/xgate.h"
159 #include "elf/xstormy16.h"
160 #include "elf/xtensa.h"
163 #include "libiberty.h"
164 #include "safe-ctype.h"
165 #include "filenames.h"
168 #define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
171 typedef struct elf_section_list
173 Elf_Internal_Shdr
* hdr
;
174 struct elf_section_list
* next
;
177 /* Flag bits indicating particular types of dump. */
178 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
179 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
180 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
181 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
182 #define RELOC_DUMP (1 << 4) /* The -R command line switch. */
184 typedef unsigned char dump_type
;
186 /* A linked list of the section names for which dumps were requested. */
187 struct dump_list_entry
191 struct dump_list_entry
* next
;
194 typedef struct filedata
196 const char * file_name
;
198 bfd_size_type file_size
;
199 Elf_Internal_Ehdr file_header
;
200 Elf_Internal_Shdr
* section_headers
;
201 Elf_Internal_Phdr
* program_headers
;
203 unsigned long string_table_length
;
204 /* A dynamic array of flags indicating for which sections a dump of
205 some kind has been requested. It is reset on a per-object file
206 basis and then initialised from the cmdline_dump_sects array,
207 the results of interpreting the -w switch, and the
208 dump_sects_byname list. */
209 dump_type
* dump_sects
;
210 unsigned int num_dump_sects
;
213 char * program_name
= "readelf";
215 static unsigned long archive_file_offset
;
216 static unsigned long archive_file_size
;
217 static unsigned long dynamic_addr
;
218 static bfd_size_type dynamic_size
;
219 static size_t dynamic_nent
;
220 static char * dynamic_strings
;
221 static unsigned long dynamic_strings_length
;
222 static unsigned long num_dynamic_syms
;
223 static Elf_Internal_Sym
* dynamic_symbols
;
224 static Elf_Internal_Syminfo
* dynamic_syminfo
;
225 static unsigned long dynamic_syminfo_offset
;
226 static unsigned int dynamic_syminfo_nent
;
227 static char program_interpreter
[PATH_MAX
];
228 static bfd_vma dynamic_info
[DT_ENCODING
];
229 static bfd_vma dynamic_info_DT_GNU_HASH
;
230 static bfd_vma version_info
[16];
231 static Elf_Internal_Dyn
* dynamic_section
;
232 static elf_section_list
* symtab_shndx_list
;
233 static bfd_boolean show_name
= FALSE
;
234 static bfd_boolean do_dynamic
= FALSE
;
235 static bfd_boolean do_syms
= FALSE
;
236 static bfd_boolean do_dyn_syms
= FALSE
;
237 static bfd_boolean do_reloc
= FALSE
;
238 static bfd_boolean do_sections
= FALSE
;
239 static bfd_boolean do_section_groups
= FALSE
;
240 static bfd_boolean do_section_details
= FALSE
;
241 static bfd_boolean do_segments
= FALSE
;
242 static bfd_boolean do_unwind
= FALSE
;
243 static bfd_boolean do_using_dynamic
= FALSE
;
244 static bfd_boolean do_header
= FALSE
;
245 static bfd_boolean do_dump
= FALSE
;
246 static bfd_boolean do_version
= FALSE
;
247 static bfd_boolean do_histogram
= FALSE
;
248 static bfd_boolean do_debugging
= FALSE
;
249 static bfd_boolean do_arch
= FALSE
;
250 static bfd_boolean do_notes
= FALSE
;
251 static bfd_boolean do_archive_index
= FALSE
;
252 static bfd_boolean is_32bit_elf
= FALSE
;
253 static bfd_boolean decompress_dumps
= FALSE
;
257 struct group_list
* next
;
258 unsigned int section_index
;
263 struct group_list
* root
;
264 unsigned int group_index
;
267 static size_t group_count
;
268 static struct group
* section_groups
;
269 static struct group
** section_headers_groups
;
271 /* A dynamic array of flags indicating for which sections a dump
272 has been requested via command line switches. */
273 static Filedata cmdline
;
275 static struct dump_list_entry
* dump_sects_byname
;
277 /* How to print a vma value. */
278 typedef enum print_mode
290 /* Versioned symbol info. */
291 enum versioned_symbol_info
298 static const char * get_symbol_version_string
299 (Filedata
*, bfd_boolean
, const char *, unsigned long, unsigned,
300 Elf_Internal_Sym
*, enum versioned_symbol_info
*, unsigned short *);
304 #define SECTION_NAME(X) \
305 ((X) == NULL ? _("<none>") \
306 : filedata->string_table == NULL ? _("<no-strings>") \
307 : ((X)->sh_name >= filedata->string_table_length ? _("<corrupt>") \
308 : filedata->string_table + (X)->sh_name))
310 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
312 #define GET_ELF_SYMBOLS(file, section, sym_count) \
313 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
314 : get_64bit_elf_symbols (file, section, sym_count))
316 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
317 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
318 already been called and verified that the string exists. */
319 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
321 #define REMOVE_ARCH_BITS(ADDR) \
324 if (filedata->file_header.e_machine == EM_ARM) \
329 /* Print a BFD_VMA to an internal buffer, for use in error messages.
330 BFD_FMA_FMT can't be used in translated strings. */
333 bfd_vmatoa (char *fmtch
, bfd_vma value
)
335 /* bfd_vmatoa is used more then once in a printf call for output.
336 Cycle through an array of buffers. */
337 static int buf_pos
= 0;
338 static struct bfd_vmatoa_buf
345 ret
= buf
[buf_pos
++].place
;
346 buf_pos
%= ARRAY_SIZE (buf
);
348 sprintf (fmt
, "%%%s%s", BFD_VMA_FMT
, fmtch
);
349 snprintf (ret
, sizeof (buf
[0].place
), fmt
, value
);
353 /* Retrieve NMEMB structures, each SIZE bytes long from FILEDATA starting at
354 OFFSET + the offset of the current archive member, if we are examining an
355 archive. Put the retrieved data into VAR, if it is not NULL. Otherwise
356 allocate a buffer using malloc and fill that. In either case return the
357 pointer to the start of the retrieved data or NULL if something went wrong.
358 If something does go wrong and REASON is not NULL then emit an error
359 message using REASON as part of the context. */
362 get_data (void * var
,
364 unsigned long offset
,
370 bfd_size_type amt
= size
* nmemb
;
372 if (size
== 0 || nmemb
== 0)
375 /* If the size_t type is smaller than the bfd_size_type, eg because
376 you are building a 32-bit tool on a 64-bit host, then make sure
377 that when the sizes are cast to (size_t) no information is lost. */
378 if (sizeof (size_t) < sizeof (bfd_size_type
)
379 && ( (bfd_size_type
) ((size_t) size
) != size
380 || (bfd_size_type
) ((size_t) nmemb
) != nmemb
))
383 error (_("Size truncation prevents reading %s"
384 " elements of size %s for %s\n"),
385 bfd_vmatoa ("u", nmemb
), bfd_vmatoa ("u", size
), reason
);
389 /* Check for size overflow. */
393 error (_("Size overflow prevents reading %s"
394 " elements of size %s for %s\n"),
395 bfd_vmatoa ("u", nmemb
), bfd_vmatoa ("u", size
), reason
);
399 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
400 attempting to allocate memory when the read is bound to fail. */
401 if (amt
> filedata
->file_size
402 || offset
+ archive_file_offset
+ amt
> filedata
->file_size
)
405 error (_("Reading %s bytes extends past end of file for %s\n"),
406 bfd_vmatoa ("u", amt
), reason
);
410 if (fseek (filedata
->handle
, archive_file_offset
+ offset
, SEEK_SET
))
413 error (_("Unable to seek to 0x%lx for %s\n"),
414 archive_file_offset
+ offset
, reason
);
421 /* Check for overflow. */
422 if (nmemb
< (~(bfd_size_type
) 0 - 1) / size
)
423 /* + 1 so that we can '\0' terminate invalid string table sections. */
424 mvar
= malloc ((size_t) amt
+ 1);
429 error (_("Out of memory allocating %s bytes for %s\n"),
430 bfd_vmatoa ("u", amt
), reason
);
434 ((char *) mvar
)[amt
] = '\0';
437 if (fread (mvar
, (size_t) size
, (size_t) nmemb
, filedata
->handle
) != nmemb
)
440 error (_("Unable to read in %s bytes of %s\n"),
441 bfd_vmatoa ("u", amt
), reason
);
450 /* Print a VMA value in the MODE specified.
451 Returns the number of characters displayed. */
454 print_vma (bfd_vma vma
, print_mode mode
)
466 return nc
+ printf ("%8.8" BFD_VMA_FMT
"x", vma
);
473 return printf ("%5" BFD_VMA_FMT
"d", vma
);
479 return nc
+ printf ("%" BFD_VMA_FMT
"x", vma
);
482 return printf ("%" BFD_VMA_FMT
"d", vma
);
485 return printf ("%" BFD_VMA_FMT
"u", vma
);
488 /* FIXME: Report unrecognised mode ? */
493 /* Display a symbol on stdout. Handles the display of control characters and
494 multibye characters (assuming the host environment supports them).
496 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
498 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
499 padding as necessary.
501 Returns the number of emitted characters. */
504 print_symbol (signed int width
, const char *symbol
)
506 bfd_boolean extra_padding
= FALSE
;
507 signed int num_printed
= 0;
508 #ifdef HAVE_MBSTATE_T
511 unsigned int width_remaining
;
515 /* Keep the width positive. This helps the code below. */
517 extra_padding
= TRUE
;
523 /* Set the remaining width to a very large value.
524 This simplifies the code below. */
525 width_remaining
= INT_MAX
;
527 width_remaining
= width
;
529 #ifdef HAVE_MBSTATE_T
530 /* Initialise the multibyte conversion state. */
531 memset (& state
, 0, sizeof (state
));
534 while (width_remaining
)
537 const char c
= *symbol
++;
542 /* Do not print control characters directly as they can affect terminal
543 settings. Such characters usually appear in the names generated
544 by the assembler for local labels. */
547 if (width_remaining
< 2)
550 printf ("^%c", c
+ 0x40);
551 width_remaining
-= 2;
554 else if (ISPRINT (c
))
562 #ifdef HAVE_MBSTATE_T
565 /* Let printf do the hard work of displaying multibyte characters. */
566 printf ("%.1s", symbol
- 1);
570 #ifdef HAVE_MBSTATE_T
571 /* Try to find out how many bytes made up the character that was
572 just printed. Advance the symbol pointer past the bytes that
574 n
= mbrtowc (& w
, symbol
- 1, MB_CUR_MAX
, & state
);
578 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
583 if (extra_padding
&& num_printed
< width
)
585 /* Fill in the remaining spaces. */
586 printf ("%-*s", width
- num_printed
, " ");
593 /* Returns a pointer to a static buffer containing a printable version of
594 the given section's name. Like print_symbol, except that it does not try
595 to print multibyte characters, it just interprets them as hex values. */
598 printable_section_name (Filedata
* filedata
, const Elf_Internal_Shdr
* sec
)
600 #define MAX_PRINT_SEC_NAME_LEN 128
601 static char sec_name_buf
[MAX_PRINT_SEC_NAME_LEN
+ 1];
602 const char * name
= SECTION_NAME (sec
);
603 char * buf
= sec_name_buf
;
605 unsigned int remaining
= MAX_PRINT_SEC_NAME_LEN
;
607 while ((c
= * name
++) != 0)
618 else if (ISPRINT (c
))
625 static char hex
[17] = "0123456789ABCDEF";
630 * buf
++ = hex
[(c
& 0xf0) >> 4];
631 * buf
++ = hex
[c
& 0x0f];
645 printable_section_name_from_index (Filedata
* filedata
, unsigned long ndx
)
647 if (ndx
>= filedata
->file_header
.e_shnum
)
648 return _("<corrupt>");
650 return printable_section_name (filedata
, filedata
->section_headers
+ ndx
);
653 /* Return a pointer to section NAME, or NULL if no such section exists. */
655 static Elf_Internal_Shdr
*
656 find_section (Filedata
* filedata
, const char * name
)
660 if (filedata
->section_headers
== NULL
)
663 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
664 if (streq (SECTION_NAME (filedata
->section_headers
+ i
), name
))
665 return filedata
->section_headers
+ i
;
670 /* Return a pointer to a section containing ADDR, or NULL if no such
673 static Elf_Internal_Shdr
*
674 find_section_by_address (Filedata
* filedata
, bfd_vma addr
)
678 if (filedata
->section_headers
== NULL
)
681 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
683 Elf_Internal_Shdr
*sec
= filedata
->section_headers
+ i
;
685 if (addr
>= sec
->sh_addr
&& addr
< sec
->sh_addr
+ sec
->sh_size
)
692 static Elf_Internal_Shdr
*
693 find_section_by_type (Filedata
* filedata
, unsigned int type
)
697 if (filedata
->section_headers
== NULL
)
700 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
702 Elf_Internal_Shdr
*sec
= filedata
->section_headers
+ i
;
704 if (sec
->sh_type
== type
)
711 /* Return a pointer to section NAME, or NULL if no such section exists,
712 restricted to the list of sections given in SET. */
714 static Elf_Internal_Shdr
*
715 find_section_in_set (Filedata
* filedata
, const char * name
, unsigned int * set
)
719 if (filedata
->section_headers
== NULL
)
724 while ((i
= *set
++) > 0)
726 /* See PR 21156 for a reproducer. */
727 if (i
>= filedata
->file_header
.e_shnum
)
728 continue; /* FIXME: Should we issue an error message ? */
730 if (streq (SECTION_NAME (filedata
->section_headers
+ i
), name
))
731 return filedata
->section_headers
+ i
;
735 return find_section (filedata
, name
);
738 /* Read an unsigned LEB128 encoded value from DATA.
739 Set *LENGTH_RETURN to the number of bytes read. */
741 static inline unsigned long
742 read_uleb128 (unsigned char * data
,
743 unsigned int * length_return
,
744 const unsigned char * const end
)
746 return read_leb128 (data
, length_return
, FALSE
, end
);
749 /* Return TRUE if the current file is for IA-64 machine and OpenVMS ABI.
750 This OS has so many departures from the ELF standard that we test it at
753 static inline bfd_boolean
754 is_ia64_vms (Filedata
* filedata
)
756 return filedata
->file_header
.e_machine
== EM_IA_64
757 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
;
760 /* Guess the relocation size commonly used by the specific machines. */
763 guess_is_rela (unsigned int e_machine
)
767 /* Targets that use REL relocations. */
783 /* Targets that use RELA relocations. */
787 case EM_ADAPTEVA_EPIPHANY
:
789 case EM_ALTERA_NIOS2
:
792 case EM_ARC_COMPACT2
:
812 case EM_LATTICEMICO32
:
821 case EM_CYGNUS_MN10200
:
823 case EM_CYGNUS_MN10300
:
859 case EM_MICROBLAZE_OLD
:
881 warn (_("Don't know about relocations on this machine architecture\n"));
886 /* Load RELA type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
887 Returns TRUE upon success, FALSE otherwise. If successful then a
888 pointer to a malloc'ed buffer containing the relocs is placed in *RELASP,
889 and the number of relocs loaded is placed in *NRELASP. It is the caller's
890 responsibility to free the allocated buffer. */
893 slurp_rela_relocs (Filedata
* filedata
,
894 unsigned long rel_offset
,
895 unsigned long rel_size
,
896 Elf_Internal_Rela
** relasp
,
897 unsigned long * nrelasp
)
899 Elf_Internal_Rela
* relas
;
905 Elf32_External_Rela
* erelas
;
907 erelas
= (Elf32_External_Rela
*) get_data (NULL
, filedata
, rel_offset
, 1,
908 rel_size
, _("32-bit relocation data"));
912 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
914 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
915 sizeof (Elf_Internal_Rela
));
920 error (_("out of memory parsing relocs\n"));
924 for (i
= 0; i
< nrelas
; i
++)
926 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
927 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
928 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
935 Elf64_External_Rela
* erelas
;
937 erelas
= (Elf64_External_Rela
*) get_data (NULL
, filedata
, rel_offset
, 1,
938 rel_size
, _("64-bit relocation data"));
942 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
944 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
945 sizeof (Elf_Internal_Rela
));
950 error (_("out of memory parsing relocs\n"));
954 for (i
= 0; i
< nrelas
; i
++)
956 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
957 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
958 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
960 /* The #ifdef BFD64 below is to prevent a compile time
961 warning. We know that if we do not have a 64 bit data
962 type that we will never execute this code anyway. */
964 if (filedata
->file_header
.e_machine
== EM_MIPS
965 && filedata
->file_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
967 /* In little-endian objects, r_info isn't really a
968 64-bit little-endian value: it has a 32-bit
969 little-endian symbol index followed by four
970 individual byte fields. Reorder INFO
972 bfd_vma inf
= relas
[i
].r_info
;
973 inf
= (((inf
& 0xffffffff) << 32)
974 | ((inf
>> 56) & 0xff)
975 | ((inf
>> 40) & 0xff00)
976 | ((inf
>> 24) & 0xff0000)
977 | ((inf
>> 8) & 0xff000000));
978 relas
[i
].r_info
= inf
;
991 /* Load REL type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
992 Returns TRUE upon success, FALSE otherwise. If successful then a
993 pointer to a malloc'ed buffer containing the relocs is placed in *RELSP,
994 and the number of relocs loaded is placed in *NRELSP. It is the caller's
995 responsibility to free the allocated buffer. */
998 slurp_rel_relocs (Filedata
* filedata
,
999 unsigned long rel_offset
,
1000 unsigned long rel_size
,
1001 Elf_Internal_Rela
** relsp
,
1002 unsigned long * nrelsp
)
1004 Elf_Internal_Rela
* rels
;
1010 Elf32_External_Rel
* erels
;
1012 erels
= (Elf32_External_Rel
*) get_data (NULL
, filedata
, rel_offset
, 1,
1013 rel_size
, _("32-bit relocation data"));
1017 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
1019 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
1024 error (_("out of memory parsing relocs\n"));
1028 for (i
= 0; i
< nrels
; i
++)
1030 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
1031 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
1032 rels
[i
].r_addend
= 0;
1039 Elf64_External_Rel
* erels
;
1041 erels
= (Elf64_External_Rel
*) get_data (NULL
, filedata
, rel_offset
, 1,
1042 rel_size
, _("64-bit relocation data"));
1046 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
1048 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
1053 error (_("out of memory parsing relocs\n"));
1057 for (i
= 0; i
< nrels
; i
++)
1059 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
1060 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
1061 rels
[i
].r_addend
= 0;
1063 /* The #ifdef BFD64 below is to prevent a compile time
1064 warning. We know that if we do not have a 64 bit data
1065 type that we will never execute this code anyway. */
1067 if (filedata
->file_header
.e_machine
== EM_MIPS
1068 && filedata
->file_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
1070 /* In little-endian objects, r_info isn't really a
1071 64-bit little-endian value: it has a 32-bit
1072 little-endian symbol index followed by four
1073 individual byte fields. Reorder INFO
1075 bfd_vma inf
= rels
[i
].r_info
;
1076 inf
= (((inf
& 0xffffffff) << 32)
1077 | ((inf
>> 56) & 0xff)
1078 | ((inf
>> 40) & 0xff00)
1079 | ((inf
>> 24) & 0xff0000)
1080 | ((inf
>> 8) & 0xff000000));
1081 rels
[i
].r_info
= inf
;
1094 /* Returns the reloc type extracted from the reloc info field. */
1097 get_reloc_type (Filedata
* filedata
, bfd_vma reloc_info
)
1100 return ELF32_R_TYPE (reloc_info
);
1102 switch (filedata
->file_header
.e_machine
)
1105 /* Note: We assume that reloc_info has already been adjusted for us. */
1106 return ELF64_MIPS_R_TYPE (reloc_info
);
1109 return ELF64_R_TYPE_ID (reloc_info
);
1112 return ELF64_R_TYPE (reloc_info
);
1116 /* Return the symbol index extracted from the reloc info field. */
1119 get_reloc_symindex (bfd_vma reloc_info
)
1121 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
1124 static inline bfd_boolean
1125 uses_msp430x_relocs (Filedata
* filedata
)
1128 filedata
->file_header
.e_machine
== EM_MSP430
/* Paranoia. */
1129 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1130 && (((filedata
->file_header
.e_flags
& EF_MSP430_MACH
) == E_MSP430_MACH_MSP430X
)
1131 /* TI compiler uses ELFOSABI_NONE. */
1132 || (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
));
1135 /* Display the contents of the relocation data found at the specified
1139 dump_relocations (Filedata
* filedata
,
1140 unsigned long rel_offset
,
1141 unsigned long rel_size
,
1142 Elf_Internal_Sym
* symtab
,
1143 unsigned long nsyms
,
1145 unsigned long strtablen
,
1147 bfd_boolean is_dynsym
)
1150 Elf_Internal_Rela
* rels
;
1151 bfd_boolean res
= TRUE
;
1153 if (is_rela
== UNKNOWN
)
1154 is_rela
= guess_is_rela (filedata
->file_header
.e_machine
);
1158 if (!slurp_rela_relocs (filedata
, rel_offset
, rel_size
, &rels
, &rel_size
))
1163 if (!slurp_rel_relocs (filedata
, rel_offset
, rel_size
, &rels
, &rel_size
))
1172 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1174 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1179 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1181 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1189 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
1191 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1196 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
1198 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1202 for (i
= 0; i
< rel_size
; i
++)
1207 bfd_vma symtab_index
;
1210 offset
= rels
[i
].r_offset
;
1211 inf
= rels
[i
].r_info
;
1213 type
= get_reloc_type (filedata
, inf
);
1214 symtab_index
= get_reloc_symindex (inf
);
1218 printf ("%8.8lx %8.8lx ",
1219 (unsigned long) offset
& 0xffffffff,
1220 (unsigned long) inf
& 0xffffffff);
1224 #if BFD_HOST_64BIT_LONG
1226 ? "%16.16lx %16.16lx "
1227 : "%12.12lx %12.12lx ",
1229 #elif BFD_HOST_64BIT_LONG_LONG
1232 ? "%16.16llx %16.16llx "
1233 : "%12.12llx %12.12llx ",
1237 ? "%16.16I64x %16.16I64x "
1238 : "%12.12I64x %12.12I64x ",
1243 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1244 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1245 _bfd_int64_high (offset
),
1246 _bfd_int64_low (offset
),
1247 _bfd_int64_high (inf
),
1248 _bfd_int64_low (inf
));
1252 switch (filedata
->file_header
.e_machine
)
1259 rtype
= elf_aarch64_reloc_type (type
);
1263 case EM_CYGNUS_M32R
:
1264 rtype
= elf_m32r_reloc_type (type
);
1269 rtype
= elf_i386_reloc_type (type
);
1274 rtype
= elf_m68hc11_reloc_type (type
);
1278 rtype
= elf_m68k_reloc_type (type
);
1282 rtype
= elf_i960_reloc_type (type
);
1287 rtype
= elf_avr_reloc_type (type
);
1290 case EM_OLD_SPARCV9
:
1291 case EM_SPARC32PLUS
:
1294 rtype
= elf_sparc_reloc_type (type
);
1298 rtype
= elf_spu_reloc_type (type
);
1302 rtype
= v800_reloc_type (type
);
1305 case EM_CYGNUS_V850
:
1306 rtype
= v850_reloc_type (type
);
1310 case EM_CYGNUS_D10V
:
1311 rtype
= elf_d10v_reloc_type (type
);
1315 case EM_CYGNUS_D30V
:
1316 rtype
= elf_d30v_reloc_type (type
);
1320 rtype
= elf_dlx_reloc_type (type
);
1324 rtype
= elf_sh_reloc_type (type
);
1328 case EM_CYGNUS_MN10300
:
1329 rtype
= elf_mn10300_reloc_type (type
);
1333 case EM_CYGNUS_MN10200
:
1334 rtype
= elf_mn10200_reloc_type (type
);
1338 case EM_CYGNUS_FR30
:
1339 rtype
= elf_fr30_reloc_type (type
);
1343 rtype
= elf_frv_reloc_type (type
);
1347 rtype
= elf_ft32_reloc_type (type
);
1351 rtype
= elf_mcore_reloc_type (type
);
1355 rtype
= elf_mmix_reloc_type (type
);
1359 rtype
= elf_moxie_reloc_type (type
);
1363 if (uses_msp430x_relocs (filedata
))
1365 rtype
= elf_msp430x_reloc_type (type
);
1370 rtype
= elf_msp430_reloc_type (type
);
1374 rtype
= elf_nds32_reloc_type (type
);
1378 rtype
= elf_ppc_reloc_type (type
);
1382 rtype
= elf_ppc64_reloc_type (type
);
1386 case EM_MIPS_RS3_LE
:
1387 rtype
= elf_mips_reloc_type (type
);
1391 rtype
= elf_riscv_reloc_type (type
);
1395 rtype
= elf_alpha_reloc_type (type
);
1399 rtype
= elf_arm_reloc_type (type
);
1403 case EM_ARC_COMPACT
:
1404 case EM_ARC_COMPACT2
:
1405 rtype
= elf_arc_reloc_type (type
);
1409 rtype
= elf_hppa_reloc_type (type
);
1415 rtype
= elf_h8_reloc_type (type
);
1419 rtype
= elf_or1k_reloc_type (type
);
1424 rtype
= elf_pj_reloc_type (type
);
1427 rtype
= elf_ia64_reloc_type (type
);
1431 rtype
= elf_cris_reloc_type (type
);
1435 rtype
= elf_i860_reloc_type (type
);
1441 rtype
= elf_x86_64_reloc_type (type
);
1445 rtype
= i370_reloc_type (type
);
1450 rtype
= elf_s390_reloc_type (type
);
1454 rtype
= elf_score_reloc_type (type
);
1458 rtype
= elf_xstormy16_reloc_type (type
);
1462 rtype
= elf_crx_reloc_type (type
);
1466 rtype
= elf_vax_reloc_type (type
);
1470 rtype
= elf_visium_reloc_type (type
);
1473 case EM_ADAPTEVA_EPIPHANY
:
1474 rtype
= elf_epiphany_reloc_type (type
);
1479 rtype
= elf_ip2k_reloc_type (type
);
1483 rtype
= elf_iq2000_reloc_type (type
);
1488 rtype
= elf_xtensa_reloc_type (type
);
1491 case EM_LATTICEMICO32
:
1492 rtype
= elf_lm32_reloc_type (type
);
1497 rtype
= elf_m32c_reloc_type (type
);
1501 rtype
= elf_mt_reloc_type (type
);
1505 rtype
= elf_bfin_reloc_type (type
);
1509 rtype
= elf_mep_reloc_type (type
);
1513 rtype
= elf_cr16_reloc_type (type
);
1517 case EM_MICROBLAZE_OLD
:
1518 rtype
= elf_microblaze_reloc_type (type
);
1522 rtype
= elf_rl78_reloc_type (type
);
1526 rtype
= elf_rx_reloc_type (type
);
1530 rtype
= elf_metag_reloc_type (type
);
1535 rtype
= elf_xc16x_reloc_type (type
);
1539 rtype
= elf_tic6x_reloc_type (type
);
1543 rtype
= elf_tilegx_reloc_type (type
);
1547 rtype
= elf_tilepro_reloc_type (type
);
1550 case EM_WEBASSEMBLY
:
1551 rtype
= elf_wasm32_reloc_type (type
);
1555 rtype
= elf_xgate_reloc_type (type
);
1558 case EM_ALTERA_NIOS2
:
1559 rtype
= elf_nios2_reloc_type (type
);
1563 rtype
= elf_pru_reloc_type (type
);
1567 if (EF_NFP_MACH (filedata
->file_header
.e_flags
) == E_NFP_MACH_3200
)
1568 rtype
= elf_nfp3200_reloc_type (type
);
1570 rtype
= elf_nfp_reloc_type (type
);
1575 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1577 printf (do_wide
? "%-22s" : "%-17.17s", rtype
);
1579 if (filedata
->file_header
.e_machine
== EM_ALPHA
1581 && streq (rtype
, "R_ALPHA_LITUSE")
1584 switch (rels
[i
].r_addend
)
1586 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1587 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1588 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1589 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1590 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1591 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1592 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1593 default: rtype
= NULL
;
1597 printf (" (%s)", rtype
);
1601 printf (_("<unknown addend: %lx>"),
1602 (unsigned long) rels
[i
].r_addend
);
1606 else if (symtab_index
)
1608 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1610 error (_(" bad symbol index: %08lx in reloc"), (unsigned long) symtab_index
);
1615 Elf_Internal_Sym
* psym
;
1616 const char * version_string
;
1617 enum versioned_symbol_info sym_info
;
1618 unsigned short vna_other
;
1620 psym
= symtab
+ symtab_index
;
1623 = get_symbol_version_string (filedata
, is_dynsym
,
1632 if (ELF_ST_TYPE (psym
->st_info
) == STT_GNU_IFUNC
)
1636 unsigned int width
= is_32bit_elf
? 8 : 14;
1638 /* Relocations against GNU_IFUNC symbols do not use the value
1639 of the symbol as the address to relocate against. Instead
1640 they invoke the function named by the symbol and use its
1641 result as the address for relocation.
1643 To indicate this to the user, do not display the value of
1644 the symbol in the "Symbols's Value" field. Instead show
1645 its name followed by () as a hint that the symbol is
1649 || psym
->st_name
== 0
1650 || psym
->st_name
>= strtablen
)
1653 name
= strtab
+ psym
->st_name
;
1655 len
= print_symbol (width
, name
);
1657 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1659 printf ("()%-*s", len
<= width
? (width
+ 1) - len
: 1, " ");
1663 print_vma (psym
->st_value
, LONG_HEX
);
1665 printf (is_32bit_elf
? " " : " ");
1668 if (psym
->st_name
== 0)
1670 const char * sec_name
= "<null>";
1673 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1675 if (psym
->st_shndx
< filedata
->file_header
.e_shnum
)
1676 sec_name
= SECTION_NAME (filedata
->section_headers
+ psym
->st_shndx
);
1677 else if (psym
->st_shndx
== SHN_ABS
)
1679 else if (psym
->st_shndx
== SHN_COMMON
)
1680 sec_name
= "COMMON";
1681 else if ((filedata
->file_header
.e_machine
== EM_MIPS
1682 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1683 || (filedata
->file_header
.e_machine
== EM_TI_C6000
1684 && psym
->st_shndx
== SHN_TIC6X_SCOMMON
))
1685 sec_name
= "SCOMMON";
1686 else if (filedata
->file_header
.e_machine
== EM_MIPS
1687 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1688 sec_name
= "SUNDEF";
1689 else if ((filedata
->file_header
.e_machine
== EM_X86_64
1690 || filedata
->file_header
.e_machine
== EM_L1OM
1691 || filedata
->file_header
.e_machine
== EM_K1OM
)
1692 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1693 sec_name
= "LARGE_COMMON";
1694 else if (filedata
->file_header
.e_machine
== EM_IA_64
1695 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1696 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1697 sec_name
= "ANSI_COM";
1698 else if (is_ia64_vms (filedata
)
1699 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
1700 sec_name
= "VMS_SYMVEC";
1703 sprintf (name_buf
, "<section 0x%x>",
1704 (unsigned int) psym
->st_shndx
);
1705 sec_name
= name_buf
;
1708 print_symbol (22, sec_name
);
1710 else if (strtab
== NULL
)
1711 printf (_("<string table index: %3ld>"), psym
->st_name
);
1712 else if (psym
->st_name
>= strtablen
)
1714 error (_("<corrupt string table index: %3ld>"), psym
->st_name
);
1719 print_symbol (22, strtab
+ psym
->st_name
);
1721 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1727 bfd_vma off
= rels
[i
].r_addend
;
1729 if ((bfd_signed_vma
) off
< 0)
1730 printf (" - %" BFD_VMA_FMT
"x", - off
);
1732 printf (" + %" BFD_VMA_FMT
"x", off
);
1738 bfd_vma off
= rels
[i
].r_addend
;
1740 printf ("%*c", is_32bit_elf
? 12 : 20, ' ');
1741 if ((bfd_signed_vma
) off
< 0)
1742 printf ("-%" BFD_VMA_FMT
"x", - off
);
1744 printf ("%" BFD_VMA_FMT
"x", off
);
1747 if (filedata
->file_header
.e_machine
== EM_SPARCV9
1749 && streq (rtype
, "R_SPARC_OLO10"))
1750 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf
));
1755 if (! is_32bit_elf
&& filedata
->file_header
.e_machine
== EM_MIPS
)
1757 bfd_vma type2
= ELF64_MIPS_R_TYPE2 (inf
);
1758 bfd_vma type3
= ELF64_MIPS_R_TYPE3 (inf
);
1759 const char * rtype2
= elf_mips_reloc_type (type2
);
1760 const char * rtype3
= elf_mips_reloc_type (type3
);
1762 printf (" Type2: ");
1765 printf (_("unrecognized: %-7lx"),
1766 (unsigned long) type2
& 0xffffffff);
1768 printf ("%-17.17s", rtype2
);
1770 printf ("\n Type3: ");
1773 printf (_("unrecognized: %-7lx"),
1774 (unsigned long) type3
& 0xffffffff);
1776 printf ("%-17.17s", rtype3
);
1789 get_mips_dynamic_type (unsigned long type
)
1793 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1794 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1795 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1796 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1797 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1798 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1799 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1800 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1801 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1802 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1803 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1804 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1805 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1806 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1807 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1808 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1809 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1810 case DT_MIPS_RLD_MAP_REL
: return "MIPS_RLD_MAP_REL";
1811 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1812 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1813 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1814 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1815 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1816 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1817 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1818 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1819 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1820 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1821 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1822 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1823 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1824 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1825 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1826 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1827 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1828 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1829 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1830 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1831 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1832 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1833 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1834 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1835 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1836 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1837 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
1838 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
1845 get_sparc64_dynamic_type (unsigned long type
)
1849 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1856 get_ppc_dynamic_type (unsigned long type
)
1860 case DT_PPC_GOT
: return "PPC_GOT";
1861 case DT_PPC_OPT
: return "PPC_OPT";
1868 get_ppc64_dynamic_type (unsigned long type
)
1872 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1873 case DT_PPC64_OPD
: return "PPC64_OPD";
1874 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1875 case DT_PPC64_OPT
: return "PPC64_OPT";
1882 get_parisc_dynamic_type (unsigned long type
)
1886 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1887 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1888 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1889 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1890 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1891 case DT_HP_PREINIT
: return "HP_PREINIT";
1892 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1893 case DT_HP_NEEDED
: return "HP_NEEDED";
1894 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1895 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1896 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1897 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1898 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1899 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1900 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1901 case DT_HP_FILTERED
: return "HP_FILTERED";
1902 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1903 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1904 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1905 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1906 case DT_PLT
: return "PLT";
1907 case DT_PLT_SIZE
: return "PLT_SIZE";
1908 case DT_DLT
: return "DLT";
1909 case DT_DLT_SIZE
: return "DLT_SIZE";
1916 get_ia64_dynamic_type (unsigned long type
)
1920 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1921 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
1922 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
1923 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
1924 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
1925 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
1926 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
1927 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
1928 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
1929 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
1930 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
1931 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
1932 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
1933 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
1934 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
1935 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
1936 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
1937 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
1938 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
1939 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
1940 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
1941 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
1942 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
1943 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
1944 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
1945 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
1946 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
1947 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
1948 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
1949 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
1950 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
1957 get_solaris_section_type (unsigned long type
)
1961 case 0x6fffffee: return "SUNW_ancillary";
1962 case 0x6fffffef: return "SUNW_capchain";
1963 case 0x6ffffff0: return "SUNW_capinfo";
1964 case 0x6ffffff1: return "SUNW_symsort";
1965 case 0x6ffffff2: return "SUNW_tlssort";
1966 case 0x6ffffff3: return "SUNW_LDYNSYM";
1967 case 0x6ffffff4: return "SUNW_dof";
1968 case 0x6ffffff5: return "SUNW_cap";
1969 case 0x6ffffff6: return "SUNW_SIGNATURE";
1970 case 0x6ffffff7: return "SUNW_ANNOTATE";
1971 case 0x6ffffff8: return "SUNW_DEBUGSTR";
1972 case 0x6ffffff9: return "SUNW_DEBUG";
1973 case 0x6ffffffa: return "SUNW_move";
1974 case 0x6ffffffb: return "SUNW_COMDAT";
1975 case 0x6ffffffc: return "SUNW_syminfo";
1976 case 0x6ffffffd: return "SUNW_verdef";
1977 case 0x6ffffffe: return "SUNW_verneed";
1978 case 0x6fffffff: return "SUNW_versym";
1979 case 0x70000000: return "SPARC_GOTDATA";
1980 default: return NULL
;
1985 get_alpha_dynamic_type (unsigned long type
)
1989 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
1990 default: return NULL
;
1995 get_score_dynamic_type (unsigned long type
)
1999 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
2000 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
2001 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
2002 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
2003 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
2004 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
2005 default: return NULL
;
2010 get_tic6x_dynamic_type (unsigned long type
)
2014 case DT_C6000_GSYM_OFFSET
: return "C6000_GSYM_OFFSET";
2015 case DT_C6000_GSTR_OFFSET
: return "C6000_GSTR_OFFSET";
2016 case DT_C6000_DSBT_BASE
: return "C6000_DSBT_BASE";
2017 case DT_C6000_DSBT_SIZE
: return "C6000_DSBT_SIZE";
2018 case DT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
2019 case DT_C6000_DSBT_INDEX
: return "C6000_DSBT_INDEX";
2020 default: return NULL
;
2025 get_nios2_dynamic_type (unsigned long type
)
2029 case DT_NIOS2_GP
: return "NIOS2_GP";
2030 default: return NULL
;
2035 get_solaris_dynamic_type (unsigned long type
)
2039 case 0x6000000d: return "SUNW_AUXILIARY";
2040 case 0x6000000e: return "SUNW_RTLDINF";
2041 case 0x6000000f: return "SUNW_FILTER";
2042 case 0x60000010: return "SUNW_CAP";
2043 case 0x60000011: return "SUNW_SYMTAB";
2044 case 0x60000012: return "SUNW_SYMSZ";
2045 case 0x60000013: return "SUNW_SORTENT";
2046 case 0x60000014: return "SUNW_SYMSORT";
2047 case 0x60000015: return "SUNW_SYMSORTSZ";
2048 case 0x60000016: return "SUNW_TLSSORT";
2049 case 0x60000017: return "SUNW_TLSSORTSZ";
2050 case 0x60000018: return "SUNW_CAPINFO";
2051 case 0x60000019: return "SUNW_STRPAD";
2052 case 0x6000001a: return "SUNW_CAPCHAIN";
2053 case 0x6000001b: return "SUNW_LDMACH";
2054 case 0x6000001d: return "SUNW_CAPCHAINENT";
2055 case 0x6000001f: return "SUNW_CAPCHAINSZ";
2056 case 0x60000021: return "SUNW_PARENT";
2057 case 0x60000023: return "SUNW_ASLR";
2058 case 0x60000025: return "SUNW_RELAX";
2059 case 0x60000029: return "SUNW_NXHEAP";
2060 case 0x6000002b: return "SUNW_NXSTACK";
2062 case 0x70000001: return "SPARC_REGISTER";
2063 case 0x7ffffffd: return "AUXILIARY";
2064 case 0x7ffffffe: return "USED";
2065 case 0x7fffffff: return "FILTER";
2067 default: return NULL
;
2072 get_dynamic_type (Filedata
* filedata
, unsigned long type
)
2074 static char buff
[64];
2078 case DT_NULL
: return "NULL";
2079 case DT_NEEDED
: return "NEEDED";
2080 case DT_PLTRELSZ
: return "PLTRELSZ";
2081 case DT_PLTGOT
: return "PLTGOT";
2082 case DT_HASH
: return "HASH";
2083 case DT_STRTAB
: return "STRTAB";
2084 case DT_SYMTAB
: return "SYMTAB";
2085 case DT_RELA
: return "RELA";
2086 case DT_RELASZ
: return "RELASZ";
2087 case DT_RELAENT
: return "RELAENT";
2088 case DT_STRSZ
: return "STRSZ";
2089 case DT_SYMENT
: return "SYMENT";
2090 case DT_INIT
: return "INIT";
2091 case DT_FINI
: return "FINI";
2092 case DT_SONAME
: return "SONAME";
2093 case DT_RPATH
: return "RPATH";
2094 case DT_SYMBOLIC
: return "SYMBOLIC";
2095 case DT_REL
: return "REL";
2096 case DT_RELSZ
: return "RELSZ";
2097 case DT_RELENT
: return "RELENT";
2098 case DT_PLTREL
: return "PLTREL";
2099 case DT_DEBUG
: return "DEBUG";
2100 case DT_TEXTREL
: return "TEXTREL";
2101 case DT_JMPREL
: return "JMPREL";
2102 case DT_BIND_NOW
: return "BIND_NOW";
2103 case DT_INIT_ARRAY
: return "INIT_ARRAY";
2104 case DT_FINI_ARRAY
: return "FINI_ARRAY";
2105 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
2106 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
2107 case DT_RUNPATH
: return "RUNPATH";
2108 case DT_FLAGS
: return "FLAGS";
2110 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2111 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
2112 case DT_SYMTAB_SHNDX
: return "SYMTAB_SHNDX";
2114 case DT_CHECKSUM
: return "CHECKSUM";
2115 case DT_PLTPADSZ
: return "PLTPADSZ";
2116 case DT_MOVEENT
: return "MOVEENT";
2117 case DT_MOVESZ
: return "MOVESZ";
2118 case DT_FEATURE
: return "FEATURE";
2119 case DT_POSFLAG_1
: return "POSFLAG_1";
2120 case DT_SYMINSZ
: return "SYMINSZ";
2121 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
2123 case DT_ADDRRNGLO
: return "ADDRRNGLO";
2124 case DT_CONFIG
: return "CONFIG";
2125 case DT_DEPAUDIT
: return "DEPAUDIT";
2126 case DT_AUDIT
: return "AUDIT";
2127 case DT_PLTPAD
: return "PLTPAD";
2128 case DT_MOVETAB
: return "MOVETAB";
2129 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
2131 case DT_VERSYM
: return "VERSYM";
2133 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
2134 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
2135 case DT_RELACOUNT
: return "RELACOUNT";
2136 case DT_RELCOUNT
: return "RELCOUNT";
2137 case DT_FLAGS_1
: return "FLAGS_1";
2138 case DT_VERDEF
: return "VERDEF";
2139 case DT_VERDEFNUM
: return "VERDEFNUM";
2140 case DT_VERNEED
: return "VERNEED";
2141 case DT_VERNEEDNUM
: return "VERNEEDNUM";
2143 case DT_AUXILIARY
: return "AUXILIARY";
2144 case DT_USED
: return "USED";
2145 case DT_FILTER
: return "FILTER";
2147 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
2148 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
2149 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
2150 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
2151 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
2152 case DT_GNU_HASH
: return "GNU_HASH";
2155 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
2157 const char * result
;
2159 switch (filedata
->file_header
.e_machine
)
2162 case EM_MIPS_RS3_LE
:
2163 result
= get_mips_dynamic_type (type
);
2166 result
= get_sparc64_dynamic_type (type
);
2169 result
= get_ppc_dynamic_type (type
);
2172 result
= get_ppc64_dynamic_type (type
);
2175 result
= get_ia64_dynamic_type (type
);
2178 result
= get_alpha_dynamic_type (type
);
2181 result
= get_score_dynamic_type (type
);
2184 result
= get_tic6x_dynamic_type (type
);
2186 case EM_ALTERA_NIOS2
:
2187 result
= get_nios2_dynamic_type (type
);
2190 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2191 result
= get_solaris_dynamic_type (type
);
2200 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
2202 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
2203 || (filedata
->file_header
.e_machine
== EM_PARISC
2204 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
2206 const char * result
;
2208 switch (filedata
->file_header
.e_machine
)
2211 result
= get_parisc_dynamic_type (type
);
2214 result
= get_ia64_dynamic_type (type
);
2217 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2218 result
= get_solaris_dynamic_type (type
);
2227 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
2231 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
2238 get_file_type (unsigned e_type
)
2240 static char buff
[32];
2244 case ET_NONE
: return _("NONE (None)");
2245 case ET_REL
: return _("REL (Relocatable file)");
2246 case ET_EXEC
: return _("EXEC (Executable file)");
2247 case ET_DYN
: return _("DYN (Shared object file)");
2248 case ET_CORE
: return _("CORE (Core file)");
2251 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
2252 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
2253 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
2254 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
2256 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
2262 get_machine_name (unsigned e_machine
)
2264 static char buff
[64]; /* XXX */
2268 /* Please keep this switch table sorted by increasing EM_ value. */
2270 case EM_NONE
: return _("None");
2271 case EM_M32
: return "WE32100";
2272 case EM_SPARC
: return "Sparc";
2273 case EM_386
: return "Intel 80386";
2274 case EM_68K
: return "MC68000";
2275 case EM_88K
: return "MC88000";
2276 case EM_IAMCU
: return "Intel MCU";
2277 case EM_860
: return "Intel 80860";
2278 case EM_MIPS
: return "MIPS R3000";
2279 case EM_S370
: return "IBM System/370";
2281 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
2282 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
2283 case EM_PARISC
: return "HPPA";
2284 case EM_VPP550
: return "Fujitsu VPP500";
2285 case EM_SPARC32PLUS
: return "Sparc v8+" ;
2286 case EM_960
: return "Intel 80960";
2287 case EM_PPC
: return "PowerPC";
2289 case EM_PPC64
: return "PowerPC64";
2291 case EM_S390
: return "IBM S/390";
2292 case EM_SPU
: return "SPU";
2294 case EM_V800
: return "Renesas V850 (using RH850 ABI)";
2295 case EM_FR20
: return "Fujitsu FR20";
2296 case EM_RH32
: return "TRW RH32";
2297 case EM_MCORE
: return "MCORE";
2299 case EM_ARM
: return "ARM";
2300 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
2301 case EM_SH
: return "Renesas / SuperH SH";
2302 case EM_SPARCV9
: return "Sparc v9";
2303 case EM_TRICORE
: return "Siemens Tricore";
2304 case EM_ARC
: return "ARC";
2305 case EM_H8_300
: return "Renesas H8/300";
2306 case EM_H8_300H
: return "Renesas H8/300H";
2307 case EM_H8S
: return "Renesas H8S";
2308 case EM_H8_500
: return "Renesas H8/500";
2310 case EM_IA_64
: return "Intel IA-64";
2311 case EM_MIPS_X
: return "Stanford MIPS-X";
2312 case EM_COLDFIRE
: return "Motorola Coldfire";
2313 case EM_68HC12
: return "Motorola MC68HC12 Microcontroller";
2314 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
2315 case EM_PCP
: return "Siemens PCP";
2316 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
2317 case EM_NDR1
: return "Denso NDR1 microprocesspr";
2318 case EM_STARCORE
: return "Motorola Star*Core processor";
2319 case EM_ME16
: return "Toyota ME16 processor";
2321 case EM_ST100
: return "STMicroelectronics ST100 processor";
2322 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
2323 case EM_X86_64
: return "Advanced Micro Devices X86-64";
2324 case EM_PDSP
: return "Sony DSP processor";
2325 case EM_PDP10
: return "Digital Equipment Corp. PDP-10";
2326 case EM_PDP11
: return "Digital Equipment Corp. PDP-11";
2327 case EM_FX66
: return "Siemens FX66 microcontroller";
2328 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2329 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
2330 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
2332 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
2333 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
2334 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
2335 case EM_SVX
: return "Silicon Graphics SVx";
2336 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
2337 case EM_VAX
: return "Digital VAX";
2338 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
2339 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
2340 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
2341 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
2343 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
2344 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
2345 case EM_PRISM
: return "Vitesse Prism";
2347 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
2348 case EM_CYGNUS_FR30
:
2349 case EM_FR30
: return "Fujitsu FR30";
2350 case EM_CYGNUS_D10V
:
2351 case EM_D10V
: return "d10v";
2352 case EM_CYGNUS_D30V
:
2353 case EM_D30V
: return "d30v";
2354 case EM_CYGNUS_V850
:
2355 case EM_V850
: return "Renesas V850";
2356 case EM_CYGNUS_M32R
:
2357 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
2358 case EM_CYGNUS_MN10300
:
2359 case EM_MN10300
: return "mn10300";
2361 case EM_CYGNUS_MN10200
:
2362 case EM_MN10200
: return "mn10200";
2363 case EM_PJ
: return "picoJava";
2364 case EM_OR1K
: return "OpenRISC 1000";
2365 case EM_ARC_COMPACT
: return "ARCompact";
2367 case EM_XTENSA
: return "Tensilica Xtensa Processor";
2368 case EM_VIDEOCORE
: return "Alphamosaic VideoCore processor";
2369 case EM_TMM_GPP
: return "Thompson Multimedia General Purpose Processor";
2370 case EM_NS32K
: return "National Semiconductor 32000 series";
2371 case EM_TPC
: return "Tenor Network TPC processor";
2372 case EM_SNP1K
: return "Trebia SNP 1000 processor";
2374 case EM_ST200
: return "STMicroelectronics ST200 microcontroller";
2376 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
2377 case EM_MAX
: return "MAX Processor";
2378 case EM_CR
: return "National Semiconductor CompactRISC";
2379 case EM_F2MC16
: return "Fujitsu F2MC16";
2380 case EM_MSP430
: return "Texas Instruments msp430 microcontroller";
2381 case EM_BLACKFIN
: return "Analog Devices Blackfin";
2382 case EM_SE_C33
: return "S1C33 Family of Seiko Epson processors";
2383 case EM_SEP
: return "Sharp embedded microprocessor";
2384 case EM_ARCA
: return "Arca RISC microprocessor";
2386 case EM_UNICORE
: return "Unicore";
2387 case EM_EXCESS
: return "eXcess 16/32/64-bit configurable embedded CPU";
2388 case EM_DXP
: return "Icera Semiconductor Inc. Deep Execution Processor";
2389 case EM_ALTERA_NIOS2
: return "Altera Nios II";
2390 case EM_CRX
: return "National Semiconductor CRX microprocessor";
2391 case EM_XGATE
: return "Motorola XGATE embedded processor";
2393 case EM_XC16X
: return "Infineon Technologies xc16x";
2394 case EM_M16C
: return "Renesas M16C series microprocessors";
2395 case EM_DSPIC30F
: return "Microchip Technology dsPIC30F Digital Signal Controller";
2396 case EM_CE
: return "Freescale Communication Engine RISC core";
2398 case EM_M32C
: return "Renesas M32c";
2400 case EM_TSK3000
: return "Altium TSK3000 core";
2401 case EM_RS08
: return "Freescale RS08 embedded processor";
2402 case EM_ECOG2
: return "Cyan Technology eCOG2 microprocessor";
2403 case EM_SCORE
: return "SUNPLUS S+Core";
2404 case EM_DSP24
: return "New Japan Radio (NJR) 24-bit DSP Processor";
2405 case EM_VIDEOCORE3
: return "Broadcom VideoCore III processor";
2406 case EM_LATTICEMICO32
: return "Lattice Mico32";
2407 case EM_SE_C17
: return "Seiko Epson C17 family";
2409 case EM_TI_C6000
: return "Texas Instruments TMS320C6000 DSP family";
2410 case EM_TI_C2000
: return "Texas Instruments TMS320C2000 DSP family";
2411 case EM_TI_C5500
: return "Texas Instruments TMS320C55x DSP family";
2412 case EM_TI_PRU
: return "TI PRU I/O processor";
2414 case EM_MMDSP_PLUS
: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2415 case EM_CYPRESS_M8C
: return "Cypress M8C microprocessor";
2416 case EM_R32C
: return "Renesas R32C series microprocessors";
2417 case EM_TRIMEDIA
: return "NXP Semiconductors TriMedia architecture family";
2418 case EM_QDSP6
: return "QUALCOMM DSP6 Processor";
2419 case EM_8051
: return "Intel 8051 and variants";
2420 case EM_STXP7X
: return "STMicroelectronics STxP7x family";
2421 case EM_NDS32
: return "Andes Technology compact code size embedded RISC processor family";
2422 case EM_ECOG1X
: return "Cyan Technology eCOG1X family";
2423 case EM_MAXQ30
: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2425 case EM_XIMO16
: return "New Japan Radio (NJR) 16-bit DSP Processor";
2426 case EM_MANIK
: return "M2000 Reconfigurable RISC Microprocessor";
2427 case EM_CRAYNV2
: return "Cray Inc. NV2 vector architecture";
2428 case EM_RX
: return "Renesas RX";
2429 case EM_METAG
: return "Imagination Technologies Meta processor architecture";
2430 case EM_MCST_ELBRUS
: return "MCST Elbrus general purpose hardware architecture";
2431 case EM_ECOG16
: return "Cyan Technology eCOG16 family";
2434 case EM_MICROBLAZE_OLD
: return "Xilinx MicroBlaze";
2435 case EM_ETPU
: return "Freescale Extended Time Processing Unit";
2436 case EM_SLE9X
: return "Infineon Technologies SLE9X core";
2438 case EM_L1OM
: return "Intel L1OM";
2439 case EM_K1OM
: return "Intel K1OM";
2440 case EM_INTEL182
: return "Intel (reserved)";
2441 case EM_AARCH64
: return "AArch64";
2442 case EM_ARM184
: return "ARM (reserved)";
2443 case EM_AVR32
: return "Atmel Corporation 32-bit microprocessor";
2444 case EM_STM8
: return "STMicroeletronics STM8 8-bit microcontroller";
2445 case EM_TILE64
: return "Tilera TILE64 multicore architecture family";
2446 case EM_TILEPRO
: return "Tilera TILEPro multicore architecture family";
2448 case EM_CUDA
: return "NVIDIA CUDA architecture";
2449 case EM_TILEGX
: return "Tilera TILE-Gx multicore architecture family";
2450 case EM_CLOUDSHIELD
: return "CloudShield architecture family";
2451 case EM_COREA_1ST
: return "KIPO-KAIST Core-A 1st generation processor family";
2452 case EM_COREA_2ND
: return "KIPO-KAIST Core-A 2nd generation processor family";
2453 case EM_ARC_COMPACT2
: return "ARCv2";
2454 case EM_OPEN8
: return "Open8 8-bit RISC soft processor core";
2455 case EM_RL78
: return "Renesas RL78";
2456 case EM_VIDEOCORE5
: return "Broadcom VideoCore V processor";
2457 case EM_78K0R
: return "Renesas 78K0R";
2459 case EM_56800EX
: return "Freescale 56800EX Digital Signal Controller (DSC)";
2460 case EM_BA1
: return "Beyond BA1 CPU architecture";
2461 case EM_BA2
: return "Beyond BA2 CPU architecture";
2462 case EM_XCORE
: return "XMOS xCORE processor family";
2463 case EM_MCHP_PIC
: return "Microchip 8-bit PIC(r) family";
2465 case EM_KM32
: return "KM211 KM32 32-bit processor";
2466 case EM_KMX32
: return "KM211 KMX32 32-bit processor";
2467 case EM_KMX16
: return "KM211 KMX16 16-bit processor";
2468 case EM_KMX8
: return "KM211 KMX8 8-bit processor";
2469 case EM_KVARC
: return "KM211 KVARC processor";
2470 case EM_CDP
: return "Paneve CDP architecture family";
2471 case EM_COGE
: return "Cognitive Smart Memory Processor";
2472 case EM_COOL
: return "Bluechip Systems CoolEngine";
2473 case EM_NORC
: return "Nanoradio Optimized RISC";
2474 case EM_CSR_KALIMBA
: return "CSR Kalimba architecture family";
2476 case EM_Z80
: return "Zilog Z80";
2477 case EM_VISIUM
: return "CDS VISIUMcore processor";
2478 case EM_FT32
: return "FTDI Chip FT32";
2479 case EM_MOXIE
: return "Moxie";
2480 case EM_AMDGPU
: return "AMD GPU";
2481 case EM_RISCV
: return "RISC-V";
2482 case EM_LANAI
: return "Lanai 32-bit processor";
2483 case EM_BPF
: return "Linux BPF";
2484 case EM_NFP
: return "Netronome Flow Processor";
2486 /* Large numbers... */
2487 case EM_MT
: return "Morpho Techologies MT processor";
2488 case EM_ALPHA
: return "Alpha";
2489 case EM_WEBASSEMBLY
: return "Web Assembly";
2490 case EM_DLX
: return "OpenDLX";
2491 case EM_XSTORMY16
: return "Sanyo XStormy16 CPU core";
2492 case EM_IQ2000
: return "Vitesse IQ2000";
2494 case EM_NIOS32
: return "Altera Nios";
2495 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
2496 case EM_ADAPTEVA_EPIPHANY
: return "Adapteva EPIPHANY";
2497 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
2500 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
2506 decode_ARC_machine_flags (unsigned e_flags
, unsigned e_machine
, char buf
[])
2508 /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2. Some
2509 other compilers don't a specific architecture type in the e_flags, and
2510 instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
2511 architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
2514 Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
2515 but also sets a specific architecture type in the e_flags field.
2517 However, when decoding the flags we don't worry if we see an
2518 unexpected pairing, for example EM_ARC_COMPACT machine type, with
2519 ARCEM architecture type. */
2521 switch (e_flags
& EF_ARC_MACH_MSK
)
2523 /* We only expect these to occur for EM_ARC_COMPACT2. */
2524 case EF_ARC_CPU_ARCV2EM
:
2525 strcat (buf
, ", ARC EM");
2527 case EF_ARC_CPU_ARCV2HS
:
2528 strcat (buf
, ", ARC HS");
2531 /* We only expect these to occur for EM_ARC_COMPACT. */
2532 case E_ARC_MACH_ARC600
:
2533 strcat (buf
, ", ARC600");
2535 case E_ARC_MACH_ARC601
:
2536 strcat (buf
, ", ARC601");
2538 case E_ARC_MACH_ARC700
:
2539 strcat (buf
, ", ARC700");
2542 /* The only times we should end up here are (a) A corrupt ELF, (b) A
2543 new ELF with new architecture being read by an old version of
2544 readelf, or (c) An ELF built with non-GNU compiler that does not
2545 set the architecture in the e_flags. */
2547 if (e_machine
== EM_ARC_COMPACT
)
2548 strcat (buf
, ", Unknown ARCompact");
2550 strcat (buf
, ", Unknown ARC");
2554 switch (e_flags
& EF_ARC_OSABI_MSK
)
2556 case E_ARC_OSABI_ORIG
:
2557 strcat (buf
, ", (ABI:legacy)");
2559 case E_ARC_OSABI_V2
:
2560 strcat (buf
, ", (ABI:v2)");
2562 /* Only upstream 3.9+ kernels will support ARCv2 ISA. */
2563 case E_ARC_OSABI_V3
:
2564 strcat (buf
, ", v3 no-legacy-syscalls ABI");
2566 case E_ARC_OSABI_V4
:
2567 strcat (buf
, ", v4 ABI");
2570 strcat (buf
, ", unrecognised ARC OSABI flag");
2576 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
2579 bfd_boolean unknown
= FALSE
;
2581 eabi
= EF_ARM_EABI_VERSION (e_flags
);
2582 e_flags
&= ~ EF_ARM_EABIMASK
;
2584 /* Handle "generic" ARM flags. */
2585 if (e_flags
& EF_ARM_RELEXEC
)
2587 strcat (buf
, ", relocatable executable");
2588 e_flags
&= ~ EF_ARM_RELEXEC
;
2591 if (e_flags
& EF_ARM_PIC
)
2593 strcat (buf
, ", position independent");
2594 e_flags
&= ~ EF_ARM_PIC
;
2597 /* Now handle EABI specific flags. */
2601 strcat (buf
, ", <unrecognized EABI>");
2606 case EF_ARM_EABI_VER1
:
2607 strcat (buf
, ", Version1 EABI");
2612 /* Process flags one bit at a time. */
2613 flag
= e_flags
& - e_flags
;
2618 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2619 strcat (buf
, ", sorted symbol tables");
2629 case EF_ARM_EABI_VER2
:
2630 strcat (buf
, ", Version2 EABI");
2635 /* Process flags one bit at a time. */
2636 flag
= e_flags
& - e_flags
;
2641 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2642 strcat (buf
, ", sorted symbol tables");
2645 case EF_ARM_DYNSYMSUSESEGIDX
:
2646 strcat (buf
, ", dynamic symbols use segment index");
2649 case EF_ARM_MAPSYMSFIRST
:
2650 strcat (buf
, ", mapping symbols precede others");
2660 case EF_ARM_EABI_VER3
:
2661 strcat (buf
, ", Version3 EABI");
2664 case EF_ARM_EABI_VER4
:
2665 strcat (buf
, ", Version4 EABI");
2670 /* Process flags one bit at a time. */
2671 flag
= e_flags
& - e_flags
;
2677 strcat (buf
, ", BE8");
2681 strcat (buf
, ", LE8");
2691 case EF_ARM_EABI_VER5
:
2692 strcat (buf
, ", Version5 EABI");
2697 /* Process flags one bit at a time. */
2698 flag
= e_flags
& - e_flags
;
2704 strcat (buf
, ", BE8");
2708 strcat (buf
, ", LE8");
2711 case EF_ARM_ABI_FLOAT_SOFT
: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2712 strcat (buf
, ", soft-float ABI");
2715 case EF_ARM_ABI_FLOAT_HARD
: /* Conflicts with EF_ARM_VFP_FLOAT. */
2716 strcat (buf
, ", hard-float ABI");
2726 case EF_ARM_EABI_UNKNOWN
:
2727 strcat (buf
, ", GNU EABI");
2732 /* Process flags one bit at a time. */
2733 flag
= e_flags
& - e_flags
;
2738 case EF_ARM_INTERWORK
:
2739 strcat (buf
, ", interworking enabled");
2742 case EF_ARM_APCS_26
:
2743 strcat (buf
, ", uses APCS/26");
2746 case EF_ARM_APCS_FLOAT
:
2747 strcat (buf
, ", uses APCS/float");
2751 strcat (buf
, ", position independent");
2755 strcat (buf
, ", 8 bit structure alignment");
2758 case EF_ARM_NEW_ABI
:
2759 strcat (buf
, ", uses new ABI");
2762 case EF_ARM_OLD_ABI
:
2763 strcat (buf
, ", uses old ABI");
2766 case EF_ARM_SOFT_FLOAT
:
2767 strcat (buf
, ", software FP");
2770 case EF_ARM_VFP_FLOAT
:
2771 strcat (buf
, ", VFP");
2774 case EF_ARM_MAVERICK_FLOAT
:
2775 strcat (buf
, ", Maverick FP");
2786 strcat (buf
,_(", <unknown>"));
2790 decode_AVR_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2792 --size
; /* Leave space for null terminator. */
2794 switch (e_flags
& EF_AVR_MACH
)
2796 case E_AVR_MACH_AVR1
:
2797 strncat (buf
, ", avr:1", size
);
2799 case E_AVR_MACH_AVR2
:
2800 strncat (buf
, ", avr:2", size
);
2802 case E_AVR_MACH_AVR25
:
2803 strncat (buf
, ", avr:25", size
);
2805 case E_AVR_MACH_AVR3
:
2806 strncat (buf
, ", avr:3", size
);
2808 case E_AVR_MACH_AVR31
:
2809 strncat (buf
, ", avr:31", size
);
2811 case E_AVR_MACH_AVR35
:
2812 strncat (buf
, ", avr:35", size
);
2814 case E_AVR_MACH_AVR4
:
2815 strncat (buf
, ", avr:4", size
);
2817 case E_AVR_MACH_AVR5
:
2818 strncat (buf
, ", avr:5", size
);
2820 case E_AVR_MACH_AVR51
:
2821 strncat (buf
, ", avr:51", size
);
2823 case E_AVR_MACH_AVR6
:
2824 strncat (buf
, ", avr:6", size
);
2826 case E_AVR_MACH_AVRTINY
:
2827 strncat (buf
, ", avr:100", size
);
2829 case E_AVR_MACH_XMEGA1
:
2830 strncat (buf
, ", avr:101", size
);
2832 case E_AVR_MACH_XMEGA2
:
2833 strncat (buf
, ", avr:102", size
);
2835 case E_AVR_MACH_XMEGA3
:
2836 strncat (buf
, ", avr:103", size
);
2838 case E_AVR_MACH_XMEGA4
:
2839 strncat (buf
, ", avr:104", size
);
2841 case E_AVR_MACH_XMEGA5
:
2842 strncat (buf
, ", avr:105", size
);
2844 case E_AVR_MACH_XMEGA6
:
2845 strncat (buf
, ", avr:106", size
);
2847 case E_AVR_MACH_XMEGA7
:
2848 strncat (buf
, ", avr:107", size
);
2851 strncat (buf
, ", avr:<unknown>", size
);
2855 size
-= strlen (buf
);
2856 if (e_flags
& EF_AVR_LINKRELAX_PREPARED
)
2857 strncat (buf
, ", link-relax", size
);
2861 decode_NDS32_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2867 bfd_boolean has_fpu
= FALSE
;
2870 static const char *ABI_STRINGS
[] =
2872 "ABI v0", /* use r5 as return register; only used in N1213HC */
2873 "ABI v1", /* use r0 as return register */
2874 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2875 "ABI v2fp", /* for FPU */
2879 static const char *VER_STRINGS
[] =
2881 "Andes ELF V1.3 or older",
2885 static const char *ARCH_STRINGS
[] =
2894 abi
= EF_NDS_ABI
& e_flags
;
2895 arch
= EF_NDS_ARCH
& e_flags
;
2896 config
= EF_NDS_INST
& e_flags
;
2897 version
= EF_NDS32_ELF_VERSION
& e_flags
;
2899 memset (buf
, 0, size
);
2906 case E_NDS_ABI_V2FP
:
2907 case E_NDS_ABI_AABI
:
2908 case E_NDS_ABI_V2FP_PLUS
:
2909 /* In case there are holes in the array. */
2910 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ABI_STRINGS
[abi
>> EF_NDS_ABI_SHIFT
]);
2914 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ABI>");
2920 case E_NDS32_ELF_VER_1_2
:
2921 case E_NDS32_ELF_VER_1_3
:
2922 case E_NDS32_ELF_VER_1_4
:
2923 r
+= snprintf (buf
+ r
, size
- r
, ", %s", VER_STRINGS
[version
>> EF_NDS32_ELF_VERSION_SHIFT
]);
2927 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ELF version number>");
2931 if (E_NDS_ABI_V0
== abi
)
2933 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2934 r
+= snprintf (buf
+ r
, size
- r
, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2935 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2936 r
+= snprintf (buf
+ r
, size
-r
, ", 16b"); /* has 16-bit instructions */
2942 case E_NDS_ARCH_STAR_V1_0
:
2943 case E_NDS_ARCH_STAR_V2_0
:
2944 case E_NDS_ARCH_STAR_V3_0
:
2945 case E_NDS_ARCH_STAR_V3_M
:
2946 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ARCH_STRINGS
[arch
>> EF_NDS_ARCH_SHIFT
]);
2950 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized architecture>");
2951 /* ARCH version determines how the e_flags are interpreted.
2952 If it is unknown, we cannot proceed. */
2956 /* Newer ABI; Now handle architecture specific flags. */
2957 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2959 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2960 r
+= snprintf (buf
+ r
, size
-r
, ", MFUSR_PC");
2962 if (!(config
& E_NDS32_HAS_NO_MAC_INST
))
2963 r
+= snprintf (buf
+ r
, size
-r
, ", MAC");
2965 if (config
& E_NDS32_HAS_DIV_INST
)
2966 r
+= snprintf (buf
+ r
, size
-r
, ", DIV");
2968 if (config
& E_NDS32_HAS_16BIT_INST
)
2969 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
2973 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2975 if (version
<= E_NDS32_ELF_VER_1_3
)
2976 r
+= snprintf (buf
+ r
, size
-r
, ", [B8]");
2978 r
+= snprintf (buf
+ r
, size
-r
, ", EX9");
2981 if (config
& E_NDS32_HAS_MAC_DX_INST
)
2982 r
+= snprintf (buf
+ r
, size
-r
, ", MAC_DX");
2984 if (config
& E_NDS32_HAS_DIV_DX_INST
)
2985 r
+= snprintf (buf
+ r
, size
-r
, ", DIV_DX");
2987 if (config
& E_NDS32_HAS_16BIT_INST
)
2989 if (version
<= E_NDS32_ELF_VER_1_3
)
2990 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
2992 r
+= snprintf (buf
+ r
, size
-r
, ", IFC");
2996 if (config
& E_NDS32_HAS_EXT_INST
)
2997 r
+= snprintf (buf
+ r
, size
-r
, ", PERF1");
2999 if (config
& E_NDS32_HAS_EXT2_INST
)
3000 r
+= snprintf (buf
+ r
, size
-r
, ", PERF2");
3002 if (config
& E_NDS32_HAS_FPU_INST
)
3005 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_SP");
3008 if (config
& E_NDS32_HAS_FPU_DP_INST
)
3011 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_DP");
3014 if (config
& E_NDS32_HAS_FPU_MAC_INST
)
3017 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_MAC");
3022 switch ((config
& E_NDS32_FPU_REG_CONF
) >> E_NDS32_FPU_REG_CONF_SHIFT
)
3024 case E_NDS32_FPU_REG_8SP_4DP
:
3025 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:8/4");
3027 case E_NDS32_FPU_REG_16SP_8DP
:
3028 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:16/8");
3030 case E_NDS32_FPU_REG_32SP_16DP
:
3031 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/16");
3033 case E_NDS32_FPU_REG_32SP_32DP
:
3034 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/32");
3039 if (config
& E_NDS32_HAS_AUDIO_INST
)
3040 r
+= snprintf (buf
+ r
, size
-r
, ", AUDIO");
3042 if (config
& E_NDS32_HAS_STRING_INST
)
3043 r
+= snprintf (buf
+ r
, size
-r
, ", STR");
3045 if (config
& E_NDS32_HAS_REDUCED_REGS
)
3046 r
+= snprintf (buf
+ r
, size
-r
, ", 16REG");
3048 if (config
& E_NDS32_HAS_VIDEO_INST
)
3050 if (version
<= E_NDS32_ELF_VER_1_3
)
3051 r
+= snprintf (buf
+ r
, size
-r
, ", VIDEO");
3053 r
+= snprintf (buf
+ r
, size
-r
, ", SATURATION");
3056 if (config
& E_NDS32_HAS_ENCRIPT_INST
)
3057 r
+= snprintf (buf
+ r
, size
-r
, ", ENCRP");
3059 if (config
& E_NDS32_HAS_L2C_INST
)
3060 r
+= snprintf (buf
+ r
, size
-r
, ", L2C");
3064 get_machine_flags (Filedata
* filedata
, unsigned e_flags
, unsigned e_machine
)
3066 static char buf
[1024];
3077 case EM_ARC_COMPACT2
:
3078 case EM_ARC_COMPACT
:
3079 decode_ARC_machine_flags (e_flags
, e_machine
, buf
);
3083 decode_ARM_machine_flags (e_flags
, buf
);
3087 decode_AVR_machine_flags (e_flags
, buf
, sizeof buf
);
3091 if (e_flags
& EF_BFIN_PIC
)
3092 strcat (buf
, ", PIC");
3094 if (e_flags
& EF_BFIN_FDPIC
)
3095 strcat (buf
, ", FDPIC");
3097 if (e_flags
& EF_BFIN_CODE_IN_L1
)
3098 strcat (buf
, ", code in L1");
3100 if (e_flags
& EF_BFIN_DATA_IN_L1
)
3101 strcat (buf
, ", data in L1");
3106 switch (e_flags
& EF_FRV_CPU_MASK
)
3108 case EF_FRV_CPU_GENERIC
:
3112 strcat (buf
, ", fr???");
3115 case EF_FRV_CPU_FR300
:
3116 strcat (buf
, ", fr300");
3119 case EF_FRV_CPU_FR400
:
3120 strcat (buf
, ", fr400");
3122 case EF_FRV_CPU_FR405
:
3123 strcat (buf
, ", fr405");
3126 case EF_FRV_CPU_FR450
:
3127 strcat (buf
, ", fr450");
3130 case EF_FRV_CPU_FR500
:
3131 strcat (buf
, ", fr500");
3133 case EF_FRV_CPU_FR550
:
3134 strcat (buf
, ", fr550");
3137 case EF_FRV_CPU_SIMPLE
:
3138 strcat (buf
, ", simple");
3140 case EF_FRV_CPU_TOMCAT
:
3141 strcat (buf
, ", tomcat");
3147 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
3148 strcat (buf
, ", m68000");
3149 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
3150 strcat (buf
, ", cpu32");
3151 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
3152 strcat (buf
, ", fido_a");
3155 char const * isa
= _("unknown");
3156 char const * mac
= _("unknown mac");
3157 char const * additional
= NULL
;
3159 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
3161 case EF_M68K_CF_ISA_A_NODIV
:
3163 additional
= ", nodiv";
3165 case EF_M68K_CF_ISA_A
:
3168 case EF_M68K_CF_ISA_A_PLUS
:
3171 case EF_M68K_CF_ISA_B_NOUSP
:
3173 additional
= ", nousp";
3175 case EF_M68K_CF_ISA_B
:
3178 case EF_M68K_CF_ISA_C
:
3181 case EF_M68K_CF_ISA_C_NODIV
:
3183 additional
= ", nodiv";
3186 strcat (buf
, ", cf, isa ");
3189 strcat (buf
, additional
);
3190 if (e_flags
& EF_M68K_CF_FLOAT
)
3191 strcat (buf
, ", float");
3192 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
3197 case EF_M68K_CF_MAC
:
3200 case EF_M68K_CF_EMAC
:
3203 case EF_M68K_CF_EMAC_B
:
3216 switch (e_flags
& EF_MEP_CPU_MASK
)
3218 case EF_MEP_CPU_MEP
: strcat (buf
, ", generic MeP"); break;
3219 case EF_MEP_CPU_C2
: strcat (buf
, ", MeP C2"); break;
3220 case EF_MEP_CPU_C3
: strcat (buf
, ", MeP C3"); break;
3221 case EF_MEP_CPU_C4
: strcat (buf
, ", MeP C4"); break;
3222 case EF_MEP_CPU_C5
: strcat (buf
, ", MeP C5"); break;
3223 case EF_MEP_CPU_H1
: strcat (buf
, ", MeP H1"); break;
3224 default: strcat (buf
, _(", <unknown MeP cpu type>")); break;
3227 switch (e_flags
& EF_MEP_COP_MASK
)
3229 case EF_MEP_COP_NONE
: break;
3230 case EF_MEP_COP_AVC
: strcat (buf
, ", AVC coprocessor"); break;
3231 case EF_MEP_COP_AVC2
: strcat (buf
, ", AVC2 coprocessor"); break;
3232 case EF_MEP_COP_FMAX
: strcat (buf
, ", FMAX coprocessor"); break;
3233 case EF_MEP_COP_IVC2
: strcat (buf
, ", IVC2 coprocessor"); break;
3234 default: strcat (buf
, _("<unknown MeP copro type>")); break;
3237 if (e_flags
& EF_MEP_LIBRARY
)
3238 strcat (buf
, ", Built for Library");
3240 if (e_flags
& EF_MEP_INDEX_MASK
)
3241 sprintf (buf
+ strlen (buf
), ", Configuration Index: %#x",
3242 e_flags
& EF_MEP_INDEX_MASK
);
3244 if (e_flags
& ~ EF_MEP_ALL_FLAGS
)
3245 sprintf (buf
+ strlen (buf
), _(", unknown flags bits: %#x"),
3246 e_flags
& ~ EF_MEP_ALL_FLAGS
);
3250 if (e_flags
& EF_PPC_EMB
)
3251 strcat (buf
, ", emb");
3253 if (e_flags
& EF_PPC_RELOCATABLE
)
3254 strcat (buf
, _(", relocatable"));
3256 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
3257 strcat (buf
, _(", relocatable-lib"));
3261 if (e_flags
& EF_PPC64_ABI
)
3263 char abi
[] = ", abiv0";
3265 abi
[6] += e_flags
& EF_PPC64_ABI
;
3271 if ((e_flags
& EF_RH850_ABI
) == EF_RH850_ABI
)
3272 strcat (buf
, ", RH850 ABI");
3274 if (e_flags
& EF_V800_850E3
)
3275 strcat (buf
, ", V3 architecture");
3277 if ((e_flags
& (EF_RH850_FPU_DOUBLE
| EF_RH850_FPU_SINGLE
)) == 0)
3278 strcat (buf
, ", FPU not used");
3280 if ((e_flags
& (EF_RH850_REGMODE22
| EF_RH850_REGMODE32
)) == 0)
3281 strcat (buf
, ", regmode: COMMON");
3283 if ((e_flags
& (EF_RH850_GP_FIX
| EF_RH850_GP_NOFIX
)) == 0)
3284 strcat (buf
, ", r4 not used");
3286 if ((e_flags
& (EF_RH850_EP_FIX
| EF_RH850_EP_NOFIX
)) == 0)
3287 strcat (buf
, ", r30 not used");
3289 if ((e_flags
& (EF_RH850_TP_FIX
| EF_RH850_TP_NOFIX
)) == 0)
3290 strcat (buf
, ", r5 not used");
3292 if ((e_flags
& (EF_RH850_REG2_RESERVE
| EF_RH850_REG2_NORESERVE
)) == 0)
3293 strcat (buf
, ", r2 not used");
3295 for (e_flags
&= 0xFFFF; e_flags
; e_flags
&= ~ (e_flags
& - e_flags
))
3297 switch (e_flags
& - e_flags
)
3299 case EF_RH850_FPU_DOUBLE
: strcat (buf
, ", double precision FPU"); break;
3300 case EF_RH850_FPU_SINGLE
: strcat (buf
, ", single precision FPU"); break;
3301 case EF_RH850_REGMODE22
: strcat (buf
, ", regmode:22"); break;
3302 case EF_RH850_REGMODE32
: strcat (buf
, ", regmode:23"); break;
3303 case EF_RH850_GP_FIX
: strcat (buf
, ", r4 fixed"); break;
3304 case EF_RH850_GP_NOFIX
: strcat (buf
, ", r4 free"); break;
3305 case EF_RH850_EP_FIX
: strcat (buf
, ", r30 fixed"); break;
3306 case EF_RH850_EP_NOFIX
: strcat (buf
, ", r30 free"); break;
3307 case EF_RH850_TP_FIX
: strcat (buf
, ", r5 fixed"); break;
3308 case EF_RH850_TP_NOFIX
: strcat (buf
, ", r5 free"); break;
3309 case EF_RH850_REG2_RESERVE
: strcat (buf
, ", r2 fixed"); break;
3310 case EF_RH850_REG2_NORESERVE
: strcat (buf
, ", r2 free"); break;
3317 case EM_CYGNUS_V850
:
3318 switch (e_flags
& EF_V850_ARCH
)
3320 case E_V850E3V5_ARCH
:
3321 strcat (buf
, ", v850e3v5");
3323 case E_V850E2V3_ARCH
:
3324 strcat (buf
, ", v850e2v3");
3327 strcat (buf
, ", v850e2");
3330 strcat (buf
, ", v850e1");
3333 strcat (buf
, ", v850e");
3336 strcat (buf
, ", v850");
3339 strcat (buf
, _(", unknown v850 architecture variant"));
3345 case EM_CYGNUS_M32R
:
3346 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
3347 strcat (buf
, ", m32r");
3351 case EM_MIPS_RS3_LE
:
3352 if (e_flags
& EF_MIPS_NOREORDER
)
3353 strcat (buf
, ", noreorder");
3355 if (e_flags
& EF_MIPS_PIC
)
3356 strcat (buf
, ", pic");
3358 if (e_flags
& EF_MIPS_CPIC
)
3359 strcat (buf
, ", cpic");
3361 if (e_flags
& EF_MIPS_UCODE
)
3362 strcat (buf
, ", ugen_reserved");
3364 if (e_flags
& EF_MIPS_ABI2
)
3365 strcat (buf
, ", abi2");
3367 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
3368 strcat (buf
, ", odk first");
3370 if (e_flags
& EF_MIPS_32BITMODE
)
3371 strcat (buf
, ", 32bitmode");
3373 if (e_flags
& EF_MIPS_NAN2008
)
3374 strcat (buf
, ", nan2008");
3376 if (e_flags
& EF_MIPS_FP64
)
3377 strcat (buf
, ", fp64");
3379 switch ((e_flags
& EF_MIPS_MACH
))
3381 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
3382 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
3383 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
3384 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
3385 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
3386 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
3387 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
3388 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
3389 case E_MIPS_MACH_5900
: strcat (buf
, ", 5900"); break;
3390 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
3391 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
3392 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
3393 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
3394 case E_MIPS_MACH_LS3A
: strcat (buf
, ", loongson-3a"); break;
3395 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
3396 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
3397 case E_MIPS_MACH_OCTEON3
: strcat (buf
, ", octeon3"); break;
3398 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
3399 case E_MIPS_MACH_IAMR2
: strcat (buf
, ", interaptiv-mr2"); break;
3401 /* We simply ignore the field in this case to avoid confusion:
3402 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3405 default: strcat (buf
, _(", unknown CPU")); break;
3408 switch ((e_flags
& EF_MIPS_ABI
))
3410 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
3411 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
3412 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
3413 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
3415 /* We simply ignore the field in this case to avoid confusion:
3416 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3417 This means it is likely to be an o32 file, but not for
3420 default: strcat (buf
, _(", unknown ABI")); break;
3423 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
3424 strcat (buf
, ", mdmx");
3426 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
3427 strcat (buf
, ", mips16");
3429 if (e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
3430 strcat (buf
, ", micromips");
3432 switch ((e_flags
& EF_MIPS_ARCH
))
3434 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
3435 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
3436 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
3437 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
3438 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
3439 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
3440 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
3441 case E_MIPS_ARCH_32R6
: strcat (buf
, ", mips32r6"); break;
3442 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
3443 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
3444 case E_MIPS_ARCH_64R6
: strcat (buf
, ", mips64r6"); break;
3445 default: strcat (buf
, _(", unknown ISA")); break;
3450 decode_NDS32_machine_flags (e_flags
, buf
, sizeof buf
);
3454 switch (EF_NFP_MACH (e_flags
))
3456 case E_NFP_MACH_3200
:
3457 strcat (buf
, ", NFP-32xx");
3459 case E_NFP_MACH_6000
:
3460 strcat (buf
, ", NFP-6xxx");
3466 if (e_flags
& EF_RISCV_RVC
)
3467 strcat (buf
, ", RVC");
3469 switch (e_flags
& EF_RISCV_FLOAT_ABI
)
3471 case EF_RISCV_FLOAT_ABI_SOFT
:
3472 strcat (buf
, ", soft-float ABI");
3475 case EF_RISCV_FLOAT_ABI_SINGLE
:
3476 strcat (buf
, ", single-float ABI");
3479 case EF_RISCV_FLOAT_ABI_DOUBLE
:
3480 strcat (buf
, ", double-float ABI");
3483 case EF_RISCV_FLOAT_ABI_QUAD
:
3484 strcat (buf
, ", quad-float ABI");
3490 switch ((e_flags
& EF_SH_MACH_MASK
))
3492 case EF_SH1
: strcat (buf
, ", sh1"); break;
3493 case EF_SH2
: strcat (buf
, ", sh2"); break;
3494 case EF_SH3
: strcat (buf
, ", sh3"); break;
3495 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
3496 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
3497 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
3498 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
3499 case EF_SH4
: strcat (buf
, ", sh4"); break;
3500 case EF_SH5
: strcat (buf
, ", sh5"); break;
3501 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
3502 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
3503 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
3504 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
3505 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
3506 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
3507 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
3508 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
3509 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3510 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
3511 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
3512 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
3513 default: strcat (buf
, _(", unknown ISA")); break;
3516 if (e_flags
& EF_SH_PIC
)
3517 strcat (buf
, ", pic");
3519 if (e_flags
& EF_SH_FDPIC
)
3520 strcat (buf
, ", fdpic");
3524 if (e_flags
& EF_OR1K_NODELAY
)
3525 strcat (buf
, ", no delay");
3529 if (e_flags
& EF_SPARC_32PLUS
)
3530 strcat (buf
, ", v8+");
3532 if (e_flags
& EF_SPARC_SUN_US1
)
3533 strcat (buf
, ", ultrasparcI");
3535 if (e_flags
& EF_SPARC_SUN_US3
)
3536 strcat (buf
, ", ultrasparcIII");
3538 if (e_flags
& EF_SPARC_HAL_R1
)
3539 strcat (buf
, ", halr1");
3541 if (e_flags
& EF_SPARC_LEDATA
)
3542 strcat (buf
, ", ledata");
3544 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
3545 strcat (buf
, ", tso");
3547 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
3548 strcat (buf
, ", pso");
3550 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
3551 strcat (buf
, ", rmo");
3555 switch (e_flags
& EF_PARISC_ARCH
)
3557 case EFA_PARISC_1_0
:
3558 strcpy (buf
, ", PA-RISC 1.0");
3560 case EFA_PARISC_1_1
:
3561 strcpy (buf
, ", PA-RISC 1.1");
3563 case EFA_PARISC_2_0
:
3564 strcpy (buf
, ", PA-RISC 2.0");
3569 if (e_flags
& EF_PARISC_TRAPNIL
)
3570 strcat (buf
, ", trapnil");
3571 if (e_flags
& EF_PARISC_EXT
)
3572 strcat (buf
, ", ext");
3573 if (e_flags
& EF_PARISC_LSB
)
3574 strcat (buf
, ", lsb");
3575 if (e_flags
& EF_PARISC_WIDE
)
3576 strcat (buf
, ", wide");
3577 if (e_flags
& EF_PARISC_NO_KABP
)
3578 strcat (buf
, ", no kabp");
3579 if (e_flags
& EF_PARISC_LAZYSWAP
)
3580 strcat (buf
, ", lazyswap");
3585 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
3586 strcat (buf
, ", new calling convention");
3588 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
3589 strcat (buf
, ", gnu calling convention");
3593 if ((e_flags
& EF_IA_64_ABI64
))
3594 strcat (buf
, ", 64-bit");
3596 strcat (buf
, ", 32-bit");
3597 if ((e_flags
& EF_IA_64_REDUCEDFP
))
3598 strcat (buf
, ", reduced fp model");
3599 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
3600 strcat (buf
, ", no function descriptors, constant gp");
3601 else if ((e_flags
& EF_IA_64_CONS_GP
))
3602 strcat (buf
, ", constant gp");
3603 if ((e_flags
& EF_IA_64_ABSOLUTE
))
3604 strcat (buf
, ", absolute");
3605 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
3607 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
3608 strcat (buf
, ", vms_linkages");
3609 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
3611 case EF_IA_64_VMS_COMCOD_SUCCESS
:
3613 case EF_IA_64_VMS_COMCOD_WARNING
:
3614 strcat (buf
, ", warning");
3616 case EF_IA_64_VMS_COMCOD_ERROR
:
3617 strcat (buf
, ", error");
3619 case EF_IA_64_VMS_COMCOD_ABORT
:
3620 strcat (buf
, ", abort");
3623 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3624 e_flags
& EF_IA_64_VMS_COMCOD
);
3625 strcat (buf
, ", <unknown>");
3631 if ((e_flags
& EF_VAX_NONPIC
))
3632 strcat (buf
, ", non-PIC");
3633 if ((e_flags
& EF_VAX_DFLOAT
))
3634 strcat (buf
, ", D-Float");
3635 if ((e_flags
& EF_VAX_GFLOAT
))
3636 strcat (buf
, ", G-Float");
3640 if (e_flags
& EF_VISIUM_ARCH_MCM
)
3641 strcat (buf
, ", mcm");
3642 else if (e_flags
& EF_VISIUM_ARCH_MCM24
)
3643 strcat (buf
, ", mcm24");
3644 if (e_flags
& EF_VISIUM_ARCH_GR6
)
3645 strcat (buf
, ", gr6");
3649 switch (e_flags
& E_FLAG_RL78_CPU_MASK
)
3651 case E_FLAG_RL78_ANY_CPU
: break;
3652 case E_FLAG_RL78_G10
: strcat (buf
, ", G10"); break;
3653 case E_FLAG_RL78_G13
: strcat (buf
, ", G13"); break;
3654 case E_FLAG_RL78_G14
: strcat (buf
, ", G14"); break;
3656 if (e_flags
& E_FLAG_RL78_64BIT_DOUBLES
)
3657 strcat (buf
, ", 64-bit doubles");
3661 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
3662 strcat (buf
, ", 64-bit doubles");
3663 if (e_flags
& E_FLAG_RX_DSP
)
3664 strcat (buf
, ", dsp");
3665 if (e_flags
& E_FLAG_RX_PID
)
3666 strcat (buf
, ", pid");
3667 if (e_flags
& E_FLAG_RX_ABI
)
3668 strcat (buf
, ", RX ABI");
3669 if (e_flags
& E_FLAG_RX_SINSNS_SET
)
3670 strcat (buf
, e_flags
& E_FLAG_RX_SINSNS_YES
3671 ? ", uses String instructions" : ", bans String instructions");
3672 if (e_flags
& E_FLAG_RX_V2
)
3673 strcat (buf
, ", V2");
3677 if (e_flags
& EF_S390_HIGH_GPRS
)
3678 strcat (buf
, ", highgprs");
3682 if ((e_flags
& EF_C6000_REL
))
3683 strcat (buf
, ", relocatable module");
3687 strcat (buf
, _(": architecture variant: "));
3688 switch (e_flags
& EF_MSP430_MACH
)
3690 case E_MSP430_MACH_MSP430x11
: strcat (buf
, "MSP430x11"); break;
3691 case E_MSP430_MACH_MSP430x11x1
: strcat (buf
, "MSP430x11x1 "); break;
3692 case E_MSP430_MACH_MSP430x12
: strcat (buf
, "MSP430x12"); break;
3693 case E_MSP430_MACH_MSP430x13
: strcat (buf
, "MSP430x13"); break;
3694 case E_MSP430_MACH_MSP430x14
: strcat (buf
, "MSP430x14"); break;
3695 case E_MSP430_MACH_MSP430x15
: strcat (buf
, "MSP430x15"); break;
3696 case E_MSP430_MACH_MSP430x16
: strcat (buf
, "MSP430x16"); break;
3697 case E_MSP430_MACH_MSP430x31
: strcat (buf
, "MSP430x31"); break;
3698 case E_MSP430_MACH_MSP430x32
: strcat (buf
, "MSP430x32"); break;
3699 case E_MSP430_MACH_MSP430x33
: strcat (buf
, "MSP430x33"); break;
3700 case E_MSP430_MACH_MSP430x41
: strcat (buf
, "MSP430x41"); break;
3701 case E_MSP430_MACH_MSP430x42
: strcat (buf
, "MSP430x42"); break;
3702 case E_MSP430_MACH_MSP430x43
: strcat (buf
, "MSP430x43"); break;
3703 case E_MSP430_MACH_MSP430x44
: strcat (buf
, "MSP430x44"); break;
3704 case E_MSP430_MACH_MSP430X
: strcat (buf
, "MSP430X"); break;
3706 strcat (buf
, _(": unknown")); break;
3709 if (e_flags
& ~ EF_MSP430_MACH
)
3710 strcat (buf
, _(": unknown extra flag bits also present"));
3718 get_osabi_name (Filedata
* filedata
, unsigned int osabi
)
3720 static char buff
[32];
3724 case ELFOSABI_NONE
: return "UNIX - System V";
3725 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
3726 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
3727 case ELFOSABI_GNU
: return "UNIX - GNU";
3728 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
3729 case ELFOSABI_AIX
: return "UNIX - AIX";
3730 case ELFOSABI_IRIX
: return "UNIX - IRIX";
3731 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
3732 case ELFOSABI_TRU64
: return "UNIX - TRU64";
3733 case ELFOSABI_MODESTO
: return "Novell - Modesto";
3734 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
3735 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
3736 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
3737 case ELFOSABI_AROS
: return "AROS";
3738 case ELFOSABI_FENIXOS
: return "FenixOS";
3739 case ELFOSABI_CLOUDABI
: return "Nuxi CloudABI";
3740 case ELFOSABI_OPENVOS
: return "Stratus Technologies OpenVOS";
3743 switch (filedata
->file_header
.e_machine
)
3748 case ELFOSABI_ARM
: return "ARM";
3749 case ELFOSABI_ARM_FDPIC
: return "ARM FDPIC";
3760 case ELFOSABI_STANDALONE
: return _("Standalone App");
3769 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
3770 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
3779 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
3785 get_aarch64_segment_type (unsigned long type
)
3789 case PT_AARCH64_ARCHEXT
: return "AARCH64_ARCHEXT";
3790 default: return NULL
;
3795 get_arm_segment_type (unsigned long type
)
3799 case PT_ARM_EXIDX
: return "EXIDX";
3800 default: return NULL
;
3805 get_s390_segment_type (unsigned long type
)
3809 case PT_S390_PGSTE
: return "S390_PGSTE";
3810 default: return NULL
;
3815 get_mips_segment_type (unsigned long type
)
3819 case PT_MIPS_REGINFO
: return "REGINFO";
3820 case PT_MIPS_RTPROC
: return "RTPROC";
3821 case PT_MIPS_OPTIONS
: return "OPTIONS";
3822 case PT_MIPS_ABIFLAGS
: return "ABIFLAGS";
3823 default: return NULL
;
3828 get_parisc_segment_type (unsigned long type
)
3832 case PT_HP_TLS
: return "HP_TLS";
3833 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
3834 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
3835 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
3836 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
3837 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
3838 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
3839 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
3840 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
3841 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
3842 case PT_HP_PARALLEL
: return "HP_PARALLEL";
3843 case PT_HP_FASTBIND
: return "HP_FASTBIND";
3844 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
3845 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
3846 case PT_HP_STACK
: return "HP_STACK";
3847 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
3848 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
3849 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
3850 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
3851 default: return NULL
;
3856 get_ia64_segment_type (unsigned long type
)
3860 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
3861 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
3862 case PT_HP_TLS
: return "HP_TLS";
3863 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
3864 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
3865 case PT_IA_64_HP_STACK
: return "HP_STACK";
3866 default: return NULL
;
3871 get_tic6x_segment_type (unsigned long type
)
3875 case PT_C6000_PHATTR
: return "C6000_PHATTR";
3876 default: return NULL
;
3881 get_solaris_segment_type (unsigned long type
)
3885 case 0x6464e550: return "PT_SUNW_UNWIND";
3886 case 0x6474e550: return "PT_SUNW_EH_FRAME";
3887 case 0x6ffffff7: return "PT_LOSUNW";
3888 case 0x6ffffffa: return "PT_SUNWBSS";
3889 case 0x6ffffffb: return "PT_SUNWSTACK";
3890 case 0x6ffffffc: return "PT_SUNWDTRACE";
3891 case 0x6ffffffd: return "PT_SUNWCAP";
3892 case 0x6fffffff: return "PT_HISUNW";
3893 default: return NULL
;
3898 get_segment_type (Filedata
* filedata
, unsigned long p_type
)
3900 static char buff
[32];
3904 case PT_NULL
: return "NULL";
3905 case PT_LOAD
: return "LOAD";
3906 case PT_DYNAMIC
: return "DYNAMIC";
3907 case PT_INTERP
: return "INTERP";
3908 case PT_NOTE
: return "NOTE";
3909 case PT_SHLIB
: return "SHLIB";
3910 case PT_PHDR
: return "PHDR";
3911 case PT_TLS
: return "TLS";
3912 case PT_GNU_EH_FRAME
: return "GNU_EH_FRAME";
3913 case PT_GNU_STACK
: return "GNU_STACK";
3914 case PT_GNU_RELRO
: return "GNU_RELRO";
3917 if (p_type
>= PT_GNU_MBIND_LO
&& p_type
<= PT_GNU_MBIND_HI
)
3919 sprintf (buff
, "GNU_MBIND+%#lx",
3920 p_type
- PT_GNU_MBIND_LO
);
3922 else if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
3924 const char * result
;
3926 switch (filedata
->file_header
.e_machine
)
3929 result
= get_aarch64_segment_type (p_type
);
3932 result
= get_arm_segment_type (p_type
);
3935 case EM_MIPS_RS3_LE
:
3936 result
= get_mips_segment_type (p_type
);
3939 result
= get_parisc_segment_type (p_type
);
3942 result
= get_ia64_segment_type (p_type
);
3945 result
= get_tic6x_segment_type (p_type
);
3949 result
= get_s390_segment_type (p_type
);
3959 sprintf (buff
, "LOPROC+%#lx", p_type
- PT_LOPROC
);
3961 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
3963 const char * result
;
3965 switch (filedata
->file_header
.e_machine
)
3968 result
= get_parisc_segment_type (p_type
);
3971 result
= get_ia64_segment_type (p_type
);
3974 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
3975 result
= get_solaris_segment_type (p_type
);
3984 sprintf (buff
, "LOOS+%#lx", p_type
- PT_LOOS
);
3987 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
3994 get_arc_section_type_name (unsigned int sh_type
)
3998 case SHT_ARC_ATTRIBUTES
: return "ARC_ATTRIBUTES";
4006 get_mips_section_type_name (unsigned int sh_type
)
4010 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
4011 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
4012 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
4013 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
4014 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
4015 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
4016 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
4017 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
4018 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
4019 case SHT_MIPS_RELD
: return "MIPS_RELD";
4020 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
4021 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
4022 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
4023 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
4024 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
4025 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
4026 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
4027 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
4028 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
4029 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
4030 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
4031 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
4032 case SHT_MIPS_LINE
: return "MIPS_LINE";
4033 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
4034 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
4035 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
4036 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
4037 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
4038 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
4039 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
4040 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
4041 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
4042 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
4043 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
4044 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
4045 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
4046 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
4047 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
4048 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
4049 case SHT_MIPS_ABIFLAGS
: return "MIPS_ABIFLAGS";
4057 get_parisc_section_type_name (unsigned int sh_type
)
4061 case SHT_PARISC_EXT
: return "PARISC_EXT";
4062 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
4063 case SHT_PARISC_DOC
: return "PARISC_DOC";
4064 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
4065 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
4066 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
4067 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
4068 default: return NULL
;
4073 get_ia64_section_type_name (Filedata
* filedata
, unsigned int sh_type
)
4075 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
4076 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
4077 return get_osabi_name (filedata
, (sh_type
& 0x00FF0000) >> 16);
4081 case SHT_IA_64_EXT
: return "IA_64_EXT";
4082 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
4083 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
4084 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
4085 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
4086 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
4087 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
4088 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
4089 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
4090 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
4098 get_x86_64_section_type_name (unsigned int sh_type
)
4102 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
4103 default: return NULL
;
4108 get_aarch64_section_type_name (unsigned int sh_type
)
4112 case SHT_AARCH64_ATTRIBUTES
: return "AARCH64_ATTRIBUTES";
4113 default: return NULL
;
4118 get_arm_section_type_name (unsigned int sh_type
)
4122 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
4123 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
4124 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
4125 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
4126 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
4127 default: return NULL
;
4132 get_tic6x_section_type_name (unsigned int sh_type
)
4136 case SHT_C6000_UNWIND
: return "C6000_UNWIND";
4137 case SHT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
4138 case SHT_C6000_ATTRIBUTES
: return "C6000_ATTRIBUTES";
4139 case SHT_TI_ICODE
: return "TI_ICODE";
4140 case SHT_TI_XREF
: return "TI_XREF";
4141 case SHT_TI_HANDLER
: return "TI_HANDLER";
4142 case SHT_TI_INITINFO
: return "TI_INITINFO";
4143 case SHT_TI_PHATTRS
: return "TI_PHATTRS";
4144 default: return NULL
;
4149 get_msp430x_section_type_name (unsigned int sh_type
)
4153 case SHT_MSP430_SEC_FLAGS
: return "MSP430_SEC_FLAGS";
4154 case SHT_MSP430_SYM_ALIASES
: return "MSP430_SYM_ALIASES";
4155 case SHT_MSP430_ATTRIBUTES
: return "MSP430_ATTRIBUTES";
4156 default: return NULL
;
4161 get_nfp_section_type_name (unsigned int sh_type
)
4165 case SHT_NFP_MECONFIG
: return "NFP_MECONFIG";
4166 case SHT_NFP_INITREG
: return "NFP_INITREG";
4167 case SHT_NFP_UDEBUG
: return "NFP_UDEBUG";
4168 default: return NULL
;
4173 get_v850_section_type_name (unsigned int sh_type
)
4177 case SHT_V850_SCOMMON
: return "V850 Small Common";
4178 case SHT_V850_TCOMMON
: return "V850 Tiny Common";
4179 case SHT_V850_ZCOMMON
: return "V850 Zero Common";
4180 case SHT_RENESAS_IOP
: return "RENESAS IOP";
4181 case SHT_RENESAS_INFO
: return "RENESAS INFO";
4182 default: return NULL
;
4187 get_section_type_name (Filedata
* filedata
, unsigned int sh_type
)
4189 static char buff
[32];
4190 const char * result
;
4194 case SHT_NULL
: return "NULL";
4195 case SHT_PROGBITS
: return "PROGBITS";
4196 case SHT_SYMTAB
: return "SYMTAB";
4197 case SHT_STRTAB
: return "STRTAB";
4198 case SHT_RELA
: return "RELA";
4199 case SHT_HASH
: return "HASH";
4200 case SHT_DYNAMIC
: return "DYNAMIC";
4201 case SHT_NOTE
: return "NOTE";
4202 case SHT_NOBITS
: return "NOBITS";
4203 case SHT_REL
: return "REL";
4204 case SHT_SHLIB
: return "SHLIB";
4205 case SHT_DYNSYM
: return "DYNSYM";
4206 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
4207 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
4208 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
4209 case SHT_GNU_HASH
: return "GNU_HASH";
4210 case SHT_GROUP
: return "GROUP";
4211 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
4212 case SHT_GNU_verdef
: return "VERDEF";
4213 case SHT_GNU_verneed
: return "VERNEED";
4214 case SHT_GNU_versym
: return "VERSYM";
4215 case 0x6ffffff0: return "VERSYM";
4216 case 0x6ffffffc: return "VERDEF";
4217 case 0x7ffffffd: return "AUXILIARY";
4218 case 0x7fffffff: return "FILTER";
4219 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
4222 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
4224 switch (filedata
->file_header
.e_machine
)
4227 case EM_ARC_COMPACT
:
4228 case EM_ARC_COMPACT2
:
4229 result
= get_arc_section_type_name (sh_type
);
4232 case EM_MIPS_RS3_LE
:
4233 result
= get_mips_section_type_name (sh_type
);
4236 result
= get_parisc_section_type_name (sh_type
);
4239 result
= get_ia64_section_type_name (filedata
, sh_type
);
4244 result
= get_x86_64_section_type_name (sh_type
);
4247 result
= get_aarch64_section_type_name (sh_type
);
4250 result
= get_arm_section_type_name (sh_type
);
4253 result
= get_tic6x_section_type_name (sh_type
);
4256 result
= get_msp430x_section_type_name (sh_type
);
4259 result
= get_nfp_section_type_name (sh_type
);
4263 case EM_CYGNUS_V850
:
4264 result
= get_v850_section_type_name (sh_type
);
4274 sprintf (buff
, "LOPROC+%#x", sh_type
- SHT_LOPROC
);
4276 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
4278 switch (filedata
->file_header
.e_machine
)
4281 result
= get_ia64_section_type_name (filedata
, sh_type
);
4284 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
4285 result
= get_solaris_section_type (sh_type
);
4290 case SHT_GNU_INCREMENTAL_INPUTS
: result
= "GNU_INCREMENTAL_INPUTS"; break;
4291 case SHT_GNU_ATTRIBUTES
: result
= "GNU_ATTRIBUTES"; break;
4292 case SHT_GNU_HASH
: result
= "GNU_HASH"; break;
4293 case SHT_GNU_LIBLIST
: result
= "GNU_LIBLIST"; break;
4305 sprintf (buff
, "LOOS+%#x", sh_type
- SHT_LOOS
);
4307 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
4309 switch (filedata
->file_header
.e_machine
)
4313 case EM_CYGNUS_V850
:
4314 result
= get_v850_section_type_name (sh_type
);
4324 sprintf (buff
, "LOUSER+%#x", sh_type
- SHT_LOUSER
);
4327 /* This message is probably going to be displayed in a 15
4328 character wide field, so put the hex value first. */
4329 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
4335 #define OPTION_DEBUG_DUMP 512
4336 #define OPTION_DYN_SYMS 513
4337 #define OPTION_DWARF_DEPTH 514
4338 #define OPTION_DWARF_START 515
4339 #define OPTION_DWARF_CHECK 516
4341 static struct option options
[] =
4343 {"all", no_argument
, 0, 'a'},
4344 {"file-header", no_argument
, 0, 'h'},
4345 {"program-headers", no_argument
, 0, 'l'},
4346 {"headers", no_argument
, 0, 'e'},
4347 {"histogram", no_argument
, 0, 'I'},
4348 {"segments", no_argument
, 0, 'l'},
4349 {"sections", no_argument
, 0, 'S'},
4350 {"section-headers", no_argument
, 0, 'S'},
4351 {"section-groups", no_argument
, 0, 'g'},
4352 {"section-details", no_argument
, 0, 't'},
4353 {"full-section-name",no_argument
, 0, 'N'},
4354 {"symbols", no_argument
, 0, 's'},
4355 {"syms", no_argument
, 0, 's'},
4356 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
4357 {"relocs", no_argument
, 0, 'r'},
4358 {"notes", no_argument
, 0, 'n'},
4359 {"dynamic", no_argument
, 0, 'd'},
4360 {"arch-specific", no_argument
, 0, 'A'},
4361 {"version-info", no_argument
, 0, 'V'},
4362 {"use-dynamic", no_argument
, 0, 'D'},
4363 {"unwind", no_argument
, 0, 'u'},
4364 {"archive-index", no_argument
, 0, 'c'},
4365 {"hex-dump", required_argument
, 0, 'x'},
4366 {"relocated-dump", required_argument
, 0, 'R'},
4367 {"string-dump", required_argument
, 0, 'p'},
4368 {"decompress", no_argument
, 0, 'z'},
4369 #ifdef SUPPORT_DISASSEMBLY
4370 {"instruction-dump", required_argument
, 0, 'i'},
4372 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
4374 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
4375 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
4376 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
4378 {"version", no_argument
, 0, 'v'},
4379 {"wide", no_argument
, 0, 'W'},
4380 {"help", no_argument
, 0, 'H'},
4381 {0, no_argument
, 0, 0}
4385 usage (FILE * stream
)
4387 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
4388 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
4389 fprintf (stream
, _(" Options are:\n\
4390 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4391 -h --file-header Display the ELF file header\n\
4392 -l --program-headers Display the program headers\n\
4393 --segments An alias for --program-headers\n\
4394 -S --section-headers Display the sections' header\n\
4395 --sections An alias for --section-headers\n\
4396 -g --section-groups Display the section groups\n\
4397 -t --section-details Display the section details\n\
4398 -e --headers Equivalent to: -h -l -S\n\
4399 -s --syms Display the symbol table\n\
4400 --symbols An alias for --syms\n\
4401 --dyn-syms Display the dynamic symbol table\n\
4402 -n --notes Display the core notes (if present)\n\
4403 -r --relocs Display the relocations (if present)\n\
4404 -u --unwind Display the unwind info (if present)\n\
4405 -d --dynamic Display the dynamic section (if present)\n\
4406 -V --version-info Display the version sections (if present)\n\
4407 -A --arch-specific Display architecture specific information (if any)\n\
4408 -c --archive-index Display the symbol/file index in an archive\n\
4409 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
4410 -x --hex-dump=<number|name>\n\
4411 Dump the contents of section <number|name> as bytes\n\
4412 -p --string-dump=<number|name>\n\
4413 Dump the contents of section <number|name> as strings\n\
4414 -R --relocated-dump=<number|name>\n\
4415 Dump the contents of section <number|name> as relocated bytes\n\
4416 -z --decompress Decompress section before dumping it\n\
4417 -w[lLiaprmfFsoRtUuTgAckK] or\n\
4418 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4419 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4420 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4421 =addr,=cu_index,=links,=follow-links]\n\
4422 Display the contents of DWARF debug sections\n"));
4423 fprintf (stream
, _("\
4424 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4425 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4427 #ifdef SUPPORT_DISASSEMBLY
4428 fprintf (stream
, _("\
4429 -i --instruction-dump=<number|name>\n\
4430 Disassemble the contents of section <number|name>\n"));
4432 fprintf (stream
, _("\
4433 -I --histogram Display histogram of bucket list lengths\n\
4434 -W --wide Allow output width to exceed 80 characters\n\
4435 @<file> Read options from <file>\n\
4436 -H --help Display this information\n\
4437 -v --version Display the version number of readelf\n"));
4439 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
4440 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
4442 exit (stream
== stdout
? 0 : 1);
4445 /* Record the fact that the user wants the contents of section number
4446 SECTION to be displayed using the method(s) encoded as flags bits
4447 in TYPE. Note, TYPE can be zero if we are creating the array for
4451 request_dump_bynumber (Filedata
* filedata
, unsigned int section
, dump_type type
)
4453 if (section
>= filedata
->num_dump_sects
)
4455 dump_type
* new_dump_sects
;
4457 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
4458 sizeof (* new_dump_sects
));
4460 if (new_dump_sects
== NULL
)
4461 error (_("Out of memory allocating dump request table.\n"));
4464 if (filedata
->dump_sects
)
4466 /* Copy current flag settings. */
4467 memcpy (new_dump_sects
, filedata
->dump_sects
,
4468 filedata
->num_dump_sects
* sizeof (* new_dump_sects
));
4470 free (filedata
->dump_sects
);
4473 filedata
->dump_sects
= new_dump_sects
;
4474 filedata
->num_dump_sects
= section
+ 1;
4478 if (filedata
->dump_sects
)
4479 filedata
->dump_sects
[section
] |= type
;
4482 /* Request a dump by section name. */
4485 request_dump_byname (const char * section
, dump_type type
)
4487 struct dump_list_entry
* new_request
;
4489 new_request
= (struct dump_list_entry
*)
4490 malloc (sizeof (struct dump_list_entry
));
4492 error (_("Out of memory allocating dump request table.\n"));
4494 new_request
->name
= strdup (section
);
4495 if (!new_request
->name
)
4496 error (_("Out of memory allocating dump request table.\n"));
4498 new_request
->type
= type
;
4500 new_request
->next
= dump_sects_byname
;
4501 dump_sects_byname
= new_request
;
4505 request_dump (Filedata
* filedata
, dump_type type
)
4511 section
= strtoul (optarg
, & cp
, 0);
4513 if (! *cp
&& section
>= 0)
4514 request_dump_bynumber (filedata
, section
, type
);
4516 request_dump_byname (optarg
, type
);
4520 parse_args (Filedata
* filedata
, int argc
, char ** argv
)
4527 while ((c
= getopt_long
4528 (argc
, argv
, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options
, NULL
)) != EOF
)
4546 do_section_groups
= TRUE
;
4549 do_histogram
= TRUE
;
4554 do_section_groups
= TRUE
;
4559 do_section_details
= TRUE
;
4570 do_using_dynamic
= TRUE
;
4594 do_histogram
= TRUE
;
4600 do_archive_index
= TRUE
;
4603 request_dump (filedata
, HEX_DUMP
);
4606 request_dump (filedata
, STRING_DUMP
);
4609 request_dump (filedata
, RELOC_DUMP
);
4612 decompress_dumps
= TRUE
;
4618 do_debugging
= TRUE
;
4619 dwarf_select_sections_all ();
4623 do_debugging
= FALSE
;
4624 dwarf_select_sections_by_letters (optarg
);
4627 case OPTION_DEBUG_DUMP
:
4630 do_debugging
= TRUE
;
4633 do_debugging
= FALSE
;
4634 dwarf_select_sections_by_names (optarg
);
4637 case OPTION_DWARF_DEPTH
:
4641 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
4644 case OPTION_DWARF_START
:
4648 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
4651 case OPTION_DWARF_CHECK
:
4654 case OPTION_DYN_SYMS
:
4657 #ifdef SUPPORT_DISASSEMBLY
4659 request_dump (filedata
, DISASS_DUMP
);
4663 print_version (program_name
);
4672 /* xgettext:c-format */
4673 error (_("Invalid option '-%c'\n"), c
);
4680 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
4681 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
4682 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
4683 && !do_section_groups
&& !do_archive_index
4689 get_elf_class (unsigned int elf_class
)
4691 static char buff
[32];
4695 case ELFCLASSNONE
: return _("none");
4696 case ELFCLASS32
: return "ELF32";
4697 case ELFCLASS64
: return "ELF64";
4699 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
4705 get_data_encoding (unsigned int encoding
)
4707 static char buff
[32];
4711 case ELFDATANONE
: return _("none");
4712 case ELFDATA2LSB
: return _("2's complement, little endian");
4713 case ELFDATA2MSB
: return _("2's complement, big endian");
4715 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
4720 /* Decode the data held in 'filedata->file_header'. */
4723 process_file_header (Filedata
* filedata
)
4725 Elf_Internal_Ehdr
* header
= & filedata
->file_header
;
4727 if ( header
->e_ident
[EI_MAG0
] != ELFMAG0
4728 || header
->e_ident
[EI_MAG1
] != ELFMAG1
4729 || header
->e_ident
[EI_MAG2
] != ELFMAG2
4730 || header
->e_ident
[EI_MAG3
] != ELFMAG3
)
4733 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4737 init_dwarf_regnames (header
->e_machine
);
4743 printf (_("ELF Header:\n"));
4744 printf (_(" Magic: "));
4745 for (i
= 0; i
< EI_NIDENT
; i
++)
4746 printf ("%2.2x ", header
->e_ident
[i
]);
4748 printf (_(" Class: %s\n"),
4749 get_elf_class (header
->e_ident
[EI_CLASS
]));
4750 printf (_(" Data: %s\n"),
4751 get_data_encoding (header
->e_ident
[EI_DATA
]));
4752 printf (_(" Version: %d %s\n"),
4753 header
->e_ident
[EI_VERSION
],
4754 (header
->e_ident
[EI_VERSION
] == EV_CURRENT
4756 : (header
->e_ident
[EI_VERSION
] != EV_NONE
4757 ? _("<unknown: %lx>")
4759 printf (_(" OS/ABI: %s\n"),
4760 get_osabi_name (filedata
, header
->e_ident
[EI_OSABI
]));
4761 printf (_(" ABI Version: %d\n"),
4762 header
->e_ident
[EI_ABIVERSION
]);
4763 printf (_(" Type: %s\n"),
4764 get_file_type (header
->e_type
));
4765 printf (_(" Machine: %s\n"),
4766 get_machine_name (header
->e_machine
));
4767 printf (_(" Version: 0x%lx\n"),
4768 (unsigned long) header
->e_version
);
4770 printf (_(" Entry point address: "));
4771 print_vma ((bfd_vma
) header
->e_entry
, PREFIX_HEX
);
4772 printf (_("\n Start of program headers: "));
4773 print_vma ((bfd_vma
) header
->e_phoff
, DEC
);
4774 printf (_(" (bytes into file)\n Start of section headers: "));
4775 print_vma ((bfd_vma
) header
->e_shoff
, DEC
);
4776 printf (_(" (bytes into file)\n"));
4778 printf (_(" Flags: 0x%lx%s\n"),
4779 (unsigned long) header
->e_flags
,
4780 get_machine_flags (filedata
, header
->e_flags
, header
->e_machine
));
4781 printf (_(" Size of this header: %ld (bytes)\n"),
4782 (long) header
->e_ehsize
);
4783 printf (_(" Size of program headers: %ld (bytes)\n"),
4784 (long) header
->e_phentsize
);
4785 printf (_(" Number of program headers: %ld"),
4786 (long) header
->e_phnum
);
4787 if (filedata
->section_headers
!= NULL
4788 && header
->e_phnum
== PN_XNUM
4789 && filedata
->section_headers
[0].sh_info
!= 0)
4790 printf (" (%ld)", (long) filedata
->section_headers
[0].sh_info
);
4791 putc ('\n', stdout
);
4792 printf (_(" Size of section headers: %ld (bytes)\n"),
4793 (long) header
->e_shentsize
);
4794 printf (_(" Number of section headers: %ld"),
4795 (long) header
->e_shnum
);
4796 if (filedata
->section_headers
!= NULL
&& header
->e_shnum
== SHN_UNDEF
)
4797 printf (" (%ld)", (long) filedata
->section_headers
[0].sh_size
);
4798 putc ('\n', stdout
);
4799 printf (_(" Section header string table index: %ld"),
4800 (long) header
->e_shstrndx
);
4801 if (filedata
->section_headers
!= NULL
4802 && header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
4803 printf (" (%u)", filedata
->section_headers
[0].sh_link
);
4804 else if (header
->e_shstrndx
!= SHN_UNDEF
4805 && header
->e_shstrndx
>= header
->e_shnum
)
4806 printf (_(" <corrupt: out of range>"));
4807 putc ('\n', stdout
);
4810 if (filedata
->section_headers
!= NULL
)
4812 if (header
->e_phnum
== PN_XNUM
4813 && filedata
->section_headers
[0].sh_info
!= 0)
4814 header
->e_phnum
= filedata
->section_headers
[0].sh_info
;
4815 if (header
->e_shnum
== SHN_UNDEF
)
4816 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
4817 if (header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
4818 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
4819 if (header
->e_shstrndx
>= header
->e_shnum
)
4820 header
->e_shstrndx
= SHN_UNDEF
;
4821 free (filedata
->section_headers
);
4822 filedata
->section_headers
= NULL
;
4828 /* Read in the program headers from FILEDATA and store them in PHEADERS.
4829 Returns TRUE upon success, FALSE otherwise. Loads 32-bit headers. */
4832 get_32bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
4834 Elf32_External_Phdr
* phdrs
;
4835 Elf32_External_Phdr
* external
;
4836 Elf_Internal_Phdr
* internal
;
4838 unsigned int size
= filedata
->file_header
.e_phentsize
;
4839 unsigned int num
= filedata
->file_header
.e_phnum
;
4841 /* PR binutils/17531: Cope with unexpected section header sizes. */
4842 if (size
== 0 || num
== 0)
4844 if (size
< sizeof * phdrs
)
4846 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4849 if (size
> sizeof * phdrs
)
4850 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4852 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
4853 size
, num
, _("program headers"));
4857 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4858 i
< filedata
->file_header
.e_phnum
;
4859 i
++, internal
++, external
++)
4861 internal
->p_type
= BYTE_GET (external
->p_type
);
4862 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4863 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4864 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4865 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4866 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4867 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4868 internal
->p_align
= BYTE_GET (external
->p_align
);
4875 /* Read in the program headers from FILEDATA and store them in PHEADERS.
4876 Returns TRUE upon success, FALSE otherwise. Loads 64-bit headers. */
4879 get_64bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
4881 Elf64_External_Phdr
* phdrs
;
4882 Elf64_External_Phdr
* external
;
4883 Elf_Internal_Phdr
* internal
;
4885 unsigned int size
= filedata
->file_header
.e_phentsize
;
4886 unsigned int num
= filedata
->file_header
.e_phnum
;
4888 /* PR binutils/17531: Cope with unexpected section header sizes. */
4889 if (size
== 0 || num
== 0)
4891 if (size
< sizeof * phdrs
)
4893 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4896 if (size
> sizeof * phdrs
)
4897 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4899 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
4900 size
, num
, _("program headers"));
4904 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4905 i
< filedata
->file_header
.e_phnum
;
4906 i
++, internal
++, external
++)
4908 internal
->p_type
= BYTE_GET (external
->p_type
);
4909 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4910 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4911 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4912 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4913 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4914 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4915 internal
->p_align
= BYTE_GET (external
->p_align
);
4922 /* Returns TRUE if the program headers were read into `program_headers'. */
4925 get_program_headers (Filedata
* filedata
)
4927 Elf_Internal_Phdr
* phdrs
;
4929 /* Check cache of prior read. */
4930 if (filedata
->program_headers
!= NULL
)
4933 /* Be kind to memory checkers by looking for
4934 e_phnum values which we know must be invalid. */
4935 if (filedata
->file_header
.e_phnum
4936 * (is_32bit_elf
? sizeof (Elf32_External_Phdr
) : sizeof (Elf64_External_Phdr
))
4937 >= filedata
->file_size
)
4939 error (_("Too many program headers - %#x - the file is not that big\n"),
4940 filedata
->file_header
.e_phnum
);
4944 phdrs
= (Elf_Internal_Phdr
*) cmalloc (filedata
->file_header
.e_phnum
,
4945 sizeof (Elf_Internal_Phdr
));
4948 error (_("Out of memory reading %u program headers\n"),
4949 filedata
->file_header
.e_phnum
);
4954 ? get_32bit_program_headers (filedata
, phdrs
)
4955 : get_64bit_program_headers (filedata
, phdrs
))
4957 filedata
->program_headers
= phdrs
;
4965 /* Returns TRUE if the program headers were loaded. */
4968 process_program_headers (Filedata
* filedata
)
4970 Elf_Internal_Phdr
* segment
;
4972 Elf_Internal_Phdr
* previous_load
= NULL
;
4974 if (filedata
->file_header
.e_phnum
== 0)
4976 /* PR binutils/12467. */
4977 if (filedata
->file_header
.e_phoff
!= 0)
4979 warn (_("possibly corrupt ELF header - it has a non-zero program"
4980 " header offset, but no program headers\n"));
4983 else if (do_segments
)
4984 printf (_("\nThere are no program headers in this file.\n"));
4988 if (do_segments
&& !do_header
)
4990 printf (_("\nElf file type is %s\n"), get_file_type (filedata
->file_header
.e_type
));
4991 printf (_("Entry point 0x%s\n"), bfd_vmatoa ("x", filedata
->file_header
.e_entry
));
4992 printf (ngettext ("There is %d program header, starting at offset %s\n",
4993 "There are %d program headers, starting at offset %s\n",
4994 filedata
->file_header
.e_phnum
),
4995 filedata
->file_header
.e_phnum
,
4996 bfd_vmatoa ("u", filedata
->file_header
.e_phoff
));
4999 if (! get_program_headers (filedata
))
5004 if (filedata
->file_header
.e_phnum
> 1)
5005 printf (_("\nProgram Headers:\n"));
5007 printf (_("\nProgram Headers:\n"));
5011 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5014 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
5018 (_(" Type Offset VirtAddr PhysAddr\n"));
5020 (_(" FileSiz MemSiz Flags Align\n"));
5027 for (i
= 0, segment
= filedata
->program_headers
;
5028 i
< filedata
->file_header
.e_phnum
;
5033 printf (" %-14.14s ", get_segment_type (filedata
, segment
->p_type
));
5037 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
5038 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
5039 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
5040 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
5041 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
5043 (segment
->p_flags
& PF_R
? 'R' : ' '),
5044 (segment
->p_flags
& PF_W
? 'W' : ' '),
5045 (segment
->p_flags
& PF_X
? 'E' : ' '));
5046 printf ("%#lx", (unsigned long) segment
->p_align
);
5050 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
5051 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
5054 print_vma (segment
->p_offset
, FULL_HEX
);
5058 print_vma (segment
->p_vaddr
, FULL_HEX
);
5060 print_vma (segment
->p_paddr
, FULL_HEX
);
5063 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
5064 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
5067 print_vma (segment
->p_filesz
, FULL_HEX
);
5071 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
5072 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
5075 print_vma (segment
->p_memsz
, FULL_HEX
);
5079 (segment
->p_flags
& PF_R
? 'R' : ' '),
5080 (segment
->p_flags
& PF_W
? 'W' : ' '),
5081 (segment
->p_flags
& PF_X
? 'E' : ' '));
5083 if ((unsigned long) segment
->p_align
== segment
->p_align
)
5084 printf ("%#lx", (unsigned long) segment
->p_align
);
5087 print_vma (segment
->p_align
, PREFIX_HEX
);
5092 print_vma (segment
->p_offset
, FULL_HEX
);
5094 print_vma (segment
->p_vaddr
, FULL_HEX
);
5096 print_vma (segment
->p_paddr
, FULL_HEX
);
5098 print_vma (segment
->p_filesz
, FULL_HEX
);
5100 print_vma (segment
->p_memsz
, FULL_HEX
);
5102 (segment
->p_flags
& PF_R
? 'R' : ' '),
5103 (segment
->p_flags
& PF_W
? 'W' : ' '),
5104 (segment
->p_flags
& PF_X
? 'E' : ' '));
5105 print_vma (segment
->p_align
, PREFIX_HEX
);
5108 putc ('\n', stdout
);
5111 switch (segment
->p_type
)
5114 #if 0 /* Do not warn about out of order PT_LOAD segments. Although officially
5115 required by the ELF standard, several programs, including the Linux
5116 kernel, make use of non-ordered segments. */
5118 && previous_load
->p_vaddr
> segment
->p_vaddr
)
5119 error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
5121 if (segment
->p_memsz
< segment
->p_filesz
)
5122 error (_("the segment's file size is larger than its memory size\n"));
5123 previous_load
= segment
;
5127 /* PR 20815 - Verify that the program header is loaded into memory. */
5128 if (i
> 0 && previous_load
!= NULL
)
5129 error (_("the PHDR segment must occur before any LOAD segment\n"));
5130 if (filedata
->file_header
.e_machine
!= EM_PARISC
)
5134 for (j
= 1; j
< filedata
->file_header
.e_phnum
; j
++)
5135 if (filedata
->program_headers
[j
].p_vaddr
<= segment
->p_vaddr
5136 && (filedata
->program_headers
[j
].p_vaddr
5137 + filedata
->program_headers
[j
].p_memsz
)
5138 >= (segment
->p_vaddr
+ segment
->p_filesz
))
5140 if (j
== filedata
->file_header
.e_phnum
)
5141 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5147 error (_("more than one dynamic segment\n"));
5149 /* By default, assume that the .dynamic section is the first
5150 section in the DYNAMIC segment. */
5151 dynamic_addr
= segment
->p_offset
;
5152 dynamic_size
= segment
->p_filesz
;
5154 /* Try to locate the .dynamic section. If there is
5155 a section header table, we can easily locate it. */
5156 if (filedata
->section_headers
!= NULL
)
5158 Elf_Internal_Shdr
* sec
;
5160 sec
= find_section (filedata
, ".dynamic");
5161 if (sec
== NULL
|| sec
->sh_size
== 0)
5163 /* A corresponding .dynamic section is expected, but on
5164 IA-64/OpenVMS it is OK for it to be missing. */
5165 if (!is_ia64_vms (filedata
))
5166 error (_("no .dynamic section in the dynamic segment\n"));
5170 if (sec
->sh_type
== SHT_NOBITS
)
5176 dynamic_addr
= sec
->sh_offset
;
5177 dynamic_size
= sec
->sh_size
;
5179 if (dynamic_addr
< segment
->p_offset
5180 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
5181 warn (_("the .dynamic section is not contained"
5182 " within the dynamic segment\n"));
5183 else if (dynamic_addr
> segment
->p_offset
)
5184 warn (_("the .dynamic section is not the first section"
5185 " in the dynamic segment.\n"));
5188 /* PR binutils/17512: Avoid corrupt dynamic section info in the
5189 segment. Check this after matching against the section headers
5190 so we don't warn on debuginfo file (which have NOBITS .dynamic
5192 if (dynamic_addr
+ dynamic_size
>= filedata
->file_size
)
5194 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5195 dynamic_addr
= dynamic_size
= 0;
5200 if (fseek (filedata
->handle
, archive_file_offset
+ (long) segment
->p_offset
,
5202 error (_("Unable to find program interpreter name\n"));
5206 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
- 1);
5208 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
5209 error (_("Internal error: failed to create format string to display program interpreter\n"));
5211 program_interpreter
[0] = 0;
5212 if (fscanf (filedata
->handle
, fmt
, program_interpreter
) <= 0)
5213 error (_("Unable to read program interpreter name\n"));
5216 printf (_(" [Requesting program interpreter: %s]\n"),
5217 program_interpreter
);
5224 && filedata
->section_headers
!= NULL
5225 && filedata
->string_table
!= NULL
)
5227 printf (_("\n Section to Segment mapping:\n"));
5228 printf (_(" Segment Sections...\n"));
5230 for (i
= 0; i
< filedata
->file_header
.e_phnum
; i
++)
5233 Elf_Internal_Shdr
* section
;
5235 segment
= filedata
->program_headers
+ i
;
5236 section
= filedata
->section_headers
+ 1;
5238 printf (" %2.2d ", i
);
5240 for (j
= 1; j
< filedata
->file_header
.e_shnum
; j
++, section
++)
5242 if (!ELF_TBSS_SPECIAL (section
, segment
)
5243 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
5244 printf ("%s ", printable_section_name (filedata
, section
));
5255 /* Find the file offset corresponding to VMA by using the program headers. */
5258 offset_from_vma (Filedata
* filedata
, bfd_vma vma
, bfd_size_type size
)
5260 Elf_Internal_Phdr
* seg
;
5262 if (! get_program_headers (filedata
))
5264 warn (_("Cannot interpret virtual addresses without program headers.\n"));
5268 for (seg
= filedata
->program_headers
;
5269 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
5272 if (seg
->p_type
!= PT_LOAD
)
5275 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
5276 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
5277 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
5280 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5281 (unsigned long) vma
);
5286 /* Allocate memory and load the sections headers into FILEDATA->filedata->section_headers.
5287 If PROBE is true, this is just a probe and we do not generate any error
5288 messages if the load fails. */
5291 get_32bit_section_headers (Filedata
* filedata
, bfd_boolean probe
)
5293 Elf32_External_Shdr
* shdrs
;
5294 Elf_Internal_Shdr
* internal
;
5296 unsigned int size
= filedata
->file_header
.e_shentsize
;
5297 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
5299 /* PR binutils/17531: Cope with unexpected section header sizes. */
5300 if (size
== 0 || num
== 0)
5302 if (size
< sizeof * shdrs
)
5305 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5308 if (!probe
&& size
> sizeof * shdrs
)
5309 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5311 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_shoff
,
5313 probe
? NULL
: _("section headers"));
5317 free (filedata
->section_headers
);
5318 filedata
->section_headers
= (Elf_Internal_Shdr
*)
5319 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
5320 if (filedata
->section_headers
== NULL
)
5323 error (_("Out of memory reading %u section headers\n"), num
);
5327 for (i
= 0, internal
= filedata
->section_headers
;
5331 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5332 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5333 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5334 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5335 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5336 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5337 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5338 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5339 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5340 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5341 if (!probe
&& internal
->sh_link
> num
)
5342 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5343 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5344 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5351 /* Like get_32bit_section_headers, except that it fetches 64-bit headers. */
5354 get_64bit_section_headers (Filedata
* filedata
, bfd_boolean probe
)
5356 Elf64_External_Shdr
* shdrs
;
5357 Elf_Internal_Shdr
* internal
;
5359 unsigned int size
= filedata
->file_header
.e_shentsize
;
5360 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
5362 /* PR binutils/17531: Cope with unexpected section header sizes. */
5363 if (size
== 0 || num
== 0)
5366 if (size
< sizeof * shdrs
)
5369 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5373 if (! probe
&& size
> sizeof * shdrs
)
5374 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5376 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, filedata
,
5377 filedata
->file_header
.e_shoff
,
5379 probe
? NULL
: _("section headers"));
5383 free (filedata
->section_headers
);
5384 filedata
->section_headers
= (Elf_Internal_Shdr
*)
5385 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
5386 if (filedata
->section_headers
== NULL
)
5389 error (_("Out of memory reading %u section headers\n"), num
);
5393 for (i
= 0, internal
= filedata
->section_headers
;
5397 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5398 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5399 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5400 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5401 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5402 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5403 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5404 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5405 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5406 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5407 if (!probe
&& internal
->sh_link
> num
)
5408 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5409 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5410 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5417 static Elf_Internal_Sym
*
5418 get_32bit_elf_symbols (Filedata
* filedata
,
5419 Elf_Internal_Shdr
* section
,
5420 unsigned long * num_syms_return
)
5422 unsigned long number
= 0;
5423 Elf32_External_Sym
* esyms
= NULL
;
5424 Elf_External_Sym_Shndx
* shndx
= NULL
;
5425 Elf_Internal_Sym
* isyms
= NULL
;
5426 Elf_Internal_Sym
* psym
;
5429 if (section
->sh_size
== 0)
5431 if (num_syms_return
!= NULL
)
5432 * num_syms_return
= 0;
5436 /* Run some sanity checks first. */
5437 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5439 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5440 printable_section_name (filedata
, section
),
5441 (unsigned long) section
->sh_entsize
);
5445 if (section
->sh_size
> filedata
->file_size
)
5447 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5448 printable_section_name (filedata
, section
),
5449 (unsigned long) section
->sh_size
);
5453 number
= section
->sh_size
/ section
->sh_entsize
;
5455 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
5457 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5458 (unsigned long) section
->sh_size
,
5459 printable_section_name (filedata
, section
),
5460 (unsigned long) section
->sh_entsize
);
5464 esyms
= (Elf32_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
5465 section
->sh_size
, _("symbols"));
5470 elf_section_list
* entry
;
5473 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5474 if (entry
->hdr
->sh_link
== (unsigned long) (section
- filedata
->section_headers
))
5476 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
5477 entry
->hdr
->sh_offset
,
5478 1, entry
->hdr
->sh_size
,
5479 _("symbol table section indicies"));
5482 /* PR17531: file: heap-buffer-overflow */
5483 else if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5485 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5486 printable_section_name (filedata
, entry
->hdr
),
5487 (unsigned long) entry
->hdr
->sh_size
,
5488 (unsigned long) section
->sh_size
);
5494 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5498 error (_("Out of memory reading %lu symbols\n"),
5499 (unsigned long) number
);
5503 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5505 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5506 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5507 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5508 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5509 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5511 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5512 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5513 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5514 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5515 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5524 if (num_syms_return
!= NULL
)
5525 * num_syms_return
= isyms
== NULL
? 0 : number
;
5530 static Elf_Internal_Sym
*
5531 get_64bit_elf_symbols (Filedata
* filedata
,
5532 Elf_Internal_Shdr
* section
,
5533 unsigned long * num_syms_return
)
5535 unsigned long number
= 0;
5536 Elf64_External_Sym
* esyms
= NULL
;
5537 Elf_External_Sym_Shndx
* shndx
= NULL
;
5538 Elf_Internal_Sym
* isyms
= NULL
;
5539 Elf_Internal_Sym
* psym
;
5542 if (section
->sh_size
== 0)
5544 if (num_syms_return
!= NULL
)
5545 * num_syms_return
= 0;
5549 /* Run some sanity checks first. */
5550 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5552 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5553 printable_section_name (filedata
, section
),
5554 (unsigned long) section
->sh_entsize
);
5558 if (section
->sh_size
> filedata
->file_size
)
5560 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5561 printable_section_name (filedata
, section
),
5562 (unsigned long) section
->sh_size
);
5566 number
= section
->sh_size
/ section
->sh_entsize
;
5568 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
5570 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5571 (unsigned long) section
->sh_size
,
5572 printable_section_name (filedata
, section
),
5573 (unsigned long) section
->sh_entsize
);
5577 esyms
= (Elf64_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
5578 section
->sh_size
, _("symbols"));
5583 elf_section_list
* entry
;
5586 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5587 if (entry
->hdr
->sh_link
== (unsigned long) (section
- filedata
->section_headers
))
5589 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
5590 entry
->hdr
->sh_offset
,
5591 1, entry
->hdr
->sh_size
,
5592 _("symbol table section indicies"));
5595 /* PR17531: file: heap-buffer-overflow */
5596 else if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5598 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5599 printable_section_name (filedata
, entry
->hdr
),
5600 (unsigned long) entry
->hdr
->sh_size
,
5601 (unsigned long) section
->sh_size
);
5607 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5611 error (_("Out of memory reading %lu symbols\n"),
5612 (unsigned long) number
);
5616 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5618 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5619 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5620 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5621 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5623 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5625 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5626 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5627 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5629 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5630 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5639 if (num_syms_return
!= NULL
)
5640 * num_syms_return
= isyms
== NULL
? 0 : number
;
5646 get_elf_section_flags (Filedata
* filedata
, bfd_vma sh_flags
)
5648 static char buff
[1024];
5650 unsigned int field_size
= is_32bit_elf
? 8 : 16;
5652 unsigned int size
= sizeof (buff
) - (field_size
+ 4 + 1);
5653 bfd_vma os_flags
= 0;
5654 bfd_vma proc_flags
= 0;
5655 bfd_vma unknown_flags
= 0;
5663 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5664 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5665 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5666 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5667 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5668 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5669 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5670 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5671 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5672 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5673 /* IA-64 specific. */
5674 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5675 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5676 /* IA-64 OpenVMS specific. */
5677 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5678 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5679 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5680 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5681 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5682 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5684 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5685 /* SPARC specific. */
5686 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5687 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5689 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5690 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5691 /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
5693 /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
5695 /* 25 */ { STRING_COMMA_LEN ("VLE") },
5698 if (do_section_details
)
5700 sprintf (buff
, "[%*.*lx]: ",
5701 field_size
, field_size
, (unsigned long) sh_flags
);
5702 p
+= field_size
+ 4;
5709 flag
= sh_flags
& - sh_flags
;
5712 if (do_section_details
)
5716 case SHF_WRITE
: sindex
= 0; break;
5717 case SHF_ALLOC
: sindex
= 1; break;
5718 case SHF_EXECINSTR
: sindex
= 2; break;
5719 case SHF_MERGE
: sindex
= 3; break;
5720 case SHF_STRINGS
: sindex
= 4; break;
5721 case SHF_INFO_LINK
: sindex
= 5; break;
5722 case SHF_LINK_ORDER
: sindex
= 6; break;
5723 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
5724 case SHF_GROUP
: sindex
= 8; break;
5725 case SHF_TLS
: sindex
= 9; break;
5726 case SHF_EXCLUDE
: sindex
= 18; break;
5727 case SHF_COMPRESSED
: sindex
= 20; break;
5728 case SHF_GNU_MBIND
: sindex
= 24; break;
5732 switch (filedata
->file_header
.e_machine
)
5735 if (flag
== SHF_IA_64_SHORT
)
5737 else if (flag
== SHF_IA_64_NORECOV
)
5740 else if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
5743 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
5744 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
5745 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
5746 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
5747 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
5748 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
5759 case EM_OLD_SPARCV9
:
5760 case EM_SPARC32PLUS
:
5763 if (flag
== SHF_ORDERED
)
5770 case SHF_ENTRYSECT
: sindex
= 21; break;
5771 case SHF_ARM_PURECODE
: sindex
= 22; break;
5772 case SHF_COMDEF
: sindex
= 23; break;
5777 if (flag
== SHF_PPC_VLE
)
5788 if (p
!= buff
+ field_size
+ 4)
5790 if (size
< (10 + 2))
5792 warn (_("Internal error: not enough buffer room for section flag info"));
5793 return _("<unknown>");
5800 size
-= flags
[sindex
].len
;
5801 p
= stpcpy (p
, flags
[sindex
].str
);
5803 else if (flag
& SHF_MASKOS
)
5805 else if (flag
& SHF_MASKPROC
)
5808 unknown_flags
|= flag
;
5814 case SHF_WRITE
: *p
= 'W'; break;
5815 case SHF_ALLOC
: *p
= 'A'; break;
5816 case SHF_EXECINSTR
: *p
= 'X'; break;
5817 case SHF_MERGE
: *p
= 'M'; break;
5818 case SHF_STRINGS
: *p
= 'S'; break;
5819 case SHF_INFO_LINK
: *p
= 'I'; break;
5820 case SHF_LINK_ORDER
: *p
= 'L'; break;
5821 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
5822 case SHF_GROUP
: *p
= 'G'; break;
5823 case SHF_TLS
: *p
= 'T'; break;
5824 case SHF_EXCLUDE
: *p
= 'E'; break;
5825 case SHF_COMPRESSED
: *p
= 'C'; break;
5826 case SHF_GNU_MBIND
: *p
= 'D'; break;
5829 if ((filedata
->file_header
.e_machine
== EM_X86_64
5830 || filedata
->file_header
.e_machine
== EM_L1OM
5831 || filedata
->file_header
.e_machine
== EM_K1OM
)
5832 && flag
== SHF_X86_64_LARGE
)
5834 else if (filedata
->file_header
.e_machine
== EM_ARM
5835 && flag
== SHF_ARM_PURECODE
)
5837 else if (filedata
->file_header
.e_machine
== EM_PPC
5838 && flag
== SHF_PPC_VLE
)
5840 else if (flag
& SHF_MASKOS
)
5843 sh_flags
&= ~ SHF_MASKOS
;
5845 else if (flag
& SHF_MASKPROC
)
5848 sh_flags
&= ~ SHF_MASKPROC
;
5858 if (do_section_details
)
5862 size
-= 5 + field_size
;
5863 if (p
!= buff
+ field_size
+ 4)
5867 warn (_("Internal error: not enough buffer room for section flag info"));
5868 return _("<unknown>");
5874 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
5875 (unsigned long) os_flags
);
5876 p
+= 5 + field_size
;
5880 size
-= 7 + field_size
;
5881 if (p
!= buff
+ field_size
+ 4)
5885 warn (_("Internal error: not enough buffer room for section flag info"));
5886 return _("<unknown>");
5892 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
5893 (unsigned long) proc_flags
);
5894 p
+= 7 + field_size
;
5898 size
-= 10 + field_size
;
5899 if (p
!= buff
+ field_size
+ 4)
5903 warn (_("Internal error: not enough buffer room for section flag info"));
5904 return _("<unknown>");
5910 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
5911 (unsigned long) unknown_flags
);
5912 p
+= 10 + field_size
;
5921 get_compression_header (Elf_Internal_Chdr
*chdr
, unsigned char *buf
, bfd_size_type size
)
5925 Elf32_External_Chdr
*echdr
= (Elf32_External_Chdr
*) buf
;
5927 if (size
< sizeof (* echdr
))
5929 error (_("Compressed section is too small even for a compression header\n"));
5933 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
5934 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
5935 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
5936 return sizeof (*echdr
);
5940 Elf64_External_Chdr
*echdr
= (Elf64_External_Chdr
*) buf
;
5942 if (size
< sizeof (* echdr
))
5944 error (_("Compressed section is too small even for a compression header\n"));
5948 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
5949 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
5950 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
5951 return sizeof (*echdr
);
5956 process_section_headers (Filedata
* filedata
)
5958 Elf_Internal_Shdr
* section
;
5961 filedata
->section_headers
= NULL
;
5963 if (filedata
->file_header
.e_shnum
== 0)
5965 /* PR binutils/12467. */
5966 if (filedata
->file_header
.e_shoff
!= 0)
5968 warn (_("possibly corrupt ELF file header - it has a non-zero"
5969 " section header offset, but no section headers\n"));
5972 else if (do_sections
)
5973 printf (_("\nThere are no sections in this file.\n"));
5978 if (do_sections
&& !do_header
)
5979 printf (ngettext ("There is %d section header, "
5980 "starting at offset 0x%lx:\n",
5981 "There are %d section headers, "
5982 "starting at offset 0x%lx:\n",
5983 filedata
->file_header
.e_shnum
),
5984 filedata
->file_header
.e_shnum
,
5985 (unsigned long) filedata
->file_header
.e_shoff
);
5989 if (! get_32bit_section_headers (filedata
, FALSE
))
5994 if (! get_64bit_section_headers (filedata
, FALSE
))
5998 /* Read in the string table, so that we have names to display. */
5999 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
6000 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
6002 section
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
6004 if (section
->sh_size
!= 0)
6006 filedata
->string_table
= (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6007 1, section
->sh_size
,
6010 filedata
->string_table_length
= filedata
->string_table
!= NULL
? section
->sh_size
: 0;
6014 /* Scan the sections for the dynamic symbol table
6015 and dynamic string table and debug sections. */
6016 dynamic_symbols
= NULL
;
6017 dynamic_strings
= NULL
;
6018 dynamic_syminfo
= NULL
;
6019 symtab_shndx_list
= NULL
;
6021 eh_addr_size
= is_32bit_elf
? 4 : 8;
6022 switch (filedata
->file_header
.e_machine
)
6025 case EM_MIPS_RS3_LE
:
6026 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
6027 FDE addresses. However, the ABI also has a semi-official ILP32
6028 variant for which the normal FDE address size rules apply.
6030 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
6031 section, where XX is the size of longs in bits. Unfortunately,
6032 earlier compilers provided no way of distinguishing ILP32 objects
6033 from LP64 objects, so if there's any doubt, we should assume that
6034 the official LP64 form is being used. */
6035 if ((filedata
->file_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
6036 && find_section (filedata
, ".gcc_compiled_long32") == NULL
)
6042 switch (filedata
->file_header
.e_flags
& EF_H8_MACH
)
6044 case E_H8_MACH_H8300
:
6045 case E_H8_MACH_H8300HN
:
6046 case E_H8_MACH_H8300SN
:
6047 case E_H8_MACH_H8300SXN
:
6050 case E_H8_MACH_H8300H
:
6051 case E_H8_MACH_H8300S
:
6052 case E_H8_MACH_H8300SX
:
6060 switch (filedata
->file_header
.e_flags
& EF_M32C_CPU_MASK
)
6062 case EF_M32C_CPU_M16C
:
6069 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
6072 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
6073 if (section->sh_entsize != expected_entsize) \
6076 sprintf_vma (buf, section->sh_entsize); \
6077 /* Note: coded this way so that there is a single string for \
6079 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
6080 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
6081 (unsigned) expected_entsize); \
6082 section->sh_entsize = expected_entsize; \
6087 #define CHECK_ENTSIZE(section, i, type) \
6088 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
6089 sizeof (Elf64_External_##type))
6091 for (i
= 0, section
= filedata
->section_headers
;
6092 i
< filedata
->file_header
.e_shnum
;
6095 char * name
= SECTION_NAME (section
);
6097 if (section
->sh_type
== SHT_DYNSYM
)
6099 if (dynamic_symbols
!= NULL
)
6101 error (_("File contains multiple dynamic symbol tables\n"));
6105 CHECK_ENTSIZE (section
, i
, Sym
);
6106 dynamic_symbols
= GET_ELF_SYMBOLS (filedata
, section
, & num_dynamic_syms
);
6108 else if (section
->sh_type
== SHT_STRTAB
6109 && streq (name
, ".dynstr"))
6111 if (dynamic_strings
!= NULL
)
6113 error (_("File contains multiple dynamic string tables\n"));
6117 dynamic_strings
= (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6118 1, section
->sh_size
,
6119 _("dynamic strings"));
6120 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : section
->sh_size
;
6122 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
6124 elf_section_list
* entry
= xmalloc (sizeof * entry
);
6126 entry
->hdr
= section
;
6127 entry
->next
= symtab_shndx_list
;
6128 symtab_shndx_list
= entry
;
6130 else if (section
->sh_type
== SHT_SYMTAB
)
6131 CHECK_ENTSIZE (section
, i
, Sym
);
6132 else if (section
->sh_type
== SHT_GROUP
)
6133 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
6134 else if (section
->sh_type
== SHT_REL
)
6135 CHECK_ENTSIZE (section
, i
, Rel
);
6136 else if (section
->sh_type
== SHT_RELA
)
6137 CHECK_ENTSIZE (section
, i
, Rela
);
6138 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
6139 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
6140 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
6141 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
6142 || do_debug_addr
|| do_debug_cu_index
|| do_debug_links
)
6143 && (const_strneq (name
, ".debug_")
6144 || const_strneq (name
, ".zdebug_")))
6147 name
+= sizeof (".zdebug_") - 1;
6149 name
+= sizeof (".debug_") - 1;
6152 || (do_debug_info
&& const_strneq (name
, "info"))
6153 || (do_debug_info
&& const_strneq (name
, "types"))
6154 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
6155 || (do_debug_lines
&& strcmp (name
, "line") == 0)
6156 || (do_debug_lines
&& const_strneq (name
, "line."))
6157 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
6158 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
6159 || (do_debug_pubnames
&& const_strneq (name
, "gnu_pubnames"))
6160 || (do_debug_pubtypes
&& const_strneq (name
, "gnu_pubtypes"))
6161 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
6162 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
6163 || (do_debug_ranges
&& const_strneq (name
, "rnglists"))
6164 || (do_debug_frames
&& const_strneq (name
, "frame"))
6165 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
6166 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
6167 || (do_debug_str
&& const_strneq (name
, "str"))
6168 || (do_debug_loc
&& const_strneq (name
, "loc"))
6169 || (do_debug_loc
&& const_strneq (name
, "loclists"))
6170 || (do_debug_addr
&& const_strneq (name
, "addr"))
6171 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
6172 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
6174 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6176 /* Linkonce section to be combined with .debug_info at link time. */
6177 else if ((do_debugging
|| do_debug_info
)
6178 && const_strneq (name
, ".gnu.linkonce.wi."))
6179 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6180 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
6181 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6182 else if (do_gdb_index
&& (streq (name
, ".gdb_index")
6183 || streq (name
, ".debug_names")))
6184 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6185 /* Trace sections for Itanium VMS. */
6186 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
6187 || do_trace_aranges
)
6188 && const_strneq (name
, ".trace_"))
6190 name
+= sizeof (".trace_") - 1;
6193 || (do_trace_info
&& streq (name
, "info"))
6194 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
6195 || (do_trace_aranges
&& streq (name
, "aranges"))
6197 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6199 else if ((do_debugging
|| do_debug_links
)
6200 && (const_strneq (name
, ".gnu_debuglink")
6201 || const_strneq (name
, ".gnu_debugaltlink")))
6202 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6208 if (filedata
->file_header
.e_shnum
> 1)
6209 printf (_("\nSection Headers:\n"));
6211 printf (_("\nSection Header:\n"));
6215 if (do_section_details
)
6217 printf (_(" [Nr] Name\n"));
6218 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
6222 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
6226 if (do_section_details
)
6228 printf (_(" [Nr] Name\n"));
6229 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
6233 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
6237 if (do_section_details
)
6239 printf (_(" [Nr] Name\n"));
6240 printf (_(" Type Address Offset Link\n"));
6241 printf (_(" Size EntSize Info Align\n"));
6245 printf (_(" [Nr] Name Type Address Offset\n"));
6246 printf (_(" Size EntSize Flags Link Info Align\n"));
6250 if (do_section_details
)
6251 printf (_(" Flags\n"));
6253 for (i
= 0, section
= filedata
->section_headers
;
6254 i
< filedata
->file_header
.e_shnum
;
6257 /* Run some sanity checks on the section header. */
6259 /* Check the sh_link field. */
6260 switch (section
->sh_type
)
6262 case SHT_SYMTAB_SHNDX
:
6266 case SHT_GNU_versym
:
6269 if (section
->sh_link
< 1
6270 || section
->sh_link
>= filedata
->file_header
.e_shnum
6271 || (filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_SYMTAB
6272 && filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_DYNSYM
))
6273 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6274 i
, section
->sh_link
);
6280 case SHT_GNU_verneed
:
6281 case SHT_GNU_verdef
:
6282 case SHT_GNU_LIBLIST
:
6283 if (section
->sh_link
< 1
6284 || section
->sh_link
>= filedata
->file_header
.e_shnum
6285 || filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_STRTAB
)
6286 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6287 i
, section
->sh_link
);
6290 case SHT_INIT_ARRAY
:
6291 case SHT_FINI_ARRAY
:
6292 case SHT_PREINIT_ARRAY
:
6293 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6294 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6295 i
, section
->sh_link
);
6299 /* FIXME: Add support for target specific section types. */
6300 #if 0 /* Currently we do not check other section types as there are too
6301 many special cases. Stab sections for example have a type
6302 of SHT_PROGBITS but an sh_link field that links to the .stabstr
6304 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6305 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6306 i
, section
->sh_link
);
6311 /* Check the sh_info field. */
6312 switch (section
->sh_type
)
6316 if (section
->sh_info
< 1
6317 || section
->sh_info
>= filedata
->file_header
.e_shnum
6318 || (filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PROGBITS
6319 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOBITS
6320 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOTE
6321 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_INIT_ARRAY
6322 /* FIXME: Are other section types valid ? */
6323 && filedata
->section_headers
[section
->sh_info
].sh_type
< SHT_LOOS
))
6325 if (section
->sh_info
== 0
6326 && (filedata
->file_header
.e_type
== ET_EXEC
6327 || filedata
->file_header
.e_type
== ET_DYN
6328 /* These next two tests may be redundant, but
6329 they have been left in for paranoia's sake. */
6330 || streq (SECTION_NAME (section
), ".rel.dyn")
6331 || streq (SECTION_NAME (section
), ".rela.dyn")))
6332 /* Dynamic relocations apply to segments, not sections, so
6333 they do not need an sh_info value. */
6336 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6337 i
, section
->sh_info
);
6343 case SHT_SYMTAB_SHNDX
:
6344 case SHT_INIT_ARRAY
:
6345 case SHT_FINI_ARRAY
:
6346 case SHT_PREINIT_ARRAY
:
6347 if (section
->sh_info
!= 0)
6348 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6349 i
, section
->sh_info
);
6355 /* A symbol index - we assume that it is valid. */
6359 /* FIXME: Add support for target specific section types. */
6360 if (section
->sh_type
== SHT_NOBITS
)
6361 /* NOBITS section headers with non-zero sh_info fields can be
6362 created when a binary is stripped of everything but its debug
6363 information. The stripped sections have their headers
6364 preserved but their types set to SHT_NOBITS. So do not check
6365 this type of section. */
6367 else if (section
->sh_flags
& SHF_INFO_LINK
)
6369 if (section
->sh_info
< 1 || section
->sh_info
>= filedata
->file_header
.e_shnum
)
6370 warn (_("[%2u]: Expected link to another section in info field"), i
);
6372 else if (section
->sh_type
< SHT_LOOS
6373 && (section
->sh_flags
& SHF_GNU_MBIND
) == 0
6374 && section
->sh_info
!= 0)
6375 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6376 i
, section
->sh_info
);
6380 /* Check the sh_size field. */
6381 if (section
->sh_size
> filedata
->file_size
6382 && section
->sh_type
!= SHT_NOBITS
6383 && section
->sh_type
!= SHT_NULL
6384 && section
->sh_type
< SHT_LOOS
)
6385 warn (_("Size of section %u is larger than the entire file!\n"), i
);
6387 printf (" [%2u] ", i
);
6388 if (do_section_details
)
6389 printf ("%s\n ", printable_section_name (filedata
, section
));
6391 print_symbol (-17, SECTION_NAME (section
));
6393 printf (do_wide
? " %-15s " : " %-15.15s ",
6394 get_section_type_name (filedata
, section
->sh_type
));
6398 const char * link_too_big
= NULL
;
6400 print_vma (section
->sh_addr
, LONG_HEX
);
6402 printf ( " %6.6lx %6.6lx %2.2lx",
6403 (unsigned long) section
->sh_offset
,
6404 (unsigned long) section
->sh_size
,
6405 (unsigned long) section
->sh_entsize
);
6407 if (do_section_details
)
6408 fputs (" ", stdout
);
6410 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6412 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
6415 /* The sh_link value is out of range. Normally this indicates
6416 an error but it can have special values in Solaris binaries. */
6417 switch (filedata
->file_header
.e_machine
)
6424 case EM_OLD_SPARCV9
:
6425 case EM_SPARC32PLUS
:
6428 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
6429 link_too_big
= "BEFORE";
6430 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
6431 link_too_big
= "AFTER";
6438 if (do_section_details
)
6440 if (link_too_big
!= NULL
&& * link_too_big
)
6441 printf ("<%s> ", link_too_big
);
6443 printf ("%2u ", section
->sh_link
);
6444 printf ("%3u %2lu\n", section
->sh_info
,
6445 (unsigned long) section
->sh_addralign
);
6448 printf ("%2u %3u %2lu\n",
6451 (unsigned long) section
->sh_addralign
);
6453 if (link_too_big
&& ! * link_too_big
)
6454 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6455 i
, section
->sh_link
);
6459 print_vma (section
->sh_addr
, LONG_HEX
);
6461 if ((long) section
->sh_offset
== section
->sh_offset
)
6462 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
6466 print_vma (section
->sh_offset
, LONG_HEX
);
6469 if ((unsigned long) section
->sh_size
== section
->sh_size
)
6470 printf (" %6.6lx", (unsigned long) section
->sh_size
);
6474 print_vma (section
->sh_size
, LONG_HEX
);
6477 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
6478 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
6482 print_vma (section
->sh_entsize
, LONG_HEX
);
6485 if (do_section_details
)
6486 fputs (" ", stdout
);
6488 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6490 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
6492 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
6493 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
6496 print_vma (section
->sh_addralign
, DEC
);
6500 else if (do_section_details
)
6502 printf (" %-15.15s ",
6503 get_section_type_name (filedata
, section
->sh_type
));
6504 print_vma (section
->sh_addr
, LONG_HEX
);
6505 if ((long) section
->sh_offset
== section
->sh_offset
)
6506 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
6510 print_vma (section
->sh_offset
, LONG_HEX
);
6512 printf (" %u\n ", section
->sh_link
);
6513 print_vma (section
->sh_size
, LONG_HEX
);
6515 print_vma (section
->sh_entsize
, LONG_HEX
);
6517 printf (" %-16u %lu\n",
6519 (unsigned long) section
->sh_addralign
);
6524 print_vma (section
->sh_addr
, LONG_HEX
);
6525 if ((long) section
->sh_offset
== section
->sh_offset
)
6526 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
6530 print_vma (section
->sh_offset
, LONG_HEX
);
6533 print_vma (section
->sh_size
, LONG_HEX
);
6535 print_vma (section
->sh_entsize
, LONG_HEX
);
6537 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6539 printf (" %2u %3u %lu\n",
6542 (unsigned long) section
->sh_addralign
);
6545 if (do_section_details
)
6547 printf (" %s\n", get_elf_section_flags (filedata
, section
->sh_flags
));
6548 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
6550 /* Minimum section size is 12 bytes for 32-bit compression
6551 header + 12 bytes for compressed data header. */
6552 unsigned char buf
[24];
6554 assert (sizeof (buf
) >= sizeof (Elf64_External_Chdr
));
6555 if (get_data (&buf
, filedata
, section
->sh_offset
, 1,
6556 sizeof (buf
), _("compression header")))
6558 Elf_Internal_Chdr chdr
;
6560 (void) get_compression_header (&chdr
, buf
, sizeof (buf
));
6562 if (chdr
.ch_type
== ELFCOMPRESS_ZLIB
)
6565 printf (_(" [<unknown>: 0x%x], "),
6567 print_vma (chdr
.ch_size
, LONG_HEX
);
6568 printf (", %lu\n", (unsigned long) chdr
.ch_addralign
);
6574 if (!do_section_details
)
6576 /* The ordering of the letters shown here matches the ordering of the
6577 corresponding SHF_xxx values, and hence the order in which these
6578 letters will be displayed to the user. */
6579 printf (_("Key to Flags:\n\
6580 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6581 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6582 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
6583 if (filedata
->file_header
.e_machine
== EM_X86_64
6584 || filedata
->file_header
.e_machine
== EM_L1OM
6585 || filedata
->file_header
.e_machine
== EM_K1OM
)
6586 printf (_("l (large), "));
6587 else if (filedata
->file_header
.e_machine
== EM_ARM
)
6588 printf (_("y (purecode), "));
6589 else if (filedata
->file_header
.e_machine
== EM_PPC
)
6590 printf (_("v (VLE), "));
6591 printf ("p (processor specific)\n");
6598 get_group_flags (unsigned int flags
)
6600 static char buff
[128];
6604 else if (flags
== GRP_COMDAT
)
6607 snprintf (buff
, 14, _("[0x%x: "), flags
);
6609 flags
&= ~ GRP_COMDAT
;
6610 if (flags
& GRP_MASKOS
)
6612 strcat (buff
, "<OS specific>");
6613 flags
&= ~ GRP_MASKOS
;
6616 if (flags
& GRP_MASKPROC
)
6618 strcat (buff
, "<PROC specific>");
6619 flags
&= ~ GRP_MASKPROC
;
6623 strcat (buff
, "<unknown>");
6630 process_section_groups (Filedata
* filedata
)
6632 Elf_Internal_Shdr
* section
;
6634 struct group
* group
;
6635 Elf_Internal_Shdr
* symtab_sec
;
6636 Elf_Internal_Shdr
* strtab_sec
;
6637 Elf_Internal_Sym
* symtab
;
6638 unsigned long num_syms
;
6642 /* Don't process section groups unless needed. */
6643 if (!do_unwind
&& !do_section_groups
)
6646 if (filedata
->file_header
.e_shnum
== 0)
6648 if (do_section_groups
)
6649 printf (_("\nThere are no sections to group in this file.\n"));
6654 if (filedata
->section_headers
== NULL
)
6656 error (_("Section headers are not available!\n"));
6657 /* PR 13622: This can happen with a corrupt ELF header. */
6661 section_headers_groups
= (struct group
**) calloc (filedata
->file_header
.e_shnum
,
6662 sizeof (struct group
*));
6664 if (section_headers_groups
== NULL
)
6666 error (_("Out of memory reading %u section group headers\n"),
6667 filedata
->file_header
.e_shnum
);
6671 /* Scan the sections for the group section. */
6673 for (i
= 0, section
= filedata
->section_headers
;
6674 i
< filedata
->file_header
.e_shnum
;
6676 if (section
->sh_type
== SHT_GROUP
)
6679 if (group_count
== 0)
6681 if (do_section_groups
)
6682 printf (_("\nThere are no section groups in this file.\n"));
6687 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
6689 if (section_groups
== NULL
)
6691 error (_("Out of memory reading %lu groups\n"),
6692 (unsigned long) group_count
);
6702 for (i
= 0, section
= filedata
->section_headers
, group
= section_groups
;
6703 i
< filedata
->file_header
.e_shnum
;
6706 if (section
->sh_type
== SHT_GROUP
)
6708 const char * name
= printable_section_name (filedata
, section
);
6709 const char * group_name
;
6710 unsigned char * start
;
6711 unsigned char * indices
;
6712 unsigned int entry
, j
, size
;
6713 Elf_Internal_Shdr
* sec
;
6714 Elf_Internal_Sym
* sym
;
6716 /* Get the symbol table. */
6717 if (section
->sh_link
>= filedata
->file_header
.e_shnum
6718 || ((sec
= filedata
->section_headers
+ section
->sh_link
)->sh_type
6721 error (_("Bad sh_link in group section `%s'\n"), name
);
6725 if (symtab_sec
!= sec
)
6730 symtab
= GET_ELF_SYMBOLS (filedata
, symtab_sec
, & num_syms
);
6735 error (_("Corrupt header in group section `%s'\n"), name
);
6739 if (section
->sh_info
>= num_syms
)
6741 error (_("Bad sh_info in group section `%s'\n"), name
);
6745 sym
= symtab
+ section
->sh_info
;
6747 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
6749 if (sym
->st_shndx
== 0
6750 || sym
->st_shndx
>= filedata
->file_header
.e_shnum
)
6752 error (_("Bad sh_info in group section `%s'\n"), name
);
6756 group_name
= SECTION_NAME (filedata
->section_headers
+ sym
->st_shndx
);
6765 /* Get the string table. */
6766 if (symtab_sec
->sh_link
>= filedata
->file_header
.e_shnum
)
6775 != (sec
= filedata
->section_headers
+ symtab_sec
->sh_link
))
6781 strtab
= (char *) get_data (NULL
, filedata
, strtab_sec
->sh_offset
,
6782 1, strtab_sec
->sh_size
,
6784 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
6786 group_name
= sym
->st_name
< strtab_size
6787 ? strtab
+ sym
->st_name
: _("<corrupt>");
6790 /* PR 17531: file: loop. */
6791 if (section
->sh_entsize
> section
->sh_size
)
6793 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6794 printable_section_name (filedata
, section
),
6795 (unsigned long) section
->sh_entsize
,
6796 (unsigned long) section
->sh_size
);
6800 start
= (unsigned char *) get_data (NULL
, filedata
, section
->sh_offset
,
6801 1, section
->sh_size
,
6807 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
6808 entry
= byte_get (indices
, 4);
6811 if (do_section_groups
)
6813 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6814 get_group_flags (entry
), i
, name
, group_name
, size
);
6816 printf (_(" [Index] Name\n"));
6819 group
->group_index
= i
;
6821 for (j
= 0; j
< size
; j
++)
6823 struct group_list
* g
;
6825 entry
= byte_get (indices
, 4);
6828 if (entry
>= filedata
->file_header
.e_shnum
)
6830 static unsigned num_group_errors
= 0;
6832 if (num_group_errors
++ < 10)
6834 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6835 entry
, i
, filedata
->file_header
.e_shnum
- 1);
6836 if (num_group_errors
== 10)
6837 warn (_("Further error messages about overlarge group section indicies suppressed\n"));
6842 if (section_headers_groups
[entry
] != NULL
)
6846 static unsigned num_errs
= 0;
6848 if (num_errs
++ < 10)
6850 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6852 section_headers_groups
[entry
]->group_index
);
6854 warn (_("Further error messages about already contained group sections suppressed\n"));
6860 /* Intel C/C++ compiler may put section 0 in a
6861 section group. We just warn it the first time
6862 and ignore it afterwards. */
6863 static bfd_boolean warned
= FALSE
;
6866 error (_("section 0 in group section [%5u]\n"),
6867 section_headers_groups
[entry
]->group_index
);
6873 section_headers_groups
[entry
] = group
;
6875 if (do_section_groups
)
6877 sec
= filedata
->section_headers
+ entry
;
6878 printf (" [%5u] %s\n", entry
, printable_section_name (filedata
, sec
));
6881 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
6882 g
->section_index
= entry
;
6883 g
->next
= group
->root
;
6901 /* Data used to display dynamic fixups. */
6903 struct ia64_vms_dynfixup
6905 bfd_vma needed_ident
; /* Library ident number. */
6906 bfd_vma needed
; /* Index in the dstrtab of the library name. */
6907 bfd_vma fixup_needed
; /* Index of the library. */
6908 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
6909 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
6912 /* Data used to display dynamic relocations. */
6914 struct ia64_vms_dynimgrela
6916 bfd_vma img_rela_cnt
; /* Number of relocations. */
6917 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
6920 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6924 dump_ia64_vms_dynamic_fixups (Filedata
* filedata
,
6925 struct ia64_vms_dynfixup
* fixup
,
6926 const char * strtab
,
6927 unsigned int strtab_sz
)
6929 Elf64_External_VMS_IMAGE_FIXUP
* imfs
;
6931 const char * lib_name
;
6933 imfs
= get_data (NULL
, filedata
, dynamic_addr
+ fixup
->fixup_rela_off
,
6934 1, fixup
->fixup_rela_cnt
* sizeof (*imfs
),
6935 _("dynamic section image fixups"));
6939 if (fixup
->needed
< strtab_sz
)
6940 lib_name
= strtab
+ fixup
->needed
;
6943 warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
6944 (unsigned long) fixup
->needed
);
6947 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6948 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
6950 (_("Seg Offset Type SymVec DataType\n"));
6952 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
6957 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
6958 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
6959 type
= BYTE_GET (imfs
[i
].type
);
6960 rtype
= elf_ia64_reloc_type (type
);
6962 printf (" 0x%08x ", type
);
6964 printf (" %-32s ", rtype
);
6965 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
6966 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
6973 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
6976 dump_ia64_vms_dynamic_relocs (Filedata
* filedata
, struct ia64_vms_dynimgrela
*imgrela
)
6978 Elf64_External_VMS_IMAGE_RELA
*imrs
;
6981 imrs
= get_data (NULL
, filedata
, dynamic_addr
+ imgrela
->img_rela_off
,
6982 1, imgrela
->img_rela_cnt
* sizeof (*imrs
),
6983 _("dynamic section image relocations"));
6987 printf (_("\nImage relocs\n"));
6989 (_("Seg Offset Type Addend Seg Sym Off\n"));
6991 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
6996 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
6997 printf ("%08" BFD_VMA_FMT
"x ",
6998 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
6999 type
= BYTE_GET (imrs
[i
].type
);
7000 rtype
= elf_ia64_reloc_type (type
);
7002 printf ("0x%08x ", type
);
7004 printf ("%-31s ", rtype
);
7005 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
7006 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
7007 printf ("%08" BFD_VMA_FMT
"x\n",
7008 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
7015 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
7018 process_ia64_vms_dynamic_relocs (Filedata
* filedata
)
7020 struct ia64_vms_dynfixup fixup
;
7021 struct ia64_vms_dynimgrela imgrela
;
7022 Elf_Internal_Dyn
*entry
;
7023 bfd_vma strtab_off
= 0;
7024 bfd_vma strtab_sz
= 0;
7025 char *strtab
= NULL
;
7026 bfd_boolean res
= TRUE
;
7028 memset (&fixup
, 0, sizeof (fixup
));
7029 memset (&imgrela
, 0, sizeof (imgrela
));
7031 /* Note: the order of the entries is specified by the OpenVMS specs. */
7032 for (entry
= dynamic_section
;
7033 entry
< dynamic_section
+ dynamic_nent
;
7036 switch (entry
->d_tag
)
7038 case DT_IA_64_VMS_STRTAB_OFFSET
:
7039 strtab_off
= entry
->d_un
.d_val
;
7042 strtab_sz
= entry
->d_un
.d_val
;
7044 strtab
= get_data (NULL
, filedata
, dynamic_addr
+ strtab_off
,
7045 1, strtab_sz
, _("dynamic string section"));
7048 case DT_IA_64_VMS_NEEDED_IDENT
:
7049 fixup
.needed_ident
= entry
->d_un
.d_val
;
7052 fixup
.needed
= entry
->d_un
.d_val
;
7054 case DT_IA_64_VMS_FIXUP_NEEDED
:
7055 fixup
.fixup_needed
= entry
->d_un
.d_val
;
7057 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
7058 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
7060 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
7061 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
7062 if (! dump_ia64_vms_dynamic_fixups (filedata
, &fixup
, strtab
, strtab_sz
))
7065 case DT_IA_64_VMS_IMG_RELA_CNT
:
7066 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
7068 case DT_IA_64_VMS_IMG_RELA_OFF
:
7069 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
7070 if (! dump_ia64_vms_dynamic_relocs (filedata
, &imgrela
))
7092 dynamic_relocations
[] =
7094 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
7095 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
7096 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
7099 /* Process the reloc section. */
7102 process_relocs (Filedata
* filedata
)
7104 unsigned long rel_size
;
7105 unsigned long rel_offset
;
7110 if (do_using_dynamic
)
7114 bfd_boolean has_dynamic_reloc
;
7117 has_dynamic_reloc
= FALSE
;
7119 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7121 is_rela
= dynamic_relocations
[i
].rela
;
7122 name
= dynamic_relocations
[i
].name
;
7123 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
7124 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
7127 has_dynamic_reloc
= TRUE
;
7129 if (is_rela
== UNKNOWN
)
7131 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
7132 switch (dynamic_info
[DT_PLTREL
])
7146 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7147 name
, rel_offset
, rel_size
);
7149 dump_relocations (filedata
,
7150 offset_from_vma (filedata
, rel_offset
, rel_size
),
7152 dynamic_symbols
, num_dynamic_syms
,
7153 dynamic_strings
, dynamic_strings_length
,
7154 is_rela
, TRUE
/* is_dynamic */);
7158 if (is_ia64_vms (filedata
))
7159 if (process_ia64_vms_dynamic_relocs (filedata
))
7160 has_dynamic_reloc
= TRUE
;
7162 if (! has_dynamic_reloc
)
7163 printf (_("\nThere are no dynamic relocations in this file.\n"));
7167 Elf_Internal_Shdr
* section
;
7169 bfd_boolean found
= FALSE
;
7171 for (i
= 0, section
= filedata
->section_headers
;
7172 i
< filedata
->file_header
.e_shnum
;
7175 if ( section
->sh_type
!= SHT_RELA
7176 && section
->sh_type
!= SHT_REL
)
7179 rel_offset
= section
->sh_offset
;
7180 rel_size
= section
->sh_size
;
7184 Elf_Internal_Shdr
* strsec
;
7186 unsigned long num_rela
;
7188 printf (_("\nRelocation section "));
7190 if (filedata
->string_table
== NULL
)
7191 printf ("%d", section
->sh_name
);
7193 printf ("'%s'", printable_section_name (filedata
, section
));
7195 num_rela
= rel_size
/ section
->sh_entsize
;
7196 printf (ngettext (" at offset 0x%lx contains %lu entry:\n",
7197 " at offset 0x%lx contains %lu entries:\n",
7199 rel_offset
, num_rela
);
7201 is_rela
= section
->sh_type
== SHT_RELA
;
7203 if (section
->sh_link
!= 0
7204 && section
->sh_link
< filedata
->file_header
.e_shnum
)
7206 Elf_Internal_Shdr
* symsec
;
7207 Elf_Internal_Sym
* symtab
;
7208 unsigned long nsyms
;
7209 unsigned long strtablen
= 0;
7210 char * strtab
= NULL
;
7212 symsec
= filedata
->section_headers
+ section
->sh_link
;
7213 if (symsec
->sh_type
!= SHT_SYMTAB
7214 && symsec
->sh_type
!= SHT_DYNSYM
)
7217 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & nsyms
);
7222 if (symsec
->sh_link
!= 0
7223 && symsec
->sh_link
< filedata
->file_header
.e_shnum
)
7225 strsec
= filedata
->section_headers
+ symsec
->sh_link
;
7227 strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
7230 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
7233 dump_relocations (filedata
, rel_offset
, rel_size
,
7234 symtab
, nsyms
, strtab
, strtablen
,
7236 symsec
->sh_type
== SHT_DYNSYM
);
7242 dump_relocations (filedata
, rel_offset
, rel_size
,
7243 NULL
, 0, NULL
, 0, is_rela
,
7244 FALSE
/* is_dynamic */);
7252 /* Users sometimes forget the -D option, so try to be helpful. */
7253 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7255 if (dynamic_info
[dynamic_relocations
[i
].size
])
7257 printf (_("\nThere are no static relocations in this file."));
7258 printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
7263 if (i
== ARRAY_SIZE (dynamic_relocations
))
7264 printf (_("\nThere are no relocations in this file.\n"));
7271 /* An absolute address consists of a section and an offset. If the
7272 section is NULL, the offset itself is the address, otherwise, the
7273 address equals to LOAD_ADDRESS(section) + offset. */
7277 unsigned short section
;
7281 #define ABSADDR(a) \
7283 ? filedata->section_headers [(a).section].sh_addr + (a).offset \
7286 /* Find the nearest symbol at or below ADDR. Returns the symbol
7287 name, if found, and the offset from the symbol to ADDR. */
7290 find_symbol_for_address (Filedata
* filedata
,
7291 Elf_Internal_Sym
* symtab
,
7292 unsigned long nsyms
,
7293 const char * strtab
,
7294 unsigned long strtab_size
,
7295 struct absaddr addr
,
7296 const char ** symname
,
7299 bfd_vma dist
= 0x100000;
7300 Elf_Internal_Sym
* sym
;
7301 Elf_Internal_Sym
* beg
;
7302 Elf_Internal_Sym
* end
;
7303 Elf_Internal_Sym
* best
= NULL
;
7305 REMOVE_ARCH_BITS (addr
.offset
);
7307 end
= symtab
+ nsyms
;
7313 sym
= beg
+ (end
- beg
) / 2;
7315 value
= sym
->st_value
;
7316 REMOVE_ARCH_BITS (value
);
7318 if (sym
->st_name
!= 0
7319 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
7320 && addr
.offset
>= value
7321 && addr
.offset
- value
< dist
)
7324 dist
= addr
.offset
- value
;
7329 if (addr
.offset
< value
)
7337 *symname
= (best
->st_name
>= strtab_size
7338 ? _("<corrupt>") : strtab
+ best
->st_name
);
7344 *offset
= addr
.offset
;
7347 static /* signed */ int
7348 symcmp (const void *p
, const void *q
)
7350 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
7351 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
7353 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
7356 /* Process the unwind section. */
7358 #include "unwind-ia64.h"
7360 struct ia64_unw_table_entry
7362 struct absaddr start
;
7364 struct absaddr info
;
7367 struct ia64_unw_aux_info
7369 struct ia64_unw_table_entry
* table
; /* Unwind table. */
7370 unsigned long table_len
; /* Length of unwind table. */
7371 unsigned char * info
; /* Unwind info. */
7372 unsigned long info_size
; /* Size of unwind info. */
7373 bfd_vma info_addr
; /* Starting address of unwind info. */
7374 bfd_vma seg_base
; /* Starting address of segment. */
7375 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7376 unsigned long nsyms
; /* Number of symbols. */
7377 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7378 unsigned long nfuns
; /* Number of entries in funtab. */
7379 char * strtab
; /* The string table. */
7380 unsigned long strtab_size
; /* Size of string table. */
7384 dump_ia64_unwind (Filedata
* filedata
, struct ia64_unw_aux_info
* aux
)
7386 struct ia64_unw_table_entry
* tp
;
7387 unsigned long j
, nfuns
;
7389 bfd_boolean res
= TRUE
;
7391 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7392 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7393 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7394 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7396 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7398 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7402 const unsigned char * dp
;
7403 const unsigned char * head
;
7404 const unsigned char * end
;
7405 const char * procname
;
7407 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7408 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
7410 fputs ("\n<", stdout
);
7414 fputs (procname
, stdout
);
7417 printf ("+%lx", (unsigned long) offset
);
7420 fputs (">: [", stdout
);
7421 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7422 fputc ('-', stdout
);
7423 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7424 printf ("], info at +0x%lx\n",
7425 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
7427 /* PR 17531: file: 86232b32. */
7428 if (aux
->info
== NULL
)
7431 /* PR 17531: file: 0997b4d1. */
7432 if ((ABSADDR (tp
->info
) - aux
->info_addr
) >= aux
->info_size
)
7434 warn (_("Invalid offset %lx in table entry %ld\n"),
7435 (long) tp
->info
.offset
, (long) (tp
- aux
->table
));
7440 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
7441 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
7443 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7444 (unsigned) UNW_VER (stamp
),
7445 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
7446 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
7447 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
7448 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
7450 if (UNW_VER (stamp
) != 1)
7452 printf (_("\tUnknown version.\n"));
7457 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
7458 /* PR 17531: file: 16ceda89. */
7459 if (end
> aux
->info
+ aux
->info_size
)
7460 end
= aux
->info
+ aux
->info_size
;
7461 for (dp
= head
+ 8; dp
< end
;)
7462 dp
= unw_decode (dp
, in_body
, & in_body
, end
);
7471 slurp_ia64_unwind_table (Filedata
* filedata
,
7472 struct ia64_unw_aux_info
* aux
,
7473 Elf_Internal_Shdr
* sec
)
7475 unsigned long size
, nrelas
, i
;
7476 Elf_Internal_Phdr
* seg
;
7477 struct ia64_unw_table_entry
* tep
;
7478 Elf_Internal_Shdr
* relsec
;
7479 Elf_Internal_Rela
* rela
;
7480 Elf_Internal_Rela
* rp
;
7481 unsigned char * table
;
7483 Elf_Internal_Sym
* sym
;
7484 const char * relname
;
7488 /* First, find the starting address of the segment that includes
7491 if (filedata
->file_header
.e_phnum
)
7493 if (! get_program_headers (filedata
))
7496 for (seg
= filedata
->program_headers
;
7497 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
7500 if (seg
->p_type
!= PT_LOAD
)
7503 if (sec
->sh_addr
>= seg
->p_vaddr
7504 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7506 aux
->seg_base
= seg
->p_vaddr
;
7512 /* Second, build the unwind table from the contents of the unwind section: */
7513 size
= sec
->sh_size
;
7514 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
7519 aux
->table_len
= size
/ (3 * eh_addr_size
);
7520 aux
->table
= (struct ia64_unw_table_entry
*)
7521 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
7524 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
7526 tep
->start
.section
= SHN_UNDEF
;
7527 tep
->end
.section
= SHN_UNDEF
;
7528 tep
->info
.section
= SHN_UNDEF
;
7529 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7530 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7531 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7532 tep
->start
.offset
+= aux
->seg_base
;
7533 tep
->end
.offset
+= aux
->seg_base
;
7534 tep
->info
.offset
+= aux
->seg_base
;
7538 /* Third, apply any relocations to the unwind table: */
7539 for (relsec
= filedata
->section_headers
;
7540 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
7543 if (relsec
->sh_type
!= SHT_RELA
7544 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
7545 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
7548 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
7557 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7559 relname
= elf_ia64_reloc_type (get_reloc_type (filedata
, rp
->r_info
));
7560 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
7562 /* PR 17531: file: 9fa67536. */
7563 if (relname
== NULL
)
7565 warn (_("Skipping unknown relocation type: %u\n"),
7566 get_reloc_type (filedata
, rp
->r_info
));
7570 if (! const_strneq (relname
, "R_IA64_SEGREL"))
7572 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
7576 i
= rp
->r_offset
/ (3 * eh_addr_size
);
7578 /* PR 17531: file: 5bc8d9bf. */
7579 if (i
>= aux
->table_len
)
7581 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
7585 switch (rp
->r_offset
/ eh_addr_size
% 3)
7588 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7589 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
7592 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7593 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
7596 aux
->table
[i
].info
.section
= sym
->st_shndx
;
7597 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
7611 ia64_process_unwind (Filedata
* filedata
)
7613 Elf_Internal_Shdr
* sec
;
7614 Elf_Internal_Shdr
* unwsec
= NULL
;
7615 Elf_Internal_Shdr
* strsec
;
7616 unsigned long i
, unwcount
= 0, unwstart
= 0;
7617 struct ia64_unw_aux_info aux
;
7618 bfd_boolean res
= TRUE
;
7620 memset (& aux
, 0, sizeof (aux
));
7622 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
7624 if (sec
->sh_type
== SHT_SYMTAB
7625 && sec
->sh_link
< filedata
->file_header
.e_shnum
)
7627 aux
.symtab
= GET_ELF_SYMBOLS (filedata
, sec
, & aux
.nsyms
);
7629 strsec
= filedata
->section_headers
+ sec
->sh_link
;
7630 if (aux
.strtab
!= NULL
)
7632 error (_("Multiple auxillary string tables encountered\n"));
7636 aux
.strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
7639 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7641 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7646 printf (_("\nThere are no unwind sections in this file.\n"));
7648 while (unwcount
-- > 0)
7653 for (i
= unwstart
, sec
= filedata
->section_headers
+ unwstart
, unwsec
= NULL
;
7654 i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
7655 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7660 /* We have already counted the number of SHT_IA64_UNWIND
7661 sections so the loop above should never fail. */
7662 assert (unwsec
!= NULL
);
7665 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
7667 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
7669 /* We need to find which section group it is in. */
7670 struct group_list
* g
;
7672 if (section_headers_groups
== NULL
7673 || section_headers_groups
[i
] == NULL
)
7674 i
= filedata
->file_header
.e_shnum
;
7677 g
= section_headers_groups
[i
]->root
;
7679 for (; g
!= NULL
; g
= g
->next
)
7681 sec
= filedata
->section_headers
+ g
->section_index
;
7683 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
7688 i
= filedata
->file_header
.e_shnum
;
7691 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
7693 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
7694 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
7695 suffix
= SECTION_NAME (unwsec
) + len
;
7696 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
;
7698 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
7699 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7704 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7705 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
7706 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
7707 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
7709 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
7710 suffix
= SECTION_NAME (unwsec
) + len
;
7711 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
;
7713 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
7714 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7718 if (i
== filedata
->file_header
.e_shnum
)
7720 printf (_("\nCould not find unwind info section for "));
7722 if (filedata
->string_table
== NULL
)
7723 printf ("%d", unwsec
->sh_name
);
7725 printf ("'%s'", printable_section_name (filedata
, unwsec
));
7729 aux
.info_addr
= sec
->sh_addr
;
7730 aux
.info
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1,
7733 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
7735 printf (_("\nUnwind section "));
7737 if (filedata
->string_table
== NULL
)
7738 printf ("%d", unwsec
->sh_name
);
7740 printf ("'%s'", printable_section_name (filedata
, unwsec
));
7742 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7743 (unsigned long) unwsec
->sh_offset
,
7744 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
7746 if (slurp_ia64_unwind_table (filedata
, & aux
, unwsec
)
7747 && aux
.table_len
> 0)
7748 dump_ia64_unwind (filedata
, & aux
);
7751 free ((char *) aux
.table
);
7753 free ((char *) aux
.info
);
7762 free ((char *) aux
.strtab
);
7767 struct hppa_unw_table_entry
7769 struct absaddr start
;
7771 unsigned int Cannot_unwind
:1; /* 0 */
7772 unsigned int Millicode
:1; /* 1 */
7773 unsigned int Millicode_save_sr0
:1; /* 2 */
7774 unsigned int Region_description
:2; /* 3..4 */
7775 unsigned int reserved1
:1; /* 5 */
7776 unsigned int Entry_SR
:1; /* 6 */
7777 unsigned int Entry_FR
:4; /* Number saved 7..10 */
7778 unsigned int Entry_GR
:5; /* Number saved 11..15 */
7779 unsigned int Args_stored
:1; /* 16 */
7780 unsigned int Variable_Frame
:1; /* 17 */
7781 unsigned int Separate_Package_Body
:1; /* 18 */
7782 unsigned int Frame_Extension_Millicode
:1; /* 19 */
7783 unsigned int Stack_Overflow_Check
:1; /* 20 */
7784 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
7785 unsigned int Ada_Region
:1; /* 22 */
7786 unsigned int cxx_info
:1; /* 23 */
7787 unsigned int cxx_try_catch
:1; /* 24 */
7788 unsigned int sched_entry_seq
:1; /* 25 */
7789 unsigned int reserved2
:1; /* 26 */
7790 unsigned int Save_SP
:1; /* 27 */
7791 unsigned int Save_RP
:1; /* 28 */
7792 unsigned int Save_MRP_in_frame
:1; /* 29 */
7793 unsigned int extn_ptr_defined
:1; /* 30 */
7794 unsigned int Cleanup_defined
:1; /* 31 */
7796 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
7797 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
7798 unsigned int Large_frame
:1; /* 2 */
7799 unsigned int Pseudo_SP_Set
:1; /* 3 */
7800 unsigned int reserved4
:1; /* 4 */
7801 unsigned int Total_frame_size
:27; /* 5..31 */
7804 struct hppa_unw_aux_info
7806 struct hppa_unw_table_entry
* table
; /* Unwind table. */
7807 unsigned long table_len
; /* Length of unwind table. */
7808 bfd_vma seg_base
; /* Starting address of segment. */
7809 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7810 unsigned long nsyms
; /* Number of symbols. */
7811 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7812 unsigned long nfuns
; /* Number of entries in funtab. */
7813 char * strtab
; /* The string table. */
7814 unsigned long strtab_size
; /* Size of string table. */
7818 dump_hppa_unwind (Filedata
* filedata
, struct hppa_unw_aux_info
* aux
)
7820 struct hppa_unw_table_entry
* tp
;
7821 unsigned long j
, nfuns
;
7822 bfd_boolean res
= TRUE
;
7824 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7825 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7826 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7827 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7829 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7831 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7834 const char * procname
;
7836 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7837 aux
->strtab_size
, tp
->start
, &procname
,
7840 fputs ("\n<", stdout
);
7844 fputs (procname
, stdout
);
7847 printf ("+%lx", (unsigned long) offset
);
7850 fputs (">: [", stdout
);
7851 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7852 fputc ('-', stdout
);
7853 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7856 #define PF(_m) if (tp->_m) printf (#_m " ");
7857 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
7860 PF(Millicode_save_sr0
);
7861 /* PV(Region_description); */
7867 PF(Separate_Package_Body
);
7868 PF(Frame_Extension_Millicode
);
7869 PF(Stack_Overflow_Check
);
7870 PF(Two_Instruction_SP_Increment
);
7874 PF(sched_entry_seq
);
7877 PF(Save_MRP_in_frame
);
7878 PF(extn_ptr_defined
);
7879 PF(Cleanup_defined
);
7880 PF(MPE_XL_interrupt_marker
);
7881 PF(HP_UX_interrupt_marker
);
7884 PV(Total_frame_size
);
7897 slurp_hppa_unwind_table (Filedata
* filedata
,
7898 struct hppa_unw_aux_info
* aux
,
7899 Elf_Internal_Shdr
* sec
)
7901 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
7902 Elf_Internal_Phdr
* seg
;
7903 struct hppa_unw_table_entry
* tep
;
7904 Elf_Internal_Shdr
* relsec
;
7905 Elf_Internal_Rela
* rela
;
7906 Elf_Internal_Rela
* rp
;
7907 unsigned char * table
;
7909 Elf_Internal_Sym
* sym
;
7910 const char * relname
;
7912 /* First, find the starting address of the segment that includes
7914 if (filedata
->file_header
.e_phnum
)
7916 if (! get_program_headers (filedata
))
7919 for (seg
= filedata
->program_headers
;
7920 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
7923 if (seg
->p_type
!= PT_LOAD
)
7926 if (sec
->sh_addr
>= seg
->p_vaddr
7927 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7929 aux
->seg_base
= seg
->p_vaddr
;
7935 /* Second, build the unwind table from the contents of the unwind
7937 size
= sec
->sh_size
;
7938 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
7944 nentries
= size
/ unw_ent_size
;
7945 size
= unw_ent_size
* nentries
;
7947 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
7948 xcmalloc (nentries
, sizeof (aux
->table
[0]));
7950 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
7952 unsigned int tmp1
, tmp2
;
7954 tep
->start
.section
= SHN_UNDEF
;
7955 tep
->end
.section
= SHN_UNDEF
;
7957 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
7958 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
7959 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
7960 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
7962 tep
->start
.offset
+= aux
->seg_base
;
7963 tep
->end
.offset
+= aux
->seg_base
;
7965 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
7966 tep
->Millicode
= (tmp1
>> 30) & 0x1;
7967 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
7968 tep
->Region_description
= (tmp1
>> 27) & 0x3;
7969 tep
->reserved1
= (tmp1
>> 26) & 0x1;
7970 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
7971 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
7972 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
7973 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
7974 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
7975 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
7976 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
7977 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
7978 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
7979 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
7980 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
7981 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
7982 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
7983 tep
->reserved2
= (tmp1
>> 5) & 0x1;
7984 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
7985 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
7986 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
7987 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
7988 tep
->Cleanup_defined
= tmp1
& 0x1;
7990 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
7991 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
7992 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
7993 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
7994 tep
->reserved4
= (tmp2
>> 27) & 0x1;
7995 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
7999 /* Third, apply any relocations to the unwind table. */
8000 for (relsec
= filedata
->section_headers
;
8001 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8004 if (relsec
->sh_type
!= SHT_RELA
8005 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
8006 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
8009 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
8013 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
8015 relname
= elf_hppa_reloc_type (get_reloc_type (filedata
, rp
->r_info
));
8016 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
8018 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
8019 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
8021 warn (_("Skipping unexpected relocation type %s\n"), relname
);
8025 i
= rp
->r_offset
/ unw_ent_size
;
8027 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
8030 aux
->table
[i
].start
.section
= sym
->st_shndx
;
8031 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
8034 aux
->table
[i
].end
.section
= sym
->st_shndx
;
8035 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
8045 aux
->table_len
= nentries
;
8051 hppa_process_unwind (Filedata
* filedata
)
8053 struct hppa_unw_aux_info aux
;
8054 Elf_Internal_Shdr
* unwsec
= NULL
;
8055 Elf_Internal_Shdr
* strsec
;
8056 Elf_Internal_Shdr
* sec
;
8058 bfd_boolean res
= TRUE
;
8060 if (filedata
->string_table
== NULL
)
8063 memset (& aux
, 0, sizeof (aux
));
8065 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8067 if (sec
->sh_type
== SHT_SYMTAB
8068 && sec
->sh_link
< filedata
->file_header
.e_shnum
)
8070 aux
.symtab
= GET_ELF_SYMBOLS (filedata
, sec
, & aux
.nsyms
);
8072 strsec
= filedata
->section_headers
+ sec
->sh_link
;
8073 if (aux
.strtab
!= NULL
)
8075 error (_("Multiple auxillary string tables encountered\n"));
8079 aux
.strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
8082 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
8084 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8089 printf (_("\nThere are no unwind sections in this file.\n"));
8091 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8093 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8095 unsigned long num_unwind
= sec
->sh_size
/ (2 * eh_addr_size
+ 8);
8097 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
8098 "contains %lu entry:\n",
8099 "\nUnwind section '%s' at offset 0x%lx "
8100 "contains %lu entries:\n",
8102 printable_section_name (filedata
, sec
),
8103 (unsigned long) sec
->sh_offset
,
8106 if (! slurp_hppa_unwind_table (filedata
, &aux
, sec
))
8109 if (aux
.table_len
> 0)
8111 if (! dump_hppa_unwind (filedata
, &aux
))
8116 free ((char *) aux
.table
);
8124 free ((char *) aux
.strtab
);
8131 unsigned char * data
; /* The unwind data. */
8132 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
8133 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
8134 unsigned long nrelas
; /* The number of relocations. */
8135 unsigned int rel_type
; /* REL or RELA ? */
8136 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
8139 struct arm_unw_aux_info
8141 Filedata
* filedata
; /* The file containing the unwind sections. */
8142 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
8143 unsigned long nsyms
; /* Number of symbols. */
8144 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8145 unsigned long nfuns
; /* Number of these symbols. */
8146 char * strtab
; /* The file's string table. */
8147 unsigned long strtab_size
; /* Size of string table. */
8151 arm_print_vma_and_name (Filedata
* filedata
,
8152 struct arm_unw_aux_info
* aux
,
8154 struct absaddr addr
)
8156 const char *procname
;
8159 if (addr
.section
== SHN_UNDEF
)
8162 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8163 aux
->strtab_size
, addr
, &procname
,
8166 print_vma (fn
, PREFIX_HEX
);
8170 fputs (" <", stdout
);
8171 fputs (procname
, stdout
);
8174 printf ("+0x%lx", (unsigned long) sym_offset
);
8175 fputc ('>', stdout
);
8182 arm_free_section (struct arm_section
*arm_sec
)
8184 if (arm_sec
->data
!= NULL
)
8185 free (arm_sec
->data
);
8187 if (arm_sec
->rela
!= NULL
)
8188 free (arm_sec
->rela
);
8191 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8192 cached section and install SEC instead.
8193 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8194 and return its valued in * WORDP, relocating if necessary.
8195 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8196 relocation's offset in ADDR.
8197 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8198 into the string table of the symbol associated with the reloc. If no
8199 reloc was applied store -1 there.
8200 5) Return TRUE upon success, FALSE otherwise. */
8203 get_unwind_section_word (Filedata
* filedata
,
8204 struct arm_unw_aux_info
* aux
,
8205 struct arm_section
* arm_sec
,
8206 Elf_Internal_Shdr
* sec
,
8207 bfd_vma word_offset
,
8208 unsigned int * wordp
,
8209 struct absaddr
* addr
,
8212 Elf_Internal_Rela
*rp
;
8213 Elf_Internal_Sym
*sym
;
8214 const char * relname
;
8216 bfd_boolean wrapped
;
8218 if (sec
== NULL
|| arm_sec
== NULL
)
8221 addr
->section
= SHN_UNDEF
;
8224 if (sym_name
!= NULL
)
8225 *sym_name
= (bfd_vma
) -1;
8227 /* If necessary, update the section cache. */
8228 if (sec
!= arm_sec
->sec
)
8230 Elf_Internal_Shdr
*relsec
;
8232 arm_free_section (arm_sec
);
8235 arm_sec
->data
= get_data (NULL
, aux
->filedata
, sec
->sh_offset
, 1,
8236 sec
->sh_size
, _("unwind data"));
8237 arm_sec
->rela
= NULL
;
8238 arm_sec
->nrelas
= 0;
8240 for (relsec
= filedata
->section_headers
;
8241 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8244 if (relsec
->sh_info
>= filedata
->file_header
.e_shnum
8245 || filedata
->section_headers
+ relsec
->sh_info
!= sec
8246 /* PR 15745: Check the section type as well. */
8247 || (relsec
->sh_type
!= SHT_REL
8248 && relsec
->sh_type
!= SHT_RELA
))
8251 arm_sec
->rel_type
= relsec
->sh_type
;
8252 if (relsec
->sh_type
== SHT_REL
)
8254 if (!slurp_rel_relocs (aux
->filedata
, relsec
->sh_offset
,
8256 & arm_sec
->rela
, & arm_sec
->nrelas
))
8259 else /* relsec->sh_type == SHT_RELA */
8261 if (!slurp_rela_relocs (aux
->filedata
, relsec
->sh_offset
,
8263 & arm_sec
->rela
, & arm_sec
->nrelas
))
8269 arm_sec
->next_rela
= arm_sec
->rela
;
8272 /* If there is no unwind data we can do nothing. */
8273 if (arm_sec
->data
== NULL
)
8276 /* If the offset is invalid then fail. */
8277 if (/* PR 21343 *//* PR 18879 */
8279 || word_offset
> (sec
->sh_size
- 4)
8280 || ((bfd_signed_vma
) word_offset
) < 0)
8283 /* Get the word at the required offset. */
8284 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
8286 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
8287 if (arm_sec
->rela
== NULL
)
8293 /* Look through the relocs to find the one that applies to the provided offset. */
8295 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
8297 bfd_vma prelval
, offset
;
8299 if (rp
->r_offset
> word_offset
&& !wrapped
)
8304 if (rp
->r_offset
> word_offset
)
8307 if (rp
->r_offset
& 3)
8309 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8310 (unsigned long) rp
->r_offset
);
8314 if (rp
->r_offset
< word_offset
)
8317 /* PR 17531: file: 027-161405-0.004 */
8318 if (aux
->symtab
== NULL
)
8321 if (arm_sec
->rel_type
== SHT_REL
)
8323 offset
= word
& 0x7fffffff;
8324 if (offset
& 0x40000000)
8325 offset
|= ~ (bfd_vma
) 0x7fffffff;
8327 else if (arm_sec
->rel_type
== SHT_RELA
)
8328 offset
= rp
->r_addend
;
8331 error (_("Unknown section relocation type %d encountered\n"),
8336 /* PR 17531 file: 027-1241568-0.004. */
8337 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
8339 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8340 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
8344 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
8345 offset
+= sym
->st_value
;
8346 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
8348 /* Check that we are processing the expected reloc type. */
8349 if (filedata
->file_header
.e_machine
== EM_ARM
)
8351 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8352 if (relname
== NULL
)
8354 warn (_("Skipping unknown ARM relocation type: %d\n"),
8355 (int) ELF32_R_TYPE (rp
->r_info
));
8359 if (streq (relname
, "R_ARM_NONE"))
8362 if (! streq (relname
, "R_ARM_PREL31"))
8364 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
8368 else if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
8370 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8371 if (relname
== NULL
)
8373 warn (_("Skipping unknown C6000 relocation type: %d\n"),
8374 (int) ELF32_R_TYPE (rp
->r_info
));
8378 if (streq (relname
, "R_C6000_NONE"))
8381 if (! streq (relname
, "R_C6000_PREL31"))
8383 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
8391 /* This function currently only supports ARM and TI unwinders. */
8392 warn (_("Only TI and ARM unwinders are currently supported\n"));
8396 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
8397 addr
->section
= sym
->st_shndx
;
8398 addr
->offset
= offset
;
8401 * sym_name
= sym
->st_name
;
8406 arm_sec
->next_rela
= rp
;
8411 static const char *tic6x_unwind_regnames
[16] =
8413 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8414 "A14", "A13", "A12", "A11", "A10",
8415 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8419 decode_tic6x_unwind_regmask (unsigned int mask
)
8423 for (i
= 12; mask
; mask
>>= 1, i
--)
8427 fputs (tic6x_unwind_regnames
[i
], stdout
);
8429 fputs (", ", stdout
);
8435 if (remaining == 0 && more_words) \
8438 if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, \
8439 data_offset, & word, & addr, NULL)) \
8445 #define GET_OP(OP) \
8450 (OP) = word >> 24; \
8455 printf (_("[Truncated opcode]\n")); \
8458 printf ("0x%02x ", OP)
8461 decode_arm_unwind_bytecode (Filedata
* filedata
,
8462 struct arm_unw_aux_info
* aux
,
8464 unsigned int remaining
,
8465 unsigned int more_words
,
8466 bfd_vma data_offset
,
8467 Elf_Internal_Shdr
* data_sec
,
8468 struct arm_section
* data_arm_sec
)
8470 struct absaddr addr
;
8471 bfd_boolean res
= TRUE
;
8473 /* Decode the unwinding instructions. */
8476 unsigned int op
, op2
;
8485 printf (" 0x%02x ", op
);
8487 if ((op
& 0xc0) == 0x00)
8489 int offset
= ((op
& 0x3f) << 2) + 4;
8491 printf (" vsp = vsp + %d", offset
);
8493 else if ((op
& 0xc0) == 0x40)
8495 int offset
= ((op
& 0x3f) << 2) + 4;
8497 printf (" vsp = vsp - %d", offset
);
8499 else if ((op
& 0xf0) == 0x80)
8502 if (op
== 0x80 && op2
== 0)
8503 printf (_("Refuse to unwind"));
8506 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
8507 bfd_boolean first
= TRUE
;
8511 for (i
= 0; i
< 12; i
++)
8512 if (mask
& (1 << i
))
8518 printf ("r%d", 4 + i
);
8523 else if ((op
& 0xf0) == 0x90)
8525 if (op
== 0x9d || op
== 0x9f)
8526 printf (_(" [Reserved]"));
8528 printf (" vsp = r%d", op
& 0x0f);
8530 else if ((op
& 0xf0) == 0xa0)
8532 int end
= 4 + (op
& 0x07);
8533 bfd_boolean first
= TRUE
;
8537 for (i
= 4; i
<= end
; i
++)
8553 else if (op
== 0xb0)
8554 printf (_(" finish"));
8555 else if (op
== 0xb1)
8558 if (op2
== 0 || (op2
& 0xf0) != 0)
8559 printf (_("[Spare]"));
8562 unsigned int mask
= op2
& 0x0f;
8563 bfd_boolean first
= TRUE
;
8567 for (i
= 0; i
< 12; i
++)
8568 if (mask
& (1 << i
))
8579 else if (op
== 0xb2)
8581 unsigned char buf
[9];
8582 unsigned int i
, len
;
8583 unsigned long offset
;
8585 for (i
= 0; i
< sizeof (buf
); i
++)
8588 if ((buf
[i
] & 0x80) == 0)
8591 if (i
== sizeof (buf
))
8593 error (_("corrupt change to vsp"));
8598 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8599 assert (len
== i
+ 1);
8600 offset
= offset
* 4 + 0x204;
8601 printf ("vsp = vsp + %ld", offset
);
8604 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
8606 unsigned int first
, last
;
8613 printf ("pop {D%d", first
);
8615 printf ("-D%d", first
+ last
);
8618 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
8620 unsigned int count
= op
& 0x07;
8624 printf ("-D%d", 8 + count
);
8627 else if (op
>= 0xc0 && op
<= 0xc5)
8629 unsigned int count
= op
& 0x07;
8631 printf (" pop {wR10");
8633 printf ("-wR%d", 10 + count
);
8636 else if (op
== 0xc6)
8638 unsigned int first
, last
;
8643 printf ("pop {wR%d", first
);
8645 printf ("-wR%d", first
+ last
);
8648 else if (op
== 0xc7)
8651 if (op2
== 0 || (op2
& 0xf0) != 0)
8652 printf (_("[Spare]"));
8655 unsigned int mask
= op2
& 0x0f;
8656 bfd_boolean first
= TRUE
;
8660 for (i
= 0; i
< 4; i
++)
8661 if (mask
& (1 << i
))
8667 printf ("wCGR%d", i
);
8674 printf (_(" [unsupported opcode]"));
8685 decode_tic6x_unwind_bytecode (Filedata
* filedata
,
8686 struct arm_unw_aux_info
* aux
,
8688 unsigned int remaining
,
8689 unsigned int more_words
,
8690 bfd_vma data_offset
,
8691 Elf_Internal_Shdr
* data_sec
,
8692 struct arm_section
* data_arm_sec
)
8694 struct absaddr addr
;
8696 /* Decode the unwinding instructions. */
8699 unsigned int op
, op2
;
8708 printf (" 0x%02x ", op
);
8710 if ((op
& 0xc0) == 0x00)
8712 int offset
= ((op
& 0x3f) << 3) + 8;
8713 printf (" sp = sp + %d", offset
);
8715 else if ((op
& 0xc0) == 0x80)
8718 if (op
== 0x80 && op2
== 0)
8719 printf (_("Refuse to unwind"));
8722 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
8724 printf ("pop compact {");
8728 decode_tic6x_unwind_regmask (mask
);
8732 else if ((op
& 0xf0) == 0xc0)
8740 unsigned int offset
;
8744 /* Scan entire instruction first so that GET_OP output is not
8745 interleaved with disassembly. */
8747 for (i
= 0; nregs
< (op
& 0xf); i
++)
8753 regpos
[nregs
].offset
= i
* 2;
8754 regpos
[nregs
].reg
= reg
;
8761 regpos
[nregs
].offset
= i
* 2 + 1;
8762 regpos
[nregs
].reg
= reg
;
8767 printf (_("pop frame {"));
8769 for (i
= i
* 2; i
> 0; i
--)
8771 if (regpos
[reg
].offset
== i
- 1)
8773 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
8780 fputs (name
, stdout
);
8787 else if (op
== 0xd0)
8788 printf (" MOV FP, SP");
8789 else if (op
== 0xd1)
8790 printf (" __c6xabi_pop_rts");
8791 else if (op
== 0xd2)
8793 unsigned char buf
[9];
8794 unsigned int i
, len
;
8795 unsigned long offset
;
8797 for (i
= 0; i
< sizeof (buf
); i
++)
8800 if ((buf
[i
] & 0x80) == 0)
8803 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
8804 if (i
== sizeof (buf
))
8806 warn (_("Corrupt stack pointer adjustment detected\n"));
8810 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8811 assert (len
== i
+ 1);
8812 offset
= offset
* 8 + 0x408;
8813 printf (_("sp = sp + %ld"), offset
);
8815 else if ((op
& 0xf0) == 0xe0)
8817 if ((op
& 0x0f) == 7)
8820 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
8824 printf (_(" [unsupported opcode]"));
8833 arm_expand_prel31 (Filedata
* filedata
, bfd_vma word
, bfd_vma where
)
8837 offset
= word
& 0x7fffffff;
8838 if (offset
& 0x40000000)
8839 offset
|= ~ (bfd_vma
) 0x7fffffff;
8841 if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
8844 return offset
+ where
;
8848 decode_arm_unwind (Filedata
* filedata
,
8849 struct arm_unw_aux_info
* aux
,
8851 unsigned int remaining
,
8852 bfd_vma data_offset
,
8853 Elf_Internal_Shdr
* data_sec
,
8854 struct arm_section
* data_arm_sec
)
8857 unsigned int more_words
= 0;
8858 struct absaddr addr
;
8859 bfd_vma sym_name
= (bfd_vma
) -1;
8860 bfd_boolean res
= TRUE
;
8864 /* Fetch the first word.
8865 Note - when decoding an object file the address extracted
8866 here will always be 0. So we also pass in the sym_name
8867 parameter so that we can find the symbol associated with
8868 the personality routine. */
8869 if (! get_unwind_section_word (filedata
, aux
, data_arm_sec
, data_sec
, data_offset
,
8870 & word
, & addr
, & sym_name
))
8876 if ((word
& 0x80000000) == 0)
8878 /* Expand prel31 for personality routine. */
8880 const char *procname
;
8882 fn
= arm_expand_prel31 (filedata
, word
, data_sec
->sh_addr
+ data_offset
);
8883 printf (_(" Personality routine: "));
8885 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
8886 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
8888 procname
= aux
->strtab
+ sym_name
;
8889 print_vma (fn
, PREFIX_HEX
);
8892 fputs (" <", stdout
);
8893 fputs (procname
, stdout
);
8894 fputc ('>', stdout
);
8898 procname
= arm_print_vma_and_name (filedata
, aux
, fn
, addr
);
8899 fputc ('\n', stdout
);
8901 /* The GCC personality routines use the standard compact
8902 encoding, starting with one byte giving the number of
8904 if (procname
!= NULL
8905 && (const_strneq (procname
, "__gcc_personality_v0")
8906 || const_strneq (procname
, "__gxx_personality_v0")
8907 || const_strneq (procname
, "__gcj_personality_v0")
8908 || const_strneq (procname
, "__gnu_objc_personality_v0")))
8915 printf (_(" [Truncated data]\n"));
8918 more_words
= word
>> 24;
8928 /* ARM EHABI Section 6.3:
8930 An exception-handling table entry for the compact model looks like:
8934 1 0 index Data for personalityRoutine[index] */
8936 if (filedata
->file_header
.e_machine
== EM_ARM
8937 && (word
& 0x70000000))
8939 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
8943 per_index
= (word
>> 24) & 0x7f;
8944 printf (_(" Compact model index: %d\n"), per_index
);
8951 else if (per_index
< 3)
8953 more_words
= (word
>> 16) & 0xff;
8959 switch (filedata
->file_header
.e_machine
)
8964 if (! decode_arm_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
8965 data_offset
, data_sec
, data_arm_sec
))
8970 warn (_("Unknown ARM compact model index encountered\n"));
8971 printf (_(" [reserved]\n"));
8979 if (! decode_tic6x_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
8980 data_offset
, data_sec
, data_arm_sec
))
8983 else if (per_index
< 5)
8985 if (((word
>> 17) & 0x7f) == 0x7f)
8986 printf (_(" Restore stack from frame pointer\n"));
8988 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
8989 printf (_(" Registers restored: "));
8991 printf (" (compact) ");
8992 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
8994 printf (_(" Return register: %s\n"),
8995 tic6x_unwind_regnames
[word
& 0xf]);
8998 printf (_(" [reserved (%d)]\n"), per_index
);
9002 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
9003 filedata
->file_header
.e_machine
);
9007 /* Decode the descriptors. Not implemented. */
9013 dump_arm_unwind (Filedata
* filedata
,
9014 struct arm_unw_aux_info
* aux
,
9015 Elf_Internal_Shdr
* exidx_sec
)
9017 struct arm_section exidx_arm_sec
, extab_arm_sec
;
9018 unsigned int i
, exidx_len
;
9019 unsigned long j
, nfuns
;
9020 bfd_boolean res
= TRUE
;
9022 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
9023 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
9024 exidx_len
= exidx_sec
->sh_size
/ 8;
9026 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
9027 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
9028 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
9029 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
9031 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
9033 for (i
= 0; i
< exidx_len
; i
++)
9035 unsigned int exidx_fn
, exidx_entry
;
9036 struct absaddr fn_addr
, entry_addr
;
9039 fputc ('\n', stdout
);
9041 if (! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9042 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
9043 || ! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9044 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
9047 arm_free_section (& exidx_arm_sec
);
9048 arm_free_section (& extab_arm_sec
);
9052 /* ARM EHABI, Section 5:
9053 An index table entry consists of 2 words.
9054 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
9055 if (exidx_fn
& 0x80000000)
9057 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
9061 fn
= arm_expand_prel31 (filedata
, exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
9063 arm_print_vma_and_name (filedata
, aux
, fn
, fn_addr
);
9064 fputs (": ", stdout
);
9066 if (exidx_entry
== 1)
9068 print_vma (exidx_entry
, PREFIX_HEX
);
9069 fputs (" [cantunwind]\n", stdout
);
9071 else if (exidx_entry
& 0x80000000)
9073 print_vma (exidx_entry
, PREFIX_HEX
);
9074 fputc ('\n', stdout
);
9075 decode_arm_unwind (filedata
, aux
, exidx_entry
, 4, 0, NULL
, NULL
);
9079 bfd_vma table
, table_offset
= 0;
9080 Elf_Internal_Shdr
*table_sec
;
9082 fputs ("@", stdout
);
9083 table
= arm_expand_prel31 (filedata
, exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
9084 print_vma (table
, PREFIX_HEX
);
9087 /* Locate the matching .ARM.extab. */
9088 if (entry_addr
.section
!= SHN_UNDEF
9089 && entry_addr
.section
< filedata
->file_header
.e_shnum
)
9091 table_sec
= filedata
->section_headers
+ entry_addr
.section
;
9092 table_offset
= entry_addr
.offset
;
9094 if (table_offset
> table_sec
->sh_size
9095 || ((bfd_signed_vma
) table_offset
) < 0)
9097 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
9098 (unsigned long) table_offset
,
9099 printable_section_name (filedata
, table_sec
));
9106 table_sec
= find_section_by_address (filedata
, table
);
9107 if (table_sec
!= NULL
)
9108 table_offset
= table
- table_sec
->sh_addr
;
9111 if (table_sec
== NULL
)
9113 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
9114 (unsigned long) table
);
9119 if (! decode_arm_unwind (filedata
, aux
, 0, 0, table_offset
, table_sec
,
9128 arm_free_section (&exidx_arm_sec
);
9129 arm_free_section (&extab_arm_sec
);
9134 /* Used for both ARM and C6X unwinding tables. */
9137 arm_process_unwind (Filedata
* filedata
)
9139 struct arm_unw_aux_info aux
;
9140 Elf_Internal_Shdr
*unwsec
= NULL
;
9141 Elf_Internal_Shdr
*strsec
;
9142 Elf_Internal_Shdr
*sec
;
9144 unsigned int sec_type
;
9145 bfd_boolean res
= TRUE
;
9147 switch (filedata
->file_header
.e_machine
)
9150 sec_type
= SHT_ARM_EXIDX
;
9154 sec_type
= SHT_C6000_UNWIND
;
9158 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9159 filedata
->file_header
.e_machine
);
9163 if (filedata
->string_table
== NULL
)
9166 memset (& aux
, 0, sizeof (aux
));
9167 aux
.filedata
= filedata
;
9169 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9171 if (sec
->sh_type
== SHT_SYMTAB
&& sec
->sh_link
< filedata
->file_header
.e_shnum
)
9173 aux
.symtab
= GET_ELF_SYMBOLS (filedata
, sec
, & aux
.nsyms
);
9175 strsec
= filedata
->section_headers
+ sec
->sh_link
;
9177 /* PR binutils/17531 file: 011-12666-0.004. */
9178 if (aux
.strtab
!= NULL
)
9180 error (_("Multiple string tables found in file.\n"));
9184 aux
.strtab
= get_data (NULL
, filedata
, strsec
->sh_offset
,
9185 1, strsec
->sh_size
, _("string table"));
9186 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
9188 else if (sec
->sh_type
== sec_type
)
9193 printf (_("\nThere are no unwind sections in this file.\n"));
9195 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9197 if (sec
->sh_type
== sec_type
)
9199 unsigned long num_unwind
= sec
->sh_size
/ (2 * eh_addr_size
);
9200 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
9201 "contains %lu entry:\n",
9202 "\nUnwind section '%s' at offset 0x%lx "
9203 "contains %lu entries:\n",
9205 printable_section_name (filedata
, sec
),
9206 (unsigned long) sec
->sh_offset
,
9209 if (! dump_arm_unwind (filedata
, &aux
, sec
))
9217 free ((char *) aux
.strtab
);
9223 process_unwind (Filedata
* filedata
)
9225 struct unwind_handler
9227 unsigned int machtype
;
9228 bfd_boolean (* handler
)(Filedata
*);
9231 { EM_ARM
, arm_process_unwind
},
9232 { EM_IA_64
, ia64_process_unwind
},
9233 { EM_PARISC
, hppa_process_unwind
},
9234 { EM_TI_C6000
, arm_process_unwind
},
9242 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
9243 if (filedata
->file_header
.e_machine
== handlers
[i
].machtype
)
9244 return handlers
[i
].handler (filedata
);
9246 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9247 get_machine_name (filedata
->file_header
.e_machine
));
9252 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
9254 switch (entry
->d_tag
)
9257 if (entry
->d_un
.d_val
== 0)
9261 static const char * opts
[] =
9263 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9264 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9265 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9266 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9270 bfd_boolean first
= TRUE
;
9272 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
9273 if (entry
->d_un
.d_val
& (1 << cnt
))
9275 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
9281 case DT_MIPS_IVERSION
:
9282 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9283 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
9287 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
9288 /* Note: coded this way so that there is a single string for translation. */
9289 printf (_("<corrupt: %s>"), buf
);
9293 case DT_MIPS_TIME_STAMP
:
9297 time_t atime
= entry
->d_un
.d_val
;
9299 tmp
= gmtime (&atime
);
9300 /* PR 17531: file: 6accc532. */
9302 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
9304 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
9305 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9306 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9307 printf (_("Time Stamp: %s"), timebuf
);
9311 case DT_MIPS_RLD_VERSION
:
9312 case DT_MIPS_LOCAL_GOTNO
:
9313 case DT_MIPS_CONFLICTNO
:
9314 case DT_MIPS_LIBLISTNO
:
9315 case DT_MIPS_SYMTABNO
:
9316 case DT_MIPS_UNREFEXTNO
:
9317 case DT_MIPS_HIPAGENO
:
9318 case DT_MIPS_DELTA_CLASS_NO
:
9319 case DT_MIPS_DELTA_INSTANCE_NO
:
9320 case DT_MIPS_DELTA_RELOC_NO
:
9321 case DT_MIPS_DELTA_SYM_NO
:
9322 case DT_MIPS_DELTA_CLASSSYM_NO
:
9323 case DT_MIPS_COMPACT_SIZE
:
9324 print_vma (entry
->d_un
.d_val
, DEC
);
9328 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9334 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
9336 switch (entry
->d_tag
)
9338 case DT_HP_DLD_FLAGS
:
9347 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
9348 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
9349 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
9350 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
9351 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
9352 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
9353 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
9354 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
9355 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
9356 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
9357 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
9358 { DT_HP_GST
, "HP_GST" },
9359 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
9360 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
9361 { DT_HP_NODELETE
, "HP_NODELETE" },
9362 { DT_HP_GROUP
, "HP_GROUP" },
9363 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
9365 bfd_boolean first
= TRUE
;
9367 bfd_vma val
= entry
->d_un
.d_val
;
9369 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
9370 if (val
& flags
[cnt
].bit
)
9374 fputs (flags
[cnt
].str
, stdout
);
9376 val
^= flags
[cnt
].bit
;
9379 if (val
!= 0 || first
)
9383 print_vma (val
, HEX
);
9389 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9397 /* VMS vs Unix time offset and factor. */
9399 #define VMS_EPOCH_OFFSET 35067168000000000LL
9400 #define VMS_GRANULARITY_FACTOR 10000000
9402 /* Display a VMS time in a human readable format. */
9405 print_vms_time (bfd_int64_t vmstime
)
9410 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
9411 tm
= gmtime (&unxtime
);
9412 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9413 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
9414 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
9419 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
9421 switch (entry
->d_tag
)
9423 case DT_IA_64_PLT_RESERVE
:
9424 /* First 3 slots reserved. */
9425 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9427 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
9430 case DT_IA_64_VMS_LINKTIME
:
9432 print_vms_time (entry
->d_un
.d_val
);
9436 case DT_IA_64_VMS_LNKFLAGS
:
9437 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9438 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
9439 printf (" CALL_DEBUG");
9440 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
9441 printf (" NOP0BUFS");
9442 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
9443 printf (" P0IMAGE");
9444 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
9445 printf (" MKTHREADS");
9446 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
9447 printf (" UPCALLS");
9448 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
9450 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
9451 printf (" INITIALIZE");
9452 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
9454 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
9455 printf (" EXE_INIT");
9456 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
9457 printf (" TBK_IN_IMG");
9458 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
9459 printf (" DBG_IN_IMG");
9460 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
9461 printf (" TBK_IN_DSF");
9462 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
9463 printf (" DBG_IN_DSF");
9464 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
9465 printf (" SIGNATURES");
9466 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
9467 printf (" REL_SEG_OFF");
9471 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9478 get_32bit_dynamic_section (Filedata
* filedata
)
9480 Elf32_External_Dyn
* edyn
;
9481 Elf32_External_Dyn
* ext
;
9482 Elf_Internal_Dyn
* entry
;
9484 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, filedata
, dynamic_addr
, 1,
9485 dynamic_size
, _("dynamic section"));
9489 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9490 might not have the luxury of section headers. Look for the DT_NULL
9491 terminator to determine the number of entries. */
9492 for (ext
= edyn
, dynamic_nent
= 0;
9493 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9497 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9501 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9503 if (dynamic_section
== NULL
)
9505 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9506 (unsigned long) dynamic_nent
);
9511 for (ext
= edyn
, entry
= dynamic_section
;
9512 entry
< dynamic_section
+ dynamic_nent
;
9515 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9516 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9525 get_64bit_dynamic_section (Filedata
* filedata
)
9527 Elf64_External_Dyn
* edyn
;
9528 Elf64_External_Dyn
* ext
;
9529 Elf_Internal_Dyn
* entry
;
9531 /* Read in the data. */
9532 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, filedata
, dynamic_addr
, 1,
9533 dynamic_size
, _("dynamic section"));
9537 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9538 might not have the luxury of section headers. Look for the DT_NULL
9539 terminator to determine the number of entries. */
9540 for (ext
= edyn
, dynamic_nent
= 0;
9541 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
9542 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9546 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9550 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9552 if (dynamic_section
== NULL
)
9554 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9555 (unsigned long) dynamic_nent
);
9560 /* Convert from external to internal formats. */
9561 for (ext
= edyn
, entry
= dynamic_section
;
9562 entry
< dynamic_section
+ dynamic_nent
;
9565 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9566 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9575 print_dynamic_flags (bfd_vma flags
)
9577 bfd_boolean first
= TRUE
;
9583 flag
= flags
& - flags
;
9593 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
9594 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
9595 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
9596 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
9597 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
9598 default: fputs (_("unknown"), stdout
); break;
9604 /* Parse and display the contents of the dynamic section. */
9607 process_dynamic_section (Filedata
* filedata
)
9609 Elf_Internal_Dyn
* entry
;
9611 if (dynamic_size
== 0)
9614 printf (_("\nThere is no dynamic section in this file.\n"));
9621 if (! get_32bit_dynamic_section (filedata
))
9626 if (! get_64bit_dynamic_section (filedata
))
9630 /* Find the appropriate symbol table. */
9631 if (dynamic_symbols
== NULL
)
9633 for (entry
= dynamic_section
;
9634 entry
< dynamic_section
+ dynamic_nent
;
9637 Elf_Internal_Shdr section
;
9639 if (entry
->d_tag
!= DT_SYMTAB
)
9642 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
9644 /* Since we do not know how big the symbol table is,
9645 we default to reading in the entire file (!) and
9646 processing that. This is overkill, I know, but it
9648 section
.sh_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
9649 if ((bfd_size_type
) section
.sh_offset
> filedata
->file_size
)
9651 /* See PR 21379 for a reproducer. */
9652 error (_("Invalid DT_SYMTAB entry: %lx"), (long) section
.sh_offset
);
9656 if (archive_file_offset
!= 0)
9657 section
.sh_size
= archive_file_size
- section
.sh_offset
;
9659 section
.sh_size
= filedata
->file_size
- section
.sh_offset
;
9662 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
9664 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
9665 section
.sh_name
= filedata
->string_table_length
;
9667 dynamic_symbols
= GET_ELF_SYMBOLS (filedata
, §ion
, & num_dynamic_syms
);
9668 if (num_dynamic_syms
< 1)
9670 error (_("Unable to determine the number of symbols to load\n"));
9676 /* Similarly find a string table. */
9677 if (dynamic_strings
== NULL
)
9679 for (entry
= dynamic_section
;
9680 entry
< dynamic_section
+ dynamic_nent
;
9683 unsigned long offset
;
9686 if (entry
->d_tag
!= DT_STRTAB
)
9689 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
9691 /* Since we do not know how big the string table is,
9692 we default to reading in the entire file (!) and
9693 processing that. This is overkill, I know, but it
9696 offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
9698 if (archive_file_offset
!= 0)
9699 str_tab_len
= archive_file_size
- offset
;
9701 str_tab_len
= filedata
->file_size
- offset
;
9703 if (str_tab_len
< 1)
9706 (_("Unable to determine the length of the dynamic string table\n"));
9710 dynamic_strings
= (char *) get_data (NULL
, filedata
, offset
, 1,
9712 _("dynamic string table"));
9713 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : str_tab_len
;
9718 /* And find the syminfo section if available. */
9719 if (dynamic_syminfo
== NULL
)
9721 unsigned long syminsz
= 0;
9723 for (entry
= dynamic_section
;
9724 entry
< dynamic_section
+ dynamic_nent
;
9727 if (entry
->d_tag
== DT_SYMINENT
)
9729 /* Note: these braces are necessary to avoid a syntax
9730 error from the SunOS4 C compiler. */
9731 /* PR binutils/17531: A corrupt file can trigger this test.
9732 So do not use an assert, instead generate an error message. */
9733 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
9734 error (_("Bad value (%d) for SYMINENT entry\n"),
9735 (int) entry
->d_un
.d_val
);
9737 else if (entry
->d_tag
== DT_SYMINSZ
)
9738 syminsz
= entry
->d_un
.d_val
;
9739 else if (entry
->d_tag
== DT_SYMINFO
)
9740 dynamic_syminfo_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
,
9744 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
9746 Elf_External_Syminfo
* extsyminfo
;
9747 Elf_External_Syminfo
* extsym
;
9748 Elf_Internal_Syminfo
* syminfo
;
9750 /* There is a syminfo section. Read the data. */
9751 extsyminfo
= (Elf_External_Syminfo
*)
9752 get_data (NULL
, filedata
, dynamic_syminfo_offset
, 1, syminsz
,
9753 _("symbol information"));
9757 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
9758 if (dynamic_syminfo
== NULL
)
9760 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9761 (unsigned long) syminsz
);
9765 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
9766 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
9767 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
9768 ++syminfo
, ++extsym
)
9770 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
9771 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
9778 if (do_dynamic
&& dynamic_addr
)
9779 printf (ngettext ("\nDynamic section at offset 0x%lx "
9780 "contains %lu entry:\n",
9781 "\nDynamic section at offset 0x%lx "
9782 "contains %lu entries:\n",
9784 dynamic_addr
, (unsigned long) dynamic_nent
);
9786 printf (_(" Tag Type Name/Value\n"));
9788 for (entry
= dynamic_section
;
9789 entry
< dynamic_section
+ dynamic_nent
;
9797 print_vma (entry
->d_tag
, FULL_HEX
);
9798 dtype
= get_dynamic_type (filedata
, entry
->d_tag
);
9799 printf (" (%s)%*s", dtype
,
9800 ((is_32bit_elf
? 27 : 19) - (int) strlen (dtype
)), " ");
9803 switch (entry
->d_tag
)
9807 print_dynamic_flags (entry
->d_un
.d_val
);
9817 switch (entry
->d_tag
)
9820 printf (_("Auxiliary library"));
9824 printf (_("Filter library"));
9828 printf (_("Configuration file"));
9832 printf (_("Dependency audit library"));
9836 printf (_("Audit library"));
9840 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9841 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
9845 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9854 printf (_("Flags:"));
9856 if (entry
->d_un
.d_val
== 0)
9857 printf (_(" None\n"));
9860 unsigned long int val
= entry
->d_un
.d_val
;
9862 if (val
& DTF_1_PARINIT
)
9864 printf (" PARINIT");
9865 val
^= DTF_1_PARINIT
;
9867 if (val
& DTF_1_CONFEXP
)
9869 printf (" CONFEXP");
9870 val
^= DTF_1_CONFEXP
;
9873 printf (" %lx", val
);
9882 printf (_("Flags:"));
9884 if (entry
->d_un
.d_val
== 0)
9885 printf (_(" None\n"));
9888 unsigned long int val
= entry
->d_un
.d_val
;
9890 if (val
& DF_P1_LAZYLOAD
)
9892 printf (" LAZYLOAD");
9893 val
^= DF_P1_LAZYLOAD
;
9895 if (val
& DF_P1_GROUPPERM
)
9897 printf (" GROUPPERM");
9898 val
^= DF_P1_GROUPPERM
;
9901 printf (" %lx", val
);
9910 printf (_("Flags:"));
9911 if (entry
->d_un
.d_val
== 0)
9912 printf (_(" None\n"));
9915 unsigned long int val
= entry
->d_un
.d_val
;
9922 if (val
& DF_1_GLOBAL
)
9927 if (val
& DF_1_GROUP
)
9932 if (val
& DF_1_NODELETE
)
9934 printf (" NODELETE");
9935 val
^= DF_1_NODELETE
;
9937 if (val
& DF_1_LOADFLTR
)
9939 printf (" LOADFLTR");
9940 val
^= DF_1_LOADFLTR
;
9942 if (val
& DF_1_INITFIRST
)
9944 printf (" INITFIRST");
9945 val
^= DF_1_INITFIRST
;
9947 if (val
& DF_1_NOOPEN
)
9952 if (val
& DF_1_ORIGIN
)
9957 if (val
& DF_1_DIRECT
)
9962 if (val
& DF_1_TRANS
)
9967 if (val
& DF_1_INTERPOSE
)
9969 printf (" INTERPOSE");
9970 val
^= DF_1_INTERPOSE
;
9972 if (val
& DF_1_NODEFLIB
)
9974 printf (" NODEFLIB");
9975 val
^= DF_1_NODEFLIB
;
9977 if (val
& DF_1_NODUMP
)
9982 if (val
& DF_1_CONFALT
)
9984 printf (" CONFALT");
9985 val
^= DF_1_CONFALT
;
9987 if (val
& DF_1_ENDFILTEE
)
9989 printf (" ENDFILTEE");
9990 val
^= DF_1_ENDFILTEE
;
9992 if (val
& DF_1_DISPRELDNE
)
9994 printf (" DISPRELDNE");
9995 val
^= DF_1_DISPRELDNE
;
9997 if (val
& DF_1_DISPRELPND
)
9999 printf (" DISPRELPND");
10000 val
^= DF_1_DISPRELPND
;
10002 if (val
& DF_1_NODIRECT
)
10004 printf (" NODIRECT");
10005 val
^= DF_1_NODIRECT
;
10007 if (val
& DF_1_IGNMULDEF
)
10009 printf (" IGNMULDEF");
10010 val
^= DF_1_IGNMULDEF
;
10012 if (val
& DF_1_NOKSYMS
)
10014 printf (" NOKSYMS");
10015 val
^= DF_1_NOKSYMS
;
10017 if (val
& DF_1_NOHDR
)
10022 if (val
& DF_1_EDITED
)
10024 printf (" EDITED");
10025 val
^= DF_1_EDITED
;
10027 if (val
& DF_1_NORELOC
)
10029 printf (" NORELOC");
10030 val
^= DF_1_NORELOC
;
10032 if (val
& DF_1_SYMINTPOSE
)
10034 printf (" SYMINTPOSE");
10035 val
^= DF_1_SYMINTPOSE
;
10037 if (val
& DF_1_GLOBAUDIT
)
10039 printf (" GLOBAUDIT");
10040 val
^= DF_1_GLOBAUDIT
;
10042 if (val
& DF_1_SINGLETON
)
10044 printf (" SINGLETON");
10045 val
^= DF_1_SINGLETON
;
10047 if (val
& DF_1_STUB
)
10052 if (val
& DF_1_PIE
)
10057 if (val
& DF_1_KMOD
)
10062 if (val
& DF_1_WEAKFILTER
)
10064 printf (" WEAKFILTER");
10065 val
^= DF_1_WEAKFILTER
;
10067 if (val
& DF_1_NOCOMMON
)
10069 printf (" NOCOMMON");
10070 val
^= DF_1_NOCOMMON
;
10073 printf (" %lx", val
);
10080 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10082 puts (get_dynamic_type (filedata
, entry
->d_un
.d_val
));
10102 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10108 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
10109 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
10115 switch (entry
->d_tag
)
10118 printf (_("Shared library: [%s]"), name
);
10120 if (streq (name
, program_interpreter
))
10121 printf (_(" program interpreter"));
10125 printf (_("Library soname: [%s]"), name
);
10129 printf (_("Library rpath: [%s]"), name
);
10133 printf (_("Library runpath: [%s]"), name
);
10137 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10142 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10155 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10156 /* Fall through. */
10160 case DT_INIT_ARRAYSZ
:
10161 case DT_FINI_ARRAYSZ
:
10162 case DT_GNU_CONFLICTSZ
:
10163 case DT_GNU_LIBLISTSZ
:
10166 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10167 printf (_(" (bytes)\n"));
10172 case DT_VERNEEDNUM
:
10177 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10186 case DT_INIT_ARRAY
:
10187 case DT_FINI_ARRAY
:
10190 if (entry
->d_tag
== DT_USED
10191 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
10193 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
10197 printf (_("Not needed object: [%s]\n"), name
);
10202 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10208 /* The value of this entry is ignored. */
10213 case DT_GNU_PRELINKED
:
10217 time_t atime
= entry
->d_un
.d_val
;
10219 tmp
= gmtime (&atime
);
10220 /* PR 17533 file: 041-1244816-0.004. */
10222 printf (_("<corrupt time val: %lx"),
10223 (unsigned long) atime
);
10225 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10226 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
10227 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
10233 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10236 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10242 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
10243 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
10248 switch (filedata
->file_header
.e_machine
)
10251 case EM_MIPS_RS3_LE
:
10252 dynamic_section_mips_val (entry
);
10255 dynamic_section_parisc_val (entry
);
10258 dynamic_section_ia64_val (entry
);
10261 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10273 get_ver_flags (unsigned int flags
)
10275 static char buff
[128];
10282 if (flags
& VER_FLG_BASE
)
10283 strcat (buff
, "BASE");
10285 if (flags
& VER_FLG_WEAK
)
10287 if (flags
& VER_FLG_BASE
)
10288 strcat (buff
, " | ");
10290 strcat (buff
, "WEAK");
10293 if (flags
& VER_FLG_INFO
)
10295 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
10296 strcat (buff
, " | ");
10298 strcat (buff
, "INFO");
10301 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10303 if (flags
& (VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10304 strcat (buff
, " | ");
10306 strcat (buff
, _("<unknown>"));
10312 /* Display the contents of the version sections. */
10315 process_version_sections (Filedata
* filedata
)
10317 Elf_Internal_Shdr
* section
;
10319 bfd_boolean found
= FALSE
;
10324 for (i
= 0, section
= filedata
->section_headers
;
10325 i
< filedata
->file_header
.e_shnum
;
10328 switch (section
->sh_type
)
10330 case SHT_GNU_verdef
:
10332 Elf_External_Verdef
* edefs
;
10339 printf (ngettext ("\nVersion definition section '%s' "
10340 "contains %u entry:\n",
10341 "\nVersion definition section '%s' "
10342 "contains %u entries:\n",
10344 printable_section_name (filedata
, section
),
10347 printf (_(" Addr: 0x"));
10348 printf_vma (section
->sh_addr
);
10349 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10350 (unsigned long) section
->sh_offset
, section
->sh_link
,
10351 printable_section_name_from_index (filedata
, section
->sh_link
));
10353 edefs
= (Elf_External_Verdef
*)
10354 get_data (NULL
, filedata
, section
->sh_offset
, 1,section
->sh_size
,
10355 _("version definition section"));
10358 endbuf
= (char *) edefs
+ section
->sh_size
;
10360 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
10363 Elf_External_Verdef
* edef
;
10364 Elf_Internal_Verdef ent
;
10365 Elf_External_Verdaux
* eaux
;
10366 Elf_Internal_Verdaux aux
;
10367 unsigned long isum
;
10370 vstart
= ((char *) edefs
) + idx
;
10371 if (vstart
+ sizeof (*edef
) > endbuf
)
10374 edef
= (Elf_External_Verdef
*) vstart
;
10376 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
10377 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
10378 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
10379 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
10380 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
10381 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
10382 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
10384 printf (_(" %#06lx: Rev: %d Flags: %s"),
10385 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
10387 printf (_(" Index: %d Cnt: %d "),
10388 ent
.vd_ndx
, ent
.vd_cnt
);
10390 /* Check for overflow. */
10391 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
10394 vstart
+= ent
.vd_aux
;
10396 if (vstart
+ sizeof (*eaux
) > endbuf
)
10398 eaux
= (Elf_External_Verdaux
*) vstart
;
10400 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10401 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10403 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10404 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
10406 printf (_("Name index: %ld\n"), aux
.vda_name
);
10408 isum
= idx
+ ent
.vd_aux
;
10410 for (j
= 1; j
< ent
.vd_cnt
; j
++)
10412 if (aux
.vda_next
< sizeof (*eaux
)
10413 && !(j
== ent
.vd_cnt
- 1 && aux
.vda_next
== 0))
10415 warn (_("Invalid vda_next field of %lx\n"),
10420 /* Check for overflow. */
10421 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
10424 isum
+= aux
.vda_next
;
10425 vstart
+= aux
.vda_next
;
10427 if (vstart
+ sizeof (*eaux
) > endbuf
)
10429 eaux
= (Elf_External_Verdaux
*) vstart
;
10431 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10432 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10434 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10435 printf (_(" %#06lx: Parent %d: %s\n"),
10436 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
10438 printf (_(" %#06lx: Parent %d, name index: %ld\n"),
10439 isum
, j
, aux
.vda_name
);
10442 if (j
< ent
.vd_cnt
)
10443 printf (_(" Version def aux past end of section\n"));
10446 file: id:000001,src:000172+005151,op:splice,rep:2. */
10447 if (ent
.vd_next
< sizeof (*edef
)
10448 && !(cnt
== section
->sh_info
- 1 && ent
.vd_next
== 0))
10450 warn (_("Invalid vd_next field of %lx\n"), ent
.vd_next
);
10451 cnt
= section
->sh_info
;
10454 if (ent
.vd_next
> (size_t) (endbuf
- ((char *) edefs
+ idx
)))
10457 idx
+= ent
.vd_next
;
10460 if (cnt
< section
->sh_info
)
10461 printf (_(" Version definition past end of section\n"));
10467 case SHT_GNU_verneed
:
10469 Elf_External_Verneed
* eneed
;
10476 printf (ngettext ("\nVersion needs section '%s' "
10477 "contains %u entry:\n",
10478 "\nVersion needs section '%s' "
10479 "contains %u entries:\n",
10481 printable_section_name (filedata
, section
), section
->sh_info
);
10483 printf (_(" Addr: 0x"));
10484 printf_vma (section
->sh_addr
);
10485 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10486 (unsigned long) section
->sh_offset
, section
->sh_link
,
10487 printable_section_name_from_index (filedata
, section
->sh_link
));
10489 eneed
= (Elf_External_Verneed
*) get_data (NULL
, filedata
,
10490 section
->sh_offset
, 1,
10492 _("Version Needs section"));
10495 endbuf
= (char *) eneed
+ section
->sh_size
;
10497 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
10499 Elf_External_Verneed
* entry
;
10500 Elf_Internal_Verneed ent
;
10501 unsigned long isum
;
10505 vstart
= ((char *) eneed
) + idx
;
10506 if (vstart
+ sizeof (*entry
) > endbuf
)
10509 entry
= (Elf_External_Verneed
*) vstart
;
10511 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
10512 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
10513 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
10514 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
10515 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
10517 printf (_(" %#06lx: Version: %d"), idx
, ent
.vn_version
);
10519 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
10520 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
10522 printf (_(" File: %lx"), ent
.vn_file
);
10524 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
10526 /* Check for overflow. */
10527 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
10529 vstart
+= ent
.vn_aux
;
10531 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
10533 Elf_External_Vernaux
* eaux
;
10534 Elf_Internal_Vernaux aux
;
10536 if (vstart
+ sizeof (*eaux
) > endbuf
)
10538 eaux
= (Elf_External_Vernaux
*) vstart
;
10540 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
10541 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
10542 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
10543 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
10544 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
10546 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
10547 printf (_(" %#06lx: Name: %s"),
10548 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
10550 printf (_(" %#06lx: Name index: %lx"),
10551 isum
, aux
.vna_name
);
10553 printf (_(" Flags: %s Version: %d\n"),
10554 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
10556 if (aux
.vna_next
< sizeof (*eaux
)
10557 && !(j
== ent
.vn_cnt
- 1 && aux
.vna_next
== 0))
10559 warn (_("Invalid vna_next field of %lx\n"),
10564 /* Check for overflow. */
10565 if (aux
.vna_next
> (size_t) (endbuf
- vstart
))
10567 isum
+= aux
.vna_next
;
10568 vstart
+= aux
.vna_next
;
10571 if (j
< ent
.vn_cnt
)
10572 warn (_("Missing Version Needs auxillary information\n"));
10574 if (ent
.vn_next
< sizeof (*entry
)
10575 && !(cnt
== section
->sh_info
- 1 && ent
.vn_next
== 0))
10577 warn (_("Invalid vn_next field of %lx\n"), ent
.vn_next
);
10578 cnt
= section
->sh_info
;
10581 if (ent
.vn_next
> (size_t) (endbuf
- ((char *) eneed
+ idx
)))
10583 idx
+= ent
.vn_next
;
10586 if (cnt
< section
->sh_info
)
10587 warn (_("Missing Version Needs information\n"));
10593 case SHT_GNU_versym
:
10595 Elf_Internal_Shdr
* link_section
;
10598 unsigned char * edata
;
10599 unsigned short * data
;
10601 Elf_Internal_Sym
* symbols
;
10602 Elf_Internal_Shdr
* string_sec
;
10603 unsigned long num_syms
;
10606 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
10609 link_section
= filedata
->section_headers
+ section
->sh_link
;
10610 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
10612 if (link_section
->sh_link
>= filedata
->file_header
.e_shnum
)
10617 symbols
= GET_ELF_SYMBOLS (filedata
, link_section
, & num_syms
);
10618 if (symbols
== NULL
)
10621 string_sec
= filedata
->section_headers
+ link_section
->sh_link
;
10623 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
10624 string_sec
->sh_size
,
10625 _("version string table"));
10632 printf (ngettext ("\nVersion symbols section '%s' "
10633 "contains %lu entry:\n",
10634 "\nVersion symbols section '%s' "
10635 "contains %lu entries:\n",
10637 printable_section_name (filedata
, section
), (unsigned long) total
);
10639 printf (_(" Addr: "));
10640 printf_vma (section
->sh_addr
);
10641 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10642 (unsigned long) section
->sh_offset
, section
->sh_link
,
10643 printable_section_name (filedata
, link_section
));
10645 off
= offset_from_vma (filedata
,
10646 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
10647 total
* sizeof (short));
10648 edata
= (unsigned char *) get_data (NULL
, filedata
, off
, total
,
10650 _("version symbol data"));
10658 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
10660 for (cnt
= total
; cnt
--;)
10661 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
10666 for (cnt
= 0; cnt
< total
; cnt
+= 4)
10670 char *invalid
= _("*invalid*");
10672 printf (" %03x:", cnt
);
10674 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
10675 switch (data
[cnt
+ j
])
10678 fputs (_(" 0 (*local*) "), stdout
);
10682 fputs (_(" 1 (*global*) "), stdout
);
10686 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
10687 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
10689 /* If this index value is greater than the size of the symbols
10690 array, break to avoid an out-of-bounds read. */
10691 if ((unsigned long)(cnt
+ j
) >= num_syms
)
10693 warn (_("invalid index into symbol array\n"));
10698 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
10700 Elf_Internal_Verneed ivn
;
10701 unsigned long offset
;
10703 offset
= offset_from_vma
10704 (filedata
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
10705 sizeof (Elf_External_Verneed
));
10709 Elf_Internal_Vernaux ivna
;
10710 Elf_External_Verneed evn
;
10711 Elf_External_Vernaux evna
;
10712 unsigned long a_off
;
10714 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
10715 _("version need")) == NULL
)
10718 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
10719 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
10721 a_off
= offset
+ ivn
.vn_aux
;
10725 if (get_data (&evna
, filedata
, a_off
, sizeof (evna
),
10726 1, _("version need aux (2)")) == NULL
)
10729 ivna
.vna_other
= 0;
10733 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
10734 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
10737 a_off
+= ivna
.vna_next
;
10739 while (ivna
.vna_other
!= data
[cnt
+ j
]
10740 && ivna
.vna_next
!= 0);
10742 if (ivna
.vna_other
== data
[cnt
+ j
])
10744 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
10746 if (ivna
.vna_name
>= string_sec
->sh_size
)
10749 name
= strtab
+ ivna
.vna_name
;
10753 offset
+= ivn
.vn_next
;
10755 while (ivn
.vn_next
);
10758 if (data
[cnt
+ j
] != 0x8001
10759 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
10761 Elf_Internal_Verdef ivd
;
10762 Elf_External_Verdef evd
;
10763 unsigned long offset
;
10765 offset
= offset_from_vma
10766 (filedata
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
10771 if (get_data (&evd
, filedata
, offset
, sizeof (evd
), 1,
10772 _("version def")) == NULL
)
10775 /* PR 17531: file: 046-1082287-0.004. */
10776 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
10781 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
10782 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
10785 offset
+= ivd
.vd_next
;
10787 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
10788 && ivd
.vd_next
!= 0);
10790 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
10792 Elf_External_Verdaux evda
;
10793 Elf_Internal_Verdaux ivda
;
10795 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
10797 if (get_data (&evda
, filedata
,
10798 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
10800 _("version def aux")) == NULL
)
10803 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
10805 if (ivda
.vda_name
>= string_sec
->sh_size
)
10807 else if (name
!= NULL
&& name
!= invalid
)
10808 name
= _("*both*");
10810 name
= strtab
+ ivda
.vda_name
;
10814 nn
+= printf ("(%s%-*s",
10816 12 - (int) strlen (name
),
10820 printf ("%*c", 18 - nn
, ' ');
10838 printf (_("\nNo version information found in this file.\n"));
10843 static const char *
10844 get_symbol_binding (Filedata
* filedata
, unsigned int binding
)
10846 static char buff
[32];
10850 case STB_LOCAL
: return "LOCAL";
10851 case STB_GLOBAL
: return "GLOBAL";
10852 case STB_WEAK
: return "WEAK";
10854 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
10855 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
10857 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
10859 if (binding
== STB_GNU_UNIQUE
10860 && (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10861 /* GNU is still using the default value 0. */
10862 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10864 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
10867 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
10872 static const char *
10873 get_symbol_type (Filedata
* filedata
, unsigned int type
)
10875 static char buff
[32];
10879 case STT_NOTYPE
: return "NOTYPE";
10880 case STT_OBJECT
: return "OBJECT";
10881 case STT_FUNC
: return "FUNC";
10882 case STT_SECTION
: return "SECTION";
10883 case STT_FILE
: return "FILE";
10884 case STT_COMMON
: return "COMMON";
10885 case STT_TLS
: return "TLS";
10886 case STT_RELC
: return "RELC";
10887 case STT_SRELC
: return "SRELC";
10889 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
10891 if (filedata
->file_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
10892 return "THUMB_FUNC";
10894 if (filedata
->file_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
10897 if (filedata
->file_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
10898 return "PARISC_MILLI";
10900 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
10902 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
10904 if (filedata
->file_header
.e_machine
== EM_PARISC
)
10906 if (type
== STT_HP_OPAQUE
)
10907 return "HP_OPAQUE";
10908 if (type
== STT_HP_STUB
)
10912 if (type
== STT_GNU_IFUNC
10913 && (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10914 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
10915 /* GNU is still using the default value 0. */
10916 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10919 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
10922 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
10927 static const char *
10928 get_symbol_visibility (unsigned int visibility
)
10930 switch (visibility
)
10932 case STV_DEFAULT
: return "DEFAULT";
10933 case STV_INTERNAL
: return "INTERNAL";
10934 case STV_HIDDEN
: return "HIDDEN";
10935 case STV_PROTECTED
: return "PROTECTED";
10937 error (_("Unrecognized visibility value: %u"), visibility
);
10938 return _("<unknown>");
10942 static const char *
10943 get_solaris_symbol_visibility (unsigned int visibility
)
10945 switch (visibility
)
10947 case 4: return "EXPORTED";
10948 case 5: return "SINGLETON";
10949 case 6: return "ELIMINATE";
10950 default: return get_symbol_visibility (visibility
);
10954 static const char *
10955 get_mips_symbol_other (unsigned int other
)
10959 case STO_OPTIONAL
: return "OPTIONAL";
10960 case STO_MIPS_PLT
: return "MIPS PLT";
10961 case STO_MIPS_PIC
: return "MIPS PIC";
10962 case STO_MICROMIPS
: return "MICROMIPS";
10963 case STO_MICROMIPS
| STO_MIPS_PIC
: return "MICROMIPS, MIPS PIC";
10964 case STO_MIPS16
: return "MIPS16";
10965 default: return NULL
;
10969 static const char *
10970 get_ia64_symbol_other (Filedata
* filedata
, unsigned int other
)
10972 if (is_ia64_vms (filedata
))
10974 static char res
[32];
10978 /* Function types is for images and .STB files only. */
10979 switch (filedata
->file_header
.e_type
)
10983 switch (VMS_ST_FUNC_TYPE (other
))
10985 case VMS_SFT_CODE_ADDR
:
10986 strcat (res
, " CA");
10988 case VMS_SFT_SYMV_IDX
:
10989 strcat (res
, " VEC");
10992 strcat (res
, " FD");
10994 case VMS_SFT_RESERVE
:
10995 strcat (res
, " RSV");
10998 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10999 VMS_ST_FUNC_TYPE (other
));
11000 strcat (res
, " <unknown>");
11007 switch (VMS_ST_LINKAGE (other
))
11009 case VMS_STL_IGNORE
:
11010 strcat (res
, " IGN");
11012 case VMS_STL_RESERVE
:
11013 strcat (res
, " RSV");
11016 strcat (res
, " STD");
11019 strcat (res
, " LNK");
11022 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
11023 VMS_ST_LINKAGE (other
));
11024 strcat (res
, " <unknown>");
11036 static const char *
11037 get_ppc64_symbol_other (unsigned int other
)
11039 if (PPC64_LOCAL_ENTRY_OFFSET (other
) != 0)
11041 static char buf
[32];
11042 snprintf (buf
, sizeof buf
, _("<localentry>: %d"),
11043 PPC64_LOCAL_ENTRY_OFFSET (other
));
11049 static const char *
11050 get_symbol_other (Filedata
* filedata
, unsigned int other
)
11052 const char * result
= NULL
;
11053 static char buff
[32];
11058 switch (filedata
->file_header
.e_machine
)
11061 result
= get_mips_symbol_other (other
);
11064 result
= get_ia64_symbol_other (filedata
, other
);
11067 result
= get_ppc64_symbol_other (other
);
11077 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
11081 static const char *
11082 get_symbol_index_type (Filedata
* filedata
, unsigned int type
)
11084 static char buff
[32];
11088 case SHN_UNDEF
: return "UND";
11089 case SHN_ABS
: return "ABS";
11090 case SHN_COMMON
: return "COM";
11092 if (type
== SHN_IA_64_ANSI_COMMON
11093 && filedata
->file_header
.e_machine
== EM_IA_64
11094 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
11096 else if ((filedata
->file_header
.e_machine
== EM_X86_64
11097 || filedata
->file_header
.e_machine
== EM_L1OM
11098 || filedata
->file_header
.e_machine
== EM_K1OM
)
11099 && type
== SHN_X86_64_LCOMMON
)
11100 return "LARGE_COM";
11101 else if ((type
== SHN_MIPS_SCOMMON
11102 && filedata
->file_header
.e_machine
== EM_MIPS
)
11103 || (type
== SHN_TIC6X_SCOMMON
11104 && filedata
->file_header
.e_machine
== EM_TI_C6000
))
11106 else if (type
== SHN_MIPS_SUNDEFINED
11107 && filedata
->file_header
.e_machine
== EM_MIPS
)
11109 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
11110 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
11111 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
11112 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
11113 else if (type
>= SHN_LORESERVE
)
11114 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
11115 else if (type
>= filedata
->file_header
.e_shnum
)
11116 sprintf (buff
, _("bad section index[%3d]"), type
);
11118 sprintf (buff
, "%3d", type
);
11126 get_dynamic_data (Filedata
* filedata
, bfd_size_type number
, unsigned int ent_size
)
11128 unsigned char * e_data
;
11131 /* If the size_t type is smaller than the bfd_size_type, eg because
11132 you are building a 32-bit tool on a 64-bit host, then make sure
11133 that when (number) is cast to (size_t) no information is lost. */
11134 if (sizeof (size_t) < sizeof (bfd_size_type
)
11135 && (bfd_size_type
) ((size_t) number
) != number
)
11137 error (_("Size truncation prevents reading %s elements of size %u\n"),
11138 bfd_vmatoa ("u", number
), ent_size
);
11142 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
11143 attempting to allocate memory when the read is bound to fail. */
11144 if (ent_size
* number
> filedata
->file_size
)
11146 error (_("Invalid number of dynamic entries: %s\n"),
11147 bfd_vmatoa ("u", number
));
11151 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
11152 if (e_data
== NULL
)
11154 error (_("Out of memory reading %s dynamic entries\n"),
11155 bfd_vmatoa ("u", number
));
11159 if (fread (e_data
, ent_size
, (size_t) number
, filedata
->handle
) != number
)
11161 error (_("Unable to read in %s bytes of dynamic data\n"),
11162 bfd_vmatoa ("u", number
* ent_size
));
11167 i_data
= (bfd_vma
*) cmalloc ((size_t) number
, sizeof (*i_data
));
11168 if (i_data
== NULL
)
11170 error (_("Out of memory allocating space for %s dynamic entries\n"),
11171 bfd_vmatoa ("u", number
));
11177 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
11185 print_dynamic_symbol (Filedata
* filedata
, bfd_vma si
, unsigned long hn
)
11187 Elf_Internal_Sym
* psym
;
11190 n
= print_vma (si
, DEC_5
);
11192 fputs (&" "[n
], stdout
);
11193 printf (" %3lu: ", hn
);
11195 if (dynamic_symbols
== NULL
|| si
>= num_dynamic_syms
)
11197 printf (_("<No info available for dynamic symbol number %lu>\n"),
11198 (unsigned long) si
);
11202 psym
= dynamic_symbols
+ si
;
11203 print_vma (psym
->st_value
, LONG_HEX
);
11205 print_vma (psym
->st_size
, DEC_5
);
11207 printf (" %-7s", get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)));
11208 printf (" %-6s", get_symbol_binding (filedata
, ELF_ST_BIND (psym
->st_info
)));
11210 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
11211 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
11214 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
11216 printf (" %-7s", get_symbol_visibility (vis
));
11217 /* Check to see if any other bits in the st_other field are set.
11218 Note - displaying this information disrupts the layout of the
11219 table being generated, but for the moment this case is very
11221 if (psym
->st_other
^ vis
)
11222 printf (" [%s] ", get_symbol_other (filedata
, psym
->st_other
^ vis
));
11225 printf (" %3.3s ", get_symbol_index_type (filedata
, psym
->st_shndx
));
11226 if (VALID_DYNAMIC_NAME (psym
->st_name
))
11227 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
11229 printf (_(" <corrupt: %14ld>"), psym
->st_name
);
11233 static const char *
11234 get_symbol_version_string (Filedata
* filedata
,
11235 bfd_boolean is_dynsym
,
11236 const char * strtab
,
11237 unsigned long int strtab_size
,
11239 Elf_Internal_Sym
* psym
,
11240 enum versioned_symbol_info
* sym_info
,
11241 unsigned short * vna_other
)
11243 unsigned char data
[2];
11244 unsigned short vers_data
;
11245 unsigned long offset
;
11248 || version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
11251 offset
= offset_from_vma (filedata
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
11252 sizeof data
+ si
* sizeof (vers_data
));
11254 if (get_data (&data
, filedata
, offset
+ si
* sizeof (vers_data
),
11255 sizeof (data
), 1, _("version data")) == NULL
)
11258 vers_data
= byte_get (data
, 2);
11260 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
<= 1)
11263 /* Usually we'd only see verdef for defined symbols, and verneed for
11264 undefined symbols. However, symbols defined by the linker in
11265 .dynbss for variables copied from a shared library in order to
11266 avoid text relocations are defined yet have verneed. We could
11267 use a heuristic to detect the special case, for example, check
11268 for verneed first on symbols defined in SHT_NOBITS sections, but
11269 it is simpler and more reliable to just look for both verdef and
11270 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
11272 if (psym
->st_shndx
!= SHN_UNDEF
11273 && vers_data
!= 0x8001
11274 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
11276 Elf_Internal_Verdef ivd
;
11277 Elf_Internal_Verdaux ivda
;
11278 Elf_External_Verdaux evda
;
11281 off
= offset_from_vma (filedata
,
11282 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
11283 sizeof (Elf_External_Verdef
));
11287 Elf_External_Verdef evd
;
11289 if (get_data (&evd
, filedata
, off
, sizeof (evd
), 1,
11290 _("version def")) == NULL
)
11298 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
11299 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
11300 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
11303 off
+= ivd
.vd_next
;
11305 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
11307 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
11309 off
-= ivd
.vd_next
;
11312 if (get_data (&evda
, filedata
, off
, sizeof (evda
), 1,
11313 _("version def aux")) != NULL
)
11315 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
11317 if (psym
->st_name
!= ivda
.vda_name
)
11319 *sym_info
= ((vers_data
& VERSYM_HIDDEN
) != 0
11320 ? symbol_hidden
: symbol_public
);
11321 return (ivda
.vda_name
< strtab_size
11322 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
11328 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
11330 Elf_External_Verneed evn
;
11331 Elf_Internal_Verneed ivn
;
11332 Elf_Internal_Vernaux ivna
;
11334 offset
= offset_from_vma (filedata
,
11335 version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
11339 unsigned long vna_off
;
11341 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
11342 _("version need")) == NULL
)
11345 ivna
.vna_other
= 0;
11350 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
11351 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
11353 vna_off
= offset
+ ivn
.vn_aux
;
11357 Elf_External_Vernaux evna
;
11359 if (get_data (&evna
, filedata
, vna_off
, sizeof (evna
), 1,
11360 _("version need aux (3)")) == NULL
)
11363 ivna
.vna_other
= 0;
11368 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
11369 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
11370 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
11373 vna_off
+= ivna
.vna_next
;
11375 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
11377 if (ivna
.vna_other
== vers_data
)
11380 offset
+= ivn
.vn_next
;
11382 while (ivn
.vn_next
!= 0);
11384 if (ivna
.vna_other
== vers_data
)
11386 *sym_info
= symbol_undefined
;
11387 *vna_other
= ivna
.vna_other
;
11388 return (ivna
.vna_name
< strtab_size
11389 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
11395 /* Dump the symbol table. */
11397 process_symbol_table (Filedata
* filedata
)
11399 Elf_Internal_Shdr
* section
;
11400 bfd_size_type nbuckets
= 0;
11401 bfd_size_type nchains
= 0;
11402 bfd_vma
* buckets
= NULL
;
11403 bfd_vma
* chains
= NULL
;
11404 bfd_vma ngnubuckets
= 0;
11405 bfd_vma
* gnubuckets
= NULL
;
11406 bfd_vma
* gnuchains
= NULL
;
11407 bfd_vma gnusymidx
= 0;
11408 bfd_size_type ngnuchains
= 0;
11410 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
11413 if (dynamic_info
[DT_HASH
]
11415 || (do_using_dynamic
11417 && dynamic_strings
!= NULL
)))
11419 unsigned char nb
[8];
11420 unsigned char nc
[8];
11421 unsigned int hash_ent_size
= 4;
11423 if ((filedata
->file_header
.e_machine
== EM_ALPHA
11424 || filedata
->file_header
.e_machine
== EM_S390
11425 || filedata
->file_header
.e_machine
== EM_S390_OLD
)
11426 && filedata
->file_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
11429 if (fseek (filedata
->handle
,
11430 (archive_file_offset
11431 + offset_from_vma (filedata
, dynamic_info
[DT_HASH
],
11432 sizeof nb
+ sizeof nc
)),
11435 error (_("Unable to seek to start of dynamic information\n"));
11439 if (fread (nb
, hash_ent_size
, 1, filedata
->handle
) != 1)
11441 error (_("Failed to read in number of buckets\n"));
11445 if (fread (nc
, hash_ent_size
, 1, filedata
->handle
) != 1)
11447 error (_("Failed to read in number of chains\n"));
11451 nbuckets
= byte_get (nb
, hash_ent_size
);
11452 nchains
= byte_get (nc
, hash_ent_size
);
11454 buckets
= get_dynamic_data (filedata
, nbuckets
, hash_ent_size
);
11455 chains
= get_dynamic_data (filedata
, nchains
, hash_ent_size
);
11458 if (buckets
== NULL
|| chains
== NULL
)
11460 if (do_using_dynamic
)
11471 if (dynamic_info_DT_GNU_HASH
11473 || (do_using_dynamic
11475 && dynamic_strings
!= NULL
)))
11477 unsigned char nb
[16];
11478 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
11479 bfd_vma buckets_vma
;
11481 if (fseek (filedata
->handle
,
11482 (archive_file_offset
11483 + offset_from_vma (filedata
, dynamic_info_DT_GNU_HASH
,
11487 error (_("Unable to seek to start of dynamic information\n"));
11491 if (fread (nb
, 16, 1, filedata
->handle
) != 1)
11493 error (_("Failed to read in number of buckets\n"));
11497 ngnubuckets
= byte_get (nb
, 4);
11498 gnusymidx
= byte_get (nb
+ 4, 4);
11499 bitmaskwords
= byte_get (nb
+ 8, 4);
11500 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
11502 buckets_vma
+= bitmaskwords
* 4;
11504 buckets_vma
+= bitmaskwords
* 8;
11506 if (fseek (filedata
->handle
,
11507 (archive_file_offset
11508 + offset_from_vma (filedata
, buckets_vma
, 4)),
11511 error (_("Unable to seek to start of dynamic information\n"));
11515 gnubuckets
= get_dynamic_data (filedata
, ngnubuckets
, 4);
11517 if (gnubuckets
== NULL
)
11520 for (i
= 0; i
< ngnubuckets
; i
++)
11521 if (gnubuckets
[i
] != 0)
11523 if (gnubuckets
[i
] < gnusymidx
)
11526 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
11527 maxchain
= gnubuckets
[i
];
11530 if (maxchain
== 0xffffffff)
11533 maxchain
-= gnusymidx
;
11535 if (fseek (filedata
->handle
,
11536 (archive_file_offset
11537 + offset_from_vma (filedata
, buckets_vma
11538 + 4 * (ngnubuckets
+ maxchain
), 4)),
11541 error (_("Unable to seek to start of dynamic information\n"));
11547 if (fread (nb
, 4, 1, filedata
->handle
) != 1)
11549 error (_("Failed to determine last chain length\n"));
11553 if (maxchain
+ 1 == 0)
11558 while ((byte_get (nb
, 4) & 1) == 0);
11560 if (fseek (filedata
->handle
,
11561 (archive_file_offset
11562 + offset_from_vma (filedata
, buckets_vma
+ 4 * ngnubuckets
, 4)),
11565 error (_("Unable to seek to start of dynamic information\n"));
11569 gnuchains
= get_dynamic_data (filedata
, maxchain
, 4);
11570 ngnuchains
= maxchain
;
11573 if (gnuchains
== NULL
)
11578 if (do_using_dynamic
)
11583 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
11585 && do_using_dynamic
11586 && dynamic_strings
!= NULL
11587 && dynamic_symbols
!= NULL
)
11591 if (dynamic_info
[DT_HASH
])
11596 printf (_("\nSymbol table for image:\n"));
11598 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11600 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11602 visited
= xcmalloc (nchains
, 1);
11603 memset (visited
, 0, nchains
);
11604 for (hn
= 0; hn
< nbuckets
; hn
++)
11606 for (si
= buckets
[hn
]; si
> 0; si
= chains
[si
])
11608 print_dynamic_symbol (filedata
, si
, hn
);
11609 if (si
>= nchains
|| visited
[si
])
11611 error (_("histogram chain is corrupt\n"));
11620 if (dynamic_info_DT_GNU_HASH
)
11622 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
11624 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11626 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11628 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11629 if (gnubuckets
[hn
] != 0)
11631 bfd_vma si
= gnubuckets
[hn
];
11632 bfd_vma off
= si
- gnusymidx
;
11636 print_dynamic_symbol (filedata
, si
, hn
);
11639 while (off
< ngnuchains
&& (gnuchains
[off
++] & 1) == 0);
11643 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
11644 && filedata
->section_headers
!= NULL
)
11648 for (i
= 0, section
= filedata
->section_headers
;
11649 i
< filedata
->file_header
.e_shnum
;
11653 char * strtab
= NULL
;
11654 unsigned long int strtab_size
= 0;
11655 Elf_Internal_Sym
* symtab
;
11656 Elf_Internal_Sym
* psym
;
11657 unsigned long num_syms
;
11659 if ((section
->sh_type
!= SHT_SYMTAB
11660 && section
->sh_type
!= SHT_DYNSYM
)
11662 && section
->sh_type
== SHT_SYMTAB
))
11665 if (section
->sh_entsize
== 0)
11667 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
11668 printable_section_name (filedata
, section
));
11672 num_syms
= section
->sh_size
/ section
->sh_entsize
;
11673 printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
11674 "\nSymbol table '%s' contains %lu entries:\n",
11676 printable_section_name (filedata
, section
),
11680 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11682 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11684 symtab
= GET_ELF_SYMBOLS (filedata
, section
, & num_syms
);
11685 if (symtab
== NULL
)
11688 if (section
->sh_link
== filedata
->file_header
.e_shstrndx
)
11690 strtab
= filedata
->string_table
;
11691 strtab_size
= filedata
->string_table_length
;
11693 else if (section
->sh_link
< filedata
->file_header
.e_shnum
)
11695 Elf_Internal_Shdr
* string_sec
;
11697 string_sec
= filedata
->section_headers
+ section
->sh_link
;
11699 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
,
11700 1, string_sec
->sh_size
,
11701 _("string table"));
11702 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
11705 for (si
= 0, psym
= symtab
; si
< num_syms
; si
++, psym
++)
11707 const char *version_string
;
11708 enum versioned_symbol_info sym_info
;
11709 unsigned short vna_other
;
11711 printf ("%6d: ", si
);
11712 print_vma (psym
->st_value
, LONG_HEX
);
11714 print_vma (psym
->st_size
, DEC_5
);
11715 printf (" %-7s", get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)));
11716 printf (" %-6s", get_symbol_binding (filedata
, ELF_ST_BIND (psym
->st_info
)));
11717 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
11718 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
11721 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
11723 printf (" %-7s", get_symbol_visibility (vis
));
11724 /* Check to see if any other bits in the st_other field are set.
11725 Note - displaying this information disrupts the layout of the
11726 table being generated, but for the moment this case is very rare. */
11727 if (psym
->st_other
^ vis
)
11728 printf (" [%s] ", get_symbol_other (filedata
, psym
->st_other
^ vis
));
11730 printf (" %4s ", get_symbol_index_type (filedata
, psym
->st_shndx
));
11731 print_symbol (25, psym
->st_name
< strtab_size
11732 ? strtab
+ psym
->st_name
: _("<corrupt>"));
11735 = get_symbol_version_string (filedata
,
11736 section
->sh_type
== SHT_DYNSYM
,
11737 strtab
, strtab_size
, si
,
11738 psym
, &sym_info
, &vna_other
);
11739 if (version_string
)
11741 if (sym_info
== symbol_undefined
)
11742 printf ("@%s (%d)", version_string
, vna_other
);
11744 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
11750 if (ELF_ST_BIND (psym
->st_info
) == STB_LOCAL
11751 && si
>= section
->sh_info
11752 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
11753 && filedata
->file_header
.e_machine
!= EM_MIPS
11754 /* Solaris binaries have been found to violate this requirement as
11755 well. Not sure if this is a bug or an ABI requirement. */
11756 && filedata
->file_header
.e_ident
[EI_OSABI
] != ELFOSABI_SOLARIS
)
11757 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
11758 si
, printable_section_name (filedata
, section
), section
->sh_info
);
11762 if (strtab
!= filedata
->string_table
)
11768 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
11770 if (do_histogram
&& buckets
!= NULL
)
11772 unsigned long * lengths
;
11773 unsigned long * counts
;
11776 unsigned long maxlength
= 0;
11777 unsigned long nzero_counts
= 0;
11778 unsigned long nsyms
= 0;
11781 printf (ngettext ("\nHistogram for bucket list length "
11782 "(total of %lu bucket):\n",
11783 "\nHistogram for bucket list length "
11784 "(total of %lu buckets):\n",
11785 (unsigned long) nbuckets
),
11786 (unsigned long) nbuckets
);
11788 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
11789 if (lengths
== NULL
)
11791 error (_("Out of memory allocating space for histogram buckets\n"));
11794 visited
= xcmalloc (nchains
, 1);
11795 memset (visited
, 0, nchains
);
11797 printf (_(" Length Number %% of total Coverage\n"));
11798 for (hn
= 0; hn
< nbuckets
; ++hn
)
11800 for (si
= buckets
[hn
]; si
> 0; si
= chains
[si
])
11803 if (maxlength
< ++lengths
[hn
])
11805 if (si
>= nchains
|| visited
[si
])
11807 error (_("histogram chain is corrupt\n"));
11815 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
11816 if (counts
== NULL
)
11819 error (_("Out of memory allocating space for histogram counts\n"));
11823 for (hn
= 0; hn
< nbuckets
; ++hn
)
11824 ++counts
[lengths
[hn
]];
11829 printf (" 0 %-10lu (%5.1f%%)\n",
11830 counts
[0], (counts
[0] * 100.0) / nbuckets
);
11831 for (i
= 1; i
<= maxlength
; ++i
)
11833 nzero_counts
+= counts
[i
] * i
;
11834 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11835 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
11836 (nzero_counts
* 100.0) / nsyms
);
11844 if (buckets
!= NULL
)
11850 if (do_histogram
&& gnubuckets
!= NULL
)
11852 unsigned long * lengths
;
11853 unsigned long * counts
;
11855 unsigned long maxlength
= 0;
11856 unsigned long nzero_counts
= 0;
11857 unsigned long nsyms
= 0;
11859 printf (ngettext ("\nHistogram for `.gnu.hash' bucket list length "
11860 "(total of %lu bucket):\n",
11861 "\nHistogram for `.gnu.hash' bucket list length "
11862 "(total of %lu buckets):\n",
11863 (unsigned long) ngnubuckets
),
11864 (unsigned long) ngnubuckets
);
11866 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
11867 if (lengths
== NULL
)
11869 error (_("Out of memory allocating space for gnu histogram buckets\n"));
11873 printf (_(" Length Number %% of total Coverage\n"));
11875 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11876 if (gnubuckets
[hn
] != 0)
11878 bfd_vma off
, length
= 1;
11880 for (off
= gnubuckets
[hn
] - gnusymidx
;
11881 /* PR 17531 file: 010-77222-0.004. */
11882 off
< ngnuchains
&& (gnuchains
[off
] & 1) == 0;
11885 lengths
[hn
] = length
;
11886 if (length
> maxlength
)
11887 maxlength
= length
;
11891 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
11892 if (counts
== NULL
)
11895 error (_("Out of memory allocating space for gnu histogram counts\n"));
11899 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11900 ++counts
[lengths
[hn
]];
11902 if (ngnubuckets
> 0)
11905 printf (" 0 %-10lu (%5.1f%%)\n",
11906 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
11907 for (j
= 1; j
<= maxlength
; ++j
)
11909 nzero_counts
+= counts
[j
] * j
;
11910 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11911 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
11912 (nzero_counts
* 100.0) / nsyms
);
11926 process_syminfo (Filedata
* filedata ATTRIBUTE_UNUSED
)
11930 if (dynamic_syminfo
== NULL
11932 /* No syminfo, this is ok. */
11935 /* There better should be a dynamic symbol section. */
11936 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
11940 printf (ngettext ("\nDynamic info segment at offset 0x%lx "
11941 "contains %d entry:\n",
11942 "\nDynamic info segment at offset 0x%lx "
11943 "contains %d entries:\n",
11944 dynamic_syminfo_nent
),
11945 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
11947 printf (_(" Num: Name BoundTo Flags\n"));
11948 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
11950 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
11952 printf ("%4d: ", i
);
11953 if (i
>= num_dynamic_syms
)
11954 printf (_("<corrupt index>"));
11955 else if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
11956 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
11958 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
11961 switch (dynamic_syminfo
[i
].si_boundto
)
11963 case SYMINFO_BT_SELF
:
11964 fputs ("SELF ", stdout
);
11966 case SYMINFO_BT_PARENT
:
11967 fputs ("PARENT ", stdout
);
11970 if (dynamic_syminfo
[i
].si_boundto
> 0
11971 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
11972 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
11974 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
11978 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
11982 if (flags
& SYMINFO_FLG_DIRECT
)
11983 printf (" DIRECT");
11984 if (flags
& SYMINFO_FLG_PASSTHRU
)
11985 printf (" PASSTHRU");
11986 if (flags
& SYMINFO_FLG_COPY
)
11988 if (flags
& SYMINFO_FLG_LAZYLOAD
)
11989 printf (" LAZYLOAD");
11997 #define IN_RANGE(START,END,ADDR,OFF) \
11998 (((ADDR) >= (START)) && ((ADDR) + (OFF) < (END)))
12000 /* Check to see if the given reloc needs to be handled in a target specific
12001 manner. If so then process the reloc and return TRUE otherwise return
12004 If called with reloc == NULL, then this is a signal that reloc processing
12005 for the current section has finished, and any saved state should be
12009 target_specific_reloc_handling (Filedata
* filedata
,
12010 Elf_Internal_Rela
* reloc
,
12011 unsigned char * start
,
12012 unsigned char * end
,
12013 Elf_Internal_Sym
* symtab
,
12014 unsigned long num_syms
)
12016 unsigned int reloc_type
= 0;
12017 unsigned long sym_index
= 0;
12021 reloc_type
= get_reloc_type (filedata
, reloc
->r_info
);
12022 sym_index
= get_reloc_symindex (reloc
->r_info
);
12025 switch (filedata
->file_header
.e_machine
)
12028 case EM_MSP430_OLD
:
12030 static Elf_Internal_Sym
* saved_sym
= NULL
;
12038 switch (reloc_type
)
12040 case 10: /* R_MSP430_SYM_DIFF */
12041 if (uses_msp430x_relocs (filedata
))
12043 /* Fall through. */
12044 case 21: /* R_MSP430X_SYM_DIFF */
12046 if (sym_index
>= num_syms
)
12047 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
12050 saved_sym
= symtab
+ sym_index
;
12053 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
12054 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
12055 goto handle_sym_diff
;
12057 case 5: /* R_MSP430_16_BYTE */
12058 case 9: /* R_MSP430_8 */
12059 if (uses_msp430x_relocs (filedata
))
12061 goto handle_sym_diff
;
12063 case 2: /* R_MSP430_ABS16 */
12064 case 15: /* R_MSP430X_ABS16 */
12065 if (! uses_msp430x_relocs (filedata
))
12067 goto handle_sym_diff
;
12070 if (saved_sym
!= NULL
)
12072 int reloc_size
= reloc_type
== 1 ? 4 : 2;
12075 if (sym_index
>= num_syms
)
12076 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
12080 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12081 - saved_sym
->st_value
);
12083 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12084 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12087 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
12088 (long) reloc
->r_offset
);
12097 if (saved_sym
!= NULL
)
12098 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
12105 case EM_CYGNUS_MN10300
:
12107 static Elf_Internal_Sym
* saved_sym
= NULL
;
12115 switch (reloc_type
)
12117 case 34: /* R_MN10300_ALIGN */
12119 case 33: /* R_MN10300_SYM_DIFF */
12120 if (sym_index
>= num_syms
)
12121 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
12124 saved_sym
= symtab
+ sym_index
;
12127 case 1: /* R_MN10300_32 */
12128 case 2: /* R_MN10300_16 */
12129 if (saved_sym
!= NULL
)
12131 int reloc_size
= reloc_type
== 1 ? 4 : 2;
12134 if (sym_index
>= num_syms
)
12135 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
12139 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12140 - saved_sym
->st_value
);
12142 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12143 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12145 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
12146 (long) reloc
->r_offset
);
12154 if (saved_sym
!= NULL
)
12155 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
12163 static bfd_vma saved_sym1
= 0;
12164 static bfd_vma saved_sym2
= 0;
12165 static bfd_vma value
;
12169 saved_sym1
= saved_sym2
= 0;
12173 switch (reloc_type
)
12175 case 0x80: /* R_RL78_SYM. */
12176 saved_sym1
= saved_sym2
;
12177 if (sym_index
>= num_syms
)
12178 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
12182 saved_sym2
= symtab
[sym_index
].st_value
;
12183 saved_sym2
+= reloc
->r_addend
;
12187 case 0x83: /* R_RL78_OPsub. */
12188 value
= saved_sym1
- saved_sym2
;
12189 saved_sym2
= saved_sym1
= 0;
12193 case 0x41: /* R_RL78_ABS32. */
12194 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 4))
12195 byte_put (start
+ reloc
->r_offset
, value
, 4);
12197 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12198 (long) reloc
->r_offset
);
12202 case 0x43: /* R_RL78_ABS16. */
12203 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 2))
12204 byte_put (start
+ reloc
->r_offset
, value
, 2);
12206 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12207 (long) reloc
->r_offset
);
12221 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12222 DWARF debug sections. This is a target specific test. Note - we do not
12223 go through the whole including-target-headers-multiple-times route, (as
12224 we have already done with <elf/h8.h>) because this would become very
12225 messy and even then this function would have to contain target specific
12226 information (the names of the relocs instead of their numeric values).
12227 FIXME: This is not the correct way to solve this problem. The proper way
12228 is to have target specific reloc sizing and typing functions created by
12229 the reloc-macros.h header, in the same way that it already creates the
12230 reloc naming functions. */
12233 is_32bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12235 /* Please keep this table alpha-sorted for ease of visual lookup. */
12236 switch (filedata
->file_header
.e_machine
)
12240 return reloc_type
== 1; /* R_386_32. */
12242 return reloc_type
== 1; /* R_68K_32. */
12244 return reloc_type
== 1; /* R_860_32. */
12246 return reloc_type
== 2; /* R_960_32. */
12248 return (reloc_type
== 258
12249 || reloc_type
== 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12250 case EM_ADAPTEVA_EPIPHANY
:
12251 return reloc_type
== 3;
12253 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
12255 return reloc_type
== 1; /* R_ARC_32. */
12256 case EM_ARC_COMPACT
:
12257 case EM_ARC_COMPACT2
:
12258 return reloc_type
== 4; /* R_ARC_32. */
12260 return reloc_type
== 2; /* R_ARM_ABS32 */
12263 return reloc_type
== 1;
12265 return reloc_type
== 0x12; /* R_byte4_data. */
12267 return reloc_type
== 3; /* R_CRIS_32. */
12269 return reloc_type
== 3; /* R_CR16_NUM32. */
12271 return reloc_type
== 15; /* R_CRX_NUM32. */
12272 case EM_CYGNUS_FRV
:
12273 return reloc_type
== 1;
12274 case EM_CYGNUS_D10V
:
12276 return reloc_type
== 6; /* R_D10V_32. */
12277 case EM_CYGNUS_D30V
:
12279 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
12281 return reloc_type
== 3; /* R_DLX_RELOC_32. */
12282 case EM_CYGNUS_FR30
:
12284 return reloc_type
== 3; /* R_FR30_32. */
12286 return reloc_type
== 1; /* R_FT32_32. */
12290 return reloc_type
== 1; /* R_H8_DIR32. */
12292 return (reloc_type
== 0x64 /* R_IA64_SECREL32MSB. */
12293 || reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
12294 || reloc_type
== 0x24 /* R_IA64_DIR32MSB. */
12295 || reloc_type
== 0x25 /* R_IA64_DIR32LSB. */);
12298 return reloc_type
== 2; /* R_IP2K_32. */
12300 return reloc_type
== 2; /* R_IQ2000_32. */
12301 case EM_LATTICEMICO32
:
12302 return reloc_type
== 3; /* R_LM32_32. */
12305 return reloc_type
== 3; /* R_M32C_32. */
12307 return reloc_type
== 34; /* R_M32R_32_RELA. */
12310 return reloc_type
== 6; /* R_M68HC11_32. */
12312 return reloc_type
== 1; /* R_MCORE_ADDR32. */
12313 case EM_CYGNUS_MEP
:
12314 return reloc_type
== 4; /* R_MEP_32. */
12316 return reloc_type
== 2; /* R_METAG_ADDR32. */
12317 case EM_MICROBLAZE
:
12318 return reloc_type
== 1; /* R_MICROBLAZE_32. */
12320 return reloc_type
== 2; /* R_MIPS_32. */
12322 return reloc_type
== 4; /* R_MMIX_32. */
12323 case EM_CYGNUS_MN10200
:
12325 return reloc_type
== 1; /* R_MN10200_32. */
12326 case EM_CYGNUS_MN10300
:
12328 return reloc_type
== 1; /* R_MN10300_32. */
12330 return reloc_type
== 1; /* R_MOXIE_32. */
12331 case EM_MSP430_OLD
:
12333 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
12335 return reloc_type
== 2; /* R_MT_32. */
12337 return reloc_type
== 20; /* R_NDS32_RELA. */
12338 case EM_ALTERA_NIOS2
:
12339 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
12341 return reloc_type
== 1; /* R_NIOS_32. */
12343 return reloc_type
== 1; /* R_OR1K_32. */
12345 return (reloc_type
== 1 /* R_PARISC_DIR32. */
12346 || reloc_type
== 2 /* R_PARISC_DIR21L. */
12347 || reloc_type
== 41); /* R_PARISC_SECREL32. */
12350 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
12352 return reloc_type
== 1; /* R_PPC64_ADDR32. */
12354 return reloc_type
== 1; /* R_PPC_ADDR32. */
12356 return reloc_type
== 11; /* R_PRU_BFD_RELOC_32. */
12358 return reloc_type
== 1; /* R_RISCV_32. */
12360 return reloc_type
== 1; /* R_RL78_DIR32. */
12362 return reloc_type
== 1; /* R_RX_DIR32. */
12364 return reloc_type
== 1; /* R_I370_ADDR31. */
12367 return reloc_type
== 4; /* R_S390_32. */
12369 return reloc_type
== 8; /* R_SCORE_ABS32. */
12371 return reloc_type
== 1; /* R_SH_DIR32. */
12372 case EM_SPARC32PLUS
:
12375 return reloc_type
== 3 /* R_SPARC_32. */
12376 || reloc_type
== 23; /* R_SPARC_UA32. */
12378 return reloc_type
== 6; /* R_SPU_ADDR32 */
12380 return reloc_type
== 1; /* R_C6000_ABS32. */
12382 return reloc_type
== 2; /* R_TILEGX_32. */
12384 return reloc_type
== 1; /* R_TILEPRO_32. */
12385 case EM_CYGNUS_V850
:
12387 return reloc_type
== 6; /* R_V850_ABS32. */
12389 return reloc_type
== 0x33; /* R_V810_WORD. */
12391 return reloc_type
== 1; /* R_VAX_32. */
12393 return reloc_type
== 3; /* R_VISIUM_32. */
12394 case EM_WEBASSEMBLY
:
12395 return reloc_type
== 1; /* R_WASM32_32. */
12399 return reloc_type
== 10; /* R_X86_64_32. */
12402 return reloc_type
== 3; /* R_XC16C_ABS_32. */
12404 return reloc_type
== 4; /* R_XGATE_32. */
12406 return reloc_type
== 1; /* R_XSTROMY16_32. */
12407 case EM_XTENSA_OLD
:
12409 return reloc_type
== 1; /* R_XTENSA_32. */
12412 static unsigned int prev_warn
= 0;
12414 /* Avoid repeating the same warning multiple times. */
12415 if (prev_warn
!= filedata
->file_header
.e_machine
)
12416 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12417 filedata
->file_header
.e_machine
);
12418 prev_warn
= filedata
->file_header
.e_machine
;
12424 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12425 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
12428 is_32bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12430 switch (filedata
->file_header
.e_machine
)
12431 /* Please keep this table alpha-sorted for ease of visual lookup. */
12435 return reloc_type
== 2; /* R_386_PC32. */
12437 return reloc_type
== 4; /* R_68K_PC32. */
12439 return reloc_type
== 261; /* R_AARCH64_PREL32 */
12440 case EM_ADAPTEVA_EPIPHANY
:
12441 return reloc_type
== 6;
12443 return reloc_type
== 10; /* R_ALPHA_SREL32. */
12444 case EM_ARC_COMPACT
:
12445 case EM_ARC_COMPACT2
:
12446 return reloc_type
== 49; /* R_ARC_32_PCREL. */
12448 return reloc_type
== 3; /* R_ARM_REL32 */
12451 return reloc_type
== 36; /* R_AVR_32_PCREL. */
12452 case EM_MICROBLAZE
:
12453 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
12455 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
12457 return reloc_type
== 9; /* R_PARISC_PCREL32. */
12459 return reloc_type
== 26; /* R_PPC_REL32. */
12461 return reloc_type
== 26; /* R_PPC64_REL32. */
12464 return reloc_type
== 5; /* R_390_PC32. */
12466 return reloc_type
== 2; /* R_SH_REL32. */
12467 case EM_SPARC32PLUS
:
12470 return reloc_type
== 6; /* R_SPARC_DISP32. */
12472 return reloc_type
== 13; /* R_SPU_REL32. */
12474 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
12476 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
12478 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
12482 return reloc_type
== 2; /* R_X86_64_PC32. */
12483 case EM_XTENSA_OLD
:
12485 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
12487 /* Do not abort or issue an error message here. Not all targets use
12488 pc-relative 32-bit relocs in their DWARF debug information and we
12489 have already tested for target coverage in is_32bit_abs_reloc. A
12490 more helpful warning message will be generated by apply_relocations
12491 anyway, so just return. */
12496 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12497 a 64-bit absolute RELA relocation used in DWARF debug sections. */
12500 is_64bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12502 switch (filedata
->file_header
.e_machine
)
12505 return reloc_type
== 257; /* R_AARCH64_ABS64. */
12507 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
12509 return (reloc_type
== 0x26 /* R_IA64_DIR64MSB. */
12510 || reloc_type
== 0x27 /* R_IA64_DIR64LSB. */);
12512 return reloc_type
== 80; /* R_PARISC_DIR64. */
12514 return reloc_type
== 38; /* R_PPC64_ADDR64. */
12516 return reloc_type
== 2; /* R_RISCV_64. */
12517 case EM_SPARC32PLUS
:
12520 return reloc_type
== 32 /* R_SPARC_64. */
12521 || reloc_type
== 54; /* R_SPARC_UA64. */
12525 return reloc_type
== 1; /* R_X86_64_64. */
12528 return reloc_type
== 22; /* R_S390_64. */
12530 return reloc_type
== 1; /* R_TILEGX_64. */
12532 return reloc_type
== 18; /* R_MIPS_64. */
12538 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12539 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
12542 is_64bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12544 switch (filedata
->file_header
.e_machine
)
12547 return reloc_type
== 260; /* R_AARCH64_PREL64. */
12549 return reloc_type
== 11; /* R_ALPHA_SREL64. */
12551 return (reloc_type
== 0x4e /* R_IA64_PCREL64MSB. */
12552 || reloc_type
== 0x4f /* R_IA64_PCREL64LSB. */);
12554 return reloc_type
== 72; /* R_PARISC_PCREL64. */
12556 return reloc_type
== 44; /* R_PPC64_REL64. */
12557 case EM_SPARC32PLUS
:
12560 return reloc_type
== 46; /* R_SPARC_DISP64. */
12564 return reloc_type
== 24; /* R_X86_64_PC64. */
12567 return reloc_type
== 23; /* R_S390_PC64. */
12569 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
12575 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12576 a 24-bit absolute RELA relocation used in DWARF debug sections. */
12579 is_24bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12581 switch (filedata
->file_header
.e_machine
)
12583 case EM_CYGNUS_MN10200
:
12585 return reloc_type
== 4; /* R_MN10200_24. */
12587 return reloc_type
== 5; /* R_FT32_20. */
12593 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12594 a 16-bit absolute RELA relocation used in DWARF debug sections. */
12597 is_16bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12599 /* Please keep this table alpha-sorted for ease of visual lookup. */
12600 switch (filedata
->file_header
.e_machine
)
12603 case EM_ARC_COMPACT
:
12604 case EM_ARC_COMPACT2
:
12605 return reloc_type
== 2; /* R_ARC_16. */
12606 case EM_ADAPTEVA_EPIPHANY
:
12607 return reloc_type
== 5;
12610 return reloc_type
== 4; /* R_AVR_16. */
12611 case EM_CYGNUS_D10V
:
12613 return reloc_type
== 3; /* R_D10V_16. */
12615 return reloc_type
== 2; /* R_FT32_16. */
12619 return reloc_type
== R_H8_DIR16
;
12622 return reloc_type
== 1; /* R_IP2K_16. */
12625 return reloc_type
== 1; /* R_M32C_16 */
12626 case EM_CYGNUS_MN10200
:
12628 return reloc_type
== 2; /* R_MN10200_16. */
12629 case EM_CYGNUS_MN10300
:
12631 return reloc_type
== 2; /* R_MN10300_16. */
12633 if (uses_msp430x_relocs (filedata
))
12634 return reloc_type
== 2; /* R_MSP430_ABS16. */
12635 /* Fall through. */
12636 case EM_MSP430_OLD
:
12637 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
12639 return reloc_type
== 19; /* R_NDS32_RELA. */
12640 case EM_ALTERA_NIOS2
:
12641 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
12643 return reloc_type
== 9; /* R_NIOS_16. */
12645 return reloc_type
== 2; /* R_OR1K_16. */
12647 return reloc_type
== 8; /* R_PRU_BFD_RELOC_16. */
12649 return reloc_type
== 2; /* R_C6000_ABS16. */
12651 return reloc_type
== 2; /* R_VISIUM_16. */
12654 return reloc_type
== 2; /* R_XC16C_ABS_16. */
12656 return reloc_type
== 3; /* R_XGATE_16. */
12662 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12663 a 32-bit inplace add RELA relocation used in DWARF debug sections. */
12666 is_32bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12668 /* Please keep this table alpha-sorted for ease of visual lookup. */
12669 switch (filedata
->file_header
.e_machine
)
12672 return reloc_type
== 35; /* R_RISCV_ADD32. */
12678 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12679 a 32-bit inplace sub RELA relocation used in DWARF debug sections. */
12682 is_32bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12684 /* Please keep this table alpha-sorted for ease of visual lookup. */
12685 switch (filedata
->file_header
.e_machine
)
12688 return reloc_type
== 39; /* R_RISCV_SUB32. */
12694 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12695 a 64-bit inplace add RELA relocation used in DWARF debug sections. */
12698 is_64bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12700 /* Please keep this table alpha-sorted for ease of visual lookup. */
12701 switch (filedata
->file_header
.e_machine
)
12704 return reloc_type
== 36; /* R_RISCV_ADD64. */
12710 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12711 a 64-bit inplace sub RELA relocation used in DWARF debug sections. */
12714 is_64bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12716 /* Please keep this table alpha-sorted for ease of visual lookup. */
12717 switch (filedata
->file_header
.e_machine
)
12720 return reloc_type
== 40; /* R_RISCV_SUB64. */
12726 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12727 a 16-bit inplace add RELA relocation used in DWARF debug sections. */
12730 is_16bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12732 /* Please keep this table alpha-sorted for ease of visual lookup. */
12733 switch (filedata
->file_header
.e_machine
)
12736 return reloc_type
== 34; /* R_RISCV_ADD16. */
12742 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12743 a 16-bit inplace sub RELA relocation used in DWARF debug sections. */
12746 is_16bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12748 /* Please keep this table alpha-sorted for ease of visual lookup. */
12749 switch (filedata
->file_header
.e_machine
)
12752 return reloc_type
== 38; /* R_RISCV_SUB16. */
12758 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12759 a 8-bit inplace add RELA relocation used in DWARF debug sections. */
12762 is_8bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12764 /* Please keep this table alpha-sorted for ease of visual lookup. */
12765 switch (filedata
->file_header
.e_machine
)
12768 return reloc_type
== 33; /* R_RISCV_ADD8. */
12774 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12775 a 8-bit inplace sub RELA relocation used in DWARF debug sections. */
12778 is_8bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12780 /* Please keep this table alpha-sorted for ease of visual lookup. */
12781 switch (filedata
->file_header
.e_machine
)
12784 return reloc_type
== 37; /* R_RISCV_SUB8. */
12790 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
12791 relocation entries (possibly formerly used for SHT_GROUP sections). */
12794 is_none_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12796 switch (filedata
->file_header
.e_machine
)
12798 case EM_386
: /* R_386_NONE. */
12799 case EM_68K
: /* R_68K_NONE. */
12800 case EM_ADAPTEVA_EPIPHANY
:
12801 case EM_ALPHA
: /* R_ALPHA_NONE. */
12802 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
12803 case EM_ARC
: /* R_ARC_NONE. */
12804 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
12805 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
12806 case EM_ARM
: /* R_ARM_NONE. */
12807 case EM_C166
: /* R_XC16X_NONE. */
12808 case EM_CRIS
: /* R_CRIS_NONE. */
12809 case EM_FT32
: /* R_FT32_NONE. */
12810 case EM_IA_64
: /* R_IA64_NONE. */
12811 case EM_K1OM
: /* R_X86_64_NONE. */
12812 case EM_L1OM
: /* R_X86_64_NONE. */
12813 case EM_M32R
: /* R_M32R_NONE. */
12814 case EM_MIPS
: /* R_MIPS_NONE. */
12815 case EM_MN10300
: /* R_MN10300_NONE. */
12816 case EM_MOXIE
: /* R_MOXIE_NONE. */
12817 case EM_NIOS32
: /* R_NIOS_NONE. */
12818 case EM_OR1K
: /* R_OR1K_NONE. */
12819 case EM_PARISC
: /* R_PARISC_NONE. */
12820 case EM_PPC64
: /* R_PPC64_NONE. */
12821 case EM_PPC
: /* R_PPC_NONE. */
12822 case EM_RISCV
: /* R_RISCV_NONE. */
12823 case EM_S390
: /* R_390_NONE. */
12825 case EM_SH
: /* R_SH_NONE. */
12826 case EM_SPARC32PLUS
:
12827 case EM_SPARC
: /* R_SPARC_NONE. */
12829 case EM_TILEGX
: /* R_TILEGX_NONE. */
12830 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
12831 case EM_TI_C6000
:/* R_C6000_NONE. */
12832 case EM_X86_64
: /* R_X86_64_NONE. */
12834 case EM_WEBASSEMBLY
: /* R_WASM32_NONE. */
12835 return reloc_type
== 0;
12838 return reloc_type
== 0 || reloc_type
== 256;
12841 return (reloc_type
== 0 /* R_AVR_NONE. */
12842 || reloc_type
== 30 /* R_AVR_DIFF8. */
12843 || reloc_type
== 31 /* R_AVR_DIFF16. */
12844 || reloc_type
== 32 /* R_AVR_DIFF32. */);
12846 return reloc_type
== 3; /* R_METAG_NONE. */
12848 return (reloc_type
== 0 /* R_XTENSA_NONE. */
12849 || reloc_type
== 204 /* R_NDS32_DIFF8. */
12850 || reloc_type
== 205 /* R_NDS32_DIFF16. */
12851 || reloc_type
== 206 /* R_NDS32_DIFF32. */
12852 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
12854 return (reloc_type
== 0 /* R_PRU_NONE. */
12855 || reloc_type
== 65 /* R_PRU_DIFF8. */
12856 || reloc_type
== 66 /* R_PRU_DIFF16. */
12857 || reloc_type
== 67 /* R_PRU_DIFF32. */);
12858 case EM_XTENSA_OLD
:
12860 return (reloc_type
== 0 /* R_XTENSA_NONE. */
12861 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
12862 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
12863 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
12868 /* Returns TRUE if there is a relocation against
12869 section NAME at OFFSET bytes. */
12872 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
12874 Elf_Internal_Rela
* relocs
;
12875 Elf_Internal_Rela
* rp
;
12877 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
12880 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
12882 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
12883 if (rp
->r_offset
== offset
)
12889 /* Apply relocations to a section.
12890 Returns TRUE upon success, FALSE otherwise.
12891 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
12892 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
12893 will be set to the number of relocs loaded.
12895 Note: So far support has been added only for those relocations
12896 which can be found in debug sections. FIXME: Add support for
12897 more relocations ? */
12900 apply_relocations (Filedata
* filedata
,
12901 const Elf_Internal_Shdr
* section
,
12902 unsigned char * start
,
12903 bfd_size_type size
,
12904 void ** relocs_return
,
12905 unsigned long * num_relocs_return
)
12907 Elf_Internal_Shdr
* relsec
;
12908 unsigned char * end
= start
+ size
;
12909 bfd_boolean res
= TRUE
;
12911 if (relocs_return
!= NULL
)
12913 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
12914 * num_relocs_return
= 0;
12917 if (filedata
->file_header
.e_type
!= ET_REL
)
12918 /* No relocs to apply. */
12921 /* Find the reloc section associated with the section. */
12922 for (relsec
= filedata
->section_headers
;
12923 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
12926 bfd_boolean is_rela
;
12927 unsigned long num_relocs
;
12928 Elf_Internal_Rela
* relocs
;
12929 Elf_Internal_Rela
* rp
;
12930 Elf_Internal_Shdr
* symsec
;
12931 Elf_Internal_Sym
* symtab
;
12932 unsigned long num_syms
;
12933 Elf_Internal_Sym
* sym
;
12935 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
12936 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
12937 || filedata
->section_headers
+ relsec
->sh_info
!= section
12938 || relsec
->sh_size
== 0
12939 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
12942 is_rela
= relsec
->sh_type
== SHT_RELA
;
12946 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
,
12947 relsec
->sh_size
, & relocs
, & num_relocs
))
12952 if (!slurp_rel_relocs (filedata
, relsec
->sh_offset
,
12953 relsec
->sh_size
, & relocs
, & num_relocs
))
12957 /* SH uses RELA but uses in place value instead of the addend field. */
12958 if (filedata
->file_header
.e_machine
== EM_SH
)
12961 symsec
= filedata
->section_headers
+ relsec
->sh_link
;
12962 if (symsec
->sh_type
!= SHT_SYMTAB
12963 && symsec
->sh_type
!= SHT_DYNSYM
)
12965 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & num_syms
);
12967 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
12970 unsigned int reloc_type
;
12971 unsigned int reloc_size
;
12972 bfd_boolean reloc_inplace
= FALSE
;
12973 bfd_boolean reloc_subtract
= FALSE
;
12974 unsigned char * rloc
;
12975 unsigned long sym_index
;
12977 reloc_type
= get_reloc_type (filedata
, rp
->r_info
);
12979 if (target_specific_reloc_handling (filedata
, rp
, start
, end
, symtab
, num_syms
))
12981 else if (is_none_reloc (filedata
, reloc_type
))
12983 else if (is_32bit_abs_reloc (filedata
, reloc_type
)
12984 || is_32bit_pcrel_reloc (filedata
, reloc_type
))
12986 else if (is_64bit_abs_reloc (filedata
, reloc_type
)
12987 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
12989 else if (is_24bit_abs_reloc (filedata
, reloc_type
))
12991 else if (is_16bit_abs_reloc (filedata
, reloc_type
))
12993 else if ((reloc_subtract
= is_32bit_inplace_sub_reloc (filedata
,
12995 || is_32bit_inplace_add_reloc (filedata
, reloc_type
))
12998 reloc_inplace
= TRUE
;
13000 else if ((reloc_subtract
= is_64bit_inplace_sub_reloc (filedata
,
13002 || is_64bit_inplace_add_reloc (filedata
, reloc_type
))
13005 reloc_inplace
= TRUE
;
13007 else if ((reloc_subtract
= is_16bit_inplace_sub_reloc (filedata
,
13009 || is_16bit_inplace_add_reloc (filedata
, reloc_type
))
13012 reloc_inplace
= TRUE
;
13014 else if ((reloc_subtract
= is_8bit_inplace_sub_reloc (filedata
,
13016 || is_8bit_inplace_add_reloc (filedata
, reloc_type
))
13019 reloc_inplace
= TRUE
;
13023 static unsigned int prev_reloc
= 0;
13025 if (reloc_type
!= prev_reloc
)
13026 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
13027 reloc_type
, printable_section_name (filedata
, section
));
13028 prev_reloc
= reloc_type
;
13033 rloc
= start
+ rp
->r_offset
;
13034 if ((rloc
+ reloc_size
) > end
|| (rloc
< start
))
13036 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
13037 (unsigned long) rp
->r_offset
,
13038 printable_section_name (filedata
, section
));
13043 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
13044 if (sym_index
>= num_syms
)
13046 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
13047 sym_index
, printable_section_name (filedata
, section
));
13051 sym
= symtab
+ sym_index
;
13053 /* If the reloc has a symbol associated with it,
13054 make sure that it is of an appropriate type.
13056 Relocations against symbols without type can happen.
13057 Gcc -feliminate-dwarf2-dups may generate symbols
13058 without type for debug info.
13060 Icc generates relocations against function symbols
13061 instead of local labels.
13063 Relocations against object symbols can happen, eg when
13064 referencing a global array. For an example of this see
13065 the _clz.o binary in libgcc.a. */
13067 && ELF_ST_TYPE (sym
->st_info
) != STT_COMMON
13068 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
13070 warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
13071 get_symbol_type (filedata
, ELF_ST_TYPE (sym
->st_info
)),
13072 printable_section_name (filedata
, relsec
),
13073 (long int)(rp
- relocs
));
13080 addend
+= rp
->r_addend
;
13081 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
13082 partial_inplace. */
13084 || (filedata
->file_header
.e_machine
== EM_XTENSA
13085 && reloc_type
== 1)
13086 || ((filedata
->file_header
.e_machine
== EM_PJ
13087 || filedata
->file_header
.e_machine
== EM_PJ_OLD
)
13088 && reloc_type
== 1)
13089 || ((filedata
->file_header
.e_machine
== EM_D30V
13090 || filedata
->file_header
.e_machine
== EM_CYGNUS_D30V
)
13091 && reloc_type
== 12)
13093 addend
+= byte_get (rloc
, reloc_size
);
13095 if (is_32bit_pcrel_reloc (filedata
, reloc_type
)
13096 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
13098 /* On HPPA, all pc-relative relocations are biased by 8. */
13099 if (filedata
->file_header
.e_machine
== EM_PARISC
)
13101 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
13104 else if (reloc_subtract
)
13105 byte_put (rloc
, addend
- sym
->st_value
, reloc_size
);
13107 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
13111 /* Let the target specific reloc processing code know that
13112 we have finished with these relocs. */
13113 target_specific_reloc_handling (filedata
, NULL
, NULL
, NULL
, NULL
, 0);
13117 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
13118 * num_relocs_return
= num_relocs
;
13129 #ifdef SUPPORT_DISASSEMBLY
13131 disassemble_section (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13133 printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata
, section
));
13135 /* FIXME: XXX -- to be done --- XXX */
13141 /* Reads in the contents of SECTION from FILE, returning a pointer
13142 to a malloc'ed buffer or NULL if something went wrong. */
13145 get_section_contents (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13147 bfd_size_type num_bytes
= section
->sh_size
;
13149 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
13151 printf (_("Section '%s' has no data to dump.\n"),
13152 printable_section_name (filedata
, section
));
13156 return (char *) get_data (NULL
, filedata
, section
->sh_offset
, 1, num_bytes
,
13157 _("section contents"));
13160 /* Uncompresses a section that was compressed using zlib, in place. */
13163 uncompress_section_contents (unsigned char ** buffer
,
13164 dwarf_size_type uncompressed_size
,
13165 dwarf_size_type
* size
)
13167 dwarf_size_type compressed_size
= *size
;
13168 unsigned char * compressed_buffer
= *buffer
;
13169 unsigned char * uncompressed_buffer
;
13173 /* It is possible the section consists of several compressed
13174 buffers concatenated together, so we uncompress in a loop. */
13175 /* PR 18313: The state field in the z_stream structure is supposed
13176 to be invisible to the user (ie us), but some compilers will
13177 still complain about it being used without initialisation. So
13178 we first zero the entire z_stream structure and then set the fields
13180 memset (& strm
, 0, sizeof strm
);
13181 strm
.avail_in
= compressed_size
;
13182 strm
.next_in
= (Bytef
*) compressed_buffer
;
13183 strm
.avail_out
= uncompressed_size
;
13184 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
13186 rc
= inflateInit (& strm
);
13187 while (strm
.avail_in
> 0)
13191 strm
.next_out
= ((Bytef
*) uncompressed_buffer
13192 + (uncompressed_size
- strm
.avail_out
));
13193 rc
= inflate (&strm
, Z_FINISH
);
13194 if (rc
!= Z_STREAM_END
)
13196 rc
= inflateReset (& strm
);
13198 rc
= inflateEnd (& strm
);
13200 || strm
.avail_out
!= 0)
13203 *buffer
= uncompressed_buffer
;
13204 *size
= uncompressed_size
;
13208 free (uncompressed_buffer
);
13209 /* Indicate decompression failure. */
13215 dump_section_as_strings (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13217 Elf_Internal_Shdr
* relsec
;
13218 bfd_size_type num_bytes
;
13219 unsigned char * data
;
13220 unsigned char * end
;
13221 unsigned char * real_start
;
13222 unsigned char * start
;
13223 bfd_boolean some_strings_shown
;
13225 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
13227 /* PR 21820: Do not fail if the section was empty. */
13228 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
13230 num_bytes
= section
->sh_size
;
13232 printf (_("\nString dump of section '%s':\n"), printable_section_name (filedata
, section
));
13234 if (decompress_dumps
)
13236 dwarf_size_type new_size
= num_bytes
;
13237 dwarf_size_type uncompressed_size
= 0;
13239 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
13241 Elf_Internal_Chdr chdr
;
13242 unsigned int compression_header_size
13243 = get_compression_header (& chdr
, (unsigned char *) start
,
13246 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13248 warn (_("section '%s' has unsupported compress type: %d\n"),
13249 printable_section_name (filedata
, section
), chdr
.ch_type
);
13252 else if (chdr
.ch_addralign
!= section
->sh_addralign
)
13254 warn (_("compressed section '%s' is corrupted\n"),
13255 printable_section_name (filedata
, section
));
13258 uncompressed_size
= chdr
.ch_size
;
13259 start
+= compression_header_size
;
13260 new_size
-= compression_header_size
;
13262 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
13264 /* Read the zlib header. In this case, it should be "ZLIB"
13265 followed by the uncompressed section size, 8 bytes in
13266 big-endian order. */
13267 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13268 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13269 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13270 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13271 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13272 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13273 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13274 uncompressed_size
+= start
[11];
13279 if (uncompressed_size
)
13281 if (uncompress_section_contents (& start
,
13282 uncompressed_size
, & new_size
))
13283 num_bytes
= new_size
;
13286 error (_("Unable to decompress section %s\n"),
13287 printable_section_name (filedata
, section
));
13292 start
= real_start
;
13295 /* If the section being dumped has relocations against it the user might
13296 be expecting these relocations to have been applied. Check for this
13297 case and issue a warning message in order to avoid confusion.
13298 FIXME: Maybe we ought to have an option that dumps a section with
13299 relocs applied ? */
13300 for (relsec
= filedata
->section_headers
;
13301 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13304 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13305 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13306 || filedata
->section_headers
+ relsec
->sh_info
!= section
13307 || relsec
->sh_size
== 0
13308 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13311 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13316 end
= start
+ num_bytes
;
13317 some_strings_shown
= FALSE
;
13321 while (!ISPRINT (* data
))
13322 if (++ data
>= end
)
13327 size_t maxlen
= end
- data
;
13330 /* PR 11128: Use two separate invocations in order to work
13331 around bugs in the Solaris 8 implementation of printf. */
13332 printf (" [%6tx] ", data
- start
);
13334 printf (" [%6Ix] ", (size_t) (data
- start
));
13338 print_symbol ((int) maxlen
, (const char *) data
);
13340 data
+= strnlen ((const char *) data
, maxlen
);
13344 printf (_("<corrupt>\n"));
13347 some_strings_shown
= TRUE
;
13351 if (! some_strings_shown
)
13352 printf (_(" No strings found in this section."));
13361 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
13362 Filedata
* filedata
,
13363 bfd_boolean relocate
)
13365 Elf_Internal_Shdr
* relsec
;
13366 bfd_size_type bytes
;
13367 bfd_size_type section_size
;
13369 unsigned char * data
;
13370 unsigned char * real_start
;
13371 unsigned char * start
;
13373 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
13375 /* PR 21820: Do not fail if the section was empty. */
13376 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
13378 section_size
= section
->sh_size
;
13380 printf (_("\nHex dump of section '%s':\n"), printable_section_name (filedata
, section
));
13382 if (decompress_dumps
)
13384 dwarf_size_type new_size
= section_size
;
13385 dwarf_size_type uncompressed_size
= 0;
13387 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
13389 Elf_Internal_Chdr chdr
;
13390 unsigned int compression_header_size
13391 = get_compression_header (& chdr
, start
, section_size
);
13393 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13395 warn (_("section '%s' has unsupported compress type: %d\n"),
13396 printable_section_name (filedata
, section
), chdr
.ch_type
);
13399 else if (chdr
.ch_addralign
!= section
->sh_addralign
)
13401 warn (_("compressed section '%s' is corrupted\n"),
13402 printable_section_name (filedata
, section
));
13405 uncompressed_size
= chdr
.ch_size
;
13406 start
+= compression_header_size
;
13407 new_size
-= compression_header_size
;
13409 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
13411 /* Read the zlib header. In this case, it should be "ZLIB"
13412 followed by the uncompressed section size, 8 bytes in
13413 big-endian order. */
13414 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13415 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13416 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13417 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13418 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13419 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13420 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13421 uncompressed_size
+= start
[11];
13426 if (uncompressed_size
)
13428 if (uncompress_section_contents (& start
, uncompressed_size
,
13431 section_size
= new_size
;
13435 error (_("Unable to decompress section %s\n"),
13436 printable_section_name (filedata
, section
));
13437 /* FIXME: Print the section anyway ? */
13442 start
= real_start
;
13447 if (! apply_relocations (filedata
, section
, start
, section_size
, NULL
, NULL
))
13452 /* If the section being dumped has relocations against it the user might
13453 be expecting these relocations to have been applied. Check for this
13454 case and issue a warning message in order to avoid confusion.
13455 FIXME: Maybe we ought to have an option that dumps a section with
13456 relocs applied ? */
13457 for (relsec
= filedata
->section_headers
;
13458 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13461 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13462 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13463 || filedata
->section_headers
+ relsec
->sh_info
!= section
13464 || relsec
->sh_size
== 0
13465 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13468 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13473 addr
= section
->sh_addr
;
13474 bytes
= section_size
;
13483 lbytes
= (bytes
> 16 ? 16 : bytes
);
13485 printf (" 0x%8.8lx ", (unsigned long) addr
);
13487 for (j
= 0; j
< 16; j
++)
13490 printf ("%2.2x", data
[j
]);
13498 for (j
= 0; j
< lbytes
; j
++)
13501 if (k
>= ' ' && k
< 0x7f)
13521 load_specific_debug_section (enum dwarf_section_display_enum debug
,
13522 const Elf_Internal_Shdr
* sec
,
13525 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13527 Filedata
* filedata
= (Filedata
*) data
;
13529 if (section
->start
!= NULL
)
13531 /* If it is already loaded, do nothing. */
13532 if (streq (section
->filename
, filedata
->file_name
))
13534 free (section
->start
);
13537 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
13538 section
->address
= sec
->sh_addr
;
13539 section
->user_data
= NULL
;
13540 section
->filename
= filedata
->file_name
;
13541 section
->start
= (unsigned char *) get_data (NULL
, filedata
,
13543 sec
->sh_size
, buf
);
13544 if (section
->start
== NULL
)
13548 unsigned char *start
= section
->start
;
13549 dwarf_size_type size
= sec
->sh_size
;
13550 dwarf_size_type uncompressed_size
= 0;
13552 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
13554 Elf_Internal_Chdr chdr
;
13555 unsigned int compression_header_size
;
13557 if (size
< (is_32bit_elf
13558 ? sizeof (Elf32_External_Chdr
)
13559 : sizeof (Elf64_External_Chdr
)))
13561 warn (_("compressed section %s is too small to contain a compression header"),
13566 compression_header_size
= get_compression_header (&chdr
, start
, size
);
13568 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13570 warn (_("section '%s' has unsupported compress type: %d\n"),
13571 section
->name
, chdr
.ch_type
);
13574 else if (chdr
.ch_addralign
!= sec
->sh_addralign
)
13576 warn (_("compressed section '%s' is corrupted\n"),
13580 uncompressed_size
= chdr
.ch_size
;
13581 start
+= compression_header_size
;
13582 size
-= compression_header_size
;
13584 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
13586 /* Read the zlib header. In this case, it should be "ZLIB"
13587 followed by the uncompressed section size, 8 bytes in
13588 big-endian order. */
13589 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13590 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13591 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13592 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13593 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13594 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13595 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13596 uncompressed_size
+= start
[11];
13601 if (uncompressed_size
)
13603 if (uncompress_section_contents (&start
, uncompressed_size
,
13606 /* Free the compressed buffer, update the section buffer
13607 and the section size if uncompress is successful. */
13608 free (section
->start
);
13609 section
->start
= start
;
13613 error (_("Unable to decompress section %s\n"),
13614 printable_section_name (filedata
, sec
));
13619 section
->size
= size
;
13622 if (section
->start
== NULL
)
13625 if (debug_displays
[debug
].relocate
)
13627 if (! apply_relocations (filedata
, sec
, section
->start
, section
->size
,
13628 & section
->reloc_info
, & section
->num_relocs
))
13633 section
->reloc_info
= NULL
;
13634 section
->num_relocs
= 0;
13640 /* If this is not NULL, load_debug_section will only look for sections
13641 within the list of sections given here. */
13642 static unsigned int * section_subset
= NULL
;
13645 load_debug_section (enum dwarf_section_display_enum debug
, void * data
)
13647 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13648 Elf_Internal_Shdr
* sec
;
13649 Filedata
* filedata
= (Filedata
*) data
;
13651 /* Without section headers we cannot find any sections. */
13652 if (filedata
->section_headers
== NULL
)
13655 if (filedata
->string_table
== NULL
13656 && filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
13657 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
13659 Elf_Internal_Shdr
* strs
;
13661 /* Read in the string table, so that we have section names to scan. */
13662 strs
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
13664 if (strs
!= NULL
&& strs
->sh_size
!= 0)
13666 filedata
->string_table
13667 = (char *) get_data (NULL
, filedata
, strs
->sh_offset
,
13668 1, strs
->sh_size
, _("string table"));
13670 filedata
->string_table_length
13671 = filedata
->string_table
!= NULL
? strs
->sh_size
: 0;
13675 /* Locate the debug section. */
13676 sec
= find_section_in_set (filedata
, section
->uncompressed_name
, section_subset
);
13678 section
->name
= section
->uncompressed_name
;
13681 sec
= find_section_in_set (filedata
, section
->compressed_name
, section_subset
);
13683 section
->name
= section
->compressed_name
;
13688 /* If we're loading from a subset of sections, and we've loaded
13689 a section matching this name before, it's likely that it's a
13691 if (section_subset
!= NULL
)
13692 free_debug_section (debug
);
13694 return load_specific_debug_section (debug
, sec
, data
);
13698 free_debug_section (enum dwarf_section_display_enum debug
)
13700 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13702 if (section
->start
== NULL
)
13705 free ((char *) section
->start
);
13706 section
->start
= NULL
;
13707 section
->address
= 0;
13712 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13714 char * name
= SECTION_NAME (section
);
13715 const char * print_name
= printable_section_name (filedata
, section
);
13716 bfd_size_type length
;
13717 bfd_boolean result
= TRUE
;
13720 length
= section
->sh_size
;
13723 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
13726 if (section
->sh_type
== SHT_NOBITS
)
13728 /* There is no point in dumping the contents of a debugging section
13729 which has the NOBITS type - the bits in the file will be random.
13730 This can happen when a file containing a .eh_frame section is
13731 stripped with the --only-keep-debug command line option. */
13732 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
13737 if (const_strneq (name
, ".gnu.linkonce.wi."))
13738 name
= ".debug_info";
13740 /* See if we know how to display the contents of this section. */
13741 for (i
= 0; i
< max
; i
++)
13743 enum dwarf_section_display_enum id
= (enum dwarf_section_display_enum
) i
;
13744 struct dwarf_section_display
* display
= debug_displays
+ i
;
13745 struct dwarf_section
* sec
= & display
->section
;
13747 if (streq (sec
->uncompressed_name
, name
)
13748 || (id
== line
&& const_strneq (name
, ".debug_line."))
13749 || streq (sec
->compressed_name
, name
))
13751 bfd_boolean secondary
= (section
!= find_section (filedata
, name
));
13754 free_debug_section (id
);
13756 if (i
== line
&& const_strneq (name
, ".debug_line."))
13758 else if (streq (sec
->uncompressed_name
, name
))
13759 sec
->name
= sec
->uncompressed_name
;
13761 sec
->name
= sec
->compressed_name
;
13763 if (load_specific_debug_section (id
, section
, filedata
))
13765 /* If this debug section is part of a CU/TU set in a .dwp file,
13766 restrict load_debug_section to the sections in that set. */
13767 section_subset
= find_cu_tu_set (filedata
, shndx
);
13769 result
&= display
->display (sec
, filedata
);
13771 section_subset
= NULL
;
13773 if (secondary
|| (id
!= info
&& id
!= abbrev
))
13774 free_debug_section (id
);
13782 printf (_("Unrecognized debug section: %s\n"), print_name
);
13789 /* Set DUMP_SECTS for all sections where dumps were requested
13790 based on section name. */
13793 initialise_dumps_byname (Filedata
* filedata
)
13795 struct dump_list_entry
* cur
;
13797 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
13800 bfd_boolean any
= FALSE
;
13802 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
13803 if (streq (SECTION_NAME (filedata
->section_headers
+ i
), cur
->name
))
13805 request_dump_bynumber (filedata
, i
, cur
->type
);
13810 warn (_("Section '%s' was not dumped because it does not exist!\n"),
13816 process_section_contents (Filedata
* filedata
)
13818 Elf_Internal_Shdr
* section
;
13820 bfd_boolean res
= TRUE
;
13825 initialise_dumps_byname (filedata
);
13827 for (i
= 0, section
= filedata
->section_headers
;
13828 i
< filedata
->file_header
.e_shnum
&& i
< filedata
->num_dump_sects
;
13831 dump_type dump
= filedata
->dump_sects
[i
];
13833 #ifdef SUPPORT_DISASSEMBLY
13834 if (dump
& DISASS_DUMP
)
13836 if (! disassemble_section (section
, filedata
))
13840 if (dump
& HEX_DUMP
)
13842 if (! dump_section_as_bytes (section
, filedata
, FALSE
))
13846 if (dump
& RELOC_DUMP
)
13848 if (! dump_section_as_bytes (section
, filedata
, TRUE
))
13852 if (dump
& STRING_DUMP
)
13854 if (! dump_section_as_strings (section
, filedata
))
13858 if (dump
& DEBUG_DUMP
)
13860 if (! display_debug_section (i
, section
, filedata
))
13865 /* Check to see if the user requested a
13866 dump of a section that does not exist. */
13867 while (i
< filedata
->num_dump_sects
)
13869 if (filedata
->dump_sects
[i
])
13871 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
13881 process_mips_fpe_exception (int mask
)
13885 bfd_boolean first
= TRUE
;
13887 if (mask
& OEX_FPU_INEX
)
13888 fputs ("INEX", stdout
), first
= FALSE
;
13889 if (mask
& OEX_FPU_UFLO
)
13890 printf ("%sUFLO", first
? "" : "|"), first
= FALSE
;
13891 if (mask
& OEX_FPU_OFLO
)
13892 printf ("%sOFLO", first
? "" : "|"), first
= FALSE
;
13893 if (mask
& OEX_FPU_DIV0
)
13894 printf ("%sDIV0", first
? "" : "|"), first
= FALSE
;
13895 if (mask
& OEX_FPU_INVAL
)
13896 printf ("%sINVAL", first
? "" : "|");
13899 fputs ("0", stdout
);
13902 /* Display's the value of TAG at location P. If TAG is
13903 greater than 0 it is assumed to be an unknown tag, and
13904 a message is printed to this effect. Otherwise it is
13905 assumed that a message has already been printed.
13907 If the bottom bit of TAG is set it assumed to have a
13908 string value, otherwise it is assumed to have an integer
13911 Returns an updated P pointing to the first unread byte
13912 beyond the end of TAG's value.
13914 Reads at or beyond END will not be made. */
13916 static unsigned char *
13917 display_tag_value (signed int tag
,
13919 const unsigned char * const end
)
13924 printf (" Tag_unknown_%d: ", tag
);
13928 warn (_("<corrupt tag>\n"));
13932 /* PR 17531 file: 027-19978-0.004. */
13933 size_t maxlen
= (end
- p
) - 1;
13938 print_symbol ((int) maxlen
, (const char *) p
);
13939 p
+= strnlen ((char *) p
, maxlen
) + 1;
13943 printf (_("<corrupt string tag>"));
13944 p
= (unsigned char *) end
;
13952 val
= read_uleb128 (p
, &len
, end
);
13954 printf ("%ld (0x%lx)\n", val
, val
);
13961 /* ARC ABI attributes section. */
13963 static unsigned char *
13964 display_arc_attribute (unsigned char * p
,
13965 const unsigned char * const end
)
13971 tag
= read_uleb128 (p
, &len
, end
);
13976 case Tag_ARC_PCS_config
:
13977 val
= read_uleb128 (p
, &len
, end
);
13979 printf (" Tag_ARC_PCS_config: ");
13983 printf (_("Absent/Non standard\n"));
13986 printf (_("Bare metal/mwdt\n"));
13989 printf (_("Bare metal/newlib\n"));
13992 printf (_("Linux/uclibc\n"));
13995 printf (_("Linux/glibc\n"));
13998 printf (_("Unknown\n"));
14003 case Tag_ARC_CPU_base
:
14004 val
= read_uleb128 (p
, &len
, end
);
14006 printf (" Tag_ARC_CPU_base: ");
14011 printf (_("Absent\n"));
14013 case TAG_CPU_ARC6xx
:
14014 printf ("ARC6xx\n");
14016 case TAG_CPU_ARC7xx
:
14017 printf ("ARC7xx\n");
14019 case TAG_CPU_ARCEM
:
14020 printf ("ARCEM\n");
14022 case TAG_CPU_ARCHS
:
14023 printf ("ARCHS\n");
14028 case Tag_ARC_CPU_variation
:
14029 val
= read_uleb128 (p
, &len
, end
);
14031 printf (" Tag_ARC_CPU_variation: ");
14035 if (val
> 0 && val
< 16)
14036 printf ("Core%d\n", val
);
14038 printf ("Unknown\n");
14042 printf (_("Absent\n"));
14047 case Tag_ARC_CPU_name
:
14048 printf (" Tag_ARC_CPU_name: ");
14049 p
= display_tag_value (-1, p
, end
);
14052 case Tag_ARC_ABI_rf16
:
14053 val
= read_uleb128 (p
, &len
, end
);
14055 printf (" Tag_ARC_ABI_rf16: %s\n", val
? _("yes") : _("no"));
14058 case Tag_ARC_ABI_osver
:
14059 val
= read_uleb128 (p
, &len
, end
);
14061 printf (" Tag_ARC_ABI_osver: v%d\n", val
);
14064 case Tag_ARC_ABI_pic
:
14065 case Tag_ARC_ABI_sda
:
14066 val
= read_uleb128 (p
, &len
, end
);
14068 printf (tag
== Tag_ARC_ABI_sda
? " Tag_ARC_ABI_sda: "
14069 : " Tag_ARC_ABI_pic: ");
14073 printf (_("Absent\n"));
14082 printf (_("Unknown\n"));
14087 case Tag_ARC_ABI_tls
:
14088 val
= read_uleb128 (p
, &len
, end
);
14090 printf (" Tag_ARC_ABI_tls: %s\n", val
? "r25": "none");
14093 case Tag_ARC_ABI_enumsize
:
14094 val
= read_uleb128 (p
, &len
, end
);
14096 printf (" Tag_ARC_ABI_enumsize: %s\n", val
? _("default") :
14100 case Tag_ARC_ABI_exceptions
:
14101 val
= read_uleb128 (p
, &len
, end
);
14103 printf (" Tag_ARC_ABI_exceptions: %s\n", val
? _("OPTFP")
14107 case Tag_ARC_ABI_double_size
:
14108 val
= read_uleb128 (p
, &len
, end
);
14110 printf (" Tag_ARC_ABI_double_size: %d\n", val
);
14113 case Tag_ARC_ISA_config
:
14114 printf (" Tag_ARC_ISA_config: ");
14115 p
= display_tag_value (-1, p
, end
);
14118 case Tag_ARC_ISA_apex
:
14119 printf (" Tag_ARC_ISA_apex: ");
14120 p
= display_tag_value (-1, p
, end
);
14123 case Tag_ARC_ISA_mpy_option
:
14124 val
= read_uleb128 (p
, &len
, end
);
14126 printf (" Tag_ARC_ISA_mpy_option: %d\n", val
);
14130 return display_tag_value (tag
& 1, p
, end
);
14136 /* ARM EABI attributes section. */
14141 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
14143 const char ** table
;
14144 } arm_attr_public_tag
;
14146 static const char * arm_attr_tag_CPU_arch
[] =
14147 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
14148 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
14150 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
14151 static const char * arm_attr_tag_THUMB_ISA_use
[] =
14152 {"No", "Thumb-1", "Thumb-2", "Yes"};
14153 static const char * arm_attr_tag_FP_arch
[] =
14154 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
14155 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
14156 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
14157 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
14158 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
14159 "NEON for ARMv8.1"};
14160 static const char * arm_attr_tag_PCS_config
[] =
14161 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
14162 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
14163 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
14164 {"V6", "SB", "TLS", "Unused"};
14165 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
14166 {"Absolute", "PC-relative", "SB-relative", "None"};
14167 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
14168 {"Absolute", "PC-relative", "None"};
14169 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
14170 {"None", "direct", "GOT-indirect"};
14171 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
14172 {"None", "??? 1", "2", "??? 3", "4"};
14173 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
14174 static const char * arm_attr_tag_ABI_FP_denormal
[] =
14175 {"Unused", "Needed", "Sign only"};
14176 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
14177 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
14178 static const char * arm_attr_tag_ABI_FP_number_model
[] =
14179 {"Unused", "Finite", "RTABI", "IEEE 754"};
14180 static const char * arm_attr_tag_ABI_enum_size
[] =
14181 {"Unused", "small", "int", "forced to int"};
14182 static const char * arm_attr_tag_ABI_HardFP_use
[] =
14183 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
14184 static const char * arm_attr_tag_ABI_VFP_args
[] =
14185 {"AAPCS", "VFP registers", "custom", "compatible"};
14186 static const char * arm_attr_tag_ABI_WMMX_args
[] =
14187 {"AAPCS", "WMMX registers", "custom"};
14188 static const char * arm_attr_tag_ABI_optimization_goals
[] =
14189 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14190 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
14191 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
14192 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14193 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
14194 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
14195 static const char * arm_attr_tag_FP_HP_extension
[] =
14196 {"Not Allowed", "Allowed"};
14197 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
14198 {"None", "IEEE 754", "Alternative Format"};
14199 static const char * arm_attr_tag_DSP_extension
[] =
14200 {"Follow architecture", "Allowed"};
14201 static const char * arm_attr_tag_MPextension_use
[] =
14202 {"Not Allowed", "Allowed"};
14203 static const char * arm_attr_tag_DIV_use
[] =
14204 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
14205 "Allowed in v7-A with integer division extension"};
14206 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
14207 static const char * arm_attr_tag_Virtualization_use
[] =
14208 {"Not Allowed", "TrustZone", "Virtualization Extensions",
14209 "TrustZone and Virtualization Extensions"};
14210 static const char * arm_attr_tag_MPextension_use_legacy
[] =
14211 {"Not Allowed", "Allowed"};
14213 #define LOOKUP(id, name) \
14214 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
14215 static arm_attr_public_tag arm_attr_public_tags
[] =
14217 {4, "CPU_raw_name", 1, NULL
},
14218 {5, "CPU_name", 1, NULL
},
14219 LOOKUP(6, CPU_arch
),
14220 {7, "CPU_arch_profile", 0, NULL
},
14221 LOOKUP(8, ARM_ISA_use
),
14222 LOOKUP(9, THUMB_ISA_use
),
14223 LOOKUP(10, FP_arch
),
14224 LOOKUP(11, WMMX_arch
),
14225 LOOKUP(12, Advanced_SIMD_arch
),
14226 LOOKUP(13, PCS_config
),
14227 LOOKUP(14, ABI_PCS_R9_use
),
14228 LOOKUP(15, ABI_PCS_RW_data
),
14229 LOOKUP(16, ABI_PCS_RO_data
),
14230 LOOKUP(17, ABI_PCS_GOT_use
),
14231 LOOKUP(18, ABI_PCS_wchar_t
),
14232 LOOKUP(19, ABI_FP_rounding
),
14233 LOOKUP(20, ABI_FP_denormal
),
14234 LOOKUP(21, ABI_FP_exceptions
),
14235 LOOKUP(22, ABI_FP_user_exceptions
),
14236 LOOKUP(23, ABI_FP_number_model
),
14237 {24, "ABI_align_needed", 0, NULL
},
14238 {25, "ABI_align_preserved", 0, NULL
},
14239 LOOKUP(26, ABI_enum_size
),
14240 LOOKUP(27, ABI_HardFP_use
),
14241 LOOKUP(28, ABI_VFP_args
),
14242 LOOKUP(29, ABI_WMMX_args
),
14243 LOOKUP(30, ABI_optimization_goals
),
14244 LOOKUP(31, ABI_FP_optimization_goals
),
14245 {32, "compatibility", 0, NULL
},
14246 LOOKUP(34, CPU_unaligned_access
),
14247 LOOKUP(36, FP_HP_extension
),
14248 LOOKUP(38, ABI_FP_16bit_format
),
14249 LOOKUP(42, MPextension_use
),
14250 LOOKUP(44, DIV_use
),
14251 LOOKUP(46, DSP_extension
),
14252 {64, "nodefaults", 0, NULL
},
14253 {65, "also_compatible_with", 0, NULL
},
14254 LOOKUP(66, T2EE_use
),
14255 {67, "conformance", 1, NULL
},
14256 LOOKUP(68, Virtualization_use
),
14257 LOOKUP(70, MPextension_use_legacy
)
14261 static unsigned char *
14262 display_arm_attribute (unsigned char * p
,
14263 const unsigned char * const end
)
14268 arm_attr_public_tag
* attr
;
14272 tag
= read_uleb128 (p
, &len
, end
);
14275 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
14277 if (arm_attr_public_tags
[i
].tag
== tag
)
14279 attr
= &arm_attr_public_tags
[i
];
14286 printf (" Tag_%s: ", attr
->name
);
14287 switch (attr
->type
)
14292 case 7: /* Tag_CPU_arch_profile. */
14293 val
= read_uleb128 (p
, &len
, end
);
14297 case 0: printf (_("None\n")); break;
14298 case 'A': printf (_("Application\n")); break;
14299 case 'R': printf (_("Realtime\n")); break;
14300 case 'M': printf (_("Microcontroller\n")); break;
14301 case 'S': printf (_("Application or Realtime\n")); break;
14302 default: printf ("??? (%d)\n", val
); break;
14306 case 24: /* Tag_align_needed. */
14307 val
= read_uleb128 (p
, &len
, end
);
14311 case 0: printf (_("None\n")); break;
14312 case 1: printf (_("8-byte\n")); break;
14313 case 2: printf (_("4-byte\n")); break;
14314 case 3: printf ("??? 3\n"); break;
14317 printf (_("8-byte and up to %d-byte extended\n"),
14320 printf ("??? (%d)\n", val
);
14325 case 25: /* Tag_align_preserved. */
14326 val
= read_uleb128 (p
, &len
, end
);
14330 case 0: printf (_("None\n")); break;
14331 case 1: printf (_("8-byte, except leaf SP\n")); break;
14332 case 2: printf (_("8-byte\n")); break;
14333 case 3: printf ("??? 3\n"); break;
14336 printf (_("8-byte and up to %d-byte extended\n"),
14339 printf ("??? (%d)\n", val
);
14344 case 32: /* Tag_compatibility. */
14346 val
= read_uleb128 (p
, &len
, end
);
14348 printf (_("flag = %d, vendor = "), val
);
14351 size_t maxlen
= (end
- p
) - 1;
14353 print_symbol ((int) maxlen
, (const char *) p
);
14354 p
+= strnlen ((char *) p
, maxlen
) + 1;
14358 printf (_("<corrupt>"));
14359 p
= (unsigned char *) end
;
14365 case 64: /* Tag_nodefaults. */
14366 /* PR 17531: file: 001-505008-0.01. */
14369 printf (_("True\n"));
14372 case 65: /* Tag_also_compatible_with. */
14373 val
= read_uleb128 (p
, &len
, end
);
14375 if (val
== 6 /* Tag_CPU_arch. */)
14377 val
= read_uleb128 (p
, &len
, end
);
14379 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
14380 printf ("??? (%d)\n", val
);
14382 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
14386 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
14391 printf (_("<unknown: %d>\n"), tag
);
14397 return display_tag_value (-1, p
, end
);
14399 return display_tag_value (0, p
, end
);
14402 assert (attr
->type
& 0x80);
14403 val
= read_uleb128 (p
, &len
, end
);
14405 type
= attr
->type
& 0x7f;
14407 printf ("??? (%d)\n", val
);
14409 printf ("%s\n", attr
->table
[val
]);
14414 return display_tag_value (tag
, p
, end
);
14417 static unsigned char *
14418 display_gnu_attribute (unsigned char * p
,
14419 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const),
14420 const unsigned char * const end
)
14426 tag
= read_uleb128 (p
, &len
, end
);
14429 /* Tag_compatibility is the only generic GNU attribute defined at
14433 val
= read_uleb128 (p
, &len
, end
);
14436 printf (_("flag = %d, vendor = "), val
);
14439 printf (_("<corrupt>\n"));
14440 warn (_("corrupt vendor attribute\n"));
14446 size_t maxlen
= (end
- p
) - 1;
14448 print_symbol ((int) maxlen
, (const char *) p
);
14449 p
+= strnlen ((char *) p
, maxlen
) + 1;
14453 printf (_("<corrupt>"));
14454 p
= (unsigned char *) end
;
14461 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
14462 return display_proc_gnu_attribute (p
, tag
, end
);
14464 return display_tag_value (tag
, p
, end
);
14467 static unsigned char *
14468 display_power_gnu_attribute (unsigned char * p
,
14470 const unsigned char * const end
)
14475 if (tag
== Tag_GNU_Power_ABI_FP
)
14477 val
= read_uleb128 (p
, &len
, end
);
14479 printf (" Tag_GNU_Power_ABI_FP: ");
14482 printf (_("<corrupt>\n"));
14487 printf ("(%#x), ", val
);
14492 printf (_("unspecified hard/soft float, "));
14495 printf (_("hard float, "));
14498 printf (_("soft float, "));
14501 printf (_("single-precision hard float, "));
14508 printf (_("unspecified long double\n"));
14511 printf (_("128-bit IBM long double\n"));
14514 printf (_("64-bit long double\n"));
14517 printf (_("128-bit IEEE long double\n"));
14523 if (tag
== Tag_GNU_Power_ABI_Vector
)
14525 val
= read_uleb128 (p
, &len
, end
);
14527 printf (" Tag_GNU_Power_ABI_Vector: ");
14530 printf (_("<corrupt>\n"));
14535 printf ("(%#x), ", val
);
14540 printf (_("unspecified\n"));
14543 printf (_("generic\n"));
14546 printf ("AltiVec\n");
14555 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
14557 val
= read_uleb128 (p
, &len
, end
);
14559 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
14562 printf (_("<corrupt>\n"));
14567 printf ("(%#x), ", val
);
14572 printf (_("unspecified\n"));
14575 printf ("r3/r4\n");
14578 printf (_("memory\n"));
14587 return display_tag_value (tag
& 1, p
, end
);
14590 static unsigned char *
14591 display_s390_gnu_attribute (unsigned char * p
,
14593 const unsigned char * const end
)
14598 if (tag
== Tag_GNU_S390_ABI_Vector
)
14600 val
= read_uleb128 (p
, &len
, end
);
14602 printf (" Tag_GNU_S390_ABI_Vector: ");
14607 printf (_("any\n"));
14610 printf (_("software\n"));
14613 printf (_("hardware\n"));
14616 printf ("??? (%d)\n", val
);
14622 return display_tag_value (tag
& 1, p
, end
);
14626 display_sparc_hwcaps (unsigned int mask
)
14630 bfd_boolean first
= TRUE
;
14632 if (mask
& ELF_SPARC_HWCAP_MUL32
)
14633 fputs ("mul32", stdout
), first
= FALSE
;
14634 if (mask
& ELF_SPARC_HWCAP_DIV32
)
14635 printf ("%sdiv32", first
? "" : "|"), first
= FALSE
;
14636 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
14637 printf ("%sfsmuld", first
? "" : "|"), first
= FALSE
;
14638 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
14639 printf ("%sv8plus", first
? "" : "|"), first
= FALSE
;
14640 if (mask
& ELF_SPARC_HWCAP_POPC
)
14641 printf ("%spopc", first
? "" : "|"), first
= FALSE
;
14642 if (mask
& ELF_SPARC_HWCAP_VIS
)
14643 printf ("%svis", first
? "" : "|"), first
= FALSE
;
14644 if (mask
& ELF_SPARC_HWCAP_VIS2
)
14645 printf ("%svis2", first
? "" : "|"), first
= FALSE
;
14646 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
14647 printf ("%sASIBlkInit", first
? "" : "|"), first
= FALSE
;
14648 if (mask
& ELF_SPARC_HWCAP_FMAF
)
14649 printf ("%sfmaf", first
? "" : "|"), first
= FALSE
;
14650 if (mask
& ELF_SPARC_HWCAP_VIS3
)
14651 printf ("%svis3", first
? "" : "|"), first
= FALSE
;
14652 if (mask
& ELF_SPARC_HWCAP_HPC
)
14653 printf ("%shpc", first
? "" : "|"), first
= FALSE
;
14654 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
14655 printf ("%srandom", first
? "" : "|"), first
= FALSE
;
14656 if (mask
& ELF_SPARC_HWCAP_TRANS
)
14657 printf ("%strans", first
? "" : "|"), first
= FALSE
;
14658 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
14659 printf ("%sfjfmau", first
? "" : "|"), first
= FALSE
;
14660 if (mask
& ELF_SPARC_HWCAP_IMA
)
14661 printf ("%sima", first
? "" : "|"), first
= FALSE
;
14662 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
14663 printf ("%scspare", first
? "" : "|"), first
= FALSE
;
14666 fputc ('0', stdout
);
14667 fputc ('\n', stdout
);
14671 display_sparc_hwcaps2 (unsigned int mask
)
14675 bfd_boolean first
= TRUE
;
14677 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
14678 fputs ("fjathplus", stdout
), first
= FALSE
;
14679 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
14680 printf ("%svis3b", first
? "" : "|"), first
= FALSE
;
14681 if (mask
& ELF_SPARC_HWCAP2_ADP
)
14682 printf ("%sadp", first
? "" : "|"), first
= FALSE
;
14683 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
14684 printf ("%ssparc5", first
? "" : "|"), first
= FALSE
;
14685 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
14686 printf ("%smwait", first
? "" : "|"), first
= FALSE
;
14687 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
14688 printf ("%sxmpmul", first
? "" : "|"), first
= FALSE
;
14689 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
14690 printf ("%sxmont2", first
? "" : "|"), first
= FALSE
;
14691 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
14692 printf ("%snsec", first
? "" : "|"), first
= FALSE
;
14693 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
14694 printf ("%sfjathhpc", first
? "" : "|"), first
= FALSE
;
14695 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
14696 printf ("%sfjdes", first
? "" : "|"), first
= FALSE
;
14697 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
14698 printf ("%sfjaes", first
? "" : "|"), first
= FALSE
;
14701 fputc ('0', stdout
);
14702 fputc ('\n', stdout
);
14705 static unsigned char *
14706 display_sparc_gnu_attribute (unsigned char * p
,
14708 const unsigned char * const end
)
14713 if (tag
== Tag_GNU_Sparc_HWCAPS
)
14715 val
= read_uleb128 (p
, &len
, end
);
14717 printf (" Tag_GNU_Sparc_HWCAPS: ");
14718 display_sparc_hwcaps (val
);
14721 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
14723 val
= read_uleb128 (p
, &len
, end
);
14725 printf (" Tag_GNU_Sparc_HWCAPS2: ");
14726 display_sparc_hwcaps2 (val
);
14730 return display_tag_value (tag
, p
, end
);
14734 print_mips_fp_abi_value (unsigned int val
)
14738 case Val_GNU_MIPS_ABI_FP_ANY
:
14739 printf (_("Hard or soft float\n"));
14741 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
14742 printf (_("Hard float (double precision)\n"));
14744 case Val_GNU_MIPS_ABI_FP_SINGLE
:
14745 printf (_("Hard float (single precision)\n"));
14747 case Val_GNU_MIPS_ABI_FP_SOFT
:
14748 printf (_("Soft float\n"));
14750 case Val_GNU_MIPS_ABI_FP_OLD_64
:
14751 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
14753 case Val_GNU_MIPS_ABI_FP_XX
:
14754 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
14756 case Val_GNU_MIPS_ABI_FP_64
:
14757 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
14759 case Val_GNU_MIPS_ABI_FP_64A
:
14760 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
14762 case Val_GNU_MIPS_ABI_FP_NAN2008
:
14763 printf (_("NaN 2008 compatibility\n"));
14766 printf ("??? (%d)\n", val
);
14771 static unsigned char *
14772 display_mips_gnu_attribute (unsigned char * p
,
14774 const unsigned char * const end
)
14776 if (tag
== Tag_GNU_MIPS_ABI_FP
)
14781 val
= read_uleb128 (p
, &len
, end
);
14783 printf (" Tag_GNU_MIPS_ABI_FP: ");
14785 print_mips_fp_abi_value (val
);
14790 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
14795 val
= read_uleb128 (p
, &len
, end
);
14797 printf (" Tag_GNU_MIPS_ABI_MSA: ");
14801 case Val_GNU_MIPS_ABI_MSA_ANY
:
14802 printf (_("Any MSA or not\n"));
14804 case Val_GNU_MIPS_ABI_MSA_128
:
14805 printf (_("128-bit MSA\n"));
14808 printf ("??? (%d)\n", val
);
14814 return display_tag_value (tag
& 1, p
, end
);
14817 static unsigned char *
14818 display_tic6x_attribute (unsigned char * p
,
14819 const unsigned char * const end
)
14825 tag
= read_uleb128 (p
, &len
, end
);
14831 val
= read_uleb128 (p
, &len
, end
);
14833 printf (" Tag_ISA: ");
14837 case C6XABI_Tag_ISA_none
:
14838 printf (_("None\n"));
14840 case C6XABI_Tag_ISA_C62X
:
14843 case C6XABI_Tag_ISA_C67X
:
14846 case C6XABI_Tag_ISA_C67XP
:
14847 printf ("C67x+\n");
14849 case C6XABI_Tag_ISA_C64X
:
14852 case C6XABI_Tag_ISA_C64XP
:
14853 printf ("C64x+\n");
14855 case C6XABI_Tag_ISA_C674X
:
14856 printf ("C674x\n");
14859 printf ("??? (%d)\n", val
);
14864 case Tag_ABI_wchar_t
:
14865 val
= read_uleb128 (p
, &len
, end
);
14867 printf (" Tag_ABI_wchar_t: ");
14871 printf (_("Not used\n"));
14874 printf (_("2 bytes\n"));
14877 printf (_("4 bytes\n"));
14880 printf ("??? (%d)\n", val
);
14885 case Tag_ABI_stack_align_needed
:
14886 val
= read_uleb128 (p
, &len
, end
);
14888 printf (" Tag_ABI_stack_align_needed: ");
14892 printf (_("8-byte\n"));
14895 printf (_("16-byte\n"));
14898 printf ("??? (%d)\n", val
);
14903 case Tag_ABI_stack_align_preserved
:
14904 val
= read_uleb128 (p
, &len
, end
);
14906 printf (" Tag_ABI_stack_align_preserved: ");
14910 printf (_("8-byte\n"));
14913 printf (_("16-byte\n"));
14916 printf ("??? (%d)\n", val
);
14922 val
= read_uleb128 (p
, &len
, end
);
14924 printf (" Tag_ABI_DSBT: ");
14928 printf (_("DSBT addressing not used\n"));
14931 printf (_("DSBT addressing used\n"));
14934 printf ("??? (%d)\n", val
);
14940 val
= read_uleb128 (p
, &len
, end
);
14942 printf (" Tag_ABI_PID: ");
14946 printf (_("Data addressing position-dependent\n"));
14949 printf (_("Data addressing position-independent, GOT near DP\n"));
14952 printf (_("Data addressing position-independent, GOT far from DP\n"));
14955 printf ("??? (%d)\n", val
);
14961 val
= read_uleb128 (p
, &len
, end
);
14963 printf (" Tag_ABI_PIC: ");
14967 printf (_("Code addressing position-dependent\n"));
14970 printf (_("Code addressing position-independent\n"));
14973 printf ("??? (%d)\n", val
);
14978 case Tag_ABI_array_object_alignment
:
14979 val
= read_uleb128 (p
, &len
, end
);
14981 printf (" Tag_ABI_array_object_alignment: ");
14985 printf (_("8-byte\n"));
14988 printf (_("4-byte\n"));
14991 printf (_("16-byte\n"));
14994 printf ("??? (%d)\n", val
);
14999 case Tag_ABI_array_object_align_expected
:
15000 val
= read_uleb128 (p
, &len
, end
);
15002 printf (" Tag_ABI_array_object_align_expected: ");
15006 printf (_("8-byte\n"));
15009 printf (_("4-byte\n"));
15012 printf (_("16-byte\n"));
15015 printf ("??? (%d)\n", val
);
15020 case Tag_ABI_compatibility
:
15022 val
= read_uleb128 (p
, &len
, end
);
15024 printf (" Tag_ABI_compatibility: ");
15025 printf (_("flag = %d, vendor = "), val
);
15028 size_t maxlen
= (end
- p
) - 1;
15030 print_symbol ((int) maxlen
, (const char *) p
);
15031 p
+= strnlen ((char *) p
, maxlen
) + 1;
15035 printf (_("<corrupt>"));
15036 p
= (unsigned char *) end
;
15042 case Tag_ABI_conformance
:
15044 printf (" Tag_ABI_conformance: \"");
15047 size_t maxlen
= (end
- p
) - 1;
15049 print_symbol ((int) maxlen
, (const char *) p
);
15050 p
+= strnlen ((char *) p
, maxlen
) + 1;
15054 printf (_("<corrupt>"));
15055 p
= (unsigned char *) end
;
15062 return display_tag_value (tag
, p
, end
);
15066 display_raw_attribute (unsigned char * p
, unsigned char const * const end
)
15068 unsigned long addr
= 0;
15069 size_t bytes
= end
- p
;
15076 int lbytes
= (bytes
> 16 ? 16 : bytes
);
15078 printf (" 0x%8.8lx ", addr
);
15080 for (j
= 0; j
< 16; j
++)
15083 printf ("%2.2x", p
[j
]);
15091 for (j
= 0; j
< lbytes
; j
++)
15094 if (k
>= ' ' && k
< 0x7f)
15110 static unsigned char *
15111 display_msp430x_attribute (unsigned char * p
,
15112 const unsigned char * const end
)
15118 tag
= read_uleb128 (p
, & len
, end
);
15123 case OFBA_MSPABI_Tag_ISA
:
15124 val
= read_uleb128 (p
, &len
, end
);
15126 printf (" Tag_ISA: ");
15129 case 0: printf (_("None\n")); break;
15130 case 1: printf (_("MSP430\n")); break;
15131 case 2: printf (_("MSP430X\n")); break;
15132 default: printf ("??? (%d)\n", val
); break;
15136 case OFBA_MSPABI_Tag_Code_Model
:
15137 val
= read_uleb128 (p
, &len
, end
);
15139 printf (" Tag_Code_Model: ");
15142 case 0: printf (_("None\n")); break;
15143 case 1: printf (_("Small\n")); break;
15144 case 2: printf (_("Large\n")); break;
15145 default: printf ("??? (%d)\n", val
); break;
15149 case OFBA_MSPABI_Tag_Data_Model
:
15150 val
= read_uleb128 (p
, &len
, end
);
15152 printf (" Tag_Data_Model: ");
15155 case 0: printf (_("None\n")); break;
15156 case 1: printf (_("Small\n")); break;
15157 case 2: printf (_("Large\n")); break;
15158 case 3: printf (_("Restricted Large\n")); break;
15159 default: printf ("??? (%d)\n", val
); break;
15164 printf (_(" <unknown tag %d>: "), tag
);
15171 size_t maxlen
= (end
- p
) - 1;
15173 print_symbol ((int) maxlen
, (const char *) p
);
15174 p
+= strnlen ((char *) p
, maxlen
) + 1;
15178 printf (_("<corrupt>"));
15179 p
= (unsigned char *) end
;
15185 val
= read_uleb128 (p
, &len
, end
);
15187 printf ("%d (0x%x)\n", val
, val
);
15197 process_attributes (Filedata
* filedata
,
15198 const char * public_name
,
15199 unsigned int proc_type
,
15200 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
15201 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const))
15203 Elf_Internal_Shdr
* sect
;
15205 bfd_boolean res
= TRUE
;
15207 /* Find the section header so that we get the size. */
15208 for (i
= 0, sect
= filedata
->section_headers
;
15209 i
< filedata
->file_header
.e_shnum
;
15212 unsigned char * contents
;
15215 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
15218 contents
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
, 1,
15219 sect
->sh_size
, _("attributes"));
15220 if (contents
== NULL
)
15227 /* The first character is the version of the attributes.
15228 Currently only version 1, (aka 'A') is recognised here. */
15231 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p
, *p
);
15236 bfd_vma section_len
;
15238 section_len
= sect
->sh_size
- 1;
15241 while (section_len
> 0)
15244 unsigned int namelen
;
15245 bfd_boolean public_section
;
15246 bfd_boolean gnu_section
;
15248 if (section_len
<= 4)
15250 error (_("Tag section ends prematurely\n"));
15254 attr_len
= byte_get (p
, 4);
15257 if (attr_len
> section_len
)
15259 error (_("Bad attribute length (%u > %u)\n"),
15260 (unsigned) attr_len
, (unsigned) section_len
);
15261 attr_len
= section_len
;
15264 /* PR 17531: file: 001-101425-0.004 */
15265 else if (attr_len
< 5)
15267 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
15272 section_len
-= attr_len
;
15275 namelen
= strnlen ((char *) p
, attr_len
) + 1;
15276 if (namelen
== 0 || namelen
>= attr_len
)
15278 error (_("Corrupt attribute section name\n"));
15283 printf (_("Attribute Section: "));
15284 print_symbol (INT_MAX
, (const char *) p
);
15287 if (public_name
&& streq ((char *) p
, public_name
))
15288 public_section
= TRUE
;
15290 public_section
= FALSE
;
15292 if (streq ((char *) p
, "gnu"))
15293 gnu_section
= TRUE
;
15295 gnu_section
= FALSE
;
15298 attr_len
-= namelen
;
15300 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
15305 unsigned char * end
;
15307 /* PR binutils/17531: Safe handling of corrupt files. */
15310 error (_("Unused bytes at end of section\n"));
15317 size
= byte_get (p
, 4);
15318 if (size
> attr_len
)
15320 error (_("Bad subsection length (%u > %u)\n"),
15321 (unsigned) size
, (unsigned) attr_len
);
15325 /* PR binutils/17531: Safe handling of corrupt files. */
15328 error (_("Bad subsection length (%u < 6)\n"),
15336 end
= p
+ size
- 1;
15337 assert (end
<= contents
+ sect
->sh_size
);
15343 printf (_("File Attributes\n"));
15346 printf (_("Section Attributes:"));
15349 printf (_("Symbol Attributes:"));
15350 /* Fall through. */
15356 val
= read_uleb128 (p
, &j
, end
);
15360 printf (" %d", val
);
15365 printf (_("Unknown tag: %d\n"), tag
);
15366 public_section
= FALSE
;
15370 if (public_section
&& display_pub_attribute
!= NULL
)
15373 p
= display_pub_attribute (p
, end
);
15376 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
15379 p
= display_gnu_attribute (p
,
15380 display_proc_gnu_attribute
,
15386 printf (_(" Unknown attribute:\n"));
15387 display_raw_attribute (p
, end
);
15402 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
15403 Print the Address, Access and Initial fields of an entry at VMA ADDR
15404 and return the VMA of the next entry, or -1 if there was a problem.
15405 Does not read from DATA_END or beyond. */
15408 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
15409 unsigned char * data_end
)
15412 print_vma (addr
, LONG_HEX
);
15414 if (addr
< pltgot
+ 0xfff0)
15415 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
15417 printf ("%10s", "");
15420 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
15424 unsigned char * from
= data
+ addr
- pltgot
;
15426 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
15428 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
15429 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
15430 return (bfd_vma
) -1;
15434 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
15435 print_vma (entry
, LONG_HEX
);
15438 return addr
+ (is_32bit_elf
? 4 : 8);
15441 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
15442 PLTGOT. Print the Address and Initial fields of an entry at VMA
15443 ADDR and return the VMA of the next entry. */
15446 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
15449 print_vma (addr
, LONG_HEX
);
15452 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
15457 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
15458 print_vma (entry
, LONG_HEX
);
15460 return addr
+ (is_32bit_elf
? 4 : 8);
15464 print_mips_ases (unsigned int mask
)
15466 if (mask
& AFL_ASE_DSP
)
15467 fputs ("\n\tDSP ASE", stdout
);
15468 if (mask
& AFL_ASE_DSPR2
)
15469 fputs ("\n\tDSP R2 ASE", stdout
);
15470 if (mask
& AFL_ASE_DSPR3
)
15471 fputs ("\n\tDSP R3 ASE", stdout
);
15472 if (mask
& AFL_ASE_EVA
)
15473 fputs ("\n\tEnhanced VA Scheme", stdout
);
15474 if (mask
& AFL_ASE_MCU
)
15475 fputs ("\n\tMCU (MicroController) ASE", stdout
);
15476 if (mask
& AFL_ASE_MDMX
)
15477 fputs ("\n\tMDMX ASE", stdout
);
15478 if (mask
& AFL_ASE_MIPS3D
)
15479 fputs ("\n\tMIPS-3D ASE", stdout
);
15480 if (mask
& AFL_ASE_MT
)
15481 fputs ("\n\tMT ASE", stdout
);
15482 if (mask
& AFL_ASE_SMARTMIPS
)
15483 fputs ("\n\tSmartMIPS ASE", stdout
);
15484 if (mask
& AFL_ASE_VIRT
)
15485 fputs ("\n\tVZ ASE", stdout
);
15486 if (mask
& AFL_ASE_MSA
)
15487 fputs ("\n\tMSA ASE", stdout
);
15488 if (mask
& AFL_ASE_MIPS16
)
15489 fputs ("\n\tMIPS16 ASE", stdout
);
15490 if (mask
& AFL_ASE_MICROMIPS
)
15491 fputs ("\n\tMICROMIPS ASE", stdout
);
15492 if (mask
& AFL_ASE_XPA
)
15493 fputs ("\n\tXPA ASE", stdout
);
15494 if (mask
& AFL_ASE_MIPS16E2
)
15495 fputs ("\n\tMIPS16e2 ASE", stdout
);
15497 fprintf (stdout
, "\n\t%s", _("None"));
15498 else if ((mask
& ~AFL_ASE_MASK
) != 0)
15499 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
15503 print_mips_isa_ext (unsigned int isa_ext
)
15508 fputs (_("None"), stdout
);
15511 fputs ("RMI XLR", stdout
);
15513 case AFL_EXT_OCTEON3
:
15514 fputs ("Cavium Networks Octeon3", stdout
);
15516 case AFL_EXT_OCTEON2
:
15517 fputs ("Cavium Networks Octeon2", stdout
);
15519 case AFL_EXT_OCTEONP
:
15520 fputs ("Cavium Networks OcteonP", stdout
);
15522 case AFL_EXT_LOONGSON_3A
:
15523 fputs ("Loongson 3A", stdout
);
15525 case AFL_EXT_OCTEON
:
15526 fputs ("Cavium Networks Octeon", stdout
);
15529 fputs ("Toshiba R5900", stdout
);
15532 fputs ("MIPS R4650", stdout
);
15535 fputs ("LSI R4010", stdout
);
15538 fputs ("NEC VR4100", stdout
);
15541 fputs ("Toshiba R3900", stdout
);
15543 case AFL_EXT_10000
:
15544 fputs ("MIPS R10000", stdout
);
15547 fputs ("Broadcom SB-1", stdout
);
15550 fputs ("NEC VR4111/VR4181", stdout
);
15553 fputs ("NEC VR4120", stdout
);
15556 fputs ("NEC VR5400", stdout
);
15559 fputs ("NEC VR5500", stdout
);
15561 case AFL_EXT_LOONGSON_2E
:
15562 fputs ("ST Microelectronics Loongson 2E", stdout
);
15564 case AFL_EXT_LOONGSON_2F
:
15565 fputs ("ST Microelectronics Loongson 2F", stdout
);
15567 case AFL_EXT_INTERAPTIV_MR2
:
15568 fputs ("Imagination interAptiv MR2", stdout
);
15571 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
15576 get_mips_reg_size (int reg_size
)
15578 return (reg_size
== AFL_REG_NONE
) ? 0
15579 : (reg_size
== AFL_REG_32
) ? 32
15580 : (reg_size
== AFL_REG_64
) ? 64
15581 : (reg_size
== AFL_REG_128
) ? 128
15586 process_mips_specific (Filedata
* filedata
)
15588 Elf_Internal_Dyn
* entry
;
15589 Elf_Internal_Shdr
*sect
= NULL
;
15590 size_t liblist_offset
= 0;
15591 size_t liblistno
= 0;
15592 size_t conflictsno
= 0;
15593 size_t options_offset
= 0;
15594 size_t conflicts_offset
= 0;
15595 size_t pltrelsz
= 0;
15597 bfd_vma pltgot
= 0;
15598 bfd_vma mips_pltgot
= 0;
15599 bfd_vma jmprel
= 0;
15600 bfd_vma local_gotno
= 0;
15601 bfd_vma gotsym
= 0;
15602 bfd_vma symtabno
= 0;
15603 bfd_boolean res
= TRUE
;
15605 if (! process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
15606 display_mips_gnu_attribute
))
15609 sect
= find_section (filedata
, ".MIPS.abiflags");
15613 Elf_External_ABIFlags_v0
*abiflags_ext
;
15614 Elf_Internal_ABIFlags_v0 abiflags_in
;
15616 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
15618 error (_("Corrupt MIPS ABI Flags section.\n"));
15623 abiflags_ext
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
15624 sect
->sh_size
, _("MIPS ABI Flags section"));
15627 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
15628 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
15629 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
15630 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
15631 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
15632 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
15633 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
15634 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
15635 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
15636 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
15637 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
15639 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
15640 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
15641 if (abiflags_in
.isa_rev
> 1)
15642 printf ("r%d", abiflags_in
.isa_rev
);
15643 printf ("\nGPR size: %d",
15644 get_mips_reg_size (abiflags_in
.gpr_size
));
15645 printf ("\nCPR1 size: %d",
15646 get_mips_reg_size (abiflags_in
.cpr1_size
));
15647 printf ("\nCPR2 size: %d",
15648 get_mips_reg_size (abiflags_in
.cpr2_size
));
15649 fputs ("\nFP ABI: ", stdout
);
15650 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
15651 fputs ("ISA Extension: ", stdout
);
15652 print_mips_isa_ext (abiflags_in
.isa_ext
);
15653 fputs ("\nASEs:", stdout
);
15654 print_mips_ases (abiflags_in
.ases
);
15655 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
15656 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
15657 fputc ('\n', stdout
);
15658 free (abiflags_ext
);
15663 /* We have a lot of special sections. Thanks SGI! */
15664 if (dynamic_section
== NULL
)
15666 /* No dynamic information available. See if there is static GOT. */
15667 sect
= find_section (filedata
, ".got");
15670 unsigned char *data_end
;
15671 unsigned char *data
;
15675 pltgot
= sect
->sh_addr
;
15678 addr_size
= (is_32bit_elf
? 4 : 8);
15679 end
= pltgot
+ sect
->sh_size
;
15681 data
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
,
15683 _("Global Offset Table data"));
15684 /* PR 12855: Null data is handled gracefully throughout. */
15685 data_end
= data
+ (end
- pltgot
);
15687 printf (_("\nStatic GOT:\n"));
15688 printf (_(" Canonical gp value: "));
15689 print_vma (ent
+ 0x7ff0, LONG_HEX
);
15692 /* In a dynamic binary GOT[0] is reserved for the dynamic
15693 loader to store the lazy resolver pointer, however in
15694 a static binary it may well have been omitted and GOT
15695 reduced to a table of addresses.
15696 PR 21344: Check for the entry being fully available
15697 before fetching it. */
15699 && data
+ ent
- pltgot
+ addr_size
<= data_end
15700 && byte_get (data
+ ent
- pltgot
, addr_size
) == 0)
15702 printf (_(" Reserved entries:\n"));
15703 printf (_(" %*s %10s %*s\n"),
15704 addr_size
* 2, _("Address"), _("Access"),
15705 addr_size
* 2, _("Value"));
15706 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15708 if (ent
== (bfd_vma
) -1)
15709 goto sgot_print_fail
;
15711 /* Check for the MSB of GOT[1] being set, identifying a
15712 GNU object. This entry will be used by some runtime
15713 loaders, to store the module pointer. Otherwise this
15714 is an ordinary local entry.
15715 PR 21344: Check for the entry being fully available
15716 before fetching it. */
15718 && data
+ ent
- pltgot
+ addr_size
<= data_end
15719 && (byte_get (data
+ ent
- pltgot
, addr_size
)
15720 >> (addr_size
* 8 - 1)) != 0)
15722 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15724 if (ent
== (bfd_vma
) -1)
15725 goto sgot_print_fail
;
15730 if (data
!= NULL
&& ent
< end
)
15732 printf (_(" Local entries:\n"));
15733 printf (" %*s %10s %*s\n",
15734 addr_size
* 2, _("Address"), _("Access"),
15735 addr_size
* 2, _("Value"));
15738 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15740 if (ent
== (bfd_vma
) -1)
15741 goto sgot_print_fail
;
15753 for (entry
= dynamic_section
;
15754 /* PR 17531 file: 012-50589-0.004. */
15755 entry
< dynamic_section
+ dynamic_nent
&& entry
->d_tag
!= DT_NULL
;
15757 switch (entry
->d_tag
)
15759 case DT_MIPS_LIBLIST
:
15761 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
15762 liblistno
* sizeof (Elf32_External_Lib
));
15764 case DT_MIPS_LIBLISTNO
:
15765 liblistno
= entry
->d_un
.d_val
;
15767 case DT_MIPS_OPTIONS
:
15768 options_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
15770 case DT_MIPS_CONFLICT
:
15772 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
15773 conflictsno
* sizeof (Elf32_External_Conflict
));
15775 case DT_MIPS_CONFLICTNO
:
15776 conflictsno
= entry
->d_un
.d_val
;
15779 pltgot
= entry
->d_un
.d_ptr
;
15781 case DT_MIPS_LOCAL_GOTNO
:
15782 local_gotno
= entry
->d_un
.d_val
;
15784 case DT_MIPS_GOTSYM
:
15785 gotsym
= entry
->d_un
.d_val
;
15787 case DT_MIPS_SYMTABNO
:
15788 symtabno
= entry
->d_un
.d_val
;
15790 case DT_MIPS_PLTGOT
:
15791 mips_pltgot
= entry
->d_un
.d_ptr
;
15794 pltrel
= entry
->d_un
.d_val
;
15797 pltrelsz
= entry
->d_un
.d_val
;
15800 jmprel
= entry
->d_un
.d_ptr
;
15806 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
15808 Elf32_External_Lib
* elib
;
15811 elib
= (Elf32_External_Lib
*) get_data (NULL
, filedata
, liblist_offset
,
15813 sizeof (Elf32_External_Lib
),
15814 _("liblist section data"));
15817 printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
15818 "\nSection '.liblist' contains %lu entries:\n",
15819 (unsigned long) liblistno
),
15820 (unsigned long) liblistno
);
15821 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
15824 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
15831 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
15832 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
15833 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
15834 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
15835 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
15837 tmp
= gmtime (&atime
);
15838 snprintf (timebuf
, sizeof (timebuf
),
15839 "%04u-%02u-%02uT%02u:%02u:%02u",
15840 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
15841 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
15843 printf ("%3lu: ", (unsigned long) cnt
);
15844 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
15845 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
15847 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
15848 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
15849 liblist
.l_version
);
15851 if (liblist
.l_flags
== 0)
15855 static const struct
15862 { " EXACT_MATCH", LL_EXACT_MATCH
},
15863 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
15864 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
15865 { " EXPORTS", LL_EXPORTS
},
15866 { " DELAY_LOAD", LL_DELAY_LOAD
},
15867 { " DELTA", LL_DELTA
}
15869 int flags
= liblist
.l_flags
;
15872 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
15873 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
15875 fputs (l_flags_vals
[fcnt
].name
, stdout
);
15876 flags
^= l_flags_vals
[fcnt
].bit
;
15879 printf (" %#x", (unsigned int) flags
);
15891 if (options_offset
!= 0)
15893 Elf_External_Options
* eopt
;
15894 Elf_Internal_Options
* iopt
;
15895 Elf_Internal_Options
* option
;
15898 sect
= filedata
->section_headers
;
15900 /* Find the section header so that we get the size. */
15901 sect
= find_section_by_type (filedata
, SHT_MIPS_OPTIONS
);
15902 /* PR 17533 file: 012-277276-0.004. */
15905 error (_("No MIPS_OPTIONS header found\n"));
15909 eopt
= (Elf_External_Options
*) get_data (NULL
, filedata
, options_offset
, 1,
15910 sect
->sh_size
, _("options"));
15913 iopt
= (Elf_Internal_Options
*)
15914 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
15917 error (_("Out of memory allocating space for MIPS options\n"));
15924 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
15926 Elf_External_Options
* eoption
;
15928 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
15930 option
->kind
= BYTE_GET (eoption
->kind
);
15931 option
->size
= BYTE_GET (eoption
->size
);
15932 option
->section
= BYTE_GET (eoption
->section
);
15933 option
->info
= BYTE_GET (eoption
->info
);
15935 /* PR 17531: file: ffa0fa3b. */
15936 if (option
->size
< sizeof (* eopt
)
15937 || offset
+ option
->size
> sect
->sh_size
)
15939 error (_("Invalid size (%u) for MIPS option\n"), option
->size
);
15942 offset
+= option
->size
;
15948 printf (ngettext ("\nSection '%s' contains %d entry:\n",
15949 "\nSection '%s' contains %d entries:\n",
15951 printable_section_name (filedata
, sect
), cnt
);
15960 switch (option
->kind
)
15963 /* This shouldn't happen. */
15964 printf (" NULL %d %lx", option
->section
, option
->info
);
15967 printf (" REGINFO ");
15968 if (filedata
->file_header
.e_machine
== EM_MIPS
)
15971 Elf32_External_RegInfo
* ereg
;
15972 Elf32_RegInfo reginfo
;
15974 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
15975 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
15976 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
15977 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
15978 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
15979 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
15980 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
15982 printf ("GPR %08lx GP 0x%lx\n",
15983 reginfo
.ri_gprmask
,
15984 (unsigned long) reginfo
.ri_gp_value
);
15985 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
15986 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
15987 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
15992 Elf64_External_RegInfo
* ereg
;
15993 Elf64_Internal_RegInfo reginfo
;
15995 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
15996 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
15997 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
15998 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
15999 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
16000 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
16001 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
16003 printf ("GPR %08lx GP 0x",
16004 reginfo
.ri_gprmask
);
16005 printf_vma (reginfo
.ri_gp_value
);
16008 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
16009 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
16010 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
16014 case ODK_EXCEPTIONS
:
16015 fputs (" EXCEPTIONS fpe_min(", stdout
);
16016 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
16017 fputs (") fpe_max(", stdout
);
16018 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
16019 fputs (")", stdout
);
16021 if (option
->info
& OEX_PAGE0
)
16022 fputs (" PAGE0", stdout
);
16023 if (option
->info
& OEX_SMM
)
16024 fputs (" SMM", stdout
);
16025 if (option
->info
& OEX_FPDBUG
)
16026 fputs (" FPDBUG", stdout
);
16027 if (option
->info
& OEX_DISMISS
)
16028 fputs (" DISMISS", stdout
);
16031 fputs (" PAD ", stdout
);
16032 if (option
->info
& OPAD_PREFIX
)
16033 fputs (" PREFIX", stdout
);
16034 if (option
->info
& OPAD_POSTFIX
)
16035 fputs (" POSTFIX", stdout
);
16036 if (option
->info
& OPAD_SYMBOL
)
16037 fputs (" SYMBOL", stdout
);
16040 fputs (" HWPATCH ", stdout
);
16041 if (option
->info
& OHW_R4KEOP
)
16042 fputs (" R4KEOP", stdout
);
16043 if (option
->info
& OHW_R8KPFETCH
)
16044 fputs (" R8KPFETCH", stdout
);
16045 if (option
->info
& OHW_R5KEOP
)
16046 fputs (" R5KEOP", stdout
);
16047 if (option
->info
& OHW_R5KCVTL
)
16048 fputs (" R5KCVTL", stdout
);
16051 fputs (" FILL ", stdout
);
16052 /* XXX Print content of info word? */
16055 fputs (" TAGS ", stdout
);
16056 /* XXX Print content of info word? */
16059 fputs (" HWAND ", stdout
);
16060 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
16061 fputs (" R4KEOP_CHECKED", stdout
);
16062 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
16063 fputs (" R4KEOP_CLEAN", stdout
);
16066 fputs (" HWOR ", stdout
);
16067 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
16068 fputs (" R4KEOP_CHECKED", stdout
);
16069 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
16070 fputs (" R4KEOP_CLEAN", stdout
);
16073 printf (" GP_GROUP %#06lx self-contained %#06lx",
16074 option
->info
& OGP_GROUP
,
16075 (option
->info
& OGP_SELF
) >> 16);
16078 printf (" IDENT %#06lx self-contained %#06lx",
16079 option
->info
& OGP_GROUP
,
16080 (option
->info
& OGP_SELF
) >> 16);
16083 /* This shouldn't happen. */
16084 printf (" %3d ??? %d %lx",
16085 option
->kind
, option
->section
, option
->info
);
16089 len
= sizeof (* eopt
);
16090 while (len
< option
->size
)
16092 unsigned char datum
= * ((unsigned char *) eopt
+ offset
+ len
);
16094 if (ISPRINT (datum
))
16095 printf ("%c", datum
);
16097 printf ("\\%03o", datum
);
16100 fputs ("\n", stdout
);
16102 offset
+= option
->size
;
16112 if (conflicts_offset
!= 0 && conflictsno
!= 0)
16114 Elf32_Conflict
* iconf
;
16117 if (dynamic_symbols
== NULL
)
16119 error (_("conflict list found without a dynamic symbol table\n"));
16123 /* PR 21345 - print a slightly more helpful error message
16124 if we are sure that the cmalloc will fail. */
16125 if (conflictsno
* sizeof (* iconf
) > filedata
->file_size
)
16127 error (_("Overlarge number of conflicts detected: %lx\n"),
16128 (long) conflictsno
);
16132 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
16135 error (_("Out of memory allocating space for dynamic conflicts\n"));
16141 Elf32_External_Conflict
* econf32
;
16143 econf32
= (Elf32_External_Conflict
*)
16144 get_data (NULL
, filedata
, conflicts_offset
, conflictsno
,
16145 sizeof (* econf32
), _("conflict"));
16149 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
16150 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
16156 Elf64_External_Conflict
* econf64
;
16158 econf64
= (Elf64_External_Conflict
*)
16159 get_data (NULL
, filedata
, conflicts_offset
, conflictsno
,
16160 sizeof (* econf64
), _("conflict"));
16164 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
16165 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
16170 printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
16171 "\nSection '.conflict' contains %lu entries:\n",
16172 (unsigned long) conflictsno
),
16173 (unsigned long) conflictsno
);
16174 puts (_(" Num: Index Value Name"));
16176 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
16178 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
16180 if (iconf
[cnt
] >= num_dynamic_syms
)
16181 printf (_("<corrupt symbol index>"));
16184 Elf_Internal_Sym
* psym
;
16186 psym
= & dynamic_symbols
[iconf
[cnt
]];
16187 print_vma (psym
->st_value
, FULL_HEX
);
16189 if (VALID_DYNAMIC_NAME (psym
->st_name
))
16190 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
16192 printf (_("<corrupt: %14ld>"), psym
->st_name
);
16200 if (pltgot
!= 0 && local_gotno
!= 0)
16202 bfd_vma ent
, local_end
, global_end
;
16204 unsigned char * data
;
16205 unsigned char * data_end
;
16209 addr_size
= (is_32bit_elf
? 4 : 8);
16210 local_end
= pltgot
+ local_gotno
* addr_size
;
16212 /* PR binutils/17533 file: 012-111227-0.004 */
16213 if (symtabno
< gotsym
)
16215 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
16216 (unsigned long) gotsym
, (unsigned long) symtabno
);
16220 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
16221 /* PR 17531: file: 54c91a34. */
16222 if (global_end
< local_end
)
16224 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
16228 offset
= offset_from_vma (filedata
, pltgot
, global_end
- pltgot
);
16229 data
= (unsigned char *) get_data (NULL
, filedata
, offset
,
16230 global_end
- pltgot
, 1,
16231 _("Global Offset Table data"));
16232 /* PR 12855: Null data is handled gracefully throughout. */
16233 data_end
= data
+ (global_end
- pltgot
);
16235 printf (_("\nPrimary GOT:\n"));
16236 printf (_(" Canonical gp value: "));
16237 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
16240 printf (_(" Reserved entries:\n"));
16241 printf (_(" %*s %10s %*s Purpose\n"),
16242 addr_size
* 2, _("Address"), _("Access"),
16243 addr_size
* 2, _("Initial"));
16244 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16245 printf (_(" Lazy resolver\n"));
16246 if (ent
== (bfd_vma
) -1)
16247 goto got_print_fail
;
16249 /* Check for the MSB of GOT[1] being set, denoting a GNU object.
16250 This entry will be used by some runtime loaders, to store the
16251 module pointer. Otherwise this is an ordinary local entry.
16252 PR 21344: Check for the entry being fully available before
16255 && data
+ ent
- pltgot
+ addr_size
<= data_end
16256 && (byte_get (data
+ ent
- pltgot
, addr_size
)
16257 >> (addr_size
* 8 - 1)) != 0)
16259 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16260 printf (_(" Module pointer (GNU extension)\n"));
16261 if (ent
== (bfd_vma
) -1)
16262 goto got_print_fail
;
16266 if (data
!= NULL
&& ent
< local_end
)
16268 printf (_(" Local entries:\n"));
16269 printf (" %*s %10s %*s\n",
16270 addr_size
* 2, _("Address"), _("Access"),
16271 addr_size
* 2, _("Initial"));
16272 while (ent
< local_end
)
16274 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16276 if (ent
== (bfd_vma
) -1)
16277 goto got_print_fail
;
16282 if (data
!= NULL
&& gotsym
< symtabno
)
16286 printf (_(" Global entries:\n"));
16287 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
16288 addr_size
* 2, _("Address"),
16290 addr_size
* 2, _("Initial"),
16291 addr_size
* 2, _("Sym.Val."),
16293 /* Note for translators: "Ndx" = abbreviated form of "Index". */
16294 _("Ndx"), _("Name"));
16296 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
16298 for (i
= gotsym
; i
< symtabno
; i
++)
16300 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16303 if (dynamic_symbols
== NULL
)
16304 printf (_("<no dynamic symbols>"));
16305 else if (i
< num_dynamic_syms
)
16307 Elf_Internal_Sym
* psym
= dynamic_symbols
+ i
;
16309 print_vma (psym
->st_value
, LONG_HEX
);
16310 printf (" %-7s %3s ",
16311 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
16312 get_symbol_index_type (filedata
, psym
->st_shndx
));
16314 if (VALID_DYNAMIC_NAME (psym
->st_name
))
16315 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
16317 printf (_("<corrupt: %14ld>"), psym
->st_name
);
16320 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
16321 (unsigned long) i
);
16324 if (ent
== (bfd_vma
) -1)
16335 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
16338 size_t offset
, rel_offset
;
16339 unsigned long count
, i
;
16340 unsigned char * data
;
16341 int addr_size
, sym_width
;
16342 Elf_Internal_Rela
* rels
;
16344 rel_offset
= offset_from_vma (filedata
, jmprel
, pltrelsz
);
16345 if (pltrel
== DT_RELA
)
16347 if (!slurp_rela_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
16352 if (!slurp_rel_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
16357 addr_size
= (is_32bit_elf
? 4 : 8);
16358 end
= mips_pltgot
+ (2 + count
) * addr_size
;
16360 offset
= offset_from_vma (filedata
, mips_pltgot
, end
- mips_pltgot
);
16361 data
= (unsigned char *) get_data (NULL
, filedata
, offset
, end
- mips_pltgot
,
16362 1, _("Procedure Linkage Table data"));
16366 printf ("\nPLT GOT:\n\n");
16367 printf (_(" Reserved entries:\n"));
16368 printf (_(" %*s %*s Purpose\n"),
16369 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
16370 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
16371 printf (_(" PLT lazy resolver\n"));
16372 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
16373 printf (_(" Module pointer\n"));
16376 printf (_(" Entries:\n"));
16377 printf (" %*s %*s %*s %-7s %3s %s\n",
16378 addr_size
* 2, _("Address"),
16379 addr_size
* 2, _("Initial"),
16380 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
16381 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
16382 for (i
= 0; i
< count
; i
++)
16384 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
16386 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
16389 if (idx
>= num_dynamic_syms
)
16390 printf (_("<corrupt symbol index: %lu>"), idx
);
16393 Elf_Internal_Sym
* psym
= dynamic_symbols
+ idx
;
16395 print_vma (psym
->st_value
, LONG_HEX
);
16396 printf (" %-7s %3s ",
16397 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
16398 get_symbol_index_type (filedata
, psym
->st_shndx
));
16399 if (VALID_DYNAMIC_NAME (psym
->st_name
))
16400 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
16402 printf (_("<corrupt: %14ld>"), psym
->st_name
);
16417 process_nds32_specific (Filedata
* filedata
)
16419 Elf_Internal_Shdr
*sect
= NULL
;
16421 sect
= find_section (filedata
, ".nds32_e_flags");
16424 unsigned int *flag
;
16426 printf ("\nNDS32 elf flags section:\n");
16427 flag
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
16428 sect
->sh_size
, _("NDS32 elf flags section"));
16433 switch ((*flag
) & 0x3)
16436 printf ("(VEC_SIZE):\tNo entry.\n");
16439 printf ("(VEC_SIZE):\t4 bytes\n");
16442 printf ("(VEC_SIZE):\t16 bytes\n");
16445 printf ("(VEC_SIZE):\treserved\n");
16454 process_gnu_liblist (Filedata
* filedata
)
16456 Elf_Internal_Shdr
* section
;
16457 Elf_Internal_Shdr
* string_sec
;
16458 Elf32_External_Lib
* elib
;
16460 size_t strtab_size
;
16462 unsigned long num_liblist
;
16464 bfd_boolean res
= TRUE
;
16469 for (i
= 0, section
= filedata
->section_headers
;
16470 i
< filedata
->file_header
.e_shnum
;
16473 switch (section
->sh_type
)
16475 case SHT_GNU_LIBLIST
:
16476 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
16479 elib
= (Elf32_External_Lib
*)
16480 get_data (NULL
, filedata
, section
->sh_offset
, 1, section
->sh_size
,
16481 _("liblist section data"));
16489 string_sec
= filedata
->section_headers
+ section
->sh_link
;
16490 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
16491 string_sec
->sh_size
,
16492 _("liblist string table"));
16494 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
16501 strtab_size
= string_sec
->sh_size
;
16503 num_liblist
= section
->sh_size
/ sizeof (Elf32_External_Lib
);
16504 printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
16505 "\nLibrary list section '%s' contains %lu entries:\n",
16507 printable_section_name (filedata
, section
),
16510 puts (_(" Library Time Stamp Checksum Version Flags"));
16512 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
16520 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
16521 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
16522 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
16523 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
16524 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
16526 tmp
= gmtime (&atime
);
16527 snprintf (timebuf
, sizeof (timebuf
),
16528 "%04u-%02u-%02uT%02u:%02u:%02u",
16529 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
16530 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
16532 printf ("%3lu: ", (unsigned long) cnt
);
16534 printf ("%-20s", liblist
.l_name
< strtab_size
16535 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
16537 printf ("%-20.20s", liblist
.l_name
< strtab_size
16538 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
16539 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
16540 liblist
.l_version
, liblist
.l_flags
);
16551 static const char *
16552 get_note_type (Filedata
* filedata
, unsigned e_type
)
16554 static char buff
[64];
16556 if (filedata
->file_header
.e_type
== ET_CORE
)
16560 return _("NT_AUXV (auxiliary vector)");
16562 return _("NT_PRSTATUS (prstatus structure)");
16564 return _("NT_FPREGSET (floating point registers)");
16566 return _("NT_PRPSINFO (prpsinfo structure)");
16567 case NT_TASKSTRUCT
:
16568 return _("NT_TASKSTRUCT (task structure)");
16570 return _("NT_PRXFPREG (user_xfpregs structure)");
16572 return _("NT_PPC_VMX (ppc Altivec registers)");
16574 return _("NT_PPC_VSX (ppc VSX registers)");
16576 return _("NT_PPC_TAR (ppc TAR register)");
16578 return _("NT_PPC_PPR (ppc PPR register)");
16580 return _("NT_PPC_DSCR (ppc DSCR register)");
16582 return _("NT_PPC_EBB (ppc EBB registers)");
16584 return _("NT_PPC_PMU (ppc PMU registers)");
16585 case NT_PPC_TM_CGPR
:
16586 return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
16587 case NT_PPC_TM_CFPR
:
16588 return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
16589 case NT_PPC_TM_CVMX
:
16590 return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
16591 case NT_PPC_TM_CVSX
:
16592 return _("NT_PPC_TM_VSX (ppc checkpointed VSX registers)");
16593 case NT_PPC_TM_SPR
:
16594 return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
16595 case NT_PPC_TM_CTAR
:
16596 return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
16597 case NT_PPC_TM_CPPR
:
16598 return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
16599 case NT_PPC_TM_CDSCR
:
16600 return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
16602 return _("NT_386_TLS (x86 TLS information)");
16603 case NT_386_IOPERM
:
16604 return _("NT_386_IOPERM (x86 I/O permissions)");
16605 case NT_X86_XSTATE
:
16606 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
16607 case NT_S390_HIGH_GPRS
:
16608 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
16609 case NT_S390_TIMER
:
16610 return _("NT_S390_TIMER (s390 timer register)");
16611 case NT_S390_TODCMP
:
16612 return _("NT_S390_TODCMP (s390 TOD comparator register)");
16613 case NT_S390_TODPREG
:
16614 return _("NT_S390_TODPREG (s390 TOD programmable register)");
16616 return _("NT_S390_CTRS (s390 control registers)");
16617 case NT_S390_PREFIX
:
16618 return _("NT_S390_PREFIX (s390 prefix register)");
16619 case NT_S390_LAST_BREAK
:
16620 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
16621 case NT_S390_SYSTEM_CALL
:
16622 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
16624 return _("NT_S390_TDB (s390 transaction diagnostic block)");
16625 case NT_S390_VXRS_LOW
:
16626 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
16627 case NT_S390_VXRS_HIGH
:
16628 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
16629 case NT_S390_GS_CB
:
16630 return _("NT_S390_GS_CB (s390 guarded-storage registers)");
16631 case NT_S390_GS_BC
:
16632 return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
16634 return _("NT_ARM_VFP (arm VFP registers)");
16636 return _("NT_ARM_TLS (AArch TLS registers)");
16637 case NT_ARM_HW_BREAK
:
16638 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
16639 case NT_ARM_HW_WATCH
:
16640 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
16642 return _("NT_PSTATUS (pstatus structure)");
16644 return _("NT_FPREGS (floating point registers)");
16646 return _("NT_PSINFO (psinfo structure)");
16648 return _("NT_LWPSTATUS (lwpstatus_t structure)");
16650 return _("NT_LWPSINFO (lwpsinfo_t structure)");
16651 case NT_WIN32PSTATUS
:
16652 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
16654 return _("NT_SIGINFO (siginfo_t data)");
16656 return _("NT_FILE (mapped files)");
16664 return _("NT_VERSION (version)");
16666 return _("NT_ARCH (architecture)");
16667 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
16669 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
16675 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16680 print_core_note (Elf_Internal_Note
*pnote
)
16682 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
16683 bfd_vma count
, page_size
;
16684 unsigned char *descdata
, *filenames
, *descend
;
16686 if (pnote
->type
!= NT_FILE
)
16696 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
16697 /* Still "successful". */
16702 if (pnote
->descsz
< 2 * addr_size
)
16704 error (_(" Malformed note - too short for header\n"));
16708 descdata
= (unsigned char *) pnote
->descdata
;
16709 descend
= descdata
+ pnote
->descsz
;
16711 if (descdata
[pnote
->descsz
- 1] != '\0')
16713 error (_(" Malformed note - does not end with \\0\n"));
16717 count
= byte_get (descdata
, addr_size
);
16718 descdata
+= addr_size
;
16720 page_size
= byte_get (descdata
, addr_size
);
16721 descdata
+= addr_size
;
16723 if (count
> ((bfd_vma
) -1 - 2 * addr_size
) / (3 * addr_size
)
16724 || pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
16726 error (_(" Malformed note - too short for supplied file count\n"));
16730 printf (_(" Page size: "));
16731 print_vma (page_size
, DEC
);
16734 printf (_(" %*s%*s%*s\n"),
16735 (int) (2 + 2 * addr_size
), _("Start"),
16736 (int) (4 + 2 * addr_size
), _("End"),
16737 (int) (4 + 2 * addr_size
), _("Page Offset"));
16738 filenames
= descdata
+ count
* 3 * addr_size
;
16739 while (count
-- > 0)
16741 bfd_vma start
, end
, file_ofs
;
16743 if (filenames
== descend
)
16745 error (_(" Malformed note - filenames end too early\n"));
16749 start
= byte_get (descdata
, addr_size
);
16750 descdata
+= addr_size
;
16751 end
= byte_get (descdata
, addr_size
);
16752 descdata
+= addr_size
;
16753 file_ofs
= byte_get (descdata
, addr_size
);
16754 descdata
+= addr_size
;
16757 print_vma (start
, FULL_HEX
);
16759 print_vma (end
, FULL_HEX
);
16761 print_vma (file_ofs
, FULL_HEX
);
16762 printf ("\n %s\n", filenames
);
16764 filenames
+= 1 + strlen ((char *) filenames
);
16770 static const char *
16771 get_gnu_elf_note_type (unsigned e_type
)
16773 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
16776 case NT_GNU_ABI_TAG
:
16777 return _("NT_GNU_ABI_TAG (ABI version tag)");
16779 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
16780 case NT_GNU_BUILD_ID
:
16781 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
16782 case NT_GNU_GOLD_VERSION
:
16783 return _("NT_GNU_GOLD_VERSION (gold version)");
16784 case NT_GNU_PROPERTY_TYPE_0
:
16785 return _("NT_GNU_PROPERTY_TYPE_0");
16786 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
16787 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
16788 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
16789 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
16792 static char buff
[64];
16794 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16801 decode_x86_isa (unsigned int bitmask
)
16805 unsigned int bit
= bitmask
& (- bitmask
);
16810 case GNU_PROPERTY_X86_ISA_1_486
: printf ("i486"); break;
16811 case GNU_PROPERTY_X86_ISA_1_586
: printf ("586"); break;
16812 case GNU_PROPERTY_X86_ISA_1_686
: printf ("686"); break;
16813 case GNU_PROPERTY_X86_ISA_1_SSE
: printf ("SSE"); break;
16814 case GNU_PROPERTY_X86_ISA_1_SSE2
: printf ("SSE2"); break;
16815 case GNU_PROPERTY_X86_ISA_1_SSE3
: printf ("SSE3"); break;
16816 case GNU_PROPERTY_X86_ISA_1_SSSE3
: printf ("SSSE3"); break;
16817 case GNU_PROPERTY_X86_ISA_1_SSE4_1
: printf ("SSE4_1"); break;
16818 case GNU_PROPERTY_X86_ISA_1_SSE4_2
: printf ("SSE4_2"); break;
16819 case GNU_PROPERTY_X86_ISA_1_AVX
: printf ("AVX"); break;
16820 case GNU_PROPERTY_X86_ISA_1_AVX2
: printf ("AVX2"); break;
16821 case GNU_PROPERTY_X86_ISA_1_AVX512F
: printf ("AVX512F"); break;
16822 case GNU_PROPERTY_X86_ISA_1_AVX512CD
: printf ("AVX512CD"); break;
16823 case GNU_PROPERTY_X86_ISA_1_AVX512ER
: printf ("AVX512ER"); break;
16824 case GNU_PROPERTY_X86_ISA_1_AVX512PF
: printf ("AVX512PF"); break;
16825 case GNU_PROPERTY_X86_ISA_1_AVX512VL
: printf ("AVX512VL"); break;
16826 case GNU_PROPERTY_X86_ISA_1_AVX512DQ
: printf ("AVX512DQ"); break;
16827 case GNU_PROPERTY_X86_ISA_1_AVX512BW
: printf ("AVX512BW"); break;
16828 default: printf (_("<unknown: %x>"), bit
); break;
16836 decode_x86_feature (unsigned int type
, unsigned int bitmask
)
16840 unsigned int bit
= bitmask
& (- bitmask
);
16845 case GNU_PROPERTY_X86_FEATURE_1_IBT
:
16848 case GNU_PROPERTY_X86_FEATURE_1_AND
:
16852 /* This should never happen. */
16856 case GNU_PROPERTY_X86_FEATURE_1_SHSTK
:
16859 case GNU_PROPERTY_X86_FEATURE_1_AND
:
16863 /* This should never happen. */
16868 printf (_("<unknown: %x>"), bit
);
16877 print_gnu_property_note (Filedata
* filedata
, Elf_Internal_Note
* pnote
)
16879 unsigned char * ptr
= (unsigned char *) pnote
->descdata
;
16880 unsigned char * ptr_end
= ptr
+ pnote
->descsz
;
16881 unsigned int size
= is_32bit_elf
? 4 : 8;
16883 printf (_(" Properties: "));
16885 if (pnote
->descsz
< 8 || (pnote
->descsz
% size
) != 0)
16887 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote
->descsz
);
16891 while (ptr
< ptr_end
)
16895 unsigned int datasz
;
16897 if ((size_t) (ptr_end
- ptr
) < 8)
16899 printf (_("<corrupt descsz: %#lx>\n"), pnote
->descsz
);
16903 type
= byte_get (ptr
, 4);
16904 datasz
= byte_get (ptr
+ 4, 4);
16908 if (datasz
> (size_t) (ptr_end
- ptr
))
16910 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
16915 if (type
>= GNU_PROPERTY_LOPROC
&& type
<= GNU_PROPERTY_HIPROC
)
16917 if (filedata
->file_header
.e_machine
== EM_X86_64
16918 || filedata
->file_header
.e_machine
== EM_IAMCU
16919 || filedata
->file_header
.e_machine
== EM_386
)
16923 case GNU_PROPERTY_X86_ISA_1_USED
:
16924 printf ("x86 ISA used: ");
16926 printf (_("<corrupt length: %#x> "), datasz
);
16928 decode_x86_isa (byte_get (ptr
, 4));
16931 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
16932 printf ("x86 ISA needed: ");
16934 printf (_("<corrupt length: %#x> "), datasz
);
16936 decode_x86_isa (byte_get (ptr
, 4));
16939 case GNU_PROPERTY_X86_FEATURE_1_AND
:
16940 printf ("x86 feature: ");
16942 printf (_("<corrupt length: %#x> "), datasz
);
16944 decode_x86_feature (type
, byte_get (ptr
, 4));
16956 case GNU_PROPERTY_STACK_SIZE
:
16957 printf (_("stack size: "));
16958 if (datasz
!= size
)
16959 printf (_("<corrupt length: %#x> "), datasz
);
16961 printf ("%#lx", (unsigned long) byte_get (ptr
, size
));
16964 case GNU_PROPERTY_NO_COPY_ON_PROTECTED
:
16965 printf ("no copy on protected ");
16967 printf (_("<corrupt length: %#x> "), datasz
);
16975 if (type
< GNU_PROPERTY_LOPROC
)
16976 printf (_("<unknown type %#x data: "), type
);
16977 else if (type
< GNU_PROPERTY_LOUSER
)
16978 printf (_("<procesor-specific type %#x data: "), type
);
16980 printf (_("<application-specific type %#x data: "), type
);
16981 for (j
= 0; j
< datasz
; ++j
)
16982 printf ("%02x ", ptr
[j
] & 0xff);
16986 ptr
+= ((datasz
+ (size
- 1)) & ~ (size
- 1));
16987 if (ptr
== ptr_end
)
17000 print_gnu_note (Filedata
* filedata
, Elf_Internal_Note
*pnote
)
17002 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
17003 switch (pnote
->type
)
17005 case NT_GNU_BUILD_ID
:
17009 printf (_(" Build ID: "));
17010 for (i
= 0; i
< pnote
->descsz
; ++i
)
17011 printf ("%02x", pnote
->descdata
[i
] & 0xff);
17016 case NT_GNU_ABI_TAG
:
17018 unsigned long os
, major
, minor
, subminor
;
17019 const char *osname
;
17021 /* PR 17531: file: 030-599401-0.004. */
17022 if (pnote
->descsz
< 16)
17024 printf (_(" <corrupt GNU_ABI_TAG>\n"));
17028 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
17029 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
17030 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
17031 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
17035 case GNU_ABI_TAG_LINUX
:
17038 case GNU_ABI_TAG_HURD
:
17041 case GNU_ABI_TAG_SOLARIS
:
17042 osname
= "Solaris";
17044 case GNU_ABI_TAG_FREEBSD
:
17045 osname
= "FreeBSD";
17047 case GNU_ABI_TAG_NETBSD
:
17050 case GNU_ABI_TAG_SYLLABLE
:
17051 osname
= "Syllable";
17053 case GNU_ABI_TAG_NACL
:
17057 osname
= "Unknown";
17061 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
17062 major
, minor
, subminor
);
17066 case NT_GNU_GOLD_VERSION
:
17070 printf (_(" Version: "));
17071 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
17072 printf ("%c", pnote
->descdata
[i
]);
17079 unsigned long num_entries
, mask
;
17081 /* Hardware capabilities information. Word 0 is the number of entries.
17082 Word 1 is a bitmask of enabled entries. The rest of the descriptor
17083 is a series of entries, where each entry is a single byte followed
17084 by a nul terminated string. The byte gives the bit number to test
17085 if enabled in the bitmask. */
17086 printf (_(" Hardware Capabilities: "));
17087 if (pnote
->descsz
< 8)
17089 error (_("<corrupt GNU_HWCAP>\n"));
17092 num_entries
= byte_get ((unsigned char *) pnote
->descdata
, 4);
17093 mask
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
17094 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries
, mask
);
17095 /* FIXME: Add code to display the entries... */
17099 case NT_GNU_PROPERTY_TYPE_0
:
17100 print_gnu_property_note (filedata
, pnote
);
17104 /* Handle unrecognised types. An error message should have already been
17105 created by get_gnu_elf_note_type(), so all that we need to do is to
17106 display the data. */
17110 printf (_(" Description data: "));
17111 for (i
= 0; i
< pnote
->descsz
; ++i
)
17112 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
17121 static const char *
17122 get_v850_elf_note_type (enum v850_notes n_type
)
17124 static char buff
[64];
17128 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
17129 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
17130 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
17131 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
17132 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
17133 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
17135 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
17141 print_v850_note (Elf_Internal_Note
* pnote
)
17145 if (pnote
->descsz
!= 4)
17148 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
17152 printf (_("not set\n"));
17156 switch (pnote
->type
)
17158 case V850_NOTE_ALIGNMENT
:
17161 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return TRUE
;
17162 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return TRUE
;
17166 case V850_NOTE_DATA_SIZE
:
17169 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return TRUE
;
17170 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return TRUE
;
17174 case V850_NOTE_FPU_INFO
:
17177 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return TRUE
;
17178 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return TRUE
;
17182 case V850_NOTE_MMU_INFO
:
17183 case V850_NOTE_CACHE_INFO
:
17184 case V850_NOTE_SIMD_INFO
:
17185 if (val
== EF_RH850_SIMD
)
17187 printf (_("yes\n"));
17193 /* An 'unknown note type' message will already have been displayed. */
17197 printf (_("unknown value: %x\n"), val
);
17202 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
17204 unsigned int version
;
17206 switch (pnote
->type
)
17208 case NT_NETBSD_IDENT
:
17209 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
17210 if ((version
/ 10000) % 100)
17211 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
17212 version
, version
/ 100000000, (version
/ 1000000) % 100,
17213 (version
/ 10000) % 100 > 26 ? "Z" : "",
17214 'A' + (version
/ 10000) % 26);
17216 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
17217 version
, version
/ 100000000, (version
/ 1000000) % 100,
17218 (version
/ 100) % 100);
17221 case NT_NETBSD_MARCH
:
17222 printf (" NetBSD\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
17227 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote
->descsz
,
17233 static const char *
17234 get_freebsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
17238 case NT_FREEBSD_THRMISC
:
17239 return _("NT_THRMISC (thrmisc structure)");
17240 case NT_FREEBSD_PROCSTAT_PROC
:
17241 return _("NT_PROCSTAT_PROC (proc data)");
17242 case NT_FREEBSD_PROCSTAT_FILES
:
17243 return _("NT_PROCSTAT_FILES (files data)");
17244 case NT_FREEBSD_PROCSTAT_VMMAP
:
17245 return _("NT_PROCSTAT_VMMAP (vmmap data)");
17246 case NT_FREEBSD_PROCSTAT_GROUPS
:
17247 return _("NT_PROCSTAT_GROUPS (groups data)");
17248 case NT_FREEBSD_PROCSTAT_UMASK
:
17249 return _("NT_PROCSTAT_UMASK (umask data)");
17250 case NT_FREEBSD_PROCSTAT_RLIMIT
:
17251 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
17252 case NT_FREEBSD_PROCSTAT_OSREL
:
17253 return _("NT_PROCSTAT_OSREL (osreldate data)");
17254 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
17255 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
17256 case NT_FREEBSD_PROCSTAT_AUXV
:
17257 return _("NT_PROCSTAT_AUXV (auxv data)");
17258 case NT_FREEBSD_PTLWPINFO
:
17259 return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
17261 return get_note_type (filedata
, e_type
);
17264 static const char *
17265 get_netbsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
17267 static char buff
[64];
17269 if (e_type
== NT_NETBSDCORE_PROCINFO
)
17270 return _("NetBSD procinfo structure");
17272 /* As of Jan 2002 there are no other machine-independent notes
17273 defined for NetBSD core files. If the note type is less
17274 than the start of the machine-dependent note types, we don't
17277 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
17279 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17283 switch (filedata
->file_header
.e_machine
)
17285 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
17286 and PT_GETFPREGS == mach+2. */
17291 case EM_SPARC32PLUS
:
17295 case NT_NETBSDCORE_FIRSTMACH
+ 0:
17296 return _("PT_GETREGS (reg structure)");
17297 case NT_NETBSDCORE_FIRSTMACH
+ 2:
17298 return _("PT_GETFPREGS (fpreg structure)");
17304 /* On all other arch's, PT_GETREGS == mach+1 and
17305 PT_GETFPREGS == mach+3. */
17309 case NT_NETBSDCORE_FIRSTMACH
+ 1:
17310 return _("PT_GETREGS (reg structure)");
17311 case NT_NETBSDCORE_FIRSTMACH
+ 3:
17312 return _("PT_GETFPREGS (fpreg structure)");
17318 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
17319 e_type
- NT_NETBSDCORE_FIRSTMACH
);
17323 static const char *
17324 get_stapsdt_note_type (unsigned e_type
)
17326 static char buff
[64];
17331 return _("NT_STAPSDT (SystemTap probe descriptors)");
17337 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17342 print_stapsdt_note (Elf_Internal_Note
*pnote
)
17344 int addr_size
= is_32bit_elf
? 4 : 8;
17345 char *data
= pnote
->descdata
;
17346 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
17347 bfd_vma pc
, base_addr
, semaphore
;
17348 char *provider
, *probe
, *arg_fmt
;
17350 pc
= byte_get ((unsigned char *) data
, addr_size
);
17352 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
17354 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
17358 data
+= strlen (data
) + 1;
17360 data
+= strlen (data
) + 1;
17362 data
+= strlen (data
) + 1;
17364 printf (_(" Provider: %s\n"), provider
);
17365 printf (_(" Name: %s\n"), probe
);
17366 printf (_(" Location: "));
17367 print_vma (pc
, FULL_HEX
);
17368 printf (_(", Base: "));
17369 print_vma (base_addr
, FULL_HEX
);
17370 printf (_(", Semaphore: "));
17371 print_vma (semaphore
, FULL_HEX
);
17373 printf (_(" Arguments: %s\n"), arg_fmt
);
17375 return data
== data_end
;
17378 static const char *
17379 get_ia64_vms_note_type (unsigned e_type
)
17381 static char buff
[64];
17386 return _("NT_VMS_MHD (module header)");
17388 return _("NT_VMS_LNM (language name)");
17390 return _("NT_VMS_SRC (source files)");
17392 return "NT_VMS_TITLE";
17394 return _("NT_VMS_EIDC (consistency check)");
17395 case NT_VMS_FPMODE
:
17396 return _("NT_VMS_FPMODE (FP mode)");
17397 case NT_VMS_LINKTIME
:
17398 return "NT_VMS_LINKTIME";
17399 case NT_VMS_IMGNAM
:
17400 return _("NT_VMS_IMGNAM (image name)");
17402 return _("NT_VMS_IMGID (image id)");
17403 case NT_VMS_LINKID
:
17404 return _("NT_VMS_LINKID (link id)");
17405 case NT_VMS_IMGBID
:
17406 return _("NT_VMS_IMGBID (build id)");
17407 case NT_VMS_GSTNAM
:
17408 return _("NT_VMS_GSTNAM (sym table name)");
17409 case NT_VMS_ORIG_DYN
:
17410 return "NT_VMS_ORIG_DYN";
17411 case NT_VMS_PATCHTIME
:
17412 return "NT_VMS_PATCHTIME";
17414 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17420 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
17422 switch (pnote
->type
)
17425 if (pnote
->descsz
> 36)
17427 size_t l
= strlen (pnote
->descdata
+ 34);
17428 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
17429 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
17430 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
17431 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
17434 printf (_(" Invalid size\n"));
17437 printf (_(" Language: %s\n"), pnote
->descdata
);
17440 case NT_VMS_FPMODE
:
17441 printf (_(" Floating Point mode: "));
17442 printf ("0x%016" BFD_VMA_FMT
"x\n",
17443 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
17445 case NT_VMS_LINKTIME
:
17446 printf (_(" Link time: "));
17448 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
17451 case NT_VMS_PATCHTIME
:
17452 printf (_(" Patch time: "));
17454 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
17457 case NT_VMS_ORIG_DYN
:
17458 printf (_(" Major id: %u, minor id: %u\n"),
17459 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
17460 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
17461 printf (_(" Last modified : "));
17463 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
17464 printf (_("\n Link flags : "));
17465 printf ("0x%016" BFD_VMA_FMT
"x\n",
17466 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
17467 printf (_(" Header flags: 0x%08x\n"),
17468 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
17469 printf (_(" Image id : %s\n"), pnote
->descdata
+ 32);
17472 case NT_VMS_IMGNAM
:
17473 printf (_(" Image name: %s\n"), pnote
->descdata
);
17475 case NT_VMS_GSTNAM
:
17476 printf (_(" Global symbol table name: %s\n"), pnote
->descdata
);
17479 printf (_(" Image id: %s\n"), pnote
->descdata
);
17481 case NT_VMS_LINKID
:
17482 printf (_(" Linker id: %s\n"), pnote
->descdata
);
17490 /* Find the symbol associated with a build attribute that is attached
17491 to address OFFSET. If PNAME is non-NULL then store the name of
17492 the symbol (if found) in the provided pointer, Returns NULL if a
17493 symbol could not be found. */
17495 static Elf_Internal_Sym
*
17496 get_symbol_for_build_attribute (Filedata
* filedata
,
17497 unsigned long offset
,
17498 bfd_boolean is_open_attr
,
17499 const char ** pname
)
17501 static Filedata
* saved_filedata
= NULL
;
17502 static char * strtab
;
17503 static unsigned long strtablen
;
17504 static Elf_Internal_Sym
* symtab
;
17505 static unsigned long nsyms
;
17506 Elf_Internal_Sym
* saved_sym
= NULL
;
17507 Elf_Internal_Sym
* sym
;
17509 if (filedata
->section_headers
!= NULL
17510 && (saved_filedata
== NULL
|| filedata
!= saved_filedata
))
17512 Elf_Internal_Shdr
* symsec
;
17514 /* Load the symbol and string sections. */
17515 for (symsec
= filedata
->section_headers
;
17516 symsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
17519 if (symsec
->sh_type
== SHT_SYMTAB
)
17521 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & nsyms
);
17523 if (symsec
->sh_link
< filedata
->file_header
.e_shnum
)
17525 Elf_Internal_Shdr
* strtab_sec
= filedata
->section_headers
+ symsec
->sh_link
;
17527 strtab
= (char *) get_data (NULL
, filedata
, strtab_sec
->sh_offset
,
17528 1, strtab_sec
->sh_size
,
17529 _("string table"));
17530 strtablen
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
17534 saved_filedata
= filedata
;
17537 if (symtab
== NULL
|| strtab
== NULL
)
17540 /* Find a symbol whose value matches offset. */
17541 for (sym
= symtab
; sym
< symtab
+ nsyms
; sym
++)
17542 if (sym
->st_value
== offset
)
17544 if (sym
->st_name
>= strtablen
)
17545 /* Huh ? This should not happen. */
17548 if (strtab
[sym
->st_name
] == 0)
17551 /* The AArch64 and ARM architectures define mapping symbols
17552 (eg $d, $x, $t) which we want to ignore. */
17553 if (strtab
[sym
->st_name
] == '$'
17554 && strtab
[sym
->st_name
+ 1] != 0
17555 && strtab
[sym
->st_name
+ 2] == 0)
17560 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
17561 and FILE or OBJECT symbols over NOTYPE symbols. We skip
17562 FUNC symbols entirely. */
17563 switch (ELF_ST_TYPE (sym
->st_info
))
17570 /* If the symbol has a size associated
17571 with it then we can stop searching. */
17572 sym
= symtab
+ nsyms
;
17577 /* Ignore function symbols. */
17584 switch (ELF_ST_BIND (sym
->st_info
))
17587 if (saved_sym
== NULL
17588 || ELF_ST_TYPE (saved_sym
->st_info
) != STT_OBJECT
)
17593 if (saved_sym
== NULL
)
17603 if (ELF_ST_TYPE (sym
->st_info
) != STT_FUNC
)
17611 if (saved_sym
&& pname
)
17612 * pname
= strtab
+ saved_sym
->st_name
;
17618 print_gnu_build_attribute_description (Elf_Internal_Note
* pnote
,
17619 Filedata
* filedata
)
17621 static unsigned long global_offset
= 0;
17622 static unsigned long global_end
= 0;
17623 static unsigned long func_offset
= 0;
17624 static unsigned long func_end
= 0;
17626 Elf_Internal_Sym
* sym
;
17628 unsigned long start
;
17630 bfd_boolean is_open_attr
= pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
;
17632 switch (pnote
->descsz
)
17635 /* A zero-length description means that the range of
17636 the previous note of the same type should be used. */
17639 if (global_end
> global_offset
)
17640 printf (_(" Applies to region from %#lx to %#lx\n"),
17641 global_offset
, global_end
);
17643 printf (_(" Applies to region from %#lx\n"), global_offset
);
17647 if (func_end
> func_offset
)
17648 printf (_(" Applies to region from %#lx to %#lx\n"), func_offset
, func_end
);
17650 printf (_(" Applies to region from %#lx\n"), func_offset
);
17655 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
17662 /* FIXME: We should check that version 3+ notes are being used here... */
17663 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
17664 end
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
17668 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
17674 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
17675 end
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 8);
17679 error (_(" <invalid description size: %lx>\n"), pnote
->descsz
);
17680 printf (_(" <invalid descsz>"));
17685 sym
= get_symbol_for_build_attribute (filedata
, start
, is_open_attr
, & name
);
17686 /* As of version 5 of the annobin plugin, filename symbols are biased by 2
17687 in order to avoid them being confused with the start address of the
17688 first function in the file... */
17689 if (sym
== NULL
&& is_open_attr
)
17690 sym
= get_symbol_for_build_attribute (filedata
, start
+ 2, is_open_attr
,
17693 if (end
== 0 && sym
!= NULL
&& sym
->st_size
> 0)
17694 end
= start
+ sym
->st_size
;
17698 /* FIXME: Need to properly allow for section alignment. 16 is just the alignment used on x86_64. */
17699 if (global_end
> 0 && start
> BFD_ALIGN (global_end
, 16))
17700 warn (_("Gap in build notes detected from %#lx to %#lx\n"),
17701 global_end
+ 1, start
- 1);
17703 printf (_(" Applies to region from %#lx"), start
);
17704 global_offset
= start
;
17708 printf (_(" to %#lx"), end
);
17714 printf (_(" Applies to region from %#lx"), start
);
17715 func_offset
= start
;
17719 printf (_(" to %#lx"), end
);
17725 printf (_(" (%s)"), name
);
17732 print_gnu_build_attribute_name (Elf_Internal_Note
* pnote
)
17734 static const char string_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING
, 0 };
17735 static const char number_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
, 0 };
17736 static const char bool_expected
[3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
, 0 };
17738 char name_attribute
;
17739 const char * expected_types
;
17740 const char * name
= pnote
->namedata
;
17744 if (name
== NULL
|| pnote
->namesz
< 2)
17746 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
17747 print_symbol (-20, _(" <corrupt name>"));
17756 /* Version 2 of the spec adds a "GA" prefix to the name field. */
17757 if (name
[0] == 'G' && name
[1] == 'A')
17759 if (pnote
->namesz
< 4)
17761 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
17762 print_symbol (-20, _(" <corrupt name>"));
17771 switch ((name_type
= * name
))
17773 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
17774 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
17775 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
17776 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
17777 printf ("%c", * name
);
17781 error (_("unrecognised attribute type in name field: %d\n"), name_type
);
17782 print_symbol (-20, _("<unknown name type>"));
17789 switch ((name_attribute
= * name
))
17791 case GNU_BUILD_ATTRIBUTE_VERSION
:
17792 text
= _("<version>");
17793 expected_types
= string_expected
;
17796 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
17797 text
= _("<stack prot>");
17798 expected_types
= "!+*";
17801 case GNU_BUILD_ATTRIBUTE_RELRO
:
17802 text
= _("<relro>");
17803 expected_types
= bool_expected
;
17806 case GNU_BUILD_ATTRIBUTE_STACK_SIZE
:
17807 text
= _("<stack size>");
17808 expected_types
= number_expected
;
17811 case GNU_BUILD_ATTRIBUTE_TOOL
:
17812 text
= _("<tool>");
17813 expected_types
= string_expected
;
17816 case GNU_BUILD_ATTRIBUTE_ABI
:
17818 expected_types
= "$*";
17821 case GNU_BUILD_ATTRIBUTE_PIC
:
17823 expected_types
= number_expected
;
17826 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM
:
17827 text
= _("<short enum>");
17828 expected_types
= bool_expected
;
17832 if (ISPRINT (* name
))
17834 int len
= strnlen (name
, pnote
->namesz
- (name
- pnote
->namedata
)) + 1;
17836 if (len
> left
&& ! do_wide
)
17838 printf ("%.*s:", len
, name
);
17844 static char tmpbuf
[128];
17846 error (_("unrecognised byte in name field: %d\n"), * name
);
17847 sprintf (tmpbuf
, _("<unknown:_%d>"), * name
);
17851 expected_types
= "*$!+";
17856 left
-= printf ("%s", text
);
17858 if (strchr (expected_types
, name_type
) == NULL
)
17859 warn (_("attribute does not have an expected type (%c)\n"), name_type
);
17861 if ((unsigned long)(name
- pnote
->namedata
) > pnote
->namesz
)
17863 error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
17864 (unsigned long) pnote
->namesz
,
17865 (long) (name
- pnote
->namedata
));
17869 if (left
< 1 && ! do_wide
)
17874 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
17876 unsigned int bytes
;
17877 unsigned long long val
= 0;
17878 unsigned int shift
= 0;
17879 char * decoded
= NULL
;
17881 bytes
= pnote
->namesz
- (name
- pnote
->namedata
);
17883 /* The -1 is because the name field is always 0 terminated, and we
17884 want to be able to ensure that the shift in the while loop below
17885 will not overflow. */
17888 if (bytes
> sizeof (val
))
17890 error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
17892 bytes
= sizeof (val
);
17894 /* We do not bother to warn if bytes == 0 as this can
17895 happen with some early versions of the gcc plugin. */
17899 unsigned long byte
= (* name
++) & 0xff;
17901 val
|= byte
<< shift
;
17905 switch (name_attribute
)
17907 case GNU_BUILD_ATTRIBUTE_PIC
:
17910 case 0: decoded
= "static"; break;
17911 case 1: decoded
= "pic"; break;
17912 case 2: decoded
= "PIC"; break;
17913 case 3: decoded
= "pie"; break;
17914 case 4: decoded
= "PIE"; break;
17918 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
17921 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
17922 case 0: decoded
= "off"; break;
17923 case 1: decoded
= "on"; break;
17924 case 2: decoded
= "all"; break;
17925 case 3: decoded
= "strong"; break;
17926 case 4: decoded
= "explicit"; break;
17934 if (decoded
!= NULL
)
17936 print_symbol (-left
, decoded
);
17947 left
-= printf ("0x%llx", val
);
17949 left
-= printf ("0x%-.*llx", left
, val
);
17953 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
17954 left
-= print_symbol (- left
, name
);
17956 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
17957 left
-= print_symbol (- left
, "true");
17959 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
17960 left
-= print_symbol (- left
, "false");
17964 if (do_wide
&& left
> 0)
17965 printf ("%-*s", left
, " ");
17970 /* Note that by the ELF standard, the name field is already null byte
17971 terminated, and namesz includes the terminating null byte.
17972 I.E. the value of namesz for the name "FSF" is 4.
17974 If the value of namesz is zero, there is no name present. */
17977 process_note (Elf_Internal_Note
* pnote
,
17978 Filedata
* filedata
)
17980 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
17983 if (pnote
->namesz
== 0)
17984 /* If there is no note name, then use the default set of
17985 note type strings. */
17986 nt
= get_note_type (filedata
, pnote
->type
);
17988 else if (const_strneq (pnote
->namedata
, "GNU"))
17989 /* GNU-specific object file notes. */
17990 nt
= get_gnu_elf_note_type (pnote
->type
);
17992 else if (const_strneq (pnote
->namedata
, "FreeBSD"))
17993 /* FreeBSD-specific core file notes. */
17994 nt
= get_freebsd_elfcore_note_type (filedata
, pnote
->type
);
17996 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
17997 /* NetBSD-specific core file notes. */
17998 nt
= get_netbsd_elfcore_note_type (filedata
, pnote
->type
);
18000 else if (const_strneq (pnote
->namedata
, "NetBSD"))
18001 /* NetBSD-specific core file notes. */
18002 return process_netbsd_elf_note (pnote
);
18004 else if (strneq (pnote
->namedata
, "SPU/", 4))
18006 /* SPU-specific core file notes. */
18007 nt
= pnote
->namedata
+ 4;
18011 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
18012 /* VMS/ia64-specific file notes. */
18013 nt
= get_ia64_vms_note_type (pnote
->type
);
18015 else if (const_strneq (pnote
->namedata
, "stapsdt"))
18016 nt
= get_stapsdt_note_type (pnote
->type
);
18019 /* Don't recognize this note name; just use the default set of
18020 note type strings. */
18021 nt
= get_note_type (filedata
, pnote
->type
);
18025 if (((const_strneq (pnote
->namedata
, "GA")
18026 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
18027 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
18028 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
18029 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
18030 print_gnu_build_attribute_name (pnote
);
18032 print_symbol (-20, name
);
18035 printf (" 0x%08lx\t%s\t", pnote
->descsz
, nt
);
18037 printf (" 0x%08lx\t%s\n", pnote
->descsz
, nt
);
18039 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
18040 return print_ia64_vms_note (pnote
);
18041 else if (const_strneq (pnote
->namedata
, "GNU"))
18042 return print_gnu_note (filedata
, pnote
);
18043 else if (const_strneq (pnote
->namedata
, "stapsdt"))
18044 return print_stapsdt_note (pnote
);
18045 else if (const_strneq (pnote
->namedata
, "CORE"))
18046 return print_core_note (pnote
);
18047 else if (((const_strneq (pnote
->namedata
, "GA")
18048 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
18049 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
18050 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
18051 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
18052 return print_gnu_build_attribute_description (pnote
, filedata
);
18058 printf (_(" description data: "));
18059 for (i
= 0; i
< pnote
->descsz
; i
++)
18060 printf ("%02x ", pnote
->descdata
[i
]);
18072 process_notes_at (Filedata
* filedata
,
18073 Elf_Internal_Shdr
* section
,
18078 Elf_External_Note
* pnotes
;
18079 Elf_External_Note
* external
;
18081 bfd_boolean res
= TRUE
;
18088 pnotes
= (Elf_External_Note
*) get_section_contents (section
, filedata
);
18091 if (! apply_relocations (filedata
, section
, (unsigned char *) pnotes
, length
, NULL
, NULL
))
18096 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
18099 if (pnotes
== NULL
)
18105 printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (filedata
, section
));
18107 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
18108 (unsigned long) offset
, (unsigned long) length
);
18110 /* NB: Some note sections may have alignment value of 0 or 1. gABI
18111 specifies that notes should be aligned to 4 bytes in 32-bit
18112 objects and to 8 bytes in 64-bit objects. As a Linux extension,
18113 we also support 4 byte alignment in 64-bit objects. If section
18114 alignment is less than 4, we treate alignment as 4 bytes. */
18117 else if (align
!= 4 && align
!= 8)
18119 warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
18124 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
18126 end
= (char *) pnotes
+ length
;
18127 while ((char *) external
< end
)
18129 Elf_Internal_Note inote
;
18132 char * temp
= NULL
;
18133 size_t data_remaining
= end
- (char *) external
;
18135 if (!is_ia64_vms (filedata
))
18137 /* PR binutils/15191
18138 Make sure that there is enough data to read. */
18139 min_notesz
= offsetof (Elf_External_Note
, name
);
18140 if (data_remaining
< min_notesz
)
18142 warn (ngettext ("Corrupt note: only %ld byte remains, "
18143 "not enough for a full note\n",
18144 "Corrupt note: only %ld bytes remain, "
18145 "not enough for a full note\n",
18147 (long) data_remaining
);
18150 data_remaining
-= min_notesz
;
18152 inote
.type
= BYTE_GET (external
->type
);
18153 inote
.namesz
= BYTE_GET (external
->namesz
);
18154 inote
.namedata
= external
->name
;
18155 inote
.descsz
= BYTE_GET (external
->descsz
);
18156 inote
.descdata
= ((char *) external
18157 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
18158 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
18159 next
= ((char *) external
18160 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
18164 Elf64_External_VMS_Note
*vms_external
;
18166 /* PR binutils/15191
18167 Make sure that there is enough data to read. */
18168 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
18169 if (data_remaining
< min_notesz
)
18171 warn (ngettext ("Corrupt note: only %ld byte remains, "
18172 "not enough for a full note\n",
18173 "Corrupt note: only %ld bytes remain, "
18174 "not enough for a full note\n",
18176 (long) data_remaining
);
18179 data_remaining
-= min_notesz
;
18181 vms_external
= (Elf64_External_VMS_Note
*) external
;
18182 inote
.type
= BYTE_GET (vms_external
->type
);
18183 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
18184 inote
.namedata
= vms_external
->name
;
18185 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
18186 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
18187 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
18188 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
18191 /* PR 17531: file: 3443835e. */
18192 /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
18193 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
18194 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
18195 || (size_t) (next
- inote
.descdata
) < inote
.descsz
18196 || ((size_t) (next
- inote
.descdata
)
18197 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
18199 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
18200 (unsigned long) ((char *) external
- (char *) pnotes
));
18201 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
18202 inote
.type
, inote
.namesz
, inote
.descsz
, (int) align
);
18206 external
= (Elf_External_Note
*) next
;
18208 /* Verify that name is null terminated. It appears that at least
18209 one version of Linux (RedHat 6.0) generates corefiles that don't
18210 comply with the ELF spec by failing to include the null byte in
18212 if (inote
.namedata
[inote
.namesz
- 1] != '\0')
18214 if ((size_t) (inote
.descdata
- inote
.namedata
) == inote
.namesz
)
18216 temp
= (char *) malloc (inote
.namesz
+ 1);
18219 error (_("Out of memory allocating space for inote name\n"));
18224 memcpy (temp
, inote
.namedata
, inote
.namesz
);
18225 inote
.namedata
= temp
;
18227 inote
.namedata
[inote
.namesz
] = 0;
18230 if (! process_note (& inote
, filedata
))
18246 process_corefile_note_segments (Filedata
* filedata
)
18248 Elf_Internal_Phdr
* segment
;
18250 bfd_boolean res
= TRUE
;
18252 if (! get_program_headers (filedata
))
18255 for (i
= 0, segment
= filedata
->program_headers
;
18256 i
< filedata
->file_header
.e_phnum
;
18259 if (segment
->p_type
== PT_NOTE
)
18260 if (! process_notes_at (filedata
, NULL
,
18261 (bfd_vma
) segment
->p_offset
,
18262 (bfd_vma
) segment
->p_filesz
,
18263 (bfd_vma
) segment
->p_align
))
18271 process_v850_notes (Filedata
* filedata
, bfd_vma offset
, bfd_vma length
)
18273 Elf_External_Note
* pnotes
;
18274 Elf_External_Note
* external
;
18276 bfd_boolean res
= TRUE
;
18281 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
18283 if (pnotes
== NULL
)
18287 end
= (char*) pnotes
+ length
;
18289 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
18290 (unsigned long) offset
, (unsigned long) length
);
18292 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
18294 Elf_External_Note
* next
;
18295 Elf_Internal_Note inote
;
18297 inote
.type
= BYTE_GET (external
->type
);
18298 inote
.namesz
= BYTE_GET (external
->namesz
);
18299 inote
.namedata
= external
->name
;
18300 inote
.descsz
= BYTE_GET (external
->descsz
);
18301 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
18302 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
18304 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
18306 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
18307 inote
.descdata
= inote
.namedata
;
18311 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
18313 if ( ((char *) next
> end
)
18314 || ((char *) next
< (char *) pnotes
))
18316 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
18317 (unsigned long) ((char *) external
- (char *) pnotes
));
18318 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
18319 inote
.type
, inote
.namesz
, inote
.descsz
);
18325 /* Prevent out-of-bounds indexing. */
18326 if ( inote
.namedata
+ inote
.namesz
> end
18327 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
18329 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
18330 (unsigned long) ((char *) external
- (char *) pnotes
));
18331 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
18332 inote
.type
, inote
.namesz
, inote
.descsz
);
18336 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
18338 if (! print_v850_note (& inote
))
18341 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
18342 inote
.namesz
, inote
.descsz
);
18352 process_note_sections (Filedata
* filedata
)
18354 Elf_Internal_Shdr
* section
;
18356 unsigned int n
= 0;
18357 bfd_boolean res
= TRUE
;
18359 for (i
= 0, section
= filedata
->section_headers
;
18360 i
< filedata
->file_header
.e_shnum
&& section
!= NULL
;
18363 if (section
->sh_type
== SHT_NOTE
)
18365 if (! process_notes_at (filedata
, section
,
18366 (bfd_vma
) section
->sh_offset
,
18367 (bfd_vma
) section
->sh_size
,
18368 (bfd_vma
) section
->sh_addralign
))
18373 if (( filedata
->file_header
.e_machine
== EM_V800
18374 || filedata
->file_header
.e_machine
== EM_V850
18375 || filedata
->file_header
.e_machine
== EM_CYGNUS_V850
)
18376 && section
->sh_type
== SHT_RENESAS_INFO
)
18378 if (! process_v850_notes (filedata
,
18379 (bfd_vma
) section
->sh_offset
,
18380 (bfd_vma
) section
->sh_size
))
18387 /* Try processing NOTE segments instead. */
18388 return process_corefile_note_segments (filedata
);
18394 process_notes (Filedata
* filedata
)
18396 /* If we have not been asked to display the notes then do nothing. */
18400 if (filedata
->file_header
.e_type
!= ET_CORE
)
18401 return process_note_sections (filedata
);
18403 /* No program headers means no NOTE segment. */
18404 if (filedata
->file_header
.e_phnum
> 0)
18405 return process_corefile_note_segments (filedata
);
18407 printf (_("No note segments present in the core file.\n"));
18411 static unsigned char *
18412 display_public_gnu_attributes (unsigned char * start
,
18413 const unsigned char * const end
)
18415 printf (_(" Unknown GNU attribute: %s\n"), start
);
18417 start
+= strnlen ((char *) start
, end
- start
);
18418 display_raw_attribute (start
, end
);
18420 return (unsigned char *) end
;
18423 static unsigned char *
18424 display_generic_attribute (unsigned char * start
,
18426 const unsigned char * const end
)
18429 return (unsigned char *) end
;
18431 return display_tag_value (tag
, start
, end
);
18435 process_arch_specific (Filedata
* filedata
)
18440 switch (filedata
->file_header
.e_machine
)
18443 case EM_ARC_COMPACT
:
18444 case EM_ARC_COMPACT2
:
18445 return process_attributes (filedata
, "ARC", SHT_ARC_ATTRIBUTES
,
18446 display_arc_attribute
,
18447 display_generic_attribute
);
18449 return process_attributes (filedata
, "aeabi", SHT_ARM_ATTRIBUTES
,
18450 display_arm_attribute
,
18451 display_generic_attribute
);
18454 case EM_MIPS_RS3_LE
:
18455 return process_mips_specific (filedata
);
18458 return process_attributes (filedata
, "mspabi", SHT_MSP430_ATTRIBUTES
,
18459 display_msp430x_attribute
,
18460 display_generic_attribute
);
18463 return process_nds32_specific (filedata
);
18467 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
18468 display_power_gnu_attribute
);
18472 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
18473 display_s390_gnu_attribute
);
18476 case EM_SPARC32PLUS
:
18478 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
18479 display_sparc_gnu_attribute
);
18482 return process_attributes (filedata
, "c6xabi", SHT_C6000_ATTRIBUTES
,
18483 display_tic6x_attribute
,
18484 display_generic_attribute
);
18487 return process_attributes (filedata
, "gnu", SHT_GNU_ATTRIBUTES
,
18488 display_public_gnu_attributes
,
18489 display_generic_attribute
);
18494 get_file_header (Filedata
* filedata
)
18496 /* Read in the identity array. */
18497 if (fread (filedata
->file_header
.e_ident
, EI_NIDENT
, 1, filedata
->handle
) != 1)
18500 /* Determine how to read the rest of the header. */
18501 switch (filedata
->file_header
.e_ident
[EI_DATA
])
18506 byte_get
= byte_get_little_endian
;
18507 byte_put
= byte_put_little_endian
;
18510 byte_get
= byte_get_big_endian
;
18511 byte_put
= byte_put_big_endian
;
18515 /* For now we only support 32 bit and 64 bit ELF files. */
18516 is_32bit_elf
= (filedata
->file_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
18518 /* Read in the rest of the header. */
18521 Elf32_External_Ehdr ehdr32
;
18523 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
18526 filedata
->file_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
18527 filedata
->file_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
18528 filedata
->file_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
18529 filedata
->file_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
18530 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
18531 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
18532 filedata
->file_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
18533 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
18534 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
18535 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
18536 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
18537 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
18538 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
18542 Elf64_External_Ehdr ehdr64
;
18544 /* If we have been compiled with sizeof (bfd_vma) == 4, then
18545 we will not be able to cope with the 64bit data found in
18546 64 ELF files. Detect this now and abort before we start
18547 overwriting things. */
18548 if (sizeof (bfd_vma
) < 8)
18550 error (_("This instance of readelf has been built without support for a\n\
18551 64 bit data type and so it cannot read 64 bit ELF files.\n"));
18555 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
18558 filedata
->file_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
18559 filedata
->file_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
18560 filedata
->file_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
18561 filedata
->file_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
18562 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
18563 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
18564 filedata
->file_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
18565 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
18566 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
18567 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
18568 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
18569 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
18570 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
18573 if (filedata
->file_header
.e_shoff
)
18575 /* There may be some extensions in the first section header. Don't
18576 bomb if we can't read it. */
18578 get_32bit_section_headers (filedata
, TRUE
);
18580 get_64bit_section_headers (filedata
, TRUE
);
18587 close_file (Filedata
* filedata
)
18591 if (filedata
->handle
)
18592 fclose (filedata
->handle
);
18598 close_debug_file (void * data
)
18600 close_file ((Filedata
*) data
);
18604 open_file (const char * pathname
)
18606 struct stat statbuf
;
18607 Filedata
* filedata
= NULL
;
18609 if (stat (pathname
, & statbuf
) < 0
18610 || ! S_ISREG (statbuf
.st_mode
))
18613 filedata
= calloc (1, sizeof * filedata
);
18614 if (filedata
== NULL
)
18617 filedata
->handle
= fopen (pathname
, "rb");
18618 if (filedata
->handle
== NULL
)
18621 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
18622 filedata
->file_name
= pathname
;
18624 if (! get_file_header (filedata
))
18627 if (filedata
->file_header
.e_shoff
)
18631 /* Read the section headers again, this time for real. */
18633 res
= get_32bit_section_headers (filedata
, FALSE
);
18635 res
= get_64bit_section_headers (filedata
, FALSE
);
18646 if (filedata
->handle
)
18647 fclose (filedata
->handle
);
18654 open_debug_file (const char * pathname
)
18656 return open_file (pathname
);
18659 /* Process one ELF object file according to the command line options.
18660 This file may actually be stored in an archive. The file is
18661 positioned at the start of the ELF object. Returns TRUE if no
18662 problems were encountered, FALSE otherwise. */
18665 process_object (Filedata
* filedata
)
18667 Filedata
* separates
;
18669 bfd_boolean res
= TRUE
;
18671 if (! get_file_header (filedata
))
18673 error (_("%s: Failed to read file header\n"), filedata
->file_name
);
18677 /* Initialise per file variables. */
18678 for (i
= ARRAY_SIZE (version_info
); i
--;)
18679 version_info
[i
] = 0;
18681 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
18682 dynamic_info
[i
] = 0;
18683 dynamic_info_DT_GNU_HASH
= 0;
18685 /* Process the file. */
18687 printf (_("\nFile: %s\n"), filedata
->file_name
);
18689 /* Initialise the dump_sects array from the cmdline_dump_sects array.
18690 Note we do this even if cmdline_dump_sects is empty because we
18691 must make sure that the dump_sets array is zeroed out before each
18692 object file is processed. */
18693 if (filedata
->num_dump_sects
> cmdline
.num_dump_sects
)
18694 memset (filedata
->dump_sects
, 0, filedata
->num_dump_sects
* sizeof (* filedata
->dump_sects
));
18696 if (cmdline
.num_dump_sects
> 0)
18698 if (filedata
->num_dump_sects
== 0)
18699 /* A sneaky way of allocating the dump_sects array. */
18700 request_dump_bynumber (filedata
, cmdline
.num_dump_sects
, 0);
18702 assert (filedata
->num_dump_sects
>= cmdline
.num_dump_sects
);
18703 memcpy (filedata
->dump_sects
, cmdline
.dump_sects
,
18704 cmdline
.num_dump_sects
* sizeof (* filedata
->dump_sects
));
18707 if (! process_file_header (filedata
))
18710 if (! process_section_headers (filedata
))
18712 /* Without loaded section headers we cannot process lots of things. */
18713 do_unwind
= do_version
= do_dump
= do_arch
= FALSE
;
18715 if (! do_using_dynamic
)
18716 do_syms
= do_dyn_syms
= do_reloc
= FALSE
;
18719 if (! process_section_groups (filedata
))
18720 /* Without loaded section groups we cannot process unwind. */
18723 if (process_program_headers (filedata
))
18724 process_dynamic_section (filedata
);
18728 if (! process_relocs (filedata
))
18731 if (! process_unwind (filedata
))
18734 if (! process_symbol_table (filedata
))
18737 if (! process_syminfo (filedata
))
18740 if (! process_version_sections (filedata
))
18743 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
)
18744 separates
= load_separate_debug_file (filedata
, filedata
->file_name
);
18748 if (! process_section_contents (filedata
))
18753 if (! process_section_headers (separates
))
18755 else if (! process_section_contents (separates
))
18759 if (! process_notes (filedata
))
18762 if (! process_gnu_liblist (filedata
))
18765 if (! process_arch_specific (filedata
))
18768 free (filedata
->program_headers
);
18769 filedata
->program_headers
= NULL
;
18771 free (filedata
->section_headers
);
18772 filedata
->section_headers
= NULL
;
18774 free (filedata
->string_table
);
18775 filedata
->string_table
= NULL
;
18776 filedata
->string_table_length
= 0;
18778 if (dynamic_strings
)
18780 free (dynamic_strings
);
18781 dynamic_strings
= NULL
;
18782 dynamic_strings_length
= 0;
18785 if (dynamic_symbols
)
18787 free (dynamic_symbols
);
18788 dynamic_symbols
= NULL
;
18789 num_dynamic_syms
= 0;
18792 if (dynamic_syminfo
)
18794 free (dynamic_syminfo
);
18795 dynamic_syminfo
= NULL
;
18798 if (dynamic_section
)
18800 free (dynamic_section
);
18801 dynamic_section
= NULL
;
18804 if (section_headers_groups
)
18806 free (section_headers_groups
);
18807 section_headers_groups
= NULL
;
18810 if (section_groups
)
18812 struct group_list
* g
;
18813 struct group_list
* next
;
18815 for (i
= 0; i
< group_count
; i
++)
18817 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
18824 free (section_groups
);
18825 section_groups
= NULL
;
18828 free_debug_memory ();
18833 /* Process an ELF archive.
18834 On entry the file is positioned just after the ARMAG string.
18835 Returns TRUE upon success, FALSE otherwise. */
18838 process_archive (Filedata
* filedata
, bfd_boolean is_thin_archive
)
18840 struct archive_info arch
;
18841 struct archive_info nested_arch
;
18843 bfd_boolean ret
= TRUE
;
18847 /* The ARCH structure is used to hold information about this archive. */
18848 arch
.file_name
= NULL
;
18850 arch
.index_array
= NULL
;
18851 arch
.sym_table
= NULL
;
18852 arch
.longnames
= NULL
;
18854 /* The NESTED_ARCH structure is used as a single-item cache of information
18855 about a nested archive (when members of a thin archive reside within
18856 another regular archive file). */
18857 nested_arch
.file_name
= NULL
;
18858 nested_arch
.file
= NULL
;
18859 nested_arch
.index_array
= NULL
;
18860 nested_arch
.sym_table
= NULL
;
18861 nested_arch
.longnames
= NULL
;
18863 if (setup_archive (&arch
, filedata
->file_name
, filedata
->handle
,
18864 is_thin_archive
, do_archive_index
) != 0)
18870 if (do_archive_index
)
18872 if (arch
.sym_table
== NULL
)
18873 error (_("%s: unable to dump the index as none was found\n"), filedata
->file_name
);
18876 unsigned long i
, l
;
18877 unsigned long current_pos
;
18879 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
18880 filedata
->file_name
, (unsigned long) arch
.index_num
, arch
.sym_size
);
18882 current_pos
= ftell (filedata
->handle
);
18884 for (i
= l
= 0; i
< arch
.index_num
; i
++)
18886 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
18888 char * member_name
;
18890 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
18892 if (member_name
!= NULL
)
18894 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
18896 if (qualified_name
!= NULL
)
18898 printf (_("Contents of binary %s at offset "), qualified_name
);
18899 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
18901 free (qualified_name
);
18906 if (l
>= arch
.sym_size
)
18908 error (_("%s: end of the symbol table reached before the end of the index\n"),
18909 filedata
->file_name
);
18913 /* PR 17531: file: 0b6630b2. */
18914 printf ("\t%.*s\n", (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
18915 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
18918 if (arch
.uses_64bit_indicies
)
18923 if (l
< arch
.sym_size
)
18925 error (ngettext ("%s: %ld byte remains in the symbol table, "
18926 "but without corresponding entries in "
18927 "the index table\n",
18928 "%s: %ld bytes remain in the symbol table, "
18929 "but without corresponding entries in "
18930 "the index table\n",
18931 arch
.sym_size
- l
),
18932 filedata
->file_name
, arch
.sym_size
- l
);
18936 if (fseek (filedata
->handle
, current_pos
, SEEK_SET
) != 0)
18938 error (_("%s: failed to seek back to start of object files in the archive\n"),
18939 filedata
->file_name
);
18945 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
18946 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
18947 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
18948 && !do_section_groups
&& !do_dyn_syms
)
18950 ret
= TRUE
; /* Archive index only. */
18959 char * qualified_name
;
18961 /* Read the next archive header. */
18962 if (fseek (filedata
->handle
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
18964 error (_("%s: failed to seek to next archive header\n"), filedata
->file_name
);
18967 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, filedata
->handle
);
18968 if (got
!= sizeof arch
.arhdr
)
18972 error (_("%s: failed to read archive header\n"), filedata
->file_name
);
18976 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
18978 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
18983 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
18985 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
18986 if (archive_file_size
& 01)
18987 ++archive_file_size
;
18989 name
= get_archive_member_name (&arch
, &nested_arch
);
18992 error (_("%s: bad archive file name\n"), filedata
->file_name
);
18996 namelen
= strlen (name
);
18998 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
18999 if (qualified_name
== NULL
)
19001 error (_("%s: bad archive file name\n"), filedata
->file_name
);
19006 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
19008 /* This is a proxy for an external member of a thin archive. */
19009 Filedata
* member_filedata
;
19010 char * member_file_name
= adjust_relative_path
19011 (filedata
->file_name
, name
, namelen
);
19013 if (member_file_name
== NULL
)
19019 member_filedata
= open_file (member_file_name
);
19020 if (member_filedata
== NULL
)
19022 error (_("Input file '%s' is not readable.\n"), member_file_name
);
19023 free (member_file_name
);
19028 archive_file_offset
= arch
.nested_member_origin
;
19029 member_filedata
->file_name
= qualified_name
;
19031 if (! process_object (member_filedata
))
19034 close_file (member_filedata
);
19035 free (member_file_name
);
19037 else if (is_thin_archive
)
19039 Filedata thin_filedata
;
19041 memset (&thin_filedata
, 0, sizeof (thin_filedata
));
19043 /* PR 15140: Allow for corrupt thin archives. */
19044 if (nested_arch
.file
== NULL
)
19046 error (_("%s: contains corrupt thin archive: %s\n"),
19047 filedata
->file_name
, name
);
19052 /* This is a proxy for a member of a nested archive. */
19053 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
19055 /* The nested archive file will have been opened and setup by
19056 get_archive_member_name. */
19057 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
19059 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
19064 thin_filedata
.handle
= nested_arch
.file
;
19065 thin_filedata
.file_name
= qualified_name
;
19067 if (! process_object (& thin_filedata
))
19072 archive_file_offset
= arch
.next_arhdr_offset
;
19073 arch
.next_arhdr_offset
+= archive_file_size
;
19075 filedata
->file_name
= qualified_name
;
19076 if (! process_object (filedata
))
19080 if (filedata
->dump_sects
!= NULL
)
19082 free (filedata
->dump_sects
);
19083 filedata
->dump_sects
= NULL
;
19084 filedata
->num_dump_sects
= 0;
19087 free (qualified_name
);
19091 if (nested_arch
.file
!= NULL
)
19092 fclose (nested_arch
.file
);
19093 release_archive (&nested_arch
);
19094 release_archive (&arch
);
19100 process_file (char * file_name
)
19102 Filedata
* filedata
= NULL
;
19103 struct stat statbuf
;
19104 char armag
[SARMAG
];
19105 bfd_boolean ret
= TRUE
;
19107 if (stat (file_name
, &statbuf
) < 0)
19109 if (errno
== ENOENT
)
19110 error (_("'%s': No such file\n"), file_name
);
19112 error (_("Could not locate '%s'. System error message: %s\n"),
19113 file_name
, strerror (errno
));
19117 if (! S_ISREG (statbuf
.st_mode
))
19119 error (_("'%s' is not an ordinary file\n"), file_name
);
19123 filedata
= calloc (1, sizeof * filedata
);
19124 if (filedata
== NULL
)
19126 error (_("Out of memory allocating file data structure\n"));
19130 filedata
->file_name
= file_name
;
19131 filedata
->handle
= fopen (file_name
, "rb");
19132 if (filedata
->handle
== NULL
)
19134 error (_("Input file '%s' is not readable.\n"), file_name
);
19139 if (fread (armag
, SARMAG
, 1, filedata
->handle
) != 1)
19141 error (_("%s: Failed to read file's magic number\n"), file_name
);
19142 fclose (filedata
->handle
);
19147 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
19149 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
19151 if (! process_archive (filedata
, FALSE
))
19154 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
19156 if ( ! process_archive (filedata
, TRUE
))
19161 if (do_archive_index
)
19162 error (_("File %s is not an archive so its index cannot be displayed.\n"),
19165 rewind (filedata
->handle
);
19166 archive_file_size
= archive_file_offset
= 0;
19168 if (! process_object (filedata
))
19172 fclose (filedata
->handle
);
19178 #ifdef SUPPORT_DISASSEMBLY
19179 /* Needed by the i386 disassembler. For extra credit, someone could
19180 fix this so that we insert symbolic addresses here, esp for GOT/PLT
19184 print_address (unsigned int addr
, FILE * outfile
)
19186 fprintf (outfile
,"0x%8.8x", addr
);
19189 /* Needed by the i386 disassembler. */
19192 db_task_printsym (unsigned int addr
)
19194 print_address (addr
, stderr
);
19199 main (int argc
, char ** argv
)
19203 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
19204 setlocale (LC_MESSAGES
, "");
19206 #if defined (HAVE_SETLOCALE)
19207 setlocale (LC_CTYPE
, "");
19209 bindtextdomain (PACKAGE
, LOCALEDIR
);
19210 textdomain (PACKAGE
);
19212 expandargv (&argc
, &argv
);
19214 cmdline
.file_name
= "<cmdline>";
19215 parse_args (& cmdline
, argc
, argv
);
19217 if (optind
< (argc
- 1))
19219 else if (optind
>= argc
)
19221 warn (_("Nothing to do.\n"));
19226 while (optind
< argc
)
19227 if (! process_file (argv
[optind
++]))
19230 if (cmdline
.dump_sects
!= NULL
)
19231 free (cmdline
.dump_sects
);
19233 return err
? EXIT_FAILURE
: EXIT_SUCCESS
;