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 /* Now handle EABI specific flags. */
2585 strcat (buf
, ", <unrecognized EABI>");
2590 case EF_ARM_EABI_VER1
:
2591 strcat (buf
, ", Version1 EABI");
2596 /* Process flags one bit at a time. */
2597 flag
= e_flags
& - e_flags
;
2602 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2603 strcat (buf
, ", sorted symbol tables");
2613 case EF_ARM_EABI_VER2
:
2614 strcat (buf
, ", Version2 EABI");
2619 /* Process flags one bit at a time. */
2620 flag
= e_flags
& - e_flags
;
2625 case EF_ARM_SYMSARESORTED
: /* Conflicts with EF_ARM_INTERWORK. */
2626 strcat (buf
, ", sorted symbol tables");
2629 case EF_ARM_DYNSYMSUSESEGIDX
:
2630 strcat (buf
, ", dynamic symbols use segment index");
2633 case EF_ARM_MAPSYMSFIRST
:
2634 strcat (buf
, ", mapping symbols precede others");
2644 case EF_ARM_EABI_VER3
:
2645 strcat (buf
, ", Version3 EABI");
2648 case EF_ARM_EABI_VER4
:
2649 strcat (buf
, ", Version4 EABI");
2654 /* Process flags one bit at a time. */
2655 flag
= e_flags
& - e_flags
;
2661 strcat (buf
, ", BE8");
2665 strcat (buf
, ", LE8");
2675 case EF_ARM_EABI_VER5
:
2676 strcat (buf
, ", Version5 EABI");
2681 /* Process flags one bit at a time. */
2682 flag
= e_flags
& - e_flags
;
2688 strcat (buf
, ", BE8");
2692 strcat (buf
, ", LE8");
2695 case EF_ARM_ABI_FLOAT_SOFT
: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2696 strcat (buf
, ", soft-float ABI");
2699 case EF_ARM_ABI_FLOAT_HARD
: /* Conflicts with EF_ARM_VFP_FLOAT. */
2700 strcat (buf
, ", hard-float ABI");
2710 case EF_ARM_EABI_UNKNOWN
:
2711 strcat (buf
, ", GNU EABI");
2716 /* Process flags one bit at a time. */
2717 flag
= e_flags
& - e_flags
;
2722 case EF_ARM_INTERWORK
:
2723 strcat (buf
, ", interworking enabled");
2726 case EF_ARM_APCS_26
:
2727 strcat (buf
, ", uses APCS/26");
2730 case EF_ARM_APCS_FLOAT
:
2731 strcat (buf
, ", uses APCS/float");
2735 strcat (buf
, ", position independent");
2739 strcat (buf
, ", 8 bit structure alignment");
2742 case EF_ARM_NEW_ABI
:
2743 strcat (buf
, ", uses new ABI");
2746 case EF_ARM_OLD_ABI
:
2747 strcat (buf
, ", uses old ABI");
2750 case EF_ARM_SOFT_FLOAT
:
2751 strcat (buf
, ", software FP");
2754 case EF_ARM_VFP_FLOAT
:
2755 strcat (buf
, ", VFP");
2758 case EF_ARM_MAVERICK_FLOAT
:
2759 strcat (buf
, ", Maverick FP");
2770 strcat (buf
,_(", <unknown>"));
2774 decode_AVR_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2776 --size
; /* Leave space for null terminator. */
2778 switch (e_flags
& EF_AVR_MACH
)
2780 case E_AVR_MACH_AVR1
:
2781 strncat (buf
, ", avr:1", size
);
2783 case E_AVR_MACH_AVR2
:
2784 strncat (buf
, ", avr:2", size
);
2786 case E_AVR_MACH_AVR25
:
2787 strncat (buf
, ", avr:25", size
);
2789 case E_AVR_MACH_AVR3
:
2790 strncat (buf
, ", avr:3", size
);
2792 case E_AVR_MACH_AVR31
:
2793 strncat (buf
, ", avr:31", size
);
2795 case E_AVR_MACH_AVR35
:
2796 strncat (buf
, ", avr:35", size
);
2798 case E_AVR_MACH_AVR4
:
2799 strncat (buf
, ", avr:4", size
);
2801 case E_AVR_MACH_AVR5
:
2802 strncat (buf
, ", avr:5", size
);
2804 case E_AVR_MACH_AVR51
:
2805 strncat (buf
, ", avr:51", size
);
2807 case E_AVR_MACH_AVR6
:
2808 strncat (buf
, ", avr:6", size
);
2810 case E_AVR_MACH_AVRTINY
:
2811 strncat (buf
, ", avr:100", size
);
2813 case E_AVR_MACH_XMEGA1
:
2814 strncat (buf
, ", avr:101", size
);
2816 case E_AVR_MACH_XMEGA2
:
2817 strncat (buf
, ", avr:102", size
);
2819 case E_AVR_MACH_XMEGA3
:
2820 strncat (buf
, ", avr:103", size
);
2822 case E_AVR_MACH_XMEGA4
:
2823 strncat (buf
, ", avr:104", size
);
2825 case E_AVR_MACH_XMEGA5
:
2826 strncat (buf
, ", avr:105", size
);
2828 case E_AVR_MACH_XMEGA6
:
2829 strncat (buf
, ", avr:106", size
);
2831 case E_AVR_MACH_XMEGA7
:
2832 strncat (buf
, ", avr:107", size
);
2835 strncat (buf
, ", avr:<unknown>", size
);
2839 size
-= strlen (buf
);
2840 if (e_flags
& EF_AVR_LINKRELAX_PREPARED
)
2841 strncat (buf
, ", link-relax", size
);
2845 decode_NDS32_machine_flags (unsigned e_flags
, char buf
[], size_t size
)
2851 bfd_boolean has_fpu
= FALSE
;
2854 static const char *ABI_STRINGS
[] =
2856 "ABI v0", /* use r5 as return register; only used in N1213HC */
2857 "ABI v1", /* use r0 as return register */
2858 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2859 "ABI v2fp", /* for FPU */
2863 static const char *VER_STRINGS
[] =
2865 "Andes ELF V1.3 or older",
2869 static const char *ARCH_STRINGS
[] =
2878 abi
= EF_NDS_ABI
& e_flags
;
2879 arch
= EF_NDS_ARCH
& e_flags
;
2880 config
= EF_NDS_INST
& e_flags
;
2881 version
= EF_NDS32_ELF_VERSION
& e_flags
;
2883 memset (buf
, 0, size
);
2890 case E_NDS_ABI_V2FP
:
2891 case E_NDS_ABI_AABI
:
2892 case E_NDS_ABI_V2FP_PLUS
:
2893 /* In case there are holes in the array. */
2894 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ABI_STRINGS
[abi
>> EF_NDS_ABI_SHIFT
]);
2898 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ABI>");
2904 case E_NDS32_ELF_VER_1_2
:
2905 case E_NDS32_ELF_VER_1_3
:
2906 case E_NDS32_ELF_VER_1_4
:
2907 r
+= snprintf (buf
+ r
, size
- r
, ", %s", VER_STRINGS
[version
>> EF_NDS32_ELF_VERSION_SHIFT
]);
2911 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized ELF version number>");
2915 if (E_NDS_ABI_V0
== abi
)
2917 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2918 r
+= snprintf (buf
+ r
, size
- r
, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2919 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2920 r
+= snprintf (buf
+ r
, size
-r
, ", 16b"); /* has 16-bit instructions */
2926 case E_NDS_ARCH_STAR_V1_0
:
2927 case E_NDS_ARCH_STAR_V2_0
:
2928 case E_NDS_ARCH_STAR_V3_0
:
2929 case E_NDS_ARCH_STAR_V3_M
:
2930 r
+= snprintf (buf
+ r
, size
- r
, ", %s", ARCH_STRINGS
[arch
>> EF_NDS_ARCH_SHIFT
]);
2934 r
+= snprintf (buf
+ r
, size
- r
, ", <unrecognized architecture>");
2935 /* ARCH version determines how the e_flags are interpreted.
2936 If it is unknown, we cannot proceed. */
2940 /* Newer ABI; Now handle architecture specific flags. */
2941 if (arch
== E_NDS_ARCH_STAR_V1_0
)
2943 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2944 r
+= snprintf (buf
+ r
, size
-r
, ", MFUSR_PC");
2946 if (!(config
& E_NDS32_HAS_NO_MAC_INST
))
2947 r
+= snprintf (buf
+ r
, size
-r
, ", MAC");
2949 if (config
& E_NDS32_HAS_DIV_INST
)
2950 r
+= snprintf (buf
+ r
, size
-r
, ", DIV");
2952 if (config
& E_NDS32_HAS_16BIT_INST
)
2953 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
2957 if (config
& E_NDS32_HAS_MFUSR_PC_INST
)
2959 if (version
<= E_NDS32_ELF_VER_1_3
)
2960 r
+= snprintf (buf
+ r
, size
-r
, ", [B8]");
2962 r
+= snprintf (buf
+ r
, size
-r
, ", EX9");
2965 if (config
& E_NDS32_HAS_MAC_DX_INST
)
2966 r
+= snprintf (buf
+ r
, size
-r
, ", MAC_DX");
2968 if (config
& E_NDS32_HAS_DIV_DX_INST
)
2969 r
+= snprintf (buf
+ r
, size
-r
, ", DIV_DX");
2971 if (config
& E_NDS32_HAS_16BIT_INST
)
2973 if (version
<= E_NDS32_ELF_VER_1_3
)
2974 r
+= snprintf (buf
+ r
, size
-r
, ", 16b");
2976 r
+= snprintf (buf
+ r
, size
-r
, ", IFC");
2980 if (config
& E_NDS32_HAS_EXT_INST
)
2981 r
+= snprintf (buf
+ r
, size
-r
, ", PERF1");
2983 if (config
& E_NDS32_HAS_EXT2_INST
)
2984 r
+= snprintf (buf
+ r
, size
-r
, ", PERF2");
2986 if (config
& E_NDS32_HAS_FPU_INST
)
2989 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_SP");
2992 if (config
& E_NDS32_HAS_FPU_DP_INST
)
2995 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_DP");
2998 if (config
& E_NDS32_HAS_FPU_MAC_INST
)
3001 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_MAC");
3006 switch ((config
& E_NDS32_FPU_REG_CONF
) >> E_NDS32_FPU_REG_CONF_SHIFT
)
3008 case E_NDS32_FPU_REG_8SP_4DP
:
3009 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:8/4");
3011 case E_NDS32_FPU_REG_16SP_8DP
:
3012 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:16/8");
3014 case E_NDS32_FPU_REG_32SP_16DP
:
3015 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/16");
3017 case E_NDS32_FPU_REG_32SP_32DP
:
3018 r
+= snprintf (buf
+ r
, size
-r
, ", FPU_REG:32/32");
3023 if (config
& E_NDS32_HAS_AUDIO_INST
)
3024 r
+= snprintf (buf
+ r
, size
-r
, ", AUDIO");
3026 if (config
& E_NDS32_HAS_STRING_INST
)
3027 r
+= snprintf (buf
+ r
, size
-r
, ", STR");
3029 if (config
& E_NDS32_HAS_REDUCED_REGS
)
3030 r
+= snprintf (buf
+ r
, size
-r
, ", 16REG");
3032 if (config
& E_NDS32_HAS_VIDEO_INST
)
3034 if (version
<= E_NDS32_ELF_VER_1_3
)
3035 r
+= snprintf (buf
+ r
, size
-r
, ", VIDEO");
3037 r
+= snprintf (buf
+ r
, size
-r
, ", SATURATION");
3040 if (config
& E_NDS32_HAS_ENCRIPT_INST
)
3041 r
+= snprintf (buf
+ r
, size
-r
, ", ENCRP");
3043 if (config
& E_NDS32_HAS_L2C_INST
)
3044 r
+= snprintf (buf
+ r
, size
-r
, ", L2C");
3048 get_machine_flags (Filedata
* filedata
, unsigned e_flags
, unsigned e_machine
)
3050 static char buf
[1024];
3061 case EM_ARC_COMPACT2
:
3062 case EM_ARC_COMPACT
:
3063 decode_ARC_machine_flags (e_flags
, e_machine
, buf
);
3067 decode_ARM_machine_flags (e_flags
, buf
);
3071 decode_AVR_machine_flags (e_flags
, buf
, sizeof buf
);
3075 if (e_flags
& EF_BFIN_PIC
)
3076 strcat (buf
, ", PIC");
3078 if (e_flags
& EF_BFIN_FDPIC
)
3079 strcat (buf
, ", FDPIC");
3081 if (e_flags
& EF_BFIN_CODE_IN_L1
)
3082 strcat (buf
, ", code in L1");
3084 if (e_flags
& EF_BFIN_DATA_IN_L1
)
3085 strcat (buf
, ", data in L1");
3090 switch (e_flags
& EF_FRV_CPU_MASK
)
3092 case EF_FRV_CPU_GENERIC
:
3096 strcat (buf
, ", fr???");
3099 case EF_FRV_CPU_FR300
:
3100 strcat (buf
, ", fr300");
3103 case EF_FRV_CPU_FR400
:
3104 strcat (buf
, ", fr400");
3106 case EF_FRV_CPU_FR405
:
3107 strcat (buf
, ", fr405");
3110 case EF_FRV_CPU_FR450
:
3111 strcat (buf
, ", fr450");
3114 case EF_FRV_CPU_FR500
:
3115 strcat (buf
, ", fr500");
3117 case EF_FRV_CPU_FR550
:
3118 strcat (buf
, ", fr550");
3121 case EF_FRV_CPU_SIMPLE
:
3122 strcat (buf
, ", simple");
3124 case EF_FRV_CPU_TOMCAT
:
3125 strcat (buf
, ", tomcat");
3131 if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_M68000
)
3132 strcat (buf
, ", m68000");
3133 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_CPU32
)
3134 strcat (buf
, ", cpu32");
3135 else if ((e_flags
& EF_M68K_ARCH_MASK
) == EF_M68K_FIDO
)
3136 strcat (buf
, ", fido_a");
3139 char const * isa
= _("unknown");
3140 char const * mac
= _("unknown mac");
3141 char const * additional
= NULL
;
3143 switch (e_flags
& EF_M68K_CF_ISA_MASK
)
3145 case EF_M68K_CF_ISA_A_NODIV
:
3147 additional
= ", nodiv";
3149 case EF_M68K_CF_ISA_A
:
3152 case EF_M68K_CF_ISA_A_PLUS
:
3155 case EF_M68K_CF_ISA_B_NOUSP
:
3157 additional
= ", nousp";
3159 case EF_M68K_CF_ISA_B
:
3162 case EF_M68K_CF_ISA_C
:
3165 case EF_M68K_CF_ISA_C_NODIV
:
3167 additional
= ", nodiv";
3170 strcat (buf
, ", cf, isa ");
3173 strcat (buf
, additional
);
3174 if (e_flags
& EF_M68K_CF_FLOAT
)
3175 strcat (buf
, ", float");
3176 switch (e_flags
& EF_M68K_CF_MAC_MASK
)
3181 case EF_M68K_CF_MAC
:
3184 case EF_M68K_CF_EMAC
:
3187 case EF_M68K_CF_EMAC_B
:
3200 switch (e_flags
& EF_MEP_CPU_MASK
)
3202 case EF_MEP_CPU_MEP
: strcat (buf
, ", generic MeP"); break;
3203 case EF_MEP_CPU_C2
: strcat (buf
, ", MeP C2"); break;
3204 case EF_MEP_CPU_C3
: strcat (buf
, ", MeP C3"); break;
3205 case EF_MEP_CPU_C4
: strcat (buf
, ", MeP C4"); break;
3206 case EF_MEP_CPU_C5
: strcat (buf
, ", MeP C5"); break;
3207 case EF_MEP_CPU_H1
: strcat (buf
, ", MeP H1"); break;
3208 default: strcat (buf
, _(", <unknown MeP cpu type>")); break;
3211 switch (e_flags
& EF_MEP_COP_MASK
)
3213 case EF_MEP_COP_NONE
: break;
3214 case EF_MEP_COP_AVC
: strcat (buf
, ", AVC coprocessor"); break;
3215 case EF_MEP_COP_AVC2
: strcat (buf
, ", AVC2 coprocessor"); break;
3216 case EF_MEP_COP_FMAX
: strcat (buf
, ", FMAX coprocessor"); break;
3217 case EF_MEP_COP_IVC2
: strcat (buf
, ", IVC2 coprocessor"); break;
3218 default: strcat (buf
, _("<unknown MeP copro type>")); break;
3221 if (e_flags
& EF_MEP_LIBRARY
)
3222 strcat (buf
, ", Built for Library");
3224 if (e_flags
& EF_MEP_INDEX_MASK
)
3225 sprintf (buf
+ strlen (buf
), ", Configuration Index: %#x",
3226 e_flags
& EF_MEP_INDEX_MASK
);
3228 if (e_flags
& ~ EF_MEP_ALL_FLAGS
)
3229 sprintf (buf
+ strlen (buf
), _(", unknown flags bits: %#x"),
3230 e_flags
& ~ EF_MEP_ALL_FLAGS
);
3234 if (e_flags
& EF_PPC_EMB
)
3235 strcat (buf
, ", emb");
3237 if (e_flags
& EF_PPC_RELOCATABLE
)
3238 strcat (buf
, _(", relocatable"));
3240 if (e_flags
& EF_PPC_RELOCATABLE_LIB
)
3241 strcat (buf
, _(", relocatable-lib"));
3245 if (e_flags
& EF_PPC64_ABI
)
3247 char abi
[] = ", abiv0";
3249 abi
[6] += e_flags
& EF_PPC64_ABI
;
3255 if ((e_flags
& EF_RH850_ABI
) == EF_RH850_ABI
)
3256 strcat (buf
, ", RH850 ABI");
3258 if (e_flags
& EF_V800_850E3
)
3259 strcat (buf
, ", V3 architecture");
3261 if ((e_flags
& (EF_RH850_FPU_DOUBLE
| EF_RH850_FPU_SINGLE
)) == 0)
3262 strcat (buf
, ", FPU not used");
3264 if ((e_flags
& (EF_RH850_REGMODE22
| EF_RH850_REGMODE32
)) == 0)
3265 strcat (buf
, ", regmode: COMMON");
3267 if ((e_flags
& (EF_RH850_GP_FIX
| EF_RH850_GP_NOFIX
)) == 0)
3268 strcat (buf
, ", r4 not used");
3270 if ((e_flags
& (EF_RH850_EP_FIX
| EF_RH850_EP_NOFIX
)) == 0)
3271 strcat (buf
, ", r30 not used");
3273 if ((e_flags
& (EF_RH850_TP_FIX
| EF_RH850_TP_NOFIX
)) == 0)
3274 strcat (buf
, ", r5 not used");
3276 if ((e_flags
& (EF_RH850_REG2_RESERVE
| EF_RH850_REG2_NORESERVE
)) == 0)
3277 strcat (buf
, ", r2 not used");
3279 for (e_flags
&= 0xFFFF; e_flags
; e_flags
&= ~ (e_flags
& - e_flags
))
3281 switch (e_flags
& - e_flags
)
3283 case EF_RH850_FPU_DOUBLE
: strcat (buf
, ", double precision FPU"); break;
3284 case EF_RH850_FPU_SINGLE
: strcat (buf
, ", single precision FPU"); break;
3285 case EF_RH850_REGMODE22
: strcat (buf
, ", regmode:22"); break;
3286 case EF_RH850_REGMODE32
: strcat (buf
, ", regmode:23"); break;
3287 case EF_RH850_GP_FIX
: strcat (buf
, ", r4 fixed"); break;
3288 case EF_RH850_GP_NOFIX
: strcat (buf
, ", r4 free"); break;
3289 case EF_RH850_EP_FIX
: strcat (buf
, ", r30 fixed"); break;
3290 case EF_RH850_EP_NOFIX
: strcat (buf
, ", r30 free"); break;
3291 case EF_RH850_TP_FIX
: strcat (buf
, ", r5 fixed"); break;
3292 case EF_RH850_TP_NOFIX
: strcat (buf
, ", r5 free"); break;
3293 case EF_RH850_REG2_RESERVE
: strcat (buf
, ", r2 fixed"); break;
3294 case EF_RH850_REG2_NORESERVE
: strcat (buf
, ", r2 free"); break;
3301 case EM_CYGNUS_V850
:
3302 switch (e_flags
& EF_V850_ARCH
)
3304 case E_V850E3V5_ARCH
:
3305 strcat (buf
, ", v850e3v5");
3307 case E_V850E2V3_ARCH
:
3308 strcat (buf
, ", v850e2v3");
3311 strcat (buf
, ", v850e2");
3314 strcat (buf
, ", v850e1");
3317 strcat (buf
, ", v850e");
3320 strcat (buf
, ", v850");
3323 strcat (buf
, _(", unknown v850 architecture variant"));
3329 case EM_CYGNUS_M32R
:
3330 if ((e_flags
& EF_M32R_ARCH
) == E_M32R_ARCH
)
3331 strcat (buf
, ", m32r");
3335 case EM_MIPS_RS3_LE
:
3336 if (e_flags
& EF_MIPS_NOREORDER
)
3337 strcat (buf
, ", noreorder");
3339 if (e_flags
& EF_MIPS_PIC
)
3340 strcat (buf
, ", pic");
3342 if (e_flags
& EF_MIPS_CPIC
)
3343 strcat (buf
, ", cpic");
3345 if (e_flags
& EF_MIPS_UCODE
)
3346 strcat (buf
, ", ugen_reserved");
3348 if (e_flags
& EF_MIPS_ABI2
)
3349 strcat (buf
, ", abi2");
3351 if (e_flags
& EF_MIPS_OPTIONS_FIRST
)
3352 strcat (buf
, ", odk first");
3354 if (e_flags
& EF_MIPS_32BITMODE
)
3355 strcat (buf
, ", 32bitmode");
3357 if (e_flags
& EF_MIPS_NAN2008
)
3358 strcat (buf
, ", nan2008");
3360 if (e_flags
& EF_MIPS_FP64
)
3361 strcat (buf
, ", fp64");
3363 switch ((e_flags
& EF_MIPS_MACH
))
3365 case E_MIPS_MACH_3900
: strcat (buf
, ", 3900"); break;
3366 case E_MIPS_MACH_4010
: strcat (buf
, ", 4010"); break;
3367 case E_MIPS_MACH_4100
: strcat (buf
, ", 4100"); break;
3368 case E_MIPS_MACH_4111
: strcat (buf
, ", 4111"); break;
3369 case E_MIPS_MACH_4120
: strcat (buf
, ", 4120"); break;
3370 case E_MIPS_MACH_4650
: strcat (buf
, ", 4650"); break;
3371 case E_MIPS_MACH_5400
: strcat (buf
, ", 5400"); break;
3372 case E_MIPS_MACH_5500
: strcat (buf
, ", 5500"); break;
3373 case E_MIPS_MACH_5900
: strcat (buf
, ", 5900"); break;
3374 case E_MIPS_MACH_SB1
: strcat (buf
, ", sb1"); break;
3375 case E_MIPS_MACH_9000
: strcat (buf
, ", 9000"); break;
3376 case E_MIPS_MACH_LS2E
: strcat (buf
, ", loongson-2e"); break;
3377 case E_MIPS_MACH_LS2F
: strcat (buf
, ", loongson-2f"); break;
3378 case E_MIPS_MACH_LS3A
: strcat (buf
, ", loongson-3a"); break;
3379 case E_MIPS_MACH_OCTEON
: strcat (buf
, ", octeon"); break;
3380 case E_MIPS_MACH_OCTEON2
: strcat (buf
, ", octeon2"); break;
3381 case E_MIPS_MACH_OCTEON3
: strcat (buf
, ", octeon3"); break;
3382 case E_MIPS_MACH_XLR
: strcat (buf
, ", xlr"); break;
3383 case E_MIPS_MACH_IAMR2
: strcat (buf
, ", interaptiv-mr2"); break;
3385 /* We simply ignore the field in this case to avoid confusion:
3386 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3389 default: strcat (buf
, _(", unknown CPU")); break;
3392 switch ((e_flags
& EF_MIPS_ABI
))
3394 case E_MIPS_ABI_O32
: strcat (buf
, ", o32"); break;
3395 case E_MIPS_ABI_O64
: strcat (buf
, ", o64"); break;
3396 case E_MIPS_ABI_EABI32
: strcat (buf
, ", eabi32"); break;
3397 case E_MIPS_ABI_EABI64
: strcat (buf
, ", eabi64"); break;
3399 /* We simply ignore the field in this case to avoid confusion:
3400 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3401 This means it is likely to be an o32 file, but not for
3404 default: strcat (buf
, _(", unknown ABI")); break;
3407 if (e_flags
& EF_MIPS_ARCH_ASE_MDMX
)
3408 strcat (buf
, ", mdmx");
3410 if (e_flags
& EF_MIPS_ARCH_ASE_M16
)
3411 strcat (buf
, ", mips16");
3413 if (e_flags
& EF_MIPS_ARCH_ASE_MICROMIPS
)
3414 strcat (buf
, ", micromips");
3416 switch ((e_flags
& EF_MIPS_ARCH
))
3418 case E_MIPS_ARCH_1
: strcat (buf
, ", mips1"); break;
3419 case E_MIPS_ARCH_2
: strcat (buf
, ", mips2"); break;
3420 case E_MIPS_ARCH_3
: strcat (buf
, ", mips3"); break;
3421 case E_MIPS_ARCH_4
: strcat (buf
, ", mips4"); break;
3422 case E_MIPS_ARCH_5
: strcat (buf
, ", mips5"); break;
3423 case E_MIPS_ARCH_32
: strcat (buf
, ", mips32"); break;
3424 case E_MIPS_ARCH_32R2
: strcat (buf
, ", mips32r2"); break;
3425 case E_MIPS_ARCH_32R6
: strcat (buf
, ", mips32r6"); break;
3426 case E_MIPS_ARCH_64
: strcat (buf
, ", mips64"); break;
3427 case E_MIPS_ARCH_64R2
: strcat (buf
, ", mips64r2"); break;
3428 case E_MIPS_ARCH_64R6
: strcat (buf
, ", mips64r6"); break;
3429 default: strcat (buf
, _(", unknown ISA")); break;
3434 decode_NDS32_machine_flags (e_flags
, buf
, sizeof buf
);
3438 if (e_flags
& EF_RISCV_RVC
)
3439 strcat (buf
, ", RVC");
3441 switch (e_flags
& EF_RISCV_FLOAT_ABI
)
3443 case EF_RISCV_FLOAT_ABI_SOFT
:
3444 strcat (buf
, ", soft-float ABI");
3447 case EF_RISCV_FLOAT_ABI_SINGLE
:
3448 strcat (buf
, ", single-float ABI");
3451 case EF_RISCV_FLOAT_ABI_DOUBLE
:
3452 strcat (buf
, ", double-float ABI");
3455 case EF_RISCV_FLOAT_ABI_QUAD
:
3456 strcat (buf
, ", quad-float ABI");
3462 switch ((e_flags
& EF_SH_MACH_MASK
))
3464 case EF_SH1
: strcat (buf
, ", sh1"); break;
3465 case EF_SH2
: strcat (buf
, ", sh2"); break;
3466 case EF_SH3
: strcat (buf
, ", sh3"); break;
3467 case EF_SH_DSP
: strcat (buf
, ", sh-dsp"); break;
3468 case EF_SH3_DSP
: strcat (buf
, ", sh3-dsp"); break;
3469 case EF_SH4AL_DSP
: strcat (buf
, ", sh4al-dsp"); break;
3470 case EF_SH3E
: strcat (buf
, ", sh3e"); break;
3471 case EF_SH4
: strcat (buf
, ", sh4"); break;
3472 case EF_SH5
: strcat (buf
, ", sh5"); break;
3473 case EF_SH2E
: strcat (buf
, ", sh2e"); break;
3474 case EF_SH4A
: strcat (buf
, ", sh4a"); break;
3475 case EF_SH2A
: strcat (buf
, ", sh2a"); break;
3476 case EF_SH4_NOFPU
: strcat (buf
, ", sh4-nofpu"); break;
3477 case EF_SH4A_NOFPU
: strcat (buf
, ", sh4a-nofpu"); break;
3478 case EF_SH2A_NOFPU
: strcat (buf
, ", sh2a-nofpu"); break;
3479 case EF_SH3_NOMMU
: strcat (buf
, ", sh3-nommu"); break;
3480 case EF_SH4_NOMMU_NOFPU
: strcat (buf
, ", sh4-nommu-nofpu"); break;
3481 case EF_SH2A_SH4_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3482 case EF_SH2A_SH3_NOFPU
: strcat (buf
, ", sh2a-nofpu-or-sh3-nommu"); break;
3483 case EF_SH2A_SH4
: strcat (buf
, ", sh2a-or-sh4"); break;
3484 case EF_SH2A_SH3E
: strcat (buf
, ", sh2a-or-sh3e"); break;
3485 default: strcat (buf
, _(", unknown ISA")); break;
3488 if (e_flags
& EF_SH_PIC
)
3489 strcat (buf
, ", pic");
3491 if (e_flags
& EF_SH_FDPIC
)
3492 strcat (buf
, ", fdpic");
3496 if (e_flags
& EF_OR1K_NODELAY
)
3497 strcat (buf
, ", no delay");
3501 if (e_flags
& EF_SPARC_32PLUS
)
3502 strcat (buf
, ", v8+");
3504 if (e_flags
& EF_SPARC_SUN_US1
)
3505 strcat (buf
, ", ultrasparcI");
3507 if (e_flags
& EF_SPARC_SUN_US3
)
3508 strcat (buf
, ", ultrasparcIII");
3510 if (e_flags
& EF_SPARC_HAL_R1
)
3511 strcat (buf
, ", halr1");
3513 if (e_flags
& EF_SPARC_LEDATA
)
3514 strcat (buf
, ", ledata");
3516 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_TSO
)
3517 strcat (buf
, ", tso");
3519 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_PSO
)
3520 strcat (buf
, ", pso");
3522 if ((e_flags
& EF_SPARCV9_MM
) == EF_SPARCV9_RMO
)
3523 strcat (buf
, ", rmo");
3527 switch (e_flags
& EF_PARISC_ARCH
)
3529 case EFA_PARISC_1_0
:
3530 strcpy (buf
, ", PA-RISC 1.0");
3532 case EFA_PARISC_1_1
:
3533 strcpy (buf
, ", PA-RISC 1.1");
3535 case EFA_PARISC_2_0
:
3536 strcpy (buf
, ", PA-RISC 2.0");
3541 if (e_flags
& EF_PARISC_TRAPNIL
)
3542 strcat (buf
, ", trapnil");
3543 if (e_flags
& EF_PARISC_EXT
)
3544 strcat (buf
, ", ext");
3545 if (e_flags
& EF_PARISC_LSB
)
3546 strcat (buf
, ", lsb");
3547 if (e_flags
& EF_PARISC_WIDE
)
3548 strcat (buf
, ", wide");
3549 if (e_flags
& EF_PARISC_NO_KABP
)
3550 strcat (buf
, ", no kabp");
3551 if (e_flags
& EF_PARISC_LAZYSWAP
)
3552 strcat (buf
, ", lazyswap");
3557 if ((e_flags
& EF_PICOJAVA_NEWCALLS
) == EF_PICOJAVA_NEWCALLS
)
3558 strcat (buf
, ", new calling convention");
3560 if ((e_flags
& EF_PICOJAVA_GNUCALLS
) == EF_PICOJAVA_GNUCALLS
)
3561 strcat (buf
, ", gnu calling convention");
3565 if ((e_flags
& EF_IA_64_ABI64
))
3566 strcat (buf
, ", 64-bit");
3568 strcat (buf
, ", 32-bit");
3569 if ((e_flags
& EF_IA_64_REDUCEDFP
))
3570 strcat (buf
, ", reduced fp model");
3571 if ((e_flags
& EF_IA_64_NOFUNCDESC_CONS_GP
))
3572 strcat (buf
, ", no function descriptors, constant gp");
3573 else if ((e_flags
& EF_IA_64_CONS_GP
))
3574 strcat (buf
, ", constant gp");
3575 if ((e_flags
& EF_IA_64_ABSOLUTE
))
3576 strcat (buf
, ", absolute");
3577 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
3579 if ((e_flags
& EF_IA_64_VMS_LINKAGES
))
3580 strcat (buf
, ", vms_linkages");
3581 switch ((e_flags
& EF_IA_64_VMS_COMCOD
))
3583 case EF_IA_64_VMS_COMCOD_SUCCESS
:
3585 case EF_IA_64_VMS_COMCOD_WARNING
:
3586 strcat (buf
, ", warning");
3588 case EF_IA_64_VMS_COMCOD_ERROR
:
3589 strcat (buf
, ", error");
3591 case EF_IA_64_VMS_COMCOD_ABORT
:
3592 strcat (buf
, ", abort");
3595 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3596 e_flags
& EF_IA_64_VMS_COMCOD
);
3597 strcat (buf
, ", <unknown>");
3603 if ((e_flags
& EF_VAX_NONPIC
))
3604 strcat (buf
, ", non-PIC");
3605 if ((e_flags
& EF_VAX_DFLOAT
))
3606 strcat (buf
, ", D-Float");
3607 if ((e_flags
& EF_VAX_GFLOAT
))
3608 strcat (buf
, ", G-Float");
3612 if (e_flags
& EF_VISIUM_ARCH_MCM
)
3613 strcat (buf
, ", mcm");
3614 else if (e_flags
& EF_VISIUM_ARCH_MCM24
)
3615 strcat (buf
, ", mcm24");
3616 if (e_flags
& EF_VISIUM_ARCH_GR6
)
3617 strcat (buf
, ", gr6");
3621 switch (e_flags
& E_FLAG_RL78_CPU_MASK
)
3623 case E_FLAG_RL78_ANY_CPU
: break;
3624 case E_FLAG_RL78_G10
: strcat (buf
, ", G10"); break;
3625 case E_FLAG_RL78_G13
: strcat (buf
, ", G13"); break;
3626 case E_FLAG_RL78_G14
: strcat (buf
, ", G14"); break;
3628 if (e_flags
& E_FLAG_RL78_64BIT_DOUBLES
)
3629 strcat (buf
, ", 64-bit doubles");
3633 if (e_flags
& E_FLAG_RX_64BIT_DOUBLES
)
3634 strcat (buf
, ", 64-bit doubles");
3635 if (e_flags
& E_FLAG_RX_DSP
)
3636 strcat (buf
, ", dsp");
3637 if (e_flags
& E_FLAG_RX_PID
)
3638 strcat (buf
, ", pid");
3639 if (e_flags
& E_FLAG_RX_ABI
)
3640 strcat (buf
, ", RX ABI");
3641 if (e_flags
& E_FLAG_RX_SINSNS_SET
)
3642 strcat (buf
, e_flags
& E_FLAG_RX_SINSNS_YES
3643 ? ", uses String instructions" : ", bans String instructions");
3644 if (e_flags
& E_FLAG_RX_V2
)
3645 strcat (buf
, ", V2");
3649 if (e_flags
& EF_S390_HIGH_GPRS
)
3650 strcat (buf
, ", highgprs");
3654 if ((e_flags
& EF_C6000_REL
))
3655 strcat (buf
, ", relocatable module");
3659 strcat (buf
, _(": architecture variant: "));
3660 switch (e_flags
& EF_MSP430_MACH
)
3662 case E_MSP430_MACH_MSP430x11
: strcat (buf
, "MSP430x11"); break;
3663 case E_MSP430_MACH_MSP430x11x1
: strcat (buf
, "MSP430x11x1 "); break;
3664 case E_MSP430_MACH_MSP430x12
: strcat (buf
, "MSP430x12"); break;
3665 case E_MSP430_MACH_MSP430x13
: strcat (buf
, "MSP430x13"); break;
3666 case E_MSP430_MACH_MSP430x14
: strcat (buf
, "MSP430x14"); break;
3667 case E_MSP430_MACH_MSP430x15
: strcat (buf
, "MSP430x15"); break;
3668 case E_MSP430_MACH_MSP430x16
: strcat (buf
, "MSP430x16"); break;
3669 case E_MSP430_MACH_MSP430x31
: strcat (buf
, "MSP430x31"); break;
3670 case E_MSP430_MACH_MSP430x32
: strcat (buf
, "MSP430x32"); break;
3671 case E_MSP430_MACH_MSP430x33
: strcat (buf
, "MSP430x33"); break;
3672 case E_MSP430_MACH_MSP430x41
: strcat (buf
, "MSP430x41"); break;
3673 case E_MSP430_MACH_MSP430x42
: strcat (buf
, "MSP430x42"); break;
3674 case E_MSP430_MACH_MSP430x43
: strcat (buf
, "MSP430x43"); break;
3675 case E_MSP430_MACH_MSP430x44
: strcat (buf
, "MSP430x44"); break;
3676 case E_MSP430_MACH_MSP430X
: strcat (buf
, "MSP430X"); break;
3678 strcat (buf
, _(": unknown")); break;
3681 if (e_flags
& ~ EF_MSP430_MACH
)
3682 strcat (buf
, _(": unknown extra flag bits also present"));
3690 get_osabi_name (Filedata
* filedata
, unsigned int osabi
)
3692 static char buff
[32];
3696 case ELFOSABI_NONE
: return "UNIX - System V";
3697 case ELFOSABI_HPUX
: return "UNIX - HP-UX";
3698 case ELFOSABI_NETBSD
: return "UNIX - NetBSD";
3699 case ELFOSABI_GNU
: return "UNIX - GNU";
3700 case ELFOSABI_SOLARIS
: return "UNIX - Solaris";
3701 case ELFOSABI_AIX
: return "UNIX - AIX";
3702 case ELFOSABI_IRIX
: return "UNIX - IRIX";
3703 case ELFOSABI_FREEBSD
: return "UNIX - FreeBSD";
3704 case ELFOSABI_TRU64
: return "UNIX - TRU64";
3705 case ELFOSABI_MODESTO
: return "Novell - Modesto";
3706 case ELFOSABI_OPENBSD
: return "UNIX - OpenBSD";
3707 case ELFOSABI_OPENVMS
: return "VMS - OpenVMS";
3708 case ELFOSABI_NSK
: return "HP - Non-Stop Kernel";
3709 case ELFOSABI_AROS
: return "AROS";
3710 case ELFOSABI_FENIXOS
: return "FenixOS";
3711 case ELFOSABI_CLOUDABI
: return "Nuxi CloudABI";
3712 case ELFOSABI_OPENVOS
: return "Stratus Technologies OpenVOS";
3715 switch (filedata
->file_header
.e_machine
)
3720 case ELFOSABI_ARM
: return "ARM";
3731 case ELFOSABI_STANDALONE
: return _("Standalone App");
3740 case ELFOSABI_C6000_ELFABI
: return _("Bare-metal C6000");
3741 case ELFOSABI_C6000_LINUX
: return "Linux C6000";
3750 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), osabi
);
3756 get_aarch64_segment_type (unsigned long type
)
3760 case PT_AARCH64_ARCHEXT
: return "AARCH64_ARCHEXT";
3761 default: return NULL
;
3766 get_arm_segment_type (unsigned long type
)
3770 case PT_ARM_EXIDX
: return "EXIDX";
3771 default: return NULL
;
3776 get_s390_segment_type (unsigned long type
)
3780 case PT_S390_PGSTE
: return "S390_PGSTE";
3781 default: return NULL
;
3786 get_mips_segment_type (unsigned long type
)
3790 case PT_MIPS_REGINFO
: return "REGINFO";
3791 case PT_MIPS_RTPROC
: return "RTPROC";
3792 case PT_MIPS_OPTIONS
: return "OPTIONS";
3793 case PT_MIPS_ABIFLAGS
: return "ABIFLAGS";
3794 default: return NULL
;
3799 get_parisc_segment_type (unsigned long type
)
3803 case PT_HP_TLS
: return "HP_TLS";
3804 case PT_HP_CORE_NONE
: return "HP_CORE_NONE";
3805 case PT_HP_CORE_VERSION
: return "HP_CORE_VERSION";
3806 case PT_HP_CORE_KERNEL
: return "HP_CORE_KERNEL";
3807 case PT_HP_CORE_COMM
: return "HP_CORE_COMM";
3808 case PT_HP_CORE_PROC
: return "HP_CORE_PROC";
3809 case PT_HP_CORE_LOADABLE
: return "HP_CORE_LOADABLE";
3810 case PT_HP_CORE_STACK
: return "HP_CORE_STACK";
3811 case PT_HP_CORE_SHM
: return "HP_CORE_SHM";
3812 case PT_HP_CORE_MMF
: return "HP_CORE_MMF";
3813 case PT_HP_PARALLEL
: return "HP_PARALLEL";
3814 case PT_HP_FASTBIND
: return "HP_FASTBIND";
3815 case PT_HP_OPT_ANNOT
: return "HP_OPT_ANNOT";
3816 case PT_HP_HSL_ANNOT
: return "HP_HSL_ANNOT";
3817 case PT_HP_STACK
: return "HP_STACK";
3818 case PT_HP_CORE_UTSNAME
: return "HP_CORE_UTSNAME";
3819 case PT_PARISC_ARCHEXT
: return "PARISC_ARCHEXT";
3820 case PT_PARISC_UNWIND
: return "PARISC_UNWIND";
3821 case PT_PARISC_WEAKORDER
: return "PARISC_WEAKORDER";
3822 default: return NULL
;
3827 get_ia64_segment_type (unsigned long type
)
3831 case PT_IA_64_ARCHEXT
: return "IA_64_ARCHEXT";
3832 case PT_IA_64_UNWIND
: return "IA_64_UNWIND";
3833 case PT_HP_TLS
: return "HP_TLS";
3834 case PT_IA_64_HP_OPT_ANOT
: return "HP_OPT_ANNOT";
3835 case PT_IA_64_HP_HSL_ANOT
: return "HP_HSL_ANNOT";
3836 case PT_IA_64_HP_STACK
: return "HP_STACK";
3837 default: return NULL
;
3842 get_tic6x_segment_type (unsigned long type
)
3846 case PT_C6000_PHATTR
: return "C6000_PHATTR";
3847 default: return NULL
;
3852 get_solaris_segment_type (unsigned long type
)
3856 case 0x6464e550: return "PT_SUNW_UNWIND";
3857 case 0x6474e550: return "PT_SUNW_EH_FRAME";
3858 case 0x6ffffff7: return "PT_LOSUNW";
3859 case 0x6ffffffa: return "PT_SUNWBSS";
3860 case 0x6ffffffb: return "PT_SUNWSTACK";
3861 case 0x6ffffffc: return "PT_SUNWDTRACE";
3862 case 0x6ffffffd: return "PT_SUNWCAP";
3863 case 0x6fffffff: return "PT_HISUNW";
3864 default: return NULL
;
3869 get_segment_type (Filedata
* filedata
, unsigned long p_type
)
3871 static char buff
[32];
3875 case PT_NULL
: return "NULL";
3876 case PT_LOAD
: return "LOAD";
3877 case PT_DYNAMIC
: return "DYNAMIC";
3878 case PT_INTERP
: return "INTERP";
3879 case PT_NOTE
: return "NOTE";
3880 case PT_SHLIB
: return "SHLIB";
3881 case PT_PHDR
: return "PHDR";
3882 case PT_TLS
: return "TLS";
3883 case PT_GNU_EH_FRAME
: return "GNU_EH_FRAME";
3884 case PT_GNU_STACK
: return "GNU_STACK";
3885 case PT_GNU_RELRO
: return "GNU_RELRO";
3888 if (p_type
>= PT_GNU_MBIND_LO
&& p_type
<= PT_GNU_MBIND_HI
)
3890 sprintf (buff
, "GNU_MBIND+%#lx",
3891 p_type
- PT_GNU_MBIND_LO
);
3893 else if ((p_type
>= PT_LOPROC
) && (p_type
<= PT_HIPROC
))
3895 const char * result
;
3897 switch (filedata
->file_header
.e_machine
)
3900 result
= get_aarch64_segment_type (p_type
);
3903 result
= get_arm_segment_type (p_type
);
3906 case EM_MIPS_RS3_LE
:
3907 result
= get_mips_segment_type (p_type
);
3910 result
= get_parisc_segment_type (p_type
);
3913 result
= get_ia64_segment_type (p_type
);
3916 result
= get_tic6x_segment_type (p_type
);
3920 result
= get_s390_segment_type (p_type
);
3930 sprintf (buff
, "LOPROC+%#lx", p_type
- PT_LOPROC
);
3932 else if ((p_type
>= PT_LOOS
) && (p_type
<= PT_HIOS
))
3934 const char * result
;
3936 switch (filedata
->file_header
.e_machine
)
3939 result
= get_parisc_segment_type (p_type
);
3942 result
= get_ia64_segment_type (p_type
);
3945 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
3946 result
= get_solaris_segment_type (p_type
);
3955 sprintf (buff
, "LOOS+%#lx", p_type
- PT_LOOS
);
3958 snprintf (buff
, sizeof (buff
), _("<unknown>: %lx"), p_type
);
3965 get_arc_section_type_name (unsigned int sh_type
)
3969 case SHT_ARC_ATTRIBUTES
: return "ARC_ATTRIBUTES";
3977 get_mips_section_type_name (unsigned int sh_type
)
3981 case SHT_MIPS_LIBLIST
: return "MIPS_LIBLIST";
3982 case SHT_MIPS_MSYM
: return "MIPS_MSYM";
3983 case SHT_MIPS_CONFLICT
: return "MIPS_CONFLICT";
3984 case SHT_MIPS_GPTAB
: return "MIPS_GPTAB";
3985 case SHT_MIPS_UCODE
: return "MIPS_UCODE";
3986 case SHT_MIPS_DEBUG
: return "MIPS_DEBUG";
3987 case SHT_MIPS_REGINFO
: return "MIPS_REGINFO";
3988 case SHT_MIPS_PACKAGE
: return "MIPS_PACKAGE";
3989 case SHT_MIPS_PACKSYM
: return "MIPS_PACKSYM";
3990 case SHT_MIPS_RELD
: return "MIPS_RELD";
3991 case SHT_MIPS_IFACE
: return "MIPS_IFACE";
3992 case SHT_MIPS_CONTENT
: return "MIPS_CONTENT";
3993 case SHT_MIPS_OPTIONS
: return "MIPS_OPTIONS";
3994 case SHT_MIPS_SHDR
: return "MIPS_SHDR";
3995 case SHT_MIPS_FDESC
: return "MIPS_FDESC";
3996 case SHT_MIPS_EXTSYM
: return "MIPS_EXTSYM";
3997 case SHT_MIPS_DENSE
: return "MIPS_DENSE";
3998 case SHT_MIPS_PDESC
: return "MIPS_PDESC";
3999 case SHT_MIPS_LOCSYM
: return "MIPS_LOCSYM";
4000 case SHT_MIPS_AUXSYM
: return "MIPS_AUXSYM";
4001 case SHT_MIPS_OPTSYM
: return "MIPS_OPTSYM";
4002 case SHT_MIPS_LOCSTR
: return "MIPS_LOCSTR";
4003 case SHT_MIPS_LINE
: return "MIPS_LINE";
4004 case SHT_MIPS_RFDESC
: return "MIPS_RFDESC";
4005 case SHT_MIPS_DELTASYM
: return "MIPS_DELTASYM";
4006 case SHT_MIPS_DELTAINST
: return "MIPS_DELTAINST";
4007 case SHT_MIPS_DELTACLASS
: return "MIPS_DELTACLASS";
4008 case SHT_MIPS_DWARF
: return "MIPS_DWARF";
4009 case SHT_MIPS_DELTADECL
: return "MIPS_DELTADECL";
4010 case SHT_MIPS_SYMBOL_LIB
: return "MIPS_SYMBOL_LIB";
4011 case SHT_MIPS_EVENTS
: return "MIPS_EVENTS";
4012 case SHT_MIPS_TRANSLATE
: return "MIPS_TRANSLATE";
4013 case SHT_MIPS_PIXIE
: return "MIPS_PIXIE";
4014 case SHT_MIPS_XLATE
: return "MIPS_XLATE";
4015 case SHT_MIPS_XLATE_DEBUG
: return "MIPS_XLATE_DEBUG";
4016 case SHT_MIPS_WHIRL
: return "MIPS_WHIRL";
4017 case SHT_MIPS_EH_REGION
: return "MIPS_EH_REGION";
4018 case SHT_MIPS_XLATE_OLD
: return "MIPS_XLATE_OLD";
4019 case SHT_MIPS_PDR_EXCEPTION
: return "MIPS_PDR_EXCEPTION";
4020 case SHT_MIPS_ABIFLAGS
: return "MIPS_ABIFLAGS";
4028 get_parisc_section_type_name (unsigned int sh_type
)
4032 case SHT_PARISC_EXT
: return "PARISC_EXT";
4033 case SHT_PARISC_UNWIND
: return "PARISC_UNWIND";
4034 case SHT_PARISC_DOC
: return "PARISC_DOC";
4035 case SHT_PARISC_ANNOT
: return "PARISC_ANNOT";
4036 case SHT_PARISC_SYMEXTN
: return "PARISC_SYMEXTN";
4037 case SHT_PARISC_STUBS
: return "PARISC_STUBS";
4038 case SHT_PARISC_DLKM
: return "PARISC_DLKM";
4039 default: return NULL
;
4044 get_ia64_section_type_name (Filedata
* filedata
, unsigned int sh_type
)
4046 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
4047 if ((sh_type
& 0xFF000000) == SHT_IA_64_LOPSREG
)
4048 return get_osabi_name (filedata
, (sh_type
& 0x00FF0000) >> 16);
4052 case SHT_IA_64_EXT
: return "IA_64_EXT";
4053 case SHT_IA_64_UNWIND
: return "IA_64_UNWIND";
4054 case SHT_IA_64_PRIORITY_INIT
: return "IA_64_PRIORITY_INIT";
4055 case SHT_IA_64_VMS_TRACE
: return "VMS_TRACE";
4056 case SHT_IA_64_VMS_TIE_SIGNATURES
: return "VMS_TIE_SIGNATURES";
4057 case SHT_IA_64_VMS_DEBUG
: return "VMS_DEBUG";
4058 case SHT_IA_64_VMS_DEBUG_STR
: return "VMS_DEBUG_STR";
4059 case SHT_IA_64_VMS_LINKAGES
: return "VMS_LINKAGES";
4060 case SHT_IA_64_VMS_SYMBOL_VECTOR
: return "VMS_SYMBOL_VECTOR";
4061 case SHT_IA_64_VMS_FIXUP
: return "VMS_FIXUP";
4069 get_x86_64_section_type_name (unsigned int sh_type
)
4073 case SHT_X86_64_UNWIND
: return "X86_64_UNWIND";
4074 default: return NULL
;
4079 get_aarch64_section_type_name (unsigned int sh_type
)
4083 case SHT_AARCH64_ATTRIBUTES
: return "AARCH64_ATTRIBUTES";
4084 default: return NULL
;
4089 get_arm_section_type_name (unsigned int sh_type
)
4093 case SHT_ARM_EXIDX
: return "ARM_EXIDX";
4094 case SHT_ARM_PREEMPTMAP
: return "ARM_PREEMPTMAP";
4095 case SHT_ARM_ATTRIBUTES
: return "ARM_ATTRIBUTES";
4096 case SHT_ARM_DEBUGOVERLAY
: return "ARM_DEBUGOVERLAY";
4097 case SHT_ARM_OVERLAYSECTION
: return "ARM_OVERLAYSECTION";
4098 default: return NULL
;
4103 get_tic6x_section_type_name (unsigned int sh_type
)
4107 case SHT_C6000_UNWIND
: return "C6000_UNWIND";
4108 case SHT_C6000_PREEMPTMAP
: return "C6000_PREEMPTMAP";
4109 case SHT_C6000_ATTRIBUTES
: return "C6000_ATTRIBUTES";
4110 case SHT_TI_ICODE
: return "TI_ICODE";
4111 case SHT_TI_XREF
: return "TI_XREF";
4112 case SHT_TI_HANDLER
: return "TI_HANDLER";
4113 case SHT_TI_INITINFO
: return "TI_INITINFO";
4114 case SHT_TI_PHATTRS
: return "TI_PHATTRS";
4115 default: return NULL
;
4120 get_msp430x_section_type_name (unsigned int sh_type
)
4124 case SHT_MSP430_SEC_FLAGS
: return "MSP430_SEC_FLAGS";
4125 case SHT_MSP430_SYM_ALIASES
: return "MSP430_SYM_ALIASES";
4126 case SHT_MSP430_ATTRIBUTES
: return "MSP430_ATTRIBUTES";
4127 default: return NULL
;
4132 get_v850_section_type_name (unsigned int sh_type
)
4136 case SHT_V850_SCOMMON
: return "V850 Small Common";
4137 case SHT_V850_TCOMMON
: return "V850 Tiny Common";
4138 case SHT_V850_ZCOMMON
: return "V850 Zero Common";
4139 case SHT_RENESAS_IOP
: return "RENESAS IOP";
4140 case SHT_RENESAS_INFO
: return "RENESAS INFO";
4141 default: return NULL
;
4146 get_section_type_name (Filedata
* filedata
, unsigned int sh_type
)
4148 static char buff
[32];
4149 const char * result
;
4153 case SHT_NULL
: return "NULL";
4154 case SHT_PROGBITS
: return "PROGBITS";
4155 case SHT_SYMTAB
: return "SYMTAB";
4156 case SHT_STRTAB
: return "STRTAB";
4157 case SHT_RELA
: return "RELA";
4158 case SHT_HASH
: return "HASH";
4159 case SHT_DYNAMIC
: return "DYNAMIC";
4160 case SHT_NOTE
: return "NOTE";
4161 case SHT_NOBITS
: return "NOBITS";
4162 case SHT_REL
: return "REL";
4163 case SHT_SHLIB
: return "SHLIB";
4164 case SHT_DYNSYM
: return "DYNSYM";
4165 case SHT_INIT_ARRAY
: return "INIT_ARRAY";
4166 case SHT_FINI_ARRAY
: return "FINI_ARRAY";
4167 case SHT_PREINIT_ARRAY
: return "PREINIT_ARRAY";
4168 case SHT_GNU_HASH
: return "GNU_HASH";
4169 case SHT_GROUP
: return "GROUP";
4170 case SHT_SYMTAB_SHNDX
: return "SYMTAB SECTION INDICIES";
4171 case SHT_GNU_verdef
: return "VERDEF";
4172 case SHT_GNU_verneed
: return "VERNEED";
4173 case SHT_GNU_versym
: return "VERSYM";
4174 case 0x6ffffff0: return "VERSYM";
4175 case 0x6ffffffc: return "VERDEF";
4176 case 0x7ffffffd: return "AUXILIARY";
4177 case 0x7fffffff: return "FILTER";
4178 case SHT_GNU_LIBLIST
: return "GNU_LIBLIST";
4181 if ((sh_type
>= SHT_LOPROC
) && (sh_type
<= SHT_HIPROC
))
4183 switch (filedata
->file_header
.e_machine
)
4186 case EM_ARC_COMPACT
:
4187 case EM_ARC_COMPACT2
:
4188 result
= get_arc_section_type_name (sh_type
);
4191 case EM_MIPS_RS3_LE
:
4192 result
= get_mips_section_type_name (sh_type
);
4195 result
= get_parisc_section_type_name (sh_type
);
4198 result
= get_ia64_section_type_name (filedata
, sh_type
);
4203 result
= get_x86_64_section_type_name (sh_type
);
4206 result
= get_aarch64_section_type_name (sh_type
);
4209 result
= get_arm_section_type_name (sh_type
);
4212 result
= get_tic6x_section_type_name (sh_type
);
4215 result
= get_msp430x_section_type_name (sh_type
);
4219 case EM_CYGNUS_V850
:
4220 result
= get_v850_section_type_name (sh_type
);
4230 sprintf (buff
, "LOPROC+%#x", sh_type
- SHT_LOPROC
);
4232 else if ((sh_type
>= SHT_LOOS
) && (sh_type
<= SHT_HIOS
))
4234 switch (filedata
->file_header
.e_machine
)
4237 result
= get_ia64_section_type_name (filedata
, sh_type
);
4240 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
4241 result
= get_solaris_section_type (sh_type
);
4246 case SHT_GNU_INCREMENTAL_INPUTS
: result
= "GNU_INCREMENTAL_INPUTS"; break;
4247 case SHT_GNU_ATTRIBUTES
: result
= "GNU_ATTRIBUTES"; break;
4248 case SHT_GNU_HASH
: result
= "GNU_HASH"; break;
4249 case SHT_GNU_LIBLIST
: result
= "GNU_LIBLIST"; break;
4261 sprintf (buff
, "LOOS+%#x", sh_type
- SHT_LOOS
);
4263 else if ((sh_type
>= SHT_LOUSER
) && (sh_type
<= SHT_HIUSER
))
4265 switch (filedata
->file_header
.e_machine
)
4269 case EM_CYGNUS_V850
:
4270 result
= get_v850_section_type_name (sh_type
);
4280 sprintf (buff
, "LOUSER+%#x", sh_type
- SHT_LOUSER
);
4283 /* This message is probably going to be displayed in a 15
4284 character wide field, so put the hex value first. */
4285 snprintf (buff
, sizeof (buff
), _("%08x: <unknown>"), sh_type
);
4291 #define OPTION_DEBUG_DUMP 512
4292 #define OPTION_DYN_SYMS 513
4293 #define OPTION_DWARF_DEPTH 514
4294 #define OPTION_DWARF_START 515
4295 #define OPTION_DWARF_CHECK 516
4297 static struct option options
[] =
4299 {"all", no_argument
, 0, 'a'},
4300 {"file-header", no_argument
, 0, 'h'},
4301 {"program-headers", no_argument
, 0, 'l'},
4302 {"headers", no_argument
, 0, 'e'},
4303 {"histogram", no_argument
, 0, 'I'},
4304 {"segments", no_argument
, 0, 'l'},
4305 {"sections", no_argument
, 0, 'S'},
4306 {"section-headers", no_argument
, 0, 'S'},
4307 {"section-groups", no_argument
, 0, 'g'},
4308 {"section-details", no_argument
, 0, 't'},
4309 {"full-section-name",no_argument
, 0, 'N'},
4310 {"symbols", no_argument
, 0, 's'},
4311 {"syms", no_argument
, 0, 's'},
4312 {"dyn-syms", no_argument
, 0, OPTION_DYN_SYMS
},
4313 {"relocs", no_argument
, 0, 'r'},
4314 {"notes", no_argument
, 0, 'n'},
4315 {"dynamic", no_argument
, 0, 'd'},
4316 {"arch-specific", no_argument
, 0, 'A'},
4317 {"version-info", no_argument
, 0, 'V'},
4318 {"use-dynamic", no_argument
, 0, 'D'},
4319 {"unwind", no_argument
, 0, 'u'},
4320 {"archive-index", no_argument
, 0, 'c'},
4321 {"hex-dump", required_argument
, 0, 'x'},
4322 {"relocated-dump", required_argument
, 0, 'R'},
4323 {"string-dump", required_argument
, 0, 'p'},
4324 {"decompress", no_argument
, 0, 'z'},
4325 #ifdef SUPPORT_DISASSEMBLY
4326 {"instruction-dump", required_argument
, 0, 'i'},
4328 {"debug-dump", optional_argument
, 0, OPTION_DEBUG_DUMP
},
4330 {"dwarf-depth", required_argument
, 0, OPTION_DWARF_DEPTH
},
4331 {"dwarf-start", required_argument
, 0, OPTION_DWARF_START
},
4332 {"dwarf-check", no_argument
, 0, OPTION_DWARF_CHECK
},
4334 {"version", no_argument
, 0, 'v'},
4335 {"wide", no_argument
, 0, 'W'},
4336 {"help", no_argument
, 0, 'H'},
4337 {0, no_argument
, 0, 0}
4341 usage (FILE * stream
)
4343 fprintf (stream
, _("Usage: readelf <option(s)> elf-file(s)\n"));
4344 fprintf (stream
, _(" Display information about the contents of ELF format files\n"));
4345 fprintf (stream
, _(" Options are:\n\
4346 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4347 -h --file-header Display the ELF file header\n\
4348 -l --program-headers Display the program headers\n\
4349 --segments An alias for --program-headers\n\
4350 -S --section-headers Display the sections' header\n\
4351 --sections An alias for --section-headers\n\
4352 -g --section-groups Display the section groups\n\
4353 -t --section-details Display the section details\n\
4354 -e --headers Equivalent to: -h -l -S\n\
4355 -s --syms Display the symbol table\n\
4356 --symbols An alias for --syms\n\
4357 --dyn-syms Display the dynamic symbol table\n\
4358 -n --notes Display the core notes (if present)\n\
4359 -r --relocs Display the relocations (if present)\n\
4360 -u --unwind Display the unwind info (if present)\n\
4361 -d --dynamic Display the dynamic section (if present)\n\
4362 -V --version-info Display the version sections (if present)\n\
4363 -A --arch-specific Display architecture specific information (if any)\n\
4364 -c --archive-index Display the symbol/file index in an archive\n\
4365 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
4366 -x --hex-dump=<number|name>\n\
4367 Dump the contents of section <number|name> as bytes\n\
4368 -p --string-dump=<number|name>\n\
4369 Dump the contents of section <number|name> as strings\n\
4370 -R --relocated-dump=<number|name>\n\
4371 Dump the contents of section <number|name> as relocated bytes\n\
4372 -z --decompress Decompress section before dumping it\n\
4373 -w[lLiaprmfFsoRtUuTgAckK] or\n\
4374 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4375 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4376 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4377 =addr,=cu_index,=links,=follow-links]\n\
4378 Display the contents of DWARF debug sections\n"));
4379 fprintf (stream
, _("\
4380 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4381 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4383 #ifdef SUPPORT_DISASSEMBLY
4384 fprintf (stream
, _("\
4385 -i --instruction-dump=<number|name>\n\
4386 Disassemble the contents of section <number|name>\n"));
4388 fprintf (stream
, _("\
4389 -I --histogram Display histogram of bucket list lengths\n\
4390 -W --wide Allow output width to exceed 80 characters\n\
4391 @<file> Read options from <file>\n\
4392 -H --help Display this information\n\
4393 -v --version Display the version number of readelf\n"));
4395 if (REPORT_BUGS_TO
[0] && stream
== stdout
)
4396 fprintf (stdout
, _("Report bugs to %s\n"), REPORT_BUGS_TO
);
4398 exit (stream
== stdout
? 0 : 1);
4401 /* Record the fact that the user wants the contents of section number
4402 SECTION to be displayed using the method(s) encoded as flags bits
4403 in TYPE. Note, TYPE can be zero if we are creating the array for
4407 request_dump_bynumber (Filedata
* filedata
, unsigned int section
, dump_type type
)
4409 if (section
>= filedata
->num_dump_sects
)
4411 dump_type
* new_dump_sects
;
4413 new_dump_sects
= (dump_type
*) calloc (section
+ 1,
4414 sizeof (* new_dump_sects
));
4416 if (new_dump_sects
== NULL
)
4417 error (_("Out of memory allocating dump request table.\n"));
4420 if (filedata
->dump_sects
)
4422 /* Copy current flag settings. */
4423 memcpy (new_dump_sects
, filedata
->dump_sects
,
4424 filedata
->num_dump_sects
* sizeof (* new_dump_sects
));
4426 free (filedata
->dump_sects
);
4429 filedata
->dump_sects
= new_dump_sects
;
4430 filedata
->num_dump_sects
= section
+ 1;
4434 if (filedata
->dump_sects
)
4435 filedata
->dump_sects
[section
] |= type
;
4438 /* Request a dump by section name. */
4441 request_dump_byname (const char * section
, dump_type type
)
4443 struct dump_list_entry
* new_request
;
4445 new_request
= (struct dump_list_entry
*)
4446 malloc (sizeof (struct dump_list_entry
));
4448 error (_("Out of memory allocating dump request table.\n"));
4450 new_request
->name
= strdup (section
);
4451 if (!new_request
->name
)
4452 error (_("Out of memory allocating dump request table.\n"));
4454 new_request
->type
= type
;
4456 new_request
->next
= dump_sects_byname
;
4457 dump_sects_byname
= new_request
;
4461 request_dump (Filedata
* filedata
, dump_type type
)
4467 section
= strtoul (optarg
, & cp
, 0);
4469 if (! *cp
&& section
>= 0)
4470 request_dump_bynumber (filedata
, section
, type
);
4472 request_dump_byname (optarg
, type
);
4476 parse_args (Filedata
* filedata
, int argc
, char ** argv
)
4483 while ((c
= getopt_long
4484 (argc
, argv
, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options
, NULL
)) != EOF
)
4502 do_section_groups
= TRUE
;
4505 do_histogram
= TRUE
;
4510 do_section_groups
= TRUE
;
4515 do_section_details
= TRUE
;
4526 do_using_dynamic
= TRUE
;
4550 do_histogram
= TRUE
;
4556 do_archive_index
= TRUE
;
4559 request_dump (filedata
, HEX_DUMP
);
4562 request_dump (filedata
, STRING_DUMP
);
4565 request_dump (filedata
, RELOC_DUMP
);
4568 decompress_dumps
= TRUE
;
4574 do_debugging
= TRUE
;
4575 dwarf_select_sections_all ();
4579 do_debugging
= FALSE
;
4580 dwarf_select_sections_by_letters (optarg
);
4583 case OPTION_DEBUG_DUMP
:
4586 do_debugging
= TRUE
;
4589 do_debugging
= FALSE
;
4590 dwarf_select_sections_by_names (optarg
);
4593 case OPTION_DWARF_DEPTH
:
4597 dwarf_cutoff_level
= strtoul (optarg
, & cp
, 0);
4600 case OPTION_DWARF_START
:
4604 dwarf_start_die
= strtoul (optarg
, & cp
, 0);
4607 case OPTION_DWARF_CHECK
:
4610 case OPTION_DYN_SYMS
:
4613 #ifdef SUPPORT_DISASSEMBLY
4615 request_dump (filedata
, DISASS_DUMP
);
4619 print_version (program_name
);
4628 /* xgettext:c-format */
4629 error (_("Invalid option '-%c'\n"), c
);
4636 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
4637 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
4638 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
4639 && !do_section_groups
&& !do_archive_index
4645 get_elf_class (unsigned int elf_class
)
4647 static char buff
[32];
4651 case ELFCLASSNONE
: return _("none");
4652 case ELFCLASS32
: return "ELF32";
4653 case ELFCLASS64
: return "ELF64";
4655 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), elf_class
);
4661 get_data_encoding (unsigned int encoding
)
4663 static char buff
[32];
4667 case ELFDATANONE
: return _("none");
4668 case ELFDATA2LSB
: return _("2's complement, little endian");
4669 case ELFDATA2MSB
: return _("2's complement, big endian");
4671 snprintf (buff
, sizeof (buff
), _("<unknown: %x>"), encoding
);
4676 /* Decode the data held in 'filedata->file_header'. */
4679 process_file_header (Filedata
* filedata
)
4681 Elf_Internal_Ehdr
* header
= & filedata
->file_header
;
4683 if ( header
->e_ident
[EI_MAG0
] != ELFMAG0
4684 || header
->e_ident
[EI_MAG1
] != ELFMAG1
4685 || header
->e_ident
[EI_MAG2
] != ELFMAG2
4686 || header
->e_ident
[EI_MAG3
] != ELFMAG3
)
4689 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4693 init_dwarf_regnames (header
->e_machine
);
4699 printf (_("ELF Header:\n"));
4700 printf (_(" Magic: "));
4701 for (i
= 0; i
< EI_NIDENT
; i
++)
4702 printf ("%2.2x ", header
->e_ident
[i
]);
4704 printf (_(" Class: %s\n"),
4705 get_elf_class (header
->e_ident
[EI_CLASS
]));
4706 printf (_(" Data: %s\n"),
4707 get_data_encoding (header
->e_ident
[EI_DATA
]));
4708 printf (_(" Version: %d %s\n"),
4709 header
->e_ident
[EI_VERSION
],
4710 (header
->e_ident
[EI_VERSION
] == EV_CURRENT
4712 : (header
->e_ident
[EI_VERSION
] != EV_NONE
4713 ? _("<unknown: %lx>")
4715 printf (_(" OS/ABI: %s\n"),
4716 get_osabi_name (filedata
, header
->e_ident
[EI_OSABI
]));
4717 printf (_(" ABI Version: %d\n"),
4718 header
->e_ident
[EI_ABIVERSION
]);
4719 printf (_(" Type: %s\n"),
4720 get_file_type (header
->e_type
));
4721 printf (_(" Machine: %s\n"),
4722 get_machine_name (header
->e_machine
));
4723 printf (_(" Version: 0x%lx\n"),
4724 (unsigned long) header
->e_version
);
4726 printf (_(" Entry point address: "));
4727 print_vma ((bfd_vma
) header
->e_entry
, PREFIX_HEX
);
4728 printf (_("\n Start of program headers: "));
4729 print_vma ((bfd_vma
) header
->e_phoff
, DEC
);
4730 printf (_(" (bytes into file)\n Start of section headers: "));
4731 print_vma ((bfd_vma
) header
->e_shoff
, DEC
);
4732 printf (_(" (bytes into file)\n"));
4734 printf (_(" Flags: 0x%lx%s\n"),
4735 (unsigned long) header
->e_flags
,
4736 get_machine_flags (filedata
, header
->e_flags
, header
->e_machine
));
4737 printf (_(" Size of this header: %ld (bytes)\n"),
4738 (long) header
->e_ehsize
);
4739 printf (_(" Size of program headers: %ld (bytes)\n"),
4740 (long) header
->e_phentsize
);
4741 printf (_(" Number of program headers: %ld"),
4742 (long) header
->e_phnum
);
4743 if (filedata
->section_headers
!= NULL
4744 && header
->e_phnum
== PN_XNUM
4745 && filedata
->section_headers
[0].sh_info
!= 0)
4746 printf (" (%ld)", (long) filedata
->section_headers
[0].sh_info
);
4747 putc ('\n', stdout
);
4748 printf (_(" Size of section headers: %ld (bytes)\n"),
4749 (long) header
->e_shentsize
);
4750 printf (_(" Number of section headers: %ld"),
4751 (long) header
->e_shnum
);
4752 if (filedata
->section_headers
!= NULL
&& header
->e_shnum
== SHN_UNDEF
)
4753 printf (" (%ld)", (long) filedata
->section_headers
[0].sh_size
);
4754 putc ('\n', stdout
);
4755 printf (_(" Section header string table index: %ld"),
4756 (long) header
->e_shstrndx
);
4757 if (filedata
->section_headers
!= NULL
4758 && header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
4759 printf (" (%u)", filedata
->section_headers
[0].sh_link
);
4760 else if (header
->e_shstrndx
!= SHN_UNDEF
4761 && header
->e_shstrndx
>= header
->e_shnum
)
4762 printf (_(" <corrupt: out of range>"));
4763 putc ('\n', stdout
);
4766 if (filedata
->section_headers
!= NULL
)
4768 if (header
->e_phnum
== PN_XNUM
4769 && filedata
->section_headers
[0].sh_info
!= 0)
4770 header
->e_phnum
= filedata
->section_headers
[0].sh_info
;
4771 if (header
->e_shnum
== SHN_UNDEF
)
4772 header
->e_shnum
= filedata
->section_headers
[0].sh_size
;
4773 if (header
->e_shstrndx
== (SHN_XINDEX
& 0xffff))
4774 header
->e_shstrndx
= filedata
->section_headers
[0].sh_link
;
4775 if (header
->e_shstrndx
>= header
->e_shnum
)
4776 header
->e_shstrndx
= SHN_UNDEF
;
4777 free (filedata
->section_headers
);
4778 filedata
->section_headers
= NULL
;
4784 /* Read in the program headers from FILEDATA and store them in PHEADERS.
4785 Returns TRUE upon success, FALSE otherwise. Loads 32-bit headers. */
4788 get_32bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
4790 Elf32_External_Phdr
* phdrs
;
4791 Elf32_External_Phdr
* external
;
4792 Elf_Internal_Phdr
* internal
;
4794 unsigned int size
= filedata
->file_header
.e_phentsize
;
4795 unsigned int num
= filedata
->file_header
.e_phnum
;
4797 /* PR binutils/17531: Cope with unexpected section header sizes. */
4798 if (size
== 0 || num
== 0)
4800 if (size
< sizeof * phdrs
)
4802 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4805 if (size
> sizeof * phdrs
)
4806 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4808 phdrs
= (Elf32_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
4809 size
, num
, _("program headers"));
4813 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4814 i
< filedata
->file_header
.e_phnum
;
4815 i
++, internal
++, external
++)
4817 internal
->p_type
= BYTE_GET (external
->p_type
);
4818 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4819 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4820 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4821 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4822 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4823 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4824 internal
->p_align
= BYTE_GET (external
->p_align
);
4831 /* Read in the program headers from FILEDATA and store them in PHEADERS.
4832 Returns TRUE upon success, FALSE otherwise. Loads 64-bit headers. */
4835 get_64bit_program_headers (Filedata
* filedata
, Elf_Internal_Phdr
* pheaders
)
4837 Elf64_External_Phdr
* phdrs
;
4838 Elf64_External_Phdr
* external
;
4839 Elf_Internal_Phdr
* internal
;
4841 unsigned int size
= filedata
->file_header
.e_phentsize
;
4842 unsigned int num
= filedata
->file_header
.e_phnum
;
4844 /* PR binutils/17531: Cope with unexpected section header sizes. */
4845 if (size
== 0 || num
== 0)
4847 if (size
< sizeof * phdrs
)
4849 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4852 if (size
> sizeof * phdrs
)
4853 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4855 phdrs
= (Elf64_External_Phdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_phoff
,
4856 size
, num
, _("program headers"));
4860 for (i
= 0, internal
= pheaders
, external
= phdrs
;
4861 i
< filedata
->file_header
.e_phnum
;
4862 i
++, internal
++, external
++)
4864 internal
->p_type
= BYTE_GET (external
->p_type
);
4865 internal
->p_flags
= BYTE_GET (external
->p_flags
);
4866 internal
->p_offset
= BYTE_GET (external
->p_offset
);
4867 internal
->p_vaddr
= BYTE_GET (external
->p_vaddr
);
4868 internal
->p_paddr
= BYTE_GET (external
->p_paddr
);
4869 internal
->p_filesz
= BYTE_GET (external
->p_filesz
);
4870 internal
->p_memsz
= BYTE_GET (external
->p_memsz
);
4871 internal
->p_align
= BYTE_GET (external
->p_align
);
4878 /* Returns TRUE if the program headers were read into `program_headers'. */
4881 get_program_headers (Filedata
* filedata
)
4883 Elf_Internal_Phdr
* phdrs
;
4885 /* Check cache of prior read. */
4886 if (filedata
->program_headers
!= NULL
)
4889 /* Be kind to memory checkers by looking for
4890 e_phnum values which we know must be invalid. */
4891 if (filedata
->file_header
.e_phnum
4892 * (is_32bit_elf
? sizeof (Elf32_External_Phdr
) : sizeof (Elf64_External_Phdr
))
4893 >= filedata
->file_size
)
4895 error (_("Too many program headers - %#x - the file is not that big\n"),
4896 filedata
->file_header
.e_phnum
);
4900 phdrs
= (Elf_Internal_Phdr
*) cmalloc (filedata
->file_header
.e_phnum
,
4901 sizeof (Elf_Internal_Phdr
));
4904 error (_("Out of memory reading %u program headers\n"),
4905 filedata
->file_header
.e_phnum
);
4910 ? get_32bit_program_headers (filedata
, phdrs
)
4911 : get_64bit_program_headers (filedata
, phdrs
))
4913 filedata
->program_headers
= phdrs
;
4921 /* Returns TRUE if the program headers were loaded. */
4924 process_program_headers (Filedata
* filedata
)
4926 Elf_Internal_Phdr
* segment
;
4928 Elf_Internal_Phdr
* previous_load
= NULL
;
4930 if (filedata
->file_header
.e_phnum
== 0)
4932 /* PR binutils/12467. */
4933 if (filedata
->file_header
.e_phoff
!= 0)
4935 warn (_("possibly corrupt ELF header - it has a non-zero program"
4936 " header offset, but no program headers\n"));
4939 else if (do_segments
)
4940 printf (_("\nThere are no program headers in this file.\n"));
4944 if (do_segments
&& !do_header
)
4946 printf (_("\nElf file type is %s\n"), get_file_type (filedata
->file_header
.e_type
));
4947 printf (_("Entry point 0x%s\n"), bfd_vmatoa ("x", filedata
->file_header
.e_entry
));
4948 printf (ngettext ("There is %d program header, starting at offset %s\n",
4949 "There are %d program headers, starting at offset %s\n",
4950 filedata
->file_header
.e_phnum
),
4951 filedata
->file_header
.e_phnum
,
4952 bfd_vmatoa ("u", filedata
->file_header
.e_phoff
));
4955 if (! get_program_headers (filedata
))
4960 if (filedata
->file_header
.e_phnum
> 1)
4961 printf (_("\nProgram Headers:\n"));
4963 printf (_("\nProgram Headers:\n"));
4967 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4970 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4974 (_(" Type Offset VirtAddr PhysAddr\n"));
4976 (_(" FileSiz MemSiz Flags Align\n"));
4983 for (i
= 0, segment
= filedata
->program_headers
;
4984 i
< filedata
->file_header
.e_phnum
;
4989 printf (" %-14.14s ", get_segment_type (filedata
, segment
->p_type
));
4993 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
4994 printf ("0x%8.8lx ", (unsigned long) segment
->p_vaddr
);
4995 printf ("0x%8.8lx ", (unsigned long) segment
->p_paddr
);
4996 printf ("0x%5.5lx ", (unsigned long) segment
->p_filesz
);
4997 printf ("0x%5.5lx ", (unsigned long) segment
->p_memsz
);
4999 (segment
->p_flags
& PF_R
? 'R' : ' '),
5000 (segment
->p_flags
& PF_W
? 'W' : ' '),
5001 (segment
->p_flags
& PF_X
? 'E' : ' '));
5002 printf ("%#lx", (unsigned long) segment
->p_align
);
5006 if ((unsigned long) segment
->p_offset
== segment
->p_offset
)
5007 printf ("0x%6.6lx ", (unsigned long) segment
->p_offset
);
5010 print_vma (segment
->p_offset
, FULL_HEX
);
5014 print_vma (segment
->p_vaddr
, FULL_HEX
);
5016 print_vma (segment
->p_paddr
, FULL_HEX
);
5019 if ((unsigned long) segment
->p_filesz
== segment
->p_filesz
)
5020 printf ("0x%6.6lx ", (unsigned long) segment
->p_filesz
);
5023 print_vma (segment
->p_filesz
, FULL_HEX
);
5027 if ((unsigned long) segment
->p_memsz
== segment
->p_memsz
)
5028 printf ("0x%6.6lx", (unsigned long) segment
->p_memsz
);
5031 print_vma (segment
->p_memsz
, FULL_HEX
);
5035 (segment
->p_flags
& PF_R
? 'R' : ' '),
5036 (segment
->p_flags
& PF_W
? 'W' : ' '),
5037 (segment
->p_flags
& PF_X
? 'E' : ' '));
5039 if ((unsigned long) segment
->p_align
== segment
->p_align
)
5040 printf ("%#lx", (unsigned long) segment
->p_align
);
5043 print_vma (segment
->p_align
, PREFIX_HEX
);
5048 print_vma (segment
->p_offset
, FULL_HEX
);
5050 print_vma (segment
->p_vaddr
, FULL_HEX
);
5052 print_vma (segment
->p_paddr
, FULL_HEX
);
5054 print_vma (segment
->p_filesz
, FULL_HEX
);
5056 print_vma (segment
->p_memsz
, FULL_HEX
);
5058 (segment
->p_flags
& PF_R
? 'R' : ' '),
5059 (segment
->p_flags
& PF_W
? 'W' : ' '),
5060 (segment
->p_flags
& PF_X
? 'E' : ' '));
5061 print_vma (segment
->p_align
, PREFIX_HEX
);
5064 putc ('\n', stdout
);
5067 switch (segment
->p_type
)
5070 #if 0 /* Do not warn about out of order PT_LOAD segments. Although officially
5071 required by the ELF standard, several programs, including the Linux
5072 kernel, make use of non-ordered segments. */
5074 && previous_load
->p_vaddr
> segment
->p_vaddr
)
5075 error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
5077 if (segment
->p_memsz
< segment
->p_filesz
)
5078 error (_("the segment's file size is larger than its memory size\n"));
5079 previous_load
= segment
;
5083 /* PR 20815 - Verify that the program header is loaded into memory. */
5084 if (i
> 0 && previous_load
!= NULL
)
5085 error (_("the PHDR segment must occur before any LOAD segment\n"));
5086 if (filedata
->file_header
.e_machine
!= EM_PARISC
)
5090 for (j
= 1; j
< filedata
->file_header
.e_phnum
; j
++)
5091 if (filedata
->program_headers
[j
].p_vaddr
<= segment
->p_vaddr
5092 && (filedata
->program_headers
[j
].p_vaddr
5093 + filedata
->program_headers
[j
].p_memsz
)
5094 >= (segment
->p_vaddr
+ segment
->p_filesz
))
5096 if (j
== filedata
->file_header
.e_phnum
)
5097 error (_("the PHDR segment is not covered by a LOAD segment\n"));
5103 error (_("more than one dynamic segment\n"));
5105 /* By default, assume that the .dynamic section is the first
5106 section in the DYNAMIC segment. */
5107 dynamic_addr
= segment
->p_offset
;
5108 dynamic_size
= segment
->p_filesz
;
5110 /* Try to locate the .dynamic section. If there is
5111 a section header table, we can easily locate it. */
5112 if (filedata
->section_headers
!= NULL
)
5114 Elf_Internal_Shdr
* sec
;
5116 sec
= find_section (filedata
, ".dynamic");
5117 if (sec
== NULL
|| sec
->sh_size
== 0)
5119 /* A corresponding .dynamic section is expected, but on
5120 IA-64/OpenVMS it is OK for it to be missing. */
5121 if (!is_ia64_vms (filedata
))
5122 error (_("no .dynamic section in the dynamic segment\n"));
5126 if (sec
->sh_type
== SHT_NOBITS
)
5132 dynamic_addr
= sec
->sh_offset
;
5133 dynamic_size
= sec
->sh_size
;
5135 if (dynamic_addr
< segment
->p_offset
5136 || dynamic_addr
> segment
->p_offset
+ segment
->p_filesz
)
5137 warn (_("the .dynamic section is not contained"
5138 " within the dynamic segment\n"));
5139 else if (dynamic_addr
> segment
->p_offset
)
5140 warn (_("the .dynamic section is not the first section"
5141 " in the dynamic segment.\n"));
5144 /* PR binutils/17512: Avoid corrupt dynamic section info in the
5145 segment. Check this after matching against the section headers
5146 so we don't warn on debuginfo file (which have NOBITS .dynamic
5148 if (dynamic_addr
+ dynamic_size
>= filedata
->file_size
)
5150 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
5151 dynamic_addr
= dynamic_size
= 0;
5156 if (fseek (filedata
->handle
, archive_file_offset
+ (long) segment
->p_offset
,
5158 error (_("Unable to find program interpreter name\n"));
5162 int ret
= snprintf (fmt
, sizeof (fmt
), "%%%ds", PATH_MAX
- 1);
5164 if (ret
>= (int) sizeof (fmt
) || ret
< 0)
5165 error (_("Internal error: failed to create format string to display program interpreter\n"));
5167 program_interpreter
[0] = 0;
5168 if (fscanf (filedata
->handle
, fmt
, program_interpreter
) <= 0)
5169 error (_("Unable to read program interpreter name\n"));
5172 printf (_(" [Requesting program interpreter: %s]\n"),
5173 program_interpreter
);
5180 && filedata
->section_headers
!= NULL
5181 && filedata
->string_table
!= NULL
)
5183 printf (_("\n Section to Segment mapping:\n"));
5184 printf (_(" Segment Sections...\n"));
5186 for (i
= 0; i
< filedata
->file_header
.e_phnum
; i
++)
5189 Elf_Internal_Shdr
* section
;
5191 segment
= filedata
->program_headers
+ i
;
5192 section
= filedata
->section_headers
+ 1;
5194 printf (" %2.2d ", i
);
5196 for (j
= 1; j
< filedata
->file_header
.e_shnum
; j
++, section
++)
5198 if (!ELF_TBSS_SPECIAL (section
, segment
)
5199 && ELF_SECTION_IN_SEGMENT_STRICT (section
, segment
))
5200 printf ("%s ", printable_section_name (filedata
, section
));
5211 /* Find the file offset corresponding to VMA by using the program headers. */
5214 offset_from_vma (Filedata
* filedata
, bfd_vma vma
, bfd_size_type size
)
5216 Elf_Internal_Phdr
* seg
;
5218 if (! get_program_headers (filedata
))
5220 warn (_("Cannot interpret virtual addresses without program headers.\n"));
5224 for (seg
= filedata
->program_headers
;
5225 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
5228 if (seg
->p_type
!= PT_LOAD
)
5231 if (vma
>= (seg
->p_vaddr
& -seg
->p_align
)
5232 && vma
+ size
<= seg
->p_vaddr
+ seg
->p_filesz
)
5233 return vma
- seg
->p_vaddr
+ seg
->p_offset
;
5236 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5237 (unsigned long) vma
);
5242 /* Allocate memory and load the sections headers into FILEDATA->filedata->section_headers.
5243 If PROBE is true, this is just a probe and we do not generate any error
5244 messages if the load fails. */
5247 get_32bit_section_headers (Filedata
* filedata
, bfd_boolean probe
)
5249 Elf32_External_Shdr
* shdrs
;
5250 Elf_Internal_Shdr
* internal
;
5252 unsigned int size
= filedata
->file_header
.e_shentsize
;
5253 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
5255 /* PR binutils/17531: Cope with unexpected section header sizes. */
5256 if (size
== 0 || num
== 0)
5258 if (size
< sizeof * shdrs
)
5261 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5264 if (!probe
&& size
> sizeof * shdrs
)
5265 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5267 shdrs
= (Elf32_External_Shdr
*) get_data (NULL
, filedata
, filedata
->file_header
.e_shoff
,
5269 probe
? NULL
: _("section headers"));
5273 free (filedata
->section_headers
);
5274 filedata
->section_headers
= (Elf_Internal_Shdr
*)
5275 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
5276 if (filedata
->section_headers
== NULL
)
5279 error (_("Out of memory reading %u section headers\n"), num
);
5283 for (i
= 0, internal
= filedata
->section_headers
;
5287 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5288 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5289 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5290 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5291 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5292 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5293 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5294 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5295 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5296 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5297 if (!probe
&& internal
->sh_link
> num
)
5298 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5299 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5300 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5307 /* Like get_32bit_section_headers, except that it fetches 64-bit headers. */
5310 get_64bit_section_headers (Filedata
* filedata
, bfd_boolean probe
)
5312 Elf64_External_Shdr
* shdrs
;
5313 Elf_Internal_Shdr
* internal
;
5315 unsigned int size
= filedata
->file_header
.e_shentsize
;
5316 unsigned int num
= probe
? 1 : filedata
->file_header
.e_shnum
;
5318 /* PR binutils/17531: Cope with unexpected section header sizes. */
5319 if (size
== 0 || num
== 0)
5322 if (size
< sizeof * shdrs
)
5325 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5329 if (! probe
&& size
> sizeof * shdrs
)
5330 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5332 shdrs
= (Elf64_External_Shdr
*) get_data (NULL
, filedata
,
5333 filedata
->file_header
.e_shoff
,
5335 probe
? NULL
: _("section headers"));
5339 free (filedata
->section_headers
);
5340 filedata
->section_headers
= (Elf_Internal_Shdr
*)
5341 cmalloc (num
, sizeof (Elf_Internal_Shdr
));
5342 if (filedata
->section_headers
== NULL
)
5345 error (_("Out of memory reading %u section headers\n"), num
);
5349 for (i
= 0, internal
= filedata
->section_headers
;
5353 internal
->sh_name
= BYTE_GET (shdrs
[i
].sh_name
);
5354 internal
->sh_type
= BYTE_GET (shdrs
[i
].sh_type
);
5355 internal
->sh_flags
= BYTE_GET (shdrs
[i
].sh_flags
);
5356 internal
->sh_addr
= BYTE_GET (shdrs
[i
].sh_addr
);
5357 internal
->sh_size
= BYTE_GET (shdrs
[i
].sh_size
);
5358 internal
->sh_entsize
= BYTE_GET (shdrs
[i
].sh_entsize
);
5359 internal
->sh_link
= BYTE_GET (shdrs
[i
].sh_link
);
5360 internal
->sh_info
= BYTE_GET (shdrs
[i
].sh_info
);
5361 internal
->sh_offset
= BYTE_GET (shdrs
[i
].sh_offset
);
5362 internal
->sh_addralign
= BYTE_GET (shdrs
[i
].sh_addralign
);
5363 if (!probe
&& internal
->sh_link
> num
)
5364 warn (_("Section %u has an out of range sh_link value of %u\n"), i
, internal
->sh_link
);
5365 if (!probe
&& internal
->sh_flags
& SHF_INFO_LINK
&& internal
->sh_info
> num
)
5366 warn (_("Section %u has an out of range sh_info value of %u\n"), i
, internal
->sh_info
);
5373 static Elf_Internal_Sym
*
5374 get_32bit_elf_symbols (Filedata
* filedata
,
5375 Elf_Internal_Shdr
* section
,
5376 unsigned long * num_syms_return
)
5378 unsigned long number
= 0;
5379 Elf32_External_Sym
* esyms
= NULL
;
5380 Elf_External_Sym_Shndx
* shndx
= NULL
;
5381 Elf_Internal_Sym
* isyms
= NULL
;
5382 Elf_Internal_Sym
* psym
;
5385 if (section
->sh_size
== 0)
5387 if (num_syms_return
!= NULL
)
5388 * num_syms_return
= 0;
5392 /* Run some sanity checks first. */
5393 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5395 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5396 printable_section_name (filedata
, section
),
5397 (unsigned long) section
->sh_entsize
);
5401 if (section
->sh_size
> filedata
->file_size
)
5403 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5404 printable_section_name (filedata
, section
),
5405 (unsigned long) section
->sh_size
);
5409 number
= section
->sh_size
/ section
->sh_entsize
;
5411 if (number
* sizeof (Elf32_External_Sym
) > section
->sh_size
+ 1)
5413 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5414 (unsigned long) section
->sh_size
,
5415 printable_section_name (filedata
, section
),
5416 (unsigned long) section
->sh_entsize
);
5420 esyms
= (Elf32_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
5421 section
->sh_size
, _("symbols"));
5426 elf_section_list
* entry
;
5429 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5430 if (entry
->hdr
->sh_link
== (unsigned long) (section
- filedata
->section_headers
))
5432 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
5433 entry
->hdr
->sh_offset
,
5434 1, entry
->hdr
->sh_size
,
5435 _("symbol table section indicies"));
5438 /* PR17531: file: heap-buffer-overflow */
5439 else if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5441 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5442 printable_section_name (filedata
, entry
->hdr
),
5443 (unsigned long) entry
->hdr
->sh_size
,
5444 (unsigned long) section
->sh_size
);
5450 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5454 error (_("Out of memory reading %lu symbols\n"),
5455 (unsigned long) number
);
5459 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5461 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5462 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5463 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5464 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5465 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5467 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5468 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5469 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5470 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5471 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5480 if (num_syms_return
!= NULL
)
5481 * num_syms_return
= isyms
== NULL
? 0 : number
;
5486 static Elf_Internal_Sym
*
5487 get_64bit_elf_symbols (Filedata
* filedata
,
5488 Elf_Internal_Shdr
* section
,
5489 unsigned long * num_syms_return
)
5491 unsigned long number
= 0;
5492 Elf64_External_Sym
* esyms
= NULL
;
5493 Elf_External_Sym_Shndx
* shndx
= NULL
;
5494 Elf_Internal_Sym
* isyms
= NULL
;
5495 Elf_Internal_Sym
* psym
;
5498 if (section
->sh_size
== 0)
5500 if (num_syms_return
!= NULL
)
5501 * num_syms_return
= 0;
5505 /* Run some sanity checks first. */
5506 if (section
->sh_entsize
== 0 || section
->sh_entsize
> section
->sh_size
)
5508 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5509 printable_section_name (filedata
, section
),
5510 (unsigned long) section
->sh_entsize
);
5514 if (section
->sh_size
> filedata
->file_size
)
5516 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5517 printable_section_name (filedata
, section
),
5518 (unsigned long) section
->sh_size
);
5522 number
= section
->sh_size
/ section
->sh_entsize
;
5524 if (number
* sizeof (Elf64_External_Sym
) > section
->sh_size
+ 1)
5526 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5527 (unsigned long) section
->sh_size
,
5528 printable_section_name (filedata
, section
),
5529 (unsigned long) section
->sh_entsize
);
5533 esyms
= (Elf64_External_Sym
*) get_data (NULL
, filedata
, section
->sh_offset
, 1,
5534 section
->sh_size
, _("symbols"));
5539 elf_section_list
* entry
;
5542 for (entry
= symtab_shndx_list
; entry
!= NULL
; entry
= entry
->next
)
5543 if (entry
->hdr
->sh_link
== (unsigned long) (section
- filedata
->section_headers
))
5545 shndx
= (Elf_External_Sym_Shndx
*) get_data (NULL
, filedata
,
5546 entry
->hdr
->sh_offset
,
5547 1, entry
->hdr
->sh_size
,
5548 _("symbol table section indicies"));
5551 /* PR17531: file: heap-buffer-overflow */
5552 else if (entry
->hdr
->sh_size
/ sizeof (Elf_External_Sym_Shndx
) < number
)
5554 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5555 printable_section_name (filedata
, entry
->hdr
),
5556 (unsigned long) entry
->hdr
->sh_size
,
5557 (unsigned long) section
->sh_size
);
5563 isyms
= (Elf_Internal_Sym
*) cmalloc (number
, sizeof (Elf_Internal_Sym
));
5567 error (_("Out of memory reading %lu symbols\n"),
5568 (unsigned long) number
);
5572 for (j
= 0, psym
= isyms
; j
< number
; j
++, psym
++)
5574 psym
->st_name
= BYTE_GET (esyms
[j
].st_name
);
5575 psym
->st_info
= BYTE_GET (esyms
[j
].st_info
);
5576 psym
->st_other
= BYTE_GET (esyms
[j
].st_other
);
5577 psym
->st_shndx
= BYTE_GET (esyms
[j
].st_shndx
);
5579 if (psym
->st_shndx
== (SHN_XINDEX
& 0xffff) && shndx
!= NULL
)
5581 = byte_get ((unsigned char *) &shndx
[j
], sizeof (shndx
[j
]));
5582 else if (psym
->st_shndx
>= (SHN_LORESERVE
& 0xffff))
5583 psym
->st_shndx
+= SHN_LORESERVE
- (SHN_LORESERVE
& 0xffff);
5585 psym
->st_value
= BYTE_GET (esyms
[j
].st_value
);
5586 psym
->st_size
= BYTE_GET (esyms
[j
].st_size
);
5595 if (num_syms_return
!= NULL
)
5596 * num_syms_return
= isyms
== NULL
? 0 : number
;
5602 get_elf_section_flags (Filedata
* filedata
, bfd_vma sh_flags
)
5604 static char buff
[1024];
5606 unsigned int field_size
= is_32bit_elf
? 8 : 16;
5608 unsigned int size
= sizeof (buff
) - (field_size
+ 4 + 1);
5609 bfd_vma os_flags
= 0;
5610 bfd_vma proc_flags
= 0;
5611 bfd_vma unknown_flags
= 0;
5619 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5620 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5621 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5622 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5623 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5624 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5625 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5626 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5627 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5628 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5629 /* IA-64 specific. */
5630 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5631 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5632 /* IA-64 OpenVMS specific. */
5633 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5634 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5635 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5636 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5637 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5638 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5640 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5641 /* SPARC specific. */
5642 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5643 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5645 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5646 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5647 /* 23 */ { STRING_COMMA_LEN ("COMDEF") },
5649 /* 24 */ { STRING_COMMA_LEN ("GNU_MBIND") },
5651 /* 25 */ { STRING_COMMA_LEN ("VLE") },
5654 if (do_section_details
)
5656 sprintf (buff
, "[%*.*lx]: ",
5657 field_size
, field_size
, (unsigned long) sh_flags
);
5658 p
+= field_size
+ 4;
5665 flag
= sh_flags
& - sh_flags
;
5668 if (do_section_details
)
5672 case SHF_WRITE
: sindex
= 0; break;
5673 case SHF_ALLOC
: sindex
= 1; break;
5674 case SHF_EXECINSTR
: sindex
= 2; break;
5675 case SHF_MERGE
: sindex
= 3; break;
5676 case SHF_STRINGS
: sindex
= 4; break;
5677 case SHF_INFO_LINK
: sindex
= 5; break;
5678 case SHF_LINK_ORDER
: sindex
= 6; break;
5679 case SHF_OS_NONCONFORMING
: sindex
= 7; break;
5680 case SHF_GROUP
: sindex
= 8; break;
5681 case SHF_TLS
: sindex
= 9; break;
5682 case SHF_EXCLUDE
: sindex
= 18; break;
5683 case SHF_COMPRESSED
: sindex
= 20; break;
5684 case SHF_GNU_MBIND
: sindex
= 24; break;
5688 switch (filedata
->file_header
.e_machine
)
5691 if (flag
== SHF_IA_64_SHORT
)
5693 else if (flag
== SHF_IA_64_NORECOV
)
5696 else if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_OPENVMS
)
5699 case SHF_IA_64_VMS_GLOBAL
: sindex
= 12; break;
5700 case SHF_IA_64_VMS_OVERLAID
: sindex
= 13; break;
5701 case SHF_IA_64_VMS_SHARED
: sindex
= 14; break;
5702 case SHF_IA_64_VMS_VECTOR
: sindex
= 15; break;
5703 case SHF_IA_64_VMS_ALLOC_64BIT
: sindex
= 16; break;
5704 case SHF_IA_64_VMS_PROTECTED
: sindex
= 17; break;
5715 case EM_OLD_SPARCV9
:
5716 case EM_SPARC32PLUS
:
5719 if (flag
== SHF_ORDERED
)
5726 case SHF_ENTRYSECT
: sindex
= 21; break;
5727 case SHF_ARM_PURECODE
: sindex
= 22; break;
5728 case SHF_COMDEF
: sindex
= 23; break;
5733 if (flag
== SHF_PPC_VLE
)
5744 if (p
!= buff
+ field_size
+ 4)
5746 if (size
< (10 + 2))
5748 warn (_("Internal error: not enough buffer room for section flag info"));
5749 return _("<unknown>");
5756 size
-= flags
[sindex
].len
;
5757 p
= stpcpy (p
, flags
[sindex
].str
);
5759 else if (flag
& SHF_MASKOS
)
5761 else if (flag
& SHF_MASKPROC
)
5764 unknown_flags
|= flag
;
5770 case SHF_WRITE
: *p
= 'W'; break;
5771 case SHF_ALLOC
: *p
= 'A'; break;
5772 case SHF_EXECINSTR
: *p
= 'X'; break;
5773 case SHF_MERGE
: *p
= 'M'; break;
5774 case SHF_STRINGS
: *p
= 'S'; break;
5775 case SHF_INFO_LINK
: *p
= 'I'; break;
5776 case SHF_LINK_ORDER
: *p
= 'L'; break;
5777 case SHF_OS_NONCONFORMING
: *p
= 'O'; break;
5778 case SHF_GROUP
: *p
= 'G'; break;
5779 case SHF_TLS
: *p
= 'T'; break;
5780 case SHF_EXCLUDE
: *p
= 'E'; break;
5781 case SHF_COMPRESSED
: *p
= 'C'; break;
5782 case SHF_GNU_MBIND
: *p
= 'D'; break;
5785 if ((filedata
->file_header
.e_machine
== EM_X86_64
5786 || filedata
->file_header
.e_machine
== EM_L1OM
5787 || filedata
->file_header
.e_machine
== EM_K1OM
)
5788 && flag
== SHF_X86_64_LARGE
)
5790 else if (filedata
->file_header
.e_machine
== EM_ARM
5791 && flag
== SHF_ARM_PURECODE
)
5793 else if (filedata
->file_header
.e_machine
== EM_PPC
5794 && flag
== SHF_PPC_VLE
)
5796 else if (flag
& SHF_MASKOS
)
5799 sh_flags
&= ~ SHF_MASKOS
;
5801 else if (flag
& SHF_MASKPROC
)
5804 sh_flags
&= ~ SHF_MASKPROC
;
5814 if (do_section_details
)
5818 size
-= 5 + field_size
;
5819 if (p
!= buff
+ field_size
+ 4)
5823 warn (_("Internal error: not enough buffer room for section flag info"));
5824 return _("<unknown>");
5830 sprintf (p
, "OS (%*.*lx)", field_size
, field_size
,
5831 (unsigned long) os_flags
);
5832 p
+= 5 + field_size
;
5836 size
-= 7 + field_size
;
5837 if (p
!= buff
+ field_size
+ 4)
5841 warn (_("Internal error: not enough buffer room for section flag info"));
5842 return _("<unknown>");
5848 sprintf (p
, "PROC (%*.*lx)", field_size
, field_size
,
5849 (unsigned long) proc_flags
);
5850 p
+= 7 + field_size
;
5854 size
-= 10 + field_size
;
5855 if (p
!= buff
+ field_size
+ 4)
5859 warn (_("Internal error: not enough buffer room for section flag info"));
5860 return _("<unknown>");
5866 sprintf (p
, _("UNKNOWN (%*.*lx)"), field_size
, field_size
,
5867 (unsigned long) unknown_flags
);
5868 p
+= 10 + field_size
;
5877 get_compression_header (Elf_Internal_Chdr
*chdr
, unsigned char *buf
, bfd_size_type size
)
5881 Elf32_External_Chdr
*echdr
= (Elf32_External_Chdr
*) buf
;
5883 if (size
< sizeof (* echdr
))
5885 error (_("Compressed section is too small even for a compression header\n"));
5889 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
5890 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
5891 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
5892 return sizeof (*echdr
);
5896 Elf64_External_Chdr
*echdr
= (Elf64_External_Chdr
*) buf
;
5898 if (size
< sizeof (* echdr
))
5900 error (_("Compressed section is too small even for a compression header\n"));
5904 chdr
->ch_type
= BYTE_GET (echdr
->ch_type
);
5905 chdr
->ch_size
= BYTE_GET (echdr
->ch_size
);
5906 chdr
->ch_addralign
= BYTE_GET (echdr
->ch_addralign
);
5907 return sizeof (*echdr
);
5912 process_section_headers (Filedata
* filedata
)
5914 Elf_Internal_Shdr
* section
;
5917 filedata
->section_headers
= NULL
;
5919 if (filedata
->file_header
.e_shnum
== 0)
5921 /* PR binutils/12467. */
5922 if (filedata
->file_header
.e_shoff
!= 0)
5924 warn (_("possibly corrupt ELF file header - it has a non-zero"
5925 " section header offset, but no section headers\n"));
5928 else if (do_sections
)
5929 printf (_("\nThere are no sections in this file.\n"));
5934 if (do_sections
&& !do_header
)
5935 printf (ngettext ("There is %d section header, "
5936 "starting at offset 0x%lx:\n",
5937 "There are %d section headers, "
5938 "starting at offset 0x%lx:\n",
5939 filedata
->file_header
.e_shnum
),
5940 filedata
->file_header
.e_shnum
,
5941 (unsigned long) filedata
->file_header
.e_shoff
);
5945 if (! get_32bit_section_headers (filedata
, FALSE
))
5950 if (! get_64bit_section_headers (filedata
, FALSE
))
5954 /* Read in the string table, so that we have names to display. */
5955 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
5956 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
5958 section
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
5960 if (section
->sh_size
!= 0)
5962 filedata
->string_table
= (char *) get_data (NULL
, filedata
, section
->sh_offset
,
5963 1, section
->sh_size
,
5966 filedata
->string_table_length
= filedata
->string_table
!= NULL
? section
->sh_size
: 0;
5970 /* Scan the sections for the dynamic symbol table
5971 and dynamic string table and debug sections. */
5972 dynamic_symbols
= NULL
;
5973 dynamic_strings
= NULL
;
5974 dynamic_syminfo
= NULL
;
5975 symtab_shndx_list
= NULL
;
5977 eh_addr_size
= is_32bit_elf
? 4 : 8;
5978 switch (filedata
->file_header
.e_machine
)
5981 case EM_MIPS_RS3_LE
:
5982 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5983 FDE addresses. However, the ABI also has a semi-official ILP32
5984 variant for which the normal FDE address size rules apply.
5986 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5987 section, where XX is the size of longs in bits. Unfortunately,
5988 earlier compilers provided no way of distinguishing ILP32 objects
5989 from LP64 objects, so if there's any doubt, we should assume that
5990 the official LP64 form is being used. */
5991 if ((filedata
->file_header
.e_flags
& EF_MIPS_ABI
) == E_MIPS_ABI_EABI64
5992 && find_section (filedata
, ".gcc_compiled_long32") == NULL
)
5998 switch (filedata
->file_header
.e_flags
& EF_H8_MACH
)
6000 case E_H8_MACH_H8300
:
6001 case E_H8_MACH_H8300HN
:
6002 case E_H8_MACH_H8300SN
:
6003 case E_H8_MACH_H8300SXN
:
6006 case E_H8_MACH_H8300H
:
6007 case E_H8_MACH_H8300S
:
6008 case E_H8_MACH_H8300SX
:
6016 switch (filedata
->file_header
.e_flags
& EF_M32C_CPU_MASK
)
6018 case EF_M32C_CPU_M16C
:
6025 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
6028 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
6029 if (section->sh_entsize != expected_entsize) \
6032 sprintf_vma (buf, section->sh_entsize); \
6033 /* Note: coded this way so that there is a single string for \
6035 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
6036 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
6037 (unsigned) expected_entsize); \
6038 section->sh_entsize = expected_entsize; \
6043 #define CHECK_ENTSIZE(section, i, type) \
6044 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
6045 sizeof (Elf64_External_##type))
6047 for (i
= 0, section
= filedata
->section_headers
;
6048 i
< filedata
->file_header
.e_shnum
;
6051 char * name
= SECTION_NAME (section
);
6053 if (section
->sh_type
== SHT_DYNSYM
)
6055 if (dynamic_symbols
!= NULL
)
6057 error (_("File contains multiple dynamic symbol tables\n"));
6061 CHECK_ENTSIZE (section
, i
, Sym
);
6062 dynamic_symbols
= GET_ELF_SYMBOLS (filedata
, section
, & num_dynamic_syms
);
6064 else if (section
->sh_type
== SHT_STRTAB
6065 && streq (name
, ".dynstr"))
6067 if (dynamic_strings
!= NULL
)
6069 error (_("File contains multiple dynamic string tables\n"));
6073 dynamic_strings
= (char *) get_data (NULL
, filedata
, section
->sh_offset
,
6074 1, section
->sh_size
,
6075 _("dynamic strings"));
6076 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : section
->sh_size
;
6078 else if (section
->sh_type
== SHT_SYMTAB_SHNDX
)
6080 elf_section_list
* entry
= xmalloc (sizeof * entry
);
6082 entry
->hdr
= section
;
6083 entry
->next
= symtab_shndx_list
;
6084 symtab_shndx_list
= entry
;
6086 else if (section
->sh_type
== SHT_SYMTAB
)
6087 CHECK_ENTSIZE (section
, i
, Sym
);
6088 else if (section
->sh_type
== SHT_GROUP
)
6089 CHECK_ENTSIZE_VALUES (section
, i
, GRP_ENTRY_SIZE
, GRP_ENTRY_SIZE
);
6090 else if (section
->sh_type
== SHT_REL
)
6091 CHECK_ENTSIZE (section
, i
, Rel
);
6092 else if (section
->sh_type
== SHT_RELA
)
6093 CHECK_ENTSIZE (section
, i
, Rela
);
6094 else if ((do_debugging
|| do_debug_info
|| do_debug_abbrevs
6095 || do_debug_lines
|| do_debug_pubnames
|| do_debug_pubtypes
6096 || do_debug_aranges
|| do_debug_frames
|| do_debug_macinfo
6097 || do_debug_str
|| do_debug_loc
|| do_debug_ranges
6098 || do_debug_addr
|| do_debug_cu_index
|| do_debug_links
)
6099 && (const_strneq (name
, ".debug_")
6100 || const_strneq (name
, ".zdebug_")))
6103 name
+= sizeof (".zdebug_") - 1;
6105 name
+= sizeof (".debug_") - 1;
6108 || (do_debug_info
&& const_strneq (name
, "info"))
6109 || (do_debug_info
&& const_strneq (name
, "types"))
6110 || (do_debug_abbrevs
&& const_strneq (name
, "abbrev"))
6111 || (do_debug_lines
&& strcmp (name
, "line") == 0)
6112 || (do_debug_lines
&& const_strneq (name
, "line."))
6113 || (do_debug_pubnames
&& const_strneq (name
, "pubnames"))
6114 || (do_debug_pubtypes
&& const_strneq (name
, "pubtypes"))
6115 || (do_debug_pubnames
&& const_strneq (name
, "gnu_pubnames"))
6116 || (do_debug_pubtypes
&& const_strneq (name
, "gnu_pubtypes"))
6117 || (do_debug_aranges
&& const_strneq (name
, "aranges"))
6118 || (do_debug_ranges
&& const_strneq (name
, "ranges"))
6119 || (do_debug_ranges
&& const_strneq (name
, "rnglists"))
6120 || (do_debug_frames
&& const_strneq (name
, "frame"))
6121 || (do_debug_macinfo
&& const_strneq (name
, "macinfo"))
6122 || (do_debug_macinfo
&& const_strneq (name
, "macro"))
6123 || (do_debug_str
&& const_strneq (name
, "str"))
6124 || (do_debug_loc
&& const_strneq (name
, "loc"))
6125 || (do_debug_loc
&& const_strneq (name
, "loclists"))
6126 || (do_debug_addr
&& const_strneq (name
, "addr"))
6127 || (do_debug_cu_index
&& const_strneq (name
, "cu_index"))
6128 || (do_debug_cu_index
&& const_strneq (name
, "tu_index"))
6130 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6132 /* Linkonce section to be combined with .debug_info at link time. */
6133 else if ((do_debugging
|| do_debug_info
)
6134 && const_strneq (name
, ".gnu.linkonce.wi."))
6135 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6136 else if (do_debug_frames
&& streq (name
, ".eh_frame"))
6137 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6138 else if (do_gdb_index
&& (streq (name
, ".gdb_index")
6139 || streq (name
, ".debug_names")))
6140 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6141 /* Trace sections for Itanium VMS. */
6142 else if ((do_debugging
|| do_trace_info
|| do_trace_abbrevs
6143 || do_trace_aranges
)
6144 && const_strneq (name
, ".trace_"))
6146 name
+= sizeof (".trace_") - 1;
6149 || (do_trace_info
&& streq (name
, "info"))
6150 || (do_trace_abbrevs
&& streq (name
, "abbrev"))
6151 || (do_trace_aranges
&& streq (name
, "aranges"))
6153 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6155 else if ((do_debugging
|| do_debug_links
)
6156 && (const_strneq (name
, ".gnu_debuglink")
6157 || const_strneq (name
, ".gnu_debugaltlink")))
6158 request_dump_bynumber (filedata
, i
, DEBUG_DUMP
);
6164 if (filedata
->file_header
.e_shnum
> 1)
6165 printf (_("\nSection Headers:\n"));
6167 printf (_("\nSection Header:\n"));
6171 if (do_section_details
)
6173 printf (_(" [Nr] Name\n"));
6174 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
6178 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
6182 if (do_section_details
)
6184 printf (_(" [Nr] Name\n"));
6185 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
6189 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
6193 if (do_section_details
)
6195 printf (_(" [Nr] Name\n"));
6196 printf (_(" Type Address Offset Link\n"));
6197 printf (_(" Size EntSize Info Align\n"));
6201 printf (_(" [Nr] Name Type Address Offset\n"));
6202 printf (_(" Size EntSize Flags Link Info Align\n"));
6206 if (do_section_details
)
6207 printf (_(" Flags\n"));
6209 for (i
= 0, section
= filedata
->section_headers
;
6210 i
< filedata
->file_header
.e_shnum
;
6213 /* Run some sanity checks on the section header. */
6215 /* Check the sh_link field. */
6216 switch (section
->sh_type
)
6218 case SHT_SYMTAB_SHNDX
:
6222 case SHT_GNU_versym
:
6225 if (section
->sh_link
< 1
6226 || section
->sh_link
>= filedata
->file_header
.e_shnum
6227 || (filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_SYMTAB
6228 && filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_DYNSYM
))
6229 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6230 i
, section
->sh_link
);
6236 case SHT_GNU_verneed
:
6237 case SHT_GNU_verdef
:
6238 case SHT_GNU_LIBLIST
:
6239 if (section
->sh_link
< 1
6240 || section
->sh_link
>= filedata
->file_header
.e_shnum
6241 || filedata
->section_headers
[section
->sh_link
].sh_type
!= SHT_STRTAB
)
6242 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6243 i
, section
->sh_link
);
6246 case SHT_INIT_ARRAY
:
6247 case SHT_FINI_ARRAY
:
6248 case SHT_PREINIT_ARRAY
:
6249 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6250 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6251 i
, section
->sh_link
);
6255 /* FIXME: Add support for target specific section types. */
6256 #if 0 /* Currently we do not check other section types as there are too
6257 many special cases. Stab sections for example have a type
6258 of SHT_PROGBITS but an sh_link field that links to the .stabstr
6260 if (section
->sh_type
< SHT_LOOS
&& section
->sh_link
!= 0)
6261 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6262 i
, section
->sh_link
);
6267 /* Check the sh_info field. */
6268 switch (section
->sh_type
)
6272 if (section
->sh_info
< 1
6273 || section
->sh_info
>= filedata
->file_header
.e_shnum
6274 || (filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_PROGBITS
6275 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOBITS
6276 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_NOTE
6277 && filedata
->section_headers
[section
->sh_info
].sh_type
!= SHT_INIT_ARRAY
6278 /* FIXME: Are other section types valid ? */
6279 && filedata
->section_headers
[section
->sh_info
].sh_type
< SHT_LOOS
))
6281 if (section
->sh_info
== 0
6282 && (filedata
->file_header
.e_type
== ET_EXEC
6283 || filedata
->file_header
.e_type
== ET_DYN
6284 /* These next two tests may be redundant, but
6285 they have been left in for paranoia's sake. */
6286 || streq (SECTION_NAME (section
), ".rel.dyn")
6287 || streq (SECTION_NAME (section
), ".rela.dyn")))
6288 /* Dynamic relocations apply to segments, not sections, so
6289 they do not need an sh_info value. */
6292 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6293 i
, section
->sh_info
);
6299 case SHT_SYMTAB_SHNDX
:
6300 case SHT_INIT_ARRAY
:
6301 case SHT_FINI_ARRAY
:
6302 case SHT_PREINIT_ARRAY
:
6303 if (section
->sh_info
!= 0)
6304 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6305 i
, section
->sh_info
);
6311 /* A symbol index - we assume that it is valid. */
6315 /* FIXME: Add support for target specific section types. */
6316 if (section
->sh_type
== SHT_NOBITS
)
6317 /* NOBITS section headers with non-zero sh_info fields can be
6318 created when a binary is stripped of everything but its debug
6319 information. The stripped sections have their headers
6320 preserved but their types set to SHT_NOBITS. So do not check
6321 this type of section. */
6323 else if (section
->sh_flags
& SHF_INFO_LINK
)
6325 if (section
->sh_info
< 1 || section
->sh_info
>= filedata
->file_header
.e_shnum
)
6326 warn (_("[%2u]: Expected link to another section in info field"), i
);
6328 else if (section
->sh_type
< SHT_LOOS
6329 && (section
->sh_flags
& SHF_GNU_MBIND
) == 0
6330 && section
->sh_info
!= 0)
6331 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6332 i
, section
->sh_info
);
6336 /* Check the sh_size field. */
6337 if (section
->sh_size
> filedata
->file_size
6338 && section
->sh_type
!= SHT_NOBITS
6339 && section
->sh_type
!= SHT_NULL
6340 && section
->sh_type
< SHT_LOOS
)
6341 warn (_("Size of section %u is larger than the entire file!\n"), i
);
6343 printf (" [%2u] ", i
);
6344 if (do_section_details
)
6345 printf ("%s\n ", printable_section_name (filedata
, section
));
6347 print_symbol (-17, SECTION_NAME (section
));
6349 printf (do_wide
? " %-15s " : " %-15.15s ",
6350 get_section_type_name (filedata
, section
->sh_type
));
6354 const char * link_too_big
= NULL
;
6356 print_vma (section
->sh_addr
, LONG_HEX
);
6358 printf ( " %6.6lx %6.6lx %2.2lx",
6359 (unsigned long) section
->sh_offset
,
6360 (unsigned long) section
->sh_size
,
6361 (unsigned long) section
->sh_entsize
);
6363 if (do_section_details
)
6364 fputs (" ", stdout
);
6366 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6368 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
6371 /* The sh_link value is out of range. Normally this indicates
6372 an error but it can have special values in Solaris binaries. */
6373 switch (filedata
->file_header
.e_machine
)
6380 case EM_OLD_SPARCV9
:
6381 case EM_SPARC32PLUS
:
6384 if (section
->sh_link
== (SHN_BEFORE
& 0xffff))
6385 link_too_big
= "BEFORE";
6386 else if (section
->sh_link
== (SHN_AFTER
& 0xffff))
6387 link_too_big
= "AFTER";
6394 if (do_section_details
)
6396 if (link_too_big
!= NULL
&& * link_too_big
)
6397 printf ("<%s> ", link_too_big
);
6399 printf ("%2u ", section
->sh_link
);
6400 printf ("%3u %2lu\n", section
->sh_info
,
6401 (unsigned long) section
->sh_addralign
);
6404 printf ("%2u %3u %2lu\n",
6407 (unsigned long) section
->sh_addralign
);
6409 if (link_too_big
&& ! * link_too_big
)
6410 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6411 i
, section
->sh_link
);
6415 print_vma (section
->sh_addr
, LONG_HEX
);
6417 if ((long) section
->sh_offset
== section
->sh_offset
)
6418 printf (" %6.6lx", (unsigned long) section
->sh_offset
);
6422 print_vma (section
->sh_offset
, LONG_HEX
);
6425 if ((unsigned long) section
->sh_size
== section
->sh_size
)
6426 printf (" %6.6lx", (unsigned long) section
->sh_size
);
6430 print_vma (section
->sh_size
, LONG_HEX
);
6433 if ((unsigned long) section
->sh_entsize
== section
->sh_entsize
)
6434 printf (" %2.2lx", (unsigned long) section
->sh_entsize
);
6438 print_vma (section
->sh_entsize
, LONG_HEX
);
6441 if (do_section_details
)
6442 fputs (" ", stdout
);
6444 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6446 printf ("%2u %3u ", section
->sh_link
, section
->sh_info
);
6448 if ((unsigned long) section
->sh_addralign
== section
->sh_addralign
)
6449 printf ("%2lu\n", (unsigned long) section
->sh_addralign
);
6452 print_vma (section
->sh_addralign
, DEC
);
6456 else if (do_section_details
)
6458 printf (" %-15.15s ",
6459 get_section_type_name (filedata
, section
->sh_type
));
6460 print_vma (section
->sh_addr
, LONG_HEX
);
6461 if ((long) section
->sh_offset
== section
->sh_offset
)
6462 printf (" %16.16lx", (unsigned long) section
->sh_offset
);
6466 print_vma (section
->sh_offset
, LONG_HEX
);
6468 printf (" %u\n ", section
->sh_link
);
6469 print_vma (section
->sh_size
, LONG_HEX
);
6471 print_vma (section
->sh_entsize
, LONG_HEX
);
6473 printf (" %-16u %lu\n",
6475 (unsigned long) section
->sh_addralign
);
6480 print_vma (section
->sh_addr
, LONG_HEX
);
6481 if ((long) section
->sh_offset
== section
->sh_offset
)
6482 printf (" %8.8lx", (unsigned long) section
->sh_offset
);
6486 print_vma (section
->sh_offset
, LONG_HEX
);
6489 print_vma (section
->sh_size
, LONG_HEX
);
6491 print_vma (section
->sh_entsize
, LONG_HEX
);
6493 printf (" %3s ", get_elf_section_flags (filedata
, section
->sh_flags
));
6495 printf (" %2u %3u %lu\n",
6498 (unsigned long) section
->sh_addralign
);
6501 if (do_section_details
)
6503 printf (" %s\n", get_elf_section_flags (filedata
, section
->sh_flags
));
6504 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
6506 /* Minimum section size is 12 bytes for 32-bit compression
6507 header + 12 bytes for compressed data header. */
6508 unsigned char buf
[24];
6510 assert (sizeof (buf
) >= sizeof (Elf64_External_Chdr
));
6511 if (get_data (&buf
, filedata
, section
->sh_offset
, 1,
6512 sizeof (buf
), _("compression header")))
6514 Elf_Internal_Chdr chdr
;
6516 (void) get_compression_header (&chdr
, buf
, sizeof (buf
));
6518 if (chdr
.ch_type
== ELFCOMPRESS_ZLIB
)
6521 printf (_(" [<unknown>: 0x%x], "),
6523 print_vma (chdr
.ch_size
, LONG_HEX
);
6524 printf (", %lu\n", (unsigned long) chdr
.ch_addralign
);
6530 if (!do_section_details
)
6532 /* The ordering of the letters shown here matches the ordering of the
6533 corresponding SHF_xxx values, and hence the order in which these
6534 letters will be displayed to the user. */
6535 printf (_("Key to Flags:\n\
6536 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6537 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6538 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
6539 if (filedata
->file_header
.e_machine
== EM_X86_64
6540 || filedata
->file_header
.e_machine
== EM_L1OM
6541 || filedata
->file_header
.e_machine
== EM_K1OM
)
6542 printf (_("l (large), "));
6543 else if (filedata
->file_header
.e_machine
== EM_ARM
)
6544 printf (_("y (purecode), "));
6545 else if (filedata
->file_header
.e_machine
== EM_PPC
)
6546 printf (_("v (VLE), "));
6547 printf ("p (processor specific)\n");
6554 get_group_flags (unsigned int flags
)
6556 static char buff
[128];
6560 else if (flags
== GRP_COMDAT
)
6563 snprintf (buff
, 14, _("[0x%x: "), flags
);
6565 flags
&= ~ GRP_COMDAT
;
6566 if (flags
& GRP_MASKOS
)
6568 strcat (buff
, "<OS specific>");
6569 flags
&= ~ GRP_MASKOS
;
6572 if (flags
& GRP_MASKPROC
)
6574 strcat (buff
, "<PROC specific>");
6575 flags
&= ~ GRP_MASKPROC
;
6579 strcat (buff
, "<unknown>");
6586 process_section_groups (Filedata
* filedata
)
6588 Elf_Internal_Shdr
* section
;
6590 struct group
* group
;
6591 Elf_Internal_Shdr
* symtab_sec
;
6592 Elf_Internal_Shdr
* strtab_sec
;
6593 Elf_Internal_Sym
* symtab
;
6594 unsigned long num_syms
;
6598 /* Don't process section groups unless needed. */
6599 if (!do_unwind
&& !do_section_groups
)
6602 if (filedata
->file_header
.e_shnum
== 0)
6604 if (do_section_groups
)
6605 printf (_("\nThere are no sections to group in this file.\n"));
6610 if (filedata
->section_headers
== NULL
)
6612 error (_("Section headers are not available!\n"));
6613 /* PR 13622: This can happen with a corrupt ELF header. */
6617 section_headers_groups
= (struct group
**) calloc (filedata
->file_header
.e_shnum
,
6618 sizeof (struct group
*));
6620 if (section_headers_groups
== NULL
)
6622 error (_("Out of memory reading %u section group headers\n"),
6623 filedata
->file_header
.e_shnum
);
6627 /* Scan the sections for the group section. */
6629 for (i
= 0, section
= filedata
->section_headers
;
6630 i
< filedata
->file_header
.e_shnum
;
6632 if (section
->sh_type
== SHT_GROUP
)
6635 if (group_count
== 0)
6637 if (do_section_groups
)
6638 printf (_("\nThere are no section groups in this file.\n"));
6643 section_groups
= (struct group
*) calloc (group_count
, sizeof (struct group
));
6645 if (section_groups
== NULL
)
6647 error (_("Out of memory reading %lu groups\n"),
6648 (unsigned long) group_count
);
6658 for (i
= 0, section
= filedata
->section_headers
, group
= section_groups
;
6659 i
< filedata
->file_header
.e_shnum
;
6662 if (section
->sh_type
== SHT_GROUP
)
6664 const char * name
= printable_section_name (filedata
, section
);
6665 const char * group_name
;
6666 unsigned char * start
;
6667 unsigned char * indices
;
6668 unsigned int entry
, j
, size
;
6669 Elf_Internal_Shdr
* sec
;
6670 Elf_Internal_Sym
* sym
;
6672 /* Get the symbol table. */
6673 if (section
->sh_link
>= filedata
->file_header
.e_shnum
6674 || ((sec
= filedata
->section_headers
+ section
->sh_link
)->sh_type
6677 error (_("Bad sh_link in group section `%s'\n"), name
);
6681 if (symtab_sec
!= sec
)
6686 symtab
= GET_ELF_SYMBOLS (filedata
, symtab_sec
, & num_syms
);
6691 error (_("Corrupt header in group section `%s'\n"), name
);
6695 if (section
->sh_info
>= num_syms
)
6697 error (_("Bad sh_info in group section `%s'\n"), name
);
6701 sym
= symtab
+ section
->sh_info
;
6703 if (ELF_ST_TYPE (sym
->st_info
) == STT_SECTION
)
6705 if (sym
->st_shndx
== 0
6706 || sym
->st_shndx
>= filedata
->file_header
.e_shnum
)
6708 error (_("Bad sh_info in group section `%s'\n"), name
);
6712 group_name
= SECTION_NAME (filedata
->section_headers
+ sym
->st_shndx
);
6721 /* Get the string table. */
6722 if (symtab_sec
->sh_link
>= filedata
->file_header
.e_shnum
)
6731 != (sec
= filedata
->section_headers
+ symtab_sec
->sh_link
))
6737 strtab
= (char *) get_data (NULL
, filedata
, strtab_sec
->sh_offset
,
6738 1, strtab_sec
->sh_size
,
6740 strtab_size
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
6742 group_name
= sym
->st_name
< strtab_size
6743 ? strtab
+ sym
->st_name
: _("<corrupt>");
6746 /* PR 17531: file: loop. */
6747 if (section
->sh_entsize
> section
->sh_size
)
6749 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6750 printable_section_name (filedata
, section
),
6751 (unsigned long) section
->sh_entsize
,
6752 (unsigned long) section
->sh_size
);
6756 start
= (unsigned char *) get_data (NULL
, filedata
, section
->sh_offset
,
6757 1, section
->sh_size
,
6763 size
= (section
->sh_size
/ section
->sh_entsize
) - 1;
6764 entry
= byte_get (indices
, 4);
6767 if (do_section_groups
)
6769 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6770 get_group_flags (entry
), i
, name
, group_name
, size
);
6772 printf (_(" [Index] Name\n"));
6775 group
->group_index
= i
;
6777 for (j
= 0; j
< size
; j
++)
6779 struct group_list
* g
;
6781 entry
= byte_get (indices
, 4);
6784 if (entry
>= filedata
->file_header
.e_shnum
)
6786 static unsigned num_group_errors
= 0;
6788 if (num_group_errors
++ < 10)
6790 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6791 entry
, i
, filedata
->file_header
.e_shnum
- 1);
6792 if (num_group_errors
== 10)
6793 warn (_("Further error messages about overlarge group section indicies suppressed\n"));
6798 if (section_headers_groups
[entry
] != NULL
)
6802 static unsigned num_errs
= 0;
6804 if (num_errs
++ < 10)
6806 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6808 section_headers_groups
[entry
]->group_index
);
6810 warn (_("Further error messages about already contained group sections suppressed\n"));
6816 /* Intel C/C++ compiler may put section 0 in a
6817 section group. We just warn it the first time
6818 and ignore it afterwards. */
6819 static bfd_boolean warned
= FALSE
;
6822 error (_("section 0 in group section [%5u]\n"),
6823 section_headers_groups
[entry
]->group_index
);
6829 section_headers_groups
[entry
] = group
;
6831 if (do_section_groups
)
6833 sec
= filedata
->section_headers
+ entry
;
6834 printf (" [%5u] %s\n", entry
, printable_section_name (filedata
, sec
));
6837 g
= (struct group_list
*) xmalloc (sizeof (struct group_list
));
6838 g
->section_index
= entry
;
6839 g
->next
= group
->root
;
6857 /* Data used to display dynamic fixups. */
6859 struct ia64_vms_dynfixup
6861 bfd_vma needed_ident
; /* Library ident number. */
6862 bfd_vma needed
; /* Index in the dstrtab of the library name. */
6863 bfd_vma fixup_needed
; /* Index of the library. */
6864 bfd_vma fixup_rela_cnt
; /* Number of fixups. */
6865 bfd_vma fixup_rela_off
; /* Fixups offset in the dynamic segment. */
6868 /* Data used to display dynamic relocations. */
6870 struct ia64_vms_dynimgrela
6872 bfd_vma img_rela_cnt
; /* Number of relocations. */
6873 bfd_vma img_rela_off
; /* Reloc offset in the dynamic segment. */
6876 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6880 dump_ia64_vms_dynamic_fixups (Filedata
* filedata
,
6881 struct ia64_vms_dynfixup
* fixup
,
6882 const char * strtab
,
6883 unsigned int strtab_sz
)
6885 Elf64_External_VMS_IMAGE_FIXUP
* imfs
;
6887 const char * lib_name
;
6889 imfs
= get_data (NULL
, filedata
, dynamic_addr
+ fixup
->fixup_rela_off
,
6890 1, fixup
->fixup_rela_cnt
* sizeof (*imfs
),
6891 _("dynamic section image fixups"));
6895 if (fixup
->needed
< strtab_sz
)
6896 lib_name
= strtab
+ fixup
->needed
;
6899 warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
6900 (unsigned long) fixup
->needed
);
6903 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6904 (int) fixup
->fixup_needed
, lib_name
, (long) fixup
->needed_ident
);
6906 (_("Seg Offset Type SymVec DataType\n"));
6908 for (i
= 0; i
< (long) fixup
->fixup_rela_cnt
; i
++)
6913 printf ("%3u ", (unsigned) BYTE_GET (imfs
[i
].fixup_seg
));
6914 printf_vma ((bfd_vma
) BYTE_GET (imfs
[i
].fixup_offset
));
6915 type
= BYTE_GET (imfs
[i
].type
);
6916 rtype
= elf_ia64_reloc_type (type
);
6918 printf (" 0x%08x ", type
);
6920 printf (" %-32s ", rtype
);
6921 printf ("%6u ", (unsigned) BYTE_GET (imfs
[i
].symvec_index
));
6922 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs
[i
].data_type
));
6929 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
6932 dump_ia64_vms_dynamic_relocs (Filedata
* filedata
, struct ia64_vms_dynimgrela
*imgrela
)
6934 Elf64_External_VMS_IMAGE_RELA
*imrs
;
6937 imrs
= get_data (NULL
, filedata
, dynamic_addr
+ imgrela
->img_rela_off
,
6938 1, imgrela
->img_rela_cnt
* sizeof (*imrs
),
6939 _("dynamic section image relocations"));
6943 printf (_("\nImage relocs\n"));
6945 (_("Seg Offset Type Addend Seg Sym Off\n"));
6947 for (i
= 0; i
< (long) imgrela
->img_rela_cnt
; i
++)
6952 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].rela_seg
));
6953 printf ("%08" BFD_VMA_FMT
"x ",
6954 (bfd_vma
) BYTE_GET (imrs
[i
].rela_offset
));
6955 type
= BYTE_GET (imrs
[i
].type
);
6956 rtype
= elf_ia64_reloc_type (type
);
6958 printf ("0x%08x ", type
);
6960 printf ("%-31s ", rtype
);
6961 print_vma (BYTE_GET (imrs
[i
].addend
), FULL_HEX
);
6962 printf ("%3u ", (unsigned) BYTE_GET (imrs
[i
].sym_seg
));
6963 printf ("%08" BFD_VMA_FMT
"x\n",
6964 (bfd_vma
) BYTE_GET (imrs
[i
].sym_offset
));
6971 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
6974 process_ia64_vms_dynamic_relocs (Filedata
* filedata
)
6976 struct ia64_vms_dynfixup fixup
;
6977 struct ia64_vms_dynimgrela imgrela
;
6978 Elf_Internal_Dyn
*entry
;
6979 bfd_vma strtab_off
= 0;
6980 bfd_vma strtab_sz
= 0;
6981 char *strtab
= NULL
;
6982 bfd_boolean res
= TRUE
;
6984 memset (&fixup
, 0, sizeof (fixup
));
6985 memset (&imgrela
, 0, sizeof (imgrela
));
6987 /* Note: the order of the entries is specified by the OpenVMS specs. */
6988 for (entry
= dynamic_section
;
6989 entry
< dynamic_section
+ dynamic_nent
;
6992 switch (entry
->d_tag
)
6994 case DT_IA_64_VMS_STRTAB_OFFSET
:
6995 strtab_off
= entry
->d_un
.d_val
;
6998 strtab_sz
= entry
->d_un
.d_val
;
7000 strtab
= get_data (NULL
, filedata
, dynamic_addr
+ strtab_off
,
7001 1, strtab_sz
, _("dynamic string section"));
7004 case DT_IA_64_VMS_NEEDED_IDENT
:
7005 fixup
.needed_ident
= entry
->d_un
.d_val
;
7008 fixup
.needed
= entry
->d_un
.d_val
;
7010 case DT_IA_64_VMS_FIXUP_NEEDED
:
7011 fixup
.fixup_needed
= entry
->d_un
.d_val
;
7013 case DT_IA_64_VMS_FIXUP_RELA_CNT
:
7014 fixup
.fixup_rela_cnt
= entry
->d_un
.d_val
;
7016 case DT_IA_64_VMS_FIXUP_RELA_OFF
:
7017 fixup
.fixup_rela_off
= entry
->d_un
.d_val
;
7018 if (! dump_ia64_vms_dynamic_fixups (filedata
, &fixup
, strtab
, strtab_sz
))
7021 case DT_IA_64_VMS_IMG_RELA_CNT
:
7022 imgrela
.img_rela_cnt
= entry
->d_un
.d_val
;
7024 case DT_IA_64_VMS_IMG_RELA_OFF
:
7025 imgrela
.img_rela_off
= entry
->d_un
.d_val
;
7026 if (! dump_ia64_vms_dynamic_relocs (filedata
, &imgrela
))
7048 dynamic_relocations
[] =
7050 { "REL", DT_REL
, DT_RELSZ
, FALSE
},
7051 { "RELA", DT_RELA
, DT_RELASZ
, TRUE
},
7052 { "PLT", DT_JMPREL
, DT_PLTRELSZ
, UNKNOWN
}
7055 /* Process the reloc section. */
7058 process_relocs (Filedata
* filedata
)
7060 unsigned long rel_size
;
7061 unsigned long rel_offset
;
7066 if (do_using_dynamic
)
7070 bfd_boolean has_dynamic_reloc
;
7073 has_dynamic_reloc
= FALSE
;
7075 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7077 is_rela
= dynamic_relocations
[i
].rela
;
7078 name
= dynamic_relocations
[i
].name
;
7079 rel_size
= dynamic_info
[dynamic_relocations
[i
].size
];
7080 rel_offset
= dynamic_info
[dynamic_relocations
[i
].reloc
];
7083 has_dynamic_reloc
= TRUE
;
7085 if (is_rela
== UNKNOWN
)
7087 if (dynamic_relocations
[i
].reloc
== DT_JMPREL
)
7088 switch (dynamic_info
[DT_PLTREL
])
7102 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
7103 name
, rel_offset
, rel_size
);
7105 dump_relocations (filedata
,
7106 offset_from_vma (filedata
, rel_offset
, rel_size
),
7108 dynamic_symbols
, num_dynamic_syms
,
7109 dynamic_strings
, dynamic_strings_length
,
7110 is_rela
, TRUE
/* is_dynamic */);
7114 if (is_ia64_vms (filedata
))
7115 if (process_ia64_vms_dynamic_relocs (filedata
))
7116 has_dynamic_reloc
= TRUE
;
7118 if (! has_dynamic_reloc
)
7119 printf (_("\nThere are no dynamic relocations in this file.\n"));
7123 Elf_Internal_Shdr
* section
;
7125 bfd_boolean found
= FALSE
;
7127 for (i
= 0, section
= filedata
->section_headers
;
7128 i
< filedata
->file_header
.e_shnum
;
7131 if ( section
->sh_type
!= SHT_RELA
7132 && section
->sh_type
!= SHT_REL
)
7135 rel_offset
= section
->sh_offset
;
7136 rel_size
= section
->sh_size
;
7140 Elf_Internal_Shdr
* strsec
;
7142 unsigned long num_rela
;
7144 printf (_("\nRelocation section "));
7146 if (filedata
->string_table
== NULL
)
7147 printf ("%d", section
->sh_name
);
7149 printf ("'%s'", printable_section_name (filedata
, section
));
7151 num_rela
= rel_size
/ section
->sh_entsize
;
7152 printf (ngettext (" at offset 0x%lx contains %lu entry:\n",
7153 " at offset 0x%lx contains %lu entries:\n",
7155 rel_offset
, num_rela
);
7157 is_rela
= section
->sh_type
== SHT_RELA
;
7159 if (section
->sh_link
!= 0
7160 && section
->sh_link
< filedata
->file_header
.e_shnum
)
7162 Elf_Internal_Shdr
* symsec
;
7163 Elf_Internal_Sym
* symtab
;
7164 unsigned long nsyms
;
7165 unsigned long strtablen
= 0;
7166 char * strtab
= NULL
;
7168 symsec
= filedata
->section_headers
+ section
->sh_link
;
7169 if (symsec
->sh_type
!= SHT_SYMTAB
7170 && symsec
->sh_type
!= SHT_DYNSYM
)
7173 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & nsyms
);
7178 if (symsec
->sh_link
!= 0
7179 && symsec
->sh_link
< filedata
->file_header
.e_shnum
)
7181 strsec
= filedata
->section_headers
+ symsec
->sh_link
;
7183 strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
7186 strtablen
= strtab
== NULL
? 0 : strsec
->sh_size
;
7189 dump_relocations (filedata
, rel_offset
, rel_size
,
7190 symtab
, nsyms
, strtab
, strtablen
,
7192 symsec
->sh_type
== SHT_DYNSYM
);
7198 dump_relocations (filedata
, rel_offset
, rel_size
,
7199 NULL
, 0, NULL
, 0, is_rela
,
7200 FALSE
/* is_dynamic */);
7208 /* Users sometimes forget the -D option, so try to be helpful. */
7209 for (i
= 0; i
< ARRAY_SIZE (dynamic_relocations
); i
++)
7211 if (dynamic_info
[dynamic_relocations
[i
].size
])
7213 printf (_("\nThere are no static relocations in this file."));
7214 printf (_("\nTo see the dynamic relocations add --use-dynamic to the command line.\n"));
7219 if (i
== ARRAY_SIZE (dynamic_relocations
))
7220 printf (_("\nThere are no relocations in this file.\n"));
7227 /* An absolute address consists of a section and an offset. If the
7228 section is NULL, the offset itself is the address, otherwise, the
7229 address equals to LOAD_ADDRESS(section) + offset. */
7233 unsigned short section
;
7237 #define ABSADDR(a) \
7239 ? filedata->section_headers [(a).section].sh_addr + (a).offset \
7242 /* Find the nearest symbol at or below ADDR. Returns the symbol
7243 name, if found, and the offset from the symbol to ADDR. */
7246 find_symbol_for_address (Filedata
* filedata
,
7247 Elf_Internal_Sym
* symtab
,
7248 unsigned long nsyms
,
7249 const char * strtab
,
7250 unsigned long strtab_size
,
7251 struct absaddr addr
,
7252 const char ** symname
,
7255 bfd_vma dist
= 0x100000;
7256 Elf_Internal_Sym
* sym
;
7257 Elf_Internal_Sym
* beg
;
7258 Elf_Internal_Sym
* end
;
7259 Elf_Internal_Sym
* best
= NULL
;
7261 REMOVE_ARCH_BITS (addr
.offset
);
7263 end
= symtab
+ nsyms
;
7269 sym
= beg
+ (end
- beg
) / 2;
7271 value
= sym
->st_value
;
7272 REMOVE_ARCH_BITS (value
);
7274 if (sym
->st_name
!= 0
7275 && (addr
.section
== SHN_UNDEF
|| addr
.section
== sym
->st_shndx
)
7276 && addr
.offset
>= value
7277 && addr
.offset
- value
< dist
)
7280 dist
= addr
.offset
- value
;
7285 if (addr
.offset
< value
)
7293 *symname
= (best
->st_name
>= strtab_size
7294 ? _("<corrupt>") : strtab
+ best
->st_name
);
7300 *offset
= addr
.offset
;
7303 static /* signed */ int
7304 symcmp (const void *p
, const void *q
)
7306 Elf_Internal_Sym
*sp
= (Elf_Internal_Sym
*) p
;
7307 Elf_Internal_Sym
*sq
= (Elf_Internal_Sym
*) q
;
7309 return sp
->st_value
> sq
->st_value
? 1 : (sp
->st_value
< sq
->st_value
? -1 : 0);
7312 /* Process the unwind section. */
7314 #include "unwind-ia64.h"
7316 struct ia64_unw_table_entry
7318 struct absaddr start
;
7320 struct absaddr info
;
7323 struct ia64_unw_aux_info
7325 struct ia64_unw_table_entry
* table
; /* Unwind table. */
7326 unsigned long table_len
; /* Length of unwind table. */
7327 unsigned char * info
; /* Unwind info. */
7328 unsigned long info_size
; /* Size of unwind info. */
7329 bfd_vma info_addr
; /* Starting address of unwind info. */
7330 bfd_vma seg_base
; /* Starting address of segment. */
7331 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7332 unsigned long nsyms
; /* Number of symbols. */
7333 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7334 unsigned long nfuns
; /* Number of entries in funtab. */
7335 char * strtab
; /* The string table. */
7336 unsigned long strtab_size
; /* Size of string table. */
7340 dump_ia64_unwind (Filedata
* filedata
, struct ia64_unw_aux_info
* aux
)
7342 struct ia64_unw_table_entry
* tp
;
7343 unsigned long j
, nfuns
;
7345 bfd_boolean res
= TRUE
;
7347 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7348 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7349 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7350 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7352 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7354 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7358 const unsigned char * dp
;
7359 const unsigned char * head
;
7360 const unsigned char * end
;
7361 const char * procname
;
7363 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7364 aux
->strtab_size
, tp
->start
, &procname
, &offset
);
7366 fputs ("\n<", stdout
);
7370 fputs (procname
, stdout
);
7373 printf ("+%lx", (unsigned long) offset
);
7376 fputs (">: [", stdout
);
7377 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7378 fputc ('-', stdout
);
7379 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7380 printf ("], info at +0x%lx\n",
7381 (unsigned long) (tp
->info
.offset
- aux
->seg_base
));
7383 /* PR 17531: file: 86232b32. */
7384 if (aux
->info
== NULL
)
7387 /* PR 17531: file: 0997b4d1. */
7388 if ((ABSADDR (tp
->info
) - aux
->info_addr
) >= aux
->info_size
)
7390 warn (_("Invalid offset %lx in table entry %ld\n"),
7391 (long) tp
->info
.offset
, (long) (tp
- aux
->table
));
7396 head
= aux
->info
+ (ABSADDR (tp
->info
) - aux
->info_addr
);
7397 stamp
= byte_get ((unsigned char *) head
, sizeof (stamp
));
7399 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7400 (unsigned) UNW_VER (stamp
),
7401 (unsigned long) ((stamp
& UNW_FLAG_MASK
) >> 32),
7402 UNW_FLAG_EHANDLER (stamp
) ? " ehandler" : "",
7403 UNW_FLAG_UHANDLER (stamp
) ? " uhandler" : "",
7404 (unsigned long) (eh_addr_size
* UNW_LENGTH (stamp
)));
7406 if (UNW_VER (stamp
) != 1)
7408 printf (_("\tUnknown version.\n"));
7413 end
= head
+ 8 + eh_addr_size
* UNW_LENGTH (stamp
);
7414 /* PR 17531: file: 16ceda89. */
7415 if (end
> aux
->info
+ aux
->info_size
)
7416 end
= aux
->info
+ aux
->info_size
;
7417 for (dp
= head
+ 8; dp
< end
;)
7418 dp
= unw_decode (dp
, in_body
, & in_body
, end
);
7427 slurp_ia64_unwind_table (Filedata
* filedata
,
7428 struct ia64_unw_aux_info
* aux
,
7429 Elf_Internal_Shdr
* sec
)
7431 unsigned long size
, nrelas
, i
;
7432 Elf_Internal_Phdr
* seg
;
7433 struct ia64_unw_table_entry
* tep
;
7434 Elf_Internal_Shdr
* relsec
;
7435 Elf_Internal_Rela
* rela
;
7436 Elf_Internal_Rela
* rp
;
7437 unsigned char * table
;
7439 Elf_Internal_Sym
* sym
;
7440 const char * relname
;
7444 /* First, find the starting address of the segment that includes
7447 if (filedata
->file_header
.e_phnum
)
7449 if (! get_program_headers (filedata
))
7452 for (seg
= filedata
->program_headers
;
7453 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
7456 if (seg
->p_type
!= PT_LOAD
)
7459 if (sec
->sh_addr
>= seg
->p_vaddr
7460 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7462 aux
->seg_base
= seg
->p_vaddr
;
7468 /* Second, build the unwind table from the contents of the unwind section: */
7469 size
= sec
->sh_size
;
7470 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
7475 aux
->table_len
= size
/ (3 * eh_addr_size
);
7476 aux
->table
= (struct ia64_unw_table_entry
*)
7477 xcmalloc (aux
->table_len
, sizeof (aux
->table
[0]));
7480 for (tp
= table
; tp
<= table
+ size
- (3 * eh_addr_size
); ++tep
)
7482 tep
->start
.section
= SHN_UNDEF
;
7483 tep
->end
.section
= SHN_UNDEF
;
7484 tep
->info
.section
= SHN_UNDEF
;
7485 tep
->start
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7486 tep
->end
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7487 tep
->info
.offset
= byte_get (tp
, eh_addr_size
); tp
+= eh_addr_size
;
7488 tep
->start
.offset
+= aux
->seg_base
;
7489 tep
->end
.offset
+= aux
->seg_base
;
7490 tep
->info
.offset
+= aux
->seg_base
;
7494 /* Third, apply any relocations to the unwind table: */
7495 for (relsec
= filedata
->section_headers
;
7496 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
7499 if (relsec
->sh_type
!= SHT_RELA
7500 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
7501 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
7504 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
7513 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7515 relname
= elf_ia64_reloc_type (get_reloc_type (filedata
, rp
->r_info
));
7516 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
7518 /* PR 17531: file: 9fa67536. */
7519 if (relname
== NULL
)
7521 warn (_("Skipping unknown relocation type: %u\n"),
7522 get_reloc_type (filedata
, rp
->r_info
));
7526 if (! const_strneq (relname
, "R_IA64_SEGREL"))
7528 warn (_("Skipping unexpected relocation type: %s\n"), relname
);
7532 i
= rp
->r_offset
/ (3 * eh_addr_size
);
7534 /* PR 17531: file: 5bc8d9bf. */
7535 if (i
>= aux
->table_len
)
7537 warn (_("Skipping reloc with overlarge offset: %lx\n"), i
);
7541 switch (rp
->r_offset
/ eh_addr_size
% 3)
7544 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7545 aux
->table
[i
].start
.offset
= rp
->r_addend
+ sym
->st_value
;
7548 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7549 aux
->table
[i
].end
.offset
= rp
->r_addend
+ sym
->st_value
;
7552 aux
->table
[i
].info
.section
= sym
->st_shndx
;
7553 aux
->table
[i
].info
.offset
= rp
->r_addend
+ sym
->st_value
;
7567 ia64_process_unwind (Filedata
* filedata
)
7569 Elf_Internal_Shdr
* sec
;
7570 Elf_Internal_Shdr
* unwsec
= NULL
;
7571 Elf_Internal_Shdr
* strsec
;
7572 unsigned long i
, unwcount
= 0, unwstart
= 0;
7573 struct ia64_unw_aux_info aux
;
7574 bfd_boolean res
= TRUE
;
7576 memset (& aux
, 0, sizeof (aux
));
7578 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
7580 if (sec
->sh_type
== SHT_SYMTAB
7581 && sec
->sh_link
< filedata
->file_header
.e_shnum
)
7583 aux
.symtab
= GET_ELF_SYMBOLS (filedata
, sec
, & aux
.nsyms
);
7585 strsec
= filedata
->section_headers
+ sec
->sh_link
;
7586 if (aux
.strtab
!= NULL
)
7588 error (_("Multiple auxillary string tables encountered\n"));
7592 aux
.strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
7595 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
7597 else if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7602 printf (_("\nThere are no unwind sections in this file.\n"));
7604 while (unwcount
-- > 0)
7609 for (i
= unwstart
, sec
= filedata
->section_headers
+ unwstart
, unwsec
= NULL
;
7610 i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
7611 if (sec
->sh_type
== SHT_IA_64_UNWIND
)
7616 /* We have already counted the number of SHT_IA64_UNWIND
7617 sections so the loop above should never fail. */
7618 assert (unwsec
!= NULL
);
7621 len
= sizeof (ELF_STRING_ia64_unwind_once
) - 1;
7623 if ((unwsec
->sh_flags
& SHF_GROUP
) != 0)
7625 /* We need to find which section group it is in. */
7626 struct group_list
* g
;
7628 if (section_headers_groups
== NULL
7629 || section_headers_groups
[i
] == NULL
)
7630 i
= filedata
->file_header
.e_shnum
;
7633 g
= section_headers_groups
[i
]->root
;
7635 for (; g
!= NULL
; g
= g
->next
)
7637 sec
= filedata
->section_headers
+ g
->section_index
;
7639 if (streq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
))
7644 i
= filedata
->file_header
.e_shnum
;
7647 else if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind_once
, len
))
7649 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
7650 len2
= sizeof (ELF_STRING_ia64_unwind_info_once
) - 1;
7651 suffix
= SECTION_NAME (unwsec
) + len
;
7652 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
;
7654 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info_once
, len2
)
7655 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7660 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7661 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
7662 len
= sizeof (ELF_STRING_ia64_unwind
) - 1;
7663 len2
= sizeof (ELF_STRING_ia64_unwind_info
) - 1;
7665 if (strneq (SECTION_NAME (unwsec
), ELF_STRING_ia64_unwind
, len
))
7666 suffix
= SECTION_NAME (unwsec
) + len
;
7667 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
;
7669 if (strneq (SECTION_NAME (sec
), ELF_STRING_ia64_unwind_info
, len2
)
7670 && streq (SECTION_NAME (sec
) + len2
, suffix
))
7674 if (i
== filedata
->file_header
.e_shnum
)
7676 printf (_("\nCould not find unwind info section for "));
7678 if (filedata
->string_table
== NULL
)
7679 printf ("%d", unwsec
->sh_name
);
7681 printf ("'%s'", printable_section_name (filedata
, unwsec
));
7685 aux
.info_addr
= sec
->sh_addr
;
7686 aux
.info
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1,
7689 aux
.info_size
= aux
.info
== NULL
? 0 : sec
->sh_size
;
7691 printf (_("\nUnwind section "));
7693 if (filedata
->string_table
== NULL
)
7694 printf ("%d", unwsec
->sh_name
);
7696 printf ("'%s'", printable_section_name (filedata
, unwsec
));
7698 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7699 (unsigned long) unwsec
->sh_offset
,
7700 (unsigned long) (unwsec
->sh_size
/ (3 * eh_addr_size
)));
7702 if (slurp_ia64_unwind_table (filedata
, & aux
, unwsec
)
7703 && aux
.table_len
> 0)
7704 dump_ia64_unwind (filedata
, & aux
);
7707 free ((char *) aux
.table
);
7709 free ((char *) aux
.info
);
7718 free ((char *) aux
.strtab
);
7723 struct hppa_unw_table_entry
7725 struct absaddr start
;
7727 unsigned int Cannot_unwind
:1; /* 0 */
7728 unsigned int Millicode
:1; /* 1 */
7729 unsigned int Millicode_save_sr0
:1; /* 2 */
7730 unsigned int Region_description
:2; /* 3..4 */
7731 unsigned int reserved1
:1; /* 5 */
7732 unsigned int Entry_SR
:1; /* 6 */
7733 unsigned int Entry_FR
:4; /* Number saved 7..10 */
7734 unsigned int Entry_GR
:5; /* Number saved 11..15 */
7735 unsigned int Args_stored
:1; /* 16 */
7736 unsigned int Variable_Frame
:1; /* 17 */
7737 unsigned int Separate_Package_Body
:1; /* 18 */
7738 unsigned int Frame_Extension_Millicode
:1; /* 19 */
7739 unsigned int Stack_Overflow_Check
:1; /* 20 */
7740 unsigned int Two_Instruction_SP_Increment
:1; /* 21 */
7741 unsigned int Ada_Region
:1; /* 22 */
7742 unsigned int cxx_info
:1; /* 23 */
7743 unsigned int cxx_try_catch
:1; /* 24 */
7744 unsigned int sched_entry_seq
:1; /* 25 */
7745 unsigned int reserved2
:1; /* 26 */
7746 unsigned int Save_SP
:1; /* 27 */
7747 unsigned int Save_RP
:1; /* 28 */
7748 unsigned int Save_MRP_in_frame
:1; /* 29 */
7749 unsigned int extn_ptr_defined
:1; /* 30 */
7750 unsigned int Cleanup_defined
:1; /* 31 */
7752 unsigned int MPE_XL_interrupt_marker
:1; /* 0 */
7753 unsigned int HP_UX_interrupt_marker
:1; /* 1 */
7754 unsigned int Large_frame
:1; /* 2 */
7755 unsigned int Pseudo_SP_Set
:1; /* 3 */
7756 unsigned int reserved4
:1; /* 4 */
7757 unsigned int Total_frame_size
:27; /* 5..31 */
7760 struct hppa_unw_aux_info
7762 struct hppa_unw_table_entry
* table
; /* Unwind table. */
7763 unsigned long table_len
; /* Length of unwind table. */
7764 bfd_vma seg_base
; /* Starting address of segment. */
7765 Elf_Internal_Sym
* symtab
; /* The symbol table. */
7766 unsigned long nsyms
; /* Number of symbols. */
7767 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
7768 unsigned long nfuns
; /* Number of entries in funtab. */
7769 char * strtab
; /* The string table. */
7770 unsigned long strtab_size
; /* Size of string table. */
7774 dump_hppa_unwind (Filedata
* filedata
, struct hppa_unw_aux_info
* aux
)
7776 struct hppa_unw_table_entry
* tp
;
7777 unsigned long j
, nfuns
;
7778 bfd_boolean res
= TRUE
;
7780 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
7781 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
7782 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
7783 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
7785 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
7787 for (tp
= aux
->table
; tp
< aux
->table
+ aux
->table_len
; ++tp
)
7790 const char * procname
;
7792 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
7793 aux
->strtab_size
, tp
->start
, &procname
,
7796 fputs ("\n<", stdout
);
7800 fputs (procname
, stdout
);
7803 printf ("+%lx", (unsigned long) offset
);
7806 fputs (">: [", stdout
);
7807 print_vma (tp
->start
.offset
, PREFIX_HEX
);
7808 fputc ('-', stdout
);
7809 print_vma (tp
->end
.offset
, PREFIX_HEX
);
7812 #define PF(_m) if (tp->_m) printf (#_m " ");
7813 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
7816 PF(Millicode_save_sr0
);
7817 /* PV(Region_description); */
7823 PF(Separate_Package_Body
);
7824 PF(Frame_Extension_Millicode
);
7825 PF(Stack_Overflow_Check
);
7826 PF(Two_Instruction_SP_Increment
);
7830 PF(sched_entry_seq
);
7833 PF(Save_MRP_in_frame
);
7834 PF(extn_ptr_defined
);
7835 PF(Cleanup_defined
);
7836 PF(MPE_XL_interrupt_marker
);
7837 PF(HP_UX_interrupt_marker
);
7840 PV(Total_frame_size
);
7853 slurp_hppa_unwind_table (Filedata
* filedata
,
7854 struct hppa_unw_aux_info
* aux
,
7855 Elf_Internal_Shdr
* sec
)
7857 unsigned long size
, unw_ent_size
, nentries
, nrelas
, i
;
7858 Elf_Internal_Phdr
* seg
;
7859 struct hppa_unw_table_entry
* tep
;
7860 Elf_Internal_Shdr
* relsec
;
7861 Elf_Internal_Rela
* rela
;
7862 Elf_Internal_Rela
* rp
;
7863 unsigned char * table
;
7865 Elf_Internal_Sym
* sym
;
7866 const char * relname
;
7868 /* First, find the starting address of the segment that includes
7870 if (filedata
->file_header
.e_phnum
)
7872 if (! get_program_headers (filedata
))
7875 for (seg
= filedata
->program_headers
;
7876 seg
< filedata
->program_headers
+ filedata
->file_header
.e_phnum
;
7879 if (seg
->p_type
!= PT_LOAD
)
7882 if (sec
->sh_addr
>= seg
->p_vaddr
7883 && (sec
->sh_addr
+ sec
->sh_size
<= seg
->p_vaddr
+ seg
->p_memsz
))
7885 aux
->seg_base
= seg
->p_vaddr
;
7891 /* Second, build the unwind table from the contents of the unwind
7893 size
= sec
->sh_size
;
7894 table
= (unsigned char *) get_data (NULL
, filedata
, sec
->sh_offset
, 1, size
,
7900 nentries
= size
/ unw_ent_size
;
7901 size
= unw_ent_size
* nentries
;
7903 tep
= aux
->table
= (struct hppa_unw_table_entry
*)
7904 xcmalloc (nentries
, sizeof (aux
->table
[0]));
7906 for (tp
= table
; tp
< table
+ size
; tp
+= unw_ent_size
, ++tep
)
7908 unsigned int tmp1
, tmp2
;
7910 tep
->start
.section
= SHN_UNDEF
;
7911 tep
->end
.section
= SHN_UNDEF
;
7913 tep
->start
.offset
= byte_get ((unsigned char *) tp
+ 0, 4);
7914 tep
->end
.offset
= byte_get ((unsigned char *) tp
+ 4, 4);
7915 tmp1
= byte_get ((unsigned char *) tp
+ 8, 4);
7916 tmp2
= byte_get ((unsigned char *) tp
+ 12, 4);
7918 tep
->start
.offset
+= aux
->seg_base
;
7919 tep
->end
.offset
+= aux
->seg_base
;
7921 tep
->Cannot_unwind
= (tmp1
>> 31) & 0x1;
7922 tep
->Millicode
= (tmp1
>> 30) & 0x1;
7923 tep
->Millicode_save_sr0
= (tmp1
>> 29) & 0x1;
7924 tep
->Region_description
= (tmp1
>> 27) & 0x3;
7925 tep
->reserved1
= (tmp1
>> 26) & 0x1;
7926 tep
->Entry_SR
= (tmp1
>> 25) & 0x1;
7927 tep
->Entry_FR
= (tmp1
>> 21) & 0xf;
7928 tep
->Entry_GR
= (tmp1
>> 16) & 0x1f;
7929 tep
->Args_stored
= (tmp1
>> 15) & 0x1;
7930 tep
->Variable_Frame
= (tmp1
>> 14) & 0x1;
7931 tep
->Separate_Package_Body
= (tmp1
>> 13) & 0x1;
7932 tep
->Frame_Extension_Millicode
= (tmp1
>> 12) & 0x1;
7933 tep
->Stack_Overflow_Check
= (tmp1
>> 11) & 0x1;
7934 tep
->Two_Instruction_SP_Increment
= (tmp1
>> 10) & 0x1;
7935 tep
->Ada_Region
= (tmp1
>> 9) & 0x1;
7936 tep
->cxx_info
= (tmp1
>> 8) & 0x1;
7937 tep
->cxx_try_catch
= (tmp1
>> 7) & 0x1;
7938 tep
->sched_entry_seq
= (tmp1
>> 6) & 0x1;
7939 tep
->reserved2
= (tmp1
>> 5) & 0x1;
7940 tep
->Save_SP
= (tmp1
>> 4) & 0x1;
7941 tep
->Save_RP
= (tmp1
>> 3) & 0x1;
7942 tep
->Save_MRP_in_frame
= (tmp1
>> 2) & 0x1;
7943 tep
->extn_ptr_defined
= (tmp1
>> 1) & 0x1;
7944 tep
->Cleanup_defined
= tmp1
& 0x1;
7946 tep
->MPE_XL_interrupt_marker
= (tmp2
>> 31) & 0x1;
7947 tep
->HP_UX_interrupt_marker
= (tmp2
>> 30) & 0x1;
7948 tep
->Large_frame
= (tmp2
>> 29) & 0x1;
7949 tep
->Pseudo_SP_Set
= (tmp2
>> 28) & 0x1;
7950 tep
->reserved4
= (tmp2
>> 27) & 0x1;
7951 tep
->Total_frame_size
= tmp2
& 0x7ffffff;
7955 /* Third, apply any relocations to the unwind table. */
7956 for (relsec
= filedata
->section_headers
;
7957 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
7960 if (relsec
->sh_type
!= SHT_RELA
7961 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
7962 || filedata
->section_headers
+ relsec
->sh_info
!= sec
)
7965 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
, relsec
->sh_size
,
7969 for (rp
= rela
; rp
< rela
+ nrelas
; ++rp
)
7971 relname
= elf_hppa_reloc_type (get_reloc_type (filedata
, rp
->r_info
));
7972 sym
= aux
->symtab
+ get_reloc_symindex (rp
->r_info
);
7974 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
7975 if (! const_strneq (relname
, "R_PARISC_SEGREL"))
7977 warn (_("Skipping unexpected relocation type %s\n"), relname
);
7981 i
= rp
->r_offset
/ unw_ent_size
;
7983 switch ((rp
->r_offset
% unw_ent_size
) / eh_addr_size
)
7986 aux
->table
[i
].start
.section
= sym
->st_shndx
;
7987 aux
->table
[i
].start
.offset
= sym
->st_value
+ rp
->r_addend
;
7990 aux
->table
[i
].end
.section
= sym
->st_shndx
;
7991 aux
->table
[i
].end
.offset
= sym
->st_value
+ rp
->r_addend
;
8001 aux
->table_len
= nentries
;
8007 hppa_process_unwind (Filedata
* filedata
)
8009 struct hppa_unw_aux_info aux
;
8010 Elf_Internal_Shdr
* unwsec
= NULL
;
8011 Elf_Internal_Shdr
* strsec
;
8012 Elf_Internal_Shdr
* sec
;
8014 bfd_boolean res
= TRUE
;
8016 if (filedata
->string_table
== NULL
)
8019 memset (& aux
, 0, sizeof (aux
));
8021 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8023 if (sec
->sh_type
== SHT_SYMTAB
8024 && sec
->sh_link
< filedata
->file_header
.e_shnum
)
8026 aux
.symtab
= GET_ELF_SYMBOLS (filedata
, sec
, & aux
.nsyms
);
8028 strsec
= filedata
->section_headers
+ sec
->sh_link
;
8029 if (aux
.strtab
!= NULL
)
8031 error (_("Multiple auxillary string tables encountered\n"));
8035 aux
.strtab
= (char *) get_data (NULL
, filedata
, strsec
->sh_offset
,
8038 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
8040 else if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8045 printf (_("\nThere are no unwind sections in this file.\n"));
8047 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
8049 if (streq (SECTION_NAME (sec
), ".PARISC.unwind"))
8051 unsigned long num_unwind
= sec
->sh_size
/ (2 * eh_addr_size
+ 8);
8053 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
8054 "contains %lu entry:\n",
8055 "\nUnwind section '%s' at offset 0x%lx "
8056 "contains %lu entries:\n",
8058 printable_section_name (filedata
, sec
),
8059 (unsigned long) sec
->sh_offset
,
8062 if (! slurp_hppa_unwind_table (filedata
, &aux
, sec
))
8065 if (aux
.table_len
> 0)
8067 if (! dump_hppa_unwind (filedata
, &aux
))
8072 free ((char *) aux
.table
);
8080 free ((char *) aux
.strtab
);
8087 unsigned char * data
; /* The unwind data. */
8088 Elf_Internal_Shdr
* sec
; /* The cached unwind section header. */
8089 Elf_Internal_Rela
* rela
; /* The cached relocations for this section. */
8090 unsigned long nrelas
; /* The number of relocations. */
8091 unsigned int rel_type
; /* REL or RELA ? */
8092 Elf_Internal_Rela
* next_rela
; /* Cyclic pointer to the next reloc to process. */
8095 struct arm_unw_aux_info
8097 Filedata
* filedata
; /* The file containing the unwind sections. */
8098 Elf_Internal_Sym
* symtab
; /* The file's symbol table. */
8099 unsigned long nsyms
; /* Number of symbols. */
8100 Elf_Internal_Sym
* funtab
; /* Sorted table of STT_FUNC symbols. */
8101 unsigned long nfuns
; /* Number of these symbols. */
8102 char * strtab
; /* The file's string table. */
8103 unsigned long strtab_size
; /* Size of string table. */
8107 arm_print_vma_and_name (Filedata
* filedata
,
8108 struct arm_unw_aux_info
* aux
,
8110 struct absaddr addr
)
8112 const char *procname
;
8115 if (addr
.section
== SHN_UNDEF
)
8118 find_symbol_for_address (filedata
, aux
->funtab
, aux
->nfuns
, aux
->strtab
,
8119 aux
->strtab_size
, addr
, &procname
,
8122 print_vma (fn
, PREFIX_HEX
);
8126 fputs (" <", stdout
);
8127 fputs (procname
, stdout
);
8130 printf ("+0x%lx", (unsigned long) sym_offset
);
8131 fputc ('>', stdout
);
8138 arm_free_section (struct arm_section
*arm_sec
)
8140 if (arm_sec
->data
!= NULL
)
8141 free (arm_sec
->data
);
8143 if (arm_sec
->rela
!= NULL
)
8144 free (arm_sec
->rela
);
8147 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
8148 cached section and install SEC instead.
8149 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
8150 and return its valued in * WORDP, relocating if necessary.
8151 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
8152 relocation's offset in ADDR.
8153 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
8154 into the string table of the symbol associated with the reloc. If no
8155 reloc was applied store -1 there.
8156 5) Return TRUE upon success, FALSE otherwise. */
8159 get_unwind_section_word (Filedata
* filedata
,
8160 struct arm_unw_aux_info
* aux
,
8161 struct arm_section
* arm_sec
,
8162 Elf_Internal_Shdr
* sec
,
8163 bfd_vma word_offset
,
8164 unsigned int * wordp
,
8165 struct absaddr
* addr
,
8168 Elf_Internal_Rela
*rp
;
8169 Elf_Internal_Sym
*sym
;
8170 const char * relname
;
8172 bfd_boolean wrapped
;
8174 if (sec
== NULL
|| arm_sec
== NULL
)
8177 addr
->section
= SHN_UNDEF
;
8180 if (sym_name
!= NULL
)
8181 *sym_name
= (bfd_vma
) -1;
8183 /* If necessary, update the section cache. */
8184 if (sec
!= arm_sec
->sec
)
8186 Elf_Internal_Shdr
*relsec
;
8188 arm_free_section (arm_sec
);
8191 arm_sec
->data
= get_data (NULL
, aux
->filedata
, sec
->sh_offset
, 1,
8192 sec
->sh_size
, _("unwind data"));
8193 arm_sec
->rela
= NULL
;
8194 arm_sec
->nrelas
= 0;
8196 for (relsec
= filedata
->section_headers
;
8197 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
8200 if (relsec
->sh_info
>= filedata
->file_header
.e_shnum
8201 || filedata
->section_headers
+ relsec
->sh_info
!= sec
8202 /* PR 15745: Check the section type as well. */
8203 || (relsec
->sh_type
!= SHT_REL
8204 && relsec
->sh_type
!= SHT_RELA
))
8207 arm_sec
->rel_type
= relsec
->sh_type
;
8208 if (relsec
->sh_type
== SHT_REL
)
8210 if (!slurp_rel_relocs (aux
->filedata
, relsec
->sh_offset
,
8212 & arm_sec
->rela
, & arm_sec
->nrelas
))
8215 else /* relsec->sh_type == SHT_RELA */
8217 if (!slurp_rela_relocs (aux
->filedata
, relsec
->sh_offset
,
8219 & arm_sec
->rela
, & arm_sec
->nrelas
))
8225 arm_sec
->next_rela
= arm_sec
->rela
;
8228 /* If there is no unwind data we can do nothing. */
8229 if (arm_sec
->data
== NULL
)
8232 /* If the offset is invalid then fail. */
8233 if (/* PR 21343 *//* PR 18879 */
8235 || word_offset
> (sec
->sh_size
- 4)
8236 || ((bfd_signed_vma
) word_offset
) < 0)
8239 /* Get the word at the required offset. */
8240 word
= byte_get (arm_sec
->data
+ word_offset
, 4);
8242 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
8243 if (arm_sec
->rela
== NULL
)
8249 /* Look through the relocs to find the one that applies to the provided offset. */
8251 for (rp
= arm_sec
->next_rela
; rp
!= arm_sec
->rela
+ arm_sec
->nrelas
; rp
++)
8253 bfd_vma prelval
, offset
;
8255 if (rp
->r_offset
> word_offset
&& !wrapped
)
8260 if (rp
->r_offset
> word_offset
)
8263 if (rp
->r_offset
& 3)
8265 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8266 (unsigned long) rp
->r_offset
);
8270 if (rp
->r_offset
< word_offset
)
8273 /* PR 17531: file: 027-161405-0.004 */
8274 if (aux
->symtab
== NULL
)
8277 if (arm_sec
->rel_type
== SHT_REL
)
8279 offset
= word
& 0x7fffffff;
8280 if (offset
& 0x40000000)
8281 offset
|= ~ (bfd_vma
) 0x7fffffff;
8283 else if (arm_sec
->rel_type
== SHT_RELA
)
8284 offset
= rp
->r_addend
;
8287 error (_("Unknown section relocation type %d encountered\n"),
8292 /* PR 17531 file: 027-1241568-0.004. */
8293 if (ELF32_R_SYM (rp
->r_info
) >= aux
->nsyms
)
8295 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8296 (unsigned long) ELF32_R_SYM (rp
->r_info
), aux
->nsyms
);
8300 sym
= aux
->symtab
+ ELF32_R_SYM (rp
->r_info
);
8301 offset
+= sym
->st_value
;
8302 prelval
= offset
- (arm_sec
->sec
->sh_addr
+ rp
->r_offset
);
8304 /* Check that we are processing the expected reloc type. */
8305 if (filedata
->file_header
.e_machine
== EM_ARM
)
8307 relname
= elf_arm_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8308 if (relname
== NULL
)
8310 warn (_("Skipping unknown ARM relocation type: %d\n"),
8311 (int) ELF32_R_TYPE (rp
->r_info
));
8315 if (streq (relname
, "R_ARM_NONE"))
8318 if (! streq (relname
, "R_ARM_PREL31"))
8320 warn (_("Skipping unexpected ARM relocation type %s\n"), relname
);
8324 else if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
8326 relname
= elf_tic6x_reloc_type (ELF32_R_TYPE (rp
->r_info
));
8327 if (relname
== NULL
)
8329 warn (_("Skipping unknown C6000 relocation type: %d\n"),
8330 (int) ELF32_R_TYPE (rp
->r_info
));
8334 if (streq (relname
, "R_C6000_NONE"))
8337 if (! streq (relname
, "R_C6000_PREL31"))
8339 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname
);
8347 /* This function currently only supports ARM and TI unwinders. */
8348 warn (_("Only TI and ARM unwinders are currently supported\n"));
8352 word
= (word
& ~ (bfd_vma
) 0x7fffffff) | (prelval
& 0x7fffffff);
8353 addr
->section
= sym
->st_shndx
;
8354 addr
->offset
= offset
;
8357 * sym_name
= sym
->st_name
;
8362 arm_sec
->next_rela
= rp
;
8367 static const char *tic6x_unwind_regnames
[16] =
8369 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8370 "A14", "A13", "A12", "A11", "A10",
8371 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8375 decode_tic6x_unwind_regmask (unsigned int mask
)
8379 for (i
= 12; mask
; mask
>>= 1, i
--)
8383 fputs (tic6x_unwind_regnames
[i
], stdout
);
8385 fputs (", ", stdout
);
8391 if (remaining == 0 && more_words) \
8394 if (! get_unwind_section_word (filedata, aux, data_arm_sec, data_sec, \
8395 data_offset, & word, & addr, NULL)) \
8401 #define GET_OP(OP) \
8406 (OP) = word >> 24; \
8411 printf (_("[Truncated opcode]\n")); \
8414 printf ("0x%02x ", OP)
8417 decode_arm_unwind_bytecode (Filedata
* filedata
,
8418 struct arm_unw_aux_info
* aux
,
8420 unsigned int remaining
,
8421 unsigned int more_words
,
8422 bfd_vma data_offset
,
8423 Elf_Internal_Shdr
* data_sec
,
8424 struct arm_section
* data_arm_sec
)
8426 struct absaddr addr
;
8427 bfd_boolean res
= TRUE
;
8429 /* Decode the unwinding instructions. */
8432 unsigned int op
, op2
;
8441 printf (" 0x%02x ", op
);
8443 if ((op
& 0xc0) == 0x00)
8445 int offset
= ((op
& 0x3f) << 2) + 4;
8447 printf (" vsp = vsp + %d", offset
);
8449 else if ((op
& 0xc0) == 0x40)
8451 int offset
= ((op
& 0x3f) << 2) + 4;
8453 printf (" vsp = vsp - %d", offset
);
8455 else if ((op
& 0xf0) == 0x80)
8458 if (op
== 0x80 && op2
== 0)
8459 printf (_("Refuse to unwind"));
8462 unsigned int mask
= ((op
& 0x0f) << 8) | op2
;
8463 bfd_boolean first
= TRUE
;
8467 for (i
= 0; i
< 12; i
++)
8468 if (mask
& (1 << i
))
8474 printf ("r%d", 4 + i
);
8479 else if ((op
& 0xf0) == 0x90)
8481 if (op
== 0x9d || op
== 0x9f)
8482 printf (_(" [Reserved]"));
8484 printf (" vsp = r%d", op
& 0x0f);
8486 else if ((op
& 0xf0) == 0xa0)
8488 int end
= 4 + (op
& 0x07);
8489 bfd_boolean first
= TRUE
;
8493 for (i
= 4; i
<= end
; i
++)
8509 else if (op
== 0xb0)
8510 printf (_(" finish"));
8511 else if (op
== 0xb1)
8514 if (op2
== 0 || (op2
& 0xf0) != 0)
8515 printf (_("[Spare]"));
8518 unsigned int mask
= op2
& 0x0f;
8519 bfd_boolean first
= TRUE
;
8523 for (i
= 0; i
< 12; i
++)
8524 if (mask
& (1 << i
))
8535 else if (op
== 0xb2)
8537 unsigned char buf
[9];
8538 unsigned int i
, len
;
8539 unsigned long offset
;
8541 for (i
= 0; i
< sizeof (buf
); i
++)
8544 if ((buf
[i
] & 0x80) == 0)
8547 if (i
== sizeof (buf
))
8549 error (_("corrupt change to vsp"));
8554 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8555 assert (len
== i
+ 1);
8556 offset
= offset
* 4 + 0x204;
8557 printf ("vsp = vsp + %ld", offset
);
8560 else if (op
== 0xb3 || op
== 0xc8 || op
== 0xc9)
8562 unsigned int first
, last
;
8569 printf ("pop {D%d", first
);
8571 printf ("-D%d", first
+ last
);
8574 else if ((op
& 0xf8) == 0xb8 || (op
& 0xf8) == 0xd0)
8576 unsigned int count
= op
& 0x07;
8580 printf ("-D%d", 8 + count
);
8583 else if (op
>= 0xc0 && op
<= 0xc5)
8585 unsigned int count
= op
& 0x07;
8587 printf (" pop {wR10");
8589 printf ("-wR%d", 10 + count
);
8592 else if (op
== 0xc6)
8594 unsigned int first
, last
;
8599 printf ("pop {wR%d", first
);
8601 printf ("-wR%d", first
+ last
);
8604 else if (op
== 0xc7)
8607 if (op2
== 0 || (op2
& 0xf0) != 0)
8608 printf (_("[Spare]"));
8611 unsigned int mask
= op2
& 0x0f;
8612 bfd_boolean first
= TRUE
;
8616 for (i
= 0; i
< 4; i
++)
8617 if (mask
& (1 << i
))
8623 printf ("wCGR%d", i
);
8630 printf (_(" [unsupported opcode]"));
8641 decode_tic6x_unwind_bytecode (Filedata
* filedata
,
8642 struct arm_unw_aux_info
* aux
,
8644 unsigned int remaining
,
8645 unsigned int more_words
,
8646 bfd_vma data_offset
,
8647 Elf_Internal_Shdr
* data_sec
,
8648 struct arm_section
* data_arm_sec
)
8650 struct absaddr addr
;
8652 /* Decode the unwinding instructions. */
8655 unsigned int op
, op2
;
8664 printf (" 0x%02x ", op
);
8666 if ((op
& 0xc0) == 0x00)
8668 int offset
= ((op
& 0x3f) << 3) + 8;
8669 printf (" sp = sp + %d", offset
);
8671 else if ((op
& 0xc0) == 0x80)
8674 if (op
== 0x80 && op2
== 0)
8675 printf (_("Refuse to unwind"));
8678 unsigned int mask
= ((op
& 0x1f) << 8) | op2
;
8680 printf ("pop compact {");
8684 decode_tic6x_unwind_regmask (mask
);
8688 else if ((op
& 0xf0) == 0xc0)
8696 unsigned int offset
;
8700 /* Scan entire instruction first so that GET_OP output is not
8701 interleaved with disassembly. */
8703 for (i
= 0; nregs
< (op
& 0xf); i
++)
8709 regpos
[nregs
].offset
= i
* 2;
8710 regpos
[nregs
].reg
= reg
;
8717 regpos
[nregs
].offset
= i
* 2 + 1;
8718 regpos
[nregs
].reg
= reg
;
8723 printf (_("pop frame {"));
8725 for (i
= i
* 2; i
> 0; i
--)
8727 if (regpos
[reg
].offset
== i
- 1)
8729 name
= tic6x_unwind_regnames
[regpos
[reg
].reg
];
8736 fputs (name
, stdout
);
8743 else if (op
== 0xd0)
8744 printf (" MOV FP, SP");
8745 else if (op
== 0xd1)
8746 printf (" __c6xabi_pop_rts");
8747 else if (op
== 0xd2)
8749 unsigned char buf
[9];
8750 unsigned int i
, len
;
8751 unsigned long offset
;
8753 for (i
= 0; i
< sizeof (buf
); i
++)
8756 if ((buf
[i
] & 0x80) == 0)
8759 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
8760 if (i
== sizeof (buf
))
8762 warn (_("Corrupt stack pointer adjustment detected\n"));
8766 offset
= read_uleb128 (buf
, &len
, buf
+ i
+ 1);
8767 assert (len
== i
+ 1);
8768 offset
= offset
* 8 + 0x408;
8769 printf (_("sp = sp + %ld"), offset
);
8771 else if ((op
& 0xf0) == 0xe0)
8773 if ((op
& 0x0f) == 7)
8776 printf (" MV %s, B3", tic6x_unwind_regnames
[op
& 0x0f]);
8780 printf (_(" [unsupported opcode]"));
8789 arm_expand_prel31 (Filedata
* filedata
, bfd_vma word
, bfd_vma where
)
8793 offset
= word
& 0x7fffffff;
8794 if (offset
& 0x40000000)
8795 offset
|= ~ (bfd_vma
) 0x7fffffff;
8797 if (filedata
->file_header
.e_machine
== EM_TI_C6000
)
8800 return offset
+ where
;
8804 decode_arm_unwind (Filedata
* filedata
,
8805 struct arm_unw_aux_info
* aux
,
8807 unsigned int remaining
,
8808 bfd_vma data_offset
,
8809 Elf_Internal_Shdr
* data_sec
,
8810 struct arm_section
* data_arm_sec
)
8813 unsigned int more_words
= 0;
8814 struct absaddr addr
;
8815 bfd_vma sym_name
= (bfd_vma
) -1;
8816 bfd_boolean res
= TRUE
;
8820 /* Fetch the first word.
8821 Note - when decoding an object file the address extracted
8822 here will always be 0. So we also pass in the sym_name
8823 parameter so that we can find the symbol associated with
8824 the personality routine. */
8825 if (! get_unwind_section_word (filedata
, aux
, data_arm_sec
, data_sec
, data_offset
,
8826 & word
, & addr
, & sym_name
))
8832 if ((word
& 0x80000000) == 0)
8834 /* Expand prel31 for personality routine. */
8836 const char *procname
;
8838 fn
= arm_expand_prel31 (filedata
, word
, data_sec
->sh_addr
+ data_offset
);
8839 printf (_(" Personality routine: "));
8841 && addr
.section
== SHN_UNDEF
&& addr
.offset
== 0
8842 && sym_name
!= (bfd_vma
) -1 && sym_name
< aux
->strtab_size
)
8844 procname
= aux
->strtab
+ sym_name
;
8845 print_vma (fn
, PREFIX_HEX
);
8848 fputs (" <", stdout
);
8849 fputs (procname
, stdout
);
8850 fputc ('>', stdout
);
8854 procname
= arm_print_vma_and_name (filedata
, aux
, fn
, addr
);
8855 fputc ('\n', stdout
);
8857 /* The GCC personality routines use the standard compact
8858 encoding, starting with one byte giving the number of
8860 if (procname
!= NULL
8861 && (const_strneq (procname
, "__gcc_personality_v0")
8862 || const_strneq (procname
, "__gxx_personality_v0")
8863 || const_strneq (procname
, "__gcj_personality_v0")
8864 || const_strneq (procname
, "__gnu_objc_personality_v0")))
8871 printf (_(" [Truncated data]\n"));
8874 more_words
= word
>> 24;
8884 /* ARM EHABI Section 6.3:
8886 An exception-handling table entry for the compact model looks like:
8890 1 0 index Data for personalityRoutine[index] */
8892 if (filedata
->file_header
.e_machine
== EM_ARM
8893 && (word
& 0x70000000))
8895 warn (_("Corrupt ARM compact model table entry: %x \n"), word
);
8899 per_index
= (word
>> 24) & 0x7f;
8900 printf (_(" Compact model index: %d\n"), per_index
);
8907 else if (per_index
< 3)
8909 more_words
= (word
>> 16) & 0xff;
8915 switch (filedata
->file_header
.e_machine
)
8920 if (! decode_arm_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
8921 data_offset
, data_sec
, data_arm_sec
))
8926 warn (_("Unknown ARM compact model index encountered\n"));
8927 printf (_(" [reserved]\n"));
8935 if (! decode_tic6x_unwind_bytecode (filedata
, aux
, word
, remaining
, more_words
,
8936 data_offset
, data_sec
, data_arm_sec
))
8939 else if (per_index
< 5)
8941 if (((word
>> 17) & 0x7f) == 0x7f)
8942 printf (_(" Restore stack from frame pointer\n"));
8944 printf (_(" Stack increment %d\n"), (word
>> 14) & 0x1fc);
8945 printf (_(" Registers restored: "));
8947 printf (" (compact) ");
8948 decode_tic6x_unwind_regmask ((word
>> 4) & 0x1fff);
8950 printf (_(" Return register: %s\n"),
8951 tic6x_unwind_regnames
[word
& 0xf]);
8954 printf (_(" [reserved (%d)]\n"), per_index
);
8958 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
8959 filedata
->file_header
.e_machine
);
8963 /* Decode the descriptors. Not implemented. */
8969 dump_arm_unwind (Filedata
* filedata
,
8970 struct arm_unw_aux_info
* aux
,
8971 Elf_Internal_Shdr
* exidx_sec
)
8973 struct arm_section exidx_arm_sec
, extab_arm_sec
;
8974 unsigned int i
, exidx_len
;
8975 unsigned long j
, nfuns
;
8976 bfd_boolean res
= TRUE
;
8978 memset (&exidx_arm_sec
, 0, sizeof (exidx_arm_sec
));
8979 memset (&extab_arm_sec
, 0, sizeof (extab_arm_sec
));
8980 exidx_len
= exidx_sec
->sh_size
/ 8;
8982 aux
->funtab
= xmalloc (aux
->nsyms
* sizeof (Elf_Internal_Sym
));
8983 for (nfuns
= 0, j
= 0; j
< aux
->nsyms
; j
++)
8984 if (aux
->symtab
[j
].st_value
&& ELF_ST_TYPE (aux
->symtab
[j
].st_info
) == STT_FUNC
)
8985 aux
->funtab
[nfuns
++] = aux
->symtab
[j
];
8987 qsort (aux
->funtab
, aux
->nfuns
, sizeof (Elf_Internal_Sym
), symcmp
);
8989 for (i
= 0; i
< exidx_len
; i
++)
8991 unsigned int exidx_fn
, exidx_entry
;
8992 struct absaddr fn_addr
, entry_addr
;
8995 fputc ('\n', stdout
);
8997 if (! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
8998 8 * i
, & exidx_fn
, & fn_addr
, NULL
)
8999 || ! get_unwind_section_word (filedata
, aux
, & exidx_arm_sec
, exidx_sec
,
9000 8 * i
+ 4, & exidx_entry
, & entry_addr
, NULL
))
9003 arm_free_section (& exidx_arm_sec
);
9004 arm_free_section (& extab_arm_sec
);
9008 /* ARM EHABI, Section 5:
9009 An index table entry consists of 2 words.
9010 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
9011 if (exidx_fn
& 0x80000000)
9013 warn (_("corrupt index table entry: %x\n"), exidx_fn
);
9017 fn
= arm_expand_prel31 (filedata
, exidx_fn
, exidx_sec
->sh_addr
+ 8 * i
);
9019 arm_print_vma_and_name (filedata
, aux
, fn
, fn_addr
);
9020 fputs (": ", stdout
);
9022 if (exidx_entry
== 1)
9024 print_vma (exidx_entry
, PREFIX_HEX
);
9025 fputs (" [cantunwind]\n", stdout
);
9027 else if (exidx_entry
& 0x80000000)
9029 print_vma (exidx_entry
, PREFIX_HEX
);
9030 fputc ('\n', stdout
);
9031 decode_arm_unwind (filedata
, aux
, exidx_entry
, 4, 0, NULL
, NULL
);
9035 bfd_vma table
, table_offset
= 0;
9036 Elf_Internal_Shdr
*table_sec
;
9038 fputs ("@", stdout
);
9039 table
= arm_expand_prel31 (filedata
, exidx_entry
, exidx_sec
->sh_addr
+ 8 * i
+ 4);
9040 print_vma (table
, PREFIX_HEX
);
9043 /* Locate the matching .ARM.extab. */
9044 if (entry_addr
.section
!= SHN_UNDEF
9045 && entry_addr
.section
< filedata
->file_header
.e_shnum
)
9047 table_sec
= filedata
->section_headers
+ entry_addr
.section
;
9048 table_offset
= entry_addr
.offset
;
9050 if (table_offset
> table_sec
->sh_size
9051 || ((bfd_signed_vma
) table_offset
) < 0)
9053 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
9054 (unsigned long) table_offset
,
9055 printable_section_name (filedata
, table_sec
));
9062 table_sec
= find_section_by_address (filedata
, table
);
9063 if (table_sec
!= NULL
)
9064 table_offset
= table
- table_sec
->sh_addr
;
9067 if (table_sec
== NULL
)
9069 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
9070 (unsigned long) table
);
9075 if (! decode_arm_unwind (filedata
, aux
, 0, 0, table_offset
, table_sec
,
9084 arm_free_section (&exidx_arm_sec
);
9085 arm_free_section (&extab_arm_sec
);
9090 /* Used for both ARM and C6X unwinding tables. */
9093 arm_process_unwind (Filedata
* filedata
)
9095 struct arm_unw_aux_info aux
;
9096 Elf_Internal_Shdr
*unwsec
= NULL
;
9097 Elf_Internal_Shdr
*strsec
;
9098 Elf_Internal_Shdr
*sec
;
9100 unsigned int sec_type
;
9101 bfd_boolean res
= TRUE
;
9103 switch (filedata
->file_header
.e_machine
)
9106 sec_type
= SHT_ARM_EXIDX
;
9110 sec_type
= SHT_C6000_UNWIND
;
9114 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
9115 filedata
->file_header
.e_machine
);
9119 if (filedata
->string_table
== NULL
)
9122 memset (& aux
, 0, sizeof (aux
));
9123 aux
.filedata
= filedata
;
9125 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9127 if (sec
->sh_type
== SHT_SYMTAB
&& sec
->sh_link
< filedata
->file_header
.e_shnum
)
9129 aux
.symtab
= GET_ELF_SYMBOLS (filedata
, sec
, & aux
.nsyms
);
9131 strsec
= filedata
->section_headers
+ sec
->sh_link
;
9133 /* PR binutils/17531 file: 011-12666-0.004. */
9134 if (aux
.strtab
!= NULL
)
9136 error (_("Multiple string tables found in file.\n"));
9140 aux
.strtab
= get_data (NULL
, filedata
, strsec
->sh_offset
,
9141 1, strsec
->sh_size
, _("string table"));
9142 aux
.strtab_size
= aux
.strtab
!= NULL
? strsec
->sh_size
: 0;
9144 else if (sec
->sh_type
== sec_type
)
9149 printf (_("\nThere are no unwind sections in this file.\n"));
9151 for (i
= 0, sec
= filedata
->section_headers
; i
< filedata
->file_header
.e_shnum
; ++i
, ++sec
)
9153 if (sec
->sh_type
== sec_type
)
9155 unsigned long num_unwind
= sec
->sh_size
/ (2 * eh_addr_size
);
9156 printf (ngettext ("\nUnwind section '%s' at offset 0x%lx "
9157 "contains %lu entry:\n",
9158 "\nUnwind section '%s' at offset 0x%lx "
9159 "contains %lu entries:\n",
9161 printable_section_name (filedata
, sec
),
9162 (unsigned long) sec
->sh_offset
,
9165 if (! dump_arm_unwind (filedata
, &aux
, sec
))
9173 free ((char *) aux
.strtab
);
9179 process_unwind (Filedata
* filedata
)
9181 struct unwind_handler
9183 unsigned int machtype
;
9184 bfd_boolean (* handler
)(Filedata
*);
9187 { EM_ARM
, arm_process_unwind
},
9188 { EM_IA_64
, ia64_process_unwind
},
9189 { EM_PARISC
, hppa_process_unwind
},
9190 { EM_TI_C6000
, arm_process_unwind
},
9198 for (i
= 0; handlers
[i
].handler
!= NULL
; i
++)
9199 if (filedata
->file_header
.e_machine
== handlers
[i
].machtype
)
9200 return handlers
[i
].handler (filedata
);
9202 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
9203 get_machine_name (filedata
->file_header
.e_machine
));
9208 dynamic_section_mips_val (Elf_Internal_Dyn
* entry
)
9210 switch (entry
->d_tag
)
9213 if (entry
->d_un
.d_val
== 0)
9217 static const char * opts
[] =
9219 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
9220 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
9221 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
9222 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
9226 bfd_boolean first
= TRUE
;
9228 for (cnt
= 0; cnt
< ARRAY_SIZE (opts
); ++cnt
)
9229 if (entry
->d_un
.d_val
& (1 << cnt
))
9231 printf ("%s%s", first
? "" : " ", opts
[cnt
]);
9237 case DT_MIPS_IVERSION
:
9238 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9239 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
9243 sprintf_vma (buf
, entry
->d_un
.d_ptr
);
9244 /* Note: coded this way so that there is a single string for translation. */
9245 printf (_("<corrupt: %s>"), buf
);
9249 case DT_MIPS_TIME_STAMP
:
9253 time_t atime
= entry
->d_un
.d_val
;
9255 tmp
= gmtime (&atime
);
9256 /* PR 17531: file: 6accc532. */
9258 snprintf (timebuf
, sizeof (timebuf
), _("<corrupt>"));
9260 snprintf (timebuf
, sizeof (timebuf
), "%04u-%02u-%02uT%02u:%02u:%02u",
9261 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
9262 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
9263 printf (_("Time Stamp: %s"), timebuf
);
9267 case DT_MIPS_RLD_VERSION
:
9268 case DT_MIPS_LOCAL_GOTNO
:
9269 case DT_MIPS_CONFLICTNO
:
9270 case DT_MIPS_LIBLISTNO
:
9271 case DT_MIPS_SYMTABNO
:
9272 case DT_MIPS_UNREFEXTNO
:
9273 case DT_MIPS_HIPAGENO
:
9274 case DT_MIPS_DELTA_CLASS_NO
:
9275 case DT_MIPS_DELTA_INSTANCE_NO
:
9276 case DT_MIPS_DELTA_RELOC_NO
:
9277 case DT_MIPS_DELTA_SYM_NO
:
9278 case DT_MIPS_DELTA_CLASSSYM_NO
:
9279 case DT_MIPS_COMPACT_SIZE
:
9280 print_vma (entry
->d_un
.d_val
, DEC
);
9284 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9290 dynamic_section_parisc_val (Elf_Internal_Dyn
* entry
)
9292 switch (entry
->d_tag
)
9294 case DT_HP_DLD_FLAGS
:
9303 { DT_HP_DEBUG_PRIVATE
, "HP_DEBUG_PRIVATE" },
9304 { DT_HP_DEBUG_CALLBACK
, "HP_DEBUG_CALLBACK" },
9305 { DT_HP_DEBUG_CALLBACK_BOR
, "HP_DEBUG_CALLBACK_BOR" },
9306 { DT_HP_NO_ENVVAR
, "HP_NO_ENVVAR" },
9307 { DT_HP_BIND_NOW
, "HP_BIND_NOW" },
9308 { DT_HP_BIND_NONFATAL
, "HP_BIND_NONFATAL" },
9309 { DT_HP_BIND_VERBOSE
, "HP_BIND_VERBOSE" },
9310 { DT_HP_BIND_RESTRICTED
, "HP_BIND_RESTRICTED" },
9311 { DT_HP_BIND_SYMBOLIC
, "HP_BIND_SYMBOLIC" },
9312 { DT_HP_RPATH_FIRST
, "HP_RPATH_FIRST" },
9313 { DT_HP_BIND_DEPTH_FIRST
, "HP_BIND_DEPTH_FIRST" },
9314 { DT_HP_GST
, "HP_GST" },
9315 { DT_HP_SHLIB_FIXED
, "HP_SHLIB_FIXED" },
9316 { DT_HP_MERGE_SHLIB_SEG
, "HP_MERGE_SHLIB_SEG" },
9317 { DT_HP_NODELETE
, "HP_NODELETE" },
9318 { DT_HP_GROUP
, "HP_GROUP" },
9319 { DT_HP_PROTECT_LINKAGE_TABLE
, "HP_PROTECT_LINKAGE_TABLE" }
9321 bfd_boolean first
= TRUE
;
9323 bfd_vma val
= entry
->d_un
.d_val
;
9325 for (cnt
= 0; cnt
< ARRAY_SIZE (flags
); ++cnt
)
9326 if (val
& flags
[cnt
].bit
)
9330 fputs (flags
[cnt
].str
, stdout
);
9332 val
^= flags
[cnt
].bit
;
9335 if (val
!= 0 || first
)
9339 print_vma (val
, HEX
);
9345 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9353 /* VMS vs Unix time offset and factor. */
9355 #define VMS_EPOCH_OFFSET 35067168000000000LL
9356 #define VMS_GRANULARITY_FACTOR 10000000
9358 /* Display a VMS time in a human readable format. */
9361 print_vms_time (bfd_int64_t vmstime
)
9366 unxtime
= (vmstime
- VMS_EPOCH_OFFSET
) / VMS_GRANULARITY_FACTOR
;
9367 tm
= gmtime (&unxtime
);
9368 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9369 tm
->tm_year
+ 1900, tm
->tm_mon
+ 1, tm
->tm_mday
,
9370 tm
->tm_hour
, tm
->tm_min
, tm
->tm_sec
);
9375 dynamic_section_ia64_val (Elf_Internal_Dyn
* entry
)
9377 switch (entry
->d_tag
)
9379 case DT_IA_64_PLT_RESERVE
:
9380 /* First 3 slots reserved. */
9381 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9383 print_vma (entry
->d_un
.d_ptr
+ (3 * 8), PREFIX_HEX
);
9386 case DT_IA_64_VMS_LINKTIME
:
9388 print_vms_time (entry
->d_un
.d_val
);
9392 case DT_IA_64_VMS_LNKFLAGS
:
9393 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9394 if (entry
->d_un
.d_val
& VMS_LF_CALL_DEBUG
)
9395 printf (" CALL_DEBUG");
9396 if (entry
->d_un
.d_val
& VMS_LF_NOP0BUFS
)
9397 printf (" NOP0BUFS");
9398 if (entry
->d_un
.d_val
& VMS_LF_P0IMAGE
)
9399 printf (" P0IMAGE");
9400 if (entry
->d_un
.d_val
& VMS_LF_MKTHREADS
)
9401 printf (" MKTHREADS");
9402 if (entry
->d_un
.d_val
& VMS_LF_UPCALLS
)
9403 printf (" UPCALLS");
9404 if (entry
->d_un
.d_val
& VMS_LF_IMGSTA
)
9406 if (entry
->d_un
.d_val
& VMS_LF_INITIALIZE
)
9407 printf (" INITIALIZE");
9408 if (entry
->d_un
.d_val
& VMS_LF_MAIN
)
9410 if (entry
->d_un
.d_val
& VMS_LF_EXE_INIT
)
9411 printf (" EXE_INIT");
9412 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_IMG
)
9413 printf (" TBK_IN_IMG");
9414 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_IMG
)
9415 printf (" DBG_IN_IMG");
9416 if (entry
->d_un
.d_val
& VMS_LF_TBK_IN_DSF
)
9417 printf (" TBK_IN_DSF");
9418 if (entry
->d_un
.d_val
& VMS_LF_DBG_IN_DSF
)
9419 printf (" DBG_IN_DSF");
9420 if (entry
->d_un
.d_val
& VMS_LF_SIGNATURES
)
9421 printf (" SIGNATURES");
9422 if (entry
->d_un
.d_val
& VMS_LF_REL_SEG_OFF
)
9423 printf (" REL_SEG_OFF");
9427 print_vma (entry
->d_un
.d_ptr
, PREFIX_HEX
);
9434 get_32bit_dynamic_section (Filedata
* filedata
)
9436 Elf32_External_Dyn
* edyn
;
9437 Elf32_External_Dyn
* ext
;
9438 Elf_Internal_Dyn
* entry
;
9440 edyn
= (Elf32_External_Dyn
*) get_data (NULL
, filedata
, dynamic_addr
, 1,
9441 dynamic_size
, _("dynamic section"));
9445 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9446 might not have the luxury of section headers. Look for the DT_NULL
9447 terminator to determine the number of entries. */
9448 for (ext
= edyn
, dynamic_nent
= 0;
9449 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9453 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9457 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9459 if (dynamic_section
== NULL
)
9461 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9462 (unsigned long) dynamic_nent
);
9467 for (ext
= edyn
, entry
= dynamic_section
;
9468 entry
< dynamic_section
+ dynamic_nent
;
9471 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9472 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9481 get_64bit_dynamic_section (Filedata
* filedata
)
9483 Elf64_External_Dyn
* edyn
;
9484 Elf64_External_Dyn
* ext
;
9485 Elf_Internal_Dyn
* entry
;
9487 /* Read in the data. */
9488 edyn
= (Elf64_External_Dyn
*) get_data (NULL
, filedata
, dynamic_addr
, 1,
9489 dynamic_size
, _("dynamic section"));
9493 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9494 might not have the luxury of section headers. Look for the DT_NULL
9495 terminator to determine the number of entries. */
9496 for (ext
= edyn
, dynamic_nent
= 0;
9497 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
9498 (char *) (ext
+ 1) <= (char *) edyn
+ dynamic_size
;
9502 if (BYTE_GET (ext
->d_tag
) == DT_NULL
)
9506 dynamic_section
= (Elf_Internal_Dyn
*) cmalloc (dynamic_nent
,
9508 if (dynamic_section
== NULL
)
9510 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9511 (unsigned long) dynamic_nent
);
9516 /* Convert from external to internal formats. */
9517 for (ext
= edyn
, entry
= dynamic_section
;
9518 entry
< dynamic_section
+ dynamic_nent
;
9521 entry
->d_tag
= BYTE_GET (ext
->d_tag
);
9522 entry
->d_un
.d_val
= BYTE_GET (ext
->d_un
.d_val
);
9531 print_dynamic_flags (bfd_vma flags
)
9533 bfd_boolean first
= TRUE
;
9539 flag
= flags
& - flags
;
9549 case DF_ORIGIN
: fputs ("ORIGIN", stdout
); break;
9550 case DF_SYMBOLIC
: fputs ("SYMBOLIC", stdout
); break;
9551 case DF_TEXTREL
: fputs ("TEXTREL", stdout
); break;
9552 case DF_BIND_NOW
: fputs ("BIND_NOW", stdout
); break;
9553 case DF_STATIC_TLS
: fputs ("STATIC_TLS", stdout
); break;
9554 default: fputs (_("unknown"), stdout
); break;
9560 /* Parse and display the contents of the dynamic section. */
9563 process_dynamic_section (Filedata
* filedata
)
9565 Elf_Internal_Dyn
* entry
;
9567 if (dynamic_size
== 0)
9570 printf (_("\nThere is no dynamic section in this file.\n"));
9577 if (! get_32bit_dynamic_section (filedata
))
9582 if (! get_64bit_dynamic_section (filedata
))
9586 /* Find the appropriate symbol table. */
9587 if (dynamic_symbols
== NULL
)
9589 for (entry
= dynamic_section
;
9590 entry
< dynamic_section
+ dynamic_nent
;
9593 Elf_Internal_Shdr section
;
9595 if (entry
->d_tag
!= DT_SYMTAB
)
9598 dynamic_info
[DT_SYMTAB
] = entry
->d_un
.d_val
;
9600 /* Since we do not know how big the symbol table is,
9601 we default to reading in the entire file (!) and
9602 processing that. This is overkill, I know, but it
9604 section
.sh_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
9605 if ((bfd_size_type
) section
.sh_offset
> filedata
->file_size
)
9607 /* See PR 21379 for a reproducer. */
9608 error (_("Invalid DT_SYMTAB entry: %lx"), (long) section
.sh_offset
);
9612 if (archive_file_offset
!= 0)
9613 section
.sh_size
= archive_file_size
- section
.sh_offset
;
9615 section
.sh_size
= filedata
->file_size
- section
.sh_offset
;
9618 section
.sh_entsize
= sizeof (Elf32_External_Sym
);
9620 section
.sh_entsize
= sizeof (Elf64_External_Sym
);
9621 section
.sh_name
= filedata
->string_table_length
;
9623 dynamic_symbols
= GET_ELF_SYMBOLS (filedata
, §ion
, & num_dynamic_syms
);
9624 if (num_dynamic_syms
< 1)
9626 error (_("Unable to determine the number of symbols to load\n"));
9632 /* Similarly find a string table. */
9633 if (dynamic_strings
== NULL
)
9635 for (entry
= dynamic_section
;
9636 entry
< dynamic_section
+ dynamic_nent
;
9639 unsigned long offset
;
9642 if (entry
->d_tag
!= DT_STRTAB
)
9645 dynamic_info
[DT_STRTAB
] = entry
->d_un
.d_val
;
9647 /* Since we do not know how big the string table is,
9648 we default to reading in the entire file (!) and
9649 processing that. This is overkill, I know, but it
9652 offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
9654 if (archive_file_offset
!= 0)
9655 str_tab_len
= archive_file_size
- offset
;
9657 str_tab_len
= filedata
->file_size
- offset
;
9659 if (str_tab_len
< 1)
9662 (_("Unable to determine the length of the dynamic string table\n"));
9666 dynamic_strings
= (char *) get_data (NULL
, filedata
, offset
, 1,
9668 _("dynamic string table"));
9669 dynamic_strings_length
= dynamic_strings
== NULL
? 0 : str_tab_len
;
9674 /* And find the syminfo section if available. */
9675 if (dynamic_syminfo
== NULL
)
9677 unsigned long syminsz
= 0;
9679 for (entry
= dynamic_section
;
9680 entry
< dynamic_section
+ dynamic_nent
;
9683 if (entry
->d_tag
== DT_SYMINENT
)
9685 /* Note: these braces are necessary to avoid a syntax
9686 error from the SunOS4 C compiler. */
9687 /* PR binutils/17531: A corrupt file can trigger this test.
9688 So do not use an assert, instead generate an error message. */
9689 if (sizeof (Elf_External_Syminfo
) != entry
->d_un
.d_val
)
9690 error (_("Bad value (%d) for SYMINENT entry\n"),
9691 (int) entry
->d_un
.d_val
);
9693 else if (entry
->d_tag
== DT_SYMINSZ
)
9694 syminsz
= entry
->d_un
.d_val
;
9695 else if (entry
->d_tag
== DT_SYMINFO
)
9696 dynamic_syminfo_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
,
9700 if (dynamic_syminfo_offset
!= 0 && syminsz
!= 0)
9702 Elf_External_Syminfo
* extsyminfo
;
9703 Elf_External_Syminfo
* extsym
;
9704 Elf_Internal_Syminfo
* syminfo
;
9706 /* There is a syminfo section. Read the data. */
9707 extsyminfo
= (Elf_External_Syminfo
*)
9708 get_data (NULL
, filedata
, dynamic_syminfo_offset
, 1, syminsz
,
9709 _("symbol information"));
9713 dynamic_syminfo
= (Elf_Internal_Syminfo
*) malloc (syminsz
);
9714 if (dynamic_syminfo
== NULL
)
9716 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9717 (unsigned long) syminsz
);
9721 dynamic_syminfo_nent
= syminsz
/ sizeof (Elf_External_Syminfo
);
9722 for (syminfo
= dynamic_syminfo
, extsym
= extsyminfo
;
9723 syminfo
< dynamic_syminfo
+ dynamic_syminfo_nent
;
9724 ++syminfo
, ++extsym
)
9726 syminfo
->si_boundto
= BYTE_GET (extsym
->si_boundto
);
9727 syminfo
->si_flags
= BYTE_GET (extsym
->si_flags
);
9734 if (do_dynamic
&& dynamic_addr
)
9735 printf (ngettext ("\nDynamic section at offset 0x%lx "
9736 "contains %lu entry:\n",
9737 "\nDynamic section at offset 0x%lx "
9738 "contains %lu entries:\n",
9740 dynamic_addr
, (unsigned long) dynamic_nent
);
9742 printf (_(" Tag Type Name/Value\n"));
9744 for (entry
= dynamic_section
;
9745 entry
< dynamic_section
+ dynamic_nent
;
9753 print_vma (entry
->d_tag
, FULL_HEX
);
9754 dtype
= get_dynamic_type (filedata
, entry
->d_tag
);
9755 printf (" (%s)%*s", dtype
,
9756 ((is_32bit_elf
? 27 : 19) - (int) strlen (dtype
)), " ");
9759 switch (entry
->d_tag
)
9763 print_dynamic_flags (entry
->d_un
.d_val
);
9773 switch (entry
->d_tag
)
9776 printf (_("Auxiliary library"));
9780 printf (_("Filter library"));
9784 printf (_("Configuration file"));
9788 printf (_("Dependency audit library"));
9792 printf (_("Audit library"));
9796 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
9797 printf (": [%s]\n", GET_DYNAMIC_NAME (entry
->d_un
.d_val
));
9801 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
9810 printf (_("Flags:"));
9812 if (entry
->d_un
.d_val
== 0)
9813 printf (_(" None\n"));
9816 unsigned long int val
= entry
->d_un
.d_val
;
9818 if (val
& DTF_1_PARINIT
)
9820 printf (" PARINIT");
9821 val
^= DTF_1_PARINIT
;
9823 if (val
& DTF_1_CONFEXP
)
9825 printf (" CONFEXP");
9826 val
^= DTF_1_CONFEXP
;
9829 printf (" %lx", val
);
9838 printf (_("Flags:"));
9840 if (entry
->d_un
.d_val
== 0)
9841 printf (_(" None\n"));
9844 unsigned long int val
= entry
->d_un
.d_val
;
9846 if (val
& DF_P1_LAZYLOAD
)
9848 printf (" LAZYLOAD");
9849 val
^= DF_P1_LAZYLOAD
;
9851 if (val
& DF_P1_GROUPPERM
)
9853 printf (" GROUPPERM");
9854 val
^= DF_P1_GROUPPERM
;
9857 printf (" %lx", val
);
9866 printf (_("Flags:"));
9867 if (entry
->d_un
.d_val
== 0)
9868 printf (_(" None\n"));
9871 unsigned long int val
= entry
->d_un
.d_val
;
9878 if (val
& DF_1_GLOBAL
)
9883 if (val
& DF_1_GROUP
)
9888 if (val
& DF_1_NODELETE
)
9890 printf (" NODELETE");
9891 val
^= DF_1_NODELETE
;
9893 if (val
& DF_1_LOADFLTR
)
9895 printf (" LOADFLTR");
9896 val
^= DF_1_LOADFLTR
;
9898 if (val
& DF_1_INITFIRST
)
9900 printf (" INITFIRST");
9901 val
^= DF_1_INITFIRST
;
9903 if (val
& DF_1_NOOPEN
)
9908 if (val
& DF_1_ORIGIN
)
9913 if (val
& DF_1_DIRECT
)
9918 if (val
& DF_1_TRANS
)
9923 if (val
& DF_1_INTERPOSE
)
9925 printf (" INTERPOSE");
9926 val
^= DF_1_INTERPOSE
;
9928 if (val
& DF_1_NODEFLIB
)
9930 printf (" NODEFLIB");
9931 val
^= DF_1_NODEFLIB
;
9933 if (val
& DF_1_NODUMP
)
9938 if (val
& DF_1_CONFALT
)
9940 printf (" CONFALT");
9941 val
^= DF_1_CONFALT
;
9943 if (val
& DF_1_ENDFILTEE
)
9945 printf (" ENDFILTEE");
9946 val
^= DF_1_ENDFILTEE
;
9948 if (val
& DF_1_DISPRELDNE
)
9950 printf (" DISPRELDNE");
9951 val
^= DF_1_DISPRELDNE
;
9953 if (val
& DF_1_DISPRELPND
)
9955 printf (" DISPRELPND");
9956 val
^= DF_1_DISPRELPND
;
9958 if (val
& DF_1_NODIRECT
)
9960 printf (" NODIRECT");
9961 val
^= DF_1_NODIRECT
;
9963 if (val
& DF_1_IGNMULDEF
)
9965 printf (" IGNMULDEF");
9966 val
^= DF_1_IGNMULDEF
;
9968 if (val
& DF_1_NOKSYMS
)
9970 printf (" NOKSYMS");
9971 val
^= DF_1_NOKSYMS
;
9973 if (val
& DF_1_NOHDR
)
9978 if (val
& DF_1_EDITED
)
9983 if (val
& DF_1_NORELOC
)
9985 printf (" NORELOC");
9986 val
^= DF_1_NORELOC
;
9988 if (val
& DF_1_SYMINTPOSE
)
9990 printf (" SYMINTPOSE");
9991 val
^= DF_1_SYMINTPOSE
;
9993 if (val
& DF_1_GLOBAUDIT
)
9995 printf (" GLOBAUDIT");
9996 val
^= DF_1_GLOBAUDIT
;
9998 if (val
& DF_1_SINGLETON
)
10000 printf (" SINGLETON");
10001 val
^= DF_1_SINGLETON
;
10003 if (val
& DF_1_STUB
)
10008 if (val
& DF_1_PIE
)
10013 if (val
& DF_1_KMOD
)
10018 if (val
& DF_1_WEAKFILTER
)
10020 printf (" WEAKFILTER");
10021 val
^= DF_1_WEAKFILTER
;
10023 if (val
& DF_1_NOCOMMON
)
10025 printf (" NOCOMMON");
10026 val
^= DF_1_NOCOMMON
;
10029 printf (" %lx", val
);
10036 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10038 puts (get_dynamic_type (filedata
, entry
->d_un
.d_val
));
10058 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10064 if (VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
10065 name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
10071 switch (entry
->d_tag
)
10074 printf (_("Shared library: [%s]"), name
);
10076 if (streq (name
, program_interpreter
))
10077 printf (_(" program interpreter"));
10081 printf (_("Library soname: [%s]"), name
);
10085 printf (_("Library rpath: [%s]"), name
);
10089 printf (_("Library runpath: [%s]"), name
);
10093 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10098 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10111 dynamic_info
[entry
->d_tag
] = entry
->d_un
.d_val
;
10112 /* Fall through. */
10116 case DT_INIT_ARRAYSZ
:
10117 case DT_FINI_ARRAYSZ
:
10118 case DT_GNU_CONFLICTSZ
:
10119 case DT_GNU_LIBLISTSZ
:
10122 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10123 printf (_(" (bytes)\n"));
10128 case DT_VERNEEDNUM
:
10133 print_vma (entry
->d_un
.d_val
, UNSIGNED
);
10142 case DT_INIT_ARRAY
:
10143 case DT_FINI_ARRAY
:
10146 if (entry
->d_tag
== DT_USED
10147 && VALID_DYNAMIC_NAME (entry
->d_un
.d_val
))
10149 char * name
= GET_DYNAMIC_NAME (entry
->d_un
.d_val
);
10153 printf (_("Not needed object: [%s]\n"), name
);
10158 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10164 /* The value of this entry is ignored. */
10169 case DT_GNU_PRELINKED
:
10173 time_t atime
= entry
->d_un
.d_val
;
10175 tmp
= gmtime (&atime
);
10176 /* PR 17533 file: 041-1244816-0.004. */
10178 printf (_("<corrupt time val: %lx"),
10179 (unsigned long) atime
);
10181 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
10182 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
10183 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
10189 dynamic_info_DT_GNU_HASH
= entry
->d_un
.d_val
;
10192 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10198 if ((entry
->d_tag
>= DT_VERSYM
) && (entry
->d_tag
<= DT_VERNEEDNUM
))
10199 version_info
[DT_VERSIONTAGIDX (entry
->d_tag
)] =
10204 switch (filedata
->file_header
.e_machine
)
10207 case EM_MIPS_RS3_LE
:
10208 dynamic_section_mips_val (entry
);
10211 dynamic_section_parisc_val (entry
);
10214 dynamic_section_ia64_val (entry
);
10217 print_vma (entry
->d_un
.d_val
, PREFIX_HEX
);
10229 get_ver_flags (unsigned int flags
)
10231 static char buff
[128];
10238 if (flags
& VER_FLG_BASE
)
10239 strcat (buff
, "BASE");
10241 if (flags
& VER_FLG_WEAK
)
10243 if (flags
& VER_FLG_BASE
)
10244 strcat (buff
, " | ");
10246 strcat (buff
, "WEAK");
10249 if (flags
& VER_FLG_INFO
)
10251 if (flags
& (VER_FLG_BASE
|VER_FLG_WEAK
))
10252 strcat (buff
, " | ");
10254 strcat (buff
, "INFO");
10257 if (flags
& ~(VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10259 if (flags
& (VER_FLG_BASE
| VER_FLG_WEAK
| VER_FLG_INFO
))
10260 strcat (buff
, " | ");
10262 strcat (buff
, _("<unknown>"));
10268 /* Display the contents of the version sections. */
10271 process_version_sections (Filedata
* filedata
)
10273 Elf_Internal_Shdr
* section
;
10275 bfd_boolean found
= FALSE
;
10280 for (i
= 0, section
= filedata
->section_headers
;
10281 i
< filedata
->file_header
.e_shnum
;
10284 switch (section
->sh_type
)
10286 case SHT_GNU_verdef
:
10288 Elf_External_Verdef
* edefs
;
10295 printf (ngettext ("\nVersion definition section '%s' "
10296 "contains %u entry:\n",
10297 "\nVersion definition section '%s' "
10298 "contains %u entries:\n",
10300 printable_section_name (filedata
, section
),
10303 printf (_(" Addr: 0x"));
10304 printf_vma (section
->sh_addr
);
10305 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10306 (unsigned long) section
->sh_offset
, section
->sh_link
,
10307 printable_section_name_from_index (filedata
, section
->sh_link
));
10309 edefs
= (Elf_External_Verdef
*)
10310 get_data (NULL
, filedata
, section
->sh_offset
, 1,section
->sh_size
,
10311 _("version definition section"));
10314 endbuf
= (char *) edefs
+ section
->sh_size
;
10316 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
10319 Elf_External_Verdef
* edef
;
10320 Elf_Internal_Verdef ent
;
10321 Elf_External_Verdaux
* eaux
;
10322 Elf_Internal_Verdaux aux
;
10323 unsigned long isum
;
10326 vstart
= ((char *) edefs
) + idx
;
10327 if (vstart
+ sizeof (*edef
) > endbuf
)
10330 edef
= (Elf_External_Verdef
*) vstart
;
10332 ent
.vd_version
= BYTE_GET (edef
->vd_version
);
10333 ent
.vd_flags
= BYTE_GET (edef
->vd_flags
);
10334 ent
.vd_ndx
= BYTE_GET (edef
->vd_ndx
);
10335 ent
.vd_cnt
= BYTE_GET (edef
->vd_cnt
);
10336 ent
.vd_hash
= BYTE_GET (edef
->vd_hash
);
10337 ent
.vd_aux
= BYTE_GET (edef
->vd_aux
);
10338 ent
.vd_next
= BYTE_GET (edef
->vd_next
);
10340 printf (_(" %#06lx: Rev: %d Flags: %s"),
10341 idx
, ent
.vd_version
, get_ver_flags (ent
.vd_flags
));
10343 printf (_(" Index: %d Cnt: %d "),
10344 ent
.vd_ndx
, ent
.vd_cnt
);
10346 /* Check for overflow. */
10347 if (ent
.vd_aux
> (size_t) (endbuf
- vstart
))
10350 vstart
+= ent
.vd_aux
;
10352 if (vstart
+ sizeof (*eaux
) > endbuf
)
10354 eaux
= (Elf_External_Verdaux
*) vstart
;
10356 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10357 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10359 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10360 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux
.vda_name
));
10362 printf (_("Name index: %ld\n"), aux
.vda_name
);
10364 isum
= idx
+ ent
.vd_aux
;
10366 for (j
= 1; j
< ent
.vd_cnt
; j
++)
10368 if (aux
.vda_next
< sizeof (*eaux
)
10369 && !(j
== ent
.vd_cnt
- 1 && aux
.vda_next
== 0))
10371 warn (_("Invalid vda_next field of %lx\n"),
10376 /* Check for overflow. */
10377 if (aux
.vda_next
> (size_t) (endbuf
- vstart
))
10380 isum
+= aux
.vda_next
;
10381 vstart
+= aux
.vda_next
;
10383 if (vstart
+ sizeof (*eaux
) > endbuf
)
10385 eaux
= (Elf_External_Verdaux
*) vstart
;
10387 aux
.vda_name
= BYTE_GET (eaux
->vda_name
);
10388 aux
.vda_next
= BYTE_GET (eaux
->vda_next
);
10390 if (VALID_DYNAMIC_NAME (aux
.vda_name
))
10391 printf (_(" %#06lx: Parent %d: %s\n"),
10392 isum
, j
, GET_DYNAMIC_NAME (aux
.vda_name
));
10394 printf (_(" %#06lx: Parent %d, name index: %ld\n"),
10395 isum
, j
, aux
.vda_name
);
10398 if (j
< ent
.vd_cnt
)
10399 printf (_(" Version def aux past end of section\n"));
10402 file: id:000001,src:000172+005151,op:splice,rep:2. */
10403 if (ent
.vd_next
< sizeof (*edef
)
10404 && !(cnt
== section
->sh_info
- 1 && ent
.vd_next
== 0))
10406 warn (_("Invalid vd_next field of %lx\n"), ent
.vd_next
);
10407 cnt
= section
->sh_info
;
10410 if (ent
.vd_next
> (size_t) (endbuf
- ((char *) edefs
+ idx
)))
10413 idx
+= ent
.vd_next
;
10416 if (cnt
< section
->sh_info
)
10417 printf (_(" Version definition past end of section\n"));
10423 case SHT_GNU_verneed
:
10425 Elf_External_Verneed
* eneed
;
10432 printf (ngettext ("\nVersion needs section '%s' "
10433 "contains %u entry:\n",
10434 "\nVersion needs section '%s' "
10435 "contains %u entries:\n",
10437 printable_section_name (filedata
, section
), section
->sh_info
);
10439 printf (_(" Addr: 0x"));
10440 printf_vma (section
->sh_addr
);
10441 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10442 (unsigned long) section
->sh_offset
, section
->sh_link
,
10443 printable_section_name_from_index (filedata
, section
->sh_link
));
10445 eneed
= (Elf_External_Verneed
*) get_data (NULL
, filedata
,
10446 section
->sh_offset
, 1,
10448 _("Version Needs section"));
10451 endbuf
= (char *) eneed
+ section
->sh_size
;
10453 for (idx
= cnt
= 0; cnt
< section
->sh_info
; ++cnt
)
10455 Elf_External_Verneed
* entry
;
10456 Elf_Internal_Verneed ent
;
10457 unsigned long isum
;
10461 vstart
= ((char *) eneed
) + idx
;
10462 if (vstart
+ sizeof (*entry
) > endbuf
)
10465 entry
= (Elf_External_Verneed
*) vstart
;
10467 ent
.vn_version
= BYTE_GET (entry
->vn_version
);
10468 ent
.vn_cnt
= BYTE_GET (entry
->vn_cnt
);
10469 ent
.vn_file
= BYTE_GET (entry
->vn_file
);
10470 ent
.vn_aux
= BYTE_GET (entry
->vn_aux
);
10471 ent
.vn_next
= BYTE_GET (entry
->vn_next
);
10473 printf (_(" %#06lx: Version: %d"), idx
, ent
.vn_version
);
10475 if (VALID_DYNAMIC_NAME (ent
.vn_file
))
10476 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent
.vn_file
));
10478 printf (_(" File: %lx"), ent
.vn_file
);
10480 printf (_(" Cnt: %d\n"), ent
.vn_cnt
);
10482 /* Check for overflow. */
10483 if (ent
.vn_aux
> (size_t) (endbuf
- vstart
))
10485 vstart
+= ent
.vn_aux
;
10487 for (j
= 0, isum
= idx
+ ent
.vn_aux
; j
< ent
.vn_cnt
; ++j
)
10489 Elf_External_Vernaux
* eaux
;
10490 Elf_Internal_Vernaux aux
;
10492 if (vstart
+ sizeof (*eaux
) > endbuf
)
10494 eaux
= (Elf_External_Vernaux
*) vstart
;
10496 aux
.vna_hash
= BYTE_GET (eaux
->vna_hash
);
10497 aux
.vna_flags
= BYTE_GET (eaux
->vna_flags
);
10498 aux
.vna_other
= BYTE_GET (eaux
->vna_other
);
10499 aux
.vna_name
= BYTE_GET (eaux
->vna_name
);
10500 aux
.vna_next
= BYTE_GET (eaux
->vna_next
);
10502 if (VALID_DYNAMIC_NAME (aux
.vna_name
))
10503 printf (_(" %#06lx: Name: %s"),
10504 isum
, GET_DYNAMIC_NAME (aux
.vna_name
));
10506 printf (_(" %#06lx: Name index: %lx"),
10507 isum
, aux
.vna_name
);
10509 printf (_(" Flags: %s Version: %d\n"),
10510 get_ver_flags (aux
.vna_flags
), aux
.vna_other
);
10512 if (aux
.vna_next
< sizeof (*eaux
)
10513 && !(j
== ent
.vn_cnt
- 1 && aux
.vna_next
== 0))
10515 warn (_("Invalid vna_next field of %lx\n"),
10520 /* Check for overflow. */
10521 if (aux
.vna_next
> (size_t) (endbuf
- vstart
))
10523 isum
+= aux
.vna_next
;
10524 vstart
+= aux
.vna_next
;
10527 if (j
< ent
.vn_cnt
)
10528 warn (_("Missing Version Needs auxillary information\n"));
10530 if (ent
.vn_next
< sizeof (*entry
)
10531 && !(cnt
== section
->sh_info
- 1 && ent
.vn_next
== 0))
10533 warn (_("Invalid vn_next field of %lx\n"), ent
.vn_next
);
10534 cnt
= section
->sh_info
;
10537 if (ent
.vn_next
> (size_t) (endbuf
- ((char *) eneed
+ idx
)))
10539 idx
+= ent
.vn_next
;
10542 if (cnt
< section
->sh_info
)
10543 warn (_("Missing Version Needs information\n"));
10549 case SHT_GNU_versym
:
10551 Elf_Internal_Shdr
* link_section
;
10554 unsigned char * edata
;
10555 unsigned short * data
;
10557 Elf_Internal_Sym
* symbols
;
10558 Elf_Internal_Shdr
* string_sec
;
10559 unsigned long num_syms
;
10562 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
10565 link_section
= filedata
->section_headers
+ section
->sh_link
;
10566 total
= section
->sh_size
/ sizeof (Elf_External_Versym
);
10568 if (link_section
->sh_link
>= filedata
->file_header
.e_shnum
)
10573 symbols
= GET_ELF_SYMBOLS (filedata
, link_section
, & num_syms
);
10574 if (symbols
== NULL
)
10577 string_sec
= filedata
->section_headers
+ link_section
->sh_link
;
10579 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
10580 string_sec
->sh_size
,
10581 _("version string table"));
10588 printf (ngettext ("\nVersion symbols section '%s' "
10589 "contains %lu entry:\n",
10590 "\nVersion symbols section '%s' "
10591 "contains %lu entries:\n",
10593 printable_section_name (filedata
, section
), (unsigned long) total
);
10595 printf (_(" Addr: "));
10596 printf_vma (section
->sh_addr
);
10597 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10598 (unsigned long) section
->sh_offset
, section
->sh_link
,
10599 printable_section_name (filedata
, link_section
));
10601 off
= offset_from_vma (filedata
,
10602 version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
10603 total
* sizeof (short));
10604 edata
= (unsigned char *) get_data (NULL
, filedata
, off
, total
,
10606 _("version symbol data"));
10614 data
= (short unsigned int *) cmalloc (total
, sizeof (short));
10616 for (cnt
= total
; cnt
--;)
10617 data
[cnt
] = byte_get (edata
+ cnt
* sizeof (short),
10622 for (cnt
= 0; cnt
< total
; cnt
+= 4)
10626 char *invalid
= _("*invalid*");
10628 printf (" %03x:", cnt
);
10630 for (j
= 0; (j
< 4) && (cnt
+ j
) < total
; ++j
)
10631 switch (data
[cnt
+ j
])
10634 fputs (_(" 0 (*local*) "), stdout
);
10638 fputs (_(" 1 (*global*) "), stdout
);
10642 nn
= printf ("%4x%c", data
[cnt
+ j
] & VERSYM_VERSION
,
10643 data
[cnt
+ j
] & VERSYM_HIDDEN
? 'h' : ' ');
10645 /* If this index value is greater than the size of the symbols
10646 array, break to avoid an out-of-bounds read. */
10647 if ((unsigned long)(cnt
+ j
) >= num_syms
)
10649 warn (_("invalid index into symbol array\n"));
10654 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
10656 Elf_Internal_Verneed ivn
;
10657 unsigned long offset
;
10659 offset
= offset_from_vma
10660 (filedata
, version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
10661 sizeof (Elf_External_Verneed
));
10665 Elf_Internal_Vernaux ivna
;
10666 Elf_External_Verneed evn
;
10667 Elf_External_Vernaux evna
;
10668 unsigned long a_off
;
10670 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
10671 _("version need")) == NULL
)
10674 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
10675 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
10677 a_off
= offset
+ ivn
.vn_aux
;
10681 if (get_data (&evna
, filedata
, a_off
, sizeof (evna
),
10682 1, _("version need aux (2)")) == NULL
)
10685 ivna
.vna_other
= 0;
10689 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
10690 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
10693 a_off
+= ivna
.vna_next
;
10695 while (ivna
.vna_other
!= data
[cnt
+ j
]
10696 && ivna
.vna_next
!= 0);
10698 if (ivna
.vna_other
== data
[cnt
+ j
])
10700 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
10702 if (ivna
.vna_name
>= string_sec
->sh_size
)
10705 name
= strtab
+ ivna
.vna_name
;
10709 offset
+= ivn
.vn_next
;
10711 while (ivn
.vn_next
);
10714 if (data
[cnt
+ j
] != 0x8001
10715 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
10717 Elf_Internal_Verdef ivd
;
10718 Elf_External_Verdef evd
;
10719 unsigned long offset
;
10721 offset
= offset_from_vma
10722 (filedata
, version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
10727 if (get_data (&evd
, filedata
, offset
, sizeof (evd
), 1,
10728 _("version def")) == NULL
)
10731 /* PR 17531: file: 046-1082287-0.004. */
10732 ivd
.vd_ndx
= (data
[cnt
+ j
] & VERSYM_VERSION
) + 1;
10737 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
10738 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
10741 offset
+= ivd
.vd_next
;
10743 while (ivd
.vd_ndx
!= (data
[cnt
+ j
] & VERSYM_VERSION
)
10744 && ivd
.vd_next
!= 0);
10746 if (ivd
.vd_ndx
== (data
[cnt
+ j
] & VERSYM_VERSION
))
10748 Elf_External_Verdaux evda
;
10749 Elf_Internal_Verdaux ivda
;
10751 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
10753 if (get_data (&evda
, filedata
,
10754 offset
- ivd
.vd_next
+ ivd
.vd_aux
,
10756 _("version def aux")) == NULL
)
10759 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
10761 if (ivda
.vda_name
>= string_sec
->sh_size
)
10763 else if (name
!= NULL
&& name
!= invalid
)
10764 name
= _("*both*");
10766 name
= strtab
+ ivda
.vda_name
;
10770 nn
+= printf ("(%s%-*s",
10772 12 - (int) strlen (name
),
10776 printf ("%*c", 18 - nn
, ' ');
10794 printf (_("\nNo version information found in this file.\n"));
10799 static const char *
10800 get_symbol_binding (Filedata
* filedata
, unsigned int binding
)
10802 static char buff
[32];
10806 case STB_LOCAL
: return "LOCAL";
10807 case STB_GLOBAL
: return "GLOBAL";
10808 case STB_WEAK
: return "WEAK";
10810 if (binding
>= STB_LOPROC
&& binding
<= STB_HIPROC
)
10811 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"),
10813 else if (binding
>= STB_LOOS
&& binding
<= STB_HIOS
)
10815 if (binding
== STB_GNU_UNIQUE
10816 && (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10817 /* GNU is still using the default value 0. */
10818 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10820 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), binding
);
10823 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), binding
);
10828 static const char *
10829 get_symbol_type (Filedata
* filedata
, unsigned int type
)
10831 static char buff
[32];
10835 case STT_NOTYPE
: return "NOTYPE";
10836 case STT_OBJECT
: return "OBJECT";
10837 case STT_FUNC
: return "FUNC";
10838 case STT_SECTION
: return "SECTION";
10839 case STT_FILE
: return "FILE";
10840 case STT_COMMON
: return "COMMON";
10841 case STT_TLS
: return "TLS";
10842 case STT_RELC
: return "RELC";
10843 case STT_SRELC
: return "SRELC";
10845 if (type
>= STT_LOPROC
&& type
<= STT_HIPROC
)
10847 if (filedata
->file_header
.e_machine
== EM_ARM
&& type
== STT_ARM_TFUNC
)
10848 return "THUMB_FUNC";
10850 if (filedata
->file_header
.e_machine
== EM_SPARCV9
&& type
== STT_REGISTER
)
10853 if (filedata
->file_header
.e_machine
== EM_PARISC
&& type
== STT_PARISC_MILLI
)
10854 return "PARISC_MILLI";
10856 snprintf (buff
, sizeof (buff
), _("<processor specific>: %d"), type
);
10858 else if (type
>= STT_LOOS
&& type
<= STT_HIOS
)
10860 if (filedata
->file_header
.e_machine
== EM_PARISC
)
10862 if (type
== STT_HP_OPAQUE
)
10863 return "HP_OPAQUE";
10864 if (type
== STT_HP_STUB
)
10868 if (type
== STT_GNU_IFUNC
10869 && (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_GNU
10870 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_FREEBSD
10871 /* GNU is still using the default value 0. */
10872 || filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_NONE
))
10875 snprintf (buff
, sizeof (buff
), _("<OS specific>: %d"), type
);
10878 snprintf (buff
, sizeof (buff
), _("<unknown>: %d"), type
);
10883 static const char *
10884 get_symbol_visibility (unsigned int visibility
)
10886 switch (visibility
)
10888 case STV_DEFAULT
: return "DEFAULT";
10889 case STV_INTERNAL
: return "INTERNAL";
10890 case STV_HIDDEN
: return "HIDDEN";
10891 case STV_PROTECTED
: return "PROTECTED";
10893 error (_("Unrecognized visibility value: %u"), visibility
);
10894 return _("<unknown>");
10898 static const char *
10899 get_solaris_symbol_visibility (unsigned int visibility
)
10901 switch (visibility
)
10903 case 4: return "EXPORTED";
10904 case 5: return "SINGLETON";
10905 case 6: return "ELIMINATE";
10906 default: return get_symbol_visibility (visibility
);
10910 static const char *
10911 get_mips_symbol_other (unsigned int other
)
10915 case STO_OPTIONAL
: return "OPTIONAL";
10916 case STO_MIPS_PLT
: return "MIPS PLT";
10917 case STO_MIPS_PIC
: return "MIPS PIC";
10918 case STO_MICROMIPS
: return "MICROMIPS";
10919 case STO_MICROMIPS
| STO_MIPS_PIC
: return "MICROMIPS, MIPS PIC";
10920 case STO_MIPS16
: return "MIPS16";
10921 default: return NULL
;
10925 static const char *
10926 get_ia64_symbol_other (Filedata
* filedata
, unsigned int other
)
10928 if (is_ia64_vms (filedata
))
10930 static char res
[32];
10934 /* Function types is for images and .STB files only. */
10935 switch (filedata
->file_header
.e_type
)
10939 switch (VMS_ST_FUNC_TYPE (other
))
10941 case VMS_SFT_CODE_ADDR
:
10942 strcat (res
, " CA");
10944 case VMS_SFT_SYMV_IDX
:
10945 strcat (res
, " VEC");
10948 strcat (res
, " FD");
10950 case VMS_SFT_RESERVE
:
10951 strcat (res
, " RSV");
10954 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10955 VMS_ST_FUNC_TYPE (other
));
10956 strcat (res
, " <unknown>");
10963 switch (VMS_ST_LINKAGE (other
))
10965 case VMS_STL_IGNORE
:
10966 strcat (res
, " IGN");
10968 case VMS_STL_RESERVE
:
10969 strcat (res
, " RSV");
10972 strcat (res
, " STD");
10975 strcat (res
, " LNK");
10978 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10979 VMS_ST_LINKAGE (other
));
10980 strcat (res
, " <unknown>");
10992 static const char *
10993 get_ppc64_symbol_other (unsigned int other
)
10995 if (PPC64_LOCAL_ENTRY_OFFSET (other
) != 0)
10997 static char buf
[32];
10998 snprintf (buf
, sizeof buf
, _("<localentry>: %d"),
10999 PPC64_LOCAL_ENTRY_OFFSET (other
));
11005 static const char *
11006 get_symbol_other (Filedata
* filedata
, unsigned int other
)
11008 const char * result
= NULL
;
11009 static char buff
[32];
11014 switch (filedata
->file_header
.e_machine
)
11017 result
= get_mips_symbol_other (other
);
11020 result
= get_ia64_symbol_other (filedata
, other
);
11023 result
= get_ppc64_symbol_other (other
);
11033 snprintf (buff
, sizeof buff
, _("<other>: %x"), other
);
11037 static const char *
11038 get_symbol_index_type (Filedata
* filedata
, unsigned int type
)
11040 static char buff
[32];
11044 case SHN_UNDEF
: return "UND";
11045 case SHN_ABS
: return "ABS";
11046 case SHN_COMMON
: return "COM";
11048 if (type
== SHN_IA_64_ANSI_COMMON
11049 && filedata
->file_header
.e_machine
== EM_IA_64
11050 && filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_HPUX
)
11052 else if ((filedata
->file_header
.e_machine
== EM_X86_64
11053 || filedata
->file_header
.e_machine
== EM_L1OM
11054 || filedata
->file_header
.e_machine
== EM_K1OM
)
11055 && type
== SHN_X86_64_LCOMMON
)
11056 return "LARGE_COM";
11057 else if ((type
== SHN_MIPS_SCOMMON
11058 && filedata
->file_header
.e_machine
== EM_MIPS
)
11059 || (type
== SHN_TIC6X_SCOMMON
11060 && filedata
->file_header
.e_machine
== EM_TI_C6000
))
11062 else if (type
== SHN_MIPS_SUNDEFINED
11063 && filedata
->file_header
.e_machine
== EM_MIPS
)
11065 else if (type
>= SHN_LOPROC
&& type
<= SHN_HIPROC
)
11066 sprintf (buff
, "PRC[0x%04x]", type
& 0xffff);
11067 else if (type
>= SHN_LOOS
&& type
<= SHN_HIOS
)
11068 sprintf (buff
, "OS [0x%04x]", type
& 0xffff);
11069 else if (type
>= SHN_LORESERVE
)
11070 sprintf (buff
, "RSV[0x%04x]", type
& 0xffff);
11071 else if (type
>= filedata
->file_header
.e_shnum
)
11072 sprintf (buff
, _("bad section index[%3d]"), type
);
11074 sprintf (buff
, "%3d", type
);
11082 get_dynamic_data (Filedata
* filedata
, bfd_size_type number
, unsigned int ent_size
)
11084 unsigned char * e_data
;
11087 /* If the size_t type is smaller than the bfd_size_type, eg because
11088 you are building a 32-bit tool on a 64-bit host, then make sure
11089 that when (number) is cast to (size_t) no information is lost. */
11090 if (sizeof (size_t) < sizeof (bfd_size_type
)
11091 && (bfd_size_type
) ((size_t) number
) != number
)
11093 error (_("Size truncation prevents reading %s elements of size %u\n"),
11094 bfd_vmatoa ("u", number
), ent_size
);
11098 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
11099 attempting to allocate memory when the read is bound to fail. */
11100 if (ent_size
* number
> filedata
->file_size
)
11102 error (_("Invalid number of dynamic entries: %s\n"),
11103 bfd_vmatoa ("u", number
));
11107 e_data
= (unsigned char *) cmalloc ((size_t) number
, ent_size
);
11108 if (e_data
== NULL
)
11110 error (_("Out of memory reading %s dynamic entries\n"),
11111 bfd_vmatoa ("u", number
));
11115 if (fread (e_data
, ent_size
, (size_t) number
, filedata
->handle
) != number
)
11117 error (_("Unable to read in %s bytes of dynamic data\n"),
11118 bfd_vmatoa ("u", number
* ent_size
));
11123 i_data
= (bfd_vma
*) cmalloc ((size_t) number
, sizeof (*i_data
));
11124 if (i_data
== NULL
)
11126 error (_("Out of memory allocating space for %s dynamic entries\n"),
11127 bfd_vmatoa ("u", number
));
11133 i_data
[number
] = byte_get (e_data
+ number
* ent_size
, ent_size
);
11141 print_dynamic_symbol (Filedata
* filedata
, bfd_vma si
, unsigned long hn
)
11143 Elf_Internal_Sym
* psym
;
11146 n
= print_vma (si
, DEC_5
);
11148 fputs (&" "[n
], stdout
);
11149 printf (" %3lu: ", hn
);
11151 if (dynamic_symbols
== NULL
|| si
>= num_dynamic_syms
)
11153 printf (_("<No info available for dynamic symbol number %lu>\n"),
11154 (unsigned long) si
);
11158 psym
= dynamic_symbols
+ si
;
11159 print_vma (psym
->st_value
, LONG_HEX
);
11161 print_vma (psym
->st_size
, DEC_5
);
11163 printf (" %-7s", get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)));
11164 printf (" %-6s", get_symbol_binding (filedata
, ELF_ST_BIND (psym
->st_info
)));
11166 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
11167 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
11170 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
11172 printf (" %-7s", get_symbol_visibility (vis
));
11173 /* Check to see if any other bits in the st_other field are set.
11174 Note - displaying this information disrupts the layout of the
11175 table being generated, but for the moment this case is very
11177 if (psym
->st_other
^ vis
)
11178 printf (" [%s] ", get_symbol_other (filedata
, psym
->st_other
^ vis
));
11181 printf (" %3.3s ", get_symbol_index_type (filedata
, psym
->st_shndx
));
11182 if (VALID_DYNAMIC_NAME (psym
->st_name
))
11183 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
11185 printf (_(" <corrupt: %14ld>"), psym
->st_name
);
11189 static const char *
11190 get_symbol_version_string (Filedata
* filedata
,
11191 bfd_boolean is_dynsym
,
11192 const char * strtab
,
11193 unsigned long int strtab_size
,
11195 Elf_Internal_Sym
* psym
,
11196 enum versioned_symbol_info
* sym_info
,
11197 unsigned short * vna_other
)
11199 unsigned char data
[2];
11200 unsigned short vers_data
;
11201 unsigned long offset
;
11204 || version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)] == 0)
11207 offset
= offset_from_vma (filedata
, version_info
[DT_VERSIONTAGIDX (DT_VERSYM
)],
11208 sizeof data
+ si
* sizeof (vers_data
));
11210 if (get_data (&data
, filedata
, offset
+ si
* sizeof (vers_data
),
11211 sizeof (data
), 1, _("version data")) == NULL
)
11214 vers_data
= byte_get (data
, 2);
11216 if ((vers_data
& VERSYM_HIDDEN
) == 0 && vers_data
<= 1)
11219 /* Usually we'd only see verdef for defined symbols, and verneed for
11220 undefined symbols. However, symbols defined by the linker in
11221 .dynbss for variables copied from a shared library in order to
11222 avoid text relocations are defined yet have verneed. We could
11223 use a heuristic to detect the special case, for example, check
11224 for verneed first on symbols defined in SHT_NOBITS sections, but
11225 it is simpler and more reliable to just look for both verdef and
11226 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
11228 if (psym
->st_shndx
!= SHN_UNDEF
11229 && vers_data
!= 0x8001
11230 && version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)])
11232 Elf_Internal_Verdef ivd
;
11233 Elf_Internal_Verdaux ivda
;
11234 Elf_External_Verdaux evda
;
11237 off
= offset_from_vma (filedata
,
11238 version_info
[DT_VERSIONTAGIDX (DT_VERDEF
)],
11239 sizeof (Elf_External_Verdef
));
11243 Elf_External_Verdef evd
;
11245 if (get_data (&evd
, filedata
, off
, sizeof (evd
), 1,
11246 _("version def")) == NULL
)
11254 ivd
.vd_ndx
= BYTE_GET (evd
.vd_ndx
);
11255 ivd
.vd_aux
= BYTE_GET (evd
.vd_aux
);
11256 ivd
.vd_next
= BYTE_GET (evd
.vd_next
);
11259 off
+= ivd
.vd_next
;
11261 while (ivd
.vd_ndx
!= (vers_data
& VERSYM_VERSION
) && ivd
.vd_next
!= 0);
11263 if (ivd
.vd_ndx
== (vers_data
& VERSYM_VERSION
))
11265 off
-= ivd
.vd_next
;
11268 if (get_data (&evda
, filedata
, off
, sizeof (evda
), 1,
11269 _("version def aux")) != NULL
)
11271 ivda
.vda_name
= BYTE_GET (evda
.vda_name
);
11273 if (psym
->st_name
!= ivda
.vda_name
)
11275 *sym_info
= ((vers_data
& VERSYM_HIDDEN
) != 0
11276 ? symbol_hidden
: symbol_public
);
11277 return (ivda
.vda_name
< strtab_size
11278 ? strtab
+ ivda
.vda_name
: _("<corrupt>"));
11284 if (version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)])
11286 Elf_External_Verneed evn
;
11287 Elf_Internal_Verneed ivn
;
11288 Elf_Internal_Vernaux ivna
;
11290 offset
= offset_from_vma (filedata
,
11291 version_info
[DT_VERSIONTAGIDX (DT_VERNEED
)],
11295 unsigned long vna_off
;
11297 if (get_data (&evn
, filedata
, offset
, sizeof (evn
), 1,
11298 _("version need")) == NULL
)
11301 ivna
.vna_other
= 0;
11306 ivn
.vn_aux
= BYTE_GET (evn
.vn_aux
);
11307 ivn
.vn_next
= BYTE_GET (evn
.vn_next
);
11309 vna_off
= offset
+ ivn
.vn_aux
;
11313 Elf_External_Vernaux evna
;
11315 if (get_data (&evna
, filedata
, vna_off
, sizeof (evna
), 1,
11316 _("version need aux (3)")) == NULL
)
11319 ivna
.vna_other
= 0;
11324 ivna
.vna_other
= BYTE_GET (evna
.vna_other
);
11325 ivna
.vna_next
= BYTE_GET (evna
.vna_next
);
11326 ivna
.vna_name
= BYTE_GET (evna
.vna_name
);
11329 vna_off
+= ivna
.vna_next
;
11331 while (ivna
.vna_other
!= vers_data
&& ivna
.vna_next
!= 0);
11333 if (ivna
.vna_other
== vers_data
)
11336 offset
+= ivn
.vn_next
;
11338 while (ivn
.vn_next
!= 0);
11340 if (ivna
.vna_other
== vers_data
)
11342 *sym_info
= symbol_undefined
;
11343 *vna_other
= ivna
.vna_other
;
11344 return (ivna
.vna_name
< strtab_size
11345 ? strtab
+ ivna
.vna_name
: _("<corrupt>"));
11351 /* Dump the symbol table. */
11353 process_symbol_table (Filedata
* filedata
)
11355 Elf_Internal_Shdr
* section
;
11356 bfd_size_type nbuckets
= 0;
11357 bfd_size_type nchains
= 0;
11358 bfd_vma
* buckets
= NULL
;
11359 bfd_vma
* chains
= NULL
;
11360 bfd_vma ngnubuckets
= 0;
11361 bfd_vma
* gnubuckets
= NULL
;
11362 bfd_vma
* gnuchains
= NULL
;
11363 bfd_vma gnusymidx
= 0;
11364 bfd_size_type ngnuchains
= 0;
11366 if (!do_syms
&& !do_dyn_syms
&& !do_histogram
)
11369 if (dynamic_info
[DT_HASH
]
11371 || (do_using_dynamic
11373 && dynamic_strings
!= NULL
)))
11375 unsigned char nb
[8];
11376 unsigned char nc
[8];
11377 unsigned int hash_ent_size
= 4;
11379 if ((filedata
->file_header
.e_machine
== EM_ALPHA
11380 || filedata
->file_header
.e_machine
== EM_S390
11381 || filedata
->file_header
.e_machine
== EM_S390_OLD
)
11382 && filedata
->file_header
.e_ident
[EI_CLASS
] == ELFCLASS64
)
11385 if (fseek (filedata
->handle
,
11386 (archive_file_offset
11387 + offset_from_vma (filedata
, dynamic_info
[DT_HASH
],
11388 sizeof nb
+ sizeof nc
)),
11391 error (_("Unable to seek to start of dynamic information\n"));
11395 if (fread (nb
, hash_ent_size
, 1, filedata
->handle
) != 1)
11397 error (_("Failed to read in number of buckets\n"));
11401 if (fread (nc
, hash_ent_size
, 1, filedata
->handle
) != 1)
11403 error (_("Failed to read in number of chains\n"));
11407 nbuckets
= byte_get (nb
, hash_ent_size
);
11408 nchains
= byte_get (nc
, hash_ent_size
);
11410 buckets
= get_dynamic_data (filedata
, nbuckets
, hash_ent_size
);
11411 chains
= get_dynamic_data (filedata
, nchains
, hash_ent_size
);
11414 if (buckets
== NULL
|| chains
== NULL
)
11416 if (do_using_dynamic
)
11427 if (dynamic_info_DT_GNU_HASH
11429 || (do_using_dynamic
11431 && dynamic_strings
!= NULL
)))
11433 unsigned char nb
[16];
11434 bfd_vma i
, maxchain
= 0xffffffff, bitmaskwords
;
11435 bfd_vma buckets_vma
;
11437 if (fseek (filedata
->handle
,
11438 (archive_file_offset
11439 + offset_from_vma (filedata
, dynamic_info_DT_GNU_HASH
,
11443 error (_("Unable to seek to start of dynamic information\n"));
11447 if (fread (nb
, 16, 1, filedata
->handle
) != 1)
11449 error (_("Failed to read in number of buckets\n"));
11453 ngnubuckets
= byte_get (nb
, 4);
11454 gnusymidx
= byte_get (nb
+ 4, 4);
11455 bitmaskwords
= byte_get (nb
+ 8, 4);
11456 buckets_vma
= dynamic_info_DT_GNU_HASH
+ 16;
11458 buckets_vma
+= bitmaskwords
* 4;
11460 buckets_vma
+= bitmaskwords
* 8;
11462 if (fseek (filedata
->handle
,
11463 (archive_file_offset
11464 + offset_from_vma (filedata
, buckets_vma
, 4)),
11467 error (_("Unable to seek to start of dynamic information\n"));
11471 gnubuckets
= get_dynamic_data (filedata
, ngnubuckets
, 4);
11473 if (gnubuckets
== NULL
)
11476 for (i
= 0; i
< ngnubuckets
; i
++)
11477 if (gnubuckets
[i
] != 0)
11479 if (gnubuckets
[i
] < gnusymidx
)
11482 if (maxchain
== 0xffffffff || gnubuckets
[i
] > maxchain
)
11483 maxchain
= gnubuckets
[i
];
11486 if (maxchain
== 0xffffffff)
11489 maxchain
-= gnusymidx
;
11491 if (fseek (filedata
->handle
,
11492 (archive_file_offset
11493 + offset_from_vma (filedata
, buckets_vma
11494 + 4 * (ngnubuckets
+ maxchain
), 4)),
11497 error (_("Unable to seek to start of dynamic information\n"));
11503 if (fread (nb
, 4, 1, filedata
->handle
) != 1)
11505 error (_("Failed to determine last chain length\n"));
11509 if (maxchain
+ 1 == 0)
11514 while ((byte_get (nb
, 4) & 1) == 0);
11516 if (fseek (filedata
->handle
,
11517 (archive_file_offset
11518 + offset_from_vma (filedata
, buckets_vma
+ 4 * ngnubuckets
, 4)),
11521 error (_("Unable to seek to start of dynamic information\n"));
11525 gnuchains
= get_dynamic_data (filedata
, maxchain
, 4);
11526 ngnuchains
= maxchain
;
11529 if (gnuchains
== NULL
)
11534 if (do_using_dynamic
)
11539 if ((dynamic_info
[DT_HASH
] || dynamic_info_DT_GNU_HASH
)
11541 && do_using_dynamic
11542 && dynamic_strings
!= NULL
11543 && dynamic_symbols
!= NULL
)
11547 if (dynamic_info
[DT_HASH
])
11552 printf (_("\nSymbol table for image:\n"));
11554 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11556 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11558 visited
= xcmalloc (nchains
, 1);
11559 memset (visited
, 0, nchains
);
11560 for (hn
= 0; hn
< nbuckets
; hn
++)
11562 for (si
= buckets
[hn
]; si
> 0; si
= chains
[si
])
11564 print_dynamic_symbol (filedata
, si
, hn
);
11565 if (si
>= nchains
|| visited
[si
])
11567 error (_("histogram chain is corrupt\n"));
11576 if (dynamic_info_DT_GNU_HASH
)
11578 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
11580 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11582 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11584 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11585 if (gnubuckets
[hn
] != 0)
11587 bfd_vma si
= gnubuckets
[hn
];
11588 bfd_vma off
= si
- gnusymidx
;
11592 print_dynamic_symbol (filedata
, si
, hn
);
11595 while (off
< ngnuchains
&& (gnuchains
[off
++] & 1) == 0);
11599 else if ((do_dyn_syms
|| (do_syms
&& !do_using_dynamic
))
11600 && filedata
->section_headers
!= NULL
)
11604 for (i
= 0, section
= filedata
->section_headers
;
11605 i
< filedata
->file_header
.e_shnum
;
11609 char * strtab
= NULL
;
11610 unsigned long int strtab_size
= 0;
11611 Elf_Internal_Sym
* symtab
;
11612 Elf_Internal_Sym
* psym
;
11613 unsigned long num_syms
;
11615 if ((section
->sh_type
!= SHT_SYMTAB
11616 && section
->sh_type
!= SHT_DYNSYM
)
11618 && section
->sh_type
== SHT_SYMTAB
))
11621 if (section
->sh_entsize
== 0)
11623 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
11624 printable_section_name (filedata
, section
));
11628 num_syms
= section
->sh_size
/ section
->sh_entsize
;
11629 printf (ngettext ("\nSymbol table '%s' contains %lu entry:\n",
11630 "\nSymbol table '%s' contains %lu entries:\n",
11632 printable_section_name (filedata
, section
),
11636 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11638 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11640 symtab
= GET_ELF_SYMBOLS (filedata
, section
, & num_syms
);
11641 if (symtab
== NULL
)
11644 if (section
->sh_link
== filedata
->file_header
.e_shstrndx
)
11646 strtab
= filedata
->string_table
;
11647 strtab_size
= filedata
->string_table_length
;
11649 else if (section
->sh_link
< filedata
->file_header
.e_shnum
)
11651 Elf_Internal_Shdr
* string_sec
;
11653 string_sec
= filedata
->section_headers
+ section
->sh_link
;
11655 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
,
11656 1, string_sec
->sh_size
,
11657 _("string table"));
11658 strtab_size
= strtab
!= NULL
? string_sec
->sh_size
: 0;
11661 for (si
= 0, psym
= symtab
; si
< num_syms
; si
++, psym
++)
11663 const char *version_string
;
11664 enum versioned_symbol_info sym_info
;
11665 unsigned short vna_other
;
11667 printf ("%6d: ", si
);
11668 print_vma (psym
->st_value
, LONG_HEX
);
11670 print_vma (psym
->st_size
, DEC_5
);
11671 printf (" %-7s", get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)));
11672 printf (" %-6s", get_symbol_binding (filedata
, ELF_ST_BIND (psym
->st_info
)));
11673 if (filedata
->file_header
.e_ident
[EI_OSABI
] == ELFOSABI_SOLARIS
)
11674 printf (" %-7s", get_solaris_symbol_visibility (psym
->st_other
));
11677 unsigned int vis
= ELF_ST_VISIBILITY (psym
->st_other
);
11679 printf (" %-7s", get_symbol_visibility (vis
));
11680 /* Check to see if any other bits in the st_other field are set.
11681 Note - displaying this information disrupts the layout of the
11682 table being generated, but for the moment this case is very rare. */
11683 if (psym
->st_other
^ vis
)
11684 printf (" [%s] ", get_symbol_other (filedata
, psym
->st_other
^ vis
));
11686 printf (" %4s ", get_symbol_index_type (filedata
, psym
->st_shndx
));
11687 print_symbol (25, psym
->st_name
< strtab_size
11688 ? strtab
+ psym
->st_name
: _("<corrupt>"));
11691 = get_symbol_version_string (filedata
,
11692 section
->sh_type
== SHT_DYNSYM
,
11693 strtab
, strtab_size
, si
,
11694 psym
, &sym_info
, &vna_other
);
11695 if (version_string
)
11697 if (sym_info
== symbol_undefined
)
11698 printf ("@%s (%d)", version_string
, vna_other
);
11700 printf (sym_info
== symbol_hidden
? "@%s" : "@@%s",
11706 if (ELF_ST_BIND (psym
->st_info
) == STB_LOCAL
11707 && si
>= section
->sh_info
11708 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
11709 && filedata
->file_header
.e_machine
!= EM_MIPS
11710 /* Solaris binaries have been found to violate this requirement as
11711 well. Not sure if this is a bug or an ABI requirement. */
11712 && filedata
->file_header
.e_ident
[EI_OSABI
] != ELFOSABI_SOLARIS
)
11713 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
11714 si
, printable_section_name (filedata
, section
), section
->sh_info
);
11718 if (strtab
!= filedata
->string_table
)
11724 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
11726 if (do_histogram
&& buckets
!= NULL
)
11728 unsigned long * lengths
;
11729 unsigned long * counts
;
11732 unsigned long maxlength
= 0;
11733 unsigned long nzero_counts
= 0;
11734 unsigned long nsyms
= 0;
11737 printf (ngettext ("\nHistogram for bucket list length "
11738 "(total of %lu bucket):\n",
11739 "\nHistogram for bucket list length "
11740 "(total of %lu buckets):\n",
11741 (unsigned long) nbuckets
),
11742 (unsigned long) nbuckets
);
11744 lengths
= (unsigned long *) calloc (nbuckets
, sizeof (*lengths
));
11745 if (lengths
== NULL
)
11747 error (_("Out of memory allocating space for histogram buckets\n"));
11750 visited
= xcmalloc (nchains
, 1);
11751 memset (visited
, 0, nchains
);
11753 printf (_(" Length Number %% of total Coverage\n"));
11754 for (hn
= 0; hn
< nbuckets
; ++hn
)
11756 for (si
= buckets
[hn
]; si
> 0; si
= chains
[si
])
11759 if (maxlength
< ++lengths
[hn
])
11761 if (si
>= nchains
|| visited
[si
])
11763 error (_("histogram chain is corrupt\n"));
11771 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
11772 if (counts
== NULL
)
11775 error (_("Out of memory allocating space for histogram counts\n"));
11779 for (hn
= 0; hn
< nbuckets
; ++hn
)
11780 ++counts
[lengths
[hn
]];
11785 printf (" 0 %-10lu (%5.1f%%)\n",
11786 counts
[0], (counts
[0] * 100.0) / nbuckets
);
11787 for (i
= 1; i
<= maxlength
; ++i
)
11789 nzero_counts
+= counts
[i
] * i
;
11790 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11791 i
, counts
[i
], (counts
[i
] * 100.0) / nbuckets
,
11792 (nzero_counts
* 100.0) / nsyms
);
11800 if (buckets
!= NULL
)
11806 if (do_histogram
&& gnubuckets
!= NULL
)
11808 unsigned long * lengths
;
11809 unsigned long * counts
;
11811 unsigned long maxlength
= 0;
11812 unsigned long nzero_counts
= 0;
11813 unsigned long nsyms
= 0;
11815 printf (ngettext ("\nHistogram for `.gnu.hash' bucket list length "
11816 "(total of %lu bucket):\n",
11817 "\nHistogram for `.gnu.hash' bucket list length "
11818 "(total of %lu buckets):\n",
11819 (unsigned long) ngnubuckets
),
11820 (unsigned long) ngnubuckets
);
11822 lengths
= (unsigned long *) calloc (ngnubuckets
, sizeof (*lengths
));
11823 if (lengths
== NULL
)
11825 error (_("Out of memory allocating space for gnu histogram buckets\n"));
11829 printf (_(" Length Number %% of total Coverage\n"));
11831 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11832 if (gnubuckets
[hn
] != 0)
11834 bfd_vma off
, length
= 1;
11836 for (off
= gnubuckets
[hn
] - gnusymidx
;
11837 /* PR 17531 file: 010-77222-0.004. */
11838 off
< ngnuchains
&& (gnuchains
[off
] & 1) == 0;
11841 lengths
[hn
] = length
;
11842 if (length
> maxlength
)
11843 maxlength
= length
;
11847 counts
= (unsigned long *) calloc (maxlength
+ 1, sizeof (*counts
));
11848 if (counts
== NULL
)
11851 error (_("Out of memory allocating space for gnu histogram counts\n"));
11855 for (hn
= 0; hn
< ngnubuckets
; ++hn
)
11856 ++counts
[lengths
[hn
]];
11858 if (ngnubuckets
> 0)
11861 printf (" 0 %-10lu (%5.1f%%)\n",
11862 counts
[0], (counts
[0] * 100.0) / ngnubuckets
);
11863 for (j
= 1; j
<= maxlength
; ++j
)
11865 nzero_counts
+= counts
[j
] * j
;
11866 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11867 j
, counts
[j
], (counts
[j
] * 100.0) / ngnubuckets
,
11868 (nzero_counts
* 100.0) / nsyms
);
11882 process_syminfo (Filedata
* filedata ATTRIBUTE_UNUSED
)
11886 if (dynamic_syminfo
== NULL
11888 /* No syminfo, this is ok. */
11891 /* There better should be a dynamic symbol section. */
11892 if (dynamic_symbols
== NULL
|| dynamic_strings
== NULL
)
11896 printf (ngettext ("\nDynamic info segment at offset 0x%lx "
11897 "contains %d entry:\n",
11898 "\nDynamic info segment at offset 0x%lx "
11899 "contains %d entries:\n",
11900 dynamic_syminfo_nent
),
11901 dynamic_syminfo_offset
, dynamic_syminfo_nent
);
11903 printf (_(" Num: Name BoundTo Flags\n"));
11904 for (i
= 0; i
< dynamic_syminfo_nent
; ++i
)
11906 unsigned short int flags
= dynamic_syminfo
[i
].si_flags
;
11908 printf ("%4d: ", i
);
11909 if (i
>= num_dynamic_syms
)
11910 printf (_("<corrupt index>"));
11911 else if (VALID_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
))
11912 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols
[i
].st_name
));
11914 printf (_("<corrupt: %19ld>"), dynamic_symbols
[i
].st_name
);
11917 switch (dynamic_syminfo
[i
].si_boundto
)
11919 case SYMINFO_BT_SELF
:
11920 fputs ("SELF ", stdout
);
11922 case SYMINFO_BT_PARENT
:
11923 fputs ("PARENT ", stdout
);
11926 if (dynamic_syminfo
[i
].si_boundto
> 0
11927 && dynamic_syminfo
[i
].si_boundto
< dynamic_nent
11928 && VALID_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
))
11930 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section
[dynamic_syminfo
[i
].si_boundto
].d_un
.d_val
));
11934 printf ("%-10d ", dynamic_syminfo
[i
].si_boundto
);
11938 if (flags
& SYMINFO_FLG_DIRECT
)
11939 printf (" DIRECT");
11940 if (flags
& SYMINFO_FLG_PASSTHRU
)
11941 printf (" PASSTHRU");
11942 if (flags
& SYMINFO_FLG_COPY
)
11944 if (flags
& SYMINFO_FLG_LAZYLOAD
)
11945 printf (" LAZYLOAD");
11953 #define IN_RANGE(START,END,ADDR,OFF) \
11954 (((ADDR) >= (START)) && ((ADDR) + (OFF) < (END)))
11956 /* Check to see if the given reloc needs to be handled in a target specific
11957 manner. If so then process the reloc and return TRUE otherwise return
11960 If called with reloc == NULL, then this is a signal that reloc processing
11961 for the current section has finished, and any saved state should be
11965 target_specific_reloc_handling (Filedata
* filedata
,
11966 Elf_Internal_Rela
* reloc
,
11967 unsigned char * start
,
11968 unsigned char * end
,
11969 Elf_Internal_Sym
* symtab
,
11970 unsigned long num_syms
)
11972 unsigned int reloc_type
= 0;
11973 unsigned long sym_index
= 0;
11977 reloc_type
= get_reloc_type (filedata
, reloc
->r_info
);
11978 sym_index
= get_reloc_symindex (reloc
->r_info
);
11981 switch (filedata
->file_header
.e_machine
)
11984 case EM_MSP430_OLD
:
11986 static Elf_Internal_Sym
* saved_sym
= NULL
;
11994 switch (reloc_type
)
11996 case 10: /* R_MSP430_SYM_DIFF */
11997 if (uses_msp430x_relocs (filedata
))
11999 /* Fall through. */
12000 case 21: /* R_MSP430X_SYM_DIFF */
12002 if (sym_index
>= num_syms
)
12003 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
12006 saved_sym
= symtab
+ sym_index
;
12009 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
12010 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
12011 goto handle_sym_diff
;
12013 case 5: /* R_MSP430_16_BYTE */
12014 case 9: /* R_MSP430_8 */
12015 if (uses_msp430x_relocs (filedata
))
12017 goto handle_sym_diff
;
12019 case 2: /* R_MSP430_ABS16 */
12020 case 15: /* R_MSP430X_ABS16 */
12021 if (! uses_msp430x_relocs (filedata
))
12023 goto handle_sym_diff
;
12026 if (saved_sym
!= NULL
)
12028 int reloc_size
= reloc_type
== 1 ? 4 : 2;
12031 if (sym_index
>= num_syms
)
12032 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
12036 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12037 - saved_sym
->st_value
);
12039 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12040 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12043 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
12044 (long) reloc
->r_offset
);
12053 if (saved_sym
!= NULL
)
12054 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
12061 case EM_CYGNUS_MN10300
:
12063 static Elf_Internal_Sym
* saved_sym
= NULL
;
12071 switch (reloc_type
)
12073 case 34: /* R_MN10300_ALIGN */
12075 case 33: /* R_MN10300_SYM_DIFF */
12076 if (sym_index
>= num_syms
)
12077 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
12080 saved_sym
= symtab
+ sym_index
;
12083 case 1: /* R_MN10300_32 */
12084 case 2: /* R_MN10300_16 */
12085 if (saved_sym
!= NULL
)
12087 int reloc_size
= reloc_type
== 1 ? 4 : 2;
12090 if (sym_index
>= num_syms
)
12091 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
12095 value
= reloc
->r_addend
+ (symtab
[sym_index
].st_value
12096 - saved_sym
->st_value
);
12098 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, reloc_size
))
12099 byte_put (start
+ reloc
->r_offset
, value
, reloc_size
);
12101 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
12102 (long) reloc
->r_offset
);
12110 if (saved_sym
!= NULL
)
12111 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
12119 static bfd_vma saved_sym1
= 0;
12120 static bfd_vma saved_sym2
= 0;
12121 static bfd_vma value
;
12125 saved_sym1
= saved_sym2
= 0;
12129 switch (reloc_type
)
12131 case 0x80: /* R_RL78_SYM. */
12132 saved_sym1
= saved_sym2
;
12133 if (sym_index
>= num_syms
)
12134 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
12138 saved_sym2
= symtab
[sym_index
].st_value
;
12139 saved_sym2
+= reloc
->r_addend
;
12143 case 0x83: /* R_RL78_OPsub. */
12144 value
= saved_sym1
- saved_sym2
;
12145 saved_sym2
= saved_sym1
= 0;
12149 case 0x41: /* R_RL78_ABS32. */
12150 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 4))
12151 byte_put (start
+ reloc
->r_offset
, value
, 4);
12153 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12154 (long) reloc
->r_offset
);
12158 case 0x43: /* R_RL78_ABS16. */
12159 if (IN_RANGE (start
, end
, start
+ reloc
->r_offset
, 2))
12160 byte_put (start
+ reloc
->r_offset
, value
, 2);
12162 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
12163 (long) reloc
->r_offset
);
12177 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
12178 DWARF debug sections. This is a target specific test. Note - we do not
12179 go through the whole including-target-headers-multiple-times route, (as
12180 we have already done with <elf/h8.h>) because this would become very
12181 messy and even then this function would have to contain target specific
12182 information (the names of the relocs instead of their numeric values).
12183 FIXME: This is not the correct way to solve this problem. The proper way
12184 is to have target specific reloc sizing and typing functions created by
12185 the reloc-macros.h header, in the same way that it already creates the
12186 reloc naming functions. */
12189 is_32bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12191 /* Please keep this table alpha-sorted for ease of visual lookup. */
12192 switch (filedata
->file_header
.e_machine
)
12196 return reloc_type
== 1; /* R_386_32. */
12198 return reloc_type
== 1; /* R_68K_32. */
12200 return reloc_type
== 1; /* R_860_32. */
12202 return reloc_type
== 2; /* R_960_32. */
12204 return (reloc_type
== 258
12205 || reloc_type
== 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
12206 case EM_ADAPTEVA_EPIPHANY
:
12207 return reloc_type
== 3;
12209 return reloc_type
== 1; /* R_ALPHA_REFLONG. */
12211 return reloc_type
== 1; /* R_ARC_32. */
12212 case EM_ARC_COMPACT
:
12213 case EM_ARC_COMPACT2
:
12214 return reloc_type
== 4; /* R_ARC_32. */
12216 return reloc_type
== 2; /* R_ARM_ABS32 */
12219 return reloc_type
== 1;
12221 return reloc_type
== 0x12; /* R_byte4_data. */
12223 return reloc_type
== 3; /* R_CRIS_32. */
12225 return reloc_type
== 3; /* R_CR16_NUM32. */
12227 return reloc_type
== 15; /* R_CRX_NUM32. */
12228 case EM_CYGNUS_FRV
:
12229 return reloc_type
== 1;
12230 case EM_CYGNUS_D10V
:
12232 return reloc_type
== 6; /* R_D10V_32. */
12233 case EM_CYGNUS_D30V
:
12235 return reloc_type
== 12; /* R_D30V_32_NORMAL. */
12237 return reloc_type
== 3; /* R_DLX_RELOC_32. */
12238 case EM_CYGNUS_FR30
:
12240 return reloc_type
== 3; /* R_FR30_32. */
12242 return reloc_type
== 1; /* R_FT32_32. */
12246 return reloc_type
== 1; /* R_H8_DIR32. */
12248 return (reloc_type
== 0x64 /* R_IA64_SECREL32MSB. */
12249 || reloc_type
== 0x65 /* R_IA64_SECREL32LSB. */
12250 || reloc_type
== 0x24 /* R_IA64_DIR32MSB. */
12251 || reloc_type
== 0x25 /* R_IA64_DIR32LSB. */);
12254 return reloc_type
== 2; /* R_IP2K_32. */
12256 return reloc_type
== 2; /* R_IQ2000_32. */
12257 case EM_LATTICEMICO32
:
12258 return reloc_type
== 3; /* R_LM32_32. */
12261 return reloc_type
== 3; /* R_M32C_32. */
12263 return reloc_type
== 34; /* R_M32R_32_RELA. */
12266 return reloc_type
== 6; /* R_M68HC11_32. */
12268 return reloc_type
== 1; /* R_MCORE_ADDR32. */
12269 case EM_CYGNUS_MEP
:
12270 return reloc_type
== 4; /* R_MEP_32. */
12272 return reloc_type
== 2; /* R_METAG_ADDR32. */
12273 case EM_MICROBLAZE
:
12274 return reloc_type
== 1; /* R_MICROBLAZE_32. */
12276 return reloc_type
== 2; /* R_MIPS_32. */
12278 return reloc_type
== 4; /* R_MMIX_32. */
12279 case EM_CYGNUS_MN10200
:
12281 return reloc_type
== 1; /* R_MN10200_32. */
12282 case EM_CYGNUS_MN10300
:
12284 return reloc_type
== 1; /* R_MN10300_32. */
12286 return reloc_type
== 1; /* R_MOXIE_32. */
12287 case EM_MSP430_OLD
:
12289 return reloc_type
== 1; /* R_MSP430_32 or R_MSP320_ABS32. */
12291 return reloc_type
== 2; /* R_MT_32. */
12293 return reloc_type
== 20; /* R_NDS32_RELA. */
12294 case EM_ALTERA_NIOS2
:
12295 return reloc_type
== 12; /* R_NIOS2_BFD_RELOC_32. */
12297 return reloc_type
== 1; /* R_NIOS_32. */
12299 return reloc_type
== 1; /* R_OR1K_32. */
12301 return (reloc_type
== 1 /* R_PARISC_DIR32. */
12302 || reloc_type
== 41); /* R_PARISC_SECREL32. */
12305 return reloc_type
== 1; /* R_PJ_DATA_DIR32. */
12307 return reloc_type
== 1; /* R_PPC64_ADDR32. */
12309 return reloc_type
== 1; /* R_PPC_ADDR32. */
12311 return reloc_type
== 11; /* R_PRU_BFD_RELOC_32. */
12313 return reloc_type
== 1; /* R_RISCV_32. */
12315 return reloc_type
== 1; /* R_RL78_DIR32. */
12317 return reloc_type
== 1; /* R_RX_DIR32. */
12319 return reloc_type
== 1; /* R_I370_ADDR31. */
12322 return reloc_type
== 4; /* R_S390_32. */
12324 return reloc_type
== 8; /* R_SCORE_ABS32. */
12326 return reloc_type
== 1; /* R_SH_DIR32. */
12327 case EM_SPARC32PLUS
:
12330 return reloc_type
== 3 /* R_SPARC_32. */
12331 || reloc_type
== 23; /* R_SPARC_UA32. */
12333 return reloc_type
== 6; /* R_SPU_ADDR32 */
12335 return reloc_type
== 1; /* R_C6000_ABS32. */
12337 return reloc_type
== 2; /* R_TILEGX_32. */
12339 return reloc_type
== 1; /* R_TILEPRO_32. */
12340 case EM_CYGNUS_V850
:
12342 return reloc_type
== 6; /* R_V850_ABS32. */
12344 return reloc_type
== 0x33; /* R_V810_WORD. */
12346 return reloc_type
== 1; /* R_VAX_32. */
12348 return reloc_type
== 3; /* R_VISIUM_32. */
12349 case EM_WEBASSEMBLY
:
12350 return reloc_type
== 1; /* R_WASM32_32. */
12354 return reloc_type
== 10; /* R_X86_64_32. */
12357 return reloc_type
== 3; /* R_XC16C_ABS_32. */
12359 return reloc_type
== 4; /* R_XGATE_32. */
12361 return reloc_type
== 1; /* R_XSTROMY16_32. */
12362 case EM_XTENSA_OLD
:
12364 return reloc_type
== 1; /* R_XTENSA_32. */
12367 static unsigned int prev_warn
= 0;
12369 /* Avoid repeating the same warning multiple times. */
12370 if (prev_warn
!= filedata
->file_header
.e_machine
)
12371 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12372 filedata
->file_header
.e_machine
);
12373 prev_warn
= filedata
->file_header
.e_machine
;
12379 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12380 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
12383 is_32bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12385 switch (filedata
->file_header
.e_machine
)
12386 /* Please keep this table alpha-sorted for ease of visual lookup. */
12390 return reloc_type
== 2; /* R_386_PC32. */
12392 return reloc_type
== 4; /* R_68K_PC32. */
12394 return reloc_type
== 261; /* R_AARCH64_PREL32 */
12395 case EM_ADAPTEVA_EPIPHANY
:
12396 return reloc_type
== 6;
12398 return reloc_type
== 10; /* R_ALPHA_SREL32. */
12399 case EM_ARC_COMPACT
:
12400 case EM_ARC_COMPACT2
:
12401 return reloc_type
== 49; /* R_ARC_32_PCREL. */
12403 return reloc_type
== 3; /* R_ARM_REL32 */
12406 return reloc_type
== 36; /* R_AVR_32_PCREL. */
12407 case EM_MICROBLAZE
:
12408 return reloc_type
== 2; /* R_MICROBLAZE_32_PCREL. */
12410 return reloc_type
== 9; /* R_OR1K_32_PCREL. */
12412 return reloc_type
== 9; /* R_PARISC_PCREL32. */
12414 return reloc_type
== 26; /* R_PPC_REL32. */
12416 return reloc_type
== 26; /* R_PPC64_REL32. */
12419 return reloc_type
== 5; /* R_390_PC32. */
12421 return reloc_type
== 2; /* R_SH_REL32. */
12422 case EM_SPARC32PLUS
:
12425 return reloc_type
== 6; /* R_SPARC_DISP32. */
12427 return reloc_type
== 13; /* R_SPU_REL32. */
12429 return reloc_type
== 6; /* R_TILEGX_32_PCREL. */
12431 return reloc_type
== 4; /* R_TILEPRO_32_PCREL. */
12433 return reloc_type
== 6; /* R_VISIUM_32_PCREL */
12437 return reloc_type
== 2; /* R_X86_64_PC32. */
12438 case EM_XTENSA_OLD
:
12440 return reloc_type
== 14; /* R_XTENSA_32_PCREL. */
12442 /* Do not abort or issue an error message here. Not all targets use
12443 pc-relative 32-bit relocs in their DWARF debug information and we
12444 have already tested for target coverage in is_32bit_abs_reloc. A
12445 more helpful warning message will be generated by apply_relocations
12446 anyway, so just return. */
12451 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12452 a 64-bit absolute RELA relocation used in DWARF debug sections. */
12455 is_64bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12457 switch (filedata
->file_header
.e_machine
)
12460 return reloc_type
== 257; /* R_AARCH64_ABS64. */
12462 return reloc_type
== 2; /* R_ALPHA_REFQUAD. */
12464 return (reloc_type
== 0x26 /* R_IA64_DIR64MSB. */
12465 || reloc_type
== 0x27 /* R_IA64_DIR64LSB. */);
12467 return reloc_type
== 80; /* R_PARISC_DIR64. */
12469 return reloc_type
== 38; /* R_PPC64_ADDR64. */
12471 return reloc_type
== 2; /* R_RISCV_64. */
12472 case EM_SPARC32PLUS
:
12475 return reloc_type
== 32 /* R_SPARC_64. */
12476 || reloc_type
== 54; /* R_SPARC_UA64. */
12480 return reloc_type
== 1; /* R_X86_64_64. */
12483 return reloc_type
== 22; /* R_S390_64. */
12485 return reloc_type
== 1; /* R_TILEGX_64. */
12487 return reloc_type
== 18; /* R_MIPS_64. */
12493 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12494 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
12497 is_64bit_pcrel_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12499 switch (filedata
->file_header
.e_machine
)
12502 return reloc_type
== 260; /* R_AARCH64_PREL64. */
12504 return reloc_type
== 11; /* R_ALPHA_SREL64. */
12506 return (reloc_type
== 0x4e /* R_IA64_PCREL64MSB. */
12507 || reloc_type
== 0x4f /* R_IA64_PCREL64LSB. */);
12509 return reloc_type
== 72; /* R_PARISC_PCREL64. */
12511 return reloc_type
== 44; /* R_PPC64_REL64. */
12512 case EM_SPARC32PLUS
:
12515 return reloc_type
== 46; /* R_SPARC_DISP64. */
12519 return reloc_type
== 24; /* R_X86_64_PC64. */
12522 return reloc_type
== 23; /* R_S390_PC64. */
12524 return reloc_type
== 5; /* R_TILEGX_64_PCREL. */
12530 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12531 a 24-bit absolute RELA relocation used in DWARF debug sections. */
12534 is_24bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12536 switch (filedata
->file_header
.e_machine
)
12538 case EM_CYGNUS_MN10200
:
12540 return reloc_type
== 4; /* R_MN10200_24. */
12542 return reloc_type
== 5; /* R_FT32_20. */
12548 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12549 a 16-bit absolute RELA relocation used in DWARF debug sections. */
12552 is_16bit_abs_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12554 /* Please keep this table alpha-sorted for ease of visual lookup. */
12555 switch (filedata
->file_header
.e_machine
)
12558 case EM_ARC_COMPACT
:
12559 case EM_ARC_COMPACT2
:
12560 return reloc_type
== 2; /* R_ARC_16. */
12561 case EM_ADAPTEVA_EPIPHANY
:
12562 return reloc_type
== 5;
12565 return reloc_type
== 4; /* R_AVR_16. */
12566 case EM_CYGNUS_D10V
:
12568 return reloc_type
== 3; /* R_D10V_16. */
12570 return reloc_type
== 2; /* R_FT32_16. */
12574 return reloc_type
== R_H8_DIR16
;
12577 return reloc_type
== 1; /* R_IP2K_16. */
12580 return reloc_type
== 1; /* R_M32C_16 */
12581 case EM_CYGNUS_MN10200
:
12583 return reloc_type
== 2; /* R_MN10200_16. */
12584 case EM_CYGNUS_MN10300
:
12586 return reloc_type
== 2; /* R_MN10300_16. */
12588 if (uses_msp430x_relocs (filedata
))
12589 return reloc_type
== 2; /* R_MSP430_ABS16. */
12590 /* Fall through. */
12591 case EM_MSP430_OLD
:
12592 return reloc_type
== 5; /* R_MSP430_16_BYTE. */
12594 return reloc_type
== 19; /* R_NDS32_RELA. */
12595 case EM_ALTERA_NIOS2
:
12596 return reloc_type
== 13; /* R_NIOS2_BFD_RELOC_16. */
12598 return reloc_type
== 9; /* R_NIOS_16. */
12600 return reloc_type
== 2; /* R_OR1K_16. */
12602 return reloc_type
== 8; /* R_PRU_BFD_RELOC_16. */
12604 return reloc_type
== 2; /* R_C6000_ABS16. */
12606 return reloc_type
== 2; /* R_VISIUM_16. */
12609 return reloc_type
== 2; /* R_XC16C_ABS_16. */
12611 return reloc_type
== 3; /* R_XGATE_16. */
12617 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12618 a 32-bit inplace add RELA relocation used in DWARF debug sections. */
12621 is_32bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12623 /* Please keep this table alpha-sorted for ease of visual lookup. */
12624 switch (filedata
->file_header
.e_machine
)
12627 return reloc_type
== 35; /* R_RISCV_ADD32. */
12633 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12634 a 32-bit inplace sub RELA relocation used in DWARF debug sections. */
12637 is_32bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12639 /* Please keep this table alpha-sorted for ease of visual lookup. */
12640 switch (filedata
->file_header
.e_machine
)
12643 return reloc_type
== 39; /* R_RISCV_SUB32. */
12649 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12650 a 64-bit inplace add RELA relocation used in DWARF debug sections. */
12653 is_64bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12655 /* Please keep this table alpha-sorted for ease of visual lookup. */
12656 switch (filedata
->file_header
.e_machine
)
12659 return reloc_type
== 36; /* R_RISCV_ADD64. */
12665 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12666 a 64-bit inplace sub RELA relocation used in DWARF debug sections. */
12669 is_64bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12671 /* Please keep this table alpha-sorted for ease of visual lookup. */
12672 switch (filedata
->file_header
.e_machine
)
12675 return reloc_type
== 40; /* R_RISCV_SUB64. */
12681 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12682 a 16-bit inplace add RELA relocation used in DWARF debug sections. */
12685 is_16bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12687 /* Please keep this table alpha-sorted for ease of visual lookup. */
12688 switch (filedata
->file_header
.e_machine
)
12691 return reloc_type
== 34; /* R_RISCV_ADD16. */
12697 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12698 a 16-bit inplace sub RELA relocation used in DWARF debug sections. */
12701 is_16bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12703 /* Please keep this table alpha-sorted for ease of visual lookup. */
12704 switch (filedata
->file_header
.e_machine
)
12707 return reloc_type
== 38; /* R_RISCV_SUB16. */
12713 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12714 a 8-bit inplace add RELA relocation used in DWARF debug sections. */
12717 is_8bit_inplace_add_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12719 /* Please keep this table alpha-sorted for ease of visual lookup. */
12720 switch (filedata
->file_header
.e_machine
)
12723 return reloc_type
== 33; /* R_RISCV_ADD8. */
12729 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12730 a 8-bit inplace sub RELA relocation used in DWARF debug sections. */
12733 is_8bit_inplace_sub_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12735 /* Please keep this table alpha-sorted for ease of visual lookup. */
12736 switch (filedata
->file_header
.e_machine
)
12739 return reloc_type
== 37; /* R_RISCV_SUB8. */
12745 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
12746 relocation entries (possibly formerly used for SHT_GROUP sections). */
12749 is_none_reloc (Filedata
* filedata
, unsigned int reloc_type
)
12751 switch (filedata
->file_header
.e_machine
)
12753 case EM_386
: /* R_386_NONE. */
12754 case EM_68K
: /* R_68K_NONE. */
12755 case EM_ADAPTEVA_EPIPHANY
:
12756 case EM_ALPHA
: /* R_ALPHA_NONE. */
12757 case EM_ALTERA_NIOS2
: /* R_NIOS2_NONE. */
12758 case EM_ARC
: /* R_ARC_NONE. */
12759 case EM_ARC_COMPACT2
: /* R_ARC_NONE. */
12760 case EM_ARC_COMPACT
: /* R_ARC_NONE. */
12761 case EM_ARM
: /* R_ARM_NONE. */
12762 case EM_C166
: /* R_XC16X_NONE. */
12763 case EM_CRIS
: /* R_CRIS_NONE. */
12764 case EM_FT32
: /* R_FT32_NONE. */
12765 case EM_IA_64
: /* R_IA64_NONE. */
12766 case EM_K1OM
: /* R_X86_64_NONE. */
12767 case EM_L1OM
: /* R_X86_64_NONE. */
12768 case EM_M32R
: /* R_M32R_NONE. */
12769 case EM_MIPS
: /* R_MIPS_NONE. */
12770 case EM_MN10300
: /* R_MN10300_NONE. */
12771 case EM_MOXIE
: /* R_MOXIE_NONE. */
12772 case EM_NIOS32
: /* R_NIOS_NONE. */
12773 case EM_OR1K
: /* R_OR1K_NONE. */
12774 case EM_PARISC
: /* R_PARISC_NONE. */
12775 case EM_PPC64
: /* R_PPC64_NONE. */
12776 case EM_PPC
: /* R_PPC_NONE. */
12777 case EM_RISCV
: /* R_RISCV_NONE. */
12778 case EM_S390
: /* R_390_NONE. */
12780 case EM_SH
: /* R_SH_NONE. */
12781 case EM_SPARC32PLUS
:
12782 case EM_SPARC
: /* R_SPARC_NONE. */
12784 case EM_TILEGX
: /* R_TILEGX_NONE. */
12785 case EM_TILEPRO
: /* R_TILEPRO_NONE. */
12786 case EM_TI_C6000
:/* R_C6000_NONE. */
12787 case EM_X86_64
: /* R_X86_64_NONE. */
12789 case EM_WEBASSEMBLY
: /* R_WASM32_NONE. */
12790 return reloc_type
== 0;
12793 return reloc_type
== 0 || reloc_type
== 256;
12796 return (reloc_type
== 0 /* R_AVR_NONE. */
12797 || reloc_type
== 30 /* R_AVR_DIFF8. */
12798 || reloc_type
== 31 /* R_AVR_DIFF16. */
12799 || reloc_type
== 32 /* R_AVR_DIFF32. */);
12801 return reloc_type
== 3; /* R_METAG_NONE. */
12803 return (reloc_type
== 0 /* R_XTENSA_NONE. */
12804 || reloc_type
== 204 /* R_NDS32_DIFF8. */
12805 || reloc_type
== 205 /* R_NDS32_DIFF16. */
12806 || reloc_type
== 206 /* R_NDS32_DIFF32. */
12807 || reloc_type
== 207 /* R_NDS32_ULEB128. */);
12809 return (reloc_type
== 0 /* R_PRU_NONE. */
12810 || reloc_type
== 65 /* R_PRU_DIFF8. */
12811 || reloc_type
== 66 /* R_PRU_DIFF16. */
12812 || reloc_type
== 67 /* R_PRU_DIFF32. */);
12813 case EM_XTENSA_OLD
:
12815 return (reloc_type
== 0 /* R_XTENSA_NONE. */
12816 || reloc_type
== 17 /* R_XTENSA_DIFF8. */
12817 || reloc_type
== 18 /* R_XTENSA_DIFF16. */
12818 || reloc_type
== 19 /* R_XTENSA_DIFF32. */);
12823 /* Returns TRUE if there is a relocation against
12824 section NAME at OFFSET bytes. */
12827 reloc_at (struct dwarf_section
* dsec
, dwarf_vma offset
)
12829 Elf_Internal_Rela
* relocs
;
12830 Elf_Internal_Rela
* rp
;
12832 if (dsec
== NULL
|| dsec
->reloc_info
== NULL
)
12835 relocs
= (Elf_Internal_Rela
*) dsec
->reloc_info
;
12837 for (rp
= relocs
; rp
< relocs
+ dsec
->num_relocs
; ++rp
)
12838 if (rp
->r_offset
== offset
)
12844 /* Apply relocations to a section.
12845 Returns TRUE upon success, FALSE otherwise.
12846 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
12847 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
12848 will be set to the number of relocs loaded.
12850 Note: So far support has been added only for those relocations
12851 which can be found in debug sections. FIXME: Add support for
12852 more relocations ? */
12855 apply_relocations (Filedata
* filedata
,
12856 const Elf_Internal_Shdr
* section
,
12857 unsigned char * start
,
12858 bfd_size_type size
,
12859 void ** relocs_return
,
12860 unsigned long * num_relocs_return
)
12862 Elf_Internal_Shdr
* relsec
;
12863 unsigned char * end
= start
+ size
;
12864 bfd_boolean res
= TRUE
;
12866 if (relocs_return
!= NULL
)
12868 * (Elf_Internal_Rela
**) relocs_return
= NULL
;
12869 * num_relocs_return
= 0;
12872 if (filedata
->file_header
.e_type
!= ET_REL
)
12873 /* No relocs to apply. */
12876 /* Find the reloc section associated with the section. */
12877 for (relsec
= filedata
->section_headers
;
12878 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
12881 bfd_boolean is_rela
;
12882 unsigned long num_relocs
;
12883 Elf_Internal_Rela
* relocs
;
12884 Elf_Internal_Rela
* rp
;
12885 Elf_Internal_Shdr
* symsec
;
12886 Elf_Internal_Sym
* symtab
;
12887 unsigned long num_syms
;
12888 Elf_Internal_Sym
* sym
;
12890 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
12891 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
12892 || filedata
->section_headers
+ relsec
->sh_info
!= section
12893 || relsec
->sh_size
== 0
12894 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
12897 is_rela
= relsec
->sh_type
== SHT_RELA
;
12901 if (!slurp_rela_relocs (filedata
, relsec
->sh_offset
,
12902 relsec
->sh_size
, & relocs
, & num_relocs
))
12907 if (!slurp_rel_relocs (filedata
, relsec
->sh_offset
,
12908 relsec
->sh_size
, & relocs
, & num_relocs
))
12912 /* SH uses RELA but uses in place value instead of the addend field. */
12913 if (filedata
->file_header
.e_machine
== EM_SH
)
12916 symsec
= filedata
->section_headers
+ relsec
->sh_link
;
12917 if (symsec
->sh_type
!= SHT_SYMTAB
12918 && symsec
->sh_type
!= SHT_DYNSYM
)
12920 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & num_syms
);
12922 for (rp
= relocs
; rp
< relocs
+ num_relocs
; ++rp
)
12925 unsigned int reloc_type
;
12926 unsigned int reloc_size
;
12927 bfd_boolean reloc_inplace
= FALSE
;
12928 bfd_boolean reloc_subtract
= FALSE
;
12929 unsigned char * rloc
;
12930 unsigned long sym_index
;
12932 reloc_type
= get_reloc_type (filedata
, rp
->r_info
);
12934 if (target_specific_reloc_handling (filedata
, rp
, start
, end
, symtab
, num_syms
))
12936 else if (is_none_reloc (filedata
, reloc_type
))
12938 else if (is_32bit_abs_reloc (filedata
, reloc_type
)
12939 || is_32bit_pcrel_reloc (filedata
, reloc_type
))
12941 else if (is_64bit_abs_reloc (filedata
, reloc_type
)
12942 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
12944 else if (is_24bit_abs_reloc (filedata
, reloc_type
))
12946 else if (is_16bit_abs_reloc (filedata
, reloc_type
))
12948 else if ((reloc_subtract
= is_32bit_inplace_sub_reloc (filedata
,
12950 || is_32bit_inplace_add_reloc (filedata
, reloc_type
))
12953 reloc_inplace
= TRUE
;
12955 else if ((reloc_subtract
= is_64bit_inplace_sub_reloc (filedata
,
12957 || is_64bit_inplace_add_reloc (filedata
, reloc_type
))
12960 reloc_inplace
= TRUE
;
12962 else if ((reloc_subtract
= is_16bit_inplace_sub_reloc (filedata
,
12964 || is_16bit_inplace_add_reloc (filedata
, reloc_type
))
12967 reloc_inplace
= TRUE
;
12969 else if ((reloc_subtract
= is_8bit_inplace_sub_reloc (filedata
,
12971 || is_8bit_inplace_add_reloc (filedata
, reloc_type
))
12974 reloc_inplace
= TRUE
;
12978 static unsigned int prev_reloc
= 0;
12980 if (reloc_type
!= prev_reloc
)
12981 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
12982 reloc_type
, printable_section_name (filedata
, section
));
12983 prev_reloc
= reloc_type
;
12988 rloc
= start
+ rp
->r_offset
;
12989 if ((rloc
+ reloc_size
) > end
|| (rloc
< start
))
12991 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
12992 (unsigned long) rp
->r_offset
,
12993 printable_section_name (filedata
, section
));
12998 sym_index
= (unsigned long) get_reloc_symindex (rp
->r_info
);
12999 if (sym_index
>= num_syms
)
13001 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
13002 sym_index
, printable_section_name (filedata
, section
));
13006 sym
= symtab
+ sym_index
;
13008 /* If the reloc has a symbol associated with it,
13009 make sure that it is of an appropriate type.
13011 Relocations against symbols without type can happen.
13012 Gcc -feliminate-dwarf2-dups may generate symbols
13013 without type for debug info.
13015 Icc generates relocations against function symbols
13016 instead of local labels.
13018 Relocations against object symbols can happen, eg when
13019 referencing a global array. For an example of this see
13020 the _clz.o binary in libgcc.a. */
13022 && ELF_ST_TYPE (sym
->st_info
) != STT_COMMON
13023 && ELF_ST_TYPE (sym
->st_info
) > STT_SECTION
)
13025 warn (_("skipping unexpected symbol type %s in section %s relocation %ld\n"),
13026 get_symbol_type (filedata
, ELF_ST_TYPE (sym
->st_info
)),
13027 printable_section_name (filedata
, relsec
),
13028 (long int)(rp
- relocs
));
13035 addend
+= rp
->r_addend
;
13036 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
13037 partial_inplace. */
13039 || (filedata
->file_header
.e_machine
== EM_XTENSA
13040 && reloc_type
== 1)
13041 || ((filedata
->file_header
.e_machine
== EM_PJ
13042 || filedata
->file_header
.e_machine
== EM_PJ_OLD
)
13043 && reloc_type
== 1)
13044 || ((filedata
->file_header
.e_machine
== EM_D30V
13045 || filedata
->file_header
.e_machine
== EM_CYGNUS_D30V
)
13046 && reloc_type
== 12)
13048 addend
+= byte_get (rloc
, reloc_size
);
13050 if (is_32bit_pcrel_reloc (filedata
, reloc_type
)
13051 || is_64bit_pcrel_reloc (filedata
, reloc_type
))
13053 /* On HPPA, all pc-relative relocations are biased by 8. */
13054 if (filedata
->file_header
.e_machine
== EM_PARISC
)
13056 byte_put (rloc
, (addend
+ sym
->st_value
) - rp
->r_offset
,
13059 else if (reloc_subtract
)
13060 byte_put (rloc
, addend
- sym
->st_value
, reloc_size
);
13062 byte_put (rloc
, addend
+ sym
->st_value
, reloc_size
);
13066 /* Let the target specific reloc processing code know that
13067 we have finished with these relocs. */
13068 target_specific_reloc_handling (filedata
, NULL
, NULL
, NULL
, NULL
, 0);
13072 * (Elf_Internal_Rela
**) relocs_return
= relocs
;
13073 * num_relocs_return
= num_relocs
;
13084 #ifdef SUPPORT_DISASSEMBLY
13086 disassemble_section (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13088 printf (_("\nAssembly dump of section %s\n"), printable_section_name (filedata
, section
));
13090 /* FIXME: XXX -- to be done --- XXX */
13096 /* Reads in the contents of SECTION from FILE, returning a pointer
13097 to a malloc'ed buffer or NULL if something went wrong. */
13100 get_section_contents (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13102 bfd_size_type num_bytes
= section
->sh_size
;
13104 if (num_bytes
== 0 || section
->sh_type
== SHT_NOBITS
)
13106 printf (_("Section '%s' has no data to dump.\n"),
13107 printable_section_name (filedata
, section
));
13111 return (char *) get_data (NULL
, filedata
, section
->sh_offset
, 1, num_bytes
,
13112 _("section contents"));
13115 /* Uncompresses a section that was compressed using zlib, in place. */
13118 uncompress_section_contents (unsigned char ** buffer
,
13119 dwarf_size_type uncompressed_size
,
13120 dwarf_size_type
* size
)
13122 dwarf_size_type compressed_size
= *size
;
13123 unsigned char * compressed_buffer
= *buffer
;
13124 unsigned char * uncompressed_buffer
;
13128 /* It is possible the section consists of several compressed
13129 buffers concatenated together, so we uncompress in a loop. */
13130 /* PR 18313: The state field in the z_stream structure is supposed
13131 to be invisible to the user (ie us), but some compilers will
13132 still complain about it being used without initialisation. So
13133 we first zero the entire z_stream structure and then set the fields
13135 memset (& strm
, 0, sizeof strm
);
13136 strm
.avail_in
= compressed_size
;
13137 strm
.next_in
= (Bytef
*) compressed_buffer
;
13138 strm
.avail_out
= uncompressed_size
;
13139 uncompressed_buffer
= (unsigned char *) xmalloc (uncompressed_size
);
13141 rc
= inflateInit (& strm
);
13142 while (strm
.avail_in
> 0)
13146 strm
.next_out
= ((Bytef
*) uncompressed_buffer
13147 + (uncompressed_size
- strm
.avail_out
));
13148 rc
= inflate (&strm
, Z_FINISH
);
13149 if (rc
!= Z_STREAM_END
)
13151 rc
= inflateReset (& strm
);
13153 rc
= inflateEnd (& strm
);
13155 || strm
.avail_out
!= 0)
13158 *buffer
= uncompressed_buffer
;
13159 *size
= uncompressed_size
;
13163 free (uncompressed_buffer
);
13164 /* Indicate decompression failure. */
13170 dump_section_as_strings (Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13172 Elf_Internal_Shdr
* relsec
;
13173 bfd_size_type num_bytes
;
13174 unsigned char * data
;
13175 unsigned char * end
;
13176 unsigned char * real_start
;
13177 unsigned char * start
;
13178 bfd_boolean some_strings_shown
;
13180 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
13182 /* PR 21820: Do not fail if the section was empty. */
13183 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
13185 num_bytes
= section
->sh_size
;
13187 printf (_("\nString dump of section '%s':\n"), printable_section_name (filedata
, section
));
13189 if (decompress_dumps
)
13191 dwarf_size_type new_size
= num_bytes
;
13192 dwarf_size_type uncompressed_size
= 0;
13194 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
13196 Elf_Internal_Chdr chdr
;
13197 unsigned int compression_header_size
13198 = get_compression_header (& chdr
, (unsigned char *) start
,
13201 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13203 warn (_("section '%s' has unsupported compress type: %d\n"),
13204 printable_section_name (filedata
, section
), chdr
.ch_type
);
13207 else if (chdr
.ch_addralign
!= section
->sh_addralign
)
13209 warn (_("compressed section '%s' is corrupted\n"),
13210 printable_section_name (filedata
, section
));
13213 uncompressed_size
= chdr
.ch_size
;
13214 start
+= compression_header_size
;
13215 new_size
-= compression_header_size
;
13217 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
13219 /* Read the zlib header. In this case, it should be "ZLIB"
13220 followed by the uncompressed section size, 8 bytes in
13221 big-endian order. */
13222 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13223 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13224 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13225 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13226 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13227 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13228 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13229 uncompressed_size
+= start
[11];
13234 if (uncompressed_size
)
13236 if (uncompress_section_contents (& start
,
13237 uncompressed_size
, & new_size
))
13238 num_bytes
= new_size
;
13241 error (_("Unable to decompress section %s\n"),
13242 printable_section_name (filedata
, section
));
13247 start
= real_start
;
13250 /* If the section being dumped has relocations against it the user might
13251 be expecting these relocations to have been applied. Check for this
13252 case and issue a warning message in order to avoid confusion.
13253 FIXME: Maybe we ought to have an option that dumps a section with
13254 relocs applied ? */
13255 for (relsec
= filedata
->section_headers
;
13256 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13259 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13260 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13261 || filedata
->section_headers
+ relsec
->sh_info
!= section
13262 || relsec
->sh_size
== 0
13263 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13266 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13271 end
= start
+ num_bytes
;
13272 some_strings_shown
= FALSE
;
13276 while (!ISPRINT (* data
))
13277 if (++ data
>= end
)
13282 size_t maxlen
= end
- data
;
13285 /* PR 11128: Use two separate invocations in order to work
13286 around bugs in the Solaris 8 implementation of printf. */
13287 printf (" [%6tx] ", data
- start
);
13289 printf (" [%6Ix] ", (size_t) (data
- start
));
13293 print_symbol ((int) maxlen
, (const char *) data
);
13295 data
+= strnlen ((const char *) data
, maxlen
);
13299 printf (_("<corrupt>\n"));
13302 some_strings_shown
= TRUE
;
13306 if (! some_strings_shown
)
13307 printf (_(" No strings found in this section."));
13316 dump_section_as_bytes (Elf_Internal_Shdr
* section
,
13317 Filedata
* filedata
,
13318 bfd_boolean relocate
)
13320 Elf_Internal_Shdr
* relsec
;
13321 bfd_size_type bytes
;
13322 bfd_size_type section_size
;
13324 unsigned char * data
;
13325 unsigned char * real_start
;
13326 unsigned char * start
;
13328 real_start
= start
= (unsigned char *) get_section_contents (section
, filedata
);
13330 /* PR 21820: Do not fail if the section was empty. */
13331 return (section
->sh_size
== 0 || section
->sh_type
== SHT_NOBITS
) ? TRUE
: FALSE
;
13333 section_size
= section
->sh_size
;
13335 printf (_("\nHex dump of section '%s':\n"), printable_section_name (filedata
, section
));
13337 if (decompress_dumps
)
13339 dwarf_size_type new_size
= section_size
;
13340 dwarf_size_type uncompressed_size
= 0;
13342 if ((section
->sh_flags
& SHF_COMPRESSED
) != 0)
13344 Elf_Internal_Chdr chdr
;
13345 unsigned int compression_header_size
13346 = get_compression_header (& chdr
, start
, section_size
);
13348 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13350 warn (_("section '%s' has unsupported compress type: %d\n"),
13351 printable_section_name (filedata
, section
), chdr
.ch_type
);
13354 else if (chdr
.ch_addralign
!= section
->sh_addralign
)
13356 warn (_("compressed section '%s' is corrupted\n"),
13357 printable_section_name (filedata
, section
));
13360 uncompressed_size
= chdr
.ch_size
;
13361 start
+= compression_header_size
;
13362 new_size
-= compression_header_size
;
13364 else if (new_size
> 12 && streq ((char *) start
, "ZLIB"))
13366 /* Read the zlib header. In this case, it should be "ZLIB"
13367 followed by the uncompressed section size, 8 bytes in
13368 big-endian order. */
13369 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13370 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13371 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13372 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13373 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13374 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13375 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13376 uncompressed_size
+= start
[11];
13381 if (uncompressed_size
)
13383 if (uncompress_section_contents (& start
, uncompressed_size
,
13386 section_size
= new_size
;
13390 error (_("Unable to decompress section %s\n"),
13391 printable_section_name (filedata
, section
));
13392 /* FIXME: Print the section anyway ? */
13397 start
= real_start
;
13402 if (! apply_relocations (filedata
, section
, start
, section_size
, NULL
, NULL
))
13407 /* If the section being dumped has relocations against it the user might
13408 be expecting these relocations to have been applied. Check for this
13409 case and issue a warning message in order to avoid confusion.
13410 FIXME: Maybe we ought to have an option that dumps a section with
13411 relocs applied ? */
13412 for (relsec
= filedata
->section_headers
;
13413 relsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
13416 if ((relsec
->sh_type
!= SHT_RELA
&& relsec
->sh_type
!= SHT_REL
)
13417 || relsec
->sh_info
>= filedata
->file_header
.e_shnum
13418 || filedata
->section_headers
+ relsec
->sh_info
!= section
13419 || relsec
->sh_size
== 0
13420 || relsec
->sh_link
>= filedata
->file_header
.e_shnum
)
13423 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
13428 addr
= section
->sh_addr
;
13429 bytes
= section_size
;
13438 lbytes
= (bytes
> 16 ? 16 : bytes
);
13440 printf (" 0x%8.8lx ", (unsigned long) addr
);
13442 for (j
= 0; j
< 16; j
++)
13445 printf ("%2.2x", data
[j
]);
13453 for (j
= 0; j
< lbytes
; j
++)
13456 if (k
>= ' ' && k
< 0x7f)
13476 load_specific_debug_section (enum dwarf_section_display_enum debug
,
13477 const Elf_Internal_Shdr
* sec
,
13480 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13482 Filedata
* filedata
= (Filedata
*) data
;
13484 if (section
->start
!= NULL
)
13486 /* If it is already loaded, do nothing. */
13487 if (streq (section
->filename
, filedata
->file_name
))
13489 free (section
->start
);
13492 snprintf (buf
, sizeof (buf
), _("%s section data"), section
->name
);
13493 section
->address
= sec
->sh_addr
;
13494 section
->user_data
= NULL
;
13495 section
->filename
= filedata
->file_name
;
13496 section
->start
= (unsigned char *) get_data (NULL
, filedata
,
13498 sec
->sh_size
, buf
);
13499 if (section
->start
== NULL
)
13503 unsigned char *start
= section
->start
;
13504 dwarf_size_type size
= sec
->sh_size
;
13505 dwarf_size_type uncompressed_size
= 0;
13507 if ((sec
->sh_flags
& SHF_COMPRESSED
) != 0)
13509 Elf_Internal_Chdr chdr
;
13510 unsigned int compression_header_size
;
13512 if (size
< (is_32bit_elf
13513 ? sizeof (Elf32_External_Chdr
)
13514 : sizeof (Elf64_External_Chdr
)))
13516 warn (_("compressed section %s is too small to contain a compression header"),
13521 compression_header_size
= get_compression_header (&chdr
, start
, size
);
13523 if (chdr
.ch_type
!= ELFCOMPRESS_ZLIB
)
13525 warn (_("section '%s' has unsupported compress type: %d\n"),
13526 section
->name
, chdr
.ch_type
);
13529 else if (chdr
.ch_addralign
!= sec
->sh_addralign
)
13531 warn (_("compressed section '%s' is corrupted\n"),
13535 uncompressed_size
= chdr
.ch_size
;
13536 start
+= compression_header_size
;
13537 size
-= compression_header_size
;
13539 else if (size
> 12 && streq ((char *) start
, "ZLIB"))
13541 /* Read the zlib header. In this case, it should be "ZLIB"
13542 followed by the uncompressed section size, 8 bytes in
13543 big-endian order. */
13544 uncompressed_size
= start
[4]; uncompressed_size
<<= 8;
13545 uncompressed_size
+= start
[5]; uncompressed_size
<<= 8;
13546 uncompressed_size
+= start
[6]; uncompressed_size
<<= 8;
13547 uncompressed_size
+= start
[7]; uncompressed_size
<<= 8;
13548 uncompressed_size
+= start
[8]; uncompressed_size
<<= 8;
13549 uncompressed_size
+= start
[9]; uncompressed_size
<<= 8;
13550 uncompressed_size
+= start
[10]; uncompressed_size
<<= 8;
13551 uncompressed_size
+= start
[11];
13556 if (uncompressed_size
)
13558 if (uncompress_section_contents (&start
, uncompressed_size
,
13561 /* Free the compressed buffer, update the section buffer
13562 and the section size if uncompress is successful. */
13563 free (section
->start
);
13564 section
->start
= start
;
13568 error (_("Unable to decompress section %s\n"),
13569 printable_section_name (filedata
, sec
));
13574 section
->size
= size
;
13577 if (section
->start
== NULL
)
13580 if (debug_displays
[debug
].relocate
)
13582 if (! apply_relocations (filedata
, sec
, section
->start
, section
->size
,
13583 & section
->reloc_info
, & section
->num_relocs
))
13588 section
->reloc_info
= NULL
;
13589 section
->num_relocs
= 0;
13595 /* If this is not NULL, load_debug_section will only look for sections
13596 within the list of sections given here. */
13597 static unsigned int * section_subset
= NULL
;
13600 load_debug_section (enum dwarf_section_display_enum debug
, void * data
)
13602 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13603 Elf_Internal_Shdr
* sec
;
13604 Filedata
* filedata
= (Filedata
*) data
;
13606 /* Without section headers we cannot find any sections. */
13607 if (filedata
->section_headers
== NULL
)
13610 if (filedata
->string_table
== NULL
13611 && filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
13612 && filedata
->file_header
.e_shstrndx
< filedata
->file_header
.e_shnum
)
13614 Elf_Internal_Shdr
* strs
;
13616 /* Read in the string table, so that we have section names to scan. */
13617 strs
= filedata
->section_headers
+ filedata
->file_header
.e_shstrndx
;
13619 if (strs
!= NULL
&& strs
->sh_size
!= 0)
13621 filedata
->string_table
13622 = (char *) get_data (NULL
, filedata
, strs
->sh_offset
,
13623 1, strs
->sh_size
, _("string table"));
13625 filedata
->string_table_length
13626 = filedata
->string_table
!= NULL
? strs
->sh_size
: 0;
13630 /* Locate the debug section. */
13631 sec
= find_section_in_set (filedata
, section
->uncompressed_name
, section_subset
);
13633 section
->name
= section
->uncompressed_name
;
13636 sec
= find_section_in_set (filedata
, section
->compressed_name
, section_subset
);
13638 section
->name
= section
->compressed_name
;
13643 /* If we're loading from a subset of sections, and we've loaded
13644 a section matching this name before, it's likely that it's a
13646 if (section_subset
!= NULL
)
13647 free_debug_section (debug
);
13649 return load_specific_debug_section (debug
, sec
, data
);
13653 free_debug_section (enum dwarf_section_display_enum debug
)
13655 struct dwarf_section
* section
= &debug_displays
[debug
].section
;
13657 if (section
->start
== NULL
)
13660 free ((char *) section
->start
);
13661 section
->start
= NULL
;
13662 section
->address
= 0;
13667 display_debug_section (int shndx
, Elf_Internal_Shdr
* section
, Filedata
* filedata
)
13669 char * name
= SECTION_NAME (section
);
13670 const char * print_name
= printable_section_name (filedata
, section
);
13671 bfd_size_type length
;
13672 bfd_boolean result
= TRUE
;
13675 length
= section
->sh_size
;
13678 printf (_("\nSection '%s' has no debugging data.\n"), print_name
);
13681 if (section
->sh_type
== SHT_NOBITS
)
13683 /* There is no point in dumping the contents of a debugging section
13684 which has the NOBITS type - the bits in the file will be random.
13685 This can happen when a file containing a .eh_frame section is
13686 stripped with the --only-keep-debug command line option. */
13687 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
13692 if (const_strneq (name
, ".gnu.linkonce.wi."))
13693 name
= ".debug_info";
13695 /* See if we know how to display the contents of this section. */
13696 for (i
= 0; i
< max
; i
++)
13698 enum dwarf_section_display_enum id
= (enum dwarf_section_display_enum
) i
;
13699 struct dwarf_section_display
* display
= debug_displays
+ i
;
13700 struct dwarf_section
* sec
= & display
->section
;
13702 if (streq (sec
->uncompressed_name
, name
)
13703 || (id
== line
&& const_strneq (name
, ".debug_line."))
13704 || streq (sec
->compressed_name
, name
))
13706 bfd_boolean secondary
= (section
!= find_section (filedata
, name
));
13709 free_debug_section (id
);
13711 if (i
== line
&& const_strneq (name
, ".debug_line."))
13713 else if (streq (sec
->uncompressed_name
, name
))
13714 sec
->name
= sec
->uncompressed_name
;
13716 sec
->name
= sec
->compressed_name
;
13718 if (load_specific_debug_section (id
, section
, filedata
))
13720 /* If this debug section is part of a CU/TU set in a .dwp file,
13721 restrict load_debug_section to the sections in that set. */
13722 section_subset
= find_cu_tu_set (filedata
, shndx
);
13724 result
&= display
->display (sec
, filedata
);
13726 section_subset
= NULL
;
13728 if (secondary
|| (id
!= info
&& id
!= abbrev
))
13729 free_debug_section (id
);
13737 printf (_("Unrecognized debug section: %s\n"), print_name
);
13744 /* Set DUMP_SECTS for all sections where dumps were requested
13745 based on section name. */
13748 initialise_dumps_byname (Filedata
* filedata
)
13750 struct dump_list_entry
* cur
;
13752 for (cur
= dump_sects_byname
; cur
; cur
= cur
->next
)
13755 bfd_boolean any
= FALSE
;
13757 for (i
= 0; i
< filedata
->file_header
.e_shnum
; i
++)
13758 if (streq (SECTION_NAME (filedata
->section_headers
+ i
), cur
->name
))
13760 request_dump_bynumber (filedata
, i
, cur
->type
);
13765 warn (_("Section '%s' was not dumped because it does not exist!\n"),
13771 process_section_contents (Filedata
* filedata
)
13773 Elf_Internal_Shdr
* section
;
13775 bfd_boolean res
= TRUE
;
13780 initialise_dumps_byname (filedata
);
13782 for (i
= 0, section
= filedata
->section_headers
;
13783 i
< filedata
->file_header
.e_shnum
&& i
< filedata
->num_dump_sects
;
13786 dump_type dump
= filedata
->dump_sects
[i
];
13788 #ifdef SUPPORT_DISASSEMBLY
13789 if (dump
& DISASS_DUMP
)
13791 if (! disassemble_section (section
, filedata
))
13795 if (dump
& HEX_DUMP
)
13797 if (! dump_section_as_bytes (section
, filedata
, FALSE
))
13801 if (dump
& RELOC_DUMP
)
13803 if (! dump_section_as_bytes (section
, filedata
, TRUE
))
13807 if (dump
& STRING_DUMP
)
13809 if (! dump_section_as_strings (section
, filedata
))
13813 if (dump
& DEBUG_DUMP
)
13815 if (! display_debug_section (i
, section
, filedata
))
13820 /* Check to see if the user requested a
13821 dump of a section that does not exist. */
13822 while (i
< filedata
->num_dump_sects
)
13824 if (filedata
->dump_sects
[i
])
13826 warn (_("Section %d was not dumped because it does not exist!\n"), i
);
13836 process_mips_fpe_exception (int mask
)
13840 bfd_boolean first
= TRUE
;
13842 if (mask
& OEX_FPU_INEX
)
13843 fputs ("INEX", stdout
), first
= FALSE
;
13844 if (mask
& OEX_FPU_UFLO
)
13845 printf ("%sUFLO", first
? "" : "|"), first
= FALSE
;
13846 if (mask
& OEX_FPU_OFLO
)
13847 printf ("%sOFLO", first
? "" : "|"), first
= FALSE
;
13848 if (mask
& OEX_FPU_DIV0
)
13849 printf ("%sDIV0", first
? "" : "|"), first
= FALSE
;
13850 if (mask
& OEX_FPU_INVAL
)
13851 printf ("%sINVAL", first
? "" : "|");
13854 fputs ("0", stdout
);
13857 /* Display's the value of TAG at location P. If TAG is
13858 greater than 0 it is assumed to be an unknown tag, and
13859 a message is printed to this effect. Otherwise it is
13860 assumed that a message has already been printed.
13862 If the bottom bit of TAG is set it assumed to have a
13863 string value, otherwise it is assumed to have an integer
13866 Returns an updated P pointing to the first unread byte
13867 beyond the end of TAG's value.
13869 Reads at or beyond END will not be made. */
13871 static unsigned char *
13872 display_tag_value (signed int tag
,
13874 const unsigned char * const end
)
13879 printf (" Tag_unknown_%d: ", tag
);
13883 warn (_("<corrupt tag>\n"));
13887 /* PR 17531 file: 027-19978-0.004. */
13888 size_t maxlen
= (end
- p
) - 1;
13893 print_symbol ((int) maxlen
, (const char *) p
);
13894 p
+= strnlen ((char *) p
, maxlen
) + 1;
13898 printf (_("<corrupt string tag>"));
13899 p
= (unsigned char *) end
;
13907 val
= read_uleb128 (p
, &len
, end
);
13909 printf ("%ld (0x%lx)\n", val
, val
);
13916 /* ARC ABI attributes section. */
13918 static unsigned char *
13919 display_arc_attribute (unsigned char * p
,
13920 const unsigned char * const end
)
13926 tag
= read_uleb128 (p
, &len
, end
);
13931 case Tag_ARC_PCS_config
:
13932 val
= read_uleb128 (p
, &len
, end
);
13934 printf (" Tag_ARC_PCS_config: ");
13938 printf (_("Absent/Non standard\n"));
13941 printf (_("Bare metal/mwdt\n"));
13944 printf (_("Bare metal/newlib\n"));
13947 printf (_("Linux/uclibc\n"));
13950 printf (_("Linux/glibc\n"));
13953 printf (_("Unknown\n"));
13958 case Tag_ARC_CPU_base
:
13959 val
= read_uleb128 (p
, &len
, end
);
13961 printf (" Tag_ARC_CPU_base: ");
13966 printf (_("Absent\n"));
13968 case TAG_CPU_ARC6xx
:
13969 printf ("ARC6xx\n");
13971 case TAG_CPU_ARC7xx
:
13972 printf ("ARC7xx\n");
13974 case TAG_CPU_ARCEM
:
13975 printf ("ARCEM\n");
13977 case TAG_CPU_ARCHS
:
13978 printf ("ARCHS\n");
13983 case Tag_ARC_CPU_variation
:
13984 val
= read_uleb128 (p
, &len
, end
);
13986 printf (" Tag_ARC_CPU_variation: ");
13990 if (val
> 0 && val
< 16)
13991 printf ("Core%d\n", val
);
13993 printf ("Unknown\n");
13997 printf (_("Absent\n"));
14002 case Tag_ARC_CPU_name
:
14003 printf (" Tag_ARC_CPU_name: ");
14004 p
= display_tag_value (-1, p
, end
);
14007 case Tag_ARC_ABI_rf16
:
14008 val
= read_uleb128 (p
, &len
, end
);
14010 printf (" Tag_ARC_ABI_rf16: %s\n", val
? _("yes") : _("no"));
14013 case Tag_ARC_ABI_osver
:
14014 val
= read_uleb128 (p
, &len
, end
);
14016 printf (" Tag_ARC_ABI_osver: v%d\n", val
);
14019 case Tag_ARC_ABI_pic
:
14020 case Tag_ARC_ABI_sda
:
14021 val
= read_uleb128 (p
, &len
, end
);
14023 printf (tag
== Tag_ARC_ABI_sda
? " Tag_ARC_ABI_sda: "
14024 : " Tag_ARC_ABI_pic: ");
14028 printf (_("Absent\n"));
14037 printf (_("Unknown\n"));
14042 case Tag_ARC_ABI_tls
:
14043 val
= read_uleb128 (p
, &len
, end
);
14045 printf (" Tag_ARC_ABI_tls: %s\n", val
? "r25": "none");
14048 case Tag_ARC_ABI_enumsize
:
14049 val
= read_uleb128 (p
, &len
, end
);
14051 printf (" Tag_ARC_ABI_enumsize: %s\n", val
? _("default") :
14055 case Tag_ARC_ABI_exceptions
:
14056 val
= read_uleb128 (p
, &len
, end
);
14058 printf (" Tag_ARC_ABI_exceptions: %s\n", val
? _("OPTFP")
14062 case Tag_ARC_ABI_double_size
:
14063 val
= read_uleb128 (p
, &len
, end
);
14065 printf (" Tag_ARC_ABI_double_size: %d\n", val
);
14068 case Tag_ARC_ISA_config
:
14069 printf (" Tag_ARC_ISA_config: ");
14070 p
= display_tag_value (-1, p
, end
);
14073 case Tag_ARC_ISA_apex
:
14074 printf (" Tag_ARC_ISA_apex: ");
14075 p
= display_tag_value (-1, p
, end
);
14078 case Tag_ARC_ISA_mpy_option
:
14079 val
= read_uleb128 (p
, &len
, end
);
14081 printf (" Tag_ARC_ISA_mpy_option: %d\n", val
);
14085 return display_tag_value (tag
& 1, p
, end
);
14091 /* ARM EABI attributes section. */
14096 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
14098 const char ** table
;
14099 } arm_attr_public_tag
;
14101 static const char * arm_attr_tag_CPU_arch
[] =
14102 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
14103 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "v8-R", "v8-M.baseline",
14105 static const char * arm_attr_tag_ARM_ISA_use
[] = {"No", "Yes"};
14106 static const char * arm_attr_tag_THUMB_ISA_use
[] =
14107 {"No", "Thumb-1", "Thumb-2", "Yes"};
14108 static const char * arm_attr_tag_FP_arch
[] =
14109 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
14110 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
14111 static const char * arm_attr_tag_WMMX_arch
[] = {"No", "WMMXv1", "WMMXv2"};
14112 static const char * arm_attr_tag_Advanced_SIMD_arch
[] =
14113 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
14114 "NEON for ARMv8.1"};
14115 static const char * arm_attr_tag_PCS_config
[] =
14116 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
14117 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
14118 static const char * arm_attr_tag_ABI_PCS_R9_use
[] =
14119 {"V6", "SB", "TLS", "Unused"};
14120 static const char * arm_attr_tag_ABI_PCS_RW_data
[] =
14121 {"Absolute", "PC-relative", "SB-relative", "None"};
14122 static const char * arm_attr_tag_ABI_PCS_RO_data
[] =
14123 {"Absolute", "PC-relative", "None"};
14124 static const char * arm_attr_tag_ABI_PCS_GOT_use
[] =
14125 {"None", "direct", "GOT-indirect"};
14126 static const char * arm_attr_tag_ABI_PCS_wchar_t
[] =
14127 {"None", "??? 1", "2", "??? 3", "4"};
14128 static const char * arm_attr_tag_ABI_FP_rounding
[] = {"Unused", "Needed"};
14129 static const char * arm_attr_tag_ABI_FP_denormal
[] =
14130 {"Unused", "Needed", "Sign only"};
14131 static const char * arm_attr_tag_ABI_FP_exceptions
[] = {"Unused", "Needed"};
14132 static const char * arm_attr_tag_ABI_FP_user_exceptions
[] = {"Unused", "Needed"};
14133 static const char * arm_attr_tag_ABI_FP_number_model
[] =
14134 {"Unused", "Finite", "RTABI", "IEEE 754"};
14135 static const char * arm_attr_tag_ABI_enum_size
[] =
14136 {"Unused", "small", "int", "forced to int"};
14137 static const char * arm_attr_tag_ABI_HardFP_use
[] =
14138 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
14139 static const char * arm_attr_tag_ABI_VFP_args
[] =
14140 {"AAPCS", "VFP registers", "custom", "compatible"};
14141 static const char * arm_attr_tag_ABI_WMMX_args
[] =
14142 {"AAPCS", "WMMX registers", "custom"};
14143 static const char * arm_attr_tag_ABI_optimization_goals
[] =
14144 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14145 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
14146 static const char * arm_attr_tag_ABI_FP_optimization_goals
[] =
14147 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
14148 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
14149 static const char * arm_attr_tag_CPU_unaligned_access
[] = {"None", "v6"};
14150 static const char * arm_attr_tag_FP_HP_extension
[] =
14151 {"Not Allowed", "Allowed"};
14152 static const char * arm_attr_tag_ABI_FP_16bit_format
[] =
14153 {"None", "IEEE 754", "Alternative Format"};
14154 static const char * arm_attr_tag_DSP_extension
[] =
14155 {"Follow architecture", "Allowed"};
14156 static const char * arm_attr_tag_MPextension_use
[] =
14157 {"Not Allowed", "Allowed"};
14158 static const char * arm_attr_tag_DIV_use
[] =
14159 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
14160 "Allowed in v7-A with integer division extension"};
14161 static const char * arm_attr_tag_T2EE_use
[] = {"Not Allowed", "Allowed"};
14162 static const char * arm_attr_tag_Virtualization_use
[] =
14163 {"Not Allowed", "TrustZone", "Virtualization Extensions",
14164 "TrustZone and Virtualization Extensions"};
14165 static const char * arm_attr_tag_MPextension_use_legacy
[] =
14166 {"Not Allowed", "Allowed"};
14168 #define LOOKUP(id, name) \
14169 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
14170 static arm_attr_public_tag arm_attr_public_tags
[] =
14172 {4, "CPU_raw_name", 1, NULL
},
14173 {5, "CPU_name", 1, NULL
},
14174 LOOKUP(6, CPU_arch
),
14175 {7, "CPU_arch_profile", 0, NULL
},
14176 LOOKUP(8, ARM_ISA_use
),
14177 LOOKUP(9, THUMB_ISA_use
),
14178 LOOKUP(10, FP_arch
),
14179 LOOKUP(11, WMMX_arch
),
14180 LOOKUP(12, Advanced_SIMD_arch
),
14181 LOOKUP(13, PCS_config
),
14182 LOOKUP(14, ABI_PCS_R9_use
),
14183 LOOKUP(15, ABI_PCS_RW_data
),
14184 LOOKUP(16, ABI_PCS_RO_data
),
14185 LOOKUP(17, ABI_PCS_GOT_use
),
14186 LOOKUP(18, ABI_PCS_wchar_t
),
14187 LOOKUP(19, ABI_FP_rounding
),
14188 LOOKUP(20, ABI_FP_denormal
),
14189 LOOKUP(21, ABI_FP_exceptions
),
14190 LOOKUP(22, ABI_FP_user_exceptions
),
14191 LOOKUP(23, ABI_FP_number_model
),
14192 {24, "ABI_align_needed", 0, NULL
},
14193 {25, "ABI_align_preserved", 0, NULL
},
14194 LOOKUP(26, ABI_enum_size
),
14195 LOOKUP(27, ABI_HardFP_use
),
14196 LOOKUP(28, ABI_VFP_args
),
14197 LOOKUP(29, ABI_WMMX_args
),
14198 LOOKUP(30, ABI_optimization_goals
),
14199 LOOKUP(31, ABI_FP_optimization_goals
),
14200 {32, "compatibility", 0, NULL
},
14201 LOOKUP(34, CPU_unaligned_access
),
14202 LOOKUP(36, FP_HP_extension
),
14203 LOOKUP(38, ABI_FP_16bit_format
),
14204 LOOKUP(42, MPextension_use
),
14205 LOOKUP(44, DIV_use
),
14206 LOOKUP(46, DSP_extension
),
14207 {64, "nodefaults", 0, NULL
},
14208 {65, "also_compatible_with", 0, NULL
},
14209 LOOKUP(66, T2EE_use
),
14210 {67, "conformance", 1, NULL
},
14211 LOOKUP(68, Virtualization_use
),
14212 LOOKUP(70, MPextension_use_legacy
)
14216 static unsigned char *
14217 display_arm_attribute (unsigned char * p
,
14218 const unsigned char * const end
)
14223 arm_attr_public_tag
* attr
;
14227 tag
= read_uleb128 (p
, &len
, end
);
14230 for (i
= 0; i
< ARRAY_SIZE (arm_attr_public_tags
); i
++)
14232 if (arm_attr_public_tags
[i
].tag
== tag
)
14234 attr
= &arm_attr_public_tags
[i
];
14241 printf (" Tag_%s: ", attr
->name
);
14242 switch (attr
->type
)
14247 case 7: /* Tag_CPU_arch_profile. */
14248 val
= read_uleb128 (p
, &len
, end
);
14252 case 0: printf (_("None\n")); break;
14253 case 'A': printf (_("Application\n")); break;
14254 case 'R': printf (_("Realtime\n")); break;
14255 case 'M': printf (_("Microcontroller\n")); break;
14256 case 'S': printf (_("Application or Realtime\n")); break;
14257 default: printf ("??? (%d)\n", val
); break;
14261 case 24: /* Tag_align_needed. */
14262 val
= read_uleb128 (p
, &len
, end
);
14266 case 0: printf (_("None\n")); break;
14267 case 1: printf (_("8-byte\n")); break;
14268 case 2: printf (_("4-byte\n")); break;
14269 case 3: printf ("??? 3\n"); break;
14272 printf (_("8-byte and up to %d-byte extended\n"),
14275 printf ("??? (%d)\n", val
);
14280 case 25: /* Tag_align_preserved. */
14281 val
= read_uleb128 (p
, &len
, end
);
14285 case 0: printf (_("None\n")); break;
14286 case 1: printf (_("8-byte, except leaf SP\n")); break;
14287 case 2: printf (_("8-byte\n")); break;
14288 case 3: printf ("??? 3\n"); break;
14291 printf (_("8-byte and up to %d-byte extended\n"),
14294 printf ("??? (%d)\n", val
);
14299 case 32: /* Tag_compatibility. */
14301 val
= read_uleb128 (p
, &len
, end
);
14303 printf (_("flag = %d, vendor = "), val
);
14306 size_t maxlen
= (end
- p
) - 1;
14308 print_symbol ((int) maxlen
, (const char *) p
);
14309 p
+= strnlen ((char *) p
, maxlen
) + 1;
14313 printf (_("<corrupt>"));
14314 p
= (unsigned char *) end
;
14320 case 64: /* Tag_nodefaults. */
14321 /* PR 17531: file: 001-505008-0.01. */
14324 printf (_("True\n"));
14327 case 65: /* Tag_also_compatible_with. */
14328 val
= read_uleb128 (p
, &len
, end
);
14330 if (val
== 6 /* Tag_CPU_arch. */)
14332 val
= read_uleb128 (p
, &len
, end
);
14334 if ((unsigned int) val
>= ARRAY_SIZE (arm_attr_tag_CPU_arch
))
14335 printf ("??? (%d)\n", val
);
14337 printf ("%s\n", arm_attr_tag_CPU_arch
[val
]);
14341 while (p
< end
&& *(p
++) != '\0' /* NUL terminator. */)
14346 printf (_("<unknown: %d>\n"), tag
);
14352 return display_tag_value (-1, p
, end
);
14354 return display_tag_value (0, p
, end
);
14357 assert (attr
->type
& 0x80);
14358 val
= read_uleb128 (p
, &len
, end
);
14360 type
= attr
->type
& 0x7f;
14362 printf ("??? (%d)\n", val
);
14364 printf ("%s\n", attr
->table
[val
]);
14369 return display_tag_value (tag
, p
, end
);
14372 static unsigned char *
14373 display_gnu_attribute (unsigned char * p
,
14374 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const),
14375 const unsigned char * const end
)
14381 tag
= read_uleb128 (p
, &len
, end
);
14384 /* Tag_compatibility is the only generic GNU attribute defined at
14388 val
= read_uleb128 (p
, &len
, end
);
14391 printf (_("flag = %d, vendor = "), val
);
14394 printf (_("<corrupt>\n"));
14395 warn (_("corrupt vendor attribute\n"));
14401 size_t maxlen
= (end
- p
) - 1;
14403 print_symbol ((int) maxlen
, (const char *) p
);
14404 p
+= strnlen ((char *) p
, maxlen
) + 1;
14408 printf (_("<corrupt>"));
14409 p
= (unsigned char *) end
;
14416 if ((tag
& 2) == 0 && display_proc_gnu_attribute
)
14417 return display_proc_gnu_attribute (p
, tag
, end
);
14419 return display_tag_value (tag
, p
, end
);
14422 static unsigned char *
14423 display_power_gnu_attribute (unsigned char * p
,
14425 const unsigned char * const end
)
14430 if (tag
== Tag_GNU_Power_ABI_FP
)
14432 val
= read_uleb128 (p
, &len
, end
);
14434 printf (" Tag_GNU_Power_ABI_FP: ");
14437 printf (_("<corrupt>\n"));
14442 printf ("(%#x), ", val
);
14447 printf (_("unspecified hard/soft float, "));
14450 printf (_("hard float, "));
14453 printf (_("soft float, "));
14456 printf (_("single-precision hard float, "));
14463 printf (_("unspecified long double\n"));
14466 printf (_("128-bit IBM long double\n"));
14469 printf (_("64-bit long double\n"));
14472 printf (_("128-bit IEEE long double\n"));
14478 if (tag
== Tag_GNU_Power_ABI_Vector
)
14480 val
= read_uleb128 (p
, &len
, end
);
14482 printf (" Tag_GNU_Power_ABI_Vector: ");
14485 printf (_("<corrupt>\n"));
14490 printf ("(%#x), ", val
);
14495 printf (_("unspecified\n"));
14498 printf (_("generic\n"));
14501 printf ("AltiVec\n");
14510 if (tag
== Tag_GNU_Power_ABI_Struct_Return
)
14512 val
= read_uleb128 (p
, &len
, end
);
14514 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
14517 printf (_("<corrupt>\n"));
14522 printf ("(%#x), ", val
);
14527 printf (_("unspecified\n"));
14530 printf ("r3/r4\n");
14533 printf (_("memory\n"));
14542 return display_tag_value (tag
& 1, p
, end
);
14545 static unsigned char *
14546 display_s390_gnu_attribute (unsigned char * p
,
14548 const unsigned char * const end
)
14553 if (tag
== Tag_GNU_S390_ABI_Vector
)
14555 val
= read_uleb128 (p
, &len
, end
);
14557 printf (" Tag_GNU_S390_ABI_Vector: ");
14562 printf (_("any\n"));
14565 printf (_("software\n"));
14568 printf (_("hardware\n"));
14571 printf ("??? (%d)\n", val
);
14577 return display_tag_value (tag
& 1, p
, end
);
14581 display_sparc_hwcaps (unsigned int mask
)
14585 bfd_boolean first
= TRUE
;
14587 if (mask
& ELF_SPARC_HWCAP_MUL32
)
14588 fputs ("mul32", stdout
), first
= FALSE
;
14589 if (mask
& ELF_SPARC_HWCAP_DIV32
)
14590 printf ("%sdiv32", first
? "" : "|"), first
= FALSE
;
14591 if (mask
& ELF_SPARC_HWCAP_FSMULD
)
14592 printf ("%sfsmuld", first
? "" : "|"), first
= FALSE
;
14593 if (mask
& ELF_SPARC_HWCAP_V8PLUS
)
14594 printf ("%sv8plus", first
? "" : "|"), first
= FALSE
;
14595 if (mask
& ELF_SPARC_HWCAP_POPC
)
14596 printf ("%spopc", first
? "" : "|"), first
= FALSE
;
14597 if (mask
& ELF_SPARC_HWCAP_VIS
)
14598 printf ("%svis", first
? "" : "|"), first
= FALSE
;
14599 if (mask
& ELF_SPARC_HWCAP_VIS2
)
14600 printf ("%svis2", first
? "" : "|"), first
= FALSE
;
14601 if (mask
& ELF_SPARC_HWCAP_ASI_BLK_INIT
)
14602 printf ("%sASIBlkInit", first
? "" : "|"), first
= FALSE
;
14603 if (mask
& ELF_SPARC_HWCAP_FMAF
)
14604 printf ("%sfmaf", first
? "" : "|"), first
= FALSE
;
14605 if (mask
& ELF_SPARC_HWCAP_VIS3
)
14606 printf ("%svis3", first
? "" : "|"), first
= FALSE
;
14607 if (mask
& ELF_SPARC_HWCAP_HPC
)
14608 printf ("%shpc", first
? "" : "|"), first
= FALSE
;
14609 if (mask
& ELF_SPARC_HWCAP_RANDOM
)
14610 printf ("%srandom", first
? "" : "|"), first
= FALSE
;
14611 if (mask
& ELF_SPARC_HWCAP_TRANS
)
14612 printf ("%strans", first
? "" : "|"), first
= FALSE
;
14613 if (mask
& ELF_SPARC_HWCAP_FJFMAU
)
14614 printf ("%sfjfmau", first
? "" : "|"), first
= FALSE
;
14615 if (mask
& ELF_SPARC_HWCAP_IMA
)
14616 printf ("%sima", first
? "" : "|"), first
= FALSE
;
14617 if (mask
& ELF_SPARC_HWCAP_ASI_CACHE_SPARING
)
14618 printf ("%scspare", first
? "" : "|"), first
= FALSE
;
14621 fputc ('0', stdout
);
14622 fputc ('\n', stdout
);
14626 display_sparc_hwcaps2 (unsigned int mask
)
14630 bfd_boolean first
= TRUE
;
14632 if (mask
& ELF_SPARC_HWCAP2_FJATHPLUS
)
14633 fputs ("fjathplus", stdout
), first
= FALSE
;
14634 if (mask
& ELF_SPARC_HWCAP2_VIS3B
)
14635 printf ("%svis3b", first
? "" : "|"), first
= FALSE
;
14636 if (mask
& ELF_SPARC_HWCAP2_ADP
)
14637 printf ("%sadp", first
? "" : "|"), first
= FALSE
;
14638 if (mask
& ELF_SPARC_HWCAP2_SPARC5
)
14639 printf ("%ssparc5", first
? "" : "|"), first
= FALSE
;
14640 if (mask
& ELF_SPARC_HWCAP2_MWAIT
)
14641 printf ("%smwait", first
? "" : "|"), first
= FALSE
;
14642 if (mask
& ELF_SPARC_HWCAP2_XMPMUL
)
14643 printf ("%sxmpmul", first
? "" : "|"), first
= FALSE
;
14644 if (mask
& ELF_SPARC_HWCAP2_XMONT
)
14645 printf ("%sxmont2", first
? "" : "|"), first
= FALSE
;
14646 if (mask
& ELF_SPARC_HWCAP2_NSEC
)
14647 printf ("%snsec", first
? "" : "|"), first
= FALSE
;
14648 if (mask
& ELF_SPARC_HWCAP2_FJATHHPC
)
14649 printf ("%sfjathhpc", first
? "" : "|"), first
= FALSE
;
14650 if (mask
& ELF_SPARC_HWCAP2_FJDES
)
14651 printf ("%sfjdes", first
? "" : "|"), first
= FALSE
;
14652 if (mask
& ELF_SPARC_HWCAP2_FJAES
)
14653 printf ("%sfjaes", first
? "" : "|"), first
= FALSE
;
14656 fputc ('0', stdout
);
14657 fputc ('\n', stdout
);
14660 static unsigned char *
14661 display_sparc_gnu_attribute (unsigned char * p
,
14663 const unsigned char * const end
)
14668 if (tag
== Tag_GNU_Sparc_HWCAPS
)
14670 val
= read_uleb128 (p
, &len
, end
);
14672 printf (" Tag_GNU_Sparc_HWCAPS: ");
14673 display_sparc_hwcaps (val
);
14676 if (tag
== Tag_GNU_Sparc_HWCAPS2
)
14678 val
= read_uleb128 (p
, &len
, end
);
14680 printf (" Tag_GNU_Sparc_HWCAPS2: ");
14681 display_sparc_hwcaps2 (val
);
14685 return display_tag_value (tag
, p
, end
);
14689 print_mips_fp_abi_value (unsigned int val
)
14693 case Val_GNU_MIPS_ABI_FP_ANY
:
14694 printf (_("Hard or soft float\n"));
14696 case Val_GNU_MIPS_ABI_FP_DOUBLE
:
14697 printf (_("Hard float (double precision)\n"));
14699 case Val_GNU_MIPS_ABI_FP_SINGLE
:
14700 printf (_("Hard float (single precision)\n"));
14702 case Val_GNU_MIPS_ABI_FP_SOFT
:
14703 printf (_("Soft float\n"));
14705 case Val_GNU_MIPS_ABI_FP_OLD_64
:
14706 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
14708 case Val_GNU_MIPS_ABI_FP_XX
:
14709 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
14711 case Val_GNU_MIPS_ABI_FP_64
:
14712 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
14714 case Val_GNU_MIPS_ABI_FP_64A
:
14715 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
14717 case Val_GNU_MIPS_ABI_FP_NAN2008
:
14718 printf (_("NaN 2008 compatibility\n"));
14721 printf ("??? (%d)\n", val
);
14726 static unsigned char *
14727 display_mips_gnu_attribute (unsigned char * p
,
14729 const unsigned char * const end
)
14731 if (tag
== Tag_GNU_MIPS_ABI_FP
)
14736 val
= read_uleb128 (p
, &len
, end
);
14738 printf (" Tag_GNU_MIPS_ABI_FP: ");
14740 print_mips_fp_abi_value (val
);
14745 if (tag
== Tag_GNU_MIPS_ABI_MSA
)
14750 val
= read_uleb128 (p
, &len
, end
);
14752 printf (" Tag_GNU_MIPS_ABI_MSA: ");
14756 case Val_GNU_MIPS_ABI_MSA_ANY
:
14757 printf (_("Any MSA or not\n"));
14759 case Val_GNU_MIPS_ABI_MSA_128
:
14760 printf (_("128-bit MSA\n"));
14763 printf ("??? (%d)\n", val
);
14769 return display_tag_value (tag
& 1, p
, end
);
14772 static unsigned char *
14773 display_tic6x_attribute (unsigned char * p
,
14774 const unsigned char * const end
)
14780 tag
= read_uleb128 (p
, &len
, end
);
14786 val
= read_uleb128 (p
, &len
, end
);
14788 printf (" Tag_ISA: ");
14792 case C6XABI_Tag_ISA_none
:
14793 printf (_("None\n"));
14795 case C6XABI_Tag_ISA_C62X
:
14798 case C6XABI_Tag_ISA_C67X
:
14801 case C6XABI_Tag_ISA_C67XP
:
14802 printf ("C67x+\n");
14804 case C6XABI_Tag_ISA_C64X
:
14807 case C6XABI_Tag_ISA_C64XP
:
14808 printf ("C64x+\n");
14810 case C6XABI_Tag_ISA_C674X
:
14811 printf ("C674x\n");
14814 printf ("??? (%d)\n", val
);
14819 case Tag_ABI_wchar_t
:
14820 val
= read_uleb128 (p
, &len
, end
);
14822 printf (" Tag_ABI_wchar_t: ");
14826 printf (_("Not used\n"));
14829 printf (_("2 bytes\n"));
14832 printf (_("4 bytes\n"));
14835 printf ("??? (%d)\n", val
);
14840 case Tag_ABI_stack_align_needed
:
14841 val
= read_uleb128 (p
, &len
, end
);
14843 printf (" Tag_ABI_stack_align_needed: ");
14847 printf (_("8-byte\n"));
14850 printf (_("16-byte\n"));
14853 printf ("??? (%d)\n", val
);
14858 case Tag_ABI_stack_align_preserved
:
14859 val
= read_uleb128 (p
, &len
, end
);
14861 printf (" Tag_ABI_stack_align_preserved: ");
14865 printf (_("8-byte\n"));
14868 printf (_("16-byte\n"));
14871 printf ("??? (%d)\n", val
);
14877 val
= read_uleb128 (p
, &len
, end
);
14879 printf (" Tag_ABI_DSBT: ");
14883 printf (_("DSBT addressing not used\n"));
14886 printf (_("DSBT addressing used\n"));
14889 printf ("??? (%d)\n", val
);
14895 val
= read_uleb128 (p
, &len
, end
);
14897 printf (" Tag_ABI_PID: ");
14901 printf (_("Data addressing position-dependent\n"));
14904 printf (_("Data addressing position-independent, GOT near DP\n"));
14907 printf (_("Data addressing position-independent, GOT far from DP\n"));
14910 printf ("??? (%d)\n", val
);
14916 val
= read_uleb128 (p
, &len
, end
);
14918 printf (" Tag_ABI_PIC: ");
14922 printf (_("Code addressing position-dependent\n"));
14925 printf (_("Code addressing position-independent\n"));
14928 printf ("??? (%d)\n", val
);
14933 case Tag_ABI_array_object_alignment
:
14934 val
= read_uleb128 (p
, &len
, end
);
14936 printf (" Tag_ABI_array_object_alignment: ");
14940 printf (_("8-byte\n"));
14943 printf (_("4-byte\n"));
14946 printf (_("16-byte\n"));
14949 printf ("??? (%d)\n", val
);
14954 case Tag_ABI_array_object_align_expected
:
14955 val
= read_uleb128 (p
, &len
, end
);
14957 printf (" Tag_ABI_array_object_align_expected: ");
14961 printf (_("8-byte\n"));
14964 printf (_("4-byte\n"));
14967 printf (_("16-byte\n"));
14970 printf ("??? (%d)\n", val
);
14975 case Tag_ABI_compatibility
:
14977 val
= read_uleb128 (p
, &len
, end
);
14979 printf (" Tag_ABI_compatibility: ");
14980 printf (_("flag = %d, vendor = "), val
);
14983 size_t maxlen
= (end
- p
) - 1;
14985 print_symbol ((int) maxlen
, (const char *) p
);
14986 p
+= strnlen ((char *) p
, maxlen
) + 1;
14990 printf (_("<corrupt>"));
14991 p
= (unsigned char *) end
;
14997 case Tag_ABI_conformance
:
14999 printf (" Tag_ABI_conformance: \"");
15002 size_t maxlen
= (end
- p
) - 1;
15004 print_symbol ((int) maxlen
, (const char *) p
);
15005 p
+= strnlen ((char *) p
, maxlen
) + 1;
15009 printf (_("<corrupt>"));
15010 p
= (unsigned char *) end
;
15017 return display_tag_value (tag
, p
, end
);
15021 display_raw_attribute (unsigned char * p
, unsigned char const * const end
)
15023 unsigned long addr
= 0;
15024 size_t bytes
= end
- p
;
15031 int lbytes
= (bytes
> 16 ? 16 : bytes
);
15033 printf (" 0x%8.8lx ", addr
);
15035 for (j
= 0; j
< 16; j
++)
15038 printf ("%2.2x", p
[j
]);
15046 for (j
= 0; j
< lbytes
; j
++)
15049 if (k
>= ' ' && k
< 0x7f)
15065 static unsigned char *
15066 display_msp430x_attribute (unsigned char * p
,
15067 const unsigned char * const end
)
15073 tag
= read_uleb128 (p
, & len
, end
);
15078 case OFBA_MSPABI_Tag_ISA
:
15079 val
= read_uleb128 (p
, &len
, end
);
15081 printf (" Tag_ISA: ");
15084 case 0: printf (_("None\n")); break;
15085 case 1: printf (_("MSP430\n")); break;
15086 case 2: printf (_("MSP430X\n")); break;
15087 default: printf ("??? (%d)\n", val
); break;
15091 case OFBA_MSPABI_Tag_Code_Model
:
15092 val
= read_uleb128 (p
, &len
, end
);
15094 printf (" Tag_Code_Model: ");
15097 case 0: printf (_("None\n")); break;
15098 case 1: printf (_("Small\n")); break;
15099 case 2: printf (_("Large\n")); break;
15100 default: printf ("??? (%d)\n", val
); break;
15104 case OFBA_MSPABI_Tag_Data_Model
:
15105 val
= read_uleb128 (p
, &len
, end
);
15107 printf (" Tag_Data_Model: ");
15110 case 0: printf (_("None\n")); break;
15111 case 1: printf (_("Small\n")); break;
15112 case 2: printf (_("Large\n")); break;
15113 case 3: printf (_("Restricted Large\n")); break;
15114 default: printf ("??? (%d)\n", val
); break;
15119 printf (_(" <unknown tag %d>: "), tag
);
15126 size_t maxlen
= (end
- p
) - 1;
15128 print_symbol ((int) maxlen
, (const char *) p
);
15129 p
+= strnlen ((char *) p
, maxlen
) + 1;
15133 printf (_("<corrupt>"));
15134 p
= (unsigned char *) end
;
15140 val
= read_uleb128 (p
, &len
, end
);
15142 printf ("%d (0x%x)\n", val
, val
);
15152 process_attributes (Filedata
* filedata
,
15153 const char * public_name
,
15154 unsigned int proc_type
,
15155 unsigned char * (* display_pub_attribute
) (unsigned char *, const unsigned char * const),
15156 unsigned char * (* display_proc_gnu_attribute
) (unsigned char *, unsigned int, const unsigned char * const))
15158 Elf_Internal_Shdr
* sect
;
15160 bfd_boolean res
= TRUE
;
15162 /* Find the section header so that we get the size. */
15163 for (i
= 0, sect
= filedata
->section_headers
;
15164 i
< filedata
->file_header
.e_shnum
;
15167 unsigned char * contents
;
15170 if (sect
->sh_type
!= proc_type
&& sect
->sh_type
!= SHT_GNU_ATTRIBUTES
)
15173 contents
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
, 1,
15174 sect
->sh_size
, _("attributes"));
15175 if (contents
== NULL
)
15182 /* The first character is the version of the attributes.
15183 Currently only version 1, (aka 'A') is recognised here. */
15186 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p
, *p
);
15191 bfd_vma section_len
;
15193 section_len
= sect
->sh_size
- 1;
15196 while (section_len
> 0)
15199 unsigned int namelen
;
15200 bfd_boolean public_section
;
15201 bfd_boolean gnu_section
;
15203 if (section_len
<= 4)
15205 error (_("Tag section ends prematurely\n"));
15209 attr_len
= byte_get (p
, 4);
15212 if (attr_len
> section_len
)
15214 error (_("Bad attribute length (%u > %u)\n"),
15215 (unsigned) attr_len
, (unsigned) section_len
);
15216 attr_len
= section_len
;
15219 /* PR 17531: file: 001-101425-0.004 */
15220 else if (attr_len
< 5)
15222 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len
);
15227 section_len
-= attr_len
;
15230 namelen
= strnlen ((char *) p
, attr_len
) + 1;
15231 if (namelen
== 0 || namelen
>= attr_len
)
15233 error (_("Corrupt attribute section name\n"));
15238 printf (_("Attribute Section: "));
15239 print_symbol (INT_MAX
, (const char *) p
);
15242 if (public_name
&& streq ((char *) p
, public_name
))
15243 public_section
= TRUE
;
15245 public_section
= FALSE
;
15247 if (streq ((char *) p
, "gnu"))
15248 gnu_section
= TRUE
;
15250 gnu_section
= FALSE
;
15253 attr_len
-= namelen
;
15255 while (attr_len
> 0 && p
< contents
+ sect
->sh_size
)
15260 unsigned char * end
;
15262 /* PR binutils/17531: Safe handling of corrupt files. */
15265 error (_("Unused bytes at end of section\n"));
15272 size
= byte_get (p
, 4);
15273 if (size
> attr_len
)
15275 error (_("Bad subsection length (%u > %u)\n"),
15276 (unsigned) size
, (unsigned) attr_len
);
15280 /* PR binutils/17531: Safe handling of corrupt files. */
15283 error (_("Bad subsection length (%u < 6)\n"),
15291 end
= p
+ size
- 1;
15292 assert (end
<= contents
+ sect
->sh_size
);
15298 printf (_("File Attributes\n"));
15301 printf (_("Section Attributes:"));
15304 printf (_("Symbol Attributes:"));
15305 /* Fall through. */
15311 val
= read_uleb128 (p
, &j
, end
);
15315 printf (" %d", val
);
15320 printf (_("Unknown tag: %d\n"), tag
);
15321 public_section
= FALSE
;
15325 if (public_section
&& display_pub_attribute
!= NULL
)
15328 p
= display_pub_attribute (p
, end
);
15331 else if (gnu_section
&& display_proc_gnu_attribute
!= NULL
)
15334 p
= display_gnu_attribute (p
,
15335 display_proc_gnu_attribute
,
15341 printf (_(" Unknown attribute:\n"));
15342 display_raw_attribute (p
, end
);
15357 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
15358 Print the Address, Access and Initial fields of an entry at VMA ADDR
15359 and return the VMA of the next entry, or -1 if there was a problem.
15360 Does not read from DATA_END or beyond. */
15363 print_mips_got_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
,
15364 unsigned char * data_end
)
15367 print_vma (addr
, LONG_HEX
);
15369 if (addr
< pltgot
+ 0xfff0)
15370 printf ("%6d(gp)", (int) (addr
- pltgot
- 0x7ff0));
15372 printf ("%10s", "");
15375 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
15379 unsigned char * from
= data
+ addr
- pltgot
;
15381 if (from
+ (is_32bit_elf
? 4 : 8) > data_end
)
15383 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
15384 printf ("%*s", is_32bit_elf
? 8 : 16, _("<corrupt>"));
15385 return (bfd_vma
) -1;
15389 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
15390 print_vma (entry
, LONG_HEX
);
15393 return addr
+ (is_32bit_elf
? 4 : 8);
15396 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
15397 PLTGOT. Print the Address and Initial fields of an entry at VMA
15398 ADDR and return the VMA of the next entry. */
15401 print_mips_pltgot_entry (unsigned char * data
, bfd_vma pltgot
, bfd_vma addr
)
15404 print_vma (addr
, LONG_HEX
);
15407 printf ("%*s", is_32bit_elf
? 8 : 16, _("<unknown>"));
15412 entry
= byte_get (data
+ addr
- pltgot
, is_32bit_elf
? 4 : 8);
15413 print_vma (entry
, LONG_HEX
);
15415 return addr
+ (is_32bit_elf
? 4 : 8);
15419 print_mips_ases (unsigned int mask
)
15421 if (mask
& AFL_ASE_DSP
)
15422 fputs ("\n\tDSP ASE", stdout
);
15423 if (mask
& AFL_ASE_DSPR2
)
15424 fputs ("\n\tDSP R2 ASE", stdout
);
15425 if (mask
& AFL_ASE_DSPR3
)
15426 fputs ("\n\tDSP R3 ASE", stdout
);
15427 if (mask
& AFL_ASE_EVA
)
15428 fputs ("\n\tEnhanced VA Scheme", stdout
);
15429 if (mask
& AFL_ASE_MCU
)
15430 fputs ("\n\tMCU (MicroController) ASE", stdout
);
15431 if (mask
& AFL_ASE_MDMX
)
15432 fputs ("\n\tMDMX ASE", stdout
);
15433 if (mask
& AFL_ASE_MIPS3D
)
15434 fputs ("\n\tMIPS-3D ASE", stdout
);
15435 if (mask
& AFL_ASE_MT
)
15436 fputs ("\n\tMT ASE", stdout
);
15437 if (mask
& AFL_ASE_SMARTMIPS
)
15438 fputs ("\n\tSmartMIPS ASE", stdout
);
15439 if (mask
& AFL_ASE_VIRT
)
15440 fputs ("\n\tVZ ASE", stdout
);
15441 if (mask
& AFL_ASE_MSA
)
15442 fputs ("\n\tMSA ASE", stdout
);
15443 if (mask
& AFL_ASE_MIPS16
)
15444 fputs ("\n\tMIPS16 ASE", stdout
);
15445 if (mask
& AFL_ASE_MICROMIPS
)
15446 fputs ("\n\tMICROMIPS ASE", stdout
);
15447 if (mask
& AFL_ASE_XPA
)
15448 fputs ("\n\tXPA ASE", stdout
);
15449 if (mask
& AFL_ASE_MIPS16E2
)
15450 fputs ("\n\tMIPS16e2 ASE", stdout
);
15452 fprintf (stdout
, "\n\t%s", _("None"));
15453 else if ((mask
& ~AFL_ASE_MASK
) != 0)
15454 fprintf (stdout
, "\n\t%s (%x)", _("Unknown"), mask
& ~AFL_ASE_MASK
);
15458 print_mips_isa_ext (unsigned int isa_ext
)
15463 fputs (_("None"), stdout
);
15466 fputs ("RMI XLR", stdout
);
15468 case AFL_EXT_OCTEON3
:
15469 fputs ("Cavium Networks Octeon3", stdout
);
15471 case AFL_EXT_OCTEON2
:
15472 fputs ("Cavium Networks Octeon2", stdout
);
15474 case AFL_EXT_OCTEONP
:
15475 fputs ("Cavium Networks OcteonP", stdout
);
15477 case AFL_EXT_LOONGSON_3A
:
15478 fputs ("Loongson 3A", stdout
);
15480 case AFL_EXT_OCTEON
:
15481 fputs ("Cavium Networks Octeon", stdout
);
15484 fputs ("Toshiba R5900", stdout
);
15487 fputs ("MIPS R4650", stdout
);
15490 fputs ("LSI R4010", stdout
);
15493 fputs ("NEC VR4100", stdout
);
15496 fputs ("Toshiba R3900", stdout
);
15498 case AFL_EXT_10000
:
15499 fputs ("MIPS R10000", stdout
);
15502 fputs ("Broadcom SB-1", stdout
);
15505 fputs ("NEC VR4111/VR4181", stdout
);
15508 fputs ("NEC VR4120", stdout
);
15511 fputs ("NEC VR5400", stdout
);
15514 fputs ("NEC VR5500", stdout
);
15516 case AFL_EXT_LOONGSON_2E
:
15517 fputs ("ST Microelectronics Loongson 2E", stdout
);
15519 case AFL_EXT_LOONGSON_2F
:
15520 fputs ("ST Microelectronics Loongson 2F", stdout
);
15522 case AFL_EXT_INTERAPTIV_MR2
:
15523 fputs ("Imagination interAptiv MR2", stdout
);
15526 fprintf (stdout
, "%s (%d)", _("Unknown"), isa_ext
);
15531 get_mips_reg_size (int reg_size
)
15533 return (reg_size
== AFL_REG_NONE
) ? 0
15534 : (reg_size
== AFL_REG_32
) ? 32
15535 : (reg_size
== AFL_REG_64
) ? 64
15536 : (reg_size
== AFL_REG_128
) ? 128
15541 process_mips_specific (Filedata
* filedata
)
15543 Elf_Internal_Dyn
* entry
;
15544 Elf_Internal_Shdr
*sect
= NULL
;
15545 size_t liblist_offset
= 0;
15546 size_t liblistno
= 0;
15547 size_t conflictsno
= 0;
15548 size_t options_offset
= 0;
15549 size_t conflicts_offset
= 0;
15550 size_t pltrelsz
= 0;
15552 bfd_vma pltgot
= 0;
15553 bfd_vma mips_pltgot
= 0;
15554 bfd_vma jmprel
= 0;
15555 bfd_vma local_gotno
= 0;
15556 bfd_vma gotsym
= 0;
15557 bfd_vma symtabno
= 0;
15558 bfd_boolean res
= TRUE
;
15560 if (! process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
15561 display_mips_gnu_attribute
))
15564 sect
= find_section (filedata
, ".MIPS.abiflags");
15568 Elf_External_ABIFlags_v0
*abiflags_ext
;
15569 Elf_Internal_ABIFlags_v0 abiflags_in
;
15571 if (sizeof (Elf_External_ABIFlags_v0
) != sect
->sh_size
)
15573 error (_("Corrupt MIPS ABI Flags section.\n"));
15578 abiflags_ext
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
15579 sect
->sh_size
, _("MIPS ABI Flags section"));
15582 abiflags_in
.version
= BYTE_GET (abiflags_ext
->version
);
15583 abiflags_in
.isa_level
= BYTE_GET (abiflags_ext
->isa_level
);
15584 abiflags_in
.isa_rev
= BYTE_GET (abiflags_ext
->isa_rev
);
15585 abiflags_in
.gpr_size
= BYTE_GET (abiflags_ext
->gpr_size
);
15586 abiflags_in
.cpr1_size
= BYTE_GET (abiflags_ext
->cpr1_size
);
15587 abiflags_in
.cpr2_size
= BYTE_GET (abiflags_ext
->cpr2_size
);
15588 abiflags_in
.fp_abi
= BYTE_GET (abiflags_ext
->fp_abi
);
15589 abiflags_in
.isa_ext
= BYTE_GET (abiflags_ext
->isa_ext
);
15590 abiflags_in
.ases
= BYTE_GET (abiflags_ext
->ases
);
15591 abiflags_in
.flags1
= BYTE_GET (abiflags_ext
->flags1
);
15592 abiflags_in
.flags2
= BYTE_GET (abiflags_ext
->flags2
);
15594 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in
.version
);
15595 printf ("\nISA: MIPS%d", abiflags_in
.isa_level
);
15596 if (abiflags_in
.isa_rev
> 1)
15597 printf ("r%d", abiflags_in
.isa_rev
);
15598 printf ("\nGPR size: %d",
15599 get_mips_reg_size (abiflags_in
.gpr_size
));
15600 printf ("\nCPR1 size: %d",
15601 get_mips_reg_size (abiflags_in
.cpr1_size
));
15602 printf ("\nCPR2 size: %d",
15603 get_mips_reg_size (abiflags_in
.cpr2_size
));
15604 fputs ("\nFP ABI: ", stdout
);
15605 print_mips_fp_abi_value (abiflags_in
.fp_abi
);
15606 fputs ("ISA Extension: ", stdout
);
15607 print_mips_isa_ext (abiflags_in
.isa_ext
);
15608 fputs ("\nASEs:", stdout
);
15609 print_mips_ases (abiflags_in
.ases
);
15610 printf ("\nFLAGS 1: %8.8lx", abiflags_in
.flags1
);
15611 printf ("\nFLAGS 2: %8.8lx", abiflags_in
.flags2
);
15612 fputc ('\n', stdout
);
15613 free (abiflags_ext
);
15618 /* We have a lot of special sections. Thanks SGI! */
15619 if (dynamic_section
== NULL
)
15621 /* No dynamic information available. See if there is static GOT. */
15622 sect
= find_section (filedata
, ".got");
15625 unsigned char *data_end
;
15626 unsigned char *data
;
15630 pltgot
= sect
->sh_addr
;
15633 addr_size
= (is_32bit_elf
? 4 : 8);
15634 end
= pltgot
+ sect
->sh_size
;
15636 data
= (unsigned char *) get_data (NULL
, filedata
, sect
->sh_offset
,
15638 _("Global Offset Table data"));
15639 /* PR 12855: Null data is handled gracefully throughout. */
15640 data_end
= data
+ (end
- pltgot
);
15642 printf (_("\nStatic GOT:\n"));
15643 printf (_(" Canonical gp value: "));
15644 print_vma (ent
+ 0x7ff0, LONG_HEX
);
15647 /* In a dynamic binary GOT[0] is reserved for the dynamic
15648 loader to store the lazy resolver pointer, however in
15649 a static binary it may well have been omitted and GOT
15650 reduced to a table of addresses.
15651 PR 21344: Check for the entry being fully available
15652 before fetching it. */
15654 && data
+ ent
- pltgot
+ addr_size
<= data_end
15655 && byte_get (data
+ ent
- pltgot
, addr_size
) == 0)
15657 printf (_(" Reserved entries:\n"));
15658 printf (_(" %*s %10s %*s\n"),
15659 addr_size
* 2, _("Address"), _("Access"),
15660 addr_size
* 2, _("Value"));
15661 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15663 if (ent
== (bfd_vma
) -1)
15664 goto sgot_print_fail
;
15666 /* Check for the MSB of GOT[1] being set, identifying a
15667 GNU object. This entry will be used by some runtime
15668 loaders, to store the module pointer. Otherwise this
15669 is an ordinary local entry.
15670 PR 21344: Check for the entry being fully available
15671 before fetching it. */
15673 && data
+ ent
- pltgot
+ addr_size
<= data_end
15674 && (byte_get (data
+ ent
- pltgot
, addr_size
)
15675 >> (addr_size
* 8 - 1)) != 0)
15677 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15679 if (ent
== (bfd_vma
) -1)
15680 goto sgot_print_fail
;
15685 if (data
!= NULL
&& ent
< end
)
15687 printf (_(" Local entries:\n"));
15688 printf (" %*s %10s %*s\n",
15689 addr_size
* 2, _("Address"), _("Access"),
15690 addr_size
* 2, _("Value"));
15693 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
15695 if (ent
== (bfd_vma
) -1)
15696 goto sgot_print_fail
;
15708 for (entry
= dynamic_section
;
15709 /* PR 17531 file: 012-50589-0.004. */
15710 entry
< dynamic_section
+ dynamic_nent
&& entry
->d_tag
!= DT_NULL
;
15712 switch (entry
->d_tag
)
15714 case DT_MIPS_LIBLIST
:
15716 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
15717 liblistno
* sizeof (Elf32_External_Lib
));
15719 case DT_MIPS_LIBLISTNO
:
15720 liblistno
= entry
->d_un
.d_val
;
15722 case DT_MIPS_OPTIONS
:
15723 options_offset
= offset_from_vma (filedata
, entry
->d_un
.d_val
, 0);
15725 case DT_MIPS_CONFLICT
:
15727 = offset_from_vma (filedata
, entry
->d_un
.d_val
,
15728 conflictsno
* sizeof (Elf32_External_Conflict
));
15730 case DT_MIPS_CONFLICTNO
:
15731 conflictsno
= entry
->d_un
.d_val
;
15734 pltgot
= entry
->d_un
.d_ptr
;
15736 case DT_MIPS_LOCAL_GOTNO
:
15737 local_gotno
= entry
->d_un
.d_val
;
15739 case DT_MIPS_GOTSYM
:
15740 gotsym
= entry
->d_un
.d_val
;
15742 case DT_MIPS_SYMTABNO
:
15743 symtabno
= entry
->d_un
.d_val
;
15745 case DT_MIPS_PLTGOT
:
15746 mips_pltgot
= entry
->d_un
.d_ptr
;
15749 pltrel
= entry
->d_un
.d_val
;
15752 pltrelsz
= entry
->d_un
.d_val
;
15755 jmprel
= entry
->d_un
.d_ptr
;
15761 if (liblist_offset
!= 0 && liblistno
!= 0 && do_dynamic
)
15763 Elf32_External_Lib
* elib
;
15766 elib
= (Elf32_External_Lib
*) get_data (NULL
, filedata
, liblist_offset
,
15768 sizeof (Elf32_External_Lib
),
15769 _("liblist section data"));
15772 printf (ngettext ("\nSection '.liblist' contains %lu entry:\n",
15773 "\nSection '.liblist' contains %lu entries:\n",
15774 (unsigned long) liblistno
),
15775 (unsigned long) liblistno
);
15776 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
15779 for (cnt
= 0; cnt
< liblistno
; ++cnt
)
15786 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
15787 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
15788 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
15789 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
15790 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
15792 tmp
= gmtime (&atime
);
15793 snprintf (timebuf
, sizeof (timebuf
),
15794 "%04u-%02u-%02uT%02u:%02u:%02u",
15795 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
15796 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
15798 printf ("%3lu: ", (unsigned long) cnt
);
15799 if (VALID_DYNAMIC_NAME (liblist
.l_name
))
15800 print_symbol (20, GET_DYNAMIC_NAME (liblist
.l_name
));
15802 printf (_("<corrupt: %9ld>"), liblist
.l_name
);
15803 printf (" %s %#10lx %-7ld", timebuf
, liblist
.l_checksum
,
15804 liblist
.l_version
);
15806 if (liblist
.l_flags
== 0)
15810 static const struct
15817 { " EXACT_MATCH", LL_EXACT_MATCH
},
15818 { " IGNORE_INT_VER", LL_IGNORE_INT_VER
},
15819 { " REQUIRE_MINOR", LL_REQUIRE_MINOR
},
15820 { " EXPORTS", LL_EXPORTS
},
15821 { " DELAY_LOAD", LL_DELAY_LOAD
},
15822 { " DELTA", LL_DELTA
}
15824 int flags
= liblist
.l_flags
;
15827 for (fcnt
= 0; fcnt
< ARRAY_SIZE (l_flags_vals
); ++fcnt
)
15828 if ((flags
& l_flags_vals
[fcnt
].bit
) != 0)
15830 fputs (l_flags_vals
[fcnt
].name
, stdout
);
15831 flags
^= l_flags_vals
[fcnt
].bit
;
15834 printf (" %#x", (unsigned int) flags
);
15846 if (options_offset
!= 0)
15848 Elf_External_Options
* eopt
;
15849 Elf_Internal_Options
* iopt
;
15850 Elf_Internal_Options
* option
;
15853 sect
= filedata
->section_headers
;
15855 /* Find the section header so that we get the size. */
15856 sect
= find_section_by_type (filedata
, SHT_MIPS_OPTIONS
);
15857 /* PR 17533 file: 012-277276-0.004. */
15860 error (_("No MIPS_OPTIONS header found\n"));
15864 eopt
= (Elf_External_Options
*) get_data (NULL
, filedata
, options_offset
, 1,
15865 sect
->sh_size
, _("options"));
15868 iopt
= (Elf_Internal_Options
*)
15869 cmalloc ((sect
->sh_size
/ sizeof (eopt
)), sizeof (* iopt
));
15872 error (_("Out of memory allocating space for MIPS options\n"));
15879 while (offset
<= sect
->sh_size
- sizeof (* eopt
))
15881 Elf_External_Options
* eoption
;
15883 eoption
= (Elf_External_Options
*) ((char *) eopt
+ offset
);
15885 option
->kind
= BYTE_GET (eoption
->kind
);
15886 option
->size
= BYTE_GET (eoption
->size
);
15887 option
->section
= BYTE_GET (eoption
->section
);
15888 option
->info
= BYTE_GET (eoption
->info
);
15890 /* PR 17531: file: ffa0fa3b. */
15891 if (option
->size
< sizeof (* eopt
)
15892 || offset
+ option
->size
> sect
->sh_size
)
15894 error (_("Invalid size (%u) for MIPS option\n"), option
->size
);
15897 offset
+= option
->size
;
15903 printf (ngettext ("\nSection '%s' contains %d entry:\n",
15904 "\nSection '%s' contains %d entries:\n",
15906 printable_section_name (filedata
, sect
), cnt
);
15915 switch (option
->kind
)
15918 /* This shouldn't happen. */
15919 printf (" NULL %d %lx", option
->section
, option
->info
);
15922 printf (" REGINFO ");
15923 if (filedata
->file_header
.e_machine
== EM_MIPS
)
15926 Elf32_External_RegInfo
* ereg
;
15927 Elf32_RegInfo reginfo
;
15929 ereg
= (Elf32_External_RegInfo
*) (option
+ 1);
15930 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
15931 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
15932 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
15933 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
15934 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
15935 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
15937 printf ("GPR %08lx GP 0x%lx\n",
15938 reginfo
.ri_gprmask
,
15939 (unsigned long) reginfo
.ri_gp_value
);
15940 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
15941 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
15942 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
15947 Elf64_External_RegInfo
* ereg
;
15948 Elf64_Internal_RegInfo reginfo
;
15950 ereg
= (Elf64_External_RegInfo
*) (option
+ 1);
15951 reginfo
.ri_gprmask
= BYTE_GET (ereg
->ri_gprmask
);
15952 reginfo
.ri_cprmask
[0] = BYTE_GET (ereg
->ri_cprmask
[0]);
15953 reginfo
.ri_cprmask
[1] = BYTE_GET (ereg
->ri_cprmask
[1]);
15954 reginfo
.ri_cprmask
[2] = BYTE_GET (ereg
->ri_cprmask
[2]);
15955 reginfo
.ri_cprmask
[3] = BYTE_GET (ereg
->ri_cprmask
[3]);
15956 reginfo
.ri_gp_value
= BYTE_GET (ereg
->ri_gp_value
);
15958 printf ("GPR %08lx GP 0x",
15959 reginfo
.ri_gprmask
);
15960 printf_vma (reginfo
.ri_gp_value
);
15963 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
15964 reginfo
.ri_cprmask
[0], reginfo
.ri_cprmask
[1],
15965 reginfo
.ri_cprmask
[2], reginfo
.ri_cprmask
[3]);
15969 case ODK_EXCEPTIONS
:
15970 fputs (" EXCEPTIONS fpe_min(", stdout
);
15971 process_mips_fpe_exception (option
->info
& OEX_FPU_MIN
);
15972 fputs (") fpe_max(", stdout
);
15973 process_mips_fpe_exception ((option
->info
& OEX_FPU_MAX
) >> 8);
15974 fputs (")", stdout
);
15976 if (option
->info
& OEX_PAGE0
)
15977 fputs (" PAGE0", stdout
);
15978 if (option
->info
& OEX_SMM
)
15979 fputs (" SMM", stdout
);
15980 if (option
->info
& OEX_FPDBUG
)
15981 fputs (" FPDBUG", stdout
);
15982 if (option
->info
& OEX_DISMISS
)
15983 fputs (" DISMISS", stdout
);
15986 fputs (" PAD ", stdout
);
15987 if (option
->info
& OPAD_PREFIX
)
15988 fputs (" PREFIX", stdout
);
15989 if (option
->info
& OPAD_POSTFIX
)
15990 fputs (" POSTFIX", stdout
);
15991 if (option
->info
& OPAD_SYMBOL
)
15992 fputs (" SYMBOL", stdout
);
15995 fputs (" HWPATCH ", stdout
);
15996 if (option
->info
& OHW_R4KEOP
)
15997 fputs (" R4KEOP", stdout
);
15998 if (option
->info
& OHW_R8KPFETCH
)
15999 fputs (" R8KPFETCH", stdout
);
16000 if (option
->info
& OHW_R5KEOP
)
16001 fputs (" R5KEOP", stdout
);
16002 if (option
->info
& OHW_R5KCVTL
)
16003 fputs (" R5KCVTL", stdout
);
16006 fputs (" FILL ", stdout
);
16007 /* XXX Print content of info word? */
16010 fputs (" TAGS ", stdout
);
16011 /* XXX Print content of info word? */
16014 fputs (" HWAND ", stdout
);
16015 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
16016 fputs (" R4KEOP_CHECKED", stdout
);
16017 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
16018 fputs (" R4KEOP_CLEAN", stdout
);
16021 fputs (" HWOR ", stdout
);
16022 if (option
->info
& OHWA0_R4KEOP_CHECKED
)
16023 fputs (" R4KEOP_CHECKED", stdout
);
16024 if (option
->info
& OHWA0_R4KEOP_CLEAN
)
16025 fputs (" R4KEOP_CLEAN", stdout
);
16028 printf (" GP_GROUP %#06lx self-contained %#06lx",
16029 option
->info
& OGP_GROUP
,
16030 (option
->info
& OGP_SELF
) >> 16);
16033 printf (" IDENT %#06lx self-contained %#06lx",
16034 option
->info
& OGP_GROUP
,
16035 (option
->info
& OGP_SELF
) >> 16);
16038 /* This shouldn't happen. */
16039 printf (" %3d ??? %d %lx",
16040 option
->kind
, option
->section
, option
->info
);
16044 len
= sizeof (* eopt
);
16045 while (len
< option
->size
)
16047 unsigned char datum
= * ((unsigned char *) eopt
+ offset
+ len
);
16049 if (ISPRINT (datum
))
16050 printf ("%c", datum
);
16052 printf ("\\%03o", datum
);
16055 fputs ("\n", stdout
);
16057 offset
+= option
->size
;
16067 if (conflicts_offset
!= 0 && conflictsno
!= 0)
16069 Elf32_Conflict
* iconf
;
16072 if (dynamic_symbols
== NULL
)
16074 error (_("conflict list found without a dynamic symbol table\n"));
16078 /* PR 21345 - print a slightly more helpful error message
16079 if we are sure that the cmalloc will fail. */
16080 if (conflictsno
* sizeof (* iconf
) > filedata
->file_size
)
16082 error (_("Overlarge number of conflicts detected: %lx\n"),
16083 (long) conflictsno
);
16087 iconf
= (Elf32_Conflict
*) cmalloc (conflictsno
, sizeof (* iconf
));
16090 error (_("Out of memory allocating space for dynamic conflicts\n"));
16096 Elf32_External_Conflict
* econf32
;
16098 econf32
= (Elf32_External_Conflict
*)
16099 get_data (NULL
, filedata
, conflicts_offset
, conflictsno
,
16100 sizeof (* econf32
), _("conflict"));
16104 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
16105 iconf
[cnt
] = BYTE_GET (econf32
[cnt
]);
16111 Elf64_External_Conflict
* econf64
;
16113 econf64
= (Elf64_External_Conflict
*)
16114 get_data (NULL
, filedata
, conflicts_offset
, conflictsno
,
16115 sizeof (* econf64
), _("conflict"));
16119 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
16120 iconf
[cnt
] = BYTE_GET (econf64
[cnt
]);
16125 printf (ngettext ("\nSection '.conflict' contains %lu entry:\n",
16126 "\nSection '.conflict' contains %lu entries:\n",
16127 (unsigned long) conflictsno
),
16128 (unsigned long) conflictsno
);
16129 puts (_(" Num: Index Value Name"));
16131 for (cnt
= 0; cnt
< conflictsno
; ++cnt
)
16133 printf ("%5lu: %8lu ", (unsigned long) cnt
, iconf
[cnt
]);
16135 if (iconf
[cnt
] >= num_dynamic_syms
)
16136 printf (_("<corrupt symbol index>"));
16139 Elf_Internal_Sym
* psym
;
16141 psym
= & dynamic_symbols
[iconf
[cnt
]];
16142 print_vma (psym
->st_value
, FULL_HEX
);
16144 if (VALID_DYNAMIC_NAME (psym
->st_name
))
16145 print_symbol (25, GET_DYNAMIC_NAME (psym
->st_name
));
16147 printf (_("<corrupt: %14ld>"), psym
->st_name
);
16155 if (pltgot
!= 0 && local_gotno
!= 0)
16157 bfd_vma ent
, local_end
, global_end
;
16159 unsigned char * data
;
16160 unsigned char * data_end
;
16164 addr_size
= (is_32bit_elf
? 4 : 8);
16165 local_end
= pltgot
+ local_gotno
* addr_size
;
16167 /* PR binutils/17533 file: 012-111227-0.004 */
16168 if (symtabno
< gotsym
)
16170 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
16171 (unsigned long) gotsym
, (unsigned long) symtabno
);
16175 global_end
= local_end
+ (symtabno
- gotsym
) * addr_size
;
16176 /* PR 17531: file: 54c91a34. */
16177 if (global_end
< local_end
)
16179 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno
);
16183 offset
= offset_from_vma (filedata
, pltgot
, global_end
- pltgot
);
16184 data
= (unsigned char *) get_data (NULL
, filedata
, offset
,
16185 global_end
- pltgot
, 1,
16186 _("Global Offset Table data"));
16187 /* PR 12855: Null data is handled gracefully throughout. */
16188 data_end
= data
+ (global_end
- pltgot
);
16190 printf (_("\nPrimary GOT:\n"));
16191 printf (_(" Canonical gp value: "));
16192 print_vma (pltgot
+ 0x7ff0, LONG_HEX
);
16195 printf (_(" Reserved entries:\n"));
16196 printf (_(" %*s %10s %*s Purpose\n"),
16197 addr_size
* 2, _("Address"), _("Access"),
16198 addr_size
* 2, _("Initial"));
16199 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16200 printf (_(" Lazy resolver\n"));
16201 if (ent
== (bfd_vma
) -1)
16202 goto got_print_fail
;
16204 /* Check for the MSB of GOT[1] being set, denoting a GNU object.
16205 This entry will be used by some runtime loaders, to store the
16206 module pointer. Otherwise this is an ordinary local entry.
16207 PR 21344: Check for the entry being fully available before
16210 && data
+ ent
- pltgot
+ addr_size
<= data_end
16211 && (byte_get (data
+ ent
- pltgot
, addr_size
)
16212 >> (addr_size
* 8 - 1)) != 0)
16214 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16215 printf (_(" Module pointer (GNU extension)\n"));
16216 if (ent
== (bfd_vma
) -1)
16217 goto got_print_fail
;
16221 if (data
!= NULL
&& ent
< local_end
)
16223 printf (_(" Local entries:\n"));
16224 printf (" %*s %10s %*s\n",
16225 addr_size
* 2, _("Address"), _("Access"),
16226 addr_size
* 2, _("Initial"));
16227 while (ent
< local_end
)
16229 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16231 if (ent
== (bfd_vma
) -1)
16232 goto got_print_fail
;
16237 if (data
!= NULL
&& gotsym
< symtabno
)
16241 printf (_(" Global entries:\n"));
16242 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
16243 addr_size
* 2, _("Address"),
16245 addr_size
* 2, _("Initial"),
16246 addr_size
* 2, _("Sym.Val."),
16248 /* Note for translators: "Ndx" = abbreviated form of "Index". */
16249 _("Ndx"), _("Name"));
16251 sym_width
= (is_32bit_elf
? 80 : 160) - 28 - addr_size
* 6 - 1;
16253 for (i
= gotsym
; i
< symtabno
; i
++)
16255 ent
= print_mips_got_entry (data
, pltgot
, ent
, data_end
);
16258 if (dynamic_symbols
== NULL
)
16259 printf (_("<no dynamic symbols>"));
16260 else if (i
< num_dynamic_syms
)
16262 Elf_Internal_Sym
* psym
= dynamic_symbols
+ i
;
16264 print_vma (psym
->st_value
, LONG_HEX
);
16265 printf (" %-7s %3s ",
16266 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
16267 get_symbol_index_type (filedata
, psym
->st_shndx
));
16269 if (VALID_DYNAMIC_NAME (psym
->st_name
))
16270 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
16272 printf (_("<corrupt: %14ld>"), psym
->st_name
);
16275 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
16276 (unsigned long) i
);
16279 if (ent
== (bfd_vma
) -1)
16290 if (mips_pltgot
!= 0 && jmprel
!= 0 && pltrel
!= 0 && pltrelsz
!= 0)
16293 size_t offset
, rel_offset
;
16294 unsigned long count
, i
;
16295 unsigned char * data
;
16296 int addr_size
, sym_width
;
16297 Elf_Internal_Rela
* rels
;
16299 rel_offset
= offset_from_vma (filedata
, jmprel
, pltrelsz
);
16300 if (pltrel
== DT_RELA
)
16302 if (!slurp_rela_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
16307 if (!slurp_rel_relocs (filedata
, rel_offset
, pltrelsz
, &rels
, &count
))
16312 addr_size
= (is_32bit_elf
? 4 : 8);
16313 end
= mips_pltgot
+ (2 + count
) * addr_size
;
16315 offset
= offset_from_vma (filedata
, mips_pltgot
, end
- mips_pltgot
);
16316 data
= (unsigned char *) get_data (NULL
, filedata
, offset
, end
- mips_pltgot
,
16317 1, _("Procedure Linkage Table data"));
16321 printf ("\nPLT GOT:\n\n");
16322 printf (_(" Reserved entries:\n"));
16323 printf (_(" %*s %*s Purpose\n"),
16324 addr_size
* 2, _("Address"), addr_size
* 2, _("Initial"));
16325 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
16326 printf (_(" PLT lazy resolver\n"));
16327 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
16328 printf (_(" Module pointer\n"));
16331 printf (_(" Entries:\n"));
16332 printf (" %*s %*s %*s %-7s %3s %s\n",
16333 addr_size
* 2, _("Address"),
16334 addr_size
* 2, _("Initial"),
16335 addr_size
* 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
16336 sym_width
= (is_32bit_elf
? 80 : 160) - 17 - addr_size
* 6 - 1;
16337 for (i
= 0; i
< count
; i
++)
16339 unsigned long idx
= get_reloc_symindex (rels
[i
].r_info
);
16341 ent
= print_mips_pltgot_entry (data
, mips_pltgot
, ent
);
16344 if (idx
>= num_dynamic_syms
)
16345 printf (_("<corrupt symbol index: %lu>"), idx
);
16348 Elf_Internal_Sym
* psym
= dynamic_symbols
+ idx
;
16350 print_vma (psym
->st_value
, LONG_HEX
);
16351 printf (" %-7s %3s ",
16352 get_symbol_type (filedata
, ELF_ST_TYPE (psym
->st_info
)),
16353 get_symbol_index_type (filedata
, psym
->st_shndx
));
16354 if (VALID_DYNAMIC_NAME (psym
->st_name
))
16355 print_symbol (sym_width
, GET_DYNAMIC_NAME (psym
->st_name
));
16357 printf (_("<corrupt: %14ld>"), psym
->st_name
);
16372 process_nds32_specific (Filedata
* filedata
)
16374 Elf_Internal_Shdr
*sect
= NULL
;
16376 sect
= find_section (filedata
, ".nds32_e_flags");
16379 unsigned int *flag
;
16381 printf ("\nNDS32 elf flags section:\n");
16382 flag
= get_data (NULL
, filedata
, sect
->sh_offset
, 1,
16383 sect
->sh_size
, _("NDS32 elf flags section"));
16388 switch ((*flag
) & 0x3)
16391 printf ("(VEC_SIZE):\tNo entry.\n");
16394 printf ("(VEC_SIZE):\t4 bytes\n");
16397 printf ("(VEC_SIZE):\t16 bytes\n");
16400 printf ("(VEC_SIZE):\treserved\n");
16409 process_gnu_liblist (Filedata
* filedata
)
16411 Elf_Internal_Shdr
* section
;
16412 Elf_Internal_Shdr
* string_sec
;
16413 Elf32_External_Lib
* elib
;
16415 size_t strtab_size
;
16417 unsigned long num_liblist
;
16419 bfd_boolean res
= TRUE
;
16424 for (i
= 0, section
= filedata
->section_headers
;
16425 i
< filedata
->file_header
.e_shnum
;
16428 switch (section
->sh_type
)
16430 case SHT_GNU_LIBLIST
:
16431 if (section
->sh_link
>= filedata
->file_header
.e_shnum
)
16434 elib
= (Elf32_External_Lib
*)
16435 get_data (NULL
, filedata
, section
->sh_offset
, 1, section
->sh_size
,
16436 _("liblist section data"));
16444 string_sec
= filedata
->section_headers
+ section
->sh_link
;
16445 strtab
= (char *) get_data (NULL
, filedata
, string_sec
->sh_offset
, 1,
16446 string_sec
->sh_size
,
16447 _("liblist string table"));
16449 || section
->sh_entsize
!= sizeof (Elf32_External_Lib
))
16456 strtab_size
= string_sec
->sh_size
;
16458 num_liblist
= section
->sh_size
/ sizeof (Elf32_External_Lib
);
16459 printf (ngettext ("\nLibrary list section '%s' contains %lu entries:\n",
16460 "\nLibrary list section '%s' contains %lu entries:\n",
16462 printable_section_name (filedata
, section
),
16465 puts (_(" Library Time Stamp Checksum Version Flags"));
16467 for (cnt
= 0; cnt
< section
->sh_size
/ sizeof (Elf32_External_Lib
);
16475 liblist
.l_name
= BYTE_GET (elib
[cnt
].l_name
);
16476 atime
= BYTE_GET (elib
[cnt
].l_time_stamp
);
16477 liblist
.l_checksum
= BYTE_GET (elib
[cnt
].l_checksum
);
16478 liblist
.l_version
= BYTE_GET (elib
[cnt
].l_version
);
16479 liblist
.l_flags
= BYTE_GET (elib
[cnt
].l_flags
);
16481 tmp
= gmtime (&atime
);
16482 snprintf (timebuf
, sizeof (timebuf
),
16483 "%04u-%02u-%02uT%02u:%02u:%02u",
16484 tmp
->tm_year
+ 1900, tmp
->tm_mon
+ 1, tmp
->tm_mday
,
16485 tmp
->tm_hour
, tmp
->tm_min
, tmp
->tm_sec
);
16487 printf ("%3lu: ", (unsigned long) cnt
);
16489 printf ("%-20s", liblist
.l_name
< strtab_size
16490 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
16492 printf ("%-20.20s", liblist
.l_name
< strtab_size
16493 ? strtab
+ liblist
.l_name
: _("<corrupt>"));
16494 printf (" %s %#010lx %-7ld %-7ld\n", timebuf
, liblist
.l_checksum
,
16495 liblist
.l_version
, liblist
.l_flags
);
16506 static const char *
16507 get_note_type (Filedata
* filedata
, unsigned e_type
)
16509 static char buff
[64];
16511 if (filedata
->file_header
.e_type
== ET_CORE
)
16515 return _("NT_AUXV (auxiliary vector)");
16517 return _("NT_PRSTATUS (prstatus structure)");
16519 return _("NT_FPREGSET (floating point registers)");
16521 return _("NT_PRPSINFO (prpsinfo structure)");
16522 case NT_TASKSTRUCT
:
16523 return _("NT_TASKSTRUCT (task structure)");
16525 return _("NT_PRXFPREG (user_xfpregs structure)");
16527 return _("NT_PPC_VMX (ppc Altivec registers)");
16529 return _("NT_PPC_VSX (ppc VSX registers)");
16531 return _("NT_PPC_TAR (ppc TAR register)");
16533 return _("NT_PPC_PPR (ppc PPR register)");
16535 return _("NT_PPC_DSCR (ppc DSCR register)");
16537 return _("NT_PPC_EBB (ppc EBB registers)");
16539 return _("NT_PPC_PMU (ppc PMU registers)");
16540 case NT_PPC_TM_CGPR
:
16541 return _("NT_PPC_TM_CGPR (ppc checkpointed GPR registers)");
16542 case NT_PPC_TM_CFPR
:
16543 return _("NT_PPC_TM_CFPR (ppc checkpointed floating point registers)");
16544 case NT_PPC_TM_CVMX
:
16545 return _("NT_PPC_TM_CVMX (ppc checkpointed Altivec registers)");
16546 case NT_PPC_TM_CVSX
:
16547 return _("NT_PPC_TM_VSX (ppc checkpointed VSX registers)");
16548 case NT_PPC_TM_SPR
:
16549 return _("NT_PPC_TM_SPR (ppc TM special purpose registers)");
16550 case NT_PPC_TM_CTAR
:
16551 return _("NT_PPC_TM_CTAR (ppc checkpointed TAR register)");
16552 case NT_PPC_TM_CPPR
:
16553 return _("NT_PPC_TM_CPPR (ppc checkpointed PPR register)");
16554 case NT_PPC_TM_CDSCR
:
16555 return _("NT_PPC_TM_CDSCR (ppc checkpointed DSCR register)");
16557 return _("NT_386_TLS (x86 TLS information)");
16558 case NT_386_IOPERM
:
16559 return _("NT_386_IOPERM (x86 I/O permissions)");
16560 case NT_X86_XSTATE
:
16561 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
16562 case NT_S390_HIGH_GPRS
:
16563 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
16564 case NT_S390_TIMER
:
16565 return _("NT_S390_TIMER (s390 timer register)");
16566 case NT_S390_TODCMP
:
16567 return _("NT_S390_TODCMP (s390 TOD comparator register)");
16568 case NT_S390_TODPREG
:
16569 return _("NT_S390_TODPREG (s390 TOD programmable register)");
16571 return _("NT_S390_CTRS (s390 control registers)");
16572 case NT_S390_PREFIX
:
16573 return _("NT_S390_PREFIX (s390 prefix register)");
16574 case NT_S390_LAST_BREAK
:
16575 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
16576 case NT_S390_SYSTEM_CALL
:
16577 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
16579 return _("NT_S390_TDB (s390 transaction diagnostic block)");
16580 case NT_S390_VXRS_LOW
:
16581 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
16582 case NT_S390_VXRS_HIGH
:
16583 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
16584 case NT_S390_GS_CB
:
16585 return _("NT_S390_GS_CB (s390 guarded-storage registers)");
16586 case NT_S390_GS_BC
:
16587 return _("NT_S390_GS_BC (s390 guarded-storage broadcast control)");
16589 return _("NT_ARM_VFP (arm VFP registers)");
16591 return _("NT_ARM_TLS (AArch TLS registers)");
16592 case NT_ARM_HW_BREAK
:
16593 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
16594 case NT_ARM_HW_WATCH
:
16595 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
16597 return _("NT_PSTATUS (pstatus structure)");
16599 return _("NT_FPREGS (floating point registers)");
16601 return _("NT_PSINFO (psinfo structure)");
16603 return _("NT_LWPSTATUS (lwpstatus_t structure)");
16605 return _("NT_LWPSINFO (lwpsinfo_t structure)");
16606 case NT_WIN32PSTATUS
:
16607 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
16609 return _("NT_SIGINFO (siginfo_t data)");
16611 return _("NT_FILE (mapped files)");
16619 return _("NT_VERSION (version)");
16621 return _("NT_ARCH (architecture)");
16622 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
16624 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
16630 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16635 print_core_note (Elf_Internal_Note
*pnote
)
16637 unsigned int addr_size
= is_32bit_elf
? 4 : 8;
16638 bfd_vma count
, page_size
;
16639 unsigned char *descdata
, *filenames
, *descend
;
16641 if (pnote
->type
!= NT_FILE
)
16651 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
16652 /* Still "successful". */
16657 if (pnote
->descsz
< 2 * addr_size
)
16659 error (_(" Malformed note - too short for header\n"));
16663 descdata
= (unsigned char *) pnote
->descdata
;
16664 descend
= descdata
+ pnote
->descsz
;
16666 if (descdata
[pnote
->descsz
- 1] != '\0')
16668 error (_(" Malformed note - does not end with \\0\n"));
16672 count
= byte_get (descdata
, addr_size
);
16673 descdata
+= addr_size
;
16675 page_size
= byte_get (descdata
, addr_size
);
16676 descdata
+= addr_size
;
16678 if (count
> ((bfd_vma
) -1 - 2 * addr_size
) / (3 * addr_size
)
16679 || pnote
->descsz
< 2 * addr_size
+ count
* 3 * addr_size
)
16681 error (_(" Malformed note - too short for supplied file count\n"));
16685 printf (_(" Page size: "));
16686 print_vma (page_size
, DEC
);
16689 printf (_(" %*s%*s%*s\n"),
16690 (int) (2 + 2 * addr_size
), _("Start"),
16691 (int) (4 + 2 * addr_size
), _("End"),
16692 (int) (4 + 2 * addr_size
), _("Page Offset"));
16693 filenames
= descdata
+ count
* 3 * addr_size
;
16694 while (count
-- > 0)
16696 bfd_vma start
, end
, file_ofs
;
16698 if (filenames
== descend
)
16700 error (_(" Malformed note - filenames end too early\n"));
16704 start
= byte_get (descdata
, addr_size
);
16705 descdata
+= addr_size
;
16706 end
= byte_get (descdata
, addr_size
);
16707 descdata
+= addr_size
;
16708 file_ofs
= byte_get (descdata
, addr_size
);
16709 descdata
+= addr_size
;
16712 print_vma (start
, FULL_HEX
);
16714 print_vma (end
, FULL_HEX
);
16716 print_vma (file_ofs
, FULL_HEX
);
16717 printf ("\n %s\n", filenames
);
16719 filenames
+= 1 + strlen ((char *) filenames
);
16725 static const char *
16726 get_gnu_elf_note_type (unsigned e_type
)
16728 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
16731 case NT_GNU_ABI_TAG
:
16732 return _("NT_GNU_ABI_TAG (ABI version tag)");
16734 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
16735 case NT_GNU_BUILD_ID
:
16736 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
16737 case NT_GNU_GOLD_VERSION
:
16738 return _("NT_GNU_GOLD_VERSION (gold version)");
16739 case NT_GNU_PROPERTY_TYPE_0
:
16740 return _("NT_GNU_PROPERTY_TYPE_0");
16741 case NT_GNU_BUILD_ATTRIBUTE_OPEN
:
16742 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
16743 case NT_GNU_BUILD_ATTRIBUTE_FUNC
:
16744 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
16747 static char buff
[64];
16749 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
16756 decode_x86_isa (unsigned int bitmask
)
16760 unsigned int bit
= bitmask
& (- bitmask
);
16765 case GNU_PROPERTY_X86_ISA_1_486
: printf ("i486"); break;
16766 case GNU_PROPERTY_X86_ISA_1_586
: printf ("586"); break;
16767 case GNU_PROPERTY_X86_ISA_1_686
: printf ("686"); break;
16768 case GNU_PROPERTY_X86_ISA_1_SSE
: printf ("SSE"); break;
16769 case GNU_PROPERTY_X86_ISA_1_SSE2
: printf ("SSE2"); break;
16770 case GNU_PROPERTY_X86_ISA_1_SSE3
: printf ("SSE3"); break;
16771 case GNU_PROPERTY_X86_ISA_1_SSSE3
: printf ("SSSE3"); break;
16772 case GNU_PROPERTY_X86_ISA_1_SSE4_1
: printf ("SSE4_1"); break;
16773 case GNU_PROPERTY_X86_ISA_1_SSE4_2
: printf ("SSE4_2"); break;
16774 case GNU_PROPERTY_X86_ISA_1_AVX
: printf ("AVX"); break;
16775 case GNU_PROPERTY_X86_ISA_1_AVX2
: printf ("AVX2"); break;
16776 case GNU_PROPERTY_X86_ISA_1_AVX512F
: printf ("AVX512F"); break;
16777 case GNU_PROPERTY_X86_ISA_1_AVX512CD
: printf ("AVX512CD"); break;
16778 case GNU_PROPERTY_X86_ISA_1_AVX512ER
: printf ("AVX512ER"); break;
16779 case GNU_PROPERTY_X86_ISA_1_AVX512PF
: printf ("AVX512PF"); break;
16780 case GNU_PROPERTY_X86_ISA_1_AVX512VL
: printf ("AVX512VL"); break;
16781 case GNU_PROPERTY_X86_ISA_1_AVX512DQ
: printf ("AVX512DQ"); break;
16782 case GNU_PROPERTY_X86_ISA_1_AVX512BW
: printf ("AVX512BW"); break;
16783 default: printf (_("<unknown: %x>"), bit
); break;
16791 decode_x86_feature (unsigned int type
, unsigned int bitmask
)
16795 unsigned int bit
= bitmask
& (- bitmask
);
16800 case GNU_PROPERTY_X86_FEATURE_1_IBT
:
16803 case GNU_PROPERTY_X86_FEATURE_1_AND
:
16807 /* This should never happen. */
16811 case GNU_PROPERTY_X86_FEATURE_1_SHSTK
:
16814 case GNU_PROPERTY_X86_FEATURE_1_AND
:
16818 /* This should never happen. */
16823 printf (_("<unknown: %x>"), bit
);
16832 print_gnu_property_note (Filedata
* filedata
, Elf_Internal_Note
* pnote
)
16834 unsigned char * ptr
= (unsigned char *) pnote
->descdata
;
16835 unsigned char * ptr_end
= ptr
+ pnote
->descsz
;
16836 unsigned int size
= is_32bit_elf
? 4 : 8;
16838 printf (_(" Properties: "));
16840 if (pnote
->descsz
< 8 || (pnote
->descsz
% size
) != 0)
16842 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote
->descsz
);
16846 while (ptr
< ptr_end
)
16850 unsigned int datasz
;
16852 if ((size_t) (ptr_end
- ptr
) < 8)
16854 printf (_("<corrupt descsz: %#lx>\n"), pnote
->descsz
);
16858 type
= byte_get (ptr
, 4);
16859 datasz
= byte_get (ptr
+ 4, 4);
16863 if (datasz
> (size_t) (ptr_end
- ptr
))
16865 printf (_("<corrupt type (%#x) datasz: %#x>\n"),
16870 if (type
>= GNU_PROPERTY_LOPROC
&& type
<= GNU_PROPERTY_HIPROC
)
16872 if (filedata
->file_header
.e_machine
== EM_X86_64
16873 || filedata
->file_header
.e_machine
== EM_IAMCU
16874 || filedata
->file_header
.e_machine
== EM_386
)
16878 case GNU_PROPERTY_X86_ISA_1_USED
:
16879 printf ("x86 ISA used: ");
16881 printf (_("<corrupt length: %#x> "), datasz
);
16883 decode_x86_isa (byte_get (ptr
, 4));
16886 case GNU_PROPERTY_X86_ISA_1_NEEDED
:
16887 printf ("x86 ISA needed: ");
16889 printf (_("<corrupt length: %#x> "), datasz
);
16891 decode_x86_isa (byte_get (ptr
, 4));
16894 case GNU_PROPERTY_X86_FEATURE_1_AND
:
16895 printf ("x86 feature: ");
16897 printf (_("<corrupt length: %#x> "), datasz
);
16899 decode_x86_feature (type
, byte_get (ptr
, 4));
16911 case GNU_PROPERTY_STACK_SIZE
:
16912 printf (_("stack size: "));
16913 if (datasz
!= size
)
16914 printf (_("<corrupt length: %#x> "), datasz
);
16916 printf ("%#lx", (unsigned long) byte_get (ptr
, size
));
16919 case GNU_PROPERTY_NO_COPY_ON_PROTECTED
:
16920 printf ("no copy on protected ");
16922 printf (_("<corrupt length: %#x> "), datasz
);
16930 if (type
< GNU_PROPERTY_LOPROC
)
16931 printf (_("<unknown type %#x data: "), type
);
16932 else if (type
< GNU_PROPERTY_LOUSER
)
16933 printf (_("<procesor-specific type %#x data: "), type
);
16935 printf (_("<application-specific type %#x data: "), type
);
16936 for (j
= 0; j
< datasz
; ++j
)
16937 printf ("%02x ", ptr
[j
] & 0xff);
16941 ptr
+= ((datasz
+ (size
- 1)) & ~ (size
- 1));
16942 if (ptr
== ptr_end
)
16955 print_gnu_note (Filedata
* filedata
, Elf_Internal_Note
*pnote
)
16957 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
16958 switch (pnote
->type
)
16960 case NT_GNU_BUILD_ID
:
16964 printf (_(" Build ID: "));
16965 for (i
= 0; i
< pnote
->descsz
; ++i
)
16966 printf ("%02x", pnote
->descdata
[i
] & 0xff);
16971 case NT_GNU_ABI_TAG
:
16973 unsigned long os
, major
, minor
, subminor
;
16974 const char *osname
;
16976 /* PR 17531: file: 030-599401-0.004. */
16977 if (pnote
->descsz
< 16)
16979 printf (_(" <corrupt GNU_ABI_TAG>\n"));
16983 os
= byte_get ((unsigned char *) pnote
->descdata
, 4);
16984 major
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
16985 minor
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 4);
16986 subminor
= byte_get ((unsigned char *) pnote
->descdata
+ 12, 4);
16990 case GNU_ABI_TAG_LINUX
:
16993 case GNU_ABI_TAG_HURD
:
16996 case GNU_ABI_TAG_SOLARIS
:
16997 osname
= "Solaris";
16999 case GNU_ABI_TAG_FREEBSD
:
17000 osname
= "FreeBSD";
17002 case GNU_ABI_TAG_NETBSD
:
17005 case GNU_ABI_TAG_SYLLABLE
:
17006 osname
= "Syllable";
17008 case GNU_ABI_TAG_NACL
:
17012 osname
= "Unknown";
17016 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname
,
17017 major
, minor
, subminor
);
17021 case NT_GNU_GOLD_VERSION
:
17025 printf (_(" Version: "));
17026 for (i
= 0; i
< pnote
->descsz
&& pnote
->descdata
[i
] != '\0'; ++i
)
17027 printf ("%c", pnote
->descdata
[i
]);
17034 unsigned long num_entries
, mask
;
17036 /* Hardware capabilities information. Word 0 is the number of entries.
17037 Word 1 is a bitmask of enabled entries. The rest of the descriptor
17038 is a series of entries, where each entry is a single byte followed
17039 by a nul terminated string. The byte gives the bit number to test
17040 if enabled in the bitmask. */
17041 printf (_(" Hardware Capabilities: "));
17042 if (pnote
->descsz
< 8)
17044 error (_("<corrupt GNU_HWCAP>\n"));
17047 num_entries
= byte_get ((unsigned char *) pnote
->descdata
, 4);
17048 mask
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
17049 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries
, mask
);
17050 /* FIXME: Add code to display the entries... */
17054 case NT_GNU_PROPERTY_TYPE_0
:
17055 print_gnu_property_note (filedata
, pnote
);
17059 /* Handle unrecognised types. An error message should have already been
17060 created by get_gnu_elf_note_type(), so all that we need to do is to
17061 display the data. */
17065 printf (_(" Description data: "));
17066 for (i
= 0; i
< pnote
->descsz
; ++i
)
17067 printf ("%02x ", pnote
->descdata
[i
] & 0xff);
17076 static const char *
17077 get_v850_elf_note_type (enum v850_notes n_type
)
17079 static char buff
[64];
17083 case V850_NOTE_ALIGNMENT
: return _("Alignment of 8-byte objects");
17084 case V850_NOTE_DATA_SIZE
: return _("Sizeof double and long double");
17085 case V850_NOTE_FPU_INFO
: return _("Type of FPU support needed");
17086 case V850_NOTE_SIMD_INFO
: return _("Use of SIMD instructions");
17087 case V850_NOTE_CACHE_INFO
: return _("Use of cache");
17088 case V850_NOTE_MMU_INFO
: return _("Use of MMU");
17090 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), n_type
);
17096 print_v850_note (Elf_Internal_Note
* pnote
)
17100 if (pnote
->descsz
!= 4)
17103 val
= byte_get ((unsigned char *) pnote
->descdata
, pnote
->descsz
);
17107 printf (_("not set\n"));
17111 switch (pnote
->type
)
17113 case V850_NOTE_ALIGNMENT
:
17116 case EF_RH850_DATA_ALIGN4
: printf (_("4-byte\n")); return TRUE
;
17117 case EF_RH850_DATA_ALIGN8
: printf (_("8-byte\n")); return TRUE
;
17121 case V850_NOTE_DATA_SIZE
:
17124 case EF_RH850_DOUBLE32
: printf (_("4-bytes\n")); return TRUE
;
17125 case EF_RH850_DOUBLE64
: printf (_("8-bytes\n")); return TRUE
;
17129 case V850_NOTE_FPU_INFO
:
17132 case EF_RH850_FPU20
: printf (_("FPU-2.0\n")); return TRUE
;
17133 case EF_RH850_FPU30
: printf (_("FPU-3.0\n")); return TRUE
;
17137 case V850_NOTE_MMU_INFO
:
17138 case V850_NOTE_CACHE_INFO
:
17139 case V850_NOTE_SIMD_INFO
:
17140 if (val
== EF_RH850_SIMD
)
17142 printf (_("yes\n"));
17148 /* An 'unknown note type' message will already have been displayed. */
17152 printf (_("unknown value: %x\n"), val
);
17157 process_netbsd_elf_note (Elf_Internal_Note
* pnote
)
17159 unsigned int version
;
17161 switch (pnote
->type
)
17163 case NT_NETBSD_IDENT
:
17164 version
= byte_get ((unsigned char *) pnote
->descdata
, sizeof (version
));
17165 if ((version
/ 10000) % 100)
17166 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote
->descsz
,
17167 version
, version
/ 100000000, (version
/ 1000000) % 100,
17168 (version
/ 10000) % 100 > 26 ? "Z" : "",
17169 'A' + (version
/ 10000) % 26);
17171 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote
->descsz
,
17172 version
, version
/ 100000000, (version
/ 1000000) % 100,
17173 (version
/ 100) % 100);
17176 case NT_NETBSD_MARCH
:
17177 printf (" NetBSD\t0x%08lx\tMARCH <%s>\n", pnote
->descsz
,
17182 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote
->descsz
,
17188 static const char *
17189 get_freebsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
17193 case NT_FREEBSD_THRMISC
:
17194 return _("NT_THRMISC (thrmisc structure)");
17195 case NT_FREEBSD_PROCSTAT_PROC
:
17196 return _("NT_PROCSTAT_PROC (proc data)");
17197 case NT_FREEBSD_PROCSTAT_FILES
:
17198 return _("NT_PROCSTAT_FILES (files data)");
17199 case NT_FREEBSD_PROCSTAT_VMMAP
:
17200 return _("NT_PROCSTAT_VMMAP (vmmap data)");
17201 case NT_FREEBSD_PROCSTAT_GROUPS
:
17202 return _("NT_PROCSTAT_GROUPS (groups data)");
17203 case NT_FREEBSD_PROCSTAT_UMASK
:
17204 return _("NT_PROCSTAT_UMASK (umask data)");
17205 case NT_FREEBSD_PROCSTAT_RLIMIT
:
17206 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
17207 case NT_FREEBSD_PROCSTAT_OSREL
:
17208 return _("NT_PROCSTAT_OSREL (osreldate data)");
17209 case NT_FREEBSD_PROCSTAT_PSSTRINGS
:
17210 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
17211 case NT_FREEBSD_PROCSTAT_AUXV
:
17212 return _("NT_PROCSTAT_AUXV (auxv data)");
17213 case NT_FREEBSD_PTLWPINFO
:
17214 return _("NT_PTLWPINFO (ptrace_lwpinfo structure)");
17216 return get_note_type (filedata
, e_type
);
17219 static const char *
17220 get_netbsd_elfcore_note_type (Filedata
* filedata
, unsigned e_type
)
17222 static char buff
[64];
17224 if (e_type
== NT_NETBSDCORE_PROCINFO
)
17225 return _("NetBSD procinfo structure");
17227 /* As of Jan 2002 there are no other machine-independent notes
17228 defined for NetBSD core files. If the note type is less
17229 than the start of the machine-dependent note types, we don't
17232 if (e_type
< NT_NETBSDCORE_FIRSTMACH
)
17234 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17238 switch (filedata
->file_header
.e_machine
)
17240 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
17241 and PT_GETFPREGS == mach+2. */
17246 case EM_SPARC32PLUS
:
17250 case NT_NETBSDCORE_FIRSTMACH
+ 0:
17251 return _("PT_GETREGS (reg structure)");
17252 case NT_NETBSDCORE_FIRSTMACH
+ 2:
17253 return _("PT_GETFPREGS (fpreg structure)");
17259 /* On all other arch's, PT_GETREGS == mach+1 and
17260 PT_GETFPREGS == mach+3. */
17264 case NT_NETBSDCORE_FIRSTMACH
+ 1:
17265 return _("PT_GETREGS (reg structure)");
17266 case NT_NETBSDCORE_FIRSTMACH
+ 3:
17267 return _("PT_GETFPREGS (fpreg structure)");
17273 snprintf (buff
, sizeof (buff
), "PT_FIRSTMACH+%d",
17274 e_type
- NT_NETBSDCORE_FIRSTMACH
);
17278 static const char *
17279 get_stapsdt_note_type (unsigned e_type
)
17281 static char buff
[64];
17286 return _("NT_STAPSDT (SystemTap probe descriptors)");
17292 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17297 print_stapsdt_note (Elf_Internal_Note
*pnote
)
17299 int addr_size
= is_32bit_elf
? 4 : 8;
17300 char *data
= pnote
->descdata
;
17301 char *data_end
= pnote
->descdata
+ pnote
->descsz
;
17302 bfd_vma pc
, base_addr
, semaphore
;
17303 char *provider
, *probe
, *arg_fmt
;
17305 pc
= byte_get ((unsigned char *) data
, addr_size
);
17307 base_addr
= byte_get ((unsigned char *) data
, addr_size
);
17309 semaphore
= byte_get ((unsigned char *) data
, addr_size
);
17313 data
+= strlen (data
) + 1;
17315 data
+= strlen (data
) + 1;
17317 data
+= strlen (data
) + 1;
17319 printf (_(" Provider: %s\n"), provider
);
17320 printf (_(" Name: %s\n"), probe
);
17321 printf (_(" Location: "));
17322 print_vma (pc
, FULL_HEX
);
17323 printf (_(", Base: "));
17324 print_vma (base_addr
, FULL_HEX
);
17325 printf (_(", Semaphore: "));
17326 print_vma (semaphore
, FULL_HEX
);
17328 printf (_(" Arguments: %s\n"), arg_fmt
);
17330 return data
== data_end
;
17333 static const char *
17334 get_ia64_vms_note_type (unsigned e_type
)
17336 static char buff
[64];
17341 return _("NT_VMS_MHD (module header)");
17343 return _("NT_VMS_LNM (language name)");
17345 return _("NT_VMS_SRC (source files)");
17347 return "NT_VMS_TITLE";
17349 return _("NT_VMS_EIDC (consistency check)");
17350 case NT_VMS_FPMODE
:
17351 return _("NT_VMS_FPMODE (FP mode)");
17352 case NT_VMS_LINKTIME
:
17353 return "NT_VMS_LINKTIME";
17354 case NT_VMS_IMGNAM
:
17355 return _("NT_VMS_IMGNAM (image name)");
17357 return _("NT_VMS_IMGID (image id)");
17358 case NT_VMS_LINKID
:
17359 return _("NT_VMS_LINKID (link id)");
17360 case NT_VMS_IMGBID
:
17361 return _("NT_VMS_IMGBID (build id)");
17362 case NT_VMS_GSTNAM
:
17363 return _("NT_VMS_GSTNAM (sym table name)");
17364 case NT_VMS_ORIG_DYN
:
17365 return "NT_VMS_ORIG_DYN";
17366 case NT_VMS_PATCHTIME
:
17367 return "NT_VMS_PATCHTIME";
17369 snprintf (buff
, sizeof (buff
), _("Unknown note type: (0x%08x)"), e_type
);
17375 print_ia64_vms_note (Elf_Internal_Note
* pnote
)
17377 switch (pnote
->type
)
17380 if (pnote
->descsz
> 36)
17382 size_t l
= strlen (pnote
->descdata
+ 34);
17383 printf (_(" Creation date : %.17s\n"), pnote
->descdata
);
17384 printf (_(" Last patch date: %.17s\n"), pnote
->descdata
+ 17);
17385 printf (_(" Module name : %s\n"), pnote
->descdata
+ 34);
17386 printf (_(" Module version : %s\n"), pnote
->descdata
+ 34 + l
+ 1);
17389 printf (_(" Invalid size\n"));
17392 printf (_(" Language: %s\n"), pnote
->descdata
);
17395 case NT_VMS_FPMODE
:
17396 printf (_(" Floating Point mode: "));
17397 printf ("0x%016" BFD_VMA_FMT
"x\n",
17398 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
, 8));
17400 case NT_VMS_LINKTIME
:
17401 printf (_(" Link time: "));
17403 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
17406 case NT_VMS_PATCHTIME
:
17407 printf (_(" Patch time: "));
17409 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
, 8));
17412 case NT_VMS_ORIG_DYN
:
17413 printf (_(" Major id: %u, minor id: %u\n"),
17414 (unsigned) byte_get ((unsigned char *)pnote
->descdata
, 4),
17415 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 4, 4));
17416 printf (_(" Last modified : "));
17418 ((bfd_int64_t
) byte_get ((unsigned char *)pnote
->descdata
+ 8, 8));
17419 printf (_("\n Link flags : "));
17420 printf ("0x%016" BFD_VMA_FMT
"x\n",
17421 (bfd_vma
) byte_get ((unsigned char *)pnote
->descdata
+ 16, 8));
17422 printf (_(" Header flags: 0x%08x\n"),
17423 (unsigned) byte_get ((unsigned char *)pnote
->descdata
+ 24, 4));
17424 printf (_(" Image id : %s\n"), pnote
->descdata
+ 32);
17427 case NT_VMS_IMGNAM
:
17428 printf (_(" Image name: %s\n"), pnote
->descdata
);
17430 case NT_VMS_GSTNAM
:
17431 printf (_(" Global symbol table name: %s\n"), pnote
->descdata
);
17434 printf (_(" Image id: %s\n"), pnote
->descdata
);
17436 case NT_VMS_LINKID
:
17437 printf (_(" Linker id: %s\n"), pnote
->descdata
);
17445 /* Find the symbol associated with a build attribute that is attached
17446 to address OFFSET. If PNAME is non-NULL then store the name of
17447 the symbol (if found) in the provided pointer, Returns NULL if a
17448 symbol could not be found. */
17450 static Elf_Internal_Sym
*
17451 get_symbol_for_build_attribute (Filedata
* filedata
,
17452 unsigned long offset
,
17453 bfd_boolean is_open_attr
,
17454 const char ** pname
)
17456 static Filedata
* saved_filedata
= NULL
;
17457 static char * strtab
;
17458 static unsigned long strtablen
;
17459 static Elf_Internal_Sym
* symtab
;
17460 static unsigned long nsyms
;
17461 Elf_Internal_Sym
* saved_sym
= NULL
;
17462 Elf_Internal_Sym
* sym
;
17464 if (filedata
->section_headers
!= NULL
17465 && (saved_filedata
== NULL
|| filedata
!= saved_filedata
))
17467 Elf_Internal_Shdr
* symsec
;
17469 /* Load the symbol and string sections. */
17470 for (symsec
= filedata
->section_headers
;
17471 symsec
< filedata
->section_headers
+ filedata
->file_header
.e_shnum
;
17474 if (symsec
->sh_type
== SHT_SYMTAB
)
17476 symtab
= GET_ELF_SYMBOLS (filedata
, symsec
, & nsyms
);
17478 if (symsec
->sh_link
< filedata
->file_header
.e_shnum
)
17480 Elf_Internal_Shdr
* strtab_sec
= filedata
->section_headers
+ symsec
->sh_link
;
17482 strtab
= (char *) get_data (NULL
, filedata
, strtab_sec
->sh_offset
,
17483 1, strtab_sec
->sh_size
,
17484 _("string table"));
17485 strtablen
= strtab
!= NULL
? strtab_sec
->sh_size
: 0;
17489 saved_filedata
= filedata
;
17492 if (symtab
== NULL
|| strtab
== NULL
)
17495 /* Find a symbol whose value matches offset. */
17496 for (sym
= symtab
; sym
< symtab
+ nsyms
; sym
++)
17497 if (sym
->st_value
== offset
)
17499 if (sym
->st_name
>= strtablen
)
17500 /* Huh ? This should not happen. */
17503 if (strtab
[sym
->st_name
] == 0)
17506 /* The AArch64 and ARM architectures define mapping symbols
17507 (eg $d, $x, $t) which we want to ignore. */
17508 if (strtab
[sym
->st_name
] == '$'
17509 && strtab
[sym
->st_name
+ 1] != 0
17510 && strtab
[sym
->st_name
+ 2] == 0)
17515 /* For OPEN attributes we prefer GLOBAL over LOCAL symbols
17516 and FILE or OBJECT symbols over NOTYPE symbols. We skip
17517 FUNC symbols entirely. */
17518 switch (ELF_ST_TYPE (sym
->st_info
))
17525 /* If the symbol has a size associated
17526 with it then we can stop searching. */
17527 sym
= symtab
+ nsyms
;
17532 /* Ignore function symbols. */
17539 switch (ELF_ST_BIND (sym
->st_info
))
17542 if (saved_sym
== NULL
17543 || ELF_ST_TYPE (saved_sym
->st_info
) != STT_OBJECT
)
17548 if (saved_sym
== NULL
)
17558 if (ELF_ST_TYPE (sym
->st_info
) != STT_FUNC
)
17566 if (saved_sym
&& pname
)
17567 * pname
= strtab
+ saved_sym
->st_name
;
17573 print_gnu_build_attribute_description (Elf_Internal_Note
* pnote
,
17574 Filedata
* filedata
)
17576 static unsigned long global_offset
= 0;
17577 static unsigned long global_end
= 0;
17578 static unsigned long func_offset
= 0;
17579 static unsigned long func_end
= 0;
17581 Elf_Internal_Sym
* sym
;
17583 unsigned long start
;
17585 bfd_boolean is_open_attr
= pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
;
17587 switch (pnote
->descsz
)
17590 /* A zero-length description means that the range of
17591 the previous note of the same type should be used. */
17594 if (global_end
> global_offset
)
17595 printf (_(" Applies to region from %#lx to %#lx\n"),
17596 global_offset
, global_end
);
17598 printf (_(" Applies to region from %#lx\n"), global_offset
);
17602 if (func_end
> func_offset
)
17603 printf (_(" Applies to region from %#lx to %#lx\n"), func_offset
, func_end
);
17605 printf (_(" Applies to region from %#lx\n"), func_offset
);
17610 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
17617 /* FIXME: We should check that version 3+ notes are being used here... */
17618 start
= byte_get ((unsigned char *) pnote
->descdata
, 4);
17619 end
= byte_get ((unsigned char *) pnote
->descdata
+ 4, 4);
17623 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
17629 start
= byte_get ((unsigned char *) pnote
->descdata
, 8);
17630 end
= byte_get ((unsigned char *) pnote
->descdata
+ 8, 8);
17634 error (_(" <invalid description size: %lx>\n"), pnote
->descsz
);
17635 printf (_(" <invalid descsz>"));
17640 sym
= get_symbol_for_build_attribute (filedata
, start
, is_open_attr
, & name
);
17641 /* As of version 5 of the annobin plugin, filename symbols are biased by 2
17642 in order to avoid them being confused with the start address of the
17643 first function in the file... */
17644 if (sym
== NULL
&& is_open_attr
)
17645 sym
= get_symbol_for_build_attribute (filedata
, start
+ 2, is_open_attr
,
17648 if (end
== 0 && sym
!= NULL
&& sym
->st_size
> 0)
17649 end
= start
+ sym
->st_size
;
17653 /* FIXME: Need to properly allow for section alignment. 16 is just the alignment used on x86_64. */
17654 if (global_end
> 0 && start
> BFD_ALIGN (global_end
, 16))
17655 warn (_("Gap in build notes detected from %#lx to %#lx\n"),
17656 global_end
+ 1, start
- 1);
17658 printf (_(" Applies to region from %#lx"), start
);
17659 global_offset
= start
;
17663 printf (_(" to %#lx"), end
);
17669 printf (_(" Applies to region from %#lx"), start
);
17670 func_offset
= start
;
17674 printf (_(" to %#lx"), end
);
17680 printf (_(" (%s)"), name
);
17687 print_gnu_build_attribute_name (Elf_Internal_Note
* pnote
)
17689 static const char string_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_STRING
, 0 };
17690 static const char number_expected
[2] = { GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
, 0 };
17691 static const char bool_expected
[3] = { GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
, GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
, 0 };
17693 char name_attribute
;
17694 const char * expected_types
;
17695 const char * name
= pnote
->namedata
;
17699 if (name
== NULL
|| pnote
->namesz
< 2)
17701 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
17702 print_symbol (-20, _(" <corrupt name>"));
17711 /* Version 2 of the spec adds a "GA" prefix to the name field. */
17712 if (name
[0] == 'G' && name
[1] == 'A')
17714 if (pnote
->namesz
< 4)
17716 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote
->namesz
);
17717 print_symbol (-20, _(" <corrupt name>"));
17726 switch ((name_type
= * name
))
17728 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
17729 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
17730 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
17731 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
17732 printf ("%c", * name
);
17736 error (_("unrecognised attribute type in name field: %d\n"), name_type
);
17737 print_symbol (-20, _("<unknown name type>"));
17744 switch ((name_attribute
= * name
))
17746 case GNU_BUILD_ATTRIBUTE_VERSION
:
17747 text
= _("<version>");
17748 expected_types
= string_expected
;
17751 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
17752 text
= _("<stack prot>");
17753 expected_types
= "!+*";
17756 case GNU_BUILD_ATTRIBUTE_RELRO
:
17757 text
= _("<relro>");
17758 expected_types
= bool_expected
;
17761 case GNU_BUILD_ATTRIBUTE_STACK_SIZE
:
17762 text
= _("<stack size>");
17763 expected_types
= number_expected
;
17766 case GNU_BUILD_ATTRIBUTE_TOOL
:
17767 text
= _("<tool>");
17768 expected_types
= string_expected
;
17771 case GNU_BUILD_ATTRIBUTE_ABI
:
17773 expected_types
= "$*";
17776 case GNU_BUILD_ATTRIBUTE_PIC
:
17778 expected_types
= number_expected
;
17781 case GNU_BUILD_ATTRIBUTE_SHORT_ENUM
:
17782 text
= _("<short enum>");
17783 expected_types
= bool_expected
;
17787 if (ISPRINT (* name
))
17789 int len
= strnlen (name
, pnote
->namesz
- (name
- pnote
->namedata
)) + 1;
17791 if (len
> left
&& ! do_wide
)
17793 printf ("%.*s:", len
, name
);
17799 static char tmpbuf
[128];
17801 error (_("unrecognised byte in name field: %d\n"), * name
);
17802 sprintf (tmpbuf
, _("<unknown:_%d>"), * name
);
17806 expected_types
= "*$!+";
17811 left
-= printf ("%s", text
);
17813 if (strchr (expected_types
, name_type
) == NULL
)
17814 warn (_("attribute does not have an expected type (%c)\n"), name_type
);
17816 if ((unsigned long)(name
- pnote
->namedata
) > pnote
->namesz
)
17818 error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
17819 (unsigned long) pnote
->namesz
,
17820 (long) (name
- pnote
->namedata
));
17824 if (left
< 1 && ! do_wide
)
17829 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC
:
17831 unsigned int bytes
;
17832 unsigned long long val
= 0;
17833 unsigned int shift
= 0;
17834 char * decoded
= NULL
;
17836 bytes
= pnote
->namesz
- (name
- pnote
->namedata
);
17838 /* The -1 is because the name field is always 0 terminated, and we
17839 want to be able to ensure that the shift in the while loop below
17840 will not overflow. */
17843 if (bytes
> sizeof (val
))
17845 error (_("corrupt numeric name field: too many bytes in the value: %x\n"),
17847 bytes
= sizeof (val
);
17849 /* We do not bother to warn if bytes == 0 as this can
17850 happen with some early versions of the gcc plugin. */
17854 unsigned long byte
= (* name
++) & 0xff;
17856 val
|= byte
<< shift
;
17860 switch (name_attribute
)
17862 case GNU_BUILD_ATTRIBUTE_PIC
:
17865 case 0: decoded
= "static"; break;
17866 case 1: decoded
= "pic"; break;
17867 case 2: decoded
= "PIC"; break;
17868 case 3: decoded
= "pie"; break;
17869 case 4: decoded
= "PIE"; break;
17873 case GNU_BUILD_ATTRIBUTE_STACK_PROT
:
17876 /* Based upon the SPCT_FLAG_xxx enum values in gcc/cfgexpand.c. */
17877 case 0: decoded
= "off"; break;
17878 case 1: decoded
= "on"; break;
17879 case 2: decoded
= "all"; break;
17880 case 3: decoded
= "strong"; break;
17881 case 4: decoded
= "explicit"; break;
17889 if (decoded
!= NULL
)
17891 print_symbol (-left
, decoded
);
17902 left
-= printf ("0x%llx", val
);
17904 left
-= printf ("0x%-.*llx", left
, val
);
17908 case GNU_BUILD_ATTRIBUTE_TYPE_STRING
:
17909 left
-= print_symbol (- left
, name
);
17911 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE
:
17912 left
-= print_symbol (- left
, "true");
17914 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE
:
17915 left
-= print_symbol (- left
, "false");
17919 if (do_wide
&& left
> 0)
17920 printf ("%-*s", left
, " ");
17925 /* Note that by the ELF standard, the name field is already null byte
17926 terminated, and namesz includes the terminating null byte.
17927 I.E. the value of namesz for the name "FSF" is 4.
17929 If the value of namesz is zero, there is no name present. */
17932 process_note (Elf_Internal_Note
* pnote
,
17933 Filedata
* filedata
)
17935 const char * name
= pnote
->namesz
? pnote
->namedata
: "(NONE)";
17938 if (pnote
->namesz
== 0)
17939 /* If there is no note name, then use the default set of
17940 note type strings. */
17941 nt
= get_note_type (filedata
, pnote
->type
);
17943 else if (const_strneq (pnote
->namedata
, "GNU"))
17944 /* GNU-specific object file notes. */
17945 nt
= get_gnu_elf_note_type (pnote
->type
);
17947 else if (const_strneq (pnote
->namedata
, "FreeBSD"))
17948 /* FreeBSD-specific core file notes. */
17949 nt
= get_freebsd_elfcore_note_type (filedata
, pnote
->type
);
17951 else if (const_strneq (pnote
->namedata
, "NetBSD-CORE"))
17952 /* NetBSD-specific core file notes. */
17953 nt
= get_netbsd_elfcore_note_type (filedata
, pnote
->type
);
17955 else if (const_strneq (pnote
->namedata
, "NetBSD"))
17956 /* NetBSD-specific core file notes. */
17957 return process_netbsd_elf_note (pnote
);
17959 else if (strneq (pnote
->namedata
, "SPU/", 4))
17961 /* SPU-specific core file notes. */
17962 nt
= pnote
->namedata
+ 4;
17966 else if (const_strneq (pnote
->namedata
, "IPF/VMS"))
17967 /* VMS/ia64-specific file notes. */
17968 nt
= get_ia64_vms_note_type (pnote
->type
);
17970 else if (const_strneq (pnote
->namedata
, "stapsdt"))
17971 nt
= get_stapsdt_note_type (pnote
->type
);
17974 /* Don't recognize this note name; just use the default set of
17975 note type strings. */
17976 nt
= get_note_type (filedata
, pnote
->type
);
17980 if (((const_strneq (pnote
->namedata
, "GA")
17981 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
17982 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
17983 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
17984 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
17985 print_gnu_build_attribute_name (pnote
);
17987 print_symbol (-20, name
);
17990 printf (" 0x%08lx\t%s\t", pnote
->descsz
, nt
);
17992 printf (" 0x%08lx\t%s\n", pnote
->descsz
, nt
);
17994 if (const_strneq (pnote
->namedata
, "IPF/VMS"))
17995 return print_ia64_vms_note (pnote
);
17996 else if (const_strneq (pnote
->namedata
, "GNU"))
17997 return print_gnu_note (filedata
, pnote
);
17998 else if (const_strneq (pnote
->namedata
, "stapsdt"))
17999 return print_stapsdt_note (pnote
);
18000 else if (const_strneq (pnote
->namedata
, "CORE"))
18001 return print_core_note (pnote
);
18002 else if (((const_strneq (pnote
->namedata
, "GA")
18003 && strchr ("*$!+", pnote
->namedata
[2]) != NULL
)
18004 || strchr ("*$!+", pnote
->namedata
[0]) != NULL
)
18005 && (pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_OPEN
18006 || pnote
->type
== NT_GNU_BUILD_ATTRIBUTE_FUNC
))
18007 return print_gnu_build_attribute_description (pnote
, filedata
);
18013 printf (_(" description data: "));
18014 for (i
= 0; i
< pnote
->descsz
; i
++)
18015 printf ("%02x ", pnote
->descdata
[i
]);
18027 process_notes_at (Filedata
* filedata
,
18028 Elf_Internal_Shdr
* section
,
18033 Elf_External_Note
* pnotes
;
18034 Elf_External_Note
* external
;
18036 bfd_boolean res
= TRUE
;
18043 pnotes
= (Elf_External_Note
*) get_section_contents (section
, filedata
);
18046 if (! apply_relocations (filedata
, section
, (unsigned char *) pnotes
, length
, NULL
, NULL
))
18051 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
18054 if (pnotes
== NULL
)
18060 printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (filedata
, section
));
18062 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
18063 (unsigned long) offset
, (unsigned long) length
);
18065 /* NB: Some note sections may have alignment value of 0 or 1. gABI
18066 specifies that notes should be aligned to 4 bytes in 32-bit
18067 objects and to 8 bytes in 64-bit objects. As a Linux extension,
18068 we also support 4 byte alignment in 64-bit objects. If section
18069 alignment is less than 4, we treate alignment as 4 bytes. */
18072 else if (align
!= 4 && align
!= 8)
18074 warn (_("Corrupt note: alignment %ld, expecting 4 or 8\n"),
18079 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
18081 end
= (char *) pnotes
+ length
;
18082 while ((char *) external
< end
)
18084 Elf_Internal_Note inote
;
18087 char * temp
= NULL
;
18088 size_t data_remaining
= end
- (char *) external
;
18090 if (!is_ia64_vms (filedata
))
18092 /* PR binutils/15191
18093 Make sure that there is enough data to read. */
18094 min_notesz
= offsetof (Elf_External_Note
, name
);
18095 if (data_remaining
< min_notesz
)
18097 warn (ngettext ("Corrupt note: only %ld byte remains, "
18098 "not enough for a full note\n",
18099 "Corrupt note: only %ld bytes remain, "
18100 "not enough for a full note\n",
18102 (long) data_remaining
);
18105 data_remaining
-= min_notesz
;
18107 inote
.type
= BYTE_GET (external
->type
);
18108 inote
.namesz
= BYTE_GET (external
->namesz
);
18109 inote
.namedata
= external
->name
;
18110 inote
.descsz
= BYTE_GET (external
->descsz
);
18111 inote
.descdata
= ((char *) external
18112 + ELF_NOTE_DESC_OFFSET (inote
.namesz
, align
));
18113 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
18114 next
= ((char *) external
18115 + ELF_NOTE_NEXT_OFFSET (inote
.namesz
, inote
.descsz
, align
));
18119 Elf64_External_VMS_Note
*vms_external
;
18121 /* PR binutils/15191
18122 Make sure that there is enough data to read. */
18123 min_notesz
= offsetof (Elf64_External_VMS_Note
, name
);
18124 if (data_remaining
< min_notesz
)
18126 warn (ngettext ("Corrupt note: only %ld byte remains, "
18127 "not enough for a full note\n",
18128 "Corrupt note: only %ld bytes remain, "
18129 "not enough for a full note\n",
18131 (long) data_remaining
);
18134 data_remaining
-= min_notesz
;
18136 vms_external
= (Elf64_External_VMS_Note
*) external
;
18137 inote
.type
= BYTE_GET (vms_external
->type
);
18138 inote
.namesz
= BYTE_GET (vms_external
->namesz
);
18139 inote
.namedata
= vms_external
->name
;
18140 inote
.descsz
= BYTE_GET (vms_external
->descsz
);
18141 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 3);
18142 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
18143 next
= inote
.descdata
+ align_power (inote
.descsz
, 3);
18146 /* PR 17531: file: 3443835e. */
18147 /* PR 17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
18148 if ((size_t) (inote
.descdata
- inote
.namedata
) < inote
.namesz
18149 || (size_t) (inote
.descdata
- inote
.namedata
) > data_remaining
18150 || (size_t) (next
- inote
.descdata
) < inote
.descsz
18151 || ((size_t) (next
- inote
.descdata
)
18152 > data_remaining
- (size_t) (inote
.descdata
- inote
.namedata
)))
18154 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
18155 (unsigned long) ((char *) external
- (char *) pnotes
));
18156 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx, alignment: %u\n"),
18157 inote
.type
, inote
.namesz
, inote
.descsz
, (int) align
);
18161 external
= (Elf_External_Note
*) next
;
18163 /* Verify that name is null terminated. It appears that at least
18164 one version of Linux (RedHat 6.0) generates corefiles that don't
18165 comply with the ELF spec by failing to include the null byte in
18167 if (inote
.namedata
[inote
.namesz
- 1] != '\0')
18169 if ((size_t) (inote
.descdata
- inote
.namedata
) == inote
.namesz
)
18171 temp
= (char *) malloc (inote
.namesz
+ 1);
18174 error (_("Out of memory allocating space for inote name\n"));
18179 memcpy (temp
, inote
.namedata
, inote
.namesz
);
18180 inote
.namedata
= temp
;
18182 inote
.namedata
[inote
.namesz
] = 0;
18185 if (! process_note (& inote
, filedata
))
18201 process_corefile_note_segments (Filedata
* filedata
)
18203 Elf_Internal_Phdr
* segment
;
18205 bfd_boolean res
= TRUE
;
18207 if (! get_program_headers (filedata
))
18210 for (i
= 0, segment
= filedata
->program_headers
;
18211 i
< filedata
->file_header
.e_phnum
;
18214 if (segment
->p_type
== PT_NOTE
)
18215 if (! process_notes_at (filedata
, NULL
,
18216 (bfd_vma
) segment
->p_offset
,
18217 (bfd_vma
) segment
->p_filesz
,
18218 (bfd_vma
) segment
->p_align
))
18226 process_v850_notes (Filedata
* filedata
, bfd_vma offset
, bfd_vma length
)
18228 Elf_External_Note
* pnotes
;
18229 Elf_External_Note
* external
;
18231 bfd_boolean res
= TRUE
;
18236 pnotes
= (Elf_External_Note
*) get_data (NULL
, filedata
, offset
, 1, length
,
18238 if (pnotes
== NULL
)
18242 end
= (char*) pnotes
+ length
;
18244 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
18245 (unsigned long) offset
, (unsigned long) length
);
18247 while ((char *) external
+ sizeof (Elf_External_Note
) < end
)
18249 Elf_External_Note
* next
;
18250 Elf_Internal_Note inote
;
18252 inote
.type
= BYTE_GET (external
->type
);
18253 inote
.namesz
= BYTE_GET (external
->namesz
);
18254 inote
.namedata
= external
->name
;
18255 inote
.descsz
= BYTE_GET (external
->descsz
);
18256 inote
.descdata
= inote
.namedata
+ align_power (inote
.namesz
, 2);
18257 inote
.descpos
= offset
+ (inote
.descdata
- (char *) pnotes
);
18259 if (inote
.descdata
< (char *) pnotes
|| inote
.descdata
>= end
)
18261 warn (_("Corrupt note: name size is too big: %lx\n"), inote
.namesz
);
18262 inote
.descdata
= inote
.namedata
;
18266 next
= (Elf_External_Note
*) (inote
.descdata
+ align_power (inote
.descsz
, 2));
18268 if ( ((char *) next
> end
)
18269 || ((char *) next
< (char *) pnotes
))
18271 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
18272 (unsigned long) ((char *) external
- (char *) pnotes
));
18273 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
18274 inote
.type
, inote
.namesz
, inote
.descsz
);
18280 /* Prevent out-of-bounds indexing. */
18281 if ( inote
.namedata
+ inote
.namesz
> end
18282 || inote
.namedata
+ inote
.namesz
< inote
.namedata
)
18284 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
18285 (unsigned long) ((char *) external
- (char *) pnotes
));
18286 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
18287 inote
.type
, inote
.namesz
, inote
.descsz
);
18291 printf (" %s: ", get_v850_elf_note_type (inote
.type
));
18293 if (! print_v850_note (& inote
))
18296 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
18297 inote
.namesz
, inote
.descsz
);
18307 process_note_sections (Filedata
* filedata
)
18309 Elf_Internal_Shdr
* section
;
18311 unsigned int n
= 0;
18312 bfd_boolean res
= TRUE
;
18314 for (i
= 0, section
= filedata
->section_headers
;
18315 i
< filedata
->file_header
.e_shnum
&& section
!= NULL
;
18318 if (section
->sh_type
== SHT_NOTE
)
18320 if (! process_notes_at (filedata
, section
,
18321 (bfd_vma
) section
->sh_offset
,
18322 (bfd_vma
) section
->sh_size
,
18323 (bfd_vma
) section
->sh_addralign
))
18328 if (( filedata
->file_header
.e_machine
== EM_V800
18329 || filedata
->file_header
.e_machine
== EM_V850
18330 || filedata
->file_header
.e_machine
== EM_CYGNUS_V850
)
18331 && section
->sh_type
== SHT_RENESAS_INFO
)
18333 if (! process_v850_notes (filedata
,
18334 (bfd_vma
) section
->sh_offset
,
18335 (bfd_vma
) section
->sh_size
))
18342 /* Try processing NOTE segments instead. */
18343 return process_corefile_note_segments (filedata
);
18349 process_notes (Filedata
* filedata
)
18351 /* If we have not been asked to display the notes then do nothing. */
18355 if (filedata
->file_header
.e_type
!= ET_CORE
)
18356 return process_note_sections (filedata
);
18358 /* No program headers means no NOTE segment. */
18359 if (filedata
->file_header
.e_phnum
> 0)
18360 return process_corefile_note_segments (filedata
);
18362 printf (_("No note segments present in the core file.\n"));
18366 static unsigned char *
18367 display_public_gnu_attributes (unsigned char * start
,
18368 const unsigned char * const end
)
18370 printf (_(" Unknown GNU attribute: %s\n"), start
);
18372 start
+= strnlen ((char *) start
, end
- start
);
18373 display_raw_attribute (start
, end
);
18375 return (unsigned char *) end
;
18378 static unsigned char *
18379 display_generic_attribute (unsigned char * start
,
18381 const unsigned char * const end
)
18384 return (unsigned char *) end
;
18386 return display_tag_value (tag
, start
, end
);
18390 process_arch_specific (Filedata
* filedata
)
18395 switch (filedata
->file_header
.e_machine
)
18398 case EM_ARC_COMPACT
:
18399 case EM_ARC_COMPACT2
:
18400 return process_attributes (filedata
, "ARC", SHT_ARC_ATTRIBUTES
,
18401 display_arc_attribute
,
18402 display_generic_attribute
);
18404 return process_attributes (filedata
, "aeabi", SHT_ARM_ATTRIBUTES
,
18405 display_arm_attribute
,
18406 display_generic_attribute
);
18409 case EM_MIPS_RS3_LE
:
18410 return process_mips_specific (filedata
);
18413 return process_attributes (filedata
, "mspabi", SHT_MSP430_ATTRIBUTES
,
18414 display_msp430x_attribute
,
18415 display_generic_attribute
);
18418 return process_nds32_specific (filedata
);
18422 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
18423 display_power_gnu_attribute
);
18427 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
18428 display_s390_gnu_attribute
);
18431 case EM_SPARC32PLUS
:
18433 return process_attributes (filedata
, NULL
, SHT_GNU_ATTRIBUTES
, NULL
,
18434 display_sparc_gnu_attribute
);
18437 return process_attributes (filedata
, "c6xabi", SHT_C6000_ATTRIBUTES
,
18438 display_tic6x_attribute
,
18439 display_generic_attribute
);
18442 return process_attributes (filedata
, "gnu", SHT_GNU_ATTRIBUTES
,
18443 display_public_gnu_attributes
,
18444 display_generic_attribute
);
18449 get_file_header (Filedata
* filedata
)
18451 /* Read in the identity array. */
18452 if (fread (filedata
->file_header
.e_ident
, EI_NIDENT
, 1, filedata
->handle
) != 1)
18455 /* Determine how to read the rest of the header. */
18456 switch (filedata
->file_header
.e_ident
[EI_DATA
])
18461 byte_get
= byte_get_little_endian
;
18462 byte_put
= byte_put_little_endian
;
18465 byte_get
= byte_get_big_endian
;
18466 byte_put
= byte_put_big_endian
;
18470 /* For now we only support 32 bit and 64 bit ELF files. */
18471 is_32bit_elf
= (filedata
->file_header
.e_ident
[EI_CLASS
] != ELFCLASS64
);
18473 /* Read in the rest of the header. */
18476 Elf32_External_Ehdr ehdr32
;
18478 if (fread (ehdr32
.e_type
, sizeof (ehdr32
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
18481 filedata
->file_header
.e_type
= BYTE_GET (ehdr32
.e_type
);
18482 filedata
->file_header
.e_machine
= BYTE_GET (ehdr32
.e_machine
);
18483 filedata
->file_header
.e_version
= BYTE_GET (ehdr32
.e_version
);
18484 filedata
->file_header
.e_entry
= BYTE_GET (ehdr32
.e_entry
);
18485 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr32
.e_phoff
);
18486 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr32
.e_shoff
);
18487 filedata
->file_header
.e_flags
= BYTE_GET (ehdr32
.e_flags
);
18488 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr32
.e_ehsize
);
18489 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr32
.e_phentsize
);
18490 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr32
.e_phnum
);
18491 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr32
.e_shentsize
);
18492 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr32
.e_shnum
);
18493 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr32
.e_shstrndx
);
18497 Elf64_External_Ehdr ehdr64
;
18499 /* If we have been compiled with sizeof (bfd_vma) == 4, then
18500 we will not be able to cope with the 64bit data found in
18501 64 ELF files. Detect this now and abort before we start
18502 overwriting things. */
18503 if (sizeof (bfd_vma
) < 8)
18505 error (_("This instance of readelf has been built without support for a\n\
18506 64 bit data type and so it cannot read 64 bit ELF files.\n"));
18510 if (fread (ehdr64
.e_type
, sizeof (ehdr64
) - EI_NIDENT
, 1, filedata
->handle
) != 1)
18513 filedata
->file_header
.e_type
= BYTE_GET (ehdr64
.e_type
);
18514 filedata
->file_header
.e_machine
= BYTE_GET (ehdr64
.e_machine
);
18515 filedata
->file_header
.e_version
= BYTE_GET (ehdr64
.e_version
);
18516 filedata
->file_header
.e_entry
= BYTE_GET (ehdr64
.e_entry
);
18517 filedata
->file_header
.e_phoff
= BYTE_GET (ehdr64
.e_phoff
);
18518 filedata
->file_header
.e_shoff
= BYTE_GET (ehdr64
.e_shoff
);
18519 filedata
->file_header
.e_flags
= BYTE_GET (ehdr64
.e_flags
);
18520 filedata
->file_header
.e_ehsize
= BYTE_GET (ehdr64
.e_ehsize
);
18521 filedata
->file_header
.e_phentsize
= BYTE_GET (ehdr64
.e_phentsize
);
18522 filedata
->file_header
.e_phnum
= BYTE_GET (ehdr64
.e_phnum
);
18523 filedata
->file_header
.e_shentsize
= BYTE_GET (ehdr64
.e_shentsize
);
18524 filedata
->file_header
.e_shnum
= BYTE_GET (ehdr64
.e_shnum
);
18525 filedata
->file_header
.e_shstrndx
= BYTE_GET (ehdr64
.e_shstrndx
);
18528 if (filedata
->file_header
.e_shoff
)
18530 /* There may be some extensions in the first section header. Don't
18531 bomb if we can't read it. */
18533 get_32bit_section_headers (filedata
, TRUE
);
18535 get_64bit_section_headers (filedata
, TRUE
);
18542 close_file (Filedata
* filedata
)
18546 if (filedata
->handle
)
18547 fclose (filedata
->handle
);
18553 close_debug_file (void * data
)
18555 close_file ((Filedata
*) data
);
18559 open_file (const char * pathname
)
18561 struct stat statbuf
;
18562 Filedata
* filedata
= NULL
;
18564 if (stat (pathname
, & statbuf
) < 0
18565 || ! S_ISREG (statbuf
.st_mode
))
18568 filedata
= calloc (1, sizeof * filedata
);
18569 if (filedata
== NULL
)
18572 filedata
->handle
= fopen (pathname
, "rb");
18573 if (filedata
->handle
== NULL
)
18576 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
18577 filedata
->file_name
= pathname
;
18579 if (! get_file_header (filedata
))
18582 if (filedata
->file_header
.e_shoff
)
18586 /* Read the section headers again, this time for real. */
18588 res
= get_32bit_section_headers (filedata
, FALSE
);
18590 res
= get_64bit_section_headers (filedata
, FALSE
);
18601 if (filedata
->handle
)
18602 fclose (filedata
->handle
);
18609 open_debug_file (const char * pathname
)
18611 return open_file (pathname
);
18614 /* Process one ELF object file according to the command line options.
18615 This file may actually be stored in an archive. The file is
18616 positioned at the start of the ELF object. Returns TRUE if no
18617 problems were encountered, FALSE otherwise. */
18620 process_object (Filedata
* filedata
)
18622 Filedata
* separates
;
18624 bfd_boolean res
= TRUE
;
18626 if (! get_file_header (filedata
))
18628 error (_("%s: Failed to read file header\n"), filedata
->file_name
);
18632 /* Initialise per file variables. */
18633 for (i
= ARRAY_SIZE (version_info
); i
--;)
18634 version_info
[i
] = 0;
18636 for (i
= ARRAY_SIZE (dynamic_info
); i
--;)
18637 dynamic_info
[i
] = 0;
18638 dynamic_info_DT_GNU_HASH
= 0;
18640 /* Process the file. */
18642 printf (_("\nFile: %s\n"), filedata
->file_name
);
18644 /* Initialise the dump_sects array from the cmdline_dump_sects array.
18645 Note we do this even if cmdline_dump_sects is empty because we
18646 must make sure that the dump_sets array is zeroed out before each
18647 object file is processed. */
18648 if (filedata
->num_dump_sects
> cmdline
.num_dump_sects
)
18649 memset (filedata
->dump_sects
, 0, filedata
->num_dump_sects
* sizeof (* filedata
->dump_sects
));
18651 if (cmdline
.num_dump_sects
> 0)
18653 if (filedata
->num_dump_sects
== 0)
18654 /* A sneaky way of allocating the dump_sects array. */
18655 request_dump_bynumber (filedata
, cmdline
.num_dump_sects
, 0);
18657 assert (filedata
->num_dump_sects
>= cmdline
.num_dump_sects
);
18658 memcpy (filedata
->dump_sects
, cmdline
.dump_sects
,
18659 cmdline
.num_dump_sects
* sizeof (* filedata
->dump_sects
));
18662 if (! process_file_header (filedata
))
18665 if (! process_section_headers (filedata
))
18667 /* Without loaded section headers we cannot process lots of things. */
18668 do_unwind
= do_version
= do_dump
= do_arch
= FALSE
;
18670 if (! do_using_dynamic
)
18671 do_syms
= do_dyn_syms
= do_reloc
= FALSE
;
18674 if (! process_section_groups (filedata
))
18675 /* Without loaded section groups we cannot process unwind. */
18678 if (process_program_headers (filedata
))
18679 process_dynamic_section (filedata
);
18683 if (! process_relocs (filedata
))
18686 if (! process_unwind (filedata
))
18689 if (! process_symbol_table (filedata
))
18692 if (! process_syminfo (filedata
))
18695 if (! process_version_sections (filedata
))
18698 if (filedata
->file_header
.e_shstrndx
!= SHN_UNDEF
)
18699 separates
= load_separate_debug_file (filedata
, filedata
->file_name
);
18703 if (! process_section_contents (filedata
))
18708 if (! process_section_headers (separates
))
18710 else if (! process_section_contents (separates
))
18714 if (! process_notes (filedata
))
18717 if (! process_gnu_liblist (filedata
))
18720 if (! process_arch_specific (filedata
))
18723 free (filedata
->program_headers
);
18724 filedata
->program_headers
= NULL
;
18726 free (filedata
->section_headers
);
18727 filedata
->section_headers
= NULL
;
18729 free (filedata
->string_table
);
18730 filedata
->string_table
= NULL
;
18731 filedata
->string_table_length
= 0;
18733 if (dynamic_strings
)
18735 free (dynamic_strings
);
18736 dynamic_strings
= NULL
;
18737 dynamic_strings_length
= 0;
18740 if (dynamic_symbols
)
18742 free (dynamic_symbols
);
18743 dynamic_symbols
= NULL
;
18744 num_dynamic_syms
= 0;
18747 if (dynamic_syminfo
)
18749 free (dynamic_syminfo
);
18750 dynamic_syminfo
= NULL
;
18753 if (dynamic_section
)
18755 free (dynamic_section
);
18756 dynamic_section
= NULL
;
18759 if (section_headers_groups
)
18761 free (section_headers_groups
);
18762 section_headers_groups
= NULL
;
18765 if (section_groups
)
18767 struct group_list
* g
;
18768 struct group_list
* next
;
18770 for (i
= 0; i
< group_count
; i
++)
18772 for (g
= section_groups
[i
].root
; g
!= NULL
; g
= next
)
18779 free (section_groups
);
18780 section_groups
= NULL
;
18783 free_debug_memory ();
18788 /* Process an ELF archive.
18789 On entry the file is positioned just after the ARMAG string.
18790 Returns TRUE upon success, FALSE otherwise. */
18793 process_archive (Filedata
* filedata
, bfd_boolean is_thin_archive
)
18795 struct archive_info arch
;
18796 struct archive_info nested_arch
;
18798 bfd_boolean ret
= TRUE
;
18802 /* The ARCH structure is used to hold information about this archive. */
18803 arch
.file_name
= NULL
;
18805 arch
.index_array
= NULL
;
18806 arch
.sym_table
= NULL
;
18807 arch
.longnames
= NULL
;
18809 /* The NESTED_ARCH structure is used as a single-item cache of information
18810 about a nested archive (when members of a thin archive reside within
18811 another regular archive file). */
18812 nested_arch
.file_name
= NULL
;
18813 nested_arch
.file
= NULL
;
18814 nested_arch
.index_array
= NULL
;
18815 nested_arch
.sym_table
= NULL
;
18816 nested_arch
.longnames
= NULL
;
18818 if (setup_archive (&arch
, filedata
->file_name
, filedata
->handle
,
18819 is_thin_archive
, do_archive_index
) != 0)
18825 if (do_archive_index
)
18827 if (arch
.sym_table
== NULL
)
18828 error (_("%s: unable to dump the index as none was found\n"), filedata
->file_name
);
18831 unsigned long i
, l
;
18832 unsigned long current_pos
;
18834 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
18835 filedata
->file_name
, (unsigned long) arch
.index_num
, arch
.sym_size
);
18837 current_pos
= ftell (filedata
->handle
);
18839 for (i
= l
= 0; i
< arch
.index_num
; i
++)
18841 if ((i
== 0) || ((i
> 0) && (arch
.index_array
[i
] != arch
.index_array
[i
- 1])))
18843 char * member_name
;
18845 member_name
= get_archive_member_name_at (&arch
, arch
.index_array
[i
], &nested_arch
);
18847 if (member_name
!= NULL
)
18849 char * qualified_name
= make_qualified_name (&arch
, &nested_arch
, member_name
);
18851 if (qualified_name
!= NULL
)
18853 printf (_("Contents of binary %s at offset "), qualified_name
);
18854 (void) print_vma (arch
.index_array
[i
], PREFIX_HEX
);
18856 free (qualified_name
);
18861 if (l
>= arch
.sym_size
)
18863 error (_("%s: end of the symbol table reached before the end of the index\n"),
18864 filedata
->file_name
);
18868 /* PR 17531: file: 0b6630b2. */
18869 printf ("\t%.*s\n", (int) (arch
.sym_size
- l
), arch
.sym_table
+ l
);
18870 l
+= strnlen (arch
.sym_table
+ l
, arch
.sym_size
- l
) + 1;
18873 if (arch
.uses_64bit_indicies
)
18878 if (l
< arch
.sym_size
)
18880 error (ngettext ("%s: %ld byte remains in the symbol table, "
18881 "but without corresponding entries in "
18882 "the index table\n",
18883 "%s: %ld bytes remain in the symbol table, "
18884 "but without corresponding entries in "
18885 "the index table\n",
18886 arch
.sym_size
- l
),
18887 filedata
->file_name
, arch
.sym_size
- l
);
18891 if (fseek (filedata
->handle
, current_pos
, SEEK_SET
) != 0)
18893 error (_("%s: failed to seek back to start of object files in the archive\n"),
18894 filedata
->file_name
);
18900 if (!do_dynamic
&& !do_syms
&& !do_reloc
&& !do_unwind
&& !do_sections
18901 && !do_segments
&& !do_header
&& !do_dump
&& !do_version
18902 && !do_histogram
&& !do_debugging
&& !do_arch
&& !do_notes
18903 && !do_section_groups
&& !do_dyn_syms
)
18905 ret
= TRUE
; /* Archive index only. */
18914 char * qualified_name
;
18916 /* Read the next archive header. */
18917 if (fseek (filedata
->handle
, arch
.next_arhdr_offset
, SEEK_SET
) != 0)
18919 error (_("%s: failed to seek to next archive header\n"), filedata
->file_name
);
18922 got
= fread (&arch
.arhdr
, 1, sizeof arch
.arhdr
, filedata
->handle
);
18923 if (got
!= sizeof arch
.arhdr
)
18927 error (_("%s: failed to read archive header\n"), filedata
->file_name
);
18931 if (memcmp (arch
.arhdr
.ar_fmag
, ARFMAG
, 2) != 0)
18933 error (_("%s: did not find a valid archive header\n"), arch
.file_name
);
18938 arch
.next_arhdr_offset
+= sizeof arch
.arhdr
;
18940 archive_file_size
= strtoul (arch
.arhdr
.ar_size
, NULL
, 10);
18941 if (archive_file_size
& 01)
18942 ++archive_file_size
;
18944 name
= get_archive_member_name (&arch
, &nested_arch
);
18947 error (_("%s: bad archive file name\n"), filedata
->file_name
);
18951 namelen
= strlen (name
);
18953 qualified_name
= make_qualified_name (&arch
, &nested_arch
, name
);
18954 if (qualified_name
== NULL
)
18956 error (_("%s: bad archive file name\n"), filedata
->file_name
);
18961 if (is_thin_archive
&& arch
.nested_member_origin
== 0)
18963 /* This is a proxy for an external member of a thin archive. */
18964 Filedata
* member_filedata
;
18965 char * member_file_name
= adjust_relative_path
18966 (filedata
->file_name
, name
, namelen
);
18968 if (member_file_name
== NULL
)
18974 member_filedata
= open_file (member_file_name
);
18975 if (member_filedata
== NULL
)
18977 error (_("Input file '%s' is not readable.\n"), member_file_name
);
18978 free (member_file_name
);
18983 archive_file_offset
= arch
.nested_member_origin
;
18984 member_filedata
->file_name
= qualified_name
;
18986 if (! process_object (member_filedata
))
18989 close_file (member_filedata
);
18990 free (member_file_name
);
18992 else if (is_thin_archive
)
18994 Filedata thin_filedata
;
18996 memset (&thin_filedata
, 0, sizeof (thin_filedata
));
18998 /* PR 15140: Allow for corrupt thin archives. */
18999 if (nested_arch
.file
== NULL
)
19001 error (_("%s: contains corrupt thin archive: %s\n"),
19002 filedata
->file_name
, name
);
19007 /* This is a proxy for a member of a nested archive. */
19008 archive_file_offset
= arch
.nested_member_origin
+ sizeof arch
.arhdr
;
19010 /* The nested archive file will have been opened and setup by
19011 get_archive_member_name. */
19012 if (fseek (nested_arch
.file
, archive_file_offset
, SEEK_SET
) != 0)
19014 error (_("%s: failed to seek to archive member.\n"), nested_arch
.file_name
);
19019 thin_filedata
.handle
= nested_arch
.file
;
19020 thin_filedata
.file_name
= qualified_name
;
19022 if (! process_object (& thin_filedata
))
19027 archive_file_offset
= arch
.next_arhdr_offset
;
19028 arch
.next_arhdr_offset
+= archive_file_size
;
19030 filedata
->file_name
= qualified_name
;
19031 if (! process_object (filedata
))
19035 if (filedata
->dump_sects
!= NULL
)
19037 free (filedata
->dump_sects
);
19038 filedata
->dump_sects
= NULL
;
19039 filedata
->num_dump_sects
= 0;
19042 free (qualified_name
);
19046 if (nested_arch
.file
!= NULL
)
19047 fclose (nested_arch
.file
);
19048 release_archive (&nested_arch
);
19049 release_archive (&arch
);
19055 process_file (char * file_name
)
19057 Filedata
* filedata
= NULL
;
19058 struct stat statbuf
;
19059 char armag
[SARMAG
];
19060 bfd_boolean ret
= TRUE
;
19062 if (stat (file_name
, &statbuf
) < 0)
19064 if (errno
== ENOENT
)
19065 error (_("'%s': No such file\n"), file_name
);
19067 error (_("Could not locate '%s'. System error message: %s\n"),
19068 file_name
, strerror (errno
));
19072 if (! S_ISREG (statbuf
.st_mode
))
19074 error (_("'%s' is not an ordinary file\n"), file_name
);
19078 filedata
= calloc (1, sizeof * filedata
);
19079 if (filedata
== NULL
)
19081 error (_("Out of memory allocating file data structure\n"));
19085 filedata
->file_name
= file_name
;
19086 filedata
->handle
= fopen (file_name
, "rb");
19087 if (filedata
->handle
== NULL
)
19089 error (_("Input file '%s' is not readable.\n"), file_name
);
19094 if (fread (armag
, SARMAG
, 1, filedata
->handle
) != 1)
19096 error (_("%s: Failed to read file's magic number\n"), file_name
);
19097 fclose (filedata
->handle
);
19102 filedata
->file_size
= (bfd_size_type
) statbuf
.st_size
;
19104 if (memcmp (armag
, ARMAG
, SARMAG
) == 0)
19106 if (! process_archive (filedata
, FALSE
))
19109 else if (memcmp (armag
, ARMAGT
, SARMAG
) == 0)
19111 if ( ! process_archive (filedata
, TRUE
))
19116 if (do_archive_index
)
19117 error (_("File %s is not an archive so its index cannot be displayed.\n"),
19120 rewind (filedata
->handle
);
19121 archive_file_size
= archive_file_offset
= 0;
19123 if (! process_object (filedata
))
19127 fclose (filedata
->handle
);
19133 #ifdef SUPPORT_DISASSEMBLY
19134 /* Needed by the i386 disassembler. For extra credit, someone could
19135 fix this so that we insert symbolic addresses here, esp for GOT/PLT
19139 print_address (unsigned int addr
, FILE * outfile
)
19141 fprintf (outfile
,"0x%8.8x", addr
);
19144 /* Needed by the i386 disassembler. */
19147 db_task_printsym (unsigned int addr
)
19149 print_address (addr
, stderr
);
19154 main (int argc
, char ** argv
)
19158 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
19159 setlocale (LC_MESSAGES
, "");
19161 #if defined (HAVE_SETLOCALE)
19162 setlocale (LC_CTYPE
, "");
19164 bindtextdomain (PACKAGE
, LOCALEDIR
);
19165 textdomain (PACKAGE
);
19167 expandargv (&argc
, &argv
);
19169 cmdline
.file_name
= "<cmdline>";
19170 parse_args (& cmdline
, argc
, argv
);
19172 if (optind
< (argc
- 1))
19174 else if (optind
>= argc
)
19176 warn (_("Nothing to do.\n"));
19181 while (optind
< argc
)
19182 if (! process_file (argv
[optind
++]))
19185 if (cmdline
.dump_sects
!= NULL
)
19186 free (cmdline
.dump_sects
);
19188 return err
? EXIT_FAILURE
: EXIT_SUCCESS
;