1 /* readelf.c -- display contents of an ELF format file
2 Copyright (C) 1998-2015 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. */
54 /* Define BFD64 here, even if our default architecture is 32 bit ELF
55 as this will allow us to read in and parse 64bit and 32bit ELF files.
56 Only do this if we believe that the compiler can support a 64 bit
57 data type. For now we only rely on GCC being able to do this. */
66 #include "elf/common.h"
67 #include "elf/external.h"
68 #include "elf/internal.h"
71 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
72 we can obtain the H8 reloc numbers. We need these for the
73 get_reloc_size() function. We include h8.h again after defining
74 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
79 /* Undo the effects of #including reloc-macros.h. */
81 #undef START_RELOC_NUMBERS
85 #undef END_RELOC_NUMBERS
86 #undef _RELOC_MACROS_H
88 /* The following headers use the elf/reloc-macros.h file to
89 automatically generate relocation recognition functions
90 such as elf_mips_reloc_type() */
92 #define RELOC_MACROS_GEN_FUNC
94 #include "elf/aarch64.h"
95 #include "elf/alpha.h"
100 #include "elf/cr16.h"
101 #include "elf/cris.h"
103 #include "elf/d10v.h"
104 #include "elf/d30v.h"
106 #include "elf/epiphany.h"
107 #include "elf/fr30.h"
109 #include "elf/ft32.h"
111 #include "elf/hppa.h"
112 #include "elf/i386.h"
113 #include "elf/i370.h"
114 #include "elf/i860.h"
115 #include "elf/i960.h"
116 #include "elf/ia64.h"
117 #include "elf/ip2k.h"
118 #include "elf/lm32.h"
119 #include "elf/iq2000.h"
120 #include "elf/m32c.h"
121 #include "elf/m32r.h"
122 #include "elf/m68k.h"
123 #include "elf/m68hc11.h"
124 #include "elf/mcore.h"
126 #include "elf/metag.h"
127 #include "elf/microblaze.h"
128 #include "elf/mips.h"
129 #include "elf/mmix.h"
130 #include "elf/mn10200.h"
131 #include "elf/mn10300.h"
132 #include "elf/moxie.h"
134 #include "elf/msp430.h"
135 #include "elf/nds32.h"
136 #include "elf/nios2.h"
137 #include "elf/or1k.h"
140 #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 char * program_name = "readelf";
170 static unsigned long archive_file_offset;
171 static unsigned long archive_file_size;
172 static bfd_size_type current_file_size;
173 static unsigned long dynamic_addr;
174 static bfd_size_type dynamic_size;
175 static size_t dynamic_nent;
176 static char * dynamic_strings;
177 static unsigned long dynamic_strings_length;
178 static char * string_table;
179 static unsigned long string_table_length;
180 static unsigned long num_dynamic_syms;
181 static Elf_Internal_Sym * dynamic_symbols;
182 static Elf_Internal_Syminfo * dynamic_syminfo;
183 static unsigned long dynamic_syminfo_offset;
184 static unsigned int dynamic_syminfo_nent;
185 static char program_interpreter[PATH_MAX];
186 static bfd_vma dynamic_info[DT_ENCODING];
187 static bfd_vma dynamic_info_DT_GNU_HASH;
188 static bfd_vma version_info[16];
189 static Elf_Internal_Ehdr elf_header;
190 static Elf_Internal_Shdr * section_headers;
191 static Elf_Internal_Phdr * program_headers;
192 static Elf_Internal_Dyn * dynamic_section;
193 static Elf_Internal_Shdr * symtab_shndx_hdr;
194 static int show_name;
195 static int do_dynamic;
197 static int do_dyn_syms;
199 static int do_sections;
200 static int do_section_groups;
201 static int do_section_details;
202 static int do_segments;
203 static int do_unwind;
204 static int do_using_dynamic;
205 static int do_header;
207 static int do_version;
208 static int do_histogram;
209 static int do_debugging;
212 static int do_archive_index;
213 static int is_32bit_elf;
217 struct group_list * next;
218 unsigned int section_index;
223 struct group_list * root;
224 unsigned int group_index;
227 static size_t group_count;
228 static struct group * section_groups;
229 static struct group ** section_headers_groups;
232 /* Flag bits indicating particular types of dump. */
233 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
234 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
235 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
236 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
237 #define RELOC_DUMP (1 << 4) /* The -R command line switch. */
239 typedef unsigned char dump_type;
241 /* A linked list of the section names for which dumps were requested. */
242 struct dump_list_entry
246 struct dump_list_entry * next;
248 static struct dump_list_entry * dump_sects_byname;
250 /* A dynamic array of flags indicating for which sections a dump
251 has been requested via command line switches. */
252 static dump_type * cmdline_dump_sects = NULL;
253 static unsigned int num_cmdline_dump_sects = 0;
255 /* A dynamic array of flags indicating for which sections a dump of
256 some kind has been requested. It is reset on a per-object file
257 basis and then initialised from the cmdline_dump_sects array,
258 the results of interpreting the -w switch, and the
259 dump_sects_byname list. */
260 static dump_type * dump_sects = NULL;
261 static unsigned int num_dump_sects = 0;
264 /* How to print a vma value. */
265 typedef enum print_mode
277 /* Versioned symbol info. */
278 enum versioned_symbol_info
285 static const char *get_symbol_version_string
286 (FILE *file, int is_dynsym, const char *strtab,
287 unsigned long int strtab_size, unsigned int si,
288 Elf_Internal_Sym *psym, enum versioned_symbol_info *sym_info,
289 unsigned short *vna_other);
293 #define SECTION_NAME(X) \
294 ((X) == NULL ? _("<none>") \
295 : string_table == NULL ? _("<no-name>") \
296 : ((X)->sh_name >= string_table_length ? _("<corrupt>") \
297 : string_table + (X)->sh_name))
299 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
301 #define GET_ELF_SYMBOLS(file, section, sym_count) \
302 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
303 : get_64bit_elf_symbols (file, section, sym_count))
305 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
306 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
307 already been called and verified that the string exists. */
308 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
310 #define REMOVE_ARCH_BITS(ADDR) \
313 if (elf_header.e_machine == EM_ARM) \
318 /* Retrieve NMEMB structures, each SIZE bytes long from FILE starting at OFFSET +
319 the offset of the current archive member, if we are examining an archive.
320 Put the retrieved data into VAR, if it is not NULL. Otherwise allocate a buffer
321 using malloc and fill that. In either case return the pointer to the start of
322 the retrieved data or NULL if something went wrong. If something does go wrong
323 and REASON is not NULL then emit an error message using REASON as part of the
327 get_data (void * var, FILE * file, unsigned long offset, bfd_size_type size,
328 bfd_size_type nmemb, const char * reason)
331 bfd_size_type amt = size * nmemb;
333 if (size == 0 || nmemb == 0)
336 /* If the size_t type is smaller than the bfd_size_type, eg because
337 you are building a 32-bit tool on a 64-bit host, then make sure
338 that when the sizes are cast to (size_t) no information is lost. */
339 if (sizeof (size_t) < sizeof (bfd_size_type)
340 && ( (bfd_size_type) ((size_t) size) != size
341 || (bfd_size_type) ((size_t) nmemb) != nmemb))
344 error (_("Size truncation prevents reading 0x%llx elements of size 0x%llx for %s\n"),
345 (unsigned long long) nmemb, (unsigned long long) size, reason);
349 /* Check for size overflow. */
353 error (_("Size overflow prevents reading 0x%llx elements of size 0x%llx for %s\n"),
354 (unsigned long long) nmemb, (unsigned long long) size, reason);
358 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
359 attempting to allocate memory when the read is bound to fail. */
360 if (amt > current_file_size
361 || offset + archive_file_offset + amt > current_file_size)
364 error (_("Reading 0x%llx bytes extends past end of file for %s\n"),
365 (unsigned long long) amt, reason);
369 if (fseek (file, archive_file_offset + offset, SEEK_SET))
372 error (_("Unable to seek to 0x%lx for %s\n"),
373 (unsigned long) archive_file_offset + offset, reason);
380 /* Check for overflow. */
381 if (nmemb < (~(bfd_size_type) 0 - 1) / size)
382 /* + 1 so that we can '\0' terminate invalid string table sections. */
383 mvar = malloc ((size_t) amt + 1);
388 error (_("Out of memory allocating 0x%llx bytes for %s\n"),
389 (unsigned long long) amt, reason);
393 ((char *) mvar)[amt] = '\0';
396 if (fread (mvar, (size_t) size, (size_t) nmemb, file) != nmemb)
399 error (_("Unable to read in 0x%llx bytes of %s\n"),
400 (unsigned long long) amt, reason);
409 /* Print a VMA value. */
412 print_vma (bfd_vma vma, print_mode mode)
425 return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
432 return printf ("%5" BFD_VMA_FMT "d", vma);
440 return nc + printf ("%" BFD_VMA_FMT "x", vma);
443 return printf ("%" BFD_VMA_FMT "d", vma);
446 return printf ("%" BFD_VMA_FMT "u", vma);
451 /* Display a symbol on stdout. Handles the display of control characters and
452 multibye characters (assuming the host environment supports them).
454 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
456 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
457 padding as necessary.
459 Returns the number of emitted characters. */
462 print_symbol (int width, const char *symbol)
464 bfd_boolean extra_padding = FALSE;
466 #ifdef HAVE_MBSTATE_T
473 /* Keep the width positive. This also helps. */
475 extra_padding = TRUE;
480 /* Set the remaining width to a very large value.
481 This simplifies the code below. */
482 width_remaining = INT_MAX;
484 width_remaining = width;
486 #ifdef HAVE_MBSTATE_T
487 /* Initialise the multibyte conversion state. */
488 memset (& state, 0, sizeof (state));
491 while (width_remaining)
494 const char c = *symbol++;
499 /* Do not print control characters directly as they can affect terminal
500 settings. Such characters usually appear in the names generated
501 by the assembler for local labels. */
504 if (width_remaining < 2)
507 printf ("^%c", c + 0x40);
508 width_remaining -= 2;
511 else if (ISPRINT (c))
519 #ifdef HAVE_MBSTATE_T
522 /* Let printf do the hard work of displaying multibyte characters. */
523 printf ("%.1s", symbol - 1);
527 #ifdef HAVE_MBSTATE_T
528 /* Try to find out how many bytes made up the character that was
529 just printed. Advance the symbol pointer past the bytes that
531 n = mbrtowc (& w, symbol - 1, MB_CUR_MAX, & state);
535 if (n != (size_t) -1 && n != (size_t) -2 && n > 0)
540 if (extra_padding && num_printed < width)
542 /* Fill in the remaining spaces. */
543 printf ("%-*s", width - num_printed, " ");
550 /* Returns a pointer to a static buffer containing a printable version of
551 the given section's name. Like print_symbol, except that it does not try
552 to print multibyte characters, it just interprets them as hex values. */
555 printable_section_name (Elf_Internal_Shdr * sec)
557 #define MAX_PRINT_SEC_NAME_LEN 128
558 static char sec_name_buf [MAX_PRINT_SEC_NAME_LEN + 1];
559 const char * name = SECTION_NAME (sec);
560 char * buf = sec_name_buf;
562 unsigned int remaining = MAX_PRINT_SEC_NAME_LEN;
564 while ((c = * name ++) != 0)
575 else if (ISPRINT (c))
582 static char hex[17] = "0123456789ABCDEF";
587 * buf ++ = hex[(c & 0xf0) >> 4];
588 * buf ++ = hex[c & 0x0f];
602 printable_section_name_from_index (unsigned long ndx)
604 if (ndx >= elf_header.e_shnum)
605 return _("<corrupt>");
607 return printable_section_name (section_headers + ndx);
610 /* Return a pointer to section NAME, or NULL if no such section exists. */
612 static Elf_Internal_Shdr *
613 find_section (const char * name)
617 for (i = 0; i < elf_header.e_shnum; i++)
618 if (streq (SECTION_NAME (section_headers + i), name))
619 return section_headers + i;
624 /* Return a pointer to a section containing ADDR, or NULL if no such
627 static Elf_Internal_Shdr *
628 find_section_by_address (bfd_vma addr)
632 for (i = 0; i < elf_header.e_shnum; i++)
634 Elf_Internal_Shdr *sec = section_headers + i;
635 if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
642 static Elf_Internal_Shdr *
643 find_section_by_type (unsigned int type)
647 for (i = 0; i < elf_header.e_shnum; i++)
649 Elf_Internal_Shdr *sec = section_headers + i;
650 if (sec->sh_type == type)
657 /* Return a pointer to section NAME, or NULL if no such section exists,
658 restricted to the list of sections given in SET. */
660 static Elf_Internal_Shdr *
661 find_section_in_set (const char * name, unsigned int * set)
667 while ((i = *set++) > 0)
668 if (streq (SECTION_NAME (section_headers + i), name))
669 return section_headers + i;
672 return find_section (name);
675 /* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
678 static inline unsigned long
679 read_uleb128 (unsigned char *data,
680 unsigned int *length_return,
681 const unsigned char * const end)
683 return read_leb128 (data, length_return, FALSE, end);
686 /* Return true if the current file is for IA-64 machine and OpenVMS ABI.
687 This OS has so many departures from the ELF standard that we test it at
693 return elf_header.e_machine == EM_IA_64
694 && elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
697 /* Guess the relocation size commonly used by the specific machines. */
700 guess_is_rela (unsigned int e_machine)
704 /* Targets that use REL relocations. */
719 /* Targets that use RELA relocations. */
723 case EM_ADAPTEVA_EPIPHANY:
725 case EM_ALTERA_NIOS2:
745 case EM_LATTICEMICO32:
754 case EM_CYGNUS_MN10200:
756 case EM_CYGNUS_MN10300:
790 case EM_MICROBLAZE_OLD:
811 warn (_("Don't know about relocations on this machine architecture\n"));
817 slurp_rela_relocs (FILE * file,
818 unsigned long rel_offset,
819 unsigned long rel_size,
820 Elf_Internal_Rela ** relasp,
821 unsigned long * nrelasp)
823 Elf_Internal_Rela * relas;
829 Elf32_External_Rela * erelas;
831 erelas = (Elf32_External_Rela *) get_data (NULL, file, rel_offset, 1,
832 rel_size, _("32-bit relocation data"));
836 nrelas = rel_size / sizeof (Elf32_External_Rela);
838 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
839 sizeof (Elf_Internal_Rela));
844 error (_("out of memory parsing relocs\n"));
848 for (i = 0; i < nrelas; i++)
850 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
851 relas[i].r_info = BYTE_GET (erelas[i].r_info);
852 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
859 Elf64_External_Rela * erelas;
861 erelas = (Elf64_External_Rela *) get_data (NULL, file, rel_offset, 1,
862 rel_size, _("64-bit relocation data"));
866 nrelas = rel_size / sizeof (Elf64_External_Rela);
868 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
869 sizeof (Elf_Internal_Rela));
874 error (_("out of memory parsing relocs\n"));
878 for (i = 0; i < nrelas; i++)
880 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
881 relas[i].r_info = BYTE_GET (erelas[i].r_info);
882 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
884 /* The #ifdef BFD64 below is to prevent a compile time
885 warning. We know that if we do not have a 64 bit data
886 type that we will never execute this code anyway. */
888 if (elf_header.e_machine == EM_MIPS
889 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
891 /* In little-endian objects, r_info isn't really a
892 64-bit little-endian value: it has a 32-bit
893 little-endian symbol index followed by four
894 individual byte fields. Reorder INFO
896 bfd_vma inf = relas[i].r_info;
897 inf = (((inf & 0xffffffff) << 32)
898 | ((inf >> 56) & 0xff)
899 | ((inf >> 40) & 0xff00)
900 | ((inf >> 24) & 0xff0000)
901 | ((inf >> 8) & 0xff000000));
902 relas[i].r_info = inf;
915 slurp_rel_relocs (FILE * file,
916 unsigned long rel_offset,
917 unsigned long rel_size,
918 Elf_Internal_Rela ** relsp,
919 unsigned long * nrelsp)
921 Elf_Internal_Rela * rels;
927 Elf32_External_Rel * erels;
929 erels = (Elf32_External_Rel *) get_data (NULL, file, rel_offset, 1,
930 rel_size, _("32-bit relocation data"));
934 nrels = rel_size / sizeof (Elf32_External_Rel);
936 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
941 error (_("out of memory parsing relocs\n"));
945 for (i = 0; i < nrels; i++)
947 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
948 rels[i].r_info = BYTE_GET (erels[i].r_info);
949 rels[i].r_addend = 0;
956 Elf64_External_Rel * erels;
958 erels = (Elf64_External_Rel *) get_data (NULL, file, rel_offset, 1,
959 rel_size, _("64-bit relocation data"));
963 nrels = rel_size / sizeof (Elf64_External_Rel);
965 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
970 error (_("out of memory parsing relocs\n"));
974 for (i = 0; i < nrels; i++)
976 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
977 rels[i].r_info = BYTE_GET (erels[i].r_info);
978 rels[i].r_addend = 0;
980 /* The #ifdef BFD64 below is to prevent a compile time
981 warning. We know that if we do not have a 64 bit data
982 type that we will never execute this code anyway. */
984 if (elf_header.e_machine == EM_MIPS
985 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
987 /* In little-endian objects, r_info isn't really a
988 64-bit little-endian value: it has a 32-bit
989 little-endian symbol index followed by four
990 individual byte fields. Reorder INFO
992 bfd_vma inf = rels[i].r_info;
993 inf = (((inf & 0xffffffff) << 32)
994 | ((inf >> 56) & 0xff)
995 | ((inf >> 40) & 0xff00)
996 | ((inf >> 24) & 0xff0000)
997 | ((inf >> 8) & 0xff000000));
998 rels[i].r_info = inf;
1010 /* Returns the reloc type extracted from the reloc info field. */
1013 get_reloc_type (bfd_vma reloc_info)
1016 return ELF32_R_TYPE (reloc_info);
1018 switch (elf_header.e_machine)
1021 /* Note: We assume that reloc_info has already been adjusted for us. */
1022 return ELF64_MIPS_R_TYPE (reloc_info);
1025 return ELF64_R_TYPE_ID (reloc_info);
1028 return ELF64_R_TYPE (reloc_info);
1032 /* Return the symbol index extracted from the reloc info field. */
1035 get_reloc_symindex (bfd_vma reloc_info)
1037 return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
1040 static inline bfd_boolean
1041 uses_msp430x_relocs (void)
1044 elf_header.e_machine == EM_MSP430 /* Paranoia. */
1045 /* GCC uses osabi == ELFOSBI_STANDALONE. */
1046 && (((elf_header.e_flags & EF_MSP430_MACH) == E_MSP430_MACH_MSP430X)
1047 /* TI compiler uses ELFOSABI_NONE. */
1048 || (elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE));
1051 /* Display the contents of the relocation data found at the specified
1055 dump_relocations (FILE * file,
1056 unsigned long rel_offset,
1057 unsigned long rel_size,
1058 Elf_Internal_Sym * symtab,
1059 unsigned long nsyms,
1061 unsigned long strtablen,
1066 Elf_Internal_Rela * rels;
1068 if (is_rela == UNKNOWN)
1069 is_rela = guess_is_rela (elf_header.e_machine);
1073 if (!slurp_rela_relocs (file, rel_offset, rel_size, &rels, &rel_size))
1078 if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
1087 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
1089 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
1094 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
1096 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
1104 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
1106 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
1111 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
1113 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
1117 for (i = 0; i < rel_size; i++)
1122 bfd_vma symtab_index;
1125 offset = rels[i].r_offset;
1126 inf = rels[i].r_info;
1128 type = get_reloc_type (inf);
1129 symtab_index = get_reloc_symindex (inf);
1133 printf ("%8.8lx %8.8lx ",
1134 (unsigned long) offset & 0xffffffff,
1135 (unsigned long) inf & 0xffffffff);
1139 #if BFD_HOST_64BIT_LONG
1141 ? "%16.16lx %16.16lx "
1142 : "%12.12lx %12.12lx ",
1144 #elif BFD_HOST_64BIT_LONG_LONG
1147 ? "%16.16llx %16.16llx "
1148 : "%12.12llx %12.12llx ",
1152 ? "%16.16I64x %16.16I64x "
1153 : "%12.12I64x %12.12I64x ",
1158 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1159 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1160 _bfd_int64_high (offset),
1161 _bfd_int64_low (offset),
1162 _bfd_int64_high (inf),
1163 _bfd_int64_low (inf));
1167 switch (elf_header.e_machine)
1174 rtype = elf_aarch64_reloc_type (type);
1178 case EM_CYGNUS_M32R:
1179 rtype = elf_m32r_reloc_type (type);
1184 rtype = elf_i386_reloc_type (type);
1189 rtype = elf_m68hc11_reloc_type (type);
1193 rtype = elf_m68k_reloc_type (type);
1197 rtype = elf_i960_reloc_type (type);
1202 rtype = elf_avr_reloc_type (type);
1205 case EM_OLD_SPARCV9:
1206 case EM_SPARC32PLUS:
1209 rtype = elf_sparc_reloc_type (type);
1213 rtype = elf_spu_reloc_type (type);
1217 rtype = v800_reloc_type (type);
1220 case EM_CYGNUS_V850:
1221 rtype = v850_reloc_type (type);
1225 case EM_CYGNUS_D10V:
1226 rtype = elf_d10v_reloc_type (type);
1230 case EM_CYGNUS_D30V:
1231 rtype = elf_d30v_reloc_type (type);
1235 rtype = elf_dlx_reloc_type (type);
1239 rtype = elf_sh_reloc_type (type);
1243 case EM_CYGNUS_MN10300:
1244 rtype = elf_mn10300_reloc_type (type);
1248 case EM_CYGNUS_MN10200:
1249 rtype = elf_mn10200_reloc_type (type);
1253 case EM_CYGNUS_FR30:
1254 rtype = elf_fr30_reloc_type (type);
1258 rtype = elf_frv_reloc_type (type);
1262 rtype = elf_ft32_reloc_type (type);
1266 rtype = elf_mcore_reloc_type (type);
1270 rtype = elf_mmix_reloc_type (type);
1274 rtype = elf_moxie_reloc_type (type);
1278 if (uses_msp430x_relocs ())
1280 rtype = elf_msp430x_reloc_type (type);
1284 rtype = elf_msp430_reloc_type (type);
1288 rtype = elf_nds32_reloc_type (type);
1292 rtype = elf_ppc_reloc_type (type);
1296 rtype = elf_ppc64_reloc_type (type);
1300 case EM_MIPS_RS3_LE:
1301 rtype = elf_mips_reloc_type (type);
1305 rtype = elf_alpha_reloc_type (type);
1309 rtype = elf_arm_reloc_type (type);
1313 rtype = elf_arc_reloc_type (type);
1317 rtype = elf_hppa_reloc_type (type);
1323 rtype = elf_h8_reloc_type (type);
1327 rtype = elf_or1k_reloc_type (type);
1332 rtype = elf_pj_reloc_type (type);
1335 rtype = elf_ia64_reloc_type (type);
1339 rtype = elf_cris_reloc_type (type);
1343 rtype = elf_i860_reloc_type (type);
1349 rtype = elf_x86_64_reloc_type (type);
1353 rtype = i370_reloc_type (type);
1358 rtype = elf_s390_reloc_type (type);
1362 rtype = elf_score_reloc_type (type);
1366 rtype = elf_xstormy16_reloc_type (type);
1370 rtype = elf_crx_reloc_type (type);
1374 rtype = elf_vax_reloc_type (type);
1378 rtype = elf_visium_reloc_type (type);
1381 case EM_ADAPTEVA_EPIPHANY:
1382 rtype = elf_epiphany_reloc_type (type);
1387 rtype = elf_ip2k_reloc_type (type);
1391 rtype = elf_iq2000_reloc_type (type);
1396 rtype = elf_xtensa_reloc_type (type);
1399 case EM_LATTICEMICO32:
1400 rtype = elf_lm32_reloc_type (type);
1405 rtype = elf_m32c_reloc_type (type);
1409 rtype = elf_mt_reloc_type (type);
1413 rtype = elf_bfin_reloc_type (type);
1417 rtype = elf_mep_reloc_type (type);
1421 rtype = elf_cr16_reloc_type (type);
1425 case EM_MICROBLAZE_OLD:
1426 rtype = elf_microblaze_reloc_type (type);
1430 rtype = elf_rl78_reloc_type (type);
1434 rtype = elf_rx_reloc_type (type);
1438 rtype = elf_metag_reloc_type (type);
1443 rtype = elf_xc16x_reloc_type (type);
1447 rtype = elf_tic6x_reloc_type (type);
1451 rtype = elf_tilegx_reloc_type (type);
1455 rtype = elf_tilepro_reloc_type (type);
1459 rtype = elf_xgate_reloc_type (type);
1462 case EM_ALTERA_NIOS2:
1463 rtype = elf_nios2_reloc_type (type);
1468 printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
1470 printf (do_wide ? "%-22.22s" : "%-17.17s", rtype);
1472 if (elf_header.e_machine == EM_ALPHA
1474 && streq (rtype, "R_ALPHA_LITUSE")
1477 switch (rels[i].r_addend)
1479 case LITUSE_ALPHA_ADDR: rtype = "ADDR"; break;
1480 case LITUSE_ALPHA_BASE: rtype = "BASE"; break;
1481 case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1482 case LITUSE_ALPHA_JSR: rtype = "JSR"; break;
1483 case LITUSE_ALPHA_TLSGD: rtype = "TLSGD"; break;
1484 case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1485 case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1486 default: rtype = NULL;
1489 printf (" (%s)", rtype);
1493 printf (_("<unknown addend: %lx>"),
1494 (unsigned long) rels[i].r_addend);
1497 else if (symtab_index)
1499 if (symtab == NULL || symtab_index >= nsyms)
1500 printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index);
1503 Elf_Internal_Sym * psym;
1504 const char * version_string;
1505 enum versioned_symbol_info sym_info;
1506 unsigned short vna_other;
1508 psym = symtab + symtab_index;
1511 = get_symbol_version_string (file, is_dynsym,
1520 if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1524 unsigned int width = is_32bit_elf ? 8 : 14;
1526 /* Relocations against GNU_IFUNC symbols do not use the value
1527 of the symbol as the address to relocate against. Instead
1528 they invoke the function named by the symbol and use its
1529 result as the address for relocation.
1531 To indicate this to the user, do not display the value of
1532 the symbol in the "Symbols's Value" field. Instead show
1533 its name followed by () as a hint that the symbol is
1537 || psym->st_name == 0
1538 || psym->st_name >= strtablen)
1541 name = strtab + psym->st_name;
1543 len = print_symbol (width, name);
1545 printf (sym_info == symbol_public ? "@@%s" : "@%s",
1547 printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1551 print_vma (psym->st_value, LONG_HEX);
1553 printf (is_32bit_elf ? " " : " ");
1556 if (psym->st_name == 0)
1558 const char * sec_name = "<null>";
1561 if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1563 if (psym->st_shndx < elf_header.e_shnum)
1564 sec_name = SECTION_NAME (section_headers + psym->st_shndx);
1565 else if (psym->st_shndx == SHN_ABS)
1567 else if (psym->st_shndx == SHN_COMMON)
1568 sec_name = "COMMON";
1569 else if ((elf_header.e_machine == EM_MIPS
1570 && psym->st_shndx == SHN_MIPS_SCOMMON)
1571 || (elf_header.e_machine == EM_TI_C6000
1572 && psym->st_shndx == SHN_TIC6X_SCOMMON))
1573 sec_name = "SCOMMON";
1574 else if (elf_header.e_machine == EM_MIPS
1575 && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1576 sec_name = "SUNDEF";
1577 else if ((elf_header.e_machine == EM_X86_64
1578 || elf_header.e_machine == EM_L1OM
1579 || elf_header.e_machine == EM_K1OM)
1580 && psym->st_shndx == SHN_X86_64_LCOMMON)
1581 sec_name = "LARGE_COMMON";
1582 else if (elf_header.e_machine == EM_IA_64
1583 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1584 && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1585 sec_name = "ANSI_COM";
1586 else if (is_ia64_vms ()
1587 && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1588 sec_name = "VMS_SYMVEC";
1591 sprintf (name_buf, "<section 0x%x>",
1592 (unsigned int) psym->st_shndx);
1593 sec_name = name_buf;
1596 print_symbol (22, sec_name);
1598 else if (strtab == NULL)
1599 printf (_("<string table index: %3ld>"), psym->st_name);
1600 else if (psym->st_name >= strtablen)
1601 printf (_("<corrupt string table index: %3ld>"), psym->st_name);
1604 print_symbol (22, strtab + psym->st_name);
1606 printf (sym_info == symbol_public ? "@@%s" : "@%s",
1612 bfd_signed_vma off = rels[i].r_addend;
1615 printf (" - %" BFD_VMA_FMT "x", - off);
1617 printf (" + %" BFD_VMA_FMT "x", off);
1623 bfd_signed_vma off = rels[i].r_addend;
1625 printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
1627 printf ("-%" BFD_VMA_FMT "x", - off);
1629 printf ("%" BFD_VMA_FMT "x", off);
1632 if (elf_header.e_machine == EM_SPARCV9
1634 && streq (rtype, "R_SPARC_OLO10"))
1635 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
1640 if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
1642 bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1643 bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
1644 const char * rtype2 = elf_mips_reloc_type (type2);
1645 const char * rtype3 = elf_mips_reloc_type (type3);
1647 printf (" Type2: ");
1650 printf (_("unrecognized: %-7lx"),
1651 (unsigned long) type2 & 0xffffffff);
1653 printf ("%-17.17s", rtype2);
1655 printf ("\n Type3: ");
1658 printf (_("unrecognized: %-7lx"),
1659 (unsigned long) type3 & 0xffffffff);
1661 printf ("%-17.17s", rtype3);
1672 get_mips_dynamic_type (unsigned long type)
1676 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1677 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1678 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1679 case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1680 case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1681 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1682 case DT_MIPS_MSYM: return "MIPS_MSYM";
1683 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1684 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1685 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1686 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1687 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1688 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1689 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1690 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1691 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1692 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1693 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1694 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1695 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1696 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1697 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1698 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1699 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1700 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1701 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1702 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1703 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1704 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1705 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1706 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1707 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1708 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1709 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1710 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1711 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1712 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1713 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1714 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1715 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1716 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1717 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1718 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
1719 case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1720 case DT_MIPS_RWPLT: return "MIPS_RWPLT";
1727 get_sparc64_dynamic_type (unsigned long type)
1731 case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1738 get_ppc_dynamic_type (unsigned long type)
1742 case DT_PPC_GOT: return "PPC_GOT";
1743 case DT_PPC_OPT: return "PPC_OPT";
1750 get_ppc64_dynamic_type (unsigned long type)
1754 case DT_PPC64_GLINK: return "PPC64_GLINK";
1755 case DT_PPC64_OPD: return "PPC64_OPD";
1756 case DT_PPC64_OPDSZ: return "PPC64_OPDSZ";
1757 case DT_PPC64_OPT: return "PPC64_OPT";
1764 get_parisc_dynamic_type (unsigned long type)
1768 case DT_HP_LOAD_MAP: return "HP_LOAD_MAP";
1769 case DT_HP_DLD_FLAGS: return "HP_DLD_FLAGS";
1770 case DT_HP_DLD_HOOK: return "HP_DLD_HOOK";
1771 case DT_HP_UX10_INIT: return "HP_UX10_INIT";
1772 case DT_HP_UX10_INITSZ: return "HP_UX10_INITSZ";
1773 case DT_HP_PREINIT: return "HP_PREINIT";
1774 case DT_HP_PREINITSZ: return "HP_PREINITSZ";
1775 case DT_HP_NEEDED: return "HP_NEEDED";
1776 case DT_HP_TIME_STAMP: return "HP_TIME_STAMP";
1777 case DT_HP_CHECKSUM: return "HP_CHECKSUM";
1778 case DT_HP_GST_SIZE: return "HP_GST_SIZE";
1779 case DT_HP_GST_VERSION: return "HP_GST_VERSION";
1780 case DT_HP_GST_HASHVAL: return "HP_GST_HASHVAL";
1781 case DT_HP_EPLTREL: return "HP_GST_EPLTREL";
1782 case DT_HP_EPLTRELSZ: return "HP_GST_EPLTRELSZ";
1783 case DT_HP_FILTERED: return "HP_FILTERED";
1784 case DT_HP_FILTER_TLS: return "HP_FILTER_TLS";
1785 case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1786 case DT_HP_LAZYLOAD: return "HP_LAZYLOAD";
1787 case DT_HP_BIND_NOW_COUNT: return "HP_BIND_NOW_COUNT";
1788 case DT_PLT: return "PLT";
1789 case DT_PLT_SIZE: return "PLT_SIZE";
1790 case DT_DLT: return "DLT";
1791 case DT_DLT_SIZE: return "DLT_SIZE";
1798 get_ia64_dynamic_type (unsigned long type)
1802 case DT_IA_64_PLT_RESERVE: return "IA_64_PLT_RESERVE";
1803 case DT_IA_64_VMS_SUBTYPE: return "VMS_SUBTYPE";
1804 case DT_IA_64_VMS_IMGIOCNT: return "VMS_IMGIOCNT";
1805 case DT_IA_64_VMS_LNKFLAGS: return "VMS_LNKFLAGS";
1806 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1807 case DT_IA_64_VMS_IDENT: return "VMS_IDENT";
1808 case DT_IA_64_VMS_NEEDED_IDENT: return "VMS_NEEDED_IDENT";
1809 case DT_IA_64_VMS_IMG_RELA_CNT: return "VMS_IMG_RELA_CNT";
1810 case DT_IA_64_VMS_SEG_RELA_CNT: return "VMS_SEG_RELA_CNT";
1811 case DT_IA_64_VMS_FIXUP_RELA_CNT: return "VMS_FIXUP_RELA_CNT";
1812 case DT_IA_64_VMS_FIXUP_NEEDED: return "VMS_FIXUP_NEEDED";
1813 case DT_IA_64_VMS_SYMVEC_CNT: return "VMS_SYMVEC_CNT";
1814 case DT_IA_64_VMS_XLATED: return "VMS_XLATED";
1815 case DT_IA_64_VMS_STACKSIZE: return "VMS_STACKSIZE";
1816 case DT_IA_64_VMS_UNWINDSZ: return "VMS_UNWINDSZ";
1817 case DT_IA_64_VMS_UNWIND_CODSEG: return "VMS_UNWIND_CODSEG";
1818 case DT_IA_64_VMS_UNWIND_INFOSEG: return "VMS_UNWIND_INFOSEG";
1819 case DT_IA_64_VMS_LINKTIME: return "VMS_LINKTIME";
1820 case DT_IA_64_VMS_SEG_NO: return "VMS_SEG_NO";
1821 case DT_IA_64_VMS_SYMVEC_OFFSET: return "VMS_SYMVEC_OFFSET";
1822 case DT_IA_64_VMS_SYMVEC_SEG: return "VMS_SYMVEC_SEG";
1823 case DT_IA_64_VMS_UNWIND_OFFSET: return "VMS_UNWIND_OFFSET";
1824 case DT_IA_64_VMS_UNWIND_SEG: return "VMS_UNWIND_SEG";
1825 case DT_IA_64_VMS_STRTAB_OFFSET: return "VMS_STRTAB_OFFSET";
1826 case DT_IA_64_VMS_SYSVER_OFFSET: return "VMS_SYSVER_OFFSET";
1827 case DT_IA_64_VMS_IMG_RELA_OFF: return "VMS_IMG_RELA_OFF";
1828 case DT_IA_64_VMS_SEG_RELA_OFF: return "VMS_SEG_RELA_OFF";
1829 case DT_IA_64_VMS_FIXUP_RELA_OFF: return "VMS_FIXUP_RELA_OFF";
1830 case DT_IA_64_VMS_PLTGOT_OFFSET: return "VMS_PLTGOT_OFFSET";
1831 case DT_IA_64_VMS_PLTGOT_SEG: return "VMS_PLTGOT_SEG";
1832 case DT_IA_64_VMS_FPMODE: return "VMS_FPMODE";
1839 get_alpha_dynamic_type (unsigned long type)
1843 case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
1850 get_score_dynamic_type (unsigned long type)
1854 case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
1855 case DT_SCORE_LOCAL_GOTNO: return "SCORE_LOCAL_GOTNO";
1856 case DT_SCORE_SYMTABNO: return "SCORE_SYMTABNO";
1857 case DT_SCORE_GOTSYM: return "SCORE_GOTSYM";
1858 case DT_SCORE_UNREFEXTNO: return "SCORE_UNREFEXTNO";
1859 case DT_SCORE_HIPAGENO: return "SCORE_HIPAGENO";
1866 get_tic6x_dynamic_type (unsigned long type)
1870 case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
1871 case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
1872 case DT_C6000_DSBT_BASE: return "C6000_DSBT_BASE";
1873 case DT_C6000_DSBT_SIZE: return "C6000_DSBT_SIZE";
1874 case DT_C6000_PREEMPTMAP: return "C6000_PREEMPTMAP";
1875 case DT_C6000_DSBT_INDEX: return "C6000_DSBT_INDEX";
1882 get_nios2_dynamic_type (unsigned long type)
1886 case DT_NIOS2_GP: return "NIOS2_GP";
1893 get_dynamic_type (unsigned long type)
1895 static char buff[64];
1899 case DT_NULL: return "NULL";
1900 case DT_NEEDED: return "NEEDED";
1901 case DT_PLTRELSZ: return "PLTRELSZ";
1902 case DT_PLTGOT: return "PLTGOT";
1903 case DT_HASH: return "HASH";
1904 case DT_STRTAB: return "STRTAB";
1905 case DT_SYMTAB: return "SYMTAB";
1906 case DT_RELA: return "RELA";
1907 case DT_RELASZ: return "RELASZ";
1908 case DT_RELAENT: return "RELAENT";
1909 case DT_STRSZ: return "STRSZ";
1910 case DT_SYMENT: return "SYMENT";
1911 case DT_INIT: return "INIT";
1912 case DT_FINI: return "FINI";
1913 case DT_SONAME: return "SONAME";
1914 case DT_RPATH: return "RPATH";
1915 case DT_SYMBOLIC: return "SYMBOLIC";
1916 case DT_REL: return "REL";
1917 case DT_RELSZ: return "RELSZ";
1918 case DT_RELENT: return "RELENT";
1919 case DT_PLTREL: return "PLTREL";
1920 case DT_DEBUG: return "DEBUG";
1921 case DT_TEXTREL: return "TEXTREL";
1922 case DT_JMPREL: return "JMPREL";
1923 case DT_BIND_NOW: return "BIND_NOW";
1924 case DT_INIT_ARRAY: return "INIT_ARRAY";
1925 case DT_FINI_ARRAY: return "FINI_ARRAY";
1926 case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
1927 case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
1928 case DT_RUNPATH: return "RUNPATH";
1929 case DT_FLAGS: return "FLAGS";
1931 case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1932 case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
1934 case DT_CHECKSUM: return "CHECKSUM";
1935 case DT_PLTPADSZ: return "PLTPADSZ";
1936 case DT_MOVEENT: return "MOVEENT";
1937 case DT_MOVESZ: return "MOVESZ";
1938 case DT_FEATURE: return "FEATURE";
1939 case DT_POSFLAG_1: return "POSFLAG_1";
1940 case DT_SYMINSZ: return "SYMINSZ";
1941 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
1943 case DT_ADDRRNGLO: return "ADDRRNGLO";
1944 case DT_CONFIG: return "CONFIG";
1945 case DT_DEPAUDIT: return "DEPAUDIT";
1946 case DT_AUDIT: return "AUDIT";
1947 case DT_PLTPAD: return "PLTPAD";
1948 case DT_MOVETAB: return "MOVETAB";
1949 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
1951 case DT_VERSYM: return "VERSYM";
1953 case DT_TLSDESC_GOT: return "TLSDESC_GOT";
1954 case DT_TLSDESC_PLT: return "TLSDESC_PLT";
1955 case DT_RELACOUNT: return "RELACOUNT";
1956 case DT_RELCOUNT: return "RELCOUNT";
1957 case DT_FLAGS_1: return "FLAGS_1";
1958 case DT_VERDEF: return "VERDEF";
1959 case DT_VERDEFNUM: return "VERDEFNUM";
1960 case DT_VERNEED: return "VERNEED";
1961 case DT_VERNEEDNUM: return "VERNEEDNUM";
1963 case DT_AUXILIARY: return "AUXILIARY";
1964 case DT_USED: return "USED";
1965 case DT_FILTER: return "FILTER";
1967 case DT_GNU_PRELINKED: return "GNU_PRELINKED";
1968 case DT_GNU_CONFLICT: return "GNU_CONFLICT";
1969 case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
1970 case DT_GNU_LIBLIST: return "GNU_LIBLIST";
1971 case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
1972 case DT_GNU_HASH: return "GNU_HASH";
1975 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1977 const char * result;
1979 switch (elf_header.e_machine)
1982 case EM_MIPS_RS3_LE:
1983 result = get_mips_dynamic_type (type);
1986 result = get_sparc64_dynamic_type (type);
1989 result = get_ppc_dynamic_type (type);
1992 result = get_ppc64_dynamic_type (type);
1995 result = get_ia64_dynamic_type (type);
1998 result = get_alpha_dynamic_type (type);
2001 result = get_score_dynamic_type (type);
2004 result = get_tic6x_dynamic_type (type);
2006 case EM_ALTERA_NIOS2:
2007 result = get_nios2_dynamic_type (type);
2017 snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
2019 else if (((type >= DT_LOOS) && (type <= DT_HIOS))
2020 || (elf_header.e_machine == EM_PARISC
2021 && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
2023 const char * result;
2025 switch (elf_header.e_machine)
2028 result = get_parisc_dynamic_type (type);
2031 result = get_ia64_dynamic_type (type);
2041 snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
2045 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
2052 get_file_type (unsigned e_type)
2054 static char buff[32];
2058 case ET_NONE: return _("NONE (None)");
2059 case ET_REL: return _("REL (Relocatable file)");
2060 case ET_EXEC: return _("EXEC (Executable file)");
2061 case ET_DYN: return _("DYN (Shared object file)");
2062 case ET_CORE: return _("CORE (Core file)");
2065 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
2066 snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
2067 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
2068 snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
2070 snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
2076 get_machine_name (unsigned e_machine)
2078 static char buff[64]; /* XXX */
2082 case EM_NONE: return _("None");
2083 case EM_AARCH64: return "AArch64";
2084 case EM_M32: return "WE32100";
2085 case EM_SPARC: return "Sparc";
2086 case EM_SPU: return "SPU";
2087 case EM_386: return "Intel 80386";
2088 case EM_68K: return "MC68000";
2089 case EM_88K: return "MC88000";
2090 case EM_486: return "Intel 80486";
2091 case EM_860: return "Intel 80860";
2092 case EM_MIPS: return "MIPS R3000";
2093 case EM_S370: return "IBM System/370";
2094 case EM_MIPS_RS3_LE: return "MIPS R4000 big-endian";
2095 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
2096 case EM_PARISC: return "HPPA";
2097 case EM_PPC_OLD: return "Power PC (old)";
2098 case EM_SPARC32PLUS: return "Sparc v8+" ;
2099 case EM_960: return "Intel 90860";
2100 case EM_PPC: return "PowerPC";
2101 case EM_PPC64: return "PowerPC64";
2102 case EM_FR20: return "Fujitsu FR20";
2103 case EM_FT32: return "FTDI FT32";
2104 case EM_RH32: return "TRW RH32";
2105 case EM_MCORE: return "MCORE";
2106 case EM_ARM: return "ARM";
2107 case EM_OLD_ALPHA: return "Digital Alpha (old)";
2108 case EM_SH: return "Renesas / SuperH SH";
2109 case EM_SPARCV9: return "Sparc v9";
2110 case EM_TRICORE: return "Siemens Tricore";
2111 case EM_ARC: return "ARC";
2112 case EM_H8_300: return "Renesas H8/300";
2113 case EM_H8_300H: return "Renesas H8/300H";
2114 case EM_H8S: return "Renesas H8S";
2115 case EM_H8_500: return "Renesas H8/500";
2116 case EM_IA_64: return "Intel IA-64";
2117 case EM_MIPS_X: return "Stanford MIPS-X";
2118 case EM_COLDFIRE: return "Motorola Coldfire";
2119 case EM_ALPHA: return "Alpha";
2120 case EM_CYGNUS_D10V:
2121 case EM_D10V: return "d10v";
2122 case EM_CYGNUS_D30V:
2123 case EM_D30V: return "d30v";
2124 case EM_CYGNUS_M32R:
2125 case EM_M32R: return "Renesas M32R (formerly Mitsubishi M32r)";
2126 case EM_CYGNUS_V850:
2127 case EM_V800: return "Renesas V850 (using RH850 ABI)";
2128 case EM_V850: return "Renesas V850";
2129 case EM_CYGNUS_MN10300:
2130 case EM_MN10300: return "mn10300";
2131 case EM_CYGNUS_MN10200:
2132 case EM_MN10200: return "mn10200";
2133 case EM_MOXIE: return "Moxie";
2134 case EM_CYGNUS_FR30:
2135 case EM_FR30: return "Fujitsu FR30";
2136 case EM_CYGNUS_FRV: return "Fujitsu FR-V";
2138 case EM_PJ: return "picoJava";
2139 case EM_MMA: return "Fujitsu Multimedia Accelerator";
2140 case EM_PCP: return "Siemens PCP";
2141 case EM_NCPU: return "Sony nCPU embedded RISC processor";
2142 case EM_NDR1: return "Denso NDR1 microprocesspr";
2143 case EM_STARCORE: return "Motorola Star*Core processor";
2144 case EM_ME16: return "Toyota ME16 processor";
2145 case EM_ST100: return "STMicroelectronics ST100 processor";
2146 case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
2147 case EM_PDSP: return "Sony DSP processor";
2148 case EM_PDP10: return "Digital Equipment Corp. PDP-10";
2149 case EM_PDP11: return "Digital Equipment Corp. PDP-11";
2150 case EM_FX66: return "Siemens FX66 microcontroller";
2151 case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
2152 case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
2153 case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
2154 case EM_68HC12: return "Motorola MC68HC12 Microcontroller";
2155 case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
2156 case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
2157 case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
2158 case EM_SVX: return "Silicon Graphics SVx";
2159 case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
2160 case EM_VAX: return "Digital VAX";
2161 case EM_VISIUM: return "CDS VISIUMcore processor";
2163 case EM_AVR: return "Atmel AVR 8-bit microcontroller";
2164 case EM_CRIS: return "Axis Communications 32-bit embedded processor";
2165 case EM_JAVELIN: return "Infineon Technologies 32-bit embedded cpu";
2166 case EM_FIREPATH: return "Element 14 64-bit DSP processor";
2167 case EM_ZSP: return "LSI Logic's 16-bit DSP processor";
2168 case EM_MMIX: return "Donald Knuth's educational 64-bit processor";
2169 case EM_HUANY: return "Harvard Universitys's machine-independent object format";
2170 case EM_PRISM: return "Vitesse Prism";
2171 case EM_X86_64: return "Advanced Micro Devices X86-64";
2172 case EM_L1OM: return "Intel L1OM";
2173 case EM_K1OM: return "Intel K1OM";
2175 case EM_S390: return "IBM S/390";
2176 case EM_SCORE: return "SUNPLUS S+Core";
2177 case EM_XSTORMY16: return "Sanyo XStormy16 CPU core";
2178 case EM_OR1K: return "OpenRISC 1000";
2179 case EM_ARC_A5: return "ARC International ARCompact processor";
2180 case EM_CRX: return "National Semiconductor CRX microprocessor";
2181 case EM_ADAPTEVA_EPIPHANY: return "Adapteva EPIPHANY";
2182 case EM_DLX: return "OpenDLX";
2184 case EM_IP2K: return "Ubicom IP2xxx 8-bit microcontrollers";
2185 case EM_IQ2000: return "Vitesse IQ2000";
2187 case EM_XTENSA: return "Tensilica Xtensa Processor";
2188 case EM_VIDEOCORE: return "Alphamosaic VideoCore processor";
2189 case EM_TMM_GPP: return "Thompson Multimedia General Purpose Processor";
2190 case EM_NS32K: return "National Semiconductor 32000 series";
2191 case EM_TPC: return "Tenor Network TPC processor";
2192 case EM_ST200: return "STMicroelectronics ST200 microcontroller";
2193 case EM_MAX: return "MAX Processor";
2194 case EM_CR: return "National Semiconductor CompactRISC";
2195 case EM_F2MC16: return "Fujitsu F2MC16";
2196 case EM_MSP430: return "Texas Instruments msp430 microcontroller";
2197 case EM_LATTICEMICO32: return "Lattice Mico32";
2199 case EM_M32C: return "Renesas M32c";
2200 case EM_MT: return "Morpho Techologies MT processor";
2201 case EM_BLACKFIN: return "Analog Devices Blackfin";
2202 case EM_SE_C33: return "S1C33 Family of Seiko Epson processors";
2203 case EM_SEP: return "Sharp embedded microprocessor";
2204 case EM_ARCA: return "Arca RISC microprocessor";
2205 case EM_UNICORE: return "Unicore";
2206 case EM_EXCESS: return "eXcess 16/32/64-bit configurable embedded CPU";
2207 case EM_DXP: return "Icera Semiconductor Inc. Deep Execution Processor";
2208 case EM_NIOS32: return "Altera Nios";
2209 case EM_ALTERA_NIOS2: return "Altera Nios II";
2211 case EM_XC16X: return "Infineon Technologies xc16x";
2212 case EM_M16C: return "Renesas M16C series microprocessors";
2213 case EM_DSPIC30F: return "Microchip Technology dsPIC30F Digital Signal Controller";
2214 case EM_CE: return "Freescale Communication Engine RISC core";
2215 case EM_TSK3000: return "Altium TSK3000 core";
2216 case EM_RS08: return "Freescale RS08 embedded processor";
2217 case EM_ECOG2: return "Cyan Technology eCOG2 microprocessor";
2218 case EM_DSP24: return "New Japan Radio (NJR) 24-bit DSP Processor";
2219 case EM_VIDEOCORE3: return "Broadcom VideoCore III processor";
2220 case EM_SE_C17: return "Seiko Epson C17 family";
2221 case EM_TI_C6000: return "Texas Instruments TMS320C6000 DSP family";
2222 case EM_TI_C2000: return "Texas Instruments TMS320C2000 DSP family";
2223 case EM_TI_C5500: return "Texas Instruments TMS320C55x DSP family";
2224 case EM_MMDSP_PLUS: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2225 case EM_CYPRESS_M8C: return "Cypress M8C microprocessor";
2226 case EM_R32C: return "Renesas R32C series microprocessors";
2227 case EM_TRIMEDIA: return "NXP Semiconductors TriMedia architecture family";
2228 case EM_QDSP6: return "QUALCOMM DSP6 Processor";
2229 case EM_8051: return "Intel 8051 and variants";
2230 case EM_STXP7X: return "STMicroelectronics STxP7x family";
2231 case EM_NDS32: return "Andes Technology compact code size embedded RISC processor family";
2232 case EM_ECOG1X: return "Cyan Technology eCOG1X family";
2233 case EM_MAXQ30: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2234 case EM_XIMO16: return "New Japan Radio (NJR) 16-bit DSP Processor";
2235 case EM_MANIK: return "M2000 Reconfigurable RISC Microprocessor";
2236 case EM_CRAYNV2: return "Cray Inc. NV2 vector architecture";
2237 case EM_CYGNUS_MEP: return "Toshiba MeP Media Engine";
2240 case EM_MICROBLAZE_OLD: return "Xilinx MicroBlaze";
2241 case EM_RL78: return "Renesas RL78";
2242 case EM_RX: return "Renesas RX";
2243 case EM_METAG: return "Imagination Technologies Meta processor architecture";
2244 case EM_MCST_ELBRUS: return "MCST Elbrus general purpose hardware architecture";
2245 case EM_ECOG16: return "Cyan Technology eCOG16 family";
2246 case EM_ETPU: return "Freescale Extended Time Processing Unit";
2247 case EM_SLE9X: return "Infineon Technologies SLE9X core";
2248 case EM_AVR32: return "Atmel Corporation 32-bit microprocessor family";
2249 case EM_STM8: return "STMicroeletronics STM8 8-bit microcontroller";
2250 case EM_TILE64: return "Tilera TILE64 multicore architecture family";
2251 case EM_TILEPRO: return "Tilera TILEPro multicore architecture family";
2252 case EM_TILEGX: return "Tilera TILE-Gx multicore architecture family";
2253 case EM_CUDA: return "NVIDIA CUDA architecture";
2254 case EM_XGATE: return "Motorola XGATE embedded processor";
2256 snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
2262 decode_ARM_machine_flags (unsigned e_flags, char buf[])
2267 eabi = EF_ARM_EABI_VERSION (e_flags);
2268 e_flags &= ~ EF_ARM_EABIMASK;
2270 /* Handle "generic" ARM flags. */
2271 if (e_flags & EF_ARM_RELEXEC)
2273 strcat (buf, ", relocatable executable");
2274 e_flags &= ~ EF_ARM_RELEXEC;
2277 if (e_flags & EF_ARM_HASENTRY)
2279 strcat (buf, ", has entry point");
2280 e_flags &= ~ EF_ARM_HASENTRY;
2283 /* Now handle EABI specific flags. */
2287 strcat (buf, ", <unrecognized EABI>");
2292 case EF_ARM_EABI_VER1:
2293 strcat (buf, ", Version1 EABI");
2298 /* Process flags one bit at a time. */
2299 flag = e_flags & - e_flags;
2304 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2305 strcat (buf, ", sorted symbol tables");
2315 case EF_ARM_EABI_VER2:
2316 strcat (buf, ", Version2 EABI");
2321 /* Process flags one bit at a time. */
2322 flag = e_flags & - e_flags;
2327 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2328 strcat (buf, ", sorted symbol tables");
2331 case EF_ARM_DYNSYMSUSESEGIDX:
2332 strcat (buf, ", dynamic symbols use segment index");
2335 case EF_ARM_MAPSYMSFIRST:
2336 strcat (buf, ", mapping symbols precede others");
2346 case EF_ARM_EABI_VER3:
2347 strcat (buf, ", Version3 EABI");
2350 case EF_ARM_EABI_VER4:
2351 strcat (buf, ", Version4 EABI");
2356 /* Process flags one bit at a time. */
2357 flag = e_flags & - e_flags;
2363 strcat (buf, ", BE8");
2367 strcat (buf, ", LE8");
2378 case EF_ARM_EABI_VER5:
2379 strcat (buf, ", Version5 EABI");
2384 /* Process flags one bit at a time. */
2385 flag = e_flags & - e_flags;
2391 strcat (buf, ", BE8");
2395 strcat (buf, ", LE8");
2398 case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2399 strcat (buf, ", soft-float ABI");
2402 case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT. */
2403 strcat (buf, ", hard-float ABI");
2413 case EF_ARM_EABI_UNKNOWN:
2414 strcat (buf, ", GNU EABI");
2419 /* Process flags one bit at a time. */
2420 flag = e_flags & - e_flags;
2425 case EF_ARM_INTERWORK:
2426 strcat (buf, ", interworking enabled");
2429 case EF_ARM_APCS_26:
2430 strcat (buf, ", uses APCS/26");
2433 case EF_ARM_APCS_FLOAT:
2434 strcat (buf, ", uses APCS/float");
2438 strcat (buf, ", position independent");
2442 strcat (buf, ", 8 bit structure alignment");
2445 case EF_ARM_NEW_ABI:
2446 strcat (buf, ", uses new ABI");
2449 case EF_ARM_OLD_ABI:
2450 strcat (buf, ", uses old ABI");
2453 case EF_ARM_SOFT_FLOAT:
2454 strcat (buf, ", software FP");
2457 case EF_ARM_VFP_FLOAT:
2458 strcat (buf, ", VFP");
2461 case EF_ARM_MAVERICK_FLOAT:
2462 strcat (buf, ", Maverick FP");
2473 strcat (buf,_(", <unknown>"));
2477 decode_AVR_machine_flags (unsigned e_flags, char buf[], size_t size)
2479 --size; /* Leave space for null terminator. */
2481 switch (e_flags & EF_AVR_MACH)
2483 case E_AVR_MACH_AVR1:
2484 strncat (buf, ", avr:1", size);
2486 case E_AVR_MACH_AVR2:
2487 strncat (buf, ", avr:2", size);
2489 case E_AVR_MACH_AVR25:
2490 strncat (buf, ", avr:25", size);
2492 case E_AVR_MACH_AVR3:
2493 strncat (buf, ", avr:3", size);
2495 case E_AVR_MACH_AVR31:
2496 strncat (buf, ", avr:31", size);
2498 case E_AVR_MACH_AVR35:
2499 strncat (buf, ", avr:35", size);
2501 case E_AVR_MACH_AVR4:
2502 strncat (buf, ", avr:4", size);
2504 case E_AVR_MACH_AVR5:
2505 strncat (buf, ", avr:5", size);
2507 case E_AVR_MACH_AVR51:
2508 strncat (buf, ", avr:51", size);
2510 case E_AVR_MACH_AVR6:
2511 strncat (buf, ", avr:6", size);
2513 case E_AVR_MACH_AVRTINY:
2514 strncat (buf, ", avr:100", size);
2516 case E_AVR_MACH_XMEGA1:
2517 strncat (buf, ", avr:101", size);
2519 case E_AVR_MACH_XMEGA2:
2520 strncat (buf, ", avr:102", size);
2522 case E_AVR_MACH_XMEGA3:
2523 strncat (buf, ", avr:103", size);
2525 case E_AVR_MACH_XMEGA4:
2526 strncat (buf, ", avr:104", size);
2528 case E_AVR_MACH_XMEGA5:
2529 strncat (buf, ", avr:105", size);
2531 case E_AVR_MACH_XMEGA6:
2532 strncat (buf, ", avr:106", size);
2534 case E_AVR_MACH_XMEGA7:
2535 strncat (buf, ", avr:107", size);
2538 strncat (buf, ", avr:<unknown>", size);
2542 size -= strlen (buf);
2543 if (e_flags & EF_AVR_LINKRELAX_PREPARED)
2544 strncat (buf, ", link-relax", size);
2548 decode_NDS32_machine_flags (unsigned e_flags, char buf[], size_t size)
2557 static const char *ABI_STRINGS[] =
2559 "ABI v0", /* use r5 as return register; only used in N1213HC */
2560 "ABI v1", /* use r0 as return register */
2561 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2562 "ABI v2fp", /* for FPU */
2566 static const char *VER_STRINGS[] =
2568 "Andes ELF V1.3 or older",
2572 static const char *ARCH_STRINGS[] =
2581 abi = EF_NDS_ABI & e_flags;
2582 arch = EF_NDS_ARCH & e_flags;
2583 config = EF_NDS_INST & e_flags;
2584 version = EF_NDS32_ELF_VERSION & e_flags;
2586 memset (buf, 0, size);
2593 case E_NDS_ABI_V2FP:
2594 case E_NDS_ABI_AABI:
2595 case E_NDS_ABI_V2FP_PLUS:
2596 /* In case there are holes in the array. */
2597 r += snprintf (buf + r, size - r, ", %s", ABI_STRINGS[abi >> EF_NDS_ABI_SHIFT]);
2601 r += snprintf (buf + r, size - r, ", <unrecognized ABI>");
2607 case E_NDS32_ELF_VER_1_2:
2608 case E_NDS32_ELF_VER_1_3:
2609 case E_NDS32_ELF_VER_1_4:
2610 r += snprintf (buf + r, size - r, ", %s", VER_STRINGS[version >> EF_NDS32_ELF_VERSION_SHIFT]);
2614 r += snprintf (buf + r, size - r, ", <unrecognized ELF version number>");
2618 if (E_NDS_ABI_V0 == abi)
2620 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2621 r += snprintf (buf + r, size - r, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2622 if (arch == E_NDS_ARCH_STAR_V1_0)
2623 r += snprintf (buf + r, size -r, ", 16b"); /* has 16-bit instructions */
2629 case E_NDS_ARCH_STAR_V1_0:
2630 case E_NDS_ARCH_STAR_V2_0:
2631 case E_NDS_ARCH_STAR_V3_0:
2632 case E_NDS_ARCH_STAR_V3_M:
2633 r += snprintf (buf + r, size - r, ", %s", ARCH_STRINGS[arch >> EF_NDS_ARCH_SHIFT]);
2637 r += snprintf (buf + r, size - r, ", <unrecognized architecture>");
2638 /* ARCH version determines how the e_flags are interpreted.
2639 If it is unknown, we cannot proceed. */
2643 /* Newer ABI; Now handle architecture specific flags. */
2644 if (arch == E_NDS_ARCH_STAR_V1_0)
2646 if (config & E_NDS32_HAS_MFUSR_PC_INST)
2647 r += snprintf (buf + r, size -r, ", MFUSR_PC");
2649 if (!(config & E_NDS32_HAS_NO_MAC_INST))
2650 r += snprintf (buf + r, size -r, ", MAC");
2652 if (config & E_NDS32_HAS_DIV_INST)
2653 r += snprintf (buf + r, size -r, ", DIV");
2655 if (config & E_NDS32_HAS_16BIT_INST)
2656 r += snprintf (buf + r, size -r, ", 16b");
2660 if (config & E_NDS32_HAS_MFUSR_PC_INST)
2662 if (version <= E_NDS32_ELF_VER_1_3)
2663 r += snprintf (buf + r, size -r, ", [B8]");
2665 r += snprintf (buf + r, size -r, ", EX9");
2668 if (config & E_NDS32_HAS_MAC_DX_INST)
2669 r += snprintf (buf + r, size -r, ", MAC_DX");
2671 if (config & E_NDS32_HAS_DIV_DX_INST)
2672 r += snprintf (buf + r, size -r, ", DIV_DX");
2674 if (config & E_NDS32_HAS_16BIT_INST)
2676 if (version <= E_NDS32_ELF_VER_1_3)
2677 r += snprintf (buf + r, size -r, ", 16b");
2679 r += snprintf (buf + r, size -r, ", IFC");
2683 if (config & E_NDS32_HAS_EXT_INST)
2684 r += snprintf (buf + r, size -r, ", PERF1");
2686 if (config & E_NDS32_HAS_EXT2_INST)
2687 r += snprintf (buf + r, size -r, ", PERF2");
2689 if (config & E_NDS32_HAS_FPU_INST)
2692 r += snprintf (buf + r, size -r, ", FPU_SP");
2695 if (config & E_NDS32_HAS_FPU_DP_INST)
2698 r += snprintf (buf + r, size -r, ", FPU_DP");
2701 if (config & E_NDS32_HAS_FPU_MAC_INST)
2704 r += snprintf (buf + r, size -r, ", FPU_MAC");
2709 switch ((config & E_NDS32_FPU_REG_CONF) >> E_NDS32_FPU_REG_CONF_SHIFT)
2711 case E_NDS32_FPU_REG_8SP_4DP:
2712 r += snprintf (buf + r, size -r, ", FPU_REG:8/4");
2714 case E_NDS32_FPU_REG_16SP_8DP:
2715 r += snprintf (buf + r, size -r, ", FPU_REG:16/8");
2717 case E_NDS32_FPU_REG_32SP_16DP:
2718 r += snprintf (buf + r, size -r, ", FPU_REG:32/16");
2720 case E_NDS32_FPU_REG_32SP_32DP:
2721 r += snprintf (buf + r, size -r, ", FPU_REG:32/32");
2726 if (config & E_NDS32_HAS_AUDIO_INST)
2727 r += snprintf (buf + r, size -r, ", AUDIO");
2729 if (config & E_NDS32_HAS_STRING_INST)
2730 r += snprintf (buf + r, size -r, ", STR");
2732 if (config & E_NDS32_HAS_REDUCED_REGS)
2733 r += snprintf (buf + r, size -r, ", 16REG");
2735 if (config & E_NDS32_HAS_VIDEO_INST)
2737 if (version <= E_NDS32_ELF_VER_1_3)
2738 r += snprintf (buf + r, size -r, ", VIDEO");
2740 r += snprintf (buf + r, size -r, ", SATURATION");
2743 if (config & E_NDS32_HAS_ENCRIPT_INST)
2744 r += snprintf (buf + r, size -r, ", ENCRP");
2746 if (config & E_NDS32_HAS_L2C_INST)
2747 r += snprintf (buf + r, size -r, ", L2C");
2751 get_machine_flags (unsigned e_flags, unsigned e_machine)
2753 static char buf[1024];
2765 decode_ARM_machine_flags (e_flags, buf);
2769 decode_AVR_machine_flags (e_flags, buf, sizeof buf);
2773 if (e_flags & EF_BFIN_PIC)
2774 strcat (buf, ", PIC");
2776 if (e_flags & EF_BFIN_FDPIC)
2777 strcat (buf, ", FDPIC");
2779 if (e_flags & EF_BFIN_CODE_IN_L1)
2780 strcat (buf, ", code in L1");
2782 if (e_flags & EF_BFIN_DATA_IN_L1)
2783 strcat (buf, ", data in L1");
2788 switch (e_flags & EF_FRV_CPU_MASK)
2790 case EF_FRV_CPU_GENERIC:
2794 strcat (buf, ", fr???");
2797 case EF_FRV_CPU_FR300:
2798 strcat (buf, ", fr300");
2801 case EF_FRV_CPU_FR400:
2802 strcat (buf, ", fr400");
2804 case EF_FRV_CPU_FR405:
2805 strcat (buf, ", fr405");
2808 case EF_FRV_CPU_FR450:
2809 strcat (buf, ", fr450");
2812 case EF_FRV_CPU_FR500:
2813 strcat (buf, ", fr500");
2815 case EF_FRV_CPU_FR550:
2816 strcat (buf, ", fr550");
2819 case EF_FRV_CPU_SIMPLE:
2820 strcat (buf, ", simple");
2822 case EF_FRV_CPU_TOMCAT:
2823 strcat (buf, ", tomcat");
2829 if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
2830 strcat (buf, ", m68000");
2831 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
2832 strcat (buf, ", cpu32");
2833 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
2834 strcat (buf, ", fido_a");
2837 char const * isa = _("unknown");
2838 char const * mac = _("unknown mac");
2839 char const * additional = NULL;
2841 switch (e_flags & EF_M68K_CF_ISA_MASK)
2843 case EF_M68K_CF_ISA_A_NODIV:
2845 additional = ", nodiv";
2847 case EF_M68K_CF_ISA_A:
2850 case EF_M68K_CF_ISA_A_PLUS:
2853 case EF_M68K_CF_ISA_B_NOUSP:
2855 additional = ", nousp";
2857 case EF_M68K_CF_ISA_B:
2860 case EF_M68K_CF_ISA_C:
2863 case EF_M68K_CF_ISA_C_NODIV:
2865 additional = ", nodiv";
2868 strcat (buf, ", cf, isa ");
2871 strcat (buf, additional);
2872 if (e_flags & EF_M68K_CF_FLOAT)
2873 strcat (buf, ", float");
2874 switch (e_flags & EF_M68K_CF_MAC_MASK)
2879 case EF_M68K_CF_MAC:
2882 case EF_M68K_CF_EMAC:
2885 case EF_M68K_CF_EMAC_B:
2898 if (e_flags & EF_PPC_EMB)
2899 strcat (buf, ", emb");
2901 if (e_flags & EF_PPC_RELOCATABLE)
2902 strcat (buf, _(", relocatable"));
2904 if (e_flags & EF_PPC_RELOCATABLE_LIB)
2905 strcat (buf, _(", relocatable-lib"));
2909 if (e_flags & EF_PPC64_ABI)
2911 char abi[] = ", abiv0";
2913 abi[6] += e_flags & EF_PPC64_ABI;
2919 if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
2920 strcat (buf, ", RH850 ABI");
2922 if (e_flags & EF_V800_850E3)
2923 strcat (buf, ", V3 architecture");
2925 if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
2926 strcat (buf, ", FPU not used");
2928 if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
2929 strcat (buf, ", regmode: COMMON");
2931 if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
2932 strcat (buf, ", r4 not used");
2934 if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
2935 strcat (buf, ", r30 not used");
2937 if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
2938 strcat (buf, ", r5 not used");
2940 if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
2941 strcat (buf, ", r2 not used");
2943 for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
2945 switch (e_flags & - e_flags)
2947 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
2948 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
2949 case EF_RH850_SIMD: strcat (buf, ", SIMD"); break;
2950 case EF_RH850_CACHE: strcat (buf, ", CACHE"); break;
2951 case EF_RH850_MMU: strcat (buf, ", MMU"); break;
2952 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
2953 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
2954 case EF_RH850_DATA_ALIGN8: strcat (buf, ", 8-byte alignment"); break;
2955 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
2956 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
2957 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
2958 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
2959 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
2960 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
2961 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
2962 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
2969 case EM_CYGNUS_V850:
2970 switch (e_flags & EF_V850_ARCH)
2972 case E_V850E3V5_ARCH:
2973 strcat (buf, ", v850e3v5");
2975 case E_V850E2V3_ARCH:
2976 strcat (buf, ", v850e2v3");
2979 strcat (buf, ", v850e2");
2982 strcat (buf, ", v850e1");
2985 strcat (buf, ", v850e");
2988 strcat (buf, ", v850");
2991 strcat (buf, _(", unknown v850 architecture variant"));
2997 case EM_CYGNUS_M32R:
2998 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
2999 strcat (buf, ", m32r");
3003 case EM_MIPS_RS3_LE:
3004 if (e_flags & EF_MIPS_NOREORDER)
3005 strcat (buf, ", noreorder");
3007 if (e_flags & EF_MIPS_PIC)
3008 strcat (buf, ", pic");
3010 if (e_flags & EF_MIPS_CPIC)
3011 strcat (buf, ", cpic");
3013 if (e_flags & EF_MIPS_UCODE)
3014 strcat (buf, ", ugen_reserved");
3016 if (e_flags & EF_MIPS_ABI2)
3017 strcat (buf, ", abi2");
3019 if (e_flags & EF_MIPS_OPTIONS_FIRST)
3020 strcat (buf, ", odk first");
3022 if (e_flags & EF_MIPS_32BITMODE)
3023 strcat (buf, ", 32bitmode");
3025 if (e_flags & EF_MIPS_NAN2008)
3026 strcat (buf, ", nan2008");
3028 if (e_flags & EF_MIPS_FP64)
3029 strcat (buf, ", fp64");
3031 switch ((e_flags & EF_MIPS_MACH))
3033 case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
3034 case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
3035 case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
3036 case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
3037 case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
3038 case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
3039 case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
3040 case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
3041 case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); break;
3042 case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
3043 case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
3044 case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
3045 case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
3046 case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
3047 case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
3048 case E_MIPS_MACH_OCTEON3: strcat (buf, ", octeon3"); break;
3049 case E_MIPS_MACH_XLR: strcat (buf, ", xlr"); break;
3051 /* We simply ignore the field in this case to avoid confusion:
3052 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
3055 default: strcat (buf, _(", unknown CPU")); break;
3058 switch ((e_flags & EF_MIPS_ABI))
3060 case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
3061 case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
3062 case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
3063 case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
3065 /* We simply ignore the field in this case to avoid confusion:
3066 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
3067 This means it is likely to be an o32 file, but not for
3070 default: strcat (buf, _(", unknown ABI")); break;
3073 if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
3074 strcat (buf, ", mdmx");
3076 if (e_flags & EF_MIPS_ARCH_ASE_M16)
3077 strcat (buf, ", mips16");
3079 if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
3080 strcat (buf, ", micromips");
3082 switch ((e_flags & EF_MIPS_ARCH))
3084 case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
3085 case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
3086 case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
3087 case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
3088 case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
3089 case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
3090 case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
3091 case E_MIPS_ARCH_32R6: strcat (buf, ", mips32r6"); break;
3092 case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
3093 case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
3094 case E_MIPS_ARCH_64R6: strcat (buf, ", mips64r6"); break;
3095 default: strcat (buf, _(", unknown ISA")); break;
3100 decode_NDS32_machine_flags (e_flags, buf, sizeof buf);
3104 switch ((e_flags & EF_SH_MACH_MASK))
3106 case EF_SH1: strcat (buf, ", sh1"); break;
3107 case EF_SH2: strcat (buf, ", sh2"); break;
3108 case EF_SH3: strcat (buf, ", sh3"); break;
3109 case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
3110 case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
3111 case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
3112 case EF_SH3E: strcat (buf, ", sh3e"); break;
3113 case EF_SH4: strcat (buf, ", sh4"); break;
3114 case EF_SH5: strcat (buf, ", sh5"); break;
3115 case EF_SH2E: strcat (buf, ", sh2e"); break;
3116 case EF_SH4A: strcat (buf, ", sh4a"); break;
3117 case EF_SH2A: strcat (buf, ", sh2a"); break;
3118 case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
3119 case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
3120 case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
3121 case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
3122 case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
3123 case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
3124 case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
3125 case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
3126 case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
3127 default: strcat (buf, _(", unknown ISA")); break;
3130 if (e_flags & EF_SH_PIC)
3131 strcat (buf, ", pic");
3133 if (e_flags & EF_SH_FDPIC)
3134 strcat (buf, ", fdpic");
3138 if (e_flags & EF_OR1K_NODELAY)
3139 strcat (buf, ", no delay");
3143 if (e_flags & EF_SPARC_32PLUS)
3144 strcat (buf, ", v8+");
3146 if (e_flags & EF_SPARC_SUN_US1)
3147 strcat (buf, ", ultrasparcI");
3149 if (e_flags & EF_SPARC_SUN_US3)
3150 strcat (buf, ", ultrasparcIII");
3152 if (e_flags & EF_SPARC_HAL_R1)
3153 strcat (buf, ", halr1");
3155 if (e_flags & EF_SPARC_LEDATA)
3156 strcat (buf, ", ledata");
3158 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
3159 strcat (buf, ", tso");
3161 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
3162 strcat (buf, ", pso");
3164 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
3165 strcat (buf, ", rmo");
3169 switch (e_flags & EF_PARISC_ARCH)
3171 case EFA_PARISC_1_0:
3172 strcpy (buf, ", PA-RISC 1.0");
3174 case EFA_PARISC_1_1:
3175 strcpy (buf, ", PA-RISC 1.1");
3177 case EFA_PARISC_2_0:
3178 strcpy (buf, ", PA-RISC 2.0");
3183 if (e_flags & EF_PARISC_TRAPNIL)
3184 strcat (buf, ", trapnil");
3185 if (e_flags & EF_PARISC_EXT)
3186 strcat (buf, ", ext");
3187 if (e_flags & EF_PARISC_LSB)
3188 strcat (buf, ", lsb");
3189 if (e_flags & EF_PARISC_WIDE)
3190 strcat (buf, ", wide");
3191 if (e_flags & EF_PARISC_NO_KABP)
3192 strcat (buf, ", no kabp");
3193 if (e_flags & EF_PARISC_LAZYSWAP)
3194 strcat (buf, ", lazyswap");
3199 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
3200 strcat (buf, ", new calling convention");
3202 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
3203 strcat (buf, ", gnu calling convention");
3207 if ((e_flags & EF_IA_64_ABI64))
3208 strcat (buf, ", 64-bit");
3210 strcat (buf, ", 32-bit");
3211 if ((e_flags & EF_IA_64_REDUCEDFP))
3212 strcat (buf, ", reduced fp model");
3213 if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
3214 strcat (buf, ", no function descriptors, constant gp");
3215 else if ((e_flags & EF_IA_64_CONS_GP))
3216 strcat (buf, ", constant gp");
3217 if ((e_flags & EF_IA_64_ABSOLUTE))
3218 strcat (buf, ", absolute");
3219 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
3221 if ((e_flags & EF_IA_64_VMS_LINKAGES))
3222 strcat (buf, ", vms_linkages");
3223 switch ((e_flags & EF_IA_64_VMS_COMCOD))
3225 case EF_IA_64_VMS_COMCOD_SUCCESS:
3227 case EF_IA_64_VMS_COMCOD_WARNING:
3228 strcat (buf, ", warning");
3230 case EF_IA_64_VMS_COMCOD_ERROR:
3231 strcat (buf, ", error");
3233 case EF_IA_64_VMS_COMCOD_ABORT:
3234 strcat (buf, ", abort");
3237 warn (_("Unrecognised IA64 VMS Command Code: %x\n"),
3238 e_flags & EF_IA_64_VMS_COMCOD);
3239 strcat (buf, ", <unknown>");
3245 if ((e_flags & EF_VAX_NONPIC))
3246 strcat (buf, ", non-PIC");
3247 if ((e_flags & EF_VAX_DFLOAT))
3248 strcat (buf, ", D-Float");
3249 if ((e_flags & EF_VAX_GFLOAT))
3250 strcat (buf, ", G-Float");
3254 if (e_flags & EF_VISIUM_ARCH_MCM)
3255 strcat (buf, ", mcm");
3256 else if (e_flags & EF_VISIUM_ARCH_MCM24)
3257 strcat (buf, ", mcm24");
3258 if (e_flags & EF_VISIUM_ARCH_GR6)
3259 strcat (buf, ", gr6");
3263 if (e_flags & E_FLAG_RL78_G10)
3264 strcat (buf, ", G10");
3265 if (e_flags & E_FLAG_RL78_64BIT_DOUBLES)
3266 strcat (buf, ", 64-bit doubles");
3270 if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
3271 strcat (buf, ", 64-bit doubles");
3272 if (e_flags & E_FLAG_RX_DSP)
3273 strcat (buf, ", dsp");
3274 if (e_flags & E_FLAG_RX_PID)
3275 strcat (buf, ", pid");
3276 if (e_flags & E_FLAG_RX_ABI)
3277 strcat (buf, ", RX ABI");
3281 if (e_flags & EF_S390_HIGH_GPRS)
3282 strcat (buf, ", highgprs");
3286 if ((e_flags & EF_C6000_REL))
3287 strcat (buf, ", relocatable module");
3291 strcat (buf, _(": architecture variant: "));
3292 switch (e_flags & EF_MSP430_MACH)
3294 case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
3295 case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
3296 case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
3297 case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
3298 case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
3299 case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
3300 case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
3301 case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
3302 case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
3303 case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
3304 case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
3305 case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
3306 case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
3307 case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
3308 case E_MSP430_MACH_MSP430X : strcat (buf, "MSP430X"); break;
3310 strcat (buf, _(": unknown")); break;
3313 if (e_flags & ~ EF_MSP430_MACH)
3314 strcat (buf, _(": unknown extra flag bits also present"));
3322 get_osabi_name (unsigned int osabi)
3324 static char buff[32];
3328 case ELFOSABI_NONE: return "UNIX - System V";
3329 case ELFOSABI_HPUX: return "UNIX - HP-UX";
3330 case ELFOSABI_NETBSD: return "UNIX - NetBSD";
3331 case ELFOSABI_GNU: return "UNIX - GNU";
3332 case ELFOSABI_SOLARIS: return "UNIX - Solaris";
3333 case ELFOSABI_AIX: return "UNIX - AIX";
3334 case ELFOSABI_IRIX: return "UNIX - IRIX";
3335 case ELFOSABI_FREEBSD: return "UNIX - FreeBSD";
3336 case ELFOSABI_TRU64: return "UNIX - TRU64";
3337 case ELFOSABI_MODESTO: return "Novell - Modesto";
3338 case ELFOSABI_OPENBSD: return "UNIX - OpenBSD";
3339 case ELFOSABI_OPENVMS: return "VMS - OpenVMS";
3340 case ELFOSABI_NSK: return "HP - Non-Stop Kernel";
3341 case ELFOSABI_AROS: return "AROS";
3342 case ELFOSABI_FENIXOS: return "FenixOS";
3345 switch (elf_header.e_machine)
3350 case ELFOSABI_ARM: return "ARM";
3361 case ELFOSABI_STANDALONE: return _("Standalone App");
3370 case ELFOSABI_C6000_ELFABI: return _("Bare-metal C6000");
3371 case ELFOSABI_C6000_LINUX: return "Linux C6000";
3380 snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
3386 get_aarch64_segment_type (unsigned long type)
3390 case PT_AARCH64_ARCHEXT:
3391 return "AARCH64_ARCHEXT";
3400 get_arm_segment_type (unsigned long type)
3414 get_mips_segment_type (unsigned long type)
3418 case PT_MIPS_REGINFO:
3420 case PT_MIPS_RTPROC:
3422 case PT_MIPS_OPTIONS:
3424 case PT_MIPS_ABIFLAGS:
3434 get_parisc_segment_type (unsigned long type)
3438 case PT_HP_TLS: return "HP_TLS";
3439 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
3440 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
3441 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
3442 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
3443 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
3444 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
3445 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
3446 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
3447 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
3448 case PT_HP_PARALLEL: return "HP_PARALLEL";
3449 case PT_HP_FASTBIND: return "HP_FASTBIND";
3450 case PT_HP_OPT_ANNOT: return "HP_OPT_ANNOT";
3451 case PT_HP_HSL_ANNOT: return "HP_HSL_ANNOT";
3452 case PT_HP_STACK: return "HP_STACK";
3453 case PT_HP_CORE_UTSNAME: return "HP_CORE_UTSNAME";
3454 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
3455 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
3456 case PT_PARISC_WEAKORDER: return "PARISC_WEAKORDER";
3465 get_ia64_segment_type (unsigned long type)
3469 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
3470 case PT_IA_64_UNWIND: return "IA_64_UNWIND";
3471 case PT_HP_TLS: return "HP_TLS";
3472 case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
3473 case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
3474 case PT_IA_64_HP_STACK: return "HP_STACK";
3483 get_tic6x_segment_type (unsigned long type)
3487 case PT_C6000_PHATTR: return "C6000_PHATTR";
3496 get_segment_type (unsigned long p_type)
3498 static char buff[32];
3502 case PT_NULL: return "NULL";
3503 case PT_LOAD: return "LOAD";
3504 case PT_DYNAMIC: return "DYNAMIC";
3505 case PT_INTERP: return "INTERP";
3506 case PT_NOTE: return "NOTE";
3507 case PT_SHLIB: return "SHLIB";
3508 case PT_PHDR: return "PHDR";
3509 case PT_TLS: return "TLS";
3511 case PT_GNU_EH_FRAME:
3512 return "GNU_EH_FRAME";
3513 case PT_GNU_STACK: return "GNU_STACK";
3514 case PT_GNU_RELRO: return "GNU_RELRO";
3517 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
3519 const char * result;
3521 switch (elf_header.e_machine)
3524 result = get_aarch64_segment_type (p_type);
3527 result = get_arm_segment_type (p_type);
3530 case EM_MIPS_RS3_LE:
3531 result = get_mips_segment_type (p_type);
3534 result = get_parisc_segment_type (p_type);
3537 result = get_ia64_segment_type (p_type);
3540 result = get_tic6x_segment_type (p_type);
3550 sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
3552 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
3554 const char * result;
3556 switch (elf_header.e_machine)
3559 result = get_parisc_segment_type (p_type);
3562 result = get_ia64_segment_type (p_type);
3572 sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
3575 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
3582 get_mips_section_type_name (unsigned int sh_type)
3586 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
3587 case SHT_MIPS_MSYM: return "MIPS_MSYM";
3588 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
3589 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
3590 case SHT_MIPS_UCODE: return "MIPS_UCODE";
3591 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
3592 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
3593 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
3594 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
3595 case SHT_MIPS_RELD: return "MIPS_RELD";
3596 case SHT_MIPS_IFACE: return "MIPS_IFACE";
3597 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
3598 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
3599 case SHT_MIPS_SHDR: return "MIPS_SHDR";
3600 case SHT_MIPS_FDESC: return "MIPS_FDESC";
3601 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
3602 case SHT_MIPS_DENSE: return "MIPS_DENSE";
3603 case SHT_MIPS_PDESC: return "MIPS_PDESC";
3604 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
3605 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
3606 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
3607 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
3608 case SHT_MIPS_LINE: return "MIPS_LINE";
3609 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
3610 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
3611 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
3612 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
3613 case SHT_MIPS_DWARF: return "MIPS_DWARF";
3614 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
3615 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
3616 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
3617 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
3618 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
3619 case SHT_MIPS_XLATE: return "MIPS_XLATE";
3620 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
3621 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
3622 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
3623 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
3624 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
3625 case SHT_MIPS_ABIFLAGS: return "MIPS_ABIFLAGS";
3633 get_parisc_section_type_name (unsigned int sh_type)
3637 case SHT_PARISC_EXT: return "PARISC_EXT";
3638 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
3639 case SHT_PARISC_DOC: return "PARISC_DOC";
3640 case SHT_PARISC_ANNOT: return "PARISC_ANNOT";
3641 case SHT_PARISC_SYMEXTN: return "PARISC_SYMEXTN";
3642 case SHT_PARISC_STUBS: return "PARISC_STUBS";
3643 case SHT_PARISC_DLKM: return "PARISC_DLKM";
3651 get_ia64_section_type_name (unsigned int sh_type)
3653 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
3654 if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
3655 return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
3659 case SHT_IA_64_EXT: return "IA_64_EXT";
3660 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
3661 case SHT_IA_64_PRIORITY_INIT: return "IA_64_PRIORITY_INIT";
3662 case SHT_IA_64_VMS_TRACE: return "VMS_TRACE";
3663 case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
3664 case SHT_IA_64_VMS_DEBUG: return "VMS_DEBUG";
3665 case SHT_IA_64_VMS_DEBUG_STR: return "VMS_DEBUG_STR";
3666 case SHT_IA_64_VMS_LINKAGES: return "VMS_LINKAGES";
3667 case SHT_IA_64_VMS_SYMBOL_VECTOR: return "VMS_SYMBOL_VECTOR";
3668 case SHT_IA_64_VMS_FIXUP: return "VMS_FIXUP";
3676 get_x86_64_section_type_name (unsigned int sh_type)
3680 case SHT_X86_64_UNWIND: return "X86_64_UNWIND";
3688 get_aarch64_section_type_name (unsigned int sh_type)
3692 case SHT_AARCH64_ATTRIBUTES:
3693 return "AARCH64_ATTRIBUTES";
3701 get_arm_section_type_name (unsigned int sh_type)
3705 case SHT_ARM_EXIDX: return "ARM_EXIDX";
3706 case SHT_ARM_PREEMPTMAP: return "ARM_PREEMPTMAP";
3707 case SHT_ARM_ATTRIBUTES: return "ARM_ATTRIBUTES";
3708 case SHT_ARM_DEBUGOVERLAY: return "ARM_DEBUGOVERLAY";
3709 case SHT_ARM_OVERLAYSECTION: return "ARM_OVERLAYSECTION";
3717 get_tic6x_section_type_name (unsigned int sh_type)
3721 case SHT_C6000_UNWIND:
3722 return "C6000_UNWIND";
3723 case SHT_C6000_PREEMPTMAP:
3724 return "C6000_PREEMPTMAP";
3725 case SHT_C6000_ATTRIBUTES:
3726 return "C6000_ATTRIBUTES";
3731 case SHT_TI_HANDLER:
3732 return "TI_HANDLER";
3733 case SHT_TI_INITINFO:
3734 return "TI_INITINFO";
3735 case SHT_TI_PHATTRS:
3736 return "TI_PHATTRS";
3744 get_msp430x_section_type_name (unsigned int sh_type)
3748 case SHT_MSP430_SEC_FLAGS: return "MSP430_SEC_FLAGS";
3749 case SHT_MSP430_SYM_ALIASES: return "MSP430_SYM_ALIASES";
3750 case SHT_MSP430_ATTRIBUTES: return "MSP430_ATTRIBUTES";
3751 default: return NULL;
3756 get_section_type_name (unsigned int sh_type)
3758 static char buff[32];
3762 case SHT_NULL: return "NULL";
3763 case SHT_PROGBITS: return "PROGBITS";
3764 case SHT_SYMTAB: return "SYMTAB";
3765 case SHT_STRTAB: return "STRTAB";
3766 case SHT_RELA: return "RELA";
3767 case SHT_HASH: return "HASH";
3768 case SHT_DYNAMIC: return "DYNAMIC";
3769 case SHT_NOTE: return "NOTE";
3770 case SHT_NOBITS: return "NOBITS";
3771 case SHT_REL: return "REL";
3772 case SHT_SHLIB: return "SHLIB";
3773 case SHT_DYNSYM: return "DYNSYM";
3774 case SHT_INIT_ARRAY: return "INIT_ARRAY";
3775 case SHT_FINI_ARRAY: return "FINI_ARRAY";
3776 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
3777 case SHT_GNU_HASH: return "GNU_HASH";
3778 case SHT_GROUP: return "GROUP";
3779 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICIES";
3780 case SHT_GNU_verdef: return "VERDEF";
3781 case SHT_GNU_verneed: return "VERNEED";
3782 case SHT_GNU_versym: return "VERSYM";
3783 case 0x6ffffff0: return "VERSYM";
3784 case 0x6ffffffc: return "VERDEF";
3785 case 0x7ffffffd: return "AUXILIARY";
3786 case 0x7fffffff: return "FILTER";
3787 case SHT_GNU_LIBLIST: return "GNU_LIBLIST";
3790 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
3792 const char * result;
3794 switch (elf_header.e_machine)
3797 case EM_MIPS_RS3_LE:
3798 result = get_mips_section_type_name (sh_type);
3801 result = get_parisc_section_type_name (sh_type);
3804 result = get_ia64_section_type_name (sh_type);
3809 result = get_x86_64_section_type_name (sh_type);
3812 result = get_aarch64_section_type_name (sh_type);
3815 result = get_arm_section_type_name (sh_type);
3818 result = get_tic6x_section_type_name (sh_type);
3821 result = get_msp430x_section_type_name (sh_type);
3831 sprintf (buff, "LOPROC+%x", sh_type - SHT_LOPROC);
3833 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
3835 const char * result;
3837 switch (elf_header.e_machine)
3840 result = get_ia64_section_type_name (sh_type);
3850 sprintf (buff, "LOOS+%x", sh_type - SHT_LOOS);
3852 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
3853 sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER);
3855 /* This message is probably going to be displayed in a 15
3856 character wide field, so put the hex value first. */
3857 snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
3863 #define OPTION_DEBUG_DUMP 512
3864 #define OPTION_DYN_SYMS 513
3865 #define OPTION_DWARF_DEPTH 514
3866 #define OPTION_DWARF_START 515
3867 #define OPTION_DWARF_CHECK 516
3869 static struct option options[] =
3871 {"all", no_argument, 0, 'a'},
3872 {"file-header", no_argument, 0, 'h'},
3873 {"program-headers", no_argument, 0, 'l'},
3874 {"headers", no_argument, 0, 'e'},
3875 {"histogram", no_argument, 0, 'I'},
3876 {"segments", no_argument, 0, 'l'},
3877 {"sections", no_argument, 0, 'S'},
3878 {"section-headers", no_argument, 0, 'S'},
3879 {"section-groups", no_argument, 0, 'g'},
3880 {"section-details", no_argument, 0, 't'},
3881 {"full-section-name",no_argument, 0, 'N'},
3882 {"symbols", no_argument, 0, 's'},
3883 {"syms", no_argument, 0, 's'},
3884 {"dyn-syms", no_argument, 0, OPTION_DYN_SYMS},
3885 {"relocs", no_argument, 0, 'r'},
3886 {"notes", no_argument, 0, 'n'},
3887 {"dynamic", no_argument, 0, 'd'},
3888 {"arch-specific", no_argument, 0, 'A'},
3889 {"version-info", no_argument, 0, 'V'},
3890 {"use-dynamic", no_argument, 0, 'D'},
3891 {"unwind", no_argument, 0, 'u'},
3892 {"archive-index", no_argument, 0, 'c'},
3893 {"hex-dump", required_argument, 0, 'x'},
3894 {"relocated-dump", required_argument, 0, 'R'},
3895 {"string-dump", required_argument, 0, 'p'},
3896 #ifdef SUPPORT_DISASSEMBLY
3897 {"instruction-dump", required_argument, 0, 'i'},
3899 {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
3901 {"dwarf-depth", required_argument, 0, OPTION_DWARF_DEPTH},
3902 {"dwarf-start", required_argument, 0, OPTION_DWARF_START},
3903 {"dwarf-check", no_argument, 0, OPTION_DWARF_CHECK},
3905 {"version", no_argument, 0, 'v'},
3906 {"wide", no_argument, 0, 'W'},
3907 {"help", no_argument, 0, 'H'},
3908 {0, no_argument, 0, 0}
3912 usage (FILE * stream)
3914 fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
3915 fprintf (stream, _(" Display information about the contents of ELF format files\n"));
3916 fprintf (stream, _(" Options are:\n\
3917 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3918 -h --file-header Display the ELF file header\n\
3919 -l --program-headers Display the program headers\n\
3920 --segments An alias for --program-headers\n\
3921 -S --section-headers Display the sections' header\n\
3922 --sections An alias for --section-headers\n\
3923 -g --section-groups Display the section groups\n\
3924 -t --section-details Display the section details\n\
3925 -e --headers Equivalent to: -h -l -S\n\
3926 -s --syms Display the symbol table\n\
3927 --symbols An alias for --syms\n\
3928 --dyn-syms Display the dynamic symbol table\n\
3929 -n --notes Display the core notes (if present)\n\
3930 -r --relocs Display the relocations (if present)\n\
3931 -u --unwind Display the unwind info (if present)\n\
3932 -d --dynamic Display the dynamic section (if present)\n\
3933 -V --version-info Display the version sections (if present)\n\
3934 -A --arch-specific Display architecture specific information (if any)\n\
3935 -c --archive-index Display the symbol/file index in an archive\n\
3936 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
3937 -x --hex-dump=<number|name>\n\
3938 Dump the contents of section <number|name> as bytes\n\
3939 -p --string-dump=<number|name>\n\
3940 Dump the contents of section <number|name> as strings\n\
3941 -R --relocated-dump=<number|name>\n\
3942 Dump the contents of section <number|name> as relocated bytes\n\
3943 -w[lLiaprmfFsoRt] or\n\
3944 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
3945 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
3946 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
3948 Display the contents of DWARF2 debug sections\n"));
3949 fprintf (stream, _("\
3950 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
3951 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
3953 #ifdef SUPPORT_DISASSEMBLY
3954 fprintf (stream, _("\
3955 -i --instruction-dump=<number|name>\n\
3956 Disassemble the contents of section <number|name>\n"));
3958 fprintf (stream, _("\
3959 -I --histogram Display histogram of bucket list lengths\n\
3960 -W --wide Allow output width to exceed 80 characters\n\
3961 @<file> Read options from <file>\n\
3962 -H --help Display this information\n\
3963 -v --version Display the version number of readelf\n"));
3965 if (REPORT_BUGS_TO[0] && stream == stdout)
3966 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
3968 exit (stream == stdout ? 0 : 1);
3971 /* Record the fact that the user wants the contents of section number
3972 SECTION to be displayed using the method(s) encoded as flags bits
3973 in TYPE. Note, TYPE can be zero if we are creating the array for
3977 request_dump_bynumber (unsigned int section, dump_type type)
3979 if (section >= num_dump_sects)
3981 dump_type * new_dump_sects;
3983 new_dump_sects = (dump_type *) calloc (section + 1,
3984 sizeof (* dump_sects));
3986 if (new_dump_sects == NULL)
3987 error (_("Out of memory allocating dump request table.\n"));
3990 /* Copy current flag settings. */
3991 memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
3995 dump_sects = new_dump_sects;
3996 num_dump_sects = section + 1;
4001 dump_sects[section] |= type;
4006 /* Request a dump by section name. */
4009 request_dump_byname (const char * section, dump_type type)
4011 struct dump_list_entry * new_request;
4013 new_request = (struct dump_list_entry *)
4014 malloc (sizeof (struct dump_list_entry));
4016 error (_("Out of memory allocating dump request table.\n"));
4018 new_request->name = strdup (section);
4019 if (!new_request->name)
4020 error (_("Out of memory allocating dump request table.\n"));
4022 new_request->type = type;
4024 new_request->next = dump_sects_byname;
4025 dump_sects_byname = new_request;
4029 request_dump (dump_type type)
4035 section = strtoul (optarg, & cp, 0);
4037 if (! *cp && section >= 0)
4038 request_dump_bynumber (section, type);
4040 request_dump_byname (optarg, type);
4045 parse_args (int argc, char ** argv)
4052 while ((c = getopt_long
4053 (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options, NULL)) != EOF)
4071 do_section_groups++;
4079 do_section_groups++;
4084 do_section_details++;
4128 request_dump (HEX_DUMP);
4131 request_dump (STRING_DUMP);
4134 request_dump (RELOC_DUMP);
4141 dwarf_select_sections_all ();
4146 dwarf_select_sections_by_letters (optarg);
4149 case OPTION_DEBUG_DUMP:
4156 dwarf_select_sections_by_names (optarg);
4159 case OPTION_DWARF_DEPTH:
4163 dwarf_cutoff_level = strtoul (optarg, & cp, 0);
4166 case OPTION_DWARF_START:
4170 dwarf_start_die = strtoul (optarg, & cp, 0);
4173 case OPTION_DWARF_CHECK:
4176 case OPTION_DYN_SYMS:
4179 #ifdef SUPPORT_DISASSEMBLY
4181 request_dump (DISASS_DUMP);
4185 print_version (program_name);
4194 /* xgettext:c-format */
4195 error (_("Invalid option '-%c'\n"), c);
4202 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
4203 && !do_segments && !do_header && !do_dump && !do_version
4204 && !do_histogram && !do_debugging && !do_arch && !do_notes
4205 && !do_section_groups && !do_archive_index
4210 warn (_("Nothing to do.\n"));
4216 get_elf_class (unsigned int elf_class)
4218 static char buff[32];
4222 case ELFCLASSNONE: return _("none");
4223 case ELFCLASS32: return "ELF32";
4224 case ELFCLASS64: return "ELF64";
4226 snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
4232 get_data_encoding (unsigned int encoding)
4234 static char buff[32];
4238 case ELFDATANONE: return _("none");
4239 case ELFDATA2LSB: return _("2's complement, little endian");
4240 case ELFDATA2MSB: return _("2's complement, big endian");
4242 snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
4247 /* Decode the data held in 'elf_header'. */
4250 process_file_header (void)
4252 if ( elf_header.e_ident[EI_MAG0] != ELFMAG0
4253 || elf_header.e_ident[EI_MAG1] != ELFMAG1
4254 || elf_header.e_ident[EI_MAG2] != ELFMAG2
4255 || elf_header.e_ident[EI_MAG3] != ELFMAG3)
4258 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4262 init_dwarf_regnames (elf_header.e_machine);
4268 printf (_("ELF Header:\n"));
4269 printf (_(" Magic: "));
4270 for (i = 0; i < EI_NIDENT; i++)
4271 printf ("%2.2x ", elf_header.e_ident[i]);
4273 printf (_(" Class: %s\n"),
4274 get_elf_class (elf_header.e_ident[EI_CLASS]));
4275 printf (_(" Data: %s\n"),
4276 get_data_encoding (elf_header.e_ident[EI_DATA]));
4277 printf (_(" Version: %d %s\n"),
4278 elf_header.e_ident[EI_VERSION],
4279 (elf_header.e_ident[EI_VERSION] == EV_CURRENT
4281 : (elf_header.e_ident[EI_VERSION] != EV_NONE
4282 ? _("<unknown: %lx>")
4284 printf (_(" OS/ABI: %s\n"),
4285 get_osabi_name (elf_header.e_ident[EI_OSABI]));
4286 printf (_(" ABI Version: %d\n"),
4287 elf_header.e_ident[EI_ABIVERSION]);
4288 printf (_(" Type: %s\n"),
4289 get_file_type (elf_header.e_type));
4290 printf (_(" Machine: %s\n"),
4291 get_machine_name (elf_header.e_machine));
4292 printf (_(" Version: 0x%lx\n"),
4293 (unsigned long) elf_header.e_version);
4295 printf (_(" Entry point address: "));
4296 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4297 printf (_("\n Start of program headers: "));
4298 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4299 printf (_(" (bytes into file)\n Start of section headers: "));
4300 print_vma ((bfd_vma) elf_header.e_shoff, DEC);
4301 printf (_(" (bytes into file)\n"));
4303 printf (_(" Flags: 0x%lx%s\n"),
4304 (unsigned long) elf_header.e_flags,
4305 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
4306 printf (_(" Size of this header: %ld (bytes)\n"),
4307 (long) elf_header.e_ehsize);
4308 printf (_(" Size of program headers: %ld (bytes)\n"),
4309 (long) elf_header.e_phentsize);
4310 printf (_(" Number of program headers: %ld"),
4311 (long) elf_header.e_phnum);
4312 if (section_headers != NULL
4313 && elf_header.e_phnum == PN_XNUM
4314 && section_headers[0].sh_info != 0)
4315 printf (" (%ld)", (long) section_headers[0].sh_info);
4316 putc ('\n', stdout);
4317 printf (_(" Size of section headers: %ld (bytes)\n"),
4318 (long) elf_header.e_shentsize);
4319 printf (_(" Number of section headers: %ld"),
4320 (long) elf_header.e_shnum);
4321 if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
4322 printf (" (%ld)", (long) section_headers[0].sh_size);
4323 putc ('\n', stdout);
4324 printf (_(" Section header string table index: %ld"),
4325 (long) elf_header.e_shstrndx);
4326 if (section_headers != NULL
4327 && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
4328 printf (" (%u)", section_headers[0].sh_link);
4329 else if (elf_header.e_shstrndx != SHN_UNDEF
4330 && elf_header.e_shstrndx >= elf_header.e_shnum)
4331 printf (_(" <corrupt: out of range>"));
4332 putc ('\n', stdout);
4335 if (section_headers != NULL)
4337 if (elf_header.e_phnum == PN_XNUM
4338 && section_headers[0].sh_info != 0)
4339 elf_header.e_phnum = section_headers[0].sh_info;
4340 if (elf_header.e_shnum == SHN_UNDEF)
4341 elf_header.e_shnum = section_headers[0].sh_size;
4342 if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
4343 elf_header.e_shstrndx = section_headers[0].sh_link;
4344 else if (elf_header.e_shstrndx >= elf_header.e_shnum)
4345 elf_header.e_shstrndx = SHN_UNDEF;
4346 free (section_headers);
4347 section_headers = NULL;
4354 get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
4356 Elf32_External_Phdr * phdrs;
4357 Elf32_External_Phdr * external;
4358 Elf_Internal_Phdr * internal;
4360 unsigned int size = elf_header.e_phentsize;
4361 unsigned int num = elf_header.e_phnum;
4363 /* PR binutils/17531: Cope with unexpected section header sizes. */
4364 if (size == 0 || num == 0)
4366 if (size < sizeof * phdrs)
4368 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4371 if (size > sizeof * phdrs)
4372 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4374 phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
4375 size, num, _("program headers"));
4379 for (i = 0, internal = pheaders, external = phdrs;
4380 i < elf_header.e_phnum;
4381 i++, internal++, external++)
4383 internal->p_type = BYTE_GET (external->p_type);
4384 internal->p_offset = BYTE_GET (external->p_offset);
4385 internal->p_vaddr = BYTE_GET (external->p_vaddr);
4386 internal->p_paddr = BYTE_GET (external->p_paddr);
4387 internal->p_filesz = BYTE_GET (external->p_filesz);
4388 internal->p_memsz = BYTE_GET (external->p_memsz);
4389 internal->p_flags = BYTE_GET (external->p_flags);
4390 internal->p_align = BYTE_GET (external->p_align);
4398 get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
4400 Elf64_External_Phdr * phdrs;
4401 Elf64_External_Phdr * external;
4402 Elf_Internal_Phdr * internal;
4404 unsigned int size = elf_header.e_phentsize;
4405 unsigned int num = elf_header.e_phnum;
4407 /* PR binutils/17531: Cope with unexpected section header sizes. */
4408 if (size == 0 || num == 0)
4410 if (size < sizeof * phdrs)
4412 error (_("The e_phentsize field in the ELF header is less than the size of an ELF program header\n"));
4415 if (size > sizeof * phdrs)
4416 warn (_("The e_phentsize field in the ELF header is larger than the size of an ELF program header\n"));
4418 phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
4419 size, num, _("program headers"));
4423 for (i = 0, internal = pheaders, external = phdrs;
4424 i < elf_header.e_phnum;
4425 i++, internal++, external++)
4427 internal->p_type = BYTE_GET (external->p_type);
4428 internal->p_flags = BYTE_GET (external->p_flags);
4429 internal->p_offset = BYTE_GET (external->p_offset);
4430 internal->p_vaddr = BYTE_GET (external->p_vaddr);
4431 internal->p_paddr = BYTE_GET (external->p_paddr);
4432 internal->p_filesz = BYTE_GET (external->p_filesz);
4433 internal->p_memsz = BYTE_GET (external->p_memsz);
4434 internal->p_align = BYTE_GET (external->p_align);
4441 /* Returns 1 if the program headers were read into `program_headers'. */
4444 get_program_headers (FILE * file)
4446 Elf_Internal_Phdr * phdrs;
4448 /* Check cache of prior read. */
4449 if (program_headers != NULL)
4452 phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
4453 sizeof (Elf_Internal_Phdr));
4457 error (_("Out of memory reading %u program headers\n"),
4458 elf_header.e_phnum);
4463 ? get_32bit_program_headers (file, phdrs)
4464 : get_64bit_program_headers (file, phdrs))
4466 program_headers = phdrs;
4474 /* Returns 1 if the program headers were loaded. */
4477 process_program_headers (FILE * file)
4479 Elf_Internal_Phdr * segment;
4482 if (elf_header.e_phnum == 0)
4484 /* PR binutils/12467. */
4485 if (elf_header.e_phoff != 0)
4486 warn (_("possibly corrupt ELF header - it has a non-zero program"
4487 " header offset, but no program headers"));
4488 else if (do_segments)
4489 printf (_("\nThere are no program headers in this file.\n"));
4493 if (do_segments && !do_header)
4495 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
4496 printf (_("Entry point "));
4497 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4498 printf (_("\nThere are %d program headers, starting at offset "),
4499 elf_header.e_phnum);
4500 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4504 if (! get_program_headers (file))
4509 if (elf_header.e_phnum > 1)
4510 printf (_("\nProgram Headers:\n"));
4512 printf (_("\nProgram Headers:\n"));
4516 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4519 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4523 (_(" Type Offset VirtAddr PhysAddr\n"));
4525 (_(" FileSiz MemSiz Flags Align\n"));
4532 for (i = 0, segment = program_headers;
4533 i < elf_header.e_phnum;
4538 printf (" %-14.14s ", get_segment_type (segment->p_type));
4542 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4543 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
4544 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
4545 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
4546 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
4548 (segment->p_flags & PF_R ? 'R' : ' '),
4549 (segment->p_flags & PF_W ? 'W' : ' '),
4550 (segment->p_flags & PF_X ? 'E' : ' '));
4551 printf ("%#lx", (unsigned long) segment->p_align);
4555 if ((unsigned long) segment->p_offset == segment->p_offset)
4556 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4559 print_vma (segment->p_offset, FULL_HEX);
4563 print_vma (segment->p_vaddr, FULL_HEX);
4565 print_vma (segment->p_paddr, FULL_HEX);
4568 if ((unsigned long) segment->p_filesz == segment->p_filesz)
4569 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
4572 print_vma (segment->p_filesz, FULL_HEX);
4576 if ((unsigned long) segment->p_memsz == segment->p_memsz)
4577 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
4580 print_vma (segment->p_memsz, FULL_HEX);
4584 (segment->p_flags & PF_R ? 'R' : ' '),
4585 (segment->p_flags & PF_W ? 'W' : ' '),
4586 (segment->p_flags & PF_X ? 'E' : ' '));
4588 if ((unsigned long) segment->p_align == segment->p_align)
4589 printf ("%#lx", (unsigned long) segment->p_align);
4592 print_vma (segment->p_align, PREFIX_HEX);
4597 print_vma (segment->p_offset, FULL_HEX);
4599 print_vma (segment->p_vaddr, FULL_HEX);
4601 print_vma (segment->p_paddr, FULL_HEX);
4603 print_vma (segment->p_filesz, FULL_HEX);
4605 print_vma (segment->p_memsz, FULL_HEX);
4607 (segment->p_flags & PF_R ? 'R' : ' '),
4608 (segment->p_flags & PF_W ? 'W' : ' '),
4609 (segment->p_flags & PF_X ? 'E' : ' '));
4610 print_vma (segment->p_align, HEX);
4615 putc ('\n', stdout);
4617 switch (segment->p_type)
4621 error (_("more than one dynamic segment\n"));
4623 /* By default, assume that the .dynamic section is the first
4624 section in the DYNAMIC segment. */
4625 dynamic_addr = segment->p_offset;
4626 dynamic_size = segment->p_filesz;
4627 /* PR binutils/17512: Avoid corrupt dynamic section info in the segment. */
4628 if (dynamic_addr + dynamic_size >= current_file_size)
4630 error (_("the dynamic segment offset + size exceeds the size of the file\n"));
4631 dynamic_addr = dynamic_size = 0;
4634 /* Try to locate the .dynamic section. If there is
4635 a section header table, we can easily locate it. */
4636 if (section_headers != NULL)
4638 Elf_Internal_Shdr * sec;
4640 sec = find_section (".dynamic");
4641 if (sec == NULL || sec->sh_size == 0)
4643 /* A corresponding .dynamic section is expected, but on
4644 IA-64/OpenVMS it is OK for it to be missing. */
4645 if (!is_ia64_vms ())
4646 error (_("no .dynamic section in the dynamic segment\n"));
4650 if (sec->sh_type == SHT_NOBITS)
4656 dynamic_addr = sec->sh_offset;
4657 dynamic_size = sec->sh_size;
4659 if (dynamic_addr < segment->p_offset
4660 || dynamic_addr > segment->p_offset + segment->p_filesz)
4661 warn (_("the .dynamic section is not contained"
4662 " within the dynamic segment\n"));
4663 else if (dynamic_addr > segment->p_offset)
4664 warn (_("the .dynamic section is not the first section"
4665 " in the dynamic segment.\n"));
4670 if (fseek (file, archive_file_offset + (long) segment->p_offset,
4672 error (_("Unable to find program interpreter name\n"));
4676 int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX - 1);
4678 if (ret >= (int) sizeof (fmt) || ret < 0)
4679 error (_("Internal error: failed to create format string to display program interpreter\n"));
4681 program_interpreter[0] = 0;
4682 if (fscanf (file, fmt, program_interpreter) <= 0)
4683 error (_("Unable to read program interpreter name\n"));
4686 printf (_(" [Requesting program interpreter: %s]\n"),
4687 program_interpreter);
4693 if (do_segments && section_headers != NULL && string_table != NULL)
4695 printf (_("\n Section to Segment mapping:\n"));
4696 printf (_(" Segment Sections...\n"));
4698 for (i = 0; i < elf_header.e_phnum; i++)
4701 Elf_Internal_Shdr * section;
4703 segment = program_headers + i;
4704 section = section_headers + 1;
4706 printf (" %2.2d ", i);
4708 for (j = 1; j < elf_header.e_shnum; j++, section++)
4710 if (!ELF_TBSS_SPECIAL (section, segment)
4711 && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
4712 printf ("%s ", printable_section_name (section));
4723 /* Find the file offset corresponding to VMA by using the program headers. */
4726 offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
4728 Elf_Internal_Phdr * seg;
4730 if (! get_program_headers (file))
4732 warn (_("Cannot interpret virtual addresses without program headers.\n"));
4736 for (seg = program_headers;
4737 seg < program_headers + elf_header.e_phnum;
4740 if (seg->p_type != PT_LOAD)
4743 if (vma >= (seg->p_vaddr & -seg->p_align)
4744 && vma + size <= seg->p_vaddr + seg->p_filesz)
4745 return vma - seg->p_vaddr + seg->p_offset;
4748 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
4749 (unsigned long) vma);
4754 /* Allocate memory and load the sections headers into the global pointer
4755 SECTION_HEADERS. If PROBE is true, this is just a probe and we do not
4756 generate any error messages if the load fails. */
4759 get_32bit_section_headers (FILE * file, bfd_boolean probe)
4761 Elf32_External_Shdr * shdrs;
4762 Elf_Internal_Shdr * internal;
4764 unsigned int size = elf_header.e_shentsize;
4765 unsigned int num = probe ? 1 : elf_header.e_shnum;
4767 /* PR binutils/17531: Cope with unexpected section header sizes. */
4768 if (size == 0 || num == 0)
4770 if (size < sizeof * shdrs)
4773 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4776 if (!probe && size > sizeof * shdrs)
4777 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
4779 shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
4781 probe ? NULL : _("section headers"));
4785 if (section_headers != NULL)
4786 free (section_headers);
4787 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4788 sizeof (Elf_Internal_Shdr));
4789 if (section_headers == NULL)
4792 error (_("Out of memory reading %u section headers\n"), num);
4796 for (i = 0, internal = section_headers;
4800 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4801 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
4802 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4803 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4804 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
4805 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4806 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4807 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
4808 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4809 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
4817 get_64bit_section_headers (FILE * file, bfd_boolean probe)
4819 Elf64_External_Shdr * shdrs;
4820 Elf_Internal_Shdr * internal;
4822 unsigned int size = elf_header.e_shentsize;
4823 unsigned int num = probe ? 1 : elf_header.e_shnum;
4825 /* PR binutils/17531: Cope with unexpected section header sizes. */
4826 if (size == 0 || num == 0)
4828 if (size < sizeof * shdrs)
4831 error (_("The e_shentsize field in the ELF header is less than the size of an ELF section header\n"));
4834 if (! probe && size > sizeof * shdrs)
4835 warn (_("The e_shentsize field in the ELF header is larger than the size of an ELF section header\n"));
4837 shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
4839 probe ? NULL : _("section headers"));
4843 if (section_headers != NULL)
4844 free (section_headers);
4845 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4846 sizeof (Elf_Internal_Shdr));
4847 if (section_headers == NULL)
4850 error (_("Out of memory reading %u section headers\n"), num);
4854 for (i = 0, internal = section_headers;
4858 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4859 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
4860 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4861 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4862 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4863 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
4864 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4865 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
4866 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
4867 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4874 static Elf_Internal_Sym *
4875 get_32bit_elf_symbols (FILE * file,
4876 Elf_Internal_Shdr * section,
4877 unsigned long * num_syms_return)
4879 unsigned long number = 0;
4880 Elf32_External_Sym * esyms = NULL;
4881 Elf_External_Sym_Shndx * shndx = NULL;
4882 Elf_Internal_Sym * isyms = NULL;
4883 Elf_Internal_Sym * psym;
4886 if (section->sh_size == 0)
4888 if (num_syms_return != NULL)
4889 * num_syms_return = 0;
4893 /* Run some sanity checks first. */
4894 if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
4896 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
4897 printable_section_name (section), (unsigned long) section->sh_entsize);
4901 if (section->sh_size > current_file_size)
4903 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
4904 printable_section_name (section), (unsigned long) section->sh_size);
4908 number = section->sh_size / section->sh_entsize;
4910 if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
4912 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
4913 (unsigned long) section->sh_size,
4914 printable_section_name (section),
4915 (unsigned long) section->sh_entsize);
4919 esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4920 section->sh_size, _("symbols"));
4925 if (symtab_shndx_hdr != NULL
4926 && (symtab_shndx_hdr->sh_link
4927 == (unsigned long) (section - section_headers)))
4929 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4930 symtab_shndx_hdr->sh_offset,
4931 1, symtab_shndx_hdr->sh_size,
4932 _("symbol table section indicies"));
4935 /* PR17531: file: heap-buffer-overflow */
4936 else if (symtab_shndx_hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
4938 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
4939 printable_section_name (symtab_shndx_hdr),
4940 (unsigned long) symtab_shndx_hdr->sh_size,
4941 (unsigned long) section->sh_size);
4946 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
4950 error (_("Out of memory reading %lu symbols\n"),
4951 (unsigned long) number);
4955 for (j = 0, psym = isyms; j < number; j++, psym++)
4957 psym->st_name = BYTE_GET (esyms[j].st_name);
4958 psym->st_value = BYTE_GET (esyms[j].st_value);
4959 psym->st_size = BYTE_GET (esyms[j].st_size);
4960 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4961 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
4963 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4964 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4965 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
4966 psym->st_info = BYTE_GET (esyms[j].st_info);
4967 psym->st_other = BYTE_GET (esyms[j].st_other);
4976 if (num_syms_return != NULL)
4977 * num_syms_return = isyms == NULL ? 0 : number;
4982 static Elf_Internal_Sym *
4983 get_64bit_elf_symbols (FILE * file,
4984 Elf_Internal_Shdr * section,
4985 unsigned long * num_syms_return)
4987 unsigned long number = 0;
4988 Elf64_External_Sym * esyms = NULL;
4989 Elf_External_Sym_Shndx * shndx = NULL;
4990 Elf_Internal_Sym * isyms = NULL;
4991 Elf_Internal_Sym * psym;
4994 if (section->sh_size == 0)
4996 if (num_syms_return != NULL)
4997 * num_syms_return = 0;
5001 /* Run some sanity checks first. */
5002 if (section->sh_entsize == 0 || section->sh_entsize > section->sh_size)
5004 error (_("Section %s has an invalid sh_entsize of 0x%lx\n"),
5005 printable_section_name (section),
5006 (unsigned long) section->sh_entsize);
5010 if (section->sh_size > current_file_size)
5012 error (_("Section %s has an invalid sh_size of 0x%lx\n"),
5013 printable_section_name (section),
5014 (unsigned long) section->sh_size);
5018 number = section->sh_size / section->sh_entsize;
5020 if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
5022 error (_("Size (0x%lx) of section %s is not a multiple of its sh_entsize (0x%lx)\n"),
5023 (unsigned long) section->sh_size,
5024 printable_section_name (section),
5025 (unsigned long) section->sh_entsize);
5029 esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
5030 section->sh_size, _("symbols"));
5034 if (symtab_shndx_hdr != NULL
5035 && (symtab_shndx_hdr->sh_link
5036 == (unsigned long) (section - section_headers)))
5038 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
5039 symtab_shndx_hdr->sh_offset,
5040 1, symtab_shndx_hdr->sh_size,
5041 _("symbol table section indicies"));
5044 else if (symtab_shndx_hdr->sh_size / sizeof (Elf_External_Sym_Shndx) < number)
5046 error (_("Index section %s has an sh_size of 0x%lx - expected 0x%lx\n"),
5047 printable_section_name (symtab_shndx_hdr),
5048 (unsigned long) symtab_shndx_hdr->sh_size,
5049 (unsigned long) section->sh_size);
5054 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
5058 error (_("Out of memory reading %lu symbols\n"),
5059 (unsigned long) number);
5063 for (j = 0, psym = isyms; j < number; j++, psym++)
5065 psym->st_name = BYTE_GET (esyms[j].st_name);
5066 psym->st_info = BYTE_GET (esyms[j].st_info);
5067 psym->st_other = BYTE_GET (esyms[j].st_other);
5068 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
5070 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
5072 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
5073 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
5074 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
5076 psym->st_value = BYTE_GET (esyms[j].st_value);
5077 psym->st_size = BYTE_GET (esyms[j].st_size);
5086 if (num_syms_return != NULL)
5087 * num_syms_return = isyms == NULL ? 0 : number;
5093 get_elf_section_flags (bfd_vma sh_flags)
5095 static char buff[1024];
5097 int field_size = is_32bit_elf ? 8 : 16;
5099 int size = sizeof (buff) - (field_size + 4 + 1);
5100 bfd_vma os_flags = 0;
5101 bfd_vma proc_flags = 0;
5102 bfd_vma unknown_flags = 0;
5110 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
5111 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
5112 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
5113 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
5114 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
5115 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
5116 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
5117 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
5118 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
5119 /* 9 */ { STRING_COMMA_LEN ("TLS") },
5120 /* IA-64 specific. */
5121 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
5122 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
5123 /* IA-64 OpenVMS specific. */
5124 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
5125 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
5126 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
5127 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
5128 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
5129 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
5131 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
5132 /* SPARC specific. */
5133 /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
5136 if (do_section_details)
5138 sprintf (buff, "[%*.*lx]: ",
5139 field_size, field_size, (unsigned long) sh_flags);
5140 p += field_size + 4;
5147 flag = sh_flags & - sh_flags;
5150 if (do_section_details)
5154 case SHF_WRITE: sindex = 0; break;
5155 case SHF_ALLOC: sindex = 1; break;
5156 case SHF_EXECINSTR: sindex = 2; break;
5157 case SHF_MERGE: sindex = 3; break;
5158 case SHF_STRINGS: sindex = 4; break;
5159 case SHF_INFO_LINK: sindex = 5; break;
5160 case SHF_LINK_ORDER: sindex = 6; break;
5161 case SHF_OS_NONCONFORMING: sindex = 7; break;
5162 case SHF_GROUP: sindex = 8; break;
5163 case SHF_TLS: sindex = 9; break;
5164 case SHF_EXCLUDE: sindex = 18; break;
5168 switch (elf_header.e_machine)
5171 if (flag == SHF_IA_64_SHORT)
5173 else if (flag == SHF_IA_64_NORECOV)
5176 else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
5179 case SHF_IA_64_VMS_GLOBAL: sindex = 12; break;
5180 case SHF_IA_64_VMS_OVERLAID: sindex = 13; break;
5181 case SHF_IA_64_VMS_SHARED: sindex = 14; break;
5182 case SHF_IA_64_VMS_VECTOR: sindex = 15; break;
5183 case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
5184 case SHF_IA_64_VMS_PROTECTED: sindex = 17; break;
5195 case EM_OLD_SPARCV9:
5196 case EM_SPARC32PLUS:
5199 if (flag == SHF_ORDERED)
5209 if (p != buff + field_size + 4)
5211 if (size < (10 + 2))
5213 warn (_("Internal error: not enough buffer room for section flag info"));
5214 return _("<unknown>");
5221 size -= flags [sindex].len;
5222 p = stpcpy (p, flags [sindex].str);
5224 else if (flag & SHF_MASKOS)
5226 else if (flag & SHF_MASKPROC)
5229 unknown_flags |= flag;
5235 case SHF_WRITE: *p = 'W'; break;
5236 case SHF_ALLOC: *p = 'A'; break;
5237 case SHF_EXECINSTR: *p = 'X'; break;
5238 case SHF_MERGE: *p = 'M'; break;
5239 case SHF_STRINGS: *p = 'S'; break;
5240 case SHF_INFO_LINK: *p = 'I'; break;
5241 case SHF_LINK_ORDER: *p = 'L'; break;
5242 case SHF_OS_NONCONFORMING: *p = 'O'; break;
5243 case SHF_GROUP: *p = 'G'; break;
5244 case SHF_TLS: *p = 'T'; break;
5245 case SHF_EXCLUDE: *p = 'E'; break;
5248 if ((elf_header.e_machine == EM_X86_64
5249 || elf_header.e_machine == EM_L1OM
5250 || elf_header.e_machine == EM_K1OM)
5251 && flag == SHF_X86_64_LARGE)
5253 else if (flag & SHF_MASKOS)
5256 sh_flags &= ~ SHF_MASKOS;
5258 else if (flag & SHF_MASKPROC)
5261 sh_flags &= ~ SHF_MASKPROC;
5271 if (do_section_details)
5275 size -= 5 + field_size;
5276 if (p != buff + field_size + 4)
5280 warn (_("Internal error: not enough buffer room for section flag info"));
5281 return _("<unknown>");
5287 sprintf (p, "OS (%*.*lx)", field_size, field_size,
5288 (unsigned long) os_flags);
5289 p += 5 + field_size;
5293 size -= 7 + field_size;
5294 if (p != buff + field_size + 4)
5298 warn (_("Internal error: not enough buffer room for section flag info"));
5299 return _("<unknown>");
5305 sprintf (p, "PROC (%*.*lx)", field_size, field_size,
5306 (unsigned long) proc_flags);
5307 p += 7 + field_size;
5311 size -= 10 + field_size;
5312 if (p != buff + field_size + 4)
5316 warn (_("Internal error: not enough buffer room for section flag info"));
5317 return _("<unknown>");
5323 sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
5324 (unsigned long) unknown_flags);
5325 p += 10 + field_size;
5334 process_section_headers (FILE * file)
5336 Elf_Internal_Shdr * section;
5339 section_headers = NULL;
5341 if (elf_header.e_shnum == 0)
5343 /* PR binutils/12467. */
5344 if (elf_header.e_shoff != 0)
5345 warn (_("possibly corrupt ELF file header - it has a non-zero"
5346 " section header offset, but no section headers\n"));
5347 else if (do_sections)
5348 printf (_("\nThere are no sections in this file.\n"));
5353 if (do_sections && !do_header)
5354 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
5355 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
5359 if (! get_32bit_section_headers (file, FALSE))
5362 else if (! get_64bit_section_headers (file, FALSE))
5365 /* Read in the string table, so that we have names to display. */
5366 if (elf_header.e_shstrndx != SHN_UNDEF
5367 && elf_header.e_shstrndx < elf_header.e_shnum)
5369 section = section_headers + elf_header.e_shstrndx;
5371 if (section->sh_size != 0)
5373 string_table = (char *) get_data (NULL, file, section->sh_offset,
5374 1, section->sh_size,
5377 string_table_length = string_table != NULL ? section->sh_size : 0;
5381 /* Scan the sections for the dynamic symbol table
5382 and dynamic string table and debug sections. */
5383 dynamic_symbols = NULL;
5384 dynamic_strings = NULL;
5385 dynamic_syminfo = NULL;
5386 symtab_shndx_hdr = NULL;
5388 eh_addr_size = is_32bit_elf ? 4 : 8;
5389 switch (elf_header.e_machine)
5392 case EM_MIPS_RS3_LE:
5393 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5394 FDE addresses. However, the ABI also has a semi-official ILP32
5395 variant for which the normal FDE address size rules apply.
5397 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5398 section, where XX is the size of longs in bits. Unfortunately,
5399 earlier compilers provided no way of distinguishing ILP32 objects
5400 from LP64 objects, so if there's any doubt, we should assume that
5401 the official LP64 form is being used. */
5402 if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
5403 && find_section (".gcc_compiled_long32") == NULL)
5409 switch (elf_header.e_flags & EF_H8_MACH)
5411 case E_H8_MACH_H8300:
5412 case E_H8_MACH_H8300HN:
5413 case E_H8_MACH_H8300SN:
5414 case E_H8_MACH_H8300SXN:
5417 case E_H8_MACH_H8300H:
5418 case E_H8_MACH_H8300S:
5419 case E_H8_MACH_H8300SX:
5427 switch (elf_header.e_flags & EF_M32C_CPU_MASK)
5429 case EF_M32C_CPU_M16C:
5436 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
5439 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
5440 if (section->sh_entsize != expected_entsize) \
5443 sprintf_vma (buf, section->sh_entsize); \
5444 /* Note: coded this way so that there is a single string for \
5446 error (_("Section %d has invalid sh_entsize of %s\n"), i, buf); \
5447 error (_("(Using the expected size of %u for the rest of this dump)\n"), \
5448 (unsigned) expected_entsize); \
5449 section->sh_entsize = expected_entsize; \
5454 #define CHECK_ENTSIZE(section, i, type) \
5455 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
5456 sizeof (Elf64_External_##type))
5458 for (i = 0, section = section_headers;
5459 i < elf_header.e_shnum;
5462 char * name = SECTION_NAME (section);
5464 if (section->sh_type == SHT_DYNSYM)
5466 if (dynamic_symbols != NULL)
5468 error (_("File contains multiple dynamic symbol tables\n"));
5472 CHECK_ENTSIZE (section, i, Sym);
5473 dynamic_symbols = GET_ELF_SYMBOLS (file, section, & num_dynamic_syms);
5475 else if (section->sh_type == SHT_STRTAB
5476 && streq (name, ".dynstr"))
5478 if (dynamic_strings != NULL)
5480 error (_("File contains multiple dynamic string tables\n"));
5484 dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
5485 1, section->sh_size,
5486 _("dynamic strings"));
5487 dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
5489 else if (section->sh_type == SHT_SYMTAB_SHNDX)
5491 if (symtab_shndx_hdr != NULL)
5493 error (_("File contains multiple symtab shndx tables\n"));
5496 symtab_shndx_hdr = section;
5498 else if (section->sh_type == SHT_SYMTAB)
5499 CHECK_ENTSIZE (section, i, Sym);
5500 else if (section->sh_type == SHT_GROUP)
5501 CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
5502 else if (section->sh_type == SHT_REL)
5503 CHECK_ENTSIZE (section, i, Rel);
5504 else if (section->sh_type == SHT_RELA)
5505 CHECK_ENTSIZE (section, i, Rela);
5506 else if ((do_debugging || do_debug_info || do_debug_abbrevs
5507 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
5508 || do_debug_aranges || do_debug_frames || do_debug_macinfo
5509 || do_debug_str || do_debug_loc || do_debug_ranges
5510 || do_debug_addr || do_debug_cu_index)
5511 && (const_strneq (name, ".debug_")
5512 || const_strneq (name, ".zdebug_")))
5515 name += sizeof (".zdebug_") - 1;
5517 name += sizeof (".debug_") - 1;
5520 || (do_debug_info && const_strneq (name, "info"))
5521 || (do_debug_info && const_strneq (name, "types"))
5522 || (do_debug_abbrevs && const_strneq (name, "abbrev"))
5523 || (do_debug_lines && strcmp (name, "line") == 0)
5524 || (do_debug_lines && const_strneq (name, "line."))
5525 || (do_debug_pubnames && const_strneq (name, "pubnames"))
5526 || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
5527 || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
5528 || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
5529 || (do_debug_aranges && const_strneq (name, "aranges"))
5530 || (do_debug_ranges && const_strneq (name, "ranges"))
5531 || (do_debug_frames && const_strneq (name, "frame"))
5532 || (do_debug_macinfo && const_strneq (name, "macinfo"))
5533 || (do_debug_macinfo && const_strneq (name, "macro"))
5534 || (do_debug_str && const_strneq (name, "str"))
5535 || (do_debug_loc && const_strneq (name, "loc"))
5536 || (do_debug_addr && const_strneq (name, "addr"))
5537 || (do_debug_cu_index && const_strneq (name, "cu_index"))
5538 || (do_debug_cu_index && const_strneq (name, "tu_index"))
5540 request_dump_bynumber (i, DEBUG_DUMP);
5542 /* Linkonce section to be combined with .debug_info at link time. */
5543 else if ((do_debugging || do_debug_info)
5544 && const_strneq (name, ".gnu.linkonce.wi."))
5545 request_dump_bynumber (i, DEBUG_DUMP);
5546 else if (do_debug_frames && streq (name, ".eh_frame"))
5547 request_dump_bynumber (i, DEBUG_DUMP);
5548 else if (do_gdb_index && streq (name, ".gdb_index"))
5549 request_dump_bynumber (i, DEBUG_DUMP);
5550 /* Trace sections for Itanium VMS. */
5551 else if ((do_debugging || do_trace_info || do_trace_abbrevs
5552 || do_trace_aranges)
5553 && const_strneq (name, ".trace_"))
5555 name += sizeof (".trace_") - 1;
5558 || (do_trace_info && streq (name, "info"))
5559 || (do_trace_abbrevs && streq (name, "abbrev"))
5560 || (do_trace_aranges && streq (name, "aranges"))
5562 request_dump_bynumber (i, DEBUG_DUMP);
5569 if (elf_header.e_shnum > 1)
5570 printf (_("\nSection Headers:\n"));
5572 printf (_("\nSection Header:\n"));
5576 if (do_section_details)
5578 printf (_(" [Nr] Name\n"));
5579 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
5583 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
5587 if (do_section_details)
5589 printf (_(" [Nr] Name\n"));
5590 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
5594 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
5598 if (do_section_details)
5600 printf (_(" [Nr] Name\n"));
5601 printf (_(" Type Address Offset Link\n"));
5602 printf (_(" Size EntSize Info Align\n"));
5606 printf (_(" [Nr] Name Type Address Offset\n"));
5607 printf (_(" Size EntSize Flags Link Info Align\n"));
5611 if (do_section_details)
5612 printf (_(" Flags\n"));
5614 for (i = 0, section = section_headers;
5615 i < elf_header.e_shnum;
5618 printf (" [%2u] ", i);
5619 if (do_section_details)
5620 printf ("%s\n ", printable_section_name (section));
5622 print_symbol (-17, SECTION_NAME (section));
5624 printf (do_wide ? " %-15s " : " %-15.15s ",
5625 get_section_type_name (section->sh_type));
5629 const char * link_too_big = NULL;
5631 print_vma (section->sh_addr, LONG_HEX);
5633 printf ( " %6.6lx %6.6lx %2.2lx",
5634 (unsigned long) section->sh_offset,
5635 (unsigned long) section->sh_size,
5636 (unsigned long) section->sh_entsize);
5638 if (do_section_details)
5639 fputs (" ", stdout);
5641 printf (" %3s ", get_elf_section_flags (section->sh_flags));
5643 if (section->sh_link >= elf_header.e_shnum)
5646 /* The sh_link value is out of range. Normally this indicates
5647 an error but it can have special values in Solaris binaries. */
5648 switch (elf_header.e_machine)
5655 case EM_OLD_SPARCV9:
5656 case EM_SPARC32PLUS:
5659 if (section->sh_link == (SHN_BEFORE & 0xffff))
5660 link_too_big = "BEFORE";
5661 else if (section->sh_link == (SHN_AFTER & 0xffff))
5662 link_too_big = "AFTER";
5669 if (do_section_details)
5671 if (link_too_big != NULL && * link_too_big)
5672 printf ("<%s> ", link_too_big);
5674 printf ("%2u ", section->sh_link);
5675 printf ("%3u %2lu\n", section->sh_info,
5676 (unsigned long) section->sh_addralign);
5679 printf ("%2u %3u %2lu\n",
5682 (unsigned long) section->sh_addralign);
5684 if (link_too_big && ! * link_too_big)
5685 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
5686 i, section->sh_link);
5690 print_vma (section->sh_addr, LONG_HEX);
5692 if ((long) section->sh_offset == section->sh_offset)
5693 printf (" %6.6lx", (unsigned long) section->sh_offset);
5697 print_vma (section->sh_offset, LONG_HEX);
5700 if ((unsigned long) section->sh_size == section->sh_size)
5701 printf (" %6.6lx", (unsigned long) section->sh_size);
5705 print_vma (section->sh_size, LONG_HEX);
5708 if ((unsigned long) section->sh_entsize == section->sh_entsize)
5709 printf (" %2.2lx", (unsigned long) section->sh_entsize);
5713 print_vma (section->sh_entsize, LONG_HEX);
5716 if (do_section_details)
5717 fputs (" ", stdout);
5719 printf (" %3s ", get_elf_section_flags (section->sh_flags));
5721 printf ("%2u %3u ", section->sh_link, section->sh_info);
5723 if ((unsigned long) section->sh_addralign == section->sh_addralign)
5724 printf ("%2lu\n", (unsigned long) section->sh_addralign);
5727 print_vma (section->sh_addralign, DEC);
5731 else if (do_section_details)
5733 printf (" %-15.15s ",
5734 get_section_type_name (section->sh_type));
5735 print_vma (section->sh_addr, LONG_HEX);
5736 if ((long) section->sh_offset == section->sh_offset)
5737 printf (" %16.16lx", (unsigned long) section->sh_offset);
5741 print_vma (section->sh_offset, LONG_HEX);
5743 printf (" %u\n ", section->sh_link);
5744 print_vma (section->sh_size, LONG_HEX);
5746 print_vma (section->sh_entsize, LONG_HEX);
5748 printf (" %-16u %lu\n",
5750 (unsigned long) section->sh_addralign);
5755 print_vma (section->sh_addr, LONG_HEX);
5756 if ((long) section->sh_offset == section->sh_offset)
5757 printf (" %8.8lx", (unsigned long) section->sh_offset);
5761 print_vma (section->sh_offset, LONG_HEX);
5764 print_vma (section->sh_size, LONG_HEX);
5766 print_vma (section->sh_entsize, LONG_HEX);
5768 printf (" %3s ", get_elf_section_flags (section->sh_flags));
5770 printf (" %2u %3u %lu\n",
5773 (unsigned long) section->sh_addralign);
5776 if (do_section_details)
5777 printf (" %s\n", get_elf_section_flags (section->sh_flags));
5780 if (!do_section_details)
5782 if (elf_header.e_machine == EM_X86_64
5783 || elf_header.e_machine == EM_L1OM
5784 || elf_header.e_machine == EM_K1OM)
5785 printf (_("Key to Flags:\n\
5786 W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
5787 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5788 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5790 printf (_("Key to Flags:\n\
5791 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
5792 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5793 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5800 get_group_flags (unsigned int flags)
5802 static char buff[32];
5812 snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x] "), flags);
5819 process_section_groups (FILE * file)
5821 Elf_Internal_Shdr * section;
5823 struct group * group;
5824 Elf_Internal_Shdr * symtab_sec;
5825 Elf_Internal_Shdr * strtab_sec;
5826 Elf_Internal_Sym * symtab;
5827 unsigned long num_syms;
5831 /* Don't process section groups unless needed. */
5832 if (!do_unwind && !do_section_groups)
5835 if (elf_header.e_shnum == 0)
5837 if (do_section_groups)
5838 printf (_("\nThere are no sections to group in this file.\n"));
5843 if (section_headers == NULL)
5845 error (_("Section headers are not available!\n"));
5846 /* PR 13622: This can happen with a corrupt ELF header. */
5850 section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
5851 sizeof (struct group *));
5853 if (section_headers_groups == NULL)
5855 error (_("Out of memory reading %u section group headers\n"),
5856 elf_header.e_shnum);
5860 /* Scan the sections for the group section. */
5862 for (i = 0, section = section_headers;
5863 i < elf_header.e_shnum;
5865 if (section->sh_type == SHT_GROUP)
5868 if (group_count == 0)
5870 if (do_section_groups)
5871 printf (_("\nThere are no section groups in this file.\n"));
5876 section_groups = (struct group *) calloc (group_count, sizeof (struct group));
5878 if (section_groups == NULL)
5880 error (_("Out of memory reading %lu groups\n"),
5881 (unsigned long) group_count);
5891 for (i = 0, section = section_headers, group = section_groups;
5892 i < elf_header.e_shnum;
5895 if (section->sh_type == SHT_GROUP)
5897 const char * name = printable_section_name (section);
5898 const char * group_name;
5899 unsigned char * start;
5900 unsigned char * indices;
5901 unsigned int entry, j, size;
5902 Elf_Internal_Shdr * sec;
5903 Elf_Internal_Sym * sym;
5905 /* Get the symbol table. */
5906 if (section->sh_link >= elf_header.e_shnum
5907 || ((sec = section_headers + section->sh_link)->sh_type
5910 error (_("Bad sh_link in group section `%s'\n"), name);
5914 if (symtab_sec != sec)
5919 symtab = GET_ELF_SYMBOLS (file, symtab_sec, & num_syms);
5924 error (_("Corrupt header in group section `%s'\n"), name);
5928 if (section->sh_info >= num_syms)
5930 error (_("Bad sh_info in group section `%s'\n"), name);
5934 sym = symtab + section->sh_info;
5936 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
5938 if (sym->st_shndx == 0
5939 || sym->st_shndx >= elf_header.e_shnum)
5941 error (_("Bad sh_info in group section `%s'\n"), name);
5945 group_name = SECTION_NAME (section_headers + sym->st_shndx);
5954 /* Get the string table. */
5955 if (symtab_sec->sh_link >= elf_header.e_shnum)
5964 != (sec = section_headers + symtab_sec->sh_link))
5970 strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
5971 1, strtab_sec->sh_size,
5973 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
5975 group_name = sym->st_name < strtab_size
5976 ? strtab + sym->st_name : _("<corrupt>");
5979 /* PR 17531: file: loop. */
5980 if (section->sh_entsize > section->sh_size)
5982 error (_("Section %s has sh_entsize (0x%lx) which is larger than its size (0x%lx)\n"),
5983 printable_section_name (section),
5984 (unsigned long) section->sh_entsize,
5985 (unsigned long) section->sh_size);
5989 start = (unsigned char *) get_data (NULL, file, section->sh_offset,
5990 1, section->sh_size,
5996 size = (section->sh_size / section->sh_entsize) - 1;
5997 entry = byte_get (indices, 4);
6000 if (do_section_groups)
6002 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
6003 get_group_flags (entry), i, name, group_name, size);
6005 printf (_(" [Index] Name\n"));
6008 group->group_index = i;
6010 for (j = 0; j < size; j++)
6012 struct group_list * g;
6014 entry = byte_get (indices, 4);
6017 if (entry >= elf_header.e_shnum)
6019 static unsigned num_group_errors = 0;
6021 if (num_group_errors ++ < 10)
6023 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
6024 entry, i, elf_header.e_shnum - 1);
6025 if (num_group_errors == 10)
6026 warn (_("Futher error messages about overlarge group section indicies suppressed\n"));
6031 if (section_headers_groups [entry] != NULL)
6035 static unsigned num_errs = 0;
6037 if (num_errs ++ < 10)
6039 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
6041 section_headers_groups [entry]->group_index);
6043 warn (_("Further error messages about already contained group sections suppressed\n"));
6049 /* Intel C/C++ compiler may put section 0 in a
6050 section group. We just warn it the first time
6051 and ignore it afterwards. */
6052 static int warned = 0;
6055 error (_("section 0 in group section [%5u]\n"),
6056 section_headers_groups [entry]->group_index);
6062 section_headers_groups [entry] = group;
6064 if (do_section_groups)
6066 sec = section_headers + entry;
6067 printf (" [%5u] %s\n", entry, printable_section_name (sec));
6070 g = (struct group_list *) xmalloc (sizeof (struct group_list));
6071 g->section_index = entry;
6072 g->next = group->root;
6090 /* Data used to display dynamic fixups. */
6092 struct ia64_vms_dynfixup
6094 bfd_vma needed_ident; /* Library ident number. */
6095 bfd_vma needed; /* Index in the dstrtab of the library name. */
6096 bfd_vma fixup_needed; /* Index of the library. */
6097 bfd_vma fixup_rela_cnt; /* Number of fixups. */
6098 bfd_vma fixup_rela_off; /* Fixups offset in the dynamic segment. */
6101 /* Data used to display dynamic relocations. */
6103 struct ia64_vms_dynimgrela
6105 bfd_vma img_rela_cnt; /* Number of relocations. */
6106 bfd_vma img_rela_off; /* Reloc offset in the dynamic segment. */
6109 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
6113 dump_ia64_vms_dynamic_fixups (FILE *file, struct ia64_vms_dynfixup *fixup,
6114 const char *strtab, unsigned int strtab_sz)
6116 Elf64_External_VMS_IMAGE_FIXUP *imfs;
6118 const char *lib_name;
6120 imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
6121 1, fixup->fixup_rela_cnt * sizeof (*imfs),
6122 _("dynamic section image fixups"));
6126 if (fixup->needed < strtab_sz)
6127 lib_name = strtab + fixup->needed;
6130 warn ("corrupt library name index of 0x%lx found in dynamic entry",
6131 (unsigned long) fixup->needed);
6134 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
6135 (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
6137 (_("Seg Offset Type SymVec DataType\n"));
6139 for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
6144 printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
6145 printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
6146 type = BYTE_GET (imfs [i].type);
6147 rtype = elf_ia64_reloc_type (type);
6149 printf (" 0x%08x ", type);
6151 printf (" %-32s ", rtype);
6152 printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
6153 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
6159 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
6162 dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
6164 Elf64_External_VMS_IMAGE_RELA *imrs;
6167 imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
6168 1, imgrela->img_rela_cnt * sizeof (*imrs),
6169 _("dynamic section image relocations"));
6173 printf (_("\nImage relocs\n"));
6175 (_("Seg Offset Type Addend Seg Sym Off\n"));
6177 for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
6182 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
6183 printf ("%08" BFD_VMA_FMT "x ",
6184 (bfd_vma) BYTE_GET (imrs [i].rela_offset));
6185 type = BYTE_GET (imrs [i].type);
6186 rtype = elf_ia64_reloc_type (type);
6188 printf ("0x%08x ", type);
6190 printf ("%-31s ", rtype);
6191 print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
6192 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
6193 printf ("%08" BFD_VMA_FMT "x\n",
6194 (bfd_vma) BYTE_GET (imrs [i].sym_offset));
6200 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
6203 process_ia64_vms_dynamic_relocs (FILE *file)
6205 struct ia64_vms_dynfixup fixup;
6206 struct ia64_vms_dynimgrela imgrela;
6207 Elf_Internal_Dyn *entry;
6209 bfd_vma strtab_off = 0;
6210 bfd_vma strtab_sz = 0;
6211 char *strtab = NULL;
6213 memset (&fixup, 0, sizeof (fixup));
6214 memset (&imgrela, 0, sizeof (imgrela));
6216 /* Note: the order of the entries is specified by the OpenVMS specs. */
6217 for (entry = dynamic_section;
6218 entry < dynamic_section + dynamic_nent;
6221 switch (entry->d_tag)
6223 case DT_IA_64_VMS_STRTAB_OFFSET:
6224 strtab_off = entry->d_un.d_val;
6227 strtab_sz = entry->d_un.d_val;
6229 strtab = get_data (NULL, file, dynamic_addr + strtab_off,
6230 1, strtab_sz, _("dynamic string section"));
6233 case DT_IA_64_VMS_NEEDED_IDENT:
6234 fixup.needed_ident = entry->d_un.d_val;
6237 fixup.needed = entry->d_un.d_val;
6239 case DT_IA_64_VMS_FIXUP_NEEDED:
6240 fixup.fixup_needed = entry->d_un.d_val;
6242 case DT_IA_64_VMS_FIXUP_RELA_CNT:
6243 fixup.fixup_rela_cnt = entry->d_un.d_val;
6245 case DT_IA_64_VMS_FIXUP_RELA_OFF:
6246 fixup.fixup_rela_off = entry->d_un.d_val;
6248 dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz);
6251 case DT_IA_64_VMS_IMG_RELA_CNT:
6252 imgrela.img_rela_cnt = entry->d_un.d_val;
6254 case DT_IA_64_VMS_IMG_RELA_OFF:
6255 imgrela.img_rela_off = entry->d_un.d_val;
6257 dump_ia64_vms_dynamic_relocs (file, &imgrela);
6277 } dynamic_relocations [] =
6279 { "REL", DT_REL, DT_RELSZ, FALSE },
6280 { "RELA", DT_RELA, DT_RELASZ, TRUE },
6281 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
6284 /* Process the reloc section. */
6287 process_relocs (FILE * file)
6289 unsigned long rel_size;
6290 unsigned long rel_offset;
6296 if (do_using_dynamic)
6300 int has_dynamic_reloc;
6303 has_dynamic_reloc = 0;
6305 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
6307 is_rela = dynamic_relocations [i].rela;
6308 name = dynamic_relocations [i].name;
6309 rel_size = dynamic_info [dynamic_relocations [i].size];
6310 rel_offset = dynamic_info [dynamic_relocations [i].reloc];
6312 has_dynamic_reloc |= rel_size;
6314 if (is_rela == UNKNOWN)
6316 if (dynamic_relocations [i].reloc == DT_JMPREL)
6317 switch (dynamic_info[DT_PLTREL])
6331 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
6332 name, rel_offset, rel_size);
6334 dump_relocations (file,
6335 offset_from_vma (file, rel_offset, rel_size),
6337 dynamic_symbols, num_dynamic_syms,
6338 dynamic_strings, dynamic_strings_length,
6344 has_dynamic_reloc |= process_ia64_vms_dynamic_relocs (file);
6346 if (! has_dynamic_reloc)
6347 printf (_("\nThere are no dynamic relocations in this file.\n"));
6351 Elf_Internal_Shdr * section;
6355 for (i = 0, section = section_headers;
6356 i < elf_header.e_shnum;
6359 if ( section->sh_type != SHT_RELA
6360 && section->sh_type != SHT_REL)
6363 rel_offset = section->sh_offset;
6364 rel_size = section->sh_size;
6368 Elf_Internal_Shdr * strsec;
6371 printf (_("\nRelocation section "));
6373 if (string_table == NULL)
6374 printf ("%d", section->sh_name);
6376 printf ("'%s'", printable_section_name (section));
6378 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6379 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
6381 is_rela = section->sh_type == SHT_RELA;
6383 if (section->sh_link != 0
6384 && section->sh_link < elf_header.e_shnum)
6386 Elf_Internal_Shdr * symsec;
6387 Elf_Internal_Sym * symtab;
6388 unsigned long nsyms;
6389 unsigned long strtablen = 0;
6390 char * strtab = NULL;
6392 symsec = section_headers + section->sh_link;
6393 if (symsec->sh_type != SHT_SYMTAB
6394 && symsec->sh_type != SHT_DYNSYM)
6397 symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
6402 if (symsec->sh_link != 0
6403 && symsec->sh_link < elf_header.e_shnum)
6405 strsec = section_headers + symsec->sh_link;
6407 strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6410 strtablen = strtab == NULL ? 0 : strsec->sh_size;
6413 dump_relocations (file, rel_offset, rel_size,
6414 symtab, nsyms, strtab, strtablen,
6416 symsec->sh_type == SHT_DYNSYM);
6422 dump_relocations (file, rel_offset, rel_size,
6423 NULL, 0, NULL, 0, is_rela, 0);
6430 printf (_("\nThere are no relocations in this file.\n"));
6436 /* Process the unwind section. */
6438 #include "unwind-ia64.h"
6440 /* An absolute address consists of a section and an offset. If the
6441 section is NULL, the offset itself is the address, otherwise, the
6442 address equals to LOAD_ADDRESS(section) + offset. */
6446 unsigned short section;
6450 #define ABSADDR(a) \
6452 ? section_headers [(a).section].sh_addr + (a).offset \
6455 struct ia64_unw_table_entry
6457 struct absaddr start;
6459 struct absaddr info;
6462 struct ia64_unw_aux_info
6465 struct ia64_unw_table_entry *table; /* Unwind table. */
6466 unsigned long table_len; /* Length of unwind table. */
6467 unsigned char * info; /* Unwind info. */
6468 unsigned long info_size; /* Size of unwind info. */
6469 bfd_vma info_addr; /* starting address of unwind info. */
6470 bfd_vma seg_base; /* Starting address of segment. */
6471 Elf_Internal_Sym * symtab; /* The symbol table. */
6472 unsigned long nsyms; /* Number of symbols. */
6473 char * strtab; /* The string table. */
6474 unsigned long strtab_size; /* Size of string table. */
6478 find_symbol_for_address (Elf_Internal_Sym * symtab,
6479 unsigned long nsyms,
6480 const char * strtab,
6481 unsigned long strtab_size,
6482 struct absaddr addr,
6483 const char ** symname,
6486 bfd_vma dist = 0x100000;
6487 Elf_Internal_Sym * sym;
6488 Elf_Internal_Sym * best = NULL;
6491 REMOVE_ARCH_BITS (addr.offset);
6493 for (i = 0, sym = symtab; i < nsyms; ++i, ++sym)
6495 bfd_vma value = sym->st_value;
6497 REMOVE_ARCH_BITS (value);
6499 if (ELF_ST_TYPE (sym->st_info) == STT_FUNC
6500 && sym->st_name != 0
6501 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
6502 && addr.offset >= value
6503 && addr.offset - value < dist)
6506 dist = addr.offset - value;
6514 *symname = (best->st_name >= strtab_size
6515 ? _("<corrupt>") : strtab + best->st_name);
6521 *offset = addr.offset;
6525 dump_ia64_unwind (struct ia64_unw_aux_info * aux)
6527 struct ia64_unw_table_entry * tp;
6530 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
6534 const unsigned char * dp;
6535 const unsigned char * head;
6536 const unsigned char * end;
6537 const char * procname;
6539 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6540 aux->strtab_size, tp->start, &procname, &offset);
6542 fputs ("\n<", stdout);
6546 fputs (procname, stdout);
6549 printf ("+%lx", (unsigned long) offset);
6552 fputs (">: [", stdout);
6553 print_vma (tp->start.offset, PREFIX_HEX);
6554 fputc ('-', stdout);
6555 print_vma (tp->end.offset, PREFIX_HEX);
6556 printf ("], info at +0x%lx\n",
6557 (unsigned long) (tp->info.offset - aux->seg_base));
6559 /* PR 17531: file: 86232b32. */
6560 if (aux->info == NULL)
6563 /* PR 17531: file: 0997b4d1. */
6564 if ((ABSADDR (tp->info) - aux->info_addr) >= aux->info_size)
6566 warn (_("Invalid offset %lx in table entry %ld\n"),
6567 (long) tp->info.offset, (long) (tp - aux->table));
6571 head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
6572 stamp = byte_get ((unsigned char *) head, sizeof (stamp));
6574 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
6575 (unsigned) UNW_VER (stamp),
6576 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
6577 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
6578 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
6579 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
6581 if (UNW_VER (stamp) != 1)
6583 printf (_("\tUnknown version.\n"));
6588 end = head + 8 + eh_addr_size * UNW_LENGTH (stamp);
6589 /* PR 17531: file: 16ceda89. */
6590 if (end > aux->info + aux->info_size)
6591 end = aux->info + aux->info_size;
6592 for (dp = head + 8; dp < end;)
6593 dp = unw_decode (dp, in_body, & in_body);
6598 slurp_ia64_unwind_table (FILE * file,
6599 struct ia64_unw_aux_info * aux,
6600 Elf_Internal_Shdr * sec)
6602 unsigned long size, nrelas, i;
6603 Elf_Internal_Phdr * seg;
6604 struct ia64_unw_table_entry * tep;
6605 Elf_Internal_Shdr * relsec;
6606 Elf_Internal_Rela * rela;
6607 Elf_Internal_Rela * rp;
6608 unsigned char * table;
6610 Elf_Internal_Sym * sym;
6611 const char * relname;
6615 /* First, find the starting address of the segment that includes
6618 if (elf_header.e_phnum)
6620 if (! get_program_headers (file))
6623 for (seg = program_headers;
6624 seg < program_headers + elf_header.e_phnum;
6627 if (seg->p_type != PT_LOAD)
6630 if (sec->sh_addr >= seg->p_vaddr
6631 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
6633 aux->seg_base = seg->p_vaddr;
6639 /* Second, build the unwind table from the contents of the unwind section: */
6640 size = sec->sh_size;
6641 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
6646 aux->table_len = size / (3 * eh_addr_size);
6647 aux->table = (struct ia64_unw_table_entry *)
6648 xcmalloc (aux->table_len, sizeof (aux->table[0]));
6651 for (tp = table; tp <= table + size - (3 * eh_addr_size); ++tep)
6653 tep->start.section = SHN_UNDEF;
6654 tep->end.section = SHN_UNDEF;
6655 tep->info.section = SHN_UNDEF;
6656 tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6657 tep->end.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6658 tep->info.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6659 tep->start.offset += aux->seg_base;
6660 tep->end.offset += aux->seg_base;
6661 tep->info.offset += aux->seg_base;
6665 /* Third, apply any relocations to the unwind table: */
6666 for (relsec = section_headers;
6667 relsec < section_headers + elf_header.e_shnum;
6670 if (relsec->sh_type != SHT_RELA
6671 || relsec->sh_info >= elf_header.e_shnum
6672 || section_headers + relsec->sh_info != sec)
6675 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6684 for (rp = rela; rp < rela + nrelas; ++rp)
6686 relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
6687 sym = aux->symtab + get_reloc_symindex (rp->r_info);
6689 /* PR 17531: file: 9fa67536. */
6690 if (relname == NULL)
6692 warn (_("Skipping unknown relocation type: %u\n"), get_reloc_type (rp->r_info));
6696 if (! const_strneq (relname, "R_IA64_SEGREL"))
6698 warn (_("Skipping unexpected relocation type: %s\n"), relname);
6702 i = rp->r_offset / (3 * eh_addr_size);
6704 /* PR 17531: file: 5bc8d9bf. */
6705 if (i >= aux->table_len)
6707 warn (_("Skipping reloc with overlarge offset: %lx\n"), i);
6711 switch (rp->r_offset / eh_addr_size % 3)
6714 aux->table[i].start.section = sym->st_shndx;
6715 aux->table[i].start.offset = rp->r_addend + sym->st_value;
6718 aux->table[i].end.section = sym->st_shndx;
6719 aux->table[i].end.offset = rp->r_addend + sym->st_value;
6722 aux->table[i].info.section = sym->st_shndx;
6723 aux->table[i].info.offset = rp->r_addend + sym->st_value;
6737 ia64_process_unwind (FILE * file)
6739 Elf_Internal_Shdr * sec;
6740 Elf_Internal_Shdr * unwsec = NULL;
6741 Elf_Internal_Shdr * strsec;
6742 unsigned long i, unwcount = 0, unwstart = 0;
6743 struct ia64_unw_aux_info aux;
6745 memset (& aux, 0, sizeof (aux));
6747 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6749 if (sec->sh_type == SHT_SYMTAB
6750 && sec->sh_link < elf_header.e_shnum)
6752 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
6754 strsec = section_headers + sec->sh_link;
6755 if (aux.strtab != NULL)
6757 error (_("Multiple auxillary string tables encountered\n"));
6760 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6763 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
6765 else if (sec->sh_type == SHT_IA_64_UNWIND)
6770 printf (_("\nThere are no unwind sections in this file.\n"));
6772 while (unwcount-- > 0)
6777 for (i = unwstart, sec = section_headers + unwstart, unwsec = NULL;
6778 i < elf_header.e_shnum; ++i, ++sec)
6779 if (sec->sh_type == SHT_IA_64_UNWIND)
6784 /* We have already counted the number of SHT_IA64_UNWIND
6785 sections so the loop above should never fail. */
6786 assert (unwsec != NULL);
6789 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
6791 if ((unwsec->sh_flags & SHF_GROUP) != 0)
6793 /* We need to find which section group it is in. */
6794 struct group_list * g;
6796 if (section_headers_groups == NULL
6797 || section_headers_groups [i] == NULL)
6798 i = elf_header.e_shnum;
6801 g = section_headers_groups [i]->root;
6803 for (; g != NULL; g = g->next)
6805 sec = section_headers + g->section_index;
6807 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
6812 i = elf_header.e_shnum;
6815 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
6817 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
6818 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
6819 suffix = SECTION_NAME (unwsec) + len;
6820 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6822 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
6823 && streq (SECTION_NAME (sec) + len2, suffix))
6828 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
6829 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
6830 len = sizeof (ELF_STRING_ia64_unwind) - 1;
6831 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
6833 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
6834 suffix = SECTION_NAME (unwsec) + len;
6835 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6837 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
6838 && streq (SECTION_NAME (sec) + len2, suffix))
6842 if (i == elf_header.e_shnum)
6844 printf (_("\nCould not find unwind info section for "));
6846 if (string_table == NULL)
6847 printf ("%d", unwsec->sh_name);
6849 printf ("'%s'", printable_section_name (unwsec));
6853 aux.info_addr = sec->sh_addr;
6854 aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
6857 aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
6859 printf (_("\nUnwind section "));
6861 if (string_table == NULL)
6862 printf ("%d", unwsec->sh_name);
6864 printf ("'%s'", printable_section_name (unwsec));
6866 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6867 (unsigned long) unwsec->sh_offset,
6868 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
6870 if (slurp_ia64_unwind_table (file, & aux, unwsec)
6871 && aux.table_len > 0)
6872 dump_ia64_unwind (& aux);
6875 free ((char *) aux.table);
6877 free ((char *) aux.info);
6886 free ((char *) aux.strtab);
6889 struct hppa_unw_table_entry
6891 struct absaddr start;
6893 unsigned int Cannot_unwind:1; /* 0 */
6894 unsigned int Millicode:1; /* 1 */
6895 unsigned int Millicode_save_sr0:1; /* 2 */
6896 unsigned int Region_description:2; /* 3..4 */
6897 unsigned int reserved1:1; /* 5 */
6898 unsigned int Entry_SR:1; /* 6 */
6899 unsigned int Entry_FR:4; /* number saved */ /* 7..10 */
6900 unsigned int Entry_GR:5; /* number saved */ /* 11..15 */
6901 unsigned int Args_stored:1; /* 16 */
6902 unsigned int Variable_Frame:1; /* 17 */
6903 unsigned int Separate_Package_Body:1; /* 18 */
6904 unsigned int Frame_Extension_Millicode:1; /* 19 */
6905 unsigned int Stack_Overflow_Check:1; /* 20 */
6906 unsigned int Two_Instruction_SP_Increment:1; /* 21 */
6907 unsigned int Ada_Region:1; /* 22 */
6908 unsigned int cxx_info:1; /* 23 */
6909 unsigned int cxx_try_catch:1; /* 24 */
6910 unsigned int sched_entry_seq:1; /* 25 */
6911 unsigned int reserved2:1; /* 26 */
6912 unsigned int Save_SP:1; /* 27 */
6913 unsigned int Save_RP:1; /* 28 */
6914 unsigned int Save_MRP_in_frame:1; /* 29 */
6915 unsigned int extn_ptr_defined:1; /* 30 */
6916 unsigned int Cleanup_defined:1; /* 31 */
6918 unsigned int MPE_XL_interrupt_marker:1; /* 0 */
6919 unsigned int HP_UX_interrupt_marker:1; /* 1 */
6920 unsigned int Large_frame:1; /* 2 */
6921 unsigned int Pseudo_SP_Set:1; /* 3 */
6922 unsigned int reserved4:1; /* 4 */
6923 unsigned int Total_frame_size:27; /* 5..31 */
6926 struct hppa_unw_aux_info
6928 struct hppa_unw_table_entry *table; /* Unwind table. */
6929 unsigned long table_len; /* Length of unwind table. */
6930 bfd_vma seg_base; /* Starting address of segment. */
6931 Elf_Internal_Sym * symtab; /* The symbol table. */
6932 unsigned long nsyms; /* Number of symbols. */
6933 char * strtab; /* The string table. */
6934 unsigned long strtab_size; /* Size of string table. */
6938 dump_hppa_unwind (struct hppa_unw_aux_info * aux)
6940 struct hppa_unw_table_entry * tp;
6942 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
6945 const char * procname;
6947 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6948 aux->strtab_size, tp->start, &procname,
6951 fputs ("\n<", stdout);
6955 fputs (procname, stdout);
6958 printf ("+%lx", (unsigned long) offset);
6961 fputs (">: [", stdout);
6962 print_vma (tp->start.offset, PREFIX_HEX);
6963 fputc ('-', stdout);
6964 print_vma (tp->end.offset, PREFIX_HEX);
6967 #define PF(_m) if (tp->_m) printf (#_m " ");
6968 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
6971 PF(Millicode_save_sr0);
6972 /* PV(Region_description); */
6978 PF(Separate_Package_Body);
6979 PF(Frame_Extension_Millicode);
6980 PF(Stack_Overflow_Check);
6981 PF(Two_Instruction_SP_Increment);
6985 PF(sched_entry_seq);
6988 PF(Save_MRP_in_frame);
6989 PF(extn_ptr_defined);
6990 PF(Cleanup_defined);
6991 PF(MPE_XL_interrupt_marker);
6992 PF(HP_UX_interrupt_marker);
6995 PV(Total_frame_size);
7004 slurp_hppa_unwind_table (FILE * file,
7005 struct hppa_unw_aux_info * aux,
7006 Elf_Internal_Shdr * sec)
7008 unsigned long size, unw_ent_size, nentries, nrelas, i;
7009 Elf_Internal_Phdr * seg;
7010 struct hppa_unw_table_entry * tep;
7011 Elf_Internal_Shdr * relsec;
7012 Elf_Internal_Rela * rela;
7013 Elf_Internal_Rela * rp;
7014 unsigned char * table;
7016 Elf_Internal_Sym * sym;
7017 const char * relname;
7019 /* First, find the starting address of the segment that includes
7022 if (elf_header.e_phnum)
7024 if (! get_program_headers (file))
7027 for (seg = program_headers;
7028 seg < program_headers + elf_header.e_phnum;
7031 if (seg->p_type != PT_LOAD)
7034 if (sec->sh_addr >= seg->p_vaddr
7035 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
7037 aux->seg_base = seg->p_vaddr;
7043 /* Second, build the unwind table from the contents of the unwind
7045 size = sec->sh_size;
7046 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
7052 nentries = size / unw_ent_size;
7053 size = unw_ent_size * nentries;
7055 tep = aux->table = (struct hppa_unw_table_entry *)
7056 xcmalloc (nentries, sizeof (aux->table[0]));
7058 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
7060 unsigned int tmp1, tmp2;
7062 tep->start.section = SHN_UNDEF;
7063 tep->end.section = SHN_UNDEF;
7065 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
7066 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
7067 tmp1 = byte_get ((unsigned char *) tp + 8, 4);
7068 tmp2 = byte_get ((unsigned char *) tp + 12, 4);
7070 tep->start.offset += aux->seg_base;
7071 tep->end.offset += aux->seg_base;
7073 tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
7074 tep->Millicode = (tmp1 >> 30) & 0x1;
7075 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
7076 tep->Region_description = (tmp1 >> 27) & 0x3;
7077 tep->reserved1 = (tmp1 >> 26) & 0x1;
7078 tep->Entry_SR = (tmp1 >> 25) & 0x1;
7079 tep->Entry_FR = (tmp1 >> 21) & 0xf;
7080 tep->Entry_GR = (tmp1 >> 16) & 0x1f;
7081 tep->Args_stored = (tmp1 >> 15) & 0x1;
7082 tep->Variable_Frame = (tmp1 >> 14) & 0x1;
7083 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
7084 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
7085 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
7086 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
7087 tep->Ada_Region = (tmp1 >> 9) & 0x1;
7088 tep->cxx_info = (tmp1 >> 8) & 0x1;
7089 tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
7090 tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
7091 tep->reserved2 = (tmp1 >> 5) & 0x1;
7092 tep->Save_SP = (tmp1 >> 4) & 0x1;
7093 tep->Save_RP = (tmp1 >> 3) & 0x1;
7094 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
7095 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
7096 tep->Cleanup_defined = tmp1 & 0x1;
7098 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
7099 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
7100 tep->Large_frame = (tmp2 >> 29) & 0x1;
7101 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
7102 tep->reserved4 = (tmp2 >> 27) & 0x1;
7103 tep->Total_frame_size = tmp2 & 0x7ffffff;
7107 /* Third, apply any relocations to the unwind table. */
7108 for (relsec = section_headers;
7109 relsec < section_headers + elf_header.e_shnum;
7112 if (relsec->sh_type != SHT_RELA
7113 || relsec->sh_info >= elf_header.e_shnum
7114 || section_headers + relsec->sh_info != sec)
7117 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
7121 for (rp = rela; rp < rela + nrelas; ++rp)
7123 relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
7124 sym = aux->symtab + get_reloc_symindex (rp->r_info);
7126 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
7127 if (! const_strneq (relname, "R_PARISC_SEGREL"))
7129 warn (_("Skipping unexpected relocation type %s\n"), relname);
7133 i = rp->r_offset / unw_ent_size;
7135 switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
7138 aux->table[i].start.section = sym->st_shndx;
7139 aux->table[i].start.offset = sym->st_value + rp->r_addend;
7142 aux->table[i].end.section = sym->st_shndx;
7143 aux->table[i].end.offset = sym->st_value + rp->r_addend;
7153 aux->table_len = nentries;
7159 hppa_process_unwind (FILE * file)
7161 struct hppa_unw_aux_info aux;
7162 Elf_Internal_Shdr * unwsec = NULL;
7163 Elf_Internal_Shdr * strsec;
7164 Elf_Internal_Shdr * sec;
7167 if (string_table == NULL)
7170 memset (& aux, 0, sizeof (aux));
7172 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7174 if (sec->sh_type == SHT_SYMTAB
7175 && sec->sh_link < elf_header.e_shnum)
7177 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
7179 strsec = section_headers + sec->sh_link;
7180 if (aux.strtab != NULL)
7182 error (_("Multiple auxillary string tables encountered\n"));
7185 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
7188 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7190 else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
7195 printf (_("\nThere are no unwind sections in this file.\n"));
7197 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7199 if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
7201 printf (_("\nUnwind section '%s' at offset 0x%lx contains %lu entries:\n"),
7202 printable_section_name (sec),
7203 (unsigned long) sec->sh_offset,
7204 (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
7206 slurp_hppa_unwind_table (file, &aux, sec);
7207 if (aux.table_len > 0)
7208 dump_hppa_unwind (&aux);
7211 free ((char *) aux.table);
7219 free ((char *) aux.strtab);
7224 unsigned char * data; /* The unwind data. */
7225 Elf_Internal_Shdr * sec; /* The cached unwind section header. */
7226 Elf_Internal_Rela * rela; /* The cached relocations for this section. */
7227 unsigned long nrelas; /* The number of relocations. */
7228 unsigned int rel_type; /* REL or RELA ? */
7229 Elf_Internal_Rela * next_rela; /* Cyclic pointer to the next reloc to process. */
7232 struct arm_unw_aux_info
7234 FILE * file; /* The file containing the unwind sections. */
7235 Elf_Internal_Sym * symtab; /* The file's symbol table. */
7236 unsigned long nsyms; /* Number of symbols. */
7237 char * strtab; /* The file's string table. */
7238 unsigned long strtab_size; /* Size of string table. */
7242 arm_print_vma_and_name (struct arm_unw_aux_info *aux,
7243 bfd_vma fn, struct absaddr addr)
7245 const char *procname;
7248 if (addr.section == SHN_UNDEF)
7251 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
7252 aux->strtab_size, addr, &procname,
7255 print_vma (fn, PREFIX_HEX);
7259 fputs (" <", stdout);
7260 fputs (procname, stdout);
7263 printf ("+0x%lx", (unsigned long) sym_offset);
7264 fputc ('>', stdout);
7271 arm_free_section (struct arm_section *arm_sec)
7273 if (arm_sec->data != NULL)
7274 free (arm_sec->data);
7276 if (arm_sec->rela != NULL)
7277 free (arm_sec->rela);
7280 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
7281 cached section and install SEC instead.
7282 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
7283 and return its valued in * WORDP, relocating if necessary.
7284 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
7285 relocation's offset in ADDR.
7286 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
7287 into the string table of the symbol associated with the reloc. If no
7288 reloc was applied store -1 there.
7289 5) Return TRUE upon success, FALSE otherwise. */
7292 get_unwind_section_word (struct arm_unw_aux_info * aux,
7293 struct arm_section * arm_sec,
7294 Elf_Internal_Shdr * sec,
7295 bfd_vma word_offset,
7296 unsigned int * wordp,
7297 struct absaddr * addr,
7300 Elf_Internal_Rela *rp;
7301 Elf_Internal_Sym *sym;
7302 const char * relname;
7304 bfd_boolean wrapped;
7306 if (sec == NULL || arm_sec == NULL)
7309 addr->section = SHN_UNDEF;
7312 if (sym_name != NULL)
7313 *sym_name = (bfd_vma) -1;
7315 /* If necessary, update the section cache. */
7316 if (sec != arm_sec->sec)
7318 Elf_Internal_Shdr *relsec;
7320 arm_free_section (arm_sec);
7323 arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
7324 sec->sh_size, _("unwind data"));
7325 arm_sec->rela = NULL;
7326 arm_sec->nrelas = 0;
7328 for (relsec = section_headers;
7329 relsec < section_headers + elf_header.e_shnum;
7332 if (relsec->sh_info >= elf_header.e_shnum
7333 || section_headers + relsec->sh_info != sec
7334 /* PR 15745: Check the section type as well. */
7335 || (relsec->sh_type != SHT_REL
7336 && relsec->sh_type != SHT_RELA))
7339 arm_sec->rel_type = relsec->sh_type;
7340 if (relsec->sh_type == SHT_REL)
7342 if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
7344 & arm_sec->rela, & arm_sec->nrelas))
7347 else /* relsec->sh_type == SHT_RELA */
7349 if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
7351 & arm_sec->rela, & arm_sec->nrelas))
7357 arm_sec->next_rela = arm_sec->rela;
7360 /* If there is no unwind data we can do nothing. */
7361 if (arm_sec->data == NULL)
7364 /* If the offset is invalid then fail. */
7365 if (word_offset > sec->sh_size - 4)
7368 /* Get the word at the required offset. */
7369 word = byte_get (arm_sec->data + word_offset, 4);
7371 /* PR 17531: file: id:000001,src:001266+003044,op:splice,rep:128. */
7372 if (arm_sec->rela == NULL)
7378 /* Look through the relocs to find the one that applies to the provided offset. */
7380 for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
7382 bfd_vma prelval, offset;
7384 if (rp->r_offset > word_offset && !wrapped)
7389 if (rp->r_offset > word_offset)
7392 if (rp->r_offset & 3)
7394 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
7395 (unsigned long) rp->r_offset);
7399 if (rp->r_offset < word_offset)
7402 /* PR 17531: file: 027-161405-0.004 */
7403 if (aux->symtab == NULL)
7406 if (arm_sec->rel_type == SHT_REL)
7408 offset = word & 0x7fffffff;
7409 if (offset & 0x40000000)
7410 offset |= ~ (bfd_vma) 0x7fffffff;
7412 else if (arm_sec->rel_type == SHT_RELA)
7413 offset = rp->r_addend;
7416 error (_("Unknown section relocation type %d encountered\n"),
7421 /* PR 17531 file: 027-1241568-0.004. */
7422 if (ELF32_R_SYM (rp->r_info) >= aux->nsyms)
7424 error (_("Bad symbol index in unwind relocation (%lu > %lu)\n"),
7425 (unsigned long) ELF32_R_SYM (rp->r_info), aux->nsyms);
7429 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
7430 offset += sym->st_value;
7431 prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
7433 /* Check that we are processing the expected reloc type. */
7434 if (elf_header.e_machine == EM_ARM)
7436 relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
7437 if (relname == NULL)
7439 warn (_("Skipping unknown ARM relocation type: %d\n"),
7440 (int) ELF32_R_TYPE (rp->r_info));
7444 if (streq (relname, "R_ARM_NONE"))
7447 if (! streq (relname, "R_ARM_PREL31"))
7449 warn (_("Skipping unexpected ARM relocation type %s\n"), relname);
7453 else if (elf_header.e_machine == EM_TI_C6000)
7455 relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
7456 if (relname == NULL)
7458 warn (_("Skipping unknown C6000 relocation type: %d\n"),
7459 (int) ELF32_R_TYPE (rp->r_info));
7463 if (streq (relname, "R_C6000_NONE"))
7466 if (! streq (relname, "R_C6000_PREL31"))
7468 warn (_("Skipping unexpected C6000 relocation type %s\n"), relname);
7476 /* This function currently only supports ARM and TI unwinders. */
7477 warn (_("Only TI and ARM unwinders are currently supported\n"));
7481 word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
7482 addr->section = sym->st_shndx;
7483 addr->offset = offset;
7486 * sym_name = sym->st_name;
7491 arm_sec->next_rela = rp;
7496 static const char *tic6x_unwind_regnames[16] =
7498 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
7499 "A14", "A13", "A12", "A11", "A10",
7500 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
7504 decode_tic6x_unwind_regmask (unsigned int mask)
7508 for (i = 12; mask; mask >>= 1, i--)
7512 fputs (tic6x_unwind_regnames[i], stdout);
7514 fputs (", ", stdout);
7520 if (remaining == 0 && more_words) \
7523 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
7524 data_offset, & word, & addr, NULL)) \
7530 #define GET_OP(OP) \
7535 (OP) = word >> 24; \
7540 printf (_("[Truncated opcode]\n")); \
7543 printf ("0x%02x ", OP)
7546 decode_arm_unwind_bytecode (struct arm_unw_aux_info *aux,
7547 unsigned int word, unsigned int remaining,
7548 unsigned int more_words,
7549 bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
7550 struct arm_section *data_arm_sec)
7552 struct absaddr addr;
7554 /* Decode the unwinding instructions. */
7557 unsigned int op, op2;
7566 printf (" 0x%02x ", op);
7568 if ((op & 0xc0) == 0x00)
7570 int offset = ((op & 0x3f) << 2) + 4;
7572 printf (" vsp = vsp + %d", offset);
7574 else if ((op & 0xc0) == 0x40)
7576 int offset = ((op & 0x3f) << 2) + 4;
7578 printf (" vsp = vsp - %d", offset);
7580 else if ((op & 0xf0) == 0x80)
7583 if (op == 0x80 && op2 == 0)
7584 printf (_("Refuse to unwind"));
7587 unsigned int mask = ((op & 0x0f) << 8) | op2;
7592 for (i = 0; i < 12; i++)
7593 if (mask & (1 << i))
7599 printf ("r%d", 4 + i);
7604 else if ((op & 0xf0) == 0x90)
7606 if (op == 0x9d || op == 0x9f)
7607 printf (_(" [Reserved]"));
7609 printf (" vsp = r%d", op & 0x0f);
7611 else if ((op & 0xf0) == 0xa0)
7613 int end = 4 + (op & 0x07);
7618 for (i = 4; i <= end; i++)
7634 else if (op == 0xb0)
7635 printf (_(" finish"));
7636 else if (op == 0xb1)
7639 if (op2 == 0 || (op2 & 0xf0) != 0)
7640 printf (_("[Spare]"));
7643 unsigned int mask = op2 & 0x0f;
7648 for (i = 0; i < 12; i++)
7649 if (mask & (1 << i))
7660 else if (op == 0xb2)
7662 unsigned char buf[9];
7663 unsigned int i, len;
7664 unsigned long offset;
7666 for (i = 0; i < sizeof (buf); i++)
7669 if ((buf[i] & 0x80) == 0)
7672 if (i == sizeof (buf))
7673 printf (_("corrupt change to vsp"));
7676 offset = read_uleb128 (buf, &len, buf + i + 1);
7677 assert (len == i + 1);
7678 offset = offset * 4 + 0x204;
7679 printf ("vsp = vsp + %ld", offset);
7682 else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
7684 unsigned int first, last;
7691 printf ("pop {D%d", first);
7693 printf ("-D%d", first + last);
7696 else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
7698 unsigned int count = op & 0x07;
7702 printf ("-D%d", 8 + count);
7705 else if (op >= 0xc0 && op <= 0xc5)
7707 unsigned int count = op & 0x07;
7709 printf (" pop {wR10");
7711 printf ("-wR%d", 10 + count);
7714 else if (op == 0xc6)
7716 unsigned int first, last;
7721 printf ("pop {wR%d", first);
7723 printf ("-wR%d", first + last);
7726 else if (op == 0xc7)
7729 if (op2 == 0 || (op2 & 0xf0) != 0)
7730 printf (_("[Spare]"));
7733 unsigned int mask = op2 & 0x0f;
7738 for (i = 0; i < 4; i++)
7739 if (mask & (1 << i))
7745 printf ("wCGR%d", i);
7751 printf (_(" [unsupported opcode]"));
7757 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info *aux,
7758 unsigned int word, unsigned int remaining,
7759 unsigned int more_words,
7760 bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
7761 struct arm_section *data_arm_sec)
7763 struct absaddr addr;
7765 /* Decode the unwinding instructions. */
7768 unsigned int op, op2;
7777 printf (" 0x%02x ", op);
7779 if ((op & 0xc0) == 0x00)
7781 int offset = ((op & 0x3f) << 3) + 8;
7782 printf (" sp = sp + %d", offset);
7784 else if ((op & 0xc0) == 0x80)
7787 if (op == 0x80 && op2 == 0)
7788 printf (_("Refuse to unwind"));
7791 unsigned int mask = ((op & 0x1f) << 8) | op2;
7793 printf ("pop compact {");
7797 decode_tic6x_unwind_regmask (mask);
7801 else if ((op & 0xf0) == 0xc0)
7809 unsigned int offset;
7813 /* Scan entire instruction first so that GET_OP output is not
7814 interleaved with disassembly. */
7816 for (i = 0; nregs < (op & 0xf); i++)
7822 regpos[nregs].offset = i * 2;
7823 regpos[nregs].reg = reg;
7830 regpos[nregs].offset = i * 2 + 1;
7831 regpos[nregs].reg = reg;
7836 printf (_("pop frame {"));
7838 for (i = i * 2; i > 0; i--)
7840 if (regpos[reg].offset == i - 1)
7842 name = tic6x_unwind_regnames[regpos[reg].reg];
7849 fputs (name, stdout);
7856 else if (op == 0xd0)
7857 printf (" MOV FP, SP");
7858 else if (op == 0xd1)
7859 printf (" __c6xabi_pop_rts");
7860 else if (op == 0xd2)
7862 unsigned char buf[9];
7863 unsigned int i, len;
7864 unsigned long offset;
7866 for (i = 0; i < sizeof (buf); i++)
7869 if ((buf[i] & 0x80) == 0)
7872 /* PR 17531: file: id:000001,src:001906+004739,op:splice,rep:2. */
7873 if (i == sizeof (buf))
7875 printf ("<corrupt sp adjust>\n");
7876 warn (_("Corrupt stack pointer adjustment detected\n"));
7880 offset = read_uleb128 (buf, &len, buf + i + 1);
7881 assert (len == i + 1);
7882 offset = offset * 8 + 0x408;
7883 printf (_("sp = sp + %ld"), offset);
7885 else if ((op & 0xf0) == 0xe0)
7887 if ((op & 0x0f) == 7)
7890 printf (" MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
7894 printf (_(" [unsupported opcode]"));
7901 arm_expand_prel31 (bfd_vma word, bfd_vma where)
7905 offset = word & 0x7fffffff;
7906 if (offset & 0x40000000)
7907 offset |= ~ (bfd_vma) 0x7fffffff;
7909 if (elf_header.e_machine == EM_TI_C6000)
7912 return offset + where;
7916 decode_arm_unwind (struct arm_unw_aux_info * aux,
7918 unsigned int remaining,
7919 bfd_vma data_offset,
7920 Elf_Internal_Shdr * data_sec,
7921 struct arm_section * data_arm_sec)
7924 unsigned int more_words = 0;
7925 struct absaddr addr;
7926 bfd_vma sym_name = (bfd_vma) -1;
7930 /* Fetch the first word.
7931 Note - when decoding an object file the address extracted
7932 here will always be 0. So we also pass in the sym_name
7933 parameter so that we can find the symbol associated with
7934 the personality routine. */
7935 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, data_offset,
7936 & word, & addr, & sym_name))
7942 if ((word & 0x80000000) == 0)
7944 /* Expand prel31 for personality routine. */
7946 const char *procname;
7948 fn = arm_expand_prel31 (word, data_sec->sh_addr + data_offset);
7949 printf (_(" Personality routine: "));
7951 && addr.section == SHN_UNDEF && addr.offset == 0
7952 && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
7954 procname = aux->strtab + sym_name;
7955 print_vma (fn, PREFIX_HEX);
7958 fputs (" <", stdout);
7959 fputs (procname, stdout);
7960 fputc ('>', stdout);
7964 procname = arm_print_vma_and_name (aux, fn, addr);
7965 fputc ('\n', stdout);
7967 /* The GCC personality routines use the standard compact
7968 encoding, starting with one byte giving the number of
7970 if (procname != NULL
7971 && (const_strneq (procname, "__gcc_personality_v0")
7972 || const_strneq (procname, "__gxx_personality_v0")
7973 || const_strneq (procname, "__gcj_personality_v0")
7974 || const_strneq (procname, "__gnu_objc_personality_v0")))
7981 printf (_(" [Truncated data]\n"));
7984 more_words = word >> 24;
7994 /* ARM EHABI Section 6.3:
7996 An exception-handling table entry for the compact model looks like:
8000 1 0 index Data for personalityRoutine[index] */
8002 if (elf_header.e_machine == EM_ARM
8003 && (word & 0x70000000))
8004 warn (_("Corrupt ARM compact model table entry: %x \n"), word);
8006 per_index = (word >> 24) & 0x7f;
8007 printf (_(" Compact model index: %d\n"), per_index);
8014 else if (per_index < 3)
8016 more_words = (word >> 16) & 0xff;
8022 switch (elf_header.e_machine)
8027 decode_arm_unwind_bytecode (aux, word, remaining, more_words,
8028 data_offset, data_sec, data_arm_sec);
8032 warn (_("Unknown ARM compact model index encountered\n"));
8033 printf (_(" [reserved]\n"));
8040 decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
8041 data_offset, data_sec, data_arm_sec);
8043 else if (per_index < 5)
8045 if (((word >> 17) & 0x7f) == 0x7f)
8046 printf (_(" Restore stack from frame pointer\n"));
8048 printf (_(" Stack increment %d\n"), (word >> 14) & 0x1fc);
8049 printf (_(" Registers restored: "));
8051 printf (" (compact) ");
8052 decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
8054 printf (_(" Return register: %s\n"),
8055 tic6x_unwind_regnames[word & 0xf]);
8058 printf (_(" [reserved (%d)]\n"), per_index);
8062 error (_("Unsupported architecture type %d encountered when decoding unwind table\n"),
8063 elf_header.e_machine);
8066 /* Decode the descriptors. Not implemented. */
8070 dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
8072 struct arm_section exidx_arm_sec, extab_arm_sec;
8073 unsigned int i, exidx_len;
8075 memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
8076 memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
8077 exidx_len = exidx_sec->sh_size / 8;
8079 for (i = 0; i < exidx_len; i++)
8081 unsigned int exidx_fn, exidx_entry;
8082 struct absaddr fn_addr, entry_addr;
8085 fputc ('\n', stdout);
8087 if (! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8088 8 * i, & exidx_fn, & fn_addr, NULL)
8089 || ! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
8090 8 * i + 4, & exidx_entry, & entry_addr, NULL))
8092 arm_free_section (& exidx_arm_sec);
8093 arm_free_section (& extab_arm_sec);
8097 /* ARM EHABI, Section 5:
8098 An index table entry consists of 2 words.
8099 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
8100 if (exidx_fn & 0x80000000)
8101 warn (_("corrupt index table entry: %x\n"), exidx_fn);
8103 fn = arm_expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
8105 arm_print_vma_and_name (aux, fn, fn_addr);
8106 fputs (": ", stdout);
8108 if (exidx_entry == 1)
8110 print_vma (exidx_entry, PREFIX_HEX);
8111 fputs (" [cantunwind]\n", stdout);
8113 else if (exidx_entry & 0x80000000)
8115 print_vma (exidx_entry, PREFIX_HEX);
8116 fputc ('\n', stdout);
8117 decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
8121 bfd_vma table, table_offset = 0;
8122 Elf_Internal_Shdr *table_sec;
8124 fputs ("@", stdout);
8125 table = arm_expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
8126 print_vma (table, PREFIX_HEX);
8129 /* Locate the matching .ARM.extab. */
8130 if (entry_addr.section != SHN_UNDEF
8131 && entry_addr.section < elf_header.e_shnum)
8133 table_sec = section_headers + entry_addr.section;
8134 table_offset = entry_addr.offset;
8138 table_sec = find_section_by_address (table);
8139 if (table_sec != NULL)
8140 table_offset = table - table_sec->sh_addr;
8142 if (table_sec == NULL)
8144 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
8145 (unsigned long) table);
8148 decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
8155 arm_free_section (&exidx_arm_sec);
8156 arm_free_section (&extab_arm_sec);
8159 /* Used for both ARM and C6X unwinding tables. */
8162 arm_process_unwind (FILE *file)
8164 struct arm_unw_aux_info aux;
8165 Elf_Internal_Shdr *unwsec = NULL;
8166 Elf_Internal_Shdr *strsec;
8167 Elf_Internal_Shdr *sec;
8169 unsigned int sec_type;
8171 switch (elf_header.e_machine)
8174 sec_type = SHT_ARM_EXIDX;
8178 sec_type = SHT_C6000_UNWIND;
8182 error (_("Unsupported architecture type %d encountered when processing unwind table\n"),
8183 elf_header.e_machine);
8187 if (string_table == NULL)
8190 memset (& aux, 0, sizeof (aux));
8193 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
8195 if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
8197 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
8199 strsec = section_headers + sec->sh_link;
8201 /* PR binutils/17531 file: 011-12666-0.004. */
8202 if (aux.strtab != NULL)
8204 error (_("Multiple string tables found in file.\n"));
8207 aux.strtab = get_data (NULL, file, strsec->sh_offset,
8208 1, strsec->sh_size, _("string table"));
8209 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
8211 else if (sec->sh_type == sec_type)
8216 printf (_("\nThere are no unwind sections in this file.\n"));
8218 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
8220 if (sec->sh_type == sec_type)
8222 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
8223 printable_section_name (sec),
8224 (unsigned long) sec->sh_offset,
8225 (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
8227 dump_arm_unwind (&aux, sec);
8234 free ((char *) aux.strtab);
8238 process_unwind (FILE * file)
8240 struct unwind_handler
8243 void (* handler)(FILE *);
8246 { EM_ARM, arm_process_unwind },
8247 { EM_IA_64, ia64_process_unwind },
8248 { EM_PARISC, hppa_process_unwind },
8249 { EM_TI_C6000, arm_process_unwind },
8257 for (i = 0; handlers[i].handler != NULL; i++)
8258 if (elf_header.e_machine == handlers[i].machtype)
8260 handlers[i].handler (file);
8264 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
8265 get_machine_name (elf_header.e_machine));
8269 dynamic_section_mips_val (Elf_Internal_Dyn * entry)
8271 switch (entry->d_tag)
8274 if (entry->d_un.d_val == 0)
8278 static const char * opts[] =
8280 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
8281 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
8282 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
8283 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
8289 for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
8290 if (entry->d_un.d_val & (1 << cnt))
8292 printf ("%s%s", first ? "" : " ", opts[cnt]);
8298 case DT_MIPS_IVERSION:
8299 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
8300 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
8304 sprintf_vma (buf, entry->d_un.d_ptr);
8305 /* Note: coded this way so that there is a single string for translation. */
8306 printf (_("<corrupt: %s>"), buf);
8310 case DT_MIPS_TIME_STAMP:
8314 time_t atime = entry->d_un.d_val;
8316 tmp = gmtime (&atime);
8317 /* PR 17531: file: 6accc532. */
8319 snprintf (timebuf, sizeof (timebuf), _("<corrupt>"));
8321 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
8322 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
8323 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
8324 printf (_("Time Stamp: %s"), timebuf);
8328 case DT_MIPS_RLD_VERSION:
8329 case DT_MIPS_LOCAL_GOTNO:
8330 case DT_MIPS_CONFLICTNO:
8331 case DT_MIPS_LIBLISTNO:
8332 case DT_MIPS_SYMTABNO:
8333 case DT_MIPS_UNREFEXTNO:
8334 case DT_MIPS_HIPAGENO:
8335 case DT_MIPS_DELTA_CLASS_NO:
8336 case DT_MIPS_DELTA_INSTANCE_NO:
8337 case DT_MIPS_DELTA_RELOC_NO:
8338 case DT_MIPS_DELTA_SYM_NO:
8339 case DT_MIPS_DELTA_CLASSSYM_NO:
8340 case DT_MIPS_COMPACT_SIZE:
8341 print_vma (entry->d_un.d_ptr, DEC);
8345 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8351 dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
8353 switch (entry->d_tag)
8355 case DT_HP_DLD_FLAGS:
8364 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
8365 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
8366 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
8367 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
8368 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
8369 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
8370 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
8371 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
8372 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
8373 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
8374 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
8375 { DT_HP_GST, "HP_GST" },
8376 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
8377 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
8378 { DT_HP_NODELETE, "HP_NODELETE" },
8379 { DT_HP_GROUP, "HP_GROUP" },
8380 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
8384 bfd_vma val = entry->d_un.d_val;
8386 for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
8387 if (val & flags[cnt].bit)
8391 fputs (flags[cnt].str, stdout);
8393 val ^= flags[cnt].bit;
8396 if (val != 0 || first)
8400 print_vma (val, HEX);
8406 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8414 /* VMS vs Unix time offset and factor. */
8416 #define VMS_EPOCH_OFFSET 35067168000000000LL
8417 #define VMS_GRANULARITY_FACTOR 10000000
8419 /* Display a VMS time in a human readable format. */
8422 print_vms_time (bfd_int64_t vmstime)
8427 unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
8428 tm = gmtime (&unxtime);
8429 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
8430 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
8431 tm->tm_hour, tm->tm_min, tm->tm_sec);
8436 dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
8438 switch (entry->d_tag)
8440 case DT_IA_64_PLT_RESERVE:
8441 /* First 3 slots reserved. */
8442 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8444 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
8447 case DT_IA_64_VMS_LINKTIME:
8449 print_vms_time (entry->d_un.d_val);
8453 case DT_IA_64_VMS_LNKFLAGS:
8454 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8455 if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
8456 printf (" CALL_DEBUG");
8457 if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
8458 printf (" NOP0BUFS");
8459 if (entry->d_un.d_val & VMS_LF_P0IMAGE)
8460 printf (" P0IMAGE");
8461 if (entry->d_un.d_val & VMS_LF_MKTHREADS)
8462 printf (" MKTHREADS");
8463 if (entry->d_un.d_val & VMS_LF_UPCALLS)
8464 printf (" UPCALLS");
8465 if (entry->d_un.d_val & VMS_LF_IMGSTA)
8467 if (entry->d_un.d_val & VMS_LF_INITIALIZE)
8468 printf (" INITIALIZE");
8469 if (entry->d_un.d_val & VMS_LF_MAIN)
8471 if (entry->d_un.d_val & VMS_LF_EXE_INIT)
8472 printf (" EXE_INIT");
8473 if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
8474 printf (" TBK_IN_IMG");
8475 if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
8476 printf (" DBG_IN_IMG");
8477 if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
8478 printf (" TBK_IN_DSF");
8479 if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
8480 printf (" DBG_IN_DSF");
8481 if (entry->d_un.d_val & VMS_LF_SIGNATURES)
8482 printf (" SIGNATURES");
8483 if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
8484 printf (" REL_SEG_OFF");
8488 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
8495 get_32bit_dynamic_section (FILE * file)
8497 Elf32_External_Dyn * edyn;
8498 Elf32_External_Dyn * ext;
8499 Elf_Internal_Dyn * entry;
8501 edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
8502 dynamic_size, _("dynamic section"));
8506 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8507 might not have the luxury of section headers. Look for the DT_NULL
8508 terminator to determine the number of entries. */
8509 for (ext = edyn, dynamic_nent = 0;
8510 (char *) ext < (char *) edyn + dynamic_size - sizeof (* entry);
8514 if (BYTE_GET (ext->d_tag) == DT_NULL)
8518 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
8520 if (dynamic_section == NULL)
8522 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8523 (unsigned long) dynamic_nent);
8528 for (ext = edyn, entry = dynamic_section;
8529 entry < dynamic_section + dynamic_nent;
8532 entry->d_tag = BYTE_GET (ext->d_tag);
8533 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
8542 get_64bit_dynamic_section (FILE * file)
8544 Elf64_External_Dyn * edyn;
8545 Elf64_External_Dyn * ext;
8546 Elf_Internal_Dyn * entry;
8548 /* Read in the data. */
8549 edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
8550 dynamic_size, _("dynamic section"));
8554 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8555 might not have the luxury of section headers. Look for the DT_NULL
8556 terminator to determine the number of entries. */
8557 for (ext = edyn, dynamic_nent = 0;
8558 /* PR 17533 file: 033-67080-0.004 - do not read off the end of the buffer. */
8559 (char *) ext < ((char *) edyn) + dynamic_size - sizeof (* ext);
8563 if (BYTE_GET (ext->d_tag) == DT_NULL)
8567 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
8569 if (dynamic_section == NULL)
8571 error (_("Out of memory allocating space for %lu dynamic entries\n"),
8572 (unsigned long) dynamic_nent);
8577 /* Convert from external to internal formats. */
8578 for (ext = edyn, entry = dynamic_section;
8579 entry < dynamic_section + dynamic_nent;
8582 entry->d_tag = BYTE_GET (ext->d_tag);
8583 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
8592 print_dynamic_flags (bfd_vma flags)
8600 flag = flags & - flags;
8610 case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
8611 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
8612 case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
8613 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
8614 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
8615 default: fputs (_("unknown"), stdout); break;
8621 /* Parse and display the contents of the dynamic section. */
8624 process_dynamic_section (FILE * file)
8626 Elf_Internal_Dyn * entry;
8628 if (dynamic_size == 0)
8631 printf (_("\nThere is no dynamic section in this file.\n"));
8638 if (! get_32bit_dynamic_section (file))
8641 else if (! get_64bit_dynamic_section (file))
8644 /* Find the appropriate symbol table. */
8645 if (dynamic_symbols == NULL)
8647 for (entry = dynamic_section;
8648 entry < dynamic_section + dynamic_nent;
8651 Elf_Internal_Shdr section;
8653 if (entry->d_tag != DT_SYMTAB)
8656 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
8658 /* Since we do not know how big the symbol table is,
8659 we default to reading in the entire file (!) and
8660 processing that. This is overkill, I know, but it
8662 section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
8664 if (archive_file_offset != 0)
8665 section.sh_size = archive_file_size - section.sh_offset;
8668 if (fseek (file, 0, SEEK_END))
8669 error (_("Unable to seek to end of file!\n"));
8671 section.sh_size = ftell (file) - section.sh_offset;
8675 section.sh_entsize = sizeof (Elf32_External_Sym);
8677 section.sh_entsize = sizeof (Elf64_External_Sym);
8678 section.sh_name = string_table_length;
8680 dynamic_symbols = GET_ELF_SYMBOLS (file, §ion, & num_dynamic_syms);
8681 if (num_dynamic_syms < 1)
8683 error (_("Unable to determine the number of symbols to load\n"));
8689 /* Similarly find a string table. */
8690 if (dynamic_strings == NULL)
8692 for (entry = dynamic_section;
8693 entry < dynamic_section + dynamic_nent;
8696 unsigned long offset;
8699 if (entry->d_tag != DT_STRTAB)
8702 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
8704 /* Since we do not know how big the string table is,
8705 we default to reading in the entire file (!) and
8706 processing that. This is overkill, I know, but it
8709 offset = offset_from_vma (file, entry->d_un.d_val, 0);
8711 if (archive_file_offset != 0)
8712 str_tab_len = archive_file_size - offset;
8715 if (fseek (file, 0, SEEK_END))
8716 error (_("Unable to seek to end of file\n"));
8717 str_tab_len = ftell (file) - offset;
8720 if (str_tab_len < 1)
8723 (_("Unable to determine the length of the dynamic string table\n"));
8727 dynamic_strings = (char *) get_data (NULL, file, offset, 1,
8729 _("dynamic string table"));
8730 dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
8735 /* And find the syminfo section if available. */
8736 if (dynamic_syminfo == NULL)
8738 unsigned long syminsz = 0;
8740 for (entry = dynamic_section;
8741 entry < dynamic_section + dynamic_nent;
8744 if (entry->d_tag == DT_SYMINENT)
8746 /* Note: these braces are necessary to avoid a syntax
8747 error from the SunOS4 C compiler. */
8748 /* PR binutils/17531: A corrupt file can trigger this test.
8749 So do not use an assert, instead generate an error message. */
8750 if (sizeof (Elf_External_Syminfo) != entry->d_un.d_val)
8751 error (_("Bad value (%d) for SYMINENT entry\n"),
8752 (int) entry->d_un.d_val);
8754 else if (entry->d_tag == DT_SYMINSZ)
8755 syminsz = entry->d_un.d_val;
8756 else if (entry->d_tag == DT_SYMINFO)
8757 dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
8761 if (dynamic_syminfo_offset != 0 && syminsz != 0)
8763 Elf_External_Syminfo * extsyminfo;
8764 Elf_External_Syminfo * extsym;
8765 Elf_Internal_Syminfo * syminfo;
8767 /* There is a syminfo section. Read the data. */
8768 extsyminfo = (Elf_External_Syminfo *)
8769 get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
8770 _("symbol information"));
8774 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
8775 if (dynamic_syminfo == NULL)
8777 error (_("Out of memory allocating %lu byte for dynamic symbol info\n"),
8778 (unsigned long) syminsz);
8782 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
8783 for (syminfo = dynamic_syminfo, extsym = extsyminfo;
8784 syminfo < dynamic_syminfo + dynamic_syminfo_nent;
8785 ++syminfo, ++extsym)
8787 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
8788 syminfo->si_flags = BYTE_GET (extsym->si_flags);
8795 if (do_dynamic && dynamic_addr)
8796 printf (_("\nDynamic section at offset 0x%lx contains %lu entries:\n"),
8797 dynamic_addr, (unsigned long) dynamic_nent);
8799 printf (_(" Tag Type Name/Value\n"));
8801 for (entry = dynamic_section;
8802 entry < dynamic_section + dynamic_nent;
8810 print_vma (entry->d_tag, FULL_HEX);
8811 dtype = get_dynamic_type (entry->d_tag);
8812 printf (" (%s)%*s", dtype,
8813 ((is_32bit_elf ? 27 : 19)
8814 - (int) strlen (dtype)),
8818 switch (entry->d_tag)
8822 print_dynamic_flags (entry->d_un.d_val);
8832 switch (entry->d_tag)
8835 printf (_("Auxiliary library"));
8839 printf (_("Filter library"));
8843 printf (_("Configuration file"));
8847 printf (_("Dependency audit library"));
8851 printf (_("Audit library"));
8855 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
8856 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
8860 print_vma (entry->d_un.d_val, PREFIX_HEX);
8869 printf (_("Flags:"));
8871 if (entry->d_un.d_val == 0)
8872 printf (_(" None\n"));
8875 unsigned long int val = entry->d_un.d_val;
8877 if (val & DTF_1_PARINIT)
8879 printf (" PARINIT");
8880 val ^= DTF_1_PARINIT;
8882 if (val & DTF_1_CONFEXP)
8884 printf (" CONFEXP");
8885 val ^= DTF_1_CONFEXP;
8888 printf (" %lx", val);
8897 printf (_("Flags:"));
8899 if (entry->d_un.d_val == 0)
8900 printf (_(" None\n"));
8903 unsigned long int val = entry->d_un.d_val;
8905 if (val & DF_P1_LAZYLOAD)
8907 printf (" LAZYLOAD");
8908 val ^= DF_P1_LAZYLOAD;
8910 if (val & DF_P1_GROUPPERM)
8912 printf (" GROUPPERM");
8913 val ^= DF_P1_GROUPPERM;
8916 printf (" %lx", val);
8925 printf (_("Flags:"));
8926 if (entry->d_un.d_val == 0)
8927 printf (_(" None\n"));
8930 unsigned long int val = entry->d_un.d_val;
8937 if (val & DF_1_GLOBAL)
8942 if (val & DF_1_GROUP)
8947 if (val & DF_1_NODELETE)
8949 printf (" NODELETE");
8950 val ^= DF_1_NODELETE;
8952 if (val & DF_1_LOADFLTR)
8954 printf (" LOADFLTR");
8955 val ^= DF_1_LOADFLTR;
8957 if (val & DF_1_INITFIRST)
8959 printf (" INITFIRST");
8960 val ^= DF_1_INITFIRST;
8962 if (val & DF_1_NOOPEN)
8967 if (val & DF_1_ORIGIN)
8972 if (val & DF_1_DIRECT)
8977 if (val & DF_1_TRANS)
8982 if (val & DF_1_INTERPOSE)
8984 printf (" INTERPOSE");
8985 val ^= DF_1_INTERPOSE;
8987 if (val & DF_1_NODEFLIB)
8989 printf (" NODEFLIB");
8990 val ^= DF_1_NODEFLIB;
8992 if (val & DF_1_NODUMP)
8997 if (val & DF_1_CONFALT)
8999 printf (" CONFALT");
9000 val ^= DF_1_CONFALT;
9002 if (val & DF_1_ENDFILTEE)
9004 printf (" ENDFILTEE");
9005 val ^= DF_1_ENDFILTEE;
9007 if (val & DF_1_DISPRELDNE)
9009 printf (" DISPRELDNE");
9010 val ^= DF_1_DISPRELDNE;
9012 if (val & DF_1_DISPRELPND)
9014 printf (" DISPRELPND");
9015 val ^= DF_1_DISPRELPND;
9017 if (val & DF_1_NODIRECT)
9019 printf (" NODIRECT");
9020 val ^= DF_1_NODIRECT;
9022 if (val & DF_1_IGNMULDEF)
9024 printf (" IGNMULDEF");
9025 val ^= DF_1_IGNMULDEF;
9027 if (val & DF_1_NOKSYMS)
9029 printf (" NOKSYMS");
9030 val ^= DF_1_NOKSYMS;
9032 if (val & DF_1_NOHDR)
9037 if (val & DF_1_EDITED)
9042 if (val & DF_1_NORELOC)
9044 printf (" NORELOC");
9045 val ^= DF_1_NORELOC;
9047 if (val & DF_1_SYMINTPOSE)
9049 printf (" SYMINTPOSE");
9050 val ^= DF_1_SYMINTPOSE;
9052 if (val & DF_1_GLOBAUDIT)
9054 printf (" GLOBAUDIT");
9055 val ^= DF_1_GLOBAUDIT;
9057 if (val & DF_1_SINGLETON)
9059 printf (" SINGLETON");
9060 val ^= DF_1_SINGLETON;
9063 printf (" %lx", val);
9070 dynamic_info[entry->d_tag] = entry->d_un.d_val;
9072 puts (get_dynamic_type (entry->d_un.d_val));
9092 dynamic_info[entry->d_tag] = entry->d_un.d_val;
9098 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
9099 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
9105 switch (entry->d_tag)
9108 printf (_("Shared library: [%s]"), name);
9110 if (streq (name, program_interpreter))
9111 printf (_(" program interpreter"));
9115 printf (_("Library soname: [%s]"), name);
9119 printf (_("Library rpath: [%s]"), name);
9123 printf (_("Library runpath: [%s]"), name);
9127 print_vma (entry->d_un.d_val, PREFIX_HEX);
9132 print_vma (entry->d_un.d_val, PREFIX_HEX);
9145 dynamic_info[entry->d_tag] = entry->d_un.d_val;
9149 case DT_INIT_ARRAYSZ:
9150 case DT_FINI_ARRAYSZ:
9151 case DT_GNU_CONFLICTSZ:
9152 case DT_GNU_LIBLISTSZ:
9155 print_vma (entry->d_un.d_val, UNSIGNED);
9156 printf (_(" (bytes)\n"));
9166 print_vma (entry->d_un.d_val, UNSIGNED);
9179 if (entry->d_tag == DT_USED
9180 && VALID_DYNAMIC_NAME (entry->d_un.d_val))
9182 char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
9186 printf (_("Not needed object: [%s]\n"), name);
9191 print_vma (entry->d_un.d_val, PREFIX_HEX);
9197 /* The value of this entry is ignored. */
9202 case DT_GNU_PRELINKED:
9206 time_t atime = entry->d_un.d_val;
9208 tmp = gmtime (&atime);
9209 /* PR 17533 file: 041-1244816-0.004. */
9211 printf (_("<corrupt time val: %lx"),
9212 (unsigned long) atime);
9214 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
9215 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9216 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
9222 dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
9225 print_vma (entry->d_un.d_val, PREFIX_HEX);
9231 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
9232 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
9237 switch (elf_header.e_machine)
9240 case EM_MIPS_RS3_LE:
9241 dynamic_section_mips_val (entry);
9244 dynamic_section_parisc_val (entry);
9247 dynamic_section_ia64_val (entry);
9250 print_vma (entry->d_un.d_val, PREFIX_HEX);
9262 get_ver_flags (unsigned int flags)
9264 static char buff[32];
9271 if (flags & VER_FLG_BASE)
9272 strcat (buff, "BASE ");
9274 if (flags & VER_FLG_WEAK)
9276 if (flags & VER_FLG_BASE)
9277 strcat (buff, "| ");
9279 strcat (buff, "WEAK ");
9282 if (flags & VER_FLG_INFO)
9284 if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
9285 strcat (buff, "| ");
9287 strcat (buff, "INFO ");
9290 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
9291 strcat (buff, _("| <unknown>"));
9296 /* Display the contents of the version sections. */
9299 process_version_sections (FILE * file)
9301 Elf_Internal_Shdr * section;
9308 for (i = 0, section = section_headers;
9309 i < elf_header.e_shnum;
9312 switch (section->sh_type)
9314 case SHT_GNU_verdef:
9316 Elf_External_Verdef * edefs;
9323 printf (_("\nVersion definition section '%s' contains %u entries:\n"),
9324 printable_section_name (section),
9327 printf (_(" Addr: 0x"));
9328 printf_vma (section->sh_addr);
9329 printf (_(" Offset: %#08lx Link: %u (%s)"),
9330 (unsigned long) section->sh_offset, section->sh_link,
9331 printable_section_name_from_index (section->sh_link));
9333 edefs = (Elf_External_Verdef *)
9334 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
9335 _("version definition section"));
9338 endbuf = (char *) edefs + section->sh_size;
9340 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
9343 Elf_External_Verdef * edef;
9344 Elf_Internal_Verdef ent;
9345 Elf_External_Verdaux * eaux;
9346 Elf_Internal_Verdaux aux;
9350 /* Check for very large indicies. */
9351 if (idx > (size_t) (endbuf - (char *) edefs))
9354 vstart = ((char *) edefs) + idx;
9355 if (vstart + sizeof (*edef) > endbuf)
9358 edef = (Elf_External_Verdef *) vstart;
9360 ent.vd_version = BYTE_GET (edef->vd_version);
9361 ent.vd_flags = BYTE_GET (edef->vd_flags);
9362 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
9363 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
9364 ent.vd_hash = BYTE_GET (edef->vd_hash);
9365 ent.vd_aux = BYTE_GET (edef->vd_aux);
9366 ent.vd_next = BYTE_GET (edef->vd_next);
9368 printf (_(" %#06x: Rev: %d Flags: %s"),
9369 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
9371 printf (_(" Index: %d Cnt: %d "),
9372 ent.vd_ndx, ent.vd_cnt);
9374 /* Check for overflow. */
9375 if (ent.vd_aux > (size_t) (endbuf - vstart))
9378 vstart += ent.vd_aux;
9380 eaux = (Elf_External_Verdaux *) vstart;
9382 aux.vda_name = BYTE_GET (eaux->vda_name);
9383 aux.vda_next = BYTE_GET (eaux->vda_next);
9385 if (VALID_DYNAMIC_NAME (aux.vda_name))
9386 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
9388 printf (_("Name index: %ld\n"), aux.vda_name);
9390 isum = idx + ent.vd_aux;
9392 for (j = 1; j < ent.vd_cnt; j++)
9394 /* Check for overflow. */
9395 if (aux.vda_next > (size_t) (endbuf - vstart))
9398 isum += aux.vda_next;
9399 vstart += aux.vda_next;
9401 eaux = (Elf_External_Verdaux *) vstart;
9402 if (vstart + sizeof (*eaux) > endbuf)
9405 aux.vda_name = BYTE_GET (eaux->vda_name);
9406 aux.vda_next = BYTE_GET (eaux->vda_next);
9408 if (VALID_DYNAMIC_NAME (aux.vda_name))
9409 printf (_(" %#06x: Parent %d: %s\n"),
9410 isum, j, GET_DYNAMIC_NAME (aux.vda_name));
9412 printf (_(" %#06x: Parent %d, name index: %ld\n"),
9413 isum, j, aux.vda_name);
9417 printf (_(" Version def aux past end of section\n"));
9419 /* PR 17531: file: id:000001,src:000172+005151,op:splice,rep:2. */
9420 if (idx + ent.vd_next <= idx)
9426 if (cnt < section->sh_info)
9427 printf (_(" Version definition past end of section\n"));
9433 case SHT_GNU_verneed:
9435 Elf_External_Verneed * eneed;
9442 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
9443 printable_section_name (section), section->sh_info);
9445 printf (_(" Addr: 0x"));
9446 printf_vma (section->sh_addr);
9447 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
9448 (unsigned long) section->sh_offset, section->sh_link,
9449 printable_section_name_from_index (section->sh_link));
9451 eneed = (Elf_External_Verneed *) get_data (NULL, file,
9452 section->sh_offset, 1,
9454 _("Version Needs section"));
9457 endbuf = (char *) eneed + section->sh_size;
9459 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
9461 Elf_External_Verneed * entry;
9462 Elf_Internal_Verneed ent;
9467 if (idx > (size_t) (endbuf - (char *) eneed))
9470 vstart = ((char *) eneed) + idx;
9471 if (vstart + sizeof (*entry) > endbuf)
9474 entry = (Elf_External_Verneed *) vstart;
9476 ent.vn_version = BYTE_GET (entry->vn_version);
9477 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
9478 ent.vn_file = BYTE_GET (entry->vn_file);
9479 ent.vn_aux = BYTE_GET (entry->vn_aux);
9480 ent.vn_next = BYTE_GET (entry->vn_next);
9482 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
9484 if (VALID_DYNAMIC_NAME (ent.vn_file))
9485 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
9487 printf (_(" File: %lx"), ent.vn_file);
9489 printf (_(" Cnt: %d\n"), ent.vn_cnt);
9491 /* Check for overflow. */
9492 if (ent.vn_aux > (size_t) (endbuf - vstart))
9494 vstart += ent.vn_aux;
9496 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
9498 Elf_External_Vernaux * eaux;
9499 Elf_Internal_Vernaux aux;
9501 if (vstart + sizeof (*eaux) > endbuf)
9503 eaux = (Elf_External_Vernaux *) vstart;
9505 aux.vna_hash = BYTE_GET (eaux->vna_hash);
9506 aux.vna_flags = BYTE_GET (eaux->vna_flags);
9507 aux.vna_other = BYTE_GET (eaux->vna_other);
9508 aux.vna_name = BYTE_GET (eaux->vna_name);
9509 aux.vna_next = BYTE_GET (eaux->vna_next);
9511 if (VALID_DYNAMIC_NAME (aux.vna_name))
9512 printf (_(" %#06x: Name: %s"),
9513 isum, GET_DYNAMIC_NAME (aux.vna_name));
9515 printf (_(" %#06x: Name index: %lx"),
9516 isum, aux.vna_name);
9518 printf (_(" Flags: %s Version: %d\n"),
9519 get_ver_flags (aux.vna_flags), aux.vna_other);
9521 /* Check for overflow. */
9522 if (aux.vna_next > (size_t) (endbuf - vstart)
9523 || (aux.vna_next == 0 && j < ent.vn_cnt - 1))
9525 warn (_("Invalid vna_next field of %lx\n"),
9530 isum += aux.vna_next;
9531 vstart += aux.vna_next;
9535 warn (_("Missing Version Needs auxillary information\n"));
9537 if (ent.vn_next == 0 && cnt < section->sh_info - 1)
9539 warn (_("Corrupt Version Needs structure - offset to next structure is zero with entries still left to be processed\n"));
9540 cnt = section->sh_info;
9546 if (cnt < section->sh_info)
9547 warn (_("Missing Version Needs information\n"));
9553 case SHT_GNU_versym:
9555 Elf_Internal_Shdr * link_section;
9558 unsigned char * edata;
9559 unsigned short * data;
9561 Elf_Internal_Sym * symbols;
9562 Elf_Internal_Shdr * string_sec;
9563 unsigned long num_syms;
9566 if (section->sh_link >= elf_header.e_shnum)
9569 link_section = section_headers + section->sh_link;
9570 total = section->sh_size / sizeof (Elf_External_Versym);
9572 if (link_section->sh_link >= elf_header.e_shnum)
9577 symbols = GET_ELF_SYMBOLS (file, link_section, & num_syms);
9578 if (symbols == NULL)
9581 string_sec = section_headers + link_section->sh_link;
9583 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
9584 string_sec->sh_size,
9585 _("version string table"));
9592 printf (_("\nVersion symbols section '%s' contains %lu entries:\n"),
9593 printable_section_name (section), (unsigned long) total);
9595 printf (_(" Addr: "));
9596 printf_vma (section->sh_addr);
9597 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
9598 (unsigned long) section->sh_offset, section->sh_link,
9599 printable_section_name (link_section));
9601 off = offset_from_vma (file,
9602 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
9603 total * sizeof (short));
9604 edata = (unsigned char *) get_data (NULL, file, off, total,
9606 _("version symbol data"));
9614 data = (short unsigned int *) cmalloc (total, sizeof (short));
9616 for (cnt = total; cnt --;)
9617 data[cnt] = byte_get (edata + cnt * sizeof (short),
9622 for (cnt = 0; cnt < total; cnt += 4)
9625 int check_def, check_need;
9628 printf (" %03x:", cnt);
9630 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
9631 switch (data[cnt + j])
9634 fputs (_(" 0 (*local*) "), stdout);
9638 fputs (_(" 1 (*global*) "), stdout);
9642 nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
9643 data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
9645 /* If this index value is greater than the size of the symbols
9646 array, break to avoid an out-of-bounds read. */
9647 if ((unsigned long)(cnt + j) >= num_syms)
9649 warn (_("invalid index into symbol array\n"));
9655 if (symbols[cnt + j].st_shndx >= elf_header.e_shnum
9656 || section_headers[symbols[cnt + j].st_shndx].sh_type
9659 if (symbols[cnt + j].st_shndx == SHN_UNDEF)
9666 && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
9668 Elf_Internal_Verneed ivn;
9669 unsigned long offset;
9671 offset = offset_from_vma
9672 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
9673 sizeof (Elf_External_Verneed));
9677 Elf_Internal_Vernaux ivna;
9678 Elf_External_Verneed evn;
9679 Elf_External_Vernaux evna;
9680 unsigned long a_off;
9682 if (get_data (&evn, file, offset, sizeof (evn), 1,
9683 _("version need")) == NULL)
9686 ivn.vn_aux = BYTE_GET (evn.vn_aux);
9687 ivn.vn_next = BYTE_GET (evn.vn_next);
9689 a_off = offset + ivn.vn_aux;
9693 if (get_data (&evna, file, a_off, sizeof (evna),
9694 1, _("version need aux (2)")) == NULL)
9701 ivna.vna_next = BYTE_GET (evna.vna_next);
9702 ivna.vna_other = BYTE_GET (evna.vna_other);
9705 a_off += ivna.vna_next;
9707 while (ivna.vna_other != data[cnt + j]
9708 && ivna.vna_next != 0);
9710 if (ivna.vna_other == data[cnt + j])
9712 ivna.vna_name = BYTE_GET (evna.vna_name);
9714 if (ivna.vna_name >= string_sec->sh_size)
9715 name = _("*invalid*");
9717 name = strtab + ivna.vna_name;
9718 nn += printf ("(%s%-*s",
9720 12 - (int) strlen (name),
9726 offset += ivn.vn_next;
9728 while (ivn.vn_next);
9731 if (check_def && data[cnt + j] != 0x8001
9732 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
9734 Elf_Internal_Verdef ivd;
9735 Elf_External_Verdef evd;
9736 unsigned long offset;
9738 offset = offset_from_vma
9739 (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
9744 if (get_data (&evd, file, offset, sizeof (evd), 1,
9745 _("version def")) == NULL)
9748 /* PR 17531: file: 046-1082287-0.004. */
9749 ivd.vd_ndx = (data[cnt + j] & VERSYM_VERSION) + 1;
9754 ivd.vd_next = BYTE_GET (evd.vd_next);
9755 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
9758 offset += ivd.vd_next;
9760 while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
9761 && ivd.vd_next != 0);
9763 if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
9765 Elf_External_Verdaux evda;
9766 Elf_Internal_Verdaux ivda;
9768 ivd.vd_aux = BYTE_GET (evd.vd_aux);
9770 if (get_data (&evda, file,
9771 offset - ivd.vd_next + ivd.vd_aux,
9773 _("version def aux")) == NULL)
9776 ivda.vda_name = BYTE_GET (evda.vda_name);
9778 if (ivda.vda_name >= string_sec->sh_size)
9779 name = _("*invalid*");
9781 name = strtab + ivda.vda_name;
9782 nn += printf ("(%s%-*s",
9784 12 - (int) strlen (name),
9790 printf ("%*c", 18 - nn, ' ');
9808 printf (_("\nNo version information found in this file.\n"));
9814 get_symbol_binding (unsigned int binding)
9816 static char buff[32];
9820 case STB_LOCAL: return "LOCAL";
9821 case STB_GLOBAL: return "GLOBAL";
9822 case STB_WEAK: return "WEAK";
9824 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
9825 snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
9827 else if (binding >= STB_LOOS && binding <= STB_HIOS)
9829 if (binding == STB_GNU_UNIQUE
9830 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
9831 /* GNU is still using the default value 0. */
9832 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
9834 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
9837 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
9843 get_symbol_type (unsigned int type)
9845 static char buff[32];
9849 case STT_NOTYPE: return "NOTYPE";
9850 case STT_OBJECT: return "OBJECT";
9851 case STT_FUNC: return "FUNC";
9852 case STT_SECTION: return "SECTION";
9853 case STT_FILE: return "FILE";
9854 case STT_COMMON: return "COMMON";
9855 case STT_TLS: return "TLS";
9856 case STT_RELC: return "RELC";
9857 case STT_SRELC: return "SRELC";
9859 if (type >= STT_LOPROC && type <= STT_HIPROC)
9861 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
9862 return "THUMB_FUNC";
9864 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
9867 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
9868 return "PARISC_MILLI";
9870 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
9872 else if (type >= STT_LOOS && type <= STT_HIOS)
9874 if (elf_header.e_machine == EM_PARISC)
9876 if (type == STT_HP_OPAQUE)
9878 if (type == STT_HP_STUB)
9882 if (type == STT_GNU_IFUNC
9883 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
9884 || elf_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
9885 /* GNU is still using the default value 0. */
9886 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
9889 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
9892 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
9898 get_symbol_visibility (unsigned int visibility)
9902 case STV_DEFAULT: return "DEFAULT";
9903 case STV_INTERNAL: return "INTERNAL";
9904 case STV_HIDDEN: return "HIDDEN";
9905 case STV_PROTECTED: return "PROTECTED";
9907 error (_("Unrecognized visibility value: %u"), visibility);
9908 return _("<unknown>");
9913 get_mips_symbol_other (unsigned int other)
9925 case STO_MICROMIPS | STO_MIPS_PIC:
9926 return "MICROMIPS, MIPS PIC";
9935 get_ia64_symbol_other (unsigned int other)
9939 static char res[32];
9943 /* Function types is for images and .STB files only. */
9944 switch (elf_header.e_type)
9948 switch (VMS_ST_FUNC_TYPE (other))
9950 case VMS_SFT_CODE_ADDR:
9951 strcat (res, " CA");
9953 case VMS_SFT_SYMV_IDX:
9954 strcat (res, " VEC");
9957 strcat (res, " FD");
9959 case VMS_SFT_RESERVE:
9960 strcat (res, " RSV");
9963 warn (_("Unrecognized IA64 VMS ST Function type: %d\n"),
9964 VMS_ST_FUNC_TYPE (other));
9965 strcat (res, " <unknown>");
9972 switch (VMS_ST_LINKAGE (other))
9974 case VMS_STL_IGNORE:
9975 strcat (res, " IGN");
9977 case VMS_STL_RESERVE:
9978 strcat (res, " RSV");
9981 strcat (res, " STD");
9984 strcat (res, " LNK");
9987 warn (_("Unrecognized IA64 VMS ST Linkage: %d\n"),
9988 VMS_ST_LINKAGE (other));
9989 strcat (res, " <unknown>");
10001 static const char *
10002 get_ppc64_symbol_other (unsigned int other)
10004 if (PPC64_LOCAL_ENTRY_OFFSET (other) != 0)
10006 static char buf[32];
10007 snprintf (buf, sizeof buf, _("<localentry>: %d"),
10008 PPC64_LOCAL_ENTRY_OFFSET (other));
10014 static const char *
10015 get_symbol_other (unsigned int other)
10017 const char * result = NULL;
10018 static char buff [32];
10023 switch (elf_header.e_machine)
10026 result = get_mips_symbol_other (other);
10029 result = get_ia64_symbol_other (other);
10032 result = get_ppc64_symbol_other (other);
10041 snprintf (buff, sizeof buff, _("<other>: %x"), other);
10045 static const char *
10046 get_symbol_index_type (unsigned int type)
10048 static char buff[32];
10052 case SHN_UNDEF: return "UND";
10053 case SHN_ABS: return "ABS";
10054 case SHN_COMMON: return "COM";
10056 if (type == SHN_IA_64_ANSI_COMMON
10057 && elf_header.e_machine == EM_IA_64
10058 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
10060 else if ((elf_header.e_machine == EM_X86_64
10061 || elf_header.e_machine == EM_L1OM
10062 || elf_header.e_machine == EM_K1OM)
10063 && type == SHN_X86_64_LCOMMON)
10064 return "LARGE_COM";
10065 else if ((type == SHN_MIPS_SCOMMON
10066 && elf_header.e_machine == EM_MIPS)
10067 || (type == SHN_TIC6X_SCOMMON
10068 && elf_header.e_machine == EM_TI_C6000))
10070 else if (type == SHN_MIPS_SUNDEFINED
10071 && elf_header.e_machine == EM_MIPS)
10073 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
10074 sprintf (buff, "PRC[0x%04x]", type & 0xffff);
10075 else if (type >= SHN_LOOS && type <= SHN_HIOS)
10076 sprintf (buff, "OS [0x%04x]", type & 0xffff);
10077 else if (type >= SHN_LORESERVE)
10078 sprintf (buff, "RSV[0x%04x]", type & 0xffff);
10079 else if (type >= elf_header.e_shnum)
10080 sprintf (buff, _("bad section index[%3d]"), type);
10082 sprintf (buff, "%3d", type);
10090 get_dynamic_data (FILE * file, bfd_size_type number, unsigned int ent_size)
10092 unsigned char * e_data;
10095 /* If the size_t type is smaller than the bfd_size_type, eg because
10096 you are building a 32-bit tool on a 64-bit host, then make sure
10097 that when (number) is cast to (size_t) no information is lost. */
10098 if (sizeof (size_t) < sizeof (bfd_size_type)
10099 && (bfd_size_type) ((size_t) number) != number)
10101 error (_("Size truncation prevents reading %llu elements of size %u\n"),
10102 (unsigned long long) number, ent_size);
10106 /* Be kind to memory chekers (eg valgrind, address sanitizer) by not
10107 attempting to allocate memory when the read is bound to fail. */
10108 if (ent_size * number > current_file_size)
10110 error (_("Invalid number of dynamic entries: %llu\n"),
10111 (unsigned long long) number);
10115 e_data = (unsigned char *) cmalloc ((size_t) number, ent_size);
10116 if (e_data == NULL)
10118 error (_("Out of memory reading %llu dynamic entries\n"),
10119 (unsigned long long) number);
10123 if (fread (e_data, ent_size, (size_t) number, file) != number)
10125 error (_("Unable to read in %llu bytes of dynamic data\n"),
10126 (unsigned long long) (number * ent_size));
10131 i_data = (bfd_vma *) cmalloc ((size_t) number, sizeof (*i_data));
10132 if (i_data == NULL)
10134 error (_("Out of memory allocating space for %llu dynamic entries\n"),
10135 (unsigned long long) number);
10141 i_data[number] = byte_get (e_data + number * ent_size, ent_size);
10149 print_dynamic_symbol (bfd_vma si, unsigned long hn)
10151 Elf_Internal_Sym * psym;
10154 n = print_vma (si, DEC_5);
10156 fputs (&" "[n], stdout);
10157 printf (" %3lu: ", hn);
10159 if (dynamic_symbols == NULL || si >= num_dynamic_syms)
10161 printf (_("<No info available for dynamic symbol number %lu>\n"),
10162 (unsigned long) si);
10166 psym = dynamic_symbols + si;
10167 print_vma (psym->st_value, LONG_HEX);
10169 print_vma (psym->st_size, DEC_5);
10171 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
10172 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
10173 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
10174 /* Check to see if any other bits in the st_other field are set.
10175 Note - displaying this information disrupts the layout of the
10176 table being generated, but for the moment this case is very
10178 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
10179 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
10180 printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
10181 if (VALID_DYNAMIC_NAME (psym->st_name))
10182 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
10184 printf (_(" <corrupt: %14ld>"), psym->st_name);
10188 static const char *
10189 get_symbol_version_string (FILE *file, int is_dynsym,
10190 const char *strtab,
10191 unsigned long int strtab_size,
10192 unsigned int si, Elf_Internal_Sym *psym,
10193 enum versioned_symbol_info *sym_info,
10194 unsigned short *vna_other)
10196 const char *version_string = NULL;
10199 && version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
10201 unsigned char data[2];
10202 unsigned short vers_data;
10203 unsigned long offset;
10207 offset = offset_from_vma
10208 (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
10209 sizeof data + si * sizeof (vers_data));
10211 if (get_data (&data, file, offset + si * sizeof (vers_data),
10212 sizeof (data), 1, _("version data")) == NULL)
10215 vers_data = byte_get (data, 2);
10217 is_nobits = (section_headers != NULL
10218 && psym->st_shndx < elf_header.e_shnum
10219 && section_headers[psym->st_shndx].sh_type
10222 check_def = (psym->st_shndx != SHN_UNDEF);
10224 if ((vers_data & VERSYM_HIDDEN) || vers_data > 1)
10226 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
10227 && (is_nobits || ! check_def))
10229 Elf_External_Verneed evn;
10230 Elf_Internal_Verneed ivn;
10231 Elf_Internal_Vernaux ivna;
10233 /* We must test both. */
10234 offset = offset_from_vma
10235 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
10240 unsigned long vna_off;
10242 if (get_data (&evn, file, offset, sizeof (evn), 1,
10243 _("version need")) == NULL)
10246 ivna.vna_other = 0;
10251 ivn.vn_aux = BYTE_GET (evn.vn_aux);
10252 ivn.vn_next = BYTE_GET (evn.vn_next);
10254 vna_off = offset + ivn.vn_aux;
10258 Elf_External_Vernaux evna;
10260 if (get_data (&evna, file, vna_off,
10262 _("version need aux (3)")) == NULL)
10265 ivna.vna_other = 0;
10270 ivna.vna_other = BYTE_GET (evna.vna_other);
10271 ivna.vna_next = BYTE_GET (evna.vna_next);
10272 ivna.vna_name = BYTE_GET (evna.vna_name);
10275 vna_off += ivna.vna_next;
10277 while (ivna.vna_other != vers_data
10278 && ivna.vna_next != 0);
10280 if (ivna.vna_other == vers_data)
10283 offset += ivn.vn_next;
10285 while (ivn.vn_next != 0);
10287 if (ivna.vna_other == vers_data)
10289 *sym_info = symbol_undefined;
10290 *vna_other = ivna.vna_other;
10291 version_string = (ivna.vna_name < strtab_size
10292 ? strtab + ivna.vna_name
10296 else if (! is_nobits)
10297 error (_("bad dynamic symbol\n"));
10304 if (vers_data != 0x8001
10305 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10307 Elf_Internal_Verdef ivd;
10308 Elf_Internal_Verdaux ivda;
10309 Elf_External_Verdaux evda;
10312 off = offset_from_vma
10314 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10315 sizeof (Elf_External_Verdef));
10319 Elf_External_Verdef evd;
10321 if (get_data (&evd, file, off, sizeof (evd),
10322 1, _("version def")) == NULL)
10330 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
10331 ivd.vd_aux = BYTE_GET (evd.vd_aux);
10332 ivd.vd_next = BYTE_GET (evd.vd_next);
10335 off += ivd.vd_next;
10337 while (ivd.vd_ndx != (vers_data & VERSYM_VERSION)
10338 && ivd.vd_next != 0);
10340 off -= ivd.vd_next;
10343 if (get_data (&evda, file, off, sizeof (evda),
10344 1, _("version def aux")) == NULL)
10345 return version_string;
10347 ivda.vda_name = BYTE_GET (evda.vda_name);
10349 if (psym->st_name != ivda.vda_name)
10351 *sym_info = ((vers_data & VERSYM_HIDDEN) != 0
10352 ? symbol_hidden : symbol_public);
10353 version_string = (ivda.vda_name < strtab_size
10354 ? strtab + ivda.vda_name
10361 return version_string;
10364 /* Dump the symbol table. */
10366 process_symbol_table (FILE * file)
10368 Elf_Internal_Shdr * section;
10369 bfd_size_type nbuckets = 0;
10370 bfd_size_type nchains = 0;
10371 bfd_vma * buckets = NULL;
10372 bfd_vma * chains = NULL;
10373 bfd_vma ngnubuckets = 0;
10374 bfd_vma * gnubuckets = NULL;
10375 bfd_vma * gnuchains = NULL;
10376 bfd_vma gnusymidx = 0;
10377 bfd_size_type ngnuchains = 0;
10379 if (!do_syms && !do_dyn_syms && !do_histogram)
10382 if (dynamic_info[DT_HASH]
10384 || (do_using_dynamic
10386 && dynamic_strings != NULL)))
10388 unsigned char nb[8];
10389 unsigned char nc[8];
10390 unsigned int hash_ent_size = 4;
10392 if ((elf_header.e_machine == EM_ALPHA
10393 || elf_header.e_machine == EM_S390
10394 || elf_header.e_machine == EM_S390_OLD)
10395 && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
10399 (archive_file_offset
10400 + offset_from_vma (file, dynamic_info[DT_HASH],
10401 sizeof nb + sizeof nc)),
10404 error (_("Unable to seek to start of dynamic information\n"));
10408 if (fread (nb, hash_ent_size, 1, file) != 1)
10410 error (_("Failed to read in number of buckets\n"));
10414 if (fread (nc, hash_ent_size, 1, file) != 1)
10416 error (_("Failed to read in number of chains\n"));
10420 nbuckets = byte_get (nb, hash_ent_size);
10421 nchains = byte_get (nc, hash_ent_size);
10423 buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
10424 chains = get_dynamic_data (file, nchains, hash_ent_size);
10427 if (buckets == NULL || chains == NULL)
10429 if (do_using_dynamic)
10440 if (dynamic_info_DT_GNU_HASH
10442 || (do_using_dynamic
10444 && dynamic_strings != NULL)))
10446 unsigned char nb[16];
10447 bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
10448 bfd_vma buckets_vma;
10451 (archive_file_offset
10452 + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
10456 error (_("Unable to seek to start of dynamic information\n"));
10460 if (fread (nb, 16, 1, file) != 1)
10462 error (_("Failed to read in number of buckets\n"));
10466 ngnubuckets = byte_get (nb, 4);
10467 gnusymidx = byte_get (nb + 4, 4);
10468 bitmaskwords = byte_get (nb + 8, 4);
10469 buckets_vma = dynamic_info_DT_GNU_HASH + 16;
10471 buckets_vma += bitmaskwords * 4;
10473 buckets_vma += bitmaskwords * 8;
10476 (archive_file_offset
10477 + offset_from_vma (file, buckets_vma, 4)),
10480 error (_("Unable to seek to start of dynamic information\n"));
10484 gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
10486 if (gnubuckets == NULL)
10489 for (i = 0; i < ngnubuckets; i++)
10490 if (gnubuckets[i] != 0)
10492 if (gnubuckets[i] < gnusymidx)
10495 if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
10496 maxchain = gnubuckets[i];
10499 if (maxchain == 0xffffffff)
10502 maxchain -= gnusymidx;
10505 (archive_file_offset
10506 + offset_from_vma (file, buckets_vma
10507 + 4 * (ngnubuckets + maxchain), 4)),
10510 error (_("Unable to seek to start of dynamic information\n"));
10516 if (fread (nb, 4, 1, file) != 1)
10518 error (_("Failed to determine last chain length\n"));
10522 if (maxchain + 1 == 0)
10527 while ((byte_get (nb, 4) & 1) == 0);
10530 (archive_file_offset
10531 + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
10534 error (_("Unable to seek to start of dynamic information\n"));
10538 gnuchains = get_dynamic_data (file, maxchain, 4);
10539 ngnuchains = maxchain;
10542 if (gnuchains == NULL)
10547 if (do_using_dynamic)
10552 if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
10554 && do_using_dynamic
10555 && dynamic_strings != NULL
10556 && dynamic_symbols != NULL)
10560 if (dynamic_info[DT_HASH])
10564 printf (_("\nSymbol table for image:\n"));
10566 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10568 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10570 for (hn = 0; hn < nbuckets; hn++)
10575 for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
10576 print_dynamic_symbol (si, hn);
10580 if (dynamic_info_DT_GNU_HASH)
10582 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
10584 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10586 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
10588 for (hn = 0; hn < ngnubuckets; ++hn)
10589 if (gnubuckets[hn] != 0)
10591 bfd_vma si = gnubuckets[hn];
10592 bfd_vma off = si - gnusymidx;
10596 print_dynamic_symbol (si, hn);
10599 while (off < ngnuchains && (gnuchains[off++] & 1) == 0);
10603 else if ((do_dyn_syms || (do_syms && !do_using_dynamic))
10604 && section_headers != NULL)
10608 for (i = 0, section = section_headers;
10609 i < elf_header.e_shnum;
10613 char * strtab = NULL;
10614 unsigned long int strtab_size = 0;
10615 Elf_Internal_Sym * symtab;
10616 Elf_Internal_Sym * psym;
10617 unsigned long num_syms;
10619 if ((section->sh_type != SHT_SYMTAB
10620 && section->sh_type != SHT_DYNSYM)
10622 && section->sh_type == SHT_SYMTAB))
10625 if (section->sh_entsize == 0)
10627 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
10628 printable_section_name (section));
10632 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
10633 printable_section_name (section),
10634 (unsigned long) (section->sh_size / section->sh_entsize));
10637 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
10639 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
10641 symtab = GET_ELF_SYMBOLS (file, section, & num_syms);
10642 if (symtab == NULL)
10645 if (section->sh_link == elf_header.e_shstrndx)
10647 strtab = string_table;
10648 strtab_size = string_table_length;
10650 else if (section->sh_link < elf_header.e_shnum)
10652 Elf_Internal_Shdr * string_sec;
10654 string_sec = section_headers + section->sh_link;
10656 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
10657 1, string_sec->sh_size,
10658 _("string table"));
10659 strtab_size = strtab != NULL ? string_sec->sh_size : 0;
10662 for (si = 0, psym = symtab; si < num_syms; si++, psym++)
10664 const char *version_string;
10665 enum versioned_symbol_info sym_info;
10666 unsigned short vna_other;
10668 printf ("%6d: ", si);
10669 print_vma (psym->st_value, LONG_HEX);
10671 print_vma (psym->st_size, DEC_5);
10672 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
10673 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
10674 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
10675 /* Check to see if any other bits in the st_other field are set.
10676 Note - displaying this information disrupts the layout of the
10677 table being generated, but for the moment this case is very rare. */
10678 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
10679 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
10680 printf (" %4s ", get_symbol_index_type (psym->st_shndx));
10681 print_symbol (25, psym->st_name < strtab_size
10682 ? strtab + psym->st_name : _("<corrupt>"));
10685 = get_symbol_version_string (file,
10686 section->sh_type == SHT_DYNSYM,
10687 strtab, strtab_size, si,
10688 psym, &sym_info, &vna_other);
10689 if (version_string)
10691 if (sym_info == symbol_undefined)
10692 printf ("@%s (%d)", version_string, vna_other);
10694 printf (sym_info == symbol_hidden ? "@%s" : "@@%s",
10702 if (strtab != string_table)
10708 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
10710 if (do_histogram && buckets != NULL)
10712 unsigned long * lengths;
10713 unsigned long * counts;
10716 unsigned long maxlength = 0;
10717 unsigned long nzero_counts = 0;
10718 unsigned long nsyms = 0;
10720 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
10721 (unsigned long) nbuckets);
10723 lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
10724 if (lengths == NULL)
10726 error (_("Out of memory allocating space for histogram buckets\n"));
10730 printf (_(" Length Number %% of total Coverage\n"));
10731 for (hn = 0; hn < nbuckets; ++hn)
10733 for (si = buckets[hn]; si > 0 && si < nchains && si < nbuckets; si = chains[si])
10736 if (maxlength < ++lengths[hn])
10739 /* PR binutils/17531: A corrupt binary could contain broken
10740 histogram data. Do not go into an infinite loop trying
10742 if (chains[si] == si)
10744 error (_("histogram chain links to itself\n"));
10750 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
10751 if (counts == NULL)
10754 error (_("Out of memory allocating space for histogram counts\n"));
10758 for (hn = 0; hn < nbuckets; ++hn)
10759 ++counts[lengths[hn]];
10764 printf (" 0 %-10lu (%5.1f%%)\n",
10765 counts[0], (counts[0] * 100.0) / nbuckets);
10766 for (i = 1; i <= maxlength; ++i)
10768 nzero_counts += counts[i] * i;
10769 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
10770 i, counts[i], (counts[i] * 100.0) / nbuckets,
10771 (nzero_counts * 100.0) / nsyms);
10779 if (buckets != NULL)
10785 if (do_histogram && gnubuckets != NULL)
10787 unsigned long * lengths;
10788 unsigned long * counts;
10790 unsigned long maxlength = 0;
10791 unsigned long nzero_counts = 0;
10792 unsigned long nsyms = 0;
10794 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
10795 (unsigned long) ngnubuckets);
10797 lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
10798 if (lengths == NULL)
10800 error (_("Out of memory allocating space for gnu histogram buckets\n"));
10804 printf (_(" Length Number %% of total Coverage\n"));
10806 for (hn = 0; hn < ngnubuckets; ++hn)
10807 if (gnubuckets[hn] != 0)
10809 bfd_vma off, length = 1;
10811 for (off = gnubuckets[hn] - gnusymidx;
10812 /* PR 17531 file: 010-77222-0.004. */
10813 off < ngnuchains && (gnuchains[off] & 1) == 0;
10816 lengths[hn] = length;
10817 if (length > maxlength)
10818 maxlength = length;
10822 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
10823 if (counts == NULL)
10826 error (_("Out of memory allocating space for gnu histogram counts\n"));
10830 for (hn = 0; hn < ngnubuckets; ++hn)
10831 ++counts[lengths[hn]];
10833 if (ngnubuckets > 0)
10836 printf (" 0 %-10lu (%5.1f%%)\n",
10837 counts[0], (counts[0] * 100.0) / ngnubuckets);
10838 for (j = 1; j <= maxlength; ++j)
10840 nzero_counts += counts[j] * j;
10841 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
10842 j, counts[j], (counts[j] * 100.0) / ngnubuckets,
10843 (nzero_counts * 100.0) / nsyms);
10857 process_syminfo (FILE * file ATTRIBUTE_UNUSED)
10861 if (dynamic_syminfo == NULL
10863 /* No syminfo, this is ok. */
10866 /* There better should be a dynamic symbol section. */
10867 if (dynamic_symbols == NULL || dynamic_strings == NULL)
10871 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
10872 dynamic_syminfo_offset, dynamic_syminfo_nent);
10874 printf (_(" Num: Name BoundTo Flags\n"));
10875 for (i = 0; i < dynamic_syminfo_nent; ++i)
10877 unsigned short int flags = dynamic_syminfo[i].si_flags;
10879 printf ("%4d: ", i);
10880 if (i >= num_dynamic_syms)
10881 printf (_("<corrupt index>"));
10882 else if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
10883 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
10885 printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
10888 switch (dynamic_syminfo[i].si_boundto)
10890 case SYMINFO_BT_SELF:
10891 fputs ("SELF ", stdout);
10893 case SYMINFO_BT_PARENT:
10894 fputs ("PARENT ", stdout);
10897 if (dynamic_syminfo[i].si_boundto > 0
10898 && dynamic_syminfo[i].si_boundto < dynamic_nent
10899 && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
10901 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
10905 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
10909 if (flags & SYMINFO_FLG_DIRECT)
10910 printf (" DIRECT");
10911 if (flags & SYMINFO_FLG_PASSTHRU)
10912 printf (" PASSTHRU");
10913 if (flags & SYMINFO_FLG_COPY)
10915 if (flags & SYMINFO_FLG_LAZYLOAD)
10916 printf (" LAZYLOAD");
10924 /* Check to see if the given reloc needs to be handled in a target specific
10925 manner. If so then process the reloc and return TRUE otherwise return
10929 target_specific_reloc_handling (Elf_Internal_Rela * reloc,
10930 unsigned char * start,
10931 Elf_Internal_Sym * symtab)
10933 unsigned int reloc_type = get_reloc_type (reloc->r_info);
10935 switch (elf_header.e_machine)
10938 case EM_MSP430_OLD:
10940 static Elf_Internal_Sym * saved_sym = NULL;
10942 switch (reloc_type)
10944 case 10: /* R_MSP430_SYM_DIFF */
10945 if (uses_msp430x_relocs ())
10947 case 21: /* R_MSP430X_SYM_DIFF */
10948 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
10951 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
10952 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
10953 goto handle_sym_diff;
10955 case 5: /* R_MSP430_16_BYTE */
10956 case 9: /* R_MSP430_8 */
10957 if (uses_msp430x_relocs ())
10959 goto handle_sym_diff;
10961 case 2: /* R_MSP430_ABS16 */
10962 case 15: /* R_MSP430X_ABS16 */
10963 if (! uses_msp430x_relocs ())
10965 goto handle_sym_diff;
10968 if (saved_sym != NULL)
10972 value = reloc->r_addend
10973 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
10974 - saved_sym->st_value);
10976 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
10984 if (saved_sym != NULL)
10985 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc\n"));
10992 case EM_CYGNUS_MN10300:
10994 static Elf_Internal_Sym * saved_sym = NULL;
10996 switch (reloc_type)
10998 case 34: /* R_MN10300_ALIGN */
11000 case 33: /* R_MN10300_SYM_DIFF */
11001 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
11003 case 1: /* R_MN10300_32 */
11004 case 2: /* R_MN10300_16 */
11005 if (saved_sym != NULL)
11009 value = reloc->r_addend
11010 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
11011 - saved_sym->st_value);
11013 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
11020 if (saved_sym != NULL)
11021 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc\n"));
11031 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
11032 DWARF debug sections. This is a target specific test. Note - we do not
11033 go through the whole including-target-headers-multiple-times route, (as
11034 we have already done with <elf/h8.h>) because this would become very
11035 messy and even then this function would have to contain target specific
11036 information (the names of the relocs instead of their numeric values).
11037 FIXME: This is not the correct way to solve this problem. The proper way
11038 is to have target specific reloc sizing and typing functions created by
11039 the reloc-macros.h header, in the same way that it already creates the
11040 reloc naming functions. */
11043 is_32bit_abs_reloc (unsigned int reloc_type)
11045 switch (elf_header.e_machine)
11049 return reloc_type == 1; /* R_386_32. */
11051 return reloc_type == 1; /* R_68K_32. */
11053 return reloc_type == 1; /* R_860_32. */
11055 return reloc_type == 2; /* R_960_32. */
11057 return reloc_type == 258; /* R_AARCH64_ABS32 */
11059 return reloc_type == 1; /* R_ALPHA_REFLONG. */
11061 return reloc_type == 1; /* R_ARC_32. */
11063 return reloc_type == 2; /* R_ARM_ABS32 */
11066 return reloc_type == 1;
11067 case EM_ADAPTEVA_EPIPHANY:
11068 return reloc_type == 3;
11070 return reloc_type == 0x12; /* R_byte4_data. */
11072 return reloc_type == 3; /* R_CRIS_32. */
11074 return reloc_type == 3; /* R_CR16_NUM32. */
11076 return reloc_type == 15; /* R_CRX_NUM32. */
11077 case EM_CYGNUS_FRV:
11078 return reloc_type == 1;
11079 case EM_CYGNUS_D10V:
11081 return reloc_type == 6; /* R_D10V_32. */
11082 case EM_CYGNUS_D30V:
11084 return reloc_type == 12; /* R_D30V_32_NORMAL. */
11086 return reloc_type == 3; /* R_DLX_RELOC_32. */
11087 case EM_CYGNUS_FR30:
11089 return reloc_type == 3; /* R_FR30_32. */
11091 return reloc_type == 1; /* R_FT32_32. */
11095 return reloc_type == 1; /* R_H8_DIR32. */
11097 return reloc_type == 0x65; /* R_IA64_SECREL32LSB. */
11100 return reloc_type == 2; /* R_IP2K_32. */
11102 return reloc_type == 2; /* R_IQ2000_32. */
11103 case EM_LATTICEMICO32:
11104 return reloc_type == 3; /* R_LM32_32. */
11107 return reloc_type == 3; /* R_M32C_32. */
11109 return reloc_type == 34; /* R_M32R_32_RELA. */
11111 return reloc_type == 1; /* R_MCORE_ADDR32. */
11112 case EM_CYGNUS_MEP:
11113 return reloc_type == 4; /* R_MEP_32. */
11115 return reloc_type == 2; /* R_METAG_ADDR32. */
11116 case EM_MICROBLAZE:
11117 return reloc_type == 1; /* R_MICROBLAZE_32. */
11119 return reloc_type == 2; /* R_MIPS_32. */
11121 return reloc_type == 4; /* R_MMIX_32. */
11122 case EM_CYGNUS_MN10200:
11124 return reloc_type == 1; /* R_MN10200_32. */
11125 case EM_CYGNUS_MN10300:
11127 return reloc_type == 1; /* R_MN10300_32. */
11129 return reloc_type == 1; /* R_MOXIE_32. */
11130 case EM_MSP430_OLD:
11132 return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32. */
11134 return reloc_type == 2; /* R_MT_32. */
11136 return reloc_type == 20; /* R_NDS32_RELA. */
11137 case EM_ALTERA_NIOS2:
11138 return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32. */
11140 return reloc_type == 1; /* R_NIOS_32. */
11142 return reloc_type == 1; /* R_OR1K_32. */
11144 return (reloc_type == 1 /* R_PARISC_DIR32. */
11145 || reloc_type == 41); /* R_PARISC_SECREL32. */
11148 return reloc_type == 1; /* R_PJ_DATA_DIR32. */
11150 return reloc_type == 1; /* R_PPC64_ADDR32. */
11152 return reloc_type == 1; /* R_PPC_ADDR32. */
11154 return reloc_type == 1; /* R_RL78_DIR32. */
11156 return reloc_type == 1; /* R_RX_DIR32. */
11158 return reloc_type == 1; /* R_I370_ADDR31. */
11161 return reloc_type == 4; /* R_S390_32. */
11163 return reloc_type == 8; /* R_SCORE_ABS32. */
11165 return reloc_type == 1; /* R_SH_DIR32. */
11166 case EM_SPARC32PLUS:
11169 return reloc_type == 3 /* R_SPARC_32. */
11170 || reloc_type == 23; /* R_SPARC_UA32. */
11172 return reloc_type == 6; /* R_SPU_ADDR32 */
11174 return reloc_type == 1; /* R_C6000_ABS32. */
11176 return reloc_type == 2; /* R_TILEGX_32. */
11178 return reloc_type == 1; /* R_TILEPRO_32. */
11179 case EM_CYGNUS_V850:
11181 return reloc_type == 6; /* R_V850_ABS32. */
11183 return reloc_type == 0x33; /* R_V810_WORD. */
11185 return reloc_type == 1; /* R_VAX_32. */
11187 return reloc_type == 3; /* R_VISIUM_32. */
11191 return reloc_type == 10; /* R_X86_64_32. */
11194 return reloc_type == 3; /* R_XC16C_ABS_32. */
11196 return reloc_type == 4; /* R_XGATE_32. */
11198 return reloc_type == 1; /* R_XSTROMY16_32. */
11199 case EM_XTENSA_OLD:
11201 return reloc_type == 1; /* R_XTENSA_32. */
11204 static unsigned int prev_warn = 0;
11206 /* Avoid repeating the same warning multiple times. */
11207 if (prev_warn != elf_header.e_machine)
11208 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
11209 elf_header.e_machine);
11210 prev_warn = elf_header.e_machine;
11216 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11217 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
11220 is_32bit_pcrel_reloc (unsigned int reloc_type)
11222 switch (elf_header.e_machine)
11226 return reloc_type == 2; /* R_386_PC32. */
11228 return reloc_type == 4; /* R_68K_PC32. */
11230 return reloc_type == 261; /* R_AARCH64_PREL32 */
11231 case EM_ADAPTEVA_EPIPHANY:
11232 return reloc_type == 6;
11234 return reloc_type == 10; /* R_ALPHA_SREL32. */
11236 return reloc_type == 3; /* R_ARM_REL32 */
11237 case EM_MICROBLAZE:
11238 return reloc_type == 2; /* R_MICROBLAZE_32_PCREL. */
11240 return reloc_type == 9; /* R_OR1K_32_PCREL. */
11242 return reloc_type == 9; /* R_PARISC_PCREL32. */
11244 return reloc_type == 26; /* R_PPC_REL32. */
11246 return reloc_type == 26; /* R_PPC64_REL32. */
11249 return reloc_type == 5; /* R_390_PC32. */
11251 return reloc_type == 2; /* R_SH_REL32. */
11252 case EM_SPARC32PLUS:
11255 return reloc_type == 6; /* R_SPARC_DISP32. */
11257 return reloc_type == 13; /* R_SPU_REL32. */
11259 return reloc_type == 6; /* R_TILEGX_32_PCREL. */
11261 return reloc_type == 4; /* R_TILEPRO_32_PCREL. */
11263 return reloc_type == 6; /* R_VISIUM_32_PCREL */
11267 return reloc_type == 2; /* R_X86_64_PC32. */
11268 case EM_XTENSA_OLD:
11270 return reloc_type == 14; /* R_XTENSA_32_PCREL. */
11272 /* Do not abort or issue an error message here. Not all targets use
11273 pc-relative 32-bit relocs in their DWARF debug information and we
11274 have already tested for target coverage in is_32bit_abs_reloc. A
11275 more helpful warning message will be generated by apply_relocations
11276 anyway, so just return. */
11281 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11282 a 64-bit absolute RELA relocation used in DWARF debug sections. */
11285 is_64bit_abs_reloc (unsigned int reloc_type)
11287 switch (elf_header.e_machine)
11290 return reloc_type == 257; /* R_AARCH64_ABS64. */
11292 return reloc_type == 2; /* R_ALPHA_REFQUAD. */
11294 return reloc_type == 0x27; /* R_IA64_DIR64LSB. */
11296 return reloc_type == 80; /* R_PARISC_DIR64. */
11298 return reloc_type == 38; /* R_PPC64_ADDR64. */
11299 case EM_SPARC32PLUS:
11302 return reloc_type == 54; /* R_SPARC_UA64. */
11306 return reloc_type == 1; /* R_X86_64_64. */
11309 return reloc_type == 22; /* R_S390_64. */
11311 return reloc_type == 1; /* R_TILEGX_64. */
11313 return reloc_type == 18; /* R_MIPS_64. */
11319 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
11320 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
11323 is_64bit_pcrel_reloc (unsigned int reloc_type)
11325 switch (elf_header.e_machine)
11328 return reloc_type == 260; /* R_AARCH64_PREL64. */
11330 return reloc_type == 11; /* R_ALPHA_SREL64. */
11332 return reloc_type == 0x4f; /* R_IA64_PCREL64LSB. */
11334 return reloc_type == 72; /* R_PARISC_PCREL64. */
11336 return reloc_type == 44; /* R_PPC64_REL64. */
11337 case EM_SPARC32PLUS:
11340 return reloc_type == 46; /* R_SPARC_DISP64. */
11344 return reloc_type == 24; /* R_X86_64_PC64. */
11347 return reloc_type == 23; /* R_S390_PC64. */
11349 return reloc_type == 5; /* R_TILEGX_64_PCREL. */
11355 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11356 a 24-bit absolute RELA relocation used in DWARF debug sections. */
11359 is_24bit_abs_reloc (unsigned int reloc_type)
11361 switch (elf_header.e_machine)
11363 case EM_CYGNUS_MN10200:
11365 return reloc_type == 4; /* R_MN10200_24. */
11371 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
11372 a 16-bit absolute RELA relocation used in DWARF debug sections. */
11375 is_16bit_abs_reloc (unsigned int reloc_type)
11377 switch (elf_header.e_machine)
11381 return reloc_type == 4; /* R_AVR_16. */
11382 case EM_ADAPTEVA_EPIPHANY:
11383 return reloc_type == 5;
11384 case EM_CYGNUS_D10V:
11386 return reloc_type == 3; /* R_D10V_16. */
11390 return reloc_type == R_H8_DIR16;
11393 return reloc_type == 1; /* R_IP2K_16. */
11396 return reloc_type == 1; /* R_M32C_16 */
11398 if (uses_msp430x_relocs ())
11399 return reloc_type == 2; /* R_MSP430_ABS16. */
11400 case EM_MSP430_OLD:
11401 return reloc_type == 5; /* R_MSP430_16_BYTE. */
11403 return reloc_type == 19; /* R_NDS32_RELA. */
11404 case EM_ALTERA_NIOS2:
11405 return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16. */
11407 return reloc_type == 9; /* R_NIOS_16. */
11409 return reloc_type == 2; /* R_OR1K_16. */
11411 return reloc_type == 2; /* R_C6000_ABS16. */
11414 return reloc_type == 2; /* R_XC16C_ABS_16. */
11415 case EM_CYGNUS_MN10200:
11417 return reloc_type == 2; /* R_MN10200_16. */
11418 case EM_CYGNUS_MN10300:
11420 return reloc_type == 2; /* R_MN10300_16. */
11422 return reloc_type == 2; /* R_VISIUM_16. */
11424 return reloc_type == 3; /* R_XGATE_16. */
11430 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
11431 relocation entries (possibly formerly used for SHT_GROUP sections). */
11434 is_none_reloc (unsigned int reloc_type)
11436 switch (elf_header.e_machine)
11438 case EM_68K: /* R_68K_NONE. */
11439 case EM_386: /* R_386_NONE. */
11440 case EM_SPARC32PLUS:
11442 case EM_SPARC: /* R_SPARC_NONE. */
11443 case EM_MIPS: /* R_MIPS_NONE. */
11444 case EM_PARISC: /* R_PARISC_NONE. */
11445 case EM_ALPHA: /* R_ALPHA_NONE. */
11446 case EM_ADAPTEVA_EPIPHANY:
11447 case EM_PPC: /* R_PPC_NONE. */
11448 case EM_PPC64: /* R_PPC64_NONE. */
11449 case EM_ARM: /* R_ARM_NONE. */
11450 case EM_IA_64: /* R_IA64_NONE. */
11451 case EM_SH: /* R_SH_NONE. */
11453 case EM_S390: /* R_390_NONE. */
11454 case EM_CRIS: /* R_CRIS_NONE. */
11455 case EM_X86_64: /* R_X86_64_NONE. */
11456 case EM_L1OM: /* R_X86_64_NONE. */
11457 case EM_K1OM: /* R_X86_64_NONE. */
11458 case EM_MN10300: /* R_MN10300_NONE. */
11459 case EM_FT32: /* R_FT32_NONE. */
11460 case EM_MOXIE: /* R_MOXIE_NONE. */
11461 case EM_M32R: /* R_M32R_NONE. */
11462 case EM_TI_C6000:/* R_C6000_NONE. */
11463 case EM_TILEGX: /* R_TILEGX_NONE. */
11464 case EM_TILEPRO: /* R_TILEPRO_NONE. */
11466 case EM_C166: /* R_XC16X_NONE. */
11467 case EM_ALTERA_NIOS2: /* R_NIOS2_NONE. */
11468 case EM_NIOS32: /* R_NIOS_NONE. */
11469 case EM_OR1K: /* R_OR1K_NONE. */
11470 return reloc_type == 0;
11472 return reloc_type == 0 || reloc_type == 256;
11474 return (reloc_type == 0 /* R_XTENSA_NONE. */
11475 || reloc_type == 204 /* R_NDS32_DIFF8. */
11476 || reloc_type == 205 /* R_NDS32_DIFF16. */
11477 || reloc_type == 206 /* R_NDS32_DIFF32. */
11478 || reloc_type == 207 /* R_NDS32_ULEB128. */);
11479 case EM_XTENSA_OLD:
11481 return (reloc_type == 0 /* R_XTENSA_NONE. */
11482 || reloc_type == 17 /* R_XTENSA_DIFF8. */
11483 || reloc_type == 18 /* R_XTENSA_DIFF16. */
11484 || reloc_type == 19 /* R_XTENSA_DIFF32. */);
11486 return reloc_type == 3; /* R_METAG_NONE. */
11491 /* Apply relocations to a section.
11492 Note: So far support has been added only for those relocations
11493 which can be found in debug sections.
11494 FIXME: Add support for more relocations ? */
11497 apply_relocations (void * file,
11498 Elf_Internal_Shdr * section,
11499 unsigned char * start)
11501 Elf_Internal_Shdr * relsec;
11502 unsigned char * end = start + section->sh_size;
11504 if (elf_header.e_type != ET_REL)
11507 /* Find the reloc section associated with the section. */
11508 for (relsec = section_headers;
11509 relsec < section_headers + elf_header.e_shnum;
11512 bfd_boolean is_rela;
11513 unsigned long num_relocs;
11514 Elf_Internal_Rela * relocs;
11515 Elf_Internal_Rela * rp;
11516 Elf_Internal_Shdr * symsec;
11517 Elf_Internal_Sym * symtab;
11518 unsigned long num_syms;
11519 Elf_Internal_Sym * sym;
11521 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
11522 || relsec->sh_info >= elf_header.e_shnum
11523 || section_headers + relsec->sh_info != section
11524 || relsec->sh_size == 0
11525 || relsec->sh_link >= elf_header.e_shnum)
11528 is_rela = relsec->sh_type == SHT_RELA;
11532 if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
11533 relsec->sh_size, & relocs, & num_relocs))
11538 if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
11539 relsec->sh_size, & relocs, & num_relocs))
11543 /* SH uses RELA but uses in place value instead of the addend field. */
11544 if (elf_header.e_machine == EM_SH)
11547 symsec = section_headers + relsec->sh_link;
11548 symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec, & num_syms);
11550 for (rp = relocs; rp < relocs + num_relocs; ++rp)
11553 unsigned int reloc_type;
11554 unsigned int reloc_size;
11555 unsigned char * rloc;
11556 unsigned long sym_index;
11558 reloc_type = get_reloc_type (rp->r_info);
11560 if (target_specific_reloc_handling (rp, start, symtab))
11562 else if (is_none_reloc (reloc_type))
11564 else if (is_32bit_abs_reloc (reloc_type)
11565 || is_32bit_pcrel_reloc (reloc_type))
11567 else if (is_64bit_abs_reloc (reloc_type)
11568 || is_64bit_pcrel_reloc (reloc_type))
11570 else if (is_24bit_abs_reloc (reloc_type))
11572 else if (is_16bit_abs_reloc (reloc_type))
11576 static unsigned int prev_reloc = 0;
11577 if (reloc_type != prev_reloc)
11578 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
11579 reloc_type, printable_section_name (section));
11580 prev_reloc = reloc_type;
11584 rloc = start + rp->r_offset;
11585 if ((rloc + reloc_size) > end || (rloc < start))
11587 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
11588 (unsigned long) rp->r_offset,
11589 printable_section_name (section));
11593 sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
11594 if (sym_index >= num_syms)
11596 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
11597 sym_index, printable_section_name (section));
11600 sym = symtab + sym_index;
11602 /* If the reloc has a symbol associated with it,
11603 make sure that it is of an appropriate type.
11605 Relocations against symbols without type can happen.
11606 Gcc -feliminate-dwarf2-dups may generate symbols
11607 without type for debug info.
11609 Icc generates relocations against function symbols
11610 instead of local labels.
11612 Relocations against object symbols can happen, eg when
11613 referencing a global array. For an example of this see
11614 the _clz.o binary in libgcc.a. */
11616 && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
11618 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
11619 get_symbol_type (ELF_ST_TYPE (sym->st_info)),
11620 (long int)(rp - relocs),
11621 printable_section_name (relsec));
11627 addend += rp->r_addend;
11628 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
11629 partial_inplace. */
11631 || (elf_header.e_machine == EM_XTENSA
11632 && reloc_type == 1)
11633 || ((elf_header.e_machine == EM_PJ
11634 || elf_header.e_machine == EM_PJ_OLD)
11635 && reloc_type == 1)
11636 || ((elf_header.e_machine == EM_D30V
11637 || elf_header.e_machine == EM_CYGNUS_D30V)
11638 && reloc_type == 12))
11639 addend += byte_get (rloc, reloc_size);
11641 if (is_32bit_pcrel_reloc (reloc_type)
11642 || is_64bit_pcrel_reloc (reloc_type))
11644 /* On HPPA, all pc-relative relocations are biased by 8. */
11645 if (elf_header.e_machine == EM_PARISC)
11647 byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
11651 byte_put (rloc, addend + sym->st_value, reloc_size);
11660 #ifdef SUPPORT_DISASSEMBLY
11662 disassemble_section (Elf_Internal_Shdr * section, FILE * file)
11664 printf (_("\nAssembly dump of section %s\n"), printable_section_name (section));
11666 /* FIXME: XXX -- to be done --- XXX */
11672 /* Reads in the contents of SECTION from FILE, returning a pointer
11673 to a malloc'ed buffer or NULL if something went wrong. */
11676 get_section_contents (Elf_Internal_Shdr * section, FILE * file)
11678 bfd_size_type num_bytes;
11680 num_bytes = section->sh_size;
11682 if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
11684 printf (_("\nSection '%s' has no data to dump.\n"),
11685 printable_section_name (section));
11689 return (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
11690 _("section contents"));
11695 dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
11697 Elf_Internal_Shdr * relsec;
11698 bfd_size_type num_bytes;
11702 bfd_boolean some_strings_shown;
11704 start = get_section_contents (section, file);
11708 printf (_("\nString dump of section '%s':\n"), printable_section_name (section));
11710 /* If the section being dumped has relocations against it the user might
11711 be expecting these relocations to have been applied. Check for this
11712 case and issue a warning message in order to avoid confusion.
11713 FIXME: Maybe we ought to have an option that dumps a section with
11714 relocs applied ? */
11715 for (relsec = section_headers;
11716 relsec < section_headers + elf_header.e_shnum;
11719 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
11720 || relsec->sh_info >= elf_header.e_shnum
11721 || section_headers + relsec->sh_info != section
11722 || relsec->sh_size == 0
11723 || relsec->sh_link >= elf_header.e_shnum)
11726 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
11730 num_bytes = section->sh_size;
11732 end = start + num_bytes;
11733 some_strings_shown = FALSE;
11737 while (!ISPRINT (* data))
11738 if (++ data >= end)
11743 size_t maxlen = end - data;
11746 /* PR 11128: Use two separate invocations in order to work
11747 around bugs in the Solaris 8 implementation of printf. */
11748 printf (" [%6tx] ", data - start);
11750 printf (" [%6Ix] ", (size_t) (data - start));
11754 print_symbol ((int) maxlen, data);
11756 data += strnlen (data, maxlen);
11760 printf (_("<corrupt>\n"));
11763 some_strings_shown = TRUE;
11767 if (! some_strings_shown)
11768 printf (_(" No strings found in this section."));
11776 dump_section_as_bytes (Elf_Internal_Shdr * section,
11778 bfd_boolean relocate)
11780 Elf_Internal_Shdr * relsec;
11781 bfd_size_type bytes;
11783 unsigned char * data;
11784 unsigned char * start;
11786 start = (unsigned char *) get_section_contents (section, file);
11790 printf (_("\nHex dump of section '%s':\n"), printable_section_name (section));
11794 apply_relocations (file, section, start);
11798 /* If the section being dumped has relocations against it the user might
11799 be expecting these relocations to have been applied. Check for this
11800 case and issue a warning message in order to avoid confusion.
11801 FIXME: Maybe we ought to have an option that dumps a section with
11802 relocs applied ? */
11803 for (relsec = section_headers;
11804 relsec < section_headers + elf_header.e_shnum;
11807 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
11808 || relsec->sh_info >= elf_header.e_shnum
11809 || section_headers + relsec->sh_info != section
11810 || relsec->sh_size == 0
11811 || relsec->sh_link >= elf_header.e_shnum)
11814 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
11819 addr = section->sh_addr;
11820 bytes = section->sh_size;
11829 lbytes = (bytes > 16 ? 16 : bytes);
11831 printf (" 0x%8.8lx ", (unsigned long) addr);
11833 for (j = 0; j < 16; j++)
11836 printf ("%2.2x", data[j]);
11844 for (j = 0; j < lbytes; j++)
11847 if (k >= ' ' && k < 0x7f)
11865 /* Uncompresses a section that was compressed using zlib, in place. */
11868 uncompress_section_contents (unsigned char **buffer ATTRIBUTE_UNUSED,
11869 dwarf_size_type *size ATTRIBUTE_UNUSED)
11871 #ifndef HAVE_ZLIB_H
11874 dwarf_size_type compressed_size = *size;
11875 unsigned char * compressed_buffer = *buffer;
11876 dwarf_size_type uncompressed_size;
11877 unsigned char * uncompressed_buffer;
11880 dwarf_size_type header_size = 12;
11882 /* Read the zlib header. In this case, it should be "ZLIB" followed
11883 by the uncompressed section size, 8 bytes in big-endian order. */
11884 if (compressed_size < header_size
11885 || ! streq ((char *) compressed_buffer, "ZLIB"))
11888 uncompressed_size = compressed_buffer[4]; uncompressed_size <<= 8;
11889 uncompressed_size += compressed_buffer[5]; uncompressed_size <<= 8;
11890 uncompressed_size += compressed_buffer[6]; uncompressed_size <<= 8;
11891 uncompressed_size += compressed_buffer[7]; uncompressed_size <<= 8;
11892 uncompressed_size += compressed_buffer[8]; uncompressed_size <<= 8;
11893 uncompressed_size += compressed_buffer[9]; uncompressed_size <<= 8;
11894 uncompressed_size += compressed_buffer[10]; uncompressed_size <<= 8;
11895 uncompressed_size += compressed_buffer[11];
11897 /* It is possible the section consists of several compressed
11898 buffers concatenated together, so we uncompress in a loop. */
11899 strm.zalloc = NULL;
11901 strm.opaque = NULL;
11902 strm.avail_in = compressed_size - header_size;
11903 strm.next_in = (Bytef *) compressed_buffer + header_size;
11904 strm.avail_out = uncompressed_size;
11905 uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
11907 rc = inflateInit (& strm);
11908 while (strm.avail_in > 0)
11912 strm.next_out = ((Bytef *) uncompressed_buffer
11913 + (uncompressed_size - strm.avail_out));
11914 rc = inflate (&strm, Z_FINISH);
11915 if (rc != Z_STREAM_END)
11917 rc = inflateReset (& strm);
11919 rc = inflateEnd (& strm);
11921 || strm.avail_out != 0)
11924 free (compressed_buffer);
11925 *buffer = uncompressed_buffer;
11926 *size = uncompressed_size;
11930 free (uncompressed_buffer);
11931 /* Indicate decompression failure. */
11934 #endif /* HAVE_ZLIB_H */
11938 load_specific_debug_section (enum dwarf_section_display_enum debug,
11939 Elf_Internal_Shdr * sec, void * file)
11941 struct dwarf_section * section = &debug_displays [debug].section;
11944 /* If it is already loaded, do nothing. */
11945 if (section->start != NULL)
11948 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
11949 section->address = sec->sh_addr;
11950 section->user_data = NULL;
11951 section->start = (unsigned char *) get_data (NULL, (FILE *) file,
11953 sec->sh_size, buf);
11954 if (section->start == NULL)
11958 section->size = sec->sh_size;
11959 if (uncompress_section_contents (§ion->start, §ion->size))
11960 sec->sh_size = section->size;
11963 if (section->start == NULL)
11966 if (debug_displays [debug].relocate)
11967 apply_relocations ((FILE *) file, sec, section->start);
11972 /* If this is not NULL, load_debug_section will only look for sections
11973 within the list of sections given here. */
11974 unsigned int *section_subset = NULL;
11977 load_debug_section (enum dwarf_section_display_enum debug, void * file)
11979 struct dwarf_section * section = &debug_displays [debug].section;
11980 Elf_Internal_Shdr * sec;
11982 /* Locate the debug section. */
11983 sec = find_section_in_set (section->uncompressed_name, section_subset);
11985 section->name = section->uncompressed_name;
11988 sec = find_section_in_set (section->compressed_name, section_subset);
11990 section->name = section->compressed_name;
11995 /* If we're loading from a subset of sections, and we've loaded
11996 a section matching this name before, it's likely that it's a
11998 if (section_subset != NULL)
11999 free_debug_section (debug);
12001 return load_specific_debug_section (debug, sec, (FILE *) file);
12005 free_debug_section (enum dwarf_section_display_enum debug)
12007 struct dwarf_section * section = &debug_displays [debug].section;
12009 if (section->start == NULL)
12012 free ((char *) section->start);
12013 section->start = NULL;
12014 section->address = 0;
12019 display_debug_section (int shndx, Elf_Internal_Shdr * section, FILE * file)
12021 char * name = SECTION_NAME (section);
12022 const char * print_name = printable_section_name (section);
12023 bfd_size_type length;
12027 length = section->sh_size;
12030 printf (_("\nSection '%s' has no debugging data.\n"), print_name);
12033 if (section->sh_type == SHT_NOBITS)
12035 /* There is no point in dumping the contents of a debugging section
12036 which has the NOBITS type - the bits in the file will be random.
12037 This can happen when a file containing a .eh_frame section is
12038 stripped with the --only-keep-debug command line option. */
12039 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"),
12044 if (const_strneq (name, ".gnu.linkonce.wi."))
12045 name = ".debug_info";
12047 /* See if we know how to display the contents of this section. */
12048 for (i = 0; i < max; i++)
12049 if (streq (debug_displays[i].section.uncompressed_name, name)
12050 || (i == line && const_strneq (name, ".debug_line."))
12051 || streq (debug_displays[i].section.compressed_name, name))
12053 struct dwarf_section * sec = &debug_displays [i].section;
12054 int secondary = (section != find_section (name));
12057 free_debug_section ((enum dwarf_section_display_enum) i);
12059 if (i == line && const_strneq (name, ".debug_line."))
12061 else if (streq (sec->uncompressed_name, name))
12062 sec->name = sec->uncompressed_name;
12064 sec->name = sec->compressed_name;
12065 if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
12068 /* If this debug section is part of a CU/TU set in a .dwp file,
12069 restrict load_debug_section to the sections in that set. */
12070 section_subset = find_cu_tu_set (file, shndx);
12072 result &= debug_displays[i].display (sec, file);
12074 section_subset = NULL;
12076 if (secondary || (i != info && i != abbrev))
12077 free_debug_section ((enum dwarf_section_display_enum) i);
12085 printf (_("Unrecognized debug section: %s\n"), print_name);
12092 /* Set DUMP_SECTS for all sections where dumps were requested
12093 based on section name. */
12096 initialise_dumps_byname (void)
12098 struct dump_list_entry * cur;
12100 for (cur = dump_sects_byname; cur; cur = cur->next)
12105 for (i = 0, any = 0; i < elf_header.e_shnum; i++)
12106 if (streq (SECTION_NAME (section_headers + i), cur->name))
12108 request_dump_bynumber (i, cur->type);
12113 warn (_("Section '%s' was not dumped because it does not exist!\n"),
12119 process_section_contents (FILE * file)
12121 Elf_Internal_Shdr * section;
12127 initialise_dumps_byname ();
12129 for (i = 0, section = section_headers;
12130 i < elf_header.e_shnum && i < num_dump_sects;
12133 #ifdef SUPPORT_DISASSEMBLY
12134 if (dump_sects[i] & DISASS_DUMP)
12135 disassemble_section (section, file);
12137 if (dump_sects[i] & HEX_DUMP)
12138 dump_section_as_bytes (section, file, FALSE);
12140 if (dump_sects[i] & RELOC_DUMP)
12141 dump_section_as_bytes (section, file, TRUE);
12143 if (dump_sects[i] & STRING_DUMP)
12144 dump_section_as_strings (section, file);
12146 if (dump_sects[i] & DEBUG_DUMP)
12147 display_debug_section (i, section, file);
12150 /* Check to see if the user requested a
12151 dump of a section that does not exist. */
12152 while (i++ < num_dump_sects)
12154 warn (_("Section %d was not dumped because it does not exist!\n"), i);
12158 process_mips_fpe_exception (int mask)
12163 if (mask & OEX_FPU_INEX)
12164 fputs ("INEX", stdout), first = 0;
12165 if (mask & OEX_FPU_UFLO)
12166 printf ("%sUFLO", first ? "" : "|"), first = 0;
12167 if (mask & OEX_FPU_OFLO)
12168 printf ("%sOFLO", first ? "" : "|"), first = 0;
12169 if (mask & OEX_FPU_DIV0)
12170 printf ("%sDIV0", first ? "" : "|"), first = 0;
12171 if (mask & OEX_FPU_INVAL)
12172 printf ("%sINVAL", first ? "" : "|");
12175 fputs ("0", stdout);
12178 /* Display's the value of TAG at location P. If TAG is
12179 greater than 0 it is assumed to be an unknown tag, and
12180 a message is printed to this effect. Otherwise it is
12181 assumed that a message has already been printed.
12183 If the bottom bit of TAG is set it assumed to have a
12184 string value, otherwise it is assumed to have an integer
12187 Returns an updated P pointing to the first unread byte
12188 beyond the end of TAG's value.
12190 Reads at or beyond END will not be made. */
12192 static unsigned char *
12193 display_tag_value (int tag,
12195 const unsigned char * const end)
12200 printf (" Tag_unknown_%d: ", tag);
12204 warn (_("<corrupt tag>\n"));
12208 /* PR 17531 file: 027-19978-0.004. */
12209 size_t maxlen = (end - p) - 1;
12214 print_symbol ((int) maxlen, (const char *) p);
12215 p += strnlen ((char *) p, maxlen) + 1;
12219 printf (_("<corrupt string tag>"));
12220 p = (unsigned char *) end;
12228 val = read_uleb128 (p, &len, end);
12230 printf ("%ld (0x%lx)\n", val, val);
12237 /* ARM EABI attributes section. */
12242 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
12244 const char ** table;
12245 } arm_attr_public_tag;
12247 static const char * arm_attr_tag_CPU_arch[] =
12248 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
12249 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8"};
12250 static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
12251 static const char * arm_attr_tag_THUMB_ISA_use[] =
12252 {"No", "Thumb-1", "Thumb-2"};
12253 static const char * arm_attr_tag_FP_arch[] =
12254 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
12255 "FP for ARMv8", "FPv5/FP-D16 for ARMv8"};
12256 static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
12257 static const char * arm_attr_tag_Advanced_SIMD_arch[] =
12258 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
12259 static const char * arm_attr_tag_PCS_config[] =
12260 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
12261 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
12262 static const char * arm_attr_tag_ABI_PCS_R9_use[] =
12263 {"V6", "SB", "TLS", "Unused"};
12264 static const char * arm_attr_tag_ABI_PCS_RW_data[] =
12265 {"Absolute", "PC-relative", "SB-relative", "None"};
12266 static const char * arm_attr_tag_ABI_PCS_RO_data[] =
12267 {"Absolute", "PC-relative", "None"};
12268 static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
12269 {"None", "direct", "GOT-indirect"};
12270 static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
12271 {"None", "??? 1", "2", "??? 3", "4"};
12272 static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
12273 static const char * arm_attr_tag_ABI_FP_denormal[] =
12274 {"Unused", "Needed", "Sign only"};
12275 static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
12276 static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
12277 static const char * arm_attr_tag_ABI_FP_number_model[] =
12278 {"Unused", "Finite", "RTABI", "IEEE 754"};
12279 static const char * arm_attr_tag_ABI_enum_size[] =
12280 {"Unused", "small", "int", "forced to int"};
12281 static const char * arm_attr_tag_ABI_HardFP_use[] =
12282 {"As Tag_FP_arch", "SP only", "DP only", "SP and DP"};
12283 static const char * arm_attr_tag_ABI_VFP_args[] =
12284 {"AAPCS", "VFP registers", "custom", "compatible"};
12285 static const char * arm_attr_tag_ABI_WMMX_args[] =
12286 {"AAPCS", "WMMX registers", "custom"};
12287 static const char * arm_attr_tag_ABI_optimization_goals[] =
12288 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12289 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
12290 static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
12291 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
12292 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
12293 static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
12294 static const char * arm_attr_tag_FP_HP_extension[] =
12295 {"Not Allowed", "Allowed"};
12296 static const char * arm_attr_tag_ABI_FP_16bit_format[] =
12297 {"None", "IEEE 754", "Alternative Format"};
12298 static const char * arm_attr_tag_MPextension_use[] =
12299 {"Not Allowed", "Allowed"};
12300 static const char * arm_attr_tag_DIV_use[] =
12301 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
12302 "Allowed in v7-A with integer division extension"};
12303 static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
12304 static const char * arm_attr_tag_Virtualization_use[] =
12305 {"Not Allowed", "TrustZone", "Virtualization Extensions",
12306 "TrustZone and Virtualization Extensions"};
12307 static const char * arm_attr_tag_MPextension_use_legacy[] =
12308 {"Not Allowed", "Allowed"};
12310 #define LOOKUP(id, name) \
12311 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
12312 static arm_attr_public_tag arm_attr_public_tags[] =
12314 {4, "CPU_raw_name", 1, NULL},
12315 {5, "CPU_name", 1, NULL},
12316 LOOKUP(6, CPU_arch),
12317 {7, "CPU_arch_profile", 0, NULL},
12318 LOOKUP(8, ARM_ISA_use),
12319 LOOKUP(9, THUMB_ISA_use),
12320 LOOKUP(10, FP_arch),
12321 LOOKUP(11, WMMX_arch),
12322 LOOKUP(12, Advanced_SIMD_arch),
12323 LOOKUP(13, PCS_config),
12324 LOOKUP(14, ABI_PCS_R9_use),
12325 LOOKUP(15, ABI_PCS_RW_data),
12326 LOOKUP(16, ABI_PCS_RO_data),
12327 LOOKUP(17, ABI_PCS_GOT_use),
12328 LOOKUP(18, ABI_PCS_wchar_t),
12329 LOOKUP(19, ABI_FP_rounding),
12330 LOOKUP(20, ABI_FP_denormal),
12331 LOOKUP(21, ABI_FP_exceptions),
12332 LOOKUP(22, ABI_FP_user_exceptions),
12333 LOOKUP(23, ABI_FP_number_model),
12334 {24, "ABI_align_needed", 0, NULL},
12335 {25, "ABI_align_preserved", 0, NULL},
12336 LOOKUP(26, ABI_enum_size),
12337 LOOKUP(27, ABI_HardFP_use),
12338 LOOKUP(28, ABI_VFP_args),
12339 LOOKUP(29, ABI_WMMX_args),
12340 LOOKUP(30, ABI_optimization_goals),
12341 LOOKUP(31, ABI_FP_optimization_goals),
12342 {32, "compatibility", 0, NULL},
12343 LOOKUP(34, CPU_unaligned_access),
12344 LOOKUP(36, FP_HP_extension),
12345 LOOKUP(38, ABI_FP_16bit_format),
12346 LOOKUP(42, MPextension_use),
12347 LOOKUP(44, DIV_use),
12348 {64, "nodefaults", 0, NULL},
12349 {65, "also_compatible_with", 0, NULL},
12350 LOOKUP(66, T2EE_use),
12351 {67, "conformance", 1, NULL},
12352 LOOKUP(68, Virtualization_use),
12353 LOOKUP(70, MPextension_use_legacy)
12357 static unsigned char *
12358 display_arm_attribute (unsigned char * p,
12359 const unsigned char * const end)
12364 arm_attr_public_tag * attr;
12368 tag = read_uleb128 (p, &len, end);
12371 for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
12373 if (arm_attr_public_tags[i].tag == tag)
12375 attr = &arm_attr_public_tags[i];
12382 printf (" Tag_%s: ", attr->name);
12383 switch (attr->type)
12388 case 7: /* Tag_CPU_arch_profile. */
12389 val = read_uleb128 (p, &len, end);
12393 case 0: printf (_("None\n")); break;
12394 case 'A': printf (_("Application\n")); break;
12395 case 'R': printf (_("Realtime\n")); break;
12396 case 'M': printf (_("Microcontroller\n")); break;
12397 case 'S': printf (_("Application or Realtime\n")); break;
12398 default: printf ("??? (%d)\n", val); break;
12402 case 24: /* Tag_align_needed. */
12403 val = read_uleb128 (p, &len, end);
12407 case 0: printf (_("None\n")); break;
12408 case 1: printf (_("8-byte\n")); break;
12409 case 2: printf (_("4-byte\n")); break;
12410 case 3: printf ("??? 3\n"); break;
12413 printf (_("8-byte and up to %d-byte extended\n"),
12416 printf ("??? (%d)\n", val);
12421 case 25: /* Tag_align_preserved. */
12422 val = read_uleb128 (p, &len, end);
12426 case 0: printf (_("None\n")); break;
12427 case 1: printf (_("8-byte, except leaf SP\n")); break;
12428 case 2: printf (_("8-byte\n")); break;
12429 case 3: printf ("??? 3\n"); break;
12432 printf (_("8-byte and up to %d-byte extended\n"),
12435 printf ("??? (%d)\n", val);
12440 case 32: /* Tag_compatibility. */
12442 val = read_uleb128 (p, &len, end);
12444 printf (_("flag = %d, vendor = "), val);
12447 size_t maxlen = (end - p) - 1;
12449 print_symbol ((int) maxlen, (const char *) p);
12450 p += strnlen ((char *) p, maxlen) + 1;
12454 printf (_("<corrupt>"));
12455 p = (unsigned char *) end;
12461 case 64: /* Tag_nodefaults. */
12462 /* PR 17531: file: 001-505008-0.01. */
12465 printf (_("True\n"));
12468 case 65: /* Tag_also_compatible_with. */
12469 val = read_uleb128 (p, &len, end);
12471 if (val == 6 /* Tag_CPU_arch. */)
12473 val = read_uleb128 (p, &len, end);
12475 if ((unsigned int) val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
12476 printf ("??? (%d)\n", val);
12478 printf ("%s\n", arm_attr_tag_CPU_arch[val]);
12482 while (p < end && *(p++) != '\0' /* NUL terminator. */)
12487 printf (_("<unknown: %d>\n"), tag);
12493 return display_tag_value (-1, p, end);
12495 return display_tag_value (0, p, end);
12498 assert (attr->type & 0x80);
12499 val = read_uleb128 (p, &len, end);
12501 type = attr->type & 0x7f;
12503 printf ("??? (%d)\n", val);
12505 printf ("%s\n", attr->table[val]);
12510 return display_tag_value (tag, p, end);
12513 static unsigned char *
12514 display_gnu_attribute (unsigned char * p,
12515 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const),
12516 const unsigned char * const end)
12522 tag = read_uleb128 (p, &len, end);
12525 /* Tag_compatibility is the only generic GNU attribute defined at
12529 val = read_uleb128 (p, &len, end);
12532 printf (_("flag = %d, vendor = "), val);
12535 printf (_("<corrupt>\n"));
12536 warn (_("corrupt vendor attribute\n"));
12542 size_t maxlen = (end - p) - 1;
12544 print_symbol ((int) maxlen, (const char *) p);
12545 p += strnlen ((char *) p, maxlen) + 1;
12549 printf (_("<corrupt>"));
12550 p = (unsigned char *) end;
12557 if ((tag & 2) == 0 && display_proc_gnu_attribute)
12558 return display_proc_gnu_attribute (p, tag, end);
12560 return display_tag_value (tag, p, end);
12563 static unsigned char *
12564 display_power_gnu_attribute (unsigned char * p,
12566 const unsigned char * const end)
12571 if (tag == Tag_GNU_Power_ABI_FP)
12573 val = read_uleb128 (p, &len, end);
12575 printf (" Tag_GNU_Power_ABI_FP: ");
12580 printf (_("Hard or soft float\n"));
12583 printf (_("Hard float\n"));
12586 printf (_("Soft float\n"));
12589 printf (_("Single-precision hard float\n"));
12592 printf ("??? (%d)\n", val);
12598 if (tag == Tag_GNU_Power_ABI_Vector)
12600 val = read_uleb128 (p, &len, end);
12602 printf (" Tag_GNU_Power_ABI_Vector: ");
12606 printf (_("Any\n"));
12609 printf (_("Generic\n"));
12612 printf ("AltiVec\n");
12618 printf ("??? (%d)\n", val);
12624 if (tag == Tag_GNU_Power_ABI_Struct_Return)
12628 warn (_("corrupt Tag_GNU_Power_ABI_Struct_Return\n"));
12632 val = read_uleb128 (p, &len, end);
12634 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
12638 printf (_("Any\n"));
12641 printf ("r3/r4\n");
12644 printf (_("Memory\n"));
12647 printf ("??? (%d)\n", val);
12653 return display_tag_value (tag & 1, p, end);
12657 display_sparc_hwcaps (int mask)
12663 if (mask & ELF_SPARC_HWCAP_MUL32)
12664 fputs ("mul32", stdout), first = 0;
12665 if (mask & ELF_SPARC_HWCAP_DIV32)
12666 printf ("%sdiv32", first ? "" : "|"), first = 0;
12667 if (mask & ELF_SPARC_HWCAP_FSMULD)
12668 printf ("%sfsmuld", first ? "" : "|"), first = 0;
12669 if (mask & ELF_SPARC_HWCAP_V8PLUS)
12670 printf ("%sv8plus", first ? "" : "|"), first = 0;
12671 if (mask & ELF_SPARC_HWCAP_POPC)
12672 printf ("%spopc", first ? "" : "|"), first = 0;
12673 if (mask & ELF_SPARC_HWCAP_VIS)
12674 printf ("%svis", first ? "" : "|"), first = 0;
12675 if (mask & ELF_SPARC_HWCAP_VIS2)
12676 printf ("%svis2", first ? "" : "|"), first = 0;
12677 if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
12678 printf ("%sASIBlkInit", first ? "" : "|"), first = 0;
12679 if (mask & ELF_SPARC_HWCAP_FMAF)
12680 printf ("%sfmaf", first ? "" : "|"), first = 0;
12681 if (mask & ELF_SPARC_HWCAP_VIS3)
12682 printf ("%svis3", first ? "" : "|"), first = 0;
12683 if (mask & ELF_SPARC_HWCAP_HPC)
12684 printf ("%shpc", first ? "" : "|"), first = 0;
12685 if (mask & ELF_SPARC_HWCAP_RANDOM)
12686 printf ("%srandom", first ? "" : "|"), first = 0;
12687 if (mask & ELF_SPARC_HWCAP_TRANS)
12688 printf ("%strans", first ? "" : "|"), first = 0;
12689 if (mask & ELF_SPARC_HWCAP_FJFMAU)
12690 printf ("%sfjfmau", first ? "" : "|"), first = 0;
12691 if (mask & ELF_SPARC_HWCAP_IMA)
12692 printf ("%sima", first ? "" : "|"), first = 0;
12693 if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
12694 printf ("%scspare", first ? "" : "|"), first = 0;
12697 fputc ('0', stdout);
12698 fputc ('\n', stdout);
12702 display_sparc_hwcaps2 (int mask)
12708 if (mask & ELF_SPARC_HWCAP2_FJATHPLUS)
12709 fputs ("fjathplus", stdout), first = 0;
12710 if (mask & ELF_SPARC_HWCAP2_VIS3B)
12711 printf ("%svis3b", first ? "" : "|"), first = 0;
12712 if (mask & ELF_SPARC_HWCAP2_ADP)
12713 printf ("%sadp", first ? "" : "|"), first = 0;
12714 if (mask & ELF_SPARC_HWCAP2_SPARC5)
12715 printf ("%ssparc5", first ? "" : "|"), first = 0;
12716 if (mask & ELF_SPARC_HWCAP2_MWAIT)
12717 printf ("%smwait", first ? "" : "|"), first = 0;
12718 if (mask & ELF_SPARC_HWCAP2_XMPMUL)
12719 printf ("%sxmpmul", first ? "" : "|"), first = 0;
12720 if (mask & ELF_SPARC_HWCAP2_XMONT)
12721 printf ("%sxmont2", first ? "" : "|"), first = 0;
12722 if (mask & ELF_SPARC_HWCAP2_NSEC)
12723 printf ("%snsec", first ? "" : "|"), first = 0;
12724 if (mask & ELF_SPARC_HWCAP2_FJATHHPC)
12725 printf ("%sfjathhpc", first ? "" : "|"), first = 0;
12726 if (mask & ELF_SPARC_HWCAP2_FJDES)
12727 printf ("%sfjdes", first ? "" : "|"), first = 0;
12728 if (mask & ELF_SPARC_HWCAP2_FJAES)
12729 printf ("%sfjaes", first ? "" : "|"), first = 0;
12732 fputc ('0', stdout);
12733 fputc ('\n', stdout);
12736 static unsigned char *
12737 display_sparc_gnu_attribute (unsigned char * p,
12739 const unsigned char * const end)
12744 if (tag == Tag_GNU_Sparc_HWCAPS)
12746 val = read_uleb128 (p, &len, end);
12748 printf (" Tag_GNU_Sparc_HWCAPS: ");
12749 display_sparc_hwcaps (val);
12752 if (tag == Tag_GNU_Sparc_HWCAPS2)
12754 val = read_uleb128 (p, &len, end);
12756 printf (" Tag_GNU_Sparc_HWCAPS2: ");
12757 display_sparc_hwcaps2 (val);
12761 return display_tag_value (tag, p, end);
12765 print_mips_fp_abi_value (int val)
12769 case Val_GNU_MIPS_ABI_FP_ANY:
12770 printf (_("Hard or soft float\n"));
12772 case Val_GNU_MIPS_ABI_FP_DOUBLE:
12773 printf (_("Hard float (double precision)\n"));
12775 case Val_GNU_MIPS_ABI_FP_SINGLE:
12776 printf (_("Hard float (single precision)\n"));
12778 case Val_GNU_MIPS_ABI_FP_SOFT:
12779 printf (_("Soft float\n"));
12781 case Val_GNU_MIPS_ABI_FP_OLD_64:
12782 printf (_("Hard float (MIPS32r2 64-bit FPU 12 callee-saved)\n"));
12784 case Val_GNU_MIPS_ABI_FP_XX:
12785 printf (_("Hard float (32-bit CPU, Any FPU)\n"));
12787 case Val_GNU_MIPS_ABI_FP_64:
12788 printf (_("Hard float (32-bit CPU, 64-bit FPU)\n"));
12790 case Val_GNU_MIPS_ABI_FP_64A:
12791 printf (_("Hard float compat (32-bit CPU, 64-bit FPU)\n"));
12794 printf ("??? (%d)\n", val);
12799 static unsigned char *
12800 display_mips_gnu_attribute (unsigned char * p,
12802 const unsigned char * const end)
12804 if (tag == Tag_GNU_MIPS_ABI_FP)
12809 val = read_uleb128 (p, &len, end);
12811 printf (" Tag_GNU_MIPS_ABI_FP: ");
12813 print_mips_fp_abi_value (val);
12818 if (tag == Tag_GNU_MIPS_ABI_MSA)
12823 val = read_uleb128 (p, &len, end);
12825 printf (" Tag_GNU_MIPS_ABI_MSA: ");
12829 case Val_GNU_MIPS_ABI_MSA_ANY:
12830 printf (_("Any MSA or not\n"));
12832 case Val_GNU_MIPS_ABI_MSA_128:
12833 printf (_("128-bit MSA\n"));
12836 printf ("??? (%d)\n", val);
12842 return display_tag_value (tag & 1, p, end);
12845 static unsigned char *
12846 display_tic6x_attribute (unsigned char * p,
12847 const unsigned char * const end)
12853 tag = read_uleb128 (p, &len, end);
12859 val = read_uleb128 (p, &len, end);
12861 printf (" Tag_ISA: ");
12865 case C6XABI_Tag_ISA_none:
12866 printf (_("None\n"));
12868 case C6XABI_Tag_ISA_C62X:
12871 case C6XABI_Tag_ISA_C67X:
12874 case C6XABI_Tag_ISA_C67XP:
12875 printf ("C67x+\n");
12877 case C6XABI_Tag_ISA_C64X:
12880 case C6XABI_Tag_ISA_C64XP:
12881 printf ("C64x+\n");
12883 case C6XABI_Tag_ISA_C674X:
12884 printf ("C674x\n");
12887 printf ("??? (%d)\n", val);
12892 case Tag_ABI_wchar_t:
12893 val = read_uleb128 (p, &len, end);
12895 printf (" Tag_ABI_wchar_t: ");
12899 printf (_("Not used\n"));
12902 printf (_("2 bytes\n"));
12905 printf (_("4 bytes\n"));
12908 printf ("??? (%d)\n", val);
12913 case Tag_ABI_stack_align_needed:
12914 val = read_uleb128 (p, &len, end);
12916 printf (" Tag_ABI_stack_align_needed: ");
12920 printf (_("8-byte\n"));
12923 printf (_("16-byte\n"));
12926 printf ("??? (%d)\n", val);
12931 case Tag_ABI_stack_align_preserved:
12932 val = read_uleb128 (p, &len, end);
12934 printf (" Tag_ABI_stack_align_preserved: ");
12938 printf (_("8-byte\n"));
12941 printf (_("16-byte\n"));
12944 printf ("??? (%d)\n", val);
12950 val = read_uleb128 (p, &len, end);
12952 printf (" Tag_ABI_DSBT: ");
12956 printf (_("DSBT addressing not used\n"));
12959 printf (_("DSBT addressing used\n"));
12962 printf ("??? (%d)\n", val);
12968 val = read_uleb128 (p, &len, end);
12970 printf (" Tag_ABI_PID: ");
12974 printf (_("Data addressing position-dependent\n"));
12977 printf (_("Data addressing position-independent, GOT near DP\n"));
12980 printf (_("Data addressing position-independent, GOT far from DP\n"));
12983 printf ("??? (%d)\n", val);
12989 val = read_uleb128 (p, &len, end);
12991 printf (" Tag_ABI_PIC: ");
12995 printf (_("Code addressing position-dependent\n"));
12998 printf (_("Code addressing position-independent\n"));
13001 printf ("??? (%d)\n", val);
13006 case Tag_ABI_array_object_alignment:
13007 val = read_uleb128 (p, &len, end);
13009 printf (" Tag_ABI_array_object_alignment: ");
13013 printf (_("8-byte\n"));
13016 printf (_("4-byte\n"));
13019 printf (_("16-byte\n"));
13022 printf ("??? (%d)\n", val);
13027 case Tag_ABI_array_object_align_expected:
13028 val = read_uleb128 (p, &len, end);
13030 printf (" Tag_ABI_array_object_align_expected: ");
13034 printf (_("8-byte\n"));
13037 printf (_("4-byte\n"));
13040 printf (_("16-byte\n"));
13043 printf ("??? (%d)\n", val);
13048 case Tag_ABI_compatibility:
13050 val = read_uleb128 (p, &len, end);
13052 printf (" Tag_ABI_compatibility: ");
13053 printf (_("flag = %d, vendor = "), val);
13056 size_t maxlen = (end - p) - 1;
13058 print_symbol ((int) maxlen, (const char *) p);
13059 p += strnlen ((char *) p, maxlen) + 1;
13063 printf (_("<corrupt>"));
13064 p = (unsigned char *) end;
13070 case Tag_ABI_conformance:
13072 printf (" Tag_ABI_conformance: \"");
13075 size_t maxlen = (end - p) - 1;
13077 print_symbol ((int) maxlen, (const char *) p);
13078 p += strnlen ((char *) p, maxlen) + 1;
13082 printf (_("<corrupt>"));
13083 p = (unsigned char *) end;
13090 return display_tag_value (tag, p, end);
13094 display_raw_attribute (unsigned char * p, unsigned char * end)
13096 unsigned long addr = 0;
13097 size_t bytes = end - p;
13104 int lbytes = (bytes > 16 ? 16 : bytes);
13106 printf (" 0x%8.8lx ", addr);
13108 for (j = 0; j < 16; j++)
13111 printf ("%2.2x", p[j]);
13119 for (j = 0; j < lbytes; j++)
13122 if (k >= ' ' && k < 0x7f)
13138 static unsigned char *
13139 display_msp430x_attribute (unsigned char * p,
13140 const unsigned char * const end)
13146 tag = read_uleb128 (p, & len, end);
13151 case OFBA_MSPABI_Tag_ISA:
13152 val = read_uleb128 (p, &len, end);
13154 printf (" Tag_ISA: ");
13157 case 0: printf (_("None\n")); break;
13158 case 1: printf (_("MSP430\n")); break;
13159 case 2: printf (_("MSP430X\n")); break;
13160 default: printf ("??? (%d)\n", val); break;
13164 case OFBA_MSPABI_Tag_Code_Model:
13165 val = read_uleb128 (p, &len, end);
13167 printf (" Tag_Code_Model: ");
13170 case 0: printf (_("None\n")); break;
13171 case 1: printf (_("Small\n")); break;
13172 case 2: printf (_("Large\n")); break;
13173 default: printf ("??? (%d)\n", val); break;
13177 case OFBA_MSPABI_Tag_Data_Model:
13178 val = read_uleb128 (p, &len, end);
13180 printf (" Tag_Data_Model: ");
13183 case 0: printf (_("None\n")); break;
13184 case 1: printf (_("Small\n")); break;
13185 case 2: printf (_("Large\n")); break;
13186 case 3: printf (_("Restricted Large\n")); break;
13187 default: printf ("??? (%d)\n", val); break;
13192 printf (_(" <unknown tag %d>: "), tag);
13199 size_t maxlen = (end - p) - 1;
13201 print_symbol ((int) maxlen, (const char *) p);
13202 p += strnlen ((char *) p, maxlen) + 1;
13206 printf (_("<corrupt>"));
13207 p = (unsigned char *) end;
13213 val = read_uleb128 (p, &len, end);
13215 printf ("%d (0x%x)\n", val, val);
13225 process_attributes (FILE * file,
13226 const char * public_name,
13227 unsigned int proc_type,
13228 unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
13229 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const))
13231 Elf_Internal_Shdr * sect;
13234 /* Find the section header so that we get the size. */
13235 for (i = 0, sect = section_headers;
13236 i < elf_header.e_shnum;
13239 unsigned char * contents;
13242 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
13245 contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
13246 sect->sh_size, _("attributes"));
13247 if (contents == NULL)
13253 bfd_vma section_len;
13255 section_len = sect->sh_size - 1;
13258 while (section_len > 0)
13261 unsigned int namelen;
13262 bfd_boolean public_section;
13263 bfd_boolean gnu_section;
13265 if (section_len <= 4)
13267 error (_("Tag section ends prematurely\n"));
13270 attr_len = byte_get (p, 4);
13273 if (attr_len > section_len)
13275 error (_("Bad attribute length (%u > %u)\n"),
13276 (unsigned) attr_len, (unsigned) section_len);
13277 attr_len = section_len;
13279 /* PR 17531: file: 001-101425-0.004 */
13280 else if (attr_len < 5)
13282 error (_("Attribute length of %u is too small\n"), (unsigned) attr_len);
13286 section_len -= attr_len;
13289 namelen = strnlen ((char *) p, attr_len) + 1;
13290 if (namelen == 0 || namelen >= attr_len)
13292 error (_("Corrupt attribute section name\n"));
13296 printf (_("Attribute Section: "));
13297 print_symbol (INT_MAX, (const char *) p);
13300 if (public_name && streq ((char *) p, public_name))
13301 public_section = TRUE;
13303 public_section = FALSE;
13305 if (streq ((char *) p, "gnu"))
13306 gnu_section = TRUE;
13308 gnu_section = FALSE;
13311 attr_len -= namelen;
13313 while (attr_len > 0 && p < contents + sect->sh_size)
13318 unsigned char * end;
13320 /* PR binutils/17531: Safe handling of corrupt files. */
13323 error (_("Unused bytes at end of section\n"));
13329 size = byte_get (p, 4);
13330 if (size > attr_len)
13332 error (_("Bad subsection length (%u > %u)\n"),
13333 (unsigned) size, (unsigned) attr_len);
13336 /* PR binutils/17531: Safe handling of corrupt files. */
13339 error (_("Bad subsection length (%u < 6)\n"),
13346 end = p + size - 1;
13347 assert (end <= contents + sect->sh_size);
13353 printf (_("File Attributes\n"));
13356 printf (_("Section Attributes:"));
13359 printf (_("Symbol Attributes:"));
13365 val = read_uleb128 (p, &j, end);
13369 printf (" %d", val);
13374 printf (_("Unknown tag: %d\n"), tag);
13375 public_section = FALSE;
13379 if (public_section && display_pub_attribute != NULL)
13382 p = display_pub_attribute (p, end);
13385 else if (gnu_section && display_proc_gnu_attribute != NULL)
13388 p = display_gnu_attribute (p,
13389 display_proc_gnu_attribute,
13395 printf (_(" Unknown attribute:\n"));
13396 display_raw_attribute (p, end);
13405 printf (_("Unknown format '%c' (%d)\n"), *p, *p);
13413 process_arm_specific (FILE * file)
13415 return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
13416 display_arm_attribute, NULL);
13420 process_power_specific (FILE * file)
13422 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13423 display_power_gnu_attribute);
13427 process_sparc_specific (FILE * file)
13429 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13430 display_sparc_gnu_attribute);
13434 process_tic6x_specific (FILE * file)
13436 return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
13437 display_tic6x_attribute, NULL);
13441 process_msp430x_specific (FILE * file)
13443 return process_attributes (file, "mspabi", SHT_MSP430_ATTRIBUTES,
13444 display_msp430x_attribute, NULL);
13447 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
13448 Print the Address, Access and Initial fields of an entry at VMA ADDR
13449 and return the VMA of the next entry, or -1 if there was a problem.
13450 Does not read from DATA_END or beyond. */
13453 print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr,
13454 unsigned char * data_end)
13457 print_vma (addr, LONG_HEX);
13459 if (addr < pltgot + 0xfff0)
13460 printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
13462 printf ("%10s", "");
13465 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
13469 unsigned char * from = data + addr - pltgot;
13471 if (from + (is_32bit_elf ? 4 : 8) > data_end)
13473 warn (_("MIPS GOT entry extends beyond the end of available data\n"));
13474 printf ("%*s", is_32bit_elf ? 8 : 16, _("<corrupt>"));
13475 return (bfd_vma) -1;
13479 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
13480 print_vma (entry, LONG_HEX);
13483 return addr + (is_32bit_elf ? 4 : 8);
13486 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
13487 PLTGOT. Print the Address and Initial fields of an entry at VMA
13488 ADDR and return the VMA of the next entry. */
13491 print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
13494 print_vma (addr, LONG_HEX);
13497 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
13502 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
13503 print_vma (entry, LONG_HEX);
13505 return addr + (is_32bit_elf ? 4 : 8);
13509 print_mips_ases (unsigned int mask)
13511 if (mask & AFL_ASE_DSP)
13512 fputs ("\n\tDSP ASE", stdout);
13513 if (mask & AFL_ASE_DSPR2)
13514 fputs ("\n\tDSP R2 ASE", stdout);
13515 if (mask & AFL_ASE_EVA)
13516 fputs ("\n\tEnhanced VA Scheme", stdout);
13517 if (mask & AFL_ASE_MCU)
13518 fputs ("\n\tMCU (MicroController) ASE", stdout);
13519 if (mask & AFL_ASE_MDMX)
13520 fputs ("\n\tMDMX ASE", stdout);
13521 if (mask & AFL_ASE_MIPS3D)
13522 fputs ("\n\tMIPS-3D ASE", stdout);
13523 if (mask & AFL_ASE_MT)
13524 fputs ("\n\tMT ASE", stdout);
13525 if (mask & AFL_ASE_SMARTMIPS)
13526 fputs ("\n\tSmartMIPS ASE", stdout);
13527 if (mask & AFL_ASE_VIRT)
13528 fputs ("\n\tVZ ASE", stdout);
13529 if (mask & AFL_ASE_MSA)
13530 fputs ("\n\tMSA ASE", stdout);
13531 if (mask & AFL_ASE_MIPS16)
13532 fputs ("\n\tMIPS16 ASE", stdout);
13533 if (mask & AFL_ASE_MICROMIPS)
13534 fputs ("\n\tMICROMIPS ASE", stdout);
13535 if (mask & AFL_ASE_XPA)
13536 fputs ("\n\tXPA ASE", stdout);
13538 fprintf (stdout, "\n\t%s", _("None"));
13539 else if ((mask & ~AFL_ASE_MASK) != 0)
13540 fprintf (stdout, "\n\t%s (%x)", _("Unknown"), mask & ~AFL_ASE_MASK);
13544 print_mips_isa_ext (unsigned int isa_ext)
13549 fputs (_("None"), stdout);
13552 fputs ("RMI XLR", stdout);
13554 case AFL_EXT_OCTEON3:
13555 fputs ("Cavium Networks Octeon3", stdout);
13557 case AFL_EXT_OCTEON2:
13558 fputs ("Cavium Networks Octeon2", stdout);
13560 case AFL_EXT_OCTEONP:
13561 fputs ("Cavium Networks OcteonP", stdout);
13563 case AFL_EXT_LOONGSON_3A:
13564 fputs ("Loongson 3A", stdout);
13566 case AFL_EXT_OCTEON:
13567 fputs ("Cavium Networks Octeon", stdout);
13570 fputs ("Toshiba R5900", stdout);
13573 fputs ("MIPS R4650", stdout);
13576 fputs ("LSI R4010", stdout);
13579 fputs ("NEC VR4100", stdout);
13582 fputs ("Toshiba R3900", stdout);
13584 case AFL_EXT_10000:
13585 fputs ("MIPS R10000", stdout);
13588 fputs ("Broadcom SB-1", stdout);
13591 fputs ("NEC VR4111/VR4181", stdout);
13594 fputs ("NEC VR4120", stdout);
13597 fputs ("NEC VR5400", stdout);
13600 fputs ("NEC VR5500", stdout);
13602 case AFL_EXT_LOONGSON_2E:
13603 fputs ("ST Microelectronics Loongson 2E", stdout);
13605 case AFL_EXT_LOONGSON_2F:
13606 fputs ("ST Microelectronics Loongson 2F", stdout);
13609 fprintf (stdout, "%s (%d)", _("Unknown"), isa_ext);
13614 get_mips_reg_size (int reg_size)
13616 return (reg_size == AFL_REG_NONE) ? 0
13617 : (reg_size == AFL_REG_32) ? 32
13618 : (reg_size == AFL_REG_64) ? 64
13619 : (reg_size == AFL_REG_128) ? 128
13624 process_mips_specific (FILE * file)
13626 Elf_Internal_Dyn * entry;
13627 Elf_Internal_Shdr *sect = NULL;
13628 size_t liblist_offset = 0;
13629 size_t liblistno = 0;
13630 size_t conflictsno = 0;
13631 size_t options_offset = 0;
13632 size_t conflicts_offset = 0;
13633 size_t pltrelsz = 0;
13635 bfd_vma pltgot = 0;
13636 bfd_vma mips_pltgot = 0;
13637 bfd_vma jmprel = 0;
13638 bfd_vma local_gotno = 0;
13639 bfd_vma gotsym = 0;
13640 bfd_vma symtabno = 0;
13642 process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
13643 display_mips_gnu_attribute);
13645 sect = find_section (".MIPS.abiflags");
13649 Elf_External_ABIFlags_v0 *abiflags_ext;
13650 Elf_Internal_ABIFlags_v0 abiflags_in;
13652 if (sizeof (Elf_External_ABIFlags_v0) != sect->sh_size)
13653 fputs ("\nCorrupt ABI Flags section.\n", stdout);
13656 abiflags_ext = get_data (NULL, file, sect->sh_offset, 1,
13657 sect->sh_size, _("MIPS ABI Flags section"));
13660 abiflags_in.version = BYTE_GET (abiflags_ext->version);
13661 abiflags_in.isa_level = BYTE_GET (abiflags_ext->isa_level);
13662 abiflags_in.isa_rev = BYTE_GET (abiflags_ext->isa_rev);
13663 abiflags_in.gpr_size = BYTE_GET (abiflags_ext->gpr_size);
13664 abiflags_in.cpr1_size = BYTE_GET (abiflags_ext->cpr1_size);
13665 abiflags_in.cpr2_size = BYTE_GET (abiflags_ext->cpr2_size);
13666 abiflags_in.fp_abi = BYTE_GET (abiflags_ext->fp_abi);
13667 abiflags_in.isa_ext = BYTE_GET (abiflags_ext->isa_ext);
13668 abiflags_in.ases = BYTE_GET (abiflags_ext->ases);
13669 abiflags_in.flags1 = BYTE_GET (abiflags_ext->flags1);
13670 abiflags_in.flags2 = BYTE_GET (abiflags_ext->flags2);
13672 printf ("\nMIPS ABI Flags Version: %d\n", abiflags_in.version);
13673 printf ("\nISA: MIPS%d", abiflags_in.isa_level);
13674 if (abiflags_in.isa_rev > 1)
13675 printf ("r%d", abiflags_in.isa_rev);
13676 printf ("\nGPR size: %d",
13677 get_mips_reg_size (abiflags_in.gpr_size));
13678 printf ("\nCPR1 size: %d",
13679 get_mips_reg_size (abiflags_in.cpr1_size));
13680 printf ("\nCPR2 size: %d",
13681 get_mips_reg_size (abiflags_in.cpr2_size));
13682 fputs ("\nFP ABI: ", stdout);
13683 print_mips_fp_abi_value (abiflags_in.fp_abi);
13684 fputs ("ISA Extension: ", stdout);
13685 print_mips_isa_ext (abiflags_in.isa_ext);
13686 fputs ("\nASEs:", stdout);
13687 print_mips_ases (abiflags_in.ases);
13688 printf ("\nFLAGS 1: %8.8lx", abiflags_in.flags1);
13689 printf ("\nFLAGS 2: %8.8lx", abiflags_in.flags2);
13690 fputc ('\n', stdout);
13691 free (abiflags_ext);
13696 /* We have a lot of special sections. Thanks SGI! */
13697 if (dynamic_section == NULL)
13698 /* No information available. */
13701 for (entry = dynamic_section;
13702 /* PR 17531 file: 012-50589-0.004. */
13703 entry < dynamic_section + dynamic_nent && entry->d_tag != DT_NULL;
13705 switch (entry->d_tag)
13707 case DT_MIPS_LIBLIST:
13709 = offset_from_vma (file, entry->d_un.d_val,
13710 liblistno * sizeof (Elf32_External_Lib));
13712 case DT_MIPS_LIBLISTNO:
13713 liblistno = entry->d_un.d_val;
13715 case DT_MIPS_OPTIONS:
13716 options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
13718 case DT_MIPS_CONFLICT:
13720 = offset_from_vma (file, entry->d_un.d_val,
13721 conflictsno * sizeof (Elf32_External_Conflict));
13723 case DT_MIPS_CONFLICTNO:
13724 conflictsno = entry->d_un.d_val;
13727 pltgot = entry->d_un.d_ptr;
13729 case DT_MIPS_LOCAL_GOTNO:
13730 local_gotno = entry->d_un.d_val;
13732 case DT_MIPS_GOTSYM:
13733 gotsym = entry->d_un.d_val;
13735 case DT_MIPS_SYMTABNO:
13736 symtabno = entry->d_un.d_val;
13738 case DT_MIPS_PLTGOT:
13739 mips_pltgot = entry->d_un.d_ptr;
13742 pltrel = entry->d_un.d_val;
13745 pltrelsz = entry->d_un.d_val;
13748 jmprel = entry->d_un.d_ptr;
13754 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
13756 Elf32_External_Lib * elib;
13759 elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
13761 sizeof (Elf32_External_Lib),
13762 _("liblist section data"));
13765 printf (_("\nSection '.liblist' contains %lu entries:\n"),
13766 (unsigned long) liblistno);
13767 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
13770 for (cnt = 0; cnt < liblistno; ++cnt)
13777 liblist.l_name = BYTE_GET (elib[cnt].l_name);
13778 atime = BYTE_GET (elib[cnt].l_time_stamp);
13779 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
13780 liblist.l_version = BYTE_GET (elib[cnt].l_version);
13781 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
13783 tmp = gmtime (&atime);
13784 snprintf (timebuf, sizeof (timebuf),
13785 "%04u-%02u-%02uT%02u:%02u:%02u",
13786 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
13787 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
13789 printf ("%3lu: ", (unsigned long) cnt);
13790 if (VALID_DYNAMIC_NAME (liblist.l_name))
13791 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
13793 printf (_("<corrupt: %9ld>"), liblist.l_name);
13794 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
13795 liblist.l_version);
13797 if (liblist.l_flags == 0)
13801 static const struct
13808 { " EXACT_MATCH", LL_EXACT_MATCH },
13809 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
13810 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
13811 { " EXPORTS", LL_EXPORTS },
13812 { " DELAY_LOAD", LL_DELAY_LOAD },
13813 { " DELTA", LL_DELTA }
13815 int flags = liblist.l_flags;
13818 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
13819 if ((flags & l_flags_vals[fcnt].bit) != 0)
13821 fputs (l_flags_vals[fcnt].name, stdout);
13822 flags ^= l_flags_vals[fcnt].bit;
13825 printf (" %#x", (unsigned int) flags);
13835 if (options_offset != 0)
13837 Elf_External_Options * eopt;
13838 Elf_Internal_Options * iopt;
13839 Elf_Internal_Options * option;
13842 sect = section_headers;
13844 /* Find the section header so that we get the size. */
13845 sect = find_section_by_type (SHT_MIPS_OPTIONS);
13846 /* PR 17533 file: 012-277276-0.004. */
13849 error (_("No MIPS_OPTIONS header found\n"));
13853 eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
13854 sect->sh_size, _("options"));
13857 iopt = (Elf_Internal_Options *)
13858 cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
13861 error (_("Out of memory allocatinf space for MIPS options\n"));
13868 while (offset <= sect->sh_size - sizeof (* eopt))
13870 Elf_External_Options * eoption;
13872 eoption = (Elf_External_Options *) ((char *) eopt + offset);
13874 option->kind = BYTE_GET (eoption->kind);
13875 option->size = BYTE_GET (eoption->size);
13876 option->section = BYTE_GET (eoption->section);
13877 option->info = BYTE_GET (eoption->info);
13879 /* PR 17531: file: ffa0fa3b. */
13880 if (option->size < sizeof (* eopt)
13881 || offset + option->size > sect->sh_size)
13883 error (_("Invalid size (%u) for MIPS option\n"), option->size);
13886 offset += option->size;
13892 printf (_("\nSection '%s' contains %d entries:\n"),
13893 printable_section_name (sect), cnt);
13902 switch (option->kind)
13905 /* This shouldn't happen. */
13906 printf (" NULL %d %lx", option->section, option->info);
13909 printf (" REGINFO ");
13910 if (elf_header.e_machine == EM_MIPS)
13913 Elf32_External_RegInfo * ereg;
13914 Elf32_RegInfo reginfo;
13916 ereg = (Elf32_External_RegInfo *) (option + 1);
13917 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
13918 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
13919 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
13920 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
13921 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
13922 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
13924 printf ("GPR %08lx GP 0x%lx\n",
13925 reginfo.ri_gprmask,
13926 (unsigned long) reginfo.ri_gp_value);
13927 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
13928 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
13929 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
13934 Elf64_External_RegInfo * ereg;
13935 Elf64_Internal_RegInfo reginfo;
13937 ereg = (Elf64_External_RegInfo *) (option + 1);
13938 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
13939 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
13940 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
13941 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
13942 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
13943 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
13945 printf ("GPR %08lx GP 0x",
13946 reginfo.ri_gprmask);
13947 printf_vma (reginfo.ri_gp_value);
13950 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
13951 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
13952 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
13956 case ODK_EXCEPTIONS:
13957 fputs (" EXCEPTIONS fpe_min(", stdout);
13958 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
13959 fputs (") fpe_max(", stdout);
13960 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
13961 fputs (")", stdout);
13963 if (option->info & OEX_PAGE0)
13964 fputs (" PAGE0", stdout);
13965 if (option->info & OEX_SMM)
13966 fputs (" SMM", stdout);
13967 if (option->info & OEX_FPDBUG)
13968 fputs (" FPDBUG", stdout);
13969 if (option->info & OEX_DISMISS)
13970 fputs (" DISMISS", stdout);
13973 fputs (" PAD ", stdout);
13974 if (option->info & OPAD_PREFIX)
13975 fputs (" PREFIX", stdout);
13976 if (option->info & OPAD_POSTFIX)
13977 fputs (" POSTFIX", stdout);
13978 if (option->info & OPAD_SYMBOL)
13979 fputs (" SYMBOL", stdout);
13982 fputs (" HWPATCH ", stdout);
13983 if (option->info & OHW_R4KEOP)
13984 fputs (" R4KEOP", stdout);
13985 if (option->info & OHW_R8KPFETCH)
13986 fputs (" R8KPFETCH", stdout);
13987 if (option->info & OHW_R5KEOP)
13988 fputs (" R5KEOP", stdout);
13989 if (option->info & OHW_R5KCVTL)
13990 fputs (" R5KCVTL", stdout);
13993 fputs (" FILL ", stdout);
13994 /* XXX Print content of info word? */
13997 fputs (" TAGS ", stdout);
13998 /* XXX Print content of info word? */
14001 fputs (" HWAND ", stdout);
14002 if (option->info & OHWA0_R4KEOP_CHECKED)
14003 fputs (" R4KEOP_CHECKED", stdout);
14004 if (option->info & OHWA0_R4KEOP_CLEAN)
14005 fputs (" R4KEOP_CLEAN", stdout);
14008 fputs (" HWOR ", stdout);
14009 if (option->info & OHWA0_R4KEOP_CHECKED)
14010 fputs (" R4KEOP_CHECKED", stdout);
14011 if (option->info & OHWA0_R4KEOP_CLEAN)
14012 fputs (" R4KEOP_CLEAN", stdout);
14015 printf (" GP_GROUP %#06lx self-contained %#06lx",
14016 option->info & OGP_GROUP,
14017 (option->info & OGP_SELF) >> 16);
14020 printf (" IDENT %#06lx self-contained %#06lx",
14021 option->info & OGP_GROUP,
14022 (option->info & OGP_SELF) >> 16);
14025 /* This shouldn't happen. */
14026 printf (" %3d ??? %d %lx",
14027 option->kind, option->section, option->info);
14031 len = sizeof (* eopt);
14032 while (len < option->size)
14034 char datum = * ((char *) eopt + offset + len);
14036 if (ISPRINT (datum))
14037 printf ("%c", datum);
14039 printf ("\\%03o", datum);
14042 fputs ("\n", stdout);
14044 offset += option->size;
14052 if (conflicts_offset != 0 && conflictsno != 0)
14054 Elf32_Conflict * iconf;
14057 if (dynamic_symbols == NULL)
14059 error (_("conflict list found without a dynamic symbol table\n"));
14063 iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
14066 error (_("Out of memory allocating space for dynamic conflicts\n"));
14072 Elf32_External_Conflict * econf32;
14074 econf32 = (Elf32_External_Conflict *)
14075 get_data (NULL, file, conflicts_offset, conflictsno,
14076 sizeof (* econf32), _("conflict"));
14080 for (cnt = 0; cnt < conflictsno; ++cnt)
14081 iconf[cnt] = BYTE_GET (econf32[cnt]);
14087 Elf64_External_Conflict * econf64;
14089 econf64 = (Elf64_External_Conflict *)
14090 get_data (NULL, file, conflicts_offset, conflictsno,
14091 sizeof (* econf64), _("conflict"));
14095 for (cnt = 0; cnt < conflictsno; ++cnt)
14096 iconf[cnt] = BYTE_GET (econf64[cnt]);
14101 printf (_("\nSection '.conflict' contains %lu entries:\n"),
14102 (unsigned long) conflictsno);
14103 puts (_(" Num: Index Value Name"));
14105 for (cnt = 0; cnt < conflictsno; ++cnt)
14107 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
14109 if (iconf[cnt] >= num_dynamic_syms)
14110 printf (_("<corrupt symbol index>"));
14113 Elf_Internal_Sym * psym;
14115 psym = & dynamic_symbols[iconf[cnt]];
14116 print_vma (psym->st_value, FULL_HEX);
14118 if (VALID_DYNAMIC_NAME (psym->st_name))
14119 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
14121 printf (_("<corrupt: %14ld>"), psym->st_name);
14129 if (pltgot != 0 && local_gotno != 0)
14131 bfd_vma ent, local_end, global_end;
14133 unsigned char * data;
14134 unsigned char * data_end;
14138 addr_size = (is_32bit_elf ? 4 : 8);
14139 local_end = pltgot + local_gotno * addr_size;
14141 /* PR binutils/17533 file: 012-111227-0.004 */
14142 if (symtabno < gotsym)
14144 error (_("The GOT symbol offset (%lu) is greater than the symbol table size (%lu)\n"),
14145 (unsigned long) gotsym, (unsigned long) symtabno);
14149 global_end = local_end + (symtabno - gotsym) * addr_size;
14150 /* PR 17531: file: 54c91a34. */
14151 if (global_end < local_end)
14153 error (_("Too many GOT symbols: %lu\n"), (unsigned long) symtabno);
14157 offset = offset_from_vma (file, pltgot, global_end - pltgot);
14158 data = (unsigned char *) get_data (NULL, file, offset,
14159 global_end - pltgot, 1,
14160 _("Global Offset Table data"));
14163 data_end = data + (global_end - pltgot);
14165 printf (_("\nPrimary GOT:\n"));
14166 printf (_(" Canonical gp value: "));
14167 print_vma (pltgot + 0x7ff0, LONG_HEX);
14170 printf (_(" Reserved entries:\n"));
14171 printf (_(" %*s %10s %*s Purpose\n"),
14172 addr_size * 2, _("Address"), _("Access"),
14173 addr_size * 2, _("Initial"));
14174 ent = print_mips_got_entry (data, pltgot, ent, data_end);
14175 printf (_(" Lazy resolver\n"));
14176 if (ent == (bfd_vma) -1)
14177 goto got_print_fail;
14179 && (byte_get (data + ent - pltgot, addr_size)
14180 >> (addr_size * 8 - 1)) != 0)
14182 ent = print_mips_got_entry (data, pltgot, ent, data_end);
14183 printf (_(" Module pointer (GNU extension)\n"));
14184 if (ent == (bfd_vma) -1)
14185 goto got_print_fail;
14189 if (ent < local_end)
14191 printf (_(" Local entries:\n"));
14192 printf (" %*s %10s %*s\n",
14193 addr_size * 2, _("Address"), _("Access"),
14194 addr_size * 2, _("Initial"));
14195 while (ent < local_end)
14197 ent = print_mips_got_entry (data, pltgot, ent, data_end);
14199 if (ent == (bfd_vma) -1)
14200 goto got_print_fail;
14205 if (gotsym < symtabno)
14209 printf (_(" Global entries:\n"));
14210 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
14211 addr_size * 2, _("Address"),
14213 addr_size * 2, _("Initial"),
14214 addr_size * 2, _("Sym.Val."),
14216 /* Note for translators: "Ndx" = abbreviated form of "Index". */
14217 _("Ndx"), _("Name"));
14219 sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
14221 for (i = gotsym; i < symtabno; i++)
14223 ent = print_mips_got_entry (data, pltgot, ent, data_end);
14226 if (dynamic_symbols == NULL)
14227 printf (_("<no dynamic symbols>"));
14228 else if (i < num_dynamic_syms)
14230 Elf_Internal_Sym * psym = dynamic_symbols + i;
14232 print_vma (psym->st_value, LONG_HEX);
14233 printf (" %-7s %3s ",
14234 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
14235 get_symbol_index_type (psym->st_shndx));
14237 if (VALID_DYNAMIC_NAME (psym->st_name))
14238 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
14240 printf (_("<corrupt: %14ld>"), psym->st_name);
14243 printf (_("<symbol index %lu exceeds number of dynamic symbols>"),
14244 (unsigned long) i);
14247 if (ent == (bfd_vma) -1)
14258 if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
14261 size_t offset, rel_offset;
14262 unsigned long count, i;
14263 unsigned char * data;
14264 int addr_size, sym_width;
14265 Elf_Internal_Rela * rels;
14267 rel_offset = offset_from_vma (file, jmprel, pltrelsz);
14268 if (pltrel == DT_RELA)
14270 if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
14275 if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
14280 addr_size = (is_32bit_elf ? 4 : 8);
14281 end = mips_pltgot + (2 + count) * addr_size;
14283 offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
14284 data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
14285 1, _("Procedure Linkage Table data"));
14289 printf ("\nPLT GOT:\n\n");
14290 printf (_(" Reserved entries:\n"));
14291 printf (_(" %*s %*s Purpose\n"),
14292 addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
14293 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
14294 printf (_(" PLT lazy resolver\n"));
14295 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
14296 printf (_(" Module pointer\n"));
14299 printf (_(" Entries:\n"));
14300 printf (" %*s %*s %*s %-7s %3s %s\n",
14301 addr_size * 2, _("Address"),
14302 addr_size * 2, _("Initial"),
14303 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
14304 sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
14305 for (i = 0; i < count; i++)
14307 unsigned long idx = get_reloc_symindex (rels[i].r_info);
14309 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
14312 if (idx >= num_dynamic_syms)
14313 printf (_("<corrupt symbol index: %lu>"), idx);
14316 Elf_Internal_Sym * psym = dynamic_symbols + idx;
14318 print_vma (psym->st_value, LONG_HEX);
14319 printf (" %-7s %3s ",
14320 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
14321 get_symbol_index_type (psym->st_shndx));
14322 if (VALID_DYNAMIC_NAME (psym->st_name))
14323 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
14325 printf (_("<corrupt: %14ld>"), psym->st_name);
14340 process_nds32_specific (FILE * file)
14342 Elf_Internal_Shdr *sect = NULL;
14344 sect = find_section (".nds32_e_flags");
14347 unsigned int *flag;
14349 printf ("\nNDS32 elf flags section:\n");
14350 flag = get_data (NULL, file, sect->sh_offset, 1,
14351 sect->sh_size, _("NDS32 elf flags section"));
14353 switch ((*flag) & 0x3)
14356 printf ("(VEC_SIZE):\tNo entry.\n");
14359 printf ("(VEC_SIZE):\t4 bytes\n");
14362 printf ("(VEC_SIZE):\t16 bytes\n");
14365 printf ("(VEC_SIZE):\treserved\n");
14374 process_gnu_liblist (FILE * file)
14376 Elf_Internal_Shdr * section;
14377 Elf_Internal_Shdr * string_sec;
14378 Elf32_External_Lib * elib;
14380 size_t strtab_size;
14387 for (i = 0, section = section_headers;
14388 i < elf_header.e_shnum;
14391 switch (section->sh_type)
14393 case SHT_GNU_LIBLIST:
14394 if (section->sh_link >= elf_header.e_shnum)
14397 elib = (Elf32_External_Lib *)
14398 get_data (NULL, file, section->sh_offset, 1, section->sh_size,
14399 _("liblist section data"));
14403 string_sec = section_headers + section->sh_link;
14405 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
14406 string_sec->sh_size,
14407 _("liblist string table"));
14409 || section->sh_entsize != sizeof (Elf32_External_Lib))
14415 strtab_size = string_sec->sh_size;
14417 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
14418 printable_section_name (section),
14419 (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
14421 puts (_(" Library Time Stamp Checksum Version Flags"));
14423 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
14431 liblist.l_name = BYTE_GET (elib[cnt].l_name);
14432 atime = BYTE_GET (elib[cnt].l_time_stamp);
14433 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
14434 liblist.l_version = BYTE_GET (elib[cnt].l_version);
14435 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
14437 tmp = gmtime (&atime);
14438 snprintf (timebuf, sizeof (timebuf),
14439 "%04u-%02u-%02uT%02u:%02u:%02u",
14440 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
14441 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
14443 printf ("%3lu: ", (unsigned long) cnt);
14445 printf ("%-20s", liblist.l_name < strtab_size
14446 ? strtab + liblist.l_name : _("<corrupt>"));
14448 printf ("%-20.20s", liblist.l_name < strtab_size
14449 ? strtab + liblist.l_name : _("<corrupt>"));
14450 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
14451 liblist.l_version, liblist.l_flags);
14462 static const char *
14463 get_note_type (unsigned e_type)
14465 static char buff[64];
14467 if (elf_header.e_type == ET_CORE)
14471 return _("NT_AUXV (auxiliary vector)");
14473 return _("NT_PRSTATUS (prstatus structure)");
14475 return _("NT_FPREGSET (floating point registers)");
14477 return _("NT_PRPSINFO (prpsinfo structure)");
14478 case NT_TASKSTRUCT:
14479 return _("NT_TASKSTRUCT (task structure)");
14481 return _("NT_PRXFPREG (user_xfpregs structure)");
14483 return _("NT_PPC_VMX (ppc Altivec registers)");
14485 return _("NT_PPC_VSX (ppc VSX registers)");
14487 return _("NT_386_TLS (x86 TLS information)");
14488 case NT_386_IOPERM:
14489 return _("NT_386_IOPERM (x86 I/O permissions)");
14490 case NT_X86_XSTATE:
14491 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
14492 case NT_S390_HIGH_GPRS:
14493 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
14494 case NT_S390_TIMER:
14495 return _("NT_S390_TIMER (s390 timer register)");
14496 case NT_S390_TODCMP:
14497 return _("NT_S390_TODCMP (s390 TOD comparator register)");
14498 case NT_S390_TODPREG:
14499 return _("NT_S390_TODPREG (s390 TOD programmable register)");
14501 return _("NT_S390_CTRS (s390 control registers)");
14502 case NT_S390_PREFIX:
14503 return _("NT_S390_PREFIX (s390 prefix register)");
14504 case NT_S390_LAST_BREAK:
14505 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
14506 case NT_S390_SYSTEM_CALL:
14507 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
14509 return _("NT_S390_TDB (s390 transaction diagnostic block)");
14511 return _("NT_ARM_VFP (arm VFP registers)");
14513 return _("NT_ARM_TLS (AArch TLS registers)");
14514 case NT_ARM_HW_BREAK:
14515 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
14516 case NT_ARM_HW_WATCH:
14517 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
14519 return _("NT_PSTATUS (pstatus structure)");
14521 return _("NT_FPREGS (floating point registers)");
14523 return _("NT_PSINFO (psinfo structure)");
14525 return _("NT_LWPSTATUS (lwpstatus_t structure)");
14527 return _("NT_LWPSINFO (lwpsinfo_t structure)");
14528 case NT_WIN32PSTATUS:
14529 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
14531 return _("NT_SIGINFO (siginfo_t data)");
14533 return _("NT_FILE (mapped files)");
14541 return _("NT_VERSION (version)");
14543 return _("NT_ARCH (architecture)");
14548 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
14553 print_core_note (Elf_Internal_Note *pnote)
14555 unsigned int addr_size = is_32bit_elf ? 4 : 8;
14556 bfd_vma count, page_size;
14557 unsigned char *descdata, *filenames, *descend;
14559 if (pnote->type != NT_FILE)
14565 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
14566 /* Still "successful". */
14571 if (pnote->descsz < 2 * addr_size)
14573 printf (_(" Malformed note - too short for header\n"));
14577 descdata = (unsigned char *) pnote->descdata;
14578 descend = descdata + pnote->descsz;
14580 if (descdata[pnote->descsz - 1] != '\0')
14582 printf (_(" Malformed note - does not end with \\0\n"));
14586 count = byte_get (descdata, addr_size);
14587 descdata += addr_size;
14589 page_size = byte_get (descdata, addr_size);
14590 descdata += addr_size;
14592 if (pnote->descsz < 2 * addr_size + count * 3 * addr_size)
14594 printf (_(" Malformed note - too short for supplied file count\n"));
14598 printf (_(" Page size: "));
14599 print_vma (page_size, DEC);
14602 printf (_(" %*s%*s%*s\n"),
14603 (int) (2 + 2 * addr_size), _("Start"),
14604 (int) (4 + 2 * addr_size), _("End"),
14605 (int) (4 + 2 * addr_size), _("Page Offset"));
14606 filenames = descdata + count * 3 * addr_size;
14607 while (--count > 0)
14609 bfd_vma start, end, file_ofs;
14611 if (filenames == descend)
14613 printf (_(" Malformed note - filenames end too early\n"));
14617 start = byte_get (descdata, addr_size);
14618 descdata += addr_size;
14619 end = byte_get (descdata, addr_size);
14620 descdata += addr_size;
14621 file_ofs = byte_get (descdata, addr_size);
14622 descdata += addr_size;
14625 print_vma (start, FULL_HEX);
14627 print_vma (end, FULL_HEX);
14629 print_vma (file_ofs, FULL_HEX);
14630 printf ("\n %s\n", filenames);
14632 filenames += 1 + strlen ((char *) filenames);
14638 static const char *
14639 get_gnu_elf_note_type (unsigned e_type)
14641 static char buff[64];
14645 case NT_GNU_ABI_TAG:
14646 return _("NT_GNU_ABI_TAG (ABI version tag)");
14648 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
14649 case NT_GNU_BUILD_ID:
14650 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
14651 case NT_GNU_GOLD_VERSION:
14652 return _("NT_GNU_GOLD_VERSION (gold version)");
14657 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
14662 print_gnu_note (Elf_Internal_Note *pnote)
14664 switch (pnote->type)
14666 case NT_GNU_BUILD_ID:
14670 printf (_(" Build ID: "));
14671 for (i = 0; i < pnote->descsz; ++i)
14672 printf ("%02x", pnote->descdata[i] & 0xff);
14677 case NT_GNU_ABI_TAG:
14679 unsigned long os, major, minor, subminor;
14680 const char *osname;
14682 /* PR 17531: file: 030-599401-0.004. */
14683 if (pnote->descsz < 16)
14685 printf (_(" <corrupt GNU_ABI_TAG>\n"));
14689 os = byte_get ((unsigned char *) pnote->descdata, 4);
14690 major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
14691 minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
14692 subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
14696 case GNU_ABI_TAG_LINUX:
14699 case GNU_ABI_TAG_HURD:
14702 case GNU_ABI_TAG_SOLARIS:
14703 osname = "Solaris";
14705 case GNU_ABI_TAG_FREEBSD:
14706 osname = "FreeBSD";
14708 case GNU_ABI_TAG_NETBSD:
14712 osname = "Unknown";
14716 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname,
14717 major, minor, subminor);
14721 case NT_GNU_GOLD_VERSION:
14725 printf (_(" Version: "));
14726 for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
14727 printf ("%c", pnote->descdata[i]);
14736 static const char *
14737 get_netbsd_elfcore_note_type (unsigned e_type)
14739 static char buff[64];
14741 if (e_type == NT_NETBSDCORE_PROCINFO)
14743 /* NetBSD core "procinfo" structure. */
14744 return _("NetBSD procinfo structure");
14747 /* As of Jan 2002 there are no other machine-independent notes
14748 defined for NetBSD core files. If the note type is less
14749 than the start of the machine-dependent note types, we don't
14752 if (e_type < NT_NETBSDCORE_FIRSTMACH)
14754 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
14758 switch (elf_header.e_machine)
14760 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
14761 and PT_GETFPREGS == mach+2. */
14766 case EM_SPARC32PLUS:
14770 case NT_NETBSDCORE_FIRSTMACH + 0:
14771 return _("PT_GETREGS (reg structure)");
14772 case NT_NETBSDCORE_FIRSTMACH + 2:
14773 return _("PT_GETFPREGS (fpreg structure)");
14779 /* On all other arch's, PT_GETREGS == mach+1 and
14780 PT_GETFPREGS == mach+3. */
14784 case NT_NETBSDCORE_FIRSTMACH + 1:
14785 return _("PT_GETREGS (reg structure)");
14786 case NT_NETBSDCORE_FIRSTMACH + 3:
14787 return _("PT_GETFPREGS (fpreg structure)");
14793 snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
14794 e_type - NT_NETBSDCORE_FIRSTMACH);
14798 static const char *
14799 get_stapsdt_note_type (unsigned e_type)
14801 static char buff[64];
14806 return _("NT_STAPSDT (SystemTap probe descriptors)");
14812 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
14817 print_stapsdt_note (Elf_Internal_Note *pnote)
14819 int addr_size = is_32bit_elf ? 4 : 8;
14820 char *data = pnote->descdata;
14821 char *data_end = pnote->descdata + pnote->descsz;
14822 bfd_vma pc, base_addr, semaphore;
14823 char *provider, *probe, *arg_fmt;
14825 pc = byte_get ((unsigned char *) data, addr_size);
14827 base_addr = byte_get ((unsigned char *) data, addr_size);
14829 semaphore = byte_get ((unsigned char *) data, addr_size);
14833 data += strlen (data) + 1;
14835 data += strlen (data) + 1;
14837 data += strlen (data) + 1;
14839 printf (_(" Provider: %s\n"), provider);
14840 printf (_(" Name: %s\n"), probe);
14841 printf (_(" Location: "));
14842 print_vma (pc, FULL_HEX);
14843 printf (_(", Base: "));
14844 print_vma (base_addr, FULL_HEX);
14845 printf (_(", Semaphore: "));
14846 print_vma (semaphore, FULL_HEX);
14848 printf (_(" Arguments: %s\n"), arg_fmt);
14850 return data == data_end;
14853 static const char *
14854 get_ia64_vms_note_type (unsigned e_type)
14856 static char buff[64];
14861 return _("NT_VMS_MHD (module header)");
14863 return _("NT_VMS_LNM (language name)");
14865 return _("NT_VMS_SRC (source files)");
14867 return "NT_VMS_TITLE";
14869 return _("NT_VMS_EIDC (consistency check)");
14870 case NT_VMS_FPMODE:
14871 return _("NT_VMS_FPMODE (FP mode)");
14872 case NT_VMS_LINKTIME:
14873 return "NT_VMS_LINKTIME";
14874 case NT_VMS_IMGNAM:
14875 return _("NT_VMS_IMGNAM (image name)");
14877 return _("NT_VMS_IMGID (image id)");
14878 case NT_VMS_LINKID:
14879 return _("NT_VMS_LINKID (link id)");
14880 case NT_VMS_IMGBID:
14881 return _("NT_VMS_IMGBID (build id)");
14882 case NT_VMS_GSTNAM:
14883 return _("NT_VMS_GSTNAM (sym table name)");
14884 case NT_VMS_ORIG_DYN:
14885 return "NT_VMS_ORIG_DYN";
14886 case NT_VMS_PATCHTIME:
14887 return "NT_VMS_PATCHTIME";
14889 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
14895 print_ia64_vms_note (Elf_Internal_Note * pnote)
14897 switch (pnote->type)
14900 if (pnote->descsz > 36)
14902 size_t l = strlen (pnote->descdata + 34);
14903 printf (_(" Creation date : %.17s\n"), pnote->descdata);
14904 printf (_(" Last patch date: %.17s\n"), pnote->descdata + 17);
14905 printf (_(" Module name : %s\n"), pnote->descdata + 34);
14906 printf (_(" Module version : %s\n"), pnote->descdata + 34 + l + 1);
14909 printf (_(" Invalid size\n"));
14912 printf (_(" Language: %s\n"), pnote->descdata);
14915 case NT_VMS_FPMODE:
14916 printf (_(" Floating Point mode: "));
14917 printf ("0x%016" BFD_VMA_FMT "x\n",
14918 (bfd_vma)byte_get ((unsigned char *)pnote->descdata, 8));
14920 case NT_VMS_LINKTIME:
14921 printf (_(" Link time: "));
14923 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
14926 case NT_VMS_PATCHTIME:
14927 printf (_(" Patch time: "));
14929 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
14932 case NT_VMS_ORIG_DYN:
14933 printf (_(" Major id: %u, minor id: %u\n"),
14934 (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
14935 (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
14936 printf (_(" Last modified : "));
14938 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
14939 printf (_("\n Link flags : "));
14940 printf ("0x%016" BFD_VMA_FMT "x\n",
14941 (bfd_vma)byte_get ((unsigned char *)pnote->descdata + 16, 8));
14942 printf (_(" Header flags: 0x%08x\n"),
14943 (unsigned)byte_get ((unsigned char *)pnote->descdata + 24, 4));
14944 printf (_(" Image id : %s\n"), pnote->descdata + 32);
14947 case NT_VMS_IMGNAM:
14948 printf (_(" Image name: %s\n"), pnote->descdata);
14950 case NT_VMS_GSTNAM:
14951 printf (_(" Global symbol table name: %s\n"), pnote->descdata);
14954 printf (_(" Image id: %s\n"), pnote->descdata);
14956 case NT_VMS_LINKID:
14957 printf (_(" Linker id: %s\n"), pnote->descdata);
14965 /* Note that by the ELF standard, the name field is already null byte
14966 terminated, and namesz includes the terminating null byte.
14967 I.E. the value of namesz for the name "FSF" is 4.
14969 If the value of namesz is zero, there is no name present. */
14971 process_note (Elf_Internal_Note * pnote)
14973 const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
14976 if (pnote->namesz == 0)
14977 /* If there is no note name, then use the default set of
14978 note type strings. */
14979 nt = get_note_type (pnote->type);
14981 else if (const_strneq (pnote->namedata, "GNU"))
14982 /* GNU-specific object file notes. */
14983 nt = get_gnu_elf_note_type (pnote->type);
14985 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
14986 /* NetBSD-specific core file notes. */
14987 nt = get_netbsd_elfcore_note_type (pnote->type);
14989 else if (strneq (pnote->namedata, "SPU/", 4))
14991 /* SPU-specific core file notes. */
14992 nt = pnote->namedata + 4;
14996 else if (const_strneq (pnote->namedata, "IPF/VMS"))
14997 /* VMS/ia64-specific file notes. */
14998 nt = get_ia64_vms_note_type (pnote->type);
15000 else if (const_strneq (pnote->namedata, "stapsdt"))
15001 nt = get_stapsdt_note_type (pnote->type);
15004 /* Don't recognize this note name; just use the default set of
15005 note type strings. */
15006 nt = get_note_type (pnote->type);
15008 printf (" %-20s 0x%08lx\t%s\n", name, pnote->descsz, nt);
15010 if (const_strneq (pnote->namedata, "IPF/VMS"))
15011 return print_ia64_vms_note (pnote);
15012 else if (const_strneq (pnote->namedata, "GNU"))
15013 return print_gnu_note (pnote);
15014 else if (const_strneq (pnote->namedata, "stapsdt"))
15015 return print_stapsdt_note (pnote);
15016 else if (const_strneq (pnote->namedata, "CORE"))
15017 return print_core_note (pnote);
15024 process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
15026 Elf_External_Note * pnotes;
15027 Elf_External_Note * external;
15033 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
15035 if (pnotes == NULL)
15040 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
15041 (unsigned long) offset, (unsigned long) length);
15042 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
15044 while ((char *) external < (char *) pnotes + length)
15046 Elf_Internal_Note inote;
15049 char * temp = NULL;
15050 size_t data_remaining = ((char *) pnotes + length) - (char *) external;
15052 if (!is_ia64_vms ())
15054 /* PR binutils/15191
15055 Make sure that there is enough data to read. */
15056 min_notesz = offsetof (Elf_External_Note, name);
15057 if (data_remaining < min_notesz)
15059 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15060 (int) data_remaining);
15063 inote.type = BYTE_GET (external->type);
15064 inote.namesz = BYTE_GET (external->namesz);
15065 inote.namedata = external->name;
15066 inote.descsz = BYTE_GET (external->descsz);
15067 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
15068 inote.descpos = offset + (inote.descdata - (char *) pnotes);
15069 next = inote.descdata + align_power (inote.descsz, 2);
15073 Elf64_External_VMS_Note *vms_external;
15075 /* PR binutils/15191
15076 Make sure that there is enough data to read. */
15077 min_notesz = offsetof (Elf64_External_VMS_Note, name);
15078 if (data_remaining < min_notesz)
15080 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
15081 (int) data_remaining);
15085 vms_external = (Elf64_External_VMS_Note *) external;
15086 inote.type = BYTE_GET (vms_external->type);
15087 inote.namesz = BYTE_GET (vms_external->namesz);
15088 inote.namedata = vms_external->name;
15089 inote.descsz = BYTE_GET (vms_external->descsz);
15090 inote.descdata = inote.namedata + align_power (inote.namesz, 3);
15091 inote.descpos = offset + (inote.descdata - (char *) pnotes);
15092 next = inote.descdata + align_power (inote.descsz, 3);
15095 if (inote.descdata < (char *) external + min_notesz
15096 || next < (char *) external + min_notesz
15097 /* PR binutils/17531: file: id:000000,sig:11,src:006986,op:havoc,rep:4. */
15098 || inote.namedata + inote.namesz < inote.namedata
15099 || inote.descdata + inote.descsz < inote.descdata
15100 || data_remaining < (size_t)(next - (char *) external))
15102 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
15103 (unsigned long) ((char *) external - (char *) pnotes));
15104 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
15105 inote.type, inote.namesz, inote.descsz);
15109 external = (Elf_External_Note *) next;
15111 /* Verify that name is null terminated. It appears that at least
15112 one version of Linux (RedHat 6.0) generates corefiles that don't
15113 comply with the ELF spec by failing to include the null byte in
15115 if (inote.namedata[inote.namesz - 1] != '\0')
15117 temp = (char *) malloc (inote.namesz + 1);
15120 error (_("Out of memory allocating space for inote name\n"));
15125 strncpy (temp, inote.namedata, inote.namesz);
15126 temp[inote.namesz] = 0;
15128 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
15129 inote.namedata = temp;
15132 res &= process_note (& inote);
15147 process_corefile_note_segments (FILE * file)
15149 Elf_Internal_Phdr * segment;
15153 if (! get_program_headers (file))
15156 for (i = 0, segment = program_headers;
15157 i < elf_header.e_phnum;
15160 if (segment->p_type == PT_NOTE)
15161 res &= process_corefile_note_segment (file,
15162 (bfd_vma) segment->p_offset,
15163 (bfd_vma) segment->p_filesz);
15170 process_note_sections (FILE * file)
15172 Elf_Internal_Shdr * section;
15177 for (i = 0, section = section_headers;
15178 i < elf_header.e_shnum && section != NULL;
15180 if (section->sh_type == SHT_NOTE)
15182 res &= process_corefile_note_segment (file,
15183 (bfd_vma) section->sh_offset,
15184 (bfd_vma) section->sh_size);
15189 /* Try processing NOTE segments instead. */
15190 return process_corefile_note_segments (file);
15196 process_notes (FILE * file)
15198 /* If we have not been asked to display the notes then do nothing. */
15202 if (elf_header.e_type != ET_CORE)
15203 return process_note_sections (file);
15205 /* No program headers means no NOTE segment. */
15206 if (elf_header.e_phnum > 0)
15207 return process_corefile_note_segments (file);
15209 printf (_("No note segments present in the core file.\n"));
15214 process_arch_specific (FILE * file)
15219 switch (elf_header.e_machine)
15222 return process_arm_specific (file);
15224 case EM_MIPS_RS3_LE:
15225 return process_mips_specific (file);
15228 return process_nds32_specific (file);
15231 return process_power_specific (file);
15234 case EM_SPARC32PLUS:
15236 return process_sparc_specific (file);
15239 return process_tic6x_specific (file);
15242 return process_msp430x_specific (file);
15250 get_file_header (FILE * file)
15252 /* Read in the identity array. */
15253 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
15256 /* Determine how to read the rest of the header. */
15257 switch (elf_header.e_ident[EI_DATA])
15259 default: /* fall through */
15260 case ELFDATANONE: /* fall through */
15262 byte_get = byte_get_little_endian;
15263 byte_put = byte_put_little_endian;
15266 byte_get = byte_get_big_endian;
15267 byte_put = byte_put_big_endian;
15271 /* For now we only support 32 bit and 64 bit ELF files. */
15272 is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
15274 /* Read in the rest of the header. */
15277 Elf32_External_Ehdr ehdr32;
15279 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
15282 elf_header.e_type = BYTE_GET (ehdr32.e_type);
15283 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
15284 elf_header.e_version = BYTE_GET (ehdr32.e_version);
15285 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
15286 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
15287 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
15288 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
15289 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
15290 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
15291 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
15292 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
15293 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
15294 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
15298 Elf64_External_Ehdr ehdr64;
15300 /* If we have been compiled with sizeof (bfd_vma) == 4, then
15301 we will not be able to cope with the 64bit data found in
15302 64 ELF files. Detect this now and abort before we start
15303 overwriting things. */
15304 if (sizeof (bfd_vma) < 8)
15306 error (_("This instance of readelf has been built without support for a\n\
15307 64 bit data type and so it cannot read 64 bit ELF files.\n"));
15311 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
15314 elf_header.e_type = BYTE_GET (ehdr64.e_type);
15315 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
15316 elf_header.e_version = BYTE_GET (ehdr64.e_version);
15317 elf_header.e_entry = BYTE_GET (ehdr64.e_entry);
15318 elf_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
15319 elf_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
15320 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
15321 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
15322 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
15323 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
15324 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
15325 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
15326 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
15329 if (elf_header.e_shoff)
15331 /* There may be some extensions in the first section header. Don't
15332 bomb if we can't read it. */
15334 get_32bit_section_headers (file, TRUE);
15336 get_64bit_section_headers (file, TRUE);
15342 /* Process one ELF object file according to the command line options.
15343 This file may actually be stored in an archive. The file is
15344 positioned at the start of the ELF object. */
15347 process_object (char * file_name, FILE * file)
15351 if (! get_file_header (file))
15353 error (_("%s: Failed to read file header\n"), file_name);
15357 /* Initialise per file variables. */
15358 for (i = ARRAY_SIZE (version_info); i--;)
15359 version_info[i] = 0;
15361 for (i = ARRAY_SIZE (dynamic_info); i--;)
15362 dynamic_info[i] = 0;
15363 dynamic_info_DT_GNU_HASH = 0;
15365 /* Process the file. */
15367 printf (_("\nFile: %s\n"), file_name);
15369 /* Initialise the dump_sects array from the cmdline_dump_sects array.
15370 Note we do this even if cmdline_dump_sects is empty because we
15371 must make sure that the dump_sets array is zeroed out before each
15372 object file is processed. */
15373 if (num_dump_sects > num_cmdline_dump_sects)
15374 memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
15376 if (num_cmdline_dump_sects > 0)
15378 if (num_dump_sects == 0)
15379 /* A sneaky way of allocating the dump_sects array. */
15380 request_dump_bynumber (num_cmdline_dump_sects, 0);
15382 assert (num_dump_sects >= num_cmdline_dump_sects);
15383 memcpy (dump_sects, cmdline_dump_sects,
15384 num_cmdline_dump_sects * sizeof (* dump_sects));
15387 if (! process_file_header ())
15390 if (! process_section_headers (file))
15392 /* Without loaded section headers we cannot process lots of
15394 do_unwind = do_version = do_dump = do_arch = 0;
15396 if (! do_using_dynamic)
15397 do_syms = do_dyn_syms = do_reloc = 0;
15400 if (! process_section_groups (file))
15402 /* Without loaded section groups we cannot process unwind. */
15406 if (process_program_headers (file))
15407 process_dynamic_section (file);
15409 process_relocs (file);
15411 process_unwind (file);
15413 process_symbol_table (file);
15415 process_syminfo (file);
15417 process_version_sections (file);
15419 process_section_contents (file);
15421 process_notes (file);
15423 process_gnu_liblist (file);
15425 process_arch_specific (file);
15427 if (program_headers)
15429 free (program_headers);
15430 program_headers = NULL;
15433 if (section_headers)
15435 free (section_headers);
15436 section_headers = NULL;
15441 free (string_table);
15442 string_table = NULL;
15443 string_table_length = 0;
15446 if (dynamic_strings)
15448 free (dynamic_strings);
15449 dynamic_strings = NULL;
15450 dynamic_strings_length = 0;
15453 if (dynamic_symbols)
15455 free (dynamic_symbols);
15456 dynamic_symbols = NULL;
15457 num_dynamic_syms = 0;
15460 if (dynamic_syminfo)
15462 free (dynamic_syminfo);
15463 dynamic_syminfo = NULL;
15466 if (dynamic_section)
15468 free (dynamic_section);
15469 dynamic_section = NULL;
15472 if (section_headers_groups)
15474 free (section_headers_groups);
15475 section_headers_groups = NULL;
15478 if (section_groups)
15480 struct group_list * g;
15481 struct group_list * next;
15483 for (i = 0; i < group_count; i++)
15485 for (g = section_groups [i].root; g != NULL; g = next)
15492 free (section_groups);
15493 section_groups = NULL;
15496 free_debug_memory ();
15501 /* Process an ELF archive.
15502 On entry the file is positioned just after the ARMAG string. */
15505 process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
15507 struct archive_info arch;
15508 struct archive_info nested_arch;
15514 /* The ARCH structure is used to hold information about this archive. */
15515 arch.file_name = NULL;
15517 arch.index_array = NULL;
15518 arch.sym_table = NULL;
15519 arch.longnames = NULL;
15521 /* The NESTED_ARCH structure is used as a single-item cache of information
15522 about a nested archive (when members of a thin archive reside within
15523 another regular archive file). */
15524 nested_arch.file_name = NULL;
15525 nested_arch.file = NULL;
15526 nested_arch.index_array = NULL;
15527 nested_arch.sym_table = NULL;
15528 nested_arch.longnames = NULL;
15530 if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
15536 if (do_archive_index)
15538 if (arch.sym_table == NULL)
15539 error (_("%s: unable to dump the index as none was found\n"), file_name);
15542 unsigned long i, l;
15543 unsigned long current_pos;
15545 printf (_("Index of archive %s: (%lu entries, 0x%lx bytes in the symbol table)\n"),
15546 file_name, (unsigned long) arch.index_num, arch.sym_size);
15547 current_pos = ftell (file);
15549 for (i = l = 0; i < arch.index_num; i++)
15551 if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
15553 char * member_name;
15555 member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
15557 if (member_name != NULL)
15559 char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
15561 if (qualified_name != NULL)
15563 printf (_("Contents of binary %s at offset "), qualified_name);
15564 (void) print_vma (arch.index_array[i], PREFIX_HEX);
15566 free (qualified_name);
15571 if (l >= arch.sym_size)
15573 error (_("%s: end of the symbol table reached before the end of the index\n"),
15577 /* PR 17531: file: 0b6630b2. */
15578 printf ("\t%.*s\n", (int) (arch.sym_size - l), arch.sym_table + l);
15579 l += strnlen (arch.sym_table + l, arch.sym_size - l) + 1;
15582 if (arch.uses_64bit_indicies)
15587 if (l < arch.sym_size)
15588 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
15589 file_name, arch.sym_size - l);
15591 if (fseek (file, current_pos, SEEK_SET) != 0)
15593 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
15599 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
15600 && !do_segments && !do_header && !do_dump && !do_version
15601 && !do_histogram && !do_debugging && !do_arch && !do_notes
15602 && !do_section_groups && !do_dyn_syms)
15604 ret = 0; /* Archive index only. */
15615 char * qualified_name;
15617 /* Read the next archive header. */
15618 if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
15620 error (_("%s: failed to seek to next archive header\n"), file_name);
15623 got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
15624 if (got != sizeof arch.arhdr)
15628 error (_("%s: failed to read archive header\n"), file_name);
15632 if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
15634 error (_("%s: did not find a valid archive header\n"), arch.file_name);
15639 arch.next_arhdr_offset += sizeof arch.arhdr;
15641 archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
15642 if (archive_file_size & 01)
15643 ++archive_file_size;
15645 name = get_archive_member_name (&arch, &nested_arch);
15648 error (_("%s: bad archive file name\n"), file_name);
15652 namelen = strlen (name);
15654 qualified_name = make_qualified_name (&arch, &nested_arch, name);
15655 if (qualified_name == NULL)
15657 error (_("%s: bad archive file name\n"), file_name);
15662 if (is_thin_archive && arch.nested_member_origin == 0)
15664 /* This is a proxy for an external member of a thin archive. */
15665 FILE * member_file;
15666 char * member_file_name = adjust_relative_path (file_name, name, namelen);
15667 if (member_file_name == NULL)
15673 member_file = fopen (member_file_name, "rb");
15674 if (member_file == NULL)
15676 error (_("Input file '%s' is not readable.\n"), member_file_name);
15677 free (member_file_name);
15682 archive_file_offset = arch.nested_member_origin;
15684 ret |= process_object (qualified_name, member_file);
15686 fclose (member_file);
15687 free (member_file_name);
15689 else if (is_thin_archive)
15691 /* PR 15140: Allow for corrupt thin archives. */
15692 if (nested_arch.file == NULL)
15694 error (_("%s: contains corrupt thin archive: %s\n"),
15700 /* This is a proxy for a member of a nested archive. */
15701 archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
15703 /* The nested archive file will have been opened and setup by
15704 get_archive_member_name. */
15705 if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
15707 error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
15712 ret |= process_object (qualified_name, nested_arch.file);
15716 archive_file_offset = arch.next_arhdr_offset;
15717 arch.next_arhdr_offset += archive_file_size;
15719 ret |= process_object (qualified_name, file);
15722 if (dump_sects != NULL)
15726 num_dump_sects = 0;
15729 free (qualified_name);
15733 if (nested_arch.file != NULL)
15734 fclose (nested_arch.file);
15735 release_archive (&nested_arch);
15736 release_archive (&arch);
15742 process_file (char * file_name)
15745 struct stat statbuf;
15746 char armag[SARMAG];
15749 if (stat (file_name, &statbuf) < 0)
15751 if (errno == ENOENT)
15752 error (_("'%s': No such file\n"), file_name);
15754 error (_("Could not locate '%s'. System error message: %s\n"),
15755 file_name, strerror (errno));
15759 if (! S_ISREG (statbuf.st_mode))
15761 error (_("'%s' is not an ordinary file\n"), file_name);
15765 file = fopen (file_name, "rb");
15768 error (_("Input file '%s' is not readable.\n"), file_name);
15772 if (fread (armag, SARMAG, 1, file) != 1)
15774 error (_("%s: Failed to read file's magic number\n"), file_name);
15779 current_file_size = (bfd_size_type) statbuf.st_size;
15781 if (memcmp (armag, ARMAG, SARMAG) == 0)
15782 ret = process_archive (file_name, file, FALSE);
15783 else if (memcmp (armag, ARMAGT, SARMAG) == 0)
15784 ret = process_archive (file_name, file, TRUE);
15787 if (do_archive_index)
15788 error (_("File %s is not an archive so its index cannot be displayed.\n"),
15792 archive_file_size = archive_file_offset = 0;
15793 ret = process_object (file_name, file);
15798 current_file_size = 0;
15802 #ifdef SUPPORT_DISASSEMBLY
15803 /* Needed by the i386 disassembler. For extra credit, someone could
15804 fix this so that we insert symbolic addresses here, esp for GOT/PLT
15808 print_address (unsigned int addr, FILE * outfile)
15810 fprintf (outfile,"0x%8.8x", addr);
15813 /* Needed by the i386 disassembler. */
15815 db_task_printsym (unsigned int addr)
15817 print_address (addr, stderr);
15822 main (int argc, char ** argv)
15826 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
15827 setlocale (LC_MESSAGES, "");
15829 #if defined (HAVE_SETLOCALE)
15830 setlocale (LC_CTYPE, "");
15832 bindtextdomain (PACKAGE, LOCALEDIR);
15833 textdomain (PACKAGE);
15835 expandargv (&argc, &argv);
15837 parse_args (argc, argv);
15839 if (num_dump_sects > 0)
15841 /* Make a copy of the dump_sects array. */
15842 cmdline_dump_sects = (dump_type *)
15843 malloc (num_dump_sects * sizeof (* dump_sects));
15844 if (cmdline_dump_sects == NULL)
15845 error (_("Out of memory allocating dump request table.\n"));
15848 memcpy (cmdline_dump_sects, dump_sects,
15849 num_dump_sects * sizeof (* dump_sects));
15850 num_cmdline_dump_sects = num_dump_sects;
15854 if (optind < (argc - 1))
15858 while (optind < argc)
15859 err |= process_file (argv[optind++]);
15861 if (dump_sects != NULL)
15863 if (cmdline_dump_sects != NULL)
15864 free (cmdline_dump_sects);