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"
134 #include "elf/nios2.h"
135 #include "elf/or1k.h"
138 #include "elf/ppc64.h"
140 #include "elf/riscv.h"
141 #include "elf/rl78.h"
143 #include "elf/s390.h"
144 #include "elf/score.h"
146 #include "elf/sparc.h"
148 #include "elf/tic6x.h"
149 #include "elf/tilegx.h"
150 #include "elf/tilepro.h"
151 #include "elf/v850.h"
153 #include "elf/visium.h"
154 #include "elf/wasm32.h"
155 #include "elf/x86-64.h"
156 #include "elf/xc16x.h"
157 #include "elf/xgate.h"
158 #include "elf/xstormy16.h"
159 #include "elf/xtensa.h"
162 #include "libiberty.h"
163 #include "safe-ctype.h"
164 #include "filenames.h"
167 #define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
170 typedef struct elf_section_list
172 Elf_Internal_Shdr
* hdr
;
173 struct elf_section_list
* next
;
176 /* Flag bits indicating particular types of dump. */
177 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
178 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
179 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
180 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
181 #define RELOC_DUMP (1 << 4) /* The -R command line switch. */
183 typedef unsigned char dump_type
;
185 /* A linked list of the section names for which dumps were requested. */
186 struct dump_list_entry
190 struct dump_list_entry
* next
;
193 typedef struct filedata
195 const char * file_name
;
197 bfd_size_type file_size
;
198 Elf_Internal_Ehdr file_header
;
199 Elf_Internal_Shdr
* section_headers
;
200 Elf_Internal_Phdr
* program_headers
;
202 unsigned long string_table_length
;
203 /* A dynamic array of flags indicating for which sections a dump of
204 some kind has been requested. It is reset on a per-object file
205 basis and then initialised from the cmdline_dump_sects array,
206 the results of interpreting the -w switch, and the
207 dump_sects_byname list. */
208 dump_type
* dump_sects
;
209 unsigned int num_dump_sects
;
212 char * program_name
= "readelf";
214 static unsigned long archive_file_offset
;
215 static unsigned long archive_file_size
;
216 static unsigned long dynamic_addr
;
217 static bfd_size_type dynamic_size
;
218 static size_t dynamic_nent
;
219 static char * dynamic_strings
;
220 static unsigned long dynamic_strings_length
;
221 static unsigned long num_dynamic_syms
;
222 static Elf_Internal_Sym
* dynamic_symbols
;
223 static Elf_Internal_Syminfo
* dynamic_syminfo
;
224 static unsigned long dynamic_syminfo_offset
;
225 static unsigned int dynamic_syminfo_nent
;
226 static char program_interpreter
[PATH_MAX
];
227 static bfd_vma dynamic_info
[DT_ENCODING
];
228 static bfd_vma dynamic_info_DT_GNU_HASH
;
229 static bfd_vma version_info
[16];
230 static Elf_Internal_Dyn
* dynamic_section
;
231 static elf_section_list
* symtab_shndx_list
;
232 static bfd_boolean show_name
= FALSE
;
233 static bfd_boolean do_dynamic
= FALSE
;
234 static bfd_boolean do_syms
= FALSE
;
235 static bfd_boolean do_dyn_syms
= FALSE
;
236 static bfd_boolean do_reloc
= FALSE
;
237 static bfd_boolean do_sections
= FALSE
;
238 static bfd_boolean do_section_groups
= FALSE
;
239 static bfd_boolean do_section_details
= FALSE
;
240 static bfd_boolean do_segments
= FALSE
;
241 static bfd_boolean do_unwind
= FALSE
;
242 static bfd_boolean do_using_dynamic
= FALSE
;
243 static bfd_boolean do_header
= FALSE
;
244 static bfd_boolean do_dump
= FALSE
;
245 static bfd_boolean do_version
= FALSE
;
246 static bfd_boolean do_histogram
= FALSE
;
247 static bfd_boolean do_debugging
= FALSE
;
248 static bfd_boolean do_arch
= FALSE
;
249 static bfd_boolean do_notes
= FALSE
;
250 static bfd_boolean do_archive_index
= FALSE
;
251 static bfd_boolean is_32bit_elf
= FALSE
;
252 static bfd_boolean decompress_dumps
= FALSE
;
256 struct group_list
* next
;
257 unsigned int section_index
;
262 struct group_list
* root
;
263 unsigned int group_index
;
266 static size_t group_count
;
267 static struct group
* section_groups
;
268 static struct group
** section_headers_groups
;
270 /* A dynamic array of flags indicating for which sections a dump
271 has been requested via command line switches. */
272 static Filedata cmdline
;
274 static struct dump_list_entry
* dump_sects_byname
;
276 /* How to print a vma value. */
277 typedef enum print_mode
289 /* Versioned symbol info. */
290 enum versioned_symbol_info
297 static const char * get_symbol_version_string
298 (Filedata
*, bfd_boolean
, const char *, unsigned long, unsigned,
299 Elf_Internal_Sym
*, enum versioned_symbol_info
*, unsigned short *);
303 #define SECTION_NAME(X) \
304 ((X) == NULL ? _("<none>") \
305 : filedata->string_table == NULL ? _("<no-strings>") \
306 : ((X)->sh_name >= filedata->string_table_length ? _("<corrupt>") \
307 : filedata->string_table + (X)->sh_name))
309 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
311 #define GET_ELF_SYMBOLS(file, section, sym_count) \
312 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
313 : get_64bit_elf_symbols (file, section, sym_count))
315 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
316 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
317 already been called and verified that the string exists. */
318 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
320 #define REMOVE_ARCH_BITS(ADDR) \
323 if (filedata->file_header.e_machine == EM_ARM) \
328 /* Print a BFD_VMA to an internal buffer, for use in error messages.
329 BFD_FMA_FMT can't be used in translated strings. */
332 bfd_vmatoa (char *fmtch
, bfd_vma value
)
334 /* bfd_vmatoa is used more then once in a printf call for output.
335 Cycle through an array of buffers. */
336 static int buf_pos
= 0;
337 static struct bfd_vmatoa_buf
344 ret
= buf
[buf_pos
++].place
;
345 buf_pos
%= ARRAY_SIZE (buf
);
347 sprintf (fmt
, "%%%s%s", BFD_VMA_FMT
, fmtch
);
348 snprintf (ret
, sizeof (buf
[0].place
), fmt
, value
);
352 /* Retrieve NMEMB structures, each SIZE bytes long from FILEDATA starting at
353 OFFSET + the offset of the current archive member, if we are examining an
354 archive. Put the retrieved data into VAR, if it is not NULL. Otherwise
355 allocate a buffer using malloc and fill that. In either case return the
356 pointer to the start of the retrieved data or NULL if something went wrong.
357 If something does go wrong and REASON is not NULL then emit an error
358 message using REASON as part of the context. */
361 get_data (void * var
,
363 unsigned long offset
,
369 bfd_size_type amt
= size
* nmemb
;
371 if (size
== 0 || nmemb
== 0)
374 /* If the size_t type is smaller than the bfd_size_type, eg because
375 you are building a 32-bit tool on a 64-bit host, then make sure
376 that when the sizes are cast to (size_t) no information is lost. */
377 if (sizeof (size_t) < sizeof (bfd_size_type
)
378 && ( (bfd_size_type
) ((size_t) size
) != size
379 || (bfd_size_type
) ((size_t) nmemb
) != nmemb
))
382 error (_("Size truncation prevents reading %s"
383 " elements of size %s for %s\n"),
384 bfd_vmatoa ("u", nmemb
), bfd_vmatoa ("u", size
), reason
);
388 /* Check for size overflow. */
392 error (_("Size overflow prevents reading %s"
393 " elements of size %s for %s\n"),
394 bfd_vmatoa ("u", nmemb
), bfd_vmatoa ("u", size
), reason
);
398 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
399 attempting to allocate memory when the read is bound to fail. */
400 if (amt
> filedata
->file_size
401 || offset
+ archive_file_offset
+ amt
> filedata
->file_size
)
404 error (_("Reading %s bytes extends past end of file for %s\n"),
405 bfd_vmatoa ("u", amt
), reason
);
409 if (fseek (filedata
->handle
, archive_file_offset
+ offset
, SEEK_SET
))
412 error (_("Unable to seek to 0x%lx for %s\n"),
413 archive_file_offset
+ offset
, reason
);
420 /* Check for overflow. */
421 if (nmemb
< (~(bfd_size_type
) 0 - 1) / size
)
422 /* + 1 so that we can '\0' terminate invalid string table sections. */
423 mvar
= malloc ((size_t) amt
+ 1);
428 error (_("Out of memory allocating %s bytes for %s\n"),
429 bfd_vmatoa ("u", amt
), reason
);
433 ((char *) mvar
)[amt
] = '\0';
436 if (fread (mvar
, (size_t) size
, (size_t) nmemb
, filedata
->handle
) != nmemb
)
439 error (_("Unable to read in %s bytes of %s\n"),
440 bfd_vmatoa ("u", amt
), reason
);
449 /* Print a VMA value in the MODE specified.
450 Returns the number of characters displayed. */
453 print_vma (bfd_vma vma
, print_mode mode
)
465 return nc
+ printf ("%8.8" BFD_VMA_FMT
"x", vma
);
472 return printf ("%5" BFD_VMA_FMT
"d", vma
);
478 return nc
+ printf ("%" BFD_VMA_FMT
"x", vma
);
481 return printf ("%" BFD_VMA_FMT
"d", vma
);
484 return printf ("%" BFD_VMA_FMT
"u", vma
);
487 /* FIXME: Report unrecognised mode ? */
492 /* Display a symbol on stdout. Handles the display of control characters and
493 multibye characters (assuming the host environment supports them).
495 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
497 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
498 padding as necessary.
500 Returns the number of emitted characters. */
503 print_symbol (signed int width
, const char *symbol
)
505 bfd_boolean extra_padding
= FALSE
;
506 signed int num_printed
= 0;
507 #ifdef HAVE_MBSTATE_T
510 unsigned int width_remaining
;
514 /* Keep the width positive. This helps the code below. */
516 extra_padding
= TRUE
;
522 /* Set the remaining width to a very large value.
523 This simplifies the code below. */
524 width_remaining
= INT_MAX
;
526 width_remaining
= width
;
528 #ifdef HAVE_MBSTATE_T
529 /* Initialise the multibyte conversion state. */
530 memset (& state
, 0, sizeof (state
));
533 while (width_remaining
)
536 const char c
= *symbol
++;
541 /* Do not print control characters directly as they can affect terminal
542 settings. Such characters usually appear in the names generated
543 by the assembler for local labels. */
546 if (width_remaining
< 2)
549 printf ("^%c", c
+ 0x40);
550 width_remaining
-= 2;
553 else if (ISPRINT (c
))
561 #ifdef HAVE_MBSTATE_T
564 /* Let printf do the hard work of displaying multibyte characters. */
565 printf ("%.1s", symbol
- 1);
569 #ifdef HAVE_MBSTATE_T
570 /* Try to find out how many bytes made up the character that was
571 just printed. Advance the symbol pointer past the bytes that
573 n
= mbrtowc (& w
, symbol
- 1, MB_CUR_MAX
, & state
);
577 if (n
!= (size_t) -1 && n
!= (size_t) -2 && n
> 0)
582 if (extra_padding
&& num_printed
< width
)
584 /* Fill in the remaining spaces. */
585 printf ("%-*s", width
- num_printed
, " ");
592 /* Returns a pointer to a static buffer containing a printable version of
593 the given section's name. Like print_symbol, except that it does not try
594 to print multibyte characters, it just interprets them as hex values. */
597 printable_section_name (Filedata
* filedata
, const Elf_Internal_Shdr
* sec
)
599 #define MAX_PRINT_SEC_NAME_LEN 128
600 static char sec_name_buf
[MAX_PRINT_SEC_NAME_LEN
+ 1];
601 const char * name
= SECTION_NAME (sec
);
602 char * buf
= sec_name_buf
;
604 unsigned int remaining
= MAX_PRINT_SEC_NAME_LEN
;
606 while ((c
= * name
++) != 0)
617 else if (ISPRINT (c
))
624 static char hex
[17] = "0123456789ABCDEF";
629 * buf
++ = hex
[(c
& 0xf0) >> 4];
630 * buf
++ = hex
[c
& 0x0f];
644 printable_section_name_from_index (Filedata
* filedata
, unsigned long ndx
)
646 if (ndx
>= filedata
->file_header
.e_shnum
)
647 return _("<corrupt>");
649 return printable_section_name (filedata
, filedata
->section_headers
+ ndx
);
652 /* Return a pointer to section NAME, or NULL if no such section exists. */
654 static Elf_Internal_Shdr
*
655 find_section (Filedata
* filedata
, const char * name
)
659 if (filedata
->section_headers
== NULL
)
662 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
663 if (streq (SECTION_NAME (filedata
->section_headers
+ i
), name
))
664 return filedata
->section_headers
+ i
;
669 /* Return a pointer to a section containing ADDR, or NULL if no such
672 static Elf_Internal_Shdr
*
673 find_section_by_address (Filedata
* filedata
, bfd_vma addr
)
677 if (filedata
->section_headers
== NULL
)
680 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
682 Elf_Internal_Shdr
*sec
= filedata
->section_headers
+ i
;
684 if (addr
>= sec
->sh_addr
&& addr
< sec
->sh_addr
+ sec
->sh_size
)
691 static Elf_Internal_Shdr
*
692 find_section_by_type (Filedata
* filedata
, unsigned int type
)
696 if (filedata
->section_headers
== NULL
)
699 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
701 Elf_Internal_Shdr
*sec
= filedata
->section_headers
+ i
;
703 if (sec
->sh_type
== type
)
710 /* Return a pointer to section NAME, or NULL if no such section exists,
711 restricted to the list of sections given in SET. */
713 static Elf_Internal_Shdr
*
714 find_section_in_set (Filedata
* filedata
, const char * name
, unsigned int * set
)
718 if (filedata
->section_headers
== NULL
)
723 while ((i
= *set
++) > 0)
725 /* See PR 21156 for a reproducer. */
726 if (i
>= filedata
->file_header
.e_shnum
)
727 continue; /* FIXME: Should we issue an error message ? */
729 if (streq (SECTION_NAME (filedata
->section_headers
+ i
), name
))
730 return filedata
->section_headers
+ i
;
734 return find_section (filedata
, name
);
737 /* Read an unsigned LEB128 encoded value from DATA.
738 Set *LENGTH_RETURN to the number of bytes read. */
740 static inline unsigned long
741 read_uleb128 (unsigned char * data
,
742 unsigned int * length_return
,
743 const unsigned char * const end
)
745 return read_leb128 (data
, length_return
, FALSE
, end
);
748 /* Return TRUE if the current file is for IA-64 machine and OpenVMS ABI.
749 This OS has so many departures from the ELF standard that we test it at
752 static inline bfd_boolean
753 is_ia64_vms (Filedata
* filedata
)
755 return filedata
->file_header
.e_machine
== EM_IA_64
756 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
;
759 /* Guess the relocation size commonly used by the specific machines. */
762 guess_is_rela (unsigned int e_machine
)
766 /* Targets that use REL relocations. */
781 /* Targets that use RELA relocations. */
785 case EM_ADAPTEVA_EPIPHANY
:
787 case EM_ALTERA_NIOS2
:
790 case EM_ARC_COMPACT2
:
810 case EM_LATTICEMICO32
:
819 case EM_CYGNUS_MN10200
:
821 case EM_CYGNUS_MN10300
:
857 case EM_MICROBLAZE_OLD
:
879 warn (_("Don't know about relocations on this machine architecture\n"));
884 /* Load RELA type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
885 Returns TRUE upon success, FALSE otherwise. If successful then a
886 pointer to a malloc'ed buffer containing the relocs is placed in *RELASP,
887 and the number of relocs loaded is placed in *NRELASP. It is the caller's
888 responsibility to free the allocated buffer. */
891 slurp_rela_relocs (Filedata
* filedata
,
892 unsigned long rel_offset
,
893 unsigned long rel_size
,
894 Elf_Internal_Rela
** relasp
,
895 unsigned long * nrelasp
)
897 Elf_Internal_Rela
* relas
;
903 Elf32_External_Rela
* erelas
;
905 erelas
= (Elf32_External_Rela
*) get_data (NULL
, filedata
, rel_offset
, 1,
906 rel_size
, _("32-bit relocation data"));
910 nrelas
= rel_size
/ sizeof (Elf32_External_Rela
);
912 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
913 sizeof (Elf_Internal_Rela
));
918 error (_("out of memory parsing relocs\n"));
922 for (i
= 0; i
< nrelas
; i
++)
924 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
925 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
926 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
933 Elf64_External_Rela
* erelas
;
935 erelas
= (Elf64_External_Rela
*) get_data (NULL
, filedata
, rel_offset
, 1,
936 rel_size
, _("64-bit relocation data"));
940 nrelas
= rel_size
/ sizeof (Elf64_External_Rela
);
942 relas
= (Elf_Internal_Rela
*) cmalloc (nrelas
,
943 sizeof (Elf_Internal_Rela
));
948 error (_("out of memory parsing relocs\n"));
952 for (i
= 0; i
< nrelas
; i
++)
954 relas
[i
].r_offset
= BYTE_GET (erelas
[i
].r_offset
);
955 relas
[i
].r_info
= BYTE_GET (erelas
[i
].r_info
);
956 relas
[i
].r_addend
= BYTE_GET_SIGNED (erelas
[i
].r_addend
);
958 /* The #ifdef BFD64 below is to prevent a compile time
959 warning. We know that if we do not have a 64 bit data
960 type that we will never execute this code anyway. */
962 if (filedata
->file_header
.e_machine
== EM_MIPS
963 && filedata
->file_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
965 /* In little-endian objects, r_info isn't really a
966 64-bit little-endian value: it has a 32-bit
967 little-endian symbol index followed by four
968 individual byte fields. Reorder INFO
970 bfd_vma inf
= relas
[i
].r_info
;
971 inf
= (((inf
& 0xffffffff) << 32)
972 | ((inf
>> 56) & 0xff)
973 | ((inf
>> 40) & 0xff00)
974 | ((inf
>> 24) & 0xff0000)
975 | ((inf
>> 8) & 0xff000000));
976 relas
[i
].r_info
= inf
;
989 /* Load REL type relocations from FILEDATA at REL_OFFSET extending for REL_SIZE bytes.
990 Returns TRUE upon success, FALSE otherwise. If successful then a
991 pointer to a malloc'ed buffer containing the relocs is placed in *RELSP,
992 and the number of relocs loaded is placed in *NRELSP. It is the caller's
993 responsibility to free the allocated buffer. */
996 slurp_rel_relocs (Filedata
* filedata
,
997 unsigned long rel_offset
,
998 unsigned long rel_size
,
999 Elf_Internal_Rela
** relsp
,
1000 unsigned long * nrelsp
)
1002 Elf_Internal_Rela
* rels
;
1008 Elf32_External_Rel
* erels
;
1010 erels
= (Elf32_External_Rel
*) get_data (NULL
, filedata
, rel_offset
, 1,
1011 rel_size
, _("32-bit relocation data"));
1015 nrels
= rel_size
/ sizeof (Elf32_External_Rel
);
1017 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
1022 error (_("out of memory parsing relocs\n"));
1026 for (i
= 0; i
< nrels
; i
++)
1028 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
1029 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
1030 rels
[i
].r_addend
= 0;
1037 Elf64_External_Rel
* erels
;
1039 erels
= (Elf64_External_Rel
*) get_data (NULL
, filedata
, rel_offset
, 1,
1040 rel_size
, _("64-bit relocation data"));
1044 nrels
= rel_size
/ sizeof (Elf64_External_Rel
);
1046 rels
= (Elf_Internal_Rela
*) cmalloc (nrels
, sizeof (Elf_Internal_Rela
));
1051 error (_("out of memory parsing relocs\n"));
1055 for (i
= 0; i
< nrels
; i
++)
1057 rels
[i
].r_offset
= BYTE_GET (erels
[i
].r_offset
);
1058 rels
[i
].r_info
= BYTE_GET (erels
[i
].r_info
);
1059 rels
[i
].r_addend
= 0;
1061 /* The #ifdef BFD64 below is to prevent a compile time
1062 warning. We know that if we do not have a 64 bit data
1063 type that we will never execute this code anyway. */
1065 if (filedata
->file_header
.e_machine
== EM_MIPS
1066 && filedata
->file_header
.e_ident
[EI_DATA
] != ELFDATA2MSB
)
1068 /* In little-endian objects, r_info isn't really a
1069 64-bit little-endian value: it has a 32-bit
1070 little-endian symbol index followed by four
1071 individual byte fields. Reorder INFO
1073 bfd_vma inf
= rels
[i
].r_info
;
1074 inf
= (((inf
& 0xffffffff) << 32)
1075 | ((inf
>> 56) & 0xff)
1076 | ((inf
>> 40) & 0xff00)
1077 | ((inf
>> 24) & 0xff0000)
1078 | ((inf
>> 8) & 0xff000000));
1079 rels
[i
].r_info
= inf
;
1092 /* Returns the reloc type extracted from the reloc info field. */
1095 get_reloc_type (Filedata
* filedata
, bfd_vma reloc_info
)
1098 return ELF32_R_TYPE (reloc_info
);
1100 switch (filedata
->file_header
.e_machine
)
1103 /* Note: We assume that reloc_info has already been adjusted for us. */
1104 return ELF64_MIPS_R_TYPE (reloc_info
);
1107 return ELF64_R_TYPE_ID (reloc_info
);
1110 return ELF64_R_TYPE (reloc_info
);
1114 /* Return the symbol index extracted from the reloc info field. */
1117 get_reloc_symindex (bfd_vma reloc_info
)
1119 return is_32bit_elf
? ELF32_R_SYM (reloc_info
) : ELF64_R_SYM (reloc_info
);
1122 static inline bfd_boolean
1123 uses_msp430x_relocs (Filedata
* filedata
)
1126 filedata
->file_header
.e_machine
== EM_MSP430
/* Paranoia. */
1127 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1128 && (((filedata
->file_header
.e_flags
& EF_MSP430_MACH
) == E_MSP430_MACH_MSP430X
)
1129 /* TI compiler uses ELFOSABI_NONE. */
1130 || (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
));
1133 /* Display the contents of the relocation data found at the specified
1137 dump_relocations (Filedata
* filedata
,
1138 unsigned long rel_offset
,
1139 unsigned long rel_size
,
1140 Elf_Internal_Sym
* symtab
,
1141 unsigned long nsyms
,
1143 unsigned long strtablen
,
1145 bfd_boolean is_dynsym
)
1148 Elf_Internal_Rela
* rels
;
1149 bfd_boolean res
= TRUE
;
1151 if (is_rela
== UNKNOWN
)
1152 is_rela
= guess_is_rela (filedata
->file_header
.e_machine
);
1156 if (!slurp_rela_relocs (filedata
, rel_offset
, rel_size
, &rels
, &rel_size
))
1161 if (!slurp_rel_relocs (filedata
, rel_offset
, rel_size
, &rels
, &rel_size
))
1170 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1172 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1177 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1179 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1187 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
1189 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1194 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
1196 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1200 for (i
= 0; i
< rel_size
; i
++)
1205 bfd_vma symtab_index
;
1208 offset
= rels
[i
].r_offset
;
1209 inf
= rels
[i
].r_info
;
1211 type
= get_reloc_type (filedata
, inf
);
1212 symtab_index
= get_reloc_symindex (inf
);
1216 printf ("%8.8lx %8.8lx ",
1217 (unsigned long) offset
& 0xffffffff,
1218 (unsigned long) inf
& 0xffffffff);
1222 #if BFD_HOST_64BIT_LONG
1224 ? "%16.16lx %16.16lx "
1225 : "%12.12lx %12.12lx ",
1227 #elif BFD_HOST_64BIT_LONG_LONG
1230 ? "%16.16llx %16.16llx "
1231 : "%12.12llx %12.12llx ",
1235 ? "%16.16I64x %16.16I64x "
1236 : "%12.12I64x %12.12I64x ",
1241 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1242 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1243 _bfd_int64_high (offset
),
1244 _bfd_int64_low (offset
),
1245 _bfd_int64_high (inf
),
1246 _bfd_int64_low (inf
));
1250 switch (filedata
->file_header
.e_machine
)
1257 rtype
= elf_aarch64_reloc_type (type
);
1261 case EM_CYGNUS_M32R
:
1262 rtype
= elf_m32r_reloc_type (type
);
1267 rtype
= elf_i386_reloc_type (type
);
1272 rtype
= elf_m68hc11_reloc_type (type
);
1276 rtype
= elf_m68k_reloc_type (type
);
1280 rtype
= elf_i960_reloc_type (type
);
1285 rtype
= elf_avr_reloc_type (type
);
1288 case EM_OLD_SPARCV9
:
1289 case EM_SPARC32PLUS
:
1292 rtype
= elf_sparc_reloc_type (type
);
1296 rtype
= elf_spu_reloc_type (type
);
1300 rtype
= v800_reloc_type (type
);
1303 case EM_CYGNUS_V850
:
1304 rtype
= v850_reloc_type (type
);
1308 case EM_CYGNUS_D10V
:
1309 rtype
= elf_d10v_reloc_type (type
);
1313 case EM_CYGNUS_D30V
:
1314 rtype
= elf_d30v_reloc_type (type
);
1318 rtype
= elf_dlx_reloc_type (type
);
1322 rtype
= elf_sh_reloc_type (type
);
1326 case EM_CYGNUS_MN10300
:
1327 rtype
= elf_mn10300_reloc_type (type
);
1331 case EM_CYGNUS_MN10200
:
1332 rtype
= elf_mn10200_reloc_type (type
);
1336 case EM_CYGNUS_FR30
:
1337 rtype
= elf_fr30_reloc_type (type
);
1341 rtype
= elf_frv_reloc_type (type
);
1345 rtype
= elf_ft32_reloc_type (type
);
1349 rtype
= elf_mcore_reloc_type (type
);
1353 rtype
= elf_mmix_reloc_type (type
);
1357 rtype
= elf_moxie_reloc_type (type
);
1361 if (uses_msp430x_relocs (filedata
))
1363 rtype
= elf_msp430x_reloc_type (type
);
1368 rtype
= elf_msp430_reloc_type (type
);
1372 rtype
= elf_nds32_reloc_type (type
);
1376 rtype
= elf_ppc_reloc_type (type
);
1380 rtype
= elf_ppc64_reloc_type (type
);
1384 case EM_MIPS_RS3_LE
:
1385 rtype
= elf_mips_reloc_type (type
);
1389 rtype
= elf_riscv_reloc_type (type
);
1393 rtype
= elf_alpha_reloc_type (type
);
1397 rtype
= elf_arm_reloc_type (type
);
1401 case EM_ARC_COMPACT
:
1402 case EM_ARC_COMPACT2
:
1403 rtype
= elf_arc_reloc_type (type
);
1407 rtype
= elf_hppa_reloc_type (type
);
1413 rtype
= elf_h8_reloc_type (type
);
1417 rtype
= elf_or1k_reloc_type (type
);
1422 rtype
= elf_pj_reloc_type (type
);
1425 rtype
= elf_ia64_reloc_type (type
);
1429 rtype
= elf_cris_reloc_type (type
);
1433 rtype
= elf_i860_reloc_type (type
);
1439 rtype
= elf_x86_64_reloc_type (type
);
1443 rtype
= i370_reloc_type (type
);
1448 rtype
= elf_s390_reloc_type (type
);
1452 rtype
= elf_score_reloc_type (type
);
1456 rtype
= elf_xstormy16_reloc_type (type
);
1460 rtype
= elf_crx_reloc_type (type
);
1464 rtype
= elf_vax_reloc_type (type
);
1468 rtype
= elf_visium_reloc_type (type
);
1471 case EM_ADAPTEVA_EPIPHANY
:
1472 rtype
= elf_epiphany_reloc_type (type
);
1477 rtype
= elf_ip2k_reloc_type (type
);
1481 rtype
= elf_iq2000_reloc_type (type
);
1486 rtype
= elf_xtensa_reloc_type (type
);
1489 case EM_LATTICEMICO32
:
1490 rtype
= elf_lm32_reloc_type (type
);
1495 rtype
= elf_m32c_reloc_type (type
);
1499 rtype
= elf_mt_reloc_type (type
);
1503 rtype
= elf_bfin_reloc_type (type
);
1507 rtype
= elf_mep_reloc_type (type
);
1511 rtype
= elf_cr16_reloc_type (type
);
1515 case EM_MICROBLAZE_OLD
:
1516 rtype
= elf_microblaze_reloc_type (type
);
1520 rtype
= elf_rl78_reloc_type (type
);
1524 rtype
= elf_rx_reloc_type (type
);
1528 rtype
= elf_metag_reloc_type (type
);
1533 rtype
= elf_xc16x_reloc_type (type
);
1537 rtype
= elf_tic6x_reloc_type (type
);
1541 rtype
= elf_tilegx_reloc_type (type
);
1545 rtype
= elf_tilepro_reloc_type (type
);
1548 case EM_WEBASSEMBLY
:
1549 rtype
= elf_wasm32_reloc_type (type
);
1553 rtype
= elf_xgate_reloc_type (type
);
1556 case EM_ALTERA_NIOS2
:
1557 rtype
= elf_nios2_reloc_type (type
);
1561 rtype
= elf_pru_reloc_type (type
);
1566 printf (_("unrecognized: %-7lx"), (unsigned long) type
& 0xffffffff);
1568 printf (do_wide
? "%-22s" : "%-17.17s", rtype
);
1570 if (filedata
->file_header
.e_machine
== EM_ALPHA
1572 && streq (rtype
, "R_ALPHA_LITUSE")
1575 switch (rels
[i
].r_addend
)
1577 case LITUSE_ALPHA_ADDR
: rtype
= "ADDR"; break;
1578 case LITUSE_ALPHA_BASE
: rtype
= "BASE"; break;
1579 case LITUSE_ALPHA_BYTOFF
: rtype
= "BYTOFF"; break;
1580 case LITUSE_ALPHA_JSR
: rtype
= "JSR"; break;
1581 case LITUSE_ALPHA_TLSGD
: rtype
= "TLSGD"; break;
1582 case LITUSE_ALPHA_TLSLDM
: rtype
= "TLSLDM"; break;
1583 case LITUSE_ALPHA_JSRDIRECT
: rtype
= "JSRDIRECT"; break;
1584 default: rtype
= NULL
;
1588 printf (" (%s)", rtype
);
1592 printf (_("<unknown addend: %lx>"),
1593 (unsigned long) rels
[i
].r_addend
);
1597 else if (symtab_index
)
1599 if (symtab
== NULL
|| symtab_index
>= nsyms
)
1601 error (_(" bad symbol index: %08lx in reloc"), (unsigned long) symtab_index
);
1606 Elf_Internal_Sym
* psym
;
1607 const char * version_string
;
1608 enum versioned_symbol_info sym_info
;
1609 unsigned short vna_other
;
1611 psym
= symtab
+ symtab_index
;
1614 = get_symbol_version_string (filedata
, is_dynsym
,
1623 if (ELF_ST_TYPE (psym
->st_info
) == STT_GNU_IFUNC
)
1627 unsigned int width
= is_32bit_elf
? 8 : 14;
1629 /* Relocations against GNU_IFUNC symbols do not use the value
1630 of the symbol as the address to relocate against. Instead
1631 they invoke the function named by the symbol and use its
1632 result as the address for relocation.
1634 To indicate this to the user, do not display the value of
1635 the symbol in the "Symbols's Value" field. Instead show
1636 its name followed by () as a hint that the symbol is
1640 || psym
->st_name
== 0
1641 || psym
->st_name
>= strtablen
)
1644 name
= strtab
+ psym
->st_name
;
1646 len
= print_symbol (width
, name
);
1648 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1650 printf ("()%-*s", len
<= width
? (width
+ 1) - len
: 1, " ");
1654 print_vma (psym
->st_value
, LONG_HEX
);
1656 printf (is_32bit_elf
? " " : " ");
1659 if (psym
->st_name
== 0)
1661 const char * sec_name
= "<null>";
1664 if (ELF_ST_TYPE (psym
->st_info
) == STT_SECTION
)
1666 if (psym
->st_shndx
< filedata
->file_header
.e_shnum
)
1667 sec_name
= SECTION_NAME (filedata
->section_headers
+ psym
->st_shndx
);
1668 else if (psym
->st_shndx
== SHN_ABS
)
1670 else if (psym
->st_shndx
== SHN_COMMON
)
1671 sec_name
= "COMMON";
1672 else if ((filedata
->file_header
.e_machine
== EM_MIPS
1673 && psym
->st_shndx
== SHN_MIPS_SCOMMON
)
1674 || (filedata
->file_header
.e_machine
== EM_TI_C6000
1675 && psym
->st_shndx
== SHN_TIC6X_SCOMMON
))
1676 sec_name
= "SCOMMON";
1677 else if (filedata
->file_header
.e_machine
== EM_MIPS
1678 && psym
->st_shndx
== SHN_MIPS_SUNDEFINED
)
1679 sec_name
= "SUNDEF";
1680 else if ((filedata
->file_header
.e_machine
== EM_X86_64
1681 || filedata
->file_header
.e_machine
== EM_L1OM
1682 || filedata
->file_header
.e_machine
== EM_K1OM
)
1683 && psym
->st_shndx
== SHN_X86_64_LCOMMON
)
1684 sec_name
= "LARGE_COMMON";
1685 else if (filedata
->file_header
.e_machine
== EM_IA_64
1686 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
1687 && psym
->st_shndx
== SHN_IA_64_ANSI_COMMON
)
1688 sec_name
= "ANSI_COM";
1689 else if (is_ia64_vms (filedata
)
1690 && psym
->st_shndx
== SHN_IA_64_VMS_SYMVEC
)
1691 sec_name
= "VMS_SYMVEC";
1694 sprintf (name_buf
, "<section 0x%x>",
1695 (unsigned int) psym
->st_shndx
);
1696 sec_name
= name_buf
;
1699 print_symbol (22, sec_name
);
1701 else if (strtab
== NULL
)
1702 printf (_("<string table index: %3ld>"), psym
->st_name
);
1703 else if (psym
->st_name
>= strtablen
)
1705 error (_("<corrupt string table index: %3ld>"), psym
->st_name
);
1710 print_symbol (22, strtab
+ psym
->st_name
);
1712 printf (sym_info
== symbol_public
? "@@%s" : "@%s",
1718 bfd_vma off
= rels
[i
].r_addend
;
1720 if ((bfd_signed_vma
) off
< 0)
1721 printf (" - %" BFD_VMA_FMT
"x", - off
);
1723 printf (" + %" BFD_VMA_FMT
"x", off
);
1729 bfd_vma off
= rels
[i
].r_addend
;
1731 printf ("%*c", is_32bit_elf
? 12 : 20, ' ');
1732 if ((bfd_signed_vma
) off
< 0)
1733 printf ("-%" BFD_VMA_FMT
"x", - off
);
1735 printf ("%" BFD_VMA_FMT
"x", off
);
1738 if (filedata
->file_header
.e_machine
== EM_SPARCV9
1740 && streq (rtype
, "R_SPARC_OLO10"))
1741 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf
));
1746 if (! is_32bit_elf
&& filedata
->file_header
.e_machine
== EM_MIPS
)
1748 bfd_vma type2
= ELF64_MIPS_R_TYPE2 (inf
);
1749 bfd_vma type3
= ELF64_MIPS_R_TYPE3 (inf
);
1750 const char * rtype2
= elf_mips_reloc_type (type2
);
1751 const char * rtype3
= elf_mips_reloc_type (type3
);
1753 printf (" Type2: ");
1756 printf (_("unrecognized: %-7lx"),
1757 (unsigned long) type2
& 0xffffffff);
1759 printf ("%-17.17s", rtype2
);
1761 printf ("\n Type3: ");
1764 printf (_("unrecognized: %-7lx"),
1765 (unsigned long) type3
& 0xffffffff);
1767 printf ("%-17.17s", rtype3
);
1780 get_mips_dynamic_type (unsigned long type
)
1784 case DT_MIPS_RLD_VERSION
: return "MIPS_RLD_VERSION";
1785 case DT_MIPS_TIME_STAMP
: return "MIPS_TIME_STAMP";
1786 case DT_MIPS_ICHECKSUM
: return "MIPS_ICHECKSUM";
1787 case DT_MIPS_IVERSION
: return "MIPS_IVERSION";
1788 case DT_MIPS_FLAGS
: return "MIPS_FLAGS";
1789 case DT_MIPS_BASE_ADDRESS
: return "MIPS_BASE_ADDRESS";
1790 case DT_MIPS_MSYM
: return "MIPS_MSYM";
1791 case DT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
1792 case DT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
1793 case DT_MIPS_LOCAL_GOTNO
: return "MIPS_LOCAL_GOTNO";
1794 case DT_MIPS_CONFLICTNO
: return "MIPS_CONFLICTNO";
1795 case DT_MIPS_LIBLISTNO
: return "MIPS_LIBLISTNO";
1796 case DT_MIPS_SYMTABNO
: return "MIPS_SYMTABNO";
1797 case DT_MIPS_UNREFEXTNO
: return "MIPS_UNREFEXTNO";
1798 case DT_MIPS_GOTSYM
: return "MIPS_GOTSYM";
1799 case DT_MIPS_HIPAGENO
: return "MIPS_HIPAGENO";
1800 case DT_MIPS_RLD_MAP
: return "MIPS_RLD_MAP";
1801 case DT_MIPS_RLD_MAP_REL
: return "MIPS_RLD_MAP_REL";
1802 case DT_MIPS_DELTA_CLASS
: return "MIPS_DELTA_CLASS";
1803 case DT_MIPS_DELTA_CLASS_NO
: return "MIPS_DELTA_CLASS_NO";
1804 case DT_MIPS_DELTA_INSTANCE
: return "MIPS_DELTA_INSTANCE";
1805 case DT_MIPS_DELTA_INSTANCE_NO
: return "MIPS_DELTA_INSTANCE_NO";
1806 case DT_MIPS_DELTA_RELOC
: return "MIPS_DELTA_RELOC";
1807 case DT_MIPS_DELTA_RELOC_NO
: return "MIPS_DELTA_RELOC_NO";
1808 case DT_MIPS_DELTA_SYM
: return "MIPS_DELTA_SYM";
1809 case DT_MIPS_DELTA_SYM_NO
: return "MIPS_DELTA_SYM_NO";
1810 case DT_MIPS_DELTA_CLASSSYM
: return "MIPS_DELTA_CLASSSYM";
1811 case DT_MIPS_DELTA_CLASSSYM_NO
: return "MIPS_DELTA_CLASSSYM_NO";
1812 case DT_MIPS_CXX_FLAGS
: return "MIPS_CXX_FLAGS";
1813 case DT_MIPS_PIXIE_INIT
: return "MIPS_PIXIE_INIT";
1814 case DT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
1815 case DT_MIPS_LOCALPAGE_GOTIDX
: return "MIPS_LOCALPAGE_GOTIDX";
1816 case DT_MIPS_LOCAL_GOTIDX
: return "MIPS_LOCAL_GOTIDX";
1817 case DT_MIPS_HIDDEN_GOTIDX
: return "MIPS_HIDDEN_GOTIDX";
1818 case DT_MIPS_PROTECTED_GOTIDX
: return "MIPS_PROTECTED_GOTIDX";
1819 case DT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
1820 case DT_MIPS_INTERFACE
: return "MIPS_INTERFACE";
1821 case DT_MIPS_DYNSTR_ALIGN
: return "MIPS_DYNSTR_ALIGN";
1822 case DT_MIPS_INTERFACE_SIZE
: return "MIPS_INTERFACE_SIZE";
1823 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR
: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1824 case DT_MIPS_PERF_SUFFIX
: return "MIPS_PERF_SUFFIX";
1825 case DT_MIPS_COMPACT_SIZE
: return "MIPS_COMPACT_SIZE";
1826 case DT_MIPS_GP_VALUE
: return "MIPS_GP_VALUE";
1827 case DT_MIPS_AUX_DYNAMIC
: return "MIPS_AUX_DYNAMIC";
1828 case DT_MIPS_PLTGOT
: return "MIPS_PLTGOT";
1829 case DT_MIPS_RWPLT
: return "MIPS_RWPLT";
1836 get_sparc64_dynamic_type (unsigned long type
)
1840 case DT_SPARC_REGISTER
: return "SPARC_REGISTER";
1847 get_ppc_dynamic_type (unsigned long type
)
1851 case DT_PPC_GOT
: return "PPC_GOT";
1852 case DT_PPC_OPT
: return "PPC_OPT";
1859 get_ppc64_dynamic_type (unsigned long type
)
1863 case DT_PPC64_GLINK
: return "PPC64_GLINK";
1864 case DT_PPC64_OPD
: return "PPC64_OPD";
1865 case DT_PPC64_OPDSZ
: return "PPC64_OPDSZ";
1866 case DT_PPC64_OPT
: return "PPC64_OPT";
1873 get_parisc_dynamic_type (unsigned long type
)
1877 case DT_HP_LOAD_MAP
: return "HP_LOAD_MAP";
1878 case DT_HP_DLD_FLAGS
: return "HP_DLD_FLAGS";
1879 case DT_HP_DLD_HOOK
: return "HP_DLD_HOOK";
1880 case DT_HP_UX10_INIT
: return "HP_UX10_INIT";
1881 case DT_HP_UX10_INITSZ
: return "HP_UX10_INITSZ";
1882 case DT_HP_PREINIT
: return "HP_PREINIT";
1883 case DT_HP_PREINITSZ
: return "HP_PREINITSZ";
1884 case DT_HP_NEEDED
: return "HP_NEEDED";
1885 case DT_HP_TIME_STAMP
: return "HP_TIME_STAMP";
1886 case DT_HP_CHECKSUM
: return "HP_CHECKSUM";
1887 case DT_HP_GST_SIZE
: return "HP_GST_SIZE";
1888 case DT_HP_GST_VERSION
: return "HP_GST_VERSION";
1889 case DT_HP_GST_HASHVAL
: return "HP_GST_HASHVAL";
1890 case DT_HP_EPLTREL
: return "HP_GST_EPLTREL";
1891 case DT_HP_EPLTRELSZ
: return "HP_GST_EPLTRELSZ";
1892 case DT_HP_FILTERED
: return "HP_FILTERED";
1893 case DT_HP_FILTER_TLS
: return "HP_FILTER_TLS";
1894 case DT_HP_COMPAT_FILTERED
: return "HP_COMPAT_FILTERED";
1895 case DT_HP_LAZYLOAD
: return "HP_LAZYLOAD";
1896 case DT_HP_BIND_NOW_COUNT
: return "HP_BIND_NOW_COUNT";
1897 case DT_PLT
: return "PLT";
1898 case DT_PLT_SIZE
: return "PLT_SIZE";
1899 case DT_DLT
: return "DLT";
1900 case DT_DLT_SIZE
: return "DLT_SIZE";
1907 get_ia64_dynamic_type (unsigned long type
)
1911 case DT_IA_64_PLT_RESERVE
: return "IA_64_PLT_RESERVE";
1912 case DT_IA_64_VMS_SUBTYPE
: return "VMS_SUBTYPE";
1913 case DT_IA_64_VMS_IMGIOCNT
: return "VMS_IMGIOCNT";
1914 case DT_IA_64_VMS_LNKFLAGS
: return "VMS_LNKFLAGS";
1915 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ
: return "VMS_VIR_MEM_BLK_SIZ";
1916 case DT_IA_64_VMS_IDENT
: return "VMS_IDENT";
1917 case DT_IA_64_VMS_NEEDED_IDENT
: return "VMS_NEEDED_IDENT";
1918 case DT_IA_64_VMS_IMG_RELA_CNT
: return "VMS_IMG_RELA_CNT";
1919 case DT_IA_64_VMS_SEG_RELA_CNT
: return "VMS_SEG_RELA_CNT";
1920 case DT_IA_64_VMS_FIXUP_RELA_CNT
: return "VMS_FIXUP_RELA_CNT";
1921 case DT_IA_64_VMS_FIXUP_NEEDED
: return "VMS_FIXUP_NEEDED";
1922 case DT_IA_64_VMS_SYMVEC_CNT
: return "VMS_SYMVEC_CNT";
1923 case DT_IA_64_VMS_XLATED
: return "VMS_XLATED";
1924 case DT_IA_64_VMS_STACKSIZE
: return "VMS_STACKSIZE";
1925 case DT_IA_64_VMS_UNWINDSZ
: return "VMS_UNWINDSZ";
1926 case DT_IA_64_VMS_UNWIND_CODSEG
: return "VMS_UNWIND_CODSEG";
1927 case DT_IA_64_VMS_UNWIND_INFOSEG
: return "VMS_UNWIND_INFOSEG";
1928 case DT_IA_64_VMS_LINKTIME
: return "VMS_LINKTIME";
1929 case DT_IA_64_VMS_SEG_NO
: return "VMS_SEG_NO";
1930 case DT_IA_64_VMS_SYMVEC_OFFSET
: return "VMS_SYMVEC_OFFSET";
1931 case DT_IA_64_VMS_SYMVEC_SEG
: return "VMS_SYMVEC_SEG";
1932 case DT_IA_64_VMS_UNWIND_OFFSET
: return "VMS_UNWIND_OFFSET";
1933 case DT_IA_64_VMS_UNWIND_SEG
: return "VMS_UNWIND_SEG";
1934 case DT_IA_64_VMS_STRTAB_OFFSET
: return "VMS_STRTAB_OFFSET";
1935 case DT_IA_64_VMS_SYSVER_OFFSET
: return "VMS_SYSVER_OFFSET";
1936 case DT_IA_64_VMS_IMG_RELA_OFF
: return "VMS_IMG_RELA_OFF";
1937 case DT_IA_64_VMS_SEG_RELA_OFF
: return "VMS_SEG_RELA_OFF";
1938 case DT_IA_64_VMS_FIXUP_RELA_OFF
: return "VMS_FIXUP_RELA_OFF";
1939 case DT_IA_64_VMS_PLTGOT_OFFSET
: return "VMS_PLTGOT_OFFSET";
1940 case DT_IA_64_VMS_PLTGOT_SEG
: return "VMS_PLTGOT_SEG";
1941 case DT_IA_64_VMS_FPMODE
: return "VMS_FPMODE";
1948 get_solaris_section_type (unsigned long type
)
1952 case 0x6fffffee: return "SUNW_ancillary";
1953 case 0x6fffffef: return "SUNW_capchain";
1954 case 0x6ffffff0: return "SUNW_capinfo";
1955 case 0x6ffffff1: return "SUNW_symsort";
1956 case 0x6ffffff2: return "SUNW_tlssort";
1957 case 0x6ffffff3: return "SUNW_LDYNSYM";
1958 case 0x6ffffff4: return "SUNW_dof";
1959 case 0x6ffffff5: return "SUNW_cap";
1960 case 0x6ffffff6: return "SUNW_SIGNATURE";
1961 case 0x6ffffff7: return "SUNW_ANNOTATE";
1962 case 0x6ffffff8: return "SUNW_DEBUGSTR";
1963 case 0x6ffffff9: return "SUNW_DEBUG";
1964 case 0x6ffffffa: return "SUNW_move";
1965 case 0x6ffffffb: return "SUNW_COMDAT";
1966 case 0x6ffffffc: return "SUNW_syminfo";
1967 case 0x6ffffffd: return "SUNW_verdef";
1968 case 0x6ffffffe: return "SUNW_verneed";
1969 case 0x6fffffff: return "SUNW_versym";
1970 case 0x70000000: return "SPARC_GOTDATA";
1971 default: return NULL
;
1976 get_alpha_dynamic_type (unsigned long type
)
1980 case DT_ALPHA_PLTRO
: return "ALPHA_PLTRO";
1981 default: return NULL
;
1986 get_score_dynamic_type (unsigned long type
)
1990 case DT_SCORE_BASE_ADDRESS
: return "SCORE_BASE_ADDRESS";
1991 case DT_SCORE_LOCAL_GOTNO
: return "SCORE_LOCAL_GOTNO";
1992 case DT_SCORE_SYMTABNO
: return "SCORE_SYMTABNO";
1993 case DT_SCORE_GOTSYM
: return "SCORE_GOTSYM";
1994 case DT_SCORE_UNREFEXTNO
: return "SCORE_UNREFEXTNO";
1995 case DT_SCORE_HIPAGENO
: return "SCORE_HIPAGENO";
1996 default: return NULL
;
2001 get_tic6x_dynamic_type (unsigned long type
)
2005 case DT_C6000_GSYM_OFFSET
: return "C6000_GSYM_OFFSET";
2006 case DT_C6000_GSTR_OFFSET
: return "C6000_GSTR_OFFSET";
2007 case DT_C6000_DSBT_BASE
: return "C6000_DSBT_BASE";
2008 case DT_C6000_DSBT_SIZE
: return "C6000_DSBT_SIZE";
2009 case DT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
2010 case DT_C6000_DSBT_INDEX
: return "C6000_DSBT_INDEX";
2011 default: return NULL
;
2016 get_nios2_dynamic_type (unsigned long type
)
2020 case DT_NIOS2_GP
: return "NIOS2_GP";
2021 default: return NULL
;
2026 get_solaris_dynamic_type (unsigned long type
)
2030 case 0x6000000d: return "SUNW_AUXILIARY";
2031 case 0x6000000e: return "SUNW_RTLDINF";
2032 case 0x6000000f: return "SUNW_FILTER";
2033 case 0x60000010: return "SUNW_CAP";
2034 case 0x60000011: return "SUNW_SYMTAB";
2035 case 0x60000012: return "SUNW_SYMSZ";
2036 case 0x60000013: return "SUNW_SORTENT";
2037 case 0x60000014: return "SUNW_SYMSORT";
2038 case 0x60000015: return "SUNW_SYMSORTSZ";
2039 case 0x60000016: return "SUNW_TLSSORT";
2040 case 0x60000017: return "SUNW_TLSSORTSZ";
2041 case 0x60000018: return "SUNW_CAPINFO";
2042 case 0x60000019: return "SUNW_STRPAD";
2043 case 0x6000001a: return "SUNW_CAPCHAIN";
2044 case 0x6000001b: return "SUNW_LDMACH";
2045 case 0x6000001d: return "SUNW_CAPCHAINENT";
2046 case 0x6000001f: return "SUNW_CAPCHAINSZ";
2047 case 0x60000021: return "SUNW_PARENT";
2048 case 0x60000023: return "SUNW_ASLR";
2049 case 0x60000025: return "SUNW_RELAX";
2050 case 0x60000029: return "SUNW_NXHEAP";
2051 case 0x6000002b: return "SUNW_NXSTACK";
2053 case 0x70000001: return "SPARC_REGISTER";
2054 case 0x7ffffffd: return "AUXILIARY";
2055 case 0x7ffffffe: return "USED";
2056 case 0x7fffffff: return "FILTER";
2058 default: return NULL
;
2063 get_dynamic_type (Filedata
* filedata
, unsigned long type
)
2065 static char buff
[64];
2069 case DT_NULL
: return "NULL";
2070 case DT_NEEDED
: return "NEEDED";
2071 case DT_PLTRELSZ
: return "PLTRELSZ";
2072 case DT_PLTGOT
: return "PLTGOT";
2073 case DT_HASH
: return "HASH";
2074 case DT_STRTAB
: return "STRTAB";
2075 case DT_SYMTAB
: return "SYMTAB";
2076 case DT_RELA
: return "RELA";
2077 case DT_RELASZ
: return "RELASZ";
2078 case DT_RELAENT
: return "RELAENT";
2079 case DT_STRSZ
: return "STRSZ";
2080 case DT_SYMENT
: return "SYMENT";
2081 case DT_INIT
: return "INIT";
2082 case DT_FINI
: return "FINI";
2083 case DT_SONAME
: return "SONAME";
2084 case DT_RPATH
: return "RPATH";
2085 case DT_SYMBOLIC
: return "SYMBOLIC";
2086 case DT_REL
: return "REL";
2087 case DT_RELSZ
: return "RELSZ";
2088 case DT_RELENT
: return "RELENT";
2089 case DT_PLTREL
: return "PLTREL";
2090 case DT_DEBUG
: return "DEBUG";
2091 case DT_TEXTREL
: return "TEXTREL";
2092 case DT_JMPREL
: return "JMPREL";
2093 case DT_BIND_NOW
: return "BIND_NOW";
2094 case DT_INIT_ARRAY
: return "INIT_ARRAY";
2095 case DT_FINI_ARRAY
: return "FINI_ARRAY";
2096 case DT_INIT_ARRAYSZ
: return "INIT_ARRAYSZ";
2097 case DT_FINI_ARRAYSZ
: return "FINI_ARRAYSZ";
2098 case DT_RUNPATH
: return "RUNPATH";
2099 case DT_FLAGS
: return "FLAGS";
2101 case DT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
2102 case DT_PREINIT_ARRAYSZ
: return "PREINIT_ARRAYSZ";
2103 case DT_SYMTAB_SHNDX
: return "SYMTAB_SHNDX";
2105 case DT_CHECKSUM
: return "CHECKSUM";
2106 case DT_PLTPADSZ
: return "PLTPADSZ";
2107 case DT_MOVEENT
: return "MOVEENT";
2108 case DT_MOVESZ
: return "MOVESZ";
2109 case DT_FEATURE
: return "FEATURE";
2110 case DT_POSFLAG_1
: return "POSFLAG_1";
2111 case DT_SYMINSZ
: return "SYMINSZ";
2112 case DT_SYMINENT
: return "SYMINENT"; /* aka VALRNGHI */
2114 case DT_ADDRRNGLO
: return "ADDRRNGLO";
2115 case DT_CONFIG
: return "CONFIG";
2116 case DT_DEPAUDIT
: return "DEPAUDIT";
2117 case DT_AUDIT
: return "AUDIT";
2118 case DT_PLTPAD
: return "PLTPAD";
2119 case DT_MOVETAB
: return "MOVETAB";
2120 case DT_SYMINFO
: return "SYMINFO"; /* aka ADDRRNGHI */
2122 case DT_VERSYM
: return "VERSYM";
2124 case DT_TLSDESC_GOT
: return "TLSDESC_GOT";
2125 case DT_TLSDESC_PLT
: return "TLSDESC_PLT";
2126 case DT_RELACOUNT
: return "RELACOUNT";
2127 case DT_RELCOUNT
: return "RELCOUNT";
2128 case DT_FLAGS_1
: return "FLAGS_1";
2129 case DT_VERDEF
: return "VERDEF";
2130 case DT_VERDEFNUM
: return "VERDEFNUM";
2131 case DT_VERNEED
: return "VERNEED";
2132 case DT_VERNEEDNUM
: return "VERNEEDNUM";
2134 case DT_AUXILIARY
: return "AUXILIARY";
2135 case DT_USED
: return "USED";
2136 case DT_FILTER
: return "FILTER";
2138 case DT_GNU_PRELINKED
: return "GNU_PRELINKED";
2139 case DT_GNU_CONFLICT
: return "GNU_CONFLICT";
2140 case DT_GNU_CONFLICTSZ
: return "GNU_CONFLICTSZ";
2141 case DT_GNU_LIBLIST
: return "GNU_LIBLIST";
2142 case DT_GNU_LIBLISTSZ
: return "GNU_LIBLISTSZ";
2143 case DT_GNU_HASH
: return "GNU_HASH";
2146 if ((type
>= DT_LOPROC
) && (type
<= DT_HIPROC
))
2148 const char * result
;
2150 switch (filedata
->file_header
.e_machine
)
2153 case EM_MIPS_RS3_LE
:
2154 result
= get_mips_dynamic_type (type
);
2157 result
= get_sparc64_dynamic_type (type
);
2160 result
= get_ppc_dynamic_type (type
);
2163 result
= get_ppc64_dynamic_type (type
);
2166 result
= get_ia64_dynamic_type (type
);
2169 result
= get_alpha_dynamic_type (type
);
2172 result
= get_score_dynamic_type (type
);
2175 result
= get_tic6x_dynamic_type (type
);
2177 case EM_ALTERA_NIOS2
:
2178 result
= get_nios2_dynamic_type (type
);
2181 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2182 result
= get_solaris_dynamic_type (type
);
2191 snprintf (buff
, sizeof (buff
), _("Processor Specific: %lx"), type
);
2193 else if (((type
>= DT_LOOS
) && (type
<= DT_HIOS
))
2194 || (filedata
->file_header
.e_machine
== EM_PARISC
2195 && (type
>= OLD_DT_LOOS
) && (type
<= OLD_DT_HIOS
)))
2197 const char * result
;
2199 switch (filedata
->file_header
.e_machine
)
2202 result
= get_parisc_dynamic_type (type
);
2205 result
= get_ia64_dynamic_type (type
);
2208 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
2209 result
= get_solaris_dynamic_type (type
);
2218 snprintf (buff
, sizeof (buff
), _("Operating System specific: %lx"),
2222 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), type
);
2229 get_file_type (unsigned e_type
)
2231 static char buff
[32];
2235 case ET_NONE
: return _("NONE (None)");
2236 case ET_REL
: return _("REL (Relocatable file)");
2237 case ET_EXEC
: return _("EXEC (Executable file)");
2238 case ET_DYN
: return _("DYN (Shared object file)");
2239 case ET_CORE
: return _("CORE (Core file)");
2242 if ((e_type
>= ET_LOPROC
) && (e_type
<= ET_HIPROC
))
2243 snprintf (buff
, sizeof (buff
), _("Processor Specific: (%x)"), e_type
);
2244 else if ((e_type
>= ET_LOOS
) && (e_type
<= ET_HIOS
))
2245 snprintf (buff
, sizeof (buff
), _("OS Specific: (%x)"), e_type
);
2247 snprintf (buff
, sizeof (buff
), _("<unknown>: %x"), e_type
);
2253 get_machine_name (unsigned e_machine
)
2255 static char buff
[64]; /* XXX */
2259 /* Please keep this switch table sorted by increasing EM_ value. */
2261 case EM_NONE
: return _("None");
2262 case EM_M32
: return "WE32100";
2263 case EM_SPARC
: return "Sparc";
2264 case EM_386
: return "Intel 80386";
2265 case EM_68K
: return "MC68000";
2266 case EM_88K
: return "MC88000";
2267 case EM_IAMCU
: return "Intel MCU";
2268 case EM_860
: return "Intel 80860";
2269 case EM_MIPS
: return "MIPS R3000";
2270 case EM_S370
: return "IBM System/370";
2272 case EM_MIPS_RS3_LE
: return "MIPS R4000 big-endian";
2273 case EM_OLD_SPARCV9
: return "Sparc v9 (old)";
2274 case EM_PARISC
: return "HPPA";
2275 case EM_VPP550
: return "Fujitsu VPP500";
2276 case EM_SPARC32PLUS
: return "Sparc v8+" ;
2277 case EM_960
: return "Intel 80960";
2278 case EM_PPC
: return "PowerPC";
2280 case EM_PPC64
: return "PowerPC64";
2282 case EM_S390
: return "IBM S/390";
2283 case EM_SPU
: return "SPU";
2285 case EM_V800
: return "Renesas V850 (using RH850 ABI)";
2286 case EM_FR20
: return "Fujitsu FR20";
2287 case EM_RH32
: return "TRW RH32";
2288 case EM_MCORE
: return "MCORE";
2290 case EM_ARM
: return "ARM";
2291 case EM_OLD_ALPHA
: return "Digital Alpha (old)";
2292 case EM_SH
: return "Renesas / SuperH SH";
2293 case EM_SPARCV9
: return "Sparc v9";
2294 case EM_TRICORE
: return "Siemens Tricore";
2295 case EM_ARC
: return "ARC";
2296 case EM_H8_300
: return "Renesas H8/300";
2297 case EM_H8_300H
: return "Renesas H8/300H";
2298 case EM_H8S
: return "Renesas H8S";
2299 case EM_H8_500
: return "Renesas H8/500";
2301 case EM_IA_64
: return "Intel IA-64";
2302 case EM_MIPS_X
: return "Stanford MIPS-X";
2303 case EM_COLDFIRE
: return "Motorola Coldfire";
2304 case EM_68HC12
: return "Motorola MC68HC12 Microcontroller";
2305 case EM_MMA
: return "Fujitsu Multimedia Accelerator";
2306 case EM_PCP
: return "Siemens PCP";
2307 case EM_NCPU
: return "Sony nCPU embedded RISC processor";
2308 case EM_NDR1
: return "Denso NDR1 microprocesspr";
2309 case EM_STARCORE
: return "Motorola Star*Core processor";
2310 case EM_ME16
: return "Toyota ME16 processor";
2312 case EM_ST100
: return "STMicroelectronics ST100 processor";
2313 case EM_TINYJ
: return "Advanced Logic Corp. TinyJ embedded processor";
2314 case EM_X86_64
: return "Advanced Micro Devices X86-64";
2315 case EM_PDSP
: return "Sony DSP processor";
2316 case EM_PDP10
: return "Digital Equipment Corp. PDP-10";
2317 case EM_PDP11
: return "Digital Equipment Corp. PDP-11";
2318 case EM_FX66
: return "Siemens FX66 microcontroller";
2319 case EM_ST9PLUS
: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2320 case EM_ST7
: return "STMicroelectronics ST7 8-bit microcontroller";
2321 case EM_68HC16
: return "Motorola MC68HC16 Microcontroller";
2323 case EM_68HC11
: return "Motorola MC68HC11 Microcontroller";
2324 case EM_68HC08
: return "Motorola MC68HC08 Microcontroller";
2325 case EM_68HC05
: return "Motorola MC68HC05 Microcontroller";
2326 case EM_SVX
: return "Silicon Graphics SVx";
2327 case EM_ST19
: return "STMicroelectronics ST19 8-bit microcontroller";
2328 case EM_VAX
: return "Digital VAX";
2329 case EM_CRIS
: return "Axis Communications 32-bit embedded processor";
2330 case EM_JAVELIN
: return "Infineon Technologies 32-bit embedded cpu";
2331 case EM_FIREPATH
: return "Element 14 64-bit DSP processor";
2332 case EM_ZSP
: return "LSI Logic's 16-bit DSP processor";
2334 case EM_MMIX
: return "Donald Knuth's educational 64-bit processor";
2335 case EM_HUANY
: return "Harvard Universitys's machine-independent object format";
2336 case EM_PRISM
: return "Vitesse Prism";
2338 case EM_AVR
: return "Atmel AVR 8-bit microcontroller";
2339 case EM_CYGNUS_FR30
:
2340 case EM_FR30
: return "Fujitsu FR30";
2341 case EM_CYGNUS_D10V
:
2342 case EM_D10V
: return "d10v";
2343 case EM_CYGNUS_D30V
:
2344 case EM_D30V
: return "d30v";
2345 case EM_CYGNUS_V850
:
2346 case EM_V850
: return "Renesas V850";
2347 case EM_CYGNUS_M32R
:
2348 case EM_M32R
: return "Renesas M32R (formerly Mitsubishi M32r)";
2349 case EM_CYGNUS_MN10300
:
2350 case EM_MN10300
: return "mn10300";
2352 case EM_CYGNUS_MN10200
:
2353 case EM_MN10200
: return "mn10200";
2354 case EM_PJ
: return "picoJava";
2355 case EM_OR1K
: return "OpenRISC 1000";
2356 case EM_ARC_COMPACT
: return "ARCompact";
2358 case EM_XTENSA
: return "Tensilica Xtensa Processor";
2359 case EM_VIDEOCORE
: return "Alphamosaic VideoCore processor";
2360 case EM_TMM_GPP
: return "Thompson Multimedia General Purpose Processor";
2361 case EM_NS32K
: return "National Semiconductor 32000 series";
2362 case EM_TPC
: return "Tenor Network TPC processor";
2363 case EM_SNP1K
: return "Trebia SNP 1000 processor";
2365 case EM_ST200
: return "STMicroelectronics ST200 microcontroller";
2367 case EM_IP2K
: return "Ubicom IP2xxx 8-bit microcontrollers";
2368 case EM_MAX
: return "MAX Processor";
2369 case EM_CR
: return "National Semiconductor CompactRISC";
2370 case EM_F2MC16
: return "Fujitsu F2MC16";
2371 case EM_MSP430
: return "Texas Instruments msp430 microcontroller";
2372 case EM_BLACKFIN
: return "Analog Devices Blackfin";
2373 case EM_SE_C33
: return "S1C33 Family of Seiko Epson processors";
2374 case EM_SEP
: return "Sharp embedded microprocessor";
2375 case EM_ARCA
: return "Arca RISC microprocessor";
2377 case EM_UNICORE
: return "Unicore";
2378 case EM_EXCESS
: return "eXcess 16/32/64-bit configurable embedded CPU";
2379 case EM_DXP
: return "Icera Semiconductor Inc. Deep Execution Processor";
2380 case EM_ALTERA_NIOS2
: return "Altera Nios II";
2381 case EM_CRX
: return "National Semiconductor CRX microprocessor";
2382 case EM_XGATE
: return "Motorola XGATE embedded processor";
2384 case EM_XC16X
: return "Infineon Technologies xc16x";
2385 case EM_M16C
: return "Renesas M16C series microprocessors";
2386 case EM_DSPIC30F
: return "Microchip Technology dsPIC30F Digital Signal Controller";
2387 case EM_CE
: return "Freescale Communication Engine RISC core";
2389 case EM_M32C
: return "Renesas M32c";
2391 case EM_TSK3000
: return "Altium TSK3000 core";
2392 case EM_RS08
: return "Freescale RS08 embedded processor";
2393 case EM_ECOG2
: return "Cyan Technology eCOG2 microprocessor";
2394 case EM_SCORE
: return "SUNPLUS S+Core";
2395 case EM_DSP24
: return "New Japan Radio (NJR) 24-bit DSP Processor";
2396 case EM_VIDEOCORE3
: return "Broadcom VideoCore III processor";
2397 case EM_LATTICEMICO32
: return "Lattice Mico32";
2398 case EM_SE_C17
: return "Seiko Epson C17 family";
2400 case EM_TI_C6000
: return "Texas Instruments TMS320C6000 DSP family";
2401 case EM_TI_C2000
: return "Texas Instruments TMS320C2000 DSP family";
2402 case EM_TI_C5500
: return "Texas Instruments TMS320C55x DSP family";
2403 case EM_TI_PRU
: return "TI PRU I/O processor";
2405 case EM_MMDSP_PLUS
: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2406 case EM_CYPRESS_M8C
: return "Cypress M8C microprocessor";
2407 case EM_R32C
: return "Renesas R32C series microprocessors";
2408 case EM_TRIMEDIA
: return "NXP Semiconductors TriMedia architecture family";
2409 case EM_QDSP6
: return "QUALCOMM DSP6 Processor";
2410 case EM_8051
: return "Intel 8051 and variants";
2411 case EM_STXP7X
: return "STMicroelectronics STxP7x family";
2412 case EM_NDS32
: return "Andes Technology compact code size embedded RISC processor family";
2413 case EM_ECOG1X
: return "Cyan Technology eCOG1X family";
2414 case EM_MAXQ30
: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2416 case EM_XIMO16
: return "New Japan Radio (NJR) 16-bit DSP Processor";
2417 case EM_MANIK
: return "M2000 Reconfigurable RISC Microprocessor";
2418 case EM_CRAYNV2
: return "Cray Inc. NV2 vector architecture";
2419 case EM_RX
: return "Renesas RX";
2420 case EM_METAG
: return "Imagination Technologies Meta processor architecture";
2421 case EM_MCST_ELBRUS
: return "MCST Elbrus general purpose hardware architecture";
2422 case EM_ECOG16
: return "Cyan Technology eCOG16 family";
2425 case EM_MICROBLAZE_OLD
: return "Xilinx MicroBlaze";
2426 case EM_ETPU
: return "Freescale Extended Time Processing Unit";
2427 case EM_SLE9X
: return "Infineon Technologies SLE9X core";
2429 case EM_L1OM
: return "Intel L1OM";
2430 case EM_K1OM
: return "Intel K1OM";
2431 case EM_INTEL182
: return "Intel (reserved)";
2432 case EM_AARCH64
: return "AArch64";
2433 case EM_ARM184
: return "ARM (reserved)";
2434 case EM_AVR32
: return "Atmel Corporation 32-bit microprocessor";
2435 case EM_STM8
: return "STMicroeletronics STM8 8-bit microcontroller";
2436 case EM_TILE64
: return "Tilera TILE64 multicore architecture family";
2437 case EM_TILEPRO
: return "Tilera TILEPro multicore architecture family";
2439 case EM_CUDA
: return "NVIDIA CUDA architecture";
2440 case EM_TILEGX
: return "Tilera TILE-Gx multicore architecture family";
2441 case EM_CLOUDSHIELD
: return "CloudShield architecture family";
2442 case EM_COREA_1ST
: return "KIPO-KAIST Core-A 1st generation processor family";
2443 case EM_COREA_2ND
: return "KIPO-KAIST Core-A 2nd generation processor family";
2444 case EM_ARC_COMPACT2
: return "ARCv2";
2445 case EM_OPEN8
: return "Open8 8-bit RISC soft processor core";
2446 case EM_RL78
: return "Renesas RL78";
2447 case EM_VIDEOCORE5
: return "Broadcom VideoCore V processor";
2448 case EM_78K0R
: return "Renesas 78K0R";
2450 case EM_56800EX
: return "Freescale 56800EX Digital Signal Controller (DSC)";
2451 case EM_BA1
: return "Beyond BA1 CPU architecture";
2452 case EM_BA2
: return "Beyond BA2 CPU architecture";
2453 case EM_XCORE
: return "XMOS xCORE processor family";
2454 case EM_MCHP_PIC
: return "Microchip 8-bit PIC(r) family";
2456 case EM_KM32
: return "KM211 KM32 32-bit processor";
2457 case EM_KMX32
: return "KM211 KMX32 32-bit processor";
2458 case EM_KMX16
: return "KM211 KMX16 16-bit processor";
2459 case EM_KMX8
: return "KM211 KMX8 8-bit processor";
2460 case EM_KVARC
: return "KM211 KVARC processor";
2461 case EM_CDP
: return "Paneve CDP architecture family";
2462 case EM_COGE
: return "Cognitive Smart Memory Processor";
2463 case EM_COOL
: return "Bluechip Systems CoolEngine";
2464 case EM_NORC
: return "Nanoradio Optimized RISC";
2465 case EM_CSR_KALIMBA
: return "CSR Kalimba architecture family";
2467 case EM_Z80
: return "Zilog Z80";
2468 case EM_VISIUM
: return "CDS VISIUMcore processor";
2469 case EM_FT32
: return "FTDI Chip FT32";
2470 case EM_MOXIE
: return "Moxie";
2471 case EM_AMDGPU
: return "AMD GPU";
2472 case EM_RISCV
: return "RISC-V";
2473 case EM_LANAI
: return "Lanai 32-bit processor";
2474 case EM_BPF
: return "Linux BPF";
2476 /* Large numbers... */
2477 case EM_MT
: return "Morpho Techologies MT processor";
2478 case EM_ALPHA
: return "Alpha";
2479 case EM_WEBASSEMBLY
: return "Web Assembly";
2480 case EM_DLX
: return "OpenDLX";
2481 case EM_XSTORMY16
: return "Sanyo XStormy16 CPU core";
2482 case EM_IQ2000
: return "Vitesse IQ2000";
2484 case EM_NIOS32
: return "Altera Nios";
2485 case EM_CYGNUS_MEP
: return "Toshiba MeP Media Engine";
2486 case EM_ADAPTEVA_EPIPHANY
: return "Adapteva EPIPHANY";
2487 case EM_CYGNUS_FRV
: return "Fujitsu FR-V";
2490 snprintf (buff
, sizeof (buff
), _("<unknown>: 0x%x"), e_machine
);
2496 decode_ARC_machine_flags (unsigned e_flags
, unsigned e_machine
, char buf
[])
2498 /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2. Some
2499 other compilers don't a specific architecture type in the e_flags, and
2500 instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
2501 architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
2504 Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
2505 but also sets a specific architecture type in the e_flags field.
2507 However, when decoding the flags we don't worry if we see an
2508 unexpected pairing, for example EM_ARC_COMPACT machine type, with
2509 ARCEM architecture type. */
2511 switch (e_flags
& EF_ARC_MACH_MSK
)
2513 /* We only expect these to occur for EM_ARC_COMPACT2. */
2514 case EF_ARC_CPU_ARCV2EM
:
2515 strcat (buf
, ", ARC EM");
2517 case EF_ARC_CPU_ARCV2HS
:
2518 strcat (buf
, ", ARC HS");
2521 /* We only expect these to occur for EM_ARC_COMPACT. */
2522 case E_ARC_MACH_ARC600
:
2523 strcat (buf
, ", ARC600");
2525 case E_ARC_MACH_ARC601
:
2526 strcat (buf
, ", ARC601");
2528 case E_ARC_MACH_ARC700
:
2529 strcat (buf
, ", ARC700");
2532 /* The only times we should end up here are (a) A corrupt ELF, (b) A
2533 new ELF with new architecture being read by an old version of
2534 readelf, or (c) An ELF built with non-GNU compiler that does not
2535 set the architecture in the e_flags. */
2537 if (e_machine
== EM_ARC_COMPACT
)
2538 strcat (buf
, ", Unknown ARCompact");
2540 strcat (buf
, ", Unknown ARC");
2544 switch (e_flags
& EF_ARC_OSABI_MSK
)
2546 case E_ARC_OSABI_ORIG
:
2547 strcat (buf
, ", (ABI:legacy)");
2549 case E_ARC_OSABI_V2
:
2550 strcat (buf
, ", (ABI:v2)");
2552 /* Only upstream 3.9+ kernels will support ARCv2 ISA. */
2553 case E_ARC_OSABI_V3
:
2554 strcat (buf
, ", v3 no-legacy-syscalls ABI");
2556 case E_ARC_OSABI_V4
:
2557 strcat (buf
, ", v4 ABI");
2560 strcat (buf
, ", unrecognised ARC OSABI flag");
2566 decode_ARM_machine_flags (unsigned e_flags
, char buf
[])
2569 bfd_boolean unknown
= FALSE
;
2571 eabi
= EF_ARM_EABI_VERSION (e_flags
);
2572 e_flags
&= ~ EF_ARM_EABIMASK
;
2574 /* Handle "generic" ARM flags. */
2575 if (e_flags
& EF_ARM_RELEXEC
)
2577 strcat (buf
, ", relocatable executable");
2578 e_flags
&= ~ EF_ARM_RELEXEC
;
2581 if (e_flags
& EF_ARM_PIC
)
2583 strcat (buf
, ", position independent");
2584 e_flags
&= ~ EF_ARM_PIC
;
2587 /* Now handle EABI specific flags. */
2591 strcat (buf
, ", <unrecognized EABI>");
2596 case EF_ARM_EABI_VER1
:
2597 strcat (buf
, ", Version1 EABI");
2602 /* Process flags one bit at a time. */
2603 flag
= e_flags
& - e_flags
;
2608 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2609 strcat (buf
, ", sorted symbol tables");
2619 case EF_ARM_EABI_VER2
:
2620 strcat (buf
, ", Version2 EABI");
2625 /* Process flags one bit at a time. */
2626 flag
= e_flags
& - e_flags
;
2631 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2632 strcat (buf
, ", sorted symbol tables");
2635 case EF_ARM_DYNSYMSUSESEGIDX
:
2636 strcat (buf
, ", dynamic symbols use segment index");
2639 case EF_ARM_MAPSYMSFIRST
:
2640 strcat (buf
, ", mapping symbols precede others");
2650 case EF_ARM_EABI_VER3
:
2651 strcat (buf
, ", Version3 EABI");
2654 case EF_ARM_EABI_VER4
:
2655 strcat (buf
, ", Version4 EABI");
2660 /* Process flags one bit at a time. */
2661 flag
= e_flags
& - e_flags
;
2667 strcat (buf
, ", BE8");
2671 strcat (buf
, ", LE8");
2681 case EF_ARM_EABI_VER5
:
2682 strcat (buf
, ", Version5 EABI");
2687 /* Process flags one bit at a time. */
2688 flag
= e_flags
& - e_flags
;
2694 strcat (buf
, ", BE8");
2698 strcat (buf
, ", LE8");
2701 case EF_ARM_ABI_FLOAT_SOFT
: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2702 strcat (buf
, ", soft-float ABI");
2705 case EF_ARM_ABI_FLOAT_HARD
: /* Conflicts with EF_ARM_VFP_FLOAT. */
2706 strcat (buf
, ", hard-float ABI");
2716 case EF_ARM_EABI_UNKNOWN
:
2717 strcat (buf
, ", GNU EABI");
2722 /* Process flags one bit at a time. */
2723 flag
= e_flags
& - e_flags
;
2728 case EF_ARM_INTERWORK
:
2729 strcat (buf
, ", interworking enabled");
2732 case EF_ARM_APCS_26
:
2733 strcat (buf
, ", uses APCS/26");
2736 case EF_ARM_APCS_FLOAT
:
2737 strcat (buf
, ", uses APCS/float");
2741 strcat (buf
, ", position independent");
2745 strcat (buf
, ", 8 bit structure alignment");
2748 case EF_ARM_NEW_ABI
:
2749 strcat (buf
, ", uses new ABI");
2752 case EF_ARM_OLD_ABI
:
2753 strcat (buf
, ", uses old ABI");
2756 case EF_ARM_SOFT_FLOAT
:
2757 strcat (buf
, ", software FP");
2760 case EF_ARM_VFP_FLOAT
:
2761 strcat (buf
, ", VFP");
2764 case EF_ARM_MAVERICK_FLOAT
:
2765 strcat (buf
, ", Maverick FP");
2776 strcat (buf
,_(", <unknown>"));
2780 decode_AVR_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2782 --size
; /* Leave space for null terminator. */
2784 switch (e_flags
& EF_AVR_MACH
)
2786 case E_AVR_MACH_AVR1
:
2787 strncat (buf
, ", avr:1", size
);
2789 case E_AVR_MACH_AVR2
:
2790 strncat (buf
, ", avr:2", size
);
2792 case E_AVR_MACH_AVR25
:
2793 strncat (buf
, ", avr:25", size
);
2795 case E_AVR_MACH_AVR3
:
2796 strncat (buf
, ", avr:3", size
);
2798 case E_AVR_MACH_AVR31
:
2799 strncat (buf
, ", avr:31", size
);
2801 case E_AVR_MACH_AVR35
:
2802 strncat (buf
, ", avr:35", size
);
2804 case E_AVR_MACH_AVR4
:
2805 strncat (buf
, ", avr:4", size
);
2807 case E_AVR_MACH_AVR5
:
2808 strncat (buf
, ", avr:5", size
);
2810 case E_AVR_MACH_AVR51
:
2811 strncat (buf
, ", avr:51", size
);
2813 case E_AVR_MACH_AVR6
:
2814 strncat (buf
, ", avr:6", size
);
2816 case E_AVR_MACH_AVRTINY
:
2817 strncat (buf
, ", avr:100", size
);
2819 case E_AVR_MACH_XMEGA1
:
2820 strncat (buf
, ", avr:101", size
);
2822 case E_AVR_MACH_XMEGA2
:
2823 strncat (buf
, ", avr:102", size
);
2825 case E_AVR_MACH_XMEGA3
:
2826 strncat (buf
, ", avr:103", size
);
2828 case E_AVR_MACH_XMEGA4
:
2829 strncat (buf
, ", avr:104", size
);
2831 case E_AVR_MACH_XMEGA5
:
2832 strncat (buf
, ", avr:105", size
);
2834 case E_AVR_MACH_XMEGA6
:
2835 strncat (buf
, ", avr:106", size
);
2837 case E_AVR_MACH_XMEGA7
:
2838 strncat (buf
, ", avr:107", size
);
2841 strncat (buf
, ", avr:<unknown>", size
);
2845 size
-= strlen (buf
);
2846 if (e_flags
& EF_AVR_LINKRELAX_PREPARED
)
2847 strncat (buf
, ", link-relax", size
);
2851 decode_NDS32_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2857 bfd_boolean has_fpu
= FALSE
;
2860 static const char *ABI_STRINGS
[] =
2862 "ABI v0", /* use r5 as return register; only used in N1213HC */
2863 "ABI v1", /* use r0 as return register */
2864 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2865 "ABI v2fp", /* for FPU */
2869 static const char *VER_STRINGS
[] =
2871 "Andes ELF V1.3 or older",
2875 static const char *ARCH_STRINGS
[] =
2884 abi
= EF_NDS_ABI
& e_flags
;
2885 arch
= EF_NDS_ARCH
& e_flags
;
2886 config
= EF_NDS_INST
& e_flags
;
2887 version
= EF_NDS32_ELF_VERSION
& e_flags
;
2889 memset (buf
, 0, size
);
2896 case E_NDS_ABI_V2FP
:
2897 case E_NDS_ABI_AABI
:
2898 case E_NDS_ABI_V2FP_PLUS
:
2899 /* In case there are holes in the array. */
2900 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ABI_STRINGS
[abi
>> EF_NDS_ABI_SHIFT
]);
2904 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ABI>");
2910 case E_NDS32_ELF_VER_1_2
:
2911 case E_NDS32_ELF_VER_1_3
:
2912 case E_NDS32_ELF_VER_1_4
:
2913 r
+= snprintf (buf
+ r
, size
- r
, ", %s", VER_STRINGS
[version
>> EF_NDS32_ELF_VERSION_SHIFT
]);
2917 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ELF version number>");
2921 if (E_NDS_ABI_V0
== abi
)
2923 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2924 r
+= snprintf (buf
+ r
, size
- r
, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2925 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2926 r
+= snprintf (buf
+ r
, size
-r
, ", 16b"); /* has 16-bit instructions */
2932 case E_NDS_ARCH_STAR_V1_0
:
2933 case E_NDS_ARCH_STAR_V2_0
:
2934 case E_NDS_ARCH_STAR_V3_0
:
2935 case E_NDS_ARCH_STAR_V3_M
:
2936 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ARCH_STRINGS
[arch
>> EF_NDS_ARCH_SHIFT
]);
2940 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized architecture>");
2941 /* ARCH version determines how the e_flags are interpreted.
2942 If it is unknown, we cannot proceed. */
2946 /* Newer ABI; Now handle architecture specific flags. */
2947 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2949 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2950 r
+= snprintf (buf
+ r
, size
-r
, ", MFUSR_PC");
2952 if (!(config
& E_NDS32_HAS_NO_MAC_INST
))
2953 r
+= snprintf (buf
+ r
, size
-r
, ", MAC");
2955 if (config
& E_NDS32_HAS_DIV_INST
)
2956 r
+= snprintf (buf
+ r
, size
-r
, ", DIV");
2958 if (config
& E_NDS32_HAS_16BIT_INST
)
2959 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
2963 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2965 if (version
<= E_NDS32_ELF_VER_1_3
)
2966 r
+= snprintf (buf
+ r
, size
-r
, ", [B8]");
2968 r
+= snprintf (buf
+ r
, size
-r
, ", EX9");
2971 if (config
& E_NDS32_HAS_MAC_DX_INST
)
2972 r
+= snprintf (buf
+ r
, size
-r
, ", MAC_DX");
2974 if (config
& E_NDS32_HAS_DIV_DX_INST
)
2975 r
+= snprintf (buf
+ r
, size
-r
, ", DIV_DX");
2977 if (config
& E_NDS32_HAS_16BIT_INST
)
2979 if (version
<= E_NDS32_ELF_VER_1_3
)
2980 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
2982 r
+= snprintf (buf
+ r
, size
-r
, ", IFC");
2986 if (config
& E_NDS32_HAS_EXT_INST
)
2987 r
+= snprintf (buf
+ r
, size
-r
, ", PERF1");
2989 if (config
& E_NDS32_HAS_EXT2_INST
)
2990 r
+= snprintf (buf
+ r
, size
-r
, ", PERF2");
2992 if (config
& E_NDS32_HAS_FPU_INST
)
2995 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_SP");
2998 if (config
& E_NDS32_HAS_FPU_DP_INST
)
3001 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_DP");
3004 if (config
& E_NDS32_HAS_FPU_MAC_INST
)
3007 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_MAC");
3012 switch ((config
& E_NDS32_FPU_REG_CONF
) >> E_NDS32_FPU_REG_CONF_SHIFT
)
3014 case E_NDS32_FPU_REG_8SP_4DP
:
3015 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:8/4");
3017 case E_NDS32_FPU_REG_16SP_8DP
:
3018 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:16/8");
3020 case E_NDS32_FPU_REG_32SP_16DP
:
3021 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/16");
3023 case E_NDS32_FPU_REG_32SP_32DP
:
3024 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/32");
3029 if (config
& E_NDS32_HAS_AUDIO_INST
)
3030 r
+= snprintf (buf
+ r
, size
-r
, ", AUDIO");
3032 if (config
& E_NDS32_HAS_STRING_INST
)
3033 r
+= snprintf (buf
+ r
, size
-r
, ", STR");
3035 if (config
& E_NDS32_HAS_REDUCED_REGS
)
3036 r
+= snprintf (buf
+ r
, size
-r
, ", 16REG");
3038 if (config
& E_NDS32_HAS_VIDEO_INST
)
3040 if (version
<= E_NDS32_ELF_VER_1_3
)
3041 r
+= snprintf (buf
+ r
, size
-r
, ", VIDEO");
3043 r
+= snprintf (buf
+ r
, size
-r
, ", SATURATION");
3046 if (config
& E_NDS32_HAS_ENCRIPT_INST
)
3047 r
+= snprintf (buf
+ r
, size
-r
, ", ENCRP");
3049 if (config
& E_NDS32_HAS_L2C_INST
)
3050 r
+= snprintf (buf
+ r
, size
-r
, ", L2C");
3054 get_machine_flags (Filedata
* filedata
, unsigned e_flags
, unsigned e_machine
)
3056 static char buf
[1024];
3067 case EM_ARC_COMPACT2
:
3068 case EM_ARC_COMPACT
:
3069 decode_ARC_machine_flags (e_flags
, e_machine
, buf
);
3073 decode_ARM_machine_flags (e_flags
, buf
);
3077 decode_AVR_machine_flags (e_flags
, buf
, sizeof buf
);
3081 if (e_flags
& EF_BFIN_PIC
)
3082 strcat (buf
, ", PIC");
3084 if (e_flags
& EF_BFIN_FDPIC
)
3085 strcat (buf
, ", FDPIC");
3087 if (e_flags
& EF_BFIN_CODE_IN_L1
)
3088 strcat (buf
, ", code in L1");
3090 if (e_flags
& EF_BFIN_DATA_IN_L1
)
3091 strcat (buf
, ", data in L1");
3096 switch (e_flags
& EF_FRV_CPU_MASK
)
3098 case EF_FRV_CPU_GENERIC
:
3102 strcat (buf
, ", fr???");
3105 case EF_FRV_CPU_FR300
:
3106 strcat (buf
, ", fr300");
3109 case EF_FRV_CPU_FR400
:
3110 strcat (buf
, ", fr400");
3112 case EF_FRV_CPU_FR405
:
3113 strcat (buf
, ", fr405");
3116 case EF_FRV_CPU_FR450
:
3117 strcat (buf
, ", fr450");
3120 case EF_FRV_CPU_FR500
:
3121 strcat (buf
, ", fr500");
3123 case EF_FRV_CPU_FR550
:
3124 strcat (buf
, ", fr550");
3127 case EF_FRV_CPU_SIMPLE
:
3128 strcat (buf
, ", simple");
3130 case EF_FRV_CPU_TOMCAT
:
3131 strcat (buf
, ", tomcat");
3137 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
3138 strcat (buf
, ", m68000");
3139 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
3140 strcat (buf
, ", cpu32");
3141 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
3142 strcat (buf
, ", fido_a");
3145 char const * isa
= _("unknown");
3146 char const * mac
= _("unknown mac");
3147 char const * additional
= NULL
;
3149 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
3151 case EF_M68K_CF_ISA_A_NODIV
:
3153 additional
= ", nodiv";
3155 case EF_M68K_CF_ISA_A
:
3158 case EF_M68K_CF_ISA_A_PLUS
:
3161 case EF_M68K_CF_ISA_B_NOUSP
:
3163 additional
= ", nousp";
3165 case EF_M68K_CF_ISA_B
:
3168 case EF_M68K_CF_ISA_C
:
3171 case EF_M68K_CF_ISA_C_NODIV
:
3173 additional
= ", nodiv";
3176 strcat (buf
, ", cf, isa ");
3179 strcat (buf
, additional
);
3180 if (e_flags
& EF_M68K_CF_FLOAT
)
3181 strcat (buf
, ", float");
3182 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
3187 case EF_M68K_CF_MAC
:
3190 case EF_M68K_CF_EMAC
:
3193 case EF_M68K_CF_EMAC_B
:
3206 switch (e_flags
& EF_MEP_CPU_MASK
)
3208 case EF_MEP_CPU_MEP
: strcat (buf
, ", generic MeP"); break;
3209 case EF_MEP_CPU_C2
: strcat (buf
, ", MeP C2"); break;
3210 case EF_MEP_CPU_C3
: strcat (buf
, ", MeP C3"); break;
3211 case EF_MEP_CPU_C4
: strcat (buf
, ", MeP C4"); break;
3212 case EF_MEP_CPU_C5
: strcat (buf
, ", MeP C5"); break;
3213 case EF_MEP_CPU_H1
: strcat (buf
, ", MeP H1"); break;
3214 default: strcat (buf
, _(", <unknown MeP cpu type>")); break;
3217 switch (e_flags
& EF_MEP_COP_MASK
)
3219 case EF_MEP_COP_NONE
: break;
3220 case EF_MEP_COP_AVC
: strcat (buf
, ", AVC coprocessor"); break;
3221 case EF_MEP_COP_AVC2
: strcat (buf
, ", AVC2 coprocessor"); break;
3222 case EF_MEP_COP_FMAX
: strcat (buf
, ", FMAX coprocessor"); break;
3223 case EF_MEP_COP_IVC2
: strcat (buf
, ", IVC2 coprocessor"); break;
3224 default: strcat (buf
, _("<unknown MeP copro type>")); break;
3227 if (e_flags
& EF_MEP_LIBRARY
)
3228 strcat (buf
, ", Built for Library");
3230 if (e_flags
& EF_MEP_INDEX_MASK
)
3231 sprintf (buf
+ strlen (buf
), ", Configuration Index: %#x",
3232 e_flags
& EF_MEP_INDEX_MASK
);
3234 if (e_flags
& ~ EF_MEP_ALL_FLAGS
)
3235 sprintf (buf
+ strlen (buf
), _(", unknown flags bits: %#x"),
3236 e_flags
& ~ EF_MEP_ALL_FLAGS
);
3240 if (e_flags
& EF_PPC_EMB
)
3241 strcat (buf
, ", emb");
3243 if (e_flags
& EF_PPC_RELOCATABLE
)
3244 strcat (buf
, _(", relocatable"));
3246 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
3247 strcat (buf
, _(", relocatable-lib"));
3251 if (e_flags
& EF_PPC64_ABI
)
3253 char abi
[] = ", abiv0";
3255 abi
[6] += e_flags
& EF_PPC64_ABI
;
3261 if ((e_flags
& EF_RH850_ABI
) == EF_RH850_ABI
)
3262 strcat (buf
, ", RH850 ABI");
3264 if (e_flags
& EF_V800_850E3
)
3265 strcat (buf
, ", V3 architecture");
3267 if ((e_flags
& (EF_RH850_FPU_DOUBLE
| EF_RH850_FPU_SINGLE
)) == 0)
3268 strcat (buf
, ", FPU not used");
3270 if ((e_flags
& (EF_RH850_REGMODE22
| EF_RH850_REGMODE32
)) == 0)
3271 strcat (buf
, ", regmode: COMMON");
3273 if ((e_flags
& (EF_RH850_GP_FIX
| EF_RH850_GP_NOFIX
)) == 0)
3274 strcat (buf
, ", r4 not used");
3276 if ((e_flags
& (EF_RH850_EP_FIX
| EF_RH850_EP_NOFIX
)) == 0)
3277 strcat (buf
, ", r30 not used");
3279 if ((e_flags
& (EF_RH850_TP_FIX
| EF_RH850_TP_NOFIX
)) == 0)
3280 strcat (buf
, ", r5 not used");
3282 if ((e_flags
& (EF_RH850_REG2_RESERVE
| EF_RH850_REG2_NORESERVE
)) == 0)
3283 strcat (buf
, ", r2 not used");
3285 for (e_flags
&= 0xFFFF; e_flags
; e_flags
&= ~ (e_flags
& - e_flags
))
3287 switch (e_flags
& - e_flags
)
3289 case EF_RH850_FPU_DOUBLE
: strcat (buf
, ", double precision FPU"); break;
3290 case EF_RH850_FPU_SINGLE
: strcat (buf
, ", single precision FPU"); break;
3291 case EF_RH850_REGMODE22
: strcat (buf
, ", regmode:22"); break;
3292 case EF_RH850_REGMODE32
: strcat (buf
, ", regmode:23"); break;
3293 case EF_RH850_GP_FIX
: strcat (buf
, ", r4 fixed"); break;
3294 case EF_RH850_GP_NOFIX
: strcat (buf
, ", r4 free"); break;
3295 case EF_RH850_EP_FIX
: strcat (buf
, ", r30 fixed"); break;
3296 case EF_RH850_EP_NOFIX
: strcat (buf
, ", r30 free"); break;
3297 case EF_RH850_TP_FIX
: strcat (buf
, ", r5 fixed"); break;
3298 case EF_RH850_TP_NOFIX
: strcat (buf
, ", r5 free"); break;
3299 case EF_RH850_REG2_RESERVE
: strcat (buf
, ", r2 fixed"); break;
3300 case EF_RH850_REG2_NORESERVE
: strcat (buf
, ", r2 free"); break;
3307 case EM_CYGNUS_V850
:
3308 switch (e_flags
& EF_V850_ARCH
)
3310 case E_V850E3V5_ARCH
:
3311 strcat (buf
, ", v850e3v5");
3313 case E_V850E2V3_ARCH
:
3314 strcat (buf
, ", v850e2v3");
3317 strcat (buf
, ", v850e2");
3320 strcat (buf
, ", v850e1");
3323 strcat (buf
, ", v850e");
3326 strcat (buf
, ", v850");
3329 strcat (buf
, _(", unknown v850 architecture variant"));
3335 case EM_CYGNUS_M32R
:
3336 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
3337 strcat (buf
, ", m32r");
3341 case EM_MIPS_RS3_LE
:
3342 if (e_flags
& EF_MIPS_NOREORDER
)
3343 strcat (buf
, ", noreorder");
3345 if (e_flags
& EF_MIPS_PIC
)
3346 strcat (buf
, ", pic");
3348 if (e_flags
& EF_MIPS_CPIC
)
3349 strcat (buf
, ", cpic");
3351 if (e_flags
& EF_MIPS_UCODE
)
3352 strcat (buf
, ", ugen_reserved");
3354 if (e_flags
& EF_MIPS_ABI2
)
3355 strcat (buf
, ", abi2");
3357 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
3358 strcat (buf
, ", odk first");
3360 if (e_flags
& EF_MIPS_32BITMODE
)
3361 strcat (buf
, ", 32bitmode");
3363 if (e_flags
& EF_MIPS_NAN2008
)
3364 strcat (buf
, ", nan2008");
3366 if (e_flags
& EF_MIPS_FP64
)
3367 strcat (buf
, ", fp64");
3369 switch ((e_flags
& EF_MIPS_MACH
))
3371 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
3372 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
3373 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
3374 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
3375 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
3376 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
3377 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
3378 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
3379 case E_MIPS_MACH_5900
: strcat (buf
, ", 5900"); break;
3380 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
3381 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
3382 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
3383 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
3384 case E_MIPS_MACH_LS3A
: strcat (buf
, ", loongson-3a"); break;
3385 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
3386 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
3387 case E_MIPS_MACH_OCTEON3
: strcat (buf
, ", octeon3"); break;
3388 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
3389 case E_MIPS_MACH_IAMR2
: strcat (buf
, ", interaptiv-mr2"); break;
3391 /* We simply ignore the field in this case to avoid confusion:
3392 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3395 default: strcat (buf
, _(", unknown CPU")); break;
3398 switch ((e_flags
& EF_MIPS_ABI
))
3400 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
3401 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
3402 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
3403 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
3405 /* We simply ignore the field in this case to avoid confusion:
3406 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3407 This means it is likely to be an o32 file, but not for
3410 default: strcat (buf
, _(", unknown ABI")); break;
3413 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
3414 strcat (buf
, ", mdmx");
3416 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
3417 strcat (buf
, ", mips16");
3419 if (e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
3420 strcat (buf
, ", micromips");
3422 switch ((e_flags
& EF_MIPS_ARCH
))
3424 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
3425 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
3426 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
3427 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
3428 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
3429 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
3430 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
3431 case E_MIPS_ARCH_32R6
: strcat (buf
, ", mips32r6"); break;
3432 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
3433 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
3434 case E_MIPS_ARCH_64R6
: strcat (buf
, ", mips64r6"); break;
3435 default: strcat (buf
, _(", unknown ISA")); break;
3440 decode_NDS32_machine_flags (e_flags
, buf
, sizeof buf
);
3444 if (e_flags
& EF_RISCV_RVC
)
3445 strcat (buf
, ", RVC");
3447 switch (e_flags
& EF_RISCV_FLOAT_ABI
)
3449 case EF_RISCV_FLOAT_ABI_SOFT
:
3450 strcat (buf
, ", soft-float ABI");
3453 case EF_RISCV_FLOAT_ABI_SINGLE
:
3454 strcat (buf
, ", single-float ABI");
3457 case EF_RISCV_FLOAT_ABI_DOUBLE
:
3458 strcat (buf
, ", double-float ABI");
3461 case EF_RISCV_FLOAT_ABI_QUAD
:
3462 strcat (buf
, ", quad-float ABI");
3468 switch ((e_flags
& EF_SH_MACH_MASK
))
3470 case EF_SH1
: strcat (buf
, ", sh1"); break;
3471 case EF_SH2
: strcat (buf
, ", sh2"); break;
3472 case EF_SH3
: strcat (buf
, ", sh3"); break;
3473 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
3474 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
3475 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
3476 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
3477 case EF_SH4
: strcat (buf
, ", sh4"); break;
3478 case EF_SH5
: strcat (buf
, ", sh5"); break;
3479 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
3480 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
3481 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
3482 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
3483 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
3484 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
3485 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
3486 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
3487 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3488 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
3489 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
3490 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
3491 default: strcat (buf
, _(", unknown ISA")); break;
3494 if (e_flags
& EF_SH_PIC
)
3495 strcat (buf
, ", pic");
3497 if (e_flags
& EF_SH_FDPIC
)
3498 strcat (buf
, ", fdpic");
3502 if (e_flags
& EF_OR1K_NODELAY
)
3503 strcat (buf
, ", no delay");
3507 if (e_flags
& EF_SPARC_32PLUS
)
3508 strcat (buf
, ", v8+");
3510 if (e_flags
& EF_SPARC_SUN_US1
)
3511 strcat (buf
, ", ultrasparcI");
3513 if (e_flags
& EF_SPARC_SUN_US3
)
3514 strcat (buf
, ", ultrasparcIII");
3516 if (e_flags
& EF_SPARC_HAL_R1
)
3517 strcat (buf
, ", halr1");
3519 if (e_flags
& EF_SPARC_LEDATA
)
3520 strcat (buf
, ", ledata");
3522 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
3523 strcat (buf
, ", tso");
3525 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
3526 strcat (buf
, ", pso");
3528 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
3529 strcat (buf
, ", rmo");
3533 switch (e_flags
& EF_PARISC_ARCH
)
3535 case EFA_PARISC_1_0
:
3536 strcpy (buf
, ", PA-RISC 1.0");
3538 case EFA_PARISC_1_1
:
3539 strcpy (buf
, ", PA-RISC 1.1");
3541 case EFA_PARISC_2_0
:
3542 strcpy (buf
, ", PA-RISC 2.0");
3547 if (e_flags
& EF_PARISC_TRAPNIL
)
3548 strcat (buf
, ", trapnil");
3549 if (e_flags
& EF_PARISC_EXT
)
3550 strcat (buf
, ", ext");
3551 if (e_flags
& EF_PARISC_LSB
)
3552 strcat (buf
, ", lsb");
3553 if (e_flags
& EF_PARISC_WIDE
)
3554 strcat (buf
, ", wide");
3555 if (e_flags
& EF_PARISC_NO_KABP
)
3556 strcat (buf
, ", no kabp");
3557 if (e_flags
& EF_PARISC_LAZYSWAP
)
3558 strcat (buf
, ", lazyswap");
3563 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
3564 strcat (buf
, ", new calling convention");
3566 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
3567 strcat (buf
, ", gnu calling convention");
3571 if ((e_flags
& EF_IA_64_ABI64
))
3572 strcat (buf
, ", 64-bit");
3574 strcat (buf
, ", 32-bit");
3575 if ((e_flags
& EF_IA_64_REDUCEDFP
))
3576 strcat (buf
, ", reduced fp model");
3577 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
3578 strcat (buf
, ", no function descriptors, constant gp");
3579 else if ((e_flags
& EF_IA_64_CONS_GP
))
3580 strcat (buf
, ", constant gp");
3581 if ((e_flags
& EF_IA_64_ABSOLUTE
))
3582 strcat (buf
, ", absolute");
3583 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
3585 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
3586 strcat (buf
, ", vms_linkages");
3587 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
3589 case EF_IA_64_VMS_COMCOD_SUCCESS
:
3591 case EF_IA_64_VMS_COMCOD_WARNING
:
3592 strcat (buf
, ", warning");
3594 case EF_IA_64_VMS_COMCOD_ERROR
:
3595 strcat (buf
, ", error");
3597 case EF_IA_64_VMS_COMCOD_ABORT
:
3598 strcat (buf
, ", abort");
3601 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3602 e_flags
& EF_IA_64_VMS_COMCOD
);
3603 strcat (buf
, ", <unknown>");
3609 if ((e_flags
& EF_VAX_NONPIC
))
3610 strcat (buf
, ", non-PIC");
3611 if ((e_flags
& EF_VAX_DFLOAT
))
3612 strcat (buf
, ", D-Float");
3613 if ((e_flags
& EF_VAX_GFLOAT
))
3614 strcat (buf
, ", G-Float");
3618 if (e_flags
& EF_VISIUM_ARCH_MCM
)
3619 strcat (buf
, ", mcm");
3620 else if (e_flags
& EF_VISIUM_ARCH_MCM24
)
3621 strcat (buf
, ", mcm24");
3622 if (e_flags
& EF_VISIUM_ARCH_GR6
)
3623 strcat (buf
, ", gr6");
3627 switch (e_flags
& E_FLAG_RL78_CPU_MASK
)
3629 case E_FLAG_RL78_ANY_CPU
: break;
3630 case E_FLAG_RL78_G10
: strcat (buf
, ", G10"); break;
3631 case E_FLAG_RL78_G13
: strcat (buf
, ", G13"); break;
3632 case E_FLAG_RL78_G14
: strcat (buf
, ", G14"); break;
3634 if (e_flags
& E_FLAG_RL78_64BIT_DOUBLES
)
3635 strcat (buf
, ", 64-bit doubles");
3639 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
3640 strcat (buf
, ", 64-bit doubles");
3641 if (e_flags
& E_FLAG_RX_DSP
)
3642 strcat (buf
, ", dsp");
3643 if (e_flags
& E_FLAG_RX_PID
)
3644 strcat (buf
, ", pid");
3645 if (e_flags
& E_FLAG_RX_ABI
)
3646 strcat (buf
, ", RX ABI");
3647 if (e_flags
& E_FLAG_RX_SINSNS_SET
)
3648 strcat (buf
, e_flags
& E_FLAG_RX_SINSNS_YES
3649 ? ", uses String instructions" : ", bans String instructions");
3650 if (e_flags
& E_FLAG_RX_V2
)
3651 strcat (buf
, ", V2");
3655 if (e_flags
& EF_S390_HIGH_GPRS
)
3656 strcat (buf
, ", highgprs");
3660 if ((e_flags
& EF_C6000_REL
))
3661 strcat (buf
, ", relocatable module");
3665 strcat (buf
, _(": architecture variant: "));
3666 switch (e_flags
& EF_MSP430_MACH
)
3668 case E_MSP430_MACH_MSP430x11
: strcat (buf
, "MSP430x11"); break;
3669 case E_MSP430_MACH_MSP430x11x1
: strcat (buf
, "MSP430x11x1 "); break;
3670 case E_MSP430_MACH_MSP430x12
: strcat (buf
, "MSP430x12"); break;
3671 case E_MSP430_MACH_MSP430x13
: strcat (buf
, "MSP430x13"); break;
3672 case E_MSP430_MACH_MSP430x14
: strcat (buf
, "MSP430x14"); break;
3673 case E_MSP430_MACH_MSP430x15
: strcat (buf
, "MSP430x15"); break;
3674 case E_MSP430_MACH_MSP430x16
: strcat (buf
, "MSP430x16"); break;
3675 case E_MSP430_MACH_MSP430x31
: strcat (buf
, "MSP430x31"); break;
3676 case E_MSP430_MACH_MSP430x32
: strcat (buf
, "MSP430x32"); break;
3677 case E_MSP430_MACH_MSP430x33
: strcat (buf
, "MSP430x33"); break;
3678 case E_MSP430_MACH_MSP430x41
: strcat (buf
, "MSP430x41"); break;
3679 case E_MSP430_MACH_MSP430x42
: strcat (buf
, "MSP430x42"); break;
3680 case E_MSP430_MACH_MSP430x43
: strcat (buf
, "MSP430x43"); break;
3681 case E_MSP430_MACH_MSP430x44
: strcat (buf
, "MSP430x44"); break;
3682 case E_MSP430_MACH_MSP430X
: strcat (buf
, "MSP430X"); break;
3684 strcat (buf
, _(": unknown")); break;
3687 if (e_flags
& ~ EF_MSP430_MACH
)
3688 strcat (buf
, _(": unknown extra flag bits also present"));
3696 get_osabi_name (Filedata
* filedata
, unsigned int osabi
)
3698 static char buff
[32];
3702 case ELFOSABI_NONE
: return "UNIX - System V";
3703 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
3704 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
3705 case ELFOSABI_GNU
: return "UNIX - GNU";
3706 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
3707 case ELFOSABI_AIX
: return "UNIX - AIX";
3708 case ELFOSABI_IRIX
: return "UNIX - IRIX";
3709 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
3710 case ELFOSABI_TRU64
: return "UNIX - TRU64";
3711 case ELFOSABI_MODESTO
: return "Novell - Modesto";
3712 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
3713 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
3714 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
3715 case ELFOSABI_AROS
: return "AROS";
3716 case ELFOSABI_FENIXOS
: return "FenixOS";
3717 case ELFOSABI_CLOUDABI
: return "Nuxi CloudABI";
3718 case ELFOSABI_OPENVOS
: return "Stratus Technologies OpenVOS";
3721 switch (filedata
->file_header
.e_machine
)
3726 case ELFOSABI_ARM
: return "ARM";
3727 case ELFOSABI_ARM_FDPIC
: return "ARM FDPIC";
3738 case ELFOSABI_STANDALONE
: return _("Standalone App");
3747 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
3748 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
3757 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
3763 get_aarch64_segment_type (unsigned long type
)
3767 case PT_AARCH64_ARCHEXT
: return "AARCH64_ARCHEXT";
3768 default: return NULL
;
3773 get_arm_segment_type (unsigned long type
)
3777 case PT_ARM_EXIDX
: return "EXIDX";
3778 default: return NULL
;
3783 get_s390_segment_type (unsigned long type
)
3787 case PT_S390_PGSTE
: return "S390_PGSTE";
3788 default: return NULL
;
3793 get_mips_segment_type (unsigned long type
)
3797 case PT_MIPS_REGINFO
: return "REGINFO";
3798 case PT_MIPS_RTPROC
: return "RTPROC";
3799 case PT_MIPS_OPTIONS
: return "OPTIONS";
3800 case PT_MIPS_ABIFLAGS
: return "ABIFLAGS";
3801 default: return NULL
;
3806 get_parisc_segment_type (unsigned long type
)
3810 case PT_HP_TLS
: return "HP_TLS";
3811 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
3812 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
3813 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
3814 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
3815 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
3816 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
3817 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
3818 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
3819 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
3820 case PT_HP_PARALLEL
: return "HP_PARALLEL";
3821 case PT_HP_FASTBIND
: return "HP_FASTBIND";
3822 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
3823 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
3824 case PT_HP_STACK
: return "HP_STACK";
3825 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
3826 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
3827 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
3828 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
3829 default: return NULL
;
3834 get_ia64_segment_type (unsigned long type
)
3838 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
3839 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
3840 case PT_HP_TLS
: return "HP_TLS";
3841 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
3842 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
3843 case PT_IA_64_HP_STACK
: return "HP_STACK";
3844 default: return NULL
;
3849 get_tic6x_segment_type (unsigned long type
)
3853 case PT_C6000_PHATTR
: return "C6000_PHATTR";
3854 default: return NULL
;
3859 get_solaris_segment_type (unsigned long type
)
3863 case 0x6464e550: return "PT_SUNW_UNWIND";
3864 case 0x6474e550: return "PT_SUNW_EH_FRAME";
3865 case 0x6ffffff7: return "PT_LOSUNW";
3866 case 0x6ffffffa: return "PT_SUNWBSS";
3867 case 0x6ffffffb: return "PT_SUNWSTACK";
3868 case 0x6ffffffc: return "PT_SUNWDTRACE";
3869 case 0x6ffffffd: return "PT_SUNWCAP";
3870 case 0x6fffffff: return "PT_HISUNW";
3871 default: return NULL
;
3876 get_segment_type (Filedata
* filedata
, unsigned long p_type
)
3878 static char buff
[32];
3882 case PT_NULL
: return "NULL";
3883 case PT_LOAD
: return "LOAD";
3884 case PT_DYNAMIC
: return "DYNAMIC";
3885 case PT_INTERP
: return "INTERP";
3886 case PT_NOTE
: return "NOTE";
3887 case PT_SHLIB
: return "SHLIB";
3888 case PT_PHDR
: return "PHDR";
3889 case PT_TLS
: return "TLS";
3890 case PT_GNU_EH_FRAME
: return "GNU_EH_FRAME";
3891 case PT_GNU_STACK
: return "GNU_STACK";
3892 case PT_GNU_RELRO
: return "GNU_RELRO";
3895 if (p_type
>= PT_GNU_MBIND_LO
&& p_type
<= PT_GNU_MBIND_HI
)
3897 sprintf (buff
, "GNU_MBIND+%#lx",
3898 p_type
- PT_GNU_MBIND_LO
);
3900 else if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
3902 const char * result
;
3904 switch (filedata
->file_header
.e_machine
)
3907 result
= get_aarch64_segment_type (p_type
);
3910 result
= get_arm_segment_type (p_type
);
3913 case EM_MIPS_RS3_LE
:
3914 result
= get_mips_segment_type (p_type
);
3917 result
= get_parisc_segment_type (p_type
);
3920 result
= get_ia64_segment_type (p_type
);
3923 result
= get_tic6x_segment_type (p_type
);
3927 result
= get_s390_segment_type (p_type
);
3937 sprintf (buff
, "LOPROC+%#lx", p_type
- PT_LOPROC
);
3939 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
3941 const char * result
;
3943 switch (filedata
->file_header
.e_machine
)
3946 result
= get_parisc_segment_type (p_type
);
3949 result
= get_ia64_segment_type (p_type
);
3952 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
3953 result
= get_solaris_segment_type (p_type
);
3962 sprintf (buff
, "LOOS+%#lx", p_type
- PT_LOOS
);
3965 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
3972 get_arc_section_type_name (unsigned int sh_type
)
3976 case SHT_ARC_ATTRIBUTES
: return "ARC_ATTRIBUTES";
3984 get_mips_section_type_name (unsigned int sh_type
)
3988 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
3989 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
3990 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
3991 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
3992 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
3993 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
3994 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
3995 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
3996 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
3997 case SHT_MIPS_RELD
: return "MIPS_RELD";
3998 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
3999 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
4000 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
4001 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
4002 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
4003 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
4004 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
4005 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
4006 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
4007 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
4008 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
4009 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
4010 case SHT_MIPS_LINE
: return "MIPS_LINE";
4011 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
4012 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
4013 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
4014 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
4015 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
4016 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
4017 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
4018 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
4019 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
4020 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
4021 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
4022 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
4023 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
4024 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
4025 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
4026 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
4027 case SHT_MIPS_ABIFLAGS
: return "MIPS_ABIFLAGS";
4035 get_parisc_section_type_name (unsigned int sh_type
)
4039 case SHT_PARISC_EXT
: return "PARISC_EXT";
4040 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
4041 case SHT_PARISC_DOC
: return "PARISC_DOC";
4042 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
4043 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
4044 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
4045 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
4046 default: return NULL
;
4051 get_ia64_section_type_name (Filedata
* filedata
, unsigned int sh_type
)
4053 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
4054 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
4055 return get_osabi_name (filedata
, (sh_type
& 0x00FF0000) >> 16);
4059 case SHT_IA_64_EXT
: return "IA_64_EXT";
4060 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
4061 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
4062 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
4063 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
4064 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
4065 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
4066 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
4067 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
4068 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
4076 get_x86_64_section_type_name (unsigned int sh_type
)
4080 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
4081 default: return NULL
;
4086 get_aarch64_section_type_name (unsigned int sh_type
)
4090 case SHT_AARCH64_ATTRIBUTES
: return "AARCH64_ATTRIBUTES";
4091 default: return NULL
;
4096 get_arm_section_type_name (unsigned int sh_type
)
4100 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
4101 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
4102 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
4103 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
4104 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
4105 default: return NULL
;
4110 get_tic6x_section_type_name (unsigned int sh_type
)
4114 case SHT_C6000_UNWIND
: return "C6000_UNWIND";
4115 case SHT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
4116 case SHT_C6000_ATTRIBUTES
: return "C6000_ATTRIBUTES";
4117 case SHT_TI_ICODE
: return "TI_ICODE";
4118 case SHT_TI_XREF
: return "TI_XREF";
4119 case SHT_TI_HANDLER
: return "TI_HANDLER";
4120 case SHT_TI_INITINFO
: return "TI_INITINFO";
4121 case SHT_TI_PHATTRS
: return "TI_PHATTRS";
4122 default: return NULL
;
4127 get_msp430x_section_type_name (unsigned int sh_type
)
4131 case SHT_MSP430_SEC_FLAGS
: return "MSP430_SEC_FLAGS";
4132 case SHT_MSP430_SYM_ALIASES
: return "MSP430_SYM_ALIASES";
4133 case SHT_MSP430_ATTRIBUTES
: return "MSP430_ATTRIBUTES";
4134 default: return NULL
;
4139 get_v850_section_type_name (unsigned int sh_type
)
4143 case SHT_V850_SCOMMON
: return "V850 Small Common";
4144 case SHT_V850_TCOMMON
: return "V850 Tiny Common";
4145 case SHT_V850_ZCOMMON
: return "V850 Zero Common";
4146 case SHT_RENESAS_IOP
: return "RENESAS IOP";
4147 case SHT_RENESAS_INFO
: return "RENESAS INFO";
4148 default: return NULL
;
4153 get_section_type_name (Filedata
* filedata
, unsigned int sh_type
)
4155 static char buff
[32];
4156 const char * result
;
4160 case SHT_NULL
: return "NULL";
4161 case SHT_PROGBITS
: return "PROGBITS";
4162 case SHT_SYMTAB
: return "SYMTAB";
4163 case SHT_STRTAB
: return "STRTAB";
4164 case SHT_RELA
: return "RELA";
4165 case SHT_HASH
: return "HASH";
4166 case SHT_DYNAMIC
: return "DYNAMIC";
4167 case SHT_NOTE
: return "NOTE";
4168 case SHT_NOBITS
: return "NOBITS";
4169 case SHT_REL
: return "REL";
4170 case SHT_SHLIB
: return "SHLIB";
4171 case SHT_DYNSYM
: return "DYNSYM";
4172 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
4173 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
4174 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
4175 case SHT_GNU_HASH
: return "GNU_HASH";
4176 case SHT_GROUP
: return "GROUP";
4177 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
4178 case SHT_GNU_verdef
: return "VERDEF";
4179 case SHT_GNU_verneed
: return "VERNEED";
4180 case SHT_GNU_versym
: return "VERSYM";
4181 case 0x6ffffff0: return "VERSYM";
4182 case 0x6ffffffc: return "VERDEF";
4183 case 0x7ffffffd: return "AUXILIARY";
4184 case 0x7fffffff: return "FILTER";
4185 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
4188 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
4190 switch (filedata
->file_header
.e_machine
)
4193 case EM_ARC_COMPACT
:
4194 case EM_ARC_COMPACT2
:
4195 result
= get_arc_section_type_name (sh_type
);
4198 case EM_MIPS_RS3_LE
:
4199 result
= get_mips_section_type_name (sh_type
);
4202 result
= get_parisc_section_type_name (sh_type
);
4205 result
= get_ia64_section_type_name (filedata
, sh_type
);
4210 result
= get_x86_64_section_type_name (sh_type
);
4213 result
= get_aarch64_section_type_name (sh_type
);
4216 result
= get_arm_section_type_name (sh_type
);
4219 result
= get_tic6x_section_type_name (sh_type
);
4222 result
= get_msp430x_section_type_name (sh_type
);
4226 case EM_CYGNUS_V850
:
4227 result
= get_v850_section_type_name (sh_type
);
4237 sprintf (buff
, "LOPROC+%#x", sh_type
- SHT_LOPROC
);
4239 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
4241 switch (filedata
->file_header
.e_machine
)
4244 result
= get_ia64_section_type_name (filedata
, sh_type
);
4247 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
4248 result
= get_solaris_section_type (sh_type
);
4253 case SHT_GNU_INCREMENTAL_INPUTS
: result
= "GNU_INCREMENTAL_INPUTS"; break;
4254 case SHT_GNU_ATTRIBUTES
: result
= "GNU_ATTRIBUTES"; break;
4255 case SHT_GNU_HASH
: result
= "GNU_HASH"; break;
4256 case SHT_GNU_LIBLIST
: result
= "GNU_LIBLIST"; break;
4268 sprintf (buff
, "LOOS+%#x", sh_type
- SHT_LOOS
);
4270 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
4272 switch (filedata
->file_header
.e_machine
)
4276 case EM_CYGNUS_V850
:
4277 result
= get_v850_section_type_name (sh_type
);
4287 sprintf (buff
, "LOUSER+%#x", sh_type
- SHT_LOUSER
);
4290 /* This message is probably going to be displayed in a 15
4291 character wide field, so put the hex value first. */
4292 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
4298 #define OPTION_DEBUG_DUMP 512
4299 #define OPTION_DYN_SYMS 513
4300 #define OPTION_DWARF_DEPTH 514
4301 #define OPTION_DWARF_START 515
4302 #define OPTION_DWARF_CHECK 516
4304 static struct option options
[] =
4306 {"all", no_argument
, 0, 'a'},
4307 {"file-header", no_argument
, 0, 'h'},
4308 {"program-headers", no_argument
, 0, 'l'},
4309 {"headers", no_argument
, 0, 'e'},
4310 {"histogram", no_argument
, 0, 'I'},
4311 {"segments", no_argument
, 0, 'l'},
4312 {"sections", no_argument
, 0, 'S'},
4313 {"section-headers", no_argument
, 0, 'S'},
4314 {"section-groups", no_argument
, 0, 'g'},
4315 {"section-details", no_argument
, 0, 't'},
4316 {"full-section-name",no_argument
, 0, 'N'},
4317 {"symbols", no_argument
, 0, 's'},
4318 {"syms", no_argument
, 0, 's'},
4319 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
4320 {"relocs", no_argument
, 0, 'r'},
4321 {"notes", no_argument
, 0, 'n'},
4322 {"dynamic", no_argument
, 0, 'd'},
4323 {"arch-specific", no_argument
, 0, 'A'},
4324 {"version-info", no_argument
, 0, 'V'},
4325 {"use-dynamic", no_argument
, 0, 'D'},
4326 {"unwind", no_argument
, 0, 'u'},
4327 {"archive-index", no_argument
, 0, 'c'},
4328 {"hex-dump", required_argument
, 0, 'x'},
4329 {"relocated-dump", required_argument
, 0, 'R'},
4330 {"string-dump", required_argument
, 0, 'p'},
4331 {"decompress", no_argument
, 0, 'z'},
4332 #ifdef SUPPORT_DISASSEMBLY
4333 {"instruction-dump", required_argument
, 0, 'i'},
4335 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
4337 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
4338 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
4339 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
4341 {"version", no_argument
, 0, 'v'},
4342 {"wide", no_argument
, 0, 'W'},
4343 {"help", no_argument
, 0, 'H'},
4344 {0, no_argument
, 0, 0}
4348 usage (FILE * stream
)
4350 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
4351 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
4352 fprintf (stream
, _(" Options are:\n\
4353 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4354 -h --file-header Display the ELF file header\n\
4355 -l --program-headers Display the program headers\n\
4356 --segments An alias for --program-headers\n\
4357 -S --section-headers Display the sections' header\n\
4358 --sections An alias for --section-headers\n\
4359 -g --section-groups Display the section groups\n\
4360 -t --section-details Display the section details\n\
4361 -e --headers Equivalent to: -h -l -S\n\
4362 -s --syms Display the symbol table\n\
4363 --symbols An alias for --syms\n\
4364 --dyn-syms Display the dynamic symbol table\n\
4365 -n --notes Display the core notes (if present)\n\
4366 -r --relocs Display the relocations (if present)\n\
4367 -u --unwind Display the unwind info (if present)\n\
4368 -d --dynamic Display the dynamic section (if present)\n\
4369 -V --version-info Display the version sections (if present)\n\
4370 -A --arch-specific Display architecture specific information (if any)\n\
4371 -c --archive-index Display the symbol/file index in an archive\n\
4372 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
4373 -x --hex-dump=<number|name>\n\
4374 Dump the contents of section <number|name> as bytes\n\
4375 -p --string-dump=<number|name>\n\
4376 Dump the contents of section <number|name> as strings\n\
4377 -R --relocated-dump=<number|name>\n\
4378 Dump the contents of section <number|name> as relocated bytes\n\
4379 -z --decompress Decompress section before dumping it\n\
4380 -w[lLiaprmfFsoRtUuTgAckK] or\n\
4381 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4382 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4383 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4384 =addr,=cu_index,=links,=follow-links]\n\
4385 Display the contents of DWARF debug sections\n"));
4386 fprintf (stream
, _("\
4387 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4388 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4390 #ifdef SUPPORT_DISASSEMBLY
4391 fprintf (stream
, _("\
4392 -i --instruction-dump=<number|name>\n\
4393 Disassemble the contents of section <number|name>\n"));
4395 fprintf (stream
, _("\
4396 -I --histogram Display histogram of bucket list lengths\n\
4397 -W --wide Allow output width to exceed 80 characters\n\
4398 @<file> Read options from <file>\n\
4399 -H --help Display this information\n\
4400 -v --version Display the version number of readelf\n"));
4402 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
4403 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
4405 exit (stream
== stdout
? 0 : 1);
4408 /* Record the fact that the user wants the contents of section number
4409 SECTION to be displayed using the method(s) encoded as flags bits
4410 in TYPE. Note, TYPE can be zero if we are creating the array for
4414 request_dump_bynumber (Filedata
* filedata
, unsigned int section
, dump_type type
)
4416 if (section
>= filedata
->num_dump_sects
)
4418 dump_type
* new_dump_sects
;
4420 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
4421 sizeof (* new_dump_sects
));
4423 if (new_dump_sects
== NULL
)
4424 error (_("Out of memory allocating dump request table.\n"));
4427 if (filedata
->dump_sects
)
4429 /* Copy current flag settings. */
4430 memcpy (new_dump_sects
, filedata
->dump_sects
,
4431 filedata
->num_dump_sects
* sizeof (* new_dump_sects
));
4433 free (filedata
->dump_sects
);
4436 filedata
->dump_sects
= new_dump_sects
;
4437 filedata
->num_dump_sects
= section
+ 1;
4441 if (filedata
->dump_sects
)
4442 filedata
->dump_sects
[section
] |= type
;
4445 /* Request a dump by section name. */
4448 request_dump_byname (const char * section
, dump_type type
)
4450 struct dump_list_entry
* new_request
;
4452 new_request
= (struct dump_list_entry
*)
4453 malloc (sizeof (struct dump_list_entry
));
4455 error (_("Out of memory allocating dump request table.\n"));
4457 new_request
->name
= strdup (section
);
4458 if (!new_request
->name
)
4459 error (_("Out of memory allocating dump request table.\n"));
4461 new_request
->type
= type
;
4463 new_request
->next
= dump_sects_byname
;
4464 dump_sects_byname
= new_request
;
4468 request_dump (Filedata
* filedata
, dump_type type
)
4474 section
= strtoul (optarg
, & cp
, 0);
4476 if (! *cp
&& section
>= 0)
4477 request_dump_bynumber (filedata
, section
, type
);
4479 request_dump_byname (optarg
, type
);
4483 parse_args (Filedata
* filedata
, int argc
, char ** argv
)
4490 while ((c
= getopt_long
4491 (argc
, argv
, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options
, NULL
)) != EOF
)
4509 do_section_groups
= TRUE
;
4512 do_histogram
= TRUE
;
4517 do_section_groups
= TRUE
;
4522 do_section_details
= TRUE
;
4533 do_using_dynamic
= TRUE
;
4557 do_histogram
= TRUE
;
4563 do_archive_index
= TRUE
;
4566 request_dump (filedata
, HEX_DUMP
);
4569 request_dump (filedata
, STRING_DUMP
);
4572 request_dump (filedata
, RELOC_DUMP
);
4575 decompress_dumps
= TRUE
;
4581 do_debugging
= TRUE
;
4582 dwarf_select_sections_all ();
4586 do_debugging
= FALSE
;
4587 dwarf_select_sections_by_letters (optarg
);
4590 case OPTION_DEBUG_DUMP
:
4593 do_debugging
= TRUE
;
4596 do_debugging
= FALSE
;
4597 dwarf_select_sections_by_names (optarg
);
4600 case OPTION_DWARF_DEPTH
:
4604 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
4607 case OPTION_DWARF_START
:
4611 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
4614 case OPTION_DWARF_CHECK
:
4617 case OPTION_DYN_SYMS
:
4620 #ifdef SUPPORT_DISASSEMBLY
4622 request_dump (filedata
, DISASS_DUMP
);
4626 print_version (program_name
);
4635 /* xgettext:c-format */
4636 error (_("Invalid option '-%c'\n"), c
);
4643 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
4644 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
4645 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
4646 && !do_section_groups
&& !do_archive_index
4652 get_elf_class (unsigned int elf_class
)
4654 static char buff
[32];
4658 case ELFCLASSNONE
: return _("none");
4659 case ELFCLASS32
: return "ELF32";
4660 case ELFCLASS64
: return "ELF64";
4662 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
4668 get_data_encoding (unsigned int encoding
)
4670 static char buff
[32];
4674 case ELFDATANONE
: return _("none");
4675 case ELFDATA2LSB
: return _("2's complement, little endian");
4676 case ELFDATA2MSB
: return _("2's complement, big endian");
4678 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
4683 /* Decode the data held in 'filedata->file_header'. */
4686 process_file_header (Filedata
* filedata
)
4688 Elf_Internal_Ehdr
* header
= & filedata
->file_header
;
4690 if ( header
->e_ident
[EI_MAG0
] != ELFMAG0
4691 || header
->e_ident
[EI_MAG1
] != ELFMAG1
4692 || header
->e_ident
[EI_MAG2
] != ELFMAG2
4693 || header
->e_ident
[EI_MAG3
] != ELFMAG3
)
4696 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4700 init_dwarf_regnames (header
->e_machine
);
4706 printf (_("ELF Header:\n"));
4707 printf (_(" Magic: "));
4708 for (i
= 0; i
< EI_NIDENT
; i
++)
4709 printf ("%2.2x ", header
->e_ident
[i
]);
4711 printf (_(" Class: %s\n"),
4712 get_elf_class (header
->e_ident
[EI_CLASS
]));
4713 printf (_(" Data: %s\n"),
4714 get_data_encoding (header
->e_ident
[EI_DATA
]));
4715 printf (_(" Version: %d %s\n"),
4716 header
->e_ident
[EI_VERSION
],
4717 (header
->e_ident
[EI_VERSION
] == EV_CURRENT
4719 : (header
->e_ident
[EI_VERSION
] != EV_NONE
4720 ? _("<unknown: %lx>")
4722 printf (_(" OS/ABI: %s\n"),
4723 get_osabi_name (filedata
, header
->e_ident
[EI_OSABI
]));
4724 printf (_(" ABI Version: %d\n"),
4725 header
->e_ident
[EI_ABIVERSION
]);
4726 printf (_(" Type: %s\n"),
4727 get_file_type (header
->e_type
));
4728 printf (_(" Machine: %s\n"),
4729 get_machine_name (header
->e_machine
));
4730 printf (_(" Version: 0x%lx\n"),
4731 (unsigned long) header
->e_version
);
4733 printf (_(" Entry point address: "));
4734 print_vma ((bfd_vma
) header
->e_entry
, PREFIX_HEX
);
4735 printf (_("\n Start of program headers: "));
4736 print_vma ((bfd_vma
) header
->e_phoff
, DEC
);
4737 printf (_(" (bytes into file)\n Start of section headers: "));
4738 print_vma ((bfd_vma
) header
->e_shoff
, DEC
);
4739 printf (_(" (bytes into file)\n"));
4741 printf (_(" Flags: 0x%lx%s\n"),
4742 (unsigned long) header
->e_flags
,
4743 get_machine_flags (filedata
, header
->e_flags
, header
->e_machine
));
4744 printf (_(" Size of this header: %ld (bytes)\n"),
4745 (long) header
->e_ehsize
);
4746 printf (_(" Size of program headers: %ld (bytes)\n"),
4747 (long) header
->e_phentsize
);
4748 printf (_(" Number of program headers: %ld"),
4749 (long) header
->e_phnum
);
4750 if (filedata
->section_headers
!= NULL
4751 && header
->e_phnum
== PN_XNUM
4752 && filedata
->section_headers
[0].sh_info
!= 0)
4753 printf (" (%ld)", (long) filedata
->section_headers
[0].sh_info
);
4754 putc ('\n', stdout
);
4755 printf (_(" Size of section headers: %ld (bytes)\n"),
4756 (long) header
->e_shentsize
);
4757 printf (_(" Number of section headers: %ld"),
4758 (long) header
->e_shnum
);
4759 if (filedata
->section_headers
!= NULL
&& header
->e_shnum
== SHN_UNDEF
)
4760 printf (" (%ld)", (long) filedata
->section_headers
[0].sh_size
);
4761 putc ('\n', stdout
);
4762 printf (_(" Section header string table index: %ld"),
4763 (long) header
->e_shstrndx
);
4764 if (filedata
->section_headers
!= NULL
4765 && header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
4766 printf (" (%u)", filedata
->section_headers
[0].sh_link
);
4767 else if (header
->e_shstrndx
!= SHN_UNDEF
4768 && header
->e_shstrndx
>= header
->e_shnum
)
4769 printf (_(" <corrupt: out of range>"));
4770 putc ('\n', stdout
);
4773 if (filedata
->section_headers
!= NULL
)
4775 if (header
->e_phnum
== PN_XNUM
4776 && filedata
->section_headers
[0].sh_info
!= 0)
4777 header
->e_phnum
= filedata
->section_headers
[0].sh_info
;
4778 if (header
->e_shnum
== SHN_UNDEF
)
4779 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
4780 if (header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
4781 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
4782 if (header
->e_shstrndx
>= header
->e_shnum
)
4783 header
->e_shstrndx
= SHN_UNDEF
;
4784 free (filedata
->section_headers
);
4785 filedata
->section_headers
= NULL
;
4791 /* Read in the program headers from FILEDATA and store them in PHEADERS.
4792 Returns TRUE upon success, FALSE otherwise. Loads 32-bit headers. */
4795 get_32bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
4797 Elf32_External_Phdr
* phdrs
;
4798 Elf32_External_Phdr
* external
;
4799 Elf_Internal_Phdr
* internal
;
4801 unsigned int size
= filedata
->file_header
.e_phentsize
;
4802 unsigned int num
= filedata
->file_header
.e_phnum
;
4804 /* PR binutils/17531: Cope with unexpected section header sizes. */
4805 if (size
== 0 || num
== 0)
4807 if (size
< sizeof * phdrs
)
4809 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4812 if (size
> sizeof * phdrs
)
4813 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4815 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
4816 size
, num
, _("program headers"));
4820 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4821 i
< filedata
->file_header
.e_phnum
;
4822 i
++, internal
++, external
++)
4824 internal
->p_type
= BYTE_GET (external
->p_type
);
4825 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4826 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4827 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4828 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4829 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4830 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4831 internal
->p_align
= BYTE_GET (external
->p_align
);
4838 /* Read in the program headers from FILEDATA and store them in PHEADERS.
4839 Returns TRUE upon success, FALSE otherwise. Loads 64-bit headers. */
4842 get_64bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
4844 Elf64_External_Phdr
* phdrs
;
4845 Elf64_External_Phdr
* external
;
4846 Elf_Internal_Phdr
* internal
;
4848 unsigned int size
= filedata
->file_header
.e_phentsize
;
4849 unsigned int num
= filedata
->file_header
.e_phnum
;
4851 /* PR binutils/17531: Cope with unexpected section header sizes. */
4852 if (size
== 0 || num
== 0)
4854 if (size
< sizeof * phdrs
)
4856 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4859 if (size
> sizeof * phdrs
)
4860 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4862 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
4863 size
, num
, _("program headers"));
4867 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4868 i
< filedata
->file_header
.e_phnum
;
4869 i
++, internal
++, external
++)
4871 internal
->p_type
= BYTE_GET (external
->p_type
);
4872 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4873 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4874 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4875 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4876 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4877 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4878 internal
->p_align
= BYTE_GET (external
->p_align
);
4885 /* Returns TRUE if the program headers were read into `program_headers'. */
4888 get_program_headers (Filedata
* filedata
)
4890 Elf_Internal_Phdr
* phdrs
;
4892 /* Check cache of prior read. */
4893 if (filedata
->program_headers
!= NULL
)
4896 /* Be kind to memory checkers by looking for
4897 e_phnum values which we know must be invalid. */
4898 if (filedata
->file_header
.e_phnum
4899 * (is_32bit_elf
? sizeof (Elf32_External_Phdr
) : sizeof (Elf64_External_Phdr
))
4900 >= filedata
->file_size
)
4902 error (_("Too many program headers - %#x - the file is not that big\n"),
4903 filedata
->file_header
.e_phnum
);
4907 phdrs
= (Elf_Internal_Phdr
*) cmalloc (filedata
->file_header
.e_phnum
,
4908 sizeof (Elf_Internal_Phdr
));
4911 error (_("Out of memory reading %u program headers\n"),
4912 filedata
->file_header
.e_phnum
);
4917 ? get_32bit_program_headers (filedata
, phdrs
)
4918 : get_64bit_program_headers (filedata
, phdrs
))
4920 filedata
->program_headers
= phdrs
;
4928 /* Returns TRUE if the program headers were loaded. */
4931 process_program_headers (Filedata
* filedata
)
4933 Elf_Internal_Phdr
* segment
;
4935 Elf_Internal_Phdr
* previous_load
= NULL
;
4937 if (filedata
->file_header
.e_phnum
== 0)
4939 /* PR binutils/12467. */
4940 if (filedata
->file_header
.e_phoff
!= 0)
4942 warn (_("possibly corrupt ELF header - it has a non-zero program"
4943 " header offset, but no program headers\n"));
4946 else if (do_segments
)
4947 printf (_("\nThere are no program headers in this file.\n"));
4951 if (do_segments
&& !do_header
)
4953 printf (_("\nElf file type is %s\n"), get_file_type (filedata
->file_header
.e_type
));
4954 printf (_("Entry point 0x%s\n"), bfd_vmatoa ("x", filedata
->file_header
.e_entry
));
4955 printf (ngettext ("There is %d program header, starting at offset %s\n",
4956 "There are %d program headers, starting at offset %s\n",
4957 filedata
->file_header
.e_phnum
),
4958 filedata
->file_header
.e_phnum
,
4959 bfd_vmatoa ("u", filedata
->file_header
.e_phoff
));
4962 if (! get_program_headers (filedata
))
4967 if (filedata
->file_header
.e_phnum
> 1)
4968 printf (_("\nProgram Headers:\n"));
4970 printf (_("\nProgram Headers:\n"));
4974 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4977 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4981 (_(" Type Offset VirtAddr PhysAddr\n"));
4983 (_(" FileSiz MemSiz Flags Align\n"));
4990 for (i
= 0, segment
= filedata
->program_headers
;
4991 i
< filedata
->file_header
.e_phnum
;
4996 printf (" %-14.14s ", get_segment_type (filedata
, segment
->p_type
));
5000 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
5001 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
5002 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
5003 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
5004 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
5006 (segment
->p_flags
& PF_R
? 'R' : ' '),
5007 (segment
->p_flags
& PF_W
? 'W' : ' '),
5008 (segment
->p_flags
& PF_X
? 'E' : ' '));
5009 printf ("%#lx", (unsigned long) segment
->p_align
);
5013 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
5014 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
5017 print_vma (segment
->p_offset
, FULL_HEX
);
5021 print_vma (segment
->p_vaddr
, FULL_HEX
);
5023 print_vma (segment
->p_paddr
, FULL_HEX
);
5026 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
5027 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
5030 print_vma (segment
->p_filesz
, FULL_HEX
);
5034 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
5035 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
5038 print_vma (segment
->p_memsz
, FULL_HEX
);
5042 (segment
->p_flags
& PF_R
? 'R' : ' '),
5043 (segment
->p_flags
& PF_W
? 'W' : ' '),
5044 (segment
->p_flags
& PF_X
? 'E' : ' '));
5046 if ((unsigned long) segment
->p_align
== segment
->p_align
)
5047 printf ("%#lx", (unsigned long) segment
->p_align
);
5050 print_vma (segment
->p_align
, PREFIX_HEX
);
5055 print_vma (segment
->p_offset
, FULL_HEX
);
5057 print_vma (segment
->p_vaddr
, FULL_HEX
);
5059 print_vma (segment
->p_paddr
, FULL_HEX
);
5061 print_vma (segment
->p_filesz
, FULL_HEX
);
5063 print_vma (segment
->p_memsz
, FULL_HEX
);
5065 (segment
->p_flags
& PF_R
? 'R' : ' '),
5066 (segment
->p_flags
& PF_W
? 'W' : ' '),
5067 (segment
->p_flags
& PF_X
? 'E' : ' '));
5068 print_vma (segment
->p_align
, PREFIX_HEX
);
5071 putc ('\n', stdout
);
5074 switch (segment
->p_type
)
5077 #if 0 /* Do not warn about out of order PT_LOAD segments. Although officially
5078 required by the ELF standard, several programs, including the Linux
5079 kernel, make use of non-ordered segments. */
5081 && previous_load
->p_vaddr
> segment
->p_vaddr
)
5082 error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
5084 if (segment
->p_memsz
< segment
->p_filesz
)
5085 error (_("the segment's file size is larger than its memory size\n"));
5086 previous_load
= segment
;
5090 /* PR 20815 - Verify that the program header is loaded into memory. */
5091 if (i
> 0 && previous_load
!= NULL
)
5092 error (_("the PHDR segment must occur before any LOAD segment\n"));
5093 if (filedata
->file_header
.e_machine
!= EM_PARISC
)
5097 for (j
= 1; j
< filedata
->file_header
.e_phnum
; j
++)
5098 if (filedata
->program_headers
[j
].p_vaddr
<= segment
->p_vaddr
5099 && (filedata
->program_headers
[j
].p_vaddr
5100 + filedata
->program_headers
[j
].p_memsz
)
5101 >= (segment
->p_vaddr
+ segment
->p_filesz
))
5103 if (j
== filedata
->file_header
.e_phnum
)
5104 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5110 error (_("more than one dynamic segment\n"));
5112 /* By default, assume that the .dynamic section is the first
5113 section in the DYNAMIC segment. */
5114 dynamic_addr
= segment
->p_offset
;
5115 dynamic_size
= segment
->p_filesz
;
5117 /* Try to locate the .dynamic section. If there is
5118 a section header table, we can easily locate it. */
5119 if (filedata
->section_headers
!= NULL
)
5121 Elf_Internal_Shdr
* sec
;
5123 sec
= find_section (filedata
, ".dynamic");
5124 if (sec
== NULL
|| sec
->sh_size
== 0)
5126 /* A corresponding .dynamic section is expected, but on
5127 IA-64/OpenVMS it is OK for it to be missing. */
5128 if (!is_ia64_vms (filedata
))
5129 error (_("no .dynamic section in the dynamic segment\n"));
5133 if (sec
->sh_type
== SHT_NOBITS
)
5139 dynamic_addr
= sec
->sh_offset
;
5140 dynamic_size
= sec
->sh_size
;
5142 if (dynamic_addr
< segment
->p_offset
5143 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
5144 warn (_("the .dynamic section is not contained"
5145 " within the dynamic segment\n"));
5146 else if (dynamic_addr
> segment
->p_offset
)
5147 warn (_("the .dynamic section is not the first section"
5148 " in the dynamic segment.\n"));
5151 /* PR binutils/17512: Avoid corrupt dynamic section info in the
5152 segment. Check this after matching against the section headers
5153 so we don't warn on debuginfo file (which have NOBITS .dynamic
5155 if (dynamic_addr
+ dynamic_size
>= filedata
->file_size
)
5157 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5158 dynamic_addr
= dynamic_size
= 0;
5163 if (fseek (filedata
->handle
, archive_file_offset
+ (long) segment
->p_offset
,
5165 error (_("Unable to find program interpreter name\n"));
5169 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
- 1);
5171 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
5172 error (_("Internal error: failed to create format string to display program interpreter\n"));
5174 program_interpreter
[0] = 0;
5175 if (fscanf (filedata
->handle
, fmt
, program_interpreter
) <= 0)
5176 error (_("Unable to read program interpreter name\n"));
5179 printf (_(" [Requesting program interpreter: %s]\n"),
5180 program_interpreter
);
5187 && filedata
->section_headers
!= NULL
5188 && filedata
->string_table
!= NULL
)
5190 printf (_("\n Section to Segment mapping:\n"));
5191 printf (_(" Segment Sections...\n"));
5193 for (i
= 0; i
< filedata
->file_header
.e_phnum
; i
++)
5196 Elf_Internal_Shdr
* section
;
5198 segment
= filedata
->program_headers
+ i
;
5199 section
= filedata
->section_headers
+ 1;
5201 printf (" %2.2d ", i
);
5203 for (j
= 1; j
< filedata
->file_header
.e_shnum
; j
++, section
++)
5205 if (!ELF_TBSS_SPECIAL (section
, segment
)
5206 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
5207 printf ("%s ", printable_section_name (filedata
, section
));
5218 /* Find the file offset corresponding to VMA by using the program headers. */
5221 offset_from_vma (Filedata
* filedata
, bfd_vma vma
, bfd_size_type size
)
5223 Elf_Internal_Phdr
* seg
;
5225 if (! get_program_headers (filedata
))
5227 warn (_("Cannot interpret virtual addresses without program headers.\n"));
5231 for (seg
= filedata
->program_headers
;
5232 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
5235 if (seg
->p_type
!= PT_LOAD
)
5238 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
5239 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
5240 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
5243 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5244 (unsigned long) vma
);
5249 /* Allocate memory and load the sections headers into FILEDATA->filedata->section_headers.
5250 If PROBE is true, this is just a probe and we do not generate any error
5251 messages if the load fails. */
5254 get_32bit_section_headers (Filedata
* filedata
, bfd_boolean probe
)
5256 Elf32_External_Shdr
* shdrs
;
5257 Elf_Internal_Shdr
* internal
;
5259 unsigned int size
= filedata
->file_header
.e_shentsize
;
5260 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
5262 /* PR binutils/17531: Cope with unexpected section header sizes. */
5263 if (size
== 0 || num
== 0)
5265 if (size
< sizeof * shdrs
)
5268 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5271 if (!probe
&& size
> sizeof * shdrs
)
5272 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5274 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_shoff
,
5276 probe
? NULL
: _("section headers"));
5280 free (filedata
->section_headers
);
5281 filedata
->section_headers
= (Elf_Internal_Shdr
*)
5282 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
5283 if (filedata
->section_headers
== NULL
)
5286 error (_("Out of memory reading %u section headers\n"), num
);
5290 for (i
= 0, internal
= filedata
->section_headers
;
5294 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5295 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5296 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5297 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5298 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5299 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5300 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5301 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5302 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5303 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5304 if (!probe
&& internal
->sh_link
> num
)
5305 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5306 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5307 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5314 /* Like get_32bit_section_headers, except that it fetches 64-bit headers. */
5317 get_64bit_section_headers (Filedata
* filedata
, bfd_boolean probe
)
5319 Elf64_External_Shdr
* shdrs
;
5320 Elf_Internal_Shdr
* internal
;
5322 unsigned int size
= filedata
->file_header
.e_shentsize
;
5323 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
5325 /* PR binutils/17531: Cope with unexpected section header sizes. */
5326 if (size
== 0 || num
== 0)
5329 if (size
< sizeof * shdrs
)
5332 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5336 if (! probe
&& size
> sizeof * shdrs
)
5337 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5339 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, filedata
,
5340 filedata
->file_header
.e_shoff
,
5342 probe
? NULL
: _("section headers"));
5346 free (filedata
->section_headers
);
5347 filedata
->section_headers
= (Elf_Internal_Shdr
*)
5348 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
5349 if (filedata
->section_headers
== NULL
)
5352 error (_("Out of memory reading %u section headers\n"), num
);
5356 for (i
= 0, internal
= filedata
->section_headers
;
5360 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5361 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5362 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5363 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5364 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5365 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5366 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5367 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5368 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5369 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5370 if (!probe
&& internal
->sh_link
> num
)
5371 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5372 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5373 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5380 static Elf_Internal_Sym
*
5381 get_32bit_elf_symbols (Filedata
* filedata
,
5382 Elf_Internal_Shdr
* section
,
5383 unsigned long * num_syms_return
)
5385 unsigned long number
= 0;
5386 Elf32_External_Sym
* esyms
= NULL
;
5387 Elf_External_Sym_Shndx
* shndx
= NULL
;
5388 Elf_Internal_Sym
* isyms
= NULL
;
5389 Elf_Internal_Sym
* psym
;
5392 if (section
->sh_size
== 0)
5394 if (num_syms_return
!= NULL
)
5395 * num_syms_return
= 0;
5399 /* Run some sanity checks first. */
5400 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5402 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5403 printable_section_name (filedata
, section
),
5404 (unsigned long) section
->sh_entsize
);
5408 if (section
->sh_size
> filedata
->file_size
)
5410 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5411 printable_section_name (filedata
, section
),
5412 (unsigned long) section
->sh_size
);
5416 number
= section
->sh_size
/ section
->sh_entsize
;
5418 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
5420 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5421 (unsigned long) section
->sh_size
,
5422 printable_section_name (filedata
, section
),
5423 (unsigned long) section
->sh_entsize
);
5427 esyms
= (Elf32_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
5428 section
->sh_size
, _("symbols"));
5433 elf_section_list
* entry
;
5436 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5437 if (entry
->hdr
->sh_link
== (unsigned long) (section
- filedata
->section_headers
))
5439 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
5440 entry
->hdr
->sh_offset
,
5441 1, entry
->hdr
->sh_size
,
5442 _("symbol table section indicies"));
5445 /* PR17531: file: heap-buffer-overflow */
5446 else if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5448 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5449 printable_section_name (filedata
, entry
->hdr
),
5450 (unsigned long) entry
->hdr
->sh_size
,
5451 (unsigned long) section
->sh_size
);
5457 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5461 error (_("Out of memory reading %lu symbols\n"),
5462 (unsigned long) number
);
5466 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5468 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5469 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5470 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5471 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5472 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5474 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5475 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5476 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5477 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5478 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5487 if (num_syms_return
!= NULL
)
5488 * num_syms_return
= isyms
== NULL
? 0 : number
;
5493 static Elf_Internal_Sym
*
5494 get_64bit_elf_symbols (Filedata
* filedata
,
5495 Elf_Internal_Shdr
* section
,
5496 unsigned long * num_syms_return
)
5498 unsigned long number
= 0;
5499 Elf64_External_Sym
* esyms
= NULL
;
5500 Elf_External_Sym_Shndx
* shndx
= NULL
;
5501 Elf_Internal_Sym
* isyms
= NULL
;
5502 Elf_Internal_Sym
* psym
;
5505 if (section
->sh_size
== 0)
5507 if (num_syms_return
!= NULL
)
5508 * num_syms_return
= 0;
5512 /* Run some sanity checks first. */
5513 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5515 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5516 printable_section_name (filedata
, section
),
5517 (unsigned long) section
->sh_entsize
);
5521 if (section
->sh_size
> filedata
->file_size
)
5523 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5524 printable_section_name (filedata
, section
),
5525 (unsigned long) section
->sh_size
);
5529 number
= section
->sh_size
/ section
->sh_entsize
;
5531 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
5533 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5534 (unsigned long) section
->sh_size
,
5535 printable_section_name (filedata
, section
),
5536 (unsigned long) section
->sh_entsize
);
5540 esyms
= (Elf64_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
5541 section
->sh_size
, _("symbols"));
5546 elf_section_list
* entry
;
5549 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5550 if (entry
->hdr
->sh_link
== (unsigned long) (section
- filedata
->section_headers
))
5552 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
5553 entry
->hdr
->sh_offset
,
5554 1, entry
->hdr
->sh_size
,
5555 _("symbol table section indicies"));
5558 /* PR17531: file: heap-buffer-overflow */
5559 else if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5561 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5562 printable_section_name (filedata
, entry
->hdr
),
5563 (unsigned long) entry
->hdr
->sh_size
,
5564 (unsigned long) section
->sh_size
);
5570 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5574 error (_("Out of memory reading %lu symbols\n"),
5575 (unsigned long) number
);
5579 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5581 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5582 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5583 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5584 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5586 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5588 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5589 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5590 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5592 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5593 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5602 if (num_syms_return
!= NULL
)
5603 * num_syms_return
= isyms
== NULL
? 0 : number
;
5609 get_elf_section_flags (Filedata
* filedata
, bfd_vma sh_flags
)
5611 static char buff
[1024];
5613 unsigned int field_size
= is_32bit_elf
? 8 : 16;
5615 unsigned int size
= sizeof (buff
) - (field_size
+ 4 + 1);
5616 bfd_vma os_flags
= 0;
5617 bfd_vma proc_flags
= 0;
5618 bfd_vma unknown_flags
= 0;
5626 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5627 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5628 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5629 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5630 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5631 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5632 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5633 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5634 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5635 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5636 /* IA-64 specific. */
5637 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5638 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5639 /* IA-64 OpenVMS specific. */
5640 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5641 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5642 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5643 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5644 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5645 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5647 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5648 /* SPARC specific. */
5649 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5650 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5652 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5653 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5654 /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
5656 /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
5658 /* 25 */ { STRING_COMMA_LEN ("VLE") },
5661 if (do_section_details
)
5663 sprintf (buff
, "[%*.*lx]: ",
5664 field_size
, field_size
, (unsigned long) sh_flags
);
5665 p
+= field_size
+ 4;
5672 flag
= sh_flags
& - sh_flags
;
5675 if (do_section_details
)
5679 case SHF_WRITE
: sindex
= 0; break;
5680 case SHF_ALLOC
: sindex
= 1; break;
5681 case SHF_EXECINSTR
: sindex
= 2; break;
5682 case SHF_MERGE
: sindex
= 3; break;
5683 case SHF_STRINGS
: sindex
= 4; break;
5684 case SHF_INFO_LINK
: sindex
= 5; break;
5685 case SHF_LINK_ORDER
: sindex
= 6; break;
5686 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
5687 case SHF_GROUP
: sindex
= 8; break;
5688 case SHF_TLS
: sindex
= 9; break;
5689 case SHF_EXCLUDE
: sindex
= 18; break;
5690 case SHF_COMPRESSED
: sindex
= 20; break;
5691 case SHF_GNU_MBIND
: sindex
= 24; break;
5695 switch (filedata
->file_header
.e_machine
)
5698 if (flag
== SHF_IA_64_SHORT
)
5700 else if (flag
== SHF_IA_64_NORECOV
)
5703 else if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
5706 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
5707 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
5708 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
5709 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
5710 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
5711 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
5722 case EM_OLD_SPARCV9
:
5723 case EM_SPARC32PLUS
:
5726 if (flag
== SHF_ORDERED
)
5733 case SHF_ENTRYSECT
: sindex
= 21; break;
5734 case SHF_ARM_PURECODE
: sindex
= 22; break;
5735 case SHF_COMDEF
: sindex
= 23; break;
5740 if (flag
== SHF_PPC_VLE
)
5751 if (p
!= buff
+ field_size
+ 4)
5753 if (size
< (10 + 2))
5755 warn (_("Internal error: not enough buffer room for section flag info"));
5756 return _("<unknown>");
5763 size
-= flags
[sindex
].len
;
5764 p
= stpcpy (p
, flags
[sindex
].str
);
5766 else if (flag
& SHF_MASKOS
)
5768 else if (flag
& SHF_MASKPROC
)
5771 unknown_flags
|= flag
;
5777 case SHF_WRITE
: *p
= 'W'; break;
5778 case SHF_ALLOC
: *p
= 'A'; break;
5779 case SHF_EXECINSTR
: *p
= 'X'; break;
5780 case SHF_MERGE
: *p
= 'M'; break;
5781 case SHF_STRINGS
: *p
= 'S'; break;
5782 case SHF_INFO_LINK
: *p
= 'I'; break;
5783 case SHF_LINK_ORDER
: *p
= 'L'; break;
5784 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
5785 case SHF_GROUP
: *p
= 'G'; break;
5786 case SHF_TLS
: *p
= 'T'; break;
5787 case SHF_EXCLUDE
: *p
= 'E'; break;
5788 case SHF_COMPRESSED
: *p
= 'C'; break;
5789 case SHF_GNU_MBIND
: *p
= 'D'; break;
5792 if ((filedata
->file_header
.e_machine
== EM_X86_64
5793 || filedata
->file_header
.e_machine
== EM_L1OM
5794 || filedata
->file_header
.e_machine
== EM_K1OM
)
5795 && flag
== SHF_X86_64_LARGE
)
5797 else if (filedata
->file_header
.e_machine
== EM_ARM
5798 && flag
== SHF_ARM_PURECODE
)
5800 else if (filedata
->file_header
.e_machine
== EM_PPC
5801 && flag
== SHF_PPC_VLE
)
5803 else if (flag
& SHF_MASKOS
)
5806 sh_flags
&= ~ SHF_MASKOS
;
5808 else if (flag
& SHF_MASKPROC
)
5811 sh_flags
&= ~ SHF_MASKPROC
;
5821 if (do_section_details
)
5825 size
-= 5 + field_size
;
5826 if (p
!= buff
+ field_size
+ 4)
5830 warn (_("Internal error: not enough buffer room for section flag info"));
5831 return _("<unknown>");
5837 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
5838 (unsigned long) os_flags
);
5839 p
+= 5 + field_size
;
5843 size
-= 7 + field_size
;
5844 if (p
!= buff
+ field_size
+ 4)
5848 warn (_("Internal error: not enough buffer room for section flag info"));
5849 return _("<unknown>");
5855 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
5856 (unsigned long) proc_flags
);
5857 p
+= 7 + field_size
;
5861 size
-= 10 + field_size
;
5862 if (p
!= buff
+ field_size
+ 4)
5866 warn (_("Internal error: not enough buffer room for section flag info"));
5867 return _("<unknown>");
5873 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
5874 (unsigned long) unknown_flags
);
5875 p
+= 10 + field_size
;
5884 get_compression_header (Elf_Internal_Chdr
*chdr
, unsigned char *buf
, bfd_size_type size
)
5888 Elf32_External_Chdr
*echdr
= (Elf32_External_Chdr
*) buf
;
5890 if (size
< sizeof (* echdr
))
5892 error (_("Compressed section is too small even for a compression header\n"));
5896 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
5897 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
5898 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
5899 return sizeof (*echdr
);
5903 Elf64_External_Chdr
*echdr
= (Elf64_External_Chdr
*) buf
;
5905 if (size
< sizeof (* echdr
))
5907 error (_("Compressed section is too small even for a compression header\n"));
5911 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
5912 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
5913 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
5914 return sizeof (*echdr
);
5919 process_section_headers (Filedata
* filedata
)
5921 Elf_Internal_Shdr
* section
;
5924 filedata
->section_headers
= NULL
;
5926 if (filedata
->file_header
.e_shnum
== 0)
5928 /* PR binutils/12467. */
5929 if (filedata
->file_header
.e_shoff
!= 0)
5931 warn (_("possibly corrupt ELF file header - it has a non-zero"
5932 " section header offset, but no section headers\n"));
5935 else if (do_sections
)
5936 printf (_("\nThere are no sections in this file.\n"));
5941 if (do_sections
&& !do_header
)
5942 printf (ngettext ("There is %d section header, "
5943 "starting at offset 0x%lx:\n",
5944 "There are %d section headers, "
5945 "starting at offset 0x%lx:\n",
5946 filedata
->file_header
.e_shnum
),
5947 filedata
->file_header
.e_shnum
,
5948 (unsigned long) filedata
->file_header
.e_shoff
);
5952 if (! get_32bit_section_headers (filedata
, FALSE
))
5957 if (! get_64bit_section_headers (filedata
, FALSE
))
5961 /* Read in the string table, so that we have names to display. */
5962 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
5963 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
5965 section
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
5967 if (section
->sh_size
!= 0)
5969 filedata
->string_table
= (char *) get_data (NULL
, filedata
, section
->sh_offset
,
5970 1, section
->sh_size
,
5973 filedata
->string_table_length
= filedata
->string_table
!= NULL
? section
->sh_size
: 0;
5977 /* Scan the sections for the dynamic symbol table
5978 and dynamic string table and debug sections. */
5979 dynamic_symbols
= NULL
;
5980 dynamic_strings
= NULL
;
5981 dynamic_syminfo
= NULL
;
5982 symtab_shndx_list
= NULL
;
5984 eh_addr_size
= is_32bit_elf
? 4 : 8;
5985 switch (filedata
->file_header
.e_machine
)
5988 case EM_MIPS_RS3_LE
:
5989 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5990 FDE addresses. However, the ABI also has a semi-official ILP32
5991 variant for which the normal FDE address size rules apply.
5993 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5994 section, where XX is the size of longs in bits. Unfortunately,
5995 earlier compilers provided no way of distinguishing ILP32 objects
5996 from LP64 objects, so if there's any doubt, we should assume that
5997 the official LP64 form is being used. */
5998 if ((filedata
->file_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
5999 && find_section (filedata
, ".gcc_compiled_long32") == NULL
)
6005 switch (filedata
->file_header
.e_flags
& EF_H8_MACH
)
6007 case E_H8_MACH_H8300
:
6008 case E_H8_MACH_H8300HN
:
6009 case E_H8_MACH_H8300SN
:
6010 case E_H8_MACH_H8300SXN
:
6013 case E_H8_MACH_H8300H
:
6014 case E_H8_MACH_H8300S
:
6015 case E_H8_MACH_H8300SX
:
6023 switch (filedata
->file_header
.e_flags
& EF_M32C_CPU_MASK
)
6025 case EF_M32C_CPU_M16C
:
6032 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
6035 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
6036 if (section->sh_entsize != expected_entsize) \
6039 sprintf_vma (buf, section->sh_entsize); \
6040 /* Note: coded this way so that there is a single string for \
6042 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
6043 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
6044 (unsigned) expected_entsize); \
6045 section->sh_entsize = expected_entsize; \
6050 #define CHECK_ENTSIZE(section, i, type) \
6051 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
6052 sizeof (Elf64_External_##type))
6054 for (i
= 0, section
= filedata
->section_headers
;
6055 i
< filedata
->file_header
.e_shnum
;
6058 char * name
= SECTION_NAME (section
);
6060 if (section
->sh_type
== SHT_DYNSYM
)
6062 if (dynamic_symbols
!= NULL
)
6064 error (_("File contains multiple dynamic symbol tables\n"));
6068 CHECK_ENTSIZE (section
, i
, Sym
);
6069 dynamic_symbols
= GET_ELF_SYMBOLS (filedata
, section
, & num_dynamic_syms
);
6071 else if (section
->sh_type
== SHT_STRTAB
6072 && streq (name
, ".dynstr"))
6074 if (dynamic_strings
!= NULL
)
6076 error (_("File contains multiple dynamic string tables\n"));
6080 dynamic_strings
= (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6081 1, section
->sh_size
,
6082 _("dynamic strings"));
6083 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : section
->sh_size
;
6085 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
6087 elf_section_list
* entry
= xmalloc (sizeof * entry
);
6089 entry
->hdr
= section
;
6090 entry
->next
= symtab_shndx_list
;
6091 symtab_shndx_list
= entry
;
6093 else if (section
->sh_type
== SHT_SYMTAB
)
6094 CHECK_ENTSIZE (section
, i
, Sym
);
6095 else if (section
->sh_type
== SHT_GROUP
)
6096 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
6097 else if (section
->sh_type
== SHT_REL
)
6098 CHECK_ENTSIZE (section
, i
, Rel
);
6099 else if (section
->sh_type
== SHT_RELA
)
6100 CHECK_ENTSIZE (section
, i
, Rela
);
6101 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
6102 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
6103 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
6104 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
6105 || do_debug_addr
|| do_debug_cu_index
|| do_debug_links
)
6106 && (const_strneq (name
, ".debug_")
6107 || const_strneq (name
, ".zdebug_")))
6110 name
+= sizeof (".zdebug_") - 1;
6112 name
+= sizeof (".debug_") - 1;
6115 || (do_debug_info
&& const_strneq (name
, "info"))
6116 || (do_debug_info
&& const_strneq (name
, "types"))
6117 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
6118 || (do_debug_lines
&& strcmp (name
, "line") == 0)
6119 || (do_debug_lines
&& const_strneq (name
, "line."))
6120 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
6121 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
6122 || (do_debug_pubnames
&& const_strneq (name
, "gnu_pubnames"))
6123 || (do_debug_pubtypes
&& const_strneq (name
, "gnu_pubtypes"))
6124 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
6125 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
6126 || (do_debug_ranges
&& const_strneq (name
, "rnglists"))
6127 || (do_debug_frames
&& const_strneq (name
, "frame"))
6128 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
6129 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
6130 || (do_debug_str
&& const_strneq (name
, "str"))
6131 || (do_debug_loc
&& const_strneq (name
, "loc"))
6132 || (do_debug_loc
&& const_strneq (name
, "loclists"))
6133 || (do_debug_addr
&& const_strneq (name
, "addr"))
6134 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
6135 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
6137 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6139 /* Linkonce section to be combined with .debug_info at link time. */
6140 else if ((do_debugging
|| do_debug_info
)
6141 && const_strneq (name
, ".gnu.linkonce.wi."))
6142 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6143 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
6144 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6145 else if (do_gdb_index
&& (streq (name
, ".gdb_index")
6146 || streq (name
, ".debug_names")))
6147 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6148 /* Trace sections for Itanium VMS. */
6149 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
6150 || do_trace_aranges
)
6151 && const_strneq (name
, ".trace_"))
6153 name
+= sizeof (".trace_") - 1;
6156 || (do_trace_info
&& streq (name
, "info"))
6157 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
6158 || (do_trace_aranges
&& streq (name
, "aranges"))
6160 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6162 else if ((do_debugging
|| do_debug_links
)
6163 && (const_strneq (name
, ".gnu_debuglink")
6164 || const_strneq (name
, ".gnu_debugaltlink")))
6165 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6171 if (filedata
->file_header
.e_shnum
> 1)
6172 printf (_("\nSection Headers:\n"));
6174 printf (_("\nSection Header:\n"));
6178 if (do_section_details
)
6180 printf (_(" [Nr] Name\n"));
6181 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
6185 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
6189 if (do_section_details
)
6191 printf (_(" [Nr] Name\n"));
6192 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
6196 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
6200 if (do_section_details
)
6202 printf (_(" [Nr] Name\n"));
6203 printf (_(" Type Address Offset Link\n"));
6204 printf (_(" Size EntSize Info Align\n"));
6208 printf (_(" [Nr] Name Type Address Offset\n"));
6209 printf (_(" Size EntSize Flags Link Info Align\n"));
6213 if (do_section_details
)
6214 printf (_(" Flags\n"));
6216 for (i
= 0, section
= filedata
->section_headers
;
6217 i
< filedata
->file_header
.e_shnum
;
6220 /* Run some sanity checks on the section header. */
6222 /* Check the sh_link field. */
6223 switch (section
->sh_type
)
6225 case SHT_SYMTAB_SHNDX
:
6229 case SHT_GNU_versym
:
6232 if (section
->sh_link
< 1
6233 || section
->sh_link
>= filedata
->file_header
.e_shnum
6234 || (filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_SYMTAB
6235 && filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_DYNSYM
))
6236 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6237 i
, section
->sh_link
);
6243 case SHT_GNU_verneed
:
6244 case SHT_GNU_verdef
:
6245 case SHT_GNU_LIBLIST
:
6246 if (section
->sh_link
< 1
6247 || section
->sh_link
>= filedata
->file_header
.e_shnum
6248 || filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_STRTAB
)
6249 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6250 i
, section
->sh_link
);
6253 case SHT_INIT_ARRAY
:
6254 case SHT_FINI_ARRAY
:
6255 case SHT_PREINIT_ARRAY
:
6256 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6257 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6258 i
, section
->sh_link
);
6262 /* FIXME: Add support for target specific section types. */
6263 #if 0 /* Currently we do not check other section types as there are too
6264 many special cases. Stab sections for example have a type
6265 of SHT_PROGBITS but an sh_link field that links to the .stabstr
6267 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6268 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6269 i
, section
->sh_link
);
6274 /* Check the sh_info field. */
6275 switch (section
->sh_type
)
6279 if (section
->sh_info
< 1
6280 || section
->sh_info
>= filedata
->file_header
.e_shnum
6281 || (filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PROGBITS
6282 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOBITS
6283 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOTE
6284 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_INIT_ARRAY
6285 /* FIXME: Are other section types valid ? */
6286 && filedata
->section_headers
[section
->sh_info
].sh_type
< SHT_LOOS
))
6288 if (section
->sh_info
== 0
6289 && (filedata
->file_header
.e_type
== ET_EXEC
6290 || filedata
->file_header
.e_type
== ET_DYN
6291 /* These next two tests may be redundant, but
6292 they have been left in for paranoia's sake. */
6293 || streq (SECTION_NAME (section
), ".rel.dyn")
6294 || streq (SECTION_NAME (section
), ".rela.dyn")))
6295 /* Dynamic relocations apply to segments, not sections, so
6296 they do not need an sh_info value. */
6299 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6300 i
, section
->sh_info
);
6306 case SHT_SYMTAB_SHNDX
:
6307 case SHT_INIT_ARRAY
:
6308 case SHT_FINI_ARRAY
:
6309 case SHT_PREINIT_ARRAY
:
6310 if (section
->sh_info
!= 0)
6311 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6312 i
, section
->sh_info
);
6318 /* A symbol index - we assume that it is valid. */
6322 /* FIXME: Add support for target specific section types. */
6323 if (section
->sh_type
== SHT_NOBITS
)
6324 /* NOBITS section headers with non-zero sh_info fields can be
6325 created when a binary is stripped of everything but its debug
6326 information. The stripped sections have their headers
6327 preserved but their types set to SHT_NOBITS. So do not check
6328 this type of section. */
6330 else if (section
->sh_flags
& SHF_INFO_LINK
)
6332 if (section
->sh_info
< 1 || section
->sh_info
>= filedata
->file_header
.e_shnum
)
6333 warn (_("[%2u]: Expected link to another section in info field"), i
);
6335 else if (section
->sh_type
< SHT_LOOS
6336 && (section
->sh_flags
& SHF_GNU_MBIND
) == 0
6337 && section
->sh_info
!= 0)
6338 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6339 i
, section
->sh_info
);
6343 /* Check the sh_size field. */
6344 if (section
->sh_size
> filedata
->file_size
6345 && section
->sh_type
!= SHT_NOBITS
6346 && section
->sh_type
!= SHT_NULL
6347 && section
->sh_type
< SHT_LOOS
)
6348 warn (_("Size of section %u is larger than the entire file!\n"), i
);
6350 printf (" [%2u] ", i
);
6351 if (do_section_details
)
6352 printf ("%s\n ", printable_section_name (filedata
, section
));
6354 print_symbol (-17, SECTION_NAME (section
));
6356 printf (do_wide
? " %-15s " : " %-15.15s ",
6357 get_section_type_name (filedata
, section
->sh_type
));
6361 const char * link_too_big
= NULL
;
6363 print_vma (section
->sh_addr
, LONG_HEX
);
6365 printf ( " %6.6lx %6.6lx %2.2lx",
6366 (unsigned long) section
->sh_offset
,
6367 (unsigned long) section
->sh_size
,
6368 (unsigned long) section
->sh_entsize
);
6370 if (do_section_details
)
6371 fputs (" ", stdout
);
6373 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6375 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
6378 /* The sh_link value is out of range. Normally this indicates
6379 an error but it can have special values in Solaris binaries. */
6380 switch (filedata
->file_header
.e_machine
)
6387 case EM_OLD_SPARCV9
:
6388 case EM_SPARC32PLUS
:
6391 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
6392 link_too_big
= "BEFORE";
6393 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
6394 link_too_big
= "AFTER";
6401 if (do_section_details
)
6403 if (link_too_big
!= NULL
&& * link_too_big
)
6404 printf ("<%s> ", link_too_big
);
6406 printf ("%2u ", section
->sh_link
);
6407 printf ("%3u %2lu\n", section
->sh_info
,
6408 (unsigned long) section
->sh_addralign
);
6411 printf ("%2u %3u %2lu\n",
6414 (unsigned long) section
->sh_addralign
);
6416 if (link_too_big
&& ! * link_too_big
)
6417 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6418 i
, section
->sh_link
);
6422 print_vma (section
->sh_addr
, LONG_HEX
);
6424 if ((long) section
->sh_offset
== section
->sh_offset
)
6425 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
6429 print_vma (section
->sh_offset
, LONG_HEX
);
6432 if ((unsigned long) section
->sh_size
== section
->sh_size
)
6433 printf (" %6.6lx", (unsigned long) section
->sh_size
);
6437 print_vma (section
->sh_size
, LONG_HEX
);
6440 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
6441 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
6445 print_vma (section
->sh_entsize
, LONG_HEX
);
6448 if (do_section_details
)
6449 fputs (" ", stdout
);
6451 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6453 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
6455 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
6456 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
6459 print_vma (section
->sh_addralign
, DEC
);
6463 else if (do_section_details
)
6465 printf (" %-15.15s ",
6466 get_section_type_name (filedata
, section
->sh_type
));
6467 print_vma (section
->sh_addr
, LONG_HEX
);
6468 if ((long) section
->sh_offset
== section
->sh_offset
)
6469 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
6473 print_vma (section
->sh_offset
, LONG_HEX
);
6475 printf (" %u\n ", section
->sh_link
);
6476 print_vma (section
->sh_size
, LONG_HEX
);
6478 print_vma (section
->sh_entsize
, LONG_HEX
);
6480 printf (" %-16u %lu\n",
6482 (unsigned long) section
->sh_addralign
);
6487 print_vma (section
->sh_addr
, LONG_HEX
);
6488 if ((long) section
->sh_offset
== section
->sh_offset
)
6489 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
6493 print_vma (section
->sh_offset
, LONG_HEX
);
6496 print_vma (section
->sh_size
, LONG_HEX
);
6498 print_vma (section
->sh_entsize
, LONG_HEX
);
6500 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6502 printf (" %2u %3u %lu\n",
6505 (unsigned long) section
->sh_addralign
);
6508 if (do_section_details
)
6510 printf (" %s\n", get_elf_section_flags (filedata
, section
->sh_flags
));
6511 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
6513 /* Minimum section size is 12 bytes for 32-bit compression
6514 header + 12 bytes for compressed data header. */
6515 unsigned char buf
[24];
6517 assert (sizeof (buf
) >= sizeof (Elf64_External_Chdr
));
6518 if (get_data (&buf
, filedata
, section
->sh_offset
, 1,
6519 sizeof (buf
), _("compression header")))
6521 Elf_Internal_Chdr chdr
;
6523 (void) get_compression_header (&chdr
, buf
, sizeof (buf
));
6525 if (chdr
.ch_type
== ELFCOMPRESS_ZLIB
)
6528 printf (_(" [<unknown>: 0x%x], "),
6530 print_vma (chdr
.ch_size
, LONG_HEX
);
6531 printf (", %lu\n", (unsigned long) chdr
.ch_addralign
);
6537 if (!do_section_details
)
6539 /* The ordering of the letters shown here matches the ordering of the
6540 corresponding SHF_xxx values, and hence the order in which these
6541 letters will be displayed to the user. */
6542 printf (_("Key to Flags:\n\
6543 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6544 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6545 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
6546 if (filedata
->file_header
.e_machine
== EM_X86_64
6547 || filedata
->file_header
.e_machine
== EM_L1OM
6548 || filedata
->file_header
.e_machine
== EM_K1OM
)
6549 printf (_("l (large), "));
6550 else if (filedata
->file_header
.e_machine
== EM_ARM
)
6551 printf (_("y (purecode), "));
6552 else if (filedata
->file_header
.e_machine
== EM_PPC
)
6553 printf (_("v (VLE), "));
6554 printf ("p (processor specific)\n");
6561 get_group_flags (unsigned int flags
)
6563 static char buff
[128];
6567 else if (flags
== GRP_COMDAT
)
6570 snprintf (buff
, 14, _("[0x%x: "), flags
);
6572 flags
&= ~ GRP_COMDAT
;
6573 if (flags
& GRP_MASKOS
)
6575 strcat (buff
, "<OS specific>");
6576 flags
&= ~ GRP_MASKOS
;
6579 if (flags
& GRP_MASKPROC
)
6581 strcat (buff
, "<PROC specific>");
6582 flags
&= ~ GRP_MASKPROC
;
6586 strcat (buff
, "<unknown>");
6593 process_section_groups (Filedata
* filedata
)
6595 Elf_Internal_Shdr
* section
;
6597 struct group
* group
;
6598 Elf_Internal_Shdr
* symtab_sec
;
6599 Elf_Internal_Shdr
* strtab_sec
;
6600 Elf_Internal_Sym
* symtab
;
6601 unsigned long num_syms
;
6605 /* Don't process section groups unless needed. */
6606 if (!do_unwind
&& !do_section_groups
)
6609 if (filedata
->file_header
.e_shnum
== 0)
6611 if (do_section_groups
)
6612 printf (_("\nThere are no sections to group in this file.\n"));
6617 if (filedata
->section_headers
== NULL
)
6619 error (_("Section headers are not available!\n"));
6620 /* PR 13622: This can happen with a corrupt ELF header. */
6624 section_headers_groups
= (struct group
**) calloc (filedata
->file_header
.e_shnum
,
6625 sizeof (struct group
*));
6627 if (section_headers_groups
== NULL
)
6629 error (_("Out of memory reading %u section group headers\n"),
6630 filedata
->file_header
.e_shnum
);
6634 /* Scan the sections for the group section. */
6636 for (i
= 0, section
= filedata
->section_headers
;
6637 i
< filedata
->file_header
.e_shnum
;
6639 if (section
->sh_type
== SHT_GROUP
)
6642 if (group_count
== 0)
6644 if (do_section_groups
)
6645 printf (_("\nThere are no section groups in this file.\n"));
6650 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
6652 if (section_groups
== NULL
)
6654 error (_("Out of memory reading %lu groups\n"),
6655 (unsigned long) group_count
);
6665 for (i
= 0, section
= filedata
->section_headers
, group
= section_groups
;
6666 i
< filedata
->file_header
.e_shnum
;
6669 if (section
->sh_type
== SHT_GROUP
)
6671 const char * name
= printable_section_name (filedata
, section
);
6672 const char * group_name
;
6673 unsigned char * start
;
6674 unsigned char * indices
;
6675 unsigned int entry
, j
, size
;
6676 Elf_Internal_Shdr
* sec
;
6677 Elf_Internal_Sym
* sym
;
6679 /* Get the symbol table. */
6680 if (section
->sh_link
>= filedata
->file_header
.e_shnum
6681 || ((sec
= filedata
->section_headers
+ section
->sh_link
)->sh_type
6684 error (_("Bad sh_link in group section `%s'\n"), name
);
6688 if (symtab_sec
!= sec
)
6693 symtab
= GET_ELF_SYMBOLS (filedata
, symtab_sec
, & num_syms
);
6698 error (_("Corrupt header in group section `%s'\n"), name
);
6702 if (section
->sh_info
>= num_syms
)
6704 error (_("Bad sh_info in group section `%s'\n"), name
);
6708 sym
= symtab
+ section
->sh_info
;
6710 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
6712 if (sym
->st_shndx
== 0
6713 || sym
->st_shndx
>= filedata
->file_header
.e_shnum
)
6715 error (_("Bad sh_info in group section `%s'\n"), name
);
6719 group_name
= SECTION_NAME (filedata
->section_headers
+ sym
->st_shndx
);
6728 /* Get the string table. */
6729 if (symtab_sec
->sh_link
>= filedata
->file_header
.e_shnum
)
6738 != (sec
= filedata
->section_headers
+ symtab_sec
->sh_link
))
6744 strtab
= (char *) get_data (NULL
, filedata
, strtab_sec
->sh_offset
,
6745 1, strtab_sec
->sh_size
,
6747 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
6749 group_name
= sym
->st_name
< strtab_size
6750 ? strtab
+ sym
->st_name
: _("<corrupt>");
6753 /* PR 17531: file: loop. */
6754 if (section
->sh_entsize
> section
->sh_size
)
6756 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6757 printable_section_name (filedata
, section
),
6758 (unsigned long) section
->sh_entsize
,
6759 (unsigned long) section
->sh_size
);
6763 start
= (unsigned char *) get_data (NULL
, filedata
, section
->sh_offset
,
6764 1, section
->sh_size
,
6770 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
6771 entry
= byte_get (indices
, 4);
6774 if (do_section_groups
)
6776 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6777 get_group_flags (entry
), i
, name
, group_name
, size
);
6779 printf (_(" [Index] Name\n"));
6782 group
->group_index
= i
;
6784 for (j
= 0; j
< size
; j
++)
6786 struct group_list
* g
;
6788 entry
= byte_get (indices
, 4);
6791 if (entry
>= filedata
->file_header
.e_shnum
)
6793 static unsigned num_group_errors
= 0;
6795 if (num_group_errors
++ < 10)
6797 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6798 entry
, i
, filedata
->file_header
.e_shnum
- 1);
6799 if (num_group_errors
== 10)
6800 warn (_("Further error messages about overlarge group section indicies suppressed\n"));
6805 if (section_headers_groups
[entry
] != NULL
)
6809 static unsigned num_errs
= 0;
6811 if (num_errs
++ < 10)
6813 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6815 section_headers_groups
[entry
]->group_index
);
6817 warn (_("Further error messages about already contained group sections suppressed\n"));
6823 /* Intel C/C++ compiler may put section 0 in a
6824 section group. We just warn it the first time
6825 and ignore it afterwards. */
6826 static bfd_boolean warned
= FALSE
;
6829 error (_("section 0 in group section [%5u]\n"),
6830 section_headers_groups
[entry
]->group_index
);
6836 section_headers_groups
[entry
] = group
;
6838 if (do_section_groups
)
6840 sec
= filedata
->section_headers
+ entry
;
6841 printf (" [%5u] %s\n", entry
, printable_section_name (filedata
, sec
));
6844 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
6845 g
->section_index
= entry
;
6846 g
->next
= group
->root
;
6864 /* Data used to display dynamic fixups. */
6866 struct ia64_vms_dynfixup
6868 bfd_vma needed_ident
; /* Library ident number. */
6869 bfd_vma needed
; /* Index in the dstrtab of the library name. */
6870 bfd_vma fixup_needed
; /* Index of the library. */
6871 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
6872 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
6875 /* Data used to display dynamic relocations. */
6877 struct ia64_vms_dynimgrela
6879 bfd_vma img_rela_cnt
; /* Number of relocations. */
6880 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
6883 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6887 dump_ia64_vms_dynamic_fixups (Filedata
* filedata
,
6888 struct ia64_vms_dynfixup
* fixup
,
6889 const char * strtab
,
6890 unsigned int strtab_sz
)
6892 Elf64_External_VMS_IMAGE_FIXUP
* imfs
;
6894 const char * lib_name
;
6896 imfs
= get_data (NULL
, filedata
, dynamic_addr
+ fixup
->fixup_rela_off
,
6897 1, fixup
->fixup_rela_cnt
* sizeof (*imfs
),
6898 _("dynamic section image fixups"));
6902 if (fixup
->needed
< strtab_sz
)
6903 lib_name
= strtab
+ fixup
->needed
;
6906 warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
6907 (unsigned long) fixup
->needed
);
6910 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6911 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
6913 (_("Seg Offset Type SymVec DataType\n"));
6915 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
6920 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
6921 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
6922 type
= BYTE_GET (imfs
[i
].type
);
6923 rtype
= elf_ia64_reloc_type (type
);
6925 printf (" 0x%08x ", type
);
6927 printf (" %-32s ", rtype
);
6928 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
6929 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
6936 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
6939 dump_ia64_vms_dynamic_relocs (Filedata
* filedata
, struct ia64_vms_dynimgrela
*imgrela
)
6941 Elf64_External_VMS_IMAGE_RELA
*imrs
;
6944 imrs
= get_data (NULL
, filedata
, dynamic_addr
+ imgrela
->img_rela_off
,
6945 1, imgrela
->img_rela_cnt
* sizeof (*imrs
),
6946 _("dynamic section image relocations"));
6950 printf (_("\nImage relocs\n"));
6952 (_("Seg Offset Type Addend Seg Sym Off\n"));
6954 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
6959 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
6960 printf ("%08" BFD_VMA_FMT
"x ",
6961 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
6962 type
= BYTE_GET (imrs
[i
].type
);
6963 rtype
= elf_ia64_reloc_type (type
);
6965 printf ("0x%08x ", type
);
6967 printf ("%-31s ", rtype
);
6968 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
6969 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
6970 printf ("%08" BFD_VMA_FMT
"x\n",
6971 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
6978 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
6981 process_ia64_vms_dynamic_relocs (Filedata
* filedata
)
6983 struct ia64_vms_dynfixup fixup
;
6984 struct ia64_vms_dynimgrela imgrela
;
6985 Elf_Internal_Dyn
*entry
;
6986 bfd_vma strtab_off
= 0;
6987 bfd_vma strtab_sz
= 0;
6988 char *strtab
= NULL
;
6989 bfd_boolean res
= TRUE
;
6991 memset (&fixup
, 0, sizeof (fixup
));
6992 memset (&imgrela
, 0, sizeof (imgrela
));
6994 /* Note: the order of the entries is specified by the OpenVMS specs. */
6995 for (entry
= dynamic_section
;
6996 entry
< dynamic_section
+ dynamic_nent
;
6999 switch (entry
->d_tag
)
7001 case DT_IA_64_VMS_STRTAB_OFFSET
:
7002 strtab_off
= entry
->d_un
.d_val
;
7005 strtab_sz
= entry
->d_un
.d_val
;
7007 strtab
= get_data (NULL
, filedata
, dynamic_addr
+ strtab_off
,
7008 1, strtab_sz
, _("dynamic string section"));
7011 case DT_IA_64_VMS_NEEDED_IDENT
:
7012 fixup
.needed_ident
= entry
->d_un
.d_val
;
7015 fixup
.needed
= entry
->d_un
.d_val
;
7017 case DT_IA_64_VMS_FIXUP_NEEDED
:
7018 fixup
.fixup_needed
= entry
->d_un
.d_val
;
7020 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
7021 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
7023 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
7024 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
7025 if (! dump_ia64_vms_dynamic_fixups (filedata
, &fixup
, strtab
, strtab_sz
))
7028 case DT_IA_64_VMS_IMG_RELA_CNT
:
7029 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
7031 case DT_IA_64_VMS_IMG_RELA_OFF
:
7032 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
7033 if (! dump_ia64_vms_dynamic_relocs (filedata
, &imgrela
))
7055 dynamic_relocations
[] =
7057 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
7058 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
7059 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
7062 /* Process the reloc section. */
7065 process_relocs (Filedata
* filedata
)
7067 unsigned long rel_size
;
7068 unsigned long rel_offset
;
7073 if (do_using_dynamic
)
7077 bfd_boolean has_dynamic_reloc
;
7080 has_dynamic_reloc
= FALSE
;
7082 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7084 is_rela
= dynamic_relocations
[i
].rela
;
7085 name
= dynamic_relocations
[i
].name
;
7086 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
7087 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
7090 has_dynamic_reloc
= TRUE
;
7092 if (is_rela
== UNKNOWN
)
7094 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
7095 switch (dynamic_info
[DT_PLTREL
])
7109 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7110 name
, rel_offset
, rel_size
);
7112 dump_relocations (filedata
,
7113 offset_from_vma (filedata
, rel_offset
, rel_size
),
7115 dynamic_symbols
, num_dynamic_syms
,
7116 dynamic_strings
, dynamic_strings_length
,
7117 is_rela
, TRUE
/* is_dynamic */);
7121 if (is_ia64_vms (filedata
))
7122 if (process_ia64_vms_dynamic_relocs (filedata
))
7123 has_dynamic_reloc
= TRUE
;
7125 if (! has_dynamic_reloc
)
7126 printf (_("\nThere are no dynamic relocations in this file.\n"));
7130 Elf_Internal_Shdr
* section
;
7132 bfd_boolean found
= FALSE
;
7134 for (i
= 0, section
= filedata
->section_headers
;
7135 i
< filedata
->file_header
.e_shnum
;
7138 if ( section
->sh_type
!= SHT_RELA
7139 && section
->sh_type
!= SHT_REL
)
7142 rel_offset
= section
->sh_offset
;
7143 rel_size
= section
->sh_size
;
7147 Elf_Internal_Shdr
* strsec
;
7149 unsigned long num_rela
;
7151 printf (_("\nRelocation section "));
7153 if (filedata
->string_table
== NULL
)
7154 printf ("%d", section
->sh_name
);
7156 printf ("'%s'", printable_section_name (filedata
, section
));
7158 num_rela
= rel_size
/ section
->sh_entsize
;
7159 printf (ngettext (" at offset 0x%lx contains %lu entry:\n",
7160 " at offset 0x%lx contains %lu entries:\n",
7162 rel_offset
, num_rela
);
7164 is_rela
= section
->sh_type
== SHT_RELA
;
7166 if (section
->sh_link
!= 0
7167 && section
->sh_link
< filedata
->file_header
.e_shnum
)
7169 Elf_Internal_Shdr
* symsec
;
7170 Elf_Internal_Sym
* symtab
;
7171 unsigned long nsyms
;
7172 unsigned long strtablen
= 0;
7173 char * strtab
= NULL
;
7175 symsec
= filedata
->section_headers
+ section
->sh_link
;
7176 if (symsec
->sh_type
!= SHT_SYMTAB
7177 && symsec
->sh_type
!= SHT_DYNSYM
)
7180 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & nsyms
);
7185 if (symsec
->sh_link
!= 0
7186 && symsec
->sh_link
< filedata
->file_header
.e_shnum
)
7188 strsec
= filedata
->section_headers
+ symsec
->sh_link
;
7190 strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
7193 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
7196 dump_relocations (filedata
, rel_offset
, rel_size
,
7197 symtab
, nsyms
, strtab
, strtablen
,
7199 symsec
->sh_type
== SHT_DYNSYM
);
7205 dump_relocations (filedata
, rel_offset
, rel_size
,
7206 NULL
, 0, NULL
, 0, is_rela
,
7207 FALSE
/* is_dynamic */);
7215 /* Users sometimes forget the -D option, so try to be helpful. */
7216 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7218 if (dynamic_info
[dynamic_relocations
[i
].size
])
7220 printf (_("\nThere are no static relocations in this file."));
7221 printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
7226 if (i
== ARRAY_SIZE (dynamic_relocations
))
7227 printf (_("\nThere are no relocations in this file.\n"));
7234 /* An absolute address consists of a section and an offset. If the
7235 section is NULL, the offset itself is the address, otherwise, the
7236 address equals to LOAD_ADDRESS(section) + offset. */
7240 unsigned short section
;
7244 #define ABSADDR(a) \
7246 ? filedata->section_headers [(a).section].sh_addr + (a).offset \
7249 /* Find the nearest symbol at or below ADDR. Returns the symbol
7250 name, if found, and the offset from the symbol to ADDR. */
7253 find_symbol_for_address (Filedata
* filedata
,
7254 Elf_Internal_Sym
* symtab
,
7255 unsigned long nsyms
,
7256 const char * strtab
,
7257 unsigned long strtab_size
,
7258 struct absaddr addr
,
7259 const char ** symname
,
7262 bfd_vma dist
= 0x100000;
7263 Elf_Internal_Sym
* sym
;
7264 Elf_Internal_Sym
* beg
;
7265 Elf_Internal_Sym
* end
;
7266 Elf_Internal_Sym
* best
= NULL
;
7268 REMOVE_ARCH_BITS (addr
.offset
);
7270 end
= symtab
+ nsyms
;
7276 sym
= beg
+ (end
- beg
) / 2;
7278 value
= sym
->st_value
;
7279 REMOVE_ARCH_BITS (value
);
7281 if (sym
->st_name
!= 0
7282 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
7283 && addr
.offset
>= value
7284 && addr
.offset
- value
< dist
)
7287 dist
= addr
.offset
- value
;
7292 if (addr
.offset
< value
)
7300 *symname
= (best
->st_name
>= strtab_size
7301 ? _("<corrupt>") : strtab
+ best
->st_name
);
7307 *offset
= addr
.offset
;
7310 static /* signed */ int
7311 symcmp (const void *p
, const void *q
)
7313 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
7314 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
7316 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
7319 /* Process the unwind section. */
7321 #include "unwind-ia64.h"
7323 struct ia64_unw_table_entry
7325 struct absaddr start
;
7327 struct absaddr info
;
7330 struct ia64_unw_aux_info
7332 struct ia64_unw_table_entry
* table
; /* Unwind table. */
7333 unsigned long table_len
; /* Length of unwind table. */
7334 unsigned char * info
; /* Unwind info. */
7335 unsigned long info_size
; /* Size of unwind info. */
7336 bfd_vma info_addr
; /* Starting address of unwind info. */
7337 bfd_vma seg_base
; /* Starting address of segment. */
7338 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7339 unsigned long nsyms
; /* Number of symbols. */
7340 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7341 unsigned long nfuns
; /* Number of entries in funtab. */
7342 char * strtab
; /* The string table. */
7343 unsigned long strtab_size
; /* Size of string table. */
7347 dump_ia64_unwind (Filedata
* filedata
, struct ia64_unw_aux_info
* aux
)
7349 struct ia64_unw_table_entry
* tp
;
7350 unsigned long j
, nfuns
;
7352 bfd_boolean res
= TRUE
;
7354 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7355 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7356 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7357 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7359 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7361 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7365 const unsigned char * dp
;
7366 const unsigned char * head
;
7367 const unsigned char * end
;
7368 const char * procname
;
7370 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7371 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
7373 fputs ("\n<", stdout
);
7377 fputs (procname
, stdout
);
7380 printf ("+%lx", (unsigned long) offset
);
7383 fputs (">: [", stdout
);
7384 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7385 fputc ('-', stdout
);
7386 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7387 printf ("], info at +0x%lx\n",
7388 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
7390 /* PR 17531: file: 86232b32. */
7391 if (aux
->info
== NULL
)
7394 /* PR 17531: file: 0997b4d1. */
7395 if ((ABSADDR (tp
->info
) - aux
->info_addr
) >= aux
->info_size
)
7397 warn (_("Invalid offset %lx in table entry %ld\n"),
7398 (long) tp
->info
.offset
, (long) (tp
- aux
->table
));
7403 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
7404 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
7406 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7407 (unsigned) UNW_VER (stamp
),
7408 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
7409 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
7410 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
7411 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
7413 if (UNW_VER (stamp
) != 1)
7415 printf (_("\tUnknown version.\n"));
7420 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
7421 /* PR 17531: file: 16ceda89. */
7422 if (end
> aux
->info
+ aux
->info_size
)
7423 end
= aux
->info
+ aux
->info_size
;
7424 for (dp
= head
+ 8; dp
< end
;)
7425 dp
= unw_decode (dp
, in_body
, & in_body
, end
);
7434 slurp_ia64_unwind_table (Filedata
* filedata
,
7435 struct ia64_unw_aux_info
* aux
,
7436 Elf_Internal_Shdr
* sec
)
7438 unsigned long size
, nrelas
, i
;
7439 Elf_Internal_Phdr
* seg
;
7440 struct ia64_unw_table_entry
* tep
;
7441 Elf_Internal_Shdr
* relsec
;
7442 Elf_Internal_Rela
* rela
;
7443 Elf_Internal_Rela
* rp
;
7444 unsigned char * table
;
7446 Elf_Internal_Sym
* sym
;
7447 const char * relname
;
7451 /* First, find the starting address of the segment that includes
7454 if (filedata
->file_header
.e_phnum
)
7456 if (! get_program_headers (filedata
))
7459 for (seg
= filedata
->program_headers
;
7460 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
7463 if (seg
->p_type
!= PT_LOAD
)
7466 if (sec
->sh_addr
>= seg
->p_vaddr
7467 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7469 aux
->seg_base
= seg
->p_vaddr
;
7475 /* Second, build the unwind table from the contents of the unwind section: */
7476 size
= sec
->sh_size
;
7477 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
7482 aux
->table_len
= size
/ (3 * eh_addr_size
);
7483 aux
->table
= (struct ia64_unw_table_entry
*)
7484 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
7487 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
7489 tep
->start
.section
= SHN_UNDEF
;
7490 tep
->end
.section
= SHN_UNDEF
;
7491 tep
->info
.section
= SHN_UNDEF
;
7492 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7493 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7494 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7495 tep
->start
.offset
+= aux
->seg_base
;
7496 tep
->end
.offset
+= aux
->seg_base
;
7497 tep
->info
.offset
+= aux
->seg_base
;
7501 /* Third, apply any relocations to the unwind table: */
7502 for (relsec
= filedata
->section_headers
;
7503 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
7506 if (relsec
->sh_type
!= SHT_RELA
7507 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
7508 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
7511 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
7520 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7522 relname
= elf_ia64_reloc_type (get_reloc_type (filedata
, rp
->r_info
));
7523 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
7525 /* PR 17531: file: 9fa67536. */
7526 if (relname
== NULL
)
7528 warn (_("Skipping unknown relocation type: %u\n"),
7529 get_reloc_type (filedata
, rp
->r_info
));
7533 if (! const_strneq (relname
, "R_IA64_SEGREL"))
7535 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
7539 i
= rp
->r_offset
/ (3 * eh_addr_size
);
7541 /* PR 17531: file: 5bc8d9bf. */
7542 if (i
>= aux
->table_len
)
7544 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
7548 switch (rp
->r_offset
/ eh_addr_size
% 3)
7551 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7552 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
7555 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7556 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
7559 aux
->table
[i
].info
.section
= sym
->st_shndx
;
7560 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
7574 ia64_process_unwind (Filedata
* filedata
)
7576 Elf_Internal_Shdr
* sec
;
7577 Elf_Internal_Shdr
* unwsec
= NULL
;
7578 Elf_Internal_Shdr
* strsec
;
7579 unsigned long i
, unwcount
= 0, unwstart
= 0;
7580 struct ia64_unw_aux_info aux
;
7581 bfd_boolean res
= TRUE
;
7583 memset (& aux
, 0, sizeof (aux
));
7585 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
7587 if (sec
->sh_type
== SHT_SYMTAB
7588 && sec
->sh_link
< filedata
->file_header
.e_shnum
)
7590 aux
.symtab
= GET_ELF_SYMBOLS (filedata
, sec
, & aux
.nsyms
);
7592 strsec
= filedata
->section_headers
+ sec
->sh_link
;
7593 if (aux
.strtab
!= NULL
)
7595 error (_("Multiple auxillary string tables encountered\n"));
7599 aux
.strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
7602 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7604 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7609 printf (_("\nThere are no unwind sections in this file.\n"));
7611 while (unwcount
-- > 0)
7616 for (i
= unwstart
, sec
= filedata
->section_headers
+ unwstart
, unwsec
= NULL
;
7617 i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
7618 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7623 /* We have already counted the number of SHT_IA64_UNWIND
7624 sections so the loop above should never fail. */
7625 assert (unwsec
!= NULL
);
7628 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
7630 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
7632 /* We need to find which section group it is in. */
7633 struct group_list
* g
;
7635 if (section_headers_groups
== NULL
7636 || section_headers_groups
[i
] == NULL
)
7637 i
= filedata
->file_header
.e_shnum
;
7640 g
= section_headers_groups
[i
]->root
;
7642 for (; g
!= NULL
; g
= g
->next
)
7644 sec
= filedata
->section_headers
+ g
->section_index
;
7646 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
7651 i
= filedata
->file_header
.e_shnum
;
7654 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
7656 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
7657 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
7658 suffix
= SECTION_NAME (unwsec
) + len
;
7659 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
;
7661 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
7662 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7667 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7668 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
7669 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
7670 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
7672 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
7673 suffix
= SECTION_NAME (unwsec
) + len
;
7674 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
;
7676 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
7677 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7681 if (i
== filedata
->file_header
.e_shnum
)
7683 printf (_("\nCould not find unwind info section for "));
7685 if (filedata
->string_table
== NULL
)
7686 printf ("%d", unwsec
->sh_name
);
7688 printf ("'%s'", printable_section_name (filedata
, unwsec
));
7692 aux
.info_addr
= sec
->sh_addr
;
7693 aux
.info
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1,
7696 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
7698 printf (_("\nUnwind section "));
7700 if (filedata
->string_table
== NULL
)
7701 printf ("%d", unwsec
->sh_name
);
7703 printf ("'%s'", printable_section_name (filedata
, unwsec
));
7705 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7706 (unsigned long) unwsec
->sh_offset
,
7707 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
7709 if (slurp_ia64_unwind_table (filedata
, & aux
, unwsec
)
7710 && aux
.table_len
> 0)
7711 dump_ia64_unwind (filedata
, & aux
);
7714 free ((char *) aux
.table
);
7716 free ((char *) aux
.info
);
7725 free ((char *) aux
.strtab
);
7730 struct hppa_unw_table_entry
7732 struct absaddr start
;
7734 unsigned int Cannot_unwind
:1; /* 0 */
7735 unsigned int Millicode
:1; /* 1 */
7736 unsigned int Millicode_save_sr0
:1; /* 2 */
7737 unsigned int Region_description
:2; /* 3..4 */
7738 unsigned int reserved1
:1; /* 5 */
7739 unsigned int Entry_SR
:1; /* 6 */
7740 unsigned int Entry_FR
:4; /* Number saved 7..10 */
7741 unsigned int Entry_GR
:5; /* Number saved 11..15 */
7742 unsigned int Args_stored
:1; /* 16 */
7743 unsigned int Variable_Frame
:1; /* 17 */
7744 unsigned int Separate_Package_Body
:1; /* 18 */
7745 unsigned int Frame_Extension_Millicode
:1; /* 19 */
7746 unsigned int Stack_Overflow_Check
:1; /* 20 */
7747 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
7748 unsigned int Ada_Region
:1; /* 22 */
7749 unsigned int cxx_info
:1; /* 23 */
7750 unsigned int cxx_try_catch
:1; /* 24 */
7751 unsigned int sched_entry_seq
:1; /* 25 */
7752 unsigned int reserved2
:1; /* 26 */
7753 unsigned int Save_SP
:1; /* 27 */
7754 unsigned int Save_RP
:1; /* 28 */
7755 unsigned int Save_MRP_in_frame
:1; /* 29 */
7756 unsigned int extn_ptr_defined
:1; /* 30 */
7757 unsigned int Cleanup_defined
:1; /* 31 */
7759 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
7760 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
7761 unsigned int Large_frame
:1; /* 2 */
7762 unsigned int Pseudo_SP_Set
:1; /* 3 */
7763 unsigned int reserved4
:1; /* 4 */
7764 unsigned int Total_frame_size
:27; /* 5..31 */
7767 struct hppa_unw_aux_info
7769 struct hppa_unw_table_entry
* table
; /* Unwind table. */
7770 unsigned long table_len
; /* Length of unwind table. */
7771 bfd_vma seg_base
; /* Starting address of segment. */
7772 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7773 unsigned long nsyms
; /* Number of symbols. */
7774 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7775 unsigned long nfuns
; /* Number of entries in funtab. */
7776 char * strtab
; /* The string table. */
7777 unsigned long strtab_size
; /* Size of string table. */
7781 dump_hppa_unwind (Filedata
* filedata
, struct hppa_unw_aux_info
* aux
)
7783 struct hppa_unw_table_entry
* tp
;
7784 unsigned long j
, nfuns
;
7785 bfd_boolean res
= TRUE
;
7787 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7788 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7789 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7790 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7792 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7794 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7797 const char * procname
;
7799 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7800 aux
->strtab_size
, tp
->start
, &procname
,
7803 fputs ("\n<", stdout
);
7807 fputs (procname
, stdout
);
7810 printf ("+%lx", (unsigned long) offset
);
7813 fputs (">: [", stdout
);
7814 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7815 fputc ('-', stdout
);
7816 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7819 #define PF(_m) if (tp->_m) printf (#_m " ");
7820 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
7823 PF(Millicode_save_sr0
);
7824 /* PV(Region_description); */
7830 PF(Separate_Package_Body
);
7831 PF(Frame_Extension_Millicode
);
7832 PF(Stack_Overflow_Check
);
7833 PF(Two_Instruction_SP_Increment
);
7837 PF(sched_entry_seq
);
7840 PF(Save_MRP_in_frame
);
7841 PF(extn_ptr_defined
);
7842 PF(Cleanup_defined
);
7843 PF(MPE_XL_interrupt_marker
);
7844 PF(HP_UX_interrupt_marker
);
7847 PV(Total_frame_size
);
7860 slurp_hppa_unwind_table (Filedata
* filedata
,
7861 struct hppa_unw_aux_info
* aux
,
7862 Elf_Internal_Shdr
* sec
)
7864 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
7865 Elf_Internal_Phdr
* seg
;
7866 struct hppa_unw_table_entry
* tep
;
7867 Elf_Internal_Shdr
* relsec
;
7868 Elf_Internal_Rela
* rela
;
7869 Elf_Internal_Rela
* rp
;
7870 unsigned char * table
;
7872 Elf_Internal_Sym
* sym
;
7873 const char * relname
;
7875 /* First, find the starting address of the segment that includes
7877 if (filedata
->file_header
.e_phnum
)
7879 if (! get_program_headers (filedata
))
7882 for (seg
= filedata
->program_headers
;
7883 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
7886 if (seg
->p_type
!= PT_LOAD
)
7889 if (sec
->sh_addr
>= seg
->p_vaddr
7890 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7892 aux
->seg_base
= seg
->p_vaddr
;
7898 /* Second, build the unwind table from the contents of the unwind
7900 size
= sec
->sh_size
;
7901 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
7907 nentries
= size
/ unw_ent_size
;
7908 size
= unw_ent_size
* nentries
;
7910 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
7911 xcmalloc (nentries
, sizeof (aux
->table
[0]));
7913 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
7915 unsigned int tmp1
, tmp2
;
7917 tep
->start
.section
= SHN_UNDEF
;
7918 tep
->end
.section
= SHN_UNDEF
;
7920 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
7921 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
7922 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
7923 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
7925 tep
->start
.offset
+= aux
->seg_base
;
7926 tep
->end
.offset
+= aux
->seg_base
;
7928 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
7929 tep
->Millicode
= (tmp1
>> 30) & 0x1;
7930 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
7931 tep
->Region_description
= (tmp1
>> 27) & 0x3;
7932 tep
->reserved1
= (tmp1
>> 26) & 0x1;
7933 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
7934 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
7935 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
7936 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
7937 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
7938 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
7939 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
7940 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
7941 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
7942 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
7943 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
7944 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
7945 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
7946 tep
->reserved2
= (tmp1
>> 5) & 0x1;
7947 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
7948 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
7949 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
7950 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
7951 tep
->Cleanup_defined
= tmp1
& 0x1;
7953 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
7954 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
7955 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
7956 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
7957 tep
->reserved4
= (tmp2
>> 27) & 0x1;
7958 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
7962 /* Third, apply any relocations to the unwind table. */
7963 for (relsec
= filedata
->section_headers
;
7964 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
7967 if (relsec
->sh_type
!= SHT_RELA
7968 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
7969 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
7972 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
7976 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7978 relname
= elf_hppa_reloc_type (get_reloc_type (filedata
, rp
->r_info
));
7979 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
7981 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
7982 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
7984 warn (_("Skipping unexpected relocation type %s\n"), relname
);
7988 i
= rp
->r_offset
/ unw_ent_size
;
7990 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
7993 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7994 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
7997 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7998 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
8008 aux
->table_len
= nentries
;
8014 hppa_process_unwind (Filedata
* filedata
)
8016 struct hppa_unw_aux_info aux
;
8017 Elf_Internal_Shdr
* unwsec
= NULL
;
8018 Elf_Internal_Shdr
* strsec
;
8019 Elf_Internal_Shdr
* sec
;
8021 bfd_boolean res
= TRUE
;
8023 if (filedata
->string_table
== NULL
)
8026 memset (& aux
, 0, sizeof (aux
));
8028 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8030 if (sec
->sh_type
== SHT_SYMTAB
8031 && sec
->sh_link
< filedata
->file_header
.e_shnum
)
8033 aux
.symtab
= GET_ELF_SYMBOLS (filedata
, sec
, & aux
.nsyms
);
8035 strsec
= filedata
->section_headers
+ sec
->sh_link
;
8036 if (aux
.strtab
!= NULL
)
8038 error (_("Multiple auxillary string tables encountered\n"));
8042 aux
.strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
8045 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
8047 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8052 printf (_("\nThere are no unwind sections in this file.\n"));
8054 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8056 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8058 unsigned long num_unwind
= sec
->sh_size
/ (2 * eh_addr_size
+ 8);
8060 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
8061 "contains %lu entry:\n",
8062 "\nUnwind section '%s' at offset 0x%lx "
8063 "contains %lu entries:\n",
8065 printable_section_name (filedata
, sec
),
8066 (unsigned long) sec
->sh_offset
,
8069 if (! slurp_hppa_unwind_table (filedata
, &aux
, sec
))
8072 if (aux
.table_len
> 0)
8074 if (! dump_hppa_unwind (filedata
, &aux
))
8079 free ((char *) aux
.table
);
8087 free ((char *) aux
.strtab
);
8094 unsigned char * data
; /* The unwind data. */
8095 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
8096 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
8097 unsigned long nrelas
; /* The number of relocations. */
8098 unsigned int rel_type
; /* REL or RELA ? */
8099 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
8102 struct arm_unw_aux_info
8104 Filedata
* filedata
; /* The file containing the unwind sections. */
8105 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
8106 unsigned long nsyms
; /* Number of symbols. */
8107 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8108 unsigned long nfuns
; /* Number of these symbols. */
8109 char * strtab
; /* The file's string table. */
8110 unsigned long strtab_size
; /* Size of string table. */
8114 arm_print_vma_and_name (Filedata
* filedata
,
8115 struct arm_unw_aux_info
* aux
,
8117 struct absaddr addr
)
8119 const char *procname
;
8122 if (addr
.section
== SHN_UNDEF
)
8125 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8126 aux
->strtab_size
, addr
, &procname
,
8129 print_vma (fn
, PREFIX_HEX
);
8133 fputs (" <", stdout
);
8134 fputs (procname
, stdout
);
8137 printf ("+0x%lx", (unsigned long) sym_offset
);
8138 fputc ('>', stdout
);
8145 arm_free_section (struct arm_section
*arm_sec
)
8147 if (arm_sec
->data
!= NULL
)
8148 free (arm_sec
->data
);
8150 if (arm_sec
->rela
!= NULL
)
8151 free (arm_sec
->rela
);
8154 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8155 cached section and install SEC instead.
8156 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8157 and return its valued in * WORDP, relocating if necessary.
8158 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8159 relocation's offset in ADDR.
8160 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8161 into the string table of the symbol associated with the reloc. If no
8162 reloc was applied store -1 there.
8163 5) Return TRUE upon success, FALSE otherwise. */
8166 get_unwind_section_word (Filedata
* filedata
,
8167 struct arm_unw_aux_info
* aux
,
8168 struct arm_section
* arm_sec
,
8169 Elf_Internal_Shdr
* sec
,
8170 bfd_vma word_offset
,
8171 unsigned int * wordp
,
8172 struct absaddr
* addr
,
8175 Elf_Internal_Rela
*rp
;
8176 Elf_Internal_Sym
*sym
;
8177 const char * relname
;
8179 bfd_boolean wrapped
;
8181 if (sec
== NULL
|| arm_sec
== NULL
)
8184 addr
->section
= SHN_UNDEF
;
8187 if (sym_name
!= NULL
)
8188 *sym_name
= (bfd_vma
) -1;
8190 /* If necessary, update the section cache. */
8191 if (sec
!= arm_sec
->sec
)
8193 Elf_Internal_Shdr
*relsec
;
8195 arm_free_section (arm_sec
);
8198 arm_sec
->data
= get_data (NULL
, aux
->filedata
, sec
->sh_offset
, 1,
8199 sec
->sh_size
, _("unwind data"));
8200 arm_sec
->rela
= NULL
;
8201 arm_sec
->nrelas
= 0;
8203 for (relsec
= filedata
->section_headers
;
8204 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8207 if (relsec
->sh_info
>= filedata
->file_header
.e_shnum
8208 || filedata
->section_headers
+ relsec
->sh_info
!= sec
8209 /* PR 15745: Check the section type as well. */
8210 || (relsec
->sh_type
!= SHT_REL
8211 && relsec
->sh_type
!= SHT_RELA
))
8214 arm_sec
->rel_type
= relsec
->sh_type
;
8215 if (relsec
->sh_type
== SHT_REL
)
8217 if (!slurp_rel_relocs (aux
->filedata
, relsec
->sh_offset
,
8219 & arm_sec
->rela
, & arm_sec
->nrelas
))
8222 else /* relsec->sh_type == SHT_RELA */
8224 if (!slurp_rela_relocs (aux
->filedata
, relsec
->sh_offset
,
8226 & arm_sec
->rela
, & arm_sec
->nrelas
))
8232 arm_sec
->next_rela
= arm_sec
->rela
;
8235 /* If there is no unwind data we can do nothing. */
8236 if (arm_sec
->data
== NULL
)
8239 /* If the offset is invalid then fail. */
8240 if (/* PR 21343 *//* PR 18879 */
8242 || word_offset
> (sec
->sh_size
- 4)
8243 || ((bfd_signed_vma
) word_offset
) < 0)
8246 /* Get the word at the required offset. */
8247 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
8249 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
8250 if (arm_sec
->rela
== NULL
)
8256 /* Look through the relocs to find the one that applies to the provided offset. */
8258 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
8260 bfd_vma prelval
, offset
;
8262 if (rp
->r_offset
> word_offset
&& !wrapped
)
8267 if (rp
->r_offset
> word_offset
)
8270 if (rp
->r_offset
& 3)
8272 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8273 (unsigned long) rp
->r_offset
);
8277 if (rp
->r_offset
< word_offset
)
8280 /* PR 17531: file: 027-161405-0.004 */
8281 if (aux
->symtab
== NULL
)
8284 if (arm_sec
->rel_type
== SHT_REL
)
8286 offset
= word
& 0x7fffffff;
8287 if (offset
& 0x40000000)
8288 offset
|= ~ (bfd_vma
) 0x7fffffff;
8290 else if (arm_sec
->rel_type
== SHT_RELA
)
8291 offset
= rp
->r_addend
;
8294 error (_("Unknown section relocation type %d encountered\n"),
8299 /* PR 17531 file: 027-1241568-0.004. */
8300 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
8302 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8303 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
8307 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
8308 offset
+= sym
->st_value
;
8309 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
8311 /* Check that we are processing the expected reloc type. */
8312 if (filedata
->file_header
.e_machine
== EM_ARM
)
8314 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8315 if (relname
== NULL
)
8317 warn (_("Skipping unknown ARM relocation type: %d\n"),
8318 (int) ELF32_R_TYPE (rp
->r_info
));
8322 if (streq (relname
, "R_ARM_NONE"))
8325 if (! streq (relname
, "R_ARM_PREL31"))
8327 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
8331 else if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
8333 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8334 if (relname
== NULL
)
8336 warn (_("Skipping unknown C6000 relocation type: %d\n"),
8337 (int) ELF32_R_TYPE (rp
->r_info
));
8341 if (streq (relname
, "R_C6000_NONE"))
8344 if (! streq (relname
, "R_C6000_PREL31"))
8346 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
8354 /* This function currently only supports ARM and TI unwinders. */
8355 warn (_("Only TI and ARM unwinders are currently supported\n"));
8359 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
8360 addr
->section
= sym
->st_shndx
;
8361 addr
->offset
= offset
;
8364 * sym_name
= sym
->st_name
;
8369 arm_sec
->next_rela
= rp
;
8374 static const char *tic6x_unwind_regnames
[16] =
8376 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8377 "A14", "A13", "A12", "A11", "A10",
8378 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8382 decode_tic6x_unwind_regmask (unsigned int mask
)
8386 for (i
= 12; mask
; mask
>>= 1, i
--)
8390 fputs (tic6x_unwind_regnames
[i
], stdout
);
8392 fputs (", ", stdout
);
8398 if (remaining == 0 && more_words) \
8401 if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, \
8402 data_offset, & word, & addr, NULL)) \
8408 #define GET_OP(OP) \
8413 (OP) = word >> 24; \
8418 printf (_("[Truncated opcode]\n")); \
8421 printf ("0x%02x ", OP)
8424 decode_arm_unwind_bytecode (Filedata
* filedata
,
8425 struct arm_unw_aux_info
* aux
,
8427 unsigned int remaining
,
8428 unsigned int more_words
,
8429 bfd_vma data_offset
,
8430 Elf_Internal_Shdr
* data_sec
,
8431 struct arm_section
* data_arm_sec
)
8433 struct absaddr addr
;
8434 bfd_boolean res
= TRUE
;
8436 /* Decode the unwinding instructions. */
8439 unsigned int op
, op2
;
8448 printf (" 0x%02x ", op
);
8450 if ((op
& 0xc0) == 0x00)
8452 int offset
= ((op
& 0x3f) << 2) + 4;
8454 printf (" vsp = vsp + %d", offset
);
8456 else if ((op
& 0xc0) == 0x40)
8458 int offset
= ((op
& 0x3f) << 2) + 4;
8460 printf (" vsp = vsp - %d", offset
);
8462 else if ((op
& 0xf0) == 0x80)
8465 if (op
== 0x80 && op2
== 0)
8466 printf (_("Refuse to unwind"));
8469 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
8470 bfd_boolean first
= TRUE
;
8474 for (i
= 0; i
< 12; i
++)
8475 if (mask
& (1 << i
))
8481 printf ("r%d", 4 + i
);
8486 else if ((op
& 0xf0) == 0x90)
8488 if (op
== 0x9d || op
== 0x9f)
8489 printf (_(" [Reserved]"));
8491 printf (" vsp = r%d", op
& 0x0f);
8493 else if ((op
& 0xf0) == 0xa0)
8495 int end
= 4 + (op
& 0x07);
8496 bfd_boolean first
= TRUE
;
8500 for (i
= 4; i
<= end
; i
++)
8516 else if (op
== 0xb0)
8517 printf (_(" finish"));
8518 else if (op
== 0xb1)
8521 if (op2
== 0 || (op2
& 0xf0) != 0)
8522 printf (_("[Spare]"));
8525 unsigned int mask
= op2
& 0x0f;
8526 bfd_boolean first
= TRUE
;
8530 for (i
= 0; i
< 12; i
++)
8531 if (mask
& (1 << i
))
8542 else if (op
== 0xb2)
8544 unsigned char buf
[9];
8545 unsigned int i
, len
;
8546 unsigned long offset
;
8548 for (i
= 0; i
< sizeof (buf
); i
++)
8551 if ((buf
[i
] & 0x80) == 0)
8554 if (i
== sizeof (buf
))
8556 error (_("corrupt change to vsp"));
8561 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8562 assert (len
== i
+ 1);
8563 offset
= offset
* 4 + 0x204;
8564 printf ("vsp = vsp + %ld", offset
);
8567 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
8569 unsigned int first
, last
;
8576 printf ("pop {D%d", first
);
8578 printf ("-D%d", first
+ last
);
8581 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
8583 unsigned int count
= op
& 0x07;
8587 printf ("-D%d", 8 + count
);
8590 else if (op
>= 0xc0 && op
<= 0xc5)
8592 unsigned int count
= op
& 0x07;
8594 printf (" pop {wR10");
8596 printf ("-wR%d", 10 + count
);
8599 else if (op
== 0xc6)
8601 unsigned int first
, last
;
8606 printf ("pop {wR%d", first
);
8608 printf ("-wR%d", first
+ last
);
8611 else if (op
== 0xc7)
8614 if (op2
== 0 || (op2
& 0xf0) != 0)
8615 printf (_("[Spare]"));
8618 unsigned int mask
= op2
& 0x0f;
8619 bfd_boolean first
= TRUE
;
8623 for (i
= 0; i
< 4; i
++)
8624 if (mask
& (1 << i
))
8630 printf ("wCGR%d", i
);
8637 printf (_(" [unsupported opcode]"));
8648 decode_tic6x_unwind_bytecode (Filedata
* filedata
,
8649 struct arm_unw_aux_info
* aux
,
8651 unsigned int remaining
,
8652 unsigned int more_words
,
8653 bfd_vma data_offset
,
8654 Elf_Internal_Shdr
* data_sec
,
8655 struct arm_section
* data_arm_sec
)
8657 struct absaddr addr
;
8659 /* Decode the unwinding instructions. */
8662 unsigned int op
, op2
;
8671 printf (" 0x%02x ", op
);
8673 if ((op
& 0xc0) == 0x00)
8675 int offset
= ((op
& 0x3f) << 3) + 8;
8676 printf (" sp = sp + %d", offset
);
8678 else if ((op
& 0xc0) == 0x80)
8681 if (op
== 0x80 && op2
== 0)
8682 printf (_("Refuse to unwind"));
8685 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
8687 printf ("pop compact {");
8691 decode_tic6x_unwind_regmask (mask
);
8695 else if ((op
& 0xf0) == 0xc0)
8703 unsigned int offset
;
8707 /* Scan entire instruction first so that GET_OP output is not
8708 interleaved with disassembly. */
8710 for (i
= 0; nregs
< (op
& 0xf); i
++)
8716 regpos
[nregs
].offset
= i
* 2;
8717 regpos
[nregs
].reg
= reg
;
8724 regpos
[nregs
].offset
= i
* 2 + 1;
8725 regpos
[nregs
].reg
= reg
;
8730 printf (_("pop frame {"));
8732 for (i
= i
* 2; i
> 0; i
--)
8734 if (regpos
[reg
].offset
== i
- 1)
8736 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
8743 fputs (name
, stdout
);
8750 else if (op
== 0xd0)
8751 printf (" MOV FP, SP");
8752 else if (op
== 0xd1)
8753 printf (" __c6xabi_pop_rts");
8754 else if (op
== 0xd2)
8756 unsigned char buf
[9];
8757 unsigned int i
, len
;
8758 unsigned long offset
;
8760 for (i
= 0; i
< sizeof (buf
); i
++)
8763 if ((buf
[i
] & 0x80) == 0)
8766 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
8767 if (i
== sizeof (buf
))
8769 warn (_("Corrupt stack pointer adjustment detected\n"));
8773 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8774 assert (len
== i
+ 1);
8775 offset
= offset
* 8 + 0x408;
8776 printf (_("sp = sp + %ld"), offset
);
8778 else if ((op
& 0xf0) == 0xe0)
8780 if ((op
& 0x0f) == 7)
8783 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
8787 printf (_(" [unsupported opcode]"));
8796 arm_expand_prel31 (Filedata
* filedata
, bfd_vma word
, bfd_vma where
)
8800 offset
= word
& 0x7fffffff;
8801 if (offset
& 0x40000000)
8802 offset
|= ~ (bfd_vma
) 0x7fffffff;
8804 if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
8807 return offset
+ where
;
8811 decode_arm_unwind (Filedata
* filedata
,
8812 struct arm_unw_aux_info
* aux
,
8814 unsigned int remaining
,
8815 bfd_vma data_offset
,
8816 Elf_Internal_Shdr
* data_sec
,
8817 struct arm_section
* data_arm_sec
)
8820 unsigned int more_words
= 0;
8821 struct absaddr addr
;
8822 bfd_vma sym_name
= (bfd_vma
) -1;
8823 bfd_boolean res
= TRUE
;
8827 /* Fetch the first word.
8828 Note - when decoding an object file the address extracted
8829 here will always be 0. So we also pass in the sym_name
8830 parameter so that we can find the symbol associated with
8831 the personality routine. */
8832 if (! get_unwind_section_word (filedata
, aux
, data_arm_sec
, data_sec
, data_offset
,
8833 & word
, & addr
, & sym_name
))
8839 if ((word
& 0x80000000) == 0)
8841 /* Expand prel31 for personality routine. */
8843 const char *procname
;
8845 fn
= arm_expand_prel31 (filedata
, word
, data_sec
->sh_addr
+ data_offset
);
8846 printf (_(" Personality routine: "));
8848 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
8849 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
8851 procname
= aux
->strtab
+ sym_name
;
8852 print_vma (fn
, PREFIX_HEX
);
8855 fputs (" <", stdout
);
8856 fputs (procname
, stdout
);
8857 fputc ('>', stdout
);
8861 procname
= arm_print_vma_and_name (filedata
, aux
, fn
, addr
);
8862 fputc ('\n', stdout
);
8864 /* The GCC personality routines use the standard compact
8865 encoding, starting with one byte giving the number of
8867 if (procname
!= NULL
8868 && (const_strneq (procname
, "__gcc_personality_v0")
8869 || const_strneq (procname
, "__gxx_personality_v0")
8870 || const_strneq (procname
, "__gcj_personality_v0")
8871 || const_strneq (procname
, "__gnu_objc_personality_v0")))
8878 printf (_(" [Truncated data]\n"));
8881 more_words
= word
>> 24;
8891 /* ARM EHABI Section 6.3:
8893 An exception-handling table entry for the compact model looks like:
8897 1 0 index Data for personalityRoutine[index] */
8899 if (filedata
->file_header
.e_machine
== EM_ARM
8900 && (word
& 0x70000000))
8902 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
8906 per_index
= (word
>> 24) & 0x7f;
8907 printf (_(" Compact model index: %d\n"), per_index
);
8914 else if (per_index
< 3)
8916 more_words
= (word
>> 16) & 0xff;
8922 switch (filedata
->file_header
.e_machine
)
8927 if (! decode_arm_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
8928 data_offset
, data_sec
, data_arm_sec
))
8933 warn (_("Unknown ARM compact model index encountered\n"));
8934 printf (_(" [reserved]\n"));
8942 if (! decode_tic6x_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
8943 data_offset
, data_sec
, data_arm_sec
))
8946 else if (per_index
< 5)
8948 if (((word
>> 17) & 0x7f) == 0x7f)
8949 printf (_(" Restore stack from frame pointer\n"));
8951 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
8952 printf (_(" Registers restored: "));
8954 printf (" (compact) ");
8955 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
8957 printf (_(" Return register: %s\n"),
8958 tic6x_unwind_regnames
[word
& 0xf]);
8961 printf (_(" [reserved (%d)]\n"), per_index
);
8965 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
8966 filedata
->file_header
.e_machine
);
8970 /* Decode the descriptors. Not implemented. */
8976 dump_arm_unwind (Filedata
* filedata
,
8977 struct arm_unw_aux_info
* aux
,
8978 Elf_Internal_Shdr
* exidx_sec
)
8980 struct arm_section exidx_arm_sec
, extab_arm_sec
;
8981 unsigned int i
, exidx_len
;
8982 unsigned long j
, nfuns
;
8983 bfd_boolean res
= TRUE
;
8985 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
8986 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
8987 exidx_len
= exidx_sec
->sh_size
/ 8;
8989 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
8990 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
8991 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
8992 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
8994 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
8996 for (i
= 0; i
< exidx_len
; i
++)
8998 unsigned int exidx_fn
, exidx_entry
;
8999 struct absaddr fn_addr
, entry_addr
;
9002 fputc ('\n', stdout
);
9004 if (! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9005 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
9006 || ! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9007 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
9010 arm_free_section (& exidx_arm_sec
);
9011 arm_free_section (& extab_arm_sec
);
9015 /* ARM EHABI, Section 5:
9016 An index table entry consists of 2 words.
9017 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
9018 if (exidx_fn
& 0x80000000)
9020 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
9024 fn
= arm_expand_prel31 (filedata
, exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
9026 arm_print_vma_and_name (filedata
, aux
, fn
, fn_addr
);
9027 fputs (": ", stdout
);
9029 if (exidx_entry
== 1)
9031 print_vma (exidx_entry
, PREFIX_HEX
);
9032 fputs (" [cantunwind]\n", stdout
);
9034 else if (exidx_entry
& 0x80000000)
9036 print_vma (exidx_entry
, PREFIX_HEX
);
9037 fputc ('\n', stdout
);
9038 decode_arm_unwind (filedata
, aux
, exidx_entry
, 4, 0, NULL
, NULL
);
9042 bfd_vma table
, table_offset
= 0;
9043 Elf_Internal_Shdr
*table_sec
;
9045 fputs ("@", stdout
);
9046 table
= arm_expand_prel31 (filedata
, exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
9047 print_vma (table
, PREFIX_HEX
);
9050 /* Locate the matching .ARM.extab. */
9051 if (entry_addr
.section
!= SHN_UNDEF
9052 && entry_addr
.section
< filedata
->file_header
.e_shnum
)
9054 table_sec
= filedata
->section_headers
+ entry_addr
.section
;
9055 table_offset
= entry_addr
.offset
;
9057 if (table_offset
> table_sec
->sh_size
9058 || ((bfd_signed_vma
) table_offset
) < 0)
9060 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
9061 (unsigned long) table_offset
,
9062 printable_section_name (filedata
, table_sec
));
9069 table_sec
= find_section_by_address (filedata
, table
);
9070 if (table_sec
!= NULL
)
9071 table_offset
= table
- table_sec
->sh_addr
;
9074 if (table_sec
== NULL
)
9076 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
9077 (unsigned long) table
);
9082 if (! decode_arm_unwind (filedata
, aux
, 0, 0, table_offset
, table_sec
,
9091 arm_free_section (&exidx_arm_sec
);
9092 arm_free_section (&extab_arm_sec
);
9097 /* Used for both ARM and C6X unwinding tables. */
9100 arm_process_unwind (Filedata
* filedata
)
9102 struct arm_unw_aux_info aux
;
9103 Elf_Internal_Shdr
*unwsec
= NULL
;
9104 Elf_Internal_Shdr
*strsec
;
9105 Elf_Internal_Shdr
*sec
;
9107 unsigned int sec_type
;
9108 bfd_boolean res
= TRUE
;
9110 switch (filedata
->file_header
.e_machine
)
9113 sec_type
= SHT_ARM_EXIDX
;
9117 sec_type
= SHT_C6000_UNWIND
;
9121 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9122 filedata
->file_header
.e_machine
);
9126 if (filedata
->string_table
== NULL
)
9129 memset (& aux
, 0, sizeof (aux
));
9130 aux
.filedata
= filedata
;
9132 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9134 if (sec
->sh_type
== SHT_SYMTAB
&& sec
->sh_link
< filedata
->file_header
.e_shnum
)
9136 aux
.symtab
= GET_ELF_SYMBOLS (filedata
, sec
, & aux
.nsyms
);
9138 strsec
= filedata
->section_headers
+ sec
->sh_link
;
9140 /* PR binutils/17531 file: 011-12666-0.004. */
9141 if (aux
.strtab
!= NULL
)
9143 error (_("Multiple string tables found in file.\n"));
9147 aux
.strtab
= get_data (NULL
, filedata
, strsec
->sh_offset
,
9148 1, strsec
->sh_size
, _("string table"));
9149 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
9151 else if (sec
->sh_type
== sec_type
)
9156 printf (_("\nThere are no unwind sections in this file.\n"));
9158 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9160 if (sec
->sh_type
== sec_type
)
9162 unsigned long num_unwind
= sec
->sh_size
/ (2 * eh_addr_size
);
9163 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
9164 "contains %lu entry:\n",
9165 "\nUnwind section '%s' at offset 0x%lx "
9166 "contains %lu entries:\n",
9168 printable_section_name (filedata
, sec
),
9169 (unsigned long) sec
->sh_offset
,
9172 if (! dump_arm_unwind (filedata
, &aux
, sec
))
9180 free ((char *) aux
.strtab
);
9186 process_unwind (Filedata
* filedata
)
9188 struct unwind_handler
9190 unsigned int machtype
;
9191 bfd_boolean (* handler
)(Filedata
*);
9194 { EM_ARM
, arm_process_unwind
},
9195 { EM_IA_64
, ia64_process_unwind
},
9196 { EM_PARISC
, hppa_process_unwind
},
9197 { EM_TI_C6000
, arm_process_unwind
},
9205 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
9206 if (filedata
->file_header
.e_machine
== handlers
[i
].machtype
)
9207 return handlers
[i
].handler (filedata
);
9209 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9210 get_machine_name (filedata
->file_header
.e_machine
));
9215 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
9217 switch (entry
->d_tag
)
9220 if (entry
->d_un
.d_val
== 0)
9224 static const char * opts
[] =
9226 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9227 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9228 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9229 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9233 bfd_boolean first
= TRUE
;
9235 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
9236 if (entry
->d_un
.d_val
& (1 << cnt
))
9238 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
9244 case DT_MIPS_IVERSION
:
9245 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9246 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
9250 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
9251 /* Note: coded this way so that there is a single string for translation. */
9252 printf (_("<corrupt: %s>"), buf
);
9256 case DT_MIPS_TIME_STAMP
:
9260 time_t atime
= entry
->d_un
.d_val
;
9262 tmp
= gmtime (&atime
);
9263 /* PR 17531: file: 6accc532. */
9265 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
9267 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
9268 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9269 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9270 printf (_("Time Stamp: %s"), timebuf
);
9274 case DT_MIPS_RLD_VERSION
:
9275 case DT_MIPS_LOCAL_GOTNO
:
9276 case DT_MIPS_CONFLICTNO
:
9277 case DT_MIPS_LIBLISTNO
:
9278 case DT_MIPS_SYMTABNO
:
9279 case DT_MIPS_UNREFEXTNO
:
9280 case DT_MIPS_HIPAGENO
:
9281 case DT_MIPS_DELTA_CLASS_NO
:
9282 case DT_MIPS_DELTA_INSTANCE_NO
:
9283 case DT_MIPS_DELTA_RELOC_NO
:
9284 case DT_MIPS_DELTA_SYM_NO
:
9285 case DT_MIPS_DELTA_CLASSSYM_NO
:
9286 case DT_MIPS_COMPACT_SIZE
:
9287 print_vma (entry
->d_un
.d_val
, DEC
);
9291 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9297 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
9299 switch (entry
->d_tag
)
9301 case DT_HP_DLD_FLAGS
:
9310 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
9311 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
9312 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
9313 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
9314 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
9315 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
9316 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
9317 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
9318 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
9319 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
9320 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
9321 { DT_HP_GST
, "HP_GST" },
9322 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
9323 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
9324 { DT_HP_NODELETE
, "HP_NODELETE" },
9325 { DT_HP_GROUP
, "HP_GROUP" },
9326 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
9328 bfd_boolean first
= TRUE
;
9330 bfd_vma val
= entry
->d_un
.d_val
;
9332 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
9333 if (val
& flags
[cnt
].bit
)
9337 fputs (flags
[cnt
].str
, stdout
);
9339 val
^= flags
[cnt
].bit
;
9342 if (val
!= 0 || first
)
9346 print_vma (val
, HEX
);
9352 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9360 /* VMS vs Unix time offset and factor. */
9362 #define VMS_EPOCH_OFFSET 35067168000000000LL
9363 #define VMS_GRANULARITY_FACTOR 10000000
9365 /* Display a VMS time in a human readable format. */
9368 print_vms_time (bfd_int64_t vmstime
)
9373 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
9374 tm
= gmtime (&unxtime
);
9375 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9376 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
9377 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
9382 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
9384 switch (entry
->d_tag
)
9386 case DT_IA_64_PLT_RESERVE
:
9387 /* First 3 slots reserved. */
9388 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9390 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
9393 case DT_IA_64_VMS_LINKTIME
:
9395 print_vms_time (entry
->d_un
.d_val
);
9399 case DT_IA_64_VMS_LNKFLAGS
:
9400 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9401 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
9402 printf (" CALL_DEBUG");
9403 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
9404 printf (" NOP0BUFS");
9405 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
9406 printf (" P0IMAGE");
9407 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
9408 printf (" MKTHREADS");
9409 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
9410 printf (" UPCALLS");
9411 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
9413 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
9414 printf (" INITIALIZE");
9415 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
9417 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
9418 printf (" EXE_INIT");
9419 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
9420 printf (" TBK_IN_IMG");
9421 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
9422 printf (" DBG_IN_IMG");
9423 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
9424 printf (" TBK_IN_DSF");
9425 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
9426 printf (" DBG_IN_DSF");
9427 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
9428 printf (" SIGNATURES");
9429 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
9430 printf (" REL_SEG_OFF");
9434 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9441 get_32bit_dynamic_section (Filedata
* filedata
)
9443 Elf32_External_Dyn
* edyn
;
9444 Elf32_External_Dyn
* ext
;
9445 Elf_Internal_Dyn
* entry
;
9447 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, filedata
, dynamic_addr
, 1,
9448 dynamic_size
, _("dynamic section"));
9452 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9453 might not have the luxury of section headers. Look for the DT_NULL
9454 terminator to determine the number of entries. */
9455 for (ext
= edyn
, dynamic_nent
= 0;
9456 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9460 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9464 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9466 if (dynamic_section
== NULL
)
9468 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9469 (unsigned long) dynamic_nent
);
9474 for (ext
= edyn
, entry
= dynamic_section
;
9475 entry
< dynamic_section
+ dynamic_nent
;
9478 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9479 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9488 get_64bit_dynamic_section (Filedata
* filedata
)
9490 Elf64_External_Dyn
* edyn
;
9491 Elf64_External_Dyn
* ext
;
9492 Elf_Internal_Dyn
* entry
;
9494 /* Read in the data. */
9495 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, filedata
, dynamic_addr
, 1,
9496 dynamic_size
, _("dynamic section"));
9500 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9501 might not have the luxury of section headers. Look for the DT_NULL
9502 terminator to determine the number of entries. */
9503 for (ext
= edyn
, dynamic_nent
= 0;
9504 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
9505 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9509 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9513 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9515 if (dynamic_section
== NULL
)
9517 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9518 (unsigned long) dynamic_nent
);
9523 /* Convert from external to internal formats. */
9524 for (ext
= edyn
, entry
= dynamic_section
;
9525 entry
< dynamic_section
+ dynamic_nent
;
9528 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9529 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9538 print_dynamic_flags (bfd_vma flags
)
9540 bfd_boolean first
= TRUE
;
9546 flag
= flags
& - flags
;
9556 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
9557 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
9558 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
9559 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
9560 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
9561 default: fputs (_("unknown"), stdout
); break;
9567 /* Parse and display the contents of the dynamic section. */
9570 process_dynamic_section (Filedata
* filedata
)
9572 Elf_Internal_Dyn
* entry
;
9574 if (dynamic_size
== 0)
9577 printf (_("\nThere is no dynamic section in this file.\n"));
9584 if (! get_32bit_dynamic_section (filedata
))
9589 if (! get_64bit_dynamic_section (filedata
))
9593 /* Find the appropriate symbol table. */
9594 if (dynamic_symbols
== NULL
)
9596 for (entry
= dynamic_section
;
9597 entry
< dynamic_section
+ dynamic_nent
;
9600 Elf_Internal_Shdr section
;
9602 if (entry
->d_tag
!= DT_SYMTAB
)
9605 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
9607 /* Since we do not know how big the symbol table is,
9608 we default to reading in the entire file (!) and
9609 processing that. This is overkill, I know, but it
9611 section
.sh_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
9612 if ((bfd_size_type
) section
.sh_offset
> filedata
->file_size
)
9614 /* See PR 21379 for a reproducer. */
9615 error (_("Invalid DT_SYMTAB entry: %lx"), (long) section
.sh_offset
);
9619 if (archive_file_offset
!= 0)
9620 section
.sh_size
= archive_file_size
- section
.sh_offset
;
9622 section
.sh_size
= filedata
->file_size
- section
.sh_offset
;
9625 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
9627 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
9628 section
.sh_name
= filedata
->string_table_length
;
9630 dynamic_symbols
= GET_ELF_SYMBOLS (filedata
, §ion
, & num_dynamic_syms
);
9631 if (num_dynamic_syms
< 1)
9633 error (_("Unable to determine the number of symbols to load\n"));
9639 /* Similarly find a string table. */
9640 if (dynamic_strings
== NULL
)
9642 for (entry
= dynamic_section
;
9643 entry
< dynamic_section
+ dynamic_nent
;
9646 unsigned long offset
;
9649 if (entry
->d_tag
!= DT_STRTAB
)
9652 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
9654 /* Since we do not know how big the string table is,
9655 we default to reading in the entire file (!) and
9656 processing that. This is overkill, I know, but it
9659 offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
9661 if (archive_file_offset
!= 0)
9662 str_tab_len
= archive_file_size
- offset
;
9664 str_tab_len
= filedata
->file_size
- offset
;
9666 if (str_tab_len
< 1)
9669 (_("Unable to determine the length of the dynamic string table\n"));
9673 dynamic_strings
= (char *) get_data (NULL
, filedata
, offset
, 1,
9675 _("dynamic string table"));
9676 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : str_tab_len
;
9681 /* And find the syminfo section if available. */
9682 if (dynamic_syminfo
== NULL
)
9684 unsigned long syminsz
= 0;
9686 for (entry
= dynamic_section
;
9687 entry
< dynamic_section
+ dynamic_nent
;
9690 if (entry
->d_tag
== DT_SYMINENT
)
9692 /* Note: these braces are necessary to avoid a syntax
9693 error from the SunOS4 C compiler. */
9694 /* PR binutils/17531: A corrupt file can trigger this test.
9695 So do not use an assert, instead generate an error message. */
9696 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
9697 error (_("Bad value (%d) for SYMINENT entry\n"),
9698 (int) entry
->d_un
.d_val
);
9700 else if (entry
->d_tag
== DT_SYMINSZ
)
9701 syminsz
= entry
->d_un
.d_val
;
9702 else if (entry
->d_tag
== DT_SYMINFO
)
9703 dynamic_syminfo_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
,
9707 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
9709 Elf_External_Syminfo
* extsyminfo
;
9710 Elf_External_Syminfo
* extsym
;
9711 Elf_Internal_Syminfo
* syminfo
;
9713 /* There is a syminfo section. Read the data. */
9714 extsyminfo
= (Elf_External_Syminfo
*)
9715 get_data (NULL
, filedata
, dynamic_syminfo_offset
, 1, syminsz
,
9716 _("symbol information"));
9720 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
9721 if (dynamic_syminfo
== NULL
)
9723 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9724 (unsigned long) syminsz
);
9728 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
9729 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
9730 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
9731 ++syminfo
, ++extsym
)
9733 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
9734 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
9741 if (do_dynamic
&& dynamic_addr
)
9742 printf (ngettext ("\nDynamic section at offset 0x%lx "
9743 "contains %lu entry:\n",
9744 "\nDynamic section at offset 0x%lx "
9745 "contains %lu entries:\n",
9747 dynamic_addr
, (unsigned long) dynamic_nent
);
9749 printf (_(" Tag Type Name/Value\n"));
9751 for (entry
= dynamic_section
;
9752 entry
< dynamic_section
+ dynamic_nent
;
9760 print_vma (entry
->d_tag
, FULL_HEX
);
9761 dtype
= get_dynamic_type (filedata
, entry
->d_tag
);
9762 printf (" (%s)%*s", dtype
,
9763 ((is_32bit_elf
? 27 : 19) - (int) strlen (dtype
)), " ");
9766 switch (entry
->d_tag
)
9770 print_dynamic_flags (entry
->d_un
.d_val
);
9780 switch (entry
->d_tag
)
9783 printf (_("Auxiliary library"));
9787 printf (_("Filter library"));
9791 printf (_("Configuration file"));
9795 printf (_("Dependency audit library"));
9799 printf (_("Audit library"));
9803 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9804 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
9808 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9817 printf (_("Flags:"));
9819 if (entry
->d_un
.d_val
== 0)
9820 printf (_(" None\n"));
9823 unsigned long int val
= entry
->d_un
.d_val
;
9825 if (val
& DTF_1_PARINIT
)
9827 printf (" PARINIT");
9828 val
^= DTF_1_PARINIT
;
9830 if (val
& DTF_1_CONFEXP
)
9832 printf (" CONFEXP");
9833 val
^= DTF_1_CONFEXP
;
9836 printf (" %lx", val
);
9845 printf (_("Flags:"));
9847 if (entry
->d_un
.d_val
== 0)
9848 printf (_(" None\n"));
9851 unsigned long int val
= entry
->d_un
.d_val
;
9853 if (val
& DF_P1_LAZYLOAD
)
9855 printf (" LAZYLOAD");
9856 val
^= DF_P1_LAZYLOAD
;
9858 if (val
& DF_P1_GROUPPERM
)
9860 printf (" GROUPPERM");
9861 val
^= DF_P1_GROUPPERM
;
9864 printf (" %lx", val
);
9873 printf (_("Flags:"));
9874 if (entry
->d_un
.d_val
== 0)
9875 printf (_(" None\n"));
9878 unsigned long int val
= entry
->d_un
.d_val
;
9885 if (val
& DF_1_GLOBAL
)
9890 if (val
& DF_1_GROUP
)
9895 if (val
& DF_1_NODELETE
)
9897 printf (" NODELETE");
9898 val
^= DF_1_NODELETE
;
9900 if (val
& DF_1_LOADFLTR
)
9902 printf (" LOADFLTR");
9903 val
^= DF_1_LOADFLTR
;
9905 if (val
& DF_1_INITFIRST
)
9907 printf (" INITFIRST");
9908 val
^= DF_1_INITFIRST
;
9910 if (val
& DF_1_NOOPEN
)
9915 if (val
& DF_1_ORIGIN
)
9920 if (val
& DF_1_DIRECT
)
9925 if (val
& DF_1_TRANS
)
9930 if (val
& DF_1_INTERPOSE
)
9932 printf (" INTERPOSE");
9933 val
^= DF_1_INTERPOSE
;
9935 if (val
& DF_1_NODEFLIB
)
9937 printf (" NODEFLIB");
9938 val
^= DF_1_NODEFLIB
;
9940 if (val
& DF_1_NODUMP
)
9945 if (val
& DF_1_CONFALT
)
9947 printf (" CONFALT");
9948 val
^= DF_1_CONFALT
;
9950 if (val
& DF_1_ENDFILTEE
)
9952 printf (" ENDFILTEE");
9953 val
^= DF_1_ENDFILTEE
;
9955 if (val
& DF_1_DISPRELDNE
)
9957 printf (" DISPRELDNE");
9958 val
^= DF_1_DISPRELDNE
;
9960 if (val
& DF_1_DISPRELPND
)
9962 printf (" DISPRELPND");
9963 val
^= DF_1_DISPRELPND
;
9965 if (val
& DF_1_NODIRECT
)
9967 printf (" NODIRECT");
9968 val
^= DF_1_NODIRECT
;
9970 if (val
& DF_1_IGNMULDEF
)
9972 printf (" IGNMULDEF");
9973 val
^= DF_1_IGNMULDEF
;
9975 if (val
& DF_1_NOKSYMS
)
9977 printf (" NOKSYMS");
9978 val
^= DF_1_NOKSYMS
;
9980 if (val
& DF_1_NOHDR
)
9985 if (val
& DF_1_EDITED
)
9990 if (val
& DF_1_NORELOC
)
9992 printf (" NORELOC");
9993 val
^= DF_1_NORELOC
;
9995 if (val
& DF_1_SYMINTPOSE
)
9997 printf (" SYMINTPOSE");
9998 val
^= DF_1_SYMINTPOSE
;
10000 if (val
& DF_1_GLOBAUDIT
)
10002 printf (" GLOBAUDIT");
10003 val
^= DF_1_GLOBAUDIT
;
10005 if (val
& DF_1_SINGLETON
)
10007 printf (" SINGLETON");
10008 val
^= DF_1_SINGLETON
;
10010 if (val
& DF_1_STUB
)
10015 if (val
& DF_1_PIE
)
10020 if (val
& DF_1_KMOD
)
10025 if (val
& DF_1_WEAKFILTER
)
10027 printf (" WEAKFILTER");
10028 val
^= DF_1_WEAKFILTER
;
10030 if (val
& DF_1_NOCOMMON
)
10032 printf (" NOCOMMON");
10033 val
^= DF_1_NOCOMMON
;
10036 printf (" %lx", val
);
10043 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10045 puts (get_dynamic_type (filedata
, entry
->d_un
.d_val
));
10065 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10071 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
10072 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
10078 switch (entry
->d_tag
)
10081 printf (_("Shared library: [%s]"), name
);
10083 if (streq (name
, program_interpreter
))
10084 printf (_(" program interpreter"));
10088 printf (_("Library soname: [%s]"), name
);
10092 printf (_("Library rpath: [%s]"), name
);
10096 printf (_("Library runpath: [%s]"), name
);
10100 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10105 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10118 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10119 /* Fall through. */
10123 case DT_INIT_ARRAYSZ
:
10124 case DT_FINI_ARRAYSZ
:
10125 case DT_GNU_CONFLICTSZ
:
10126 case DT_GNU_LIBLISTSZ
:
10129 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10130 printf (_(" (bytes)\n"));
10135 case DT_VERNEEDNUM
:
10140 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10149 case DT_INIT_ARRAY
:
10150 case DT_FINI_ARRAY
:
10153 if (entry
->d_tag
== DT_USED
10154 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
10156 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
10160 printf (_("Not needed object: [%s]\n"), name
);
10165 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10171 /* The value of this entry is ignored. */
10176 case DT_GNU_PRELINKED
:
10180 time_t atime
= entry
->d_un
.d_val
;
10182 tmp
= gmtime (&atime
);
10183 /* PR 17533 file: 041-1244816-0.004. */
10185 printf (_("<corrupt time val: %lx"),
10186 (unsigned long) atime
);
10188 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10189 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
10190 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
10196 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10199 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10205 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
10206 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
10211 switch (filedata
->file_header
.e_machine
)
10214 case EM_MIPS_RS3_LE
:
10215 dynamic_section_mips_val (entry
);
10218 dynamic_section_parisc_val (entry
);
10221 dynamic_section_ia64_val (entry
);
10224 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10236 get_ver_flags (unsigned int flags
)
10238 static char buff
[128];
10245 if (flags
& VER_FLG_BASE
)
10246 strcat (buff
, "BASE");
10248 if (flags
& VER_FLG_WEAK
)
10250 if (flags
& VER_FLG_BASE
)
10251 strcat (buff
, " | ");
10253 strcat (buff
, "WEAK");
10256 if (flags
& VER_FLG_INFO
)
10258 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
10259 strcat (buff
, " | ");
10261 strcat (buff
, "INFO");
10264 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10266 if (flags
& (VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10267 strcat (buff
, " | ");
10269 strcat (buff
, _("<unknown>"));
10275 /* Display the contents of the version sections. */
10278 process_version_sections (Filedata
* filedata
)
10280 Elf_Internal_Shdr
* section
;
10282 bfd_boolean found
= FALSE
;
10287 for (i
= 0, section
= filedata
->section_headers
;
10288 i
< filedata
->file_header
.e_shnum
;
10291 switch (section
->sh_type
)
10293 case SHT_GNU_verdef
:
10295 Elf_External_Verdef
* edefs
;
10302 printf (ngettext ("\nVersion definition section '%s' "
10303 "contains %u entry:\n",
10304 "\nVersion definition section '%s' "
10305 "contains %u entries:\n",
10307 printable_section_name (filedata
, section
),
10310 printf (_(" Addr: 0x"));
10311 printf_vma (section
->sh_addr
);
10312 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10313 (unsigned long) section
->sh_offset
, section
->sh_link
,
10314 printable_section_name_from_index (filedata
, section
->sh_link
));
10316 edefs
= (Elf_External_Verdef
*)
10317 get_data (NULL
, filedata
, section
->sh_offset
, 1,section
->sh_size
,
10318 _("version definition section"));
10321 endbuf
= (char *) edefs
+ section
->sh_size
;
10323 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
10326 Elf_External_Verdef
* edef
;
10327 Elf_Internal_Verdef ent
;
10328 Elf_External_Verdaux
* eaux
;
10329 Elf_Internal_Verdaux aux
;
10330 unsigned long isum
;
10333 vstart
= ((char *) edefs
) + idx
;
10334 if (vstart
+ sizeof (*edef
) > endbuf
)
10337 edef
= (Elf_External_Verdef
*) vstart
;
10339 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
10340 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
10341 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
10342 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
10343 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
10344 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
10345 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
10347 printf (_(" %#06lx: Rev: %d Flags: %s"),
10348 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
10350 printf (_(" Index: %d Cnt: %d "),
10351 ent
.vd_ndx
, ent
.vd_cnt
);
10353 /* Check for overflow. */
10354 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
10357 vstart
+= ent
.vd_aux
;
10359 if (vstart
+ sizeof (*eaux
) > endbuf
)
10361 eaux
= (Elf_External_Verdaux
*) vstart
;
10363 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10364 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10366 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10367 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
10369 printf (_("Name index: %ld\n"), aux
.vda_name
);
10371 isum
= idx
+ ent
.vd_aux
;
10373 for (j
= 1; j
< ent
.vd_cnt
; j
++)
10375 if (aux
.vda_next
< sizeof (*eaux
)
10376 && !(j
== ent
.vd_cnt
- 1 && aux
.vda_next
== 0))
10378 warn (_("Invalid vda_next field of %lx\n"),
10383 /* Check for overflow. */
10384 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
10387 isum
+= aux
.vda_next
;
10388 vstart
+= aux
.vda_next
;
10390 if (vstart
+ sizeof (*eaux
) > endbuf
)
10392 eaux
= (Elf_External_Verdaux
*) vstart
;
10394 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10395 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10397 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10398 printf (_(" %#06lx: Parent %d: %s\n"),
10399 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
10401 printf (_(" %#06lx: Parent %d, name index: %ld\n"),
10402 isum
, j
, aux
.vda_name
);
10405 if (j
< ent
.vd_cnt
)
10406 printf (_(" Version def aux past end of section\n"));
10409 file: id:000001,src:000172+005151,op:splice,rep:2. */
10410 if (ent
.vd_next
< sizeof (*edef
)
10411 && !(cnt
== section
->sh_info
- 1 && ent
.vd_next
== 0))
10413 warn (_("Invalid vd_next field of %lx\n"), ent
.vd_next
);
10414 cnt
= section
->sh_info
;
10417 if (ent
.vd_next
> (size_t) (endbuf
- ((char *) edefs
+ idx
)))
10420 idx
+= ent
.vd_next
;
10423 if (cnt
< section
->sh_info
)
10424 printf (_(" Version definition past end of section\n"));
10430 case SHT_GNU_verneed
:
10432 Elf_External_Verneed
* eneed
;
10439 printf (ngettext ("\nVersion needs section '%s' "
10440 "contains %u entry:\n",
10441 "\nVersion needs section '%s' "
10442 "contains %u entries:\n",
10444 printable_section_name (filedata
, section
), section
->sh_info
);
10446 printf (_(" Addr: 0x"));
10447 printf_vma (section
->sh_addr
);
10448 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10449 (unsigned long) section
->sh_offset
, section
->sh_link
,
10450 printable_section_name_from_index (filedata
, section
->sh_link
));
10452 eneed
= (Elf_External_Verneed
*) get_data (NULL
, filedata
,
10453 section
->sh_offset
, 1,
10455 _("Version Needs section"));
10458 endbuf
= (char *) eneed
+ section
->sh_size
;
10460 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
10462 Elf_External_Verneed
* entry
;
10463 Elf_Internal_Verneed ent
;
10464 unsigned long isum
;
10468 vstart
= ((char *) eneed
) + idx
;
10469 if (vstart
+ sizeof (*entry
) > endbuf
)
10472 entry
= (Elf_External_Verneed
*) vstart
;
10474 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
10475 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
10476 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
10477 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
10478 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
10480 printf (_(" %#06lx: Version: %d"), idx
, ent
.vn_version
);
10482 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
10483 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
10485 printf (_(" File: %lx"), ent
.vn_file
);
10487 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
10489 /* Check for overflow. */
10490 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
10492 vstart
+= ent
.vn_aux
;
10494 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
10496 Elf_External_Vernaux
* eaux
;
10497 Elf_Internal_Vernaux aux
;
10499 if (vstart
+ sizeof (*eaux
) > endbuf
)
10501 eaux
= (Elf_External_Vernaux
*) vstart
;
10503 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
10504 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
10505 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
10506 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
10507 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
10509 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
10510 printf (_(" %#06lx: Name: %s"),
10511 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
10513 printf (_(" %#06lx: Name index: %lx"),
10514 isum
, aux
.vna_name
);
10516 printf (_(" Flags: %s Version: %d\n"),
10517 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
10519 if (aux
.vna_next
< sizeof (*eaux
)
10520 && !(j
== ent
.vn_cnt
- 1 && aux
.vna_next
== 0))
10522 warn (_("Invalid vna_next field of %lx\n"),
10527 /* Check for overflow. */
10528 if (aux
.vna_next
> (size_t) (endbuf
- vstart
))
10530 isum
+= aux
.vna_next
;
10531 vstart
+= aux
.vna_next
;
10534 if (j
< ent
.vn_cnt
)
10535 warn (_("Missing Version Needs auxillary information\n"));
10537 if (ent
.vn_next
< sizeof (*entry
)
10538 && !(cnt
== section
->sh_info
- 1 && ent
.vn_next
== 0))
10540 warn (_("Invalid vn_next field of %lx\n"), ent
.vn_next
);
10541 cnt
= section
->sh_info
;
10544 if (ent
.vn_next
> (size_t) (endbuf
- ((char *) eneed
+ idx
)))
10546 idx
+= ent
.vn_next
;
10549 if (cnt
< section
->sh_info
)
10550 warn (_("Missing Version Needs information\n"));
10556 case SHT_GNU_versym
:
10558 Elf_Internal_Shdr
* link_section
;
10561 unsigned char * edata
;
10562 unsigned short * data
;
10564 Elf_Internal_Sym
* symbols
;
10565 Elf_Internal_Shdr
* string_sec
;
10566 unsigned long num_syms
;
10569 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
10572 link_section
= filedata
->section_headers
+ section
->sh_link
;
10573 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
10575 if (link_section
->sh_link
>= filedata
->file_header
.e_shnum
)
10580 symbols
= GET_ELF_SYMBOLS (filedata
, link_section
, & num_syms
);
10581 if (symbols
== NULL
)
10584 string_sec
= filedata
->section_headers
+ link_section
->sh_link
;
10586 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
10587 string_sec
->sh_size
,
10588 _("version string table"));
10595 printf (ngettext ("\nVersion symbols section '%s' "
10596 "contains %lu entry:\n",
10597 "\nVersion symbols section '%s' "
10598 "contains %lu entries:\n",
10600 printable_section_name (filedata
, section
), (unsigned long) total
);
10602 printf (_(" Addr: "));
10603 printf_vma (section
->sh_addr
);
10604 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10605 (unsigned long) section
->sh_offset
, section
->sh_link
,
10606 printable_section_name (filedata
, link_section
));
10608 off
= offset_from_vma (filedata
,
10609 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
10610 total
* sizeof (short));
10611 edata
= (unsigned char *) get_data (NULL
, filedata
, off
, total
,
10613 _("version symbol data"));
10621 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
10623 for (cnt
= total
; cnt
--;)
10624 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
10629 for (cnt
= 0; cnt
< total
; cnt
+= 4)
10633 char *invalid
= _("*invalid*");
10635 printf (" %03x:", cnt
);
10637 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
10638 switch (data
[cnt
+ j
])
10641 fputs (_(" 0 (*local*) "), stdout
);
10645 fputs (_(" 1 (*global*) "), stdout
);
10649 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
10650 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
10652 /* If this index value is greater than the size of the symbols
10653 array, break to avoid an out-of-bounds read. */
10654 if ((unsigned long)(cnt
+ j
) >= num_syms
)
10656 warn (_("invalid index into symbol array\n"));
10661 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
10663 Elf_Internal_Verneed ivn
;
10664 unsigned long offset
;
10666 offset
= offset_from_vma
10667 (filedata
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
10668 sizeof (Elf_External_Verneed
));
10672 Elf_Internal_Vernaux ivna
;
10673 Elf_External_Verneed evn
;
10674 Elf_External_Vernaux evna
;
10675 unsigned long a_off
;
10677 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
10678 _("version need")) == NULL
)
10681 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
10682 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
10684 a_off
= offset
+ ivn
.vn_aux
;
10688 if (get_data (&evna
, filedata
, a_off
, sizeof (evna
),
10689 1, _("version need aux (2)")) == NULL
)
10692 ivna
.vna_other
= 0;
10696 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
10697 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
10700 a_off
+= ivna
.vna_next
;
10702 while (ivna
.vna_other
!= data
[cnt
+ j
]
10703 && ivna
.vna_next
!= 0);
10705 if (ivna
.vna_other
== data
[cnt
+ j
])
10707 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
10709 if (ivna
.vna_name
>= string_sec
->sh_size
)
10712 name
= strtab
+ ivna
.vna_name
;
10716 offset
+= ivn
.vn_next
;
10718 while (ivn
.vn_next
);
10721 if (data
[cnt
+ j
] != 0x8001
10722 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
10724 Elf_Internal_Verdef ivd
;
10725 Elf_External_Verdef evd
;
10726 unsigned long offset
;
10728 offset
= offset_from_vma
10729 (filedata
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
10734 if (get_data (&evd
, filedata
, offset
, sizeof (evd
), 1,
10735 _("version def")) == NULL
)
10738 /* PR 17531: file: 046-1082287-0.004. */
10739 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
10744 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
10745 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
10748 offset
+= ivd
.vd_next
;
10750 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
10751 && ivd
.vd_next
!= 0);
10753 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
10755 Elf_External_Verdaux evda
;
10756 Elf_Internal_Verdaux ivda
;
10758 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
10760 if (get_data (&evda
, filedata
,
10761 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
10763 _("version def aux")) == NULL
)
10766 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
10768 if (ivda
.vda_name
>= string_sec
->sh_size
)
10770 else if (name
!= NULL
&& name
!= invalid
)
10771 name
= _("*both*");
10773 name
= strtab
+ ivda
.vda_name
;
10777 nn
+= printf ("(%s%-*s",
10779 12 - (int) strlen (name
),
10783 printf ("%*c", 18 - nn
, ' ');
10801 printf (_("\nNo version information found in this file.\n"));
10806 static const char *
10807 get_symbol_binding (Filedata
* filedata
, unsigned int binding
)
10809 static char buff
[32];
10813 case STB_LOCAL
: return "LOCAL";
10814 case STB_GLOBAL
: return "GLOBAL";
10815 case STB_WEAK
: return "WEAK";
10817 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
10818 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
10820 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
10822 if (binding
== STB_GNU_UNIQUE
10823 && (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10824 /* GNU is still using the default value 0. */
10825 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10827 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
10830 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
10835 static const char *
10836 get_symbol_type (Filedata
* filedata
, unsigned int type
)
10838 static char buff
[32];
10842 case STT_NOTYPE
: return "NOTYPE";
10843 case STT_OBJECT
: return "OBJECT";
10844 case STT_FUNC
: return "FUNC";
10845 case STT_SECTION
: return "SECTION";
10846 case STT_FILE
: return "FILE";
10847 case STT_COMMON
: return "COMMON";
10848 case STT_TLS
: return "TLS";
10849 case STT_RELC
: return "RELC";
10850 case STT_SRELC
: return "SRELC";
10852 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
10854 if (filedata
->file_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
10855 return "THUMB_FUNC";
10857 if (filedata
->file_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
10860 if (filedata
->file_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
10861 return "PARISC_MILLI";
10863 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
10865 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
10867 if (filedata
->file_header
.e_machine
== EM_PARISC
)
10869 if (type
== STT_HP_OPAQUE
)
10870 return "HP_OPAQUE";
10871 if (type
== STT_HP_STUB
)
10875 if (type
== STT_GNU_IFUNC
10876 && (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10877 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
10878 /* GNU is still using the default value 0. */
10879 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10882 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
10885 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
10890 static const char *
10891 get_symbol_visibility (unsigned int visibility
)
10893 switch (visibility
)
10895 case STV_DEFAULT
: return "DEFAULT";
10896 case STV_INTERNAL
: return "INTERNAL";
10897 case STV_HIDDEN
: return "HIDDEN";
10898 case STV_PROTECTED
: return "PROTECTED";
10900 error (_("Unrecognized visibility value: %u"), visibility
);
10901 return _("<unknown>");
10905 static const char *
10906 get_solaris_symbol_visibility (unsigned int visibility
)
10908 switch (visibility
)
10910 case 4: return "EXPORTED";
10911 case 5: return "SINGLETON";
10912 case 6: return "ELIMINATE";
10913 default: return get_symbol_visibility (visibility
);
10917 static const char *
10918 get_mips_symbol_other (unsigned int other
)
10922 case STO_OPTIONAL
: return "OPTIONAL";
10923 case STO_MIPS_PLT
: return "MIPS PLT";
10924 case STO_MIPS_PIC
: return "MIPS PIC";
10925 case STO_MICROMIPS
: return "MICROMIPS";
10926 case STO_MICROMIPS
| STO_MIPS_PIC
: return "MICROMIPS, MIPS PIC";
10927 case STO_MIPS16
: return "MIPS16";
10928 default: return NULL
;
10932 static const char *
10933 get_ia64_symbol_other (Filedata
* filedata
, unsigned int other
)
10935 if (is_ia64_vms (filedata
))
10937 static char res
[32];
10941 /* Function types is for images and .STB files only. */
10942 switch (filedata
->file_header
.e_type
)
10946 switch (VMS_ST_FUNC_TYPE (other
))
10948 case VMS_SFT_CODE_ADDR
:
10949 strcat (res
, " CA");
10951 case VMS_SFT_SYMV_IDX
:
10952 strcat (res
, " VEC");
10955 strcat (res
, " FD");
10957 case VMS_SFT_RESERVE
:
10958 strcat (res
, " RSV");
10961 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10962 VMS_ST_FUNC_TYPE (other
));
10963 strcat (res
, " <unknown>");
10970 switch (VMS_ST_LINKAGE (other
))
10972 case VMS_STL_IGNORE
:
10973 strcat (res
, " IGN");
10975 case VMS_STL_RESERVE
:
10976 strcat (res
, " RSV");
10979 strcat (res
, " STD");
10982 strcat (res
, " LNK");
10985 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10986 VMS_ST_LINKAGE (other
));
10987 strcat (res
, " <unknown>");
10999 static const char *
11000 get_ppc64_symbol_other (unsigned int other
)
11002 if (PPC64_LOCAL_ENTRY_OFFSET (other
) != 0)
11004 static char buf
[32];
11005 snprintf (buf
, sizeof buf
, _("<localentry>: %d"),
11006 PPC64_LOCAL_ENTRY_OFFSET (other
));
11012 static const char *
11013 get_symbol_other (Filedata
* filedata
, unsigned int other
)
11015 const char * result
= NULL
;
11016 static char buff
[32];
11021 switch (filedata
->file_header
.e_machine
)
11024 result
= get_mips_symbol_other (other
);
11027 result
= get_ia64_symbol_other (filedata
, other
);
11030 result
= get_ppc64_symbol_other (other
);
11040 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
11044 static const char *
11045 get_symbol_index_type (Filedata
* filedata
, unsigned int type
)
11047 static char buff
[32];
11051 case SHN_UNDEF
: return "UND";
11052 case SHN_ABS
: return "ABS";
11053 case SHN_COMMON
: return "COM";
11055 if (type
== SHN_IA_64_ANSI_COMMON
11056 && filedata
->file_header
.e_machine
== EM_IA_64
11057 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
11059 else if ((filedata
->file_header
.e_machine
== EM_X86_64
11060 || filedata
->file_header
.e_machine
== EM_L1OM
11061 || filedata
->file_header
.e_machine
== EM_K1OM
)
11062 && type
== SHN_X86_64_LCOMMON
)
11063 return "LARGE_COM";
11064 else if ((type
== SHN_MIPS_SCOMMON
11065 && filedata
->file_header
.e_machine
== EM_MIPS
)
11066 || (type
== SHN_TIC6X_SCOMMON
11067 && filedata
->file_header
.e_machine
== EM_TI_C6000
))
11069 else if (type
== SHN_MIPS_SUNDEFINED
11070 && filedata
->file_header
.e_machine
== EM_MIPS
)
11072 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
11073 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
11074 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
11075 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
11076 else if (type
>= SHN_LORESERVE
)
11077 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
11078 else if (type
>= filedata
->file_header
.e_shnum
)
11079 sprintf (buff
, _("bad section index[%3d]"), type
);
11081 sprintf (buff
, "%3d", type
);
11089 get_dynamic_data (Filedata
* filedata
, bfd_size_type number
, unsigned int ent_size
)
11091 unsigned char * e_data
;
11094 /* If the size_t type is smaller than the bfd_size_type, eg because
11095 you are building a 32-bit tool on a 64-bit host, then make sure
11096 that when (number) is cast to (size_t) no information is lost. */
11097 if (sizeof (size_t) < sizeof (bfd_size_type
)
11098 && (bfd_size_type
) ((size_t) number
) != number
)
11100 error (_("Size truncation prevents reading %s elements of size %u\n"),
11101 bfd_vmatoa ("u", number
), ent_size
);
11105 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
11106 attempting to allocate memory when the read is bound to fail. */
11107 if (ent_size
* number
> filedata
->file_size
)
11109 error (_("Invalid number of dynamic entries: %s\n"),
11110 bfd_vmatoa ("u", number
));
11114 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
11115 if (e_data
== NULL
)
11117 error (_("Out of memory reading %s dynamic entries\n"),
11118 bfd_vmatoa ("u", number
));
11122 if (fread (e_data
, ent_size
, (size_t) number
, filedata
->handle
) != number
)
11124 error (_("Unable to read in %s bytes of dynamic data\n"),
11125 bfd_vmatoa ("u", number
* ent_size
));
11130 i_data
= (bfd_vma
*) cmalloc ((size_t) number
, sizeof (*i_data
));
11131 if (i_data
== NULL
)
11133 error (_("Out of memory allocating space for %s dynamic entries\n"),
11134 bfd_vmatoa ("u", number
));
11140 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
11148 print_dynamic_symbol (Filedata
* filedata
, bfd_vma si
, unsigned long hn
)
11150 Elf_Internal_Sym
* psym
;
11153 n
= print_vma (si
, DEC_5
);
11155 fputs (&" "[n
], stdout
);
11156 printf (" %3lu: ", hn
);
11158 if (dynamic_symbols
== NULL
|| si
>= num_dynamic_syms
)
11160 printf (_("<No info available for dynamic symbol number %lu>\n"),
11161 (unsigned long) si
);
11165 psym
= dynamic_symbols
+ si
;
11166 print_vma (psym
->st_value
, LONG_HEX
);
11168 print_vma (psym
->st_size
, DEC_5
);
11170 printf (" %-7s", get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)));
11171 printf (" %-6s", get_symbol_binding (filedata
, ELF_ST_BIND (psym
->st_info
)));
11173 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
11174 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
11177 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
11179 printf (" %-7s", get_symbol_visibility (vis
));
11180 /* Check to see if any other bits in the st_other field are set.
11181 Note - displaying this information disrupts the layout of the
11182 table being generated, but for the moment this case is very
11184 if (psym
->st_other
^ vis
)
11185 printf (" [%s] ", get_symbol_other (filedata
, psym
->st_other
^ vis
));
11188 printf (" %3.3s ", get_symbol_index_type (filedata
, psym
->st_shndx
));
11189 if (VALID_DYNAMIC_NAME (psym
->st_name
))
11190 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
11192 printf (_(" <corrupt: %14ld>"), psym
->st_name
);
11196 static const char *
11197 get_symbol_version_string (Filedata
* filedata
,
11198 bfd_boolean is_dynsym
,
11199 const char * strtab
,
11200 unsigned long int strtab_size
,
11202 Elf_Internal_Sym
* psym
,
11203 enum versioned_symbol_info
* sym_info
,
11204 unsigned short * vna_other
)
11206 unsigned char data
[2];
11207 unsigned short vers_data
;
11208 unsigned long offset
;
11211 || version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
11214 offset
= offset_from_vma (filedata
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
11215 sizeof data
+ si
* sizeof (vers_data
));
11217 if (get_data (&data
, filedata
, offset
+ si
* sizeof (vers_data
),
11218 sizeof (data
), 1, _("version data")) == NULL
)
11221 vers_data
= byte_get (data
, 2);
11223 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
<= 1)
11226 /* Usually we'd only see verdef for defined symbols, and verneed for
11227 undefined symbols. However, symbols defined by the linker in
11228 .dynbss for variables copied from a shared library in order to
11229 avoid text relocations are defined yet have verneed. We could
11230 use a heuristic to detect the special case, for example, check
11231 for verneed first on symbols defined in SHT_NOBITS sections, but
11232 it is simpler and more reliable to just look for both verdef and
11233 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
11235 if (psym
->st_shndx
!= SHN_UNDEF
11236 && vers_data
!= 0x8001
11237 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
11239 Elf_Internal_Verdef ivd
;
11240 Elf_Internal_Verdaux ivda
;
11241 Elf_External_Verdaux evda
;
11244 off
= offset_from_vma (filedata
,
11245 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
11246 sizeof (Elf_External_Verdef
));
11250 Elf_External_Verdef evd
;
11252 if (get_data (&evd
, filedata
, off
, sizeof (evd
), 1,
11253 _("version def")) == NULL
)
11261 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
11262 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
11263 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
11266 off
+= ivd
.vd_next
;
11268 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
11270 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
11272 off
-= ivd
.vd_next
;
11275 if (get_data (&evda
, filedata
, off
, sizeof (evda
), 1,
11276 _("version def aux")) != NULL
)
11278 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
11280 if (psym
->st_name
!= ivda
.vda_name
)
11282 *sym_info
= ((vers_data
& VERSYM_HIDDEN
) != 0
11283 ? symbol_hidden
: symbol_public
);
11284 return (ivda
.vda_name
< strtab_size
11285 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
11291 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
11293 Elf_External_Verneed evn
;
11294 Elf_Internal_Verneed ivn
;
11295 Elf_Internal_Vernaux ivna
;
11297 offset
= offset_from_vma (filedata
,
11298 version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
11302 unsigned long vna_off
;
11304 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
11305 _("version need")) == NULL
)
11308 ivna
.vna_other
= 0;
11313 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
11314 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
11316 vna_off
= offset
+ ivn
.vn_aux
;
11320 Elf_External_Vernaux evna
;
11322 if (get_data (&evna
, filedata
, vna_off
, sizeof (evna
), 1,
11323 _("version need aux (3)")) == NULL
)
11326 ivna
.vna_other
= 0;
11331 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
11332 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
11333 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
11336 vna_off
+= ivna
.vna_next
;
11338 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
11340 if (ivna
.vna_other
== vers_data
)
11343 offset
+= ivn
.vn_next
;
11345 while (ivn
.vn_next
!= 0);
11347 if (ivna
.vna_other
== vers_data
)
11349 *sym_info
= symbol_undefined
;
11350 *vna_other
= ivna
.vna_other
;
11351 return (ivna
.vna_name
< strtab_size
11352 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
11358 /* Dump the symbol table. */
11360 process_symbol_table (Filedata
* filedata
)
11362 Elf_Internal_Shdr
* section
;
11363 bfd_size_type nbuckets
= 0;
11364 bfd_size_type nchains
= 0;
11365 bfd_vma
* buckets
= NULL
;
11366 bfd_vma
* chains
= NULL
;
11367 bfd_vma ngnubuckets
= 0;
11368 bfd_vma
* gnubuckets
= NULL
;
11369 bfd_vma
* gnuchains
= NULL
;
11370 bfd_vma gnusymidx
= 0;
11371 bfd_size_type ngnuchains
= 0;
11373 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
11376 if (dynamic_info
[DT_HASH
]
11378 || (do_using_dynamic
11380 && dynamic_strings
!= NULL
)))
11382 unsigned char nb
[8];
11383 unsigned char nc
[8];
11384 unsigned int hash_ent_size
= 4;
11386 if ((filedata
->file_header
.e_machine
== EM_ALPHA
11387 || filedata
->file_header
.e_machine
== EM_S390
11388 || filedata
->file_header
.e_machine
== EM_S390_OLD
)
11389 && filedata
->file_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
11392 if (fseek (filedata
->handle
,
11393 (archive_file_offset
11394 + offset_from_vma (filedata
, dynamic_info
[DT_HASH
],
11395 sizeof nb
+ sizeof nc
)),
11398 error (_("Unable to seek to start of dynamic information\n"));
11402 if (fread (nb
, hash_ent_size
, 1, filedata
->handle
) != 1)
11404 error (_("Failed to read in number of buckets\n"));
11408 if (fread (nc
, hash_ent_size
, 1, filedata
->handle
) != 1)
11410 error (_("Failed to read in number of chains\n"));
11414 nbuckets
= byte_get (nb
, hash_ent_size
);
11415 nchains
= byte_get (nc
, hash_ent_size
);
11417 buckets
= get_dynamic_data (filedata
, nbuckets
, hash_ent_size
);
11418 chains
= get_dynamic_data (filedata
, nchains
, hash_ent_size
);
11421 if (buckets
== NULL
|| chains
== NULL
)
11423 if (do_using_dynamic
)
11434 if (dynamic_info_DT_GNU_HASH
11436 || (do_using_dynamic
11438 && dynamic_strings
!= NULL
)))
11440 unsigned char nb
[16];
11441 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
11442 bfd_vma buckets_vma
;
11444 if (fseek (filedata
->handle
,
11445 (archive_file_offset
11446 + offset_from_vma (filedata
, dynamic_info_DT_GNU_HASH
,
11450 error (_("Unable to seek to start of dynamic information\n"));
11454 if (fread (nb
, 16, 1, filedata
->handle
) != 1)
11456 error (_("Failed to read in number of buckets\n"));
11460 ngnubuckets
= byte_get (nb
, 4);
11461 gnusymidx
= byte_get (nb
+ 4, 4);
11462 bitmaskwords
= byte_get (nb
+ 8, 4);
11463 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
11465 buckets_vma
+= bitmaskwords
* 4;
11467 buckets_vma
+= bitmaskwords
* 8;
11469 if (fseek (filedata
->handle
,
11470 (archive_file_offset
11471 + offset_from_vma (filedata
, buckets_vma
, 4)),
11474 error (_("Unable to seek to start of dynamic information\n"));
11478 gnubuckets
= get_dynamic_data (filedata
, ngnubuckets
, 4);
11480 if (gnubuckets
== NULL
)
11483 for (i
= 0; i
< ngnubuckets
; i
++)
11484 if (gnubuckets
[i
] != 0)
11486 if (gnubuckets
[i
] < gnusymidx
)
11489 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
11490 maxchain
= gnubuckets
[i
];
11493 if (maxchain
== 0xffffffff)
11496 maxchain
-= gnusymidx
;
11498 if (fseek (filedata
->handle
,
11499 (archive_file_offset
11500 + offset_from_vma (filedata
, buckets_vma
11501 + 4 * (ngnubuckets
+ maxchain
), 4)),
11504 error (_("Unable to seek to start of dynamic information\n"));
11510 if (fread (nb
, 4, 1, filedata
->handle
) != 1)
11512 error (_("Failed to determine last chain length\n"));
11516 if (maxchain
+ 1 == 0)
11521 while ((byte_get (nb
, 4) & 1) == 0);
11523 if (fseek (filedata
->handle
,
11524 (archive_file_offset
11525 + offset_from_vma (filedata
, buckets_vma
+ 4 * ngnubuckets
, 4)),
11528 error (_("Unable to seek to start of dynamic information\n"));
11532 gnuchains
= get_dynamic_data (filedata
, maxchain
, 4);
11533 ngnuchains
= maxchain
;
11536 if (gnuchains
== NULL
)
11541 if (do_using_dynamic
)
11546 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
11548 && do_using_dynamic
11549 && dynamic_strings
!= NULL
11550 && dynamic_symbols
!= NULL
)
11554 if (dynamic_info
[DT_HASH
])
11559 printf (_("\nSymbol table for image:\n"));
11561 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11563 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11565 visited
= xcmalloc (nchains
, 1);
11566 memset (visited
, 0, nchains
);
11567 for (hn
= 0; hn
< nbuckets
; hn
++)
11569 for (si
= buckets
[hn
]; si
> 0; si
= chains
[si
])
11571 print_dynamic_symbol (filedata
, si
, hn
);
11572 if (si
>= nchains
|| visited
[si
])
11574 error (_("histogram chain is corrupt\n"));
11583 if (dynamic_info_DT_GNU_HASH
)
11585 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
11587 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11589 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11591 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11592 if (gnubuckets
[hn
] != 0)
11594 bfd_vma si
= gnubuckets
[hn
];
11595 bfd_vma off
= si
- gnusymidx
;
11599 print_dynamic_symbol (filedata
, si
, hn
);
11602 while (off
< ngnuchains
&& (gnuchains
[off
++] & 1) == 0);
11606 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
11607 && filedata
->section_headers
!= NULL
)
11611 for (i
= 0, section
= filedata
->section_headers
;
11612 i
< filedata
->file_header
.e_shnum
;
11616 char * strtab
= NULL
;
11617 unsigned long int strtab_size
= 0;
11618 Elf_Internal_Sym
* symtab
;
11619 Elf_Internal_Sym
* psym
;
11620 unsigned long num_syms
;
11622 if ((section
->sh_type
!= SHT_SYMTAB
11623 && section
->sh_type
!= SHT_DYNSYM
)
11625 && section
->sh_type
== SHT_SYMTAB
))
11628 if (section
->sh_entsize
== 0)
11630 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
11631 printable_section_name (filedata
, section
));
11635 num_syms
= section
->sh_size
/ section
->sh_entsize
;
11636 printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
11637 "\nSymbol table '%s' contains %lu entries:\n",
11639 printable_section_name (filedata
, section
),
11643 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11645 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11647 symtab
= GET_ELF_SYMBOLS (filedata
, section
, & num_syms
);
11648 if (symtab
== NULL
)
11651 if (section
->sh_link
== filedata
->file_header
.e_shstrndx
)
11653 strtab
= filedata
->string_table
;
11654 strtab_size
= filedata
->string_table_length
;
11656 else if (section
->sh_link
< filedata
->file_header
.e_shnum
)
11658 Elf_Internal_Shdr
* string_sec
;
11660 string_sec
= filedata
->section_headers
+ section
->sh_link
;
11662 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
,
11663 1, string_sec
->sh_size
,
11664 _("string table"));
11665 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
11668 for (si
= 0, psym
= symtab
; si
< num_syms
; si
++, psym
++)
11670 const char *version_string
;
11671 enum versioned_symbol_info sym_info
;
11672 unsigned short vna_other
;
11674 printf ("%6d: ", si
);
11675 print_vma (psym
->st_value
, LONG_HEX
);
11677 print_vma (psym
->st_size
, DEC_5
);
11678 printf (" %-7s", get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)));
11679 printf (" %-6s", get_symbol_binding (filedata
, ELF_ST_BIND (psym
->st_info
)));
11680 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
11681 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
11684 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
11686 printf (" %-7s", get_symbol_visibility (vis
));
11687 /* Check to see if any other bits in the st_other field are set.
11688 Note - displaying this information disrupts the layout of the
11689 table being generated, but for the moment this case is very rare. */
11690 if (psym
->st_other
^ vis
)
11691 printf (" [%s] ", get_symbol_other (filedata
, psym
->st_other
^ vis
));
11693 printf (" %4s ", get_symbol_index_type (filedata
, psym
->st_shndx
));
11694 print_symbol (25, psym
->st_name
< strtab_size
11695 ? strtab
+ psym
->st_name
: _("<corrupt>"));
11698 = get_symbol_version_string (filedata
,
11699 section
->sh_type
== SHT_DYNSYM
,
11700 strtab
, strtab_size
, si
,
11701 psym
, &sym_info
, &vna_other
);
11702 if (version_string
)
11704 if (sym_info
== symbol_undefined
)
11705 printf ("@%s (%d)", version_string
, vna_other
);
11707 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
11713 if (ELF_ST_BIND (psym
->st_info
) == STB_LOCAL
11714 && si
>= section
->sh_info
11715 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
11716 && filedata
->file_header
.e_machine
!= EM_MIPS
11717 /* Solaris binaries have been found to violate this requirement as
11718 well. Not sure if this is a bug or an ABI requirement. */
11719 && filedata
->file_header
.e_ident
[EI_OSABI
] != ELFOSABI_SOLARIS
)
11720 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
11721 si
, printable_section_name (filedata
, section
), section
->sh_info
);
11725 if (strtab
!= filedata
->string_table
)
11731 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
11733 if (do_histogram
&& buckets
!= NULL
)
11735 unsigned long * lengths
;
11736 unsigned long * counts
;
11739 unsigned long maxlength
= 0;
11740 unsigned long nzero_counts
= 0;
11741 unsigned long nsyms
= 0;
11744 printf (ngettext ("\nHistogram for bucket list length "
11745 "(total of %lu bucket):\n",
11746 "\nHistogram for bucket list length "
11747 "(total of %lu buckets):\n",
11748 (unsigned long) nbuckets
),
11749 (unsigned long) nbuckets
);
11751 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
11752 if (lengths
== NULL
)
11754 error (_("Out of memory allocating space for histogram buckets\n"));
11757 visited
= xcmalloc (nchains
, 1);
11758 memset (visited
, 0, nchains
);
11760 printf (_(" Length Number %% of total Coverage\n"));
11761 for (hn
= 0; hn
< nbuckets
; ++hn
)
11763 for (si
= buckets
[hn
]; si
> 0; si
= chains
[si
])
11766 if (maxlength
< ++lengths
[hn
])
11768 if (si
>= nchains
|| visited
[si
])
11770 error (_("histogram chain is corrupt\n"));
11778 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
11779 if (counts
== NULL
)
11782 error (_("Out of memory allocating space for histogram counts\n"));
11786 for (hn
= 0; hn
< nbuckets
; ++hn
)
11787 ++counts
[lengths
[hn
]];
11792 printf (" 0 %-10lu (%5.1f%%)\n",
11793 counts
[0], (counts
[0] * 100.0) / nbuckets
);
11794 for (i
= 1; i
<= maxlength
; ++i
)
11796 nzero_counts
+= counts
[i
] * i
;
11797 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11798 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
11799 (nzero_counts
* 100.0) / nsyms
);
11807 if (buckets
!= NULL
)
11813 if (do_histogram
&& gnubuckets
!= NULL
)
11815 unsigned long * lengths
;
11816 unsigned long * counts
;
11818 unsigned long maxlength
= 0;
11819 unsigned long nzero_counts
= 0;
11820 unsigned long nsyms
= 0;
11822 printf (ngettext ("\nHistogram for `.gnu.hash' bucket list length "
11823 "(total of %lu bucket):\n",
11824 "\nHistogram for `.gnu.hash' bucket list length "
11825 "(total of %lu buckets):\n",
11826 (unsigned long) ngnubuckets
),
11827 (unsigned long) ngnubuckets
);
11829 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
11830 if (lengths
== NULL
)
11832 error (_("Out of memory allocating space for gnu histogram buckets\n"));
11836 printf (_(" Length Number %% of total Coverage\n"));
11838 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11839 if (gnubuckets
[hn
] != 0)
11841 bfd_vma off
, length
= 1;
11843 for (off
= gnubuckets
[hn
] - gnusymidx
;
11844 /* PR 17531 file: 010-77222-0.004. */
11845 off
< ngnuchains
&& (gnuchains
[off
] & 1) == 0;
11848 lengths
[hn
] = length
;
11849 if (length
> maxlength
)
11850 maxlength
= length
;
11854 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
11855 if (counts
== NULL
)
11858 error (_("Out of memory allocating space for gnu histogram counts\n"));
11862 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11863 ++counts
[lengths
[hn
]];
11865 if (ngnubuckets
> 0)
11868 printf (" 0 %-10lu (%5.1f%%)\n",
11869 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
11870 for (j
= 1; j
<= maxlength
; ++j
)
11872 nzero_counts
+= counts
[j
] * j
;
11873 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11874 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
11875 (nzero_counts
* 100.0) / nsyms
);
11889 process_syminfo (Filedata
* filedata ATTRIBUTE_UNUSED
)
11893 if (dynamic_syminfo
== NULL
11895 /* No syminfo, this is ok. */
11898 /* There better should be a dynamic symbol section. */
11899 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
11903 printf (ngettext ("\nDynamic info segment at offset 0x%lx "
11904 "contains %d entry:\n",
11905 "\nDynamic info segment at offset 0x%lx "
11906 "contains %d entries:\n",
11907 dynamic_syminfo_nent
),
11908 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
11910 printf (_(" Num: Name BoundTo Flags\n"));
11911 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
11913 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
11915 printf ("%4d: ", i
);
11916 if (i
>= num_dynamic_syms
)
11917 printf (_("<corrupt index>"));
11918 else if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
11919 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
11921 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
11924 switch (dynamic_syminfo
[i
].si_boundto
)
11926 case SYMINFO_BT_SELF
:
11927 fputs ("SELF ", stdout
);
11929 case SYMINFO_BT_PARENT
:
11930 fputs ("PARENT ", stdout
);
11933 if (dynamic_syminfo
[i
].si_boundto
> 0
11934 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
11935 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
11937 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
11941 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
11945 if (flags
& SYMINFO_FLG_DIRECT
)
11946 printf (" DIRECT");
11947 if (flags
& SYMINFO_FLG_PASSTHRU
)
11948 printf (" PASSTHRU");
11949 if (flags
& SYMINFO_FLG_COPY
)
11951 if (flags
& SYMINFO_FLG_LAZYLOAD
)
11952 printf (" LAZYLOAD");
11960 #define IN_RANGE(START,END,ADDR,OFF) \
11961 (((ADDR) >= (START)) && ((ADDR) + (OFF) < (END)))
11963 /* Check to see if the given reloc needs to be handled in a target specific
11964 manner. If so then process the reloc and return TRUE otherwise return
11967 If called with reloc == NULL, then this is a signal that reloc processing
11968 for the current section has finished, and any saved state should be
11972 target_specific_reloc_handling (Filedata
* filedata
,
11973 Elf_Internal_Rela
* reloc
,
11974 unsigned char * start
,
11975 unsigned char * end
,
11976 Elf_Internal_Sym
* symtab
,
11977 unsigned long num_syms
)
11979 unsigned int reloc_type
= 0;
11980 unsigned long sym_index
= 0;
11984 reloc_type
= get_reloc_type (filedata
, reloc
->r_info
);
11985 sym_index
= get_reloc_symindex (reloc
->r_info
);
11988 switch (filedata
->file_header
.e_machine
)
11991 case EM_MSP430_OLD
:
11993 static Elf_Internal_Sym
* saved_sym
= NULL
;
12001 switch (reloc_type
)
12003 case 10: /* R_MSP430_SYM_DIFF */
12004 if (uses_msp430x_relocs (filedata
))
12006 /* Fall through. */
12007 case 21: /* R_MSP430X_SYM_DIFF */
12009 if (sym_index
>= num_syms
)
12010 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
12013 saved_sym
= symtab
+ sym_index
;
12016 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
12017 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
12018 goto handle_sym_diff
;
12020 case 5: /* R_MSP430_16_BYTE */
12021 case 9: /* R_MSP430_8 */
12022 if (uses_msp430x_relocs (filedata
))
12024 goto handle_sym_diff
;
12026 case 2: /* R_MSP430_ABS16 */
12027 case 15: /* R_MSP430X_ABS16 */
12028 if (! uses_msp430x_relocs (filedata
))
12030 goto handle_sym_diff
;
12033 if (saved_sym
!= NULL
)
12035 int reloc_size
= reloc_type
== 1 ? 4 : 2;
12038 if (sym_index
>= num_syms
)
12039 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
12043 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12044 - saved_sym
->st_value
);
12046 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12047 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12050 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
12051 (long) reloc
->r_offset
);
12060 if (saved_sym
!= NULL
)
12061 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
12068 case EM_CYGNUS_MN10300
:
12070 static Elf_Internal_Sym
* saved_sym
= NULL
;
12078 switch (reloc_type
)
12080 case 34: /* R_MN10300_ALIGN */
12082 case 33: /* R_MN10300_SYM_DIFF */
12083 if (sym_index
>= num_syms
)
12084 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
12087 saved_sym
= symtab
+ sym_index
;
12090 case 1: /* R_MN10300_32 */
12091 case 2: /* R_MN10300_16 */
12092 if (saved_sym
!= NULL
)
12094 int reloc_size
= reloc_type
== 1 ? 4 : 2;
12097 if (sym_index
>= num_syms
)
12098 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
12102 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12103 - saved_sym
->st_value
);
12105 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12106 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12108 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
12109 (long) reloc
->r_offset
);
12117 if (saved_sym
!= NULL
)
12118 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
12126 static bfd_vma saved_sym1
= 0;
12127 static bfd_vma saved_sym2
= 0;
12128 static bfd_vma value
;
12132 saved_sym1
= saved_sym2
= 0;
12136 switch (reloc_type
)
12138 case 0x80: /* R_RL78_SYM. */
12139 saved_sym1
= saved_sym2
;
12140 if (sym_index
>= num_syms
)
12141 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
12145 saved_sym2
= symtab
[sym_index
].st_value
;
12146 saved_sym2
+= reloc
->r_addend
;
12150 case 0x83: /* R_RL78_OPsub. */
12151 value
= saved_sym1
- saved_sym2
;
12152 saved_sym2
= saved_sym1
= 0;
12156 case 0x41: /* R_RL78_ABS32. */
12157 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 4))
12158 byte_put (start
+ reloc
->r_offset
, value
, 4);
12160 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12161 (long) reloc
->r_offset
);
12165 case 0x43: /* R_RL78_ABS16. */
12166 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 2))
12167 byte_put (start
+ reloc
->r_offset
, value
, 2);
12169 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12170 (long) reloc
->r_offset
);
12184 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12185 DWARF debug sections. This is a target specific test. Note - we do not
12186 go through the whole including-target-headers-multiple-times route, (as
12187 we have already done with <elf/h8.h>) because this would become very
12188 messy and even then this function would have to contain target specific
12189 information (the names of the relocs instead of their numeric values).
12190 FIXME: This is not the correct way to solve this problem. The proper way
12191 is to have target specific reloc sizing and typing functions created by
12192 the reloc-macros.h header, in the same way that it already creates the
12193 reloc naming functions. */
12196 is_32bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12198 /* Please keep this table alpha-sorted for ease of visual lookup. */
12199 switch (filedata
->file_header
.e_machine
)
12203 return reloc_type
== 1; /* R_386_32. */
12205 return reloc_type
== 1; /* R_68K_32. */
12207 return reloc_type
== 1; /* R_860_32. */
12209 return reloc_type
== 2; /* R_960_32. */
12211 return (reloc_type
== 258
12212 || reloc_type
== 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12213 case EM_ADAPTEVA_EPIPHANY
:
12214 return reloc_type
== 3;
12216 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
12218 return reloc_type
== 1; /* R_ARC_32. */
12219 case EM_ARC_COMPACT
:
12220 case EM_ARC_COMPACT2
:
12221 return reloc_type
== 4; /* R_ARC_32. */
12223 return reloc_type
== 2; /* R_ARM_ABS32 */
12226 return reloc_type
== 1;
12228 return reloc_type
== 0x12; /* R_byte4_data. */
12230 return reloc_type
== 3; /* R_CRIS_32. */
12232 return reloc_type
== 3; /* R_CR16_NUM32. */
12234 return reloc_type
== 15; /* R_CRX_NUM32. */
12235 case EM_CYGNUS_FRV
:
12236 return reloc_type
== 1;
12237 case EM_CYGNUS_D10V
:
12239 return reloc_type
== 6; /* R_D10V_32. */
12240 case EM_CYGNUS_D30V
:
12242 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
12244 return reloc_type
== 3; /* R_DLX_RELOC_32. */
12245 case EM_CYGNUS_FR30
:
12247 return reloc_type
== 3; /* R_FR30_32. */
12249 return reloc_type
== 1; /* R_FT32_32. */
12253 return reloc_type
== 1; /* R_H8_DIR32. */
12255 return (reloc_type
== 0x64 /* R_IA64_SECREL32MSB. */
12256 || reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
12257 || reloc_type
== 0x24 /* R_IA64_DIR32MSB. */
12258 || reloc_type
== 0x25 /* R_IA64_DIR32LSB. */);
12261 return reloc_type
== 2; /* R_IP2K_32. */
12263 return reloc_type
== 2; /* R_IQ2000_32. */
12264 case EM_LATTICEMICO32
:
12265 return reloc_type
== 3; /* R_LM32_32. */
12268 return reloc_type
== 3; /* R_M32C_32. */
12270 return reloc_type
== 34; /* R_M32R_32_RELA. */
12273 return reloc_type
== 6; /* R_M68HC11_32. */
12275 return reloc_type
== 1; /* R_MCORE_ADDR32. */
12276 case EM_CYGNUS_MEP
:
12277 return reloc_type
== 4; /* R_MEP_32. */
12279 return reloc_type
== 2; /* R_METAG_ADDR32. */
12280 case EM_MICROBLAZE
:
12281 return reloc_type
== 1; /* R_MICROBLAZE_32. */
12283 return reloc_type
== 2; /* R_MIPS_32. */
12285 return reloc_type
== 4; /* R_MMIX_32. */
12286 case EM_CYGNUS_MN10200
:
12288 return reloc_type
== 1; /* R_MN10200_32. */
12289 case EM_CYGNUS_MN10300
:
12291 return reloc_type
== 1; /* R_MN10300_32. */
12293 return reloc_type
== 1; /* R_MOXIE_32. */
12294 case EM_MSP430_OLD
:
12296 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
12298 return reloc_type
== 2; /* R_MT_32. */
12300 return reloc_type
== 20; /* R_NDS32_RELA. */
12301 case EM_ALTERA_NIOS2
:
12302 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
12304 return reloc_type
== 1; /* R_NIOS_32. */
12306 return reloc_type
== 1; /* R_OR1K_32. */
12308 return (reloc_type
== 1 /* R_PARISC_DIR32. */
12309 || reloc_type
== 2 /* R_PARISC_DIR21L. */
12310 || reloc_type
== 41); /* R_PARISC_SECREL32. */
12313 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
12315 return reloc_type
== 1; /* R_PPC64_ADDR32. */
12317 return reloc_type
== 1; /* R_PPC_ADDR32. */
12319 return reloc_type
== 11; /* R_PRU_BFD_RELOC_32. */
12321 return reloc_type
== 1; /* R_RISCV_32. */
12323 return reloc_type
== 1; /* R_RL78_DIR32. */
12325 return reloc_type
== 1; /* R_RX_DIR32. */
12327 return reloc_type
== 1; /* R_I370_ADDR31. */
12330 return reloc_type
== 4; /* R_S390_32. */
12332 return reloc_type
== 8; /* R_SCORE_ABS32. */
12334 return reloc_type
== 1; /* R_SH_DIR32. */
12335 case EM_SPARC32PLUS
:
12338 return reloc_type
== 3 /* R_SPARC_32. */
12339 || reloc_type
== 23; /* R_SPARC_UA32. */
12341 return reloc_type
== 6; /* R_SPU_ADDR32 */
12343 return reloc_type
== 1; /* R_C6000_ABS32. */
12345 return reloc_type
== 2; /* R_TILEGX_32. */
12347 return reloc_type
== 1; /* R_TILEPRO_32. */
12348 case EM_CYGNUS_V850
:
12350 return reloc_type
== 6; /* R_V850_ABS32. */
12352 return reloc_type
== 0x33; /* R_V810_WORD. */
12354 return reloc_type
== 1; /* R_VAX_32. */
12356 return reloc_type
== 3; /* R_VISIUM_32. */
12357 case EM_WEBASSEMBLY
:
12358 return reloc_type
== 1; /* R_WASM32_32. */
12362 return reloc_type
== 10; /* R_X86_64_32. */
12365 return reloc_type
== 3; /* R_XC16C_ABS_32. */
12367 return reloc_type
== 4; /* R_XGATE_32. */
12369 return reloc_type
== 1; /* R_XSTROMY16_32. */
12370 case EM_XTENSA_OLD
:
12372 return reloc_type
== 1; /* R_XTENSA_32. */
12375 static unsigned int prev_warn
= 0;
12377 /* Avoid repeating the same warning multiple times. */
12378 if (prev_warn
!= filedata
->file_header
.e_machine
)
12379 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12380 filedata
->file_header
.e_machine
);
12381 prev_warn
= filedata
->file_header
.e_machine
;
12387 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12388 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
12391 is_32bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12393 switch (filedata
->file_header
.e_machine
)
12394 /* Please keep this table alpha-sorted for ease of visual lookup. */
12398 return reloc_type
== 2; /* R_386_PC32. */
12400 return reloc_type
== 4; /* R_68K_PC32. */
12402 return reloc_type
== 261; /* R_AARCH64_PREL32 */
12403 case EM_ADAPTEVA_EPIPHANY
:
12404 return reloc_type
== 6;
12406 return reloc_type
== 10; /* R_ALPHA_SREL32. */
12407 case EM_ARC_COMPACT
:
12408 case EM_ARC_COMPACT2
:
12409 return reloc_type
== 49; /* R_ARC_32_PCREL. */
12411 return reloc_type
== 3; /* R_ARM_REL32 */
12414 return reloc_type
== 36; /* R_AVR_32_PCREL. */
12415 case EM_MICROBLAZE
:
12416 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
12418 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
12420 return reloc_type
== 9; /* R_PARISC_PCREL32. */
12422 return reloc_type
== 26; /* R_PPC_REL32. */
12424 return reloc_type
== 26; /* R_PPC64_REL32. */
12427 return reloc_type
== 5; /* R_390_PC32. */
12429 return reloc_type
== 2; /* R_SH_REL32. */
12430 case EM_SPARC32PLUS
:
12433 return reloc_type
== 6; /* R_SPARC_DISP32. */
12435 return reloc_type
== 13; /* R_SPU_REL32. */
12437 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
12439 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
12441 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
12445 return reloc_type
== 2; /* R_X86_64_PC32. */
12446 case EM_XTENSA_OLD
:
12448 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
12450 /* Do not abort or issue an error message here. Not all targets use
12451 pc-relative 32-bit relocs in their DWARF debug information and we
12452 have already tested for target coverage in is_32bit_abs_reloc. A
12453 more helpful warning message will be generated by apply_relocations
12454 anyway, so just return. */
12459 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12460 a 64-bit absolute RELA relocation used in DWARF debug sections. */
12463 is_64bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12465 switch (filedata
->file_header
.e_machine
)
12468 return reloc_type
== 257; /* R_AARCH64_ABS64. */
12470 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
12472 return (reloc_type
== 0x26 /* R_IA64_DIR64MSB. */
12473 || reloc_type
== 0x27 /* R_IA64_DIR64LSB. */);
12475 return reloc_type
== 80; /* R_PARISC_DIR64. */
12477 return reloc_type
== 38; /* R_PPC64_ADDR64. */
12479 return reloc_type
== 2; /* R_RISCV_64. */
12480 case EM_SPARC32PLUS
:
12483 return reloc_type
== 32 /* R_SPARC_64. */
12484 || reloc_type
== 54; /* R_SPARC_UA64. */
12488 return reloc_type
== 1; /* R_X86_64_64. */
12491 return reloc_type
== 22; /* R_S390_64. */
12493 return reloc_type
== 1; /* R_TILEGX_64. */
12495 return reloc_type
== 18; /* R_MIPS_64. */
12501 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12502 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
12505 is_64bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12507 switch (filedata
->file_header
.e_machine
)
12510 return reloc_type
== 260; /* R_AARCH64_PREL64. */
12512 return reloc_type
== 11; /* R_ALPHA_SREL64. */
12514 return (reloc_type
== 0x4e /* R_IA64_PCREL64MSB. */
12515 || reloc_type
== 0x4f /* R_IA64_PCREL64LSB. */);
12517 return reloc_type
== 72; /* R_PARISC_PCREL64. */
12519 return reloc_type
== 44; /* R_PPC64_REL64. */
12520 case EM_SPARC32PLUS
:
12523 return reloc_type
== 46; /* R_SPARC_DISP64. */
12527 return reloc_type
== 24; /* R_X86_64_PC64. */
12530 return reloc_type
== 23; /* R_S390_PC64. */
12532 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
12538 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12539 a 24-bit absolute RELA relocation used in DWARF debug sections. */
12542 is_24bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12544 switch (filedata
->file_header
.e_machine
)
12546 case EM_CYGNUS_MN10200
:
12548 return reloc_type
== 4; /* R_MN10200_24. */
12550 return reloc_type
== 5; /* R_FT32_20. */
12556 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12557 a 16-bit absolute RELA relocation used in DWARF debug sections. */
12560 is_16bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12562 /* Please keep this table alpha-sorted for ease of visual lookup. */
12563 switch (filedata
->file_header
.e_machine
)
12566 case EM_ARC_COMPACT
:
12567 case EM_ARC_COMPACT2
:
12568 return reloc_type
== 2; /* R_ARC_16. */
12569 case EM_ADAPTEVA_EPIPHANY
:
12570 return reloc_type
== 5;
12573 return reloc_type
== 4; /* R_AVR_16. */
12574 case EM_CYGNUS_D10V
:
12576 return reloc_type
== 3; /* R_D10V_16. */
12578 return reloc_type
== 2; /* R_FT32_16. */
12582 return reloc_type
== R_H8_DIR16
;
12585 return reloc_type
== 1; /* R_IP2K_16. */
12588 return reloc_type
== 1; /* R_M32C_16 */
12589 case EM_CYGNUS_MN10200
:
12591 return reloc_type
== 2; /* R_MN10200_16. */
12592 case EM_CYGNUS_MN10300
:
12594 return reloc_type
== 2; /* R_MN10300_16. */
12596 if (uses_msp430x_relocs (filedata
))
12597 return reloc_type
== 2; /* R_MSP430_ABS16. */
12598 /* Fall through. */
12599 case EM_MSP430_OLD
:
12600 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
12602 return reloc_type
== 19; /* R_NDS32_RELA. */
12603 case EM_ALTERA_NIOS2
:
12604 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
12606 return reloc_type
== 9; /* R_NIOS_16. */
12608 return reloc_type
== 2; /* R_OR1K_16. */
12610 return reloc_type
== 8; /* R_PRU_BFD_RELOC_16. */
12612 return reloc_type
== 2; /* R_C6000_ABS16. */
12614 return reloc_type
== 2; /* R_VISIUM_16. */
12617 return reloc_type
== 2; /* R_XC16C_ABS_16. */
12619 return reloc_type
== 3; /* R_XGATE_16. */
12625 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12626 a 32-bit inplace add RELA relocation used in DWARF debug sections. */
12629 is_32bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12631 /* Please keep this table alpha-sorted for ease of visual lookup. */
12632 switch (filedata
->file_header
.e_machine
)
12635 return reloc_type
== 35; /* R_RISCV_ADD32. */
12641 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12642 a 32-bit inplace sub RELA relocation used in DWARF debug sections. */
12645 is_32bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12647 /* Please keep this table alpha-sorted for ease of visual lookup. */
12648 switch (filedata
->file_header
.e_machine
)
12651 return reloc_type
== 39; /* R_RISCV_SUB32. */
12657 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12658 a 64-bit inplace add RELA relocation used in DWARF debug sections. */
12661 is_64bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12663 /* Please keep this table alpha-sorted for ease of visual lookup. */
12664 switch (filedata
->file_header
.e_machine
)
12667 return reloc_type
== 36; /* R_RISCV_ADD64. */
12673 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12674 a 64-bit inplace sub RELA relocation used in DWARF debug sections. */
12677 is_64bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12679 /* Please keep this table alpha-sorted for ease of visual lookup. */
12680 switch (filedata
->file_header
.e_machine
)
12683 return reloc_type
== 40; /* R_RISCV_SUB64. */
12689 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12690 a 16-bit inplace add RELA relocation used in DWARF debug sections. */
12693 is_16bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12695 /* Please keep this table alpha-sorted for ease of visual lookup. */
12696 switch (filedata
->file_header
.e_machine
)
12699 return reloc_type
== 34; /* R_RISCV_ADD16. */
12705 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12706 a 16-bit inplace sub RELA relocation used in DWARF debug sections. */
12709 is_16bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12711 /* Please keep this table alpha-sorted for ease of visual lookup. */
12712 switch (filedata
->file_header
.e_machine
)
12715 return reloc_type
== 38; /* R_RISCV_SUB16. */
12721 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12722 a 8-bit inplace add RELA relocation used in DWARF debug sections. */
12725 is_8bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12727 /* Please keep this table alpha-sorted for ease of visual lookup. */
12728 switch (filedata
->file_header
.e_machine
)
12731 return reloc_type
== 33; /* R_RISCV_ADD8. */
12737 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12738 a 8-bit inplace sub RELA relocation used in DWARF debug sections. */
12741 is_8bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12743 /* Please keep this table alpha-sorted for ease of visual lookup. */
12744 switch (filedata
->file_header
.e_machine
)
12747 return reloc_type
== 37; /* R_RISCV_SUB8. */
12753 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
12754 relocation entries (possibly formerly used for SHT_GROUP sections). */
12757 is_none_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12759 switch (filedata
->file_header
.e_machine
)
12761 case EM_386
: /* R_386_NONE. */
12762 case EM_68K
: /* R_68K_NONE. */
12763 case EM_ADAPTEVA_EPIPHANY
:
12764 case EM_ALPHA
: /* R_ALPHA_NONE. */
12765 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
12766 case EM_ARC
: /* R_ARC_NONE. */
12767 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
12768 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
12769 case EM_ARM
: /* R_ARM_NONE. */
12770 case EM_C166
: /* R_XC16X_NONE. */
12771 case EM_CRIS
: /* R_CRIS_NONE. */
12772 case EM_FT32
: /* R_FT32_NONE. */
12773 case EM_IA_64
: /* R_IA64_NONE. */
12774 case EM_K1OM
: /* R_X86_64_NONE. */
12775 case EM_L1OM
: /* R_X86_64_NONE. */
12776 case EM_M32R
: /* R_M32R_NONE. */
12777 case EM_MIPS
: /* R_MIPS_NONE. */
12778 case EM_MN10300
: /* R_MN10300_NONE. */
12779 case EM_MOXIE
: /* R_MOXIE_NONE. */
12780 case EM_NIOS32
: /* R_NIOS_NONE. */
12781 case EM_OR1K
: /* R_OR1K_NONE. */
12782 case EM_PARISC
: /* R_PARISC_NONE. */
12783 case EM_PPC64
: /* R_PPC64_NONE. */
12784 case EM_PPC
: /* R_PPC_NONE. */
12785 case EM_RISCV
: /* R_RISCV_NONE. */
12786 case EM_S390
: /* R_390_NONE. */
12788 case EM_SH
: /* R_SH_NONE. */
12789 case EM_SPARC32PLUS
:
12790 case EM_SPARC
: /* R_SPARC_NONE. */
12792 case EM_TILEGX
: /* R_TILEGX_NONE. */
12793 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
12794 case EM_TI_C6000
:/* R_C6000_NONE. */
12795 case EM_X86_64
: /* R_X86_64_NONE. */
12797 case EM_WEBASSEMBLY
: /* R_WASM32_NONE. */
12798 return reloc_type
== 0;
12801 return reloc_type
== 0 || reloc_type
== 256;
12804 return (reloc_type
== 0 /* R_AVR_NONE. */
12805 || reloc_type
== 30 /* R_AVR_DIFF8. */
12806 || reloc_type
== 31 /* R_AVR_DIFF16. */
12807 || reloc_type
== 32 /* R_AVR_DIFF32. */);
12809 return reloc_type
== 3; /* R_METAG_NONE. */
12811 return (reloc_type
== 0 /* R_XTENSA_NONE. */
12812 || reloc_type
== 204 /* R_NDS32_DIFF8. */
12813 || reloc_type
== 205 /* R_NDS32_DIFF16. */
12814 || reloc_type
== 206 /* R_NDS32_DIFF32. */
12815 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
12817 return (reloc_type
== 0 /* R_PRU_NONE. */
12818 || reloc_type
== 65 /* R_PRU_DIFF8. */
12819 || reloc_type
== 66 /* R_PRU_DIFF16. */
12820 || reloc_type
== 67 /* R_PRU_DIFF32. */);
12821 case EM_XTENSA_OLD
:
12823 return (reloc_type
== 0 /* R_XTENSA_NONE. */
12824 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
12825 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
12826 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
12831 /* Returns TRUE if there is a relocation against
12832 section NAME at OFFSET bytes. */
12835 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
12837 Elf_Internal_Rela
* relocs
;
12838 Elf_Internal_Rela
* rp
;
12840 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
12843 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
12845 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
12846 if (rp
->r_offset
== offset
)
12852 /* Apply relocations to a section.
12853 Returns TRUE upon success, FALSE otherwise.
12854 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
12855 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
12856 will be set to the number of relocs loaded.
12858 Note: So far support has been added only for those relocations
12859 which can be found in debug sections. FIXME: Add support for
12860 more relocations ? */
12863 apply_relocations (Filedata
* filedata
,
12864 const Elf_Internal_Shdr
* section
,
12865 unsigned char * start
,
12866 bfd_size_type size
,
12867 void ** relocs_return
,
12868 unsigned long * num_relocs_return
)
12870 Elf_Internal_Shdr
* relsec
;
12871 unsigned char * end
= start
+ size
;
12872 bfd_boolean res
= TRUE
;
12874 if (relocs_return
!= NULL
)
12876 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
12877 * num_relocs_return
= 0;
12880 if (filedata
->file_header
.e_type
!= ET_REL
)
12881 /* No relocs to apply. */
12884 /* Find the reloc section associated with the section. */
12885 for (relsec
= filedata
->section_headers
;
12886 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
12889 bfd_boolean is_rela
;
12890 unsigned long num_relocs
;
12891 Elf_Internal_Rela
* relocs
;
12892 Elf_Internal_Rela
* rp
;
12893 Elf_Internal_Shdr
* symsec
;
12894 Elf_Internal_Sym
* symtab
;
12895 unsigned long num_syms
;
12896 Elf_Internal_Sym
* sym
;
12898 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
12899 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
12900 || filedata
->section_headers
+ relsec
->sh_info
!= section
12901 || relsec
->sh_size
== 0
12902 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
12905 is_rela
= relsec
->sh_type
== SHT_RELA
;
12909 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
,
12910 relsec
->sh_size
, & relocs
, & num_relocs
))
12915 if (!slurp_rel_relocs (filedata
, relsec
->sh_offset
,
12916 relsec
->sh_size
, & relocs
, & num_relocs
))
12920 /* SH uses RELA but uses in place value instead of the addend field. */
12921 if (filedata
->file_header
.e_machine
== EM_SH
)
12924 symsec
= filedata
->section_headers
+ relsec
->sh_link
;
12925 if (symsec
->sh_type
!= SHT_SYMTAB
12926 && symsec
->sh_type
!= SHT_DYNSYM
)
12928 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & num_syms
);
12930 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
12933 unsigned int reloc_type
;
12934 unsigned int reloc_size
;
12935 bfd_boolean reloc_inplace
= FALSE
;
12936 bfd_boolean reloc_subtract
= FALSE
;
12937 unsigned char * rloc
;
12938 unsigned long sym_index
;
12940 reloc_type
= get_reloc_type (filedata
, rp
->r_info
);
12942 if (target_specific_reloc_handling (filedata
, rp
, start
, end
, symtab
, num_syms
))
12944 else if (is_none_reloc (filedata
, reloc_type
))
12946 else if (is_32bit_abs_reloc (filedata
, reloc_type
)
12947 || is_32bit_pcrel_reloc (filedata
, reloc_type
))
12949 else if (is_64bit_abs_reloc (filedata
, reloc_type
)
12950 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
12952 else if (is_24bit_abs_reloc (filedata
, reloc_type
))
12954 else if (is_16bit_abs_reloc (filedata
, reloc_type
))
12956 else if ((reloc_subtract
= is_32bit_inplace_sub_reloc (filedata
,
12958 || is_32bit_inplace_add_reloc (filedata
, reloc_type
))
12961 reloc_inplace
= TRUE
;
12963 else if ((reloc_subtract
= is_64bit_inplace_sub_reloc (filedata
,
12965 || is_64bit_inplace_add_reloc (filedata
, reloc_type
))
12968 reloc_inplace
= TRUE
;
12970 else if ((reloc_subtract
= is_16bit_inplace_sub_reloc (filedata
,
12972 || is_16bit_inplace_add_reloc (filedata
, reloc_type
))
12975 reloc_inplace
= TRUE
;
12977 else if ((reloc_subtract
= is_8bit_inplace_sub_reloc (filedata
,
12979 || is_8bit_inplace_add_reloc (filedata
, reloc_type
))
12982 reloc_inplace
= TRUE
;
12986 static unsigned int prev_reloc
= 0;
12988 if (reloc_type
!= prev_reloc
)
12989 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
12990 reloc_type
, printable_section_name (filedata
, section
));
12991 prev_reloc
= reloc_type
;
12996 rloc
= start
+ rp
->r_offset
;
12997 if ((rloc
+ reloc_size
) > end
|| (rloc
< start
))
12999 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
13000 (unsigned long) rp
->r_offset
,
13001 printable_section_name (filedata
, section
));
13006 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
13007 if (sym_index
>= num_syms
)
13009 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
13010 sym_index
, printable_section_name (filedata
, section
));
13014 sym
= symtab
+ sym_index
;
13016 /* If the reloc has a symbol associated with it,
13017 make sure that it is of an appropriate type.
13019 Relocations against symbols without type can happen.
13020 Gcc -feliminate-dwarf2-dups may generate symbols
13021 without type for debug info.
13023 Icc generates relocations against function symbols
13024 instead of local labels.
13026 Relocations against object symbols can happen, eg when
13027 referencing a global array. For an example of this see
13028 the _clz.o binary in libgcc.a. */
13030 && ELF_ST_TYPE (sym
->st_info
) != STT_COMMON
13031 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
13033 warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
13034 get_symbol_type (filedata
, ELF_ST_TYPE (sym
->st_info
)),
13035 printable_section_name (filedata
, relsec
),
13036 (long int)(rp
- relocs
));
13043 addend
+= rp
->r_addend
;
13044 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
13045 partial_inplace. */
13047 || (filedata
->file_header
.e_machine
== EM_XTENSA
13048 && reloc_type
== 1)
13049 || ((filedata
->file_header
.e_machine
== EM_PJ
13050 || filedata
->file_header
.e_machine
== EM_PJ_OLD
)
13051 && reloc_type
== 1)
13052 || ((filedata
->file_header
.e_machine
== EM_D30V
13053 || filedata
->file_header
.e_machine
== EM_CYGNUS_D30V
)
13054 && reloc_type
== 12)
13056 addend
+= byte_get (rloc
, reloc_size
);
13058 if (is_32bit_pcrel_reloc (filedata
, reloc_type
)
13059 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
13061 /* On HPPA, all pc-relative relocations are biased by 8. */
13062 if (filedata
->file_header
.e_machine
== EM_PARISC
)
13064 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
13067 else if (reloc_subtract
)
13068 byte_put (rloc
, addend
- sym
->st_value
, reloc_size
);
13070 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
13074 /* Let the target specific reloc processing code know that
13075 we have finished with these relocs. */
13076 target_specific_reloc_handling (filedata
, NULL
, NULL
, NULL
, NULL
, 0);
13080 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
13081 * num_relocs_return
= num_relocs
;
13092 #ifdef SUPPORT_DISASSEMBLY
13094 disassemble_section (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13096 printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata
, section
));
13098 /* FIXME: XXX -- to be done --- XXX */
13104 /* Reads in the contents of SECTION from FILE, returning a pointer
13105 to a malloc'ed buffer or NULL if something went wrong. */
13108 get_section_contents (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13110 bfd_size_type num_bytes
= section
->sh_size
;
13112 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
13114 printf (_("Section '%s' has no data to dump.\n"),
13115 printable_section_name (filedata
, section
));
13119 return (char *) get_data (NULL
, filedata
, section
->sh_offset
, 1, num_bytes
,
13120 _("section contents"));
13123 /* Uncompresses a section that was compressed using zlib, in place. */
13126 uncompress_section_contents (unsigned char ** buffer
,
13127 dwarf_size_type uncompressed_size
,
13128 dwarf_size_type
* size
)
13130 dwarf_size_type compressed_size
= *size
;
13131 unsigned char * compressed_buffer
= *buffer
;
13132 unsigned char * uncompressed_buffer
;
13136 /* It is possible the section consists of several compressed
13137 buffers concatenated together, so we uncompress in a loop. */
13138 /* PR 18313: The state field in the z_stream structure is supposed
13139 to be invisible to the user (ie us), but some compilers will
13140 still complain about it being used without initialisation. So
13141 we first zero the entire z_stream structure and then set the fields
13143 memset (& strm
, 0, sizeof strm
);
13144 strm
.avail_in
= compressed_size
;
13145 strm
.next_in
= (Bytef
*) compressed_buffer
;
13146 strm
.avail_out
= uncompressed_size
;
13147 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
13149 rc
= inflateInit (& strm
);
13150 while (strm
.avail_in
> 0)
13154 strm
.next_out
= ((Bytef
*) uncompressed_buffer
13155 + (uncompressed_size
- strm
.avail_out
));
13156 rc
= inflate (&strm
, Z_FINISH
);
13157 if (rc
!= Z_STREAM_END
)
13159 rc
= inflateReset (& strm
);
13161 rc
= inflateEnd (& strm
);
13163 || strm
.avail_out
!= 0)
13166 *buffer
= uncompressed_buffer
;
13167 *size
= uncompressed_size
;
13171 free (uncompressed_buffer
);
13172 /* Indicate decompression failure. */
13178 dump_section_as_strings (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13180 Elf_Internal_Shdr
* relsec
;
13181 bfd_size_type num_bytes
;
13182 unsigned char * data
;
13183 unsigned char * end
;
13184 unsigned char * real_start
;
13185 unsigned char * start
;
13186 bfd_boolean some_strings_shown
;
13188 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
13190 /* PR 21820: Do not fail if the section was empty. */
13191 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
13193 num_bytes
= section
->sh_size
;
13195 printf (_("\nString dump of section '%s':\n"), printable_section_name (filedata
, section
));
13197 if (decompress_dumps
)
13199 dwarf_size_type new_size
= num_bytes
;
13200 dwarf_size_type uncompressed_size
= 0;
13202 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
13204 Elf_Internal_Chdr chdr
;
13205 unsigned int compression_header_size
13206 = get_compression_header (& chdr
, (unsigned char *) start
,
13209 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13211 warn (_("section '%s' has unsupported compress type: %d\n"),
13212 printable_section_name (filedata
, section
), chdr
.ch_type
);
13215 else if (chdr
.ch_addralign
!= section
->sh_addralign
)
13217 warn (_("compressed section '%s' is corrupted\n"),
13218 printable_section_name (filedata
, section
));
13221 uncompressed_size
= chdr
.ch_size
;
13222 start
+= compression_header_size
;
13223 new_size
-= compression_header_size
;
13225 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
13227 /* Read the zlib header. In this case, it should be "ZLIB"
13228 followed by the uncompressed section size, 8 bytes in
13229 big-endian order. */
13230 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13231 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13232 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13233 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13234 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13235 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13236 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13237 uncompressed_size
+= start
[11];
13242 if (uncompressed_size
)
13244 if (uncompress_section_contents (& start
,
13245 uncompressed_size
, & new_size
))
13246 num_bytes
= new_size
;
13249 error (_("Unable to decompress section %s\n"),
13250 printable_section_name (filedata
, section
));
13255 start
= real_start
;
13258 /* If the section being dumped has relocations against it the user might
13259 be expecting these relocations to have been applied. Check for this
13260 case and issue a warning message in order to avoid confusion.
13261 FIXME: Maybe we ought to have an option that dumps a section with
13262 relocs applied ? */
13263 for (relsec
= filedata
->section_headers
;
13264 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13267 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13268 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13269 || filedata
->section_headers
+ relsec
->sh_info
!= section
13270 || relsec
->sh_size
== 0
13271 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13274 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13279 end
= start
+ num_bytes
;
13280 some_strings_shown
= FALSE
;
13284 while (!ISPRINT (* data
))
13285 if (++ data
>= end
)
13290 size_t maxlen
= end
- data
;
13293 /* PR 11128: Use two separate invocations in order to work
13294 around bugs in the Solaris 8 implementation of printf. */
13295 printf (" [%6tx] ", data
- start
);
13297 printf (" [%6Ix] ", (size_t) (data
- start
));
13301 print_symbol ((int) maxlen
, (const char *) data
);
13303 data
+= strnlen ((const char *) data
, maxlen
);
13307 printf (_("<corrupt>\n"));
13310 some_strings_shown
= TRUE
;
13314 if (! some_strings_shown
)
13315 printf (_(" No strings found in this section."));
13324 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
13325 Filedata
* filedata
,
13326 bfd_boolean relocate
)
13328 Elf_Internal_Shdr
* relsec
;
13329 bfd_size_type bytes
;
13330 bfd_size_type section_size
;
13332 unsigned char * data
;
13333 unsigned char * real_start
;
13334 unsigned char * start
;
13336 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
13338 /* PR 21820: Do not fail if the section was empty. */
13339 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
13341 section_size
= section
->sh_size
;
13343 printf (_("\nHex dump of section '%s':\n"), printable_section_name (filedata
, section
));
13345 if (decompress_dumps
)
13347 dwarf_size_type new_size
= section_size
;
13348 dwarf_size_type uncompressed_size
= 0;
13350 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
13352 Elf_Internal_Chdr chdr
;
13353 unsigned int compression_header_size
13354 = get_compression_header (& chdr
, start
, section_size
);
13356 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13358 warn (_("section '%s' has unsupported compress type: %d\n"),
13359 printable_section_name (filedata
, section
), chdr
.ch_type
);
13362 else if (chdr
.ch_addralign
!= section
->sh_addralign
)
13364 warn (_("compressed section '%s' is corrupted\n"),
13365 printable_section_name (filedata
, section
));
13368 uncompressed_size
= chdr
.ch_size
;
13369 start
+= compression_header_size
;
13370 new_size
-= compression_header_size
;
13372 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
13374 /* Read the zlib header. In this case, it should be "ZLIB"
13375 followed by the uncompressed section size, 8 bytes in
13376 big-endian order. */
13377 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13378 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13379 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13380 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13381 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13382 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13383 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13384 uncompressed_size
+= start
[11];
13389 if (uncompressed_size
)
13391 if (uncompress_section_contents (& start
, uncompressed_size
,
13394 section_size
= new_size
;
13398 error (_("Unable to decompress section %s\n"),
13399 printable_section_name (filedata
, section
));
13400 /* FIXME: Print the section anyway ? */
13405 start
= real_start
;
13410 if (! apply_relocations (filedata
, section
, start
, section_size
, NULL
, NULL
))
13415 /* If the section being dumped has relocations against it the user might
13416 be expecting these relocations to have been applied. Check for this
13417 case and issue a warning message in order to avoid confusion.
13418 FIXME: Maybe we ought to have an option that dumps a section with
13419 relocs applied ? */
13420 for (relsec
= filedata
->section_headers
;
13421 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13424 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13425 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13426 || filedata
->section_headers
+ relsec
->sh_info
!= section
13427 || relsec
->sh_size
== 0
13428 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13431 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13436 addr
= section
->sh_addr
;
13437 bytes
= section_size
;
13446 lbytes
= (bytes
> 16 ? 16 : bytes
);
13448 printf (" 0x%8.8lx ", (unsigned long) addr
);
13450 for (j
= 0; j
< 16; j
++)
13453 printf ("%2.2x", data
[j
]);
13461 for (j
= 0; j
< lbytes
; j
++)
13464 if (k
>= ' ' && k
< 0x7f)
13484 load_specific_debug_section (enum dwarf_section_display_enum debug
,
13485 const Elf_Internal_Shdr
* sec
,
13488 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13490 Filedata
* filedata
= (Filedata
*) data
;
13492 if (section
->start
!= NULL
)
13494 /* If it is already loaded, do nothing. */
13495 if (streq (section
->filename
, filedata
->file_name
))
13497 free (section
->start
);
13500 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
13501 section
->address
= sec
->sh_addr
;
13502 section
->user_data
= NULL
;
13503 section
->filename
= filedata
->file_name
;
13504 section
->start
= (unsigned char *) get_data (NULL
, filedata
,
13506 sec
->sh_size
, buf
);
13507 if (section
->start
== NULL
)
13511 unsigned char *start
= section
->start
;
13512 dwarf_size_type size
= sec
->sh_size
;
13513 dwarf_size_type uncompressed_size
= 0;
13515 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
13517 Elf_Internal_Chdr chdr
;
13518 unsigned int compression_header_size
;
13520 if (size
< (is_32bit_elf
13521 ? sizeof (Elf32_External_Chdr
)
13522 : sizeof (Elf64_External_Chdr
)))
13524 warn (_("compressed section %s is too small to contain a compression header"),
13529 compression_header_size
= get_compression_header (&chdr
, start
, size
);
13531 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13533 warn (_("section '%s' has unsupported compress type: %d\n"),
13534 section
->name
, chdr
.ch_type
);
13537 else if (chdr
.ch_addralign
!= sec
->sh_addralign
)
13539 warn (_("compressed section '%s' is corrupted\n"),
13543 uncompressed_size
= chdr
.ch_size
;
13544 start
+= compression_header_size
;
13545 size
-= compression_header_size
;
13547 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
13549 /* Read the zlib header. In this case, it should be "ZLIB"
13550 followed by the uncompressed section size, 8 bytes in
13551 big-endian order. */
13552 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13553 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13554 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13555 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13556 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13557 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13558 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13559 uncompressed_size
+= start
[11];
13564 if (uncompressed_size
)
13566 if (uncompress_section_contents (&start
, uncompressed_size
,
13569 /* Free the compressed buffer, update the section buffer
13570 and the section size if uncompress is successful. */
13571 free (section
->start
);
13572 section
->start
= start
;
13576 error (_("Unable to decompress section %s\n"),
13577 printable_section_name (filedata
, sec
));
13582 section
->size
= size
;
13585 if (section
->start
== NULL
)
13588 if (debug_displays
[debug
].relocate
)
13590 if (! apply_relocations (filedata
, sec
, section
->start
, section
->size
,
13591 & section
->reloc_info
, & section
->num_relocs
))
13596 section
->reloc_info
= NULL
;
13597 section
->num_relocs
= 0;
13603 /* If this is not NULL, load_debug_section will only look for sections
13604 within the list of sections given here. */
13605 static unsigned int * section_subset
= NULL
;
13608 load_debug_section (enum dwarf_section_display_enum debug
, void * data
)
13610 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13611 Elf_Internal_Shdr
* sec
;
13612 Filedata
* filedata
= (Filedata
*) data
;
13614 /* Without section headers we cannot find any sections. */
13615 if (filedata
->section_headers
== NULL
)
13618 if (filedata
->string_table
== NULL
13619 && filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
13620 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
13622 Elf_Internal_Shdr
* strs
;
13624 /* Read in the string table, so that we have section names to scan. */
13625 strs
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
13627 if (strs
!= NULL
&& strs
->sh_size
!= 0)
13629 filedata
->string_table
13630 = (char *) get_data (NULL
, filedata
, strs
->sh_offset
,
13631 1, strs
->sh_size
, _("string table"));
13633 filedata
->string_table_length
13634 = filedata
->string_table
!= NULL
? strs
->sh_size
: 0;
13638 /* Locate the debug section. */
13639 sec
= find_section_in_set (filedata
, section
->uncompressed_name
, section_subset
);
13641 section
->name
= section
->uncompressed_name
;
13644 sec
= find_section_in_set (filedata
, section
->compressed_name
, section_subset
);
13646 section
->name
= section
->compressed_name
;
13651 /* If we're loading from a subset of sections, and we've loaded
13652 a section matching this name before, it's likely that it's a
13654 if (section_subset
!= NULL
)
13655 free_debug_section (debug
);
13657 return load_specific_debug_section (debug
, sec
, data
);
13661 free_debug_section (enum dwarf_section_display_enum debug
)
13663 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13665 if (section
->start
== NULL
)
13668 free ((char *) section
->start
);
13669 section
->start
= NULL
;
13670 section
->address
= 0;
13675 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13677 char * name
= SECTION_NAME (section
);
13678 const char * print_name
= printable_section_name (filedata
, section
);
13679 bfd_size_type length
;
13680 bfd_boolean result
= TRUE
;
13683 length
= section
->sh_size
;
13686 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
13689 if (section
->sh_type
== SHT_NOBITS
)
13691 /* There is no point in dumping the contents of a debugging section
13692 which has the NOBITS type - the bits in the file will be random.
13693 This can happen when a file containing a .eh_frame section is
13694 stripped with the --only-keep-debug command line option. */
13695 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
13700 if (const_strneq (name
, ".gnu.linkonce.wi."))
13701 name
= ".debug_info";
13703 /* See if we know how to display the contents of this section. */
13704 for (i
= 0; i
< max
; i
++)
13706 enum dwarf_section_display_enum id
= (enum dwarf_section_display_enum
) i
;
13707 struct dwarf_section_display
* display
= debug_displays
+ i
;
13708 struct dwarf_section
* sec
= & display
->section
;
13710 if (streq (sec
->uncompressed_name
, name
)
13711 || (id
== line
&& const_strneq (name
, ".debug_line."))
13712 || streq (sec
->compressed_name
, name
))
13714 bfd_boolean secondary
= (section
!= find_section (filedata
, name
));
13717 free_debug_section (id
);
13719 if (i
== line
&& const_strneq (name
, ".debug_line."))
13721 else if (streq (sec
->uncompressed_name
, name
))
13722 sec
->name
= sec
->uncompressed_name
;
13724 sec
->name
= sec
->compressed_name
;
13726 if (load_specific_debug_section (id
, section
, filedata
))
13728 /* If this debug section is part of a CU/TU set in a .dwp file,
13729 restrict load_debug_section to the sections in that set. */
13730 section_subset
= find_cu_tu_set (filedata
, shndx
);
13732 result
&= display
->display (sec
, filedata
);
13734 section_subset
= NULL
;
13736 if (secondary
|| (id
!= info
&& id
!= abbrev
))
13737 free_debug_section (id
);
13745 printf (_("Unrecognized debug section: %s\n"), print_name
);
13752 /* Set DUMP_SECTS for all sections where dumps were requested
13753 based on section name. */
13756 initialise_dumps_byname (Filedata
* filedata
)
13758 struct dump_list_entry
* cur
;
13760 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
13763 bfd_boolean any
= FALSE
;
13765 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
13766 if (streq (SECTION_NAME (filedata
->section_headers
+ i
), cur
->name
))
13768 request_dump_bynumber (filedata
, i
, cur
->type
);
13773 warn (_("Section '%s' was not dumped because it does not exist!\n"),
13779 process_section_contents (Filedata
* filedata
)
13781 Elf_Internal_Shdr
* section
;
13783 bfd_boolean res
= TRUE
;
13788 initialise_dumps_byname (filedata
);
13790 for (i
= 0, section
= filedata
->section_headers
;
13791 i
< filedata
->file_header
.e_shnum
&& i
< filedata
->num_dump_sects
;
13794 dump_type dump
= filedata
->dump_sects
[i
];
13796 #ifdef SUPPORT_DISASSEMBLY
13797 if (dump
& DISASS_DUMP
)
13799 if (! disassemble_section (section
, filedata
))
13803 if (dump
& HEX_DUMP
)
13805 if (! dump_section_as_bytes (section
, filedata
, FALSE
))
13809 if (dump
& RELOC_DUMP
)
13811 if (! dump_section_as_bytes (section
, filedata
, TRUE
))
13815 if (dump
& STRING_DUMP
)
13817 if (! dump_section_as_strings (section
, filedata
))
13821 if (dump
& DEBUG_DUMP
)
13823 if (! display_debug_section (i
, section
, filedata
))
13828 /* Check to see if the user requested a
13829 dump of a section that does not exist. */
13830 while (i
< filedata
->num_dump_sects
)
13832 if (filedata
->dump_sects
[i
])
13834 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
13844 process_mips_fpe_exception (int mask
)
13848 bfd_boolean first
= TRUE
;
13850 if (mask
& OEX_FPU_INEX
)
13851 fputs ("INEX", stdout
), first
= FALSE
;
13852 if (mask
& OEX_FPU_UFLO
)
13853 printf ("%sUFLO", first
? "" : "|"), first
= FALSE
;
13854 if (mask
& OEX_FPU_OFLO
)
13855 printf ("%sOFLO", first
? "" : "|"), first
= FALSE
;
13856 if (mask
& OEX_FPU_DIV0
)
13857 printf ("%sDIV0", first
? "" : "|"), first
= FALSE
;
13858 if (mask
& OEX_FPU_INVAL
)
13859 printf ("%sINVAL", first
? "" : "|");
13862 fputs ("0", stdout
);
13865 /* Display's the value of TAG at location P. If TAG is
13866 greater than 0 it is assumed to be an unknown tag, and
13867 a message is printed to this effect. Otherwise it is
13868 assumed that a message has already been printed.
13870 If the bottom bit of TAG is set it assumed to have a
13871 string value, otherwise it is assumed to have an integer
13874 Returns an updated P pointing to the first unread byte
13875 beyond the end of TAG's value.
13877 Reads at or beyond END will not be made. */
13879 static unsigned char *
13880 display_tag_value (signed int tag
,
13882 const unsigned char * const end
)
13887 printf (" Tag_unknown_%d: ", tag
);
13891 warn (_("<corrupt tag>\n"));
13895 /* PR 17531 file: 027-19978-0.004. */
13896 size_t maxlen
= (end
- p
) - 1;
13901 print_symbol ((int) maxlen
, (const char *) p
);
13902 p
+= strnlen ((char *) p
, maxlen
) + 1;
13906 printf (_("<corrupt string tag>"));
13907 p
= (unsigned char *) end
;
13915 val
= read_uleb128 (p
, &len
, end
);
13917 printf ("%ld (0x%lx)\n", val
, val
);
13924 /* ARC ABI attributes section. */
13926 static unsigned char *
13927 display_arc_attribute (unsigned char * p
,
13928 const unsigned char * const end
)
13934 tag
= read_uleb128 (p
, &len
, end
);
13939 case Tag_ARC_PCS_config
:
13940 val
= read_uleb128 (p
, &len
, end
);
13942 printf (" Tag_ARC_PCS_config: ");
13946 printf (_("Absent/Non standard\n"));
13949 printf (_("Bare metal/mwdt\n"));
13952 printf (_("Bare metal/newlib\n"));
13955 printf (_("Linux/uclibc\n"));
13958 printf (_("Linux/glibc\n"));
13961 printf (_("Unknown\n"));
13966 case Tag_ARC_CPU_base
:
13967 val
= read_uleb128 (p
, &len
, end
);
13969 printf (" Tag_ARC_CPU_base: ");
13974 printf (_("Absent\n"));
13976 case TAG_CPU_ARC6xx
:
13977 printf ("ARC6xx\n");
13979 case TAG_CPU_ARC7xx
:
13980 printf ("ARC7xx\n");
13982 case TAG_CPU_ARCEM
:
13983 printf ("ARCEM\n");
13985 case TAG_CPU_ARCHS
:
13986 printf ("ARCHS\n");
13991 case Tag_ARC_CPU_variation
:
13992 val
= read_uleb128 (p
, &len
, end
);
13994 printf (" Tag_ARC_CPU_variation: ");
13998 if (val
> 0 && val
< 16)
13999 printf ("Core%d\n", val
);
14001 printf ("Unknown\n");
14005 printf (_("Absent\n"));
14010 case Tag_ARC_CPU_name
:
14011 printf (" Tag_ARC_CPU_name: ");
14012 p
= display_tag_value (-1, p
, end
);
14015 case Tag_ARC_ABI_rf16
:
14016 val
= read_uleb128 (p
, &len
, end
);
14018 printf (" Tag_ARC_ABI_rf16: %s\n", val
? _("yes") : _("no"));
14021 case Tag_ARC_ABI_osver
:
14022 val
= read_uleb128 (p
, &len
, end
);
14024 printf (" Tag_ARC_ABI_osver: v%d\n", val
);
14027 case Tag_ARC_ABI_pic
:
14028 case Tag_ARC_ABI_sda
:
14029 val
= read_uleb128 (p
, &len
, end
);
14031 printf (tag
== Tag_ARC_ABI_sda
? " Tag_ARC_ABI_sda: "
14032 : " Tag_ARC_ABI_pic: ");
14036 printf (_("Absent\n"));
14045 printf (_("Unknown\n"));
14050 case Tag_ARC_ABI_tls
:
14051 val
= read_uleb128 (p
, &len
, end
);
14053 printf (" Tag_ARC_ABI_tls: %s\n", val
? "r25": "none");
14056 case Tag_ARC_ABI_enumsize
:
14057 val
= read_uleb128 (p
, &len
, end
);
14059 printf (" Tag_ARC_ABI_enumsize: %s\n", val
? _("default") :
14063 case Tag_ARC_ABI_exceptions
:
14064 val
= read_uleb128 (p
, &len
, end
);
14066 printf (" Tag_ARC_ABI_exceptions: %s\n", val
? _("OPTFP")
14070 case Tag_ARC_ABI_double_size
:
14071 val
= read_uleb128 (p
, &len
, end
);
14073 printf (" Tag_ARC_ABI_double_size: %d\n", val
);
14076 case Tag_ARC_ISA_config
:
14077 printf (" Tag_ARC_ISA_config: ");
14078 p
= display_tag_value (-1, p
, end
);
14081 case Tag_ARC_ISA_apex
:
14082 printf (" Tag_ARC_ISA_apex: ");
14083 p
= display_tag_value (-1, p
, end
);
14086 case Tag_ARC_ISA_mpy_option
:
14087 val
= read_uleb128 (p
, &len
, end
);
14089 printf (" Tag_ARC_ISA_mpy_option: %d\n", val
);
14093 return display_tag_value (tag
& 1, p
, end
);
14099 /* ARM EABI attributes section. */
14104 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
14106 const char ** table
;
14107 } arm_attr_public_tag
;
14109 static const char * arm_attr_tag_CPU_arch
[] =
14110 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
14111 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
14113 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
14114 static const char * arm_attr_tag_THUMB_ISA_use
[] =
14115 {"No", "Thumb-1", "Thumb-2", "Yes"};
14116 static const char * arm_attr_tag_FP_arch
[] =
14117 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
14118 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
14119 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
14120 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
14121 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
14122 "NEON for ARMv8.1"};
14123 static const char * arm_attr_tag_PCS_config
[] =
14124 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
14125 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
14126 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
14127 {"V6", "SB", "TLS", "Unused"};
14128 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
14129 {"Absolute", "PC-relative", "SB-relative", "None"};
14130 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
14131 {"Absolute", "PC-relative", "None"};
14132 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
14133 {"None", "direct", "GOT-indirect"};
14134 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
14135 {"None", "??? 1", "2", "??? 3", "4"};
14136 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
14137 static const char * arm_attr_tag_ABI_FP_denormal
[] =
14138 {"Unused", "Needed", "Sign only"};
14139 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
14140 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
14141 static const char * arm_attr_tag_ABI_FP_number_model
[] =
14142 {"Unused", "Finite", "RTABI", "IEEE 754"};
14143 static const char * arm_attr_tag_ABI_enum_size
[] =
14144 {"Unused", "small", "int", "forced to int"};
14145 static const char * arm_attr_tag_ABI_HardFP_use
[] =
14146 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
14147 static const char * arm_attr_tag_ABI_VFP_args
[] =
14148 {"AAPCS", "VFP registers", "custom", "compatible"};
14149 static const char * arm_attr_tag_ABI_WMMX_args
[] =
14150 {"AAPCS", "WMMX registers", "custom"};
14151 static const char * arm_attr_tag_ABI_optimization_goals
[] =
14152 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14153 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
14154 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
14155 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14156 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
14157 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
14158 static const char * arm_attr_tag_FP_HP_extension
[] =
14159 {"Not Allowed", "Allowed"};
14160 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
14161 {"None", "IEEE 754", "Alternative Format"};
14162 static const char * arm_attr_tag_DSP_extension
[] =
14163 {"Follow architecture", "Allowed"};
14164 static const char * arm_attr_tag_MPextension_use
[] =
14165 {"Not Allowed", "Allowed"};
14166 static const char * arm_attr_tag_DIV_use
[] =
14167 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
14168 "Allowed in v7-A with integer division extension"};
14169 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
14170 static const char * arm_attr_tag_Virtualization_use
[] =
14171 {"Not Allowed", "TrustZone", "Virtualization Extensions",
14172 "TrustZone and Virtualization Extensions"};
14173 static const char * arm_attr_tag_MPextension_use_legacy
[] =
14174 {"Not Allowed", "Allowed"};
14176 #define LOOKUP(id, name) \
14177 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
14178 static arm_attr_public_tag arm_attr_public_tags
[] =
14180 {4, "CPU_raw_name", 1, NULL
},
14181 {5, "CPU_name", 1, NULL
},
14182 LOOKUP(6, CPU_arch
),
14183 {7, "CPU_arch_profile", 0, NULL
},
14184 LOOKUP(8, ARM_ISA_use
),
14185 LOOKUP(9, THUMB_ISA_use
),
14186 LOOKUP(10, FP_arch
),
14187 LOOKUP(11, WMMX_arch
),
14188 LOOKUP(12, Advanced_SIMD_arch
),
14189 LOOKUP(13, PCS_config
),
14190 LOOKUP(14, ABI_PCS_R9_use
),
14191 LOOKUP(15, ABI_PCS_RW_data
),
14192 LOOKUP(16, ABI_PCS_RO_data
),
14193 LOOKUP(17, ABI_PCS_GOT_use
),
14194 LOOKUP(18, ABI_PCS_wchar_t
),
14195 LOOKUP(19, ABI_FP_rounding
),
14196 LOOKUP(20, ABI_FP_denormal
),
14197 LOOKUP(21, ABI_FP_exceptions
),
14198 LOOKUP(22, ABI_FP_user_exceptions
),
14199 LOOKUP(23, ABI_FP_number_model
),
14200 {24, "ABI_align_needed", 0, NULL
},
14201 {25, "ABI_align_preserved", 0, NULL
},
14202 LOOKUP(26, ABI_enum_size
),
14203 LOOKUP(27, ABI_HardFP_use
),
14204 LOOKUP(28, ABI_VFP_args
),
14205 LOOKUP(29, ABI_WMMX_args
),
14206 LOOKUP(30, ABI_optimization_goals
),
14207 LOOKUP(31, ABI_FP_optimization_goals
),
14208 {32, "compatibility", 0, NULL
},
14209 LOOKUP(34, CPU_unaligned_access
),
14210 LOOKUP(36, FP_HP_extension
),
14211 LOOKUP(38, ABI_FP_16bit_format
),
14212 LOOKUP(42, MPextension_use
),
14213 LOOKUP(44, DIV_use
),
14214 LOOKUP(46, DSP_extension
),
14215 {64, "nodefaults", 0, NULL
},
14216 {65, "also_compatible_with", 0, NULL
},
14217 LOOKUP(66, T2EE_use
),
14218 {67, "conformance", 1, NULL
},
14219 LOOKUP(68, Virtualization_use
),
14220 LOOKUP(70, MPextension_use_legacy
)
14224 static unsigned char *
14225 display_arm_attribute (unsigned char * p
,
14226 const unsigned char * const end
)
14231 arm_attr_public_tag
* attr
;
14235 tag
= read_uleb128 (p
, &len
, end
);
14238 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
14240 if (arm_attr_public_tags
[i
].tag
== tag
)
14242 attr
= &arm_attr_public_tags
[i
];
14249 printf (" Tag_%s: ", attr
->name
);
14250 switch (attr
->type
)
14255 case 7: /* Tag_CPU_arch_profile. */
14256 val
= read_uleb128 (p
, &len
, end
);
14260 case 0: printf (_("None\n")); break;
14261 case 'A': printf (_("Application\n")); break;
14262 case 'R': printf (_("Realtime\n")); break;
14263 case 'M': printf (_("Microcontroller\n")); break;
14264 case 'S': printf (_("Application or Realtime\n")); break;
14265 default: printf ("??? (%d)\n", val
); break;
14269 case 24: /* Tag_align_needed. */
14270 val
= read_uleb128 (p
, &len
, end
);
14274 case 0: printf (_("None\n")); break;
14275 case 1: printf (_("8-byte\n")); break;
14276 case 2: printf (_("4-byte\n")); break;
14277 case 3: printf ("??? 3\n"); break;
14280 printf (_("8-byte and up to %d-byte extended\n"),
14283 printf ("??? (%d)\n", val
);
14288 case 25: /* Tag_align_preserved. */
14289 val
= read_uleb128 (p
, &len
, end
);
14293 case 0: printf (_("None\n")); break;
14294 case 1: printf (_("8-byte, except leaf SP\n")); break;
14295 case 2: printf (_("8-byte\n")); break;
14296 case 3: printf ("??? 3\n"); break;
14299 printf (_("8-byte and up to %d-byte extended\n"),
14302 printf ("??? (%d)\n", val
);
14307 case 32: /* Tag_compatibility. */
14309 val
= read_uleb128 (p
, &len
, end
);
14311 printf (_("flag = %d, vendor = "), val
);
14314 size_t maxlen
= (end
- p
) - 1;
14316 print_symbol ((int) maxlen
, (const char *) p
);
14317 p
+= strnlen ((char *) p
, maxlen
) + 1;
14321 printf (_("<corrupt>"));
14322 p
= (unsigned char *) end
;
14328 case 64: /* Tag_nodefaults. */
14329 /* PR 17531: file: 001-505008-0.01. */
14332 printf (_("True\n"));
14335 case 65: /* Tag_also_compatible_with. */
14336 val
= read_uleb128 (p
, &len
, end
);
14338 if (val
== 6 /* Tag_CPU_arch. */)
14340 val
= read_uleb128 (p
, &len
, end
);
14342 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
14343 printf ("??? (%d)\n", val
);
14345 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
14349 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
14354 printf (_("<unknown: %d>\n"), tag
);
14360 return display_tag_value (-1, p
, end
);
14362 return display_tag_value (0, p
, end
);
14365 assert (attr
->type
& 0x80);
14366 val
= read_uleb128 (p
, &len
, end
);
14368 type
= attr
->type
& 0x7f;
14370 printf ("??? (%d)\n", val
);
14372 printf ("%s\n", attr
->table
[val
]);
14377 return display_tag_value (tag
, p
, end
);
14380 static unsigned char *
14381 display_gnu_attribute (unsigned char * p
,
14382 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const),
14383 const unsigned char * const end
)
14389 tag
= read_uleb128 (p
, &len
, end
);
14392 /* Tag_compatibility is the only generic GNU attribute defined at
14396 val
= read_uleb128 (p
, &len
, end
);
14399 printf (_("flag = %d, vendor = "), val
);
14402 printf (_("<corrupt>\n"));
14403 warn (_("corrupt vendor attribute\n"));
14409 size_t maxlen
= (end
- p
) - 1;
14411 print_symbol ((int) maxlen
, (const char *) p
);
14412 p
+= strnlen ((char *) p
, maxlen
) + 1;
14416 printf (_("<corrupt>"));
14417 p
= (unsigned char *) end
;
14424 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
14425 return display_proc_gnu_attribute (p
, tag
, end
);
14427 return display_tag_value (tag
, p
, end
);
14430 static unsigned char *
14431 display_power_gnu_attribute (unsigned char * p
,
14433 const unsigned char * const end
)
14438 if (tag
== Tag_GNU_Power_ABI_FP
)
14440 val
= read_uleb128 (p
, &len
, end
);
14442 printf (" Tag_GNU_Power_ABI_FP: ");
14445 printf (_("<corrupt>\n"));
14450 printf ("(%#x), ", val
);
14455 printf (_("unspecified hard/soft float, "));
14458 printf (_("hard float, "));
14461 printf (_("soft float, "));
14464 printf (_("single-precision hard float, "));
14471 printf (_("unspecified long double\n"));
14474 printf (_("128-bit IBM long double\n"));
14477 printf (_("64-bit long double\n"));
14480 printf (_("128-bit IEEE long double\n"));
14486 if (tag
== Tag_GNU_Power_ABI_Vector
)
14488 val
= read_uleb128 (p
, &len
, end
);
14490 printf (" Tag_GNU_Power_ABI_Vector: ");
14493 printf (_("<corrupt>\n"));
14498 printf ("(%#x), ", val
);
14503 printf (_("unspecified\n"));
14506 printf (_("generic\n"));
14509 printf ("AltiVec\n");
14518 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
14520 val
= read_uleb128 (p
, &len
, end
);
14522 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
14525 printf (_("<corrupt>\n"));
14530 printf ("(%#x), ", val
);
14535 printf (_("unspecified\n"));
14538 printf ("r3/r4\n");
14541 printf (_("memory\n"));
14550 return display_tag_value (tag
& 1, p
, end
);
14553 static unsigned char *
14554 display_s390_gnu_attribute (unsigned char * p
,
14556 const unsigned char * const end
)
14561 if (tag
== Tag_GNU_S390_ABI_Vector
)
14563 val
= read_uleb128 (p
, &len
, end
);
14565 printf (" Tag_GNU_S390_ABI_Vector: ");
14570 printf (_("any\n"));
14573 printf (_("software\n"));
14576 printf (_("hardware\n"));
14579 printf ("??? (%d)\n", val
);
14585 return display_tag_value (tag
& 1, p
, end
);
14589 display_sparc_hwcaps (unsigned int mask
)
14593 bfd_boolean first
= TRUE
;
14595 if (mask
& ELF_SPARC_HWCAP_MUL32
)
14596 fputs ("mul32", stdout
), first
= FALSE
;
14597 if (mask
& ELF_SPARC_HWCAP_DIV32
)
14598 printf ("%sdiv32", first
? "" : "|"), first
= FALSE
;
14599 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
14600 printf ("%sfsmuld", first
? "" : "|"), first
= FALSE
;
14601 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
14602 printf ("%sv8plus", first
? "" : "|"), first
= FALSE
;
14603 if (mask
& ELF_SPARC_HWCAP_POPC
)
14604 printf ("%spopc", first
? "" : "|"), first
= FALSE
;
14605 if (mask
& ELF_SPARC_HWCAP_VIS
)
14606 printf ("%svis", first
? "" : "|"), first
= FALSE
;
14607 if (mask
& ELF_SPARC_HWCAP_VIS2
)
14608 printf ("%svis2", first
? "" : "|"), first
= FALSE
;
14609 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
14610 printf ("%sASIBlkInit", first
? "" : "|"), first
= FALSE
;
14611 if (mask
& ELF_SPARC_HWCAP_FMAF
)
14612 printf ("%sfmaf", first
? "" : "|"), first
= FALSE
;
14613 if (mask
& ELF_SPARC_HWCAP_VIS3
)
14614 printf ("%svis3", first
? "" : "|"), first
= FALSE
;
14615 if (mask
& ELF_SPARC_HWCAP_HPC
)
14616 printf ("%shpc", first
? "" : "|"), first
= FALSE
;
14617 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
14618 printf ("%srandom", first
? "" : "|"), first
= FALSE
;
14619 if (mask
& ELF_SPARC_HWCAP_TRANS
)
14620 printf ("%strans", first
? "" : "|"), first
= FALSE
;
14621 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
14622 printf ("%sfjfmau", first
? "" : "|"), first
= FALSE
;
14623 if (mask
& ELF_SPARC_HWCAP_IMA
)
14624 printf ("%sima", first
? "" : "|"), first
= FALSE
;
14625 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
14626 printf ("%scspare", first
? "" : "|"), first
= FALSE
;
14629 fputc ('0', stdout
);
14630 fputc ('\n', stdout
);
14634 display_sparc_hwcaps2 (unsigned int mask
)
14638 bfd_boolean first
= TRUE
;
14640 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
14641 fputs ("fjathplus", stdout
), first
= FALSE
;
14642 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
14643 printf ("%svis3b", first
? "" : "|"), first
= FALSE
;
14644 if (mask
& ELF_SPARC_HWCAP2_ADP
)
14645 printf ("%sadp", first
? "" : "|"), first
= FALSE
;
14646 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
14647 printf ("%ssparc5", first
? "" : "|"), first
= FALSE
;
14648 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
14649 printf ("%smwait", first
? "" : "|"), first
= FALSE
;
14650 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
14651 printf ("%sxmpmul", first
? "" : "|"), first
= FALSE
;
14652 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
14653 printf ("%sxmont2", first
? "" : "|"), first
= FALSE
;
14654 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
14655 printf ("%snsec", first
? "" : "|"), first
= FALSE
;
14656 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
14657 printf ("%sfjathhpc", first
? "" : "|"), first
= FALSE
;
14658 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
14659 printf ("%sfjdes", first
? "" : "|"), first
= FALSE
;
14660 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
14661 printf ("%sfjaes", first
? "" : "|"), first
= FALSE
;
14664 fputc ('0', stdout
);
14665 fputc ('\n', stdout
);
14668 static unsigned char *
14669 display_sparc_gnu_attribute (unsigned char * p
,
14671 const unsigned char * const end
)
14676 if (tag
== Tag_GNU_Sparc_HWCAPS
)
14678 val
= read_uleb128 (p
, &len
, end
);
14680 printf (" Tag_GNU_Sparc_HWCAPS: ");
14681 display_sparc_hwcaps (val
);
14684 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
14686 val
= read_uleb128 (p
, &len
, end
);
14688 printf (" Tag_GNU_Sparc_HWCAPS2: ");
14689 display_sparc_hwcaps2 (val
);
14693 return display_tag_value (tag
, p
, end
);
14697 print_mips_fp_abi_value (unsigned int val
)
14701 case Val_GNU_MIPS_ABI_FP_ANY
:
14702 printf (_("Hard or soft float\n"));
14704 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
14705 printf (_("Hard float (double precision)\n"));
14707 case Val_GNU_MIPS_ABI_FP_SINGLE
:
14708 printf (_("Hard float (single precision)\n"));
14710 case Val_GNU_MIPS_ABI_FP_SOFT
:
14711 printf (_("Soft float\n"));
14713 case Val_GNU_MIPS_ABI_FP_OLD_64
:
14714 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
14716 case Val_GNU_MIPS_ABI_FP_XX
:
14717 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
14719 case Val_GNU_MIPS_ABI_FP_64
:
14720 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
14722 case Val_GNU_MIPS_ABI_FP_64A
:
14723 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
14725 case Val_GNU_MIPS_ABI_FP_NAN2008
:
14726 printf (_("NaN 2008 compatibility\n"));
14729 printf ("??? (%d)\n", val
);
14734 static unsigned char *
14735 display_mips_gnu_attribute (unsigned char * p
,
14737 const unsigned char * const end
)
14739 if (tag
== Tag_GNU_MIPS_ABI_FP
)
14744 val
= read_uleb128 (p
, &len
, end
);
14746 printf (" Tag_GNU_MIPS_ABI_FP: ");
14748 print_mips_fp_abi_value (val
);
14753 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
14758 val
= read_uleb128 (p
, &len
, end
);
14760 printf (" Tag_GNU_MIPS_ABI_MSA: ");
14764 case Val_GNU_MIPS_ABI_MSA_ANY
:
14765 printf (_("Any MSA or not\n"));
14767 case Val_GNU_MIPS_ABI_MSA_128
:
14768 printf (_("128-bit MSA\n"));
14771 printf ("??? (%d)\n", val
);
14777 return display_tag_value (tag
& 1, p
, end
);
14780 static unsigned char *
14781 display_tic6x_attribute (unsigned char * p
,
14782 const unsigned char * const end
)
14788 tag
= read_uleb128 (p
, &len
, end
);
14794 val
= read_uleb128 (p
, &len
, end
);
14796 printf (" Tag_ISA: ");
14800 case C6XABI_Tag_ISA_none
:
14801 printf (_("None\n"));
14803 case C6XABI_Tag_ISA_C62X
:
14806 case C6XABI_Tag_ISA_C67X
:
14809 case C6XABI_Tag_ISA_C67XP
:
14810 printf ("C67x+\n");
14812 case C6XABI_Tag_ISA_C64X
:
14815 case C6XABI_Tag_ISA_C64XP
:
14816 printf ("C64x+\n");
14818 case C6XABI_Tag_ISA_C674X
:
14819 printf ("C674x\n");
14822 printf ("??? (%d)\n", val
);
14827 case Tag_ABI_wchar_t
:
14828 val
= read_uleb128 (p
, &len
, end
);
14830 printf (" Tag_ABI_wchar_t: ");
14834 printf (_("Not used\n"));
14837 printf (_("2 bytes\n"));
14840 printf (_("4 bytes\n"));
14843 printf ("??? (%d)\n", val
);
14848 case Tag_ABI_stack_align_needed
:
14849 val
= read_uleb128 (p
, &len
, end
);
14851 printf (" Tag_ABI_stack_align_needed: ");
14855 printf (_("8-byte\n"));
14858 printf (_("16-byte\n"));
14861 printf ("??? (%d)\n", val
);
14866 case Tag_ABI_stack_align_preserved
:
14867 val
= read_uleb128 (p
, &len
, end
);
14869 printf (" Tag_ABI_stack_align_preserved: ");
14873 printf (_("8-byte\n"));
14876 printf (_("16-byte\n"));
14879 printf ("??? (%d)\n", val
);
14885 val
= read_uleb128 (p
, &len
, end
);
14887 printf (" Tag_ABI_DSBT: ");
14891 printf (_("DSBT addressing not used\n"));
14894 printf (_("DSBT addressing used\n"));
14897 printf ("??? (%d)\n", val
);
14903 val
= read_uleb128 (p
, &len
, end
);
14905 printf (" Tag_ABI_PID: ");
14909 printf (_("Data addressing position-dependent\n"));
14912 printf (_("Data addressing position-independent, GOT near DP\n"));
14915 printf (_("Data addressing position-independent, GOT far from DP\n"));
14918 printf ("??? (%d)\n", val
);
14924 val
= read_uleb128 (p
, &len
, end
);
14926 printf (" Tag_ABI_PIC: ");
14930 printf (_("Code addressing position-dependent\n"));
14933 printf (_("Code addressing position-independent\n"));
14936 printf ("??? (%d)\n", val
);
14941 case Tag_ABI_array_object_alignment
:
14942 val
= read_uleb128 (p
, &len
, end
);
14944 printf (" Tag_ABI_array_object_alignment: ");
14948 printf (_("8-byte\n"));
14951 printf (_("4-byte\n"));
14954 printf (_("16-byte\n"));
14957 printf ("??? (%d)\n", val
);
14962 case Tag_ABI_array_object_align_expected
:
14963 val
= read_uleb128 (p
, &len
, end
);
14965 printf (" Tag_ABI_array_object_align_expected: ");
14969 printf (_("8-byte\n"));
14972 printf (_("4-byte\n"));
14975 printf (_("16-byte\n"));
14978 printf ("??? (%d)\n", val
);
14983 case Tag_ABI_compatibility
:
14985 val
= read_uleb128 (p
, &len
, end
);
14987 printf (" Tag_ABI_compatibility: ");
14988 printf (_("flag = %d, vendor = "), val
);
14991 size_t maxlen
= (end
- p
) - 1;
14993 print_symbol ((int) maxlen
, (const char *) p
);
14994 p
+= strnlen ((char *) p
, maxlen
) + 1;
14998 printf (_("<corrupt>"));
14999 p
= (unsigned char *) end
;
15005 case Tag_ABI_conformance
:
15007 printf (" Tag_ABI_conformance: \"");
15010 size_t maxlen
= (end
- p
) - 1;
15012 print_symbol ((int) maxlen
, (const char *) p
);
15013 p
+= strnlen ((char *) p
, maxlen
) + 1;
15017 printf (_("<corrupt>"));
15018 p
= (unsigned char *) end
;
15025 return display_tag_value (tag
, p
, end
);
15029 display_raw_attribute (unsigned char * p
, unsigned char const * const end
)
15031 unsigned long addr
= 0;
15032 size_t bytes
= end
- p
;
15039 int lbytes
= (bytes
> 16 ? 16 : bytes
);
15041 printf (" 0x%8.8lx ", addr
);
15043 for (j
= 0; j
< 16; j
++)
15046 printf ("%2.2x", p
[j
]);
15054 for (j
= 0; j
< lbytes
; j
++)
15057 if (k
>= ' ' && k
< 0x7f)
15073 static unsigned char *
15074 display_msp430x_attribute (unsigned char * p
,
15075 const unsigned char * const end
)
15081 tag
= read_uleb128 (p
, & len
, end
);
15086 case OFBA_MSPABI_Tag_ISA
:
15087 val
= read_uleb128 (p
, &len
, end
);
15089 printf (" Tag_ISA: ");
15092 case 0: printf (_("None\n")); break;
15093 case 1: printf (_("MSP430\n")); break;
15094 case 2: printf (_("MSP430X\n")); break;
15095 default: printf ("??? (%d)\n", val
); break;
15099 case OFBA_MSPABI_Tag_Code_Model
:
15100 val
= read_uleb128 (p
, &len
, end
);
15102 printf (" Tag_Code_Model: ");
15105 case 0: printf (_("None\n")); break;
15106 case 1: printf (_("Small\n")); break;
15107 case 2: printf (_("Large\n")); break;
15108 default: printf ("??? (%d)\n", val
); break;
15112 case OFBA_MSPABI_Tag_Data_Model
:
15113 val
= read_uleb128 (p
, &len
, end
);
15115 printf (" Tag_Data_Model: ");
15118 case 0: printf (_("None\n")); break;
15119 case 1: printf (_("Small\n")); break;
15120 case 2: printf (_("Large\n")); break;
15121 case 3: printf (_("Restricted Large\n")); break;
15122 default: printf ("??? (%d)\n", val
); break;
15127 printf (_(" <unknown tag %d>: "), tag
);
15134 size_t maxlen
= (end
- p
) - 1;
15136 print_symbol ((int) maxlen
, (const char *) p
);
15137 p
+= strnlen ((char *) p
, maxlen
) + 1;
15141 printf (_("<corrupt>"));
15142 p
= (unsigned char *) end
;
15148 val
= read_uleb128 (p
, &len
, end
);
15150 printf ("%d (0x%x)\n", val
, val
);
15160 process_attributes (Filedata
* filedata
,
15161 const char * public_name
,
15162 unsigned int proc_type
,
15163 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
15164 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const))
15166 Elf_Internal_Shdr
* sect
;
15168 bfd_boolean res
= TRUE
;
15170 /* Find the section header so that we get the size. */
15171 for (i
= 0, sect
= filedata
->section_headers
;
15172 i
< filedata
->file_header
.e_shnum
;
15175 unsigned char * contents
;
15178 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
15181 contents
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
, 1,
15182 sect
->sh_size
, _("attributes"));
15183 if (contents
== NULL
)
15190 /* The first character is the version of the attributes.
15191 Currently only version 1, (aka 'A') is recognised here. */
15194 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p
, *p
);
15199 bfd_vma section_len
;
15201 section_len
= sect
->sh_size
- 1;
15204 while (section_len
> 0)
15207 unsigned int namelen
;
15208 bfd_boolean public_section
;
15209 bfd_boolean gnu_section
;
15211 if (section_len
<= 4)
15213 error (_("Tag section ends prematurely\n"));
15217 attr_len
= byte_get (p
, 4);
15220 if (attr_len
> section_len
)
15222 error (_("Bad attribute length (%u > %u)\n"),
15223 (unsigned) attr_len
, (unsigned) section_len
);
15224 attr_len
= section_len
;
15227 /* PR 17531: file: 001-101425-0.004 */
15228 else if (attr_len
< 5)
15230 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
15235 section_len
-= attr_len
;
15238 namelen
= strnlen ((char *) p
, attr_len
) + 1;
15239 if (namelen
== 0 || namelen
>= attr_len
)
15241 error (_("Corrupt attribute section name\n"));
15246 printf (_("Attribute Section: "));
15247 print_symbol (INT_MAX
, (const char *) p
);
15250 if (public_name
&& streq ((char *) p
, public_name
))
15251 public_section
= TRUE
;
15253 public_section
= FALSE
;
15255 if (streq ((char *) p
, "gnu"))
15256 gnu_section
= TRUE
;
15258 gnu_section
= FALSE
;
15261 attr_len
-= namelen
;
15263 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
15268 unsigned char * end
;
15270 /* PR binutils/17531: Safe handling of corrupt files. */
15273 error (_("Unused bytes at end of section\n"));
15280 size
= byte_get (p
, 4);
15281 if (size
> attr_len
)
15283 error (_("Bad subsection length (%u > %u)\n"),
15284 (unsigned) size
, (unsigned) attr_len
);
15288 /* PR binutils/17531: Safe handling of corrupt files. */
15291 error (_("Bad subsection length (%u < 6)\n"),
15299 end
= p
+ size
- 1;
15300 assert (end
<= contents
+ sect
->sh_size
);
15306 printf (_("File Attributes\n"));
15309 printf (_("Section Attributes:"));
15312 printf (_("Symbol Attributes:"));
15313 /* Fall through. */
15319 val
= read_uleb128 (p
, &j
, end
);
15323 printf (" %d", val
);
15328 printf (_("Unknown tag: %d\n"), tag
);
15329 public_section
= FALSE
;
15333 if (public_section
&& display_pub_attribute
!= NULL
)
15336 p
= display_pub_attribute (p
, end
);
15339 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
15342 p
= display_gnu_attribute (p
,
15343 display_proc_gnu_attribute
,
15349 printf (_(" Unknown attribute:\n"));
15350 display_raw_attribute (p
, end
);
15365 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
15366 Print the Address, Access and Initial fields of an entry at VMA ADDR
15367 and return the VMA of the next entry, or -1 if there was a problem.
15368 Does not read from DATA_END or beyond. */
15371 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
15372 unsigned char * data_end
)
15375 print_vma (addr
, LONG_HEX
);
15377 if (addr
< pltgot
+ 0xfff0)
15378 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
15380 printf ("%10s", "");
15383 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
15387 unsigned char * from
= data
+ addr
- pltgot
;
15389 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
15391 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
15392 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
15393 return (bfd_vma
) -1;
15397 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
15398 print_vma (entry
, LONG_HEX
);
15401 return addr
+ (is_32bit_elf
? 4 : 8);
15404 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
15405 PLTGOT. Print the Address and Initial fields of an entry at VMA
15406 ADDR and return the VMA of the next entry. */
15409 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
15412 print_vma (addr
, LONG_HEX
);
15415 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
15420 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
15421 print_vma (entry
, LONG_HEX
);
15423 return addr
+ (is_32bit_elf
? 4 : 8);
15427 print_mips_ases (unsigned int mask
)
15429 if (mask
& AFL_ASE_DSP
)
15430 fputs ("\n\tDSP ASE", stdout
);
15431 if (mask
& AFL_ASE_DSPR2
)
15432 fputs ("\n\tDSP R2 ASE", stdout
);
15433 if (mask
& AFL_ASE_DSPR3
)
15434 fputs ("\n\tDSP R3 ASE", stdout
);
15435 if (mask
& AFL_ASE_EVA
)
15436 fputs ("\n\tEnhanced VA Scheme", stdout
);
15437 if (mask
& AFL_ASE_MCU
)
15438 fputs ("\n\tMCU (MicroController) ASE", stdout
);
15439 if (mask
& AFL_ASE_MDMX
)
15440 fputs ("\n\tMDMX ASE", stdout
);
15441 if (mask
& AFL_ASE_MIPS3D
)
15442 fputs ("\n\tMIPS-3D ASE", stdout
);
15443 if (mask
& AFL_ASE_MT
)
15444 fputs ("\n\tMT ASE", stdout
);
15445 if (mask
& AFL_ASE_SMARTMIPS
)
15446 fputs ("\n\tSmartMIPS ASE", stdout
);
15447 if (mask
& AFL_ASE_VIRT
)
15448 fputs ("\n\tVZ ASE", stdout
);
15449 if (mask
& AFL_ASE_MSA
)
15450 fputs ("\n\tMSA ASE", stdout
);
15451 if (mask
& AFL_ASE_MIPS16
)
15452 fputs ("\n\tMIPS16 ASE", stdout
);
15453 if (mask
& AFL_ASE_MICROMIPS
)
15454 fputs ("\n\tMICROMIPS ASE", stdout
);
15455 if (mask
& AFL_ASE_XPA
)
15456 fputs ("\n\tXPA ASE", stdout
);
15457 if (mask
& AFL_ASE_MIPS16E2
)
15458 fputs ("\n\tMIPS16e2 ASE", stdout
);
15460 fprintf (stdout
, "\n\t%s", _("None"));
15461 else if ((mask
& ~AFL_ASE_MASK
) != 0)
15462 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
15466 print_mips_isa_ext (unsigned int isa_ext
)
15471 fputs (_("None"), stdout
);
15474 fputs ("RMI XLR", stdout
);
15476 case AFL_EXT_OCTEON3
:
15477 fputs ("Cavium Networks Octeon3", stdout
);
15479 case AFL_EXT_OCTEON2
:
15480 fputs ("Cavium Networks Octeon2", stdout
);
15482 case AFL_EXT_OCTEONP
:
15483 fputs ("Cavium Networks OcteonP", stdout
);
15485 case AFL_EXT_LOONGSON_3A
:
15486 fputs ("Loongson 3A", stdout
);
15488 case AFL_EXT_OCTEON
:
15489 fputs ("Cavium Networks Octeon", stdout
);
15492 fputs ("Toshiba R5900", stdout
);
15495 fputs ("MIPS R4650", stdout
);
15498 fputs ("LSI R4010", stdout
);
15501 fputs ("NEC VR4100", stdout
);
15504 fputs ("Toshiba R3900", stdout
);
15506 case AFL_EXT_10000
:
15507 fputs ("MIPS R10000", stdout
);
15510 fputs ("Broadcom SB-1", stdout
);
15513 fputs ("NEC VR4111/VR4181", stdout
);
15516 fputs ("NEC VR4120", stdout
);
15519 fputs ("NEC VR5400", stdout
);
15522 fputs ("NEC VR5500", stdout
);
15524 case AFL_EXT_LOONGSON_2E
:
15525 fputs ("ST Microelectronics Loongson 2E", stdout
);
15527 case AFL_EXT_LOONGSON_2F
:
15528 fputs ("ST Microelectronics Loongson 2F", stdout
);
15530 case AFL_EXT_INTERAPTIV_MR2
:
15531 fputs ("Imagination interAptiv MR2", stdout
);
15534 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
15539 get_mips_reg_size (int reg_size
)
15541 return (reg_size
== AFL_REG_NONE
) ? 0
15542 : (reg_size
== AFL_REG_32
) ? 32
15543 : (reg_size
== AFL_REG_64
) ? 64
15544 : (reg_size
== AFL_REG_128
) ? 128
15549 process_mips_specific (Filedata
* filedata
)
15551 Elf_Internal_Dyn
* entry
;
15552 Elf_Internal_Shdr
*sect
= NULL
;
15553 size_t liblist_offset
= 0;
15554 size_t liblistno
= 0;
15555 size_t conflictsno
= 0;
15556 size_t options_offset
= 0;
15557 size_t conflicts_offset
= 0;
15558 size_t pltrelsz
= 0;
15560 bfd_vma pltgot
= 0;
15561 bfd_vma mips_pltgot
= 0;
15562 bfd_vma jmprel
= 0;
15563 bfd_vma local_gotno
= 0;
15564 bfd_vma gotsym
= 0;
15565 bfd_vma symtabno
= 0;
15566 bfd_boolean res
= TRUE
;
15568 if (! process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
15569 display_mips_gnu_attribute
))
15572 sect
= find_section (filedata
, ".MIPS.abiflags");
15576 Elf_External_ABIFlags_v0
*abiflags_ext
;
15577 Elf_Internal_ABIFlags_v0 abiflags_in
;
15579 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
15581 error (_("Corrupt MIPS ABI Flags section.\n"));
15586 abiflags_ext
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
15587 sect
->sh_size
, _("MIPS ABI Flags section"));
15590 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
15591 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
15592 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
15593 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
15594 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
15595 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
15596 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
15597 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
15598 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
15599 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
15600 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
15602 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
15603 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
15604 if (abiflags_in
.isa_rev
> 1)
15605 printf ("r%d", abiflags_in
.isa_rev
);
15606 printf ("\nGPR size: %d",
15607 get_mips_reg_size (abiflags_in
.gpr_size
));
15608 printf ("\nCPR1 size: %d",
15609 get_mips_reg_size (abiflags_in
.cpr1_size
));
15610 printf ("\nCPR2 size: %d",
15611 get_mips_reg_size (abiflags_in
.cpr2_size
));
15612 fputs ("\nFP ABI: ", stdout
);
15613 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
15614 fputs ("ISA Extension: ", stdout
);
15615 print_mips_isa_ext (abiflags_in
.isa_ext
);
15616 fputs ("\nASEs:", stdout
);
15617 print_mips_ases (abiflags_in
.ases
);
15618 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
15619 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
15620 fputc ('\n', stdout
);
15621 free (abiflags_ext
);
15626 /* We have a lot of special sections. Thanks SGI! */
15627 if (dynamic_section
== NULL
)
15629 /* No dynamic information available. See if there is static GOT. */
15630 sect
= find_section (filedata
, ".got");
15633 unsigned char *data_end
;
15634 unsigned char *data
;
15638 pltgot
= sect
->sh_addr
;
15641 addr_size
= (is_32bit_elf
? 4 : 8);
15642 end
= pltgot
+ sect
->sh_size
;
15644 data
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
,
15646 _("Global Offset Table data"));
15647 /* PR 12855: Null data is handled gracefully throughout. */
15648 data_end
= data
+ (end
- pltgot
);
15650 printf (_("\nStatic GOT:\n"));
15651 printf (_(" Canonical gp value: "));
15652 print_vma (ent
+ 0x7ff0, LONG_HEX
);
15655 /* In a dynamic binary GOT[0] is reserved for the dynamic
15656 loader to store the lazy resolver pointer, however in
15657 a static binary it may well have been omitted and GOT
15658 reduced to a table of addresses.
15659 PR 21344: Check for the entry being fully available
15660 before fetching it. */
15662 && data
+ ent
- pltgot
+ addr_size
<= data_end
15663 && byte_get (data
+ ent
- pltgot
, addr_size
) == 0)
15665 printf (_(" Reserved entries:\n"));
15666 printf (_(" %*s %10s %*s\n"),
15667 addr_size
* 2, _("Address"), _("Access"),
15668 addr_size
* 2, _("Value"));
15669 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15671 if (ent
== (bfd_vma
) -1)
15672 goto sgot_print_fail
;
15674 /* Check for the MSB of GOT[1] being set, identifying a
15675 GNU object. This entry will be used by some runtime
15676 loaders, to store the module pointer. Otherwise this
15677 is an ordinary local entry.
15678 PR 21344: Check for the entry being fully available
15679 before fetching it. */
15681 && data
+ ent
- pltgot
+ addr_size
<= data_end
15682 && (byte_get (data
+ ent
- pltgot
, addr_size
)
15683 >> (addr_size
* 8 - 1)) != 0)
15685 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15687 if (ent
== (bfd_vma
) -1)
15688 goto sgot_print_fail
;
15693 if (data
!= NULL
&& ent
< end
)
15695 printf (_(" Local entries:\n"));
15696 printf (" %*s %10s %*s\n",
15697 addr_size
* 2, _("Address"), _("Access"),
15698 addr_size
* 2, _("Value"));
15701 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15703 if (ent
== (bfd_vma
) -1)
15704 goto sgot_print_fail
;
15716 for (entry
= dynamic_section
;
15717 /* PR 17531 file: 012-50589-0.004. */
15718 entry
< dynamic_section
+ dynamic_nent
&& entry
->d_tag
!= DT_NULL
;
15720 switch (entry
->d_tag
)
15722 case DT_MIPS_LIBLIST
:
15724 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
15725 liblistno
* sizeof (Elf32_External_Lib
));
15727 case DT_MIPS_LIBLISTNO
:
15728 liblistno
= entry
->d_un
.d_val
;
15730 case DT_MIPS_OPTIONS
:
15731 options_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
15733 case DT_MIPS_CONFLICT
:
15735 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
15736 conflictsno
* sizeof (Elf32_External_Conflict
));
15738 case DT_MIPS_CONFLICTNO
:
15739 conflictsno
= entry
->d_un
.d_val
;
15742 pltgot
= entry
->d_un
.d_ptr
;
15744 case DT_MIPS_LOCAL_GOTNO
:
15745 local_gotno
= entry
->d_un
.d_val
;
15747 case DT_MIPS_GOTSYM
:
15748 gotsym
= entry
->d_un
.d_val
;
15750 case DT_MIPS_SYMTABNO
:
15751 symtabno
= entry
->d_un
.d_val
;
15753 case DT_MIPS_PLTGOT
:
15754 mips_pltgot
= entry
->d_un
.d_ptr
;
15757 pltrel
= entry
->d_un
.d_val
;
15760 pltrelsz
= entry
->d_un
.d_val
;
15763 jmprel
= entry
->d_un
.d_ptr
;
15769 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
15771 Elf32_External_Lib
* elib
;
15774 elib
= (Elf32_External_Lib
*) get_data (NULL
, filedata
, liblist_offset
,
15776 sizeof (Elf32_External_Lib
),
15777 _("liblist section data"));
15780 printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
15781 "\nSection '.liblist' contains %lu entries:\n",
15782 (unsigned long) liblistno
),
15783 (unsigned long) liblistno
);
15784 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
15787 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
15794 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
15795 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
15796 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
15797 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
15798 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
15800 tmp
= gmtime (&atime
);
15801 snprintf (timebuf
, sizeof (timebuf
),
15802 "%04u-%02u-%02uT%02u:%02u:%02u",
15803 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
15804 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
15806 printf ("%3lu: ", (unsigned long) cnt
);
15807 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
15808 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
15810 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
15811 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
15812 liblist
.l_version
);
15814 if (liblist
.l_flags
== 0)
15818 static const struct
15825 { " EXACT_MATCH", LL_EXACT_MATCH
},
15826 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
15827 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
15828 { " EXPORTS", LL_EXPORTS
},
15829 { " DELAY_LOAD", LL_DELAY_LOAD
},
15830 { " DELTA", LL_DELTA
}
15832 int flags
= liblist
.l_flags
;
15835 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
15836 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
15838 fputs (l_flags_vals
[fcnt
].name
, stdout
);
15839 flags
^= l_flags_vals
[fcnt
].bit
;
15842 printf (" %#x", (unsigned int) flags
);
15854 if (options_offset
!= 0)
15856 Elf_External_Options
* eopt
;
15857 Elf_Internal_Options
* iopt
;
15858 Elf_Internal_Options
* option
;
15861 sect
= filedata
->section_headers
;
15863 /* Find the section header so that we get the size. */
15864 sect
= find_section_by_type (filedata
, SHT_MIPS_OPTIONS
);
15865 /* PR 17533 file: 012-277276-0.004. */
15868 error (_("No MIPS_OPTIONS header found\n"));
15872 eopt
= (Elf_External_Options
*) get_data (NULL
, filedata
, options_offset
, 1,
15873 sect
->sh_size
, _("options"));
15876 iopt
= (Elf_Internal_Options
*)
15877 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
15880 error (_("Out of memory allocating space for MIPS options\n"));
15887 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
15889 Elf_External_Options
* eoption
;
15891 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
15893 option
->kind
= BYTE_GET (eoption
->kind
);
15894 option
->size
= BYTE_GET (eoption
->size
);
15895 option
->section
= BYTE_GET (eoption
->section
);
15896 option
->info
= BYTE_GET (eoption
->info
);
15898 /* PR 17531: file: ffa0fa3b. */
15899 if (option
->size
< sizeof (* eopt
)
15900 || offset
+ option
->size
> sect
->sh_size
)
15902 error (_("Invalid size (%u) for MIPS option\n"), option
->size
);
15905 offset
+= option
->size
;
15911 printf (ngettext ("\nSection '%s' contains %d entry:\n",
15912 "\nSection '%s' contains %d entries:\n",
15914 printable_section_name (filedata
, sect
), cnt
);
15923 switch (option
->kind
)
15926 /* This shouldn't happen. */
15927 printf (" NULL %d %lx", option
->section
, option
->info
);
15930 printf (" REGINFO ");
15931 if (filedata
->file_header
.e_machine
== EM_MIPS
)
15934 Elf32_External_RegInfo
* ereg
;
15935 Elf32_RegInfo reginfo
;
15937 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
15938 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
15939 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
15940 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
15941 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
15942 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
15943 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
15945 printf ("GPR %08lx GP 0x%lx\n",
15946 reginfo
.ri_gprmask
,
15947 (unsigned long) reginfo
.ri_gp_value
);
15948 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
15949 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
15950 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
15955 Elf64_External_RegInfo
* ereg
;
15956 Elf64_Internal_RegInfo reginfo
;
15958 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
15959 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
15960 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
15961 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
15962 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
15963 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
15964 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
15966 printf ("GPR %08lx GP 0x",
15967 reginfo
.ri_gprmask
);
15968 printf_vma (reginfo
.ri_gp_value
);
15971 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
15972 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
15973 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
15977 case ODK_EXCEPTIONS
:
15978 fputs (" EXCEPTIONS fpe_min(", stdout
);
15979 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
15980 fputs (") fpe_max(", stdout
);
15981 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
15982 fputs (")", stdout
);
15984 if (option
->info
& OEX_PAGE0
)
15985 fputs (" PAGE0", stdout
);
15986 if (option
->info
& OEX_SMM
)
15987 fputs (" SMM", stdout
);
15988 if (option
->info
& OEX_FPDBUG
)
15989 fputs (" FPDBUG", stdout
);
15990 if (option
->info
& OEX_DISMISS
)
15991 fputs (" DISMISS", stdout
);
15994 fputs (" PAD ", stdout
);
15995 if (option
->info
& OPAD_PREFIX
)
15996 fputs (" PREFIX", stdout
);
15997 if (option
->info
& OPAD_POSTFIX
)
15998 fputs (" POSTFIX", stdout
);
15999 if (option
->info
& OPAD_SYMBOL
)
16000 fputs (" SYMBOL", stdout
);
16003 fputs (" HWPATCH ", stdout
);
16004 if (option
->info
& OHW_R4KEOP
)
16005 fputs (" R4KEOP", stdout
);
16006 if (option
->info
& OHW_R8KPFETCH
)
16007 fputs (" R8KPFETCH", stdout
);
16008 if (option
->info
& OHW_R5KEOP
)
16009 fputs (" R5KEOP", stdout
);
16010 if (option
->info
& OHW_R5KCVTL
)
16011 fputs (" R5KCVTL", stdout
);
16014 fputs (" FILL ", stdout
);
16015 /* XXX Print content of info word? */
16018 fputs (" TAGS ", stdout
);
16019 /* XXX Print content of info word? */
16022 fputs (" HWAND ", stdout
);
16023 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
16024 fputs (" R4KEOP_CHECKED", stdout
);
16025 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
16026 fputs (" R4KEOP_CLEAN", stdout
);
16029 fputs (" HWOR ", stdout
);
16030 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
16031 fputs (" R4KEOP_CHECKED", stdout
);
16032 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
16033 fputs (" R4KEOP_CLEAN", stdout
);
16036 printf (" GP_GROUP %#06lx self-contained %#06lx",
16037 option
->info
& OGP_GROUP
,
16038 (option
->info
& OGP_SELF
) >> 16);
16041 printf (" IDENT %#06lx self-contained %#06lx",
16042 option
->info
& OGP_GROUP
,
16043 (option
->info
& OGP_SELF
) >> 16);
16046 /* This shouldn't happen. */
16047 printf (" %3d ??? %d %lx",
16048 option
->kind
, option
->section
, option
->info
);
16052 len
= sizeof (* eopt
);
16053 while (len
< option
->size
)
16055 unsigned char datum
= * ((unsigned char *) eopt
+ offset
+ len
);
16057 if (ISPRINT (datum
))
16058 printf ("%c", datum
);
16060 printf ("\\%03o", datum
);
16063 fputs ("\n", stdout
);
16065 offset
+= option
->size
;
16075 if (conflicts_offset
!= 0 && conflictsno
!= 0)
16077 Elf32_Conflict
* iconf
;
16080 if (dynamic_symbols
== NULL
)
16082 error (_("conflict list found without a dynamic symbol table\n"));
16086 /* PR 21345 - print a slightly more helpful error message
16087 if we are sure that the cmalloc will fail. */
16088 if (conflictsno
* sizeof (* iconf
) > filedata
->file_size
)
16090 error (_("Overlarge number of conflicts detected: %lx\n"),
16091 (long) conflictsno
);
16095 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
16098 error (_("Out of memory allocating space for dynamic conflicts\n"));
16104 Elf32_External_Conflict
* econf32
;
16106 econf32
= (Elf32_External_Conflict
*)
16107 get_data (NULL
, filedata
, conflicts_offset
, conflictsno
,
16108 sizeof (* econf32
), _("conflict"));
16112 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
16113 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
16119 Elf64_External_Conflict
* econf64
;
16121 econf64
= (Elf64_External_Conflict
*)
16122 get_data (NULL
, filedata
, conflicts_offset
, conflictsno
,
16123 sizeof (* econf64
), _("conflict"));
16127 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
16128 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
16133 printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
16134 "\nSection '.conflict' contains %lu entries:\n",
16135 (unsigned long) conflictsno
),
16136 (unsigned long) conflictsno
);
16137 puts (_(" Num: Index Value Name"));
16139 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
16141 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
16143 if (iconf
[cnt
] >= num_dynamic_syms
)
16144 printf (_("<corrupt symbol index>"));
16147 Elf_Internal_Sym
* psym
;
16149 psym
= & dynamic_symbols
[iconf
[cnt
]];
16150 print_vma (psym
->st_value
, FULL_HEX
);
16152 if (VALID_DYNAMIC_NAME (psym
->st_name
))
16153 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
16155 printf (_("<corrupt: %14ld>"), psym
->st_name
);
16163 if (pltgot
!= 0 && local_gotno
!= 0)
16165 bfd_vma ent
, local_end
, global_end
;
16167 unsigned char * data
;
16168 unsigned char * data_end
;
16172 addr_size
= (is_32bit_elf
? 4 : 8);
16173 local_end
= pltgot
+ local_gotno
* addr_size
;
16175 /* PR binutils/17533 file: 012-111227-0.004 */
16176 if (symtabno
< gotsym
)
16178 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
16179 (unsigned long) gotsym
, (unsigned long) symtabno
);
16183 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
16184 /* PR 17531: file: 54c91a34. */
16185 if (global_end
< local_end
)
16187 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
16191 offset
= offset_from_vma (filedata
, pltgot
, global_end
- pltgot
);
16192 data
= (unsigned char *) get_data (NULL
, filedata
, offset
,
16193 global_end
- pltgot
, 1,
16194 _("Global Offset Table data"));
16195 /* PR 12855: Null data is handled gracefully throughout. */
16196 data_end
= data
+ (global_end
- pltgot
);
16198 printf (_("\nPrimary GOT:\n"));
16199 printf (_(" Canonical gp value: "));
16200 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
16203 printf (_(" Reserved entries:\n"));
16204 printf (_(" %*s %10s %*s Purpose\n"),
16205 addr_size
* 2, _("Address"), _("Access"),
16206 addr_size
* 2, _("Initial"));
16207 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16208 printf (_(" Lazy resolver\n"));
16209 if (ent
== (bfd_vma
) -1)
16210 goto got_print_fail
;
16212 /* Check for the MSB of GOT[1] being set, denoting a GNU object.
16213 This entry will be used by some runtime loaders, to store the
16214 module pointer. Otherwise this is an ordinary local entry.
16215 PR 21344: Check for the entry being fully available before
16218 && data
+ ent
- pltgot
+ addr_size
<= data_end
16219 && (byte_get (data
+ ent
- pltgot
, addr_size
)
16220 >> (addr_size
* 8 - 1)) != 0)
16222 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16223 printf (_(" Module pointer (GNU extension)\n"));
16224 if (ent
== (bfd_vma
) -1)
16225 goto got_print_fail
;
16229 if (data
!= NULL
&& ent
< local_end
)
16231 printf (_(" Local entries:\n"));
16232 printf (" %*s %10s %*s\n",
16233 addr_size
* 2, _("Address"), _("Access"),
16234 addr_size
* 2, _("Initial"));
16235 while (ent
< local_end
)
16237 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16239 if (ent
== (bfd_vma
) -1)
16240 goto got_print_fail
;
16245 if (data
!= NULL
&& gotsym
< symtabno
)
16249 printf (_(" Global entries:\n"));
16250 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
16251 addr_size
* 2, _("Address"),
16253 addr_size
* 2, _("Initial"),
16254 addr_size
* 2, _("Sym.Val."),
16256 /* Note for translators: "Ndx" = abbreviated form of "Index". */
16257 _("Ndx"), _("Name"));
16259 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
16261 for (i
= gotsym
; i
< symtabno
; i
++)
16263 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16266 if (dynamic_symbols
== NULL
)
16267 printf (_("<no dynamic symbols>"));
16268 else if (i
< num_dynamic_syms
)
16270 Elf_Internal_Sym
* psym
= dynamic_symbols
+ i
;
16272 print_vma (psym
->st_value
, LONG_HEX
);
16273 printf (" %-7s %3s ",
16274 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
16275 get_symbol_index_type (filedata
, psym
->st_shndx
));
16277 if (VALID_DYNAMIC_NAME (psym
->st_name
))
16278 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
16280 printf (_("<corrupt: %14ld>"), psym
->st_name
);
16283 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
16284 (unsigned long) i
);
16287 if (ent
== (bfd_vma
) -1)
16298 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
16301 size_t offset
, rel_offset
;
16302 unsigned long count
, i
;
16303 unsigned char * data
;
16304 int addr_size
, sym_width
;
16305 Elf_Internal_Rela
* rels
;
16307 rel_offset
= offset_from_vma (filedata
, jmprel
, pltrelsz
);
16308 if (pltrel
== DT_RELA
)
16310 if (!slurp_rela_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
16315 if (!slurp_rel_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
16320 addr_size
= (is_32bit_elf
? 4 : 8);
16321 end
= mips_pltgot
+ (2 + count
) * addr_size
;
16323 offset
= offset_from_vma (filedata
, mips_pltgot
, end
- mips_pltgot
);
16324 data
= (unsigned char *) get_data (NULL
, filedata
, offset
, end
- mips_pltgot
,
16325 1, _("Procedure Linkage Table data"));
16329 printf ("\nPLT GOT:\n\n");
16330 printf (_(" Reserved entries:\n"));
16331 printf (_(" %*s %*s Purpose\n"),
16332 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
16333 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
16334 printf (_(" PLT lazy resolver\n"));
16335 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
16336 printf (_(" Module pointer\n"));
16339 printf (_(" Entries:\n"));
16340 printf (" %*s %*s %*s %-7s %3s %s\n",
16341 addr_size
* 2, _("Address"),
16342 addr_size
* 2, _("Initial"),
16343 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
16344 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
16345 for (i
= 0; i
< count
; i
++)
16347 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
16349 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
16352 if (idx
>= num_dynamic_syms
)
16353 printf (_("<corrupt symbol index: %lu>"), idx
);
16356 Elf_Internal_Sym
* psym
= dynamic_symbols
+ idx
;
16358 print_vma (psym
->st_value
, LONG_HEX
);
16359 printf (" %-7s %3s ",
16360 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
16361 get_symbol_index_type (filedata
, psym
->st_shndx
));
16362 if (VALID_DYNAMIC_NAME (psym
->st_name
))
16363 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
16365 printf (_("<corrupt: %14ld>"), psym
->st_name
);
16380 process_nds32_specific (Filedata
* filedata
)
16382 Elf_Internal_Shdr
*sect
= NULL
;
16384 sect
= find_section (filedata
, ".nds32_e_flags");
16387 unsigned int *flag
;
16389 printf ("\nNDS32 elf flags section:\n");
16390 flag
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
16391 sect
->sh_size
, _("NDS32 elf flags section"));
16396 switch ((*flag
) & 0x3)
16399 printf ("(VEC_SIZE):\tNo entry.\n");
16402 printf ("(VEC_SIZE):\t4 bytes\n");
16405 printf ("(VEC_SIZE):\t16 bytes\n");
16408 printf ("(VEC_SIZE):\treserved\n");
16417 process_gnu_liblist (Filedata
* filedata
)
16419 Elf_Internal_Shdr
* section
;
16420 Elf_Internal_Shdr
* string_sec
;
16421 Elf32_External_Lib
* elib
;
16423 size_t strtab_size
;
16425 unsigned long num_liblist
;
16427 bfd_boolean res
= TRUE
;
16432 for (i
= 0, section
= filedata
->section_headers
;
16433 i
< filedata
->file_header
.e_shnum
;
16436 switch (section
->sh_type
)
16438 case SHT_GNU_LIBLIST
:
16439 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
16442 elib
= (Elf32_External_Lib
*)
16443 get_data (NULL
, filedata
, section
->sh_offset
, 1, section
->sh_size
,
16444 _("liblist section data"));
16452 string_sec
= filedata
->section_headers
+ section
->sh_link
;
16453 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
16454 string_sec
->sh_size
,
16455 _("liblist string table"));
16457 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
16464 strtab_size
= string_sec
->sh_size
;
16466 num_liblist
= section
->sh_size
/ sizeof (Elf32_External_Lib
);
16467 printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
16468 "\nLibrary list section '%s' contains %lu entries:\n",
16470 printable_section_name (filedata
, section
),
16473 puts (_(" Library Time Stamp Checksum Version Flags"));
16475 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
16483 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
16484 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
16485 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
16486 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
16487 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
16489 tmp
= gmtime (&atime
);
16490 snprintf (timebuf
, sizeof (timebuf
),
16491 "%04u-%02u-%02uT%02u:%02u:%02u",
16492 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
16493 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
16495 printf ("%3lu: ", (unsigned long) cnt
);
16497 printf ("%-20s", liblist
.l_name
< strtab_size
16498 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
16500 printf ("%-20.20s", liblist
.l_name
< strtab_size
16501 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
16502 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
16503 liblist
.l_version
, liblist
.l_flags
);
16514 static const char *
16515 get_note_type (Filedata
* filedata
, unsigned e_type
)
16517 static char buff
[64];
16519 if (filedata
->file_header
.e_type
== ET_CORE
)
16523 return _("NT_AUXV (auxiliary vector)");
16525 return _("NT_PRSTATUS (prstatus structure)");
16527 return _("NT_FPREGSET (floating point registers)");
16529 return _("NT_PRPSINFO (prpsinfo structure)");
16530 case NT_TASKSTRUCT
:
16531 return _("NT_TASKSTRUCT (task structure)");
16533 return _("NT_PRXFPREG (user_xfpregs structure)");
16535 return _("NT_PPC_VMX (ppc Altivec registers)");
16537 return _("NT_PPC_VSX (ppc VSX registers)");
16539 return _("NT_PPC_TAR (ppc TAR register)");
16541 return _("NT_PPC_PPR (ppc PPR register)");
16543 return _("NT_PPC_DSCR (ppc DSCR register)");
16545 return _("NT_PPC_EBB (ppc EBB registers)");
16547 return _("NT_PPC_PMU (ppc PMU registers)");
16548 case NT_PPC_TM_CGPR
:
16549 return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
16550 case NT_PPC_TM_CFPR
:
16551 return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
16552 case NT_PPC_TM_CVMX
:
16553 return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
16554 case NT_PPC_TM_CVSX
:
16555 return _("NT_PPC_TM_VSX (ppc checkpointed VSX registers)");
16556 case NT_PPC_TM_SPR
:
16557 return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
16558 case NT_PPC_TM_CTAR
:
16559 return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
16560 case NT_PPC_TM_CPPR
:
16561 return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
16562 case NT_PPC_TM_CDSCR
:
16563 return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
16565 return _("NT_386_TLS (x86 TLS information)");
16566 case NT_386_IOPERM
:
16567 return _("NT_386_IOPERM (x86 I/O permissions)");
16568 case NT_X86_XSTATE
:
16569 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
16570 case NT_S390_HIGH_GPRS
:
16571 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
16572 case NT_S390_TIMER
:
16573 return _("NT_S390_TIMER (s390 timer register)");
16574 case NT_S390_TODCMP
:
16575 return _("NT_S390_TODCMP (s390 TOD comparator register)");
16576 case NT_S390_TODPREG
:
16577 return _("NT_S390_TODPREG (s390 TOD programmable register)");
16579 return _("NT_S390_CTRS (s390 control registers)");
16580 case NT_S390_PREFIX
:
16581 return _("NT_S390_PREFIX (s390 prefix register)");
16582 case NT_S390_LAST_BREAK
:
16583 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
16584 case NT_S390_SYSTEM_CALL
:
16585 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
16587 return _("NT_S390_TDB (s390 transaction diagnostic block)");
16588 case NT_S390_VXRS_LOW
:
16589 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
16590 case NT_S390_VXRS_HIGH
:
16591 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
16592 case NT_S390_GS_CB
:
16593 return _("NT_S390_GS_CB (s390 guarded-storage registers)");
16594 case NT_S390_GS_BC
:
16595 return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
16597 return _("NT_ARM_VFP (arm VFP registers)");
16599 return _("NT_ARM_TLS (AArch TLS registers)");
16600 case NT_ARM_HW_BREAK
:
16601 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
16602 case NT_ARM_HW_WATCH
:
16603 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
16605 return _("NT_PSTATUS (pstatus structure)");
16607 return _("NT_FPREGS (floating point registers)");
16609 return _("NT_PSINFO (psinfo structure)");
16611 return _("NT_LWPSTATUS (lwpstatus_t structure)");
16613 return _("NT_LWPSINFO (lwpsinfo_t structure)");
16614 case NT_WIN32PSTATUS
:
16615 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
16617 return _("NT_SIGINFO (siginfo_t data)");
16619 return _("NT_FILE (mapped files)");
16627 return _("NT_VERSION (version)");
16629 return _("NT_ARCH (architecture)");
16630 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
16632 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
16638 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16643 print_core_note (Elf_Internal_Note
*pnote
)
16645 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
16646 bfd_vma count
, page_size
;
16647 unsigned char *descdata
, *filenames
, *descend
;
16649 if (pnote
->type
!= NT_FILE
)
16659 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
16660 /* Still "successful". */
16665 if (pnote
->descsz
< 2 * addr_size
)
16667 error (_(" Malformed note - too short for header\n"));
16671 descdata
= (unsigned char *) pnote
->descdata
;
16672 descend
= descdata
+ pnote
->descsz
;
16674 if (descdata
[pnote
->descsz
- 1] != '\0')
16676 error (_(" Malformed note - does not end with \\0\n"));
16680 count
= byte_get (descdata
, addr_size
);
16681 descdata
+= addr_size
;
16683 page_size
= byte_get (descdata
, addr_size
);
16684 descdata
+= addr_size
;
16686 if (count
> ((bfd_vma
) -1 - 2 * addr_size
) / (3 * addr_size
)
16687 || pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
16689 error (_(" Malformed note - too short for supplied file count\n"));
16693 printf (_(" Page size: "));
16694 print_vma (page_size
, DEC
);
16697 printf (_(" %*s%*s%*s\n"),
16698 (int) (2 + 2 * addr_size
), _("Start"),
16699 (int) (4 + 2 * addr_size
), _("End"),
16700 (int) (4 + 2 * addr_size
), _("Page Offset"));
16701 filenames
= descdata
+ count
* 3 * addr_size
;
16702 while (count
-- > 0)
16704 bfd_vma start
, end
, file_ofs
;
16706 if (filenames
== descend
)
16708 error (_(" Malformed note - filenames end too early\n"));
16712 start
= byte_get (descdata
, addr_size
);
16713 descdata
+= addr_size
;
16714 end
= byte_get (descdata
, addr_size
);
16715 descdata
+= addr_size
;
16716 file_ofs
= byte_get (descdata
, addr_size
);
16717 descdata
+= addr_size
;
16720 print_vma (start
, FULL_HEX
);
16722 print_vma (end
, FULL_HEX
);
16724 print_vma (file_ofs
, FULL_HEX
);
16725 printf ("\n %s\n", filenames
);
16727 filenames
+= 1 + strlen ((char *) filenames
);
16733 static const char *
16734 get_gnu_elf_note_type (unsigned e_type
)
16736 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
16739 case NT_GNU_ABI_TAG
:
16740 return _("NT_GNU_ABI_TAG (ABI version tag)");
16742 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
16743 case NT_GNU_BUILD_ID
:
16744 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
16745 case NT_GNU_GOLD_VERSION
:
16746 return _("NT_GNU_GOLD_VERSION (gold version)");
16747 case NT_GNU_PROPERTY_TYPE_0
:
16748 return _("NT_GNU_PROPERTY_TYPE_0");
16749 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
16750 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
16751 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
16752 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
16755 static char buff
[64];
16757 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16764 decode_x86_isa (unsigned int bitmask
)
16768 unsigned int bit
= bitmask
& (- bitmask
);
16773 case GNU_PROPERTY_X86_ISA_1_486
: printf ("i486"); break;
16774 case GNU_PROPERTY_X86_ISA_1_586
: printf ("586"); break;
16775 case GNU_PROPERTY_X86_ISA_1_686
: printf ("686"); break;
16776 case GNU_PROPERTY_X86_ISA_1_SSE
: printf ("SSE"); break;
16777 case GNU_PROPERTY_X86_ISA_1_SSE2
: printf ("SSE2"); break;
16778 case GNU_PROPERTY_X86_ISA_1_SSE3
: printf ("SSE3"); break;
16779 case GNU_PROPERTY_X86_ISA_1_SSSE3
: printf ("SSSE3"); break;
16780 case GNU_PROPERTY_X86_ISA_1_SSE4_1
: printf ("SSE4_1"); break;
16781 case GNU_PROPERTY_X86_ISA_1_SSE4_2
: printf ("SSE4_2"); break;
16782 case GNU_PROPERTY_X86_ISA_1_AVX
: printf ("AVX"); break;
16783 case GNU_PROPERTY_X86_ISA_1_AVX2
: printf ("AVX2"); break;
16784 case GNU_PROPERTY_X86_ISA_1_AVX512F
: printf ("AVX512F"); break;
16785 case GNU_PROPERTY_X86_ISA_1_AVX512CD
: printf ("AVX512CD"); break;
16786 case GNU_PROPERTY_X86_ISA_1_AVX512ER
: printf ("AVX512ER"); break;
16787 case GNU_PROPERTY_X86_ISA_1_AVX512PF
: printf ("AVX512PF"); break;
16788 case GNU_PROPERTY_X86_ISA_1_AVX512VL
: printf ("AVX512VL"); break;
16789 case GNU_PROPERTY_X86_ISA_1_AVX512DQ
: printf ("AVX512DQ"); break;
16790 case GNU_PROPERTY_X86_ISA_1_AVX512BW
: printf ("AVX512BW"); break;
16791 default: printf (_("<unknown: %x>"), bit
); break;
16799 decode_x86_feature (unsigned int type
, unsigned int bitmask
)
16803 unsigned int bit
= bitmask
& (- bitmask
);
16808 case GNU_PROPERTY_X86_FEATURE_1_IBT
:
16811 case GNU_PROPERTY_X86_FEATURE_1_AND
:
16815 /* This should never happen. */
16819 case GNU_PROPERTY_X86_FEATURE_1_SHSTK
:
16822 case GNU_PROPERTY_X86_FEATURE_1_AND
:
16826 /* This should never happen. */
16831 printf (_("<unknown: %x>"), bit
);
16840 print_gnu_property_note (Filedata
* filedata
, Elf_Internal_Note
* pnote
)
16842 unsigned char * ptr
= (unsigned char *) pnote
->descdata
;
16843 unsigned char * ptr_end
= ptr
+ pnote
->descsz
;
16844 unsigned int size
= is_32bit_elf
? 4 : 8;
16846 printf (_(" Properties: "));
16848 if (pnote
->descsz
< 8 || (pnote
->descsz
% size
) != 0)
16850 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote
->descsz
);
16854 while (ptr
< ptr_end
)
16858 unsigned int datasz
;
16860 if ((size_t) (ptr_end
- ptr
) < 8)
16862 printf (_("<corrupt descsz: %#lx>\n"), pnote
->descsz
);
16866 type
= byte_get (ptr
, 4);
16867 datasz
= byte_get (ptr
+ 4, 4);
16871 if (datasz
> (size_t) (ptr_end
- ptr
))
16873 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
16878 if (type
>= GNU_PROPERTY_LOPROC
&& type
<= GNU_PROPERTY_HIPROC
)
16880 if (filedata
->file_header
.e_machine
== EM_X86_64
16881 || filedata
->file_header
.e_machine
== EM_IAMCU
16882 || filedata
->file_header
.e_machine
== EM_386
)
16886 case GNU_PROPERTY_X86_ISA_1_USED
:
16887 printf ("x86 ISA used: ");
16889 printf (_("<corrupt length: %#x> "), datasz
);
16891 decode_x86_isa (byte_get (ptr
, 4));
16894 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
16895 printf ("x86 ISA needed: ");
16897 printf (_("<corrupt length: %#x> "), datasz
);
16899 decode_x86_isa (byte_get (ptr
, 4));
16902 case GNU_PROPERTY_X86_FEATURE_1_AND
:
16903 printf ("x86 feature: ");
16905 printf (_("<corrupt length: %#x> "), datasz
);
16907 decode_x86_feature (type
, byte_get (ptr
, 4));
16919 case GNU_PROPERTY_STACK_SIZE
:
16920 printf (_("stack size: "));
16921 if (datasz
!= size
)
16922 printf (_("<corrupt length: %#x> "), datasz
);
16924 printf ("%#lx", (unsigned long) byte_get (ptr
, size
));
16927 case GNU_PROPERTY_NO_COPY_ON_PROTECTED
:
16928 printf ("no copy on protected ");
16930 printf (_("<corrupt length: %#x> "), datasz
);
16938 if (type
< GNU_PROPERTY_LOPROC
)
16939 printf (_("<unknown type %#x data: "), type
);
16940 else if (type
< GNU_PROPERTY_LOUSER
)
16941 printf (_("<procesor-specific type %#x data: "), type
);
16943 printf (_("<application-specific type %#x data: "), type
);
16944 for (j
= 0; j
< datasz
; ++j
)
16945 printf ("%02x ", ptr
[j
] & 0xff);
16949 ptr
+= ((datasz
+ (size
- 1)) & ~ (size
- 1));
16950 if (ptr
== ptr_end
)
16963 print_gnu_note (Filedata
* filedata
, Elf_Internal_Note
*pnote
)
16965 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
16966 switch (pnote
->type
)
16968 case NT_GNU_BUILD_ID
:
16972 printf (_(" Build ID: "));
16973 for (i
= 0; i
< pnote
->descsz
; ++i
)
16974 printf ("%02x", pnote
->descdata
[i
] & 0xff);
16979 case NT_GNU_ABI_TAG
:
16981 unsigned long os
, major
, minor
, subminor
;
16982 const char *osname
;
16984 /* PR 17531: file: 030-599401-0.004. */
16985 if (pnote
->descsz
< 16)
16987 printf (_(" <corrupt GNU_ABI_TAG>\n"));
16991 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
16992 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
16993 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
16994 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
16998 case GNU_ABI_TAG_LINUX
:
17001 case GNU_ABI_TAG_HURD
:
17004 case GNU_ABI_TAG_SOLARIS
:
17005 osname
= "Solaris";
17007 case GNU_ABI_TAG_FREEBSD
:
17008 osname
= "FreeBSD";
17010 case GNU_ABI_TAG_NETBSD
:
17013 case GNU_ABI_TAG_SYLLABLE
:
17014 osname
= "Syllable";
17016 case GNU_ABI_TAG_NACL
:
17020 osname
= "Unknown";
17024 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
17025 major
, minor
, subminor
);
17029 case NT_GNU_GOLD_VERSION
:
17033 printf (_(" Version: "));
17034 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
17035 printf ("%c", pnote
->descdata
[i
]);
17042 unsigned long num_entries
, mask
;
17044 /* Hardware capabilities information. Word 0 is the number of entries.
17045 Word 1 is a bitmask of enabled entries. The rest of the descriptor
17046 is a series of entries, where each entry is a single byte followed
17047 by a nul terminated string. The byte gives the bit number to test
17048 if enabled in the bitmask. */
17049 printf (_(" Hardware Capabilities: "));
17050 if (pnote
->descsz
< 8)
17052 error (_("<corrupt GNU_HWCAP>\n"));
17055 num_entries
= byte_get ((unsigned char *) pnote
->descdata
, 4);
17056 mask
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
17057 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries
, mask
);
17058 /* FIXME: Add code to display the entries... */
17062 case NT_GNU_PROPERTY_TYPE_0
:
17063 print_gnu_property_note (filedata
, pnote
);
17067 /* Handle unrecognised types. An error message should have already been
17068 created by get_gnu_elf_note_type(), so all that we need to do is to
17069 display the data. */
17073 printf (_(" Description data: "));
17074 for (i
= 0; i
< pnote
->descsz
; ++i
)
17075 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
17084 static const char *
17085 get_v850_elf_note_type (enum v850_notes n_type
)
17087 static char buff
[64];
17091 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
17092 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
17093 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
17094 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
17095 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
17096 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
17098 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
17104 print_v850_note (Elf_Internal_Note
* pnote
)
17108 if (pnote
->descsz
!= 4)
17111 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
17115 printf (_("not set\n"));
17119 switch (pnote
->type
)
17121 case V850_NOTE_ALIGNMENT
:
17124 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return TRUE
;
17125 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return TRUE
;
17129 case V850_NOTE_DATA_SIZE
:
17132 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return TRUE
;
17133 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return TRUE
;
17137 case V850_NOTE_FPU_INFO
:
17140 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return TRUE
;
17141 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return TRUE
;
17145 case V850_NOTE_MMU_INFO
:
17146 case V850_NOTE_CACHE_INFO
:
17147 case V850_NOTE_SIMD_INFO
:
17148 if (val
== EF_RH850_SIMD
)
17150 printf (_("yes\n"));
17156 /* An 'unknown note type' message will already have been displayed. */
17160 printf (_("unknown value: %x\n"), val
);
17165 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
17167 unsigned int version
;
17169 switch (pnote
->type
)
17171 case NT_NETBSD_IDENT
:
17172 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
17173 if ((version
/ 10000) % 100)
17174 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
17175 version
, version
/ 100000000, (version
/ 1000000) % 100,
17176 (version
/ 10000) % 100 > 26 ? "Z" : "",
17177 'A' + (version
/ 10000) % 26);
17179 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
17180 version
, version
/ 100000000, (version
/ 1000000) % 100,
17181 (version
/ 100) % 100);
17184 case NT_NETBSD_MARCH
:
17185 printf (" NetBSD\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
17190 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote
->descsz
,
17196 static const char *
17197 get_freebsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
17201 case NT_FREEBSD_THRMISC
:
17202 return _("NT_THRMISC (thrmisc structure)");
17203 case NT_FREEBSD_PROCSTAT_PROC
:
17204 return _("NT_PROCSTAT_PROC (proc data)");
17205 case NT_FREEBSD_PROCSTAT_FILES
:
17206 return _("NT_PROCSTAT_FILES (files data)");
17207 case NT_FREEBSD_PROCSTAT_VMMAP
:
17208 return _("NT_PROCSTAT_VMMAP (vmmap data)");
17209 case NT_FREEBSD_PROCSTAT_GROUPS
:
17210 return _("NT_PROCSTAT_GROUPS (groups data)");
17211 case NT_FREEBSD_PROCSTAT_UMASK
:
17212 return _("NT_PROCSTAT_UMASK (umask data)");
17213 case NT_FREEBSD_PROCSTAT_RLIMIT
:
17214 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
17215 case NT_FREEBSD_PROCSTAT_OSREL
:
17216 return _("NT_PROCSTAT_OSREL (osreldate data)");
17217 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
17218 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
17219 case NT_FREEBSD_PROCSTAT_AUXV
:
17220 return _("NT_PROCSTAT_AUXV (auxv data)");
17221 case NT_FREEBSD_PTLWPINFO
:
17222 return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
17224 return get_note_type (filedata
, e_type
);
17227 static const char *
17228 get_netbsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
17230 static char buff
[64];
17232 if (e_type
== NT_NETBSDCORE_PROCINFO
)
17233 return _("NetBSD procinfo structure");
17235 /* As of Jan 2002 there are no other machine-independent notes
17236 defined for NetBSD core files. If the note type is less
17237 than the start of the machine-dependent note types, we don't
17240 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
17242 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17246 switch (filedata
->file_header
.e_machine
)
17248 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
17249 and PT_GETFPREGS == mach+2. */
17254 case EM_SPARC32PLUS
:
17258 case NT_NETBSDCORE_FIRSTMACH
+ 0:
17259 return _("PT_GETREGS (reg structure)");
17260 case NT_NETBSDCORE_FIRSTMACH
+ 2:
17261 return _("PT_GETFPREGS (fpreg structure)");
17267 /* On all other arch's, PT_GETREGS == mach+1 and
17268 PT_GETFPREGS == mach+3. */
17272 case NT_NETBSDCORE_FIRSTMACH
+ 1:
17273 return _("PT_GETREGS (reg structure)");
17274 case NT_NETBSDCORE_FIRSTMACH
+ 3:
17275 return _("PT_GETFPREGS (fpreg structure)");
17281 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
17282 e_type
- NT_NETBSDCORE_FIRSTMACH
);
17286 static const char *
17287 get_stapsdt_note_type (unsigned e_type
)
17289 static char buff
[64];
17294 return _("NT_STAPSDT (SystemTap probe descriptors)");
17300 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17305 print_stapsdt_note (Elf_Internal_Note
*pnote
)
17307 int addr_size
= is_32bit_elf
? 4 : 8;
17308 char *data
= pnote
->descdata
;
17309 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
17310 bfd_vma pc
, base_addr
, semaphore
;
17311 char *provider
, *probe
, *arg_fmt
;
17313 pc
= byte_get ((unsigned char *) data
, addr_size
);
17315 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
17317 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
17321 data
+= strlen (data
) + 1;
17323 data
+= strlen (data
) + 1;
17325 data
+= strlen (data
) + 1;
17327 printf (_(" Provider: %s\n"), provider
);
17328 printf (_(" Name: %s\n"), probe
);
17329 printf (_(" Location: "));
17330 print_vma (pc
, FULL_HEX
);
17331 printf (_(", Base: "));
17332 print_vma (base_addr
, FULL_HEX
);
17333 printf (_(", Semaphore: "));
17334 print_vma (semaphore
, FULL_HEX
);
17336 printf (_(" Arguments: %s\n"), arg_fmt
);
17338 return data
== data_end
;
17341 static const char *
17342 get_ia64_vms_note_type (unsigned e_type
)
17344 static char buff
[64];
17349 return _("NT_VMS_MHD (module header)");
17351 return _("NT_VMS_LNM (language name)");
17353 return _("NT_VMS_SRC (source files)");
17355 return "NT_VMS_TITLE";
17357 return _("NT_VMS_EIDC (consistency check)");
17358 case NT_VMS_FPMODE
:
17359 return _("NT_VMS_FPMODE (FP mode)");
17360 case NT_VMS_LINKTIME
:
17361 return "NT_VMS_LINKTIME";
17362 case NT_VMS_IMGNAM
:
17363 return _("NT_VMS_IMGNAM (image name)");
17365 return _("NT_VMS_IMGID (image id)");
17366 case NT_VMS_LINKID
:
17367 return _("NT_VMS_LINKID (link id)");
17368 case NT_VMS_IMGBID
:
17369 return _("NT_VMS_IMGBID (build id)");
17370 case NT_VMS_GSTNAM
:
17371 return _("NT_VMS_GSTNAM (sym table name)");
17372 case NT_VMS_ORIG_DYN
:
17373 return "NT_VMS_ORIG_DYN";
17374 case NT_VMS_PATCHTIME
:
17375 return "NT_VMS_PATCHTIME";
17377 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17383 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
17385 switch (pnote
->type
)
17388 if (pnote
->descsz
> 36)
17390 size_t l
= strlen (pnote
->descdata
+ 34);
17391 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
17392 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
17393 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
17394 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
17397 printf (_(" Invalid size\n"));
17400 printf (_(" Language: %s\n"), pnote
->descdata
);
17403 case NT_VMS_FPMODE
:
17404 printf (_(" Floating Point mode: "));
17405 printf ("0x%016" BFD_VMA_FMT
"x\n",
17406 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
17408 case NT_VMS_LINKTIME
:
17409 printf (_(" Link time: "));
17411 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
17414 case NT_VMS_PATCHTIME
:
17415 printf (_(" Patch time: "));
17417 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
17420 case NT_VMS_ORIG_DYN
:
17421 printf (_(" Major id: %u, minor id: %u\n"),
17422 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
17423 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
17424 printf (_(" Last modified : "));
17426 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
17427 printf (_("\n Link flags : "));
17428 printf ("0x%016" BFD_VMA_FMT
"x\n",
17429 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
17430 printf (_(" Header flags: 0x%08x\n"),
17431 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
17432 printf (_(" Image id : %s\n"), pnote
->descdata
+ 32);
17435 case NT_VMS_IMGNAM
:
17436 printf (_(" Image name: %s\n"), pnote
->descdata
);
17438 case NT_VMS_GSTNAM
:
17439 printf (_(" Global symbol table name: %s\n"), pnote
->descdata
);
17442 printf (_(" Image id: %s\n"), pnote
->descdata
);
17444 case NT_VMS_LINKID
:
17445 printf (_(" Linker id: %s\n"), pnote
->descdata
);
17453 /* Find the symbol associated with a build attribute that is attached
17454 to address OFFSET. If PNAME is non-NULL then store the name of
17455 the symbol (if found) in the provided pointer, Returns NULL if a
17456 symbol could not be found. */
17458 static Elf_Internal_Sym
*
17459 get_symbol_for_build_attribute (Filedata
* filedata
,
17460 unsigned long offset
,
17461 bfd_boolean is_open_attr
,
17462 const char ** pname
)
17464 static Filedata
* saved_filedata
= NULL
;
17465 static char * strtab
;
17466 static unsigned long strtablen
;
17467 static Elf_Internal_Sym
* symtab
;
17468 static unsigned long nsyms
;
17469 Elf_Internal_Sym
* saved_sym
= NULL
;
17470 Elf_Internal_Sym
* sym
;
17472 if (filedata
->section_headers
!= NULL
17473 && (saved_filedata
== NULL
|| filedata
!= saved_filedata
))
17475 Elf_Internal_Shdr
* symsec
;
17477 /* Load the symbol and string sections. */
17478 for (symsec
= filedata
->section_headers
;
17479 symsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
17482 if (symsec
->sh_type
== SHT_SYMTAB
)
17484 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & nsyms
);
17486 if (symsec
->sh_link
< filedata
->file_header
.e_shnum
)
17488 Elf_Internal_Shdr
* strtab_sec
= filedata
->section_headers
+ symsec
->sh_link
;
17490 strtab
= (char *) get_data (NULL
, filedata
, strtab_sec
->sh_offset
,
17491 1, strtab_sec
->sh_size
,
17492 _("string table"));
17493 strtablen
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
17497 saved_filedata
= filedata
;
17500 if (symtab
== NULL
|| strtab
== NULL
)
17503 /* Find a symbol whose value matches offset. */
17504 for (sym
= symtab
; sym
< symtab
+ nsyms
; sym
++)
17505 if (sym
->st_value
== offset
)
17507 if (sym
->st_name
>= strtablen
)
17508 /* Huh ? This should not happen. */
17511 if (strtab
[sym
->st_name
] == 0)
17514 /* The AArch64 and ARM architectures define mapping symbols
17515 (eg $d, $x, $t) which we want to ignore. */
17516 if (strtab
[sym
->st_name
] == '$'
17517 && strtab
[sym
->st_name
+ 1] != 0
17518 && strtab
[sym
->st_name
+ 2] == 0)
17523 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
17524 and FILE or OBJECT symbols over NOTYPE symbols. We skip
17525 FUNC symbols entirely. */
17526 switch (ELF_ST_TYPE (sym
->st_info
))
17533 /* If the symbol has a size associated
17534 with it then we can stop searching. */
17535 sym
= symtab
+ nsyms
;
17540 /* Ignore function symbols. */
17547 switch (ELF_ST_BIND (sym
->st_info
))
17550 if (saved_sym
== NULL
17551 || ELF_ST_TYPE (saved_sym
->st_info
) != STT_OBJECT
)
17556 if (saved_sym
== NULL
)
17566 if (ELF_ST_TYPE (sym
->st_info
) != STT_FUNC
)
17574 if (saved_sym
&& pname
)
17575 * pname
= strtab
+ saved_sym
->st_name
;
17581 print_gnu_build_attribute_description (Elf_Internal_Note
* pnote
,
17582 Filedata
* filedata
)
17584 static unsigned long global_offset
= 0;
17585 static unsigned long global_end
= 0;
17586 static unsigned long func_offset
= 0;
17587 static unsigned long func_end
= 0;
17589 Elf_Internal_Sym
* sym
;
17591 unsigned long start
;
17593 bfd_boolean is_open_attr
= pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
;
17595 switch (pnote
->descsz
)
17598 /* A zero-length description means that the range of
17599 the previous note of the same type should be used. */
17602 if (global_end
> global_offset
)
17603 printf (_(" Applies to region from %#lx to %#lx\n"),
17604 global_offset
, global_end
);
17606 printf (_(" Applies to region from %#lx\n"), global_offset
);
17610 if (func_end
> func_offset
)
17611 printf (_(" Applies to region from %#lx to %#lx\n"), func_offset
, func_end
);
17613 printf (_(" Applies to region from %#lx\n"), func_offset
);
17618 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
17625 /* FIXME: We should check that version 3+ notes are being used here... */
17626 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
17627 end
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
17631 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
17637 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
17638 end
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 8);
17642 error (_(" <invalid description size: %lx>\n"), pnote
->descsz
);
17643 printf (_(" <invalid descsz>"));
17648 sym
= get_symbol_for_build_attribute (filedata
, start
, is_open_attr
, & name
);
17649 /* As of version 5 of the annobin plugin, filename symbols are biased by 2
17650 in order to avoid them being confused with the start address of the
17651 first function in the file... */
17652 if (sym
== NULL
&& is_open_attr
)
17653 sym
= get_symbol_for_build_attribute (filedata
, start
+ 2, is_open_attr
,
17656 if (end
== 0 && sym
!= NULL
&& sym
->st_size
> 0)
17657 end
= start
+ sym
->st_size
;
17661 /* FIXME: Need to properly allow for section alignment. 16 is just the alignment used on x86_64. */
17662 if (global_end
> 0 && start
> BFD_ALIGN (global_end
, 16))
17663 warn (_("Gap in build notes detected from %#lx to %#lx\n"),
17664 global_end
+ 1, start
- 1);
17666 printf (_(" Applies to region from %#lx"), start
);
17667 global_offset
= start
;
17671 printf (_(" to %#lx"), end
);
17677 printf (_(" Applies to region from %#lx"), start
);
17678 func_offset
= start
;
17682 printf (_(" to %#lx"), end
);
17688 printf (_(" (%s)"), name
);
17695 print_gnu_build_attribute_name (Elf_Internal_Note
* pnote
)
17697 static const char string_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING
, 0 };
17698 static const char number_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
, 0 };
17699 static const char bool_expected
[3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
, 0 };
17701 char name_attribute
;
17702 const char * expected_types
;
17703 const char * name
= pnote
->namedata
;
17707 if (name
== NULL
|| pnote
->namesz
< 2)
17709 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
17710 print_symbol (-20, _(" <corrupt name>"));
17719 /* Version 2 of the spec adds a "GA" prefix to the name field. */
17720 if (name
[0] == 'G' && name
[1] == 'A')
17722 if (pnote
->namesz
< 4)
17724 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
17725 print_symbol (-20, _(" <corrupt name>"));
17734 switch ((name_type
= * name
))
17736 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
17737 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
17738 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
17739 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
17740 printf ("%c", * name
);
17744 error (_("unrecognised attribute type in name field: %d\n"), name_type
);
17745 print_symbol (-20, _("<unknown name type>"));
17752 switch ((name_attribute
= * name
))
17754 case GNU_BUILD_ATTRIBUTE_VERSION
:
17755 text
= _("<version>");
17756 expected_types
= string_expected
;
17759 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
17760 text
= _("<stack prot>");
17761 expected_types
= "!+*";
17764 case GNU_BUILD_ATTRIBUTE_RELRO
:
17765 text
= _("<relro>");
17766 expected_types
= bool_expected
;
17769 case GNU_BUILD_ATTRIBUTE_STACK_SIZE
:
17770 text
= _("<stack size>");
17771 expected_types
= number_expected
;
17774 case GNU_BUILD_ATTRIBUTE_TOOL
:
17775 text
= _("<tool>");
17776 expected_types
= string_expected
;
17779 case GNU_BUILD_ATTRIBUTE_ABI
:
17781 expected_types
= "$*";
17784 case GNU_BUILD_ATTRIBUTE_PIC
:
17786 expected_types
= number_expected
;
17789 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM
:
17790 text
= _("<short enum>");
17791 expected_types
= bool_expected
;
17795 if (ISPRINT (* name
))
17797 int len
= strnlen (name
, pnote
->namesz
- (name
- pnote
->namedata
)) + 1;
17799 if (len
> left
&& ! do_wide
)
17801 printf ("%.*s:", len
, name
);
17807 static char tmpbuf
[128];
17809 error (_("unrecognised byte in name field: %d\n"), * name
);
17810 sprintf (tmpbuf
, _("<unknown:_%d>"), * name
);
17814 expected_types
= "*$!+";
17819 left
-= printf ("%s", text
);
17821 if (strchr (expected_types
, name_type
) == NULL
)
17822 warn (_("attribute does not have an expected type (%c)\n"), name_type
);
17824 if ((unsigned long)(name
- pnote
->namedata
) > pnote
->namesz
)
17826 error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
17827 (unsigned long) pnote
->namesz
,
17828 (long) (name
- pnote
->namedata
));
17832 if (left
< 1 && ! do_wide
)
17837 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
17839 unsigned int bytes
;
17840 unsigned long long val
= 0;
17841 unsigned int shift
= 0;
17842 char * decoded
= NULL
;
17844 bytes
= pnote
->namesz
- (name
- pnote
->namedata
);
17846 /* The -1 is because the name field is always 0 terminated, and we
17847 want to be able to ensure that the shift in the while loop below
17848 will not overflow. */
17851 if (bytes
> sizeof (val
))
17853 error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
17855 bytes
= sizeof (val
);
17857 /* We do not bother to warn if bytes == 0 as this can
17858 happen with some early versions of the gcc plugin. */
17862 unsigned long byte
= (* name
++) & 0xff;
17864 val
|= byte
<< shift
;
17868 switch (name_attribute
)
17870 case GNU_BUILD_ATTRIBUTE_PIC
:
17873 case 0: decoded
= "static"; break;
17874 case 1: decoded
= "pic"; break;
17875 case 2: decoded
= "PIC"; break;
17876 case 3: decoded
= "pie"; break;
17877 case 4: decoded
= "PIE"; break;
17881 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
17884 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
17885 case 0: decoded
= "off"; break;
17886 case 1: decoded
= "on"; break;
17887 case 2: decoded
= "all"; break;
17888 case 3: decoded
= "strong"; break;
17889 case 4: decoded
= "explicit"; break;
17897 if (decoded
!= NULL
)
17899 print_symbol (-left
, decoded
);
17910 left
-= printf ("0x%llx", val
);
17912 left
-= printf ("0x%-.*llx", left
, val
);
17916 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
17917 left
-= print_symbol (- left
, name
);
17919 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
17920 left
-= print_symbol (- left
, "true");
17922 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
17923 left
-= print_symbol (- left
, "false");
17927 if (do_wide
&& left
> 0)
17928 printf ("%-*s", left
, " ");
17933 /* Note that by the ELF standard, the name field is already null byte
17934 terminated, and namesz includes the terminating null byte.
17935 I.E. the value of namesz for the name "FSF" is 4.
17937 If the value of namesz is zero, there is no name present. */
17940 process_note (Elf_Internal_Note
* pnote
,
17941 Filedata
* filedata
)
17943 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
17946 if (pnote
->namesz
== 0)
17947 /* If there is no note name, then use the default set of
17948 note type strings. */
17949 nt
= get_note_type (filedata
, pnote
->type
);
17951 else if (const_strneq (pnote
->namedata
, "GNU"))
17952 /* GNU-specific object file notes. */
17953 nt
= get_gnu_elf_note_type (pnote
->type
);
17955 else if (const_strneq (pnote
->namedata
, "FreeBSD"))
17956 /* FreeBSD-specific core file notes. */
17957 nt
= get_freebsd_elfcore_note_type (filedata
, pnote
->type
);
17959 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
17960 /* NetBSD-specific core file notes. */
17961 nt
= get_netbsd_elfcore_note_type (filedata
, pnote
->type
);
17963 else if (const_strneq (pnote
->namedata
, "NetBSD"))
17964 /* NetBSD-specific core file notes. */
17965 return process_netbsd_elf_note (pnote
);
17967 else if (strneq (pnote
->namedata
, "SPU/", 4))
17969 /* SPU-specific core file notes. */
17970 nt
= pnote
->namedata
+ 4;
17974 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
17975 /* VMS/ia64-specific file notes. */
17976 nt
= get_ia64_vms_note_type (pnote
->type
);
17978 else if (const_strneq (pnote
->namedata
, "stapsdt"))
17979 nt
= get_stapsdt_note_type (pnote
->type
);
17982 /* Don't recognize this note name; just use the default set of
17983 note type strings. */
17984 nt
= get_note_type (filedata
, pnote
->type
);
17988 if (((const_strneq (pnote
->namedata
, "GA")
17989 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
17990 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
17991 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
17992 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
17993 print_gnu_build_attribute_name (pnote
);
17995 print_symbol (-20, name
);
17998 printf (" 0x%08lx\t%s\t", pnote
->descsz
, nt
);
18000 printf (" 0x%08lx\t%s\n", pnote
->descsz
, nt
);
18002 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
18003 return print_ia64_vms_note (pnote
);
18004 else if (const_strneq (pnote
->namedata
, "GNU"))
18005 return print_gnu_note (filedata
, pnote
);
18006 else if (const_strneq (pnote
->namedata
, "stapsdt"))
18007 return print_stapsdt_note (pnote
);
18008 else if (const_strneq (pnote
->namedata
, "CORE"))
18009 return print_core_note (pnote
);
18010 else if (((const_strneq (pnote
->namedata
, "GA")
18011 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
18012 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
18013 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
18014 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
18015 return print_gnu_build_attribute_description (pnote
, filedata
);
18021 printf (_(" description data: "));
18022 for (i
= 0; i
< pnote
->descsz
; i
++)
18023 printf ("%02x ", pnote
->descdata
[i
]);
18035 process_notes_at (Filedata
* filedata
,
18036 Elf_Internal_Shdr
* section
,
18041 Elf_External_Note
* pnotes
;
18042 Elf_External_Note
* external
;
18044 bfd_boolean res
= TRUE
;
18051 pnotes
= (Elf_External_Note
*) get_section_contents (section
, filedata
);
18054 if (! apply_relocations (filedata
, section
, (unsigned char *) pnotes
, length
, NULL
, NULL
))
18059 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
18062 if (pnotes
== NULL
)
18068 printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (filedata
, section
));
18070 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
18071 (unsigned long) offset
, (unsigned long) length
);
18073 /* NB: Some note sections may have alignment value of 0 or 1. gABI
18074 specifies that notes should be aligned to 4 bytes in 32-bit
18075 objects and to 8 bytes in 64-bit objects. As a Linux extension,
18076 we also support 4 byte alignment in 64-bit objects. If section
18077 alignment is less than 4, we treate alignment as 4 bytes. */
18080 else if (align
!= 4 && align
!= 8)
18082 warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
18087 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
18089 end
= (char *) pnotes
+ length
;
18090 while ((char *) external
< end
)
18092 Elf_Internal_Note inote
;
18095 char * temp
= NULL
;
18096 size_t data_remaining
= end
- (char *) external
;
18098 if (!is_ia64_vms (filedata
))
18100 /* PR binutils/15191
18101 Make sure that there is enough data to read. */
18102 min_notesz
= offsetof (Elf_External_Note
, name
);
18103 if (data_remaining
< min_notesz
)
18105 warn (ngettext ("Corrupt note: only %ld byte remains, "
18106 "not enough for a full note\n",
18107 "Corrupt note: only %ld bytes remain, "
18108 "not enough for a full note\n",
18110 (long) data_remaining
);
18113 data_remaining
-= min_notesz
;
18115 inote
.type
= BYTE_GET (external
->type
);
18116 inote
.namesz
= BYTE_GET (external
->namesz
);
18117 inote
.namedata
= external
->name
;
18118 inote
.descsz
= BYTE_GET (external
->descsz
);
18119 inote
.descdata
= ((char *) external
18120 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
18121 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
18122 next
= ((char *) external
18123 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
18127 Elf64_External_VMS_Note
*vms_external
;
18129 /* PR binutils/15191
18130 Make sure that there is enough data to read. */
18131 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
18132 if (data_remaining
< min_notesz
)
18134 warn (ngettext ("Corrupt note: only %ld byte remains, "
18135 "not enough for a full note\n",
18136 "Corrupt note: only %ld bytes remain, "
18137 "not enough for a full note\n",
18139 (long) data_remaining
);
18142 data_remaining
-= min_notesz
;
18144 vms_external
= (Elf64_External_VMS_Note
*) external
;
18145 inote
.type
= BYTE_GET (vms_external
->type
);
18146 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
18147 inote
.namedata
= vms_external
->name
;
18148 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
18149 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
18150 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
18151 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
18154 /* PR 17531: file: 3443835e. */
18155 /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
18156 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
18157 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
18158 || (size_t) (next
- inote
.descdata
) < inote
.descsz
18159 || ((size_t) (next
- inote
.descdata
)
18160 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
18162 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
18163 (unsigned long) ((char *) external
- (char *) pnotes
));
18164 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
18165 inote
.type
, inote
.namesz
, inote
.descsz
, (int) align
);
18169 external
= (Elf_External_Note
*) next
;
18171 /* Verify that name is null terminated. It appears that at least
18172 one version of Linux (RedHat 6.0) generates corefiles that don't
18173 comply with the ELF spec by failing to include the null byte in
18175 if (inote
.namedata
[inote
.namesz
- 1] != '\0')
18177 if ((size_t) (inote
.descdata
- inote
.namedata
) == inote
.namesz
)
18179 temp
= (char *) malloc (inote
.namesz
+ 1);
18182 error (_("Out of memory allocating space for inote name\n"));
18187 memcpy (temp
, inote
.namedata
, inote
.namesz
);
18188 inote
.namedata
= temp
;
18190 inote
.namedata
[inote
.namesz
] = 0;
18193 if (! process_note (& inote
, filedata
))
18209 process_corefile_note_segments (Filedata
* filedata
)
18211 Elf_Internal_Phdr
* segment
;
18213 bfd_boolean res
= TRUE
;
18215 if (! get_program_headers (filedata
))
18218 for (i
= 0, segment
= filedata
->program_headers
;
18219 i
< filedata
->file_header
.e_phnum
;
18222 if (segment
->p_type
== PT_NOTE
)
18223 if (! process_notes_at (filedata
, NULL
,
18224 (bfd_vma
) segment
->p_offset
,
18225 (bfd_vma
) segment
->p_filesz
,
18226 (bfd_vma
) segment
->p_align
))
18234 process_v850_notes (Filedata
* filedata
, bfd_vma offset
, bfd_vma length
)
18236 Elf_External_Note
* pnotes
;
18237 Elf_External_Note
* external
;
18239 bfd_boolean res
= TRUE
;
18244 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
18246 if (pnotes
== NULL
)
18250 end
= (char*) pnotes
+ length
;
18252 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
18253 (unsigned long) offset
, (unsigned long) length
);
18255 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
18257 Elf_External_Note
* next
;
18258 Elf_Internal_Note inote
;
18260 inote
.type
= BYTE_GET (external
->type
);
18261 inote
.namesz
= BYTE_GET (external
->namesz
);
18262 inote
.namedata
= external
->name
;
18263 inote
.descsz
= BYTE_GET (external
->descsz
);
18264 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
18265 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
18267 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
18269 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
18270 inote
.descdata
= inote
.namedata
;
18274 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
18276 if ( ((char *) next
> end
)
18277 || ((char *) next
< (char *) pnotes
))
18279 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
18280 (unsigned long) ((char *) external
- (char *) pnotes
));
18281 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
18282 inote
.type
, inote
.namesz
, inote
.descsz
);
18288 /* Prevent out-of-bounds indexing. */
18289 if ( inote
.namedata
+ inote
.namesz
> end
18290 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
18292 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
18293 (unsigned long) ((char *) external
- (char *) pnotes
));
18294 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
18295 inote
.type
, inote
.namesz
, inote
.descsz
);
18299 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
18301 if (! print_v850_note (& inote
))
18304 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
18305 inote
.namesz
, inote
.descsz
);
18315 process_note_sections (Filedata
* filedata
)
18317 Elf_Internal_Shdr
* section
;
18319 unsigned int n
= 0;
18320 bfd_boolean res
= TRUE
;
18322 for (i
= 0, section
= filedata
->section_headers
;
18323 i
< filedata
->file_header
.e_shnum
&& section
!= NULL
;
18326 if (section
->sh_type
== SHT_NOTE
)
18328 if (! process_notes_at (filedata
, section
,
18329 (bfd_vma
) section
->sh_offset
,
18330 (bfd_vma
) section
->sh_size
,
18331 (bfd_vma
) section
->sh_addralign
))
18336 if (( filedata
->file_header
.e_machine
== EM_V800
18337 || filedata
->file_header
.e_machine
== EM_V850
18338 || filedata
->file_header
.e_machine
== EM_CYGNUS_V850
)
18339 && section
->sh_type
== SHT_RENESAS_INFO
)
18341 if (! process_v850_notes (filedata
,
18342 (bfd_vma
) section
->sh_offset
,
18343 (bfd_vma
) section
->sh_size
))
18350 /* Try processing NOTE segments instead. */
18351 return process_corefile_note_segments (filedata
);
18357 process_notes (Filedata
* filedata
)
18359 /* If we have not been asked to display the notes then do nothing. */
18363 if (filedata
->file_header
.e_type
!= ET_CORE
)
18364 return process_note_sections (filedata
);
18366 /* No program headers means no NOTE segment. */
18367 if (filedata
->file_header
.e_phnum
> 0)
18368 return process_corefile_note_segments (filedata
);
18370 printf (_("No note segments present in the core file.\n"));
18374 static unsigned char *
18375 display_public_gnu_attributes (unsigned char * start
,
18376 const unsigned char * const end
)
18378 printf (_(" Unknown GNU attribute: %s\n"), start
);
18380 start
+= strnlen ((char *) start
, end
- start
);
18381 display_raw_attribute (start
, end
);
18383 return (unsigned char *) end
;
18386 static unsigned char *
18387 display_generic_attribute (unsigned char * start
,
18389 const unsigned char * const end
)
18392 return (unsigned char *) end
;
18394 return display_tag_value (tag
, start
, end
);
18398 process_arch_specific (Filedata
* filedata
)
18403 switch (filedata
->file_header
.e_machine
)
18406 case EM_ARC_COMPACT
:
18407 case EM_ARC_COMPACT2
:
18408 return process_attributes (filedata
, "ARC", SHT_ARC_ATTRIBUTES
,
18409 display_arc_attribute
,
18410 display_generic_attribute
);
18412 return process_attributes (filedata
, "aeabi", SHT_ARM_ATTRIBUTES
,
18413 display_arm_attribute
,
18414 display_generic_attribute
);
18417 case EM_MIPS_RS3_LE
:
18418 return process_mips_specific (filedata
);
18421 return process_attributes (filedata
, "mspabi", SHT_MSP430_ATTRIBUTES
,
18422 display_msp430x_attribute
,
18423 display_generic_attribute
);
18426 return process_nds32_specific (filedata
);
18430 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
18431 display_power_gnu_attribute
);
18435 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
18436 display_s390_gnu_attribute
);
18439 case EM_SPARC32PLUS
:
18441 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
18442 display_sparc_gnu_attribute
);
18445 return process_attributes (filedata
, "c6xabi", SHT_C6000_ATTRIBUTES
,
18446 display_tic6x_attribute
,
18447 display_generic_attribute
);
18450 return process_attributes (filedata
, "gnu", SHT_GNU_ATTRIBUTES
,
18451 display_public_gnu_attributes
,
18452 display_generic_attribute
);
18457 get_file_header (Filedata
* filedata
)
18459 /* Read in the identity array. */
18460 if (fread (filedata
->file_header
.e_ident
, EI_NIDENT
, 1, filedata
->handle
) != 1)
18463 /* Determine how to read the rest of the header. */
18464 switch (filedata
->file_header
.e_ident
[EI_DATA
])
18469 byte_get
= byte_get_little_endian
;
18470 byte_put
= byte_put_little_endian
;
18473 byte_get
= byte_get_big_endian
;
18474 byte_put
= byte_put_big_endian
;
18478 /* For now we only support 32 bit and 64 bit ELF files. */
18479 is_32bit_elf
= (filedata
->file_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
18481 /* Read in the rest of the header. */
18484 Elf32_External_Ehdr ehdr32
;
18486 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
18489 filedata
->file_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
18490 filedata
->file_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
18491 filedata
->file_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
18492 filedata
->file_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
18493 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
18494 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
18495 filedata
->file_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
18496 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
18497 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
18498 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
18499 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
18500 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
18501 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
18505 Elf64_External_Ehdr ehdr64
;
18507 /* If we have been compiled with sizeof (bfd_vma) == 4, then
18508 we will not be able to cope with the 64bit data found in
18509 64 ELF files. Detect this now and abort before we start
18510 overwriting things. */
18511 if (sizeof (bfd_vma
) < 8)
18513 error (_("This instance of readelf has been built without support for a\n\
18514 64 bit data type and so it cannot read 64 bit ELF files.\n"));
18518 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
18521 filedata
->file_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
18522 filedata
->file_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
18523 filedata
->file_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
18524 filedata
->file_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
18525 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
18526 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
18527 filedata
->file_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
18528 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
18529 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
18530 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
18531 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
18532 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
18533 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
18536 if (filedata
->file_header
.e_shoff
)
18538 /* There may be some extensions in the first section header. Don't
18539 bomb if we can't read it. */
18541 get_32bit_section_headers (filedata
, TRUE
);
18543 get_64bit_section_headers (filedata
, TRUE
);
18550 close_file (Filedata
* filedata
)
18554 if (filedata
->handle
)
18555 fclose (filedata
->handle
);
18561 close_debug_file (void * data
)
18563 close_file ((Filedata
*) data
);
18567 open_file (const char * pathname
)
18569 struct stat statbuf
;
18570 Filedata
* filedata
= NULL
;
18572 if (stat (pathname
, & statbuf
) < 0
18573 || ! S_ISREG (statbuf
.st_mode
))
18576 filedata
= calloc (1, sizeof * filedata
);
18577 if (filedata
== NULL
)
18580 filedata
->handle
= fopen (pathname
, "rb");
18581 if (filedata
->handle
== NULL
)
18584 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
18585 filedata
->file_name
= pathname
;
18587 if (! get_file_header (filedata
))
18590 if (filedata
->file_header
.e_shoff
)
18594 /* Read the section headers again, this time for real. */
18596 res
= get_32bit_section_headers (filedata
, FALSE
);
18598 res
= get_64bit_section_headers (filedata
, FALSE
);
18609 if (filedata
->handle
)
18610 fclose (filedata
->handle
);
18617 open_debug_file (const char * pathname
)
18619 return open_file (pathname
);
18622 /* Process one ELF object file according to the command line options.
18623 This file may actually be stored in an archive. The file is
18624 positioned at the start of the ELF object. Returns TRUE if no
18625 problems were encountered, FALSE otherwise. */
18628 process_object (Filedata
* filedata
)
18630 Filedata
* separates
;
18632 bfd_boolean res
= TRUE
;
18634 if (! get_file_header (filedata
))
18636 error (_("%s: Failed to read file header\n"), filedata
->file_name
);
18640 /* Initialise per file variables. */
18641 for (i
= ARRAY_SIZE (version_info
); i
--;)
18642 version_info
[i
] = 0;
18644 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
18645 dynamic_info
[i
] = 0;
18646 dynamic_info_DT_GNU_HASH
= 0;
18648 /* Process the file. */
18650 printf (_("\nFile: %s\n"), filedata
->file_name
);
18652 /* Initialise the dump_sects array from the cmdline_dump_sects array.
18653 Note we do this even if cmdline_dump_sects is empty because we
18654 must make sure that the dump_sets array is zeroed out before each
18655 object file is processed. */
18656 if (filedata
->num_dump_sects
> cmdline
.num_dump_sects
)
18657 memset (filedata
->dump_sects
, 0, filedata
->num_dump_sects
* sizeof (* filedata
->dump_sects
));
18659 if (cmdline
.num_dump_sects
> 0)
18661 if (filedata
->num_dump_sects
== 0)
18662 /* A sneaky way of allocating the dump_sects array. */
18663 request_dump_bynumber (filedata
, cmdline
.num_dump_sects
, 0);
18665 assert (filedata
->num_dump_sects
>= cmdline
.num_dump_sects
);
18666 memcpy (filedata
->dump_sects
, cmdline
.dump_sects
,
18667 cmdline
.num_dump_sects
* sizeof (* filedata
->dump_sects
));
18670 if (! process_file_header (filedata
))
18673 if (! process_section_headers (filedata
))
18675 /* Without loaded section headers we cannot process lots of things. */
18676 do_unwind
= do_version
= do_dump
= do_arch
= FALSE
;
18678 if (! do_using_dynamic
)
18679 do_syms
= do_dyn_syms
= do_reloc
= FALSE
;
18682 if (! process_section_groups (filedata
))
18683 /* Without loaded section groups we cannot process unwind. */
18686 if (process_program_headers (filedata
))
18687 process_dynamic_section (filedata
);
18691 if (! process_relocs (filedata
))
18694 if (! process_unwind (filedata
))
18697 if (! process_symbol_table (filedata
))
18700 if (! process_syminfo (filedata
))
18703 if (! process_version_sections (filedata
))
18706 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
)
18707 separates
= load_separate_debug_file (filedata
, filedata
->file_name
);
18711 if (! process_section_contents (filedata
))
18716 if (! process_section_headers (separates
))
18718 else if (! process_section_contents (separates
))
18722 if (! process_notes (filedata
))
18725 if (! process_gnu_liblist (filedata
))
18728 if (! process_arch_specific (filedata
))
18731 free (filedata
->program_headers
);
18732 filedata
->program_headers
= NULL
;
18734 free (filedata
->section_headers
);
18735 filedata
->section_headers
= NULL
;
18737 free (filedata
->string_table
);
18738 filedata
->string_table
= NULL
;
18739 filedata
->string_table_length
= 0;
18741 if (dynamic_strings
)
18743 free (dynamic_strings
);
18744 dynamic_strings
= NULL
;
18745 dynamic_strings_length
= 0;
18748 if (dynamic_symbols
)
18750 free (dynamic_symbols
);
18751 dynamic_symbols
= NULL
;
18752 num_dynamic_syms
= 0;
18755 if (dynamic_syminfo
)
18757 free (dynamic_syminfo
);
18758 dynamic_syminfo
= NULL
;
18761 if (dynamic_section
)
18763 free (dynamic_section
);
18764 dynamic_section
= NULL
;
18767 if (section_headers_groups
)
18769 free (section_headers_groups
);
18770 section_headers_groups
= NULL
;
18773 if (section_groups
)
18775 struct group_list
* g
;
18776 struct group_list
* next
;
18778 for (i
= 0; i
< group_count
; i
++)
18780 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
18787 free (section_groups
);
18788 section_groups
= NULL
;
18791 free_debug_memory ();
18796 /* Process an ELF archive.
18797 On entry the file is positioned just after the ARMAG string.
18798 Returns TRUE upon success, FALSE otherwise. */
18801 process_archive (Filedata
* filedata
, bfd_boolean is_thin_archive
)
18803 struct archive_info arch
;
18804 struct archive_info nested_arch
;
18806 bfd_boolean ret
= TRUE
;
18810 /* The ARCH structure is used to hold information about this archive. */
18811 arch
.file_name
= NULL
;
18813 arch
.index_array
= NULL
;
18814 arch
.sym_table
= NULL
;
18815 arch
.longnames
= NULL
;
18817 /* The NESTED_ARCH structure is used as a single-item cache of information
18818 about a nested archive (when members of a thin archive reside within
18819 another regular archive file). */
18820 nested_arch
.file_name
= NULL
;
18821 nested_arch
.file
= NULL
;
18822 nested_arch
.index_array
= NULL
;
18823 nested_arch
.sym_table
= NULL
;
18824 nested_arch
.longnames
= NULL
;
18826 if (setup_archive (&arch
, filedata
->file_name
, filedata
->handle
,
18827 is_thin_archive
, do_archive_index
) != 0)
18833 if (do_archive_index
)
18835 if (arch
.sym_table
== NULL
)
18836 error (_("%s: unable to dump the index as none was found\n"), filedata
->file_name
);
18839 unsigned long i
, l
;
18840 unsigned long current_pos
;
18842 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
18843 filedata
->file_name
, (unsigned long) arch
.index_num
, arch
.sym_size
);
18845 current_pos
= ftell (filedata
->handle
);
18847 for (i
= l
= 0; i
< arch
.index_num
; i
++)
18849 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
18851 char * member_name
;
18853 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
18855 if (member_name
!= NULL
)
18857 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
18859 if (qualified_name
!= NULL
)
18861 printf (_("Contents of binary %s at offset "), qualified_name
);
18862 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
18864 free (qualified_name
);
18869 if (l
>= arch
.sym_size
)
18871 error (_("%s: end of the symbol table reached before the end of the index\n"),
18872 filedata
->file_name
);
18876 /* PR 17531: file: 0b6630b2. */
18877 printf ("\t%.*s\n", (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
18878 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
18881 if (arch
.uses_64bit_indicies
)
18886 if (l
< arch
.sym_size
)
18888 error (ngettext ("%s: %ld byte remains in the symbol table, "
18889 "but without corresponding entries in "
18890 "the index table\n",
18891 "%s: %ld bytes remain in the symbol table, "
18892 "but without corresponding entries in "
18893 "the index table\n",
18894 arch
.sym_size
- l
),
18895 filedata
->file_name
, arch
.sym_size
- l
);
18899 if (fseek (filedata
->handle
, current_pos
, SEEK_SET
) != 0)
18901 error (_("%s: failed to seek back to start of object files in the archive\n"),
18902 filedata
->file_name
);
18908 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
18909 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
18910 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
18911 && !do_section_groups
&& !do_dyn_syms
)
18913 ret
= TRUE
; /* Archive index only. */
18922 char * qualified_name
;
18924 /* Read the next archive header. */
18925 if (fseek (filedata
->handle
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
18927 error (_("%s: failed to seek to next archive header\n"), filedata
->file_name
);
18930 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, filedata
->handle
);
18931 if (got
!= sizeof arch
.arhdr
)
18935 error (_("%s: failed to read archive header\n"), filedata
->file_name
);
18939 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
18941 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
18946 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
18948 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
18949 if (archive_file_size
& 01)
18950 ++archive_file_size
;
18952 name
= get_archive_member_name (&arch
, &nested_arch
);
18955 error (_("%s: bad archive file name\n"), filedata
->file_name
);
18959 namelen
= strlen (name
);
18961 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
18962 if (qualified_name
== NULL
)
18964 error (_("%s: bad archive file name\n"), filedata
->file_name
);
18969 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
18971 /* This is a proxy for an external member of a thin archive. */
18972 Filedata
* member_filedata
;
18973 char * member_file_name
= adjust_relative_path
18974 (filedata
->file_name
, name
, namelen
);
18976 if (member_file_name
== NULL
)
18982 member_filedata
= open_file (member_file_name
);
18983 if (member_filedata
== NULL
)
18985 error (_("Input file '%s' is not readable.\n"), member_file_name
);
18986 free (member_file_name
);
18991 archive_file_offset
= arch
.nested_member_origin
;
18992 member_filedata
->file_name
= qualified_name
;
18994 if (! process_object (member_filedata
))
18997 close_file (member_filedata
);
18998 free (member_file_name
);
19000 else if (is_thin_archive
)
19002 Filedata thin_filedata
;
19004 memset (&thin_filedata
, 0, sizeof (thin_filedata
));
19006 /* PR 15140: Allow for corrupt thin archives. */
19007 if (nested_arch
.file
== NULL
)
19009 error (_("%s: contains corrupt thin archive: %s\n"),
19010 filedata
->file_name
, name
);
19015 /* This is a proxy for a member of a nested archive. */
19016 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
19018 /* The nested archive file will have been opened and setup by
19019 get_archive_member_name. */
19020 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
19022 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
19027 thin_filedata
.handle
= nested_arch
.file
;
19028 thin_filedata
.file_name
= qualified_name
;
19030 if (! process_object (& thin_filedata
))
19035 archive_file_offset
= arch
.next_arhdr_offset
;
19036 arch
.next_arhdr_offset
+= archive_file_size
;
19038 filedata
->file_name
= qualified_name
;
19039 if (! process_object (filedata
))
19043 if (filedata
->dump_sects
!= NULL
)
19045 free (filedata
->dump_sects
);
19046 filedata
->dump_sects
= NULL
;
19047 filedata
->num_dump_sects
= 0;
19050 free (qualified_name
);
19054 if (nested_arch
.file
!= NULL
)
19055 fclose (nested_arch
.file
);
19056 release_archive (&nested_arch
);
19057 release_archive (&arch
);
19063 process_file (char * file_name
)
19065 Filedata
* filedata
= NULL
;
19066 struct stat statbuf
;
19067 char armag
[SARMAG
];
19068 bfd_boolean ret
= TRUE
;
19070 if (stat (file_name
, &statbuf
) < 0)
19072 if (errno
== ENOENT
)
19073 error (_("'%s': No such file\n"), file_name
);
19075 error (_("Could not locate '%s'. System error message: %s\n"),
19076 file_name
, strerror (errno
));
19080 if (! S_ISREG (statbuf
.st_mode
))
19082 error (_("'%s' is not an ordinary file\n"), file_name
);
19086 filedata
= calloc (1, sizeof * filedata
);
19087 if (filedata
== NULL
)
19089 error (_("Out of memory allocating file data structure\n"));
19093 filedata
->file_name
= file_name
;
19094 filedata
->handle
= fopen (file_name
, "rb");
19095 if (filedata
->handle
== NULL
)
19097 error (_("Input file '%s' is not readable.\n"), file_name
);
19102 if (fread (armag
, SARMAG
, 1, filedata
->handle
) != 1)
19104 error (_("%s: Failed to read file's magic number\n"), file_name
);
19105 fclose (filedata
->handle
);
19110 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
19112 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
19114 if (! process_archive (filedata
, FALSE
))
19117 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
19119 if ( ! process_archive (filedata
, TRUE
))
19124 if (do_archive_index
)
19125 error (_("File %s is not an archive so its index cannot be displayed.\n"),
19128 rewind (filedata
->handle
);
19129 archive_file_size
= archive_file_offset
= 0;
19131 if (! process_object (filedata
))
19135 fclose (filedata
->handle
);
19141 #ifdef SUPPORT_DISASSEMBLY
19142 /* Needed by the i386 disassembler. For extra credit, someone could
19143 fix this so that we insert symbolic addresses here, esp for GOT/PLT
19147 print_address (unsigned int addr
, FILE * outfile
)
19149 fprintf (outfile
,"0x%8.8x", addr
);
19152 /* Needed by the i386 disassembler. */
19155 db_task_printsym (unsigned int addr
)
19157 print_address (addr
, stderr
);
19162 main (int argc
, char ** argv
)
19166 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
19167 setlocale (LC_MESSAGES
, "");
19169 #if defined (HAVE_SETLOCALE)
19170 setlocale (LC_CTYPE
, "");
19172 bindtextdomain (PACKAGE
, LOCALEDIR
);
19173 textdomain (PACKAGE
);
19175 expandargv (&argc
, &argv
);
19177 cmdline
.file_name
= "<cmdline>";
19178 parse_args (& cmdline
, argc
, argv
);
19180 if (optind
< (argc
- 1))
19182 else if (optind
>= argc
)
19184 warn (_("Nothing to do.\n"));
19189 while (optind
< argc
)
19190 if (! process_file (argv
[optind
++]))
19193 if (cmdline
.dump_sects
!= NULL
)
19194 free (cmdline
.dump_sects
);
19196 return err
? EXIT_FAILURE
: EXIT_SUCCESS
;