1 /* readelf.c -- display contents of an ELF format file
2 Copyright (C) 1998-2017 Free Software Foundation, Inc.
4 Originally developed by Eric Youngdale <eric@andante.jic.com>
5 Modifications by Nick Clifton <nickc@redhat.com>
7 This file is part of GNU Binutils.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
24 /* The difference between readelf and objdump:
26 Both programs are capable of displaying the contents of ELF format files,
27 so why does the binutils project have two file dumpers ?
29 The reason is that objdump sees an ELF file through a BFD filter of the
30 world; if BFD has a bug where, say, it disagrees about a machine constant
31 in e_flags, then the odds are good that it will remain internally
32 consistent. The linker sees it the BFD way, objdump sees it the BFD way,
33 GAS sees it the BFD way. There was need for a tool to go find out what
34 the file actually says.
36 This is why the readelf program does not link against the BFD library - it
37 exists as an independent program to help verify the correct working of BFD.
39 There is also the case that readelf can provide more information about an
40 ELF file than is provided by objdump. In particular it can display DWARF
41 debugging information which (at the moment) objdump cannot. */
52 /* Define BFD64 here, even if our default architecture is 32 bit ELF
53 as this will allow us to read in and parse 64bit and 32bit ELF files.
54 Only do this if we believe that the compiler can support a 64 bit
55 data type. For now we only rely on GCC being able to do this. */
64 #include "elf/common.h"
65 #include "elf/external.h"
66 #include "elf/internal.h"
69 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
70 we can obtain the H8 reloc numbers. We need these for the
71 get_reloc_size() function. We include h8.h again after defining
72 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
77 /* Undo the effects of #including reloc-macros.h. */
79 #undef START_RELOC_NUMBERS
83 #undef END_RELOC_NUMBERS
84 #undef _RELOC_MACROS_H
86 /* The following headers use the elf/reloc-macros.h file to
87 automatically generate relocation recognition functions
88 such as elf_mips_reloc_type() */
90 #define RELOC_MACROS_GEN_FUNC
92 #include "elf/aarch64.h"
93 #include "elf/alpha.h"
101 #include "elf/d10v.h"
102 #include "elf/d30v.h"
104 #include "elf/epiphany.h"
105 #include "elf/fr30.h"
107 #include "elf/ft32.h"
109 #include "elf/hppa.h"
110 #include "elf/i386.h"
111 #include "elf/i370.h"
112 #include "elf/i860.h"
113 #include "elf/i960.h"
114 #include "elf/ia64.h"
115 #include "elf/ip2k.h"
116 #include "elf/lm32.h"
117 #include "elf/iq2000.h"
118 #include "elf/m32c.h"
119 #include "elf/m32r.h"
120 #include "elf/m68k.h"
121 #include "elf/m68hc11.h"
122 #include "elf/mcore.h"
124 #include "elf/metag.h"
125 #include "elf/microblaze.h"
126 #include "elf/mips.h"
127 #include "elf/riscv.h"
128 #include "elf/mmix.h"
129 #include "elf/mn10200.h"
130 #include "elf/mn10300.h"
131 #include "elf/moxie.h"
133 #include "elf/msp430.h"
134 #include "elf/nds32.h"
135 #include "elf/nios2.h"
136 #include "elf/or1k.h"
139 #include "elf/ppc64.h"
141 #include "elf/rl78.h"
143 #include "elf/s390.h"
144 #include "elf/score.h"
146 #include "elf/sparc.h"
148 #include "elf/tic6x.h"
149 #include "elf/tilegx.h"
150 #include "elf/tilepro.h"
151 #include "elf/v850.h"
153 #include "elf/visium.h"
154 #include "elf/x86-64.h"
155 #include "elf/xc16x.h"
156 #include "elf/xgate.h"
157 #include "elf/xstormy16.h"
158 #include "elf/xtensa.h"
161 #include "libiberty.h"
162 #include "safe-ctype.h"
163 #include "filenames.h"
166 #define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
169 typedef struct elf_section_list
171 Elf_Internal_Shdr * hdr;
172 struct elf_section_list * next;
175 char * program_name = "readelf";
176 static unsigned long archive_file_offset;
177 static unsigned long archive_file_size;
178 static bfd_size_type current_file_size;
179 static unsigned long dynamic_addr;
180 static bfd_size_type dynamic_size;
181 static size_t dynamic_nent;
182 static char * dynamic_strings;
183 static unsigned long dynamic_strings_length;
184 static char * string_table;
185 static unsigned long string_table_length;
186 static unsigned long num_dynamic_syms;
187 static Elf_Internal_Sym * dynamic_symbols;
188 static Elf_Internal_Syminfo * dynamic_syminfo;
189 static unsigned long dynamic_syminfo_offset;
190 static unsigned int dynamic_syminfo_nent;
191 static char program_interpreter[PATH_MAX];
192 static bfd_vma dynamic_info[DT_ENCODING];
193 static bfd_vma dynamic_info_DT_GNU_HASH;
194 static bfd_vma version_info[16];
195 static Elf_Internal_Ehdr elf_header;
196 static Elf_Internal_Shdr * section_headers;
197 static Elf_Internal_Phdr * program_headers;
198 static Elf_Internal_Dyn * dynamic_section;
199 static elf_section_list * symtab_shndx_list;
200 static bfd_boolean show_name = FALSE;
201 static bfd_boolean do_dynamic = FALSE;
202 static bfd_boolean do_syms = FALSE;
203 static bfd_boolean do_dyn_syms = FALSE;
204 static bfd_boolean do_reloc = FALSE;
205 static bfd_boolean do_sections = FALSE;
206 static bfd_boolean do_section_groups = FALSE;
207 static bfd_boolean do_section_details = FALSE;
208 static bfd_boolean do_segments = FALSE;
209 static bfd_boolean do_unwind = FALSE;
210 static bfd_boolean do_using_dynamic = FALSE;
211 static bfd_boolean do_header = FALSE;
212 static bfd_boolean do_dump = FALSE;
213 static bfd_boolean do_version = FALSE;
214 static bfd_boolean do_histogram = FALSE;
215 static bfd_boolean do_debugging = FALSE;
216 static bfd_boolean do_arch = FALSE;
217 static bfd_boolean do_notes = FALSE;
218 static bfd_boolean do_archive_index = FALSE;
219 static bfd_boolean is_32bit_elf = FALSE;
220 static bfd_boolean decompress_dumps = FALSE;
224 struct group_list * next;
225 unsigned int section_index;
230 struct group_list * root;
231 unsigned int group_index;
234 static size_t group_count;
235 static struct group * section_groups;
236 static struct group ** section_headers_groups;
239 /* Flag bits indicating particular types of dump. */
240 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
241 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
242 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
243 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
244 #define RELOC_DUMP (1 << 4) /* The -R command line switch. */
246 typedef unsigned char dump_type;
248 /* A linked list of the section names for which dumps were requested. */
249 struct dump_list_entry
253 struct dump_list_entry * next;
255 static struct dump_list_entry * dump_sects_byname;
257 /* A dynamic array of flags indicating for which sections a dump
258 has been requested via command line switches. */
259 static dump_type * cmdline_dump_sects = NULL;
260 static unsigned int num_cmdline_dump_sects = 0;
262 /* A dynamic array of flags indicating for which sections a dump of
263 some kind has been requested. It is reset on a per-object file
264 basis and then initialised from the cmdline_dump_sects array,
265 the results of interpreting the -w switch, and the
266 dump_sects_byname list. */
267 static dump_type * dump_sects = NULL;
268 static unsigned int num_dump_sects = 0;
271 /* How to print a vma value. */
272 typedef enum print_mode
284 /* Versioned symbol info. */
285 enum versioned_symbol_info
292 static const char * get_symbol_version_string
293 (FILE *, bfd_boolean, const char *, unsigned long, unsigned,
294 Elf_Internal_Sym *, enum versioned_symbol_info *, unsigned short *);
298 #define SECTION_NAME(X) \
299 ((X) == NULL ? _("<none>") \
300 : string_table == NULL ? _("<no-name>") \
301 : ((X)->sh_name >= string_table_length ? _("<corrupt>") \
302 : string_table + (X)->sh_name))
304 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
306 #define GET_ELF_SYMBOLS(file, section, sym_count) \
307 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
308 : get_64bit_elf_symbols (file, section, sym_count))
310 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
311 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
312 already been called and verified that the string exists. */
313 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
315 #define REMOVE_ARCH_BITS(ADDR) \
318 if (elf_header.e_machine == EM_ARM) \
323 /* Retrieve NMEMB structures, each SIZE bytes long from FILE starting at OFFSET +
324 the offset of the current archive member, if we are examining an archive.
325 Put the retrieved data into VAR, if it is not NULL. Otherwise allocate a buffer
326 using malloc and fill that. In either case return the pointer to the start of
327 the retrieved data or NULL if something went wrong. If something does go wrong
328 and REASON is not NULL then emit an error message using REASON as part of the
332 get_data (void * var, FILE * file, unsigned long offset, bfd_size_type size,
333 bfd_size_type nmemb, const char * reason)
336 bfd_size_type amt = size * nmemb;
338 if (size == 0 || nmemb == 0)
341 /* If the size_t type is smaller than the bfd_size_type, eg because
342 you are building a 32-bit tool on a 64-bit host, then make sure
343 that when the sizes are cast to (size_t) no information is lost. */
344 if (sizeof (size_t) < sizeof (bfd_size_type)
345 && ( (bfd_size_type) ((size_t) size) != size
346 || (bfd_size_type) ((size_t) nmemb) != nmemb))
349 error (_("Size truncation prevents reading 0x%" BFD_VMA_FMT "x"
350 " elements of size 0x%" BFD_VMA_FMT "x for %s\n"),
351 nmemb, size, reason);
355 /* Check for size overflow. */
359 error (_("Size overflow prevents reading 0x%" BFD_VMA_FMT "x"
360 " elements of size 0x%" BFD_VMA_FMT "x for %s\n"),
361 nmemb, size, reason);
365 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
366 attempting to allocate memory when the read is bound to fail. */
367 if (amt > current_file_size
368 || offset + archive_file_offset + amt > current_file_size)
371 error (_("Reading 0x%" BFD_VMA_FMT "x"
372 " bytes extends past end of file for %s\n"),
377 if (fseek (file, archive_file_offset + offset, SEEK_SET))
380 error (_("Unable to seek to 0x%lx for %s\n"),
381 archive_file_offset + offset, reason);
388 /* Check for overflow. */
389 if (nmemb < (~(bfd_size_type) 0 - 1) / size)
390 /* + 1 so that we can '\0' terminate invalid string table sections. */
391 mvar = malloc ((size_t) amt + 1);
396 error (_("Out of memory allocating 0x%" BFD_VMA_FMT "x"
402 ((char *) mvar)[amt] = '\0';
405 if (fread (mvar, (size_t) size, (size_t) nmemb, file) != nmemb)
408 error (_("Unable to read in 0x%" BFD_VMA_FMT "x bytes of %s\n"),
418 /* Print a VMA value in the MODE specified.
419 Returns the number of characters displayed. */
422 print_vma (bfd_vma vma, print_mode mode)
434 return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
441 return printf ("%5" BFD_VMA_FMT "d", vma);
447 return nc + printf ("%" BFD_VMA_FMT "x", vma);
450 return printf ("%" BFD_VMA_FMT "d", vma);
453 return printf ("%" BFD_VMA_FMT "u", vma);
456 /* FIXME: Report unrecognised mode ? */
461 /* Display a symbol on stdout. Handles the display of control characters and
462 multibye characters (assuming the host environment supports them).
464 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
466 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
467 padding as necessary.
469 Returns the number of emitted characters. */
472 print_symbol (signed int width, const char *symbol)
474 bfd_boolean extra_padding = FALSE;
475 signed int num_printed = 0;
476 #ifdef HAVE_MBSTATE_T
479 unsigned int width_remaining;
483 /* Keep the width positive. This also helps. */
485 extra_padding = TRUE;
490 /* Set the remaining width to a very large value.
491 This simplifies the code below. */
492 width_remaining = INT_MAX;
494 width_remaining = width;
496 #ifdef HAVE_MBSTATE_T
497 /* Initialise the multibyte conversion state. */
498 memset (& state, 0, sizeof (state));
501 while (width_remaining)
504 const char c = *symbol++;
509 /* Do not print control characters directly as they can affect terminal
510 settings. Such characters usually appear in the names generated
511 by the assembler for local labels. */
514 if (width_remaining < 2)
517 printf ("^%c", c + 0x40);
518 width_remaining -= 2;
521 else if (ISPRINT (c))
529 #ifdef HAVE_MBSTATE_T
532 /* Let printf do the hard work of displaying multibyte characters. */
533 printf ("%.1s", symbol - 1);
537 #ifdef HAVE_MBSTATE_T
538 /* Try to find out how many bytes made up the character that was
539 just printed. Advance the symbol pointer past the bytes that
541 n = mbrtowc (& w, symbol - 1, MB_CUR_MAX, & state);
545 if (n != (size_t) -1 && n != (size_t) -2 && n > 0)
550 if (extra_padding && num_printed < width)
552 /* Fill in the remaining spaces. */
553 printf ("%-*s", width - num_printed, " ");
560 /* Returns a pointer to a static buffer containing a printable version of
561 the given section's name. Like print_symbol, except that it does not try
562 to print multibyte characters, it just interprets them as hex values. */
565 printable_section_name (const Elf_Internal_Shdr * sec)
567 #define MAX_PRINT_SEC_NAME_LEN 128
568 static char sec_name_buf [MAX_PRINT_SEC_NAME_LEN + 1];
569 const char * name = SECTION_NAME (sec);
570 char * buf = sec_name_buf;
572 unsigned int remaining = MAX_PRINT_SEC_NAME_LEN;
574 while ((c = * name ++) != 0)
585 else if (ISPRINT (c))
592 static char hex[17] = "0123456789ABCDEF";
597 * buf ++ = hex[(c & 0xf0) >> 4];
598 * buf ++ = hex[c & 0x0f];
612 printable_section_name_from_index (unsigned long ndx)
614 if (ndx >= elf_header.e_shnum)
615 return _("<corrupt>");
617 return printable_section_name (section_headers + ndx);
620 /* Return a pointer to section NAME, or NULL if no such section exists. */
622 static Elf_Internal_Shdr *
623 find_section (const char * name)
627 for (i = 0; i < elf_header.e_shnum; i++)
628 if (streq (SECTION_NAME (section_headers + i), name))
629 return section_headers + i;
634 /* Return a pointer to a section containing ADDR, or NULL if no such
637 static Elf_Internal_Shdr *
638 find_section_by_address (bfd_vma addr)
642 for (i = 0; i < elf_header.e_shnum; i++)
644 Elf_Internal_Shdr *sec = section_headers + i;
645 if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
652 static Elf_Internal_Shdr *
653 find_section_by_type (unsigned int type)
657 for (i = 0; i < elf_header.e_shnum; i++)
659 Elf_Internal_Shdr *sec = section_headers + i;
660 if (sec->sh_type == type)
667 /* Return a pointer to section NAME, or NULL if no such section exists,
668 restricted to the list of sections given in SET. */
670 static Elf_Internal_Shdr *
671 find_section_in_set (const char * name, unsigned int * set)
677 while ((i = *set++) > 0)
679 /* See PR 21156 for a reproducer. */
680 if (i >= elf_header.e_shnum)
681 continue; /* FIXME: Should we issue an error message ? */
683 if (streq (SECTION_NAME (section_headers + i), name))
684 return section_headers + i;
688 return find_section (name);
691 /* Read an unsigned LEB128 encoded value from DATA.
692 Set *LENGTH_RETURN to the number of bytes read. */
694 static inline unsigned long
695 read_uleb128 (unsigned char * data,
696 unsigned int * length_return,
697 const unsigned char * const end)
699 return read_leb128 (data, length_return, FALSE, end);
702 /* Return TRUE if the current file is for IA-64 machine and OpenVMS ABI.
703 This OS has so many departures from the ELF standard that we test it at
706 static inline bfd_boolean
709 return elf_header.e_machine == EM_IA_64
710 && elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
713 /* Guess the relocation size commonly used by the specific machines. */
716 guess_is_rela (unsigned int e_machine)
720 /* Targets that use REL relocations. */
735 /* Targets that use RELA relocations. */
739 case EM_ADAPTEVA_EPIPHANY:
741 case EM_ALTERA_NIOS2:
744 case EM_ARC_COMPACT2:
764 case EM_LATTICEMICO32:
773 case EM_CYGNUS_MN10200:
775 case EM_CYGNUS_MN10300:
811 case EM_MICROBLAZE_OLD:
832 warn (_("Don't know about relocations on this machine architecture\n"));
837 /* Load RELA type relocations from FILE at REL_OFFSET extending for REL_SIZE bytes.
838 Returns TRUE upon success, FALSE otherwise. If successful then a
839 pointer to a malloc'ed buffer containing the relocs is placed in *RELASP,
840 and the number of relocs loaded is placed in *NRELASP. It is the caller's
841 responsibility to free the allocated buffer. */
844 slurp_rela_relocs (FILE * file,
845 unsigned long rel_offset,
846 unsigned long rel_size,
847 Elf_Internal_Rela ** relasp,
848 unsigned long * nrelasp)
850 Elf_Internal_Rela * relas;
856 Elf32_External_Rela * erelas;
858 erelas = (Elf32_External_Rela *) get_data (NULL, file, rel_offset, 1,
859 rel_size, _("32-bit relocation data"));
863 nrelas = rel_size / sizeof (Elf32_External_Rela);
865 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
866 sizeof (Elf_Internal_Rela));
871 error (_("out of memory parsing relocs\n"));
875 for (i = 0; i < nrelas; i++)
877 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
878 relas[i].r_info = BYTE_GET (erelas[i].r_info);
879 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
886 Elf64_External_Rela * erelas;
888 erelas = (Elf64_External_Rela *) get_data (NULL, file, rel_offset, 1,
889 rel_size, _("64-bit relocation data"));
893 nrelas = rel_size / sizeof (Elf64_External_Rela);
895 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
896 sizeof (Elf_Internal_Rela));
901 error (_("out of memory parsing relocs\n"));
905 for (i = 0; i < nrelas; i++)
907 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
908 relas[i].r_info = BYTE_GET (erelas[i].r_info);
909 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
911 /* The #ifdef BFD64 below is to prevent a compile time
912 warning. We know that if we do not have a 64 bit data
913 type that we will never execute this code anyway. */
915 if (elf_header.e_machine == EM_MIPS
916 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
918 /* In little-endian objects, r_info isn't really a
919 64-bit little-endian value: it has a 32-bit
920 little-endian symbol index followed by four
921 individual byte fields. Reorder INFO
923 bfd_vma inf = relas[i].r_info;
924 inf = (((inf & 0xffffffff) << 32)
925 | ((inf >> 56) & 0xff)
926 | ((inf >> 40) & 0xff00)
927 | ((inf >> 24) & 0xff0000)
928 | ((inf >> 8) & 0xff000000));
929 relas[i].r_info = inf;
942 /* Load REL type relocations from FILE at REL_OFFSET extending for REL_SIZE bytes.
943 Returns TRUE upon success, FALSE otherwise. If successful then a
944 pointer to a malloc'ed buffer containing the relocs is placed in *RELSP,
945 and the number of relocs loaded is placed in *NRELSP. It is the caller's
946 responsibility to free the allocated buffer. */
949 slurp_rel_relocs (FILE * file,
950 unsigned long rel_offset,
951 unsigned long rel_size,
952 Elf_Internal_Rela ** relsp,
953 unsigned long * nrelsp)
955 Elf_Internal_Rela * rels;
961 Elf32_External_Rel * erels;
963 erels = (Elf32_External_Rel *) get_data (NULL, file, rel_offset, 1,
964 rel_size, _("32-bit relocation data"));
968 nrels = rel_size / sizeof (Elf32_External_Rel);
970 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
975 error (_("out of memory parsing relocs\n"));
979 for (i = 0; i < nrels; i++)
981 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
982 rels[i].r_info = BYTE_GET (erels[i].r_info);
983 rels[i].r_addend = 0;
990 Elf64_External_Rel * erels;
992 erels = (Elf64_External_Rel *) get_data (NULL, file, rel_offset, 1,
993 rel_size, _("64-bit relocation data"));
997 nrels = rel_size / sizeof (Elf64_External_Rel);
999 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
1004 error (_("out of memory parsing relocs\n"));
1008 for (i = 0; i < nrels; i++)
1010 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
1011 rels[i].r_info = BYTE_GET (erels[i].r_info);
1012 rels[i].r_addend = 0;
1014 /* The #ifdef BFD64 below is to prevent a compile time
1015 warning. We know that if we do not have a 64 bit data
1016 type that we will never execute this code anyway. */
1018 if (elf_header.e_machine == EM_MIPS
1019 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
1021 /* In little-endian objects, r_info isn't really a
1022 64-bit little-endian value: it has a 32-bit
1023 little-endian symbol index followed by four
1024 individual byte fields. Reorder INFO
1026 bfd_vma inf = rels[i].r_info;
1027 inf = (((inf & 0xffffffff) << 32)
1028 | ((inf >> 56) & 0xff)
1029 | ((inf >> 40) & 0xff00)
1030 | ((inf >> 24) & 0xff0000)
1031 | ((inf >> 8) & 0xff000000));
1032 rels[i].r_info = inf;
1045 /* Returns the reloc type extracted from the reloc info field. */
1048 get_reloc_type (bfd_vma reloc_info)
1051 return ELF32_R_TYPE (reloc_info);
1053 switch (elf_header.e_machine)
1056 /* Note: We assume that reloc_info has already been adjusted for us. */
1057 return ELF64_MIPS_R_TYPE (reloc_info);
1060 return ELF64_R_TYPE_ID (reloc_info);
1063 return ELF64_R_TYPE (reloc_info);
1067 /* Return the symbol index extracted from the reloc info field. */
1070 get_reloc_symindex (bfd_vma reloc_info)
1072 return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
1075 static inline bfd_boolean
1076 uses_msp430x_relocs (void)
1079 elf_header.e_machine == EM_MSP430 /* Paranoia. */
1080 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1081 && (((elf_header.e_flags & EF_MSP430_MACH) == E_MSP430_MACH_MSP430X)
1082 /* TI compiler uses ELFOSABI_NONE. */
1083 || (elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE));
1086 /* Display the contents of the relocation data found at the specified
1090 dump_relocations (FILE * file,
1091 unsigned long rel_offset,
1092 unsigned long rel_size,
1093 Elf_Internal_Sym * symtab,
1094 unsigned long nsyms,
1096 unsigned long strtablen,
1098 bfd_boolean is_dynsym)
1101 Elf_Internal_Rela * rels;
1102 bfd_boolean res = TRUE;
1104 if (is_rela == UNKNOWN)
1105 is_rela = guess_is_rela (elf_header.e_machine);
1109 if (!slurp_rela_relocs (file, rel_offset, rel_size, &rels, &rel_size))
1114 if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
1123 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1125 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1130 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1132 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1140 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
1142 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1147 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
1149 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1153 for (i = 0; i < rel_size; i++)
1158 bfd_vma symtab_index;
1161 offset = rels[i].r_offset;
1162 inf = rels[i].r_info;
1164 type = get_reloc_type (inf);
1165 symtab_index = get_reloc_symindex (inf);
1169 printf ("%8.8lx %8.8lx ",
1170 (unsigned long) offset & 0xffffffff,
1171 (unsigned long) inf & 0xffffffff);
1175 #if BFD_HOST_64BIT_LONG
1177 ? "%16.16lx %16.16lx "
1178 : "%12.12lx %12.12lx ",
1180 #elif BFD_HOST_64BIT_LONG_LONG
1183 ? "%16.16llx %16.16llx "
1184 : "%12.12llx %12.12llx ",
1188 ? "%16.16I64x %16.16I64x "
1189 : "%12.12I64x %12.12I64x ",
1194 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1195 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1196 _bfd_int64_high (offset),
1197 _bfd_int64_low (offset),
1198 _bfd_int64_high (inf),
1199 _bfd_int64_low (inf));
1203 switch (elf_header.e_machine)
1210 rtype = elf_aarch64_reloc_type (type);
1214 case EM_CYGNUS_M32R:
1215 rtype = elf_m32r_reloc_type (type);
1220 rtype = elf_i386_reloc_type (type);
1225 rtype = elf_m68hc11_reloc_type (type);
1229 rtype = elf_m68k_reloc_type (type);
1233 rtype = elf_i960_reloc_type (type);
1238 rtype = elf_avr_reloc_type (type);
1241 case EM_OLD_SPARCV9:
1242 case EM_SPARC32PLUS:
1245 rtype = elf_sparc_reloc_type (type);
1249 rtype = elf_spu_reloc_type (type);
1253 rtype = v800_reloc_type (type);
1256 case EM_CYGNUS_V850:
1257 rtype = v850_reloc_type (type);
1261 case EM_CYGNUS_D10V:
1262 rtype = elf_d10v_reloc_type (type);
1266 case EM_CYGNUS_D30V:
1267 rtype = elf_d30v_reloc_type (type);
1271 rtype = elf_dlx_reloc_type (type);
1275 rtype = elf_sh_reloc_type (type);
1279 case EM_CYGNUS_MN10300:
1280 rtype = elf_mn10300_reloc_type (type);
1284 case EM_CYGNUS_MN10200:
1285 rtype = elf_mn10200_reloc_type (type);
1289 case EM_CYGNUS_FR30:
1290 rtype = elf_fr30_reloc_type (type);
1294 rtype = elf_frv_reloc_type (type);
1298 rtype = elf_ft32_reloc_type (type);
1302 rtype = elf_mcore_reloc_type (type);
1306 rtype = elf_mmix_reloc_type (type);
1310 rtype = elf_moxie_reloc_type (type);
1314 if (uses_msp430x_relocs ())
1316 rtype = elf_msp430x_reloc_type (type);
1321 rtype = elf_msp430_reloc_type (type);
1325 rtype = elf_nds32_reloc_type (type);
1329 rtype = elf_ppc_reloc_type (type);
1333 rtype = elf_ppc64_reloc_type (type);
1337 case EM_MIPS_RS3_LE:
1338 rtype = elf_mips_reloc_type (type);
1342 rtype = elf_riscv_reloc_type (type);
1346 rtype = elf_alpha_reloc_type (type);
1350 rtype = elf_arm_reloc_type (type);
1354 case EM_ARC_COMPACT:
1355 case EM_ARC_COMPACT2:
1356 rtype = elf_arc_reloc_type (type);
1360 rtype = elf_hppa_reloc_type (type);
1366 rtype = elf_h8_reloc_type (type);
1370 rtype = elf_or1k_reloc_type (type);
1375 rtype = elf_pj_reloc_type (type);
1378 rtype = elf_ia64_reloc_type (type);
1382 rtype = elf_cris_reloc_type (type);
1386 rtype = elf_i860_reloc_type (type);
1392 rtype = elf_x86_64_reloc_type (type);
1396 rtype = i370_reloc_type (type);
1401 rtype = elf_s390_reloc_type (type);
1405 rtype = elf_score_reloc_type (type);
1409 rtype = elf_xstormy16_reloc_type (type);
1413 rtype = elf_crx_reloc_type (type);
1417 rtype = elf_vax_reloc_type (type);
1421 rtype = elf_visium_reloc_type (type);
1424 case EM_ADAPTEVA_EPIPHANY:
1425 rtype = elf_epiphany_reloc_type (type);
1430 rtype = elf_ip2k_reloc_type (type);
1434 rtype = elf_iq2000_reloc_type (type);
1439 rtype = elf_xtensa_reloc_type (type);
1442 case EM_LATTICEMICO32:
1443 rtype = elf_lm32_reloc_type (type);
1448 rtype = elf_m32c_reloc_type (type);
1452 rtype = elf_mt_reloc_type (type);
1456 rtype = elf_bfin_reloc_type (type);
1460 rtype = elf_mep_reloc_type (type);
1464 rtype = elf_cr16_reloc_type (type);
1468 case EM_MICROBLAZE_OLD:
1469 rtype = elf_microblaze_reloc_type (type);
1473 rtype = elf_rl78_reloc_type (type);
1477 rtype = elf_rx_reloc_type (type);
1481 rtype = elf_metag_reloc_type (type);
1486 rtype = elf_xc16x_reloc_type (type);
1490 rtype = elf_tic6x_reloc_type (type);
1494 rtype = elf_tilegx_reloc_type (type);
1498 rtype = elf_tilepro_reloc_type (type);
1502 rtype = elf_xgate_reloc_type (type);
1505 case EM_ALTERA_NIOS2:
1506 rtype = elf_nios2_reloc_type (type);
1510 rtype = elf_pru_reloc_type (type);
1515 printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
1517 printf (do_wide ? "%-22.22s" : "%-17.17s", rtype);
1519 if (elf_header.e_machine == EM_ALPHA
1521 && streq (rtype, "R_ALPHA_LITUSE")
1524 switch (rels[i].r_addend)
1526 case LITUSE_ALPHA_ADDR: rtype = "ADDR"; break;
1527 case LITUSE_ALPHA_BASE: rtype = "BASE"; break;
1528 case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1529 case LITUSE_ALPHA_JSR: rtype = "JSR"; break;
1530 case LITUSE_ALPHA_TLSGD: rtype = "TLSGD"; break;
1531 case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1532 case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1533 default: rtype = NULL;
1537 printf (" (%s)", rtype);
1541 printf (_("<unknown addend: %lx>"),
1542 (unsigned long) rels[i].r_addend);
1546 else if (symtab_index)
1548 if (symtab == NULL || symtab_index >= nsyms)
1550 error (_(" bad symbol index: %08lx in reloc"), (unsigned long) symtab_index);
1555 Elf_Internal_Sym * psym;
1556 const char * version_string;
1557 enum versioned_symbol_info sym_info;
1558 unsigned short vna_other;
1560 psym = symtab + symtab_index;
1563 = get_symbol_version_string (file, is_dynsym,
1572 if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1576 unsigned int width = is_32bit_elf ? 8 : 14;
1578 /* Relocations against GNU_IFUNC symbols do not use the value
1579 of the symbol as the address to relocate against. Instead
1580 they invoke the function named by the symbol and use its
1581 result as the address for relocation.
1583 To indicate this to the user, do not display the value of
1584 the symbol in the "Symbols's Value" field. Instead show
1585 its name followed by () as a hint that the symbol is
1589 || psym->st_name == 0
1590 || psym->st_name >= strtablen)
1593 name = strtab + psym->st_name;
1595 len = print_symbol (width, name);
1597 printf (sym_info == symbol_public ? "@@%s" : "@%s",
1599 printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1603 print_vma (psym->st_value, LONG_HEX);
1605 printf (is_32bit_elf ? " " : " ");
1608 if (psym->st_name == 0)
1610 const char * sec_name = "<null>";
1613 if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1615 if (psym->st_shndx < elf_header.e_shnum)
1616 sec_name = SECTION_NAME (section_headers + psym->st_shndx);
1617 else if (psym->st_shndx == SHN_ABS)
1619 else if (psym->st_shndx == SHN_COMMON)
1620 sec_name = "COMMON";
1621 else if ((elf_header.e_machine == EM_MIPS
1622 && psym->st_shndx == SHN_MIPS_SCOMMON)
1623 || (elf_header.e_machine == EM_TI_C6000
1624 && psym->st_shndx == SHN_TIC6X_SCOMMON))
1625 sec_name = "SCOMMON";
1626 else if (elf_header.e_machine == EM_MIPS
1627 && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1628 sec_name = "SUNDEF";
1629 else if ((elf_header.e_machine == EM_X86_64
1630 || elf_header.e_machine == EM_L1OM
1631 || elf_header.e_machine == EM_K1OM)
1632 && psym->st_shndx == SHN_X86_64_LCOMMON)
1633 sec_name = "LARGE_COMMON";
1634 else if (elf_header.e_machine == EM_IA_64
1635 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1636 && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1637 sec_name = "ANSI_COM";
1638 else if (is_ia64_vms ()
1639 && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1640 sec_name = "VMS_SYMVEC";
1643 sprintf (name_buf, "<section 0x%x>",
1644 (unsigned int) psym->st_shndx);
1645 sec_name = name_buf;
1648 print_symbol (22, sec_name);
1650 else if (strtab == NULL)
1651 printf (_("<string table index: %3ld>"), psym->st_name);
1652 else if (psym->st_name >= strtablen)
1654 error (_("<corrupt string table index: %3ld>"), psym->st_name);
1659 print_symbol (22, strtab + psym->st_name);
1661 printf (sym_info == symbol_public ? "@@%s" : "@%s",
1667 bfd_vma off = rels[i].r_addend;
1669 if ((bfd_signed_vma) off < 0)
1670 printf (" - %" BFD_VMA_FMT "x", - off);
1672 printf (" + %" BFD_VMA_FMT "x", off);
1678 bfd_vma off = rels[i].r_addend;
1680 printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
1681 if ((bfd_signed_vma) off < 0)
1682 printf ("-%" BFD_VMA_FMT "x", - off);
1684 printf ("%" BFD_VMA_FMT "x", off);
1687 if (elf_header.e_machine == EM_SPARCV9
1689 && streq (rtype, "R_SPARC_OLO10"))
1690 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
1695 if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
1697 bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1698 bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
1699 const char * rtype2 = elf_mips_reloc_type (type2);
1700 const char * rtype3 = elf_mips_reloc_type (type3);
1702 printf (" Type2: ");
1705 printf (_("unrecognized: %-7lx"),
1706 (unsigned long) type2 & 0xffffffff);
1708 printf ("%-17.17s", rtype2);
1710 printf ("\n Type3: ");
1713 printf (_("unrecognized: %-7lx"),
1714 (unsigned long) type3 & 0xffffffff);
1716 printf ("%-17.17s", rtype3);
1729 get_mips_dynamic_type (unsigned long type)
1733 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1734 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1735 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1736 case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1737 case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1738 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1739 case DT_MIPS_MSYM: return "MIPS_MSYM";
1740 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1741 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1742 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1743 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1744 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1745 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1746 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1747 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1748 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1749 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1750 case DT_MIPS_RLD_MAP_REL: return "MIPS_RLD_MAP_REL";
1751 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1752 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1753 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1754 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1755 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1756 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1757 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1758 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1759 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1760 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1761 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1762 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1763 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1764 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1765 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1766 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1767 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1768 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1769 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1770 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1771 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1772 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1773 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1774 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1775 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1776 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
1777 case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1778 case DT_MIPS_RWPLT: return "MIPS_RWPLT";
1785 get_sparc64_dynamic_type (unsigned long type)
1789 case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1796 get_ppc_dynamic_type (unsigned long type)
1800 case DT_PPC_GOT: return "PPC_GOT";
1801 case DT_PPC_OPT: return "PPC_OPT";
1808 get_ppc64_dynamic_type (unsigned long type)
1812 case DT_PPC64_GLINK: return "PPC64_GLINK";
1813 case DT_PPC64_OPD: return "PPC64_OPD";
1814 case DT_PPC64_OPDSZ: return "PPC64_OPDSZ";
1815 case DT_PPC64_OPT: return "PPC64_OPT";
1822 get_parisc_dynamic_type (unsigned long type)
1826 case DT_HP_LOAD_MAP: return "HP_LOAD_MAP";
1827 case DT_HP_DLD_FLAGS: return "HP_DLD_FLAGS";
1828 case DT_HP_DLD_HOOK: return "HP_DLD_HOOK";
1829 case DT_HP_UX10_INIT: return "HP_UX10_INIT";
1830 case DT_HP_UX10_INITSZ: return "HP_UX10_INITSZ";
1831 case DT_HP_PREINIT: return "HP_PREINIT";
1832 case DT_HP_PREINITSZ: return "HP_PREINITSZ";
1833 case DT_HP_NEEDED: return "HP_NEEDED";
1834 case DT_HP_TIME_STAMP: return "HP_TIME_STAMP";
1835 case DT_HP_CHECKSUM: return "HP_CHECKSUM";
1836 case DT_HP_GST_SIZE: return "HP_GST_SIZE";
1837 case DT_HP_GST_VERSION: return "HP_GST_VERSION";
1838 case DT_HP_GST_HASHVAL: return "HP_GST_HASHVAL";
1839 case DT_HP_EPLTREL: return "HP_GST_EPLTREL";
1840 case DT_HP_EPLTRELSZ: return "HP_GST_EPLTRELSZ";
1841 case DT_HP_FILTERED: return "HP_FILTERED";
1842 case DT_HP_FILTER_TLS: return "HP_FILTER_TLS";
1843 case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1844 case DT_HP_LAZYLOAD: return "HP_LAZYLOAD";
1845 case DT_HP_BIND_NOW_COUNT: return "HP_BIND_NOW_COUNT";
1846 case DT_PLT: return "PLT";
1847 case DT_PLT_SIZE: return "PLT_SIZE";
1848 case DT_DLT: return "DLT";
1849 case DT_DLT_SIZE: return "DLT_SIZE";
1856 get_ia64_dynamic_type (unsigned long type)
1860 case DT_IA_64_PLT_RESERVE: return "IA_64_PLT_RESERVE";
1861 case DT_IA_64_VMS_SUBTYPE: return "VMS_SUBTYPE";
1862 case DT_IA_64_VMS_IMGIOCNT: return "VMS_IMGIOCNT";
1863 case DT_IA_64_VMS_LNKFLAGS: return "VMS_LNKFLAGS";
1864 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1865 case DT_IA_64_VMS_IDENT: return "VMS_IDENT";
1866 case DT_IA_64_VMS_NEEDED_IDENT: return "VMS_NEEDED_IDENT";
1867 case DT_IA_64_VMS_IMG_RELA_CNT: return "VMS_IMG_RELA_CNT";
1868 case DT_IA_64_VMS_SEG_RELA_CNT: return "VMS_SEG_RELA_CNT";
1869 case DT_IA_64_VMS_FIXUP_RELA_CNT: return "VMS_FIXUP_RELA_CNT";
1870 case DT_IA_64_VMS_FIXUP_NEEDED: return "VMS_FIXUP_NEEDED";
1871 case DT_IA_64_VMS_SYMVEC_CNT: return "VMS_SYMVEC_CNT";
1872 case DT_IA_64_VMS_XLATED: return "VMS_XLATED";
1873 case DT_IA_64_VMS_STACKSIZE: return "VMS_STACKSIZE";
1874 case DT_IA_64_VMS_UNWINDSZ: return "VMS_UNWINDSZ";
1875 case DT_IA_64_VMS_UNWIND_CODSEG: return "VMS_UNWIND_CODSEG";
1876 case DT_IA_64_VMS_UNWIND_INFOSEG: return "VMS_UNWIND_INFOSEG";
1877 case DT_IA_64_VMS_LINKTIME: return "VMS_LINKTIME";
1878 case DT_IA_64_VMS_SEG_NO: return "VMS_SEG_NO";
1879 case DT_IA_64_VMS_SYMVEC_OFFSET: return "VMS_SYMVEC_OFFSET";
1880 case DT_IA_64_VMS_SYMVEC_SEG: return "VMS_SYMVEC_SEG";
1881 case DT_IA_64_VMS_UNWIND_OFFSET: return "VMS_UNWIND_OFFSET";
1882 case DT_IA_64_VMS_UNWIND_SEG: return "VMS_UNWIND_SEG";
1883 case DT_IA_64_VMS_STRTAB_OFFSET: return "VMS_STRTAB_OFFSET";
1884 case DT_IA_64_VMS_SYSVER_OFFSET: return "VMS_SYSVER_OFFSET";
1885 case DT_IA_64_VMS_IMG_RELA_OFF: return "VMS_IMG_RELA_OFF";
1886 case DT_IA_64_VMS_SEG_RELA_OFF: return "VMS_SEG_RELA_OFF";
1887 case DT_IA_64_VMS_FIXUP_RELA_OFF: return "VMS_FIXUP_RELA_OFF";
1888 case DT_IA_64_VMS_PLTGOT_OFFSET: return "VMS_PLTGOT_OFFSET";
1889 case DT_IA_64_VMS_PLTGOT_SEG: return "VMS_PLTGOT_SEG";
1890 case DT_IA_64_VMS_FPMODE: return "VMS_FPMODE";
1897 get_solaris_section_type (unsigned long type)
1901 case 0x6fffffee: return "SUNW_ancillary";
1902 case 0x6fffffef: return "SUNW_capchain";
1903 case 0x6ffffff0: return "SUNW_capinfo";
1904 case 0x6ffffff1: return "SUNW_symsort";
1905 case 0x6ffffff2: return "SUNW_tlssort";
1906 case 0x6ffffff3: return "SUNW_LDYNSYM";
1907 case 0x6ffffff4: return "SUNW_dof";
1908 case 0x6ffffff5: return "SUNW_cap";
1909 case 0x6ffffff6: return "SUNW_SIGNATURE";
1910 case 0x6ffffff7: return "SUNW_ANNOTATE";
1911 case 0x6ffffff8: return "SUNW_DEBUGSTR";
1912 case 0x6ffffff9: return "SUNW_DEBUG";
1913 case 0x6ffffffa: return "SUNW_move";
1914 case 0x6ffffffb: return "SUNW_COMDAT";
1915 case 0x6ffffffc: return "SUNW_syminfo";
1916 case 0x6ffffffd: return "SUNW_verdef";
1917 case 0x6ffffffe: return "SUNW_verneed";
1918 case 0x6fffffff: return "SUNW_versym";
1919 case 0x70000000: return "SPARC_GOTDATA";
1920 default: return NULL;
1925 get_alpha_dynamic_type (unsigned long type)
1929 case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
1930 default: return NULL;
1935 get_score_dynamic_type (unsigned long type)
1939 case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
1940 case DT_SCORE_LOCAL_GOTNO: return "SCORE_LOCAL_GOTNO";
1941 case DT_SCORE_SYMTABNO: return "SCORE_SYMTABNO";
1942 case DT_SCORE_GOTSYM: return "SCORE_GOTSYM";
1943 case DT_SCORE_UNREFEXTNO: return "SCORE_UNREFEXTNO";
1944 case DT_SCORE_HIPAGENO: return "SCORE_HIPAGENO";
1945 default: return NULL;
1950 get_tic6x_dynamic_type (unsigned long type)
1954 case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
1955 case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
1956 case DT_C6000_DSBT_BASE: return "C6000_DSBT_BASE";
1957 case DT_C6000_DSBT_SIZE: return "C6000_DSBT_SIZE";
1958 case DT_C6000_PREEMPTMAP: return "C6000_PREEMPTMAP";
1959 case DT_C6000_DSBT_INDEX: return "C6000_DSBT_INDEX";
1960 default: return NULL;
1965 get_nios2_dynamic_type (unsigned long type)
1969 case DT_NIOS2_GP: return "NIOS2_GP";
1970 default: return NULL;
1975 get_solaris_dynamic_type (unsigned long type)
1979 case 0x6000000d: return "SUNW_AUXILIARY";
1980 case 0x6000000e: return "SUNW_RTLDINF";
1981 case 0x6000000f: return "SUNW_FILTER";
1982 case 0x60000010: return "SUNW_CAP";
1983 case 0x60000011: return "SUNW_SYMTAB";
1984 case 0x60000012: return "SUNW_SYMSZ";
1985 case 0x60000013: return "SUNW_SORTENT";
1986 case 0x60000014: return "SUNW_SYMSORT";
1987 case 0x60000015: return "SUNW_SYMSORTSZ";
1988 case 0x60000016: return "SUNW_TLSSORT";
1989 case 0x60000017: return "SUNW_TLSSORTSZ";
1990 case 0x60000018: return "SUNW_CAPINFO";
1991 case 0x60000019: return "SUNW_STRPAD";
1992 case 0x6000001a: return "SUNW_CAPCHAIN";
1993 case 0x6000001b: return "SUNW_LDMACH";
1994 case 0x6000001d: return "SUNW_CAPCHAINENT";
1995 case 0x6000001f: return "SUNW_CAPCHAINSZ";
1996 case 0x60000021: return "SUNW_PARENT";
1997 case 0x60000023: return "SUNW_ASLR";
1998 case 0x60000025: return "SUNW_RELAX";
1999 case 0x60000029: return "SUNW_NXHEAP";
2000 case 0x6000002b: return "SUNW_NXSTACK";
2002 case 0x70000001: return "SPARC_REGISTER";
2003 case 0x7ffffffd: return "AUXILIARY";
2004 case 0x7ffffffe: return "USED";
2005 case 0x7fffffff: return "FILTER";
2007 default: return NULL;
2012 get_dynamic_type (unsigned long type)
2014 static char buff[64];
2018 case DT_NULL: return "NULL";
2019 case DT_NEEDED: return "NEEDED";
2020 case DT_PLTRELSZ: return "PLTRELSZ";
2021 case DT_PLTGOT: return "PLTGOT";
2022 case DT_HASH: return "HASH";
2023 case DT_STRTAB: return "STRTAB";
2024 case DT_SYMTAB: return "SYMTAB";
2025 case DT_RELA: return "RELA";
2026 case DT_RELASZ: return "RELASZ";
2027 case DT_RELAENT: return "RELAENT";
2028 case DT_STRSZ: return "STRSZ";
2029 case DT_SYMENT: return "SYMENT";
2030 case DT_INIT: return "INIT";
2031 case DT_FINI: return "FINI";
2032 case DT_SONAME: return "SONAME";
2033 case DT_RPATH: return "RPATH";
2034 case DT_SYMBOLIC: return "SYMBOLIC";
2035 case DT_REL: return "REL";
2036 case DT_RELSZ: return "RELSZ";
2037 case DT_RELENT: return "RELENT";
2038 case DT_PLTREL: return "PLTREL";
2039 case DT_DEBUG: return "DEBUG";
2040 case DT_TEXTREL: return "TEXTREL";
2041 case DT_JMPREL: return "JMPREL";
2042 case DT_BIND_NOW: return "BIND_NOW";
2043 case DT_INIT_ARRAY: return "INIT_ARRAY";
2044 case DT_FINI_ARRAY: return "FINI_ARRAY";
2045 case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
2046 case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
2047 case DT_RUNPATH: return "RUNPATH";
2048 case DT_FLAGS: return "FLAGS";
2050 case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
2051 case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
2052 case DT_SYMTAB_SHNDX: return "SYMTAB_SHNDX";
2054 case DT_CHECKSUM: return "CHECKSUM";
2055 case DT_PLTPADSZ: return "PLTPADSZ";
2056 case DT_MOVEENT: return "MOVEENT";
2057 case DT_MOVESZ: return "MOVESZ";
2058 case DT_FEATURE: return "FEATURE";
2059 case DT_POSFLAG_1: return "POSFLAG_1";
2060 case DT_SYMINSZ: return "SYMINSZ";
2061 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
2063 case DT_ADDRRNGLO: return "ADDRRNGLO";
2064 case DT_CONFIG: return "CONFIG";
2065 case DT_DEPAUDIT: return "DEPAUDIT";
2066 case DT_AUDIT: return "AUDIT";
2067 case DT_PLTPAD: return "PLTPAD";
2068 case DT_MOVETAB: return "MOVETAB";
2069 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
2071 case DT_VERSYM: return "VERSYM";
2073 case DT_TLSDESC_GOT: return "TLSDESC_GOT";
2074 case DT_TLSDESC_PLT: return "TLSDESC_PLT";
2075 case DT_RELACOUNT: return "RELACOUNT";
2076 case DT_RELCOUNT: return "RELCOUNT";
2077 case DT_FLAGS_1: return "FLAGS_1";
2078 case DT_VERDEF: return "VERDEF";
2079 case DT_VERDEFNUM: return "VERDEFNUM";
2080 case DT_VERNEED: return "VERNEED";
2081 case DT_VERNEEDNUM: return "VERNEEDNUM";
2083 case DT_AUXILIARY: return "AUXILIARY";
2084 case DT_USED: return "USED";
2085 case DT_FILTER: return "FILTER";
2087 case DT_GNU_PRELINKED: return "GNU_PRELINKED";
2088 case DT_GNU_CONFLICT: return "GNU_CONFLICT";
2089 case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
2090 case DT_GNU_LIBLIST: return "GNU_LIBLIST";
2091 case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
2092 case DT_GNU_HASH: return "GNU_HASH";
2095 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
2097 const char * result;
2099 switch (elf_header.e_machine)
2102 case EM_MIPS_RS3_LE:
2103 result = get_mips_dynamic_type (type);
2106 result = get_sparc64_dynamic_type (type);
2109 result = get_ppc_dynamic_type (type);
2112 result = get_ppc64_dynamic_type (type);
2115 result = get_ia64_dynamic_type (type);
2118 result = get_alpha_dynamic_type (type);
2121 result = get_score_dynamic_type (type);
2124 result = get_tic6x_dynamic_type (type);
2126 case EM_ALTERA_NIOS2:
2127 result = get_nios2_dynamic_type (type);
2130 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
2131 result = get_solaris_dynamic_type (type);
2140 snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
2142 else if (((type >= DT_LOOS) && (type <= DT_HIOS))
2143 || (elf_header.e_machine == EM_PARISC
2144 && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
2146 const char * result;
2148 switch (elf_header.e_machine)
2151 result = get_parisc_dynamic_type (type);
2154 result = get_ia64_dynamic_type (type);
2157 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
2158 result = get_solaris_dynamic_type (type);
2167 snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
2171 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
2178 get_file_type (unsigned e_type)
2180 static char buff[32];
2184 case ET_NONE: return _("NONE (None)");
2185 case ET_REL: return _("REL (Relocatable file)");
2186 case ET_EXEC: return _("EXEC (Executable file)");
2187 case ET_DYN: return _("DYN (Shared object file)");
2188 case ET_CORE: return _("CORE (Core file)");
2191 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
2192 snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
2193 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
2194 snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
2196 snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
2202 get_machine_name (unsigned e_machine)
2204 static char buff[64]; /* XXX */
2208 case EM_NONE: return _("None");
2209 case EM_AARCH64: return "AArch64";
2210 case EM_M32: return "WE32100";
2211 case EM_SPARC: return "Sparc";
2212 case EM_SPU: return "SPU";
2213 case EM_386: return "Intel 80386";
2214 case EM_68K: return "MC68000";
2215 case EM_88K: return "MC88000";
2216 case EM_IAMCU: return "Intel MCU";
2217 case EM_860: return "Intel 80860";
2218 case EM_MIPS: return "MIPS R3000";
2219 case EM_S370: return "IBM System/370";
2220 case EM_MIPS_RS3_LE: return "MIPS R4000 big-endian";
2221 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
2222 case EM_PARISC: return "HPPA";
2223 case EM_PPC_OLD: return "Power PC (old)";
2224 case EM_SPARC32PLUS: return "Sparc v8+" ;
2225 case EM_960: return "Intel 90860";
2226 case EM_PPC: return "PowerPC";
2227 case EM_PPC64: return "PowerPC64";
2228 case EM_FR20: return "Fujitsu FR20";
2229 case EM_FT32: return "FTDI FT32";
2230 case EM_RH32: return "TRW RH32";
2231 case EM_MCORE: return "MCORE";
2232 case EM_ARM: return "ARM";
2233 case EM_OLD_ALPHA: return "Digital Alpha (old)";
2234 case EM_SH: return "Renesas / SuperH SH";
2235 case EM_SPARCV9: return "Sparc v9";
2236 case EM_TRICORE: return "Siemens Tricore";
2237 case EM_ARC: return "ARC";
2238 case EM_ARC_COMPACT: return "ARCompact";
2239 case EM_ARC_COMPACT2: return "ARCv2";
2240 case EM_H8_300: return "Renesas H8/300";
2241 case EM_H8_300H: return "Renesas H8/300H";
2242 case EM_H8S: return "Renesas H8S";
2243 case EM_H8_500: return "Renesas H8/500";
2244 case EM_IA_64: return "Intel IA-64";
2245 case EM_MIPS_X: return "Stanford MIPS-X";
2246 case EM_COLDFIRE: return "Motorola Coldfire";
2247 case EM_ALPHA: return "Alpha";
2248 case EM_CYGNUS_D10V:
2249 case EM_D10V: return "d10v";
2250 case EM_CYGNUS_D30V:
2251 case EM_D30V: return "d30v";
2252 case EM_CYGNUS_M32R:
2253 case EM_M32R: return "Renesas M32R (formerly Mitsubishi M32r)";
2254 case EM_CYGNUS_V850:
2255 case EM_V800: return "Renesas V850 (using RH850 ABI)";
2256 case EM_V850: return "Renesas V850";
2257 case EM_CYGNUS_MN10300:
2258 case EM_MN10300: return "mn10300";
2259 case EM_CYGNUS_MN10200:
2260 case EM_MN10200: return "mn10200";
2261 case EM_MOXIE: return "Moxie";
2262 case EM_CYGNUS_FR30:
2263 case EM_FR30: return "Fujitsu FR30";
2264 case EM_CYGNUS_FRV: return "Fujitsu FR-V";
2266 case EM_PJ: return "picoJava";
2267 case EM_MMA: return "Fujitsu Multimedia Accelerator";
2268 case EM_PCP: return "Siemens PCP";
2269 case EM_NCPU: return "Sony nCPU embedded RISC processor";
2270 case EM_NDR1: return "Denso NDR1 microprocesspr";
2271 case EM_STARCORE: return "Motorola Star*Core processor";
2272 case EM_ME16: return "Toyota ME16 processor";
2273 case EM_ST100: return "STMicroelectronics ST100 processor";
2274 case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
2275 case EM_PDSP: return "Sony DSP processor";
2276 case EM_PDP10: return "Digital Equipment Corp. PDP-10";
2277 case EM_PDP11: return "Digital Equipment Corp. PDP-11";
2278 case EM_FX66: return "Siemens FX66 microcontroller";
2279 case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2280 case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
2281 case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
2282 case EM_68HC12: return "Motorola MC68HC12 Microcontroller";
2283 case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
2284 case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
2285 case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
2286 case EM_SVX: return "Silicon Graphics SVx";
2287 case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
2288 case EM_VAX: return "Digital VAX";
2289 case EM_VISIUM: return "CDS VISIUMcore processor";
2291 case EM_AVR: return "Atmel AVR 8-bit microcontroller";
2292 case EM_CRIS: return "Axis Communications 32-bit embedded processor";
2293 case EM_JAVELIN: return "Infineon Technologies 32-bit embedded cpu";
2294 case EM_FIREPATH: return "Element 14 64-bit DSP processor";
2295 case EM_ZSP: return "LSI Logic's 16-bit DSP processor";
2296 case EM_MMIX: return "Donald Knuth's educational 64-bit processor";
2297 case EM_HUANY: return "Harvard Universitys's machine-independent object format";
2298 case EM_PRISM: return "Vitesse Prism";
2299 case EM_X86_64: return "Advanced Micro Devices X86-64";
2300 case EM_L1OM: return "Intel L1OM";
2301 case EM_K1OM: return "Intel K1OM";
2303 case EM_S390: return "IBM S/390";
2304 case EM_SCORE: return "SUNPLUS S+Core";
2305 case EM_XSTORMY16: return "Sanyo XStormy16 CPU core";
2306 case EM_OR1K: return "OpenRISC 1000";
2307 case EM_CRX: return "National Semiconductor CRX microprocessor";
2308 case EM_ADAPTEVA_EPIPHANY: return "Adapteva EPIPHANY";
2309 case EM_DLX: return "OpenDLX";
2311 case EM_IP2K: return "Ubicom IP2xxx 8-bit microcontrollers";
2312 case EM_IQ2000: return "Vitesse IQ2000";
2314 case EM_XTENSA: return "Tensilica Xtensa Processor";
2315 case EM_VIDEOCORE: return "Alphamosaic VideoCore processor";
2316 case EM_TMM_GPP: return "Thompson Multimedia General Purpose Processor";
2317 case EM_NS32K: return "National Semiconductor 32000 series";
2318 case EM_TPC: return "Tenor Network TPC processor";
2319 case EM_ST200: return "STMicroelectronics ST200 microcontroller";
2320 case EM_MAX: return "MAX Processor";
2321 case EM_CR: return "National Semiconductor CompactRISC";
2322 case EM_F2MC16: return "Fujitsu F2MC16";
2323 case EM_MSP430: return "Texas Instruments msp430 microcontroller";
2324 case EM_LATTICEMICO32: return "Lattice Mico32";
2326 case EM_M32C: return "Renesas M32c";
2327 case EM_MT: return "Morpho Techologies MT processor";
2328 case EM_BLACKFIN: return "Analog Devices Blackfin";
2329 case EM_SE_C33: return "S1C33 Family of Seiko Epson processors";
2330 case EM_SEP: return "Sharp embedded microprocessor";
2331 case EM_ARCA: return "Arca RISC microprocessor";
2332 case EM_UNICORE: return "Unicore";
2333 case EM_EXCESS: return "eXcess 16/32/64-bit configurable embedded CPU";
2334 case EM_DXP: return "Icera Semiconductor Inc. Deep Execution Processor";
2335 case EM_NIOS32: return "Altera Nios";
2336 case EM_ALTERA_NIOS2: return "Altera Nios II";
2338 case EM_XC16X: return "Infineon Technologies xc16x";
2339 case EM_M16C: return "Renesas M16C series microprocessors";
2340 case EM_DSPIC30F: return "Microchip Technology dsPIC30F Digital Signal Controller";
2341 case EM_CE: return "Freescale Communication Engine RISC core";
2342 case EM_TSK3000: return "Altium TSK3000 core";
2343 case EM_RS08: return "Freescale RS08 embedded processor";
2344 case EM_ECOG2: return "Cyan Technology eCOG2 microprocessor";
2345 case EM_DSP24: return "New Japan Radio (NJR) 24-bit DSP Processor";
2346 case EM_VIDEOCORE3: return "Broadcom VideoCore III processor";
2347 case EM_SE_C17: return "Seiko Epson C17 family";
2348 case EM_TI_C6000: return "Texas Instruments TMS320C6000 DSP family";
2349 case EM_TI_C2000: return "Texas Instruments TMS320C2000 DSP family";
2350 case EM_TI_C5500: return "Texas Instruments TMS320C55x DSP family";
2351 case EM_MMDSP_PLUS: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2352 case EM_CYPRESS_M8C: return "Cypress M8C microprocessor";
2353 case EM_R32C: return "Renesas R32C series microprocessors";
2354 case EM_TRIMEDIA: return "NXP Semiconductors TriMedia architecture family";
2355 case EM_QDSP6: return "QUALCOMM DSP6 Processor";
2356 case EM_8051: return "Intel 8051 and variants";
2357 case EM_STXP7X: return "STMicroelectronics STxP7x family";
2358 case EM_NDS32: return "Andes Technology compact code size embedded RISC processor family";
2359 case EM_ECOG1X: return "Cyan Technology eCOG1X family";
2360 case EM_MAXQ30: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2361 case EM_XIMO16: return "New Japan Radio (NJR) 16-bit DSP Processor";
2362 case EM_MANIK: return "M2000 Reconfigurable RISC Microprocessor";
2363 case EM_CRAYNV2: return "Cray Inc. NV2 vector architecture";
2364 case EM_CYGNUS_MEP: return "Toshiba MeP Media Engine";
2367 case EM_MICROBLAZE_OLD: return "Xilinx MicroBlaze";
2368 case EM_RISCV: return "RISC-V";
2369 case EM_RL78: return "Renesas RL78";
2370 case EM_RX: return "Renesas RX";
2371 case EM_METAG: return "Imagination Technologies Meta processor architecture";
2372 case EM_MCST_ELBRUS: return "MCST Elbrus general purpose hardware architecture";
2373 case EM_ECOG16: return "Cyan Technology eCOG16 family";
2374 case EM_ETPU: return "Freescale Extended Time Processing Unit";
2375 case EM_SLE9X: return "Infineon Technologies SLE9X core";
2376 case EM_AVR32: return "Atmel Corporation 32-bit microprocessor family";
2377 case EM_STM8: return "STMicroeletronics STM8 8-bit microcontroller";
2378 case EM_TILE64: return "Tilera TILE64 multicore architecture family";
2379 case EM_TILEPRO: return "Tilera TILEPro multicore architecture family";
2380 case EM_TILEGX: return "Tilera TILE-Gx multicore architecture family";
2381 case EM_CUDA: return "NVIDIA CUDA architecture";
2382 case EM_XGATE: return "Motorola XGATE embedded processor";
2383 case EM_CLOUDSHIELD: return "CloudShield architecture family";
2384 case EM_COREA_1ST: return "KIPO-KAIST Core-A 1st generation processor family";
2385 case EM_COREA_2ND: return "KIPO-KAIST Core-A 2nd generation processor family";
2386 case EM_OPEN8: return "Open8 8-bit RISC soft processor core";
2387 case EM_VIDEOCORE5: return "Broadcom VideoCore V processor";
2388 case EM_56800EX: return "Freescale 56800EX Digital Signal Controller (DSC)";
2389 case EM_BA1: return "Beyond BA1 CPU architecture";
2390 case EM_BA2: return "Beyond BA2 CPU architecture";
2391 case EM_XCORE: return "XMOS xCORE processor family";
2392 case EM_MCHP_PIC: return "Microchip 8-bit PIC(r) family";
2393 case EM_KM32: return "KM211 KM32 32-bit processor";
2394 case EM_KMX32: return "KM211 KMX32 32-bit processor";
2395 case EM_KMX16: return "KM211 KMX16 16-bit processor";
2396 case EM_KMX8: return "KM211 KMX8 8-bit processor";
2397 case EM_KVARC: return "KM211 KVARC processor";
2398 case EM_CDP: return "Paneve CDP architecture family";
2399 case EM_COGE: return "Cognitive Smart Memory Processor";
2400 case EM_COOL: return "Bluechip Systems CoolEngine";
2401 case EM_NORC: return "Nanoradio Optimized RISC";
2402 case EM_CSR_KALIMBA: return "CSR Kalimba architecture family";
2403 case EM_Z80: return "Zilog Z80";
2404 case EM_AMDGPU: return "AMD GPU architecture";
2405 case EM_TI_PRU: return "TI PRU I/O processor";
2407 snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
2413 decode_ARC_machine_flags (unsigned e_flags, unsigned e_machine, char buf[])
2415 /* ARC has two machine types EM_ARC_COMPACT and EM_ARC_COMPACT2. Some
2416 other compilers don't a specific architecture type in the e_flags, and
2417 instead use EM_ARC_COMPACT for old ARC600, ARC601, and ARC700
2418 architectures, and switch to EM_ARC_COMPACT2 for newer ARCEM and ARCHS
2421 Th GNU tools follows this use of EM_ARC_COMPACT and EM_ARC_COMPACT2,
2422 but also sets a specific architecture type in the e_flags field.
2424 However, when decoding the flags we don't worry if we see an
2425 unexpected pairing, for example EM_ARC_COMPACT machine type, with
2426 ARCEM architecture type. */
2428 switch (e_flags & EF_ARC_MACH_MSK)
2430 /* We only expect these to occur for EM_ARC_COMPACT2. */
2431 case EF_ARC_CPU_ARCV2EM:
2432 strcat (buf, ", ARC EM");
2434 case EF_ARC_CPU_ARCV2HS:
2435 strcat (buf, ", ARC HS");
2438 /* We only expect these to occur for EM_ARC_COMPACT. */
2439 case E_ARC_MACH_ARC600:
2440 strcat (buf, ", ARC600");
2442 case E_ARC_MACH_ARC601:
2443 strcat (buf, ", ARC601");
2445 case E_ARC_MACH_ARC700:
2446 strcat (buf, ", ARC700");
2449 /* The only times we should end up here are (a) A corrupt ELF, (b) A
2450 new ELF with new architecture being read by an old version of
2451 readelf, or (c) An ELF built with non-GNU compiler that does not
2452 set the architecture in the e_flags. */
2454 if (e_machine == EM_ARC_COMPACT)
2455 strcat (buf, ", Unknown ARCompact");
2457 strcat (buf, ", Unknown ARC");
2461 switch (e_flags & EF_ARC_OSABI_MSK)
2463 case E_ARC_OSABI_ORIG:
2464 strcat (buf, ", (ABI:legacy)");
2466 case E_ARC_OSABI_V2:
2467 strcat (buf, ", (ABI:v2)");
2469 /* Only upstream 3.9+ kernels will support ARCv2 ISA. */
2470 case E_ARC_OSABI_V3:
2471 strcat (buf, ", v3 no-legacy-syscalls ABI");
2474 strcat (buf, ", unrecognised ARC OSABI flag");
2480 decode_ARM_machine_flags (unsigned e_flags, char buf[])
2483 bfd_boolean unknown = FALSE;
2485 eabi = EF_ARM_EABI_VERSION (e_flags);
2486 e_flags &= ~ EF_ARM_EABIMASK;
2488 /* Handle "generic" ARM flags. */
2489 if (e_flags & EF_ARM_RELEXEC)
2491 strcat (buf, ", relocatable executable");
2492 e_flags &= ~ EF_ARM_RELEXEC;
2495 /* Now handle EABI specific flags. */
2499 strcat (buf, ", <unrecognized EABI>");
2504 case EF_ARM_EABI_VER1:
2505 strcat (buf, ", Version1 EABI");
2510 /* Process flags one bit at a time. */
2511 flag = e_flags & - e_flags;
2516 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2517 strcat (buf, ", sorted symbol tables");
2527 case EF_ARM_EABI_VER2:
2528 strcat (buf, ", Version2 EABI");
2533 /* Process flags one bit at a time. */
2534 flag = e_flags & - e_flags;
2539 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2540 strcat (buf, ", sorted symbol tables");
2543 case EF_ARM_DYNSYMSUSESEGIDX:
2544 strcat (buf, ", dynamic symbols use segment index");
2547 case EF_ARM_MAPSYMSFIRST:
2548 strcat (buf, ", mapping symbols precede others");
2558 case EF_ARM_EABI_VER3:
2559 strcat (buf, ", Version3 EABI");
2562 case EF_ARM_EABI_VER4:
2563 strcat (buf, ", Version4 EABI");
2568 /* Process flags one bit at a time. */
2569 flag = e_flags & - e_flags;
2575 strcat (buf, ", BE8");
2579 strcat (buf, ", LE8");
2589 case EF_ARM_EABI_VER5:
2590 strcat (buf, ", Version5 EABI");
2595 /* Process flags one bit at a time. */
2596 flag = e_flags & - e_flags;
2602 strcat (buf, ", BE8");
2606 strcat (buf, ", LE8");
2609 case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2610 strcat (buf, ", soft-float ABI");
2613 case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT. */
2614 strcat (buf, ", hard-float ABI");
2624 case EF_ARM_EABI_UNKNOWN:
2625 strcat (buf, ", GNU EABI");
2630 /* Process flags one bit at a time. */
2631 flag = e_flags & - e_flags;
2636 case EF_ARM_INTERWORK:
2637 strcat (buf, ", interworking enabled");
2640 case EF_ARM_APCS_26:
2641 strcat (buf, ", uses APCS/26");
2644 case EF_ARM_APCS_FLOAT:
2645 strcat (buf, ", uses APCS/float");
2649 strcat (buf, ", position independent");
2653 strcat (buf, ", 8 bit structure alignment");
2656 case EF_ARM_NEW_ABI:
2657 strcat (buf, ", uses new ABI");
2660 case EF_ARM_OLD_ABI:
2661 strcat (buf, ", uses old ABI");
2664 case EF_ARM_SOFT_FLOAT:
2665 strcat (buf, ", software FP");
2668 case EF_ARM_VFP_FLOAT:
2669 strcat (buf, ", VFP");
2672 case EF_ARM_MAVERICK_FLOAT:
2673 strcat (buf, ", Maverick FP");
2684 strcat (buf,_(", <unknown>"));
2688 decode_AVR_machine_flags (unsigned e_flags, char buf[], size_t size)
2690 --size; /* Leave space for null terminator. */
2692 switch (e_flags & EF_AVR_MACH)
2694 case E_AVR_MACH_AVR1:
2695 strncat (buf, ", avr:1", size);
2697 case E_AVR_MACH_AVR2:
2698 strncat (buf, ", avr:2", size);
2700 case E_AVR_MACH_AVR25:
2701 strncat (buf, ", avr:25", size);
2703 case E_AVR_MACH_AVR3:
2704 strncat (buf, ", avr:3", size);
2706 case E_AVR_MACH_AVR31:
2707 strncat (buf, ", avr:31", size);
2709 case E_AVR_MACH_AVR35:
2710 strncat (buf, ", avr:35", size);
2712 case E_AVR_MACH_AVR4:
2713 strncat (buf, ", avr:4", size);
2715 case E_AVR_MACH_AVR5:
2716 strncat (buf, ", avr:5", size);
2718 case E_AVR_MACH_AVR51:
2719 strncat (buf, ", avr:51", size);
2721 case E_AVR_MACH_AVR6:
2722 strncat (buf, ", avr:6", size);
2724 case E_AVR_MACH_AVRTINY:
2725 strncat (buf, ", avr:100", size);
2727 case E_AVR_MACH_XMEGA1:
2728 strncat (buf, ", avr:101", size);
2730 case E_AVR_MACH_XMEGA2:
2731 strncat (buf, ", avr:102", size);
2733 case E_AVR_MACH_XMEGA3:
2734 strncat (buf, ", avr:103", size);
2736 case E_AVR_MACH_XMEGA4:
2737 strncat (buf, ", avr:104", size);
2739 case E_AVR_MACH_XMEGA5:
2740 strncat (buf, ", avr:105", size);
2742 case E_AVR_MACH_XMEGA6:
2743 strncat (buf, ", avr:106", size);
2745 case E_AVR_MACH_XMEGA7:
2746 strncat (buf, ", avr:107", size);
2749 strncat (buf, ", avr:<unknown>", size);
2753 size -= strlen (buf);
2754 if (e_flags & EF_AVR_LINKRELAX_PREPARED)
2755 strncat (buf, ", link-relax", size);
2759 decode_NDS32_machine_flags (unsigned e_flags, char buf[], size_t size)
2765 bfd_boolean has_fpu = FALSE;
2768 static const char *ABI_STRINGS[] =
2770 "ABI v0", /* use r5 as return register; only used in N1213HC */
2771 "ABI v1", /* use r0 as return register */
2772 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2773 "ABI v2fp", /* for FPU */
2777 static const char *VER_STRINGS[] =
2779 "Andes ELF V1.3 or older",
2783 static const char *ARCH_STRINGS[] =
2792 abi = EF_NDS_ABI & e_flags;
2793 arch = EF_NDS_ARCH & e_flags;
2794 config = EF_NDS_INST & e_flags;
2795 version = EF_NDS32_ELF_VERSION & e_flags;
2797 memset (buf, 0, size);
2804 case E_NDS_ABI_V2FP:
2805 case E_NDS_ABI_AABI:
2806 case E_NDS_ABI_V2FP_PLUS:
2807 /* In case there are holes in the array. */
2808 r += snprintf (buf + r, size - r, ", %s", ABI_STRINGS[abi >> EF_NDS_ABI_SHIFT]);
2812 r += snprintf (buf + r, size - r, ", <unrecognized ABI>");
2818 case E_NDS32_ELF_VER_1_2:
2819 case E_NDS32_ELF_VER_1_3:
2820 case E_NDS32_ELF_VER_1_4:
2821 r += snprintf (buf + r, size - r, ", %s", VER_STRINGS[version >> EF_NDS32_ELF_VERSION_SHIFT]);
2825 r += snprintf (buf + r, size - r, ", <unrecognized ELF version number>");
2829 if (E_NDS_ABI_V0 == abi)
2831 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2832 r += snprintf (buf + r, size - r, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2833 if (arch == E_NDS_ARCH_STAR_V1_0)
2834 r += snprintf (buf + r, size -r, ", 16b"); /* has 16-bit instructions */
2840 case E_NDS_ARCH_STAR_V1_0:
2841 case E_NDS_ARCH_STAR_V2_0:
2842 case E_NDS_ARCH_STAR_V3_0:
2843 case E_NDS_ARCH_STAR_V3_M:
2844 r += snprintf (buf + r, size - r, ", %s", ARCH_STRINGS[arch >> EF_NDS_ARCH_SHIFT]);
2848 r += snprintf (buf + r, size - r, ", <unrecognized architecture>");
2849 /* ARCH version determines how the e_flags are interpreted.
2850 If it is unknown, we cannot proceed. */
2854 /* Newer ABI; Now handle architecture specific flags. */
2855 if (arch == E_NDS_ARCH_STAR_V1_0)
2857 if (config & E_NDS32_HAS_MFUSR_PC_INST)
2858 r += snprintf (buf + r, size -r, ", MFUSR_PC");
2860 if (!(config & E_NDS32_HAS_NO_MAC_INST))
2861 r += snprintf (buf + r, size -r, ", MAC");
2863 if (config & E_NDS32_HAS_DIV_INST)
2864 r += snprintf (buf + r, size -r, ", DIV");
2866 if (config & E_NDS32_HAS_16BIT_INST)
2867 r += snprintf (buf + r, size -r, ", 16b");
2871 if (config & E_NDS32_HAS_MFUSR_PC_INST)
2873 if (version <= E_NDS32_ELF_VER_1_3)
2874 r += snprintf (buf + r, size -r, ", [B8]");
2876 r += snprintf (buf + r, size -r, ", EX9");
2879 if (config & E_NDS32_HAS_MAC_DX_INST)
2880 r += snprintf (buf + r, size -r, ", MAC_DX");
2882 if (config & E_NDS32_HAS_DIV_DX_INST)
2883 r += snprintf (buf + r, size -r, ", DIV_DX");
2885 if (config & E_NDS32_HAS_16BIT_INST)
2887 if (version <= E_NDS32_ELF_VER_1_3)
2888 r += snprintf (buf + r, size -r, ", 16b");
2890 r += snprintf (buf + r, size -r, ", IFC");
2894 if (config & E_NDS32_HAS_EXT_INST)
2895 r += snprintf (buf + r, size -r, ", PERF1");
2897 if (config & E_NDS32_HAS_EXT2_INST)
2898 r += snprintf (buf + r, size -r, ", PERF2");
2900 if (config & E_NDS32_HAS_FPU_INST)
2903 r += snprintf (buf + r, size -r, ", FPU_SP");
2906 if (config & E_NDS32_HAS_FPU_DP_INST)
2909 r += snprintf (buf + r, size -r, ", FPU_DP");
2912 if (config & E_NDS32_HAS_FPU_MAC_INST)
2915 r += snprintf (buf + r, size -r, ", FPU_MAC");
2920 switch ((config & E_NDS32_FPU_REG_CONF) >> E_NDS32_FPU_REG_CONF_SHIFT)
2922 case E_NDS32_FPU_REG_8SP_4DP:
2923 r += snprintf (buf + r, size -r, ", FPU_REG:8/4");
2925 case E_NDS32_FPU_REG_16SP_8DP:
2926 r += snprintf (buf + r, size -r, ", FPU_REG:16/8");
2928 case E_NDS32_FPU_REG_32SP_16DP:
2929 r += snprintf (buf + r, size -r, ", FPU_REG:32/16");
2931 case E_NDS32_FPU_REG_32SP_32DP:
2932 r += snprintf (buf + r, size -r, ", FPU_REG:32/32");
2937 if (config & E_NDS32_HAS_AUDIO_INST)
2938 r += snprintf (buf + r, size -r, ", AUDIO");
2940 if (config & E_NDS32_HAS_STRING_INST)
2941 r += snprintf (buf + r, size -r, ", STR");
2943 if (config & E_NDS32_HAS_REDUCED_REGS)
2944 r += snprintf (buf + r, size -r, ", 16REG");
2946 if (config & E_NDS32_HAS_VIDEO_INST)
2948 if (version <= E_NDS32_ELF_VER_1_3)
2949 r += snprintf (buf + r, size -r, ", VIDEO");
2951 r += snprintf (buf + r, size -r, ", SATURATION");
2954 if (config & E_NDS32_HAS_ENCRIPT_INST)
2955 r += snprintf (buf + r, size -r, ", ENCRP");
2957 if (config & E_NDS32_HAS_L2C_INST)
2958 r += snprintf (buf + r, size -r, ", L2C");
2962 get_machine_flags (unsigned e_flags, unsigned e_machine)
2964 static char buf[1024];
2975 case EM_ARC_COMPACT2:
2976 case EM_ARC_COMPACT:
2977 decode_ARC_machine_flags (e_flags, e_machine, buf);
2981 decode_ARM_machine_flags (e_flags, buf);
2985 decode_AVR_machine_flags (e_flags, buf, sizeof buf);
2989 if (e_flags & EF_BFIN_PIC)
2990 strcat (buf, ", PIC");
2992 if (e_flags & EF_BFIN_FDPIC)
2993 strcat (buf, ", FDPIC");
2995 if (e_flags & EF_BFIN_CODE_IN_L1)
2996 strcat (buf, ", code in L1");
2998 if (e_flags & EF_BFIN_DATA_IN_L1)
2999 strcat (buf, ", data in L1");
3004 switch (e_flags & EF_FRV_CPU_MASK)
3006 case EF_FRV_CPU_GENERIC:
3010 strcat (buf, ", fr???");
3013 case EF_FRV_CPU_FR300:
3014 strcat (buf, ", fr300");
3017 case EF_FRV_CPU_FR400:
3018 strcat (buf, ", fr400");
3020 case EF_FRV_CPU_FR405:
3021 strcat (buf, ", fr405");
3024 case EF_FRV_CPU_FR450:
3025 strcat (buf, ", fr450");
3028 case EF_FRV_CPU_FR500:
3029 strcat (buf, ", fr500");
3031 case EF_FRV_CPU_FR550:
3032 strcat (buf, ", fr550");
3035 case EF_FRV_CPU_SIMPLE:
3036 strcat (buf, ", simple");
3038 case EF_FRV_CPU_TOMCAT:
3039 strcat (buf, ", tomcat");
3045 if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
3046 strcat (buf, ", m68000");
3047 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
3048 strcat (buf, ", cpu32");
3049 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
3050 strcat (buf, ", fido_a");
3053 char const * isa = _("unknown");
3054 char const * mac = _("unknown mac");
3055 char const * additional = NULL;
3057 switch (e_flags & EF_M68K_CF_ISA_MASK)
3059 case EF_M68K_CF_ISA_A_NODIV:
3061 additional = ", nodiv";
3063 case EF_M68K_CF_ISA_A:
3066 case EF_M68K_CF_ISA_A_PLUS:
3069 case EF_M68K_CF_ISA_B_NOUSP:
3071 additional = ", nousp";
3073 case EF_M68K_CF_ISA_B:
3076 case EF_M68K_CF_ISA_C:
3079 case EF_M68K_CF_ISA_C_NODIV:
3081 additional = ", nodiv";
3084 strcat (buf, ", cf, isa ");
3087 strcat (buf, additional);
3088 if (e_flags & EF_M68K_CF_FLOAT)
3089 strcat (buf, ", float");
3090 switch (e_flags & EF_M68K_CF_MAC_MASK)
3095 case EF_M68K_CF_MAC:
3098 case EF_M68K_CF_EMAC:
3101 case EF_M68K_CF_EMAC_B:
3114 switch (e_flags & EF_MEP_CPU_MASK)
3116 case EF_MEP_CPU_MEP: strcat (buf, ", generic MeP"); break;
3117 case EF_MEP_CPU_C2: strcat (buf, ", MeP C2"); break;
3118 case EF_MEP_CPU_C3: strcat (buf, ", MeP C3"); break;
3119 case EF_MEP_CPU_C4: strcat (buf, ", MeP C4"); break;
3120 case EF_MEP_CPU_C5: strcat (buf, ", MeP C5"); break;
3121 case EF_MEP_CPU_H1: strcat (buf, ", MeP H1"); break;
3122 default: strcat (buf, _(", <unknown MeP cpu type>")); break;
3125 switch (e_flags & EF_MEP_COP_MASK)
3127 case EF_MEP_COP_NONE: break;
3128 case EF_MEP_COP_AVC: strcat (buf, ", AVC coprocessor"); break;
3129 case EF_MEP_COP_AVC2: strcat (buf, ", AVC2 coprocessor"); break;
3130 case EF_MEP_COP_FMAX: strcat (buf, ", FMAX coprocessor"); break;
3131 case EF_MEP_COP_IVC2: strcat (buf, ", IVC2 coprocessor"); break;
3132 default: strcat (buf, _("<unknown MeP copro type>")); break;
3135 if (e_flags & EF_MEP_LIBRARY)
3136 strcat (buf, ", Built for Library");
3138 if (e_flags & EF_MEP_INDEX_MASK)
3139 sprintf (buf + strlen (buf), ", Configuration Index: %#x",
3140 e_flags & EF_MEP_INDEX_MASK);
3142 if (e_flags & ~ EF_MEP_ALL_FLAGS)
3143 sprintf (buf + strlen (buf), _(", unknown flags bits: %#x"),
3144 e_flags & ~ EF_MEP_ALL_FLAGS);
3148 if (e_flags & EF_PPC_EMB)
3149 strcat (buf, ", emb");
3151 if (e_flags & EF_PPC_RELOCATABLE)
3152 strcat (buf, _(", relocatable"));
3154 if (e_flags & EF_PPC_RELOCATABLE_LIB)
3155 strcat (buf, _(", relocatable-lib"));
3159 if (e_flags & EF_PPC64_ABI)
3161 char abi[] = ", abiv0";
3163 abi[6] += e_flags & EF_PPC64_ABI;
3169 if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
3170 strcat (buf, ", RH850 ABI");
3172 if (e_flags & EF_V800_850E3)
3173 strcat (buf, ", V3 architecture");
3175 if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
3176 strcat (buf, ", FPU not used");
3178 if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
3179 strcat (buf, ", regmode: COMMON");
3181 if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
3182 strcat (buf, ", r4 not used");
3184 if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
3185 strcat (buf, ", r30 not used");
3187 if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
3188 strcat (buf, ", r5 not used");
3190 if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
3191 strcat (buf, ", r2 not used");
3193 for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
3195 switch (e_flags & - e_flags)
3197 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
3198 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
3199 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
3200 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
3201 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
3202 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
3203 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
3204 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
3205 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
3206 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
3207 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
3208 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
3215 case EM_CYGNUS_V850:
3216 switch (e_flags & EF_V850_ARCH)
3218 case E_V850E3V5_ARCH:
3219 strcat (buf, ", v850e3v5");
3221 case E_V850E2V3_ARCH:
3222 strcat (buf, ", v850e2v3");
3225 strcat (buf, ", v850e2");
3228 strcat (buf, ", v850e1");
3231 strcat (buf, ", v850e");
3234 strcat (buf, ", v850");
3237 strcat (buf, _(", unknown v850 architecture variant"));
3243 case EM_CYGNUS_M32R:
3244 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
3245 strcat (buf, ", m32r");
3249 case EM_MIPS_RS3_LE:
3250 if (e_flags & EF_MIPS_NOREORDER)
3251 strcat (buf, ", noreorder");
3253 if (e_flags & EF_MIPS_PIC)
3254 strcat (buf, ", pic");
3256 if (e_flags & EF_MIPS_CPIC)
3257 strcat (buf, ", cpic");
3259 if (e_flags & EF_MIPS_UCODE)
3260 strcat (buf, ", ugen_reserved");
3262 if (e_flags & EF_MIPS_ABI2)
3263 strcat (buf, ", abi2");
3265 if (e_flags & EF_MIPS_OPTIONS_FIRST)
3266 strcat (buf, ", odk first");
3268 if (e_flags & EF_MIPS_32BITMODE)
3269 strcat (buf, ", 32bitmode");
3271 if (e_flags & EF_MIPS_NAN2008)
3272 strcat (buf, ", nan2008");
3274 if (e_flags & EF_MIPS_FP64)
3275 strcat (buf, ", fp64");
3277 switch ((e_flags & EF_MIPS_MACH))
3279 case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
3280 case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
3281 case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
3282 case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
3283 case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
3284 case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
3285 case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
3286 case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
3287 case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); break;
3288 case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
3289 case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
3290 case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
3291 case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
3292 case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
3293 case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
3294 case E_MIPS_MACH_OCTEON3: strcat (buf, ", octeon3"); break;
3295 case E_MIPS_MACH_XLR: strcat (buf, ", xlr"); break;
3297 /* We simply ignore the field in this case to avoid confusion:
3298 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3301 default: strcat (buf, _(", unknown CPU")); break;
3304 switch ((e_flags & EF_MIPS_ABI))
3306 case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
3307 case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
3308 case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
3309 case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
3311 /* We simply ignore the field in this case to avoid confusion:
3312 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3313 This means it is likely to be an o32 file, but not for
3316 default: strcat (buf, _(", unknown ABI")); break;
3319 if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
3320 strcat (buf, ", mdmx");
3322 if (e_flags & EF_MIPS_ARCH_ASE_M16)
3323 strcat (buf, ", mips16");
3325 if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
3326 strcat (buf, ", micromips");
3328 switch ((e_flags & EF_MIPS_ARCH))
3330 case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
3331 case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
3332 case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
3333 case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
3334 case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
3335 case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
3336 case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
3337 case E_MIPS_ARCH_32R6: strcat (buf, ", mips32r6"); break;
3338 case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
3339 case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
3340 case E_MIPS_ARCH_64R6: strcat (buf, ", mips64r6"); break;
3341 default: strcat (buf, _(", unknown ISA")); break;
3346 decode_NDS32_machine_flags (e_flags, buf, sizeof buf);
3350 if (e_flags & EF_RISCV_RVC)
3351 strcat (buf, ", RVC");
3353 switch (e_flags & EF_RISCV_FLOAT_ABI)
3355 case EF_RISCV_FLOAT_ABI_SOFT:
3356 strcat (buf, ", soft-float ABI");
3359 case EF_RISCV_FLOAT_ABI_SINGLE:
3360 strcat (buf, ", single-float ABI");
3363 case EF_RISCV_FLOAT_ABI_DOUBLE:
3364 strcat (buf, ", double-float ABI");
3367 case EF_RISCV_FLOAT_ABI_QUAD:
3368 strcat (buf, ", quad-float ABI");
3374 switch ((e_flags & EF_SH_MACH_MASK))
3376 case EF_SH1: strcat (buf, ", sh1"); break;
3377 case EF_SH2: strcat (buf, ", sh2"); break;
3378 case EF_SH3: strcat (buf, ", sh3"); break;
3379 case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
3380 case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
3381 case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
3382 case EF_SH3E: strcat (buf, ", sh3e"); break;
3383 case EF_SH4: strcat (buf, ", sh4"); break;
3384 case EF_SH5: strcat (buf, ", sh5"); break;
3385 case EF_SH2E: strcat (buf, ", sh2e"); break;
3386 case EF_SH4A: strcat (buf, ", sh4a"); break;
3387 case EF_SH2A: strcat (buf, ", sh2a"); break;
3388 case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
3389 case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
3390 case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
3391 case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
3392 case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
3393 case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3394 case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
3395 case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
3396 case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
3397 default: strcat (buf, _(", unknown ISA")); break;
3400 if (e_flags & EF_SH_PIC)
3401 strcat (buf, ", pic");
3403 if (e_flags & EF_SH_FDPIC)
3404 strcat (buf, ", fdpic");
3408 if (e_flags & EF_OR1K_NODELAY)
3409 strcat (buf, ", no delay");
3413 if (e_flags & EF_SPARC_32PLUS)
3414 strcat (buf, ", v8+");
3416 if (e_flags & EF_SPARC_SUN_US1)
3417 strcat (buf, ", ultrasparcI");
3419 if (e_flags & EF_SPARC_SUN_US3)
3420 strcat (buf, ", ultrasparcIII");
3422 if (e_flags & EF_SPARC_HAL_R1)
3423 strcat (buf, ", halr1");
3425 if (e_flags & EF_SPARC_LEDATA)
3426 strcat (buf, ", ledata");
3428 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
3429 strcat (buf, ", tso");
3431 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
3432 strcat (buf, ", pso");
3434 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
3435 strcat (buf, ", rmo");
3439 switch (e_flags & EF_PARISC_ARCH)
3441 case EFA_PARISC_1_0:
3442 strcpy (buf, ", PA-RISC 1.0");
3444 case EFA_PARISC_1_1:
3445 strcpy (buf, ", PA-RISC 1.1");
3447 case EFA_PARISC_2_0:
3448 strcpy (buf, ", PA-RISC 2.0");
3453 if (e_flags & EF_PARISC_TRAPNIL)
3454 strcat (buf, ", trapnil");
3455 if (e_flags & EF_PARISC_EXT)
3456 strcat (buf, ", ext");
3457 if (e_flags & EF_PARISC_LSB)
3458 strcat (buf, ", lsb");
3459 if (e_flags & EF_PARISC_WIDE)
3460 strcat (buf, ", wide");
3461 if (e_flags & EF_PARISC_NO_KABP)
3462 strcat (buf, ", no kabp");
3463 if (e_flags & EF_PARISC_LAZYSWAP)
3464 strcat (buf, ", lazyswap");
3469 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
3470 strcat (buf, ", new calling convention");
3472 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
3473 strcat (buf, ", gnu calling convention");
3477 if ((e_flags & EF_IA_64_ABI64))
3478 strcat (buf, ", 64-bit");
3480 strcat (buf, ", 32-bit");
3481 if ((e_flags & EF_IA_64_REDUCEDFP))
3482 strcat (buf, ", reduced fp model");
3483 if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
3484 strcat (buf, ", no function descriptors, constant gp");
3485 else if ((e_flags & EF_IA_64_CONS_GP))
3486 strcat (buf, ", constant gp");
3487 if ((e_flags & EF_IA_64_ABSOLUTE))
3488 strcat (buf, ", absolute");
3489 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
3491 if ((e_flags & EF_IA_64_VMS_LINKAGES))
3492 strcat (buf, ", vms_linkages");
3493 switch ((e_flags & EF_IA_64_VMS_COMCOD))
3495 case EF_IA_64_VMS_COMCOD_SUCCESS:
3497 case EF_IA_64_VMS_COMCOD_WARNING:
3498 strcat (buf, ", warning");
3500 case EF_IA_64_VMS_COMCOD_ERROR:
3501 strcat (buf, ", error");
3503 case EF_IA_64_VMS_COMCOD_ABORT:
3504 strcat (buf, ", abort");
3507 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3508 e_flags & EF_IA_64_VMS_COMCOD);
3509 strcat (buf, ", <unknown>");
3515 if ((e_flags & EF_VAX_NONPIC))
3516 strcat (buf, ", non-PIC");
3517 if ((e_flags & EF_VAX_DFLOAT))
3518 strcat (buf, ", D-Float");
3519 if ((e_flags & EF_VAX_GFLOAT))
3520 strcat (buf, ", G-Float");
3524 if (e_flags & EF_VISIUM_ARCH_MCM)
3525 strcat (buf, ", mcm");
3526 else if (e_flags & EF_VISIUM_ARCH_MCM24)
3527 strcat (buf, ", mcm24");
3528 if (e_flags & EF_VISIUM_ARCH_GR6)
3529 strcat (buf, ", gr6");
3533 switch (e_flags & E_FLAG_RL78_CPU_MASK)
3535 case E_FLAG_RL78_ANY_CPU: break;
3536 case E_FLAG_RL78_G10: strcat (buf, ", G10"); break;
3537 case E_FLAG_RL78_G13: strcat (buf, ", G13"); break;
3538 case E_FLAG_RL78_G14: strcat (buf, ", G14"); break;
3540 if (e_flags & E_FLAG_RL78_64BIT_DOUBLES)
3541 strcat (buf, ", 64-bit doubles");
3545 if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
3546 strcat (buf, ", 64-bit doubles");
3547 if (e_flags & E_FLAG_RX_DSP)
3548 strcat (buf, ", dsp");
3549 if (e_flags & E_FLAG_RX_PID)
3550 strcat (buf, ", pid");
3551 if (e_flags & E_FLAG_RX_ABI)
3552 strcat (buf, ", RX ABI");
3553 if (e_flags & E_FLAG_RX_SINSNS_SET)
3554 strcat (buf, e_flags & E_FLAG_RX_SINSNS_YES
3555 ? ", uses String instructions" : ", bans String instructions");
3556 if (e_flags & E_FLAG_RX_V2)
3557 strcat (buf, ", V2");
3561 if (e_flags & EF_S390_HIGH_GPRS)
3562 strcat (buf, ", highgprs");
3566 if ((e_flags & EF_C6000_REL))
3567 strcat (buf, ", relocatable module");
3571 strcat (buf, _(": architecture variant: "));
3572 switch (e_flags & EF_MSP430_MACH)
3574 case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
3575 case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
3576 case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
3577 case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
3578 case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
3579 case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
3580 case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
3581 case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
3582 case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
3583 case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
3584 case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
3585 case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
3586 case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
3587 case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
3588 case E_MSP430_MACH_MSP430X : strcat (buf, "MSP430X"); break;
3590 strcat (buf, _(": unknown")); break;
3593 if (e_flags & ~ EF_MSP430_MACH)
3594 strcat (buf, _(": unknown extra flag bits also present"));
3602 get_osabi_name (unsigned int osabi)
3604 static char buff[32];
3608 case ELFOSABI_NONE: return "UNIX - System V";
3609 case ELFOSABI_HPUX: return "UNIX - HP-UX";
3610 case ELFOSABI_NETBSD: return "UNIX - NetBSD";
3611 case ELFOSABI_GNU: return "UNIX - GNU";
3612 case ELFOSABI_SOLARIS: return "UNIX - Solaris";
3613 case ELFOSABI_AIX: return "UNIX - AIX";
3614 case ELFOSABI_IRIX: return "UNIX - IRIX";
3615 case ELFOSABI_FREEBSD: return "UNIX - FreeBSD";
3616 case ELFOSABI_TRU64: return "UNIX - TRU64";
3617 case ELFOSABI_MODESTO: return "Novell - Modesto";
3618 case ELFOSABI_OPENBSD: return "UNIX - OpenBSD";
3619 case ELFOSABI_OPENVMS: return "VMS - OpenVMS";
3620 case ELFOSABI_NSK: return "HP - Non-Stop Kernel";
3621 case ELFOSABI_AROS: return "AROS";
3622 case ELFOSABI_FENIXOS: return "FenixOS";
3623 case ELFOSABI_CLOUDABI: return "Nuxi CloudABI";
3624 case ELFOSABI_OPENVOS: return "Stratus Technologies OpenVOS";
3627 switch (elf_header.e_machine)
3632 case ELFOSABI_ARM: return "ARM";
3643 case ELFOSABI_STANDALONE: return _("Standalone App");
3652 case ELFOSABI_C6000_ELFABI: return _("Bare-metal C6000");
3653 case ELFOSABI_C6000_LINUX: return "Linux C6000";
3662 snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
3668 get_aarch64_segment_type (unsigned long type)
3672 case PT_AARCH64_ARCHEXT: return "AARCH64_ARCHEXT";
3673 default: return NULL;
3678 get_arm_segment_type (unsigned long type)
3682 case PT_ARM_EXIDX: return "EXIDX";
3683 default: return NULL;
3688 get_mips_segment_type (unsigned long type)
3692 case PT_MIPS_REGINFO: return "REGINFO";
3693 case PT_MIPS_RTPROC: return "RTPROC";
3694 case PT_MIPS_OPTIONS: return "OPTIONS";
3695 case PT_MIPS_ABIFLAGS: return "ABIFLAGS";
3696 default: return NULL;
3701 get_parisc_segment_type (unsigned long type)
3705 case PT_HP_TLS: return "HP_TLS";
3706 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
3707 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
3708 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
3709 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
3710 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
3711 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
3712 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
3713 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
3714 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
3715 case PT_HP_PARALLEL: return "HP_PARALLEL";
3716 case PT_HP_FASTBIND: return "HP_FASTBIND";
3717 case PT_HP_OPT_ANNOT: return "HP_OPT_ANNOT";
3718 case PT_HP_HSL_ANNOT: return "HP_HSL_ANNOT";
3719 case PT_HP_STACK: return "HP_STACK";
3720 case PT_HP_CORE_UTSNAME: return "HP_CORE_UTSNAME";
3721 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
3722 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
3723 case PT_PARISC_WEAKORDER: return "PARISC_WEAKORDER";
3724 default: return NULL;
3729 get_ia64_segment_type (unsigned long type)
3733 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
3734 case PT_IA_64_UNWIND: return "IA_64_UNWIND";
3735 case PT_HP_TLS: return "HP_TLS";
3736 case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
3737 case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
3738 case PT_IA_64_HP_STACK: return "HP_STACK";
3739 default: return NULL;
3744 get_tic6x_segment_type (unsigned long type)
3748 case PT_C6000_PHATTR: return "C6000_PHATTR";
3749 default: return NULL;
3754 get_solaris_segment_type (unsigned long type)
3758 case 0x6464e550: return "PT_SUNW_UNWIND";
3759 case 0x6474e550: return "PT_SUNW_EH_FRAME";
3760 case 0x6ffffff7: return "PT_LOSUNW";
3761 case 0x6ffffffa: return "PT_SUNWBSS";
3762 case 0x6ffffffb: return "PT_SUNWSTACK";
3763 case 0x6ffffffc: return "PT_SUNWDTRACE";
3764 case 0x6ffffffd: return "PT_SUNWCAP";
3765 case 0x6fffffff: return "PT_HISUNW";
3766 default: return NULL;
3771 get_segment_type (unsigned long p_type)
3773 static char buff[32];
3777 case PT_NULL: return "NULL";
3778 case PT_LOAD: return "LOAD";
3779 case PT_DYNAMIC: return "DYNAMIC";
3780 case PT_INTERP: return "INTERP";
3781 case PT_NOTE: return "NOTE";
3782 case PT_SHLIB: return "SHLIB";
3783 case PT_PHDR: return "PHDR";
3784 case PT_TLS: return "TLS";
3785 case PT_GNU_EH_FRAME: return "GNU_EH_FRAME";
3786 case PT_GNU_STACK: return "GNU_STACK";
3787 case PT_GNU_RELRO: return "GNU_RELRO";
3790 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
3792 const char * result;
3794 switch (elf_header.e_machine)
3797 result = get_aarch64_segment_type (p_type);
3800 result = get_arm_segment_type (p_type);
3803 case EM_MIPS_RS3_LE:
3804 result = get_mips_segment_type (p_type);
3807 result = get_parisc_segment_type (p_type);
3810 result = get_ia64_segment_type (p_type);
3813 result = get_tic6x_segment_type (p_type);
3823 sprintf (buff, "LOPROC+%#lx", p_type - PT_LOPROC);
3825 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
3827 const char * result;
3829 switch (elf_header.e_machine)
3832 result = get_parisc_segment_type (p_type);
3835 result = get_ia64_segment_type (p_type);
3838 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
3839 result = get_solaris_segment_type (p_type);
3848 sprintf (buff, "LOOS+%#lx", p_type - PT_LOOS);
3851 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
3858 get_mips_section_type_name (unsigned int sh_type)
3862 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
3863 case SHT_MIPS_MSYM: return "MIPS_MSYM";
3864 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
3865 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
3866 case SHT_MIPS_UCODE: return "MIPS_UCODE";
3867 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
3868 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
3869 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
3870 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
3871 case SHT_MIPS_RELD: return "MIPS_RELD";
3872 case SHT_MIPS_IFACE: return "MIPS_IFACE";
3873 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
3874 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
3875 case SHT_MIPS_SHDR: return "MIPS_SHDR";
3876 case SHT_MIPS_FDESC: return "MIPS_FDESC";
3877 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
3878 case SHT_MIPS_DENSE: return "MIPS_DENSE";
3879 case SHT_MIPS_PDESC: return "MIPS_PDESC";
3880 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
3881 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
3882 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
3883 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
3884 case SHT_MIPS_LINE: return "MIPS_LINE";
3885 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
3886 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
3887 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
3888 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
3889 case SHT_MIPS_DWARF: return "MIPS_DWARF";
3890 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
3891 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
3892 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
3893 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
3894 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
3895 case SHT_MIPS_XLATE: return "MIPS_XLATE";
3896 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
3897 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
3898 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
3899 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
3900 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
3901 case SHT_MIPS_ABIFLAGS: return "MIPS_ABIFLAGS";
3909 get_parisc_section_type_name (unsigned int sh_type)
3913 case SHT_PARISC_EXT: return "PARISC_EXT";
3914 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
3915 case SHT_PARISC_DOC: return "PARISC_DOC";
3916 case SHT_PARISC_ANNOT: return "PARISC_ANNOT";
3917 case SHT_PARISC_SYMEXTN: return "PARISC_SYMEXTN";
3918 case SHT_PARISC_STUBS: return "PARISC_STUBS";
3919 case SHT_PARISC_DLKM: return "PARISC_DLKM";
3920 default: return NULL;
3925 get_ia64_section_type_name (unsigned int sh_type)
3927 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
3928 if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
3929 return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
3933 case SHT_IA_64_EXT: return "IA_64_EXT";
3934 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
3935 case SHT_IA_64_PRIORITY_INIT: return "IA_64_PRIORITY_INIT";
3936 case SHT_IA_64_VMS_TRACE: return "VMS_TRACE";
3937 case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
3938 case SHT_IA_64_VMS_DEBUG: return "VMS_DEBUG";
3939 case SHT_IA_64_VMS_DEBUG_STR: return "VMS_DEBUG_STR";
3940 case SHT_IA_64_VMS_LINKAGES: return "VMS_LINKAGES";
3941 case SHT_IA_64_VMS_SYMBOL_VECTOR: return "VMS_SYMBOL_VECTOR";
3942 case SHT_IA_64_VMS_FIXUP: return "VMS_FIXUP";
3950 get_x86_64_section_type_name (unsigned int sh_type)
3954 case SHT_X86_64_UNWIND: return "X86_64_UNWIND";
3955 default: return NULL;
3960 get_aarch64_section_type_name (unsigned int sh_type)
3964 case SHT_AARCH64_ATTRIBUTES: return "AARCH64_ATTRIBUTES";
3965 default: return NULL;
3970 get_arm_section_type_name (unsigned int sh_type)
3974 case SHT_ARM_EXIDX: return "ARM_EXIDX";
3975 case SHT_ARM_PREEMPTMAP: return "ARM_PREEMPTMAP";
3976 case SHT_ARM_ATTRIBUTES: return "ARM_ATTRIBUTES";
3977 case SHT_ARM_DEBUGOVERLAY: return "ARM_DEBUGOVERLAY";
3978 case SHT_ARM_OVERLAYSECTION: return "ARM_OVERLAYSECTION";
3979 default: return NULL;
3984 get_tic6x_section_type_name (unsigned int sh_type)
3988 case SHT_C6000_UNWIND: return "C6000_UNWIND";
3989 case SHT_C6000_PREEMPTMAP: return "C6000_PREEMPTMAP";
3990 case SHT_C6000_ATTRIBUTES: return "C6000_ATTRIBUTES";
3991 case SHT_TI_ICODE: return "TI_ICODE";
3992 case SHT_TI_XREF: return "TI_XREF";
3993 case SHT_TI_HANDLER: return "TI_HANDLER";
3994 case SHT_TI_INITINFO: return "TI_INITINFO";
3995 case SHT_TI_PHATTRS: return "TI_PHATTRS";
3996 default: return NULL;
4001 get_msp430x_section_type_name (unsigned int sh_type)
4005 case SHT_MSP430_SEC_FLAGS: return "MSP430_SEC_FLAGS";
4006 case SHT_MSP430_SYM_ALIASES: return "MSP430_SYM_ALIASES";
4007 case SHT_MSP430_ATTRIBUTES: return "MSP430_ATTRIBUTES";
4008 default: return NULL;
4013 get_v850_section_type_name (unsigned int sh_type)
4017 case SHT_V850_SCOMMON: return "V850 Small Common";
4018 case SHT_V850_TCOMMON: return "V850 Tiny Common";
4019 case SHT_V850_ZCOMMON: return "V850 Zero Common";
4020 case SHT_RENESAS_IOP: return "RENESAS IOP";
4021 case SHT_RENESAS_INFO: return "RENESAS INFO";
4022 default: return NULL;
4027 get_section_type_name (unsigned int sh_type)
4029 static char buff[32];
4030 const char * result;
4034 case SHT_NULL: return "NULL";
4035 case SHT_PROGBITS: return "PROGBITS";
4036 case SHT_SYMTAB: return "SYMTAB";
4037 case SHT_STRTAB: return "STRTAB";
4038 case SHT_RELA: return "RELA";
4039 case SHT_HASH: return "HASH";
4040 case SHT_DYNAMIC: return "DYNAMIC";
4041 case SHT_NOTE: return "NOTE";
4042 case SHT_NOBITS: return "NOBITS";
4043 case SHT_REL: return "REL";
4044 case SHT_SHLIB: return "SHLIB";
4045 case SHT_DYNSYM: return "DYNSYM";
4046 case SHT_INIT_ARRAY: return "INIT_ARRAY";
4047 case SHT_FINI_ARRAY: return "FINI_ARRAY";
4048 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
4049 case SHT_GNU_HASH: return "GNU_HASH";
4050 case SHT_GROUP: return "GROUP";
4051 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICIES";
4052 case SHT_GNU_verdef: return "VERDEF";
4053 case SHT_GNU_verneed: return "VERNEED";
4054 case SHT_GNU_versym: return "VERSYM";
4055 case 0x6ffffff0: return "VERSYM";
4056 case 0x6ffffffc: return "VERDEF";
4057 case 0x7ffffffd: return "AUXILIARY";
4058 case 0x7fffffff: return "FILTER";
4059 case SHT_GNU_LIBLIST: return "GNU_LIBLIST";
4062 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
4064 switch (elf_header.e_machine)
4067 case EM_MIPS_RS3_LE:
4068 result = get_mips_section_type_name (sh_type);
4071 result = get_parisc_section_type_name (sh_type);
4074 result = get_ia64_section_type_name (sh_type);
4079 result = get_x86_64_section_type_name (sh_type);
4082 result = get_aarch64_section_type_name (sh_type);
4085 result = get_arm_section_type_name (sh_type);
4088 result = get_tic6x_section_type_name (sh_type);
4091 result = get_msp430x_section_type_name (sh_type);
4095 case EM_CYGNUS_V850:
4096 result = get_v850_section_type_name (sh_type);
4106 sprintf (buff, "LOPROC+%#x", sh_type - SHT_LOPROC);
4108 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
4110 switch (elf_header.e_machine)
4113 result = get_ia64_section_type_name (sh_type);
4116 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
4117 result = get_solaris_section_type (sh_type);
4122 case SHT_GNU_INCREMENTAL_INPUTS: result = "GNU_INCREMENTAL_INPUTS"; break;
4123 case SHT_GNU_ATTRIBUTES: result = "GNU_ATTRIBUTES"; break;
4124 case SHT_GNU_HASH: result = "GNU_HASH"; break;
4125 case SHT_GNU_LIBLIST: result = "GNU_LIBLIST"; break;
4137 sprintf (buff, "LOOS+%#x", sh_type - SHT_LOOS);
4139 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
4141 switch (elf_header.e_machine)
4145 case EM_CYGNUS_V850:
4146 result = get_v850_section_type_name (sh_type);
4156 sprintf (buff, "LOUSER+%#x", sh_type - SHT_LOUSER);
4159 /* This message is probably going to be displayed in a 15
4160 character wide field, so put the hex value first. */
4161 snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
4167 #define OPTION_DEBUG_DUMP 512
4168 #define OPTION_DYN_SYMS 513
4169 #define OPTION_DWARF_DEPTH 514
4170 #define OPTION_DWARF_START 515
4171 #define OPTION_DWARF_CHECK 516
4173 static struct option options[] =
4175 {"all", no_argument, 0, 'a'},
4176 {"file-header", no_argument, 0, 'h'},
4177 {"program-headers", no_argument, 0, 'l'},
4178 {"headers", no_argument, 0, 'e'},
4179 {"histogram", no_argument, 0, 'I'},
4180 {"segments", no_argument, 0, 'l'},
4181 {"sections", no_argument, 0, 'S'},
4182 {"section-headers", no_argument, 0, 'S'},
4183 {"section-groups", no_argument, 0, 'g'},
4184 {"section-details", no_argument, 0, 't'},
4185 {"full-section-name",no_argument, 0, 'N'},
4186 {"symbols", no_argument, 0, 's'},
4187 {"syms", no_argument, 0, 's'},
4188 {"dyn-syms", no_argument, 0, OPTION_DYN_SYMS},
4189 {"relocs", no_argument, 0, 'r'},
4190 {"notes", no_argument, 0, 'n'},
4191 {"dynamic", no_argument, 0, 'd'},
4192 {"arch-specific", no_argument, 0, 'A'},
4193 {"version-info", no_argument, 0, 'V'},
4194 {"use-dynamic", no_argument, 0, 'D'},
4195 {"unwind", no_argument, 0, 'u'},
4196 {"archive-index", no_argument, 0, 'c'},
4197 {"hex-dump", required_argument, 0, 'x'},
4198 {"relocated-dump", required_argument, 0, 'R'},
4199 {"string-dump", required_argument, 0, 'p'},
4200 {"decompress", no_argument, 0, 'z'},
4201 #ifdef SUPPORT_DISASSEMBLY
4202 {"instruction-dump", required_argument, 0, 'i'},
4204 {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
4206 {"dwarf-depth", required_argument, 0, OPTION_DWARF_DEPTH},
4207 {"dwarf-start", required_argument, 0, OPTION_DWARF_START},
4208 {"dwarf-check", no_argument, 0, OPTION_DWARF_CHECK},
4210 {"version", no_argument, 0, 'v'},
4211 {"wide", no_argument, 0, 'W'},
4212 {"help", no_argument, 0, 'H'},
4213 {0, no_argument, 0, 0}
4217 usage (FILE * stream)
4219 fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
4220 fprintf (stream, _(" Display information about the contents of ELF format files\n"));
4221 fprintf (stream, _(" Options are:\n\
4222 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
4223 -h --file-header Display the ELF file header\n\
4224 -l --program-headers Display the program headers\n\
4225 --segments An alias for --program-headers\n\
4226 -S --section-headers Display the sections' header\n\
4227 --sections An alias for --section-headers\n\
4228 -g --section-groups Display the section groups\n\
4229 -t --section-details Display the section details\n\
4230 -e --headers Equivalent to: -h -l -S\n\
4231 -s --syms Display the symbol table\n\
4232 --symbols An alias for --syms\n\
4233 --dyn-syms Display the dynamic symbol table\n\
4234 -n --notes Display the core notes (if present)\n\
4235 -r --relocs Display the relocations (if present)\n\
4236 -u --unwind Display the unwind info (if present)\n\
4237 -d --dynamic Display the dynamic section (if present)\n\
4238 -V --version-info Display the version sections (if present)\n\
4239 -A --arch-specific Display architecture specific information (if any)\n\
4240 -c --archive-index Display the symbol/file index in an archive\n\
4241 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
4242 -x --hex-dump=<number|name>\n\
4243 Dump the contents of section <number|name> as bytes\n\
4244 -p --string-dump=<number|name>\n\
4245 Dump the contents of section <number|name> as strings\n\
4246 -R --relocated-dump=<number|name>\n\
4247 Dump the contents of section <number|name> as relocated bytes\n\
4248 -z --decompress Decompress section before dumping it\n\
4249 -w[lLiaprmfFsoRt] or\n\
4250 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
4251 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
4252 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
4254 Display the contents of DWARF2 debug sections\n"));
4255 fprintf (stream, _("\
4256 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
4257 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
4259 #ifdef SUPPORT_DISASSEMBLY
4260 fprintf (stream, _("\
4261 -i --instruction-dump=<number|name>\n\
4262 Disassemble the contents of section <number|name>\n"));
4264 fprintf (stream, _("\
4265 -I --histogram Display histogram of bucket list lengths\n\
4266 -W --wide Allow output width to exceed 80 characters\n\
4267 @<file> Read options from <file>\n\
4268 -H --help Display this information\n\
4269 -v --version Display the version number of readelf\n"));
4271 if (REPORT_BUGS_TO[0] && stream == stdout)
4272 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
4274 exit (stream == stdout ? 0 : 1);
4277 /* Record the fact that the user wants the contents of section number
4278 SECTION to be displayed using the method(s) encoded as flags bits
4279 in TYPE. Note, TYPE can be zero if we are creating the array for
4283 request_dump_bynumber (unsigned int section, dump_type type)
4285 if (section >= num_dump_sects)
4287 dump_type * new_dump_sects;
4289 new_dump_sects = (dump_type *) calloc (section + 1,
4290 sizeof (* dump_sects));
4292 if (new_dump_sects == NULL)
4293 error (_("Out of memory allocating dump request table.\n"));
4298 /* Copy current flag settings. */
4299 memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
4304 dump_sects = new_dump_sects;
4305 num_dump_sects = section + 1;
4310 dump_sects[section] |= type;
4315 /* Request a dump by section name. */
4318 request_dump_byname (const char * section, dump_type type)
4320 struct dump_list_entry * new_request;
4322 new_request = (struct dump_list_entry *)
4323 malloc (sizeof (struct dump_list_entry));
4325 error (_("Out of memory allocating dump request table.\n"));
4327 new_request->name = strdup (section);
4328 if (!new_request->name)
4329 error (_("Out of memory allocating dump request table.\n"));
4331 new_request->type = type;
4333 new_request->next = dump_sects_byname;
4334 dump_sects_byname = new_request;
4338 request_dump (dump_type type)
4344 section = strtoul (optarg, & cp, 0);
4346 if (! *cp && section >= 0)
4347 request_dump_bynumber (section, type);
4349 request_dump_byname (optarg, type);
4354 parse_args (int argc, char ** argv)
4361 while ((c = getopt_long
4362 (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:z", options, NULL)) != EOF)
4380 do_section_groups = TRUE;
4383 do_histogram = TRUE;
4388 do_section_groups = TRUE;
4393 do_section_details = TRUE;
4404 do_using_dynamic = TRUE;
4428 do_histogram = TRUE;
4434 do_archive_index = TRUE;
4437 request_dump (HEX_DUMP);
4440 request_dump (STRING_DUMP);
4443 request_dump (RELOC_DUMP);
4446 decompress_dumps = TRUE;
4452 do_debugging = TRUE;
4453 dwarf_select_sections_all ();
4457 do_debugging = FALSE;
4458 dwarf_select_sections_by_letters (optarg);
4461 case OPTION_DEBUG_DUMP:
4464 do_debugging = TRUE;
4467 do_debugging = FALSE;
4468 dwarf_select_sections_by_names (optarg);
4471 case OPTION_DWARF_DEPTH:
4475 dwarf_cutoff_level = strtoul (optarg, & cp, 0);
4478 case OPTION_DWARF_START:
4482 dwarf_start_die = strtoul (optarg, & cp, 0);
4485 case OPTION_DWARF_CHECK:
4488 case OPTION_DYN_SYMS:
4491 #ifdef SUPPORT_DISASSEMBLY
4493 request_dump (DISASS_DUMP);
4497 print_version (program_name);
4506 /* xgettext:c-format */
4507 error (_("Invalid option '-%c'\n"), c);
4514 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
4515 && !do_segments && !do_header && !do_dump && !do_version
4516 && !do_histogram && !do_debugging && !do_arch && !do_notes
4517 && !do_section_groups && !do_archive_index
4523 get_elf_class (unsigned int elf_class)
4525 static char buff[32];
4529 case ELFCLASSNONE: return _("none");
4530 case ELFCLASS32: return "ELF32";
4531 case ELFCLASS64: return "ELF64";
4533 snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
4539 get_data_encoding (unsigned int encoding)
4541 static char buff[32];
4545 case ELFDATANONE: return _("none");
4546 case ELFDATA2LSB: return _("2's complement, little endian");
4547 case ELFDATA2MSB: return _("2's complement, big endian");
4549 snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
4554 /* Decode the data held in 'elf_header'. */
4557 process_file_header (void)
4559 if ( elf_header.e_ident[EI_MAG0] != ELFMAG0
4560 || elf_header.e_ident[EI_MAG1] != ELFMAG1
4561 || elf_header.e_ident[EI_MAG2] != ELFMAG2
4562 || elf_header.e_ident[EI_MAG3] != ELFMAG3)
4565 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4569 init_dwarf_regnames (elf_header.e_machine);
4575 printf (_("ELF Header:\n"));
4576 printf (_(" Magic: "));
4577 for (i = 0; i < EI_NIDENT; i++)
4578 printf ("%2.2x ", elf_header.e_ident[i]);
4580 printf (_(" Class: %s\n"),
4581 get_elf_class (elf_header.e_ident[EI_CLASS]));
4582 printf (_(" Data: %s\n"),
4583 get_data_encoding (elf_header.e_ident[EI_DATA]));
4584 printf (_(" Version: %d %s\n"),
4585 elf_header.e_ident[EI_VERSION],
4586 (elf_header.e_ident[EI_VERSION] == EV_CURRENT
4588 : (elf_header.e_ident[EI_VERSION] != EV_NONE
4589 ? _("<unknown: %lx>")
4591 printf (_(" OS/ABI: %s\n"),
4592 get_osabi_name (elf_header.e_ident[EI_OSABI]));
4593 printf (_(" ABI Version: %d\n"),
4594 elf_header.e_ident[EI_ABIVERSION]);
4595 printf (_(" Type: %s\n"),
4596 get_file_type (elf_header.e_type));
4597 printf (_(" Machine: %s\n"),
4598 get_machine_name (elf_header.e_machine));
4599 printf (_(" Version: 0x%lx\n"),
4600 (unsigned long) elf_header.e_version);
4602 printf (_(" Entry point address: "));
4603 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4604 printf (_("\n Start of program headers: "));
4605 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4606 printf (_(" (bytes into file)\n Start of section headers: "));
4607 print_vma ((bfd_vma) elf_header.e_shoff, DEC);
4608 printf (_(" (bytes into file)\n"));
4610 printf (_(" Flags: 0x%lx%s\n"),
4611 (unsigned long) elf_header.e_flags,
4612 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
4613 printf (_(" Size of this header: %ld (bytes)\n"),
4614 (long) elf_header.e_ehsize);
4615 printf (_(" Size of program headers: %ld (bytes)\n"),
4616 (long) elf_header.e_phentsize);
4617 printf (_(" Number of program headers: %ld"),
4618 (long) elf_header.e_phnum);
4619 if (section_headers != NULL
4620 && elf_header.e_phnum == PN_XNUM
4621 && section_headers[0].sh_info != 0)
4622 printf (" (%ld)", (long) section_headers[0].sh_info);
4623 putc ('\n', stdout);
4624 printf (_(" Size of section headers: %ld (bytes)\n"),
4625 (long) elf_header.e_shentsize);
4626 printf (_(" Number of section headers: %ld"),
4627 (long) elf_header.e_shnum);
4628 if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
4629 printf (" (%ld)", (long) section_headers[0].sh_size);
4630 putc ('\n', stdout);
4631 printf (_(" Section header string table index: %ld"),
4632 (long) elf_header.e_shstrndx);
4633 if (section_headers != NULL
4634 && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
4635 printf (" (%u)", section_headers[0].sh_link);
4636 else if (elf_header.e_shstrndx != SHN_UNDEF
4637 && elf_header.e_shstrndx >= elf_header.e_shnum)
4638 printf (_(" <corrupt: out of range>"));
4639 putc ('\n', stdout);
4642 if (section_headers != NULL)
4644 if (elf_header.e_phnum == PN_XNUM
4645 && section_headers[0].sh_info != 0)
4646 elf_header.e_phnum = section_headers[0].sh_info;
4647 if (elf_header.e_shnum == SHN_UNDEF)
4648 elf_header.e_shnum = section_headers[0].sh_size;
4649 if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
4650 elf_header.e_shstrndx = section_headers[0].sh_link;
4651 else if (elf_header.e_shstrndx >= elf_header.e_shnum)
4652 elf_header.e_shstrndx = SHN_UNDEF;
4653 free (section_headers);
4654 section_headers = NULL;
4661 get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
4663 Elf32_External_Phdr * phdrs;
4664 Elf32_External_Phdr * external;
4665 Elf_Internal_Phdr * internal;
4667 unsigned int size = elf_header.e_phentsize;
4668 unsigned int num = elf_header.e_phnum;
4670 /* PR binutils/17531: Cope with unexpected section header sizes. */
4671 if (size == 0 || num == 0)
4673 if (size < sizeof * phdrs)
4675 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4678 if (size > sizeof * phdrs)
4679 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4681 phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
4682 size, num, _("program headers"));
4686 for (i = 0, internal = pheaders, external = phdrs;
4687 i < elf_header.e_phnum;
4688 i++, internal++, external++)
4690 internal->p_type = BYTE_GET (external->p_type);
4691 internal->p_offset = BYTE_GET (external->p_offset);
4692 internal->p_vaddr = BYTE_GET (external->p_vaddr);
4693 internal->p_paddr = BYTE_GET (external->p_paddr);
4694 internal->p_filesz = BYTE_GET (external->p_filesz);
4695 internal->p_memsz = BYTE_GET (external->p_memsz);
4696 internal->p_flags = BYTE_GET (external->p_flags);
4697 internal->p_align = BYTE_GET (external->p_align);
4705 get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
4707 Elf64_External_Phdr * phdrs;
4708 Elf64_External_Phdr * external;
4709 Elf_Internal_Phdr * internal;
4711 unsigned int size = elf_header.e_phentsize;
4712 unsigned int num = elf_header.e_phnum;
4714 /* PR binutils/17531: Cope with unexpected section header sizes. */
4715 if (size == 0 || num == 0)
4717 if (size < sizeof * phdrs)
4719 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4722 if (size > sizeof * phdrs)
4723 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4725 phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
4726 size, num, _("program headers"));
4730 for (i = 0, internal = pheaders, external = phdrs;
4731 i < elf_header.e_phnum;
4732 i++, internal++, external++)
4734 internal->p_type = BYTE_GET (external->p_type);
4735 internal->p_flags = BYTE_GET (external->p_flags);
4736 internal->p_offset = BYTE_GET (external->p_offset);
4737 internal->p_vaddr = BYTE_GET (external->p_vaddr);
4738 internal->p_paddr = BYTE_GET (external->p_paddr);
4739 internal->p_filesz = BYTE_GET (external->p_filesz);
4740 internal->p_memsz = BYTE_GET (external->p_memsz);
4741 internal->p_align = BYTE_GET (external->p_align);
4748 /* Returns TRUE if the program headers were read into `program_headers'. */
4751 get_program_headers (FILE * file)
4753 Elf_Internal_Phdr * phdrs;
4755 /* Check cache of prior read. */
4756 if (program_headers != NULL)
4759 phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
4760 sizeof (Elf_Internal_Phdr));
4764 error (_("Out of memory reading %u program headers\n"),
4765 elf_header.e_phnum);
4770 ? get_32bit_program_headers (file, phdrs)
4771 : get_64bit_program_headers (file, phdrs))
4773 program_headers = phdrs;
4781 /* Returns TRUE if the program headers were loaded. */
4784 process_program_headers (FILE * file)
4786 Elf_Internal_Phdr * segment;
4788 Elf_Internal_Phdr * previous_load = NULL;
4790 if (elf_header.e_phnum == 0)
4792 /* PR binutils/12467. */
4793 if (elf_header.e_phoff != 0)
4795 warn (_("possibly corrupt ELF header - it has a non-zero program"
4796 " header offset, but no program headers\n"));
4799 else if (do_segments)
4800 printf (_("\nThere are no program headers in this file.\n"));
4804 if (do_segments && !do_header)
4806 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
4807 printf (_("Entry point "));
4808 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4809 printf (_("\nThere are %d program headers, starting at offset "),
4810 elf_header.e_phnum);
4811 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4815 if (! get_program_headers (file))
4820 if (elf_header.e_phnum > 1)
4821 printf (_("\nProgram Headers:\n"));
4823 printf (_("\nProgram Headers:\n"));
4827 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4830 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4834 (_(" Type Offset VirtAddr PhysAddr\n"));
4836 (_(" FileSiz MemSiz Flags Align\n"));
4843 for (i = 0, segment = program_headers;
4844 i < elf_header.e_phnum;
4849 printf (" %-14.14s ", get_segment_type (segment->p_type));
4853 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4854 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
4855 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
4856 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
4857 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
4859 (segment->p_flags & PF_R ? 'R' : ' '),
4860 (segment->p_flags & PF_W ? 'W' : ' '),
4861 (segment->p_flags & PF_X ? 'E' : ' '));
4862 printf ("%#lx", (unsigned long) segment->p_align);
4866 if ((unsigned long) segment->p_offset == segment->p_offset)
4867 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4870 print_vma (segment->p_offset, FULL_HEX);
4874 print_vma (segment->p_vaddr, FULL_HEX);
4876 print_vma (segment->p_paddr, FULL_HEX);
4879 if ((unsigned long) segment->p_filesz == segment->p_filesz)
4880 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
4883 print_vma (segment->p_filesz, FULL_HEX);
4887 if ((unsigned long) segment->p_memsz == segment->p_memsz)
4888 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
4891 print_vma (segment->p_memsz, FULL_HEX);
4895 (segment->p_flags & PF_R ? 'R' : ' '),
4896 (segment->p_flags & PF_W ? 'W' : ' '),
4897 (segment->p_flags & PF_X ? 'E' : ' '));
4899 if ((unsigned long) segment->p_align == segment->p_align)
4900 printf ("%#lx", (unsigned long) segment->p_align);
4903 print_vma (segment->p_align, PREFIX_HEX);
4908 print_vma (segment->p_offset, FULL_HEX);
4910 print_vma (segment->p_vaddr, FULL_HEX);
4912 print_vma (segment->p_paddr, FULL_HEX);
4914 print_vma (segment->p_filesz, FULL_HEX);
4916 print_vma (segment->p_memsz, FULL_HEX);
4918 (segment->p_flags & PF_R ? 'R' : ' '),
4919 (segment->p_flags & PF_W ? 'W' : ' '),
4920 (segment->p_flags & PF_X ? 'E' : ' '));
4921 print_vma (segment->p_align, PREFIX_HEX);
4924 putc ('\n', stdout);
4927 switch (segment->p_type)
4930 #if 0 /* Do not warn about out of order PT_LOAD segments. Although officially
4931 required by the ELF standard, several programs, including the Linux
4932 kernel, make use of non-ordered segments. */
4934 && previous_load->p_vaddr > segment->p_vaddr)
4935 error (_("LOAD segments must be sorted in order of increasing VirtAddr\n"));
4937 if (segment->p_memsz < segment->p_filesz)
4938 error (_("the segment's file size is larger than its memory size\n"));
4939 previous_load = segment;
4943 /* PR 20815 - Verify that the program header is loaded into memory. */
4944 if (i > 0 && previous_load != NULL)
4945 error (_("the PHDR segment must occur before any LOAD segment\n"));
4946 if (elf_header.e_machine != EM_PARISC)
4950 for (j = 1; j < elf_header.e_phnum; j++)
4951 if (program_headers[j].p_vaddr <= segment->p_vaddr
4952 && (program_headers[j].p_vaddr + program_headers[j].p_memsz)
4953 >= (segment->p_vaddr + segment->p_filesz))
4955 if (j == elf_header.e_phnum)
4956 error (_("the PHDR segment is not covered by a LOAD segment\n"));
4962 error (_("more than one dynamic segment\n"));
4964 /* By default, assume that the .dynamic section is the first
4965 section in the DYNAMIC segment. */
4966 dynamic_addr = segment->p_offset;
4967 dynamic_size = segment->p_filesz;
4968 /* PR binutils/17512: Avoid corrupt dynamic section info in the segment. */
4969 if (dynamic_addr + dynamic_size >= current_file_size)
4971 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
4972 dynamic_addr = dynamic_size = 0;
4975 /* Try to locate the .dynamic section. If there is
4976 a section header table, we can easily locate it. */
4977 if (section_headers != NULL)
4979 Elf_Internal_Shdr * sec;
4981 sec = find_section (".dynamic");
4982 if (sec == NULL || sec->sh_size == 0)
4984 /* A corresponding .dynamic section is expected, but on
4985 IA-64/OpenVMS it is OK for it to be missing. */
4986 if (!is_ia64_vms ())
4987 error (_("no .dynamic section in the dynamic segment\n"));
4991 if (sec->sh_type == SHT_NOBITS)
4997 dynamic_addr = sec->sh_offset;
4998 dynamic_size = sec->sh_size;
5000 if (dynamic_addr < segment->p_offset
5001 || dynamic_addr > segment->p_offset + segment->p_filesz)
5002 warn (_("the .dynamic section is not contained"
5003 " within the dynamic segment\n"));
5004 else if (dynamic_addr > segment->p_offset)
5005 warn (_("the .dynamic section is not the first section"
5006 " in the dynamic segment.\n"));
5011 if (fseek (file, archive_file_offset + (long) segment->p_offset,
5013 error (_("Unable to find program interpreter name\n"));
5017 int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX - 1);
5019 if (ret >= (int) sizeof (fmt) || ret < 0)
5020 error (_("Internal error: failed to create format string to display program interpreter\n"));
5022 program_interpreter[0] = 0;
5023 if (fscanf (file, fmt, program_interpreter) <= 0)
5024 error (_("Unable to read program interpreter name\n"));
5027 printf (_(" [Requesting program interpreter: %s]\n"),
5028 program_interpreter);
5034 if (do_segments && section_headers != NULL && string_table != NULL)
5036 printf (_("\n Section to Segment mapping:\n"));
5037 printf (_(" Segment Sections...\n"));
5039 for (i = 0; i < elf_header.e_phnum; i++)
5042 Elf_Internal_Shdr * section;
5044 segment = program_headers + i;
5045 section = section_headers + 1;
5047 printf (" %2.2d ", i);
5049 for (j = 1; j < elf_header.e_shnum; j++, section++)
5051 if (!ELF_TBSS_SPECIAL (section, segment)
5052 && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
5053 printf ("%s ", printable_section_name (section));
5064 /* Find the file offset corresponding to VMA by using the program headers. */
5067 offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
5069 Elf_Internal_Phdr * seg;
5071 if (! get_program_headers (file))
5073 warn (_("Cannot interpret virtual addresses without program headers.\n"));
5077 for (seg = program_headers;
5078 seg < program_headers + elf_header.e_phnum;
5081 if (seg->p_type != PT_LOAD)
5084 if (vma >= (seg->p_vaddr & -seg->p_align)
5085 && vma + size <= seg->p_vaddr + seg->p_filesz)
5086 return vma - seg->p_vaddr + seg->p_offset;
5089 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
5090 (unsigned long) vma);
5095 /* Allocate memory and load the sections headers into the global pointer
5096 SECTION_HEADERS. If PROBE is true, this is just a probe and we do not
5097 generate any error messages if the load fails. */
5100 get_32bit_section_headers (FILE * file, bfd_boolean probe)
5102 Elf32_External_Shdr * shdrs;
5103 Elf_Internal_Shdr * internal;
5105 unsigned int size = elf_header.e_shentsize;
5106 unsigned int num = probe ? 1 : elf_header.e_shnum;
5108 /* PR binutils/17531: Cope with unexpected section header sizes. */
5109 if (size == 0 || num == 0)
5111 if (size < sizeof * shdrs)
5114 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5117 if (!probe && size > sizeof * shdrs)
5118 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5120 shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
5122 probe ? NULL : _("section headers"));
5126 if (section_headers != NULL)
5127 free (section_headers);
5128 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
5129 sizeof (Elf_Internal_Shdr));
5130 if (section_headers == NULL)
5133 error (_("Out of memory reading %u section headers\n"), num);
5137 for (i = 0, internal = section_headers;
5141 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
5142 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
5143 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
5144 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
5145 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
5146 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
5147 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
5148 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
5149 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5150 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
5151 if (!probe && internal->sh_link > num)
5152 warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
5153 if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
5154 warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
5162 get_64bit_section_headers (FILE * file, bfd_boolean probe)
5164 Elf64_External_Shdr * shdrs;
5165 Elf_Internal_Shdr * internal;
5167 unsigned int size = elf_header.e_shentsize;
5168 unsigned int num = probe ? 1 : elf_header.e_shnum;
5170 /* PR binutils/17531: Cope with unexpected section header sizes. */
5171 if (size == 0 || num == 0)
5173 if (size < sizeof * shdrs)
5176 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
5179 if (! probe && size > sizeof * shdrs)
5180 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
5182 shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
5184 probe ? NULL : _("section headers"));
5188 if (section_headers != NULL)
5189 free (section_headers);
5190 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
5191 sizeof (Elf_Internal_Shdr));
5192 if (section_headers == NULL)
5195 error (_("Out of memory reading %u section headers\n"), num);
5199 for (i = 0, internal = section_headers;
5203 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
5204 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
5205 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
5206 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
5207 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
5208 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
5209 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
5210 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
5211 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
5212 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
5213 if (!probe && internal->sh_link > num)
5214 warn (_("Section %u has an out of range sh_link value of %u\n"), i, internal->sh_link);
5215 if (!probe && internal->sh_flags & SHF_INFO_LINK && internal->sh_info > num)
5216 warn (_("Section %u has an out of range sh_info value of %u\n"), i, internal->sh_info);
5223 static Elf_Internal_Sym *
5224 get_32bit_elf_symbols (FILE * file,
5225 Elf_Internal_Shdr * section,
5226 unsigned long * num_syms_return)
5228 unsigned long number = 0;
5229 Elf32_External_Sym * esyms = NULL;
5230 Elf_External_Sym_Shndx * shndx = NULL;
5231 Elf_Internal_Sym * isyms = NULL;
5232 Elf_Internal_Sym * psym;
5235 if (section->sh_size == 0)
5237 if (num_syms_return != NULL)
5238 * num_syms_return = 0;
5242 /* Run some sanity checks first. */
5243 if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5245 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5246 printable_section_name (section), (unsigned long) section->sh_entsize);
5250 if (section->sh_size > current_file_size)
5252 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5253 printable_section_name (section), (unsigned long) section->sh_size);
5257 number = section->sh_size / section->sh_entsize;
5259 if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
5261 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5262 (unsigned long) section->sh_size,
5263 printable_section_name (section),
5264 (unsigned long) section->sh_entsize);
5268 esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
5269 section->sh_size, _("symbols"));
5274 elf_section_list * entry;
5277 for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5278 if (entry->hdr->sh_link == (unsigned long) (section - section_headers))
5280 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
5281 entry->hdr->sh_offset,
5282 1, entry->hdr->sh_size,
5283 _("symbol table section indicies"));
5286 /* PR17531: file: heap-buffer-overflow */
5287 else if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5289 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5290 printable_section_name (entry->hdr),
5291 (unsigned long) entry->hdr->sh_size,
5292 (unsigned long) section->sh_size);
5298 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5302 error (_("Out of memory reading %lu symbols\n"),
5303 (unsigned long) number);
5307 for (j = 0, psym = isyms; j < number; j++, psym++)
5309 psym->st_name = BYTE_GET (esyms[j].st_name);
5310 psym->st_value = BYTE_GET (esyms[j].st_value);
5311 psym->st_size = BYTE_GET (esyms[j].st_size);
5312 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5313 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5315 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5316 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5317 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5318 psym->st_info = BYTE_GET (esyms[j].st_info);
5319 psym->st_other = BYTE_GET (esyms[j].st_other);
5328 if (num_syms_return != NULL)
5329 * num_syms_return = isyms == NULL ? 0 : number;
5334 static Elf_Internal_Sym *
5335 get_64bit_elf_symbols (FILE * file,
5336 Elf_Internal_Shdr * section,
5337 unsigned long * num_syms_return)
5339 unsigned long number = 0;
5340 Elf64_External_Sym * esyms = NULL;
5341 Elf_External_Sym_Shndx * shndx = NULL;
5342 Elf_Internal_Sym * isyms = NULL;
5343 Elf_Internal_Sym * psym;
5346 if (section->sh_size == 0)
5348 if (num_syms_return != NULL)
5349 * num_syms_return = 0;
5353 /* Run some sanity checks first. */
5354 if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5356 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5357 printable_section_name (section),
5358 (unsigned long) section->sh_entsize);
5362 if (section->sh_size > current_file_size)
5364 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5365 printable_section_name (section),
5366 (unsigned long) section->sh_size);
5370 number = section->sh_size / section->sh_entsize;
5372 if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
5374 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5375 (unsigned long) section->sh_size,
5376 printable_section_name (section),
5377 (unsigned long) section->sh_entsize);
5381 esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
5382 section->sh_size, _("symbols"));
5387 elf_section_list * entry;
5390 for (entry = symtab_shndx_list; entry != NULL; entry = entry->next)
5391 if (entry->hdr->sh_link == (unsigned long) (section - section_headers))
5393 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
5394 entry->hdr->sh_offset,
5395 1, entry->hdr->sh_size,
5396 _("symbol table section indicies"));
5399 /* PR17531: file: heap-buffer-overflow */
5400 else if (entry->hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5402 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5403 printable_section_name (entry->hdr),
5404 (unsigned long) entry->hdr->sh_size,
5405 (unsigned long) section->sh_size);
5411 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5415 error (_("Out of memory reading %lu symbols\n"),
5416 (unsigned long) number);
5420 for (j = 0, psym = isyms; j < number; j++, psym++)
5422 psym->st_name = BYTE_GET (esyms[j].st_name);
5423 psym->st_info = BYTE_GET (esyms[j].st_info);
5424 psym->st_other = BYTE_GET (esyms[j].st_other);
5425 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5427 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5429 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5430 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5431 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5433 psym->st_value = BYTE_GET (esyms[j].st_value);
5434 psym->st_size = BYTE_GET (esyms[j].st_size);
5443 if (num_syms_return != NULL)
5444 * num_syms_return = isyms == NULL ? 0 : number;
5450 get_elf_section_flags (bfd_vma sh_flags)
5452 static char buff[1024];
5454 unsigned int field_size = is_32bit_elf ? 8 : 16;
5456 unsigned int size = sizeof (buff) - (field_size + 4 + 1);
5457 bfd_vma os_flags = 0;
5458 bfd_vma proc_flags = 0;
5459 bfd_vma unknown_flags = 0;
5467 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5468 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5469 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5470 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5471 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5472 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5473 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5474 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5475 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5476 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5477 /* IA-64 specific. */
5478 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5479 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5480 /* IA-64 OpenVMS specific. */
5481 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5482 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5483 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5484 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5485 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5486 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5488 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5489 /* SPARC specific. */
5490 /* 19 */ { STRING_COMMA_LEN ("ORDERED") },
5491 /* 20 */ { STRING_COMMA_LEN ("COMPRESSED") },
5493 /* 21 */ { STRING_COMMA_LEN ("ENTRYSECT") },
5494 /* 22 */ { STRING_COMMA_LEN ("ARM_PURECODE") },
5495 /* 23 */ { STRING_COMMA_LEN ("COMDEF") }
5498 if (do_section_details)
5500 sprintf (buff, "[%*.*lx]: ",
5501 field_size, field_size, (unsigned long) sh_flags);
5502 p += field_size + 4;
5509 flag = sh_flags & - sh_flags;
5512 if (do_section_details)
5516 case SHF_WRITE: sindex = 0; break;
5517 case SHF_ALLOC: sindex = 1; break;
5518 case SHF_EXECINSTR: sindex = 2; break;
5519 case SHF_MERGE: sindex = 3; break;
5520 case SHF_STRINGS: sindex = 4; break;
5521 case SHF_INFO_LINK: sindex = 5; break;
5522 case SHF_LINK_ORDER: sindex = 6; break;
5523 case SHF_OS_NONCONFORMING: sindex = 7; break;
5524 case SHF_GROUP: sindex = 8; break;
5525 case SHF_TLS: sindex = 9; break;
5526 case SHF_EXCLUDE: sindex = 18; break;
5527 case SHF_COMPRESSED: sindex = 20; break;
5531 switch (elf_header.e_machine)
5534 if (flag == SHF_IA_64_SHORT)
5536 else if (flag == SHF_IA_64_NORECOV)
5539 else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
5542 case SHF_IA_64_VMS_GLOBAL: sindex = 12; break;
5543 case SHF_IA_64_VMS_OVERLAID: sindex = 13; break;
5544 case SHF_IA_64_VMS_SHARED: sindex = 14; break;
5545 case SHF_IA_64_VMS_VECTOR: sindex = 15; break;
5546 case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
5547 case SHF_IA_64_VMS_PROTECTED: sindex = 17; break;
5558 case EM_OLD_SPARCV9:
5559 case EM_SPARC32PLUS:
5562 if (flag == SHF_ORDERED)
5569 case SHF_ENTRYSECT: sindex = 21; break;
5570 case SHF_ARM_PURECODE: sindex = 22; break;
5571 case SHF_COMDEF: sindex = 23; break;
5583 if (p != buff + field_size + 4)
5585 if (size < (10 + 2))
5587 warn (_("Internal error: not enough buffer room for section flag info"));
5588 return _("<unknown>");
5595 size -= flags [sindex].len;
5596 p = stpcpy (p, flags [sindex].str);
5598 else if (flag & SHF_MASKOS)
5600 else if (flag & SHF_MASKPROC)
5603 unknown_flags |= flag;
5609 case SHF_WRITE: *p = 'W'; break;
5610 case SHF_ALLOC: *p = 'A'; break;
5611 case SHF_EXECINSTR: *p = 'X'; break;
5612 case SHF_MERGE: *p = 'M'; break;
5613 case SHF_STRINGS: *p = 'S'; break;
5614 case SHF_INFO_LINK: *p = 'I'; break;
5615 case SHF_LINK_ORDER: *p = 'L'; break;
5616 case SHF_OS_NONCONFORMING: *p = 'O'; break;
5617 case SHF_GROUP: *p = 'G'; break;
5618 case SHF_TLS: *p = 'T'; break;
5619 case SHF_EXCLUDE: *p = 'E'; break;
5620 case SHF_COMPRESSED: *p = 'C'; break;
5623 if ((elf_header.e_machine == EM_X86_64
5624 || elf_header.e_machine == EM_L1OM
5625 || elf_header.e_machine == EM_K1OM)
5626 && flag == SHF_X86_64_LARGE)
5628 else if (elf_header.e_machine == EM_ARM
5629 && flag == SHF_ARM_PURECODE)
5631 else if (flag & SHF_MASKOS)
5634 sh_flags &= ~ SHF_MASKOS;
5636 else if (flag & SHF_MASKPROC)
5639 sh_flags &= ~ SHF_MASKPROC;
5649 if (do_section_details)
5653 size -= 5 + field_size;
5654 if (p != buff + field_size + 4)
5658 warn (_("Internal error: not enough buffer room for section flag info"));
5659 return _("<unknown>");
5665 sprintf (p, "OS (%*.*lx)", field_size, field_size,
5666 (unsigned long) os_flags);
5667 p += 5 + field_size;
5671 size -= 7 + field_size;
5672 if (p != buff + field_size + 4)
5676 warn (_("Internal error: not enough buffer room for section flag info"));
5677 return _("<unknown>");
5683 sprintf (p, "PROC (%*.*lx)", field_size, field_size,
5684 (unsigned long) proc_flags);
5685 p += 7 + field_size;
5689 size -= 10 + field_size;
5690 if (p != buff + field_size + 4)
5694 warn (_("Internal error: not enough buffer room for section flag info"));
5695 return _("<unknown>");
5701 sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
5702 (unsigned long) unknown_flags);
5703 p += 10 + field_size;
5712 get_compression_header (Elf_Internal_Chdr *chdr, unsigned char *buf, bfd_size_type size)
5716 Elf32_External_Chdr *echdr = (Elf32_External_Chdr *) buf;
5718 if (size < sizeof (* echdr))
5720 error (_("Compressed section is too small even for a compression header\n"));
5724 chdr->ch_type = BYTE_GET (echdr->ch_type);
5725 chdr->ch_size = BYTE_GET (echdr->ch_size);
5726 chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5727 return sizeof (*echdr);
5731 Elf64_External_Chdr *echdr = (Elf64_External_Chdr *) buf;
5733 if (size < sizeof (* echdr))
5735 error (_("Compressed section is too small even for a compression header\n"));
5739 chdr->ch_type = BYTE_GET (echdr->ch_type);
5740 chdr->ch_size = BYTE_GET (echdr->ch_size);
5741 chdr->ch_addralign = BYTE_GET (echdr->ch_addralign);
5742 return sizeof (*echdr);
5747 process_section_headers (FILE * file)
5749 Elf_Internal_Shdr * section;
5752 section_headers = NULL;
5754 if (elf_header.e_shnum == 0)
5756 /* PR binutils/12467. */
5757 if (elf_header.e_shoff != 0)
5759 warn (_("possibly corrupt ELF file header - it has a non-zero"
5760 " section header offset, but no section headers\n"));
5763 else if (do_sections)
5764 printf (_("\nThere are no sections in this file.\n"));
5769 if (do_sections && !do_header)
5770 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
5771 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
5775 if (! get_32bit_section_headers (file, FALSE))
5780 if (! get_64bit_section_headers (file, FALSE))
5784 /* Read in the string table, so that we have names to display. */
5785 if (elf_header.e_shstrndx != SHN_UNDEF
5786 && elf_header.e_shstrndx < elf_header.e_shnum)
5788 section = section_headers + elf_header.e_shstrndx;
5790 if (section->sh_size != 0)
5792 string_table = (char *) get_data (NULL, file, section->sh_offset,
5793 1, section->sh_size,
5796 string_table_length = string_table != NULL ? section->sh_size : 0;
5800 /* Scan the sections for the dynamic symbol table
5801 and dynamic string table and debug sections. */
5802 dynamic_symbols = NULL;
5803 dynamic_strings = NULL;
5804 dynamic_syminfo = NULL;
5805 symtab_shndx_list = NULL;
5807 eh_addr_size = is_32bit_elf ? 4 : 8;
5808 switch (elf_header.e_machine)
5811 case EM_MIPS_RS3_LE:
5812 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5813 FDE addresses. However, the ABI also has a semi-official ILP32
5814 variant for which the normal FDE address size rules apply.
5816 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5817 section, where XX is the size of longs in bits. Unfortunately,
5818 earlier compilers provided no way of distinguishing ILP32 objects
5819 from LP64 objects, so if there's any doubt, we should assume that
5820 the official LP64 form is being used. */
5821 if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
5822 && find_section (".gcc_compiled_long32") == NULL)
5828 switch (elf_header.e_flags & EF_H8_MACH)
5830 case E_H8_MACH_H8300:
5831 case E_H8_MACH_H8300HN:
5832 case E_H8_MACH_H8300SN:
5833 case E_H8_MACH_H8300SXN:
5836 case E_H8_MACH_H8300H:
5837 case E_H8_MACH_H8300S:
5838 case E_H8_MACH_H8300SX:
5846 switch (elf_header.e_flags & EF_M32C_CPU_MASK)
5848 case EF_M32C_CPU_M16C:
5855 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
5858 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
5859 if (section->sh_entsize != expected_entsize) \
5862 sprintf_vma (buf, section->sh_entsize); \
5863 /* Note: coded this way so that there is a single string for \
5865 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5866 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5867 (unsigned) expected_entsize); \
5868 section->sh_entsize = expected_entsize; \
5873 #define CHECK_ENTSIZE(section, i, type) \
5874 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
5875 sizeof (Elf64_External_##type))
5877 for (i = 0, section = section_headers;
5878 i < elf_header.e_shnum;
5881 char * name = SECTION_NAME (section);
5883 if (section->sh_type == SHT_DYNSYM)
5885 if (dynamic_symbols != NULL)
5887 error (_("File contains multiple dynamic symbol tables\n"));
5891 CHECK_ENTSIZE (section, i, Sym);
5892 dynamic_symbols = GET_ELF_SYMBOLS (file, section, & num_dynamic_syms);
5894 else if (section->sh_type == SHT_STRTAB
5895 && streq (name, ".dynstr"))
5897 if (dynamic_strings != NULL)
5899 error (_("File contains multiple dynamic string tables\n"));
5903 dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
5904 1, section->sh_size,
5905 _("dynamic strings"));
5906 dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
5908 else if (section->sh_type == SHT_SYMTAB_SHNDX)
5910 elf_section_list * entry = xmalloc (sizeof * entry);
5911 entry->hdr = section;
5912 entry->next = symtab_shndx_list;
5913 symtab_shndx_list = entry;
5915 else if (section->sh_type == SHT_SYMTAB)
5916 CHECK_ENTSIZE (section, i, Sym);
5917 else if (section->sh_type == SHT_GROUP)
5918 CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
5919 else if (section->sh_type == SHT_REL)
5920 CHECK_ENTSIZE (section, i, Rel);
5921 else if (section->sh_type == SHT_RELA)
5922 CHECK_ENTSIZE (section, i, Rela);
5923 else if ((do_debugging || do_debug_info || do_debug_abbrevs
5924 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
5925 || do_debug_aranges || do_debug_frames || do_debug_macinfo
5926 || do_debug_str || do_debug_loc || do_debug_ranges
5927 || do_debug_addr || do_debug_cu_index)
5928 && (const_strneq (name, ".debug_")
5929 || const_strneq (name, ".zdebug_")))
5932 name += sizeof (".zdebug_") - 1;
5934 name += sizeof (".debug_") - 1;
5937 || (do_debug_info && const_strneq (name, "info"))
5938 || (do_debug_info && const_strneq (name, "types"))
5939 || (do_debug_abbrevs && const_strneq (name, "abbrev"))
5940 || (do_debug_lines && strcmp (name, "line") == 0)
5941 || (do_debug_lines && const_strneq (name, "line."))
5942 || (do_debug_pubnames && const_strneq (name, "pubnames"))
5943 || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
5944 || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
5945 || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
5946 || (do_debug_aranges && const_strneq (name, "aranges"))
5947 || (do_debug_ranges && const_strneq (name, "ranges"))
5948 || (do_debug_ranges && const_strneq (name, "rnglists"))
5949 || (do_debug_frames && const_strneq (name, "frame"))
5950 || (do_debug_macinfo && const_strneq (name, "macinfo"))
5951 || (do_debug_macinfo && const_strneq (name, "macro"))
5952 || (do_debug_str && const_strneq (name, "str"))
5953 || (do_debug_loc && const_strneq (name, "loc"))
5954 || (do_debug_loc && const_strneq (name, "loclists"))
5955 || (do_debug_addr && const_strneq (name, "addr"))
5956 || (do_debug_cu_index && const_strneq (name, "cu_index"))
5957 || (do_debug_cu_index && const_strneq (name, "tu_index"))
5959 request_dump_bynumber (i, DEBUG_DUMP);
5961 /* Linkonce section to be combined with .debug_info at link time. */
5962 else if ((do_debugging || do_debug_info)
5963 && const_strneq (name, ".gnu.linkonce.wi."))
5964 request_dump_bynumber (i, DEBUG_DUMP);
5965 else if (do_debug_frames && streq (name, ".eh_frame"))
5966 request_dump_bynumber (i, DEBUG_DUMP);
5967 else if (do_gdb_index && streq (name, ".gdb_index"))
5968 request_dump_bynumber (i, DEBUG_DUMP);
5969 /* Trace sections for Itanium VMS. */
5970 else if ((do_debugging || do_trace_info || do_trace_abbrevs
5971 || do_trace_aranges)
5972 && const_strneq (name, ".trace_"))
5974 name += sizeof (".trace_") - 1;
5977 || (do_trace_info && streq (name, "info"))
5978 || (do_trace_abbrevs && streq (name, "abbrev"))
5979 || (do_trace_aranges && streq (name, "aranges"))
5981 request_dump_bynumber (i, DEBUG_DUMP);
5988 if (elf_header.e_shnum > 1)
5989 printf (_("\nSection Headers:\n"));
5991 printf (_("\nSection Header:\n"));
5995 if (do_section_details)
5997 printf (_(" [Nr] Name\n"));
5998 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
6002 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
6006 if (do_section_details)
6008 printf (_(" [Nr] Name\n"));
6009 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
6013 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
6017 if (do_section_details)
6019 printf (_(" [Nr] Name\n"));
6020 printf (_(" Type Address Offset Link\n"));
6021 printf (_(" Size EntSize Info Align\n"));
6025 printf (_(" [Nr] Name Type Address Offset\n"));
6026 printf (_(" Size EntSize Flags Link Info Align\n"));
6030 if (do_section_details)
6031 printf (_(" Flags\n"));
6033 for (i = 0, section = section_headers;
6034 i < elf_header.e_shnum;
6037 /* Run some sanity checks on the section header. */
6039 /* Check the sh_link field. */
6040 switch (section->sh_type)
6042 case SHT_SYMTAB_SHNDX:
6046 case SHT_GNU_versym:
6049 if (section->sh_link < 1
6050 || section->sh_link >= elf_header.e_shnum
6051 || (section_headers[section->sh_link].sh_type != SHT_SYMTAB
6052 && section_headers[section->sh_link].sh_type != SHT_DYNSYM))
6053 warn (_("[%2u]: Link field (%u) should index a symtab section.\n"),
6054 i, section->sh_link);
6060 case SHT_GNU_verneed:
6061 case SHT_GNU_verdef:
6062 case SHT_GNU_LIBLIST:
6063 if (section->sh_link < 1
6064 || section->sh_link >= elf_header.e_shnum
6065 || section_headers[section->sh_link].sh_type != SHT_STRTAB)
6066 warn (_("[%2u]: Link field (%u) should index a string section.\n"),
6067 i, section->sh_link);
6070 case SHT_INIT_ARRAY:
6071 case SHT_FINI_ARRAY:
6072 case SHT_PREINIT_ARRAY:
6073 if (section->sh_type < SHT_LOOS && section->sh_link != 0)
6074 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6075 i, section->sh_link);
6079 /* FIXME: Add support for target specific section types. */
6080 #if 0 /* Currently we do not check other section types as there are too
6081 many special cases. Stab sections for example have a type
6082 of SHT_PROGBITS but an sh_link field that links to the .stabstr
6084 if (section->sh_type < SHT_LOOS && section->sh_link != 0)
6085 warn (_("[%2u]: Unexpected value (%u) in link field.\n"),
6086 i, section->sh_link);
6091 /* Check the sh_info field. */
6092 switch (section->sh_type)
6096 if (section->sh_info < 1
6097 || section->sh_info >= elf_header.e_shnum
6098 || (section_headers[section->sh_info].sh_type != SHT_PROGBITS
6099 && section_headers[section->sh_info].sh_type != SHT_NOBITS
6100 && section_headers[section->sh_info].sh_type != SHT_NOTE
6101 && section_headers[section->sh_info].sh_type != SHT_INIT_ARRAY
6102 /* FIXME: Are other section types valid ? */
6103 && section_headers[section->sh_info].sh_type < SHT_LOOS))
6105 if (section->sh_info == 0
6106 && (streq (SECTION_NAME (section), ".rel.dyn")
6107 || streq (SECTION_NAME (section), ".rela.dyn")))
6108 /* The .rel.dyn and .rela.dyn sections have an sh_info field
6109 of zero. The relocations in these sections may apply
6110 to many different sections. */
6113 warn (_("[%2u]: Info field (%u) should index a relocatable section.\n"),
6114 i, section->sh_info);
6120 case SHT_SYMTAB_SHNDX:
6121 case SHT_INIT_ARRAY:
6122 case SHT_FINI_ARRAY:
6123 case SHT_PREINIT_ARRAY:
6124 if (section->sh_info != 0)
6125 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6126 i, section->sh_info);
6132 /* A symbol index - we assume that it is valid. */
6136 /* FIXME: Add support for target specific section types. */
6137 if (section->sh_type == SHT_NOBITS)
6138 /* NOBITS section headers with non-zero sh_info fields can be
6139 created when a binary is stripped of everything but its debug
6140 information. The stripped sections have their headers
6141 preserved but their types set to SHT_NOBITS. So do not check
6142 this type of section. */
6144 else if (section->sh_flags & SHF_INFO_LINK)
6146 if (section->sh_info < 1 || section->sh_info >= elf_header.e_shnum)
6147 warn (_("[%2u]: Expected link to another section in info field"), i);
6149 else if (section->sh_type < SHT_LOOS && section->sh_info != 0)
6150 warn (_("[%2u]: Unexpected value (%u) in info field.\n"),
6151 i, section->sh_info);
6155 printf (" [%2u] ", i);
6156 if (do_section_details)
6157 printf ("%s\n ", printable_section_name (section));
6159 print_symbol (-17, SECTION_NAME (section));
6161 printf (do_wide ? " %-15s " : " %-15.15s ",
6162 get_section_type_name (section->sh_type));
6166 const char * link_too_big = NULL;
6168 print_vma (section->sh_addr, LONG_HEX);
6170 printf ( " %6.6lx %6.6lx %2.2lx",
6171 (unsigned long) section->sh_offset,
6172 (unsigned long) section->sh_size,
6173 (unsigned long) section->sh_entsize);
6175 if (do_section_details)
6176 fputs (" ", stdout);
6178 printf (" %3s ", get_elf_section_flags (section->sh_flags));
6180 if (section->sh_link >= elf_header.e_shnum)
6183 /* The sh_link value is out of range. Normally this indicates
6184 an error but it can have special values in Solaris binaries. */
6185 switch (elf_header.e_machine)
6192 case EM_OLD_SPARCV9:
6193 case EM_SPARC32PLUS:
6196 if (section->sh_link == (SHN_BEFORE & 0xffff))
6197 link_too_big = "BEFORE";
6198 else if (section->sh_link == (SHN_AFTER & 0xffff))
6199 link_too_big = "AFTER";
6206 if (do_section_details)
6208 if (link_too_big != NULL && * link_too_big)
6209 printf ("<%s> ", link_too_big);
6211 printf ("%2u ", section->sh_link);
6212 printf ("%3u %2lu\n", section->sh_info,
6213 (unsigned long) section->sh_addralign);
6216 printf ("%2u %3u %2lu\n",
6219 (unsigned long) section->sh_addralign);
6221 if (link_too_big && ! * link_too_big)
6222 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
6223 i, section->sh_link);
6227 print_vma (section->sh_addr, LONG_HEX);
6229 if ((long) section->sh_offset == section->sh_offset)
6230 printf (" %6.6lx", (unsigned long) section->sh_offset);
6234 print_vma (section->sh_offset, LONG_HEX);
6237 if ((unsigned long) section->sh_size == section->sh_size)
6238 printf (" %6.6lx", (unsigned long) section->sh_size);
6242 print_vma (section->sh_size, LONG_HEX);
6245 if ((unsigned long) section->sh_entsize == section->sh_entsize)
6246 printf (" %2.2lx", (unsigned long) section->sh_entsize);
6250 print_vma (section->sh_entsize, LONG_HEX);
6253 if (do_section_details)
6254 fputs (" ", stdout);
6256 printf (" %3s ", get_elf_section_flags (section->sh_flags));
6258 printf ("%2u %3u ", section->sh_link, section->sh_info);
6260 if ((unsigned long) section->sh_addralign == section->sh_addralign)
6261 printf ("%2lu\n", (unsigned long) section->sh_addralign);
6264 print_vma (section->sh_addralign, DEC);
6268 else if (do_section_details)
6270 printf (" %-15.15s ",
6271 get_section_type_name (section->sh_type));
6272 print_vma (section->sh_addr, LONG_HEX);
6273 if ((long) section->sh_offset == section->sh_offset)
6274 printf (" %16.16lx", (unsigned long) section->sh_offset);
6278 print_vma (section->sh_offset, LONG_HEX);
6280 printf (" %u\n ", section->sh_link);
6281 print_vma (section->sh_size, LONG_HEX);
6283 print_vma (section->sh_entsize, LONG_HEX);
6285 printf (" %-16u %lu\n",
6287 (unsigned long) section->sh_addralign);
6292 print_vma (section->sh_addr, LONG_HEX);
6293 if ((long) section->sh_offset == section->sh_offset)
6294 printf (" %8.8lx", (unsigned long) section->sh_offset);
6298 print_vma (section->sh_offset, LONG_HEX);
6301 print_vma (section->sh_size, LONG_HEX);
6303 print_vma (section->sh_entsize, LONG_HEX);
6305 printf (" %3s ", get_elf_section_flags (section->sh_flags));
6307 printf (" %2u %3u %lu\n",
6310 (unsigned long) section->sh_addralign);
6313 if (do_section_details)
6315 printf (" %s\n", get_elf_section_flags (section->sh_flags));
6316 if ((section->sh_flags & SHF_COMPRESSED) != 0)
6318 /* Minimum section size is 12 bytes for 32-bit compression
6319 header + 12 bytes for compressed data header. */
6320 unsigned char buf[24];
6322 assert (sizeof (buf) >= sizeof (Elf64_External_Chdr));
6323 if (get_data (&buf, (FILE *) file, section->sh_offset, 1,
6324 sizeof (buf), _("compression header")))
6326 Elf_Internal_Chdr chdr;
6328 (void) get_compression_header (&chdr, buf, sizeof (buf));
6330 if (chdr.ch_type == ELFCOMPRESS_ZLIB)
6333 printf (_(" [<unknown>: 0x%x], "),
6335 print_vma (chdr.ch_size, LONG_HEX);
6336 printf (", %lu\n", (unsigned long) chdr.ch_addralign);
6342 if (!do_section_details)
6344 /* The ordering of the letters shown here matches the ordering of the
6345 corresponding SHF_xxx values, and hence the order in which these
6346 letters will be displayed to the user. */
6347 printf (_("Key to Flags:\n\
6348 W (write), A (alloc), X (execute), M (merge), S (strings), I (info),\n\
6349 L (link order), O (extra OS processing required), G (group), T (TLS),\n\
6350 C (compressed), x (unknown), o (OS specific), E (exclude),\n "));
6351 if (elf_header.e_machine == EM_X86_64
6352 || elf_header.e_machine == EM_L1OM
6353 || elf_header.e_machine == EM_K1OM)
6354 printf (_("l (large), "));
6355 else if (elf_header.e_machine == EM_ARM)
6356 printf (_("y (purecode), "));
6357 printf ("p (processor specific)\n");
6364 get_group_flags (unsigned int flags)
6366 static char buff[128];
6370 else if (flags == GRP_COMDAT)
6373 snprintf (buff, 14, _("[0x%x: "), flags);
6375 flags &= ~ GRP_COMDAT;
6376 if (flags & GRP_MASKOS)
6378 strcat (buff, "<OS specific>");
6379 flags &= ~ GRP_MASKOS;
6382 if (flags & GRP_MASKPROC)
6384 strcat (buff, "<PROC specific>");
6385 flags &= ~ GRP_MASKPROC;
6389 strcat (buff, "<unknown>");
6396 process_section_groups (FILE * file)
6398 Elf_Internal_Shdr * section;
6400 struct group * group;
6401 Elf_Internal_Shdr * symtab_sec;
6402 Elf_Internal_Shdr * strtab_sec;
6403 Elf_Internal_Sym * symtab;
6404 unsigned long num_syms;
6408 /* Don't process section groups unless needed. */
6409 if (!do_unwind && !do_section_groups)
6412 if (elf_header.e_shnum == 0)
6414 if (do_section_groups)
6415 printf (_("\nThere are no sections to group in this file.\n"));
6420 if (section_headers == NULL)
6422 error (_("Section headers are not available!\n"));
6423 /* PR 13622: This can happen with a corrupt ELF header. */
6427 section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
6428 sizeof (struct group *));
6430 if (section_headers_groups == NULL)
6432 error (_("Out of memory reading %u section group headers\n"),
6433 elf_header.e_shnum);
6437 /* Scan the sections for the group section. */
6439 for (i = 0, section = section_headers;
6440 i < elf_header.e_shnum;
6442 if (section->sh_type == SHT_GROUP)
6445 if (group_count == 0)
6447 if (do_section_groups)
6448 printf (_("\nThere are no section groups in this file.\n"));
6453 section_groups = (struct group *) calloc (group_count, sizeof (struct group));
6455 if (section_groups == NULL)
6457 error (_("Out of memory reading %lu groups\n"),
6458 (unsigned long) group_count);
6468 for (i = 0, section = section_headers, group = section_groups;
6469 i < elf_header.e_shnum;
6472 if (section->sh_type == SHT_GROUP)
6474 const char * name = printable_section_name (section);
6475 const char * group_name;
6476 unsigned char * start;
6477 unsigned char * indices;
6478 unsigned int entry, j, size;
6479 Elf_Internal_Shdr * sec;
6480 Elf_Internal_Sym * sym;
6482 /* Get the symbol table. */
6483 if (section->sh_link >= elf_header.e_shnum
6484 || ((sec = section_headers + section->sh_link)->sh_type
6487 error (_("Bad sh_link in group section `%s'\n"), name);
6491 if (symtab_sec != sec)
6496 symtab = GET_ELF_SYMBOLS (file, symtab_sec, & num_syms);
6501 error (_("Corrupt header in group section `%s'\n"), name);
6505 if (section->sh_info >= num_syms)
6507 error (_("Bad sh_info in group section `%s'\n"), name);
6511 sym = symtab + section->sh_info;
6513 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
6515 if (sym->st_shndx == 0
6516 || sym->st_shndx >= elf_header.e_shnum)
6518 error (_("Bad sh_info in group section `%s'\n"), name);
6522 group_name = SECTION_NAME (section_headers + sym->st_shndx);
6531 /* Get the string table. */
6532 if (symtab_sec->sh_link >= elf_header.e_shnum)
6541 != (sec = section_headers + symtab_sec->sh_link))
6547 strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
6548 1, strtab_sec->sh_size,
6550 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
6552 group_name = sym->st_name < strtab_size
6553 ? strtab + sym->st_name : _("<corrupt>");
6556 /* PR 17531: file: loop. */
6557 if (section->sh_entsize > section->sh_size)
6559 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
6560 printable_section_name (section),
6561 (unsigned long) section->sh_entsize,
6562 (unsigned long) section->sh_size);
6566 start = (unsigned char *) get_data (NULL, file, section->sh_offset,
6567 1, section->sh_size,
6573 size = (section->sh_size / section->sh_entsize) - 1;
6574 entry = byte_get (indices, 4);
6577 if (do_section_groups)
6579 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6580 get_group_flags (entry), i, name, group_name, size);
6582 printf (_(" [Index] Name\n"));
6585 group->group_index = i;
6587 for (j = 0; j < size; j++)
6589 struct group_list * g;
6591 entry = byte_get (indices, 4);
6594 if (entry >= elf_header.e_shnum)
6596 static unsigned num_group_errors = 0;
6598 if (num_group_errors ++ < 10)
6600 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6601 entry, i, elf_header.e_shnum - 1);
6602 if (num_group_errors == 10)
6603 warn (_("Futher error messages about overlarge group section indicies suppressed\n"));
6608 if (section_headers_groups [entry] != NULL)
6612 static unsigned num_errs = 0;
6614 if (num_errs ++ < 10)
6616 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6618 section_headers_groups [entry]->group_index);
6620 warn (_("Further error messages about already contained group sections suppressed\n"));
6626 /* Intel C/C++ compiler may put section 0 in a
6627 section group. We just warn it the first time
6628 and ignore it afterwards. */
6629 static bfd_boolean warned = FALSE;
6632 error (_("section 0 in group section [%5u]\n"),
6633 section_headers_groups [entry]->group_index);
6639 section_headers_groups [entry] = group;
6641 if (do_section_groups)
6643 sec = section_headers + entry;
6644 printf (" [%5u] %s\n", entry, printable_section_name (sec));
6647 g = (struct group_list *) xmalloc (sizeof (struct group_list));
6648 g->section_index = entry;
6649 g->next = group->root;
6667 /* Data used to display dynamic fixups. */
6669 struct ia64_vms_dynfixup
6671 bfd_vma needed_ident; /* Library ident number. */
6672 bfd_vma needed; /* Index in the dstrtab of the library name. */
6673 bfd_vma fixup_needed; /* Index of the library. */
6674 bfd_vma fixup_rela_cnt; /* Number of fixups. */
6675 bfd_vma fixup_rela_off; /* Fixups offset in the dynamic segment. */
6678 /* Data used to display dynamic relocations. */
6680 struct ia64_vms_dynimgrela
6682 bfd_vma img_rela_cnt; /* Number of relocations. */
6683 bfd_vma img_rela_off; /* Reloc offset in the dynamic segment. */
6686 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6690 dump_ia64_vms_dynamic_fixups (FILE * file,
6691 struct ia64_vms_dynfixup * fixup,
6692 const char * strtab,
6693 unsigned int strtab_sz)
6695 Elf64_External_VMS_IMAGE_FIXUP * imfs;
6697 const char * lib_name;
6699 imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
6700 1, fixup->fixup_rela_cnt * sizeof (*imfs),
6701 _("dynamic section image fixups"));
6705 if (fixup->needed < strtab_sz)
6706 lib_name = strtab + fixup->needed;
6709 warn (_("corrupt library name index of 0x%lx found in dynamic entry"),
6710 (unsigned long) fixup->needed);
6713 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6714 (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
6716 (_("Seg Offset Type SymVec DataType\n"));
6718 for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
6723 printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
6724 printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
6725 type = BYTE_GET (imfs [i].type);
6726 rtype = elf_ia64_reloc_type (type);
6728 printf (" 0x%08x ", type);
6730 printf (" %-32s ", rtype);
6731 printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
6732 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
6739 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
6742 dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
6744 Elf64_External_VMS_IMAGE_RELA *imrs;
6747 imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
6748 1, imgrela->img_rela_cnt * sizeof (*imrs),
6749 _("dynamic section image relocations"));
6753 printf (_("\nImage relocs\n"));
6755 (_("Seg Offset Type Addend Seg Sym Off\n"));
6757 for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
6762 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
6763 printf ("%08" BFD_VMA_FMT "x ",
6764 (bfd_vma) BYTE_GET (imrs [i].rela_offset));
6765 type = BYTE_GET (imrs [i].type);
6766 rtype = elf_ia64_reloc_type (type);
6768 printf ("0x%08x ", type);
6770 printf ("%-31s ", rtype);
6771 print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
6772 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
6773 printf ("%08" BFD_VMA_FMT "x\n",
6774 (bfd_vma) BYTE_GET (imrs [i].sym_offset));
6781 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
6784 process_ia64_vms_dynamic_relocs (FILE *file)
6786 struct ia64_vms_dynfixup fixup;
6787 struct ia64_vms_dynimgrela imgrela;
6788 Elf_Internal_Dyn *entry;
6789 bfd_vma strtab_off = 0;
6790 bfd_vma strtab_sz = 0;
6791 char *strtab = NULL;
6792 bfd_boolean res = TRUE;
6794 memset (&fixup, 0, sizeof (fixup));
6795 memset (&imgrela, 0, sizeof (imgrela));
6797 /* Note: the order of the entries is specified by the OpenVMS specs. */
6798 for (entry = dynamic_section;
6799 entry < dynamic_section + dynamic_nent;
6802 switch (entry->d_tag)
6804 case DT_IA_64_VMS_STRTAB_OFFSET:
6805 strtab_off = entry->d_un.d_val;
6808 strtab_sz = entry->d_un.d_val;
6810 strtab = get_data (NULL, file, dynamic_addr + strtab_off,
6811 1, strtab_sz, _("dynamic string section"));
6814 case DT_IA_64_VMS_NEEDED_IDENT:
6815 fixup.needed_ident = entry->d_un.d_val;
6818 fixup.needed = entry->d_un.d_val;
6820 case DT_IA_64_VMS_FIXUP_NEEDED:
6821 fixup.fixup_needed = entry->d_un.d_val;
6823 case DT_IA_64_VMS_FIXUP_RELA_CNT:
6824 fixup.fixup_rela_cnt = entry->d_un.d_val;
6826 case DT_IA_64_VMS_FIXUP_RELA_OFF:
6827 fixup.fixup_rela_off = entry->d_un.d_val;
6828 if (! dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz))
6831 case DT_IA_64_VMS_IMG_RELA_CNT:
6832 imgrela.img_rela_cnt = entry->d_un.d_val;
6834 case DT_IA_64_VMS_IMG_RELA_OFF:
6835 imgrela.img_rela_off = entry->d_un.d_val;
6836 if (! dump_ia64_vms_dynamic_relocs (file, &imgrela))
6858 dynamic_relocations [] =
6860 { "REL", DT_REL, DT_RELSZ, FALSE },
6861 { "RELA", DT_RELA, DT_RELASZ, TRUE },
6862 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
6865 /* Process the reloc section. */
6868 process_relocs (FILE * file)
6870 unsigned long rel_size;
6871 unsigned long rel_offset;
6876 if (do_using_dynamic)
6880 bfd_boolean has_dynamic_reloc;
6883 has_dynamic_reloc = FALSE;
6885 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
6887 is_rela = dynamic_relocations [i].rela;
6888 name = dynamic_relocations [i].name;
6889 rel_size = dynamic_info [dynamic_relocations [i].size];
6890 rel_offset = dynamic_info [dynamic_relocations [i].reloc];
6893 has_dynamic_reloc = TRUE;
6895 if (is_rela == UNKNOWN)
6897 if (dynamic_relocations [i].reloc == DT_JMPREL)
6898 switch (dynamic_info[DT_PLTREL])
6912 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
6913 name, rel_offset, rel_size);
6915 dump_relocations (file,
6916 offset_from_vma (file, rel_offset, rel_size),
6918 dynamic_symbols, num_dynamic_syms,
6919 dynamic_strings, dynamic_strings_length,
6920 is_rela, TRUE /* is_dynamic */);
6925 if (process_ia64_vms_dynamic_relocs (file))
6926 has_dynamic_reloc = TRUE;
6928 if (! has_dynamic_reloc)
6929 printf (_("\nThere are no dynamic relocations in this file.\n"));
6933 Elf_Internal_Shdr * section;
6935 bfd_boolean found = FALSE;
6937 for (i = 0, section = section_headers;
6938 i < elf_header.e_shnum;
6941 if ( section->sh_type != SHT_RELA
6942 && section->sh_type != SHT_REL)
6945 rel_offset = section->sh_offset;
6946 rel_size = section->sh_size;
6950 Elf_Internal_Shdr * strsec;
6953 printf (_("\nRelocation section "));
6955 if (string_table == NULL)
6956 printf ("%d", section->sh_name);
6958 printf ("'%s'", printable_section_name (section));
6960 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6961 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
6963 is_rela = section->sh_type == SHT_RELA;
6965 if (section->sh_link != 0
6966 && section->sh_link < elf_header.e_shnum)
6968 Elf_Internal_Shdr * symsec;
6969 Elf_Internal_Sym * symtab;
6970 unsigned long nsyms;
6971 unsigned long strtablen = 0;
6972 char * strtab = NULL;
6974 symsec = section_headers + section->sh_link;
6975 if (symsec->sh_type != SHT_SYMTAB
6976 && symsec->sh_type != SHT_DYNSYM)
6979 symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
6984 if (symsec->sh_link != 0
6985 && symsec->sh_link < elf_header.e_shnum)
6987 strsec = section_headers + symsec->sh_link;
6989 strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6992 strtablen = strtab == NULL ? 0 : strsec->sh_size;
6995 dump_relocations (file, rel_offset, rel_size,
6996 symtab, nsyms, strtab, strtablen,
6998 symsec->sh_type == SHT_DYNSYM);
7004 dump_relocations (file, rel_offset, rel_size,
7005 NULL, 0, NULL, 0, is_rela,
7006 FALSE /* is_dynamic */);
7013 printf (_("\nThere are no relocations in this file.\n"));
7019 /* An absolute address consists of a section and an offset. If the
7020 section is NULL, the offset itself is the address, otherwise, the
7021 address equals to LOAD_ADDRESS(section) + offset. */
7025 unsigned short section;
7029 #define ABSADDR(a) \
7031 ? section_headers [(a).section].sh_addr + (a).offset \
7034 /* Find the nearest symbol at or below ADDR. Returns the symbol
7035 name, if found, and the offset from the symbol to ADDR. */
7038 find_symbol_for_address (Elf_Internal_Sym * symtab,
7039 unsigned long nsyms,
7040 const char * strtab,
7041 unsigned long strtab_size,
7042 struct absaddr addr,
7043 const char ** symname,
7046 bfd_vma dist = 0x100000;
7047 Elf_Internal_Sym * sym;
7048 Elf_Internal_Sym * beg;
7049 Elf_Internal_Sym * end;
7050 Elf_Internal_Sym * best = NULL;
7052 REMOVE_ARCH_BITS (addr.offset);
7054 end = symtab + nsyms;
7060 sym = beg + (end - beg) / 2;
7062 value = sym->st_value;
7063 REMOVE_ARCH_BITS (value);
7065 if (sym->st_name != 0
7066 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
7067 && addr.offset >= value
7068 && addr.offset - value < dist)
7071 dist = addr.offset - value;
7076 if (addr.offset < value)
7084 *symname = (best->st_name >= strtab_size
7085 ? _("<corrupt>") : strtab + best->st_name);
7091 *offset = addr.offset;
7094 static /* signed */ int
7095 symcmp (const void *p, const void *q)
7097 Elf_Internal_Sym *sp = (Elf_Internal_Sym *) p;
7098 Elf_Internal_Sym *sq = (Elf_Internal_Sym *) q;
7100 return sp->st_value > sq->st_value ? 1 : (sp->st_value < sq->st_value ? -1 : 0);
7103 /* Process the unwind section. */
7105 #include "unwind-ia64.h"
7107 struct ia64_unw_table_entry
7109 struct absaddr start;
7111 struct absaddr info;
7114 struct ia64_unw_aux_info
7116 struct ia64_unw_table_entry * table; /* Unwind table. */
7117 unsigned long table_len; /* Length of unwind table. */
7118 unsigned char * info; /* Unwind info. */
7119 unsigned long info_size; /* Size of unwind info. */
7120 bfd_vma info_addr; /* Starting address of unwind info. */
7121 bfd_vma seg_base; /* Starting address of segment. */
7122 Elf_Internal_Sym * symtab; /* The symbol table. */
7123 unsigned long nsyms; /* Number of symbols. */
7124 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
7125 unsigned long nfuns; /* Number of entries in funtab. */
7126 char * strtab; /* The string table. */
7127 unsigned long strtab_size; /* Size of string table. */
7131 dump_ia64_unwind (struct ia64_unw_aux_info * aux)
7133 struct ia64_unw_table_entry * tp;
7134 unsigned long j, nfuns;
7136 bfd_boolean res = TRUE;
7138 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7139 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7140 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7141 aux->funtab[nfuns++] = aux->symtab[j];
7143 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7145 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7149 const unsigned char * dp;
7150 const unsigned char * head;
7151 const unsigned char * end;
7152 const char * procname;
7154 find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
7155 aux->strtab_size, tp->start, &procname, &offset);
7157 fputs ("\n<", stdout);
7161 fputs (procname, stdout);
7164 printf ("+%lx", (unsigned long) offset);
7167 fputs (">: [", stdout);
7168 print_vma (tp->start.offset, PREFIX_HEX);
7169 fputc ('-', stdout);
7170 print_vma (tp->end.offset, PREFIX_HEX);
7171 printf ("], info at +0x%lx\n",
7172 (unsigned long) (tp->info.offset - aux->seg_base));
7174 /* PR 17531: file: 86232b32. */
7175 if (aux->info == NULL)
7178 /* PR 17531: file: 0997b4d1. */
7179 if ((ABSADDR (tp->info) - aux->info_addr) >= aux->info_size)
7181 warn (_("Invalid offset %lx in table entry %ld\n"),
7182 (long) tp->info.offset, (long) (tp - aux->table));
7187 head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
7188 stamp = byte_get ((unsigned char *) head, sizeof (stamp));
7190 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
7191 (unsigned) UNW_VER (stamp),
7192 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
7193 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
7194 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
7195 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
7197 if (UNW_VER (stamp) != 1)
7199 printf (_("\tUnknown version.\n"));
7204 end = head + 8 + eh_addr_size * UNW_LENGTH (stamp);
7205 /* PR 17531: file: 16ceda89. */
7206 if (end > aux->info + aux->info_size)
7207 end = aux->info + aux->info_size;
7208 for (dp = head + 8; dp < end;)
7209 dp = unw_decode (dp, in_body, & in_body, end);
7218 slurp_ia64_unwind_table (FILE * file,
7219 struct ia64_unw_aux_info * aux,
7220 Elf_Internal_Shdr * sec)
7222 unsigned long size, nrelas, i;
7223 Elf_Internal_Phdr * seg;
7224 struct ia64_unw_table_entry * tep;
7225 Elf_Internal_Shdr * relsec;
7226 Elf_Internal_Rela * rela;
7227 Elf_Internal_Rela * rp;
7228 unsigned char * table;
7230 Elf_Internal_Sym * sym;
7231 const char * relname;
7235 /* First, find the starting address of the segment that includes
7238 if (elf_header.e_phnum)
7240 if (! get_program_headers (file))
7243 for (seg = program_headers;
7244 seg < program_headers + elf_header.e_phnum;
7247 if (seg->p_type != PT_LOAD)
7250 if (sec->sh_addr >= seg->p_vaddr
7251 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7253 aux->seg_base = seg->p_vaddr;
7259 /* Second, build the unwind table from the contents of the unwind section: */
7260 size = sec->sh_size;
7261 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
7266 aux->table_len = size / (3 * eh_addr_size);
7267 aux->table = (struct ia64_unw_table_entry *)
7268 xcmalloc (aux->table_len, sizeof (aux->table[0]));
7271 for (tp = table; tp <= table + size - (3 * eh_addr_size); ++tep)
7273 tep->start.section = SHN_UNDEF;
7274 tep->end.section = SHN_UNDEF;
7275 tep->info.section = SHN_UNDEF;
7276 tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7277 tep->end.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7278 tep->info.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
7279 tep->start.offset += aux->seg_base;
7280 tep->end.offset += aux->seg_base;
7281 tep->info.offset += aux->seg_base;
7285 /* Third, apply any relocations to the unwind table: */
7286 for (relsec = section_headers;
7287 relsec < section_headers + elf_header.e_shnum;
7290 if (relsec->sh_type != SHT_RELA
7291 || relsec->sh_info >= elf_header.e_shnum
7292 || section_headers + relsec->sh_info != sec)
7295 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
7304 for (rp = rela; rp < rela + nrelas; ++rp)
7306 relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
7307 sym = aux->symtab + get_reloc_symindex (rp->r_info);
7309 /* PR 17531: file: 9fa67536. */
7310 if (relname == NULL)
7312 warn (_("Skipping unknown relocation type: %u\n"), get_reloc_type (rp->r_info));
7316 if (! const_strneq (relname, "R_IA64_SEGREL"))
7318 warn (_("Skipping unexpected relocation type: %s\n"), relname);
7322 i = rp->r_offset / (3 * eh_addr_size);
7324 /* PR 17531: file: 5bc8d9bf. */
7325 if (i >= aux->table_len)
7327 warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
7331 switch (rp->r_offset / eh_addr_size % 3)
7334 aux->table[i].start.section = sym->st_shndx;
7335 aux->table[i].start.offset = rp->r_addend + sym->st_value;
7338 aux->table[i].end.section = sym->st_shndx;
7339 aux->table[i].end.offset = rp->r_addend + sym->st_value;
7342 aux->table[i].info.section = sym->st_shndx;
7343 aux->table[i].info.offset = rp->r_addend + sym->st_value;
7357 ia64_process_unwind (FILE * file)
7359 Elf_Internal_Shdr * sec;
7360 Elf_Internal_Shdr * unwsec = NULL;
7361 Elf_Internal_Shdr * strsec;
7362 unsigned long i, unwcount = 0, unwstart = 0;
7363 struct ia64_unw_aux_info aux;
7364 bfd_boolean res = TRUE;
7366 memset (& aux, 0, sizeof (aux));
7368 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7370 if (sec->sh_type == SHT_SYMTAB
7371 && sec->sh_link < elf_header.e_shnum)
7373 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
7375 strsec = section_headers + sec->sh_link;
7376 if (aux.strtab != NULL)
7378 error (_("Multiple auxillary string tables encountered\n"));
7382 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
7385 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7387 else if (sec->sh_type == SHT_IA_64_UNWIND)
7392 printf (_("\nThere are no unwind sections in this file.\n"));
7394 while (unwcount-- > 0)
7399 for (i = unwstart, sec = section_headers + unwstart, unwsec = NULL;
7400 i < elf_header.e_shnum; ++i, ++sec)
7401 if (sec->sh_type == SHT_IA_64_UNWIND)
7406 /* We have already counted the number of SHT_IA64_UNWIND
7407 sections so the loop above should never fail. */
7408 assert (unwsec != NULL);
7411 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
7413 if ((unwsec->sh_flags & SHF_GROUP) != 0)
7415 /* We need to find which section group it is in. */
7416 struct group_list * g;
7418 if (section_headers_groups == NULL
7419 || section_headers_groups [i] == NULL)
7420 i = elf_header.e_shnum;
7423 g = section_headers_groups [i]->root;
7425 for (; g != NULL; g = g->next)
7427 sec = section_headers + g->section_index;
7429 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
7434 i = elf_header.e_shnum;
7437 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
7439 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
7440 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
7441 suffix = SECTION_NAME (unwsec) + len;
7442 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
7444 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
7445 && streq (SECTION_NAME (sec) + len2, suffix))
7450 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
7451 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
7452 len = sizeof (ELF_STRING_ia64_unwind) - 1;
7453 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
7455 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
7456 suffix = SECTION_NAME (unwsec) + len;
7457 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
7459 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
7460 && streq (SECTION_NAME (sec) + len2, suffix))
7464 if (i == elf_header.e_shnum)
7466 printf (_("\nCould not find unwind info section for "));
7468 if (string_table == NULL)
7469 printf ("%d", unwsec->sh_name);
7471 printf ("'%s'", printable_section_name (unwsec));
7475 aux.info_addr = sec->sh_addr;
7476 aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
7479 aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
7481 printf (_("\nUnwind section "));
7483 if (string_table == NULL)
7484 printf ("%d", unwsec->sh_name);
7486 printf ("'%s'", printable_section_name (unwsec));
7488 printf (_(" at offset 0x%lx contains %lu entries:\n"),
7489 (unsigned long) unwsec->sh_offset,
7490 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
7492 if (slurp_ia64_unwind_table (file, & aux, unwsec)
7493 && aux.table_len > 0)
7494 dump_ia64_unwind (& aux);
7497 free ((char *) aux.table);
7499 free ((char *) aux.info);
7508 free ((char *) aux.strtab);
7513 struct hppa_unw_table_entry
7515 struct absaddr start;
7517 unsigned int Cannot_unwind:1; /* 0 */
7518 unsigned int Millicode:1; /* 1 */
7519 unsigned int Millicode_save_sr0:1; /* 2 */
7520 unsigned int Region_description:2; /* 3..4 */
7521 unsigned int reserved1:1; /* 5 */
7522 unsigned int Entry_SR:1; /* 6 */
7523 unsigned int Entry_FR:4; /* Number saved 7..10 */
7524 unsigned int Entry_GR:5; /* Number saved 11..15 */
7525 unsigned int Args_stored:1; /* 16 */
7526 unsigned int Variable_Frame:1; /* 17 */
7527 unsigned int Separate_Package_Body:1; /* 18 */
7528 unsigned int Frame_Extension_Millicode:1; /* 19 */
7529 unsigned int Stack_Overflow_Check:1; /* 20 */
7530 unsigned int Two_Instruction_SP_Increment:1; /* 21 */
7531 unsigned int Ada_Region:1; /* 22 */
7532 unsigned int cxx_info:1; /* 23 */
7533 unsigned int cxx_try_catch:1; /* 24 */
7534 unsigned int sched_entry_seq:1; /* 25 */
7535 unsigned int reserved2:1; /* 26 */
7536 unsigned int Save_SP:1; /* 27 */
7537 unsigned int Save_RP:1; /* 28 */
7538 unsigned int Save_MRP_in_frame:1; /* 29 */
7539 unsigned int extn_ptr_defined:1; /* 30 */
7540 unsigned int Cleanup_defined:1; /* 31 */
7542 unsigned int MPE_XL_interrupt_marker:1; /* 0 */
7543 unsigned int HP_UX_interrupt_marker:1; /* 1 */
7544 unsigned int Large_frame:1; /* 2 */
7545 unsigned int Pseudo_SP_Set:1; /* 3 */
7546 unsigned int reserved4:1; /* 4 */
7547 unsigned int Total_frame_size:27; /* 5..31 */
7550 struct hppa_unw_aux_info
7552 struct hppa_unw_table_entry * table; /* Unwind table. */
7553 unsigned long table_len; /* Length of unwind table. */
7554 bfd_vma seg_base; /* Starting address of segment. */
7555 Elf_Internal_Sym * symtab; /* The symbol table. */
7556 unsigned long nsyms; /* Number of symbols. */
7557 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
7558 unsigned long nfuns; /* Number of entries in funtab. */
7559 char * strtab; /* The string table. */
7560 unsigned long strtab_size; /* Size of string table. */
7564 dump_hppa_unwind (struct hppa_unw_aux_info * aux)
7566 struct hppa_unw_table_entry * tp;
7567 unsigned long j, nfuns;
7568 bfd_boolean res = TRUE;
7570 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
7571 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
7572 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
7573 aux->funtab[nfuns++] = aux->symtab[j];
7575 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
7577 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
7580 const char * procname;
7582 find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
7583 aux->strtab_size, tp->start, &procname,
7586 fputs ("\n<", stdout);
7590 fputs (procname, stdout);
7593 printf ("+%lx", (unsigned long) offset);
7596 fputs (">: [", stdout);
7597 print_vma (tp->start.offset, PREFIX_HEX);
7598 fputc ('-', stdout);
7599 print_vma (tp->end.offset, PREFIX_HEX);
7602 #define PF(_m) if (tp->_m) printf (#_m " ");
7603 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
7606 PF(Millicode_save_sr0);
7607 /* PV(Region_description); */
7613 PF(Separate_Package_Body);
7614 PF(Frame_Extension_Millicode);
7615 PF(Stack_Overflow_Check);
7616 PF(Two_Instruction_SP_Increment);
7620 PF(sched_entry_seq);
7623 PF(Save_MRP_in_frame);
7624 PF(extn_ptr_defined);
7625 PF(Cleanup_defined);
7626 PF(MPE_XL_interrupt_marker);
7627 PF(HP_UX_interrupt_marker);
7630 PV(Total_frame_size);
7643 slurp_hppa_unwind_table (FILE * file,
7644 struct hppa_unw_aux_info * aux,
7645 Elf_Internal_Shdr * sec)
7647 unsigned long size, unw_ent_size, nentries, nrelas, i;
7648 Elf_Internal_Phdr * seg;
7649 struct hppa_unw_table_entry * tep;
7650 Elf_Internal_Shdr * relsec;
7651 Elf_Internal_Rela * rela;
7652 Elf_Internal_Rela * rp;
7653 unsigned char * table;
7655 Elf_Internal_Sym * sym;
7656 const char * relname;
7658 /* First, find the starting address of the segment that includes
7660 if (elf_header.e_phnum)
7662 if (! get_program_headers (file))
7665 for (seg = program_headers;
7666 seg < program_headers + elf_header.e_phnum;
7669 if (seg->p_type != PT_LOAD)
7672 if (sec->sh_addr >= seg->p_vaddr
7673 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7675 aux->seg_base = seg->p_vaddr;
7681 /* Second, build the unwind table from the contents of the unwind
7683 size = sec->sh_size;
7684 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
7690 nentries = size / unw_ent_size;
7691 size = unw_ent_size * nentries;
7693 tep = aux->table = (struct hppa_unw_table_entry *)
7694 xcmalloc (nentries, sizeof (aux->table[0]));
7696 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
7698 unsigned int tmp1, tmp2;
7700 tep->start.section = SHN_UNDEF;
7701 tep->end.section = SHN_UNDEF;
7703 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
7704 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
7705 tmp1 = byte_get ((unsigned char *) tp + 8, 4);
7706 tmp2 = byte_get ((unsigned char *) tp + 12, 4);
7708 tep->start.offset += aux->seg_base;
7709 tep->end.offset += aux->seg_base;
7711 tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
7712 tep->Millicode = (tmp1 >> 30) & 0x1;
7713 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
7714 tep->Region_description = (tmp1 >> 27) & 0x3;
7715 tep->reserved1 = (tmp1 >> 26) & 0x1;
7716 tep->Entry_SR = (tmp1 >> 25) & 0x1;
7717 tep->Entry_FR = (tmp1 >> 21) & 0xf;
7718 tep->Entry_GR = (tmp1 >> 16) & 0x1f;
7719 tep->Args_stored = (tmp1 >> 15) & 0x1;
7720 tep->Variable_Frame = (tmp1 >> 14) & 0x1;
7721 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
7722 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
7723 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
7724 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
7725 tep->Ada_Region = (tmp1 >> 9) & 0x1;
7726 tep->cxx_info = (tmp1 >> 8) & 0x1;
7727 tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
7728 tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
7729 tep->reserved2 = (tmp1 >> 5) & 0x1;
7730 tep->Save_SP = (tmp1 >> 4) & 0x1;
7731 tep->Save_RP = (tmp1 >> 3) & 0x1;
7732 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
7733 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
7734 tep->Cleanup_defined = tmp1 & 0x1;
7736 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
7737 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
7738 tep->Large_frame = (tmp2 >> 29) & 0x1;
7739 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
7740 tep->reserved4 = (tmp2 >> 27) & 0x1;
7741 tep->Total_frame_size = tmp2 & 0x7ffffff;
7745 /* Third, apply any relocations to the unwind table. */
7746 for (relsec = section_headers;
7747 relsec < section_headers + elf_header.e_shnum;
7750 if (relsec->sh_type != SHT_RELA
7751 || relsec->sh_info >= elf_header.e_shnum
7752 || section_headers + relsec->sh_info != sec)
7755 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
7759 for (rp = rela; rp < rela + nrelas; ++rp)
7761 relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
7762 sym = aux->symtab + get_reloc_symindex (rp->r_info);
7764 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
7765 if (! const_strneq (relname, "R_PARISC_SEGREL"))
7767 warn (_("Skipping unexpected relocation type %s\n"), relname);
7771 i = rp->r_offset / unw_ent_size;
7773 switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
7776 aux->table[i].start.section = sym->st_shndx;
7777 aux->table[i].start.offset = sym->st_value + rp->r_addend;
7780 aux->table[i].end.section = sym->st_shndx;
7781 aux->table[i].end.offset = sym->st_value + rp->r_addend;
7791 aux->table_len = nentries;
7797 hppa_process_unwind (FILE * file)
7799 struct hppa_unw_aux_info aux;
7800 Elf_Internal_Shdr * unwsec = NULL;
7801 Elf_Internal_Shdr * strsec;
7802 Elf_Internal_Shdr * sec;
7804 bfd_boolean res = TRUE;
7806 if (string_table == NULL)
7809 memset (& aux, 0, sizeof (aux));
7811 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7813 if (sec->sh_type == SHT_SYMTAB
7814 && sec->sh_link < elf_header.e_shnum)
7816 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
7818 strsec = section_headers + sec->sh_link;
7819 if (aux.strtab != NULL)
7821 error (_("Multiple auxillary string tables encountered\n"));
7825 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
7828 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7830 else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
7835 printf (_("\nThere are no unwind sections in this file.\n"));
7837 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7839 if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
7841 printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
7842 printable_section_name (sec),
7843 (unsigned long) sec->sh_offset,
7844 (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
7846 if (! slurp_hppa_unwind_table (file, &aux, sec))
7849 if (aux.table_len > 0)
7851 if (! dump_hppa_unwind (&aux))
7856 free ((char *) aux.table);
7864 free ((char *) aux.strtab);
7871 unsigned char * data; /* The unwind data. */
7872 Elf_Internal_Shdr * sec; /* The cached unwind section header. */
7873 Elf_Internal_Rela * rela; /* The cached relocations for this section. */
7874 unsigned long nrelas; /* The number of relocations. */
7875 unsigned int rel_type; /* REL or RELA ? */
7876 Elf_Internal_Rela * next_rela; /* Cyclic pointer to the next reloc to process. */
7879 struct arm_unw_aux_info
7881 FILE * file; /* The file containing the unwind sections. */
7882 Elf_Internal_Sym * symtab; /* The file's symbol table. */
7883 unsigned long nsyms; /* Number of symbols. */
7884 Elf_Internal_Sym * funtab; /* Sorted table of STT_FUNC symbols. */
7885 unsigned long nfuns; /* Number of these symbols. */
7886 char * strtab; /* The file's string table. */
7887 unsigned long strtab_size; /* Size of string table. */
7891 arm_print_vma_and_name (struct arm_unw_aux_info *aux,
7892 bfd_vma fn, struct absaddr addr)
7894 const char *procname;
7897 if (addr.section == SHN_UNDEF)
7900 find_symbol_for_address (aux->funtab, aux->nfuns, aux->strtab,
7901 aux->strtab_size, addr, &procname,
7904 print_vma (fn, PREFIX_HEX);
7908 fputs (" <", stdout);
7909 fputs (procname, stdout);
7912 printf ("+0x%lx", (unsigned long) sym_offset);
7913 fputc ('>', stdout);
7920 arm_free_section (struct arm_section *arm_sec)
7922 if (arm_sec->data != NULL)
7923 free (arm_sec->data);
7925 if (arm_sec->rela != NULL)
7926 free (arm_sec->rela);
7929 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
7930 cached section and install SEC instead.
7931 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
7932 and return its valued in * WORDP, relocating if necessary.
7933 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
7934 relocation's offset in ADDR.
7935 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
7936 into the string table of the symbol associated with the reloc. If no
7937 reloc was applied store -1 there.
7938 5) Return TRUE upon success, FALSE otherwise. */
7941 get_unwind_section_word (struct arm_unw_aux_info * aux,
7942 struct arm_section * arm_sec,
7943 Elf_Internal_Shdr * sec,
7944 bfd_vma word_offset,
7945 unsigned int * wordp,
7946 struct absaddr * addr,
7949 Elf_Internal_Rela *rp;
7950 Elf_Internal_Sym *sym;
7951 const char * relname;
7953 bfd_boolean wrapped;
7955 if (sec == NULL || arm_sec == NULL)
7958 addr->section = SHN_UNDEF;
7961 if (sym_name != NULL)
7962 *sym_name = (bfd_vma) -1;
7964 /* If necessary, update the section cache. */
7965 if (sec != arm_sec->sec)
7967 Elf_Internal_Shdr *relsec;
7969 arm_free_section (arm_sec);
7972 arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
7973 sec->sh_size, _("unwind data"));
7974 arm_sec->rela = NULL;
7975 arm_sec->nrelas = 0;
7977 for (relsec = section_headers;
7978 relsec < section_headers + elf_header.e_shnum;
7981 if (relsec->sh_info >= elf_header.e_shnum
7982 || section_headers + relsec->sh_info != sec
7983 /* PR 15745: Check the section type as well. */
7984 || (relsec->sh_type != SHT_REL
7985 && relsec->sh_type != SHT_RELA))
7988 arm_sec->rel_type = relsec->sh_type;
7989 if (relsec->sh_type == SHT_REL)
7991 if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
7993 & arm_sec->rela, & arm_sec->nrelas))
7996 else /* relsec->sh_type == SHT_RELA */
7998 if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
8000 & arm_sec->rela, & arm_sec->nrelas))
8006 arm_sec->next_rela = arm_sec->rela;
8009 /* If there is no unwind data we can do nothing. */
8010 if (arm_sec->data == NULL)
8013 /* If the offset is invalid then fail. */
8014 if (word_offset > (sec->sh_size - 4)
8016 || (sec->sh_size < 5 && word_offset >= sec->sh_size)
8017 || ((bfd_signed_vma) word_offset) < 0)
8020 /* Get the word at the required offset. */
8021 word = byte_get (arm_sec->data + word_offset, 4);
8023 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
8024 if (arm_sec->rela == NULL)
8030 /* Look through the relocs to find the one that applies to the provided offset. */
8032 for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
8034 bfd_vma prelval, offset;
8036 if (rp->r_offset > word_offset && !wrapped)
8041 if (rp->r_offset > word_offset)
8044 if (rp->r_offset & 3)
8046 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
8047 (unsigned long) rp->r_offset);
8051 if (rp->r_offset < word_offset)
8054 /* PR 17531: file: 027-161405-0.004 */
8055 if (aux->symtab == NULL)
8058 if (arm_sec->rel_type == SHT_REL)
8060 offset = word & 0x7fffffff;
8061 if (offset & 0x40000000)
8062 offset |= ~ (bfd_vma) 0x7fffffff;
8064 else if (arm_sec->rel_type == SHT_RELA)
8065 offset = rp->r_addend;
8068 error (_("Unknown section relocation type %d encountered\n"),
8073 /* PR 17531 file: 027-1241568-0.004. */
8074 if (ELF32_R_SYM (rp->r_info) >= aux->nsyms)
8076 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
8077 (unsigned long) ELF32_R_SYM (rp->r_info), aux->nsyms);
8081 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
8082 offset += sym->st_value;
8083 prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
8085 /* Check that we are processing the expected reloc type. */
8086 if (elf_header.e_machine == EM_ARM)
8088 relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
8089 if (relname == NULL)
8091 warn (_("Skipping unknown ARM relocation type: %d\n"),
8092 (int) ELF32_R_TYPE (rp->r_info));
8096 if (streq (relname, "R_ARM_NONE"))
8099 if (! streq (relname, "R_ARM_PREL31"))
8101 warn (_("Skipping unexpected ARM relocation type %s\n"), relname);
8105 else if (elf_header.e_machine == EM_TI_C6000)
8107 relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
8108 if (relname == NULL)
8110 warn (_("Skipping unknown C6000 relocation type: %d\n"),
8111 (int) ELF32_R_TYPE (rp->r_info));
8115 if (streq (relname, "R_C6000_NONE"))
8118 if (! streq (relname, "R_C6000_PREL31"))
8120 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname);
8128 /* This function currently only supports ARM and TI unwinders. */
8129 warn (_("Only TI and ARM unwinders are currently supported\n"));
8133 word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
8134 addr->section = sym->st_shndx;
8135 addr->offset = offset;
8138 * sym_name = sym->st_name;
8143 arm_sec->next_rela = rp;
8148 static const char *tic6x_unwind_regnames[16] =
8150 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
8151 "A14", "A13", "A12", "A11", "A10",
8152 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
8156 decode_tic6x_unwind_regmask (unsigned int mask)
8160 for (i = 12; mask; mask >>= 1, i--)
8164 fputs (tic6x_unwind_regnames[i], stdout);
8166 fputs (", ", stdout);
8172 if (remaining == 0 && more_words) \
8175 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
8176 data_offset, & word, & addr, NULL)) \
8182 #define GET_OP(OP) \
8187 (OP) = word >> 24; \
8192 printf (_("[Truncated opcode]\n")); \
8195 printf ("0x%02x ", OP)
8198 decode_arm_unwind_bytecode (struct arm_unw_aux_info * aux,
8200 unsigned int remaining,
8201 unsigned int more_words,
8202 bfd_vma data_offset,
8203 Elf_Internal_Shdr * data_sec,
8204 struct arm_section * data_arm_sec)
8206 struct absaddr addr;
8207 bfd_boolean res = TRUE;
8209 /* Decode the unwinding instructions. */
8212 unsigned int op, op2;
8221 printf (" 0x%02x ", op);
8223 if ((op & 0xc0) == 0x00)
8225 int offset = ((op & 0x3f) << 2) + 4;
8227 printf (" vsp = vsp + %d", offset);
8229 else if ((op & 0xc0) == 0x40)
8231 int offset = ((op & 0x3f) << 2) + 4;
8233 printf (" vsp = vsp - %d", offset);
8235 else if ((op & 0xf0) == 0x80)
8238 if (op == 0x80 && op2 == 0)
8239 printf (_("Refuse to unwind"));
8242 unsigned int mask = ((op & 0x0f) << 8) | op2;
8243 bfd_boolean first = TRUE;
8247 for (i = 0; i < 12; i++)
8248 if (mask & (1 << i))
8254 printf ("r%d", 4 + i);
8259 else if ((op & 0xf0) == 0x90)
8261 if (op == 0x9d || op == 0x9f)
8262 printf (_(" [Reserved]"));
8264 printf (" vsp = r%d", op & 0x0f);
8266 else if ((op & 0xf0) == 0xa0)
8268 int end = 4 + (op & 0x07);
8269 bfd_boolean first = TRUE;
8273 for (i = 4; i <= end; i++)
8289 else if (op == 0xb0)
8290 printf (_(" finish"));
8291 else if (op == 0xb1)
8294 if (op2 == 0 || (op2 & 0xf0) != 0)
8295 printf (_("[Spare]"));
8298 unsigned int mask = op2 & 0x0f;
8299 bfd_boolean first = TRUE;
8303 for (i = 0; i < 12; i++)
8304 if (mask & (1 << i))
8315 else if (op == 0xb2)
8317 unsigned char buf[9];
8318 unsigned int i, len;
8319 unsigned long offset;
8321 for (i = 0; i < sizeof (buf); i++)
8324 if ((buf[i] & 0x80) == 0)
8327 if (i == sizeof (buf))
8329 error (_("corrupt change to vsp"));
8334 offset = read_uleb128 (buf, &len, buf + i + 1);
8335 assert (len == i + 1);
8336 offset = offset * 4 + 0x204;
8337 printf ("vsp = vsp + %ld", offset);
8340 else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
8342 unsigned int first, last;
8349 printf ("pop {D%d", first);
8351 printf ("-D%d", first + last);
8354 else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
8356 unsigned int count = op & 0x07;
8360 printf ("-D%d", 8 + count);
8363 else if (op >= 0xc0 && op <= 0xc5)
8365 unsigned int count = op & 0x07;
8367 printf (" pop {wR10");
8369 printf ("-wR%d", 10 + count);
8372 else if (op == 0xc6)
8374 unsigned int first, last;
8379 printf ("pop {wR%d", first);
8381 printf ("-wR%d", first + last);
8384 else if (op == 0xc7)
8387 if (op2 == 0 || (op2 & 0xf0) != 0)
8388 printf (_("[Spare]"));
8391 unsigned int mask = op2 & 0x0f;
8392 bfd_boolean first = TRUE;
8396 for (i = 0; i < 4; i++)
8397 if (mask & (1 << i))
8403 printf ("wCGR%d", i);
8410 printf (_(" [unsupported opcode]"));
8421 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info * aux,
8423 unsigned int remaining,
8424 unsigned int more_words,
8425 bfd_vma data_offset,
8426 Elf_Internal_Shdr * data_sec,
8427 struct arm_section * data_arm_sec)
8429 struct absaddr addr;
8431 /* Decode the unwinding instructions. */
8434 unsigned int op, op2;
8443 printf (" 0x%02x ", op);
8445 if ((op & 0xc0) == 0x00)
8447 int offset = ((op & 0x3f) << 3) + 8;
8448 printf (" sp = sp + %d", offset);
8450 else if ((op & 0xc0) == 0x80)
8453 if (op == 0x80 && op2 == 0)
8454 printf (_("Refuse to unwind"));
8457 unsigned int mask = ((op & 0x1f) << 8) | op2;
8459 printf ("pop compact {");
8463 decode_tic6x_unwind_regmask (mask);
8467 else if ((op & 0xf0) == 0xc0)
8475 unsigned int offset;
8479 /* Scan entire instruction first so that GET_OP output is not
8480 interleaved with disassembly. */
8482 for (i = 0; nregs < (op & 0xf); i++)
8488 regpos[nregs].offset = i * 2;
8489 regpos[nregs].reg = reg;
8496 regpos[nregs].offset = i * 2 + 1;
8497 regpos[nregs].reg = reg;
8502 printf (_("pop frame {"));
8504 for (i = i * 2; i > 0; i--)
8506 if (regpos[reg].offset == i - 1)
8508 name = tic6x_unwind_regnames[regpos[reg].reg];
8515 fputs (name, stdout);
8522 else if (op == 0xd0)
8523 printf (" MOV FP, SP");
8524 else if (op == 0xd1)
8525 printf (" __c6xabi_pop_rts");
8526 else if (op == 0xd2)
8528 unsigned char buf[9];
8529 unsigned int i, len;
8530 unsigned long offset;
8532 for (i = 0; i < sizeof (buf); i++)
8535 if ((buf[i] & 0x80) == 0)
8538 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
8539 if (i == sizeof (buf))
8541 warn (_("Corrupt stack pointer adjustment detected\n"));
8545 offset = read_uleb128 (buf, &len, buf + i + 1);
8546 assert (len == i + 1);
8547 offset = offset * 8 + 0x408;
8548 printf (_("sp = sp + %ld"), offset);
8550 else if ((op & 0xf0) == 0xe0)
8552 if ((op & 0x0f) == 7)
8555 printf (" MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
8559 printf (_(" [unsupported opcode]"));
8568 arm_expand_prel31 (bfd_vma word, bfd_vma where)
8572 offset = word & 0x7fffffff;
8573 if (offset & 0x40000000)
8574 offset |= ~ (bfd_vma) 0x7fffffff;
8576 if (elf_header.e_machine == EM_TI_C6000)
8579 return offset + where;
8583 decode_arm_unwind (struct arm_unw_aux_info * aux,
8585 unsigned int remaining,
8586 bfd_vma data_offset,
8587 Elf_Internal_Shdr * data_sec,
8588 struct arm_section * data_arm_sec)
8591 unsigned int more_words = 0;
8592 struct absaddr addr;
8593 bfd_vma sym_name = (bfd_vma) -1;
8594 bfd_boolean res = FALSE;
8598 /* Fetch the first word.
8599 Note - when decoding an object file the address extracted
8600 here will always be 0. So we also pass in the sym_name
8601 parameter so that we can find the symbol associated with
8602 the personality routine. */
8603 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, data_offset,
8604 & word, & addr, & sym_name))
8610 if ((word & 0x80000000) == 0)
8612 /* Expand prel31 for personality routine. */
8614 const char *procname;
8616 fn = arm_expand_prel31 (word, data_sec->sh_addr + data_offset);
8617 printf (_(" Personality routine: "));
8619 && addr.section == SHN_UNDEF && addr.offset == 0
8620 && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
8622 procname = aux->strtab + sym_name;
8623 print_vma (fn, PREFIX_HEX);
8626 fputs (" <", stdout);
8627 fputs (procname, stdout);
8628 fputc ('>', stdout);
8632 procname = arm_print_vma_and_name (aux, fn, addr);
8633 fputc ('\n', stdout);
8635 /* The GCC personality routines use the standard compact
8636 encoding, starting with one byte giving the number of
8638 if (procname != NULL
8639 && (const_strneq (procname, "__gcc_personality_v0")
8640 || const_strneq (procname, "__gxx_personality_v0")
8641 || const_strneq (procname, "__gcj_personality_v0")
8642 || const_strneq (procname, "__gnu_objc_personality_v0")))
8649 printf (_(" [Truncated data]\n"));
8652 more_words = word >> 24;
8662 /* ARM EHABI Section 6.3:
8664 An exception-handling table entry for the compact model looks like:
8668 1 0 index Data for personalityRoutine[index] */
8670 if (elf_header.e_machine == EM_ARM
8671 && (word & 0x70000000))
8673 warn (_("Corrupt ARM compact model table entry: %x \n"), word);
8677 per_index = (word >> 24) & 0x7f;
8678 printf (_(" Compact model index: %d\n"), per_index);
8685 else if (per_index < 3)
8687 more_words = (word >> 16) & 0xff;
8693 switch (elf_header.e_machine)
8698 if (! decode_arm_unwind_bytecode (aux, word, remaining, more_words,
8699 data_offset, data_sec, data_arm_sec))
8704 warn (_("Unknown ARM compact model index encountered\n"));
8705 printf (_(" [reserved]\n"));
8713 if (! decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
8714 data_offset, data_sec, data_arm_sec))
8717 else if (per_index < 5)
8719 if (((word >> 17) & 0x7f) == 0x7f)
8720 printf (_(" Restore stack from frame pointer\n"));
8722 printf (_(" Stack increment %d\n"), (word >> 14) & 0x1fc);
8723 printf (_(" Registers restored: "));
8725 printf (" (compact) ");
8726 decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
8728 printf (_(" Return register: %s\n"),
8729 tic6x_unwind_regnames[word & 0xf]);
8732 printf (_(" [reserved (%d)]\n"), per_index);
8736 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
8737 elf_header.e_machine);
8741 /* Decode the descriptors. Not implemented. */
8747 dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
8749 struct arm_section exidx_arm_sec, extab_arm_sec;
8750 unsigned int i, exidx_len;
8751 unsigned long j, nfuns;
8752 bfd_boolean res = TRUE;
8754 memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
8755 memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
8756 exidx_len = exidx_sec->sh_size / 8;
8758 aux->funtab = xmalloc (aux->nsyms * sizeof (Elf_Internal_Sym));
8759 for (nfuns = 0, j = 0; j < aux->nsyms; j++)
8760 if (aux->symtab[j].st_value && ELF_ST_TYPE (aux->symtab[j].st_info) == STT_FUNC)
8761 aux->funtab[nfuns++] = aux->symtab[j];
8763 qsort (aux->funtab, aux->nfuns, sizeof (Elf_Internal_Sym), symcmp);
8765 for (i = 0; i < exidx_len; i++)
8767 unsigned int exidx_fn, exidx_entry;
8768 struct absaddr fn_addr, entry_addr;
8771 fputc ('\n', stdout);
8773 if (! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8774 8 * i, & exidx_fn, & fn_addr, NULL)
8775 || ! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8776 8 * i + 4, & exidx_entry, & entry_addr, NULL))
8779 arm_free_section (& exidx_arm_sec);
8780 arm_free_section (& extab_arm_sec);
8784 /* ARM EHABI, Section 5:
8785 An index table entry consists of 2 words.
8786 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
8787 if (exidx_fn & 0x80000000)
8789 warn (_("corrupt index table entry: %x\n"), exidx_fn);
8793 fn = arm_expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
8795 arm_print_vma_and_name (aux, fn, fn_addr);
8796 fputs (": ", stdout);
8798 if (exidx_entry == 1)
8800 print_vma (exidx_entry, PREFIX_HEX);
8801 fputs (" [cantunwind]\n", stdout);
8803 else if (exidx_entry & 0x80000000)
8805 print_vma (exidx_entry, PREFIX_HEX);
8806 fputc ('\n', stdout);
8807 decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
8811 bfd_vma table, table_offset = 0;
8812 Elf_Internal_Shdr *table_sec;
8814 fputs ("@", stdout);
8815 table = arm_expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
8816 print_vma (table, PREFIX_HEX);
8819 /* Locate the matching .ARM.extab. */
8820 if (entry_addr.section != SHN_UNDEF
8821 && entry_addr.section < elf_header.e_shnum)
8823 table_sec = section_headers + entry_addr.section;
8824 table_offset = entry_addr.offset;
8826 if (table_offset > table_sec->sh_size
8827 || ((bfd_signed_vma) table_offset) < 0)
8829 warn (_("Unwind entry contains corrupt offset (0x%lx) into section %s\n"),
8830 (unsigned long) table_offset,
8831 printable_section_name (table_sec));
8838 table_sec = find_section_by_address (table);
8839 if (table_sec != NULL)
8840 table_offset = table - table_sec->sh_addr;
8843 if (table_sec == NULL)
8845 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
8846 (unsigned long) table);
8851 if (! decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
8860 arm_free_section (&exidx_arm_sec);
8861 arm_free_section (&extab_arm_sec);
8866 /* Used for both ARM and C6X unwinding tables. */
8869 arm_process_unwind (FILE *file)
8871 struct arm_unw_aux_info aux;
8872 Elf_Internal_Shdr *unwsec = NULL;
8873 Elf_Internal_Shdr *strsec;
8874 Elf_Internal_Shdr *sec;
8876 unsigned int sec_type;
8877 bfd_boolean res = TRUE;
8879 switch (elf_header.e_machine)
8882 sec_type = SHT_ARM_EXIDX;
8886 sec_type = SHT_C6000_UNWIND;
8890 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
8891 elf_header.e_machine);
8895 if (string_table == NULL)
8898 memset (& aux, 0, sizeof (aux));
8901 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
8903 if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
8905 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
8907 strsec = section_headers + sec->sh_link;
8909 /* PR binutils/17531 file: 011-12666-0.004. */
8910 if (aux.strtab != NULL)
8912 error (_("Multiple string tables found in file.\n"));
8916 aux.strtab = get_data (NULL, file, strsec->sh_offset,
8917 1, strsec->sh_size, _("string table"));
8918 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
8920 else if (sec->sh_type == sec_type)
8925 printf (_("\nThere are no unwind sections in this file.\n"));
8927 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
8929 if (sec->sh_type == sec_type)
8931 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
8932 printable_section_name (sec),
8933 (unsigned long) sec->sh_offset,
8934 (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
8936 if (! dump_arm_unwind (&aux, sec))
8944 free ((char *) aux.strtab);
8950 process_unwind (FILE * file)
8952 struct unwind_handler
8954 unsigned int machtype;
8955 bfd_boolean (* handler)(FILE *);
8958 { EM_ARM, arm_process_unwind },
8959 { EM_IA_64, ia64_process_unwind },
8960 { EM_PARISC, hppa_process_unwind },
8961 { EM_TI_C6000, arm_process_unwind },
8969 for (i = 0; handlers[i].handler != NULL; i++)
8970 if (elf_header.e_machine == handlers[i].machtype)
8971 return handlers[i].handler (file);
8973 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
8974 get_machine_name (elf_header.e_machine));
8979 dynamic_section_mips_val (Elf_Internal_Dyn * entry)
8981 switch (entry->d_tag)
8984 if (entry->d_un.d_val == 0)
8988 static const char * opts[] =
8990 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
8991 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
8992 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
8993 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
8997 bfd_boolean first = TRUE;
8999 for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
9000 if (entry->d_un.d_val & (1 << cnt))
9002 printf ("%s%s", first ? "" : " ", opts[cnt]);
9008 case DT_MIPS_IVERSION:
9009 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9010 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
9014 sprintf_vma (buf, entry->d_un.d_ptr);
9015 /* Note: coded this way so that there is a single string for translation. */
9016 printf (_("<corrupt: %s>"), buf);
9020 case DT_MIPS_TIME_STAMP:
9024 time_t atime = entry->d_un.d_val;
9026 tmp = gmtime (&atime);
9027 /* PR 17531: file: 6accc532. */
9029 snprintf (timebuf, sizeof (timebuf), _("<corrupt>"));
9031 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
9032 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9033 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
9034 printf (_("Time Stamp: %s"), timebuf);
9038 case DT_MIPS_RLD_VERSION:
9039 case DT_MIPS_LOCAL_GOTNO:
9040 case DT_MIPS_CONFLICTNO:
9041 case DT_MIPS_LIBLISTNO:
9042 case DT_MIPS_SYMTABNO:
9043 case DT_MIPS_UNREFEXTNO:
9044 case DT_MIPS_HIPAGENO:
9045 case DT_MIPS_DELTA_CLASS_NO:
9046 case DT_MIPS_DELTA_INSTANCE_NO:
9047 case DT_MIPS_DELTA_RELOC_NO:
9048 case DT_MIPS_DELTA_SYM_NO:
9049 case DT_MIPS_DELTA_CLASSSYM_NO:
9050 case DT_MIPS_COMPACT_SIZE:
9051 print_vma (entry->d_un.d_val, DEC);
9055 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9061 dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
9063 switch (entry->d_tag)
9065 case DT_HP_DLD_FLAGS:
9074 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
9075 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
9076 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
9077 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
9078 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
9079 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
9080 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
9081 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
9082 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
9083 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
9084 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
9085 { DT_HP_GST, "HP_GST" },
9086 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
9087 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
9088 { DT_HP_NODELETE, "HP_NODELETE" },
9089 { DT_HP_GROUP, "HP_GROUP" },
9090 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
9092 bfd_boolean first = TRUE;
9094 bfd_vma val = entry->d_un.d_val;
9096 for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
9097 if (val & flags[cnt].bit)
9101 fputs (flags[cnt].str, stdout);
9103 val ^= flags[cnt].bit;
9106 if (val != 0 || first)
9110 print_vma (val, HEX);
9116 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9124 /* VMS vs Unix time offset and factor. */
9126 #define VMS_EPOCH_OFFSET 35067168000000000LL
9127 #define VMS_GRANULARITY_FACTOR 10000000
9129 /* Display a VMS time in a human readable format. */
9132 print_vms_time (bfd_int64_t vmstime)
9137 unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
9138 tm = gmtime (&unxtime);
9139 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
9140 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
9141 tm->tm_hour, tm->tm_min, tm->tm_sec);
9146 dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
9148 switch (entry->d_tag)
9150 case DT_IA_64_PLT_RESERVE:
9151 /* First 3 slots reserved. */
9152 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9154 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
9157 case DT_IA_64_VMS_LINKTIME:
9159 print_vms_time (entry->d_un.d_val);
9163 case DT_IA_64_VMS_LNKFLAGS:
9164 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9165 if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
9166 printf (" CALL_DEBUG");
9167 if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
9168 printf (" NOP0BUFS");
9169 if (entry->d_un.d_val & VMS_LF_P0IMAGE)
9170 printf (" P0IMAGE");
9171 if (entry->d_un.d_val & VMS_LF_MKTHREADS)
9172 printf (" MKTHREADS");
9173 if (entry->d_un.d_val & VMS_LF_UPCALLS)
9174 printf (" UPCALLS");
9175 if (entry->d_un.d_val & VMS_LF_IMGSTA)
9177 if (entry->d_un.d_val & VMS_LF_INITIALIZE)
9178 printf (" INITIALIZE");
9179 if (entry->d_un.d_val & VMS_LF_MAIN)
9181 if (entry->d_un.d_val & VMS_LF_EXE_INIT)
9182 printf (" EXE_INIT");
9183 if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
9184 printf (" TBK_IN_IMG");
9185 if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
9186 printf (" DBG_IN_IMG");
9187 if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
9188 printf (" TBK_IN_DSF");
9189 if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
9190 printf (" DBG_IN_DSF");
9191 if (entry->d_un.d_val & VMS_LF_SIGNATURES)
9192 printf (" SIGNATURES");
9193 if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
9194 printf (" REL_SEG_OFF");
9198 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
9205 get_32bit_dynamic_section (FILE * file)
9207 Elf32_External_Dyn * edyn;
9208 Elf32_External_Dyn * ext;
9209 Elf_Internal_Dyn * entry;
9211 edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
9212 dynamic_size, _("dynamic section"));
9216 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9217 might not have the luxury of section headers. Look for the DT_NULL
9218 terminator to determine the number of entries. */
9219 for (ext = edyn, dynamic_nent = 0;
9220 (char *) (ext + 1) <= (char *) edyn + dynamic_size;
9224 if (BYTE_GET (ext->d_tag) == DT_NULL)
9228 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
9230 if (dynamic_section == NULL)
9232 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9233 (unsigned long) dynamic_nent);
9238 for (ext = edyn, entry = dynamic_section;
9239 entry < dynamic_section + dynamic_nent;
9242 entry->d_tag = BYTE_GET (ext->d_tag);
9243 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
9252 get_64bit_dynamic_section (FILE * file)
9254 Elf64_External_Dyn * edyn;
9255 Elf64_External_Dyn * ext;
9256 Elf_Internal_Dyn * entry;
9258 /* Read in the data. */
9259 edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
9260 dynamic_size, _("dynamic section"));
9264 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
9265 might not have the luxury of section headers. Look for the DT_NULL
9266 terminator to determine the number of entries. */
9267 for (ext = edyn, dynamic_nent = 0;
9268 /* PR 17533 file: 033-67080-0.004 - do not read past end of buffer. */
9269 (char *) (ext + 1) <= (char *) edyn + dynamic_size;
9273 if (BYTE_GET (ext->d_tag) == DT_NULL)
9277 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
9279 if (dynamic_section == NULL)
9281 error (_("Out of memory allocating space for %lu dynamic entries\n"),
9282 (unsigned long) dynamic_nent);
9287 /* Convert from external to internal formats. */
9288 for (ext = edyn, entry = dynamic_section;
9289 entry < dynamic_section + dynamic_nent;
9292 entry->d_tag = BYTE_GET (ext->d_tag);
9293 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
9302 print_dynamic_flags (bfd_vma flags)
9304 bfd_boolean first = TRUE;
9310 flag = flags & - flags;
9320 case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
9321 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
9322 case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
9323 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
9324 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
9325 default: fputs (_("unknown"), stdout); break;
9331 /* Parse and display the contents of the dynamic section. */
9334 process_dynamic_section (FILE * file)
9336 Elf_Internal_Dyn * entry;
9338 if (dynamic_size == 0)
9341 printf (_("\nThere is no dynamic section in this file.\n"));
9348 if (! get_32bit_dynamic_section (file))
9353 if (! get_64bit_dynamic_section (file))
9357 /* Find the appropriate symbol table. */
9358 if (dynamic_symbols == NULL)
9360 for (entry = dynamic_section;
9361 entry < dynamic_section + dynamic_nent;
9364 Elf_Internal_Shdr section;
9366 if (entry->d_tag != DT_SYMTAB)
9369 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
9371 /* Since we do not know how big the symbol table is,
9372 we default to reading in the entire file (!) and
9373 processing that. This is overkill, I know, but it
9375 section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
9377 if (archive_file_offset != 0)
9378 section.sh_size = archive_file_size - section.sh_offset;
9381 if (fseek (file, 0, SEEK_END))
9382 error (_("Unable to seek to end of file!\n"));
9384 section.sh_size = ftell (file) - section.sh_offset;
9388 section.sh_entsize = sizeof (Elf32_External_Sym);
9390 section.sh_entsize = sizeof (Elf64_External_Sym);
9391 section.sh_name = string_table_length;
9393 dynamic_symbols = GET_ELF_SYMBOLS (file, §ion, & num_dynamic_syms);
9394 if (num_dynamic_syms < 1)
9396 error (_("Unable to determine the number of symbols to load\n"));
9402 /* Similarly find a string table. */
9403 if (dynamic_strings == NULL)
9405 for (entry = dynamic_section;
9406 entry < dynamic_section + dynamic_nent;
9409 unsigned long offset;
9412 if (entry->d_tag != DT_STRTAB)
9415 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
9417 /* Since we do not know how big the string table is,
9418 we default to reading in the entire file (!) and
9419 processing that. This is overkill, I know, but it
9422 offset = offset_from_vma (file, entry->d_un.d_val, 0);
9424 if (archive_file_offset != 0)
9425 str_tab_len = archive_file_size - offset;
9428 if (fseek (file, 0, SEEK_END))
9429 error (_("Unable to seek to end of file\n"));
9430 str_tab_len = ftell (file) - offset;
9433 if (str_tab_len < 1)
9436 (_("Unable to determine the length of the dynamic string table\n"));
9440 dynamic_strings = (char *) get_data (NULL, file, offset, 1,
9442 _("dynamic string table"));
9443 dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
9448 /* And find the syminfo section if available. */
9449 if (dynamic_syminfo == NULL)
9451 unsigned long syminsz = 0;
9453 for (entry = dynamic_section;
9454 entry < dynamic_section + dynamic_nent;
9457 if (entry->d_tag == DT_SYMINENT)
9459 /* Note: these braces are necessary to avoid a syntax
9460 error from the SunOS4 C compiler. */
9461 /* PR binutils/17531: A corrupt file can trigger this test.
9462 So do not use an assert, instead generate an error message. */
9463 if (sizeof (Elf_External_Syminfo) != entry->d_un.d_val)
9464 error (_("Bad value (%d) for SYMINENT entry\n"),
9465 (int) entry->d_un.d_val);
9467 else if (entry->d_tag == DT_SYMINSZ)
9468 syminsz = entry->d_un.d_val;
9469 else if (entry->d_tag == DT_SYMINFO)
9470 dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
9474 if (dynamic_syminfo_offset != 0 && syminsz != 0)
9476 Elf_External_Syminfo * extsyminfo;
9477 Elf_External_Syminfo * extsym;
9478 Elf_Internal_Syminfo * syminfo;
9480 /* There is a syminfo section. Read the data. */
9481 extsyminfo = (Elf_External_Syminfo *)
9482 get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
9483 _("symbol information"));
9487 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
9488 if (dynamic_syminfo == NULL)
9490 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
9491 (unsigned long) syminsz);
9495 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
9496 for (syminfo = dynamic_syminfo, extsym = extsyminfo;
9497 syminfo < dynamic_syminfo + dynamic_syminfo_nent;
9498 ++syminfo, ++extsym)
9500 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
9501 syminfo->si_flags = BYTE_GET (extsym->si_flags);
9508 if (do_dynamic && dynamic_addr)
9509 printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
9510 dynamic_addr, (unsigned long) dynamic_nent);
9512 printf (_(" Tag Type Name/Value\n"));
9514 for (entry = dynamic_section;
9515 entry < dynamic_section + dynamic_nent;
9523 print_vma (entry->d_tag, FULL_HEX);
9524 dtype = get_dynamic_type (entry->d_tag);
9525 printf (" (%s)%*s", dtype,
9526 ((is_32bit_elf ? 27 : 19) - (int) strlen (dtype)), " ");
9529 switch (entry->d_tag)
9533 print_dynamic_flags (entry->d_un.d_val);
9543 switch (entry->d_tag)
9546 printf (_("Auxiliary library"));
9550 printf (_("Filter library"));
9554 printf (_("Configuration file"));
9558 printf (_("Dependency audit library"));
9562 printf (_("Audit library"));
9566 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9567 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
9571 print_vma (entry->d_un.d_val, PREFIX_HEX);
9580 printf (_("Flags:"));
9582 if (entry->d_un.d_val == 0)
9583 printf (_(" None\n"));
9586 unsigned long int val = entry->d_un.d_val;
9588 if (val & DTF_1_PARINIT)
9590 printf (" PARINIT");
9591 val ^= DTF_1_PARINIT;
9593 if (val & DTF_1_CONFEXP)
9595 printf (" CONFEXP");
9596 val ^= DTF_1_CONFEXP;
9599 printf (" %lx", val);
9608 printf (_("Flags:"));
9610 if (entry->d_un.d_val == 0)
9611 printf (_(" None\n"));
9614 unsigned long int val = entry->d_un.d_val;
9616 if (val & DF_P1_LAZYLOAD)
9618 printf (" LAZYLOAD");
9619 val ^= DF_P1_LAZYLOAD;
9621 if (val & DF_P1_GROUPPERM)
9623 printf (" GROUPPERM");
9624 val ^= DF_P1_GROUPPERM;
9627 printf (" %lx", val);
9636 printf (_("Flags:"));
9637 if (entry->d_un.d_val == 0)
9638 printf (_(" None\n"));
9641 unsigned long int val = entry->d_un.d_val;
9648 if (val & DF_1_GLOBAL)
9653 if (val & DF_1_GROUP)
9658 if (val & DF_1_NODELETE)
9660 printf (" NODELETE");
9661 val ^= DF_1_NODELETE;
9663 if (val & DF_1_LOADFLTR)
9665 printf (" LOADFLTR");
9666 val ^= DF_1_LOADFLTR;
9668 if (val & DF_1_INITFIRST)
9670 printf (" INITFIRST");
9671 val ^= DF_1_INITFIRST;
9673 if (val & DF_1_NOOPEN)
9678 if (val & DF_1_ORIGIN)
9683 if (val & DF_1_DIRECT)
9688 if (val & DF_1_TRANS)
9693 if (val & DF_1_INTERPOSE)
9695 printf (" INTERPOSE");
9696 val ^= DF_1_INTERPOSE;
9698 if (val & DF_1_NODEFLIB)
9700 printf (" NODEFLIB");
9701 val ^= DF_1_NODEFLIB;
9703 if (val & DF_1_NODUMP)
9708 if (val & DF_1_CONFALT)
9710 printf (" CONFALT");
9711 val ^= DF_1_CONFALT;
9713 if (val & DF_1_ENDFILTEE)
9715 printf (" ENDFILTEE");
9716 val ^= DF_1_ENDFILTEE;
9718 if (val & DF_1_DISPRELDNE)
9720 printf (" DISPRELDNE");
9721 val ^= DF_1_DISPRELDNE;
9723 if (val & DF_1_DISPRELPND)
9725 printf (" DISPRELPND");
9726 val ^= DF_1_DISPRELPND;
9728 if (val & DF_1_NODIRECT)
9730 printf (" NODIRECT");
9731 val ^= DF_1_NODIRECT;
9733 if (val & DF_1_IGNMULDEF)
9735 printf (" IGNMULDEF");
9736 val ^= DF_1_IGNMULDEF;
9738 if (val & DF_1_NOKSYMS)
9740 printf (" NOKSYMS");
9741 val ^= DF_1_NOKSYMS;
9743 if (val & DF_1_NOHDR)
9748 if (val & DF_1_EDITED)
9753 if (val & DF_1_NORELOC)
9755 printf (" NORELOC");
9756 val ^= DF_1_NORELOC;
9758 if (val & DF_1_SYMINTPOSE)
9760 printf (" SYMINTPOSE");
9761 val ^= DF_1_SYMINTPOSE;
9763 if (val & DF_1_GLOBAUDIT)
9765 printf (" GLOBAUDIT");
9766 val ^= DF_1_GLOBAUDIT;
9768 if (val & DF_1_SINGLETON)
9770 printf (" SINGLETON");
9771 val ^= DF_1_SINGLETON;
9773 if (val & DF_1_STUB)
9784 printf (" %lx", val);
9791 dynamic_info[entry->d_tag] = entry->d_un.d_val;
9793 puts (get_dynamic_type (entry->d_un.d_val));
9813 dynamic_info[entry->d_tag] = entry->d_un.d_val;
9819 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9820 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
9826 switch (entry->d_tag)
9829 printf (_("Shared library: [%s]"), name);
9831 if (streq (name, program_interpreter))
9832 printf (_(" program interpreter"));
9836 printf (_("Library soname: [%s]"), name);
9840 printf (_("Library rpath: [%s]"), name);
9844 printf (_("Library runpath: [%s]"), name);
9848 print_vma (entry->d_un.d_val, PREFIX_HEX);
9853 print_vma (entry->d_un.d_val, PREFIX_HEX);
9866 dynamic_info[entry->d_tag] = entry->d_un.d_val;
9871 case DT_INIT_ARRAYSZ:
9872 case DT_FINI_ARRAYSZ:
9873 case DT_GNU_CONFLICTSZ:
9874 case DT_GNU_LIBLISTSZ:
9877 print_vma (entry->d_un.d_val, UNSIGNED);
9878 printf (_(" (bytes)\n"));
9888 print_vma (entry->d_un.d_val, UNSIGNED);
9901 if (entry->d_tag == DT_USED
9902 && VALID_DYNAMIC_NAME (entry->d_un.d_val))
9904 char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
9908 printf (_("Not needed object: [%s]\n"), name);
9913 print_vma (entry->d_un.d_val, PREFIX_HEX);
9919 /* The value of this entry is ignored. */
9924 case DT_GNU_PRELINKED:
9928 time_t atime = entry->d_un.d_val;
9930 tmp = gmtime (&atime);
9931 /* PR 17533 file: 041-1244816-0.004. */
9933 printf (_("<corrupt time val: %lx"),
9934 (unsigned long) atime);
9936 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
9937 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9938 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
9944 dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
9947 print_vma (entry->d_un.d_val, PREFIX_HEX);
9953 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
9954 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
9959 switch (elf_header.e_machine)
9962 case EM_MIPS_RS3_LE:
9963 dynamic_section_mips_val (entry);
9966 dynamic_section_parisc_val (entry);
9969 dynamic_section_ia64_val (entry);
9972 print_vma (entry->d_un.d_val, PREFIX_HEX);
9984 get_ver_flags (unsigned int flags)
9986 static char buff[32];
9993 if (flags & VER_FLG_BASE)
9994 strcat (buff, "BASE");
9996 if (flags & VER_FLG_WEAK)
9998 if (flags & VER_FLG_BASE)
9999 strcat (buff, " | ");
10001 strcat (buff, "WEAK");
10004 if (flags & VER_FLG_INFO)
10006 if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
10007 strcat (buff, " | ");
10009 strcat (buff, "INFO");
10012 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
10014 if (flags & (VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
10015 strcat (buff, " | ");
10017 strcat (buff, _("<unknown>"));
10023 /* Display the contents of the version sections. */
10026 process_version_sections (FILE * file)
10028 Elf_Internal_Shdr * section;
10030 bfd_boolean found = FALSE;
10035 for (i = 0, section = section_headers;
10036 i < elf_header.e_shnum;
10039 switch (section->sh_type)
10041 case SHT_GNU_verdef:
10043 Elf_External_Verdef * edefs;
10051 printf (_("\nVersion definition section '%s' contains %u entries:\n"),
10052 printable_section_name (section),
10055 printf (_(" Addr: 0x"));
10056 printf_vma (section->sh_addr);
10057 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10058 (unsigned long) section->sh_offset, section->sh_link,
10059 printable_section_name_from_index (section->sh_link));
10061 edefs = (Elf_External_Verdef *)
10062 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
10063 _("version definition section"));
10066 endbuf = (char *) edefs + section->sh_size;
10068 /* PR 17531: file: id:000001,src:000172+005151,op:splice,rep:2. */
10069 end = (section->sh_info < section->sh_size
10070 ? section->sh_info : section->sh_size);
10071 for (idx = cnt = 0; cnt < end; ++cnt)
10074 Elf_External_Verdef * edef;
10075 Elf_Internal_Verdef ent;
10076 Elf_External_Verdaux * eaux;
10077 Elf_Internal_Verdaux aux;
10081 /* Check for very large indices. */
10082 if (idx > (size_t) (endbuf - (char *) edefs))
10085 vstart = ((char *) edefs) + idx;
10086 if (vstart + sizeof (*edef) > endbuf)
10089 edef = (Elf_External_Verdef *) vstart;
10091 ent.vd_version = BYTE_GET (edef->vd_version);
10092 ent.vd_flags = BYTE_GET (edef->vd_flags);
10093 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
10094 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
10095 ent.vd_hash = BYTE_GET (edef->vd_hash);
10096 ent.vd_aux = BYTE_GET (edef->vd_aux);
10097 ent.vd_next = BYTE_GET (edef->vd_next);
10099 printf (_(" %#06x: Rev: %d Flags: %s"),
10100 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
10102 printf (_(" Index: %d Cnt: %d "),
10103 ent.vd_ndx, ent.vd_cnt);
10105 /* Check for overflow. */
10106 if (ent.vd_aux + sizeof (* eaux) > (size_t) (endbuf - vstart))
10109 vstart += ent.vd_aux;
10111 eaux = (Elf_External_Verdaux *) vstart;
10113 aux.vda_name = BYTE_GET (eaux->vda_name);
10114 aux.vda_next = BYTE_GET (eaux->vda_next);
10116 if (VALID_DYNAMIC_NAME (aux.vda_name))
10117 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
10119 printf (_("Name index: %ld\n"), aux.vda_name);
10121 isum = idx + ent.vd_aux;
10123 for (j = 1; j < ent.vd_cnt; j++)
10125 /* Check for overflow. */
10126 if (aux.vda_next > (size_t) (endbuf - vstart))
10129 isum += aux.vda_next;
10130 vstart += aux.vda_next;
10132 eaux = (Elf_External_Verdaux *) vstart;
10133 if (vstart + sizeof (*eaux) > endbuf)
10136 aux.vda_name = BYTE_GET (eaux->vda_name);
10137 aux.vda_next = BYTE_GET (eaux->vda_next);
10139 if (VALID_DYNAMIC_NAME (aux.vda_name))
10140 printf (_(" %#06x: Parent %d: %s\n"),
10141 isum, j, GET_DYNAMIC_NAME (aux.vda_name));
10143 printf (_(" %#06x: Parent %d, name index: %ld\n"),
10144 isum, j, aux.vda_name);
10147 if (j < ent.vd_cnt)
10148 printf (_(" Version def aux past end of section\n"));
10151 file: id:000001,src:000172+005151,op:splice,rep:2. */
10152 if (idx + ent.vd_next < idx)
10155 idx += ent.vd_next;
10158 if (cnt < section->sh_info)
10159 printf (_(" Version definition past end of section\n"));
10165 case SHT_GNU_verneed:
10167 Elf_External_Verneed * eneed;
10174 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
10175 printable_section_name (section), section->sh_info);
10177 printf (_(" Addr: 0x"));
10178 printf_vma (section->sh_addr);
10179 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10180 (unsigned long) section->sh_offset, section->sh_link,
10181 printable_section_name_from_index (section->sh_link));
10183 eneed = (Elf_External_Verneed *) get_data (NULL, file,
10184 section->sh_offset, 1,
10186 _("Version Needs section"));
10189 endbuf = (char *) eneed + section->sh_size;
10191 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
10193 Elf_External_Verneed * entry;
10194 Elf_Internal_Verneed ent;
10199 if (idx > (size_t) (endbuf - (char *) eneed))
10202 vstart = ((char *) eneed) + idx;
10203 if (vstart + sizeof (*entry) > endbuf)
10206 entry = (Elf_External_Verneed *) vstart;
10208 ent.vn_version = BYTE_GET (entry->vn_version);
10209 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
10210 ent.vn_file = BYTE_GET (entry->vn_file);
10211 ent.vn_aux = BYTE_GET (entry->vn_aux);
10212 ent.vn_next = BYTE_GET (entry->vn_next);
10214 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
10216 if (VALID_DYNAMIC_NAME (ent.vn_file))
10217 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
10219 printf (_(" File: %lx"), ent.vn_file);
10221 printf (_(" Cnt: %d\n"), ent.vn_cnt);
10223 /* Check for overflow. */
10224 if (ent.vn_aux > (size_t) (endbuf - vstart))
10226 vstart += ent.vn_aux;
10228 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
10230 Elf_External_Vernaux * eaux;
10231 Elf_Internal_Vernaux aux;
10233 if (vstart + sizeof (*eaux) > endbuf)
10235 eaux = (Elf_External_Vernaux *) vstart;
10237 aux.vna_hash = BYTE_GET (eaux->vna_hash);
10238 aux.vna_flags = BYTE_GET (eaux->vna_flags);
10239 aux.vna_other = BYTE_GET (eaux->vna_other);
10240 aux.vna_name = BYTE_GET (eaux->vna_name);
10241 aux.vna_next = BYTE_GET (eaux->vna_next);
10243 if (VALID_DYNAMIC_NAME (aux.vna_name))
10244 printf (_(" %#06x: Name: %s"),
10245 isum, GET_DYNAMIC_NAME (aux.vna_name));
10247 printf (_(" %#06x: Name index: %lx"),
10248 isum, aux.vna_name);
10250 printf (_(" Flags: %s Version: %d\n"),
10251 get_ver_flags (aux.vna_flags), aux.vna_other);
10253 /* Check for overflow. */
10254 if (aux.vna_next > (size_t) (endbuf - vstart)
10255 || (aux.vna_next == 0 && j < ent.vn_cnt - 1))
10257 warn (_("Invalid vna_next field of %lx\n"),
10262 isum += aux.vna_next;
10263 vstart += aux.vna_next;
10266 if (j < ent.vn_cnt)
10267 warn (_("Missing Version Needs auxillary information\n"));
10269 if (ent.vn_next == 0 && cnt < section->sh_info - 1)
10271 warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
10272 cnt = section->sh_info;
10275 idx += ent.vn_next;
10278 if (cnt < section->sh_info)
10279 warn (_("Missing Version Needs information\n"));
10285 case SHT_GNU_versym:
10287 Elf_Internal_Shdr * link_section;
10290 unsigned char * edata;
10291 unsigned short * data;
10293 Elf_Internal_Sym * symbols;
10294 Elf_Internal_Shdr * string_sec;
10295 unsigned long num_syms;
10298 if (section->sh_link >= elf_header.e_shnum)
10301 link_section = section_headers + section->sh_link;
10302 total = section->sh_size / sizeof (Elf_External_Versym);
10304 if (link_section->sh_link >= elf_header.e_shnum)
10309 symbols = GET_ELF_SYMBOLS (file, link_section, & num_syms);
10310 if (symbols == NULL)
10313 string_sec = section_headers + link_section->sh_link;
10315 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
10316 string_sec->sh_size,
10317 _("version string table"));
10324 printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
10325 printable_section_name (section), (unsigned long) total);
10327 printf (_(" Addr: "));
10328 printf_vma (section->sh_addr);
10329 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
10330 (unsigned long) section->sh_offset, section->sh_link,
10331 printable_section_name (link_section));
10333 off = offset_from_vma (file,
10334 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10335 total * sizeof (short));
10336 edata = (unsigned char *) get_data (NULL, file, off, total,
10338 _("version symbol data"));
10346 data = (short unsigned int *) cmalloc (total, sizeof (short));
10348 for (cnt = total; cnt --;)
10349 data[cnt] = byte_get (edata + cnt * sizeof (short),
10354 for (cnt = 0; cnt < total; cnt += 4)
10358 char *invalid = _("*invalid*");
10360 printf (" %03x:", cnt);
10362 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
10363 switch (data[cnt + j])
10366 fputs (_(" 0 (*local*) "), stdout);
10370 fputs (_(" 1 (*global*) "), stdout);
10374 nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
10375 data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
10377 /* If this index value is greater than the size of the symbols
10378 array, break to avoid an out-of-bounds read. */
10379 if ((unsigned long)(cnt + j) >= num_syms)
10381 warn (_("invalid index into symbol array\n"));
10386 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
10388 Elf_Internal_Verneed ivn;
10389 unsigned long offset;
10391 offset = offset_from_vma
10392 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10393 sizeof (Elf_External_Verneed));
10397 Elf_Internal_Vernaux ivna;
10398 Elf_External_Verneed evn;
10399 Elf_External_Vernaux evna;
10400 unsigned long a_off;
10402 if (get_data (&evn, file, offset, sizeof (evn), 1,
10403 _("version need")) == NULL)
10406 ivn.vn_aux = BYTE_GET (evn.vn_aux);
10407 ivn.vn_next = BYTE_GET (evn.vn_next);
10409 a_off = offset + ivn.vn_aux;
10413 if (get_data (&evna, file, a_off, sizeof (evna),
10414 1, _("version need aux (2)")) == NULL)
10417 ivna.vna_other = 0;
10421 ivna.vna_next = BYTE_GET (evna.vna_next);
10422 ivna.vna_other = BYTE_GET (evna.vna_other);
10425 a_off += ivna.vna_next;
10427 while (ivna.vna_other != data[cnt + j]
10428 && ivna.vna_next != 0);
10430 if (ivna.vna_other == data[cnt + j])
10432 ivna.vna_name = BYTE_GET (evna.vna_name);
10434 if (ivna.vna_name >= string_sec->sh_size)
10437 name = strtab + ivna.vna_name;
10441 offset += ivn.vn_next;
10443 while (ivn.vn_next);
10446 if (data[cnt + j] != 0x8001
10447 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10449 Elf_Internal_Verdef ivd;
10450 Elf_External_Verdef evd;
10451 unsigned long offset;
10453 offset = offset_from_vma
10454 (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10459 if (get_data (&evd, file, offset, sizeof (evd), 1,
10460 _("version def")) == NULL)
10463 /* PR 17531: file: 046-1082287-0.004. */
10464 ivd.vd_ndx = (data[cnt + j] & VERSYM_VERSION) + 1;
10469 ivd.vd_next = BYTE_GET (evd.vd_next);
10470 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
10473 offset += ivd.vd_next;
10475 while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
10476 && ivd.vd_next != 0);
10478 if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
10480 Elf_External_Verdaux evda;
10481 Elf_Internal_Verdaux ivda;
10483 ivd.vd_aux = BYTE_GET (evd.vd_aux);
10485 if (get_data (&evda, file,
10486 offset - ivd.vd_next + ivd.vd_aux,
10488 _("version def aux")) == NULL)
10491 ivda.vda_name = BYTE_GET (evda.vda_name);
10493 if (ivda.vda_name >= string_sec->sh_size)
10495 else if (name != NULL && name != invalid)
10496 name = _("*both*");
10498 name = strtab + ivda.vda_name;
10502 nn += printf ("(%s%-*s",
10504 12 - (int) strlen (name),
10508 printf ("%*c", 18 - nn, ' ');
10526 printf (_("\nNo version information found in this file.\n"));
10531 static const char *
10532 get_symbol_binding (unsigned int binding)
10534 static char buff[32];
10538 case STB_LOCAL: return "LOCAL";
10539 case STB_GLOBAL: return "GLOBAL";
10540 case STB_WEAK: return "WEAK";
10542 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
10543 snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
10545 else if (binding >= STB_LOOS && binding <= STB_HIOS)
10547 if (binding == STB_GNU_UNIQUE
10548 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10549 /* GNU is still using the default value 0. */
10550 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10552 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
10555 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
10560 static const char *
10561 get_symbol_type (unsigned int type)
10563 static char buff[32];
10567 case STT_NOTYPE: return "NOTYPE";
10568 case STT_OBJECT: return "OBJECT";
10569 case STT_FUNC: return "FUNC";
10570 case STT_SECTION: return "SECTION";
10571 case STT_FILE: return "FILE";
10572 case STT_COMMON: return "COMMON";
10573 case STT_TLS: return "TLS";
10574 case STT_RELC: return "RELC";
10575 case STT_SRELC: return "SRELC";
10577 if (type >= STT_LOPROC && type <= STT_HIPROC)
10579 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
10580 return "THUMB_FUNC";
10582 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
10585 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
10586 return "PARISC_MILLI";
10588 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
10590 else if (type >= STT_LOOS && type <= STT_HIOS)
10592 if (elf_header.e_machine == EM_PARISC)
10594 if (type == STT_HP_OPAQUE)
10595 return "HP_OPAQUE";
10596 if (type == STT_HP_STUB)
10600 if (type == STT_GNU_IFUNC
10601 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
10602 || elf_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
10603 /* GNU is still using the default value 0. */
10604 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
10607 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
10610 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
10615 static const char *
10616 get_symbol_visibility (unsigned int visibility)
10618 switch (visibility)
10620 case STV_DEFAULT: return "DEFAULT";
10621 case STV_INTERNAL: return "INTERNAL";
10622 case STV_HIDDEN: return "HIDDEN";
10623 case STV_PROTECTED: return "PROTECTED";
10625 error (_("Unrecognized visibility value: %u"), visibility);
10626 return _("<unknown>");
10630 static const char *
10631 get_solaris_symbol_visibility (unsigned int visibility)
10633 switch (visibility)
10635 case 4: return "EXPORTED";
10636 case 5: return "SINGLETON";
10637 case 6: return "ELIMINATE";
10638 default: return get_symbol_visibility (visibility);
10642 static const char *
10643 get_mips_symbol_other (unsigned int other)
10647 case STO_OPTIONAL: return "OPTIONAL";
10648 case STO_MIPS_PLT: return "MIPS PLT";
10649 case STO_MIPS_PIC: return "MIPS PIC";
10650 case STO_MICROMIPS: return "MICROMIPS";
10651 case STO_MICROMIPS | STO_MIPS_PIC: return "MICROMIPS, MIPS PIC";
10652 case STO_MIPS16: return "MIPS16";
10653 default: return NULL;
10657 static const char *
10658 get_ia64_symbol_other (unsigned int other)
10660 if (is_ia64_vms ())
10662 static char res[32];
10666 /* Function types is for images and .STB files only. */
10667 switch (elf_header.e_type)
10671 switch (VMS_ST_FUNC_TYPE (other))
10673 case VMS_SFT_CODE_ADDR:
10674 strcat (res, " CA");
10676 case VMS_SFT_SYMV_IDX:
10677 strcat (res, " VEC");
10680 strcat (res, " FD");
10682 case VMS_SFT_RESERVE:
10683 strcat (res, " RSV");
10686 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
10687 VMS_ST_FUNC_TYPE (other));
10688 strcat (res, " <unknown>");
10695 switch (VMS_ST_LINKAGE (other))
10697 case VMS_STL_IGNORE:
10698 strcat (res, " IGN");
10700 case VMS_STL_RESERVE:
10701 strcat (res, " RSV");
10704 strcat (res, " STD");
10707 strcat (res, " LNK");
10710 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
10711 VMS_ST_LINKAGE (other));
10712 strcat (res, " <unknown>");
10724 static const char *
10725 get_ppc64_symbol_other (unsigned int other)
10727 if (PPC64_LOCAL_ENTRY_OFFSET (other) != 0)
10729 static char buf[32];
10730 snprintf (buf, sizeof buf, _("<localentry>: %d"),
10731 PPC64_LOCAL_ENTRY_OFFSET (other));
10737 static const char *
10738 get_symbol_other (unsigned int other)
10740 const char * result = NULL;
10741 static char buff [32];
10746 switch (elf_header.e_machine)
10749 result = get_mips_symbol_other (other);
10752 result = get_ia64_symbol_other (other);
10755 result = get_ppc64_symbol_other (other);
10765 snprintf (buff, sizeof buff, _("<other>: %x"), other);
10769 static const char *
10770 get_symbol_index_type (unsigned int type)
10772 static char buff[32];
10776 case SHN_UNDEF: return "UND";
10777 case SHN_ABS: return "ABS";
10778 case SHN_COMMON: return "COM";
10780 if (type == SHN_IA_64_ANSI_COMMON
10781 && elf_header.e_machine == EM_IA_64
10782 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
10784 else if ((elf_header.e_machine == EM_X86_64
10785 || elf_header.e_machine == EM_L1OM
10786 || elf_header.e_machine == EM_K1OM)
10787 && type == SHN_X86_64_LCOMMON)
10788 return "LARGE_COM";
10789 else if ((type == SHN_MIPS_SCOMMON
10790 && elf_header.e_machine == EM_MIPS)
10791 || (type == SHN_TIC6X_SCOMMON
10792 && elf_header.e_machine == EM_TI_C6000))
10794 else if (type == SHN_MIPS_SUNDEFINED
10795 && elf_header.e_machine == EM_MIPS)
10797 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
10798 sprintf (buff, "PRC[0x%04x]", type & 0xffff);
10799 else if (type >= SHN_LOOS && type <= SHN_HIOS)
10800 sprintf (buff, "OS [0x%04x]", type & 0xffff);
10801 else if (type >= SHN_LORESERVE)
10802 sprintf (buff, "RSV[0x%04x]", type & 0xffff);
10803 else if (type >= elf_header.e_shnum)
10804 sprintf (buff, _("bad section index[%3d]"), type);
10806 sprintf (buff, "%3d", type);
10814 get_dynamic_data (FILE * file, bfd_size_type number, unsigned int ent_size)
10816 unsigned char * e_data;
10819 /* If the size_t type is smaller than the bfd_size_type, eg because
10820 you are building a 32-bit tool on a 64-bit host, then make sure
10821 that when (number) is cast to (size_t) no information is lost. */
10822 if (sizeof (size_t) < sizeof (bfd_size_type)
10823 && (bfd_size_type) ((size_t) number) != number)
10825 error (_("Size truncation prevents reading %" BFD_VMA_FMT "u"
10826 " elements of size %u\n"),
10831 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
10832 attempting to allocate memory when the read is bound to fail. */
10833 if (ent_size * number > current_file_size)
10835 error (_("Invalid number of dynamic entries: %" BFD_VMA_FMT "u\n"),
10840 e_data = (unsigned char *) cmalloc ((size_t) number, ent_size);
10841 if (e_data == NULL)
10843 error (_("Out of memory reading %" BFD_VMA_FMT "u dynamic entries\n"),
10848 if (fread (e_data, ent_size, (size_t) number, file) != number)
10850 error (_("Unable to read in %" BFD_VMA_FMT "u bytes of dynamic data\n"),
10851 number * ent_size);
10856 i_data = (bfd_vma *) cmalloc ((size_t) number, sizeof (*i_data));
10857 if (i_data == NULL)
10859 error (_("Out of memory allocating space for %" BFD_VMA_FMT "u"
10860 " dynamic entries\n"),
10867 i_data[number] = byte_get (e_data + number * ent_size, ent_size);
10875 print_dynamic_symbol (bfd_vma si, unsigned long hn)
10877 Elf_Internal_Sym * psym;
10880 n = print_vma (si, DEC_5);
10882 fputs (&" "[n], stdout);
10883 printf (" %3lu: ", hn);
10885 if (dynamic_symbols == NULL || si >= num_dynamic_syms)
10887 printf (_("<No info available for dynamic symbol number %lu>\n"),
10888 (unsigned long) si);
10892 psym = dynamic_symbols + si;
10893 print_vma (psym->st_value, LONG_HEX);
10895 print_vma (psym->st_size, DEC_5);
10897 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
10898 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
10900 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
10901 printf (" %-7s", get_solaris_symbol_visibility (psym->st_other));
10904 unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
10906 printf (" %-7s", get_symbol_visibility (vis));
10907 /* Check to see if any other bits in the st_other field are set.
10908 Note - displaying this information disrupts the layout of the
10909 table being generated, but for the moment this case is very
10911 if (psym->st_other ^ vis)
10912 printf (" [%s] ", get_symbol_other (psym->st_other ^ vis));
10915 printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
10916 if (VALID_DYNAMIC_NAME (psym->st_name))
10917 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
10919 printf (_(" <corrupt: %14ld>"), psym->st_name);
10923 static const char *
10924 get_symbol_version_string (FILE * file,
10925 bfd_boolean is_dynsym,
10926 const char * strtab,
10927 unsigned long int strtab_size,
10929 Elf_Internal_Sym * psym,
10930 enum versioned_symbol_info * sym_info,
10931 unsigned short * vna_other)
10933 unsigned char data[2];
10934 unsigned short vers_data;
10935 unsigned long offset;
10938 || version_info[DT_VERSIONTAGIDX (DT_VERSYM)] == 0)
10941 offset = offset_from_vma (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10942 sizeof data + si * sizeof (vers_data));
10944 if (get_data (&data, file, offset + si * sizeof (vers_data),
10945 sizeof (data), 1, _("version data")) == NULL)
10948 vers_data = byte_get (data, 2);
10950 if ((vers_data & VERSYM_HIDDEN) == 0 && vers_data <= 1)
10953 /* Usually we'd only see verdef for defined symbols, and verneed for
10954 undefined symbols. However, symbols defined by the linker in
10955 .dynbss for variables copied from a shared library in order to
10956 avoid text relocations are defined yet have verneed. We could
10957 use a heuristic to detect the special case, for example, check
10958 for verneed first on symbols defined in SHT_NOBITS sections, but
10959 it is simpler and more reliable to just look for both verdef and
10960 verneed. .dynbss might not be mapped to a SHT_NOBITS section. */
10962 if (psym->st_shndx != SHN_UNDEF
10963 && vers_data != 0x8001
10964 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10966 Elf_Internal_Verdef ivd;
10967 Elf_Internal_Verdaux ivda;
10968 Elf_External_Verdaux evda;
10971 off = offset_from_vma (file,
10972 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10973 sizeof (Elf_External_Verdef));
10977 Elf_External_Verdef evd;
10979 if (get_data (&evd, file, off, sizeof (evd), 1,
10980 _("version def")) == NULL)
10988 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
10989 ivd.vd_aux = BYTE_GET (evd.vd_aux);
10990 ivd.vd_next = BYTE_GET (evd.vd_next);
10993 off += ivd.vd_next;
10995 while (ivd.vd_ndx != (vers_data & VERSYM_VERSION) && ivd.vd_next != 0);
10997 if (ivd.vd_ndx == (vers_data & VERSYM_VERSION))
10999 off -= ivd.vd_next;
11002 if (get_data (&evda, file, off, sizeof (evda), 1,
11003 _("version def aux")) != NULL)
11005 ivda.vda_name = BYTE_GET (evda.vda_name);
11007 if (psym->st_name != ivda.vda_name)
11009 *sym_info = ((vers_data & VERSYM_HIDDEN) != 0
11010 ? symbol_hidden : symbol_public);
11011 return (ivda.vda_name < strtab_size
11012 ? strtab + ivda.vda_name : _("<corrupt>"));
11018 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
11020 Elf_External_Verneed evn;
11021 Elf_Internal_Verneed ivn;
11022 Elf_Internal_Vernaux ivna;
11024 offset = offset_from_vma (file,
11025 version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
11029 unsigned long vna_off;
11031 if (get_data (&evn, file, offset, sizeof (evn), 1,
11032 _("version need")) == NULL)
11035 ivna.vna_other = 0;
11040 ivn.vn_aux = BYTE_GET (evn.vn_aux);
11041 ivn.vn_next = BYTE_GET (evn.vn_next);
11043 vna_off = offset + ivn.vn_aux;
11047 Elf_External_Vernaux evna;
11049 if (get_data (&evna, file, vna_off, sizeof (evna), 1,
11050 _("version need aux (3)")) == NULL)
11053 ivna.vna_other = 0;
11058 ivna.vna_other = BYTE_GET (evna.vna_other);
11059 ivna.vna_next = BYTE_GET (evna.vna_next);
11060 ivna.vna_name = BYTE_GET (evna.vna_name);
11063 vna_off += ivna.vna_next;
11065 while (ivna.vna_other != vers_data && ivna.vna_next != 0);
11067 if (ivna.vna_other == vers_data)
11070 offset += ivn.vn_next;
11072 while (ivn.vn_next != 0);
11074 if (ivna.vna_other == vers_data)
11076 *sym_info = symbol_undefined;
11077 *vna_other = ivna.vna_other;
11078 return (ivna.vna_name < strtab_size
11079 ? strtab + ivna.vna_name : _("<corrupt>"));
11085 /* Dump the symbol table. */
11087 process_symbol_table (FILE * file)
11089 Elf_Internal_Shdr * section;
11090 bfd_size_type nbuckets = 0;
11091 bfd_size_type nchains = 0;
11092 bfd_vma * buckets = NULL;
11093 bfd_vma * chains = NULL;
11094 bfd_vma ngnubuckets = 0;
11095 bfd_vma * gnubuckets = NULL;
11096 bfd_vma * gnuchains = NULL;
11097 bfd_vma gnusymidx = 0;
11098 bfd_size_type ngnuchains = 0;
11100 if (!do_syms && !do_dyn_syms && !do_histogram)
11103 if (dynamic_info[DT_HASH]
11105 || (do_using_dynamic
11107 && dynamic_strings != NULL)))
11109 unsigned char nb[8];
11110 unsigned char nc[8];
11111 unsigned int hash_ent_size = 4;
11113 if ((elf_header.e_machine == EM_ALPHA
11114 || elf_header.e_machine == EM_S390
11115 || elf_header.e_machine == EM_S390_OLD)
11116 && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
11120 (archive_file_offset
11121 + offset_from_vma (file, dynamic_info[DT_HASH],
11122 sizeof nb + sizeof nc)),
11125 error (_("Unable to seek to start of dynamic information\n"));
11129 if (fread (nb, hash_ent_size, 1, file) != 1)
11131 error (_("Failed to read in number of buckets\n"));
11135 if (fread (nc, hash_ent_size, 1, file) != 1)
11137 error (_("Failed to read in number of chains\n"));
11141 nbuckets = byte_get (nb, hash_ent_size);
11142 nchains = byte_get (nc, hash_ent_size);
11144 buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
11145 chains = get_dynamic_data (file, nchains, hash_ent_size);
11148 if (buckets == NULL || chains == NULL)
11150 if (do_using_dynamic)
11161 if (dynamic_info_DT_GNU_HASH
11163 || (do_using_dynamic
11165 && dynamic_strings != NULL)))
11167 unsigned char nb[16];
11168 bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
11169 bfd_vma buckets_vma;
11172 (archive_file_offset
11173 + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
11177 error (_("Unable to seek to start of dynamic information\n"));
11181 if (fread (nb, 16, 1, file) != 1)
11183 error (_("Failed to read in number of buckets\n"));
11187 ngnubuckets = byte_get (nb, 4);
11188 gnusymidx = byte_get (nb + 4, 4);
11189 bitmaskwords = byte_get (nb + 8, 4);
11190 buckets_vma = dynamic_info_DT_GNU_HASH + 16;
11192 buckets_vma += bitmaskwords * 4;
11194 buckets_vma += bitmaskwords * 8;
11197 (archive_file_offset
11198 + offset_from_vma (file, buckets_vma, 4)),
11201 error (_("Unable to seek to start of dynamic information\n"));
11205 gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
11207 if (gnubuckets == NULL)
11210 for (i = 0; i < ngnubuckets; i++)
11211 if (gnubuckets[i] != 0)
11213 if (gnubuckets[i] < gnusymidx)
11216 if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
11217 maxchain = gnubuckets[i];
11220 if (maxchain == 0xffffffff)
11223 maxchain -= gnusymidx;
11226 (archive_file_offset
11227 + offset_from_vma (file, buckets_vma
11228 + 4 * (ngnubuckets + maxchain), 4)),
11231 error (_("Unable to seek to start of dynamic information\n"));
11237 if (fread (nb, 4, 1, file) != 1)
11239 error (_("Failed to determine last chain length\n"));
11243 if (maxchain + 1 == 0)
11248 while ((byte_get (nb, 4) & 1) == 0);
11251 (archive_file_offset
11252 + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
11255 error (_("Unable to seek to start of dynamic information\n"));
11259 gnuchains = get_dynamic_data (file, maxchain, 4);
11260 ngnuchains = maxchain;
11263 if (gnuchains == NULL)
11268 if (do_using_dynamic)
11273 if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
11275 && do_using_dynamic
11276 && dynamic_strings != NULL
11277 && dynamic_symbols != NULL)
11281 if (dynamic_info[DT_HASH])
11285 printf (_("\nSymbol table for image:\n"));
11287 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11289 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11291 for (hn = 0; hn < nbuckets; hn++)
11296 for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
11297 print_dynamic_symbol (si, hn);
11301 if (dynamic_info_DT_GNU_HASH)
11303 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
11305 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11307 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
11309 for (hn = 0; hn < ngnubuckets; ++hn)
11310 if (gnubuckets[hn] != 0)
11312 bfd_vma si = gnubuckets[hn];
11313 bfd_vma off = si - gnusymidx;
11317 print_dynamic_symbol (si, hn);
11320 while (off < ngnuchains && (gnuchains[off++] & 1) == 0);
11324 else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
11325 && section_headers != NULL)
11329 for (i = 0, section = section_headers;
11330 i < elf_header.e_shnum;
11334 char * strtab = NULL;
11335 unsigned long int strtab_size = 0;
11336 Elf_Internal_Sym * symtab;
11337 Elf_Internal_Sym * psym;
11338 unsigned long num_syms;
11340 if ((section->sh_type != SHT_SYMTAB
11341 && section->sh_type != SHT_DYNSYM)
11343 && section->sh_type == SHT_SYMTAB))
11346 if (section->sh_entsize == 0)
11348 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
11349 printable_section_name (section));
11353 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
11354 printable_section_name (section),
11355 (unsigned long) (section->sh_size / section->sh_entsize));
11358 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11360 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
11362 symtab = GET_ELF_SYMBOLS (file, section, & num_syms);
11363 if (symtab == NULL)
11366 if (section->sh_link == elf_header.e_shstrndx)
11368 strtab = string_table;
11369 strtab_size = string_table_length;
11371 else if (section->sh_link < elf_header.e_shnum)
11373 Elf_Internal_Shdr * string_sec;
11375 string_sec = section_headers + section->sh_link;
11377 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
11378 1, string_sec->sh_size,
11379 _("string table"));
11380 strtab_size = strtab != NULL ? string_sec->sh_size : 0;
11383 for (si = 0, psym = symtab; si < num_syms; si++, psym++)
11385 const char *version_string;
11386 enum versioned_symbol_info sym_info;
11387 unsigned short vna_other;
11389 printf ("%6d: ", si);
11390 print_vma (psym->st_value, LONG_HEX);
11392 print_vma (psym->st_size, DEC_5);
11393 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
11394 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
11395 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_SOLARIS)
11396 printf (" %-7s", get_solaris_symbol_visibility (psym->st_other));
11399 unsigned int vis = ELF_ST_VISIBILITY (psym->st_other);
11401 printf (" %-7s", get_symbol_visibility (vis));
11402 /* Check to see if any other bits in the st_other field are set.
11403 Note - displaying this information disrupts the layout of the
11404 table being generated, but for the moment this case is very rare. */
11405 if (psym->st_other ^ vis)
11406 printf (" [%s] ", get_symbol_other (psym->st_other ^ vis));
11408 printf (" %4s ", get_symbol_index_type (psym->st_shndx));
11409 print_symbol (25, psym->st_name < strtab_size
11410 ? strtab + psym->st_name : _("<corrupt>"));
11413 = get_symbol_version_string (file,
11414 section->sh_type == SHT_DYNSYM,
11415 strtab, strtab_size, si,
11416 psym, &sym_info, &vna_other);
11417 if (version_string)
11419 if (sym_info == symbol_undefined)
11420 printf ("@%s (%d)", version_string, vna_other);
11422 printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
11428 if (ELF_ST_BIND (psym->st_info) == STB_LOCAL
11429 && si >= section->sh_info
11430 /* Irix 5 and 6 MIPS binaries are known to ignore this requirement. */
11431 && elf_header.e_machine != EM_MIPS
11432 /* Solaris binaries have been found to violate this requirement as
11433 well. Not sure if this is a bug or an ABI requirement. */
11434 && elf_header.e_ident[EI_OSABI] != ELFOSABI_SOLARIS)
11435 warn (_("local symbol %u found at index >= %s's sh_info value of %u\n"),
11436 si, printable_section_name (section), section->sh_info);
11440 if (strtab != string_table)
11446 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
11448 if (do_histogram && buckets != NULL)
11450 unsigned long * lengths;
11451 unsigned long * counts;
11454 unsigned long maxlength = 0;
11455 unsigned long nzero_counts = 0;
11456 unsigned long nsyms = 0;
11457 unsigned long chained;
11459 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
11460 (unsigned long) nbuckets);
11462 lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
11463 if (lengths == NULL)
11465 error (_("Out of memory allocating space for histogram buckets\n"));
11469 printf (_(" Length Number %% of total Coverage\n"));
11470 for (hn = 0; hn < nbuckets; ++hn)
11472 for (si = buckets[hn], chained = 0;
11473 si > 0 && si < nchains && si < nbuckets && chained <= nchains;
11474 si = chains[si], ++chained)
11477 if (maxlength < ++lengths[hn])
11481 /* PR binutils/17531: A corrupt binary could contain broken
11482 histogram data. Do not go into an infinite loop trying
11484 if (chained > nchains)
11486 error (_("histogram chain is corrupt\n"));
11491 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
11492 if (counts == NULL)
11495 error (_("Out of memory allocating space for histogram counts\n"));
11499 for (hn = 0; hn < nbuckets; ++hn)
11500 ++counts[lengths[hn]];
11505 printf (" 0 %-10lu (%5.1f%%)\n",
11506 counts[0], (counts[0] * 100.0) / nbuckets);
11507 for (i = 1; i <= maxlength; ++i)
11509 nzero_counts += counts[i] * i;
11510 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11511 i, counts[i], (counts[i] * 100.0) / nbuckets,
11512 (nzero_counts * 100.0) / nsyms);
11520 if (buckets != NULL)
11526 if (do_histogram && gnubuckets != NULL)
11528 unsigned long * lengths;
11529 unsigned long * counts;
11531 unsigned long maxlength = 0;
11532 unsigned long nzero_counts = 0;
11533 unsigned long nsyms = 0;
11535 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
11536 (unsigned long) ngnubuckets);
11538 lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
11539 if (lengths == NULL)
11541 error (_("Out of memory allocating space for gnu histogram buckets\n"));
11545 printf (_(" Length Number %% of total Coverage\n"));
11547 for (hn = 0; hn < ngnubuckets; ++hn)
11548 if (gnubuckets[hn] != 0)
11550 bfd_vma off, length = 1;
11552 for (off = gnubuckets[hn] - gnusymidx;
11553 /* PR 17531 file: 010-77222-0.004. */
11554 off < ngnuchains && (gnuchains[off] & 1) == 0;
11557 lengths[hn] = length;
11558 if (length > maxlength)
11559 maxlength = length;
11563 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
11564 if (counts == NULL)
11567 error (_("Out of memory allocating space for gnu histogram counts\n"));
11571 for (hn = 0; hn < ngnubuckets; ++hn)
11572 ++counts[lengths[hn]];
11574 if (ngnubuckets > 0)
11577 printf (" 0 %-10lu (%5.1f%%)\n",
11578 counts[0], (counts[0] * 100.0) / ngnubuckets);
11579 for (j = 1; j <= maxlength; ++j)
11581 nzero_counts += counts[j] * j;
11582 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
11583 j, counts[j], (counts[j] * 100.0) / ngnubuckets,
11584 (nzero_counts * 100.0) / nsyms);
11598 process_syminfo (FILE * file ATTRIBUTE_UNUSED)
11602 if (dynamic_syminfo == NULL
11604 /* No syminfo, this is ok. */
11607 /* There better should be a dynamic symbol section. */
11608 if (dynamic_symbols == NULL || dynamic_strings == NULL)
11612 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
11613 dynamic_syminfo_offset, dynamic_syminfo_nent);
11615 printf (_(" Num: Name BoundTo Flags\n"));
11616 for (i = 0; i < dynamic_syminfo_nent; ++i)
11618 unsigned short int flags = dynamic_syminfo[i].si_flags;
11620 printf ("%4d: ", i);
11621 if (i >= num_dynamic_syms)
11622 printf (_("<corrupt index>"));
11623 else if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
11624 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
11626 printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
11629 switch (dynamic_syminfo[i].si_boundto)
11631 case SYMINFO_BT_SELF:
11632 fputs ("SELF ", stdout);
11634 case SYMINFO_BT_PARENT:
11635 fputs ("PARENT ", stdout);
11638 if (dynamic_syminfo[i].si_boundto > 0
11639 && dynamic_syminfo[i].si_boundto < dynamic_nent
11640 && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
11642 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
11646 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
11650 if (flags & SYMINFO_FLG_DIRECT)
11651 printf (" DIRECT");
11652 if (flags & SYMINFO_FLG_PASSTHRU)
11653 printf (" PASSTHRU");
11654 if (flags & SYMINFO_FLG_COPY)
11656 if (flags & SYMINFO_FLG_LAZYLOAD)
11657 printf (" LAZYLOAD");
11665 #define IN_RANGE(START,END,ADDR,OFF) \
11666 (((ADDR) >= (START)) && ((ADDR) + (OFF) < (END)))
11668 /* Check to see if the given reloc needs to be handled in a target specific
11669 manner. If so then process the reloc and return TRUE otherwise return
11672 If called with reloc == NULL, then this is a signal that reloc processing
11673 for the current section has finished, and any saved state should be
11677 target_specific_reloc_handling (Elf_Internal_Rela * reloc,
11678 unsigned char * start,
11679 unsigned char * end,
11680 Elf_Internal_Sym * symtab,
11681 unsigned long num_syms)
11683 unsigned int reloc_type = 0;
11684 unsigned long sym_index = 0;
11688 reloc_type = get_reloc_type (reloc->r_info);
11689 sym_index = get_reloc_symindex (reloc->r_info);
11692 switch (elf_header.e_machine)
11695 case EM_MSP430_OLD:
11697 static Elf_Internal_Sym * saved_sym = NULL;
11705 switch (reloc_type)
11707 case 10: /* R_MSP430_SYM_DIFF */
11708 if (uses_msp430x_relocs ())
11710 /* Fall through. */
11711 case 21: /* R_MSP430X_SYM_DIFF */
11713 if (sym_index >= num_syms)
11714 error (_("MSP430 SYM_DIFF reloc contains invalid symbol index %lu\n"),
11717 saved_sym = symtab + sym_index;
11720 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
11721 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
11722 goto handle_sym_diff;
11724 case 5: /* R_MSP430_16_BYTE */
11725 case 9: /* R_MSP430_8 */
11726 if (uses_msp430x_relocs ())
11728 goto handle_sym_diff;
11730 case 2: /* R_MSP430_ABS16 */
11731 case 15: /* R_MSP430X_ABS16 */
11732 if (! uses_msp430x_relocs ())
11734 goto handle_sym_diff;
11737 if (saved_sym != NULL)
11739 int reloc_size = reloc_type == 1 ? 4 : 2;
11742 if (sym_index >= num_syms)
11743 error (_("MSP430 reloc contains invalid symbol index %lu\n"),
11747 value = reloc->r_addend + (symtab[sym_index].st_value
11748 - saved_sym->st_value);
11750 if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
11751 byte_put (start + reloc->r_offset, value, reloc_size);
11754 error (_("MSP430 sym diff reloc contains invalid offset: 0x%lx\n"),
11755 (long) reloc->r_offset);
11764 if (saved_sym != NULL)
11765 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
11772 case EM_CYGNUS_MN10300:
11774 static Elf_Internal_Sym * saved_sym = NULL;
11782 switch (reloc_type)
11784 case 34: /* R_MN10300_ALIGN */
11786 case 33: /* R_MN10300_SYM_DIFF */
11787 if (sym_index >= num_syms)
11788 error (_("MN10300_SYM_DIFF reloc contains invalid symbol index %lu\n"),
11791 saved_sym = symtab + sym_index;
11794 case 1: /* R_MN10300_32 */
11795 case 2: /* R_MN10300_16 */
11796 if (saved_sym != NULL)
11798 int reloc_size = reloc_type == 1 ? 4 : 2;
11801 if (sym_index >= num_syms)
11802 error (_("MN10300 reloc contains invalid symbol index %lu\n"),
11806 value = reloc->r_addend + (symtab[sym_index].st_value
11807 - saved_sym->st_value);
11809 if (IN_RANGE (start, end, start + reloc->r_offset, reloc_size))
11810 byte_put (start + reloc->r_offset, value, reloc_size);
11812 error (_("MN10300 sym diff reloc contains invalid offset: 0x%lx\n"),
11813 (long) reloc->r_offset);
11821 if (saved_sym != NULL)
11822 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
11830 static bfd_vma saved_sym1 = 0;
11831 static bfd_vma saved_sym2 = 0;
11832 static bfd_vma value;
11836 saved_sym1 = saved_sym2 = 0;
11840 switch (reloc_type)
11842 case 0x80: /* R_RL78_SYM. */
11843 saved_sym1 = saved_sym2;
11844 if (sym_index >= num_syms)
11845 error (_("RL78_SYM reloc contains invalid symbol index %lu\n"),
11849 saved_sym2 = symtab[sym_index].st_value;
11850 saved_sym2 += reloc->r_addend;
11854 case 0x83: /* R_RL78_OPsub. */
11855 value = saved_sym1 - saved_sym2;
11856 saved_sym2 = saved_sym1 = 0;
11860 case 0x41: /* R_RL78_ABS32. */
11861 if (IN_RANGE (start, end, start + reloc->r_offset, 4))
11862 byte_put (start + reloc->r_offset, value, 4);
11864 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
11865 (long) reloc->r_offset);
11869 case 0x43: /* R_RL78_ABS16. */
11870 if (IN_RANGE (start, end, start + reloc->r_offset, 2))
11871 byte_put (start + reloc->r_offset, value, 2);
11873 error (_("RL78 sym diff reloc contains invalid offset: 0x%lx\n"),
11874 (long) reloc->r_offset);
11888 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
11889 DWARF debug sections. This is a target specific test. Note - we do not
11890 go through the whole including-target-headers-multiple-times route, (as
11891 we have already done with <elf/h8.h>) because this would become very
11892 messy and even then this function would have to contain target specific
11893 information (the names of the relocs instead of their numeric values).
11894 FIXME: This is not the correct way to solve this problem. The proper way
11895 is to have target specific reloc sizing and typing functions created by
11896 the reloc-macros.h header, in the same way that it already creates the
11897 reloc naming functions. */
11900 is_32bit_abs_reloc (unsigned int reloc_type)
11902 /* Please keep this table alpha-sorted for ease of visual lookup. */
11903 switch (elf_header.e_machine)
11907 return reloc_type == 1; /* R_386_32. */
11909 return reloc_type == 1; /* R_68K_32. */
11911 return reloc_type == 1; /* R_860_32. */
11913 return reloc_type == 2; /* R_960_32. */
11915 return (reloc_type == 258
11916 || reloc_type == 1); /* R_AARCH64_ABS32 || R_AARCH64_P32_ABS32 */
11917 case EM_ADAPTEVA_EPIPHANY:
11918 return reloc_type == 3;
11920 return reloc_type == 1; /* R_ALPHA_REFLONG. */
11922 return reloc_type == 1; /* R_ARC_32. */
11923 case EM_ARC_COMPACT:
11924 case EM_ARC_COMPACT2:
11925 return reloc_type == 4; /* R_ARC_32. */
11927 return reloc_type == 2; /* R_ARM_ABS32 */
11930 return reloc_type == 1;
11932 return reloc_type == 0x12; /* R_byte4_data. */
11934 return reloc_type == 3; /* R_CRIS_32. */
11936 return reloc_type == 3; /* R_CR16_NUM32. */
11938 return reloc_type == 15; /* R_CRX_NUM32. */
11939 case EM_CYGNUS_FRV:
11940 return reloc_type == 1;
11941 case EM_CYGNUS_D10V:
11943 return reloc_type == 6; /* R_D10V_32. */
11944 case EM_CYGNUS_D30V:
11946 return reloc_type == 12; /* R_D30V_32_NORMAL. */
11948 return reloc_type == 3; /* R_DLX_RELOC_32. */
11949 case EM_CYGNUS_FR30:
11951 return reloc_type == 3; /* R_FR30_32. */
11953 return reloc_type == 1; /* R_FT32_32. */
11957 return reloc_type == 1; /* R_H8_DIR32. */
11959 return reloc_type == 0x65 /* R_IA64_SECREL32LSB. */
11960 || reloc_type == 0x25; /* R_IA64_DIR32LSB. */
11963 return reloc_type == 2; /* R_IP2K_32. */
11965 return reloc_type == 2; /* R_IQ2000_32. */
11966 case EM_LATTICEMICO32:
11967 return reloc_type == 3; /* R_LM32_32. */
11970 return reloc_type == 3; /* R_M32C_32. */
11972 return reloc_type == 34; /* R_M32R_32_RELA. */
11975 return reloc_type == 6; /* R_M68HC11_32. */
11977 return reloc_type == 1; /* R_MCORE_ADDR32. */
11978 case EM_CYGNUS_MEP:
11979 return reloc_type == 4; /* R_MEP_32. */
11981 return reloc_type == 2; /* R_METAG_ADDR32. */
11982 case EM_MICROBLAZE:
11983 return reloc_type == 1; /* R_MICROBLAZE_32. */
11985 return reloc_type == 2; /* R_MIPS_32. */
11987 return reloc_type == 4; /* R_MMIX_32. */
11988 case EM_CYGNUS_MN10200:
11990 return reloc_type == 1; /* R_MN10200_32. */
11991 case EM_CYGNUS_MN10300:
11993 return reloc_type == 1; /* R_MN10300_32. */
11995 return reloc_type == 1; /* R_MOXIE_32. */
11996 case EM_MSP430_OLD:
11998 return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32. */
12000 return reloc_type == 2; /* R_MT_32. */
12002 return reloc_type == 20; /* R_NDS32_RELA. */
12003 case EM_ALTERA_NIOS2:
12004 return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32. */
12006 return reloc_type == 1; /* R_NIOS_32. */
12008 return reloc_type == 1; /* R_OR1K_32. */
12010 return (reloc_type == 1 /* R_PARISC_DIR32. */
12011 || reloc_type == 41); /* R_PARISC_SECREL32. */
12014 return reloc_type == 1; /* R_PJ_DATA_DIR32. */
12016 return reloc_type == 1; /* R_PPC64_ADDR32. */
12018 return reloc_type == 1; /* R_PPC_ADDR32. */
12020 return reloc_type == 11; /* R_PRU_BFD_RELOC_32. */
12022 return reloc_type == 1; /* R_RISCV_32. */
12024 return reloc_type == 1; /* R_RL78_DIR32. */
12026 return reloc_type == 1; /* R_RX_DIR32. */
12028 return reloc_type == 1; /* R_I370_ADDR31. */
12031 return reloc_type == 4; /* R_S390_32. */
12033 return reloc_type == 8; /* R_SCORE_ABS32. */
12035 return reloc_type == 1; /* R_SH_DIR32. */
12036 case EM_SPARC32PLUS:
12039 return reloc_type == 3 /* R_SPARC_32. */
12040 || reloc_type == 23; /* R_SPARC_UA32. */
12042 return reloc_type == 6; /* R_SPU_ADDR32 */
12044 return reloc_type == 1; /* R_C6000_ABS32. */
12046 return reloc_type == 2; /* R_TILEGX_32. */
12048 return reloc_type == 1; /* R_TILEPRO_32. */
12049 case EM_CYGNUS_V850:
12051 return reloc_type == 6; /* R_V850_ABS32. */
12053 return reloc_type == 0x33; /* R_V810_WORD. */
12055 return reloc_type == 1; /* R_VAX_32. */
12057 return reloc_type == 3; /* R_VISIUM_32. */
12061 return reloc_type == 10; /* R_X86_64_32. */
12064 return reloc_type == 3; /* R_XC16C_ABS_32. */
12066 return reloc_type == 4; /* R_XGATE_32. */
12068 return reloc_type == 1; /* R_XSTROMY16_32. */
12069 case EM_XTENSA_OLD:
12071 return reloc_type == 1; /* R_XTENSA_32. */
12074 static unsigned int prev_warn = 0;
12076 /* Avoid repeating the same warning multiple times. */
12077 if (prev_warn != elf_header.e_machine)
12078 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
12079 elf_header.e_machine);
12080 prev_warn = elf_header.e_machine;
12086 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12087 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
12090 is_32bit_pcrel_reloc (unsigned int reloc_type)
12092 switch (elf_header.e_machine)
12093 /* Please keep this table alpha-sorted for ease of visual lookup. */
12097 return reloc_type == 2; /* R_386_PC32. */
12099 return reloc_type == 4; /* R_68K_PC32. */
12101 return reloc_type == 261; /* R_AARCH64_PREL32 */
12102 case EM_ADAPTEVA_EPIPHANY:
12103 return reloc_type == 6;
12105 return reloc_type == 10; /* R_ALPHA_SREL32. */
12106 case EM_ARC_COMPACT:
12107 case EM_ARC_COMPACT2:
12108 return reloc_type == 49; /* R_ARC_32_PCREL. */
12110 return reloc_type == 3; /* R_ARM_REL32 */
12113 return reloc_type == 36; /* R_AVR_32_PCREL. */
12114 case EM_MICROBLAZE:
12115 return reloc_type == 2; /* R_MICROBLAZE_32_PCREL. */
12117 return reloc_type == 9; /* R_OR1K_32_PCREL. */
12119 return reloc_type == 9; /* R_PARISC_PCREL32. */
12121 return reloc_type == 26; /* R_PPC_REL32. */
12123 return reloc_type == 26; /* R_PPC64_REL32. */
12126 return reloc_type == 5; /* R_390_PC32. */
12128 return reloc_type == 2; /* R_SH_REL32. */
12129 case EM_SPARC32PLUS:
12132 return reloc_type == 6; /* R_SPARC_DISP32. */
12134 return reloc_type == 13; /* R_SPU_REL32. */
12136 return reloc_type == 6; /* R_TILEGX_32_PCREL. */
12138 return reloc_type == 4; /* R_TILEPRO_32_PCREL. */
12140 return reloc_type == 6; /* R_VISIUM_32_PCREL */
12144 return reloc_type == 2; /* R_X86_64_PC32. */
12145 case EM_XTENSA_OLD:
12147 return reloc_type == 14; /* R_XTENSA_32_PCREL. */
12149 /* Do not abort or issue an error message here. Not all targets use
12150 pc-relative 32-bit relocs in their DWARF debug information and we
12151 have already tested for target coverage in is_32bit_abs_reloc. A
12152 more helpful warning message will be generated by apply_relocations
12153 anyway, so just return. */
12158 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12159 a 64-bit absolute RELA relocation used in DWARF debug sections. */
12162 is_64bit_abs_reloc (unsigned int reloc_type)
12164 switch (elf_header.e_machine)
12167 return reloc_type == 257; /* R_AARCH64_ABS64. */
12169 return reloc_type == 2; /* R_ALPHA_REFQUAD. */
12171 return reloc_type == 0x27; /* R_IA64_DIR64LSB. */
12173 return reloc_type == 80; /* R_PARISC_DIR64. */
12175 return reloc_type == 38; /* R_PPC64_ADDR64. */
12177 return reloc_type == 2; /* R_RISCV_64. */
12178 case EM_SPARC32PLUS:
12181 return reloc_type == 54; /* R_SPARC_UA64. */
12185 return reloc_type == 1; /* R_X86_64_64. */
12188 return reloc_type == 22; /* R_S390_64. */
12190 return reloc_type == 1; /* R_TILEGX_64. */
12192 return reloc_type == 18; /* R_MIPS_64. */
12198 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
12199 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
12202 is_64bit_pcrel_reloc (unsigned int reloc_type)
12204 switch (elf_header.e_machine)
12207 return reloc_type == 260; /* R_AARCH64_PREL64. */
12209 return reloc_type == 11; /* R_ALPHA_SREL64. */
12211 return reloc_type == 0x4f; /* R_IA64_PCREL64LSB. */
12213 return reloc_type == 72; /* R_PARISC_PCREL64. */
12215 return reloc_type == 44; /* R_PPC64_REL64. */
12216 case EM_SPARC32PLUS:
12219 return reloc_type == 46; /* R_SPARC_DISP64. */
12223 return reloc_type == 24; /* R_X86_64_PC64. */
12226 return reloc_type == 23; /* R_S390_PC64. */
12228 return reloc_type == 5; /* R_TILEGX_64_PCREL. */
12234 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12235 a 24-bit absolute RELA relocation used in DWARF debug sections. */
12238 is_24bit_abs_reloc (unsigned int reloc_type)
12240 switch (elf_header.e_machine)
12242 case EM_CYGNUS_MN10200:
12244 return reloc_type == 4; /* R_MN10200_24. */
12246 return reloc_type == 5; /* R_FT32_20. */
12252 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
12253 a 16-bit absolute RELA relocation used in DWARF debug sections. */
12256 is_16bit_abs_reloc (unsigned int reloc_type)
12258 /* Please keep this table alpha-sorted for ease of visual lookup. */
12259 switch (elf_header.e_machine)
12262 case EM_ARC_COMPACT:
12263 case EM_ARC_COMPACT2:
12264 return reloc_type == 2; /* R_ARC_16. */
12265 case EM_ADAPTEVA_EPIPHANY:
12266 return reloc_type == 5;
12269 return reloc_type == 4; /* R_AVR_16. */
12270 case EM_CYGNUS_D10V:
12272 return reloc_type == 3; /* R_D10V_16. */
12276 return reloc_type == R_H8_DIR16;
12279 return reloc_type == 1; /* R_IP2K_16. */
12282 return reloc_type == 1; /* R_M32C_16 */
12283 case EM_CYGNUS_MN10200:
12285 return reloc_type == 2; /* R_MN10200_16. */
12286 case EM_CYGNUS_MN10300:
12288 return reloc_type == 2; /* R_MN10300_16. */
12290 if (uses_msp430x_relocs ())
12291 return reloc_type == 2; /* R_MSP430_ABS16. */
12292 /* Fall through. */
12293 case EM_MSP430_OLD:
12294 return reloc_type == 5; /* R_MSP430_16_BYTE. */
12296 return reloc_type == 19; /* R_NDS32_RELA. */
12297 case EM_ALTERA_NIOS2:
12298 return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16. */
12300 return reloc_type == 9; /* R_NIOS_16. */
12302 return reloc_type == 2; /* R_OR1K_16. */
12304 return reloc_type == 8; /* R_PRU_BFD_RELOC_16. */
12306 return reloc_type == 2; /* R_C6000_ABS16. */
12308 return reloc_type == 2; /* R_VISIUM_16. */
12311 return reloc_type == 2; /* R_XC16C_ABS_16. */
12313 return reloc_type == 3; /* R_XGATE_16. */
12319 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
12320 relocation entries (possibly formerly used for SHT_GROUP sections). */
12323 is_none_reloc (unsigned int reloc_type)
12325 switch (elf_header.e_machine)
12327 case EM_386: /* R_386_NONE. */
12328 case EM_68K: /* R_68K_NONE. */
12329 case EM_ADAPTEVA_EPIPHANY:
12330 case EM_ALPHA: /* R_ALPHA_NONE. */
12331 case EM_ALTERA_NIOS2: /* R_NIOS2_NONE. */
12332 case EM_ARC: /* R_ARC_NONE. */
12333 case EM_ARC_COMPACT2: /* R_ARC_NONE. */
12334 case EM_ARC_COMPACT: /* R_ARC_NONE. */
12335 case EM_ARM: /* R_ARM_NONE. */
12336 case EM_C166: /* R_XC16X_NONE. */
12337 case EM_CRIS: /* R_CRIS_NONE. */
12338 case EM_FT32: /* R_FT32_NONE. */
12339 case EM_IA_64: /* R_IA64_NONE. */
12340 case EM_K1OM: /* R_X86_64_NONE. */
12341 case EM_L1OM: /* R_X86_64_NONE. */
12342 case EM_M32R: /* R_M32R_NONE. */
12343 case EM_MIPS: /* R_MIPS_NONE. */
12344 case EM_MN10300: /* R_MN10300_NONE. */
12345 case EM_MOXIE: /* R_MOXIE_NONE. */
12346 case EM_NIOS32: /* R_NIOS_NONE. */
12347 case EM_OR1K: /* R_OR1K_NONE. */
12348 case EM_PARISC: /* R_PARISC_NONE. */
12349 case EM_PPC64: /* R_PPC64_NONE. */
12350 case EM_PPC: /* R_PPC_NONE. */
12351 case EM_RISCV: /* R_RISCV_NONE. */
12352 case EM_S390: /* R_390_NONE. */
12354 case EM_SH: /* R_SH_NONE. */
12355 case EM_SPARC32PLUS:
12356 case EM_SPARC: /* R_SPARC_NONE. */
12358 case EM_TILEGX: /* R_TILEGX_NONE. */
12359 case EM_TILEPRO: /* R_TILEPRO_NONE. */
12360 case EM_TI_C6000:/* R_C6000_NONE. */
12361 case EM_X86_64: /* R_X86_64_NONE. */
12363 return reloc_type == 0;
12366 return reloc_type == 0 || reloc_type == 256;
12369 return (reloc_type == 0 /* R_AVR_NONE. */
12370 || reloc_type == 30 /* R_AVR_DIFF8. */
12371 || reloc_type == 31 /* R_AVR_DIFF16. */
12372 || reloc_type == 32 /* R_AVR_DIFF32. */);
12374 return reloc_type == 3; /* R_METAG_NONE. */
12376 return (reloc_type == 0 /* R_XTENSA_NONE. */
12377 || reloc_type == 204 /* R_NDS32_DIFF8. */
12378 || reloc_type == 205 /* R_NDS32_DIFF16. */
12379 || reloc_type == 206 /* R_NDS32_DIFF32. */
12380 || reloc_type == 207 /* R_NDS32_ULEB128. */);
12382 return (reloc_type == 0 /* R_PRU_NONE. */
12383 || reloc_type == 65 /* R_PRU_DIFF8. */
12384 || reloc_type == 66 /* R_PRU_DIFF16. */
12385 || reloc_type == 67 /* R_PRU_DIFF32. */);
12386 case EM_XTENSA_OLD:
12388 return (reloc_type == 0 /* R_XTENSA_NONE. */
12389 || reloc_type == 17 /* R_XTENSA_DIFF8. */
12390 || reloc_type == 18 /* R_XTENSA_DIFF16. */
12391 || reloc_type == 19 /* R_XTENSA_DIFF32. */);
12396 /* Returns TRUE if there is a relocation against
12397 section NAME at OFFSET bytes. */
12400 reloc_at (struct dwarf_section * dsec, dwarf_vma offset)
12402 Elf_Internal_Rela * relocs;
12403 Elf_Internal_Rela * rp;
12405 if (dsec == NULL || dsec->reloc_info == NULL)
12408 relocs = (Elf_Internal_Rela *) dsec->reloc_info;
12410 for (rp = relocs; rp < relocs + dsec->num_relocs; ++rp)
12411 if (rp->r_offset == offset)
12417 /* Apply relocations to a section.
12418 Returns TRUE upon success, FALSE otherwise.
12419 If RELOCS_RETURN is non-NULL then it is set to point to the loaded relocs.
12420 It is then the caller's responsibility to free them. NUM_RELOCS_RETURN
12421 will be set to the number of relocs loaded.
12423 Note: So far support has been added only for those relocations
12424 which can be found in debug sections. FIXME: Add support for
12425 more relocations ? */
12428 apply_relocations (void * file,
12429 const Elf_Internal_Shdr * section,
12430 unsigned char * start,
12431 bfd_size_type size,
12432 void ** relocs_return,
12433 unsigned long * num_relocs_return)
12435 Elf_Internal_Shdr * relsec;
12436 unsigned char * end = start + size;
12437 bfd_boolean res = TRUE;
12439 if (relocs_return != NULL)
12441 * (Elf_Internal_Rela **) relocs_return = NULL;
12442 * num_relocs_return = 0;
12445 if (elf_header.e_type != ET_REL)
12446 /* No relocs to apply. */
12449 /* Find the reloc section associated with the section. */
12450 for (relsec = section_headers;
12451 relsec < section_headers + elf_header.e_shnum;
12454 bfd_boolean is_rela;
12455 unsigned long num_relocs;
12456 Elf_Internal_Rela * relocs;
12457 Elf_Internal_Rela * rp;
12458 Elf_Internal_Shdr * symsec;
12459 Elf_Internal_Sym * symtab;
12460 unsigned long num_syms;
12461 Elf_Internal_Sym * sym;
12463 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12464 || relsec->sh_info >= elf_header.e_shnum
12465 || section_headers + relsec->sh_info != section
12466 || relsec->sh_size == 0
12467 || relsec->sh_link >= elf_header.e_shnum)
12470 is_rela = relsec->sh_type == SHT_RELA;
12474 if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
12475 relsec->sh_size, & relocs, & num_relocs))
12480 if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
12481 relsec->sh_size, & relocs, & num_relocs))
12485 /* SH uses RELA but uses in place value instead of the addend field. */
12486 if (elf_header.e_machine == EM_SH)
12489 symsec = section_headers + relsec->sh_link;
12490 if (symsec->sh_type != SHT_SYMTAB
12491 && symsec->sh_type != SHT_DYNSYM)
12493 symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec, & num_syms);
12495 for (rp = relocs; rp < relocs + num_relocs; ++rp)
12498 unsigned int reloc_type;
12499 unsigned int reloc_size;
12500 unsigned char * rloc;
12501 unsigned long sym_index;
12503 reloc_type = get_reloc_type (rp->r_info);
12505 if (target_specific_reloc_handling (rp, start, end, symtab, num_syms))
12507 else if (is_none_reloc (reloc_type))
12509 else if (is_32bit_abs_reloc (reloc_type)
12510 || is_32bit_pcrel_reloc (reloc_type))
12512 else if (is_64bit_abs_reloc (reloc_type)
12513 || is_64bit_pcrel_reloc (reloc_type))
12515 else if (is_24bit_abs_reloc (reloc_type))
12517 else if (is_16bit_abs_reloc (reloc_type))
12521 static unsigned int prev_reloc = 0;
12522 if (reloc_type != prev_reloc)
12523 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
12524 reloc_type, printable_section_name (section));
12525 prev_reloc = reloc_type;
12530 rloc = start + rp->r_offset;
12531 if ((rloc + reloc_size) > end || (rloc < start))
12533 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
12534 (unsigned long) rp->r_offset,
12535 printable_section_name (section));
12540 sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
12541 if (sym_index >= num_syms)
12543 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
12544 sym_index, printable_section_name (section));
12548 sym = symtab + sym_index;
12550 /* If the reloc has a symbol associated with it,
12551 make sure that it is of an appropriate type.
12553 Relocations against symbols without type can happen.
12554 Gcc -feliminate-dwarf2-dups may generate symbols
12555 without type for debug info.
12557 Icc generates relocations against function symbols
12558 instead of local labels.
12560 Relocations against object symbols can happen, eg when
12561 referencing a global array. For an example of this see
12562 the _clz.o binary in libgcc.a. */
12564 && ELF_ST_TYPE (sym->st_info) != STT_COMMON
12565 && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
12567 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
12568 get_symbol_type (ELF_ST_TYPE (sym->st_info)),
12569 (long int)(rp - relocs),
12570 printable_section_name (relsec));
12577 addend += rp->r_addend;
12578 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
12579 partial_inplace. */
12581 || (elf_header.e_machine == EM_XTENSA
12582 && reloc_type == 1)
12583 || ((elf_header.e_machine == EM_PJ
12584 || elf_header.e_machine == EM_PJ_OLD)
12585 && reloc_type == 1)
12586 || ((elf_header.e_machine == EM_D30V
12587 || elf_header.e_machine == EM_CYGNUS_D30V)
12588 && reloc_type == 12))
12589 addend += byte_get (rloc, reloc_size);
12591 if (is_32bit_pcrel_reloc (reloc_type)
12592 || is_64bit_pcrel_reloc (reloc_type))
12594 /* On HPPA, all pc-relative relocations are biased by 8. */
12595 if (elf_header.e_machine == EM_PARISC)
12597 byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
12601 byte_put (rloc, addend + sym->st_value, reloc_size);
12605 /* Let the target specific reloc processing code know that
12606 we have finished with these relocs. */
12607 target_specific_reloc_handling (NULL, NULL, NULL, NULL, 0);
12611 * (Elf_Internal_Rela **) relocs_return = relocs;
12612 * num_relocs_return = num_relocs;
12623 #ifdef SUPPORT_DISASSEMBLY
12625 disassemble_section (Elf_Internal_Shdr * section, FILE * file)
12627 printf (_("\nAssembly dump of section %s\n"), printable_section_name (section));
12629 /* FIXME: XXX -- to be done --- XXX */
12635 /* Reads in the contents of SECTION from FILE, returning a pointer
12636 to a malloc'ed buffer or NULL if something went wrong. */
12639 get_section_contents (Elf_Internal_Shdr * section, FILE * file)
12641 bfd_size_type num_bytes;
12643 num_bytes = section->sh_size;
12645 if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
12647 printf (_("\nSection '%s' has no data to dump.\n"),
12648 printable_section_name (section));
12652 return (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
12653 _("section contents"));
12656 /* Uncompresses a section that was compressed using zlib, in place. */
12659 uncompress_section_contents (unsigned char **buffer,
12660 dwarf_size_type uncompressed_size,
12661 dwarf_size_type *size)
12663 dwarf_size_type compressed_size = *size;
12664 unsigned char * compressed_buffer = *buffer;
12665 unsigned char * uncompressed_buffer;
12669 /* It is possible the section consists of several compressed
12670 buffers concatenated together, so we uncompress in a loop. */
12671 /* PR 18313: The state field in the z_stream structure is supposed
12672 to be invisible to the user (ie us), but some compilers will
12673 still complain about it being used without initialisation. So
12674 we first zero the entire z_stream structure and then set the fields
12676 memset (& strm, 0, sizeof strm);
12677 strm.avail_in = compressed_size;
12678 strm.next_in = (Bytef *) compressed_buffer;
12679 strm.avail_out = uncompressed_size;
12680 uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
12682 rc = inflateInit (& strm);
12683 while (strm.avail_in > 0)
12687 strm.next_out = ((Bytef *) uncompressed_buffer
12688 + (uncompressed_size - strm.avail_out));
12689 rc = inflate (&strm, Z_FINISH);
12690 if (rc != Z_STREAM_END)
12692 rc = inflateReset (& strm);
12694 rc = inflateEnd (& strm);
12696 || strm.avail_out != 0)
12699 *buffer = uncompressed_buffer;
12700 *size = uncompressed_size;
12704 free (uncompressed_buffer);
12705 /* Indicate decompression failure. */
12711 dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
12713 Elf_Internal_Shdr * relsec;
12714 bfd_size_type num_bytes;
12715 unsigned char * data;
12716 unsigned char * end;
12717 unsigned char * real_start;
12718 unsigned char * start;
12719 bfd_boolean some_strings_shown;
12721 real_start = start = (unsigned char *) get_section_contents (section,
12725 num_bytes = section->sh_size;
12727 printf (_("\nString dump of section '%s':\n"), printable_section_name (section));
12729 if (decompress_dumps)
12731 dwarf_size_type new_size = num_bytes;
12732 dwarf_size_type uncompressed_size = 0;
12734 if ((section->sh_flags & SHF_COMPRESSED) != 0)
12736 Elf_Internal_Chdr chdr;
12737 unsigned int compression_header_size
12738 = get_compression_header (& chdr, (unsigned char *) start,
12741 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
12743 warn (_("section '%s' has unsupported compress type: %d\n"),
12744 printable_section_name (section), chdr.ch_type);
12747 else if (chdr.ch_addralign != section->sh_addralign)
12749 warn (_("compressed section '%s' is corrupted\n"),
12750 printable_section_name (section));
12753 uncompressed_size = chdr.ch_size;
12754 start += compression_header_size;
12755 new_size -= compression_header_size;
12757 else if (new_size > 12 && streq ((char *) start, "ZLIB"))
12759 /* Read the zlib header. In this case, it should be "ZLIB"
12760 followed by the uncompressed section size, 8 bytes in
12761 big-endian order. */
12762 uncompressed_size = start[4]; uncompressed_size <<= 8;
12763 uncompressed_size += start[5]; uncompressed_size <<= 8;
12764 uncompressed_size += start[6]; uncompressed_size <<= 8;
12765 uncompressed_size += start[7]; uncompressed_size <<= 8;
12766 uncompressed_size += start[8]; uncompressed_size <<= 8;
12767 uncompressed_size += start[9]; uncompressed_size <<= 8;
12768 uncompressed_size += start[10]; uncompressed_size <<= 8;
12769 uncompressed_size += start[11];
12774 if (uncompressed_size)
12776 if (uncompress_section_contents (& start,
12777 uncompressed_size, & new_size))
12778 num_bytes = new_size;
12781 error (_("Unable to decompress section %s\n"),
12782 printable_section_name (section));
12787 start = real_start;
12790 /* If the section being dumped has relocations against it the user might
12791 be expecting these relocations to have been applied. Check for this
12792 case and issue a warning message in order to avoid confusion.
12793 FIXME: Maybe we ought to have an option that dumps a section with
12794 relocs applied ? */
12795 for (relsec = section_headers;
12796 relsec < section_headers + elf_header.e_shnum;
12799 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12800 || relsec->sh_info >= elf_header.e_shnum
12801 || section_headers + relsec->sh_info != section
12802 || relsec->sh_size == 0
12803 || relsec->sh_link >= elf_header.e_shnum)
12806 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12811 end = start + num_bytes;
12812 some_strings_shown = FALSE;
12816 while (!ISPRINT (* data))
12817 if (++ data >= end)
12822 size_t maxlen = end - data;
12825 /* PR 11128: Use two separate invocations in order to work
12826 around bugs in the Solaris 8 implementation of printf. */
12827 printf (" [%6tx] ", data - start);
12829 printf (" [%6Ix] ", (size_t) (data - start));
12833 print_symbol ((int) maxlen, (const char *) data);
12835 data += strnlen ((const char *) data, maxlen);
12839 printf (_("<corrupt>\n"));
12842 some_strings_shown = TRUE;
12846 if (! some_strings_shown)
12847 printf (_(" No strings found in this section."));
12856 dump_section_as_bytes (Elf_Internal_Shdr * section,
12858 bfd_boolean relocate)
12860 Elf_Internal_Shdr * relsec;
12861 bfd_size_type bytes;
12862 bfd_size_type section_size;
12864 unsigned char * data;
12865 unsigned char * real_start;
12866 unsigned char * start;
12868 real_start = start = (unsigned char *) get_section_contents (section, file);
12872 section_size = section->sh_size;
12874 printf (_("\nHex dump of section '%s':\n"), printable_section_name (section));
12876 if (decompress_dumps)
12878 dwarf_size_type new_size = section_size;
12879 dwarf_size_type uncompressed_size = 0;
12881 if ((section->sh_flags & SHF_COMPRESSED) != 0)
12883 Elf_Internal_Chdr chdr;
12884 unsigned int compression_header_size
12885 = get_compression_header (& chdr, start, section_size);
12887 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
12889 warn (_("section '%s' has unsupported compress type: %d\n"),
12890 printable_section_name (section), chdr.ch_type);
12893 else if (chdr.ch_addralign != section->sh_addralign)
12895 warn (_("compressed section '%s' is corrupted\n"),
12896 printable_section_name (section));
12899 uncompressed_size = chdr.ch_size;
12900 start += compression_header_size;
12901 new_size -= compression_header_size;
12903 else if (new_size > 12 && streq ((char *) start, "ZLIB"))
12905 /* Read the zlib header. In this case, it should be "ZLIB"
12906 followed by the uncompressed section size, 8 bytes in
12907 big-endian order. */
12908 uncompressed_size = start[4]; uncompressed_size <<= 8;
12909 uncompressed_size += start[5]; uncompressed_size <<= 8;
12910 uncompressed_size += start[6]; uncompressed_size <<= 8;
12911 uncompressed_size += start[7]; uncompressed_size <<= 8;
12912 uncompressed_size += start[8]; uncompressed_size <<= 8;
12913 uncompressed_size += start[9]; uncompressed_size <<= 8;
12914 uncompressed_size += start[10]; uncompressed_size <<= 8;
12915 uncompressed_size += start[11];
12920 if (uncompressed_size)
12922 if (uncompress_section_contents (& start, uncompressed_size,
12925 section_size = new_size;
12929 error (_("Unable to decompress section %s\n"),
12930 printable_section_name (section));
12931 /* FIXME: Print the section anyway ? */
12936 start = real_start;
12941 if (! apply_relocations (file, section, start, section_size, NULL, NULL))
12946 /* If the section being dumped has relocations against it the user might
12947 be expecting these relocations to have been applied. Check for this
12948 case and issue a warning message in order to avoid confusion.
12949 FIXME: Maybe we ought to have an option that dumps a section with
12950 relocs applied ? */
12951 for (relsec = section_headers;
12952 relsec < section_headers + elf_header.e_shnum;
12955 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
12956 || relsec->sh_info >= elf_header.e_shnum
12957 || section_headers + relsec->sh_info != section
12958 || relsec->sh_size == 0
12959 || relsec->sh_link >= elf_header.e_shnum)
12962 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
12967 addr = section->sh_addr;
12968 bytes = section_size;
12977 lbytes = (bytes > 16 ? 16 : bytes);
12979 printf (" 0x%8.8lx ", (unsigned long) addr);
12981 for (j = 0; j < 16; j++)
12984 printf ("%2.2x", data[j]);
12992 for (j = 0; j < lbytes; j++)
12995 if (k >= ' ' && k < 0x7f)
13015 load_specific_debug_section (enum dwarf_section_display_enum debug,
13016 const Elf_Internal_Shdr * sec, void * file)
13018 struct dwarf_section * section = &debug_displays [debug].section;
13021 /* If it is already loaded, do nothing. */
13022 if (section->start != NULL)
13025 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
13026 section->address = sec->sh_addr;
13027 section->user_data = NULL;
13028 section->start = (unsigned char *) get_data (NULL, (FILE *) file,
13030 sec->sh_size, buf);
13031 if (section->start == NULL)
13035 unsigned char *start = section->start;
13036 dwarf_size_type size = sec->sh_size;
13037 dwarf_size_type uncompressed_size = 0;
13039 if ((sec->sh_flags & SHF_COMPRESSED) != 0)
13041 Elf_Internal_Chdr chdr;
13042 unsigned int compression_header_size;
13044 if (size < (is_32bit_elf
13045 ? sizeof (Elf32_External_Chdr)
13046 : sizeof (Elf64_External_Chdr)))
13048 warn (_("compressed section %s is too small to contain a compression header"),
13053 compression_header_size = get_compression_header (&chdr, start, size);
13055 if (chdr.ch_type != ELFCOMPRESS_ZLIB)
13057 warn (_("section '%s' has unsupported compress type: %d\n"),
13058 section->name, chdr.ch_type);
13061 else if (chdr.ch_addralign != sec->sh_addralign)
13063 warn (_("compressed section '%s' is corrupted\n"),
13067 uncompressed_size = chdr.ch_size;
13068 start += compression_header_size;
13069 size -= compression_header_size;
13071 else if (size > 12 && streq ((char *) start, "ZLIB"))
13073 /* Read the zlib header. In this case, it should be "ZLIB"
13074 followed by the uncompressed section size, 8 bytes in
13075 big-endian order. */
13076 uncompressed_size = start[4]; uncompressed_size <<= 8;
13077 uncompressed_size += start[5]; uncompressed_size <<= 8;
13078 uncompressed_size += start[6]; uncompressed_size <<= 8;
13079 uncompressed_size += start[7]; uncompressed_size <<= 8;
13080 uncompressed_size += start[8]; uncompressed_size <<= 8;
13081 uncompressed_size += start[9]; uncompressed_size <<= 8;
13082 uncompressed_size += start[10]; uncompressed_size <<= 8;
13083 uncompressed_size += start[11];
13088 if (uncompressed_size)
13090 if (uncompress_section_contents (&start, uncompressed_size,
13093 /* Free the compressed buffer, update the section buffer
13094 and the section size if uncompress is successful. */
13095 free (section->start);
13096 section->start = start;
13100 error (_("Unable to decompress section %s\n"),
13101 printable_section_name (sec));
13106 section->size = size;
13109 if (section->start == NULL)
13112 if (debug_displays [debug].relocate)
13114 if (! apply_relocations ((FILE *) file, sec, section->start, section->size,
13115 & section->reloc_info, & section->num_relocs))
13120 section->reloc_info = NULL;
13121 section->num_relocs = 0;
13127 /* If this is not NULL, load_debug_section will only look for sections
13128 within the list of sections given here. */
13129 static unsigned int * section_subset = NULL;
13132 load_debug_section (enum dwarf_section_display_enum debug, void * file)
13134 struct dwarf_section * section = &debug_displays [debug].section;
13135 Elf_Internal_Shdr * sec;
13137 /* Locate the debug section. */
13138 sec = find_section_in_set (section->uncompressed_name, section_subset);
13140 section->name = section->uncompressed_name;
13143 sec = find_section_in_set (section->compressed_name, section_subset);
13145 section->name = section->compressed_name;
13150 /* If we're loading from a subset of sections, and we've loaded
13151 a section matching this name before, it's likely that it's a
13153 if (section_subset != NULL)
13154 free_debug_section (debug);
13156 return load_specific_debug_section (debug, sec, (FILE *) file);
13160 free_debug_section (enum dwarf_section_display_enum debug)
13162 struct dwarf_section * section = &debug_displays [debug].section;
13164 if (section->start == NULL)
13167 free ((char *) section->start);
13168 section->start = NULL;
13169 section->address = 0;
13174 display_debug_section (int shndx, Elf_Internal_Shdr * section, FILE * file)
13176 char * name = SECTION_NAME (section);
13177 const char * print_name = printable_section_name (section);
13178 bfd_size_type length;
13179 bfd_boolean result = TRUE;
13182 length = section->sh_size;
13185 printf (_("\nSection '%s' has no debugging data.\n"), print_name);
13188 if (section->sh_type == SHT_NOBITS)
13190 /* There is no point in dumping the contents of a debugging section
13191 which has the NOBITS type - the bits in the file will be random.
13192 This can happen when a file containing a .eh_frame section is
13193 stripped with the --only-keep-debug command line option. */
13194 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
13199 if (const_strneq (name, ".gnu.linkonce.wi."))
13200 name = ".debug_info";
13202 /* See if we know how to display the contents of this section. */
13203 for (i = 0; i < max; i++)
13204 if (streq (debug_displays[i].section.uncompressed_name, name)
13205 || (i == line && const_strneq (name, ".debug_line."))
13206 || streq (debug_displays[i].section.compressed_name, name))
13208 struct dwarf_section * sec = &debug_displays [i].section;
13209 int secondary = (section != find_section (name));
13212 free_debug_section ((enum dwarf_section_display_enum) i);
13214 if (i == line && const_strneq (name, ".debug_line."))
13216 else if (streq (sec->uncompressed_name, name))
13217 sec->name = sec->uncompressed_name;
13219 sec->name = sec->compressed_name;
13220 if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
13223 /* If this debug section is part of a CU/TU set in a .dwp file,
13224 restrict load_debug_section to the sections in that set. */
13225 section_subset = find_cu_tu_set (file, shndx);
13227 result &= debug_displays[i].display (sec, file);
13229 section_subset = NULL;
13231 if (secondary || (i != info && i != abbrev))
13232 free_debug_section ((enum dwarf_section_display_enum) i);
13240 printf (_("Unrecognized debug section: %s\n"), print_name);
13247 /* Set DUMP_SECTS for all sections where dumps were requested
13248 based on section name. */
13251 initialise_dumps_byname (void)
13253 struct dump_list_entry * cur;
13255 for (cur = dump_sects_byname; cur; cur = cur->next)
13258 bfd_boolean any = FALSE;
13260 for (i = 0; i < elf_header.e_shnum; i++)
13261 if (streq (SECTION_NAME (section_headers + i), cur->name))
13263 request_dump_bynumber (i, cur->type);
13268 warn (_("Section '%s' was not dumped because it does not exist!\n"),
13274 process_section_contents (FILE * file)
13276 Elf_Internal_Shdr * section;
13278 bfd_boolean res = TRUE;
13283 initialise_dumps_byname ();
13285 for (i = 0, section = section_headers;
13286 i < elf_header.e_shnum && i < num_dump_sects;
13289 #ifdef SUPPORT_DISASSEMBLY
13290 if (dump_sects[i] & DISASS_DUMP)
13291 disassemble_section (section, file);
13293 if (dump_sects[i] & HEX_DUMP)
13295 if (! dump_section_as_bytes (section, file, FALSE))
13299 if (dump_sects[i] & RELOC_DUMP)
13301 if (! dump_section_as_bytes (section, file, TRUE))
13305 if (dump_sects[i] & STRING_DUMP)
13307 if (! dump_section_as_strings (section, file))
13311 if (dump_sects[i] & DEBUG_DUMP)
13313 if (! display_debug_section (i, section, file))
13318 /* Check to see if the user requested a
13319 dump of a section that does not exist. */
13320 while (i < num_dump_sects)
13324 warn (_("Section %d was not dumped because it does not exist!\n"), i);
13334 process_mips_fpe_exception (int mask)
13338 bfd_boolean first = TRUE;
13340 if (mask & OEX_FPU_INEX)
13341 fputs ("INEX", stdout), first = FALSE;
13342 if (mask & OEX_FPU_UFLO)
13343 printf ("%sUFLO", first ? "" : "|"), first = FALSE;
13344 if (mask & OEX_FPU_OFLO)
13345 printf ("%sOFLO", first ? "" : "|"), first = FALSE;
13346 if (mask & OEX_FPU_DIV0)
13347 printf ("%sDIV0", first ? "" : "|"), first = FALSE;
13348 if (mask & OEX_FPU_INVAL)
13349 printf ("%sINVAL", first ? "" : "|");
13352 fputs ("0", stdout);
13355 /* Display's the value of TAG at location P. If TAG is
13356 greater than 0 it is assumed to be an unknown tag, and
13357 a message is printed to this effect. Otherwise it is
13358 assumed that a message has already been printed.
13360 If the bottom bit of TAG is set it assumed to have a
13361 string value, otherwise it is assumed to have an integer
13364 Returns an updated P pointing to the first unread byte
13365 beyond the end of TAG's value.
13367 Reads at or beyond END will not be made. */
13369 static unsigned char *
13370 display_tag_value (signed int tag,
13372 const unsigned char * const end)
13377 printf (" Tag_unknown_%d: ", tag);
13381 warn (_("<corrupt tag>\n"));
13385 /* PR 17531 file: 027-19978-0.004. */
13386 size_t maxlen = (end - p) - 1;
13391 print_symbol ((int) maxlen, (const char *) p);
13392 p += strnlen ((char *) p, maxlen) + 1;
13396 printf (_("<corrupt string tag>"));
13397 p = (unsigned char *) end;
13405 val = read_uleb128 (p, &len, end);
13407 printf ("%ld (0x%lx)\n", val, val);
13414 /* ARM EABI attributes section. */
13419 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
13421 const char ** table;
13422 } arm_attr_public_tag;
13424 static const char * arm_attr_tag_CPU_arch[] =
13425 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
13426 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8", "", "v8-M.baseline",
13428 static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
13429 static const char * arm_attr_tag_THUMB_ISA_use[] =
13430 {"No", "Thumb-1", "Thumb-2", "Yes"};
13431 static const char * arm_attr_tag_FP_arch[] =
13432 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
13433 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
13434 static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
13435 static const char * arm_attr_tag_Advanced_SIMD_arch[] =
13436 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8",
13437 "NEON for ARMv8.1"};
13438 static const char * arm_attr_tag_PCS_config[] =
13439 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
13440 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
13441 static const char * arm_attr_tag_ABI_PCS_R9_use[] =
13442 {"V6", "SB", "TLS", "Unused"};
13443 static const char * arm_attr_tag_ABI_PCS_RW_data[] =
13444 {"Absolute", "PC-relative", "SB-relative", "None"};
13445 static const char * arm_attr_tag_ABI_PCS_RO_data[] =
13446 {"Absolute", "PC-relative", "None"};
13447 static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
13448 {"None", "direct", "GOT-indirect"};
13449 static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
13450 {"None", "??? 1", "2", "??? 3", "4"};
13451 static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
13452 static const char * arm_attr_tag_ABI_FP_denormal[] =
13453 {"Unused", "Needed", "Sign only"};
13454 static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
13455 static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
13456 static const char * arm_attr_tag_ABI_FP_number_model[] =
13457 {"Unused", "Finite", "RTABI", "IEEE 754"};
13458 static const char * arm_attr_tag_ABI_enum_size[] =
13459 {"Unused", "small", "int", "forced to int"};
13460 static const char * arm_attr_tag_ABI_HardFP_use[] =
13461 {"As Tag_FP_arch", "SP only", "Reserved", "Deprecated"};
13462 static const char * arm_attr_tag_ABI_VFP_args[] =
13463 {"AAPCS", "VFP registers", "custom", "compatible"};
13464 static const char * arm_attr_tag_ABI_WMMX_args[] =
13465 {"AAPCS", "WMMX registers", "custom"};
13466 static const char * arm_attr_tag_ABI_optimization_goals[] =
13467 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
13468 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
13469 static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
13470 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
13471 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
13472 static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
13473 static const char * arm_attr_tag_FP_HP_extension[] =
13474 {"Not Allowed", "Allowed"};
13475 static const char * arm_attr_tag_ABI_FP_16bit_format[] =
13476 {"None", "IEEE 754", "Alternative Format"};
13477 static const char * arm_attr_tag_DSP_extension[] =
13478 {"Follow architecture", "Allowed"};
13479 static const char * arm_attr_tag_MPextension_use[] =
13480 {"Not Allowed", "Allowed"};
13481 static const char * arm_attr_tag_DIV_use[] =
13482 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
13483 "Allowed in v7-A with integer division extension"};
13484 static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
13485 static const char * arm_attr_tag_Virtualization_use[] =
13486 {"Not Allowed", "TrustZone", "Virtualization Extensions",
13487 "TrustZone and Virtualization Extensions"};
13488 static const char * arm_attr_tag_MPextension_use_legacy[] =
13489 {"Not Allowed", "Allowed"};
13491 #define LOOKUP(id, name) \
13492 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
13493 static arm_attr_public_tag arm_attr_public_tags[] =
13495 {4, "CPU_raw_name", 1, NULL},
13496 {5, "CPU_name", 1, NULL},
13497 LOOKUP(6, CPU_arch),
13498 {7, "CPU_arch_profile", 0, NULL},
13499 LOOKUP(8, ARM_ISA_use),
13500 LOOKUP(9, THUMB_ISA_use),
13501 LOOKUP(10, FP_arch),
13502 LOOKUP(11, WMMX_arch),
13503 LOOKUP(12, Advanced_SIMD_arch),
13504 LOOKUP(13, PCS_config),
13505 LOOKUP(14, ABI_PCS_R9_use),
13506 LOOKUP(15, ABI_PCS_RW_data),
13507 LOOKUP(16, ABI_PCS_RO_data),
13508 LOOKUP(17, ABI_PCS_GOT_use),
13509 LOOKUP(18, ABI_PCS_wchar_t),
13510 LOOKUP(19, ABI_FP_rounding),
13511 LOOKUP(20, ABI_FP_denormal),
13512 LOOKUP(21, ABI_FP_exceptions),
13513 LOOKUP(22, ABI_FP_user_exceptions),
13514 LOOKUP(23, ABI_FP_number_model),
13515 {24, "ABI_align_needed", 0, NULL},
13516 {25, "ABI_align_preserved", 0, NULL},
13517 LOOKUP(26, ABI_enum_size),
13518 LOOKUP(27, ABI_HardFP_use),
13519 LOOKUP(28, ABI_VFP_args),
13520 LOOKUP(29, ABI_WMMX_args),
13521 LOOKUP(30, ABI_optimization_goals),
13522 LOOKUP(31, ABI_FP_optimization_goals),
13523 {32, "compatibility", 0, NULL},
13524 LOOKUP(34, CPU_unaligned_access),
13525 LOOKUP(36, FP_HP_extension),
13526 LOOKUP(38, ABI_FP_16bit_format),
13527 LOOKUP(42, MPextension_use),
13528 LOOKUP(44, DIV_use),
13529 LOOKUP(46, DSP_extension),
13530 {64, "nodefaults", 0, NULL},
13531 {65, "also_compatible_with", 0, NULL},
13532 LOOKUP(66, T2EE_use),
13533 {67, "conformance", 1, NULL},
13534 LOOKUP(68, Virtualization_use),
13535 LOOKUP(70, MPextension_use_legacy)
13539 static unsigned char *
13540 display_arm_attribute (unsigned char * p,
13541 const unsigned char * const end)
13546 arm_attr_public_tag * attr;
13550 tag = read_uleb128 (p, &len, end);
13553 for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
13555 if (arm_attr_public_tags[i].tag == tag)
13557 attr = &arm_attr_public_tags[i];
13564 printf (" Tag_%s: ", attr->name);
13565 switch (attr->type)
13570 case 7: /* Tag_CPU_arch_profile. */
13571 val = read_uleb128 (p, &len, end);
13575 case 0: printf (_("None\n")); break;
13576 case 'A': printf (_("Application\n")); break;
13577 case 'R': printf (_("Realtime\n")); break;
13578 case 'M': printf (_("Microcontroller\n")); break;
13579 case 'S': printf (_("Application or Realtime\n")); break;
13580 default: printf ("??? (%d)\n", val); break;
13584 case 24: /* Tag_align_needed. */
13585 val = read_uleb128 (p, &len, end);
13589 case 0: printf (_("None\n")); break;
13590 case 1: printf (_("8-byte\n")); break;
13591 case 2: printf (_("4-byte\n")); break;
13592 case 3: printf ("??? 3\n"); break;
13595 printf (_("8-byte and up to %d-byte extended\n"),
13598 printf ("??? (%d)\n", val);
13603 case 25: /* Tag_align_preserved. */
13604 val = read_uleb128 (p, &len, end);
13608 case 0: printf (_("None\n")); break;
13609 case 1: printf (_("8-byte, except leaf SP\n")); break;
13610 case 2: printf (_("8-byte\n")); break;
13611 case 3: printf ("??? 3\n"); break;
13614 printf (_("8-byte and up to %d-byte extended\n"),
13617 printf ("??? (%d)\n", val);
13622 case 32: /* Tag_compatibility. */
13624 val = read_uleb128 (p, &len, end);
13626 printf (_("flag = %d, vendor = "), val);
13629 size_t maxlen = (end - p) - 1;
13631 print_symbol ((int) maxlen, (const char *) p);
13632 p += strnlen ((char *) p, maxlen) + 1;
13636 printf (_("<corrupt>"));
13637 p = (unsigned char *) end;
13643 case 64: /* Tag_nodefaults. */
13644 /* PR 17531: file: 001-505008-0.01. */
13647 printf (_("True\n"));
13650 case 65: /* Tag_also_compatible_with. */
13651 val = read_uleb128 (p, &len, end);
13653 if (val == 6 /* Tag_CPU_arch. */)
13655 val = read_uleb128 (p, &len, end);
13657 if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
13658 printf ("??? (%d)\n", val);
13660 printf ("%s\n", arm_attr_tag_CPU_arch[val]);
13664 while (p < end && *(p++) != '\0' /* NUL terminator. */)
13669 printf (_("<unknown: %d>\n"), tag);
13675 return display_tag_value (-1, p, end);
13677 return display_tag_value (0, p, end);
13680 assert (attr->type & 0x80);
13681 val = read_uleb128 (p, &len, end);
13683 type = attr->type & 0x7f;
13685 printf ("??? (%d)\n", val);
13687 printf ("%s\n", attr->table[val]);
13692 return display_tag_value (tag, p, end);
13695 static unsigned char *
13696 display_gnu_attribute (unsigned char * p,
13697 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const),
13698 const unsigned char * const end)
13704 tag = read_uleb128 (p, &len, end);
13707 /* Tag_compatibility is the only generic GNU attribute defined at
13711 val = read_uleb128 (p, &len, end);
13714 printf (_("flag = %d, vendor = "), val);
13717 printf (_("<corrupt>\n"));
13718 warn (_("corrupt vendor attribute\n"));
13724 size_t maxlen = (end - p) - 1;
13726 print_symbol ((int) maxlen, (const char *) p);
13727 p += strnlen ((char *) p, maxlen) + 1;
13731 printf (_("<corrupt>"));
13732 p = (unsigned char *) end;
13739 if ((tag & 2) == 0 && display_proc_gnu_attribute)
13740 return display_proc_gnu_attribute (p, tag, end);
13742 return display_tag_value (tag, p, end);
13745 static unsigned char *
13746 display_power_gnu_attribute (unsigned char * p,
13748 const unsigned char * const end)
13753 if (tag == Tag_GNU_Power_ABI_FP)
13755 val = read_uleb128 (p, &len, end);
13757 printf (" Tag_GNU_Power_ABI_FP: ");
13760 printf (_("<corrupt>\n"));
13765 printf ("(%#x), ", val);
13770 printf (_("unspecified hard/soft float, "));
13773 printf (_("hard float, "));
13776 printf (_("soft float, "));
13779 printf (_("single-precision hard float, "));
13786 printf (_("unspecified long double\n"));
13789 printf (_("128-bit IBM long double\n"));
13792 printf (_("64-bit long double\n"));
13795 printf (_("128-bit IEEE long double\n"));
13801 if (tag == Tag_GNU_Power_ABI_Vector)
13803 val = read_uleb128 (p, &len, end);
13805 printf (" Tag_GNU_Power_ABI_Vector: ");
13808 printf (_("<corrupt>\n"));
13813 printf ("(%#x), ", val);
13818 printf (_("unspecified\n"));
13821 printf (_("generic\n"));
13824 printf ("AltiVec\n");
13833 if (tag == Tag_GNU_Power_ABI_Struct_Return)
13835 val = read_uleb128 (p, &len, end);
13837 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
13840 printf (_("<corrupt>\n"));
13845 printf ("(%#x), ", val);
13850 printf (_("unspecified\n"));
13853 printf ("r3/r4\n");
13856 printf (_("memory\n"));
13865 return display_tag_value (tag & 1, p, end);
13868 static unsigned char *
13869 display_s390_gnu_attribute (unsigned char * p,
13871 const unsigned char * const end)
13876 if (tag == Tag_GNU_S390_ABI_Vector)
13878 val = read_uleb128 (p, &len, end);
13880 printf (" Tag_GNU_S390_ABI_Vector: ");
13885 printf (_("any\n"));
13888 printf (_("software\n"));
13891 printf (_("hardware\n"));
13894 printf ("??? (%d)\n", val);
13900 return display_tag_value (tag & 1, p, end);
13904 display_sparc_hwcaps (unsigned int mask)
13908 bfd_boolean first = TRUE;
13910 if (mask & ELF_SPARC_HWCAP_MUL32)
13911 fputs ("mul32", stdout), first = FALSE;
13912 if (mask & ELF_SPARC_HWCAP_DIV32)
13913 printf ("%sdiv32", first ? "" : "|"), first = FALSE;
13914 if (mask & ELF_SPARC_HWCAP_FSMULD)
13915 printf ("%sfsmuld", first ? "" : "|"), first = FALSE;
13916 if (mask & ELF_SPARC_HWCAP_V8PLUS)
13917 printf ("%sv8plus", first ? "" : "|"), first = FALSE;
13918 if (mask & ELF_SPARC_HWCAP_POPC)
13919 printf ("%spopc", first ? "" : "|"), first = FALSE;
13920 if (mask & ELF_SPARC_HWCAP_VIS)
13921 printf ("%svis", first ? "" : "|"), first = FALSE;
13922 if (mask & ELF_SPARC_HWCAP_VIS2)
13923 printf ("%svis2", first ? "" : "|"), first = FALSE;
13924 if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
13925 printf ("%sASIBlkInit", first ? "" : "|"), first = FALSE;
13926 if (mask & ELF_SPARC_HWCAP_FMAF)
13927 printf ("%sfmaf", first ? "" : "|"), first = FALSE;
13928 if (mask & ELF_SPARC_HWCAP_VIS3)
13929 printf ("%svis3", first ? "" : "|"), first = FALSE;
13930 if (mask & ELF_SPARC_HWCAP_HPC)
13931 printf ("%shpc", first ? "" : "|"), first = FALSE;
13932 if (mask & ELF_SPARC_HWCAP_RANDOM)
13933 printf ("%srandom", first ? "" : "|"), first = FALSE;
13934 if (mask & ELF_SPARC_HWCAP_TRANS)
13935 printf ("%strans", first ? "" : "|"), first = FALSE;
13936 if (mask & ELF_SPARC_HWCAP_FJFMAU)
13937 printf ("%sfjfmau", first ? "" : "|"), first = FALSE;
13938 if (mask & ELF_SPARC_HWCAP_IMA)
13939 printf ("%sima", first ? "" : "|"), first = FALSE;
13940 if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
13941 printf ("%scspare", first ? "" : "|"), first = FALSE;
13944 fputc ('0', stdout);
13945 fputc ('\n', stdout);
13949 display_sparc_hwcaps2 (unsigned int mask)
13953 bfd_boolean first = TRUE;
13955 if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
13956 fputs ("fjathplus", stdout), first = FALSE;
13957 if (mask & ELF_SPARC_HWCAP2_VIS3B)
13958 printf ("%svis3b", first ? "" : "|"), first = FALSE;
13959 if (mask & ELF_SPARC_HWCAP2_ADP)
13960 printf ("%sadp", first ? "" : "|"), first = FALSE;
13961 if (mask & ELF_SPARC_HWCAP2_SPARC5)
13962 printf ("%ssparc5", first ? "" : "|"), first = FALSE;
13963 if (mask & ELF_SPARC_HWCAP2_MWAIT)
13964 printf ("%smwait", first ? "" : "|"), first = FALSE;
13965 if (mask & ELF_SPARC_HWCAP2_XMPMUL)
13966 printf ("%sxmpmul", first ? "" : "|"), first = FALSE;
13967 if (mask & ELF_SPARC_HWCAP2_XMONT)
13968 printf ("%sxmont2", first ? "" : "|"), first = FALSE;
13969 if (mask & ELF_SPARC_HWCAP2_NSEC)
13970 printf ("%snsec", first ? "" : "|"), first = FALSE;
13971 if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
13972 printf ("%sfjathhpc", first ? "" : "|"), first = FALSE;
13973 if (mask & ELF_SPARC_HWCAP2_FJDES)
13974 printf ("%sfjdes", first ? "" : "|"), first = FALSE;
13975 if (mask & ELF_SPARC_HWCAP2_FJAES)
13976 printf ("%sfjaes", first ? "" : "|"), first = FALSE;
13979 fputc ('0', stdout);
13980 fputc ('\n', stdout);
13983 static unsigned char *
13984 display_sparc_gnu_attribute (unsigned char * p,
13986 const unsigned char * const end)
13991 if (tag == Tag_GNU_Sparc_HWCAPS)
13993 val = read_uleb128 (p, &len, end);
13995 printf (" Tag_GNU_Sparc_HWCAPS: ");
13996 display_sparc_hwcaps (val);
13999 if (tag == Tag_GNU_Sparc_HWCAPS2)
14001 val = read_uleb128 (p, &len, end);
14003 printf (" Tag_GNU_Sparc_HWCAPS2: ");
14004 display_sparc_hwcaps2 (val);
14008 return display_tag_value (tag, p, end);
14012 print_mips_fp_abi_value (unsigned int val)
14016 case Val_GNU_MIPS_ABI_FP_ANY:
14017 printf (_("Hard or soft float\n"));
14019 case Val_GNU_MIPS_ABI_FP_DOUBLE:
14020 printf (_("Hard float (double precision)\n"));
14022 case Val_GNU_MIPS_ABI_FP_SINGLE:
14023 printf (_("Hard float (single precision)\n"));
14025 case Val_GNU_MIPS_ABI_FP_SOFT:
14026 printf (_("Soft float\n"));
14028 case Val_GNU_MIPS_ABI_FP_OLD_64:
14029 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
14031 case Val_GNU_MIPS_ABI_FP_XX:
14032 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
14034 case Val_GNU_MIPS_ABI_FP_64:
14035 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
14037 case Val_GNU_MIPS_ABI_FP_64A:
14038 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
14040 case Val_GNU_MIPS_ABI_FP_NAN2008:
14041 printf (_("NaN 2008 compatibility\n"));
14044 printf ("??? (%d)\n", val);
14049 static unsigned char *
14050 display_mips_gnu_attribute (unsigned char * p,
14052 const unsigned char * const end)
14054 if (tag == Tag_GNU_MIPS_ABI_FP)
14059 val = read_uleb128 (p, &len, end);
14061 printf (" Tag_GNU_MIPS_ABI_FP: ");
14063 print_mips_fp_abi_value (val);
14068 if (tag == Tag_GNU_MIPS_ABI_MSA)
14073 val = read_uleb128 (p, &len, end);
14075 printf (" Tag_GNU_MIPS_ABI_MSA: ");
14079 case Val_GNU_MIPS_ABI_MSA_ANY:
14080 printf (_("Any MSA or not\n"));
14082 case Val_GNU_MIPS_ABI_MSA_128:
14083 printf (_("128-bit MSA\n"));
14086 printf ("??? (%d)\n", val);
14092 return display_tag_value (tag & 1, p, end);
14095 static unsigned char *
14096 display_tic6x_attribute (unsigned char * p,
14097 const unsigned char * const end)
14103 tag = read_uleb128 (p, &len, end);
14109 val = read_uleb128 (p, &len, end);
14111 printf (" Tag_ISA: ");
14115 case C6XABI_Tag_ISA_none:
14116 printf (_("None\n"));
14118 case C6XABI_Tag_ISA_C62X:
14121 case C6XABI_Tag_ISA_C67X:
14124 case C6XABI_Tag_ISA_C67XP:
14125 printf ("C67x+\n");
14127 case C6XABI_Tag_ISA_C64X:
14130 case C6XABI_Tag_ISA_C64XP:
14131 printf ("C64x+\n");
14133 case C6XABI_Tag_ISA_C674X:
14134 printf ("C674x\n");
14137 printf ("??? (%d)\n", val);
14142 case Tag_ABI_wchar_t:
14143 val = read_uleb128 (p, &len, end);
14145 printf (" Tag_ABI_wchar_t: ");
14149 printf (_("Not used\n"));
14152 printf (_("2 bytes\n"));
14155 printf (_("4 bytes\n"));
14158 printf ("??? (%d)\n", val);
14163 case Tag_ABI_stack_align_needed:
14164 val = read_uleb128 (p, &len, end);
14166 printf (" Tag_ABI_stack_align_needed: ");
14170 printf (_("8-byte\n"));
14173 printf (_("16-byte\n"));
14176 printf ("??? (%d)\n", val);
14181 case Tag_ABI_stack_align_preserved:
14182 val = read_uleb128 (p, &len, end);
14184 printf (" Tag_ABI_stack_align_preserved: ");
14188 printf (_("8-byte\n"));
14191 printf (_("16-byte\n"));
14194 printf ("??? (%d)\n", val);
14200 val = read_uleb128 (p, &len, end);
14202 printf (" Tag_ABI_DSBT: ");
14206 printf (_("DSBT addressing not used\n"));
14209 printf (_("DSBT addressing used\n"));
14212 printf ("??? (%d)\n", val);
14218 val = read_uleb128 (p, &len, end);
14220 printf (" Tag_ABI_PID: ");
14224 printf (_("Data addressing position-dependent\n"));
14227 printf (_("Data addressing position-independent, GOT near DP\n"));
14230 printf (_("Data addressing position-independent, GOT far from DP\n"));
14233 printf ("??? (%d)\n", val);
14239 val = read_uleb128 (p, &len, end);
14241 printf (" Tag_ABI_PIC: ");
14245 printf (_("Code addressing position-dependent\n"));
14248 printf (_("Code addressing position-independent\n"));
14251 printf ("??? (%d)\n", val);
14256 case Tag_ABI_array_object_alignment:
14257 val = read_uleb128 (p, &len, end);
14259 printf (" Tag_ABI_array_object_alignment: ");
14263 printf (_("8-byte\n"));
14266 printf (_("4-byte\n"));
14269 printf (_("16-byte\n"));
14272 printf ("??? (%d)\n", val);
14277 case Tag_ABI_array_object_align_expected:
14278 val = read_uleb128 (p, &len, end);
14280 printf (" Tag_ABI_array_object_align_expected: ");
14284 printf (_("8-byte\n"));
14287 printf (_("4-byte\n"));
14290 printf (_("16-byte\n"));
14293 printf ("??? (%d)\n", val);
14298 case Tag_ABI_compatibility:
14300 val = read_uleb128 (p, &len, end);
14302 printf (" Tag_ABI_compatibility: ");
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 Tag_ABI_conformance:
14322 printf (" Tag_ABI_conformance: \"");
14325 size_t maxlen = (end - p) - 1;
14327 print_symbol ((int) maxlen, (const char *) p);
14328 p += strnlen ((char *) p, maxlen) + 1;
14332 printf (_("<corrupt>"));
14333 p = (unsigned char *) end;
14340 return display_tag_value (tag, p, end);
14344 display_raw_attribute (unsigned char * p, unsigned char const * const end)
14346 unsigned long addr = 0;
14347 size_t bytes = end - p;
14354 int lbytes = (bytes > 16 ? 16 : bytes);
14356 printf (" 0x%8.8lx ", addr);
14358 for (j = 0; j < 16; j++)
14361 printf ("%2.2x", p[j]);
14369 for (j = 0; j < lbytes; j++)
14372 if (k >= ' ' && k < 0x7f)
14388 static unsigned char *
14389 display_msp430x_attribute (unsigned char * p,
14390 const unsigned char * const end)
14396 tag = read_uleb128 (p, & len, end);
14401 case OFBA_MSPABI_Tag_ISA:
14402 val = read_uleb128 (p, &len, end);
14404 printf (" Tag_ISA: ");
14407 case 0: printf (_("None\n")); break;
14408 case 1: printf (_("MSP430\n")); break;
14409 case 2: printf (_("MSP430X\n")); break;
14410 default: printf ("??? (%d)\n", val); break;
14414 case OFBA_MSPABI_Tag_Code_Model:
14415 val = read_uleb128 (p, &len, end);
14417 printf (" Tag_Code_Model: ");
14420 case 0: printf (_("None\n")); break;
14421 case 1: printf (_("Small\n")); break;
14422 case 2: printf (_("Large\n")); break;
14423 default: printf ("??? (%d)\n", val); break;
14427 case OFBA_MSPABI_Tag_Data_Model:
14428 val = read_uleb128 (p, &len, end);
14430 printf (" Tag_Data_Model: ");
14433 case 0: printf (_("None\n")); break;
14434 case 1: printf (_("Small\n")); break;
14435 case 2: printf (_("Large\n")); break;
14436 case 3: printf (_("Restricted Large\n")); break;
14437 default: printf ("??? (%d)\n", val); break;
14442 printf (_(" <unknown tag %d>: "), tag);
14449 size_t maxlen = (end - p) - 1;
14451 print_symbol ((int) maxlen, (const char *) p);
14452 p += strnlen ((char *) p, maxlen) + 1;
14456 printf (_("<corrupt>"));
14457 p = (unsigned char *) end;
14463 val = read_uleb128 (p, &len, end);
14465 printf ("%d (0x%x)\n", val, val);
14475 process_attributes (FILE * file,
14476 const char * public_name,
14477 unsigned int proc_type,
14478 unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
14479 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, unsigned int, const unsigned char * const))
14481 Elf_Internal_Shdr * sect;
14483 bfd_boolean res = TRUE;
14485 /* Find the section header so that we get the size. */
14486 for (i = 0, sect = section_headers;
14487 i < elf_header.e_shnum;
14490 unsigned char * contents;
14493 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
14496 contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
14497 sect->sh_size, _("attributes"));
14498 if (contents == NULL)
14505 /* The first character is the version of the attributes.
14506 Currently only version 1, (aka 'A') is recognised here. */
14509 printf (_("Unknown attributes version '%c'(%d) - expecting 'A'\n"), *p, *p);
14514 bfd_vma section_len;
14516 section_len = sect->sh_size - 1;
14519 while (section_len > 0)
14522 unsigned int namelen;
14523 bfd_boolean public_section;
14524 bfd_boolean gnu_section;
14526 if (section_len <= 4)
14528 error (_("Tag section ends prematurely\n"));
14532 attr_len = byte_get (p, 4);
14535 if (attr_len > section_len)
14537 error (_("Bad attribute length (%u > %u)\n"),
14538 (unsigned) attr_len, (unsigned) section_len);
14539 attr_len = section_len;
14542 /* PR 17531: file: 001-101425-0.004 */
14543 else if (attr_len < 5)
14545 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
14550 section_len -= attr_len;
14553 namelen = strnlen ((char *) p, attr_len) + 1;
14554 if (namelen == 0 || namelen >= attr_len)
14556 error (_("Corrupt attribute section name\n"));
14561 printf (_("Attribute Section: "));
14562 print_symbol (INT_MAX, (const char *) p);
14565 if (public_name && streq ((char *) p, public_name))
14566 public_section = TRUE;
14568 public_section = FALSE;
14570 if (streq ((char *) p, "gnu"))
14571 gnu_section = TRUE;
14573 gnu_section = FALSE;
14576 attr_len -= namelen;
14578 while (attr_len > 0 && p < contents + sect->sh_size)
14583 unsigned char * end;
14585 /* PR binutils/17531: Safe handling of corrupt files. */
14588 error (_("Unused bytes at end of section\n"));
14595 size = byte_get (p, 4);
14596 if (size > attr_len)
14598 error (_("Bad subsection length (%u > %u)\n"),
14599 (unsigned) size, (unsigned) attr_len);
14603 /* PR binutils/17531: Safe handling of corrupt files. */
14606 error (_("Bad subsection length (%u < 6)\n"),
14614 end = p + size - 1;
14615 assert (end <= contents + sect->sh_size);
14621 printf (_("File Attributes\n"));
14624 printf (_("Section Attributes:"));
14627 printf (_("Symbol Attributes:"));
14628 /* Fall through. */
14634 val = read_uleb128 (p, &j, end);
14638 printf (" %d", val);
14643 printf (_("Unknown tag: %d\n"), tag);
14644 public_section = FALSE;
14648 if (public_section && display_pub_attribute != NULL)
14651 p = display_pub_attribute (p, end);
14654 else if (gnu_section && display_proc_gnu_attribute != NULL)
14657 p = display_gnu_attribute (p,
14658 display_proc_gnu_attribute,
14664 printf (_(" Unknown attribute:\n"));
14665 display_raw_attribute (p, end);
14680 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
14681 Print the Address, Access and Initial fields of an entry at VMA ADDR
14682 and return the VMA of the next entry, or -1 if there was a problem.
14683 Does not read from DATA_END or beyond. */
14686 print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
14687 unsigned char * data_end)
14690 print_vma (addr, LONG_HEX);
14692 if (addr < pltgot + 0xfff0)
14693 printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
14695 printf ("%10s", "");
14698 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
14702 unsigned char * from = data + addr - pltgot;
14704 if (from + (is_32bit_elf ? 4 : 8) > data_end)
14706 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
14707 printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
14708 return (bfd_vma) -1;
14712 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
14713 print_vma (entry, LONG_HEX);
14716 return addr + (is_32bit_elf ? 4 : 8);
14719 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
14720 PLTGOT. Print the Address and Initial fields of an entry at VMA
14721 ADDR and return the VMA of the next entry. */
14724 print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
14727 print_vma (addr, LONG_HEX);
14730 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
14735 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
14736 print_vma (entry, LONG_HEX);
14738 return addr + (is_32bit_elf ? 4 : 8);
14742 print_mips_ases (unsigned int mask)
14744 if (mask & AFL_ASE_DSP)
14745 fputs ("\n\tDSP ASE", stdout);
14746 if (mask & AFL_ASE_DSPR2)
14747 fputs ("\n\tDSP R2 ASE", stdout);
14748 if (mask & AFL_ASE_DSPR3)
14749 fputs ("\n\tDSP R3 ASE", stdout);
14750 if (mask & AFL_ASE_EVA)
14751 fputs ("\n\tEnhanced VA Scheme", stdout);
14752 if (mask & AFL_ASE_MCU)
14753 fputs ("\n\tMCU (MicroController) ASE", stdout);
14754 if (mask & AFL_ASE_MDMX)
14755 fputs ("\n\tMDMX ASE", stdout);
14756 if (mask & AFL_ASE_MIPS3D)
14757 fputs ("\n\tMIPS-3D ASE", stdout);
14758 if (mask & AFL_ASE_MT)
14759 fputs ("\n\tMT ASE", stdout);
14760 if (mask & AFL_ASE_SMARTMIPS)
14761 fputs ("\n\tSmartMIPS ASE", stdout);
14762 if (mask & AFL_ASE_VIRT)
14763 fputs ("\n\tVZ ASE", stdout);
14764 if (mask & AFL_ASE_MSA)
14765 fputs ("\n\tMSA ASE", stdout);
14766 if (mask & AFL_ASE_MIPS16)
14767 fputs ("\n\tMIPS16 ASE", stdout);
14768 if (mask & AFL_ASE_MICROMIPS)
14769 fputs ("\n\tMICROMIPS ASE", stdout);
14770 if (mask & AFL_ASE_XPA)
14771 fputs ("\n\tXPA ASE", stdout);
14773 fprintf (stdout, "\n\t%s", _("None"));
14774 else if ((mask & ~AFL_ASE_MASK) != 0)
14775 fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
14779 print_mips_isa_ext (unsigned int isa_ext)
14784 fputs (_("None"), stdout);
14787 fputs ("RMI XLR", stdout);
14789 case AFL_EXT_OCTEON3:
14790 fputs ("Cavium Networks Octeon3", stdout);
14792 case AFL_EXT_OCTEON2:
14793 fputs ("Cavium Networks Octeon2", stdout);
14795 case AFL_EXT_OCTEONP:
14796 fputs ("Cavium Networks OcteonP", stdout);
14798 case AFL_EXT_LOONGSON_3A:
14799 fputs ("Loongson 3A", stdout);
14801 case AFL_EXT_OCTEON:
14802 fputs ("Cavium Networks Octeon", stdout);
14805 fputs ("Toshiba R5900", stdout);
14808 fputs ("MIPS R4650", stdout);
14811 fputs ("LSI R4010", stdout);
14814 fputs ("NEC VR4100", stdout);
14817 fputs ("Toshiba R3900", stdout);
14819 case AFL_EXT_10000:
14820 fputs ("MIPS R10000", stdout);
14823 fputs ("Broadcom SB-1", stdout);
14826 fputs ("NEC VR4111/VR4181", stdout);
14829 fputs ("NEC VR4120", stdout);
14832 fputs ("NEC VR5400", stdout);
14835 fputs ("NEC VR5500", stdout);
14837 case AFL_EXT_LOONGSON_2E:
14838 fputs ("ST Microelectronics Loongson 2E", stdout);
14840 case AFL_EXT_LOONGSON_2F:
14841 fputs ("ST Microelectronics Loongson 2F", stdout);
14844 fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
14849 get_mips_reg_size (int reg_size)
14851 return (reg_size == AFL_REG_NONE) ? 0
14852 : (reg_size == AFL_REG_32) ? 32
14853 : (reg_size == AFL_REG_64) ? 64
14854 : (reg_size == AFL_REG_128) ? 128
14859 process_mips_specific (FILE * file)
14861 Elf_Internal_Dyn * entry;
14862 Elf_Internal_Shdr *sect = NULL;
14863 size_t liblist_offset = 0;
14864 size_t liblistno = 0;
14865 size_t conflictsno = 0;
14866 size_t options_offset = 0;
14867 size_t conflicts_offset = 0;
14868 size_t pltrelsz = 0;
14870 bfd_vma pltgot = 0;
14871 bfd_vma mips_pltgot = 0;
14872 bfd_vma jmprel = 0;
14873 bfd_vma local_gotno = 0;
14874 bfd_vma gotsym = 0;
14875 bfd_vma symtabno = 0;
14876 bfd_boolean res = TRUE;
14878 if (! process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
14879 display_mips_gnu_attribute))
14882 sect = find_section (".MIPS.abiflags");
14886 Elf_External_ABIFlags_v0 *abiflags_ext;
14887 Elf_Internal_ABIFlags_v0 abiflags_in;
14889 if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
14891 error (_("Corrupt MIPS ABI Flags section.\n"));
14896 abiflags_ext = get_data (NULL, file, sect->sh_offset, 1,
14897 sect->sh_size, _("MIPS ABI Flags section"));
14900 abiflags_in.version = BYTE_GET (abiflags_ext->version);
14901 abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
14902 abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
14903 abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
14904 abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
14905 abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
14906 abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
14907 abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
14908 abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
14909 abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
14910 abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
14912 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
14913 printf ("\nISA: MIPS%d", abiflags_in.isa_level);
14914 if (abiflags_in.isa_rev > 1)
14915 printf ("r%d", abiflags_in.isa_rev);
14916 printf ("\nGPR size: %d",
14917 get_mips_reg_size (abiflags_in.gpr_size));
14918 printf ("\nCPR1 size: %d",
14919 get_mips_reg_size (abiflags_in.cpr1_size));
14920 printf ("\nCPR2 size: %d",
14921 get_mips_reg_size (abiflags_in.cpr2_size));
14922 fputs ("\nFP ABI: ", stdout);
14923 print_mips_fp_abi_value (abiflags_in.fp_abi);
14924 fputs ("ISA Extension: ", stdout);
14925 print_mips_isa_ext (abiflags_in.isa_ext);
14926 fputs ("\nASEs:", stdout);
14927 print_mips_ases (abiflags_in.ases);
14928 printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
14929 printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
14930 fputc ('\n', stdout);
14931 free (abiflags_ext);
14936 /* We have a lot of special sections. Thanks SGI! */
14937 if (dynamic_section == NULL)
14938 /* No information available. */
14941 for (entry = dynamic_section;
14942 /* PR 17531 file: 012-50589-0.004. */
14943 entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
14945 switch (entry->d_tag)
14947 case DT_MIPS_LIBLIST:
14949 = offset_from_vma (file, entry->d_un.d_val,
14950 liblistno * sizeof (Elf32_External_Lib));
14952 case DT_MIPS_LIBLISTNO:
14953 liblistno = entry->d_un.d_val;
14955 case DT_MIPS_OPTIONS:
14956 options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
14958 case DT_MIPS_CONFLICT:
14960 = offset_from_vma (file, entry->d_un.d_val,
14961 conflictsno * sizeof (Elf32_External_Conflict));
14963 case DT_MIPS_CONFLICTNO:
14964 conflictsno = entry->d_un.d_val;
14967 pltgot = entry->d_un.d_ptr;
14969 case DT_MIPS_LOCAL_GOTNO:
14970 local_gotno = entry->d_un.d_val;
14972 case DT_MIPS_GOTSYM:
14973 gotsym = entry->d_un.d_val;
14975 case DT_MIPS_SYMTABNO:
14976 symtabno = entry->d_un.d_val;
14978 case DT_MIPS_PLTGOT:
14979 mips_pltgot = entry->d_un.d_ptr;
14982 pltrel = entry->d_un.d_val;
14985 pltrelsz = entry->d_un.d_val;
14988 jmprel = entry->d_un.d_ptr;
14994 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
14996 Elf32_External_Lib * elib;
14999 elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
15001 sizeof (Elf32_External_Lib),
15002 _("liblist section data"));
15005 printf (_("\nSection '.liblist' contains %lu entries:\n"),
15006 (unsigned long) liblistno);
15007 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
15010 for (cnt = 0; cnt < liblistno; ++cnt)
15017 liblist.l_name = BYTE_GET (elib[cnt].l_name);
15018 atime = BYTE_GET (elib[cnt].l_time_stamp);
15019 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
15020 liblist.l_version = BYTE_GET (elib[cnt].l_version);
15021 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
15023 tmp = gmtime (&atime);
15024 snprintf (timebuf, sizeof (timebuf),
15025 "%04u-%02u-%02uT%02u:%02u:%02u",
15026 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
15027 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
15029 printf ("%3lu: ", (unsigned long) cnt);
15030 if (VALID_DYNAMIC_NAME (liblist.l_name))
15031 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
15033 printf (_("<corrupt: %9ld>"), liblist.l_name);
15034 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
15035 liblist.l_version);
15037 if (liblist.l_flags == 0)
15041 static const struct
15048 { " EXACT_MATCH", LL_EXACT_MATCH },
15049 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
15050 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
15051 { " EXPORTS", LL_EXPORTS },
15052 { " DELAY_LOAD", LL_DELAY_LOAD },
15053 { " DELTA", LL_DELTA }
15055 int flags = liblist.l_flags;
15058 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
15059 if ((flags & l_flags_vals[fcnt].bit) != 0)
15061 fputs (l_flags_vals[fcnt].name, stdout);
15062 flags ^= l_flags_vals[fcnt].bit;
15065 printf (" %#x", (unsigned int) flags);
15077 if (options_offset != 0)
15079 Elf_External_Options * eopt;
15080 Elf_Internal_Options * iopt;
15081 Elf_Internal_Options * option;
15084 sect = section_headers;
15086 /* Find the section header so that we get the size. */
15087 sect = find_section_by_type (SHT_MIPS_OPTIONS);
15088 /* PR 17533 file: 012-277276-0.004. */
15091 error (_("No MIPS_OPTIONS header found\n"));
15095 eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
15096 sect->sh_size, _("options"));
15099 iopt = (Elf_Internal_Options *)
15100 cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
15103 error (_("Out of memory allocating space for MIPS options\n"));
15110 while (offset <= sect->sh_size - sizeof (* eopt))
15112 Elf_External_Options * eoption;
15114 eoption = (Elf_External_Options *) ((char *) eopt + offset);
15116 option->kind = BYTE_GET (eoption->kind);
15117 option->size = BYTE_GET (eoption->size);
15118 option->section = BYTE_GET (eoption->section);
15119 option->info = BYTE_GET (eoption->info);
15121 /* PR 17531: file: ffa0fa3b. */
15122 if (option->size < sizeof (* eopt)
15123 || offset + option->size > sect->sh_size)
15125 error (_("Invalid size (%u) for MIPS option\n"), option->size);
15128 offset += option->size;
15134 printf (_("\nSection '%s' contains %d entries:\n"),
15135 printable_section_name (sect), cnt);
15144 switch (option->kind)
15147 /* This shouldn't happen. */
15148 printf (" NULL %d %lx", option->section, option->info);
15151 printf (" REGINFO ");
15152 if (elf_header.e_machine == EM_MIPS)
15155 Elf32_External_RegInfo * ereg;
15156 Elf32_RegInfo reginfo;
15158 ereg = (Elf32_External_RegInfo *) (option + 1);
15159 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
15160 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
15161 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
15162 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
15163 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
15164 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
15166 printf ("GPR %08lx GP 0x%lx\n",
15167 reginfo.ri_gprmask,
15168 (unsigned long) reginfo.ri_gp_value);
15169 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
15170 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
15171 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
15176 Elf64_External_RegInfo * ereg;
15177 Elf64_Internal_RegInfo reginfo;
15179 ereg = (Elf64_External_RegInfo *) (option + 1);
15180 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
15181 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
15182 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
15183 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
15184 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
15185 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
15187 printf ("GPR %08lx GP 0x",
15188 reginfo.ri_gprmask);
15189 printf_vma (reginfo.ri_gp_value);
15192 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
15193 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
15194 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
15198 case ODK_EXCEPTIONS:
15199 fputs (" EXCEPTIONS fpe_min(", stdout);
15200 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
15201 fputs (") fpe_max(", stdout);
15202 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
15203 fputs (")", stdout);
15205 if (option->info & OEX_PAGE0)
15206 fputs (" PAGE0", stdout);
15207 if (option->info & OEX_SMM)
15208 fputs (" SMM", stdout);
15209 if (option->info & OEX_FPDBUG)
15210 fputs (" FPDBUG", stdout);
15211 if (option->info & OEX_DISMISS)
15212 fputs (" DISMISS", stdout);
15215 fputs (" PAD ", stdout);
15216 if (option->info & OPAD_PREFIX)
15217 fputs (" PREFIX", stdout);
15218 if (option->info & OPAD_POSTFIX)
15219 fputs (" POSTFIX", stdout);
15220 if (option->info & OPAD_SYMBOL)
15221 fputs (" SYMBOL", stdout);
15224 fputs (" HWPATCH ", stdout);
15225 if (option->info & OHW_R4KEOP)
15226 fputs (" R4KEOP", stdout);
15227 if (option->info & OHW_R8KPFETCH)
15228 fputs (" R8KPFETCH", stdout);
15229 if (option->info & OHW_R5KEOP)
15230 fputs (" R5KEOP", stdout);
15231 if (option->info & OHW_R5KCVTL)
15232 fputs (" R5KCVTL", stdout);
15235 fputs (" FILL ", stdout);
15236 /* XXX Print content of info word? */
15239 fputs (" TAGS ", stdout);
15240 /* XXX Print content of info word? */
15243 fputs (" HWAND ", stdout);
15244 if (option->info & OHWA0_R4KEOP_CHECKED)
15245 fputs (" R4KEOP_CHECKED", stdout);
15246 if (option->info & OHWA0_R4KEOP_CLEAN)
15247 fputs (" R4KEOP_CLEAN", stdout);
15250 fputs (" HWOR ", stdout);
15251 if (option->info & OHWA0_R4KEOP_CHECKED)
15252 fputs (" R4KEOP_CHECKED", stdout);
15253 if (option->info & OHWA0_R4KEOP_CLEAN)
15254 fputs (" R4KEOP_CLEAN", stdout);
15257 printf (" GP_GROUP %#06lx self-contained %#06lx",
15258 option->info & OGP_GROUP,
15259 (option->info & OGP_SELF) >> 16);
15262 printf (" IDENT %#06lx self-contained %#06lx",
15263 option->info & OGP_GROUP,
15264 (option->info & OGP_SELF) >> 16);
15267 /* This shouldn't happen. */
15268 printf (" %3d ??? %d %lx",
15269 option->kind, option->section, option->info);
15273 len = sizeof (* eopt);
15274 while (len < option->size)
15276 unsigned char datum = * ((unsigned char *) eopt + offset + len);
15278 if (ISPRINT (datum))
15279 printf ("%c", datum);
15281 printf ("\\%03o", datum);
15284 fputs ("\n", stdout);
15286 offset += option->size;
15296 if (conflicts_offset != 0 && conflictsno != 0)
15298 Elf32_Conflict * iconf;
15301 if (dynamic_symbols == NULL)
15303 error (_("conflict list found without a dynamic symbol table\n"));
15307 iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
15310 error (_("Out of memory allocating space for dynamic conflicts\n"));
15316 Elf32_External_Conflict * econf32;
15318 econf32 = (Elf32_External_Conflict *)
15319 get_data (NULL, file, conflicts_offset, conflictsno,
15320 sizeof (* econf32), _("conflict"));
15324 for (cnt = 0; cnt < conflictsno; ++cnt)
15325 iconf[cnt] = BYTE_GET (econf32[cnt]);
15331 Elf64_External_Conflict * econf64;
15333 econf64 = (Elf64_External_Conflict *)
15334 get_data (NULL, file, conflicts_offset, conflictsno,
15335 sizeof (* econf64), _("conflict"));
15339 for (cnt = 0; cnt < conflictsno; ++cnt)
15340 iconf[cnt] = BYTE_GET (econf64[cnt]);
15345 printf (_("\nSection '.conflict' contains %lu entries:\n"),
15346 (unsigned long) conflictsno);
15347 puts (_(" Num: Index Value Name"));
15349 for (cnt = 0; cnt < conflictsno; ++cnt)
15351 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
15353 if (iconf[cnt] >= num_dynamic_syms)
15354 printf (_("<corrupt symbol index>"));
15357 Elf_Internal_Sym * psym;
15359 psym = & dynamic_symbols[iconf[cnt]];
15360 print_vma (psym->st_value, FULL_HEX);
15362 if (VALID_DYNAMIC_NAME (psym->st_name))
15363 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
15365 printf (_("<corrupt: %14ld>"), psym->st_name);
15373 if (pltgot != 0 && local_gotno != 0)
15375 bfd_vma ent, local_end, global_end;
15377 unsigned char * data;
15378 unsigned char * data_end;
15382 addr_size = (is_32bit_elf ? 4 : 8);
15383 local_end = pltgot + local_gotno * addr_size;
15385 /* PR binutils/17533 file: 012-111227-0.004 */
15386 if (symtabno < gotsym)
15388 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
15389 (unsigned long) gotsym, (unsigned long) symtabno);
15393 global_end = local_end + (symtabno - gotsym) * addr_size;
15394 /* PR 17531: file: 54c91a34. */
15395 if (global_end < local_end)
15397 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
15401 offset = offset_from_vma (file, pltgot, global_end - pltgot);
15402 data = (unsigned char *) get_data (NULL, file, offset,
15403 global_end - pltgot, 1,
15404 _("Global Offset Table data"));
15407 data_end = data + (global_end - pltgot);
15409 printf (_("\nPrimary GOT:\n"));
15410 printf (_(" Canonical gp value: "));
15411 print_vma (pltgot + 0x7ff0, LONG_HEX);
15414 printf (_(" Reserved entries:\n"));
15415 printf (_(" %*s %10s %*s Purpose\n"),
15416 addr_size * 2, _("Address"), _("Access"),
15417 addr_size * 2, _("Initial"));
15418 ent = print_mips_got_entry (data, pltgot, ent, data_end);
15419 printf (_(" Lazy resolver\n"));
15420 if (ent == (bfd_vma) -1)
15421 goto got_print_fail;
15423 && (byte_get (data + ent - pltgot, addr_size)
15424 >> (addr_size * 8 - 1)) != 0)
15426 ent = print_mips_got_entry (data, pltgot, ent, data_end);
15427 printf (_(" Module pointer (GNU extension)\n"));
15428 if (ent == (bfd_vma) -1)
15429 goto got_print_fail;
15433 if (ent < local_end)
15435 printf (_(" Local entries:\n"));
15436 printf (" %*s %10s %*s\n",
15437 addr_size * 2, _("Address"), _("Access"),
15438 addr_size * 2, _("Initial"));
15439 while (ent < local_end)
15441 ent = print_mips_got_entry (data, pltgot, ent, data_end);
15443 if (ent == (bfd_vma) -1)
15444 goto got_print_fail;
15449 if (gotsym < symtabno)
15453 printf (_(" Global entries:\n"));
15454 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
15455 addr_size * 2, _("Address"),
15457 addr_size * 2, _("Initial"),
15458 addr_size * 2, _("Sym.Val."),
15460 /* Note for translators: "Ndx" = abbreviated form of "Index". */
15461 _("Ndx"), _("Name"));
15463 sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
15465 for (i = gotsym; i < symtabno; i++)
15467 ent = print_mips_got_entry (data, pltgot, ent, data_end);
15470 if (dynamic_symbols == NULL)
15471 printf (_("<no dynamic symbols>"));
15472 else if (i < num_dynamic_syms)
15474 Elf_Internal_Sym * psym = dynamic_symbols + i;
15476 print_vma (psym->st_value, LONG_HEX);
15477 printf (" %-7s %3s ",
15478 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
15479 get_symbol_index_type (psym->st_shndx));
15481 if (VALID_DYNAMIC_NAME (psym->st_name))
15482 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
15484 printf (_("<corrupt: %14ld>"), psym->st_name);
15487 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
15488 (unsigned long) i);
15491 if (ent == (bfd_vma) -1)
15502 if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
15505 size_t offset, rel_offset;
15506 unsigned long count, i;
15507 unsigned char * data;
15508 int addr_size, sym_width;
15509 Elf_Internal_Rela * rels;
15511 rel_offset = offset_from_vma (file, jmprel, pltrelsz);
15512 if (pltrel == DT_RELA)
15514 if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
15519 if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
15524 addr_size = (is_32bit_elf ? 4 : 8);
15525 end = mips_pltgot + (2 + count) * addr_size;
15527 offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
15528 data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
15529 1, _("Procedure Linkage Table data"));
15533 printf ("\nPLT GOT:\n\n");
15534 printf (_(" Reserved entries:\n"));
15535 printf (_(" %*s %*s Purpose\n"),
15536 addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
15537 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
15538 printf (_(" PLT lazy resolver\n"));
15539 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
15540 printf (_(" Module pointer\n"));
15543 printf (_(" Entries:\n"));
15544 printf (" %*s %*s %*s %-7s %3s %s\n",
15545 addr_size * 2, _("Address"),
15546 addr_size * 2, _("Initial"),
15547 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
15548 sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
15549 for (i = 0; i < count; i++)
15551 unsigned long idx = get_reloc_symindex (rels[i].r_info);
15553 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
15556 if (idx >= num_dynamic_syms)
15557 printf (_("<corrupt symbol index: %lu>"), idx);
15560 Elf_Internal_Sym * psym = dynamic_symbols + idx;
15562 print_vma (psym->st_value, LONG_HEX);
15563 printf (" %-7s %3s ",
15564 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
15565 get_symbol_index_type (psym->st_shndx));
15566 if (VALID_DYNAMIC_NAME (psym->st_name))
15567 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
15569 printf (_("<corrupt: %14ld>"), psym->st_name);
15584 process_nds32_specific (FILE * file)
15586 Elf_Internal_Shdr *sect = NULL;
15588 sect = find_section (".nds32_e_flags");
15591 unsigned int *flag;
15593 printf ("\nNDS32 elf flags section:\n");
15594 flag = get_data (NULL, file, sect->sh_offset, 1,
15595 sect->sh_size, _("NDS32 elf flags section"));
15600 switch ((*flag) & 0x3)
15603 printf ("(VEC_SIZE):\tNo entry.\n");
15606 printf ("(VEC_SIZE):\t4 bytes\n");
15609 printf ("(VEC_SIZE):\t16 bytes\n");
15612 printf ("(VEC_SIZE):\treserved\n");
15621 process_gnu_liblist (FILE * file)
15623 Elf_Internal_Shdr * section;
15624 Elf_Internal_Shdr * string_sec;
15625 Elf32_External_Lib * elib;
15627 size_t strtab_size;
15630 bfd_boolean res = TRUE;
15635 for (i = 0, section = section_headers;
15636 i < elf_header.e_shnum;
15639 switch (section->sh_type)
15641 case SHT_GNU_LIBLIST:
15642 if (section->sh_link >= elf_header.e_shnum)
15645 elib = (Elf32_External_Lib *)
15646 get_data (NULL, file, section->sh_offset, 1, section->sh_size,
15647 _("liblist section data"));
15655 string_sec = section_headers + section->sh_link;
15656 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
15657 string_sec->sh_size,
15658 _("liblist string table"));
15660 || section->sh_entsize != sizeof (Elf32_External_Lib))
15667 strtab_size = string_sec->sh_size;
15669 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
15670 printable_section_name (section),
15671 (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
15673 puts (_(" Library Time Stamp Checksum Version Flags"));
15675 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
15683 liblist.l_name = BYTE_GET (elib[cnt].l_name);
15684 atime = BYTE_GET (elib[cnt].l_time_stamp);
15685 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
15686 liblist.l_version = BYTE_GET (elib[cnt].l_version);
15687 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
15689 tmp = gmtime (&atime);
15690 snprintf (timebuf, sizeof (timebuf),
15691 "%04u-%02u-%02uT%02u:%02u:%02u",
15692 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
15693 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
15695 printf ("%3lu: ", (unsigned long) cnt);
15697 printf ("%-20s", liblist.l_name < strtab_size
15698 ? strtab + liblist.l_name : _("<corrupt>"));
15700 printf ("%-20.20s", liblist.l_name < strtab_size
15701 ? strtab + liblist.l_name : _("<corrupt>"));
15702 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
15703 liblist.l_version, liblist.l_flags);
15714 static const char *
15715 get_note_type (unsigned e_type)
15717 static char buff[64];
15719 if (elf_header.e_type == ET_CORE)
15723 return _("NT_AUXV (auxiliary vector)");
15725 return _("NT_PRSTATUS (prstatus structure)");
15727 return _("NT_FPREGSET (floating point registers)");
15729 return _("NT_PRPSINFO (prpsinfo structure)");
15730 case NT_TASKSTRUCT:
15731 return _("NT_TASKSTRUCT (task structure)");
15733 return _("NT_PRXFPREG (user_xfpregs structure)");
15735 return _("NT_PPC_VMX (ppc Altivec registers)");
15737 return _("NT_PPC_VSX (ppc VSX registers)");
15739 return _("NT_386_TLS (x86 TLS information)");
15740 case NT_386_IOPERM:
15741 return _("NT_386_IOPERM (x86 I/O permissions)");
15742 case NT_X86_XSTATE:
15743 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
15744 case NT_S390_HIGH_GPRS:
15745 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
15746 case NT_S390_TIMER:
15747 return _("NT_S390_TIMER (s390 timer register)");
15748 case NT_S390_TODCMP:
15749 return _("NT_S390_TODCMP (s390 TOD comparator register)");
15750 case NT_S390_TODPREG:
15751 return _("NT_S390_TODPREG (s390 TOD programmable register)");
15753 return _("NT_S390_CTRS (s390 control registers)");
15754 case NT_S390_PREFIX:
15755 return _("NT_S390_PREFIX (s390 prefix register)");
15756 case NT_S390_LAST_BREAK:
15757 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
15758 case NT_S390_SYSTEM_CALL:
15759 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
15761 return _("NT_S390_TDB (s390 transaction diagnostic block)");
15762 case NT_S390_VXRS_LOW:
15763 return _("NT_S390_VXRS_LOW (s390 vector registers 0-15 upper half)");
15764 case NT_S390_VXRS_HIGH:
15765 return _("NT_S390_VXRS_HIGH (s390 vector registers 16-31)");
15767 return _("NT_ARM_VFP (arm VFP registers)");
15769 return _("NT_ARM_TLS (AArch TLS registers)");
15770 case NT_ARM_HW_BREAK:
15771 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
15772 case NT_ARM_HW_WATCH:
15773 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
15775 return _("NT_PSTATUS (pstatus structure)");
15777 return _("NT_FPREGS (floating point registers)");
15779 return _("NT_PSINFO (psinfo structure)");
15781 return _("NT_LWPSTATUS (lwpstatus_t structure)");
15783 return _("NT_LWPSINFO (lwpsinfo_t structure)");
15784 case NT_WIN32PSTATUS:
15785 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
15787 return _("NT_SIGINFO (siginfo_t data)");
15789 return _("NT_FILE (mapped files)");
15797 return _("NT_VERSION (version)");
15799 return _("NT_ARCH (architecture)");
15800 case NT_GNU_BUILD_ATTRIBUTE_OPEN:
15801 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
15802 case NT_GNU_BUILD_ATTRIBUTE_FUNC:
15803 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
15808 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15813 print_core_note (Elf_Internal_Note *pnote)
15815 unsigned int addr_size = is_32bit_elf ? 4 : 8;
15816 bfd_vma count, page_size;
15817 unsigned char *descdata, *filenames, *descend;
15819 if (pnote->type != NT_FILE)
15825 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
15826 /* Still "successful". */
15831 if (pnote->descsz < 2 * addr_size)
15833 error (_(" Malformed note - too short for header\n"));
15837 descdata = (unsigned char *) pnote->descdata;
15838 descend = descdata + pnote->descsz;
15840 if (descdata[pnote->descsz - 1] != '\0')
15842 error (_(" Malformed note - does not end with \\0\n"));
15846 count = byte_get (descdata, addr_size);
15847 descdata += addr_size;
15849 page_size = byte_get (descdata, addr_size);
15850 descdata += addr_size;
15852 if (pnote->descsz < 2 * addr_size + count * 3 * addr_size)
15854 error (_(" Malformed note - too short for supplied file count\n"));
15858 printf (_(" Page size: "));
15859 print_vma (page_size, DEC);
15862 printf (_(" %*s%*s%*s\n"),
15863 (int) (2 + 2 * addr_size), _("Start"),
15864 (int) (4 + 2 * addr_size), _("End"),
15865 (int) (4 + 2 * addr_size), _("Page Offset"));
15866 filenames = descdata + count * 3 * addr_size;
15867 while (count-- > 0)
15869 bfd_vma start, end, file_ofs;
15871 if (filenames == descend)
15873 error (_(" Malformed note - filenames end too early\n"));
15877 start = byte_get (descdata, addr_size);
15878 descdata += addr_size;
15879 end = byte_get (descdata, addr_size);
15880 descdata += addr_size;
15881 file_ofs = byte_get (descdata, addr_size);
15882 descdata += addr_size;
15885 print_vma (start, FULL_HEX);
15887 print_vma (end, FULL_HEX);
15889 print_vma (file_ofs, FULL_HEX);
15890 printf ("\n %s\n", filenames);
15892 filenames += 1 + strlen ((char *) filenames);
15898 static const char *
15899 get_gnu_elf_note_type (unsigned e_type)
15901 /* NB/ Keep this switch statement in sync with print_gnu_note (). */
15904 case NT_GNU_ABI_TAG:
15905 return _("NT_GNU_ABI_TAG (ABI version tag)");
15907 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
15908 case NT_GNU_BUILD_ID:
15909 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
15910 case NT_GNU_GOLD_VERSION:
15911 return _("NT_GNU_GOLD_VERSION (gold version)");
15912 case NT_GNU_PROPERTY_TYPE_0:
15913 return _("NT_GNU_PROPERTY_TYPE_0");
15914 case NT_GNU_BUILD_ATTRIBUTE_OPEN:
15915 return _("NT_GNU_BUILD_ATTRIBUTE_OPEN");
15916 case NT_GNU_BUILD_ATTRIBUTE_FUNC:
15917 return _("NT_GNU_BUILD_ATTRIBUTE_FUNC");
15920 static char buff[64];
15922 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
15929 decode_x86_isa (unsigned long bitmask)
15933 unsigned long bit = bitmask & (- bitmask);
15938 case GNU_PROPERTY_X86_ISA_1_486: printf ("i486"); break;
15939 case GNU_PROPERTY_X86_ISA_1_586: printf ("586"); break;
15940 case GNU_PROPERTY_X86_ISA_1_686: printf ("686"); break;
15941 case GNU_PROPERTY_X86_ISA_1_SSE: printf ("SSE"); break;
15942 case GNU_PROPERTY_X86_ISA_1_SSE2: printf ("SSE2"); break;
15943 case GNU_PROPERTY_X86_ISA_1_SSE3: printf ("SSE3"); break;
15944 case GNU_PROPERTY_X86_ISA_1_SSSE3: printf ("SSSE3"); break;
15945 case GNU_PROPERTY_X86_ISA_1_SSE4_1: printf ("SSE4_1"); break;
15946 case GNU_PROPERTY_X86_ISA_1_SSE4_2: printf ("SSE4_2"); break;
15947 case GNU_PROPERTY_X86_ISA_1_AVX: printf ("AVX"); break;
15948 case GNU_PROPERTY_X86_ISA_1_AVX2: printf ("AVX2"); break;
15949 case GNU_PROPERTY_X86_ISA_1_AVX512F: printf ("AVX512F"); break;
15950 case GNU_PROPERTY_X86_ISA_1_AVX512CD: printf ("AVX512CD"); break;
15951 case GNU_PROPERTY_X86_ISA_1_AVX512ER: printf ("AVX512ER"); break;
15952 case GNU_PROPERTY_X86_ISA_1_AVX512PF: printf ("AVX512PF"); break;
15953 case GNU_PROPERTY_X86_ISA_1_AVX512VL: printf ("AVX512VL"); break;
15954 case GNU_PROPERTY_X86_ISA_1_AVX512DQ: printf ("AVX512DQ"); break;
15955 case GNU_PROPERTY_X86_ISA_1_AVX512BW: printf ("AVX512BW"); break;
15956 default: printf (_("<unknown: %lx>"), bit); break;
15964 print_gnu_property_note (Elf_Internal_Note * pnote)
15966 unsigned char * ptr = (unsigned char *) pnote->descdata;
15967 unsigned char * ptr_end = ptr + pnote->descsz;
15968 unsigned int size = is_32bit_elf ? 4 : 8;
15970 printf (_(" Properties: "));
15972 if (pnote->descsz % size)
15974 printf (_("<corrupt GNU_PROPERTY_TYPE, size = %#lx>\n"), pnote->descsz);
15978 while (ptr < (ptr_end - (size * 2)))
15981 unsigned long type = byte_get (ptr, size);
15982 unsigned long datasz = byte_get (ptr + size, size);
15988 case GNU_PROPERTY_STACK_SIZE:
15989 printf (_("stack size: "));
15990 if (datasz != size || (ptr + size > ptr_end))
15991 printf (_("<corrupt length: %#lx> "), datasz);
15993 printf ("%#lx", (unsigned long) byte_get (ptr, size));
15996 case GNU_PROPERTY_NO_COPY_ON_PROTECTED:
15997 printf ("no copy on protected ");
15999 printf (_("<corrupt length: %#lx> "), datasz);
16002 case GNU_PROPERTY_X86_ISA_1_USED:
16003 printf ("x86 ISA used: ");
16004 if (datasz != size || (ptr + size > ptr_end))
16005 printf (_("<corrupt length: %#lx> "), datasz);
16007 decode_x86_isa (byte_get (ptr, size));
16010 case GNU_PROPERTY_X86_ISA_1_NEEDED:
16011 printf ("x86 ISA needed: ");
16012 if (datasz != size || (ptr + size > ptr_end))
16013 printf (_("<corrupt length: %#lx> "), datasz);
16015 decode_x86_isa (byte_get (ptr, size));
16019 printf (_("<unknown type %#lx data: "), type);
16020 if (ptr + datasz > ptr_end)
16022 printf (_("corrupt datasz: %#lx>\n"), datasz);
16025 for (j = 0; j < datasz; ++j)
16026 printf ("%02x ", ptr[j] & 0xff);
16031 ptr += ((datasz + (size - 1)) & ~ (size - 1));
16032 if (ptr < (ptr_end - (size * 2)))
16045 print_gnu_note (Elf_Internal_Note *pnote)
16047 /* NB/ Keep this switch statement in sync with get_gnu_elf_note_type (). */
16048 switch (pnote->type)
16050 case NT_GNU_BUILD_ID:
16054 printf (_(" Build ID: "));
16055 for (i = 0; i < pnote->descsz; ++i)
16056 printf ("%02x", pnote->descdata[i] & 0xff);
16061 case NT_GNU_ABI_TAG:
16063 unsigned long os, major, minor, subminor;
16064 const char *osname;
16066 /* PR 17531: file: 030-599401-0.004. */
16067 if (pnote->descsz < 16)
16069 printf (_(" <corrupt GNU_ABI_TAG>\n"));
16073 os = byte_get ((unsigned char *) pnote->descdata, 4);
16074 major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
16075 minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
16076 subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
16080 case GNU_ABI_TAG_LINUX:
16083 case GNU_ABI_TAG_HURD:
16086 case GNU_ABI_TAG_SOLARIS:
16087 osname = "Solaris";
16089 case GNU_ABI_TAG_FREEBSD:
16090 osname = "FreeBSD";
16092 case GNU_ABI_TAG_NETBSD:
16095 case GNU_ABI_TAG_SYLLABLE:
16096 osname = "Syllable";
16098 case GNU_ABI_TAG_NACL:
16102 osname = "Unknown";
16106 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname,
16107 major, minor, subminor);
16111 case NT_GNU_GOLD_VERSION:
16115 printf (_(" Version: "));
16116 for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
16117 printf ("%c", pnote->descdata[i]);
16124 unsigned long num_entries, mask;
16126 /* Hardware capabilities information. Word 0 is the number of entries.
16127 Word 1 is a bitmask of enabled entries. The rest of the descriptor
16128 is a series of entries, where each entry is a single byte followed
16129 by a nul terminated string. The byte gives the bit number to test
16130 if enabled in the bitmask. */
16131 printf (_(" Hardware Capabilities: "));
16132 if (pnote->descsz < 8)
16134 error (_("<corrupt GNU_HWCAP>\n"));
16137 num_entries = byte_get ((unsigned char *) pnote->descdata, 4);
16138 mask = byte_get ((unsigned char *) pnote->descdata + 4, 4);
16139 printf (_("num entries: %ld, enabled mask: %lx\n"), num_entries, mask);
16140 /* FIXME: Add code to display the entries... */
16144 case NT_GNU_PROPERTY_TYPE_0:
16145 print_gnu_property_note (pnote);
16149 /* Handle unrecognised types. An error message should have already been
16150 created by get_gnu_elf_note_type(), so all that we need to do is to
16151 display the data. */
16155 printf (_(" Description data: "));
16156 for (i = 0; i < pnote->descsz; ++i)
16157 printf ("%02x ", pnote->descdata[i] & 0xff);
16166 static const char *
16167 get_v850_elf_note_type (enum v850_notes n_type)
16169 static char buff[64];
16173 case V850_NOTE_ALIGNMENT: return _("Alignment of 8-byte objects");
16174 case V850_NOTE_DATA_SIZE: return _("Sizeof double and long double");
16175 case V850_NOTE_FPU_INFO: return _("Type of FPU support needed");
16176 case V850_NOTE_SIMD_INFO: return _("Use of SIMD instructions");
16177 case V850_NOTE_CACHE_INFO: return _("Use of cache");
16178 case V850_NOTE_MMU_INFO: return _("Use of MMU");
16180 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), n_type);
16186 print_v850_note (Elf_Internal_Note * pnote)
16190 if (pnote->descsz != 4)
16193 val = byte_get ((unsigned char *) pnote->descdata, pnote->descsz);
16197 printf (_("not set\n"));
16201 switch (pnote->type)
16203 case V850_NOTE_ALIGNMENT:
16206 case EF_RH850_DATA_ALIGN4: printf (_("4-byte\n")); return TRUE;
16207 case EF_RH850_DATA_ALIGN8: printf (_("8-byte\n")); return TRUE;
16211 case V850_NOTE_DATA_SIZE:
16214 case EF_RH850_DOUBLE32: printf (_("4-bytes\n")); return TRUE;
16215 case EF_RH850_DOUBLE64: printf (_("8-bytes\n")); return TRUE;
16219 case V850_NOTE_FPU_INFO:
16222 case EF_RH850_FPU20: printf (_("FPU-2.0\n")); return TRUE;
16223 case EF_RH850_FPU30: printf (_("FPU-3.0\n")); return TRUE;
16227 case V850_NOTE_MMU_INFO:
16228 case V850_NOTE_CACHE_INFO:
16229 case V850_NOTE_SIMD_INFO:
16230 if (val == EF_RH850_SIMD)
16232 printf (_("yes\n"));
16238 /* An 'unknown note type' message will already have been displayed. */
16242 printf (_("unknown value: %x\n"), val);
16247 process_netbsd_elf_note (Elf_Internal_Note * pnote)
16249 unsigned int version;
16251 switch (pnote->type)
16253 case NT_NETBSD_IDENT:
16254 version = byte_get ((unsigned char *) pnote->descdata, sizeof (version));
16255 if ((version / 10000) % 100)
16256 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u%s%c)\n", pnote->descsz,
16257 version, version / 100000000, (version / 1000000) % 100,
16258 (version / 10000) % 100 > 26 ? "Z" : "",
16259 'A' + (version / 10000) % 26);
16261 printf (" NetBSD\t\t0x%08lx\tIDENT %u (%u.%u.%u)\n", pnote->descsz,
16262 version, version / 100000000, (version / 1000000) % 100,
16263 (version / 100) % 100);
16266 case NT_NETBSD_MARCH:
16267 printf (" NetBSD\t0x%08lx\tMARCH <%s>\n", pnote->descsz,
16272 printf (" NetBSD\t0x%08lx\tUnknown note type: (0x%08lx)\n", pnote->descsz,
16278 static const char *
16279 get_freebsd_elfcore_note_type (unsigned e_type)
16283 case NT_FREEBSD_THRMISC:
16284 return _("NT_THRMISC (thrmisc structure)");
16285 case NT_FREEBSD_PROCSTAT_PROC:
16286 return _("NT_PROCSTAT_PROC (proc data)");
16287 case NT_FREEBSD_PROCSTAT_FILES:
16288 return _("NT_PROCSTAT_FILES (files data)");
16289 case NT_FREEBSD_PROCSTAT_VMMAP:
16290 return _("NT_PROCSTAT_VMMAP (vmmap data)");
16291 case NT_FREEBSD_PROCSTAT_GROUPS:
16292 return _("NT_PROCSTAT_GROUPS (groups data)");
16293 case NT_FREEBSD_PROCSTAT_UMASK:
16294 return _("NT_PROCSTAT_UMASK (umask data)");
16295 case NT_FREEBSD_PROCSTAT_RLIMIT:
16296 return _("NT_PROCSTAT_RLIMIT (rlimit data)");
16297 case NT_FREEBSD_PROCSTAT_OSREL:
16298 return _("NT_PROCSTAT_OSREL (osreldate data)");
16299 case NT_FREEBSD_PROCSTAT_PSSTRINGS:
16300 return _("NT_PROCSTAT_PSSTRINGS (ps_strings data)");
16301 case NT_FREEBSD_PROCSTAT_AUXV:
16302 return _("NT_PROCSTAT_AUXV (auxv data)");
16304 return get_note_type (e_type);
16307 static const char *
16308 get_netbsd_elfcore_note_type (unsigned e_type)
16310 static char buff[64];
16312 if (e_type == NT_NETBSDCORE_PROCINFO)
16314 /* NetBSD core "procinfo" structure. */
16315 return _("NetBSD procinfo structure");
16318 /* As of Jan 2002 there are no other machine-independent notes
16319 defined for NetBSD core files. If the note type is less
16320 than the start of the machine-dependent note types, we don't
16323 if (e_type < NT_NETBSDCORE_FIRSTMACH)
16325 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16329 switch (elf_header.e_machine)
16331 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
16332 and PT_GETFPREGS == mach+2. */
16337 case EM_SPARC32PLUS:
16341 case NT_NETBSDCORE_FIRSTMACH + 0:
16342 return _("PT_GETREGS (reg structure)");
16343 case NT_NETBSDCORE_FIRSTMACH + 2:
16344 return _("PT_GETFPREGS (fpreg structure)");
16350 /* On all other arch's, PT_GETREGS == mach+1 and
16351 PT_GETFPREGS == mach+3. */
16355 case NT_NETBSDCORE_FIRSTMACH + 1:
16356 return _("PT_GETREGS (reg structure)");
16357 case NT_NETBSDCORE_FIRSTMACH + 3:
16358 return _("PT_GETFPREGS (fpreg structure)");
16364 snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
16365 e_type - NT_NETBSDCORE_FIRSTMACH);
16369 static const char *
16370 get_stapsdt_note_type (unsigned e_type)
16372 static char buff[64];
16377 return _("NT_STAPSDT (SystemTap probe descriptors)");
16383 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16388 print_stapsdt_note (Elf_Internal_Note *pnote)
16390 int addr_size = is_32bit_elf ? 4 : 8;
16391 char *data = pnote->descdata;
16392 char *data_end = pnote->descdata + pnote->descsz;
16393 bfd_vma pc, base_addr, semaphore;
16394 char *provider, *probe, *arg_fmt;
16396 pc = byte_get ((unsigned char *) data, addr_size);
16398 base_addr = byte_get ((unsigned char *) data, addr_size);
16400 semaphore = byte_get ((unsigned char *) data, addr_size);
16404 data += strlen (data) + 1;
16406 data += strlen (data) + 1;
16408 data += strlen (data) + 1;
16410 printf (_(" Provider: %s\n"), provider);
16411 printf (_(" Name: %s\n"), probe);
16412 printf (_(" Location: "));
16413 print_vma (pc, FULL_HEX);
16414 printf (_(", Base: "));
16415 print_vma (base_addr, FULL_HEX);
16416 printf (_(", Semaphore: "));
16417 print_vma (semaphore, FULL_HEX);
16419 printf (_(" Arguments: %s\n"), arg_fmt);
16421 return data == data_end;
16424 static const char *
16425 get_ia64_vms_note_type (unsigned e_type)
16427 static char buff[64];
16432 return _("NT_VMS_MHD (module header)");
16434 return _("NT_VMS_LNM (language name)");
16436 return _("NT_VMS_SRC (source files)");
16438 return "NT_VMS_TITLE";
16440 return _("NT_VMS_EIDC (consistency check)");
16441 case NT_VMS_FPMODE:
16442 return _("NT_VMS_FPMODE (FP mode)");
16443 case NT_VMS_LINKTIME:
16444 return "NT_VMS_LINKTIME";
16445 case NT_VMS_IMGNAM:
16446 return _("NT_VMS_IMGNAM (image name)");
16448 return _("NT_VMS_IMGID (image id)");
16449 case NT_VMS_LINKID:
16450 return _("NT_VMS_LINKID (link id)");
16451 case NT_VMS_IMGBID:
16452 return _("NT_VMS_IMGBID (build id)");
16453 case NT_VMS_GSTNAM:
16454 return _("NT_VMS_GSTNAM (sym table name)");
16455 case NT_VMS_ORIG_DYN:
16456 return "NT_VMS_ORIG_DYN";
16457 case NT_VMS_PATCHTIME:
16458 return "NT_VMS_PATCHTIME";
16460 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
16466 print_ia64_vms_note (Elf_Internal_Note * pnote)
16468 switch (pnote->type)
16471 if (pnote->descsz > 36)
16473 size_t l = strlen (pnote->descdata + 34);
16474 printf (_(" Creation date : %.17s\n"), pnote->descdata);
16475 printf (_(" Last patch date: %.17s\n"), pnote->descdata + 17);
16476 printf (_(" Module name : %s\n"), pnote->descdata + 34);
16477 printf (_(" Module version : %s\n"), pnote->descdata + 34 + l + 1);
16480 printf (_(" Invalid size\n"));
16483 printf (_(" Language: %s\n"), pnote->descdata);
16486 case NT_VMS_FPMODE:
16487 printf (_(" Floating Point mode: "));
16488 printf ("0x%016" BFD_VMA_FMT "x\n",
16489 (bfd_vma) byte_get ((unsigned char *)pnote->descdata, 8));
16491 case NT_VMS_LINKTIME:
16492 printf (_(" Link time: "));
16494 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
16497 case NT_VMS_PATCHTIME:
16498 printf (_(" Patch time: "));
16500 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
16503 case NT_VMS_ORIG_DYN:
16504 printf (_(" Major id: %u, minor id: %u\n"),
16505 (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
16506 (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
16507 printf (_(" Last modified : "));
16509 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
16510 printf (_("\n Link flags : "));
16511 printf ("0x%016" BFD_VMA_FMT "x\n",
16512 (bfd_vma) byte_get ((unsigned char *)pnote->descdata + 16, 8));
16513 printf (_(" Header flags: 0x%08x\n"),
16514 (unsigned) byte_get ((unsigned char *)pnote->descdata + 24, 4));
16515 printf (_(" Image id : %s\n"), pnote->descdata + 32);
16518 case NT_VMS_IMGNAM:
16519 printf (_(" Image name: %s\n"), pnote->descdata);
16521 case NT_VMS_GSTNAM:
16522 printf (_(" Global symbol table name: %s\n"), pnote->descdata);
16525 printf (_(" Image id: %s\n"), pnote->descdata);
16527 case NT_VMS_LINKID:
16528 printf (_(" Linker id: %s\n"), pnote->descdata);
16537 print_gnu_build_attribute_description (Elf_Internal_Note * pnote,
16539 Elf_Internal_Shdr * section ATTRIBUTE_UNUSED)
16541 static unsigned long global_offset = 0;
16543 unsigned long strtab_size = 0;
16544 char * strtab = NULL;
16545 Elf_Internal_Sym * symtab = NULL;
16546 unsigned long nsyms = 0;
16547 Elf_Internal_Shdr * symsec = NULL;
16548 unsigned int desc_size = is_32bit_elf ? 4 : 8;
16550 if (pnote->descsz == 0)
16552 printf (_(" Applies from offset %#lx\n"), global_offset);
16556 if (pnote->descsz != desc_size)
16558 error (_(" <invalid description size: %lx>\n"), pnote->descsz);
16559 printf (_(" <invalid descsz>"));
16563 /* Load the symbols. */
16564 for (symsec = section_headers;
16565 symsec < section_headers + elf_header.e_shnum;
16568 if (symsec->sh_type == SHT_SYMTAB)
16570 symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
16572 if (symsec->sh_link < elf_header.e_shnum)
16574 Elf_Internal_Shdr * strtab_sec = section_headers + symsec->sh_link;
16576 strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
16577 1, strtab_sec->sh_size,
16578 _("string table"));
16579 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
16584 printf (_(" Applies from offset"));
16586 for (i = 0; i < pnote->descsz; i += desc_size)
16588 Elf_Internal_Sym * sym;
16589 unsigned long offset;
16591 offset = byte_get ((unsigned char *) pnote->descdata + i, desc_size);
16593 if (i + desc_size == pnote->descsz)
16594 printf (_(" %#lx"), offset);
16596 printf (_(" %#lx, "), offset);
16598 if (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN)
16599 global_offset = offset;
16601 if (symtab == NULL || strtab == NULL)
16604 /* Find a symbol whose value matches offset. */
16605 for (sym = symtab; sym < symtab + nsyms; sym ++)
16606 if (sym->st_value == offset)
16608 if (sym->st_name < strtab_size)
16610 if (strtab[sym->st_name] == 0)
16612 if (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN)
16613 printf (_(" (file: %s)"), strtab + sym->st_name);
16614 else if (ELF_ST_TYPE (sym->st_info) != STT_FUNC)
16617 printf (_(" (function: %s)"), strtab + sym->st_name);
16621 if (sym == symtab + nsyms)
16622 printf (_(" (<symbol name unknown>)"));
16630 print_gnu_build_attribute_name (Elf_Internal_Note * pnote)
16633 char name_attribute;
16634 char * expected_types;
16635 const char * name = pnote->namedata;
16639 if (name == NULL || pnote->namesz < 2)
16641 error (_("corrupt name field in GNU build attribute note: size = %ld\n"), pnote->namesz);
16642 print_symbol (-20, _(" <corrupt name field>"));
16646 switch ((name_type = * name))
16648 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
16649 case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
16650 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
16651 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
16652 printf ("%c", * name);
16655 error (_("unrecognised attribute type in name field: %d\n"), name_type);
16656 print_symbol (-20, _("<unknown name type>"));
16664 switch ((name_attribute = * name))
16666 case GNU_BUILD_ATTRIBUTE_VERSION:
16667 text = _("<version>");
16668 expected_types = "$";
16671 case GNU_BUILD_ATTRIBUTE_STACK_PROT:
16672 text = _("<stack prot>");
16673 expected_types = "!+";
16676 case GNU_BUILD_ATTRIBUTE_RELRO:
16677 text = _("<relro>");
16678 expected_types = "!+";
16681 case GNU_BUILD_ATTRIBUTE_STACK_SIZE:
16682 text = _("<stack size>");
16683 expected_types = "*";
16686 case GNU_BUILD_ATTRIBUTE_TOOL:
16687 text = _("<tool>");
16688 expected_types = "$";
16691 case GNU_BUILD_ATTRIBUTE_ABI:
16693 expected_types = "$*";
16696 case GNU_BUILD_ATTRIBUTE_PIC:
16698 expected_types = "*";
16703 if (ISPRINT (* name))
16705 int len = strnlen (name, pnote->namesz - (name - pnote->namedata)) + 1;
16707 if (len > left && ! do_wide)
16709 printf ("%.*s ", len, name);
16715 error (_("unexpected character in name field\n"));
16716 print_symbol (- left, _("<unknown attribute>"));
16719 expected_types = "*$!+";
16725 printf ("%s", text);
16726 left -= strlen (text);
16729 if (strchr (expected_types, name_type) == NULL)
16730 warn (_("attribute does not have the expected type\n"));
16732 if ((unsigned long)(name - pnote->namedata) > pnote->namesz)
16734 error (_("corrupt name field: namesz: %lu but parsing gets to %ld\n"),
16735 (unsigned long) pnote->namesz,
16736 (long) (name - pnote->namedata));
16740 if (left < 1 && ! do_wide)
16745 case GNU_BUILD_ATTRIBUTE_TYPE_NUMERIC:
16747 unsigned int bytes = pnote->namesz - (name - pnote->namedata);
16748 unsigned long val = 0;
16749 unsigned int shift = 0;
16753 val |= ((* name ++) << shift);
16757 if (name_attribute == GNU_BUILD_ATTRIBUTE_PIC)
16759 char * pic_type = NULL;
16763 case 0: pic_type = "static"; break;
16764 case 1: pic_type = "pic"; break;
16765 case 2: pic_type = "PIC"; break;
16766 case 3: pic_type = "pie"; break;
16767 case 4: pic_type = "PIE"; break;
16770 if (pic_type != NULL)
16773 left -= printf ("%s", pic_type);
16775 left -= printf ("%-.*s", left, pic_type);
16781 left -= printf ("0x%lx", val);
16783 left -= printf ("0x%-.*lx", left, val);
16786 case GNU_BUILD_ATTRIBUTE_TYPE_STRING:
16787 left -= print_symbol (- left, name);
16789 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_TRUE:
16790 left -= print_symbol (- left, "true");
16792 case GNU_BUILD_ATTRIBUTE_TYPE_BOOL_FALSE:
16793 left -= print_symbol (- left, "false");
16797 if (do_wide && left > 0)
16798 printf ("%-*s", left, " ");
16803 /* Note that by the ELF standard, the name field is already null byte
16804 terminated, and namesz includes the terminating null byte.
16805 I.E. the value of namesz for the name "FSF" is 4.
16807 If the value of namesz is zero, there is no name present. */
16810 process_note (Elf_Internal_Note * pnote,
16812 Elf_Internal_Shdr * section)
16814 const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
16817 if (pnote->namesz == 0)
16818 /* If there is no note name, then use the default set of
16819 note type strings. */
16820 nt = get_note_type (pnote->type);
16822 else if (const_strneq (pnote->namedata, "GNU"))
16823 /* GNU-specific object file notes. */
16824 nt = get_gnu_elf_note_type (pnote->type);
16826 else if (const_strneq (pnote->namedata, "FreeBSD"))
16827 /* FreeBSD-specific core file notes. */
16828 nt = get_freebsd_elfcore_note_type (pnote->type);
16830 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
16831 /* NetBSD-specific core file notes. */
16832 nt = get_netbsd_elfcore_note_type (pnote->type);
16834 else if (const_strneq (pnote->namedata, "NetBSD"))
16835 /* NetBSD-specific core file notes. */
16836 return process_netbsd_elf_note (pnote);
16838 else if (strneq (pnote->namedata, "SPU/", 4))
16840 /* SPU-specific core file notes. */
16841 nt = pnote->namedata + 4;
16845 else if (const_strneq (pnote->namedata, "IPF/VMS"))
16846 /* VMS/ia64-specific file notes. */
16847 nt = get_ia64_vms_note_type (pnote->type);
16849 else if (const_strneq (pnote->namedata, "stapsdt"))
16850 nt = get_stapsdt_note_type (pnote->type);
16853 /* Don't recognize this note name; just use the default set of
16854 note type strings. */
16855 nt = get_note_type (pnote->type);
16859 if (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
16860 || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC)
16861 print_gnu_build_attribute_name (pnote);
16863 print_symbol (-20, name);
16866 printf (" 0x%08lx\t%s\t", pnote->descsz, nt);
16868 printf (" 0x%08lx\t%s\n", pnote->descsz, nt);
16870 if (const_strneq (pnote->namedata, "IPF/VMS"))
16871 return print_ia64_vms_note (pnote);
16872 else if (const_strneq (pnote->namedata, "GNU"))
16873 return print_gnu_note (pnote);
16874 else if (const_strneq (pnote->namedata, "stapsdt"))
16875 return print_stapsdt_note (pnote);
16876 else if (const_strneq (pnote->namedata, "CORE"))
16877 return print_core_note (pnote);
16878 else if (pnote->type == NT_GNU_BUILD_ATTRIBUTE_OPEN
16879 || pnote->type == NT_GNU_BUILD_ATTRIBUTE_FUNC)
16880 return print_gnu_build_attribute_description (pnote, file, section);
16886 printf (_(" description data: "));
16887 for (i = 0; i < pnote->descsz; i++)
16888 printf ("%02x ", pnote->descdata[i]);
16898 process_notes_at (FILE * file,
16899 Elf_Internal_Shdr * section,
16903 Elf_External_Note * pnotes;
16904 Elf_External_Note * external;
16906 bfd_boolean res = TRUE;
16913 pnotes = (Elf_External_Note *) get_section_contents (section, file);
16916 if (! apply_relocations (file, section, (unsigned char *) pnotes, length, NULL, NULL))
16921 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
16923 if (pnotes == NULL)
16929 printf (_("\nDisplaying notes found in: %s\n"), printable_section_name (section));
16931 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
16932 (unsigned long) offset, (unsigned long) length);
16934 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
16936 end = (char *) pnotes + length;
16937 while ((char *) external < end)
16939 Elf_Internal_Note inote;
16942 char * temp = NULL;
16943 size_t data_remaining = end - (char *) external;
16945 if (!is_ia64_vms ())
16947 /* PR binutils/15191
16948 Make sure that there is enough data to read. */
16949 min_notesz = offsetof (Elf_External_Note, name);
16950 if (data_remaining < min_notesz)
16952 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
16953 (int) data_remaining);
16956 inote.type = BYTE_GET (external->type);
16957 inote.namesz = BYTE_GET (external->namesz);
16958 inote.namedata = external->name;
16959 inote.descsz = BYTE_GET (external->descsz);
16960 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
16961 /* PR 17531: file: 3443835e. */
16962 if (inote.descdata < (char *) pnotes || inote.descdata > end)
16964 warn (_("Corrupt note: name size is too big: (got: %lx, expected no more than: %lx)\n"),
16965 inote.namesz, (long)(end - inote.namedata));
16966 inote.descdata = inote.namedata;
16970 inote.descpos = offset + (inote.descdata - (char *) pnotes);
16971 next = inote.descdata + align_power (inote.descsz, 2);
16975 Elf64_External_VMS_Note *vms_external;
16977 /* PR binutils/15191
16978 Make sure that there is enough data to read. */
16979 min_notesz = offsetof (Elf64_External_VMS_Note, name);
16980 if (data_remaining < min_notesz)
16982 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
16983 (int) data_remaining);
16987 vms_external = (Elf64_External_VMS_Note *) external;
16988 inote.type = BYTE_GET (vms_external->type);
16989 inote.namesz = BYTE_GET (vms_external->namesz);
16990 inote.namedata = vms_external->name;
16991 inote.descsz = BYTE_GET (vms_external->descsz);
16992 inote.descdata = inote.namedata + align_power (inote.namesz, 3);
16993 inote.descpos = offset + (inote.descdata - (char *) pnotes);
16994 next = inote.descdata + align_power (inote.descsz, 3);
16997 if (inote.descdata < (char *) external + min_notesz
16998 || next < (char *) external + min_notesz
16999 /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
17000 || inote.namedata + inote.namesz < inote.namedata
17001 || inote.descdata + inote.descsz < inote.descdata
17002 || data_remaining < (size_t)(next - (char *) external))
17004 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
17005 (unsigned long) ((char *) external - (char *) pnotes));
17006 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
17007 inote.type, inote.namesz, inote.descsz);
17011 external = (Elf_External_Note *) next;
17013 /* Verify that name is null terminated. It appears that at least
17014 one version of Linux (RedHat 6.0) generates corefiles that don't
17015 comply with the ELF spec by failing to include the null byte in
17017 if (inote.namedata[inote.namesz - 1] != '\0')
17019 temp = (char *) malloc (inote.namesz + 1);
17022 error (_("Out of memory allocating space for inote name\n"));
17027 strncpy (temp, inote.namedata, inote.namesz);
17028 temp[inote.namesz] = 0;
17030 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
17031 inote.namedata = temp;
17034 if (! process_note (& inote, file, section))
17050 process_corefile_note_segments (FILE * file)
17052 Elf_Internal_Phdr * segment;
17054 bfd_boolean res = TRUE;
17056 if (! get_program_headers (file))
17059 for (i = 0, segment = program_headers;
17060 i < elf_header.e_phnum;
17063 if (segment->p_type == PT_NOTE)
17064 if (! process_notes_at (file, NULL,
17065 (bfd_vma) segment->p_offset,
17066 (bfd_vma) segment->p_filesz))
17074 process_v850_notes (FILE * file, bfd_vma offset, bfd_vma length)
17076 Elf_External_Note * pnotes;
17077 Elf_External_Note * external;
17079 bfd_boolean res = TRUE;
17084 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
17086 if (pnotes == NULL)
17090 end = (char*) pnotes + length;
17092 printf (_("\nDisplaying contents of Renesas V850 notes section at offset 0x%lx with length 0x%lx:\n"),
17093 (unsigned long) offset, (unsigned long) length);
17095 while ((char *) external + sizeof (Elf_External_Note) < end)
17097 Elf_External_Note * next;
17098 Elf_Internal_Note inote;
17100 inote.type = BYTE_GET (external->type);
17101 inote.namesz = BYTE_GET (external->namesz);
17102 inote.namedata = external->name;
17103 inote.descsz = BYTE_GET (external->descsz);
17104 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
17105 inote.descpos = offset + (inote.descdata - (char *) pnotes);
17107 if (inote.descdata < (char *) pnotes || inote.descdata >= end)
17109 warn (_("Corrupt note: name size is too big: %lx\n"), inote.namesz);
17110 inote.descdata = inote.namedata;
17114 next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
17116 if ( ((char *) next > end)
17117 || ((char *) next < (char *) pnotes))
17119 warn (_("corrupt descsz found in note at offset 0x%lx\n"),
17120 (unsigned long) ((char *) external - (char *) pnotes));
17121 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
17122 inote.type, inote.namesz, inote.descsz);
17128 /* Prevent out-of-bounds indexing. */
17129 if ( inote.namedata + inote.namesz > end
17130 || inote.namedata + inote.namesz < inote.namedata)
17132 warn (_("corrupt namesz found in note at offset 0x%lx\n"),
17133 (unsigned long) ((char *) external - (char *) pnotes));
17134 warn (_(" type: 0x%lx, namesize: 0x%lx, descsize: 0x%lx\n"),
17135 inote.type, inote.namesz, inote.descsz);
17139 printf (" %s: ", get_v850_elf_note_type (inote.type));
17141 if (! print_v850_note (& inote))
17144 printf ("<corrupt sizes: namesz: %lx, descsz: %lx>\n",
17145 inote.namesz, inote.descsz);
17155 process_note_sections (FILE * file)
17157 Elf_Internal_Shdr * section;
17159 unsigned int n = 0;
17160 bfd_boolean res = TRUE;
17162 for (i = 0, section = section_headers;
17163 i < elf_header.e_shnum && section != NULL;
17166 if (section->sh_type == SHT_NOTE)
17168 if (! process_notes_at (file, section,
17169 (bfd_vma) section->sh_offset,
17170 (bfd_vma) section->sh_size))
17175 if (( elf_header.e_machine == EM_V800
17176 || elf_header.e_machine == EM_V850
17177 || elf_header.e_machine == EM_CYGNUS_V850)
17178 && section->sh_type == SHT_RENESAS_INFO)
17180 if (! process_v850_notes (file,
17181 (bfd_vma) section->sh_offset,
17182 (bfd_vma) section->sh_size))
17189 /* Try processing NOTE segments instead. */
17190 return process_corefile_note_segments (file);
17196 process_notes (FILE * file)
17198 /* If we have not been asked to display the notes then do nothing. */
17202 if (elf_header.e_type != ET_CORE)
17203 return process_note_sections (file);
17205 /* No program headers means no NOTE segment. */
17206 if (elf_header.e_phnum > 0)
17207 return process_corefile_note_segments (file);
17209 printf (_("No note segments present in the core file.\n"));
17213 static unsigned char *
17214 display_public_gnu_attributes (unsigned char * start,
17215 const unsigned char * const end)
17217 printf (_(" Unknown GNU attribute: %s\n"), start);
17219 start += strnlen ((char *) start, end - start);
17220 display_raw_attribute (start, end);
17222 return (unsigned char *) end;
17225 static unsigned char *
17226 display_generic_attribute (unsigned char * start,
17228 const unsigned char * const end)
17231 return (unsigned char *) end;
17233 return display_tag_value (tag, start, end);
17237 process_arch_specific (FILE * file)
17242 switch (elf_header.e_machine)
17245 return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
17246 display_arm_attribute,
17247 display_generic_attribute);
17250 case EM_MIPS_RS3_LE:
17251 return process_mips_specific (file);
17254 return process_attributes (file, "mspabi", SHT_MSP430_ATTRIBUTES,
17255 display_msp430x_attribute,
17256 display_generic_attribute);
17259 return process_nds32_specific (file);
17263 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
17264 display_power_gnu_attribute);
17268 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
17269 display_s390_gnu_attribute);
17272 case EM_SPARC32PLUS:
17274 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
17275 display_sparc_gnu_attribute);
17278 return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
17279 display_tic6x_attribute,
17280 display_generic_attribute);
17283 return process_attributes (file, "gnu", SHT_GNU_ATTRIBUTES,
17284 display_public_gnu_attributes,
17285 display_generic_attribute);
17290 get_file_header (FILE * file)
17292 /* Read in the identity array. */
17293 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
17296 /* Determine how to read the rest of the header. */
17297 switch (elf_header.e_ident[EI_DATA])
17302 byte_get = byte_get_little_endian;
17303 byte_put = byte_put_little_endian;
17306 byte_get = byte_get_big_endian;
17307 byte_put = byte_put_big_endian;
17311 /* For now we only support 32 bit and 64 bit ELF files. */
17312 is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
17314 /* Read in the rest of the header. */
17317 Elf32_External_Ehdr ehdr32;
17319 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
17322 elf_header.e_type = BYTE_GET (ehdr32.e_type);
17323 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
17324 elf_header.e_version = BYTE_GET (ehdr32.e_version);
17325 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
17326 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
17327 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
17328 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
17329 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
17330 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
17331 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
17332 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
17333 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
17334 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
17338 Elf64_External_Ehdr ehdr64;
17340 /* If we have been compiled with sizeof (bfd_vma) == 4, then
17341 we will not be able to cope with the 64bit data found in
17342 64 ELF files. Detect this now and abort before we start
17343 overwriting things. */
17344 if (sizeof (bfd_vma) < 8)
17346 error (_("This instance of readelf has been built without support for a\n\
17347 64 bit data type and so it cannot read 64 bit ELF files.\n"));
17351 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
17354 elf_header.e_type = BYTE_GET (ehdr64.e_type);
17355 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
17356 elf_header.e_version = BYTE_GET (ehdr64.e_version);
17357 elf_header.e_entry = BYTE_GET (ehdr64.e_entry);
17358 elf_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
17359 elf_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
17360 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
17361 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
17362 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
17363 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
17364 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
17365 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
17366 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
17369 if (elf_header.e_shoff)
17371 /* There may be some extensions in the first section header. Don't
17372 bomb if we can't read it. */
17374 get_32bit_section_headers (file, TRUE);
17376 get_64bit_section_headers (file, TRUE);
17382 /* Process one ELF object file according to the command line options.
17383 This file may actually be stored in an archive. The file is
17384 positioned at the start of the ELF object. Returns TRUE if no
17385 problems were encountered, FALSE otherwise. */
17388 process_object (char * file_name, FILE * file)
17391 bfd_boolean res = TRUE;
17393 if (! get_file_header (file))
17395 error (_("%s: Failed to read file header\n"), file_name);
17399 /* Initialise per file variables. */
17400 for (i = ARRAY_SIZE (version_info); i--;)
17401 version_info[i] = 0;
17403 for (i = ARRAY_SIZE (dynamic_info); i--;)
17404 dynamic_info[i] = 0;
17405 dynamic_info_DT_GNU_HASH = 0;
17407 /* Process the file. */
17409 printf (_("\nFile: %s\n"), file_name);
17411 /* Initialise the dump_sects array from the cmdline_dump_sects array.
17412 Note we do this even if cmdline_dump_sects is empty because we
17413 must make sure that the dump_sets array is zeroed out before each
17414 object file is processed. */
17415 if (num_dump_sects > num_cmdline_dump_sects)
17416 memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
17418 if (num_cmdline_dump_sects > 0)
17420 if (num_dump_sects == 0)
17421 /* A sneaky way of allocating the dump_sects array. */
17422 request_dump_bynumber (num_cmdline_dump_sects, 0);
17424 assert (num_dump_sects >= num_cmdline_dump_sects);
17425 memcpy (dump_sects, cmdline_dump_sects,
17426 num_cmdline_dump_sects * sizeof (* dump_sects));
17429 if (! process_file_header ())
17432 if (! process_section_headers (file))
17434 /* Without loaded section headers we cannot process lots of things. */
17435 do_unwind = do_version = do_dump = do_arch = FALSE;
17437 if (! do_using_dynamic)
17438 do_syms = do_dyn_syms = do_reloc = FALSE;
17441 if (! process_section_groups (file))
17442 /* Without loaded section groups we cannot process unwind. */
17445 if (process_program_headers (file))
17446 process_dynamic_section (file);
17450 if (! process_relocs (file))
17453 if (! process_unwind (file))
17456 if (! process_symbol_table (file))
17459 if (! process_syminfo (file))
17462 if (! process_version_sections (file))
17465 if (! process_section_contents (file))
17468 if (! process_notes (file))
17471 if (! process_gnu_liblist (file))
17474 if (! process_arch_specific (file))
17477 if (program_headers)
17479 free (program_headers);
17480 program_headers = NULL;
17483 if (section_headers)
17485 free (section_headers);
17486 section_headers = NULL;
17491 free (string_table);
17492 string_table = NULL;
17493 string_table_length = 0;
17496 if (dynamic_strings)
17498 free (dynamic_strings);
17499 dynamic_strings = NULL;
17500 dynamic_strings_length = 0;
17503 if (dynamic_symbols)
17505 free (dynamic_symbols);
17506 dynamic_symbols = NULL;
17507 num_dynamic_syms = 0;
17510 if (dynamic_syminfo)
17512 free (dynamic_syminfo);
17513 dynamic_syminfo = NULL;
17516 if (dynamic_section)
17518 free (dynamic_section);
17519 dynamic_section = NULL;
17522 if (section_headers_groups)
17524 free (section_headers_groups);
17525 section_headers_groups = NULL;
17528 if (section_groups)
17530 struct group_list * g;
17531 struct group_list * next;
17533 for (i = 0; i < group_count; i++)
17535 for (g = section_groups [i].root; g != NULL; g = next)
17542 free (section_groups);
17543 section_groups = NULL;
17546 free_debug_memory ();
17551 /* Process an ELF archive.
17552 On entry the file is positioned just after the ARMAG string.
17553 Returns TRUE upon success, FALSE otherwise. */
17556 process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
17558 struct archive_info arch;
17559 struct archive_info nested_arch;
17561 bfd_boolean ret = TRUE;
17565 /* The ARCH structure is used to hold information about this archive. */
17566 arch.file_name = NULL;
17568 arch.index_array = NULL;
17569 arch.sym_table = NULL;
17570 arch.longnames = NULL;
17572 /* The NESTED_ARCH structure is used as a single-item cache of information
17573 about a nested archive (when members of a thin archive reside within
17574 another regular archive file). */
17575 nested_arch.file_name = NULL;
17576 nested_arch.file = NULL;
17577 nested_arch.index_array = NULL;
17578 nested_arch.sym_table = NULL;
17579 nested_arch.longnames = NULL;
17581 if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
17587 if (do_archive_index)
17589 if (arch.sym_table == NULL)
17590 error (_("%s: unable to dump the index as none was found\n"), file_name);
17593 unsigned long i, l;
17594 unsigned long current_pos;
17596 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
17597 file_name, (unsigned long) arch.index_num, arch.sym_size);
17598 current_pos = ftell (file);
17600 for (i = l = 0; i < arch.index_num; i++)
17602 if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
17604 char * member_name;
17606 member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
17608 if (member_name != NULL)
17610 char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
17612 if (qualified_name != NULL)
17614 printf (_("Contents of binary %s at offset "), qualified_name);
17615 (void) print_vma (arch.index_array[i], PREFIX_HEX);
17617 free (qualified_name);
17622 if (l >= arch.sym_size)
17624 error (_("%s: end of the symbol table reached before the end of the index\n"),
17629 /* PR 17531: file: 0b6630b2. */
17630 printf ("\t%.*s\n", (int) (arch.sym_size - l), arch.sym_table + l);
17631 l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
17634 if (arch.uses_64bit_indicies)
17639 if (l < arch.sym_size)
17641 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
17642 file_name, arch.sym_size - l);
17646 if (fseek (file, current_pos, SEEK_SET) != 0)
17648 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
17654 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
17655 && !do_segments && !do_header && !do_dump && !do_version
17656 && !do_histogram && !do_debugging && !do_arch && !do_notes
17657 && !do_section_groups && !do_dyn_syms)
17659 ret = TRUE; /* Archive index only. */
17668 char * qualified_name;
17670 /* Read the next archive header. */
17671 if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
17673 error (_("%s: failed to seek to next archive header\n"), file_name);
17676 got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
17677 if (got != sizeof arch.arhdr)
17681 error (_("%s: failed to read archive header\n"), file_name);
17685 if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
17687 error (_("%s: did not find a valid archive header\n"), arch.file_name);
17692 arch.next_arhdr_offset += sizeof arch.arhdr;
17694 archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
17695 if (archive_file_size & 01)
17696 ++archive_file_size;
17698 name = get_archive_member_name (&arch, &nested_arch);
17701 error (_("%s: bad archive file name\n"), file_name);
17705 namelen = strlen (name);
17707 qualified_name = make_qualified_name (&arch, &nested_arch, name);
17708 if (qualified_name == NULL)
17710 error (_("%s: bad archive file name\n"), file_name);
17715 if (is_thin_archive && arch.nested_member_origin == 0)
17717 /* This is a proxy for an external member of a thin archive. */
17718 FILE * member_file;
17719 char * member_file_name = adjust_relative_path (file_name, name, namelen);
17721 if (member_file_name == NULL)
17727 member_file = fopen (member_file_name, "rb");
17728 if (member_file == NULL)
17730 error (_("Input file '%s' is not readable.\n"), member_file_name);
17731 free (member_file_name);
17736 archive_file_offset = arch.nested_member_origin;
17738 if (! process_object (qualified_name, member_file))
17741 fclose (member_file);
17742 free (member_file_name);
17744 else if (is_thin_archive)
17746 /* PR 15140: Allow for corrupt thin archives. */
17747 if (nested_arch.file == NULL)
17749 error (_("%s: contains corrupt thin archive: %s\n"),
17755 /* This is a proxy for a member of a nested archive. */
17756 archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
17758 /* The nested archive file will have been opened and setup by
17759 get_archive_member_name. */
17760 if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
17762 error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
17767 if (! process_object (qualified_name, nested_arch.file))
17772 archive_file_offset = arch.next_arhdr_offset;
17773 arch.next_arhdr_offset += archive_file_size;
17775 if (! process_object (qualified_name, file))
17779 if (dump_sects != NULL)
17783 num_dump_sects = 0;
17786 free (qualified_name);
17790 if (nested_arch.file != NULL)
17791 fclose (nested_arch.file);
17792 release_archive (&nested_arch);
17793 release_archive (&arch);
17799 process_file (char * file_name)
17802 struct stat statbuf;
17803 char armag[SARMAG];
17804 bfd_boolean ret = TRUE;
17806 if (stat (file_name, &statbuf) < 0)
17808 if (errno == ENOENT)
17809 error (_("'%s': No such file\n"), file_name);
17811 error (_("Could not locate '%s'. System error message: %s\n"),
17812 file_name, strerror (errno));
17816 if (! S_ISREG (statbuf.st_mode))
17818 error (_("'%s' is not an ordinary file\n"), file_name);
17822 file = fopen (file_name, "rb");
17825 error (_("Input file '%s' is not readable.\n"), file_name);
17829 if (fread (armag, SARMAG, 1, file) != 1)
17831 error (_("%s: Failed to read file's magic number\n"), file_name);
17836 current_file_size = (bfd_size_type) statbuf.st_size;
17838 if (memcmp (armag, ARMAG, SARMAG) == 0)
17840 if (! process_archive (file_name, file, FALSE))
17843 else if (memcmp (armag, ARMAGT, SARMAG) == 0)
17845 if ( ! process_archive (file_name, file, TRUE))
17850 if (do_archive_index)
17851 error (_("File %s is not an archive so its index cannot be displayed.\n"),
17855 archive_file_size = archive_file_offset = 0;
17857 if (! process_object (file_name, file))
17862 current_file_size = 0;
17867 #ifdef SUPPORT_DISASSEMBLY
17868 /* Needed by the i386 disassembler. For extra credit, someone could
17869 fix this so that we insert symbolic addresses here, esp for GOT/PLT
17873 print_address (unsigned int addr, FILE * outfile)
17875 fprintf (outfile,"0x%8.8x", addr);
17878 /* Needed by the i386 disassembler. */
17880 db_task_printsym (unsigned int addr)
17882 print_address (addr, stderr);
17887 main (int argc, char ** argv)
17891 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
17892 setlocale (LC_MESSAGES, "");
17894 #if defined (HAVE_SETLOCALE)
17895 setlocale (LC_CTYPE, "");
17897 bindtextdomain (PACKAGE, LOCALEDIR);
17898 textdomain (PACKAGE);
17900 expandargv (&argc, &argv);
17902 parse_args (argc, argv);
17904 if (num_dump_sects > 0)
17906 /* Make a copy of the dump_sects array. */
17907 cmdline_dump_sects = (dump_type *)
17908 malloc (num_dump_sects * sizeof (* dump_sects));
17909 if (cmdline_dump_sects == NULL)
17910 error (_("Out of memory allocating dump request table.\n"));
17913 memcpy (cmdline_dump_sects, dump_sects,
17914 num_dump_sects * sizeof (* dump_sects));
17915 num_cmdline_dump_sects = num_dump_sects;
17919 if (optind < (argc - 1))
17921 else if (optind >= argc)
17923 warn (_("Nothing to do.\n"));
17928 while (optind < argc)
17929 if (! process_file (argv[optind++]))
17932 if (dump_sects != NULL)
17934 if (cmdline_dump_sects != NULL)
17935 free (cmdline_dump_sects);
17937 return err ? EXIT_FAILURE : EXIT_SUCCESS;