1 /* readelf.c -- display contents of an ELF format file
2 Copyright (C) 1998-2014 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"
110 #include "elf/hppa.h"
111 #include "elf/i386.h"
112 #include "elf/i370.h"
113 #include "elf/i860.h"
114 #include "elf/i960.h"
115 #include "elf/ia64.h"
116 #include "elf/ip2k.h"
117 #include "elf/lm32.h"
118 #include "elf/iq2000.h"
119 #include "elf/m32c.h"
120 #include "elf/m32r.h"
121 #include "elf/m68k.h"
122 #include "elf/m68hc11.h"
123 #include "elf/mcore.h"
125 #include "elf/metag.h"
126 #include "elf/microblaze.h"
127 #include "elf/mips.h"
128 #include "elf/mmix.h"
129 #include "elf/mn10200.h"
130 #include "elf/mn10300.h"
131 #include "elf/moxie.h"
133 #include "elf/msp430.h"
134 #include "elf/nds32.h"
135 #include "elf/nios2.h"
136 #include "elf/or32.h"
139 #include "elf/ppc64.h"
140 #include "elf/rl78.h"
142 #include "elf/s390.h"
143 #include "elf/score.h"
145 #include "elf/sparc.h"
147 #include "elf/tic6x.h"
148 #include "elf/tilegx.h"
149 #include "elf/tilepro.h"
150 #include "elf/v850.h"
152 #include "elf/x86-64.h"
153 #include "elf/xc16x.h"
154 #include "elf/xgate.h"
155 #include "elf/xstormy16.h"
156 #include "elf/xtensa.h"
159 #include "libiberty.h"
160 #include "safe-ctype.h"
161 #include "filenames.h"
164 #define offsetof(TYPE, MEMBER) ((size_t) &(((TYPE *) 0)->MEMBER))
167 char * program_name = "readelf";
168 static long archive_file_offset;
169 static unsigned long archive_file_size;
170 static unsigned long dynamic_addr;
171 static bfd_size_type dynamic_size;
172 static unsigned int dynamic_nent;
173 static char * dynamic_strings;
174 static unsigned long dynamic_strings_length;
175 static char * string_table;
176 static unsigned long string_table_length;
177 static unsigned long num_dynamic_syms;
178 static Elf_Internal_Sym * dynamic_symbols;
179 static Elf_Internal_Syminfo * dynamic_syminfo;
180 static unsigned long dynamic_syminfo_offset;
181 static unsigned int dynamic_syminfo_nent;
182 static char program_interpreter[PATH_MAX];
183 static bfd_vma dynamic_info[DT_ENCODING];
184 static bfd_vma dynamic_info_DT_GNU_HASH;
185 static bfd_vma version_info[16];
186 static Elf_Internal_Ehdr elf_header;
187 static Elf_Internal_Shdr * section_headers;
188 static Elf_Internal_Phdr * program_headers;
189 static Elf_Internal_Dyn * dynamic_section;
190 static Elf_Internal_Shdr * symtab_shndx_hdr;
191 static int show_name;
192 static int do_dynamic;
194 static int do_dyn_syms;
196 static int do_sections;
197 static int do_section_groups;
198 static int do_section_details;
199 static int do_segments;
200 static int do_unwind;
201 static int do_using_dynamic;
202 static int do_header;
204 static int do_version;
205 static int do_histogram;
206 static int do_debugging;
209 static int do_archive_index;
210 static int is_32bit_elf;
214 struct group_list * next;
215 unsigned int section_index;
220 struct group_list * root;
221 unsigned int group_index;
224 static size_t group_count;
225 static struct group * section_groups;
226 static struct group ** section_headers_groups;
229 /* Flag bits indicating particular types of dump. */
230 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
231 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
232 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
233 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
234 #define RELOC_DUMP (1 << 4) /* The -R command line switch. */
236 typedef unsigned char dump_type;
238 /* A linked list of the section names for which dumps were requested. */
239 struct dump_list_entry
243 struct dump_list_entry * next;
245 static struct dump_list_entry * dump_sects_byname;
247 /* A dynamic array of flags indicating for which sections a dump
248 has been requested via command line switches. */
249 static dump_type * cmdline_dump_sects = NULL;
250 static unsigned int num_cmdline_dump_sects = 0;
252 /* A dynamic array of flags indicating for which sections a dump of
253 some kind has been requested. It is reset on a per-object file
254 basis and then initialised from the cmdline_dump_sects array,
255 the results of interpreting the -w switch, and the
256 dump_sects_byname list. */
257 static dump_type * dump_sects = NULL;
258 static unsigned int num_dump_sects = 0;
261 /* How to print a vma value. */
262 typedef enum print_mode
276 #define SECTION_NAME(X) \
277 ((X) == NULL ? _("<none>") \
278 : string_table == NULL ? _("<no-name>") \
279 : ((X)->sh_name >= string_table_length ? _("<corrupt>") \
280 : string_table + (X)->sh_name))
282 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
284 #define GET_ELF_SYMBOLS(file, section, sym_count) \
285 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
286 : get_64bit_elf_symbols (file, section, sym_count))
288 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
289 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
290 already been called and verified that the string exists. */
291 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
293 #define REMOVE_ARCH_BITS(ADDR) \
296 if (elf_header.e_machine == EM_ARM) \
301 /* Retrieve NMEMB structures, each SIZE bytes long from FILE starting at OFFSET.
302 Put the retrieved data into VAR, if it is not NULL. Otherwise allocate a buffer
303 using malloc and fill that. In either case return the pointer to the start of
304 the retrieved data or NULL if something went wrong. If something does go wrong
305 emit an error message using REASON as part of the context. */
308 get_data (void * var, FILE * file, long offset, size_t size, size_t nmemb,
313 if (size == 0 || nmemb == 0)
316 if (fseek (file, archive_file_offset + offset, SEEK_SET))
318 error (_("Unable to seek to 0x%lx for %s\n"),
319 (unsigned long) archive_file_offset + offset, reason);
326 /* Check for overflow. */
327 if (nmemb < (~(size_t) 0 - 1) / size)
328 /* + 1 so that we can '\0' terminate invalid string table sections. */
329 mvar = malloc (size * nmemb + 1);
333 error (_("Out of memory allocating 0x%lx bytes for %s\n"),
334 (unsigned long)(size * nmemb), reason);
338 ((char *) mvar)[size * nmemb] = '\0';
341 if (fread (mvar, size, nmemb, file) != nmemb)
343 error (_("Unable to read in 0x%lx bytes of %s\n"),
344 (unsigned long)(size * nmemb), reason);
353 /* Print a VMA value. */
356 print_vma (bfd_vma vma, print_mode mode)
369 return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
376 return printf ("%5" BFD_VMA_FMT "d", vma);
384 return nc + printf ("%" BFD_VMA_FMT "x", vma);
387 return printf ("%" BFD_VMA_FMT "d", vma);
390 return printf ("%" BFD_VMA_FMT "u", vma);
395 /* Display a symbol on stdout. Handles the display of control characters and
396 multibye characters (assuming the host environment supports them).
398 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
400 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
401 padding as necessary.
403 Returns the number of emitted characters. */
406 print_symbol (int width, const char *symbol)
408 bfd_boolean extra_padding = FALSE;
410 #ifdef HAVE_MBSTATE_T
417 /* Keep the width positive. This also helps. */
419 extra_padding = TRUE;
423 /* Set the remaining width to a very large value.
424 This simplifies the code below. */
425 width_remaining = INT_MAX;
427 width_remaining = width;
429 #ifdef HAVE_MBSTATE_T
430 /* Initialise the multibyte conversion state. */
431 memset (& state, 0, sizeof (state));
434 while (width_remaining)
437 const char c = *symbol++;
442 /* Do not print control characters directly as they can affect terminal
443 settings. Such characters usually appear in the names generated
444 by the assembler for local labels. */
447 if (width_remaining < 2)
450 printf ("^%c", c + 0x40);
451 width_remaining -= 2;
454 else if (ISPRINT (c))
462 #ifdef HAVE_MBSTATE_T
465 /* Let printf do the hard work of displaying multibyte characters. */
466 printf ("%.1s", symbol - 1);
470 #ifdef HAVE_MBSTATE_T
471 /* Try to find out how many bytes made up the character that was
472 just printed. Advance the symbol pointer past the bytes that
474 n = mbrtowc (& w, symbol - 1, MB_CUR_MAX, & state);
478 if (n != (size_t) -1 && n != (size_t) -2 && n > 0)
483 if (extra_padding && num_printed < width)
485 /* Fill in the remaining spaces. */
486 printf ("%-*s", width - num_printed, " ");
493 /* Return a pointer to section NAME, or NULL if no such section exists. */
495 static Elf_Internal_Shdr *
496 find_section (const char * name)
500 for (i = 0; i < elf_header.e_shnum; i++)
501 if (streq (SECTION_NAME (section_headers + i), name))
502 return section_headers + i;
507 /* Return a pointer to a section containing ADDR, or NULL if no such
510 static Elf_Internal_Shdr *
511 find_section_by_address (bfd_vma addr)
515 for (i = 0; i < elf_header.e_shnum; i++)
517 Elf_Internal_Shdr *sec = section_headers + i;
518 if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
525 /* Return a pointer to section NAME, or NULL if no such section exists,
526 restricted to the list of sections given in SET. */
528 static Elf_Internal_Shdr *
529 find_section_in_set (const char * name, unsigned int * set)
535 while ((i = *set++) > 0)
536 if (streq (SECTION_NAME (section_headers + i), name))
537 return section_headers + i;
540 return find_section (name);
543 /* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
546 static inline unsigned long
547 read_uleb128 (unsigned char *data,
548 unsigned int *length_return,
549 const unsigned char * const end)
551 return read_leb128 (data, length_return, FALSE, end);
554 /* Return true if the current file is for IA-64 machine and OpenVMS ABI.
555 This OS has so many departures from the ELF standard that we test it at
561 return elf_header.e_machine == EM_IA_64
562 && elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
565 /* Guess the relocation size commonly used by the specific machines. */
568 guess_is_rela (unsigned int e_machine)
572 /* Targets that use REL relocations. */
589 /* Targets that use RELA relocations. */
593 case EM_ADAPTEVA_EPIPHANY:
595 case EM_ALTERA_NIOS2:
614 case EM_LATTICEMICO32:
623 case EM_CYGNUS_MN10200:
625 case EM_CYGNUS_MN10300:
657 case EM_MICROBLAZE_OLD:
678 warn (_("Don't know about relocations on this machine architecture\n"));
684 slurp_rela_relocs (FILE * file,
685 unsigned long rel_offset,
686 unsigned long rel_size,
687 Elf_Internal_Rela ** relasp,
688 unsigned long * nrelasp)
690 Elf_Internal_Rela * relas;
691 unsigned long nrelas;
696 Elf32_External_Rela * erelas;
698 erelas = (Elf32_External_Rela *) get_data (NULL, file, rel_offset, 1,
699 rel_size, _("32-bit relocation data"));
703 nrelas = rel_size / sizeof (Elf32_External_Rela);
705 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
706 sizeof (Elf_Internal_Rela));
711 error (_("out of memory parsing relocs\n"));
715 for (i = 0; i < nrelas; i++)
717 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
718 relas[i].r_info = BYTE_GET (erelas[i].r_info);
719 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
726 Elf64_External_Rela * erelas;
728 erelas = (Elf64_External_Rela *) get_data (NULL, file, rel_offset, 1,
729 rel_size, _("64-bit relocation data"));
733 nrelas = rel_size / sizeof (Elf64_External_Rela);
735 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
736 sizeof (Elf_Internal_Rela));
741 error (_("out of memory parsing relocs\n"));
745 for (i = 0; i < nrelas; i++)
747 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
748 relas[i].r_info = BYTE_GET (erelas[i].r_info);
749 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
751 /* The #ifdef BFD64 below is to prevent a compile time
752 warning. We know that if we do not have a 64 bit data
753 type that we will never execute this code anyway. */
755 if (elf_header.e_machine == EM_MIPS
756 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
758 /* In little-endian objects, r_info isn't really a
759 64-bit little-endian value: it has a 32-bit
760 little-endian symbol index followed by four
761 individual byte fields. Reorder INFO
763 bfd_vma inf = relas[i].r_info;
764 inf = (((inf & 0xffffffff) << 32)
765 | ((inf >> 56) & 0xff)
766 | ((inf >> 40) & 0xff00)
767 | ((inf >> 24) & 0xff0000)
768 | ((inf >> 8) & 0xff000000));
769 relas[i].r_info = inf;
782 slurp_rel_relocs (FILE * file,
783 unsigned long rel_offset,
784 unsigned long rel_size,
785 Elf_Internal_Rela ** relsp,
786 unsigned long * nrelsp)
788 Elf_Internal_Rela * rels;
794 Elf32_External_Rel * erels;
796 erels = (Elf32_External_Rel *) get_data (NULL, file, rel_offset, 1,
797 rel_size, _("32-bit relocation data"));
801 nrels = rel_size / sizeof (Elf32_External_Rel);
803 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
808 error (_("out of memory parsing relocs\n"));
812 for (i = 0; i < nrels; i++)
814 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
815 rels[i].r_info = BYTE_GET (erels[i].r_info);
816 rels[i].r_addend = 0;
823 Elf64_External_Rel * erels;
825 erels = (Elf64_External_Rel *) get_data (NULL, file, rel_offset, 1,
826 rel_size, _("64-bit relocation data"));
830 nrels = rel_size / sizeof (Elf64_External_Rel);
832 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
837 error (_("out of memory parsing relocs\n"));
841 for (i = 0; i < nrels; i++)
843 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
844 rels[i].r_info = BYTE_GET (erels[i].r_info);
845 rels[i].r_addend = 0;
847 /* The #ifdef BFD64 below is to prevent a compile time
848 warning. We know that if we do not have a 64 bit data
849 type that we will never execute this code anyway. */
851 if (elf_header.e_machine == EM_MIPS
852 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
854 /* In little-endian objects, r_info isn't really a
855 64-bit little-endian value: it has a 32-bit
856 little-endian symbol index followed by four
857 individual byte fields. Reorder INFO
859 bfd_vma inf = rels[i].r_info;
860 inf = (((inf & 0xffffffff) << 32)
861 | ((inf >> 56) & 0xff)
862 | ((inf >> 40) & 0xff00)
863 | ((inf >> 24) & 0xff0000)
864 | ((inf >> 8) & 0xff000000));
865 rels[i].r_info = inf;
877 /* Returns the reloc type extracted from the reloc info field. */
880 get_reloc_type (bfd_vma reloc_info)
883 return ELF32_R_TYPE (reloc_info);
885 switch (elf_header.e_machine)
888 /* Note: We assume that reloc_info has already been adjusted for us. */
889 return ELF64_MIPS_R_TYPE (reloc_info);
892 return ELF64_R_TYPE_ID (reloc_info);
895 return ELF64_R_TYPE (reloc_info);
899 /* Return the symbol index extracted from the reloc info field. */
902 get_reloc_symindex (bfd_vma reloc_info)
904 return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
907 static inline bfd_boolean
908 uses_msp430x_relocs (void)
911 elf_header.e_machine == EM_MSP430 /* Paranoia. */
912 /* GCC uses osabi == ELFOSBI_STANDALONE. */
913 && (((elf_header.e_flags & EF_MSP430_MACH) == E_MSP430_MACH_MSP430X)
914 /* TI compiler uses ELFOSABI_NONE. */
915 || (elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE));
918 /* Display the contents of the relocation data found at the specified
922 dump_relocations (FILE * file,
923 unsigned long rel_offset,
924 unsigned long rel_size,
925 Elf_Internal_Sym * symtab,
928 unsigned long strtablen,
932 Elf_Internal_Rela * rels;
934 if (is_rela == UNKNOWN)
935 is_rela = guess_is_rela (elf_header.e_machine);
939 if (!slurp_rela_relocs (file, rel_offset, rel_size, &rels, &rel_size))
944 if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
953 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
955 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
960 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
962 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
970 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
972 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
977 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
979 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
983 for (i = 0; i < rel_size; i++)
988 bfd_vma symtab_index;
991 offset = rels[i].r_offset;
992 inf = rels[i].r_info;
994 type = get_reloc_type (inf);
995 symtab_index = get_reloc_symindex (inf);
999 printf ("%8.8lx %8.8lx ",
1000 (unsigned long) offset & 0xffffffff,
1001 (unsigned long) inf & 0xffffffff);
1005 #if BFD_HOST_64BIT_LONG
1007 ? "%16.16lx %16.16lx "
1008 : "%12.12lx %12.12lx ",
1010 #elif BFD_HOST_64BIT_LONG_LONG
1013 ? "%16.16llx %16.16llx "
1014 : "%12.12llx %12.12llx ",
1018 ? "%16.16I64x %16.16I64x "
1019 : "%12.12I64x %12.12I64x ",
1024 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1025 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1026 _bfd_int64_high (offset),
1027 _bfd_int64_low (offset),
1028 _bfd_int64_high (inf),
1029 _bfd_int64_low (inf));
1033 switch (elf_header.e_machine)
1040 rtype = elf_aarch64_reloc_type (type);
1044 case EM_CYGNUS_M32R:
1045 rtype = elf_m32r_reloc_type (type);
1050 rtype = elf_i386_reloc_type (type);
1055 rtype = elf_m68hc11_reloc_type (type);
1059 rtype = elf_m68k_reloc_type (type);
1063 rtype = elf_i960_reloc_type (type);
1068 rtype = elf_avr_reloc_type (type);
1071 case EM_OLD_SPARCV9:
1072 case EM_SPARC32PLUS:
1075 rtype = elf_sparc_reloc_type (type);
1079 rtype = elf_spu_reloc_type (type);
1083 rtype = v800_reloc_type (type);
1086 case EM_CYGNUS_V850:
1087 rtype = v850_reloc_type (type);
1091 case EM_CYGNUS_D10V:
1092 rtype = elf_d10v_reloc_type (type);
1096 case EM_CYGNUS_D30V:
1097 rtype = elf_d30v_reloc_type (type);
1101 rtype = elf_dlx_reloc_type (type);
1105 rtype = elf_sh_reloc_type (type);
1109 case EM_CYGNUS_MN10300:
1110 rtype = elf_mn10300_reloc_type (type);
1114 case EM_CYGNUS_MN10200:
1115 rtype = elf_mn10200_reloc_type (type);
1119 case EM_CYGNUS_FR30:
1120 rtype = elf_fr30_reloc_type (type);
1124 rtype = elf_frv_reloc_type (type);
1128 rtype = elf_mcore_reloc_type (type);
1132 rtype = elf_mmix_reloc_type (type);
1136 rtype = elf_moxie_reloc_type (type);
1140 if (uses_msp430x_relocs ())
1142 rtype = elf_msp430x_reloc_type (type);
1146 rtype = elf_msp430_reloc_type (type);
1150 rtype = elf_nds32_reloc_type (type);
1154 rtype = elf_ppc_reloc_type (type);
1158 rtype = elf_ppc64_reloc_type (type);
1162 case EM_MIPS_RS3_LE:
1163 rtype = elf_mips_reloc_type (type);
1167 rtype = elf_alpha_reloc_type (type);
1171 rtype = elf_arm_reloc_type (type);
1175 rtype = elf_arc_reloc_type (type);
1179 rtype = elf_hppa_reloc_type (type);
1185 rtype = elf_h8_reloc_type (type);
1190 rtype = elf_or32_reloc_type (type);
1195 rtype = elf_pj_reloc_type (type);
1198 rtype = elf_ia64_reloc_type (type);
1202 rtype = elf_cris_reloc_type (type);
1206 rtype = elf_i860_reloc_type (type);
1212 rtype = elf_x86_64_reloc_type (type);
1216 rtype = i370_reloc_type (type);
1221 rtype = elf_s390_reloc_type (type);
1225 rtype = elf_score_reloc_type (type);
1229 rtype = elf_xstormy16_reloc_type (type);
1233 rtype = elf_crx_reloc_type (type);
1237 rtype = elf_vax_reloc_type (type);
1240 case EM_ADAPTEVA_EPIPHANY:
1241 rtype = elf_epiphany_reloc_type (type);
1246 rtype = elf_ip2k_reloc_type (type);
1250 rtype = elf_iq2000_reloc_type (type);
1255 rtype = elf_xtensa_reloc_type (type);
1258 case EM_LATTICEMICO32:
1259 rtype = elf_lm32_reloc_type (type);
1264 rtype = elf_m32c_reloc_type (type);
1268 rtype = elf_mt_reloc_type (type);
1272 rtype = elf_bfin_reloc_type (type);
1276 rtype = elf_mep_reloc_type (type);
1280 rtype = elf_cr16_reloc_type (type);
1284 case EM_MICROBLAZE_OLD:
1285 rtype = elf_microblaze_reloc_type (type);
1289 rtype = elf_rl78_reloc_type (type);
1293 rtype = elf_rx_reloc_type (type);
1297 rtype = elf_metag_reloc_type (type);
1302 rtype = elf_xc16x_reloc_type (type);
1306 rtype = elf_tic6x_reloc_type (type);
1310 rtype = elf_tilegx_reloc_type (type);
1314 rtype = elf_tilepro_reloc_type (type);
1318 rtype = elf_xgate_reloc_type (type);
1321 case EM_ALTERA_NIOS2:
1322 rtype = elf_nios2_reloc_type (type);
1327 printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
1329 printf (do_wide ? "%-22.22s" : "%-17.17s", rtype);
1331 if (elf_header.e_machine == EM_ALPHA
1333 && streq (rtype, "R_ALPHA_LITUSE")
1336 switch (rels[i].r_addend)
1338 case LITUSE_ALPHA_ADDR: rtype = "ADDR"; break;
1339 case LITUSE_ALPHA_BASE: rtype = "BASE"; break;
1340 case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1341 case LITUSE_ALPHA_JSR: rtype = "JSR"; break;
1342 case LITUSE_ALPHA_TLSGD: rtype = "TLSGD"; break;
1343 case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1344 case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1345 default: rtype = NULL;
1348 printf (" (%s)", rtype);
1352 printf (_("<unknown addend: %lx>"),
1353 (unsigned long) rels[i].r_addend);
1356 else if (symtab_index)
1358 if (symtab == NULL || symtab_index >= nsyms)
1359 printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index);
1362 Elf_Internal_Sym * psym;
1364 psym = symtab + symtab_index;
1368 if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1372 unsigned int width = is_32bit_elf ? 8 : 14;
1374 /* Relocations against GNU_IFUNC symbols do not use the value
1375 of the symbol as the address to relocate against. Instead
1376 they invoke the function named by the symbol and use its
1377 result as the address for relocation.
1379 To indicate this to the user, do not display the value of
1380 the symbol in the "Symbols's Value" field. Instead show
1381 its name followed by () as a hint that the symbol is
1385 || psym->st_name == 0
1386 || psym->st_name >= strtablen)
1389 name = strtab + psym->st_name;
1391 len = print_symbol (width, name);
1392 printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1396 print_vma (psym->st_value, LONG_HEX);
1398 printf (is_32bit_elf ? " " : " ");
1401 if (psym->st_name == 0)
1403 const char * sec_name = "<null>";
1406 if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1408 if (psym->st_shndx < elf_header.e_shnum)
1410 = SECTION_NAME (section_headers + psym->st_shndx);
1411 else if (psym->st_shndx == SHN_ABS)
1413 else if (psym->st_shndx == SHN_COMMON)
1414 sec_name = "COMMON";
1415 else if ((elf_header.e_machine == EM_MIPS
1416 && psym->st_shndx == SHN_MIPS_SCOMMON)
1417 || (elf_header.e_machine == EM_TI_C6000
1418 && psym->st_shndx == SHN_TIC6X_SCOMMON))
1419 sec_name = "SCOMMON";
1420 else if (elf_header.e_machine == EM_MIPS
1421 && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1422 sec_name = "SUNDEF";
1423 else if ((elf_header.e_machine == EM_X86_64
1424 || elf_header.e_machine == EM_L1OM
1425 || elf_header.e_machine == EM_K1OM)
1426 && psym->st_shndx == SHN_X86_64_LCOMMON)
1427 sec_name = "LARGE_COMMON";
1428 else if (elf_header.e_machine == EM_IA_64
1429 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1430 && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1431 sec_name = "ANSI_COM";
1432 else if (is_ia64_vms ()
1433 && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1434 sec_name = "VMS_SYMVEC";
1437 sprintf (name_buf, "<section 0x%x>",
1438 (unsigned int) psym->st_shndx);
1439 sec_name = name_buf;
1442 print_symbol (22, sec_name);
1444 else if (strtab == NULL)
1445 printf (_("<string table index: %3ld>"), psym->st_name);
1446 else if (psym->st_name >= strtablen)
1447 printf (_("<corrupt string table index: %3ld>"), psym->st_name);
1449 print_symbol (22, strtab + psym->st_name);
1453 bfd_signed_vma off = rels[i].r_addend;
1456 printf (" - %" BFD_VMA_FMT "x", - off);
1458 printf (" + %" BFD_VMA_FMT "x", off);
1464 bfd_signed_vma off = rels[i].r_addend;
1466 printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
1468 printf ("-%" BFD_VMA_FMT "x", - off);
1470 printf ("%" BFD_VMA_FMT "x", off);
1473 if (elf_header.e_machine == EM_SPARCV9
1475 && streq (rtype, "R_SPARC_OLO10"))
1476 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
1481 if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
1483 bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1484 bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
1485 const char * rtype2 = elf_mips_reloc_type (type2);
1486 const char * rtype3 = elf_mips_reloc_type (type3);
1488 printf (" Type2: ");
1491 printf (_("unrecognized: %-7lx"),
1492 (unsigned long) type2 & 0xffffffff);
1494 printf ("%-17.17s", rtype2);
1496 printf ("\n Type3: ");
1499 printf (_("unrecognized: %-7lx"),
1500 (unsigned long) type3 & 0xffffffff);
1502 printf ("%-17.17s", rtype3);
1513 get_mips_dynamic_type (unsigned long type)
1517 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1518 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1519 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1520 case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1521 case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1522 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1523 case DT_MIPS_MSYM: return "MIPS_MSYM";
1524 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1525 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1526 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1527 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1528 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1529 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1530 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1531 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1532 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1533 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1534 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1535 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1536 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1537 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1538 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1539 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1540 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1541 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1542 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1543 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1544 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1545 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1546 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1547 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1548 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1549 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1550 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1551 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1552 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1553 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1554 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1555 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1556 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1557 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1558 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1559 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
1560 case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1561 case DT_MIPS_RWPLT: return "MIPS_RWPLT";
1568 get_sparc64_dynamic_type (unsigned long type)
1572 case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1579 get_ppc_dynamic_type (unsigned long type)
1583 case DT_PPC_GOT: return "PPC_GOT";
1584 case DT_PPC_OPT: return "PPC_OPT";
1591 get_ppc64_dynamic_type (unsigned long type)
1595 case DT_PPC64_GLINK: return "PPC64_GLINK";
1596 case DT_PPC64_OPD: return "PPC64_OPD";
1597 case DT_PPC64_OPDSZ: return "PPC64_OPDSZ";
1598 case DT_PPC64_OPT: return "PPC64_OPT";
1605 get_parisc_dynamic_type (unsigned long type)
1609 case DT_HP_LOAD_MAP: return "HP_LOAD_MAP";
1610 case DT_HP_DLD_FLAGS: return "HP_DLD_FLAGS";
1611 case DT_HP_DLD_HOOK: return "HP_DLD_HOOK";
1612 case DT_HP_UX10_INIT: return "HP_UX10_INIT";
1613 case DT_HP_UX10_INITSZ: return "HP_UX10_INITSZ";
1614 case DT_HP_PREINIT: return "HP_PREINIT";
1615 case DT_HP_PREINITSZ: return "HP_PREINITSZ";
1616 case DT_HP_NEEDED: return "HP_NEEDED";
1617 case DT_HP_TIME_STAMP: return "HP_TIME_STAMP";
1618 case DT_HP_CHECKSUM: return "HP_CHECKSUM";
1619 case DT_HP_GST_SIZE: return "HP_GST_SIZE";
1620 case DT_HP_GST_VERSION: return "HP_GST_VERSION";
1621 case DT_HP_GST_HASHVAL: return "HP_GST_HASHVAL";
1622 case DT_HP_EPLTREL: return "HP_GST_EPLTREL";
1623 case DT_HP_EPLTRELSZ: return "HP_GST_EPLTRELSZ";
1624 case DT_HP_FILTERED: return "HP_FILTERED";
1625 case DT_HP_FILTER_TLS: return "HP_FILTER_TLS";
1626 case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1627 case DT_HP_LAZYLOAD: return "HP_LAZYLOAD";
1628 case DT_HP_BIND_NOW_COUNT: return "HP_BIND_NOW_COUNT";
1629 case DT_PLT: return "PLT";
1630 case DT_PLT_SIZE: return "PLT_SIZE";
1631 case DT_DLT: return "DLT";
1632 case DT_DLT_SIZE: return "DLT_SIZE";
1639 get_ia64_dynamic_type (unsigned long type)
1643 case DT_IA_64_PLT_RESERVE: return "IA_64_PLT_RESERVE";
1644 case DT_IA_64_VMS_SUBTYPE: return "VMS_SUBTYPE";
1645 case DT_IA_64_VMS_IMGIOCNT: return "VMS_IMGIOCNT";
1646 case DT_IA_64_VMS_LNKFLAGS: return "VMS_LNKFLAGS";
1647 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1648 case DT_IA_64_VMS_IDENT: return "VMS_IDENT";
1649 case DT_IA_64_VMS_NEEDED_IDENT: return "VMS_NEEDED_IDENT";
1650 case DT_IA_64_VMS_IMG_RELA_CNT: return "VMS_IMG_RELA_CNT";
1651 case DT_IA_64_VMS_SEG_RELA_CNT: return "VMS_SEG_RELA_CNT";
1652 case DT_IA_64_VMS_FIXUP_RELA_CNT: return "VMS_FIXUP_RELA_CNT";
1653 case DT_IA_64_VMS_FIXUP_NEEDED: return "VMS_FIXUP_NEEDED";
1654 case DT_IA_64_VMS_SYMVEC_CNT: return "VMS_SYMVEC_CNT";
1655 case DT_IA_64_VMS_XLATED: return "VMS_XLATED";
1656 case DT_IA_64_VMS_STACKSIZE: return "VMS_STACKSIZE";
1657 case DT_IA_64_VMS_UNWINDSZ: return "VMS_UNWINDSZ";
1658 case DT_IA_64_VMS_UNWIND_CODSEG: return "VMS_UNWIND_CODSEG";
1659 case DT_IA_64_VMS_UNWIND_INFOSEG: return "VMS_UNWIND_INFOSEG";
1660 case DT_IA_64_VMS_LINKTIME: return "VMS_LINKTIME";
1661 case DT_IA_64_VMS_SEG_NO: return "VMS_SEG_NO";
1662 case DT_IA_64_VMS_SYMVEC_OFFSET: return "VMS_SYMVEC_OFFSET";
1663 case DT_IA_64_VMS_SYMVEC_SEG: return "VMS_SYMVEC_SEG";
1664 case DT_IA_64_VMS_UNWIND_OFFSET: return "VMS_UNWIND_OFFSET";
1665 case DT_IA_64_VMS_UNWIND_SEG: return "VMS_UNWIND_SEG";
1666 case DT_IA_64_VMS_STRTAB_OFFSET: return "VMS_STRTAB_OFFSET";
1667 case DT_IA_64_VMS_SYSVER_OFFSET: return "VMS_SYSVER_OFFSET";
1668 case DT_IA_64_VMS_IMG_RELA_OFF: return "VMS_IMG_RELA_OFF";
1669 case DT_IA_64_VMS_SEG_RELA_OFF: return "VMS_SEG_RELA_OFF";
1670 case DT_IA_64_VMS_FIXUP_RELA_OFF: return "VMS_FIXUP_RELA_OFF";
1671 case DT_IA_64_VMS_PLTGOT_OFFSET: return "VMS_PLTGOT_OFFSET";
1672 case DT_IA_64_VMS_PLTGOT_SEG: return "VMS_PLTGOT_SEG";
1673 case DT_IA_64_VMS_FPMODE: return "VMS_FPMODE";
1680 get_alpha_dynamic_type (unsigned long type)
1684 case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
1691 get_score_dynamic_type (unsigned long type)
1695 case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
1696 case DT_SCORE_LOCAL_GOTNO: return "SCORE_LOCAL_GOTNO";
1697 case DT_SCORE_SYMTABNO: return "SCORE_SYMTABNO";
1698 case DT_SCORE_GOTSYM: return "SCORE_GOTSYM";
1699 case DT_SCORE_UNREFEXTNO: return "SCORE_UNREFEXTNO";
1700 case DT_SCORE_HIPAGENO: return "SCORE_HIPAGENO";
1707 get_tic6x_dynamic_type (unsigned long type)
1711 case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
1712 case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
1713 case DT_C6000_DSBT_BASE: return "C6000_DSBT_BASE";
1714 case DT_C6000_DSBT_SIZE: return "C6000_DSBT_SIZE";
1715 case DT_C6000_PREEMPTMAP: return "C6000_PREEMPTMAP";
1716 case DT_C6000_DSBT_INDEX: return "C6000_DSBT_INDEX";
1723 get_nios2_dynamic_type (unsigned long type)
1727 case DT_NIOS2_GP: return "NIOS2_GP";
1734 get_dynamic_type (unsigned long type)
1736 static char buff[64];
1740 case DT_NULL: return "NULL";
1741 case DT_NEEDED: return "NEEDED";
1742 case DT_PLTRELSZ: return "PLTRELSZ";
1743 case DT_PLTGOT: return "PLTGOT";
1744 case DT_HASH: return "HASH";
1745 case DT_STRTAB: return "STRTAB";
1746 case DT_SYMTAB: return "SYMTAB";
1747 case DT_RELA: return "RELA";
1748 case DT_RELASZ: return "RELASZ";
1749 case DT_RELAENT: return "RELAENT";
1750 case DT_STRSZ: return "STRSZ";
1751 case DT_SYMENT: return "SYMENT";
1752 case DT_INIT: return "INIT";
1753 case DT_FINI: return "FINI";
1754 case DT_SONAME: return "SONAME";
1755 case DT_RPATH: return "RPATH";
1756 case DT_SYMBOLIC: return "SYMBOLIC";
1757 case DT_REL: return "REL";
1758 case DT_RELSZ: return "RELSZ";
1759 case DT_RELENT: return "RELENT";
1760 case DT_PLTREL: return "PLTREL";
1761 case DT_DEBUG: return "DEBUG";
1762 case DT_TEXTREL: return "TEXTREL";
1763 case DT_JMPREL: return "JMPREL";
1764 case DT_BIND_NOW: return "BIND_NOW";
1765 case DT_INIT_ARRAY: return "INIT_ARRAY";
1766 case DT_FINI_ARRAY: return "FINI_ARRAY";
1767 case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
1768 case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
1769 case DT_RUNPATH: return "RUNPATH";
1770 case DT_FLAGS: return "FLAGS";
1772 case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1773 case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
1775 case DT_CHECKSUM: return "CHECKSUM";
1776 case DT_PLTPADSZ: return "PLTPADSZ";
1777 case DT_MOVEENT: return "MOVEENT";
1778 case DT_MOVESZ: return "MOVESZ";
1779 case DT_FEATURE: return "FEATURE";
1780 case DT_POSFLAG_1: return "POSFLAG_1";
1781 case DT_SYMINSZ: return "SYMINSZ";
1782 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
1784 case DT_ADDRRNGLO: return "ADDRRNGLO";
1785 case DT_CONFIG: return "CONFIG";
1786 case DT_DEPAUDIT: return "DEPAUDIT";
1787 case DT_AUDIT: return "AUDIT";
1788 case DT_PLTPAD: return "PLTPAD";
1789 case DT_MOVETAB: return "MOVETAB";
1790 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
1792 case DT_VERSYM: return "VERSYM";
1794 case DT_TLSDESC_GOT: return "TLSDESC_GOT";
1795 case DT_TLSDESC_PLT: return "TLSDESC_PLT";
1796 case DT_RELACOUNT: return "RELACOUNT";
1797 case DT_RELCOUNT: return "RELCOUNT";
1798 case DT_FLAGS_1: return "FLAGS_1";
1799 case DT_VERDEF: return "VERDEF";
1800 case DT_VERDEFNUM: return "VERDEFNUM";
1801 case DT_VERNEED: return "VERNEED";
1802 case DT_VERNEEDNUM: return "VERNEEDNUM";
1804 case DT_AUXILIARY: return "AUXILIARY";
1805 case DT_USED: return "USED";
1806 case DT_FILTER: return "FILTER";
1808 case DT_GNU_PRELINKED: return "GNU_PRELINKED";
1809 case DT_GNU_CONFLICT: return "GNU_CONFLICT";
1810 case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
1811 case DT_GNU_LIBLIST: return "GNU_LIBLIST";
1812 case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
1813 case DT_GNU_HASH: return "GNU_HASH";
1816 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1818 const char * result;
1820 switch (elf_header.e_machine)
1823 case EM_MIPS_RS3_LE:
1824 result = get_mips_dynamic_type (type);
1827 result = get_sparc64_dynamic_type (type);
1830 result = get_ppc_dynamic_type (type);
1833 result = get_ppc64_dynamic_type (type);
1836 result = get_ia64_dynamic_type (type);
1839 result = get_alpha_dynamic_type (type);
1842 result = get_score_dynamic_type (type);
1845 result = get_tic6x_dynamic_type (type);
1847 case EM_ALTERA_NIOS2:
1848 result = get_nios2_dynamic_type (type);
1858 snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
1860 else if (((type >= DT_LOOS) && (type <= DT_HIOS))
1861 || (elf_header.e_machine == EM_PARISC
1862 && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
1864 const char * result;
1866 switch (elf_header.e_machine)
1869 result = get_parisc_dynamic_type (type);
1872 result = get_ia64_dynamic_type (type);
1882 snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
1886 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
1893 get_file_type (unsigned e_type)
1895 static char buff[32];
1899 case ET_NONE: return _("NONE (None)");
1900 case ET_REL: return _("REL (Relocatable file)");
1901 case ET_EXEC: return _("EXEC (Executable file)");
1902 case ET_DYN: return _("DYN (Shared object file)");
1903 case ET_CORE: return _("CORE (Core file)");
1906 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
1907 snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
1908 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
1909 snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
1911 snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
1917 get_machine_name (unsigned e_machine)
1919 static char buff[64]; /* XXX */
1923 case EM_NONE: return _("None");
1924 case EM_AARCH64: return "AArch64";
1925 case EM_M32: return "WE32100";
1926 case EM_SPARC: return "Sparc";
1927 case EM_SPU: return "SPU";
1928 case EM_386: return "Intel 80386";
1929 case EM_68K: return "MC68000";
1930 case EM_88K: return "MC88000";
1931 case EM_486: return "Intel 80486";
1932 case EM_860: return "Intel 80860";
1933 case EM_MIPS: return "MIPS R3000";
1934 case EM_S370: return "IBM System/370";
1935 case EM_MIPS_RS3_LE: return "MIPS R4000 big-endian";
1936 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
1937 case EM_PARISC: return "HPPA";
1938 case EM_PPC_OLD: return "Power PC (old)";
1939 case EM_SPARC32PLUS: return "Sparc v8+" ;
1940 case EM_960: return "Intel 90860";
1941 case EM_PPC: return "PowerPC";
1942 case EM_PPC64: return "PowerPC64";
1943 case EM_FR20: return "Fujitsu FR20";
1944 case EM_RH32: return "TRW RH32";
1945 case EM_MCORE: return "MCORE";
1946 case EM_ARM: return "ARM";
1947 case EM_OLD_ALPHA: return "Digital Alpha (old)";
1948 case EM_SH: return "Renesas / SuperH SH";
1949 case EM_SPARCV9: return "Sparc v9";
1950 case EM_TRICORE: return "Siemens Tricore";
1951 case EM_ARC: return "ARC";
1952 case EM_H8_300: return "Renesas H8/300";
1953 case EM_H8_300H: return "Renesas H8/300H";
1954 case EM_H8S: return "Renesas H8S";
1955 case EM_H8_500: return "Renesas H8/500";
1956 case EM_IA_64: return "Intel IA-64";
1957 case EM_MIPS_X: return "Stanford MIPS-X";
1958 case EM_COLDFIRE: return "Motorola Coldfire";
1959 case EM_ALPHA: return "Alpha";
1960 case EM_CYGNUS_D10V:
1961 case EM_D10V: return "d10v";
1962 case EM_CYGNUS_D30V:
1963 case EM_D30V: return "d30v";
1964 case EM_CYGNUS_M32R:
1965 case EM_M32R: return "Renesas M32R (formerly Mitsubishi M32r)";
1966 case EM_CYGNUS_V850:
1967 case EM_V800: return "Renesas V850 (using RH850 ABI)";
1968 case EM_V850: return "Renesas V850";
1969 case EM_CYGNUS_MN10300:
1970 case EM_MN10300: return "mn10300";
1971 case EM_CYGNUS_MN10200:
1972 case EM_MN10200: return "mn10200";
1973 case EM_MOXIE: return "Moxie";
1974 case EM_CYGNUS_FR30:
1975 case EM_FR30: return "Fujitsu FR30";
1976 case EM_CYGNUS_FRV: return "Fujitsu FR-V";
1978 case EM_PJ: return "picoJava";
1979 case EM_MMA: return "Fujitsu Multimedia Accelerator";
1980 case EM_PCP: return "Siemens PCP";
1981 case EM_NCPU: return "Sony nCPU embedded RISC processor";
1982 case EM_NDR1: return "Denso NDR1 microprocesspr";
1983 case EM_STARCORE: return "Motorola Star*Core processor";
1984 case EM_ME16: return "Toyota ME16 processor";
1985 case EM_ST100: return "STMicroelectronics ST100 processor";
1986 case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
1987 case EM_PDSP: return "Sony DSP processor";
1988 case EM_PDP10: return "Digital Equipment Corp. PDP-10";
1989 case EM_PDP11: return "Digital Equipment Corp. PDP-11";
1990 case EM_FX66: return "Siemens FX66 microcontroller";
1991 case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1992 case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
1993 case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
1994 case EM_68HC12: return "Motorola MC68HC12 Microcontroller";
1995 case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
1996 case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
1997 case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
1998 case EM_SVX: return "Silicon Graphics SVx";
1999 case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
2000 case EM_VAX: return "Digital VAX";
2002 case EM_AVR: return "Atmel AVR 8-bit microcontroller";
2003 case EM_CRIS: return "Axis Communications 32-bit embedded processor";
2004 case EM_JAVELIN: return "Infineon Technologies 32-bit embedded cpu";
2005 case EM_FIREPATH: return "Element 14 64-bit DSP processor";
2006 case EM_ZSP: return "LSI Logic's 16-bit DSP processor";
2007 case EM_MMIX: return "Donald Knuth's educational 64-bit processor";
2008 case EM_HUANY: return "Harvard Universitys's machine-independent object format";
2009 case EM_PRISM: return "Vitesse Prism";
2010 case EM_X86_64: return "Advanced Micro Devices X86-64";
2011 case EM_L1OM: return "Intel L1OM";
2012 case EM_K1OM: return "Intel K1OM";
2014 case EM_S390: return "IBM S/390";
2015 case EM_SCORE: return "SUNPLUS S+Core";
2016 case EM_XSTORMY16: return "Sanyo XStormy16 CPU core";
2018 case EM_OR32: return "OpenRISC";
2019 case EM_ARC_A5: return "ARC International ARCompact processor";
2020 case EM_CRX: return "National Semiconductor CRX microprocessor";
2021 case EM_ADAPTEVA_EPIPHANY: return "Adapteva EPIPHANY";
2022 case EM_DLX: return "OpenDLX";
2024 case EM_IP2K: return "Ubicom IP2xxx 8-bit microcontrollers";
2025 case EM_IQ2000: return "Vitesse IQ2000";
2027 case EM_XTENSA: return "Tensilica Xtensa Processor";
2028 case EM_VIDEOCORE: return "Alphamosaic VideoCore processor";
2029 case EM_TMM_GPP: return "Thompson Multimedia General Purpose Processor";
2030 case EM_NS32K: return "National Semiconductor 32000 series";
2031 case EM_TPC: return "Tenor Network TPC processor";
2032 case EM_ST200: return "STMicroelectronics ST200 microcontroller";
2033 case EM_MAX: return "MAX Processor";
2034 case EM_CR: return "National Semiconductor CompactRISC";
2035 case EM_F2MC16: return "Fujitsu F2MC16";
2036 case EM_MSP430: return "Texas Instruments msp430 microcontroller";
2037 case EM_LATTICEMICO32: return "Lattice Mico32";
2039 case EM_M32C: return "Renesas M32c";
2040 case EM_MT: return "Morpho Techologies MT processor";
2041 case EM_BLACKFIN: return "Analog Devices Blackfin";
2042 case EM_SE_C33: return "S1C33 Family of Seiko Epson processors";
2043 case EM_SEP: return "Sharp embedded microprocessor";
2044 case EM_ARCA: return "Arca RISC microprocessor";
2045 case EM_UNICORE: return "Unicore";
2046 case EM_EXCESS: return "eXcess 16/32/64-bit configurable embedded CPU";
2047 case EM_DXP: return "Icera Semiconductor Inc. Deep Execution Processor";
2048 case EM_NIOS32: return "Altera Nios";
2049 case EM_ALTERA_NIOS2: return "Altera Nios II";
2051 case EM_XC16X: return "Infineon Technologies xc16x";
2052 case EM_M16C: return "Renesas M16C series microprocessors";
2053 case EM_DSPIC30F: return "Microchip Technology dsPIC30F Digital Signal Controller";
2054 case EM_CE: return "Freescale Communication Engine RISC core";
2055 case EM_TSK3000: return "Altium TSK3000 core";
2056 case EM_RS08: return "Freescale RS08 embedded processor";
2057 case EM_ECOG2: return "Cyan Technology eCOG2 microprocessor";
2058 case EM_DSP24: return "New Japan Radio (NJR) 24-bit DSP Processor";
2059 case EM_VIDEOCORE3: return "Broadcom VideoCore III processor";
2060 case EM_SE_C17: return "Seiko Epson C17 family";
2061 case EM_TI_C6000: return "Texas Instruments TMS320C6000 DSP family";
2062 case EM_TI_C2000: return "Texas Instruments TMS320C2000 DSP family";
2063 case EM_TI_C5500: return "Texas Instruments TMS320C55x DSP family";
2064 case EM_MMDSP_PLUS: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2065 case EM_CYPRESS_M8C: return "Cypress M8C microprocessor";
2066 case EM_R32C: return "Renesas R32C series microprocessors";
2067 case EM_TRIMEDIA: return "NXP Semiconductors TriMedia architecture family";
2068 case EM_QDSP6: return "QUALCOMM DSP6 Processor";
2069 case EM_8051: return "Intel 8051 and variants";
2070 case EM_STXP7X: return "STMicroelectronics STxP7x family";
2071 case EM_NDS32: return "Andes Technology compact code size embedded RISC processor family";
2072 case EM_ECOG1X: return "Cyan Technology eCOG1X family";
2073 case EM_MAXQ30: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2074 case EM_XIMO16: return "New Japan Radio (NJR) 16-bit DSP Processor";
2075 case EM_MANIK: return "M2000 Reconfigurable RISC Microprocessor";
2076 case EM_CRAYNV2: return "Cray Inc. NV2 vector architecture";
2077 case EM_CYGNUS_MEP: return "Toshiba MeP Media Engine";
2080 case EM_MICROBLAZE_OLD: return "Xilinx MicroBlaze";
2081 case EM_RL78: return "Renesas RL78";
2082 case EM_RX: return "Renesas RX";
2083 case EM_METAG: return "Imagination Technologies Meta processor architecture";
2084 case EM_MCST_ELBRUS: return "MCST Elbrus general purpose hardware architecture";
2085 case EM_ECOG16: return "Cyan Technology eCOG16 family";
2086 case EM_ETPU: return "Freescale Extended Time Processing Unit";
2087 case EM_SLE9X: return "Infineon Technologies SLE9X core";
2088 case EM_AVR32: return "Atmel Corporation 32-bit microprocessor family";
2089 case EM_STM8: return "STMicroeletronics STM8 8-bit microcontroller";
2090 case EM_TILE64: return "Tilera TILE64 multicore architecture family";
2091 case EM_TILEPRO: return "Tilera TILEPro multicore architecture family";
2092 case EM_TILEGX: return "Tilera TILE-Gx multicore architecture family";
2093 case EM_CUDA: return "NVIDIA CUDA architecture";
2094 case EM_XGATE: return "Motorola XGATE embedded processor";
2096 snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
2102 decode_ARM_machine_flags (unsigned e_flags, char buf[])
2107 eabi = EF_ARM_EABI_VERSION (e_flags);
2108 e_flags &= ~ EF_ARM_EABIMASK;
2110 /* Handle "generic" ARM flags. */
2111 if (e_flags & EF_ARM_RELEXEC)
2113 strcat (buf, ", relocatable executable");
2114 e_flags &= ~ EF_ARM_RELEXEC;
2117 if (e_flags & EF_ARM_HASENTRY)
2119 strcat (buf, ", has entry point");
2120 e_flags &= ~ EF_ARM_HASENTRY;
2123 /* Now handle EABI specific flags. */
2127 strcat (buf, ", <unrecognized EABI>");
2132 case EF_ARM_EABI_VER1:
2133 strcat (buf, ", Version1 EABI");
2138 /* Process flags one bit at a time. */
2139 flag = e_flags & - e_flags;
2144 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2145 strcat (buf, ", sorted symbol tables");
2155 case EF_ARM_EABI_VER2:
2156 strcat (buf, ", Version2 EABI");
2161 /* Process flags one bit at a time. */
2162 flag = e_flags & - e_flags;
2167 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2168 strcat (buf, ", sorted symbol tables");
2171 case EF_ARM_DYNSYMSUSESEGIDX:
2172 strcat (buf, ", dynamic symbols use segment index");
2175 case EF_ARM_MAPSYMSFIRST:
2176 strcat (buf, ", mapping symbols precede others");
2186 case EF_ARM_EABI_VER3:
2187 strcat (buf, ", Version3 EABI");
2190 case EF_ARM_EABI_VER4:
2191 strcat (buf, ", Version4 EABI");
2196 /* Process flags one bit at a time. */
2197 flag = e_flags & - e_flags;
2203 strcat (buf, ", BE8");
2207 strcat (buf, ", LE8");
2218 case EF_ARM_EABI_VER5:
2219 strcat (buf, ", Version5 EABI");
2224 /* Process flags one bit at a time. */
2225 flag = e_flags & - e_flags;
2231 strcat (buf, ", BE8");
2235 strcat (buf, ", LE8");
2238 case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2239 strcat (buf, ", soft-float ABI");
2242 case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT. */
2243 strcat (buf, ", hard-float ABI");
2253 case EF_ARM_EABI_UNKNOWN:
2254 strcat (buf, ", GNU EABI");
2259 /* Process flags one bit at a time. */
2260 flag = e_flags & - e_flags;
2265 case EF_ARM_INTERWORK:
2266 strcat (buf, ", interworking enabled");
2269 case EF_ARM_APCS_26:
2270 strcat (buf, ", uses APCS/26");
2273 case EF_ARM_APCS_FLOAT:
2274 strcat (buf, ", uses APCS/float");
2278 strcat (buf, ", position independent");
2282 strcat (buf, ", 8 bit structure alignment");
2285 case EF_ARM_NEW_ABI:
2286 strcat (buf, ", uses new ABI");
2289 case EF_ARM_OLD_ABI:
2290 strcat (buf, ", uses old ABI");
2293 case EF_ARM_SOFT_FLOAT:
2294 strcat (buf, ", software FP");
2297 case EF_ARM_VFP_FLOAT:
2298 strcat (buf, ", VFP");
2301 case EF_ARM_MAVERICK_FLOAT:
2302 strcat (buf, ", Maverick FP");
2313 strcat (buf,_(", <unknown>"));
2317 decode_NDS32_machine_flags (unsigned e_flags, char buf[], size_t size)
2326 static const char *ABI_STRINGS[] =
2328 "ABI v0", /* use r5 as return register; only used in N1213HC */
2329 "ABI v1", /* use r0 as return register */
2330 "ABI v2", /* use r0 as return register and don't reserve 24 bytes for arguments */
2331 "ABI v2fp", /* for FPU */
2334 static const char *VER_STRINGS[] =
2336 "Andes ELF V1.3 or older",
2340 static const char *ARCH_STRINGS[] =
2349 abi = EF_NDS_ABI & e_flags;
2350 arch = EF_NDS_ARCH & e_flags;
2351 config = EF_NDS_INST & e_flags;
2352 version = EF_NDS32_ELF_VERSION & e_flags;
2354 memset (buf, 0, size);
2361 case E_NDS_ABI_V2FP:
2362 case E_NDS_ABI_AABI:
2363 /* In case there are holes in the array. */
2364 r += snprintf (buf + r, size - r, ", %s", ABI_STRINGS[abi >> EF_NDS_ABI_SHIFT]);
2368 r += snprintf (buf + r, size - r, ", <unrecognized ABI>");
2374 case E_NDS32_ELF_VER_1_2:
2375 case E_NDS32_ELF_VER_1_3:
2376 case E_NDS32_ELF_VER_1_4:
2377 r += snprintf (buf + r, size - r, ", %s", VER_STRINGS[version >> EF_NDS32_ELF_VERSION_SHIFT]);
2381 r += snprintf (buf + r, size - r, ", <unrecognized ELF version number>");
2385 if (E_NDS_ABI_V0 == abi)
2387 /* OLD ABI; only used in N1213HC, has performance extension 1. */
2388 r += snprintf (buf + r, size - r, ", Andes Star v1.0, N1213HC, MAC, PERF1");
2389 if (arch == E_NDS_ARCH_STAR_V1_0)
2390 r += snprintf (buf + r, size -r, ", 16b"); /* has 16-bit instructions */
2396 case E_NDS_ARCH_STAR_V1_0:
2397 case E_NDS_ARCH_STAR_V2_0:
2398 case E_NDS_ARCH_STAR_V3_0:
2399 case E_NDS_ARCH_STAR_V3_M:
2400 r += snprintf (buf + r, size - r, ", %s", ARCH_STRINGS[arch >> EF_NDS_ARCH_SHIFT]);
2404 r += snprintf (buf + r, size - r, ", <unrecognized architecture>");
2405 /* ARCH version determines how the e_flags are interpreted.
2406 If it is unknown, we cannot proceed. */
2410 /* Newer ABI; Now handle architecture specific flags. */
2411 if (arch == E_NDS_ARCH_STAR_V1_0)
2413 if (config & E_NDS32_HAS_MFUSR_PC_INST)
2414 r += snprintf (buf + r, size -r, ", MFUSR_PC");
2416 if (!(config & E_NDS32_HAS_NO_MAC_INST))
2417 r += snprintf (buf + r, size -r, ", MAC");
2419 if (config & E_NDS32_HAS_DIV_INST)
2420 r += snprintf (buf + r, size -r, ", DIV");
2422 if (config & E_NDS32_HAS_16BIT_INST)
2423 r += snprintf (buf + r, size -r, ", 16b");
2427 if (config & E_NDS32_HAS_MFUSR_PC_INST)
2429 if (version <= E_NDS32_ELF_VER_1_3)
2430 r += snprintf (buf + r, size -r, ", [B8]");
2432 r += snprintf (buf + r, size -r, ", EX9");
2435 if (config & E_NDS32_HAS_MAC_DX_INST)
2436 r += snprintf (buf + r, size -r, ", MAC_DX");
2438 if (config & E_NDS32_HAS_DIV_DX_INST)
2439 r += snprintf (buf + r, size -r, ", DIV_DX");
2441 if (config & E_NDS32_HAS_16BIT_INST)
2443 if (version <= E_NDS32_ELF_VER_1_3)
2444 r += snprintf (buf + r, size -r, ", 16b");
2446 r += snprintf (buf + r, size -r, ", IFC");
2450 if (config & E_NDS32_HAS_EXT_INST)
2451 r += snprintf (buf + r, size -r, ", PERF1");
2453 if (config & E_NDS32_HAS_EXT2_INST)
2454 r += snprintf (buf + r, size -r, ", PERF2");
2456 if (config & E_NDS32_HAS_FPU_INST)
2459 r += snprintf (buf + r, size -r, ", FPU_SP");
2462 if (config & E_NDS32_HAS_FPU_DP_INST)
2465 r += snprintf (buf + r, size -r, ", FPU_DP");
2468 if (config & E_NDS32_HAS_FPU_MAC_INST)
2471 r += snprintf (buf + r, size -r, ", FPU_MAC");
2476 switch ((config & E_NDS32_FPU_REG_CONF) >> E_NDS32_FPU_REG_CONF_SHIFT)
2478 case E_NDS32_FPU_REG_8SP_4DP:
2479 r += snprintf (buf + r, size -r, ", FPU_REG:8/4");
2481 case E_NDS32_FPU_REG_16SP_8DP:
2482 r += snprintf (buf + r, size -r, ", FPU_REG:16/8");
2484 case E_NDS32_FPU_REG_32SP_16DP:
2485 r += snprintf (buf + r, size -r, ", FPU_REG:32/16");
2487 case E_NDS32_FPU_REG_32SP_32DP:
2488 r += snprintf (buf + r, size -r, ", FPU_REG:32/32");
2493 if (config & E_NDS32_HAS_AUDIO_INST)
2494 r += snprintf (buf + r, size -r, ", AUDIO");
2496 if (config & E_NDS32_HAS_STRING_INST)
2497 r += snprintf (buf + r, size -r, ", STR");
2499 if (config & E_NDS32_HAS_REDUCED_REGS)
2500 r += snprintf (buf + r, size -r, ", 16REG");
2502 if (config & E_NDS32_HAS_VIDEO_INST)
2504 if (version <= E_NDS32_ELF_VER_1_3)
2505 r += snprintf (buf + r, size -r, ", VIDEO");
2507 r += snprintf (buf + r, size -r, ", SATURATION");
2510 if (config & E_NDS32_HAS_ENCRIPT_INST)
2511 r += snprintf (buf + r, size -r, ", ENCRP");
2513 if (config & E_NDS32_HAS_L2C_INST)
2514 r += snprintf (buf + r, size -r, ", L2C");
2518 get_machine_flags (unsigned e_flags, unsigned e_machine)
2520 static char buf[1024];
2532 decode_ARM_machine_flags (e_flags, buf);
2536 if (e_flags & EF_BFIN_PIC)
2537 strcat (buf, ", PIC");
2539 if (e_flags & EF_BFIN_FDPIC)
2540 strcat (buf, ", FDPIC");
2542 if (e_flags & EF_BFIN_CODE_IN_L1)
2543 strcat (buf, ", code in L1");
2545 if (e_flags & EF_BFIN_DATA_IN_L1)
2546 strcat (buf, ", data in L1");
2551 switch (e_flags & EF_FRV_CPU_MASK)
2553 case EF_FRV_CPU_GENERIC:
2557 strcat (buf, ", fr???");
2560 case EF_FRV_CPU_FR300:
2561 strcat (buf, ", fr300");
2564 case EF_FRV_CPU_FR400:
2565 strcat (buf, ", fr400");
2567 case EF_FRV_CPU_FR405:
2568 strcat (buf, ", fr405");
2571 case EF_FRV_CPU_FR450:
2572 strcat (buf, ", fr450");
2575 case EF_FRV_CPU_FR500:
2576 strcat (buf, ", fr500");
2578 case EF_FRV_CPU_FR550:
2579 strcat (buf, ", fr550");
2582 case EF_FRV_CPU_SIMPLE:
2583 strcat (buf, ", simple");
2585 case EF_FRV_CPU_TOMCAT:
2586 strcat (buf, ", tomcat");
2592 if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
2593 strcat (buf, ", m68000");
2594 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
2595 strcat (buf, ", cpu32");
2596 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
2597 strcat (buf, ", fido_a");
2600 char const * isa = _("unknown");
2601 char const * mac = _("unknown mac");
2602 char const * additional = NULL;
2604 switch (e_flags & EF_M68K_CF_ISA_MASK)
2606 case EF_M68K_CF_ISA_A_NODIV:
2608 additional = ", nodiv";
2610 case EF_M68K_CF_ISA_A:
2613 case EF_M68K_CF_ISA_A_PLUS:
2616 case EF_M68K_CF_ISA_B_NOUSP:
2618 additional = ", nousp";
2620 case EF_M68K_CF_ISA_B:
2623 case EF_M68K_CF_ISA_C:
2626 case EF_M68K_CF_ISA_C_NODIV:
2628 additional = ", nodiv";
2631 strcat (buf, ", cf, isa ");
2634 strcat (buf, additional);
2635 if (e_flags & EF_M68K_CF_FLOAT)
2636 strcat (buf, ", float");
2637 switch (e_flags & EF_M68K_CF_MAC_MASK)
2642 case EF_M68K_CF_MAC:
2645 case EF_M68K_CF_EMAC:
2648 case EF_M68K_CF_EMAC_B:
2661 if (e_flags & EF_PPC_EMB)
2662 strcat (buf, ", emb");
2664 if (e_flags & EF_PPC_RELOCATABLE)
2665 strcat (buf, _(", relocatable"));
2667 if (e_flags & EF_PPC_RELOCATABLE_LIB)
2668 strcat (buf, _(", relocatable-lib"));
2672 if (e_flags & EF_PPC64_ABI)
2674 char abi[] = ", abiv0";
2676 abi[6] += e_flags & EF_PPC64_ABI;
2682 if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
2683 strcat (buf, ", RH850 ABI");
2685 if (e_flags & EF_V800_850E3)
2686 strcat (buf, ", V3 architecture");
2688 if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
2689 strcat (buf, ", FPU not used");
2691 if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
2692 strcat (buf, ", regmode: COMMON");
2694 if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
2695 strcat (buf, ", r4 not used");
2697 if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
2698 strcat (buf, ", r30 not used");
2700 if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
2701 strcat (buf, ", r5 not used");
2703 if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
2704 strcat (buf, ", r2 not used");
2706 for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
2708 switch (e_flags & - e_flags)
2710 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
2711 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
2712 case EF_RH850_SIMD: strcat (buf, ", SIMD"); break;
2713 case EF_RH850_CACHE: strcat (buf, ", CACHE"); break;
2714 case EF_RH850_MMU: strcat (buf, ", MMU"); break;
2715 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
2716 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
2717 case EF_RH850_DATA_ALIGN8: strcat (buf, ", 8-byte alignment"); break;
2718 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
2719 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
2720 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
2721 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
2722 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
2723 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
2724 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
2725 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
2732 case EM_CYGNUS_V850:
2733 switch (e_flags & EF_V850_ARCH)
2735 case E_V850E3V5_ARCH:
2736 strcat (buf, ", v850e3v5");
2738 case E_V850E2V3_ARCH:
2739 strcat (buf, ", v850e2v3");
2742 strcat (buf, ", v850e2");
2745 strcat (buf, ", v850e1");
2748 strcat (buf, ", v850e");
2751 strcat (buf, ", v850");
2754 strcat (buf, _(", unknown v850 architecture variant"));
2760 case EM_CYGNUS_M32R:
2761 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
2762 strcat (buf, ", m32r");
2766 case EM_MIPS_RS3_LE:
2767 if (e_flags & EF_MIPS_NOREORDER)
2768 strcat (buf, ", noreorder");
2770 if (e_flags & EF_MIPS_PIC)
2771 strcat (buf, ", pic");
2773 if (e_flags & EF_MIPS_CPIC)
2774 strcat (buf, ", cpic");
2776 if (e_flags & EF_MIPS_UCODE)
2777 strcat (buf, ", ugen_reserved");
2779 if (e_flags & EF_MIPS_ABI2)
2780 strcat (buf, ", abi2");
2782 if (e_flags & EF_MIPS_OPTIONS_FIRST)
2783 strcat (buf, ", odk first");
2785 if (e_flags & EF_MIPS_32BITMODE)
2786 strcat (buf, ", 32bitmode");
2788 if (e_flags & EF_MIPS_NAN2008)
2789 strcat (buf, ", nan2008");
2791 if (e_flags & EF_MIPS_FP64)
2792 strcat (buf, ", fp64");
2794 switch ((e_flags & EF_MIPS_MACH))
2796 case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
2797 case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
2798 case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
2799 case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
2800 case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
2801 case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
2802 case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
2803 case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
2804 case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); break;
2805 case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
2806 case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
2807 case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
2808 case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
2809 case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
2810 case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
2811 case E_MIPS_MACH_OCTEON3: strcat (buf, ", octeon3"); break;
2812 case E_MIPS_MACH_XLR: strcat (buf, ", xlr"); break;
2814 /* We simply ignore the field in this case to avoid confusion:
2815 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2818 default: strcat (buf, _(", unknown CPU")); break;
2821 switch ((e_flags & EF_MIPS_ABI))
2823 case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
2824 case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
2825 case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
2826 case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
2828 /* We simply ignore the field in this case to avoid confusion:
2829 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2830 This means it is likely to be an o32 file, but not for
2833 default: strcat (buf, _(", unknown ABI")); break;
2836 if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
2837 strcat (buf, ", mdmx");
2839 if (e_flags & EF_MIPS_ARCH_ASE_M16)
2840 strcat (buf, ", mips16");
2842 if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
2843 strcat (buf, ", micromips");
2845 switch ((e_flags & EF_MIPS_ARCH))
2847 case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
2848 case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
2849 case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
2850 case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
2851 case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
2852 case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
2853 case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
2854 case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
2855 case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
2856 default: strcat (buf, _(", unknown ISA")); break;
2861 decode_NDS32_machine_flags (e_flags, buf, sizeof buf);
2865 switch ((e_flags & EF_SH_MACH_MASK))
2867 case EF_SH1: strcat (buf, ", sh1"); break;
2868 case EF_SH2: strcat (buf, ", sh2"); break;
2869 case EF_SH3: strcat (buf, ", sh3"); break;
2870 case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
2871 case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
2872 case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
2873 case EF_SH3E: strcat (buf, ", sh3e"); break;
2874 case EF_SH4: strcat (buf, ", sh4"); break;
2875 case EF_SH5: strcat (buf, ", sh5"); break;
2876 case EF_SH2E: strcat (buf, ", sh2e"); break;
2877 case EF_SH4A: strcat (buf, ", sh4a"); break;
2878 case EF_SH2A: strcat (buf, ", sh2a"); break;
2879 case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
2880 case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
2881 case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
2882 case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
2883 case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
2884 case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
2885 case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
2886 case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
2887 case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
2888 default: strcat (buf, _(", unknown ISA")); break;
2891 if (e_flags & EF_SH_PIC)
2892 strcat (buf, ", pic");
2894 if (e_flags & EF_SH_FDPIC)
2895 strcat (buf, ", fdpic");
2899 if (e_flags & EF_SPARC_32PLUS)
2900 strcat (buf, ", v8+");
2902 if (e_flags & EF_SPARC_SUN_US1)
2903 strcat (buf, ", ultrasparcI");
2905 if (e_flags & EF_SPARC_SUN_US3)
2906 strcat (buf, ", ultrasparcIII");
2908 if (e_flags & EF_SPARC_HAL_R1)
2909 strcat (buf, ", halr1");
2911 if (e_flags & EF_SPARC_LEDATA)
2912 strcat (buf, ", ledata");
2914 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
2915 strcat (buf, ", tso");
2917 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
2918 strcat (buf, ", pso");
2920 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
2921 strcat (buf, ", rmo");
2925 switch (e_flags & EF_PARISC_ARCH)
2927 case EFA_PARISC_1_0:
2928 strcpy (buf, ", PA-RISC 1.0");
2930 case EFA_PARISC_1_1:
2931 strcpy (buf, ", PA-RISC 1.1");
2933 case EFA_PARISC_2_0:
2934 strcpy (buf, ", PA-RISC 2.0");
2939 if (e_flags & EF_PARISC_TRAPNIL)
2940 strcat (buf, ", trapnil");
2941 if (e_flags & EF_PARISC_EXT)
2942 strcat (buf, ", ext");
2943 if (e_flags & EF_PARISC_LSB)
2944 strcat (buf, ", lsb");
2945 if (e_flags & EF_PARISC_WIDE)
2946 strcat (buf, ", wide");
2947 if (e_flags & EF_PARISC_NO_KABP)
2948 strcat (buf, ", no kabp");
2949 if (e_flags & EF_PARISC_LAZYSWAP)
2950 strcat (buf, ", lazyswap");
2955 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
2956 strcat (buf, ", new calling convention");
2958 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
2959 strcat (buf, ", gnu calling convention");
2963 if ((e_flags & EF_IA_64_ABI64))
2964 strcat (buf, ", 64-bit");
2966 strcat (buf, ", 32-bit");
2967 if ((e_flags & EF_IA_64_REDUCEDFP))
2968 strcat (buf, ", reduced fp model");
2969 if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
2970 strcat (buf, ", no function descriptors, constant gp");
2971 else if ((e_flags & EF_IA_64_CONS_GP))
2972 strcat (buf, ", constant gp");
2973 if ((e_flags & EF_IA_64_ABSOLUTE))
2974 strcat (buf, ", absolute");
2975 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
2977 if ((e_flags & EF_IA_64_VMS_LINKAGES))
2978 strcat (buf, ", vms_linkages");
2979 switch ((e_flags & EF_IA_64_VMS_COMCOD))
2981 case EF_IA_64_VMS_COMCOD_SUCCESS:
2983 case EF_IA_64_VMS_COMCOD_WARNING:
2984 strcat (buf, ", warning");
2986 case EF_IA_64_VMS_COMCOD_ERROR:
2987 strcat (buf, ", error");
2989 case EF_IA_64_VMS_COMCOD_ABORT:
2990 strcat (buf, ", abort");
2999 if ((e_flags & EF_VAX_NONPIC))
3000 strcat (buf, ", non-PIC");
3001 if ((e_flags & EF_VAX_DFLOAT))
3002 strcat (buf, ", D-Float");
3003 if ((e_flags & EF_VAX_GFLOAT))
3004 strcat (buf, ", G-Float");
3008 if (e_flags & E_FLAG_RL78_G10)
3009 strcat (buf, ", G10");
3013 if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
3014 strcat (buf, ", 64-bit doubles");
3015 if (e_flags & E_FLAG_RX_DSP)
3016 strcat (buf, ", dsp");
3017 if (e_flags & E_FLAG_RX_PID)
3018 strcat (buf, ", pid");
3019 if (e_flags & E_FLAG_RX_ABI)
3020 strcat (buf, ", RX ABI");
3024 if (e_flags & EF_S390_HIGH_GPRS)
3025 strcat (buf, ", highgprs");
3029 if ((e_flags & EF_C6000_REL))
3030 strcat (buf, ", relocatable module");
3034 strcat (buf, _(": architecture variant: "));
3035 switch (e_flags & EF_MSP430_MACH)
3037 case E_MSP430_MACH_MSP430x11: strcat (buf, "MSP430x11"); break;
3038 case E_MSP430_MACH_MSP430x11x1 : strcat (buf, "MSP430x11x1 "); break;
3039 case E_MSP430_MACH_MSP430x12: strcat (buf, "MSP430x12"); break;
3040 case E_MSP430_MACH_MSP430x13: strcat (buf, "MSP430x13"); break;
3041 case E_MSP430_MACH_MSP430x14: strcat (buf, "MSP430x14"); break;
3042 case E_MSP430_MACH_MSP430x15: strcat (buf, "MSP430x15"); break;
3043 case E_MSP430_MACH_MSP430x16: strcat (buf, "MSP430x16"); break;
3044 case E_MSP430_MACH_MSP430x31: strcat (buf, "MSP430x31"); break;
3045 case E_MSP430_MACH_MSP430x32: strcat (buf, "MSP430x32"); break;
3046 case E_MSP430_MACH_MSP430x33: strcat (buf, "MSP430x33"); break;
3047 case E_MSP430_MACH_MSP430x41: strcat (buf, "MSP430x41"); break;
3048 case E_MSP430_MACH_MSP430x42: strcat (buf, "MSP430x42"); break;
3049 case E_MSP430_MACH_MSP430x43: strcat (buf, "MSP430x43"); break;
3050 case E_MSP430_MACH_MSP430x44: strcat (buf, "MSP430x44"); break;
3051 case E_MSP430_MACH_MSP430X : strcat (buf, "MSP430X"); break;
3053 strcat (buf, _(": unknown")); break;
3056 if (e_flags & ~ EF_MSP430_MACH)
3057 strcat (buf, _(": unknown extra flag bits also present"));
3065 get_osabi_name (unsigned int osabi)
3067 static char buff[32];
3071 case ELFOSABI_NONE: return "UNIX - System V";
3072 case ELFOSABI_HPUX: return "UNIX - HP-UX";
3073 case ELFOSABI_NETBSD: return "UNIX - NetBSD";
3074 case ELFOSABI_GNU: return "UNIX - GNU";
3075 case ELFOSABI_SOLARIS: return "UNIX - Solaris";
3076 case ELFOSABI_AIX: return "UNIX - AIX";
3077 case ELFOSABI_IRIX: return "UNIX - IRIX";
3078 case ELFOSABI_FREEBSD: return "UNIX - FreeBSD";
3079 case ELFOSABI_TRU64: return "UNIX - TRU64";
3080 case ELFOSABI_MODESTO: return "Novell - Modesto";
3081 case ELFOSABI_OPENBSD: return "UNIX - OpenBSD";
3082 case ELFOSABI_OPENVMS: return "VMS - OpenVMS";
3083 case ELFOSABI_NSK: return "HP - Non-Stop Kernel";
3084 case ELFOSABI_AROS: return "AROS";
3085 case ELFOSABI_FENIXOS: return "FenixOS";
3088 switch (elf_header.e_machine)
3093 case ELFOSABI_ARM: return "ARM";
3103 case ELFOSABI_STANDALONE: return _("Standalone App");
3112 case ELFOSABI_C6000_ELFABI: return _("Bare-metal C6000");
3113 case ELFOSABI_C6000_LINUX: return "Linux C6000";
3122 snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
3128 get_aarch64_segment_type (unsigned long type)
3132 case PT_AARCH64_ARCHEXT:
3133 return "AARCH64_ARCHEXT";
3142 get_arm_segment_type (unsigned long type)
3156 get_mips_segment_type (unsigned long type)
3160 case PT_MIPS_REGINFO:
3162 case PT_MIPS_RTPROC:
3164 case PT_MIPS_OPTIONS:
3174 get_parisc_segment_type (unsigned long type)
3178 case PT_HP_TLS: return "HP_TLS";
3179 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
3180 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
3181 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
3182 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
3183 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
3184 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
3185 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
3186 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
3187 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
3188 case PT_HP_PARALLEL: return "HP_PARALLEL";
3189 case PT_HP_FASTBIND: return "HP_FASTBIND";
3190 case PT_HP_OPT_ANNOT: return "HP_OPT_ANNOT";
3191 case PT_HP_HSL_ANNOT: return "HP_HSL_ANNOT";
3192 case PT_HP_STACK: return "HP_STACK";
3193 case PT_HP_CORE_UTSNAME: return "HP_CORE_UTSNAME";
3194 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
3195 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
3196 case PT_PARISC_WEAKORDER: return "PARISC_WEAKORDER";
3205 get_ia64_segment_type (unsigned long type)
3209 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
3210 case PT_IA_64_UNWIND: return "IA_64_UNWIND";
3211 case PT_HP_TLS: return "HP_TLS";
3212 case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
3213 case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
3214 case PT_IA_64_HP_STACK: return "HP_STACK";
3223 get_tic6x_segment_type (unsigned long type)
3227 case PT_C6000_PHATTR: return "C6000_PHATTR";
3236 get_segment_type (unsigned long p_type)
3238 static char buff[32];
3242 case PT_NULL: return "NULL";
3243 case PT_LOAD: return "LOAD";
3244 case PT_DYNAMIC: return "DYNAMIC";
3245 case PT_INTERP: return "INTERP";
3246 case PT_NOTE: return "NOTE";
3247 case PT_SHLIB: return "SHLIB";
3248 case PT_PHDR: return "PHDR";
3249 case PT_TLS: return "TLS";
3251 case PT_GNU_EH_FRAME:
3252 return "GNU_EH_FRAME";
3253 case PT_GNU_STACK: return "GNU_STACK";
3254 case PT_GNU_RELRO: return "GNU_RELRO";
3257 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
3259 const char * result;
3261 switch (elf_header.e_machine)
3264 result = get_aarch64_segment_type (p_type);
3267 result = get_arm_segment_type (p_type);
3270 case EM_MIPS_RS3_LE:
3271 result = get_mips_segment_type (p_type);
3274 result = get_parisc_segment_type (p_type);
3277 result = get_ia64_segment_type (p_type);
3280 result = get_tic6x_segment_type (p_type);
3290 sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
3292 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
3294 const char * result;
3296 switch (elf_header.e_machine)
3299 result = get_parisc_segment_type (p_type);
3302 result = get_ia64_segment_type (p_type);
3312 sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
3315 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
3322 get_mips_section_type_name (unsigned int sh_type)
3326 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
3327 case SHT_MIPS_MSYM: return "MIPS_MSYM";
3328 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
3329 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
3330 case SHT_MIPS_UCODE: return "MIPS_UCODE";
3331 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
3332 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
3333 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
3334 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
3335 case SHT_MIPS_RELD: return "MIPS_RELD";
3336 case SHT_MIPS_IFACE: return "MIPS_IFACE";
3337 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
3338 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
3339 case SHT_MIPS_SHDR: return "MIPS_SHDR";
3340 case SHT_MIPS_FDESC: return "MIPS_FDESC";
3341 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
3342 case SHT_MIPS_DENSE: return "MIPS_DENSE";
3343 case SHT_MIPS_PDESC: return "MIPS_PDESC";
3344 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
3345 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
3346 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
3347 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
3348 case SHT_MIPS_LINE: return "MIPS_LINE";
3349 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
3350 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
3351 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
3352 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
3353 case SHT_MIPS_DWARF: return "MIPS_DWARF";
3354 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
3355 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
3356 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
3357 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
3358 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
3359 case SHT_MIPS_XLATE: return "MIPS_XLATE";
3360 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
3361 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
3362 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
3363 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
3364 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
3372 get_parisc_section_type_name (unsigned int sh_type)
3376 case SHT_PARISC_EXT: return "PARISC_EXT";
3377 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
3378 case SHT_PARISC_DOC: return "PARISC_DOC";
3379 case SHT_PARISC_ANNOT: return "PARISC_ANNOT";
3380 case SHT_PARISC_SYMEXTN: return "PARISC_SYMEXTN";
3381 case SHT_PARISC_STUBS: return "PARISC_STUBS";
3382 case SHT_PARISC_DLKM: return "PARISC_DLKM";
3390 get_ia64_section_type_name (unsigned int sh_type)
3392 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
3393 if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
3394 return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
3398 case SHT_IA_64_EXT: return "IA_64_EXT";
3399 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
3400 case SHT_IA_64_PRIORITY_INIT: return "IA_64_PRIORITY_INIT";
3401 case SHT_IA_64_VMS_TRACE: return "VMS_TRACE";
3402 case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
3403 case SHT_IA_64_VMS_DEBUG: return "VMS_DEBUG";
3404 case SHT_IA_64_VMS_DEBUG_STR: return "VMS_DEBUG_STR";
3405 case SHT_IA_64_VMS_LINKAGES: return "VMS_LINKAGES";
3406 case SHT_IA_64_VMS_SYMBOL_VECTOR: return "VMS_SYMBOL_VECTOR";
3407 case SHT_IA_64_VMS_FIXUP: return "VMS_FIXUP";
3415 get_x86_64_section_type_name (unsigned int sh_type)
3419 case SHT_X86_64_UNWIND: return "X86_64_UNWIND";
3427 get_aarch64_section_type_name (unsigned int sh_type)
3431 case SHT_AARCH64_ATTRIBUTES:
3432 return "AARCH64_ATTRIBUTES";
3440 get_arm_section_type_name (unsigned int sh_type)
3444 case SHT_ARM_EXIDX: return "ARM_EXIDX";
3445 case SHT_ARM_PREEMPTMAP: return "ARM_PREEMPTMAP";
3446 case SHT_ARM_ATTRIBUTES: return "ARM_ATTRIBUTES";
3447 case SHT_ARM_DEBUGOVERLAY: return "ARM_DEBUGOVERLAY";
3448 case SHT_ARM_OVERLAYSECTION: return "ARM_OVERLAYSECTION";
3456 get_tic6x_section_type_name (unsigned int sh_type)
3460 case SHT_C6000_UNWIND:
3461 return "C6000_UNWIND";
3462 case SHT_C6000_PREEMPTMAP:
3463 return "C6000_PREEMPTMAP";
3464 case SHT_C6000_ATTRIBUTES:
3465 return "C6000_ATTRIBUTES";
3470 case SHT_TI_HANDLER:
3471 return "TI_HANDLER";
3472 case SHT_TI_INITINFO:
3473 return "TI_INITINFO";
3474 case SHT_TI_PHATTRS:
3475 return "TI_PHATTRS";
3483 get_msp430x_section_type_name (unsigned int sh_type)
3487 case SHT_MSP430_SEC_FLAGS: return "MSP430_SEC_FLAGS";
3488 case SHT_MSP430_SYM_ALIASES: return "MSP430_SYM_ALIASES";
3489 case SHT_MSP430_ATTRIBUTES: return "MSP430_ATTRIBUTES";
3490 default: return NULL;
3495 get_section_type_name (unsigned int sh_type)
3497 static char buff[32];
3501 case SHT_NULL: return "NULL";
3502 case SHT_PROGBITS: return "PROGBITS";
3503 case SHT_SYMTAB: return "SYMTAB";
3504 case SHT_STRTAB: return "STRTAB";
3505 case SHT_RELA: return "RELA";
3506 case SHT_HASH: return "HASH";
3507 case SHT_DYNAMIC: return "DYNAMIC";
3508 case SHT_NOTE: return "NOTE";
3509 case SHT_NOBITS: return "NOBITS";
3510 case SHT_REL: return "REL";
3511 case SHT_SHLIB: return "SHLIB";
3512 case SHT_DYNSYM: return "DYNSYM";
3513 case SHT_INIT_ARRAY: return "INIT_ARRAY";
3514 case SHT_FINI_ARRAY: return "FINI_ARRAY";
3515 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
3516 case SHT_GNU_HASH: return "GNU_HASH";
3517 case SHT_GROUP: return "GROUP";
3518 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICIES";
3519 case SHT_GNU_verdef: return "VERDEF";
3520 case SHT_GNU_verneed: return "VERNEED";
3521 case SHT_GNU_versym: return "VERSYM";
3522 case 0x6ffffff0: return "VERSYM";
3523 case 0x6ffffffc: return "VERDEF";
3524 case 0x7ffffffd: return "AUXILIARY";
3525 case 0x7fffffff: return "FILTER";
3526 case SHT_GNU_LIBLIST: return "GNU_LIBLIST";
3529 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
3531 const char * result;
3533 switch (elf_header.e_machine)
3536 case EM_MIPS_RS3_LE:
3537 result = get_mips_section_type_name (sh_type);
3540 result = get_parisc_section_type_name (sh_type);
3543 result = get_ia64_section_type_name (sh_type);
3548 result = get_x86_64_section_type_name (sh_type);
3551 result = get_aarch64_section_type_name (sh_type);
3554 result = get_arm_section_type_name (sh_type);
3557 result = get_tic6x_section_type_name (sh_type);
3560 result = get_msp430x_section_type_name (sh_type);
3570 sprintf (buff, "LOPROC+%x", sh_type - SHT_LOPROC);
3572 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
3574 const char * result;
3576 switch (elf_header.e_machine)
3579 result = get_ia64_section_type_name (sh_type);
3589 sprintf (buff, "LOOS+%x", sh_type - SHT_LOOS);
3591 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
3592 sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER);
3594 /* This message is probably going to be displayed in a 15
3595 character wide field, so put the hex value first. */
3596 snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
3602 #define OPTION_DEBUG_DUMP 512
3603 #define OPTION_DYN_SYMS 513
3604 #define OPTION_DWARF_DEPTH 514
3605 #define OPTION_DWARF_START 515
3606 #define OPTION_DWARF_CHECK 516
3608 static struct option options[] =
3610 {"all", no_argument, 0, 'a'},
3611 {"file-header", no_argument, 0, 'h'},
3612 {"program-headers", no_argument, 0, 'l'},
3613 {"headers", no_argument, 0, 'e'},
3614 {"histogram", no_argument, 0, 'I'},
3615 {"segments", no_argument, 0, 'l'},
3616 {"sections", no_argument, 0, 'S'},
3617 {"section-headers", no_argument, 0, 'S'},
3618 {"section-groups", no_argument, 0, 'g'},
3619 {"section-details", no_argument, 0, 't'},
3620 {"full-section-name",no_argument, 0, 'N'},
3621 {"symbols", no_argument, 0, 's'},
3622 {"syms", no_argument, 0, 's'},
3623 {"dyn-syms", no_argument, 0, OPTION_DYN_SYMS},
3624 {"relocs", no_argument, 0, 'r'},
3625 {"notes", no_argument, 0, 'n'},
3626 {"dynamic", no_argument, 0, 'd'},
3627 {"arch-specific", no_argument, 0, 'A'},
3628 {"version-info", no_argument, 0, 'V'},
3629 {"use-dynamic", no_argument, 0, 'D'},
3630 {"unwind", no_argument, 0, 'u'},
3631 {"archive-index", no_argument, 0, 'c'},
3632 {"hex-dump", required_argument, 0, 'x'},
3633 {"relocated-dump", required_argument, 0, 'R'},
3634 {"string-dump", required_argument, 0, 'p'},
3635 #ifdef SUPPORT_DISASSEMBLY
3636 {"instruction-dump", required_argument, 0, 'i'},
3638 {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
3640 {"dwarf-depth", required_argument, 0, OPTION_DWARF_DEPTH},
3641 {"dwarf-start", required_argument, 0, OPTION_DWARF_START},
3642 {"dwarf-check", no_argument, 0, OPTION_DWARF_CHECK},
3644 {"version", no_argument, 0, 'v'},
3645 {"wide", no_argument, 0, 'W'},
3646 {"help", no_argument, 0, 'H'},
3647 {0, no_argument, 0, 0}
3651 usage (FILE * stream)
3653 fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
3654 fprintf (stream, _(" Display information about the contents of ELF format files\n"));
3655 fprintf (stream, _(" Options are:\n\
3656 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3657 -h --file-header Display the ELF file header\n\
3658 -l --program-headers Display the program headers\n\
3659 --segments An alias for --program-headers\n\
3660 -S --section-headers Display the sections' header\n\
3661 --sections An alias for --section-headers\n\
3662 -g --section-groups Display the section groups\n\
3663 -t --section-details Display the section details\n\
3664 -e --headers Equivalent to: -h -l -S\n\
3665 -s --syms Display the symbol table\n\
3666 --symbols An alias for --syms\n\
3667 --dyn-syms Display the dynamic symbol table\n\
3668 -n --notes Display the core notes (if present)\n\
3669 -r --relocs Display the relocations (if present)\n\
3670 -u --unwind Display the unwind info (if present)\n\
3671 -d --dynamic Display the dynamic section (if present)\n\
3672 -V --version-info Display the version sections (if present)\n\
3673 -A --arch-specific Display architecture specific information (if any)\n\
3674 -c --archive-index Display the symbol/file index in an archive\n\
3675 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
3676 -x --hex-dump=<number|name>\n\
3677 Dump the contents of section <number|name> as bytes\n\
3678 -p --string-dump=<number|name>\n\
3679 Dump the contents of section <number|name> as strings\n\
3680 -R --relocated-dump=<number|name>\n\
3681 Dump the contents of section <number|name> as relocated bytes\n\
3682 -w[lLiaprmfFsoRt] or\n\
3683 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
3684 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
3685 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
3687 Display the contents of DWARF2 debug sections\n"));
3688 fprintf (stream, _("\
3689 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
3690 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
3692 #ifdef SUPPORT_DISASSEMBLY
3693 fprintf (stream, _("\
3694 -i --instruction-dump=<number|name>\n\
3695 Disassemble the contents of section <number|name>\n"));
3697 fprintf (stream, _("\
3698 -I --histogram Display histogram of bucket list lengths\n\
3699 -W --wide Allow output width to exceed 80 characters\n\
3700 @<file> Read options from <file>\n\
3701 -H --help Display this information\n\
3702 -v --version Display the version number of readelf\n"));
3704 if (REPORT_BUGS_TO[0] && stream == stdout)
3705 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
3707 exit (stream == stdout ? 0 : 1);
3710 /* Record the fact that the user wants the contents of section number
3711 SECTION to be displayed using the method(s) encoded as flags bits
3712 in TYPE. Note, TYPE can be zero if we are creating the array for
3716 request_dump_bynumber (unsigned int section, dump_type type)
3718 if (section >= num_dump_sects)
3720 dump_type * new_dump_sects;
3722 new_dump_sects = (dump_type *) calloc (section + 1,
3723 sizeof (* dump_sects));
3725 if (new_dump_sects == NULL)
3726 error (_("Out of memory allocating dump request table.\n"));
3729 /* Copy current flag settings. */
3730 memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
3734 dump_sects = new_dump_sects;
3735 num_dump_sects = section + 1;
3740 dump_sects[section] |= type;
3745 /* Request a dump by section name. */
3748 request_dump_byname (const char * section, dump_type type)
3750 struct dump_list_entry * new_request;
3752 new_request = (struct dump_list_entry *)
3753 malloc (sizeof (struct dump_list_entry));
3755 error (_("Out of memory allocating dump request table.\n"));
3757 new_request->name = strdup (section);
3758 if (!new_request->name)
3759 error (_("Out of memory allocating dump request table.\n"));
3761 new_request->type = type;
3763 new_request->next = dump_sects_byname;
3764 dump_sects_byname = new_request;
3768 request_dump (dump_type type)
3774 section = strtoul (optarg, & cp, 0);
3776 if (! *cp && section >= 0)
3777 request_dump_bynumber (section, type);
3779 request_dump_byname (optarg, type);
3784 parse_args (int argc, char ** argv)
3791 while ((c = getopt_long
3792 (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options, NULL)) != EOF)
3810 do_section_groups++;
3818 do_section_groups++;
3823 do_section_details++;
3867 request_dump (HEX_DUMP);
3870 request_dump (STRING_DUMP);
3873 request_dump (RELOC_DUMP);
3880 dwarf_select_sections_all ();
3885 dwarf_select_sections_by_letters (optarg);
3888 case OPTION_DEBUG_DUMP:
3895 dwarf_select_sections_by_names (optarg);
3898 case OPTION_DWARF_DEPTH:
3902 dwarf_cutoff_level = strtoul (optarg, & cp, 0);
3905 case OPTION_DWARF_START:
3909 dwarf_start_die = strtoul (optarg, & cp, 0);
3912 case OPTION_DWARF_CHECK:
3915 case OPTION_DYN_SYMS:
3918 #ifdef SUPPORT_DISASSEMBLY
3920 request_dump (DISASS_DUMP);
3924 print_version (program_name);
3933 /* xgettext:c-format */
3934 error (_("Invalid option '-%c'\n"), c);
3941 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
3942 && !do_segments && !do_header && !do_dump && !do_version
3943 && !do_histogram && !do_debugging && !do_arch && !do_notes
3944 && !do_section_groups && !do_archive_index
3949 warn (_("Nothing to do.\n"));
3955 get_elf_class (unsigned int elf_class)
3957 static char buff[32];
3961 case ELFCLASSNONE: return _("none");
3962 case ELFCLASS32: return "ELF32";
3963 case ELFCLASS64: return "ELF64";
3965 snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
3971 get_data_encoding (unsigned int encoding)
3973 static char buff[32];
3977 case ELFDATANONE: return _("none");
3978 case ELFDATA2LSB: return _("2's complement, little endian");
3979 case ELFDATA2MSB: return _("2's complement, big endian");
3981 snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
3986 /* Decode the data held in 'elf_header'. */
3989 process_file_header (void)
3991 if ( elf_header.e_ident[EI_MAG0] != ELFMAG0
3992 || elf_header.e_ident[EI_MAG1] != ELFMAG1
3993 || elf_header.e_ident[EI_MAG2] != ELFMAG2
3994 || elf_header.e_ident[EI_MAG3] != ELFMAG3)
3997 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
4001 init_dwarf_regnames (elf_header.e_machine);
4007 printf (_("ELF Header:\n"));
4008 printf (_(" Magic: "));
4009 for (i = 0; i < EI_NIDENT; i++)
4010 printf ("%2.2x ", elf_header.e_ident[i]);
4012 printf (_(" Class: %s\n"),
4013 get_elf_class (elf_header.e_ident[EI_CLASS]));
4014 printf (_(" Data: %s\n"),
4015 get_data_encoding (elf_header.e_ident[EI_DATA]));
4016 printf (_(" Version: %d %s\n"),
4017 elf_header.e_ident[EI_VERSION],
4018 (elf_header.e_ident[EI_VERSION] == EV_CURRENT
4020 : (elf_header.e_ident[EI_VERSION] != EV_NONE
4021 ? _("<unknown: %lx>")
4023 printf (_(" OS/ABI: %s\n"),
4024 get_osabi_name (elf_header.e_ident[EI_OSABI]));
4025 printf (_(" ABI Version: %d\n"),
4026 elf_header.e_ident[EI_ABIVERSION]);
4027 printf (_(" Type: %s\n"),
4028 get_file_type (elf_header.e_type));
4029 printf (_(" Machine: %s\n"),
4030 get_machine_name (elf_header.e_machine));
4031 printf (_(" Version: 0x%lx\n"),
4032 (unsigned long) elf_header.e_version);
4034 printf (_(" Entry point address: "));
4035 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4036 printf (_("\n Start of program headers: "));
4037 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4038 printf (_(" (bytes into file)\n Start of section headers: "));
4039 print_vma ((bfd_vma) elf_header.e_shoff, DEC);
4040 printf (_(" (bytes into file)\n"));
4042 printf (_(" Flags: 0x%lx%s\n"),
4043 (unsigned long) elf_header.e_flags,
4044 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
4045 printf (_(" Size of this header: %ld (bytes)\n"),
4046 (long) elf_header.e_ehsize);
4047 printf (_(" Size of program headers: %ld (bytes)\n"),
4048 (long) elf_header.e_phentsize);
4049 printf (_(" Number of program headers: %ld"),
4050 (long) elf_header.e_phnum);
4051 if (section_headers != NULL
4052 && elf_header.e_phnum == PN_XNUM
4053 && section_headers[0].sh_info != 0)
4054 printf (" (%ld)", (long) section_headers[0].sh_info);
4055 putc ('\n', stdout);
4056 printf (_(" Size of section headers: %ld (bytes)\n"),
4057 (long) elf_header.e_shentsize);
4058 printf (_(" Number of section headers: %ld"),
4059 (long) elf_header.e_shnum);
4060 if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
4061 printf (" (%ld)", (long) section_headers[0].sh_size);
4062 putc ('\n', stdout);
4063 printf (_(" Section header string table index: %ld"),
4064 (long) elf_header.e_shstrndx);
4065 if (section_headers != NULL
4066 && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
4067 printf (" (%u)", section_headers[0].sh_link);
4068 else if (elf_header.e_shstrndx != SHN_UNDEF
4069 && elf_header.e_shstrndx >= elf_header.e_shnum)
4070 printf (_(" <corrupt: out of range>"));
4071 putc ('\n', stdout);
4074 if (section_headers != NULL)
4076 if (elf_header.e_phnum == PN_XNUM
4077 && section_headers[0].sh_info != 0)
4078 elf_header.e_phnum = section_headers[0].sh_info;
4079 if (elf_header.e_shnum == SHN_UNDEF)
4080 elf_header.e_shnum = section_headers[0].sh_size;
4081 if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
4082 elf_header.e_shstrndx = section_headers[0].sh_link;
4083 else if (elf_header.e_shstrndx >= elf_header.e_shnum)
4084 elf_header.e_shstrndx = SHN_UNDEF;
4085 free (section_headers);
4086 section_headers = NULL;
4094 get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
4096 Elf32_External_Phdr * phdrs;
4097 Elf32_External_Phdr * external;
4098 Elf_Internal_Phdr * internal;
4101 phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
4102 elf_header.e_phentsize,
4104 _("program headers"));
4108 for (i = 0, internal = pheaders, external = phdrs;
4109 i < elf_header.e_phnum;
4110 i++, internal++, external++)
4112 internal->p_type = BYTE_GET (external->p_type);
4113 internal->p_offset = BYTE_GET (external->p_offset);
4114 internal->p_vaddr = BYTE_GET (external->p_vaddr);
4115 internal->p_paddr = BYTE_GET (external->p_paddr);
4116 internal->p_filesz = BYTE_GET (external->p_filesz);
4117 internal->p_memsz = BYTE_GET (external->p_memsz);
4118 internal->p_flags = BYTE_GET (external->p_flags);
4119 internal->p_align = BYTE_GET (external->p_align);
4128 get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
4130 Elf64_External_Phdr * phdrs;
4131 Elf64_External_Phdr * external;
4132 Elf_Internal_Phdr * internal;
4135 phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
4136 elf_header.e_phentsize,
4138 _("program headers"));
4142 for (i = 0, internal = pheaders, external = phdrs;
4143 i < elf_header.e_phnum;
4144 i++, internal++, external++)
4146 internal->p_type = BYTE_GET (external->p_type);
4147 internal->p_flags = BYTE_GET (external->p_flags);
4148 internal->p_offset = BYTE_GET (external->p_offset);
4149 internal->p_vaddr = BYTE_GET (external->p_vaddr);
4150 internal->p_paddr = BYTE_GET (external->p_paddr);
4151 internal->p_filesz = BYTE_GET (external->p_filesz);
4152 internal->p_memsz = BYTE_GET (external->p_memsz);
4153 internal->p_align = BYTE_GET (external->p_align);
4161 /* Returns 1 if the program headers were read into `program_headers'. */
4164 get_program_headers (FILE * file)
4166 Elf_Internal_Phdr * phdrs;
4168 /* Check cache of prior read. */
4169 if (program_headers != NULL)
4172 phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
4173 sizeof (Elf_Internal_Phdr));
4177 error (_("Out of memory\n"));
4182 ? get_32bit_program_headers (file, phdrs)
4183 : get_64bit_program_headers (file, phdrs))
4185 program_headers = phdrs;
4193 /* Returns 1 if the program headers were loaded. */
4196 process_program_headers (FILE * file)
4198 Elf_Internal_Phdr * segment;
4201 if (elf_header.e_phnum == 0)
4203 /* PR binutils/12467. */
4204 if (elf_header.e_phoff != 0)
4205 warn (_("possibly corrupt ELF header - it has a non-zero program"
4206 " header offset, but no program headers"));
4207 else if (do_segments)
4208 printf (_("\nThere are no program headers in this file.\n"));
4212 if (do_segments && !do_header)
4214 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
4215 printf (_("Entry point "));
4216 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
4217 printf (_("\nThere are %d program headers, starting at offset "),
4218 elf_header.e_phnum);
4219 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
4223 if (! get_program_headers (file))
4228 if (elf_header.e_phnum > 1)
4229 printf (_("\nProgram Headers:\n"));
4231 printf (_("\nProgram Headers:\n"));
4235 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4238 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
4242 (_(" Type Offset VirtAddr PhysAddr\n"));
4244 (_(" FileSiz MemSiz Flags Align\n"));
4251 for (i = 0, segment = program_headers;
4252 i < elf_header.e_phnum;
4257 printf (" %-14.14s ", get_segment_type (segment->p_type));
4261 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4262 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
4263 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
4264 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
4265 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
4267 (segment->p_flags & PF_R ? 'R' : ' '),
4268 (segment->p_flags & PF_W ? 'W' : ' '),
4269 (segment->p_flags & PF_X ? 'E' : ' '));
4270 printf ("%#lx", (unsigned long) segment->p_align);
4274 if ((unsigned long) segment->p_offset == segment->p_offset)
4275 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
4278 print_vma (segment->p_offset, FULL_HEX);
4282 print_vma (segment->p_vaddr, FULL_HEX);
4284 print_vma (segment->p_paddr, FULL_HEX);
4287 if ((unsigned long) segment->p_filesz == segment->p_filesz)
4288 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
4291 print_vma (segment->p_filesz, FULL_HEX);
4295 if ((unsigned long) segment->p_memsz == segment->p_memsz)
4296 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
4299 print_vma (segment->p_memsz, FULL_HEX);
4303 (segment->p_flags & PF_R ? 'R' : ' '),
4304 (segment->p_flags & PF_W ? 'W' : ' '),
4305 (segment->p_flags & PF_X ? 'E' : ' '));
4307 if ((unsigned long) segment->p_align == segment->p_align)
4308 printf ("%#lx", (unsigned long) segment->p_align);
4311 print_vma (segment->p_align, PREFIX_HEX);
4316 print_vma (segment->p_offset, FULL_HEX);
4318 print_vma (segment->p_vaddr, FULL_HEX);
4320 print_vma (segment->p_paddr, FULL_HEX);
4322 print_vma (segment->p_filesz, FULL_HEX);
4324 print_vma (segment->p_memsz, FULL_HEX);
4326 (segment->p_flags & PF_R ? 'R' : ' '),
4327 (segment->p_flags & PF_W ? 'W' : ' '),
4328 (segment->p_flags & PF_X ? 'E' : ' '));
4329 print_vma (segment->p_align, HEX);
4333 switch (segment->p_type)
4337 error (_("more than one dynamic segment\n"));
4339 /* By default, assume that the .dynamic section is the first
4340 section in the DYNAMIC segment. */
4341 dynamic_addr = segment->p_offset;
4342 dynamic_size = segment->p_filesz;
4344 /* Try to locate the .dynamic section. If there is
4345 a section header table, we can easily locate it. */
4346 if (section_headers != NULL)
4348 Elf_Internal_Shdr * sec;
4350 sec = find_section (".dynamic");
4351 if (sec == NULL || sec->sh_size == 0)
4353 /* A corresponding .dynamic section is expected, but on
4354 IA-64/OpenVMS it is OK for it to be missing. */
4355 if (!is_ia64_vms ())
4356 error (_("no .dynamic section in the dynamic segment\n"));
4360 if (sec->sh_type == SHT_NOBITS)
4366 dynamic_addr = sec->sh_offset;
4367 dynamic_size = sec->sh_size;
4369 if (dynamic_addr < segment->p_offset
4370 || dynamic_addr > segment->p_offset + segment->p_filesz)
4371 warn (_("the .dynamic section is not contained"
4372 " within the dynamic segment\n"));
4373 else if (dynamic_addr > segment->p_offset)
4374 warn (_("the .dynamic section is not the first section"
4375 " in the dynamic segment.\n"));
4380 if (fseek (file, archive_file_offset + (long) segment->p_offset,
4382 error (_("Unable to find program interpreter name\n"));
4386 int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX);
4388 if (ret >= (int) sizeof (fmt) || ret < 0)
4389 error (_("Internal error: failed to create format string to display program interpreter\n"));
4391 program_interpreter[0] = 0;
4392 if (fscanf (file, fmt, program_interpreter) <= 0)
4393 error (_("Unable to read program interpreter name\n"));
4396 printf (_("\n [Requesting program interpreter: %s]"),
4397 program_interpreter);
4403 putc ('\n', stdout);
4406 if (do_segments && section_headers != NULL && string_table != NULL)
4408 printf (_("\n Section to Segment mapping:\n"));
4409 printf (_(" Segment Sections...\n"));
4411 for (i = 0; i < elf_header.e_phnum; i++)
4414 Elf_Internal_Shdr * section;
4416 segment = program_headers + i;
4417 section = section_headers + 1;
4419 printf (" %2.2d ", i);
4421 for (j = 1; j < elf_header.e_shnum; j++, section++)
4423 if (!ELF_TBSS_SPECIAL (section, segment)
4424 && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
4425 printf ("%s ", SECTION_NAME (section));
4436 /* Find the file offset corresponding to VMA by using the program headers. */
4439 offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
4441 Elf_Internal_Phdr * seg;
4443 if (! get_program_headers (file))
4445 warn (_("Cannot interpret virtual addresses without program headers.\n"));
4449 for (seg = program_headers;
4450 seg < program_headers + elf_header.e_phnum;
4453 if (seg->p_type != PT_LOAD)
4456 if (vma >= (seg->p_vaddr & -seg->p_align)
4457 && vma + size <= seg->p_vaddr + seg->p_filesz)
4458 return vma - seg->p_vaddr + seg->p_offset;
4461 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
4462 (unsigned long) vma);
4468 get_32bit_section_headers (FILE * file, unsigned int num)
4470 Elf32_External_Shdr * shdrs;
4471 Elf_Internal_Shdr * internal;
4474 shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
4475 elf_header.e_shentsize, num,
4476 _("section headers"));
4480 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4481 sizeof (Elf_Internal_Shdr));
4483 if (section_headers == NULL)
4485 error (_("Out of memory\n"));
4489 for (i = 0, internal = section_headers;
4493 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4494 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
4495 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4496 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4497 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
4498 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4499 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4500 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
4501 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4502 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
4511 get_64bit_section_headers (FILE * file, unsigned int num)
4513 Elf64_External_Shdr * shdrs;
4514 Elf_Internal_Shdr * internal;
4517 shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
4518 elf_header.e_shentsize, num,
4519 _("section headers"));
4523 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4524 sizeof (Elf_Internal_Shdr));
4526 if (section_headers == NULL)
4528 error (_("Out of memory\n"));
4532 for (i = 0, internal = section_headers;
4536 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4537 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
4538 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4539 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4540 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4541 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
4542 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4543 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
4544 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
4545 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4553 static Elf_Internal_Sym *
4554 get_32bit_elf_symbols (FILE * file,
4555 Elf_Internal_Shdr * section,
4556 unsigned long * num_syms_return)
4558 unsigned long number = 0;
4559 Elf32_External_Sym * esyms = NULL;
4560 Elf_External_Sym_Shndx * shndx = NULL;
4561 Elf_Internal_Sym * isyms = NULL;
4562 Elf_Internal_Sym * psym;
4565 /* Run some sanity checks first. */
4566 if (section->sh_entsize == 0)
4568 error (_("sh_entsize is zero\n"));
4572 number = section->sh_size / section->sh_entsize;
4574 if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
4576 error (_("Invalid sh_entsize\n"));
4580 esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4581 section->sh_size, _("symbols"));
4586 if (symtab_shndx_hdr != NULL
4587 && (symtab_shndx_hdr->sh_link
4588 == (unsigned long) (section - section_headers)))
4590 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4591 symtab_shndx_hdr->sh_offset,
4592 1, symtab_shndx_hdr->sh_size,
4593 _("symbol table section indicies"));
4598 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
4602 error (_("Out of memory\n"));
4606 for (j = 0, psym = isyms; j < number; j++, psym++)
4608 psym->st_name = BYTE_GET (esyms[j].st_name);
4609 psym->st_value = BYTE_GET (esyms[j].st_value);
4610 psym->st_size = BYTE_GET (esyms[j].st_size);
4611 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4612 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
4614 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4615 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4616 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
4617 psym->st_info = BYTE_GET (esyms[j].st_info);
4618 psym->st_other = BYTE_GET (esyms[j].st_other);
4627 if (num_syms_return != NULL)
4628 * num_syms_return = isyms == NULL ? 0 : number;
4633 static Elf_Internal_Sym *
4634 get_64bit_elf_symbols (FILE * file,
4635 Elf_Internal_Shdr * section,
4636 unsigned long * num_syms_return)
4638 unsigned long number = 0;
4639 Elf64_External_Sym * esyms = NULL;
4640 Elf_External_Sym_Shndx * shndx = NULL;
4641 Elf_Internal_Sym * isyms = NULL;
4642 Elf_Internal_Sym * psym;
4645 /* Run some sanity checks first. */
4646 if (section->sh_entsize == 0)
4648 error (_("sh_entsize is zero\n"));
4652 number = section->sh_size / section->sh_entsize;
4654 if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
4656 error (_("Invalid sh_entsize\n"));
4660 esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4661 section->sh_size, _("symbols"));
4665 if (symtab_shndx_hdr != NULL
4666 && (symtab_shndx_hdr->sh_link
4667 == (unsigned long) (section - section_headers)))
4669 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4670 symtab_shndx_hdr->sh_offset,
4671 1, symtab_shndx_hdr->sh_size,
4672 _("symbol table section indicies"));
4677 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
4681 error (_("Out of memory\n"));
4685 for (j = 0, psym = isyms; j < number; j++, psym++)
4687 psym->st_name = BYTE_GET (esyms[j].st_name);
4688 psym->st_info = BYTE_GET (esyms[j].st_info);
4689 psym->st_other = BYTE_GET (esyms[j].st_other);
4690 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4692 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
4694 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4695 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4696 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
4698 psym->st_value = BYTE_GET (esyms[j].st_value);
4699 psym->st_size = BYTE_GET (esyms[j].st_size);
4708 if (num_syms_return != NULL)
4709 * num_syms_return = isyms == NULL ? 0 : number;
4715 get_elf_section_flags (bfd_vma sh_flags)
4717 static char buff[1024];
4719 int field_size = is_32bit_elf ? 8 : 16;
4721 int size = sizeof (buff) - (field_size + 4 + 1);
4722 bfd_vma os_flags = 0;
4723 bfd_vma proc_flags = 0;
4724 bfd_vma unknown_flags = 0;
4732 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
4733 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
4734 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
4735 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
4736 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
4737 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
4738 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
4739 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
4740 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
4741 /* 9 */ { STRING_COMMA_LEN ("TLS") },
4742 /* IA-64 specific. */
4743 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
4744 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
4745 /* IA-64 OpenVMS specific. */
4746 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
4747 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
4748 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
4749 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
4750 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
4751 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
4753 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
4754 /* SPARC specific. */
4755 /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
4758 if (do_section_details)
4760 sprintf (buff, "[%*.*lx]: ",
4761 field_size, field_size, (unsigned long) sh_flags);
4762 p += field_size + 4;
4769 flag = sh_flags & - sh_flags;
4772 if (do_section_details)
4776 case SHF_WRITE: sindex = 0; break;
4777 case SHF_ALLOC: sindex = 1; break;
4778 case SHF_EXECINSTR: sindex = 2; break;
4779 case SHF_MERGE: sindex = 3; break;
4780 case SHF_STRINGS: sindex = 4; break;
4781 case SHF_INFO_LINK: sindex = 5; break;
4782 case SHF_LINK_ORDER: sindex = 6; break;
4783 case SHF_OS_NONCONFORMING: sindex = 7; break;
4784 case SHF_GROUP: sindex = 8; break;
4785 case SHF_TLS: sindex = 9; break;
4786 case SHF_EXCLUDE: sindex = 18; break;
4790 switch (elf_header.e_machine)
4793 if (flag == SHF_IA_64_SHORT)
4795 else if (flag == SHF_IA_64_NORECOV)
4798 else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
4801 case SHF_IA_64_VMS_GLOBAL: sindex = 12; break;
4802 case SHF_IA_64_VMS_OVERLAID: sindex = 13; break;
4803 case SHF_IA_64_VMS_SHARED: sindex = 14; break;
4804 case SHF_IA_64_VMS_VECTOR: sindex = 15; break;
4805 case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
4806 case SHF_IA_64_VMS_PROTECTED: sindex = 17; break;
4817 case EM_OLD_SPARCV9:
4818 case EM_SPARC32PLUS:
4821 if (flag == SHF_ORDERED)
4831 if (p != buff + field_size + 4)
4833 if (size < (10 + 2))
4840 size -= flags [sindex].len;
4841 p = stpcpy (p, flags [sindex].str);
4843 else if (flag & SHF_MASKOS)
4845 else if (flag & SHF_MASKPROC)
4848 unknown_flags |= flag;
4854 case SHF_WRITE: *p = 'W'; break;
4855 case SHF_ALLOC: *p = 'A'; break;
4856 case SHF_EXECINSTR: *p = 'X'; break;
4857 case SHF_MERGE: *p = 'M'; break;
4858 case SHF_STRINGS: *p = 'S'; break;
4859 case SHF_INFO_LINK: *p = 'I'; break;
4860 case SHF_LINK_ORDER: *p = 'L'; break;
4861 case SHF_OS_NONCONFORMING: *p = 'O'; break;
4862 case SHF_GROUP: *p = 'G'; break;
4863 case SHF_TLS: *p = 'T'; break;
4864 case SHF_EXCLUDE: *p = 'E'; break;
4867 if ((elf_header.e_machine == EM_X86_64
4868 || elf_header.e_machine == EM_L1OM
4869 || elf_header.e_machine == EM_K1OM)
4870 && flag == SHF_X86_64_LARGE)
4872 else if (flag & SHF_MASKOS)
4875 sh_flags &= ~ SHF_MASKOS;
4877 else if (flag & SHF_MASKPROC)
4880 sh_flags &= ~ SHF_MASKPROC;
4890 if (do_section_details)
4894 size -= 5 + field_size;
4895 if (p != buff + field_size + 4)
4903 sprintf (p, "OS (%*.*lx)", field_size, field_size,
4904 (unsigned long) os_flags);
4905 p += 5 + field_size;
4909 size -= 7 + field_size;
4910 if (p != buff + field_size + 4)
4918 sprintf (p, "PROC (%*.*lx)", field_size, field_size,
4919 (unsigned long) proc_flags);
4920 p += 7 + field_size;
4924 size -= 10 + field_size;
4925 if (p != buff + field_size + 4)
4933 sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
4934 (unsigned long) unknown_flags);
4935 p += 10 + field_size;
4944 process_section_headers (FILE * file)
4946 Elf_Internal_Shdr * section;
4949 section_headers = NULL;
4951 if (elf_header.e_shnum == 0)
4953 /* PR binutils/12467. */
4954 if (elf_header.e_shoff != 0)
4955 warn (_("possibly corrupt ELF file header - it has a non-zero"
4956 " section header offset, but no section headers\n"));
4957 else if (do_sections)
4958 printf (_("\nThere are no sections in this file.\n"));
4963 if (do_sections && !do_header)
4964 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
4965 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
4969 if (! get_32bit_section_headers (file, elf_header.e_shnum))
4972 else if (! get_64bit_section_headers (file, elf_header.e_shnum))
4975 /* Read in the string table, so that we have names to display. */
4976 if (elf_header.e_shstrndx != SHN_UNDEF
4977 && elf_header.e_shstrndx < elf_header.e_shnum)
4979 section = section_headers + elf_header.e_shstrndx;
4981 if (section->sh_size != 0)
4983 string_table = (char *) get_data (NULL, file, section->sh_offset,
4984 1, section->sh_size,
4987 string_table_length = string_table != NULL ? section->sh_size : 0;
4991 /* Scan the sections for the dynamic symbol table
4992 and dynamic string table and debug sections. */
4993 dynamic_symbols = NULL;
4994 dynamic_strings = NULL;
4995 dynamic_syminfo = NULL;
4996 symtab_shndx_hdr = NULL;
4998 eh_addr_size = is_32bit_elf ? 4 : 8;
4999 switch (elf_header.e_machine)
5002 case EM_MIPS_RS3_LE:
5003 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
5004 FDE addresses. However, the ABI also has a semi-official ILP32
5005 variant for which the normal FDE address size rules apply.
5007 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
5008 section, where XX is the size of longs in bits. Unfortunately,
5009 earlier compilers provided no way of distinguishing ILP32 objects
5010 from LP64 objects, so if there's any doubt, we should assume that
5011 the official LP64 form is being used. */
5012 if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
5013 && find_section (".gcc_compiled_long32") == NULL)
5019 switch (elf_header.e_flags & EF_H8_MACH)
5021 case E_H8_MACH_H8300:
5022 case E_H8_MACH_H8300HN:
5023 case E_H8_MACH_H8300SN:
5024 case E_H8_MACH_H8300SXN:
5027 case E_H8_MACH_H8300H:
5028 case E_H8_MACH_H8300S:
5029 case E_H8_MACH_H8300SX:
5037 switch (elf_header.e_flags & EF_M32C_CPU_MASK)
5039 case EF_M32C_CPU_M16C:
5046 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
5049 bfd_size_type expected_entsize = is_32bit_elf ? size32 : size64; \
5050 if (section->sh_entsize != expected_entsize) \
5052 error (_("Section %d has invalid sh_entsize of %" BFD_VMA_FMT "x\n"), \
5053 i, section->sh_entsize); \
5054 error (_("(Using the expected size of %d for the rest of this dump)\n"), \
5055 (int) expected_entsize); \
5056 section->sh_entsize = expected_entsize; \
5061 #define CHECK_ENTSIZE(section, i, type) \
5062 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
5063 sizeof (Elf64_External_##type))
5065 for (i = 0, section = section_headers;
5066 i < elf_header.e_shnum;
5069 char * name = SECTION_NAME (section);
5071 if (section->sh_type == SHT_DYNSYM)
5073 if (dynamic_symbols != NULL)
5075 error (_("File contains multiple dynamic symbol tables\n"));
5079 CHECK_ENTSIZE (section, i, Sym);
5080 dynamic_symbols = GET_ELF_SYMBOLS (file, section, & num_dynamic_syms);
5082 else if (section->sh_type == SHT_STRTAB
5083 && streq (name, ".dynstr"))
5085 if (dynamic_strings != NULL)
5087 error (_("File contains multiple dynamic string tables\n"));
5091 dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
5092 1, section->sh_size,
5093 _("dynamic strings"));
5094 dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
5096 else if (section->sh_type == SHT_SYMTAB_SHNDX)
5098 if (symtab_shndx_hdr != NULL)
5100 error (_("File contains multiple symtab shndx tables\n"));
5103 symtab_shndx_hdr = section;
5105 else if (section->sh_type == SHT_SYMTAB)
5106 CHECK_ENTSIZE (section, i, Sym);
5107 else if (section->sh_type == SHT_GROUP)
5108 CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
5109 else if (section->sh_type == SHT_REL)
5110 CHECK_ENTSIZE (section, i, Rel);
5111 else if (section->sh_type == SHT_RELA)
5112 CHECK_ENTSIZE (section, i, Rela);
5113 else if ((do_debugging || do_debug_info || do_debug_abbrevs
5114 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
5115 || do_debug_aranges || do_debug_frames || do_debug_macinfo
5116 || do_debug_str || do_debug_loc || do_debug_ranges
5117 || do_debug_addr || do_debug_cu_index)
5118 && (const_strneq (name, ".debug_")
5119 || const_strneq (name, ".zdebug_")))
5122 name += sizeof (".zdebug_") - 1;
5124 name += sizeof (".debug_") - 1;
5127 || (do_debug_info && const_strneq (name, "info"))
5128 || (do_debug_info && const_strneq (name, "types"))
5129 || (do_debug_abbrevs && const_strneq (name, "abbrev"))
5130 || (do_debug_lines && strcmp (name, "line") == 0)
5131 || (do_debug_lines && const_strneq (name, "line."))
5132 || (do_debug_pubnames && const_strneq (name, "pubnames"))
5133 || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
5134 || (do_debug_pubnames && const_strneq (name, "gnu_pubnames"))
5135 || (do_debug_pubtypes && const_strneq (name, "gnu_pubtypes"))
5136 || (do_debug_aranges && const_strneq (name, "aranges"))
5137 || (do_debug_ranges && const_strneq (name, "ranges"))
5138 || (do_debug_frames && const_strneq (name, "frame"))
5139 || (do_debug_macinfo && const_strneq (name, "macinfo"))
5140 || (do_debug_macinfo && const_strneq (name, "macro"))
5141 || (do_debug_str && const_strneq (name, "str"))
5142 || (do_debug_loc && const_strneq (name, "loc"))
5143 || (do_debug_addr && const_strneq (name, "addr"))
5144 || (do_debug_cu_index && const_strneq (name, "cu_index"))
5145 || (do_debug_cu_index && const_strneq (name, "tu_index"))
5147 request_dump_bynumber (i, DEBUG_DUMP);
5149 /* Linkonce section to be combined with .debug_info at link time. */
5150 else if ((do_debugging || do_debug_info)
5151 && const_strneq (name, ".gnu.linkonce.wi."))
5152 request_dump_bynumber (i, DEBUG_DUMP);
5153 else if (do_debug_frames && streq (name, ".eh_frame"))
5154 request_dump_bynumber (i, DEBUG_DUMP);
5155 else if (do_gdb_index && streq (name, ".gdb_index"))
5156 request_dump_bynumber (i, DEBUG_DUMP);
5157 /* Trace sections for Itanium VMS. */
5158 else if ((do_debugging || do_trace_info || do_trace_abbrevs
5159 || do_trace_aranges)
5160 && const_strneq (name, ".trace_"))
5162 name += sizeof (".trace_") - 1;
5165 || (do_trace_info && streq (name, "info"))
5166 || (do_trace_abbrevs && streq (name, "abbrev"))
5167 || (do_trace_aranges && streq (name, "aranges"))
5169 request_dump_bynumber (i, DEBUG_DUMP);
5177 if (elf_header.e_shnum > 1)
5178 printf (_("\nSection Headers:\n"));
5180 printf (_("\nSection Header:\n"));
5184 if (do_section_details)
5186 printf (_(" [Nr] Name\n"));
5187 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
5191 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
5195 if (do_section_details)
5197 printf (_(" [Nr] Name\n"));
5198 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
5202 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
5206 if (do_section_details)
5208 printf (_(" [Nr] Name\n"));
5209 printf (_(" Type Address Offset Link\n"));
5210 printf (_(" Size EntSize Info Align\n"));
5214 printf (_(" [Nr] Name Type Address Offset\n"));
5215 printf (_(" Size EntSize Flags Link Info Align\n"));
5219 if (do_section_details)
5220 printf (_(" Flags\n"));
5222 for (i = 0, section = section_headers;
5223 i < elf_header.e_shnum;
5226 printf (" [%2u] ", i);
5227 if (do_section_details)
5229 print_symbol (INT_MAX, SECTION_NAME (section));
5234 print_symbol (-17, SECTION_NAME (section));
5237 printf (do_wide ? " %-15s " : " %-15.15s ",
5238 get_section_type_name (section->sh_type));
5242 const char * link_too_big = NULL;
5244 print_vma (section->sh_addr, LONG_HEX);
5246 printf ( " %6.6lx %6.6lx %2.2lx",
5247 (unsigned long) section->sh_offset,
5248 (unsigned long) section->sh_size,
5249 (unsigned long) section->sh_entsize);
5251 if (do_section_details)
5252 fputs (" ", stdout);
5254 printf (" %3s ", get_elf_section_flags (section->sh_flags));
5256 if (section->sh_link >= elf_header.e_shnum)
5259 /* The sh_link value is out of range. Normally this indicates
5260 an error but it can have special values in Solaris binaries. */
5261 switch (elf_header.e_machine)
5268 case EM_OLD_SPARCV9:
5269 case EM_SPARC32PLUS:
5272 if (section->sh_link == (SHN_BEFORE & 0xffff))
5273 link_too_big = "BEFORE";
5274 else if (section->sh_link == (SHN_AFTER & 0xffff))
5275 link_too_big = "AFTER";
5282 if (do_section_details)
5284 if (link_too_big != NULL && * link_too_big)
5285 printf ("<%s> ", link_too_big);
5287 printf ("%2u ", section->sh_link);
5288 printf ("%3u %2lu\n", section->sh_info,
5289 (unsigned long) section->sh_addralign);
5292 printf ("%2u %3u %2lu\n",
5295 (unsigned long) section->sh_addralign);
5297 if (link_too_big && ! * link_too_big)
5298 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
5299 i, section->sh_link);
5303 print_vma (section->sh_addr, LONG_HEX);
5305 if ((long) section->sh_offset == section->sh_offset)
5306 printf (" %6.6lx", (unsigned long) section->sh_offset);
5310 print_vma (section->sh_offset, LONG_HEX);
5313 if ((unsigned long) section->sh_size == section->sh_size)
5314 printf (" %6.6lx", (unsigned long) section->sh_size);
5318 print_vma (section->sh_size, LONG_HEX);
5321 if ((unsigned long) section->sh_entsize == section->sh_entsize)
5322 printf (" %2.2lx", (unsigned long) section->sh_entsize);
5326 print_vma (section->sh_entsize, LONG_HEX);
5329 if (do_section_details)
5330 fputs (" ", stdout);
5332 printf (" %3s ", get_elf_section_flags (section->sh_flags));
5334 printf ("%2u %3u ", section->sh_link, section->sh_info);
5336 if ((unsigned long) section->sh_addralign == section->sh_addralign)
5337 printf ("%2lu\n", (unsigned long) section->sh_addralign);
5340 print_vma (section->sh_addralign, DEC);
5344 else if (do_section_details)
5346 printf (" %-15.15s ",
5347 get_section_type_name (section->sh_type));
5348 print_vma (section->sh_addr, LONG_HEX);
5349 if ((long) section->sh_offset == section->sh_offset)
5350 printf (" %16.16lx", (unsigned long) section->sh_offset);
5354 print_vma (section->sh_offset, LONG_HEX);
5356 printf (" %u\n ", section->sh_link);
5357 print_vma (section->sh_size, LONG_HEX);
5359 print_vma (section->sh_entsize, LONG_HEX);
5361 printf (" %-16u %lu\n",
5363 (unsigned long) section->sh_addralign);
5368 print_vma (section->sh_addr, LONG_HEX);
5369 if ((long) section->sh_offset == section->sh_offset)
5370 printf (" %8.8lx", (unsigned long) section->sh_offset);
5374 print_vma (section->sh_offset, LONG_HEX);
5377 print_vma (section->sh_size, LONG_HEX);
5379 print_vma (section->sh_entsize, LONG_HEX);
5381 printf (" %3s ", get_elf_section_flags (section->sh_flags));
5383 printf (" %2u %3u %lu\n",
5386 (unsigned long) section->sh_addralign);
5389 if (do_section_details)
5390 printf (" %s\n", get_elf_section_flags (section->sh_flags));
5393 if (!do_section_details)
5395 if (elf_header.e_machine == EM_X86_64
5396 || elf_header.e_machine == EM_L1OM
5397 || elf_header.e_machine == EM_K1OM)
5398 printf (_("Key to Flags:\n\
5399 W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
5400 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5401 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5403 printf (_("Key to Flags:\n\
5404 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
5405 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5406 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5413 get_group_flags (unsigned int flags)
5415 static char buff[32];
5425 snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x] "), flags);
5432 process_section_groups (FILE * file)
5434 Elf_Internal_Shdr * section;
5436 struct group * group;
5437 Elf_Internal_Shdr * symtab_sec;
5438 Elf_Internal_Shdr * strtab_sec;
5439 Elf_Internal_Sym * symtab;
5440 unsigned long num_syms;
5444 /* Don't process section groups unless needed. */
5445 if (!do_unwind && !do_section_groups)
5448 if (elf_header.e_shnum == 0)
5450 if (do_section_groups)
5451 printf (_("\nThere are no sections to group in this file.\n"));
5456 if (section_headers == NULL)
5458 error (_("Section headers are not available!\n"));
5459 /* PR 13622: This can happen with a corrupt ELF header. */
5463 section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
5464 sizeof (struct group *));
5466 if (section_headers_groups == NULL)
5468 error (_("Out of memory\n"));
5472 /* Scan the sections for the group section. */
5474 for (i = 0, section = section_headers;
5475 i < elf_header.e_shnum;
5477 if (section->sh_type == SHT_GROUP)
5480 if (group_count == 0)
5482 if (do_section_groups)
5483 printf (_("\nThere are no section groups in this file.\n"));
5488 section_groups = (struct group *) calloc (group_count, sizeof (struct group));
5490 if (section_groups == NULL)
5492 error (_("Out of memory\n"));
5502 for (i = 0, section = section_headers, group = section_groups;
5503 i < elf_header.e_shnum;
5506 if (section->sh_type == SHT_GROUP)
5508 char * name = SECTION_NAME (section);
5510 unsigned char * start;
5511 unsigned char * indices;
5512 unsigned int entry, j, size;
5513 Elf_Internal_Shdr * sec;
5514 Elf_Internal_Sym * sym;
5516 /* Get the symbol table. */
5517 if (section->sh_link >= elf_header.e_shnum
5518 || ((sec = section_headers + section->sh_link)->sh_type
5521 error (_("Bad sh_link in group section `%s'\n"), name);
5525 if (symtab_sec != sec)
5530 symtab = GET_ELF_SYMBOLS (file, symtab_sec, & num_syms);
5535 error (_("Corrupt header in group section `%s'\n"), name);
5539 if (section->sh_info >= num_syms)
5541 error (_("Bad sh_info in group section `%s'\n"), name);
5545 sym = symtab + section->sh_info;
5547 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
5549 if (sym->st_shndx == 0
5550 || sym->st_shndx >= elf_header.e_shnum)
5552 error (_("Bad sh_info in group section `%s'\n"), name);
5556 group_name = SECTION_NAME (section_headers + sym->st_shndx);
5565 /* Get the string table. */
5566 if (symtab_sec->sh_link >= elf_header.e_shnum)
5575 != (sec = section_headers + symtab_sec->sh_link))
5580 strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
5581 1, strtab_sec->sh_size,
5583 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
5585 group_name = sym->st_name < strtab_size
5586 ? strtab + sym->st_name : _("<corrupt>");
5589 start = (unsigned char *) get_data (NULL, file, section->sh_offset,
5590 1, section->sh_size,
5596 size = (section->sh_size / section->sh_entsize) - 1;
5597 entry = byte_get (indices, 4);
5600 if (do_section_groups)
5602 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
5603 get_group_flags (entry), i, name, group_name, size);
5605 printf (_(" [Index] Name\n"));
5608 group->group_index = i;
5610 for (j = 0; j < size; j++)
5612 struct group_list * g;
5614 entry = byte_get (indices, 4);
5617 if (entry >= elf_header.e_shnum)
5619 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
5620 entry, i, elf_header.e_shnum - 1);
5624 if (section_headers_groups [entry] != NULL)
5628 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
5630 section_headers_groups [entry]->group_index);
5635 /* Intel C/C++ compiler may put section 0 in a
5636 section group. We just warn it the first time
5637 and ignore it afterwards. */
5638 static int warned = 0;
5641 error (_("section 0 in group section [%5u]\n"),
5642 section_headers_groups [entry]->group_index);
5648 section_headers_groups [entry] = group;
5650 if (do_section_groups)
5652 sec = section_headers + entry;
5653 printf (" [%5u] %s\n", entry, SECTION_NAME (sec));
5656 g = (struct group_list *) xmalloc (sizeof (struct group_list));
5657 g->section_index = entry;
5658 g->next = group->root;
5676 /* Data used to display dynamic fixups. */
5678 struct ia64_vms_dynfixup
5680 bfd_vma needed_ident; /* Library ident number. */
5681 bfd_vma needed; /* Index in the dstrtab of the library name. */
5682 bfd_vma fixup_needed; /* Index of the library. */
5683 bfd_vma fixup_rela_cnt; /* Number of fixups. */
5684 bfd_vma fixup_rela_off; /* Fixups offset in the dynamic segment. */
5687 /* Data used to display dynamic relocations. */
5689 struct ia64_vms_dynimgrela
5691 bfd_vma img_rela_cnt; /* Number of relocations. */
5692 bfd_vma img_rela_off; /* Reloc offset in the dynamic segment. */
5695 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
5699 dump_ia64_vms_dynamic_fixups (FILE *file, struct ia64_vms_dynfixup *fixup,
5700 const char *strtab, unsigned int strtab_sz)
5702 Elf64_External_VMS_IMAGE_FIXUP *imfs;
5704 const char *lib_name;
5706 imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
5707 1, fixup->fixup_rela_cnt * sizeof (*imfs),
5708 _("dynamic section image fixups"));
5712 if (fixup->needed < strtab_sz)
5713 lib_name = strtab + fixup->needed;
5716 warn ("corrupt library name index of 0x%lx found in dynamic entry",
5717 (unsigned long) fixup->needed);
5720 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
5721 (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
5723 (_("Seg Offset Type SymVec DataType\n"));
5725 for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
5730 printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
5731 printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
5732 type = BYTE_GET (imfs [i].type);
5733 rtype = elf_ia64_reloc_type (type);
5735 printf (" 0x%08x ", type);
5737 printf (" %-32s ", rtype);
5738 printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
5739 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
5745 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
5748 dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
5750 Elf64_External_VMS_IMAGE_RELA *imrs;
5753 imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
5754 1, imgrela->img_rela_cnt * sizeof (*imrs),
5755 _("dynamic section image relocations"));
5759 printf (_("\nImage relocs\n"));
5761 (_("Seg Offset Type Addend Seg Sym Off\n"));
5763 for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
5768 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
5769 printf ("%08" BFD_VMA_FMT "x ",
5770 (bfd_vma) BYTE_GET (imrs [i].rela_offset));
5771 type = BYTE_GET (imrs [i].type);
5772 rtype = elf_ia64_reloc_type (type);
5774 printf ("0x%08x ", type);
5776 printf ("%-31s ", rtype);
5777 print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
5778 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
5779 printf ("%08" BFD_VMA_FMT "x\n",
5780 (bfd_vma) BYTE_GET (imrs [i].sym_offset));
5786 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
5789 process_ia64_vms_dynamic_relocs (FILE *file)
5791 struct ia64_vms_dynfixup fixup;
5792 struct ia64_vms_dynimgrela imgrela;
5793 Elf_Internal_Dyn *entry;
5795 bfd_vma strtab_off = 0;
5796 bfd_vma strtab_sz = 0;
5797 char *strtab = NULL;
5799 memset (&fixup, 0, sizeof (fixup));
5800 memset (&imgrela, 0, sizeof (imgrela));
5802 /* Note: the order of the entries is specified by the OpenVMS specs. */
5803 for (entry = dynamic_section;
5804 entry < dynamic_section + dynamic_nent;
5807 switch (entry->d_tag)
5809 case DT_IA_64_VMS_STRTAB_OFFSET:
5810 strtab_off = entry->d_un.d_val;
5813 strtab_sz = entry->d_un.d_val;
5815 strtab = get_data (NULL, file, dynamic_addr + strtab_off,
5816 1, strtab_sz, _("dynamic string section"));
5819 case DT_IA_64_VMS_NEEDED_IDENT:
5820 fixup.needed_ident = entry->d_un.d_val;
5823 fixup.needed = entry->d_un.d_val;
5825 case DT_IA_64_VMS_FIXUP_NEEDED:
5826 fixup.fixup_needed = entry->d_un.d_val;
5828 case DT_IA_64_VMS_FIXUP_RELA_CNT:
5829 fixup.fixup_rela_cnt = entry->d_un.d_val;
5831 case DT_IA_64_VMS_FIXUP_RELA_OFF:
5832 fixup.fixup_rela_off = entry->d_un.d_val;
5834 dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz);
5837 case DT_IA_64_VMS_IMG_RELA_CNT:
5838 imgrela.img_rela_cnt = entry->d_un.d_val;
5840 case DT_IA_64_VMS_IMG_RELA_OFF:
5841 imgrela.img_rela_off = entry->d_un.d_val;
5843 dump_ia64_vms_dynamic_relocs (file, &imgrela);
5863 } dynamic_relocations [] =
5865 { "REL", DT_REL, DT_RELSZ, FALSE },
5866 { "RELA", DT_RELA, DT_RELASZ, TRUE },
5867 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
5870 /* Process the reloc section. */
5873 process_relocs (FILE * file)
5875 unsigned long rel_size;
5876 unsigned long rel_offset;
5882 if (do_using_dynamic)
5886 int has_dynamic_reloc;
5889 has_dynamic_reloc = 0;
5891 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
5893 is_rela = dynamic_relocations [i].rela;
5894 name = dynamic_relocations [i].name;
5895 rel_size = dynamic_info [dynamic_relocations [i].size];
5896 rel_offset = dynamic_info [dynamic_relocations [i].reloc];
5898 has_dynamic_reloc |= rel_size;
5900 if (is_rela == UNKNOWN)
5902 if (dynamic_relocations [i].reloc == DT_JMPREL)
5903 switch (dynamic_info[DT_PLTREL])
5917 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
5918 name, rel_offset, rel_size);
5920 dump_relocations (file,
5921 offset_from_vma (file, rel_offset, rel_size),
5923 dynamic_symbols, num_dynamic_syms,
5924 dynamic_strings, dynamic_strings_length, is_rela);
5929 has_dynamic_reloc |= process_ia64_vms_dynamic_relocs (file);
5931 if (! has_dynamic_reloc)
5932 printf (_("\nThere are no dynamic relocations in this file.\n"));
5936 Elf_Internal_Shdr * section;
5940 for (i = 0, section = section_headers;
5941 i < elf_header.e_shnum;
5944 if ( section->sh_type != SHT_RELA
5945 && section->sh_type != SHT_REL)
5948 rel_offset = section->sh_offset;
5949 rel_size = section->sh_size;
5953 Elf_Internal_Shdr * strsec;
5956 printf (_("\nRelocation section "));
5958 if (string_table == NULL)
5959 printf ("%d", section->sh_name);
5961 printf ("'%s'", SECTION_NAME (section));
5963 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5964 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
5966 is_rela = section->sh_type == SHT_RELA;
5968 if (section->sh_link != 0
5969 && section->sh_link < elf_header.e_shnum)
5971 Elf_Internal_Shdr * symsec;
5972 Elf_Internal_Sym * symtab;
5973 unsigned long nsyms;
5974 unsigned long strtablen = 0;
5975 char * strtab = NULL;
5977 symsec = section_headers + section->sh_link;
5978 if (symsec->sh_type != SHT_SYMTAB
5979 && symsec->sh_type != SHT_DYNSYM)
5982 symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
5987 if (symsec->sh_link != 0
5988 && symsec->sh_link < elf_header.e_shnum)
5990 strsec = section_headers + symsec->sh_link;
5992 strtab = (char *) get_data (NULL, file, strsec->sh_offset,
5995 strtablen = strtab == NULL ? 0 : strsec->sh_size;
5998 dump_relocations (file, rel_offset, rel_size,
5999 symtab, nsyms, strtab, strtablen, is_rela);
6005 dump_relocations (file, rel_offset, rel_size,
6006 NULL, 0, NULL, 0, is_rela);
6013 printf (_("\nThere are no relocations in this file.\n"));
6019 /* Process the unwind section. */
6021 #include "unwind-ia64.h"
6023 /* An absolute address consists of a section and an offset. If the
6024 section is NULL, the offset itself is the address, otherwise, the
6025 address equals to LOAD_ADDRESS(section) + offset. */
6029 unsigned short section;
6033 #define ABSADDR(a) \
6035 ? section_headers [(a).section].sh_addr + (a).offset \
6038 struct ia64_unw_table_entry
6040 struct absaddr start;
6042 struct absaddr info;
6045 struct ia64_unw_aux_info
6048 struct ia64_unw_table_entry *table; /* Unwind table. */
6049 unsigned long table_len; /* Length of unwind table. */
6050 unsigned char * info; /* Unwind info. */
6051 unsigned long info_size; /* Size of unwind info. */
6052 bfd_vma info_addr; /* starting address of unwind info. */
6053 bfd_vma seg_base; /* Starting address of segment. */
6054 Elf_Internal_Sym * symtab; /* The symbol table. */
6055 unsigned long nsyms; /* Number of symbols. */
6056 char * strtab; /* The string table. */
6057 unsigned long strtab_size; /* Size of string table. */
6061 find_symbol_for_address (Elf_Internal_Sym * symtab,
6062 unsigned long nsyms,
6063 const char * strtab,
6064 unsigned long strtab_size,
6065 struct absaddr addr,
6066 const char ** symname,
6069 bfd_vma dist = 0x100000;
6070 Elf_Internal_Sym * sym;
6071 Elf_Internal_Sym * best = NULL;
6074 REMOVE_ARCH_BITS (addr.offset);
6076 for (i = 0, sym = symtab; i < nsyms; ++i, ++sym)
6078 bfd_vma value = sym->st_value;
6080 REMOVE_ARCH_BITS (value);
6082 if (ELF_ST_TYPE (sym->st_info) == STT_FUNC
6083 && sym->st_name != 0
6084 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
6085 && addr.offset >= value
6086 && addr.offset - value < dist)
6089 dist = addr.offset - value;
6097 *symname = (best->st_name >= strtab_size
6098 ? _("<corrupt>") : strtab + best->st_name);
6104 *offset = addr.offset;
6108 dump_ia64_unwind (struct ia64_unw_aux_info * aux)
6110 struct ia64_unw_table_entry * tp;
6113 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
6117 const unsigned char * dp;
6118 const unsigned char * head;
6119 const char * procname;
6121 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6122 aux->strtab_size, tp->start, &procname, &offset);
6124 fputs ("\n<", stdout);
6128 fputs (procname, stdout);
6131 printf ("+%lx", (unsigned long) offset);
6134 fputs (">: [", stdout);
6135 print_vma (tp->start.offset, PREFIX_HEX);
6136 fputc ('-', stdout);
6137 print_vma (tp->end.offset, PREFIX_HEX);
6138 printf ("], info at +0x%lx\n",
6139 (unsigned long) (tp->info.offset - aux->seg_base));
6141 head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
6142 stamp = byte_get ((unsigned char *) head, sizeof (stamp));
6144 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
6145 (unsigned) UNW_VER (stamp),
6146 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
6147 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
6148 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
6149 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
6151 if (UNW_VER (stamp) != 1)
6153 printf (_("\tUnknown version.\n"));
6158 for (dp = head + 8; dp < head + 8 + eh_addr_size * UNW_LENGTH (stamp);)
6159 dp = unw_decode (dp, in_body, & in_body);
6164 slurp_ia64_unwind_table (FILE * file,
6165 struct ia64_unw_aux_info * aux,
6166 Elf_Internal_Shdr * sec)
6168 unsigned long size, nrelas, i;
6169 Elf_Internal_Phdr * seg;
6170 struct ia64_unw_table_entry * tep;
6171 Elf_Internal_Shdr * relsec;
6172 Elf_Internal_Rela * rela;
6173 Elf_Internal_Rela * rp;
6174 unsigned char * table;
6176 Elf_Internal_Sym * sym;
6177 const char * relname;
6179 /* First, find the starting address of the segment that includes
6182 if (elf_header.e_phnum)
6184 if (! get_program_headers (file))
6187 for (seg = program_headers;
6188 seg < program_headers + elf_header.e_phnum;
6191 if (seg->p_type != PT_LOAD)
6194 if (sec->sh_addr >= seg->p_vaddr
6195 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
6197 aux->seg_base = seg->p_vaddr;
6203 /* Second, build the unwind table from the contents of the unwind section: */
6204 size = sec->sh_size;
6205 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
6210 aux->table = (struct ia64_unw_table_entry *)
6211 xcmalloc (size / (3 * eh_addr_size), sizeof (aux->table[0]));
6213 for (tp = table; tp < table + size; ++tep)
6215 tep->start.section = SHN_UNDEF;
6216 tep->end.section = SHN_UNDEF;
6217 tep->info.section = SHN_UNDEF;
6218 tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6219 tep->end.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6220 tep->info.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
6221 tep->start.offset += aux->seg_base;
6222 tep->end.offset += aux->seg_base;
6223 tep->info.offset += aux->seg_base;
6227 /* Third, apply any relocations to the unwind table: */
6228 for (relsec = section_headers;
6229 relsec < section_headers + elf_header.e_shnum;
6232 if (relsec->sh_type != SHT_RELA
6233 || relsec->sh_info >= elf_header.e_shnum
6234 || section_headers + relsec->sh_info != sec)
6237 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6241 for (rp = rela; rp < rela + nrelas; ++rp)
6243 relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
6244 sym = aux->symtab + get_reloc_symindex (rp->r_info);
6246 if (! const_strneq (relname, "R_IA64_SEGREL"))
6248 warn (_("Skipping unexpected relocation type %s\n"), relname);
6252 i = rp->r_offset / (3 * eh_addr_size);
6254 switch (rp->r_offset/eh_addr_size % 3)
6257 aux->table[i].start.section = sym->st_shndx;
6258 aux->table[i].start.offset = rp->r_addend + sym->st_value;
6261 aux->table[i].end.section = sym->st_shndx;
6262 aux->table[i].end.offset = rp->r_addend + sym->st_value;
6265 aux->table[i].info.section = sym->st_shndx;
6266 aux->table[i].info.offset = rp->r_addend + sym->st_value;
6276 aux->table_len = size / (3 * eh_addr_size);
6281 ia64_process_unwind (FILE * file)
6283 Elf_Internal_Shdr * sec;
6284 Elf_Internal_Shdr * unwsec = NULL;
6285 Elf_Internal_Shdr * strsec;
6286 unsigned long i, unwcount = 0, unwstart = 0;
6287 struct ia64_unw_aux_info aux;
6289 memset (& aux, 0, sizeof (aux));
6291 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6293 if (sec->sh_type == SHT_SYMTAB
6294 && sec->sh_link < elf_header.e_shnum)
6296 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
6298 strsec = section_headers + sec->sh_link;
6299 assert (aux.strtab == NULL);
6300 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6303 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
6305 else if (sec->sh_type == SHT_IA_64_UNWIND)
6310 printf (_("\nThere are no unwind sections in this file.\n"));
6312 while (unwcount-- > 0)
6317 for (i = unwstart, sec = section_headers + unwstart;
6318 i < elf_header.e_shnum; ++i, ++sec)
6319 if (sec->sh_type == SHT_IA_64_UNWIND)
6326 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
6328 if ((unwsec->sh_flags & SHF_GROUP) != 0)
6330 /* We need to find which section group it is in. */
6331 struct group_list * g = section_headers_groups [i]->root;
6333 for (; g != NULL; g = g->next)
6335 sec = section_headers + g->section_index;
6337 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
6342 i = elf_header.e_shnum;
6344 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
6346 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
6347 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
6348 suffix = SECTION_NAME (unwsec) + len;
6349 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6351 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
6352 && streq (SECTION_NAME (sec) + len2, suffix))
6357 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
6358 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
6359 len = sizeof (ELF_STRING_ia64_unwind) - 1;
6360 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
6362 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
6363 suffix = SECTION_NAME (unwsec) + len;
6364 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6366 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
6367 && streq (SECTION_NAME (sec) + len2, suffix))
6371 if (i == elf_header.e_shnum)
6373 printf (_("\nCould not find unwind info section for "));
6375 if (string_table == NULL)
6376 printf ("%d", unwsec->sh_name);
6378 printf (_("'%s'"), SECTION_NAME (unwsec));
6382 aux.info_addr = sec->sh_addr;
6383 aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
6386 aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
6388 printf (_("\nUnwind section "));
6390 if (string_table == NULL)
6391 printf ("%d", unwsec->sh_name);
6393 printf (_("'%s'"), SECTION_NAME (unwsec));
6395 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6396 (unsigned long) unwsec->sh_offset,
6397 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
6399 (void) slurp_ia64_unwind_table (file, & aux, unwsec);
6401 if (aux.table_len > 0)
6402 dump_ia64_unwind (& aux);
6405 free ((char *) aux.table);
6407 free ((char *) aux.info);
6416 free ((char *) aux.strtab);
6419 struct hppa_unw_table_entry
6421 struct absaddr start;
6423 unsigned int Cannot_unwind:1; /* 0 */
6424 unsigned int Millicode:1; /* 1 */
6425 unsigned int Millicode_save_sr0:1; /* 2 */
6426 unsigned int Region_description:2; /* 3..4 */
6427 unsigned int reserved1:1; /* 5 */
6428 unsigned int Entry_SR:1; /* 6 */
6429 unsigned int Entry_FR:4; /* number saved */ /* 7..10 */
6430 unsigned int Entry_GR:5; /* number saved */ /* 11..15 */
6431 unsigned int Args_stored:1; /* 16 */
6432 unsigned int Variable_Frame:1; /* 17 */
6433 unsigned int Separate_Package_Body:1; /* 18 */
6434 unsigned int Frame_Extension_Millicode:1; /* 19 */
6435 unsigned int Stack_Overflow_Check:1; /* 20 */
6436 unsigned int Two_Instruction_SP_Increment:1; /* 21 */
6437 unsigned int Ada_Region:1; /* 22 */
6438 unsigned int cxx_info:1; /* 23 */
6439 unsigned int cxx_try_catch:1; /* 24 */
6440 unsigned int sched_entry_seq:1; /* 25 */
6441 unsigned int reserved2:1; /* 26 */
6442 unsigned int Save_SP:1; /* 27 */
6443 unsigned int Save_RP:1; /* 28 */
6444 unsigned int Save_MRP_in_frame:1; /* 29 */
6445 unsigned int extn_ptr_defined:1; /* 30 */
6446 unsigned int Cleanup_defined:1; /* 31 */
6448 unsigned int MPE_XL_interrupt_marker:1; /* 0 */
6449 unsigned int HP_UX_interrupt_marker:1; /* 1 */
6450 unsigned int Large_frame:1; /* 2 */
6451 unsigned int Pseudo_SP_Set:1; /* 3 */
6452 unsigned int reserved4:1; /* 4 */
6453 unsigned int Total_frame_size:27; /* 5..31 */
6456 struct hppa_unw_aux_info
6458 struct hppa_unw_table_entry *table; /* Unwind table. */
6459 unsigned long table_len; /* Length of unwind table. */
6460 bfd_vma seg_base; /* Starting address of segment. */
6461 Elf_Internal_Sym * symtab; /* The symbol table. */
6462 unsigned long nsyms; /* Number of symbols. */
6463 char * strtab; /* The string table. */
6464 unsigned long strtab_size; /* Size of string table. */
6468 dump_hppa_unwind (struct hppa_unw_aux_info * aux)
6470 struct hppa_unw_table_entry * tp;
6472 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
6475 const char * procname;
6477 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6478 aux->strtab_size, tp->start, &procname,
6481 fputs ("\n<", stdout);
6485 fputs (procname, stdout);
6488 printf ("+%lx", (unsigned long) offset);
6491 fputs (">: [", stdout);
6492 print_vma (tp->start.offset, PREFIX_HEX);
6493 fputc ('-', stdout);
6494 print_vma (tp->end.offset, PREFIX_HEX);
6497 #define PF(_m) if (tp->_m) printf (#_m " ");
6498 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
6501 PF(Millicode_save_sr0);
6502 /* PV(Region_description); */
6508 PF(Separate_Package_Body);
6509 PF(Frame_Extension_Millicode);
6510 PF(Stack_Overflow_Check);
6511 PF(Two_Instruction_SP_Increment);
6515 PF(sched_entry_seq);
6518 PF(Save_MRP_in_frame);
6519 PF(extn_ptr_defined);
6520 PF(Cleanup_defined);
6521 PF(MPE_XL_interrupt_marker);
6522 PF(HP_UX_interrupt_marker);
6525 PV(Total_frame_size);
6534 slurp_hppa_unwind_table (FILE * file,
6535 struct hppa_unw_aux_info * aux,
6536 Elf_Internal_Shdr * sec)
6538 unsigned long size, unw_ent_size, nentries, nrelas, i;
6539 Elf_Internal_Phdr * seg;
6540 struct hppa_unw_table_entry * tep;
6541 Elf_Internal_Shdr * relsec;
6542 Elf_Internal_Rela * rela;
6543 Elf_Internal_Rela * rp;
6544 unsigned char * table;
6546 Elf_Internal_Sym * sym;
6547 const char * relname;
6549 /* First, find the starting address of the segment that includes
6552 if (elf_header.e_phnum)
6554 if (! get_program_headers (file))
6557 for (seg = program_headers;
6558 seg < program_headers + elf_header.e_phnum;
6561 if (seg->p_type != PT_LOAD)
6564 if (sec->sh_addr >= seg->p_vaddr
6565 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
6567 aux->seg_base = seg->p_vaddr;
6573 /* Second, build the unwind table from the contents of the unwind
6575 size = sec->sh_size;
6576 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
6582 nentries = size / unw_ent_size;
6583 size = unw_ent_size * nentries;
6585 tep = aux->table = (struct hppa_unw_table_entry *)
6586 xcmalloc (nentries, sizeof (aux->table[0]));
6588 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
6590 unsigned int tmp1, tmp2;
6592 tep->start.section = SHN_UNDEF;
6593 tep->end.section = SHN_UNDEF;
6595 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
6596 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
6597 tmp1 = byte_get ((unsigned char *) tp + 8, 4);
6598 tmp2 = byte_get ((unsigned char *) tp + 12, 4);
6600 tep->start.offset += aux->seg_base;
6601 tep->end.offset += aux->seg_base;
6603 tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
6604 tep->Millicode = (tmp1 >> 30) & 0x1;
6605 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
6606 tep->Region_description = (tmp1 >> 27) & 0x3;
6607 tep->reserved1 = (tmp1 >> 26) & 0x1;
6608 tep->Entry_SR = (tmp1 >> 25) & 0x1;
6609 tep->Entry_FR = (tmp1 >> 21) & 0xf;
6610 tep->Entry_GR = (tmp1 >> 16) & 0x1f;
6611 tep->Args_stored = (tmp1 >> 15) & 0x1;
6612 tep->Variable_Frame = (tmp1 >> 14) & 0x1;
6613 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
6614 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
6615 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
6616 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
6617 tep->Ada_Region = (tmp1 >> 9) & 0x1;
6618 tep->cxx_info = (tmp1 >> 8) & 0x1;
6619 tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
6620 tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
6621 tep->reserved2 = (tmp1 >> 5) & 0x1;
6622 tep->Save_SP = (tmp1 >> 4) & 0x1;
6623 tep->Save_RP = (tmp1 >> 3) & 0x1;
6624 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
6625 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
6626 tep->Cleanup_defined = tmp1 & 0x1;
6628 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
6629 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
6630 tep->Large_frame = (tmp2 >> 29) & 0x1;
6631 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
6632 tep->reserved4 = (tmp2 >> 27) & 0x1;
6633 tep->Total_frame_size = tmp2 & 0x7ffffff;
6637 /* Third, apply any relocations to the unwind table. */
6638 for (relsec = section_headers;
6639 relsec < section_headers + elf_header.e_shnum;
6642 if (relsec->sh_type != SHT_RELA
6643 || relsec->sh_info >= elf_header.e_shnum
6644 || section_headers + relsec->sh_info != sec)
6647 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6651 for (rp = rela; rp < rela + nrelas; ++rp)
6653 relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
6654 sym = aux->symtab + get_reloc_symindex (rp->r_info);
6656 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
6657 if (! const_strneq (relname, "R_PARISC_SEGREL"))
6659 warn (_("Skipping unexpected relocation type %s\n"), relname);
6663 i = rp->r_offset / unw_ent_size;
6665 switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
6668 aux->table[i].start.section = sym->st_shndx;
6669 aux->table[i].start.offset = sym->st_value + rp->r_addend;
6672 aux->table[i].end.section = sym->st_shndx;
6673 aux->table[i].end.offset = sym->st_value + rp->r_addend;
6683 aux->table_len = nentries;
6689 hppa_process_unwind (FILE * file)
6691 struct hppa_unw_aux_info aux;
6692 Elf_Internal_Shdr * unwsec = NULL;
6693 Elf_Internal_Shdr * strsec;
6694 Elf_Internal_Shdr * sec;
6697 if (string_table == NULL)
6700 memset (& aux, 0, sizeof (aux));
6702 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6704 if (sec->sh_type == SHT_SYMTAB
6705 && sec->sh_link < elf_header.e_shnum)
6707 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
6709 strsec = section_headers + sec->sh_link;
6710 assert (aux.strtab == NULL);
6711 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6714 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
6716 else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
6721 printf (_("\nThere are no unwind sections in this file.\n"));
6723 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6725 if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
6727 printf (_("\nUnwind section "));
6728 printf (_("'%s'"), SECTION_NAME (sec));
6730 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6731 (unsigned long) sec->sh_offset,
6732 (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
6734 slurp_hppa_unwind_table (file, &aux, sec);
6735 if (aux.table_len > 0)
6736 dump_hppa_unwind (&aux);
6739 free ((char *) aux.table);
6747 free ((char *) aux.strtab);
6752 unsigned char * data; /* The unwind data. */
6753 Elf_Internal_Shdr * sec; /* The cached unwind section header. */
6754 Elf_Internal_Rela * rela; /* The cached relocations for this section. */
6755 unsigned long nrelas; /* The number of relocations. */
6756 unsigned int rel_type; /* REL or RELA ? */
6757 Elf_Internal_Rela * next_rela; /* Cyclic pointer to the next reloc to process. */
6760 struct arm_unw_aux_info
6762 FILE * file; /* The file containing the unwind sections. */
6763 Elf_Internal_Sym * symtab; /* The file's symbol table. */
6764 unsigned long nsyms; /* Number of symbols. */
6765 char * strtab; /* The file's string table. */
6766 unsigned long strtab_size; /* Size of string table. */
6770 arm_print_vma_and_name (struct arm_unw_aux_info *aux,
6771 bfd_vma fn, struct absaddr addr)
6773 const char *procname;
6776 if (addr.section == SHN_UNDEF)
6779 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6780 aux->strtab_size, addr, &procname,
6783 print_vma (fn, PREFIX_HEX);
6787 fputs (" <", stdout);
6788 fputs (procname, stdout);
6791 printf ("+0x%lx", (unsigned long) sym_offset);
6792 fputc ('>', stdout);
6799 arm_free_section (struct arm_section *arm_sec)
6801 if (arm_sec->data != NULL)
6802 free (arm_sec->data);
6804 if (arm_sec->rela != NULL)
6805 free (arm_sec->rela);
6808 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
6809 cached section and install SEC instead.
6810 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
6811 and return its valued in * WORDP, relocating if necessary.
6812 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
6813 relocation's offset in ADDR.
6814 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
6815 into the string table of the symbol associated with the reloc. If no
6816 reloc was applied store -1 there.
6817 5) Return TRUE upon success, FALSE otherwise. */
6820 get_unwind_section_word (struct arm_unw_aux_info * aux,
6821 struct arm_section * arm_sec,
6822 Elf_Internal_Shdr * sec,
6823 bfd_vma word_offset,
6824 unsigned int * wordp,
6825 struct absaddr * addr,
6828 Elf_Internal_Rela *rp;
6829 Elf_Internal_Sym *sym;
6830 const char * relname;
6832 bfd_boolean wrapped;
6834 addr->section = SHN_UNDEF;
6837 if (sym_name != NULL)
6838 *sym_name = (bfd_vma) -1;
6840 /* If necessary, update the section cache. */
6841 if (sec != arm_sec->sec)
6843 Elf_Internal_Shdr *relsec;
6845 arm_free_section (arm_sec);
6848 arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
6849 sec->sh_size, _("unwind data"));
6850 arm_sec->rela = NULL;
6851 arm_sec->nrelas = 0;
6853 for (relsec = section_headers;
6854 relsec < section_headers + elf_header.e_shnum;
6857 if (relsec->sh_info >= elf_header.e_shnum
6858 || section_headers + relsec->sh_info != sec
6859 /* PR 15745: Check the section type as well. */
6860 || (relsec->sh_type != SHT_REL
6861 && relsec->sh_type != SHT_RELA))
6864 arm_sec->rel_type = relsec->sh_type;
6865 if (relsec->sh_type == SHT_REL)
6867 if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
6869 & arm_sec->rela, & arm_sec->nrelas))
6872 else /* relsec->sh_type == SHT_RELA */
6874 if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
6876 & arm_sec->rela, & arm_sec->nrelas))
6882 arm_sec->next_rela = arm_sec->rela;
6885 /* If there is no unwind data we can do nothing. */
6886 if (arm_sec->data == NULL)
6889 /* Get the word at the required offset. */
6890 word = byte_get (arm_sec->data + word_offset, 4);
6892 /* Look through the relocs to find the one that applies to the provided offset. */
6894 for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
6896 bfd_vma prelval, offset;
6898 if (rp->r_offset > word_offset && !wrapped)
6903 if (rp->r_offset > word_offset)
6906 if (rp->r_offset & 3)
6908 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
6909 (unsigned long) rp->r_offset);
6913 if (rp->r_offset < word_offset)
6916 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
6918 if (arm_sec->rel_type == SHT_REL)
6920 offset = word & 0x7fffffff;
6921 if (offset & 0x40000000)
6922 offset |= ~ (bfd_vma) 0x7fffffff;
6924 else if (arm_sec->rel_type == SHT_RELA)
6925 offset = rp->r_addend;
6929 offset += sym->st_value;
6930 prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
6932 /* Check that we are processing the expected reloc type. */
6933 if (elf_header.e_machine == EM_ARM)
6935 relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
6937 if (streq (relname, "R_ARM_NONE"))
6940 if (! streq (relname, "R_ARM_PREL31"))
6942 warn (_("Skipping unexpected relocation type %s\n"), relname);
6946 else if (elf_header.e_machine == EM_TI_C6000)
6948 relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
6950 if (streq (relname, "R_C6000_NONE"))
6953 if (! streq (relname, "R_C6000_PREL31"))
6955 warn (_("Skipping unexpected relocation type %s\n"), relname);
6962 /* This function currently only supports ARM and TI unwinders. */
6965 word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
6966 addr->section = sym->st_shndx;
6967 addr->offset = offset;
6969 * sym_name = sym->st_name;
6974 arm_sec->next_rela = rp;
6979 static const char *tic6x_unwind_regnames[16] =
6981 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
6982 "A14", "A13", "A12", "A11", "A10",
6983 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
6987 decode_tic6x_unwind_regmask (unsigned int mask)
6991 for (i = 12; mask; mask >>= 1, i--)
6995 fputs (tic6x_unwind_regnames[i], stdout);
6997 fputs (", ", stdout);
7003 if (remaining == 0 && more_words) \
7006 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
7007 data_offset, & word, & addr, NULL)) \
7013 #define GET_OP(OP) \
7018 (OP) = word >> 24; \
7023 printf (_("[Truncated opcode]\n")); \
7026 printf ("0x%02x ", OP)
7029 decode_arm_unwind_bytecode (struct arm_unw_aux_info *aux,
7030 unsigned int word, unsigned int remaining,
7031 unsigned int more_words,
7032 bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
7033 struct arm_section *data_arm_sec)
7035 struct absaddr addr;
7037 /* Decode the unwinding instructions. */
7040 unsigned int op, op2;
7049 printf (" 0x%02x ", op);
7051 if ((op & 0xc0) == 0x00)
7053 int offset = ((op & 0x3f) << 2) + 4;
7055 printf (" vsp = vsp + %d", offset);
7057 else if ((op & 0xc0) == 0x40)
7059 int offset = ((op & 0x3f) << 2) + 4;
7061 printf (" vsp = vsp - %d", offset);
7063 else if ((op & 0xf0) == 0x80)
7066 if (op == 0x80 && op2 == 0)
7067 printf (_("Refuse to unwind"));
7070 unsigned int mask = ((op & 0x0f) << 8) | op2;
7075 for (i = 0; i < 12; i++)
7076 if (mask & (1 << i))
7082 printf ("r%d", 4 + i);
7087 else if ((op & 0xf0) == 0x90)
7089 if (op == 0x9d || op == 0x9f)
7090 printf (_(" [Reserved]"));
7092 printf (" vsp = r%d", op & 0x0f);
7094 else if ((op & 0xf0) == 0xa0)
7096 int end = 4 + (op & 0x07);
7101 for (i = 4; i <= end; i++)
7117 else if (op == 0xb0)
7118 printf (_(" finish"));
7119 else if (op == 0xb1)
7122 if (op2 == 0 || (op2 & 0xf0) != 0)
7123 printf (_("[Spare]"));
7126 unsigned int mask = op2 & 0x0f;
7131 for (i = 0; i < 12; i++)
7132 if (mask & (1 << i))
7143 else if (op == 0xb2)
7145 unsigned char buf[9];
7146 unsigned int i, len;
7147 unsigned long offset;
7149 for (i = 0; i < sizeof (buf); i++)
7152 if ((buf[i] & 0x80) == 0)
7155 assert (i < sizeof (buf));
7156 offset = read_uleb128 (buf, &len, buf + i + 1);
7157 assert (len == i + 1);
7158 offset = offset * 4 + 0x204;
7159 printf ("vsp = vsp + %ld", offset);
7161 else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
7163 unsigned int first, last;
7170 printf ("pop {D%d", first);
7172 printf ("-D%d", first + last);
7175 else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
7177 unsigned int count = op & 0x07;
7181 printf ("-D%d", 8 + count);
7184 else if (op >= 0xc0 && op <= 0xc5)
7186 unsigned int count = op & 0x07;
7188 printf (" pop {wR10");
7190 printf ("-wR%d", 10 + count);
7193 else if (op == 0xc6)
7195 unsigned int first, last;
7200 printf ("pop {wR%d", first);
7202 printf ("-wR%d", first + last);
7205 else if (op == 0xc7)
7208 if (op2 == 0 || (op2 & 0xf0) != 0)
7209 printf (_("[Spare]"));
7212 unsigned int mask = op2 & 0x0f;
7217 for (i = 0; i < 4; i++)
7218 if (mask & (1 << i))
7224 printf ("wCGR%d", i);
7230 printf (_(" [unsupported opcode]"));
7236 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info *aux,
7237 unsigned int word, unsigned int remaining,
7238 unsigned int more_words,
7239 bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
7240 struct arm_section *data_arm_sec)
7242 struct absaddr addr;
7244 /* Decode the unwinding instructions. */
7247 unsigned int op, op2;
7256 printf (" 0x%02x ", op);
7258 if ((op & 0xc0) == 0x00)
7260 int offset = ((op & 0x3f) << 3) + 8;
7261 printf (" sp = sp + %d", offset);
7263 else if ((op & 0xc0) == 0x80)
7266 if (op == 0x80 && op2 == 0)
7267 printf (_("Refuse to unwind"));
7270 unsigned int mask = ((op & 0x1f) << 8) | op2;
7272 printf ("pop compact {");
7276 decode_tic6x_unwind_regmask (mask);
7280 else if ((op & 0xf0) == 0xc0)
7288 unsigned int offset;
7292 /* Scan entire instruction first so that GET_OP output is not
7293 interleaved with disassembly. */
7295 for (i = 0; nregs < (op & 0xf); i++)
7301 regpos[nregs].offset = i * 2;
7302 regpos[nregs].reg = reg;
7309 regpos[nregs].offset = i * 2 + 1;
7310 regpos[nregs].reg = reg;
7315 printf (_("pop frame {"));
7317 for (i = i * 2; i > 0; i--)
7319 if (regpos[reg].offset == i - 1)
7321 name = tic6x_unwind_regnames[regpos[reg].reg];
7328 fputs (name, stdout);
7335 else if (op == 0xd0)
7336 printf (" MOV FP, SP");
7337 else if (op == 0xd1)
7338 printf (" __c6xabi_pop_rts");
7339 else if (op == 0xd2)
7341 unsigned char buf[9];
7342 unsigned int i, len;
7343 unsigned long offset;
7345 for (i = 0; i < sizeof (buf); i++)
7348 if ((buf[i] & 0x80) == 0)
7351 assert (i < sizeof (buf));
7352 offset = read_uleb128 (buf, &len, buf + i + 1);
7353 assert (len == i + 1);
7354 offset = offset * 8 + 0x408;
7355 printf (_("sp = sp + %ld"), offset);
7357 else if ((op & 0xf0) == 0xe0)
7359 if ((op & 0x0f) == 7)
7362 printf (" MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
7366 printf (_(" [unsupported opcode]"));
7373 arm_expand_prel31 (bfd_vma word, bfd_vma where)
7377 offset = word & 0x7fffffff;
7378 if (offset & 0x40000000)
7379 offset |= ~ (bfd_vma) 0x7fffffff;
7381 if (elf_header.e_machine == EM_TI_C6000)
7384 return offset + where;
7388 decode_arm_unwind (struct arm_unw_aux_info * aux,
7390 unsigned int remaining,
7391 bfd_vma data_offset,
7392 Elf_Internal_Shdr * data_sec,
7393 struct arm_section * data_arm_sec)
7396 unsigned int more_words = 0;
7397 struct absaddr addr;
7398 bfd_vma sym_name = (bfd_vma) -1;
7402 /* Fetch the first word.
7403 Note - when decoding an object file the address extracted
7404 here will always be 0. So we also pass in the sym_name
7405 parameter so that we can find the symbol associated with
7406 the personality routine. */
7407 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, data_offset,
7408 & word, & addr, & sym_name))
7414 if ((word & 0x80000000) == 0)
7416 /* Expand prel31 for personality routine. */
7418 const char *procname;
7420 fn = arm_expand_prel31 (word, data_sec->sh_addr + data_offset);
7421 printf (_(" Personality routine: "));
7423 && addr.section == SHN_UNDEF && addr.offset == 0
7424 && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
7426 procname = aux->strtab + sym_name;
7427 print_vma (fn, PREFIX_HEX);
7430 fputs (" <", stdout);
7431 fputs (procname, stdout);
7432 fputc ('>', stdout);
7436 procname = arm_print_vma_and_name (aux, fn, addr);
7437 fputc ('\n', stdout);
7439 /* The GCC personality routines use the standard compact
7440 encoding, starting with one byte giving the number of
7442 if (procname != NULL
7443 && (const_strneq (procname, "__gcc_personality_v0")
7444 || const_strneq (procname, "__gxx_personality_v0")
7445 || const_strneq (procname, "__gcj_personality_v0")
7446 || const_strneq (procname, "__gnu_objc_personality_v0")))
7453 printf (_(" [Truncated data]\n"));
7456 more_words = word >> 24;
7466 /* ARM EHABI Section 6.3:
7468 An exception-handling table entry for the compact model looks like:
7472 1 0 index Data for personalityRoutine[index] */
7474 if (elf_header.e_machine == EM_ARM
7475 && (word & 0x70000000))
7476 warn (_("Corrupt ARM compact model table entry: %x \n"), word);
7478 per_index = (word >> 24) & 0x7f;
7479 printf (_(" Compact model index: %d\n"), per_index);
7486 else if (per_index < 3)
7488 more_words = (word >> 16) & 0xff;
7494 switch (elf_header.e_machine)
7499 decode_arm_unwind_bytecode (aux, word, remaining, more_words,
7500 data_offset, data_sec, data_arm_sec);
7504 warn (_("Unknown ARM compact model index encountered\n"));
7505 printf (_(" [reserved]\n"));
7512 decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
7513 data_offset, data_sec, data_arm_sec);
7515 else if (per_index < 5)
7517 if (((word >> 17) & 0x7f) == 0x7f)
7518 printf (_(" Restore stack from frame pointer\n"));
7520 printf (_(" Stack increment %d\n"), (word >> 14) & 0x1fc);
7521 printf (_(" Registers restored: "));
7523 printf (" (compact) ");
7524 decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
7526 printf (_(" Return register: %s\n"),
7527 tic6x_unwind_regnames[word & 0xf]);
7530 printf (_(" [reserved (%d)]\n"), per_index);
7534 error (_("Unsupported architecture type %d encountered when decoding unwind table"),
7535 elf_header.e_machine);
7538 /* Decode the descriptors. Not implemented. */
7542 dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
7544 struct arm_section exidx_arm_sec, extab_arm_sec;
7545 unsigned int i, exidx_len;
7547 memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
7548 memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
7549 exidx_len = exidx_sec->sh_size / 8;
7551 for (i = 0; i < exidx_len; i++)
7553 unsigned int exidx_fn, exidx_entry;
7554 struct absaddr fn_addr, entry_addr;
7557 fputc ('\n', stdout);
7559 if (! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
7560 8 * i, & exidx_fn, & fn_addr, NULL)
7561 || ! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
7562 8 * i + 4, & exidx_entry, & entry_addr, NULL))
7564 arm_free_section (& exidx_arm_sec);
7565 arm_free_section (& extab_arm_sec);
7569 /* ARM EHABI, Section 5:
7570 An index table entry consists of 2 words.
7571 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
7572 if (exidx_fn & 0x80000000)
7573 warn (_("corrupt index table entry: %x\n"), exidx_fn);
7575 fn = arm_expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
7577 arm_print_vma_and_name (aux, fn, fn_addr);
7578 fputs (": ", stdout);
7580 if (exidx_entry == 1)
7582 print_vma (exidx_entry, PREFIX_HEX);
7583 fputs (" [cantunwind]\n", stdout);
7585 else if (exidx_entry & 0x80000000)
7587 print_vma (exidx_entry, PREFIX_HEX);
7588 fputc ('\n', stdout);
7589 decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
7593 bfd_vma table, table_offset = 0;
7594 Elf_Internal_Shdr *table_sec;
7596 fputs ("@", stdout);
7597 table = arm_expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
7598 print_vma (table, PREFIX_HEX);
7601 /* Locate the matching .ARM.extab. */
7602 if (entry_addr.section != SHN_UNDEF
7603 && entry_addr.section < elf_header.e_shnum)
7605 table_sec = section_headers + entry_addr.section;
7606 table_offset = entry_addr.offset;
7610 table_sec = find_section_by_address (table);
7611 if (table_sec != NULL)
7612 table_offset = table - table_sec->sh_addr;
7614 if (table_sec == NULL)
7616 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
7617 (unsigned long) table);
7620 decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
7627 arm_free_section (&exidx_arm_sec);
7628 arm_free_section (&extab_arm_sec);
7631 /* Used for both ARM and C6X unwinding tables. */
7634 arm_process_unwind (FILE *file)
7636 struct arm_unw_aux_info aux;
7637 Elf_Internal_Shdr *unwsec = NULL;
7638 Elf_Internal_Shdr *strsec;
7639 Elf_Internal_Shdr *sec;
7641 unsigned int sec_type;
7643 switch (elf_header.e_machine)
7646 sec_type = SHT_ARM_EXIDX;
7650 sec_type = SHT_C6000_UNWIND;
7654 error (_("Unsupported architecture type %d encountered when processing unwind table"),
7655 elf_header.e_machine);
7659 if (string_table == NULL)
7662 memset (& aux, 0, sizeof (aux));
7665 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7667 if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
7669 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
7671 strsec = section_headers + sec->sh_link;
7672 assert (aux.strtab == NULL);
7673 aux.strtab = get_data (NULL, file, strsec->sh_offset,
7674 1, strsec->sh_size, _("string table"));
7675 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7677 else if (sec->sh_type == sec_type)
7682 printf (_("\nThere are no unwind sections in this file.\n"));
7684 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7686 if (sec->sh_type == sec_type)
7688 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
7690 (unsigned long) sec->sh_offset,
7691 (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
7693 dump_arm_unwind (&aux, sec);
7700 free ((char *) aux.strtab);
7704 process_unwind (FILE * file)
7706 struct unwind_handler
7709 void (* handler)(FILE *);
7712 { EM_ARM, arm_process_unwind },
7713 { EM_IA_64, ia64_process_unwind },
7714 { EM_PARISC, hppa_process_unwind },
7715 { EM_TI_C6000, arm_process_unwind },
7723 for (i = 0; handlers[i].handler != NULL; i++)
7724 if (elf_header.e_machine == handlers[i].machtype)
7726 handlers[i].handler (file);
7730 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
7731 get_machine_name (elf_header.e_machine));
7735 dynamic_section_mips_val (Elf_Internal_Dyn * entry)
7737 switch (entry->d_tag)
7740 if (entry->d_un.d_val == 0)
7744 static const char * opts[] =
7746 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
7747 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
7748 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
7749 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
7755 for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
7756 if (entry->d_un.d_val & (1 << cnt))
7758 printf ("%s%s", first ? "" : " ", opts[cnt]);
7764 case DT_MIPS_IVERSION:
7765 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
7766 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
7768 printf (_("<corrupt: %" BFD_VMA_FMT "d>"), entry->d_un.d_ptr);
7771 case DT_MIPS_TIME_STAMP:
7776 time_t atime = entry->d_un.d_val;
7777 tmp = gmtime (&atime);
7778 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
7779 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
7780 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
7781 printf (_("Time Stamp: %s"), timebuf);
7785 case DT_MIPS_RLD_VERSION:
7786 case DT_MIPS_LOCAL_GOTNO:
7787 case DT_MIPS_CONFLICTNO:
7788 case DT_MIPS_LIBLISTNO:
7789 case DT_MIPS_SYMTABNO:
7790 case DT_MIPS_UNREFEXTNO:
7791 case DT_MIPS_HIPAGENO:
7792 case DT_MIPS_DELTA_CLASS_NO:
7793 case DT_MIPS_DELTA_INSTANCE_NO:
7794 case DT_MIPS_DELTA_RELOC_NO:
7795 case DT_MIPS_DELTA_SYM_NO:
7796 case DT_MIPS_DELTA_CLASSSYM_NO:
7797 case DT_MIPS_COMPACT_SIZE:
7798 print_vma (entry->d_un.d_ptr, DEC);
7802 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7808 dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
7810 switch (entry->d_tag)
7812 case DT_HP_DLD_FLAGS:
7821 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
7822 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
7823 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
7824 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
7825 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
7826 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
7827 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
7828 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
7829 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
7830 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
7831 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
7832 { DT_HP_GST, "HP_GST" },
7833 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
7834 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
7835 { DT_HP_NODELETE, "HP_NODELETE" },
7836 { DT_HP_GROUP, "HP_GROUP" },
7837 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
7841 bfd_vma val = entry->d_un.d_val;
7843 for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
7844 if (val & flags[cnt].bit)
7848 fputs (flags[cnt].str, stdout);
7850 val ^= flags[cnt].bit;
7853 if (val != 0 || first)
7857 print_vma (val, HEX);
7863 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7871 /* VMS vs Unix time offset and factor. */
7873 #define VMS_EPOCH_OFFSET 35067168000000000LL
7874 #define VMS_GRANULARITY_FACTOR 10000000
7876 /* Display a VMS time in a human readable format. */
7879 print_vms_time (bfd_int64_t vmstime)
7884 unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
7885 tm = gmtime (&unxtime);
7886 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
7887 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
7888 tm->tm_hour, tm->tm_min, tm->tm_sec);
7893 dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
7895 switch (entry->d_tag)
7897 case DT_IA_64_PLT_RESERVE:
7898 /* First 3 slots reserved. */
7899 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7901 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
7904 case DT_IA_64_VMS_LINKTIME:
7906 print_vms_time (entry->d_un.d_val);
7910 case DT_IA_64_VMS_LNKFLAGS:
7911 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7912 if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
7913 printf (" CALL_DEBUG");
7914 if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
7915 printf (" NOP0BUFS");
7916 if (entry->d_un.d_val & VMS_LF_P0IMAGE)
7917 printf (" P0IMAGE");
7918 if (entry->d_un.d_val & VMS_LF_MKTHREADS)
7919 printf (" MKTHREADS");
7920 if (entry->d_un.d_val & VMS_LF_UPCALLS)
7921 printf (" UPCALLS");
7922 if (entry->d_un.d_val & VMS_LF_IMGSTA)
7924 if (entry->d_un.d_val & VMS_LF_INITIALIZE)
7925 printf (" INITIALIZE");
7926 if (entry->d_un.d_val & VMS_LF_MAIN)
7928 if (entry->d_un.d_val & VMS_LF_EXE_INIT)
7929 printf (" EXE_INIT");
7930 if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
7931 printf (" TBK_IN_IMG");
7932 if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
7933 printf (" DBG_IN_IMG");
7934 if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
7935 printf (" TBK_IN_DSF");
7936 if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
7937 printf (" DBG_IN_DSF");
7938 if (entry->d_un.d_val & VMS_LF_SIGNATURES)
7939 printf (" SIGNATURES");
7940 if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
7941 printf (" REL_SEG_OFF");
7945 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7952 get_32bit_dynamic_section (FILE * file)
7954 Elf32_External_Dyn * edyn;
7955 Elf32_External_Dyn * ext;
7956 Elf_Internal_Dyn * entry;
7958 edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
7959 dynamic_size, _("dynamic section"));
7963 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
7964 might not have the luxury of section headers. Look for the DT_NULL
7965 terminator to determine the number of entries. */
7966 for (ext = edyn, dynamic_nent = 0;
7967 (char *) ext < (char *) edyn + dynamic_size;
7971 if (BYTE_GET (ext->d_tag) == DT_NULL)
7975 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
7977 if (dynamic_section == NULL)
7979 error (_("Out of memory\n"));
7984 for (ext = edyn, entry = dynamic_section;
7985 entry < dynamic_section + dynamic_nent;
7988 entry->d_tag = BYTE_GET (ext->d_tag);
7989 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
7998 get_64bit_dynamic_section (FILE * file)
8000 Elf64_External_Dyn * edyn;
8001 Elf64_External_Dyn * ext;
8002 Elf_Internal_Dyn * entry;
8004 edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
8005 dynamic_size, _("dynamic section"));
8009 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
8010 might not have the luxury of section headers. Look for the DT_NULL
8011 terminator to determine the number of entries. */
8012 for (ext = edyn, dynamic_nent = 0;
8013 (char *) ext < (char *) edyn + dynamic_size;
8017 if (BYTE_GET (ext->d_tag) == DT_NULL)
8021 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
8023 if (dynamic_section == NULL)
8025 error (_("Out of memory\n"));
8030 for (ext = edyn, entry = dynamic_section;
8031 entry < dynamic_section + dynamic_nent;
8034 entry->d_tag = BYTE_GET (ext->d_tag);
8035 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
8044 print_dynamic_flags (bfd_vma flags)
8052 flag = flags & - flags;
8062 case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
8063 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
8064 case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
8065 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
8066 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
8067 default: fputs (_("unknown"), stdout); break;
8073 /* Parse and display the contents of the dynamic section. */
8076 process_dynamic_section (FILE * file)
8078 Elf_Internal_Dyn * entry;
8080 if (dynamic_size == 0)
8083 printf (_("\nThere is no dynamic section in this file.\n"));
8090 if (! get_32bit_dynamic_section (file))
8093 else if (! get_64bit_dynamic_section (file))
8096 /* Find the appropriate symbol table. */
8097 if (dynamic_symbols == NULL)
8099 for (entry = dynamic_section;
8100 entry < dynamic_section + dynamic_nent;
8103 Elf_Internal_Shdr section;
8105 if (entry->d_tag != DT_SYMTAB)
8108 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
8110 /* Since we do not know how big the symbol table is,
8111 we default to reading in the entire file (!) and
8112 processing that. This is overkill, I know, but it
8114 section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
8116 if (archive_file_offset != 0)
8117 section.sh_size = archive_file_size - section.sh_offset;
8120 if (fseek (file, 0, SEEK_END))
8121 error (_("Unable to seek to end of file!\n"));
8123 section.sh_size = ftell (file) - section.sh_offset;
8127 section.sh_entsize = sizeof (Elf32_External_Sym);
8129 section.sh_entsize = sizeof (Elf64_External_Sym);
8131 dynamic_symbols = GET_ELF_SYMBOLS (file, §ion, & num_dynamic_syms);
8132 if (num_dynamic_syms < 1)
8134 error (_("Unable to determine the number of symbols to load\n"));
8140 /* Similarly find a string table. */
8141 if (dynamic_strings == NULL)
8143 for (entry = dynamic_section;
8144 entry < dynamic_section + dynamic_nent;
8147 unsigned long offset;
8150 if (entry->d_tag != DT_STRTAB)
8153 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
8155 /* Since we do not know how big the string table is,
8156 we default to reading in the entire file (!) and
8157 processing that. This is overkill, I know, but it
8160 offset = offset_from_vma (file, entry->d_un.d_val, 0);
8162 if (archive_file_offset != 0)
8163 str_tab_len = archive_file_size - offset;
8166 if (fseek (file, 0, SEEK_END))
8167 error (_("Unable to seek to end of file\n"));
8168 str_tab_len = ftell (file) - offset;
8171 if (str_tab_len < 1)
8174 (_("Unable to determine the length of the dynamic string table\n"));
8178 dynamic_strings = (char *) get_data (NULL, file, offset, 1,
8180 _("dynamic string table"));
8181 dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
8186 /* And find the syminfo section if available. */
8187 if (dynamic_syminfo == NULL)
8189 unsigned long syminsz = 0;
8191 for (entry = dynamic_section;
8192 entry < dynamic_section + dynamic_nent;
8195 if (entry->d_tag == DT_SYMINENT)
8197 /* Note: these braces are necessary to avoid a syntax
8198 error from the SunOS4 C compiler. */
8199 assert (sizeof (Elf_External_Syminfo) == entry->d_un.d_val);
8201 else if (entry->d_tag == DT_SYMINSZ)
8202 syminsz = entry->d_un.d_val;
8203 else if (entry->d_tag == DT_SYMINFO)
8204 dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
8208 if (dynamic_syminfo_offset != 0 && syminsz != 0)
8210 Elf_External_Syminfo * extsyminfo;
8211 Elf_External_Syminfo * extsym;
8212 Elf_Internal_Syminfo * syminfo;
8214 /* There is a syminfo section. Read the data. */
8215 extsyminfo = (Elf_External_Syminfo *)
8216 get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
8217 _("symbol information"));
8221 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
8222 if (dynamic_syminfo == NULL)
8224 error (_("Out of memory\n"));
8228 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
8229 for (syminfo = dynamic_syminfo, extsym = extsyminfo;
8230 syminfo < dynamic_syminfo + dynamic_syminfo_nent;
8231 ++syminfo, ++extsym)
8233 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
8234 syminfo->si_flags = BYTE_GET (extsym->si_flags);
8241 if (do_dynamic && dynamic_addr)
8242 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
8243 dynamic_addr, dynamic_nent);
8245 printf (_(" Tag Type Name/Value\n"));
8247 for (entry = dynamic_section;
8248 entry < dynamic_section + dynamic_nent;
8256 print_vma (entry->d_tag, FULL_HEX);
8257 dtype = get_dynamic_type (entry->d_tag);
8258 printf (" (%s)%*s", dtype,
8259 ((is_32bit_elf ? 27 : 19)
8260 - (int) strlen (dtype)),
8264 switch (entry->d_tag)
8268 print_dynamic_flags (entry->d_un.d_val);
8278 switch (entry->d_tag)
8281 printf (_("Auxiliary library"));
8285 printf (_("Filter library"));
8289 printf (_("Configuration file"));
8293 printf (_("Dependency audit library"));
8297 printf (_("Audit library"));
8301 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
8302 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
8306 print_vma (entry->d_un.d_val, PREFIX_HEX);
8315 printf (_("Flags:"));
8317 if (entry->d_un.d_val == 0)
8318 printf (_(" None\n"));
8321 unsigned long int val = entry->d_un.d_val;
8323 if (val & DTF_1_PARINIT)
8325 printf (" PARINIT");
8326 val ^= DTF_1_PARINIT;
8328 if (val & DTF_1_CONFEXP)
8330 printf (" CONFEXP");
8331 val ^= DTF_1_CONFEXP;
8334 printf (" %lx", val);
8343 printf (_("Flags:"));
8345 if (entry->d_un.d_val == 0)
8346 printf (_(" None\n"));
8349 unsigned long int val = entry->d_un.d_val;
8351 if (val & DF_P1_LAZYLOAD)
8353 printf (" LAZYLOAD");
8354 val ^= DF_P1_LAZYLOAD;
8356 if (val & DF_P1_GROUPPERM)
8358 printf (" GROUPPERM");
8359 val ^= DF_P1_GROUPPERM;
8362 printf (" %lx", val);
8371 printf (_("Flags:"));
8372 if (entry->d_un.d_val == 0)
8373 printf (_(" None\n"));
8376 unsigned long int val = entry->d_un.d_val;
8383 if (val & DF_1_GLOBAL)
8388 if (val & DF_1_GROUP)
8393 if (val & DF_1_NODELETE)
8395 printf (" NODELETE");
8396 val ^= DF_1_NODELETE;
8398 if (val & DF_1_LOADFLTR)
8400 printf (" LOADFLTR");
8401 val ^= DF_1_LOADFLTR;
8403 if (val & DF_1_INITFIRST)
8405 printf (" INITFIRST");
8406 val ^= DF_1_INITFIRST;
8408 if (val & DF_1_NOOPEN)
8413 if (val & DF_1_ORIGIN)
8418 if (val & DF_1_DIRECT)
8423 if (val & DF_1_TRANS)
8428 if (val & DF_1_INTERPOSE)
8430 printf (" INTERPOSE");
8431 val ^= DF_1_INTERPOSE;
8433 if (val & DF_1_NODEFLIB)
8435 printf (" NODEFLIB");
8436 val ^= DF_1_NODEFLIB;
8438 if (val & DF_1_NODUMP)
8443 if (val & DF_1_CONFALT)
8445 printf (" CONFALT");
8446 val ^= DF_1_CONFALT;
8448 if (val & DF_1_ENDFILTEE)
8450 printf (" ENDFILTEE");
8451 val ^= DF_1_ENDFILTEE;
8453 if (val & DF_1_DISPRELDNE)
8455 printf (" DISPRELDNE");
8456 val ^= DF_1_DISPRELDNE;
8458 if (val & DF_1_DISPRELPND)
8460 printf (" DISPRELPND");
8461 val ^= DF_1_DISPRELPND;
8463 if (val & DF_1_NODIRECT)
8465 printf (" NODIRECT");
8466 val ^= DF_1_NODIRECT;
8468 if (val & DF_1_IGNMULDEF)
8470 printf (" IGNMULDEF");
8471 val ^= DF_1_IGNMULDEF;
8473 if (val & DF_1_NOKSYMS)
8475 printf (" NOKSYMS");
8476 val ^= DF_1_NOKSYMS;
8478 if (val & DF_1_NOHDR)
8483 if (val & DF_1_EDITED)
8488 if (val & DF_1_NORELOC)
8490 printf (" NORELOC");
8491 val ^= DF_1_NORELOC;
8493 if (val & DF_1_SYMINTPOSE)
8495 printf (" SYMINTPOSE");
8496 val ^= DF_1_SYMINTPOSE;
8498 if (val & DF_1_GLOBAUDIT)
8500 printf (" GLOBAUDIT");
8501 val ^= DF_1_GLOBAUDIT;
8503 if (val & DF_1_SINGLETON)
8505 printf (" SINGLETON");
8506 val ^= DF_1_SINGLETON;
8509 printf (" %lx", val);
8516 dynamic_info[entry->d_tag] = entry->d_un.d_val;
8518 puts (get_dynamic_type (entry->d_un.d_val));
8538 dynamic_info[entry->d_tag] = entry->d_un.d_val;
8544 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
8545 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
8551 switch (entry->d_tag)
8554 printf (_("Shared library: [%s]"), name);
8556 if (streq (name, program_interpreter))
8557 printf (_(" program interpreter"));
8561 printf (_("Library soname: [%s]"), name);
8565 printf (_("Library rpath: [%s]"), name);
8569 printf (_("Library runpath: [%s]"), name);
8573 print_vma (entry->d_un.d_val, PREFIX_HEX);
8578 print_vma (entry->d_un.d_val, PREFIX_HEX);
8591 dynamic_info[entry->d_tag] = entry->d_un.d_val;
8595 case DT_INIT_ARRAYSZ:
8596 case DT_FINI_ARRAYSZ:
8597 case DT_GNU_CONFLICTSZ:
8598 case DT_GNU_LIBLISTSZ:
8601 print_vma (entry->d_un.d_val, UNSIGNED);
8602 printf (_(" (bytes)\n"));
8612 print_vma (entry->d_un.d_val, UNSIGNED);
8625 if (entry->d_tag == DT_USED
8626 && VALID_DYNAMIC_NAME (entry->d_un.d_val))
8628 char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
8632 printf (_("Not needed object: [%s]\n"), name);
8637 print_vma (entry->d_un.d_val, PREFIX_HEX);
8643 /* The value of this entry is ignored. */
8648 case DT_GNU_PRELINKED:
8652 time_t atime = entry->d_un.d_val;
8654 tmp = gmtime (&atime);
8655 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
8656 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
8657 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
8663 dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
8666 print_vma (entry->d_un.d_val, PREFIX_HEX);
8672 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
8673 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
8678 switch (elf_header.e_machine)
8681 case EM_MIPS_RS3_LE:
8682 dynamic_section_mips_val (entry);
8685 dynamic_section_parisc_val (entry);
8688 dynamic_section_ia64_val (entry);
8691 print_vma (entry->d_un.d_val, PREFIX_HEX);
8703 get_ver_flags (unsigned int flags)
8705 static char buff[32];
8712 if (flags & VER_FLG_BASE)
8713 strcat (buff, "BASE ");
8715 if (flags & VER_FLG_WEAK)
8717 if (flags & VER_FLG_BASE)
8718 strcat (buff, "| ");
8720 strcat (buff, "WEAK ");
8723 if (flags & VER_FLG_INFO)
8725 if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
8726 strcat (buff, "| ");
8728 strcat (buff, "INFO ");
8731 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
8732 strcat (buff, _("| <unknown>"));
8737 /* Display the contents of the version sections. */
8740 process_version_sections (FILE * file)
8742 Elf_Internal_Shdr * section;
8749 for (i = 0, section = section_headers;
8750 i < elf_header.e_shnum;
8753 switch (section->sh_type)
8755 case SHT_GNU_verdef:
8757 Elf_External_Verdef * edefs;
8765 (_("\nVersion definition section '%s' contains %u entries:\n"),
8766 SECTION_NAME (section), section->sh_info);
8768 printf (_(" Addr: 0x"));
8769 printf_vma (section->sh_addr);
8770 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
8771 (unsigned long) section->sh_offset, section->sh_link,
8772 section->sh_link < elf_header.e_shnum
8773 ? SECTION_NAME (section_headers + section->sh_link)
8776 edefs = (Elf_External_Verdef *)
8777 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
8778 _("version definition section"));
8781 endbuf = (char *) edefs + section->sh_size;
8783 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
8786 Elf_External_Verdef * edef;
8787 Elf_Internal_Verdef ent;
8788 Elf_External_Verdaux * eaux;
8789 Elf_Internal_Verdaux aux;
8793 /* Check for very large indicies. */
8794 if (idx > (size_t) (endbuf - (char *) edefs))
8797 vstart = ((char *) edefs) + idx;
8798 if (vstart + sizeof (*edef) > endbuf)
8801 edef = (Elf_External_Verdef *) vstart;
8803 ent.vd_version = BYTE_GET (edef->vd_version);
8804 ent.vd_flags = BYTE_GET (edef->vd_flags);
8805 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
8806 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
8807 ent.vd_hash = BYTE_GET (edef->vd_hash);
8808 ent.vd_aux = BYTE_GET (edef->vd_aux);
8809 ent.vd_next = BYTE_GET (edef->vd_next);
8811 printf (_(" %#06x: Rev: %d Flags: %s"),
8812 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
8814 printf (_(" Index: %d Cnt: %d "),
8815 ent.vd_ndx, ent.vd_cnt);
8817 /* Check for overflow. */
8818 if (ent.vd_aux > (size_t) (endbuf - vstart))
8821 vstart += ent.vd_aux;
8823 eaux = (Elf_External_Verdaux *) vstart;
8825 aux.vda_name = BYTE_GET (eaux->vda_name);
8826 aux.vda_next = BYTE_GET (eaux->vda_next);
8828 if (VALID_DYNAMIC_NAME (aux.vda_name))
8829 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
8831 printf (_("Name index: %ld\n"), aux.vda_name);
8833 isum = idx + ent.vd_aux;
8835 for (j = 1; j < ent.vd_cnt; j++)
8837 /* Check for overflow. */
8838 if (aux.vda_next > (size_t) (endbuf - vstart))
8841 isum += aux.vda_next;
8842 vstart += aux.vda_next;
8844 eaux = (Elf_External_Verdaux *) vstart;
8845 if (vstart + sizeof (*eaux) > endbuf)
8848 aux.vda_name = BYTE_GET (eaux->vda_name);
8849 aux.vda_next = BYTE_GET (eaux->vda_next);
8851 if (VALID_DYNAMIC_NAME (aux.vda_name))
8852 printf (_(" %#06x: Parent %d: %s\n"),
8853 isum, j, GET_DYNAMIC_NAME (aux.vda_name));
8855 printf (_(" %#06x: Parent %d, name index: %ld\n"),
8856 isum, j, aux.vda_name);
8860 printf (_(" Version def aux past end of section\n"));
8865 if (cnt < section->sh_info)
8866 printf (_(" Version definition past end of section\n"));
8872 case SHT_GNU_verneed:
8874 Elf_External_Verneed * eneed;
8881 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
8882 SECTION_NAME (section), section->sh_info);
8884 printf (_(" Addr: 0x"));
8885 printf_vma (section->sh_addr);
8886 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
8887 (unsigned long) section->sh_offset, section->sh_link,
8888 section->sh_link < elf_header.e_shnum
8889 ? SECTION_NAME (section_headers + section->sh_link)
8892 eneed = (Elf_External_Verneed *) get_data (NULL, file,
8893 section->sh_offset, 1,
8895 _("Version Needs section"));
8898 endbuf = (char *) eneed + section->sh_size;
8900 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
8902 Elf_External_Verneed * entry;
8903 Elf_Internal_Verneed ent;
8908 if (idx > (size_t) (endbuf - (char *) eneed))
8911 vstart = ((char *) eneed) + idx;
8912 if (vstart + sizeof (*entry) > endbuf)
8915 entry = (Elf_External_Verneed *) vstart;
8917 ent.vn_version = BYTE_GET (entry->vn_version);
8918 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
8919 ent.vn_file = BYTE_GET (entry->vn_file);
8920 ent.vn_aux = BYTE_GET (entry->vn_aux);
8921 ent.vn_next = BYTE_GET (entry->vn_next);
8923 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
8925 if (VALID_DYNAMIC_NAME (ent.vn_file))
8926 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
8928 printf (_(" File: %lx"), ent.vn_file);
8930 printf (_(" Cnt: %d\n"), ent.vn_cnt);
8932 /* Check for overflow. */
8933 if (ent.vn_aux > (size_t) (endbuf - vstart))
8936 vstart += ent.vn_aux;
8938 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
8940 Elf_External_Vernaux * eaux;
8941 Elf_Internal_Vernaux aux;
8943 if (vstart + sizeof (*eaux) > endbuf)
8945 eaux = (Elf_External_Vernaux *) vstart;
8947 aux.vna_hash = BYTE_GET (eaux->vna_hash);
8948 aux.vna_flags = BYTE_GET (eaux->vna_flags);
8949 aux.vna_other = BYTE_GET (eaux->vna_other);
8950 aux.vna_name = BYTE_GET (eaux->vna_name);
8951 aux.vna_next = BYTE_GET (eaux->vna_next);
8953 if (VALID_DYNAMIC_NAME (aux.vna_name))
8954 printf (_(" %#06x: Name: %s"),
8955 isum, GET_DYNAMIC_NAME (aux.vna_name));
8957 printf (_(" %#06x: Name index: %lx"),
8958 isum, aux.vna_name);
8960 printf (_(" Flags: %s Version: %d\n"),
8961 get_ver_flags (aux.vna_flags), aux.vna_other);
8963 /* Check for overflow. */
8964 if (aux.vna_next > (size_t) (endbuf - vstart))
8967 isum += aux.vna_next;
8968 vstart += aux.vna_next;
8972 warn (_("Missing Version Needs auxillary information\n"));
8977 if (cnt < section->sh_info)
8978 warn (_("Missing Version Needs information\n"));
8984 case SHT_GNU_versym:
8986 Elf_Internal_Shdr * link_section;
8989 unsigned char * edata;
8990 unsigned short * data;
8992 Elf_Internal_Sym * symbols;
8993 Elf_Internal_Shdr * string_sec;
8994 unsigned long num_syms;
8997 if (section->sh_link >= elf_header.e_shnum)
9000 link_section = section_headers + section->sh_link;
9001 total = section->sh_size / sizeof (Elf_External_Versym);
9003 if (link_section->sh_link >= elf_header.e_shnum)
9008 symbols = GET_ELF_SYMBOLS (file, link_section, & num_syms);
9009 if (symbols == NULL)
9012 string_sec = section_headers + link_section->sh_link;
9014 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
9015 string_sec->sh_size,
9016 _("version string table"));
9023 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
9024 SECTION_NAME (section), total);
9026 printf (_(" Addr: "));
9027 printf_vma (section->sh_addr);
9028 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
9029 (unsigned long) section->sh_offset, section->sh_link,
9030 SECTION_NAME (link_section));
9032 off = offset_from_vma (file,
9033 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
9034 total * sizeof (short));
9035 edata = (unsigned char *) get_data (NULL, file, off, total,
9037 _("version symbol data"));
9045 data = (short unsigned int *) cmalloc (total, sizeof (short));
9047 for (cnt = total; cnt --;)
9048 data[cnt] = byte_get (edata + cnt * sizeof (short),
9053 for (cnt = 0; cnt < total; cnt += 4)
9056 int check_def, check_need;
9059 printf (" %03x:", cnt);
9061 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
9062 switch (data[cnt + j])
9065 fputs (_(" 0 (*local*) "), stdout);
9069 fputs (_(" 1 (*global*) "), stdout);
9073 nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
9074 data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
9076 /* If this index value is greater than the size of the symbols
9077 array, break to avoid an out-of-bounds read. */
9078 if ((unsigned long)(cnt + j) >= num_syms)
9080 warn (_("invalid index into symbol array\n"));
9086 if (symbols[cnt + j].st_shndx >= elf_header.e_shnum
9087 || section_headers[symbols[cnt + j].st_shndx].sh_type
9090 if (symbols[cnt + j].st_shndx == SHN_UNDEF)
9097 && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
9099 Elf_Internal_Verneed ivn;
9100 unsigned long offset;
9102 offset = offset_from_vma
9103 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
9104 sizeof (Elf_External_Verneed));
9108 Elf_Internal_Vernaux ivna;
9109 Elf_External_Verneed evn;
9110 Elf_External_Vernaux evna;
9111 unsigned long a_off;
9113 if (get_data (&evn, file, offset, sizeof (evn), 1,
9114 _("version need")) == NULL)
9117 ivn.vn_aux = BYTE_GET (evn.vn_aux);
9118 ivn.vn_next = BYTE_GET (evn.vn_next);
9120 a_off = offset + ivn.vn_aux;
9124 if (get_data (&evna, file, a_off, sizeof (evna),
9125 1, _("version need aux (2)")) == NULL)
9132 ivna.vna_next = BYTE_GET (evna.vna_next);
9133 ivna.vna_other = BYTE_GET (evna.vna_other);
9136 a_off += ivna.vna_next;
9138 while (ivna.vna_other != data[cnt + j]
9139 && ivna.vna_next != 0);
9141 if (ivna.vna_other == data[cnt + j])
9143 ivna.vna_name = BYTE_GET (evna.vna_name);
9145 if (ivna.vna_name >= string_sec->sh_size)
9146 name = _("*invalid*");
9148 name = strtab + ivna.vna_name;
9149 nn += printf ("(%s%-*s",
9151 12 - (int) strlen (name),
9157 offset += ivn.vn_next;
9159 while (ivn.vn_next);
9162 if (check_def && data[cnt + j] != 0x8001
9163 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
9165 Elf_Internal_Verdef ivd;
9166 Elf_External_Verdef evd;
9167 unsigned long offset;
9169 offset = offset_from_vma
9170 (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
9175 if (get_data (&evd, file, offset, sizeof (evd), 1,
9176 _("version def")) == NULL)
9183 ivd.vd_next = BYTE_GET (evd.vd_next);
9184 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
9187 offset += ivd.vd_next;
9189 while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
9190 && ivd.vd_next != 0);
9192 if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
9194 Elf_External_Verdaux evda;
9195 Elf_Internal_Verdaux ivda;
9197 ivd.vd_aux = BYTE_GET (evd.vd_aux);
9199 if (get_data (&evda, file,
9200 offset - ivd.vd_next + ivd.vd_aux,
9202 _("version def aux")) == NULL)
9205 ivda.vda_name = BYTE_GET (evda.vda_name);
9207 if (ivda.vda_name >= string_sec->sh_size)
9208 name = _("*invalid*");
9210 name = strtab + ivda.vda_name;
9211 nn += printf ("(%s%-*s",
9213 12 - (int) strlen (name),
9219 printf ("%*c", 18 - nn, ' ');
9237 printf (_("\nNo version information found in this file.\n"));
9243 get_symbol_binding (unsigned int binding)
9245 static char buff[32];
9249 case STB_LOCAL: return "LOCAL";
9250 case STB_GLOBAL: return "GLOBAL";
9251 case STB_WEAK: return "WEAK";
9253 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
9254 snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
9256 else if (binding >= STB_LOOS && binding <= STB_HIOS)
9258 if (binding == STB_GNU_UNIQUE
9259 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
9260 /* GNU is still using the default value 0. */
9261 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
9263 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
9266 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
9272 get_symbol_type (unsigned int type)
9274 static char buff[32];
9278 case STT_NOTYPE: return "NOTYPE";
9279 case STT_OBJECT: return "OBJECT";
9280 case STT_FUNC: return "FUNC";
9281 case STT_SECTION: return "SECTION";
9282 case STT_FILE: return "FILE";
9283 case STT_COMMON: return "COMMON";
9284 case STT_TLS: return "TLS";
9285 case STT_RELC: return "RELC";
9286 case STT_SRELC: return "SRELC";
9288 if (type >= STT_LOPROC && type <= STT_HIPROC)
9290 if (elf_header.e_machine == EM_ARM)
9292 if (type == STT_ARM_TFUNC)
9293 return "THUMB_FUNC";
9294 if (type == STT_ARM_16BIT)
9295 return "THUMB_LABEL";
9298 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
9301 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
9302 return "PARISC_MILLI";
9304 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
9306 else if (type >= STT_LOOS && type <= STT_HIOS)
9308 if (elf_header.e_machine == EM_PARISC)
9310 if (type == STT_HP_OPAQUE)
9312 if (type == STT_HP_STUB)
9316 if (type == STT_GNU_IFUNC
9317 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
9318 || elf_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
9319 /* GNU is still using the default value 0. */
9320 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
9323 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
9326 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
9332 get_symbol_visibility (unsigned int visibility)
9336 case STV_DEFAULT: return "DEFAULT";
9337 case STV_INTERNAL: return "INTERNAL";
9338 case STV_HIDDEN: return "HIDDEN";
9339 case STV_PROTECTED: return "PROTECTED";
9345 get_mips_symbol_other (unsigned int other)
9357 case STO_MICROMIPS | STO_MIPS_PIC:
9358 return "MICROMIPS, MIPS PIC";
9367 get_ia64_symbol_other (unsigned int other)
9371 static char res[32];
9375 /* Function types is for images and .STB files only. */
9376 switch (elf_header.e_type)
9380 switch (VMS_ST_FUNC_TYPE (other))
9382 case VMS_SFT_CODE_ADDR:
9383 strcat (res, " CA");
9385 case VMS_SFT_SYMV_IDX:
9386 strcat (res, " VEC");
9389 strcat (res, " FD");
9391 case VMS_SFT_RESERVE:
9392 strcat (res, " RSV");
9401 switch (VMS_ST_LINKAGE (other))
9403 case VMS_STL_IGNORE:
9404 strcat (res, " IGN");
9406 case VMS_STL_RESERVE:
9407 strcat (res, " RSV");
9410 strcat (res, " STD");
9413 strcat (res, " LNK");
9428 get_ppc64_symbol_other (unsigned int other)
9430 if (PPC64_LOCAL_ENTRY_OFFSET (other) != 0)
9432 static char buf[32];
9433 snprintf (buf, sizeof buf, _("<localentry>: %d"),
9434 PPC64_LOCAL_ENTRY_OFFSET (other));
9441 get_symbol_other (unsigned int other)
9443 const char * result = NULL;
9444 static char buff [32];
9449 switch (elf_header.e_machine)
9452 result = get_mips_symbol_other (other);
9455 result = get_ia64_symbol_other (other);
9458 result = get_ppc64_symbol_other (other);
9467 snprintf (buff, sizeof buff, _("<other>: %x"), other);
9472 get_symbol_index_type (unsigned int type)
9474 static char buff[32];
9478 case SHN_UNDEF: return "UND";
9479 case SHN_ABS: return "ABS";
9480 case SHN_COMMON: return "COM";
9482 if (type == SHN_IA_64_ANSI_COMMON
9483 && elf_header.e_machine == EM_IA_64
9484 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
9486 else if ((elf_header.e_machine == EM_X86_64
9487 || elf_header.e_machine == EM_L1OM
9488 || elf_header.e_machine == EM_K1OM)
9489 && type == SHN_X86_64_LCOMMON)
9491 else if ((type == SHN_MIPS_SCOMMON
9492 && elf_header.e_machine == EM_MIPS)
9493 || (type == SHN_TIC6X_SCOMMON
9494 && elf_header.e_machine == EM_TI_C6000))
9496 else if (type == SHN_MIPS_SUNDEFINED
9497 && elf_header.e_machine == EM_MIPS)
9499 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
9500 sprintf (buff, "PRC[0x%04x]", type & 0xffff);
9501 else if (type >= SHN_LOOS && type <= SHN_HIOS)
9502 sprintf (buff, "OS [0x%04x]", type & 0xffff);
9503 else if (type >= SHN_LORESERVE)
9504 sprintf (buff, "RSV[0x%04x]", type & 0xffff);
9505 else if (type >= elf_header.e_shnum)
9506 sprintf (buff, "bad section index[%3d]", type);
9508 sprintf (buff, "%3d", type);
9516 get_dynamic_data (FILE * file, unsigned int number, unsigned int ent_size)
9518 unsigned char * e_data;
9521 e_data = (unsigned char *) cmalloc (number, ent_size);
9525 error (_("Out of memory\n"));
9529 if (fread (e_data, ent_size, number, file) != number)
9531 error (_("Unable to read in dynamic data\n"));
9535 i_data = (bfd_vma *) cmalloc (number, sizeof (*i_data));
9539 error (_("Out of memory\n"));
9545 i_data[number] = byte_get (e_data + number * ent_size, ent_size);
9553 print_dynamic_symbol (bfd_vma si, unsigned long hn)
9555 Elf_Internal_Sym * psym;
9558 psym = dynamic_symbols + si;
9560 n = print_vma (si, DEC_5);
9562 fputs (&" "[n], stdout);
9563 printf (" %3lu: ", hn);
9564 print_vma (psym->st_value, LONG_HEX);
9566 print_vma (psym->st_size, DEC_5);
9568 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
9569 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
9570 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
9571 /* Check to see if any other bits in the st_other field are set.
9572 Note - displaying this information disrupts the layout of the
9573 table being generated, but for the moment this case is very
9575 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
9576 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
9577 printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
9578 if (VALID_DYNAMIC_NAME (psym->st_name))
9579 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
9581 printf (_(" <corrupt: %14ld>"), psym->st_name);
9585 /* Dump the symbol table. */
9587 process_symbol_table (FILE * file)
9589 Elf_Internal_Shdr * section;
9590 bfd_vma nbuckets = 0;
9591 bfd_vma nchains = 0;
9592 bfd_vma * buckets = NULL;
9593 bfd_vma * chains = NULL;
9594 bfd_vma ngnubuckets = 0;
9595 bfd_vma * gnubuckets = NULL;
9596 bfd_vma * gnuchains = NULL;
9597 bfd_vma gnusymidx = 0;
9599 if (!do_syms && !do_dyn_syms && !do_histogram)
9602 if (dynamic_info[DT_HASH]
9604 || (do_using_dynamic
9606 && dynamic_strings != NULL)))
9608 unsigned char nb[8];
9609 unsigned char nc[8];
9610 int hash_ent_size = 4;
9612 if ((elf_header.e_machine == EM_ALPHA
9613 || elf_header.e_machine == EM_S390
9614 || elf_header.e_machine == EM_S390_OLD)
9615 && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
9619 (archive_file_offset
9620 + offset_from_vma (file, dynamic_info[DT_HASH],
9621 sizeof nb + sizeof nc)),
9624 error (_("Unable to seek to start of dynamic information\n"));
9628 if (fread (nb, hash_ent_size, 1, file) != 1)
9630 error (_("Failed to read in number of buckets\n"));
9634 if (fread (nc, hash_ent_size, 1, file) != 1)
9636 error (_("Failed to read in number of chains\n"));
9640 nbuckets = byte_get (nb, hash_ent_size);
9641 nchains = byte_get (nc, hash_ent_size);
9643 buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
9644 chains = get_dynamic_data (file, nchains, hash_ent_size);
9647 if (buckets == NULL || chains == NULL)
9649 if (do_using_dynamic)
9660 if (dynamic_info_DT_GNU_HASH
9662 || (do_using_dynamic
9664 && dynamic_strings != NULL)))
9666 unsigned char nb[16];
9667 bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
9668 bfd_vma buckets_vma;
9671 (archive_file_offset
9672 + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
9676 error (_("Unable to seek to start of dynamic information\n"));
9680 if (fread (nb, 16, 1, file) != 1)
9682 error (_("Failed to read in number of buckets\n"));
9686 ngnubuckets = byte_get (nb, 4);
9687 gnusymidx = byte_get (nb + 4, 4);
9688 bitmaskwords = byte_get (nb + 8, 4);
9689 buckets_vma = dynamic_info_DT_GNU_HASH + 16;
9691 buckets_vma += bitmaskwords * 4;
9693 buckets_vma += bitmaskwords * 8;
9696 (archive_file_offset
9697 + offset_from_vma (file, buckets_vma, 4)),
9700 error (_("Unable to seek to start of dynamic information\n"));
9704 gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
9706 if (gnubuckets == NULL)
9709 for (i = 0; i < ngnubuckets; i++)
9710 if (gnubuckets[i] != 0)
9712 if (gnubuckets[i] < gnusymidx)
9715 if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
9716 maxchain = gnubuckets[i];
9719 if (maxchain == 0xffffffff)
9722 maxchain -= gnusymidx;
9725 (archive_file_offset
9726 + offset_from_vma (file, buckets_vma
9727 + 4 * (ngnubuckets + maxchain), 4)),
9730 error (_("Unable to seek to start of dynamic information\n"));
9736 if (fread (nb, 4, 1, file) != 1)
9738 error (_("Failed to determine last chain length\n"));
9742 if (maxchain + 1 == 0)
9747 while ((byte_get (nb, 4) & 1) == 0);
9750 (archive_file_offset
9751 + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
9754 error (_("Unable to seek to start of dynamic information\n"));
9758 gnuchains = get_dynamic_data (file, maxchain, 4);
9761 if (gnuchains == NULL)
9766 if (do_using_dynamic)
9771 if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
9774 && dynamic_strings != NULL)
9778 if (dynamic_info[DT_HASH])
9782 printf (_("\nSymbol table for image:\n"));
9784 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9786 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9788 for (hn = 0; hn < nbuckets; hn++)
9793 for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
9794 print_dynamic_symbol (si, hn);
9798 if (dynamic_info_DT_GNU_HASH)
9800 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
9802 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9804 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9806 for (hn = 0; hn < ngnubuckets; ++hn)
9807 if (gnubuckets[hn] != 0)
9809 bfd_vma si = gnubuckets[hn];
9810 bfd_vma off = si - gnusymidx;
9814 print_dynamic_symbol (si, hn);
9817 while ((gnuchains[off++] & 1) == 0);
9821 else if (do_dyn_syms || (do_syms && !do_using_dynamic))
9825 for (i = 0, section = section_headers;
9826 i < elf_header.e_shnum;
9830 char * strtab = NULL;
9831 unsigned long int strtab_size = 0;
9832 Elf_Internal_Sym * symtab;
9833 Elf_Internal_Sym * psym;
9834 unsigned long num_syms;
9836 if ((section->sh_type != SHT_SYMTAB
9837 && section->sh_type != SHT_DYNSYM)
9839 && section->sh_type == SHT_SYMTAB))
9842 if (section->sh_entsize == 0)
9844 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
9845 SECTION_NAME (section));
9849 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
9850 SECTION_NAME (section),
9851 (unsigned long) (section->sh_size / section->sh_entsize));
9854 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
9856 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
9858 symtab = GET_ELF_SYMBOLS (file, section, & num_syms);
9862 if (section->sh_link == elf_header.e_shstrndx)
9864 strtab = string_table;
9865 strtab_size = string_table_length;
9867 else if (section->sh_link < elf_header.e_shnum)
9869 Elf_Internal_Shdr * string_sec;
9871 string_sec = section_headers + section->sh_link;
9873 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
9874 1, string_sec->sh_size,
9876 strtab_size = strtab != NULL ? string_sec->sh_size : 0;
9879 for (si = 0, psym = symtab; si < num_syms; si++, psym++)
9881 printf ("%6d: ", si);
9882 print_vma (psym->st_value, LONG_HEX);
9884 print_vma (psym->st_size, DEC_5);
9885 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
9886 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
9887 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
9888 /* Check to see if any other bits in the st_other field are set.
9889 Note - displaying this information disrupts the layout of the
9890 table being generated, but for the moment this case is very rare. */
9891 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
9892 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
9893 printf (" %4s ", get_symbol_index_type (psym->st_shndx));
9894 print_symbol (25, psym->st_name < strtab_size
9895 ? strtab + psym->st_name : _("<corrupt>"));
9897 if (section->sh_type == SHT_DYNSYM
9898 && version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
9900 unsigned char data[2];
9901 unsigned short vers_data;
9902 unsigned long offset;
9906 offset = offset_from_vma
9907 (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
9908 sizeof data + si * sizeof (vers_data));
9910 if (get_data (&data, file, offset + si * sizeof (vers_data),
9911 sizeof (data), 1, _("version data")) == NULL)
9914 vers_data = byte_get (data, 2);
9916 is_nobits = (psym->st_shndx < elf_header.e_shnum
9917 && section_headers[psym->st_shndx].sh_type
9920 check_def = (psym->st_shndx != SHN_UNDEF);
9922 if ((vers_data & VERSYM_HIDDEN) || vers_data > 1)
9924 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
9925 && (is_nobits || ! check_def))
9927 Elf_External_Verneed evn;
9928 Elf_Internal_Verneed ivn;
9929 Elf_Internal_Vernaux ivna;
9931 /* We must test both. */
9932 offset = offset_from_vma
9933 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
9938 unsigned long vna_off;
9940 if (get_data (&evn, file, offset, sizeof (evn), 1,
9941 _("version need")) == NULL)
9949 ivn.vn_aux = BYTE_GET (evn.vn_aux);
9950 ivn.vn_next = BYTE_GET (evn.vn_next);
9952 vna_off = offset + ivn.vn_aux;
9956 Elf_External_Vernaux evna;
9958 if (get_data (&evna, file, vna_off,
9960 _("version need aux (3)")) == NULL)
9968 ivna.vna_other = BYTE_GET (evna.vna_other);
9969 ivna.vna_next = BYTE_GET (evna.vna_next);
9970 ivna.vna_name = BYTE_GET (evna.vna_name);
9973 vna_off += ivna.vna_next;
9975 while (ivna.vna_other != vers_data
9976 && ivna.vna_next != 0);
9978 if (ivna.vna_other == vers_data)
9981 offset += ivn.vn_next;
9983 while (ivn.vn_next != 0);
9985 if (ivna.vna_other == vers_data)
9988 ivna.vna_name < strtab_size
9989 ? strtab + ivna.vna_name : _("<corrupt>"),
9993 else if (! is_nobits)
9994 error (_("bad dynamic symbol\n"));
10001 if (vers_data != 0x8001
10002 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
10004 Elf_Internal_Verdef ivd;
10005 Elf_Internal_Verdaux ivda;
10006 Elf_External_Verdaux evda;
10009 off = offset_from_vma
10011 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
10012 sizeof (Elf_External_Verdef));
10016 Elf_External_Verdef evd;
10018 if (get_data (&evd, file, off, sizeof (evd),
10019 1, _("version def")) == NULL)
10027 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
10028 ivd.vd_aux = BYTE_GET (evd.vd_aux);
10029 ivd.vd_next = BYTE_GET (evd.vd_next);
10032 off += ivd.vd_next;
10034 while (ivd.vd_ndx != (vers_data & VERSYM_VERSION)
10035 && ivd.vd_next != 0);
10037 off -= ivd.vd_next;
10040 if (get_data (&evda, file, off, sizeof (evda),
10041 1, _("version def aux")) == NULL)
10044 ivda.vda_name = BYTE_GET (evda.vda_name);
10046 if (psym->st_name != ivda.vda_name)
10047 printf ((vers_data & VERSYM_HIDDEN)
10049 ivda.vda_name < strtab_size
10050 ? strtab + ivda.vda_name : _("<corrupt>"));
10060 if (strtab != string_table)
10066 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
10068 if (do_histogram && buckets != NULL)
10070 unsigned long * lengths;
10071 unsigned long * counts;
10074 unsigned long maxlength = 0;
10075 unsigned long nzero_counts = 0;
10076 unsigned long nsyms = 0;
10078 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
10079 (unsigned long) nbuckets);
10080 printf (_(" Length Number %% of total Coverage\n"));
10082 lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
10083 if (lengths == NULL)
10085 error (_("Out of memory\n"));
10088 for (hn = 0; hn < nbuckets; ++hn)
10090 for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
10093 if (maxlength < ++lengths[hn])
10098 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
10099 if (counts == NULL)
10102 error (_("Out of memory\n"));
10106 for (hn = 0; hn < nbuckets; ++hn)
10107 ++counts[lengths[hn]];
10112 printf (" 0 %-10lu (%5.1f%%)\n",
10113 counts[0], (counts[0] * 100.0) / nbuckets);
10114 for (i = 1; i <= maxlength; ++i)
10116 nzero_counts += counts[i] * i;
10117 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
10118 i, counts[i], (counts[i] * 100.0) / nbuckets,
10119 (nzero_counts * 100.0) / nsyms);
10127 if (buckets != NULL)
10133 if (do_histogram && gnubuckets != NULL)
10135 unsigned long * lengths;
10136 unsigned long * counts;
10138 unsigned long maxlength = 0;
10139 unsigned long nzero_counts = 0;
10140 unsigned long nsyms = 0;
10142 lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
10143 if (lengths == NULL)
10145 error (_("Out of memory\n"));
10149 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
10150 (unsigned long) ngnubuckets);
10151 printf (_(" Length Number %% of total Coverage\n"));
10153 for (hn = 0; hn < ngnubuckets; ++hn)
10154 if (gnubuckets[hn] != 0)
10156 bfd_vma off, length = 1;
10158 for (off = gnubuckets[hn] - gnusymidx;
10159 (gnuchains[off] & 1) == 0; ++off)
10161 lengths[hn] = length;
10162 if (length > maxlength)
10163 maxlength = length;
10167 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
10168 if (counts == NULL)
10171 error (_("Out of memory\n"));
10175 for (hn = 0; hn < ngnubuckets; ++hn)
10176 ++counts[lengths[hn]];
10178 if (ngnubuckets > 0)
10181 printf (" 0 %-10lu (%5.1f%%)\n",
10182 counts[0], (counts[0] * 100.0) / ngnubuckets);
10183 for (j = 1; j <= maxlength; ++j)
10185 nzero_counts += counts[j] * j;
10186 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
10187 j, counts[j], (counts[j] * 100.0) / ngnubuckets,
10188 (nzero_counts * 100.0) / nsyms);
10202 process_syminfo (FILE * file ATTRIBUTE_UNUSED)
10206 if (dynamic_syminfo == NULL
10208 /* No syminfo, this is ok. */
10211 /* There better should be a dynamic symbol section. */
10212 if (dynamic_symbols == NULL || dynamic_strings == NULL)
10216 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
10217 dynamic_syminfo_offset, dynamic_syminfo_nent);
10219 printf (_(" Num: Name BoundTo Flags\n"));
10220 for (i = 0; i < dynamic_syminfo_nent; ++i)
10222 unsigned short int flags = dynamic_syminfo[i].si_flags;
10224 printf ("%4d: ", i);
10225 if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
10226 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
10228 printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
10231 switch (dynamic_syminfo[i].si_boundto)
10233 case SYMINFO_BT_SELF:
10234 fputs ("SELF ", stdout);
10236 case SYMINFO_BT_PARENT:
10237 fputs ("PARENT ", stdout);
10240 if (dynamic_syminfo[i].si_boundto > 0
10241 && dynamic_syminfo[i].si_boundto < dynamic_nent
10242 && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
10244 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
10248 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
10252 if (flags & SYMINFO_FLG_DIRECT)
10253 printf (" DIRECT");
10254 if (flags & SYMINFO_FLG_PASSTHRU)
10255 printf (" PASSTHRU");
10256 if (flags & SYMINFO_FLG_COPY)
10258 if (flags & SYMINFO_FLG_LAZYLOAD)
10259 printf (" LAZYLOAD");
10267 /* Check to see if the given reloc needs to be handled in a target specific
10268 manner. If so then process the reloc and return TRUE otherwise return
10272 target_specific_reloc_handling (Elf_Internal_Rela * reloc,
10273 unsigned char * start,
10274 Elf_Internal_Sym * symtab)
10276 unsigned int reloc_type = get_reloc_type (reloc->r_info);
10278 switch (elf_header.e_machine)
10281 case EM_MSP430_OLD:
10283 static Elf_Internal_Sym * saved_sym = NULL;
10285 switch (reloc_type)
10287 case 10: /* R_MSP430_SYM_DIFF */
10288 if (uses_msp430x_relocs ())
10290 case 21: /* R_MSP430X_SYM_DIFF */
10291 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
10294 case 1: /* R_MSP430_32 or R_MSP430_ABS32 */
10295 case 3: /* R_MSP430_16 or R_MSP430_ABS8 */
10296 goto handle_sym_diff;
10298 case 5: /* R_MSP430_16_BYTE */
10299 case 9: /* R_MSP430_8 */
10300 if (uses_msp430x_relocs ())
10302 goto handle_sym_diff;
10304 case 2: /* R_MSP430_ABS16 */
10305 case 15: /* R_MSP430X_ABS16 */
10306 if (! uses_msp430x_relocs ())
10308 goto handle_sym_diff;
10311 if (saved_sym != NULL)
10315 value = reloc->r_addend
10316 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
10317 - saved_sym->st_value);
10319 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
10327 if (saved_sym != NULL)
10328 error (_("Unhandled MSP430 reloc type found after SYM_DIFF reloc"));
10335 case EM_CYGNUS_MN10300:
10337 static Elf_Internal_Sym * saved_sym = NULL;
10339 switch (reloc_type)
10341 case 34: /* R_MN10300_ALIGN */
10343 case 33: /* R_MN10300_SYM_DIFF */
10344 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
10346 case 1: /* R_MN10300_32 */
10347 case 2: /* R_MN10300_16 */
10348 if (saved_sym != NULL)
10352 value = reloc->r_addend
10353 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
10354 - saved_sym->st_value);
10356 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
10363 if (saved_sym != NULL)
10364 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc"));
10374 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
10375 DWARF debug sections. This is a target specific test. Note - we do not
10376 go through the whole including-target-headers-multiple-times route, (as
10377 we have already done with <elf/h8.h>) because this would become very
10378 messy and even then this function would have to contain target specific
10379 information (the names of the relocs instead of their numeric values).
10380 FIXME: This is not the correct way to solve this problem. The proper way
10381 is to have target specific reloc sizing and typing functions created by
10382 the reloc-macros.h header, in the same way that it already creates the
10383 reloc naming functions. */
10386 is_32bit_abs_reloc (unsigned int reloc_type)
10388 switch (elf_header.e_machine)
10392 return reloc_type == 1; /* R_386_32. */
10394 return reloc_type == 1; /* R_68K_32. */
10396 return reloc_type == 1; /* R_860_32. */
10398 return reloc_type == 2; /* R_960_32. */
10400 return reloc_type == 258; /* R_AARCH64_ABS32 */
10402 return reloc_type == 1; /* R_ALPHA_REFLONG. */
10404 return reloc_type == 1; /* R_ARC_32. */
10406 return reloc_type == 2; /* R_ARM_ABS32 */
10409 return reloc_type == 1;
10410 case EM_ADAPTEVA_EPIPHANY:
10411 return reloc_type == 3;
10413 return reloc_type == 0x12; /* R_byte4_data. */
10415 return reloc_type == 3; /* R_CRIS_32. */
10417 return reloc_type == 3; /* R_CR16_NUM32. */
10419 return reloc_type == 15; /* R_CRX_NUM32. */
10420 case EM_CYGNUS_FRV:
10421 return reloc_type == 1;
10422 case EM_CYGNUS_D10V:
10424 return reloc_type == 6; /* R_D10V_32. */
10425 case EM_CYGNUS_D30V:
10427 return reloc_type == 12; /* R_D30V_32_NORMAL. */
10429 return reloc_type == 3; /* R_DLX_RELOC_32. */
10430 case EM_CYGNUS_FR30:
10432 return reloc_type == 3; /* R_FR30_32. */
10436 return reloc_type == 1; /* R_H8_DIR32. */
10438 return reloc_type == 0x65; /* R_IA64_SECREL32LSB. */
10441 return reloc_type == 2; /* R_IP2K_32. */
10443 return reloc_type == 2; /* R_IQ2000_32. */
10444 case EM_LATTICEMICO32:
10445 return reloc_type == 3; /* R_LM32_32. */
10448 return reloc_type == 3; /* R_M32C_32. */
10450 return reloc_type == 34; /* R_M32R_32_RELA. */
10452 return reloc_type == 1; /* R_MCORE_ADDR32. */
10453 case EM_CYGNUS_MEP:
10454 return reloc_type == 4; /* R_MEP_32. */
10456 return reloc_type == 2; /* R_METAG_ADDR32. */
10457 case EM_MICROBLAZE:
10458 return reloc_type == 1; /* R_MICROBLAZE_32. */
10460 return reloc_type == 2; /* R_MIPS_32. */
10462 return reloc_type == 4; /* R_MMIX_32. */
10463 case EM_CYGNUS_MN10200:
10465 return reloc_type == 1; /* R_MN10200_32. */
10466 case EM_CYGNUS_MN10300:
10468 return reloc_type == 1; /* R_MN10300_32. */
10470 return reloc_type == 1; /* R_MOXIE_32. */
10471 case EM_MSP430_OLD:
10473 return reloc_type == 1; /* R_MSP430_32 or R_MSP320_ABS32. */
10475 return reloc_type == 2; /* R_MT_32. */
10477 return reloc_type == 20; /* R_NDS32_RELA. */
10478 case EM_ALTERA_NIOS2:
10479 return reloc_type == 12; /* R_NIOS2_BFD_RELOC_32. */
10481 return reloc_type == 1; /* R_NIOS_32. */
10484 return reloc_type == 1; /* R_OR32_32. */
10486 return (reloc_type == 1 /* R_PARISC_DIR32. */
10487 || reloc_type == 41); /* R_PARISC_SECREL32. */
10490 return reloc_type == 1; /* R_PJ_DATA_DIR32. */
10492 return reloc_type == 1; /* R_PPC64_ADDR32. */
10494 return reloc_type == 1; /* R_PPC_ADDR32. */
10496 return reloc_type == 1; /* R_RL78_DIR32. */
10498 return reloc_type == 1; /* R_RX_DIR32. */
10500 return reloc_type == 1; /* R_I370_ADDR31. */
10503 return reloc_type == 4; /* R_S390_32. */
10505 return reloc_type == 8; /* R_SCORE_ABS32. */
10507 return reloc_type == 1; /* R_SH_DIR32. */
10508 case EM_SPARC32PLUS:
10511 return reloc_type == 3 /* R_SPARC_32. */
10512 || reloc_type == 23; /* R_SPARC_UA32. */
10514 return reloc_type == 6; /* R_SPU_ADDR32 */
10516 return reloc_type == 1; /* R_C6000_ABS32. */
10518 return reloc_type == 2; /* R_TILEGX_32. */
10520 return reloc_type == 1; /* R_TILEPRO_32. */
10521 case EM_CYGNUS_V850:
10523 return reloc_type == 6; /* R_V850_ABS32. */
10525 return reloc_type == 0x33; /* R_V810_WORD. */
10527 return reloc_type == 1; /* R_VAX_32. */
10531 return reloc_type == 10; /* R_X86_64_32. */
10534 return reloc_type == 3; /* R_XC16C_ABS_32. */
10536 return reloc_type == 4; /* R_XGATE_32. */
10538 return reloc_type == 1; /* R_XSTROMY16_32. */
10539 case EM_XTENSA_OLD:
10541 return reloc_type == 1; /* R_XTENSA_32. */
10543 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
10544 elf_header.e_machine);
10549 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10550 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
10553 is_32bit_pcrel_reloc (unsigned int reloc_type)
10555 switch (elf_header.e_machine)
10559 return reloc_type == 2; /* R_386_PC32. */
10561 return reloc_type == 4; /* R_68K_PC32. */
10563 return reloc_type == 261; /* R_AARCH64_PREL32 */
10564 case EM_ADAPTEVA_EPIPHANY:
10565 return reloc_type == 6;
10567 return reloc_type == 10; /* R_ALPHA_SREL32. */
10569 return reloc_type == 3; /* R_ARM_REL32 */
10570 case EM_MICROBLAZE:
10571 return reloc_type == 2; /* R_MICROBLAZE_32_PCREL. */
10573 return reloc_type == 9; /* R_PARISC_PCREL32. */
10575 return reloc_type == 26; /* R_PPC_REL32. */
10577 return reloc_type == 26; /* R_PPC64_REL32. */
10580 return reloc_type == 5; /* R_390_PC32. */
10582 return reloc_type == 2; /* R_SH_REL32. */
10583 case EM_SPARC32PLUS:
10586 return reloc_type == 6; /* R_SPARC_DISP32. */
10588 return reloc_type == 13; /* R_SPU_REL32. */
10590 return reloc_type == 6; /* R_TILEGX_32_PCREL. */
10592 return reloc_type == 4; /* R_TILEPRO_32_PCREL. */
10596 return reloc_type == 2; /* R_X86_64_PC32. */
10597 case EM_XTENSA_OLD:
10599 return reloc_type == 14; /* R_XTENSA_32_PCREL. */
10601 /* Do not abort or issue an error message here. Not all targets use
10602 pc-relative 32-bit relocs in their DWARF debug information and we
10603 have already tested for target coverage in is_32bit_abs_reloc. A
10604 more helpful warning message will be generated by apply_relocations
10605 anyway, so just return. */
10610 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10611 a 64-bit absolute RELA relocation used in DWARF debug sections. */
10614 is_64bit_abs_reloc (unsigned int reloc_type)
10616 switch (elf_header.e_machine)
10619 return reloc_type == 257; /* R_AARCH64_ABS64. */
10621 return reloc_type == 2; /* R_ALPHA_REFQUAD. */
10623 return reloc_type == 0x27; /* R_IA64_DIR64LSB. */
10625 return reloc_type == 80; /* R_PARISC_DIR64. */
10627 return reloc_type == 38; /* R_PPC64_ADDR64. */
10628 case EM_SPARC32PLUS:
10631 return reloc_type == 54; /* R_SPARC_UA64. */
10635 return reloc_type == 1; /* R_X86_64_64. */
10638 return reloc_type == 22; /* R_S390_64. */
10640 return reloc_type == 1; /* R_TILEGX_64. */
10642 return reloc_type == 18; /* R_MIPS_64. */
10648 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
10649 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
10652 is_64bit_pcrel_reloc (unsigned int reloc_type)
10654 switch (elf_header.e_machine)
10657 return reloc_type == 260; /* R_AARCH64_PREL64. */
10659 return reloc_type == 11; /* R_ALPHA_SREL64. */
10661 return reloc_type == 0x4f; /* R_IA64_PCREL64LSB. */
10663 return reloc_type == 72; /* R_PARISC_PCREL64. */
10665 return reloc_type == 44; /* R_PPC64_REL64. */
10666 case EM_SPARC32PLUS:
10669 return reloc_type == 46; /* R_SPARC_DISP64. */
10673 return reloc_type == 24; /* R_X86_64_PC64. */
10676 return reloc_type == 23; /* R_S390_PC64. */
10678 return reloc_type == 5; /* R_TILEGX_64_PCREL. */
10684 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10685 a 24-bit absolute RELA relocation used in DWARF debug sections. */
10688 is_24bit_abs_reloc (unsigned int reloc_type)
10690 switch (elf_header.e_machine)
10692 case EM_CYGNUS_MN10200:
10694 return reloc_type == 4; /* R_MN10200_24. */
10700 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10701 a 16-bit absolute RELA relocation used in DWARF debug sections. */
10704 is_16bit_abs_reloc (unsigned int reloc_type)
10706 switch (elf_header.e_machine)
10710 return reloc_type == 4; /* R_AVR_16. */
10711 case EM_ADAPTEVA_EPIPHANY:
10712 return reloc_type == 5;
10713 case EM_CYGNUS_D10V:
10715 return reloc_type == 3; /* R_D10V_16. */
10719 return reloc_type == R_H8_DIR16;
10722 return reloc_type == 1; /* R_IP2K_16. */
10725 return reloc_type == 1; /* R_M32C_16 */
10727 if (uses_msp430x_relocs ())
10728 return reloc_type == 2; /* R_MSP430_ABS16. */
10729 case EM_MSP430_OLD:
10730 return reloc_type == 5; /* R_MSP430_16_BYTE. */
10732 return reloc_type == 19; /* R_NDS32_RELA. */
10733 case EM_ALTERA_NIOS2:
10734 return reloc_type == 13; /* R_NIOS2_BFD_RELOC_16. */
10736 return reloc_type == 9; /* R_NIOS_16. */
10738 return reloc_type == 2; /* R_C6000_ABS16. */
10741 return reloc_type == 2; /* R_XC16C_ABS_16. */
10742 case EM_CYGNUS_MN10200:
10744 return reloc_type == 2; /* R_MN10200_16. */
10745 case EM_CYGNUS_MN10300:
10747 return reloc_type == 2; /* R_MN10300_16. */
10749 return reloc_type == 3; /* R_XGATE_16. */
10755 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
10756 relocation entries (possibly formerly used for SHT_GROUP sections). */
10759 is_none_reloc (unsigned int reloc_type)
10761 switch (elf_header.e_machine)
10763 case EM_68K: /* R_68K_NONE. */
10764 case EM_386: /* R_386_NONE. */
10765 case EM_SPARC32PLUS:
10767 case EM_SPARC: /* R_SPARC_NONE. */
10768 case EM_MIPS: /* R_MIPS_NONE. */
10769 case EM_PARISC: /* R_PARISC_NONE. */
10770 case EM_ALPHA: /* R_ALPHA_NONE. */
10771 case EM_ADAPTEVA_EPIPHANY:
10772 case EM_PPC: /* R_PPC_NONE. */
10773 case EM_PPC64: /* R_PPC64_NONE. */
10774 case EM_ARM: /* R_ARM_NONE. */
10775 case EM_IA_64: /* R_IA64_NONE. */
10776 case EM_SH: /* R_SH_NONE. */
10778 case EM_S390: /* R_390_NONE. */
10779 case EM_CRIS: /* R_CRIS_NONE. */
10780 case EM_X86_64: /* R_X86_64_NONE. */
10781 case EM_L1OM: /* R_X86_64_NONE. */
10782 case EM_K1OM: /* R_X86_64_NONE. */
10783 case EM_MN10300: /* R_MN10300_NONE. */
10784 case EM_MOXIE: /* R_MOXIE_NONE. */
10785 case EM_M32R: /* R_M32R_NONE. */
10786 case EM_TI_C6000:/* R_C6000_NONE. */
10787 case EM_TILEGX: /* R_TILEGX_NONE. */
10788 case EM_TILEPRO: /* R_TILEPRO_NONE. */
10790 case EM_C166: /* R_XC16X_NONE. */
10791 case EM_ALTERA_NIOS2: /* R_NIOS2_NONE. */
10792 case EM_NIOS32: /* R_NIOS_NONE. */
10793 return reloc_type == 0;
10795 return reloc_type == 0 || reloc_type == 256;
10797 return (reloc_type == 0 /* R_XTENSA_NONE. */
10798 || reloc_type == 204 /* R_NDS32_DIFF8. */
10799 || reloc_type == 205 /* R_NDS32_DIFF16. */
10800 || reloc_type == 206 /* R_NDS32_DIFF32. */
10801 || reloc_type == 207 /* R_NDS32_ULEB128. */);
10802 case EM_XTENSA_OLD:
10804 return (reloc_type == 0 /* R_XTENSA_NONE. */
10805 || reloc_type == 17 /* R_XTENSA_DIFF8. */
10806 || reloc_type == 18 /* R_XTENSA_DIFF16. */
10807 || reloc_type == 19 /* R_XTENSA_DIFF32. */);
10809 return reloc_type == 3; /* R_METAG_NONE. */
10814 /* Apply relocations to a section.
10815 Note: So far support has been added only for those relocations
10816 which can be found in debug sections.
10817 FIXME: Add support for more relocations ? */
10820 apply_relocations (void * file,
10821 Elf_Internal_Shdr * section,
10822 unsigned char * start)
10824 Elf_Internal_Shdr * relsec;
10825 unsigned char * end = start + section->sh_size;
10827 if (elf_header.e_type != ET_REL)
10830 /* Find the reloc section associated with the section. */
10831 for (relsec = section_headers;
10832 relsec < section_headers + elf_header.e_shnum;
10835 bfd_boolean is_rela;
10836 unsigned long num_relocs;
10837 Elf_Internal_Rela * relocs;
10838 Elf_Internal_Rela * rp;
10839 Elf_Internal_Shdr * symsec;
10840 Elf_Internal_Sym * symtab;
10841 unsigned long num_syms;
10842 Elf_Internal_Sym * sym;
10844 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
10845 || relsec->sh_info >= elf_header.e_shnum
10846 || section_headers + relsec->sh_info != section
10847 || relsec->sh_size == 0
10848 || relsec->sh_link >= elf_header.e_shnum)
10851 is_rela = relsec->sh_type == SHT_RELA;
10855 if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
10856 relsec->sh_size, & relocs, & num_relocs))
10861 if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
10862 relsec->sh_size, & relocs, & num_relocs))
10866 /* SH uses RELA but uses in place value instead of the addend field. */
10867 if (elf_header.e_machine == EM_SH)
10870 symsec = section_headers + relsec->sh_link;
10871 symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec, & num_syms);
10873 for (rp = relocs; rp < relocs + num_relocs; ++rp)
10876 unsigned int reloc_type;
10877 unsigned int reloc_size;
10878 unsigned char * rloc;
10879 unsigned long sym_index;
10881 reloc_type = get_reloc_type (rp->r_info);
10883 if (target_specific_reloc_handling (rp, start, symtab))
10885 else if (is_none_reloc (reloc_type))
10887 else if (is_32bit_abs_reloc (reloc_type)
10888 || is_32bit_pcrel_reloc (reloc_type))
10890 else if (is_64bit_abs_reloc (reloc_type)
10891 || is_64bit_pcrel_reloc (reloc_type))
10893 else if (is_24bit_abs_reloc (reloc_type))
10895 else if (is_16bit_abs_reloc (reloc_type))
10899 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
10900 reloc_type, SECTION_NAME (section));
10904 rloc = start + rp->r_offset;
10905 if ((rloc + reloc_size) > end || (rloc < start))
10907 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
10908 (unsigned long) rp->r_offset,
10909 SECTION_NAME (section));
10913 sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
10914 if (sym_index >= num_syms)
10916 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
10917 sym_index, SECTION_NAME (section));
10920 sym = symtab + sym_index;
10922 /* If the reloc has a symbol associated with it,
10923 make sure that it is of an appropriate type.
10925 Relocations against symbols without type can happen.
10926 Gcc -feliminate-dwarf2-dups may generate symbols
10927 without type for debug info.
10929 Icc generates relocations against function symbols
10930 instead of local labels.
10932 Relocations against object symbols can happen, eg when
10933 referencing a global array. For an example of this see
10934 the _clz.o binary in libgcc.a. */
10936 && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
10938 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
10939 get_symbol_type (ELF_ST_TYPE (sym->st_info)),
10940 (long int)(rp - relocs),
10941 SECTION_NAME (relsec));
10947 addend += rp->r_addend;
10948 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
10949 partial_inplace. */
10951 || (elf_header.e_machine == EM_XTENSA
10952 && reloc_type == 1)
10953 || ((elf_header.e_machine == EM_PJ
10954 || elf_header.e_machine == EM_PJ_OLD)
10955 && reloc_type == 1)
10956 || ((elf_header.e_machine == EM_D30V
10957 || elf_header.e_machine == EM_CYGNUS_D30V)
10958 && reloc_type == 12))
10959 addend += byte_get (rloc, reloc_size);
10961 if (is_32bit_pcrel_reloc (reloc_type)
10962 || is_64bit_pcrel_reloc (reloc_type))
10964 /* On HPPA, all pc-relative relocations are biased by 8. */
10965 if (elf_header.e_machine == EM_PARISC)
10967 byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
10971 byte_put (rloc, addend + sym->st_value, reloc_size);
10980 #ifdef SUPPORT_DISASSEMBLY
10982 disassemble_section (Elf_Internal_Shdr * section, FILE * file)
10984 printf (_("\nAssembly dump of section %s\n"),
10985 SECTION_NAME (section));
10987 /* XXX -- to be done --- XXX */
10993 /* Reads in the contents of SECTION from FILE, returning a pointer
10994 to a malloc'ed buffer or NULL if something went wrong. */
10997 get_section_contents (Elf_Internal_Shdr * section, FILE * file)
10999 bfd_size_type num_bytes;
11001 num_bytes = section->sh_size;
11003 if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
11005 printf (_("\nSection '%s' has no data to dump.\n"),
11006 SECTION_NAME (section));
11010 return (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
11011 _("section contents"));
11016 dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
11018 Elf_Internal_Shdr * relsec;
11019 bfd_size_type num_bytes;
11023 char * name = SECTION_NAME (section);
11024 bfd_boolean some_strings_shown;
11026 start = get_section_contents (section, file);
11030 printf (_("\nString dump of section '%s':\n"), name);
11032 /* If the section being dumped has relocations against it the user might
11033 be expecting these relocations to have been applied. Check for this
11034 case and issue a warning message in order to avoid confusion.
11035 FIXME: Maybe we ought to have an option that dumps a section with
11036 relocs applied ? */
11037 for (relsec = section_headers;
11038 relsec < section_headers + elf_header.e_shnum;
11041 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
11042 || relsec->sh_info >= elf_header.e_shnum
11043 || section_headers + relsec->sh_info != section
11044 || relsec->sh_size == 0
11045 || relsec->sh_link >= elf_header.e_shnum)
11048 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
11052 num_bytes = section->sh_size;
11054 end = start + num_bytes;
11055 some_strings_shown = FALSE;
11059 while (!ISPRINT (* data))
11060 if (++ data >= end)
11066 /* PR 11128: Use two separate invocations in order to work
11067 around bugs in the Solaris 8 implementation of printf. */
11068 printf (" [%6tx] ", data - start);
11069 printf ("%s\n", data);
11071 printf (" [%6Ix] %s\n", (size_t) (data - start), data);
11073 data += strlen (data);
11074 some_strings_shown = TRUE;
11078 if (! some_strings_shown)
11079 printf (_(" No strings found in this section."));
11087 dump_section_as_bytes (Elf_Internal_Shdr * section,
11089 bfd_boolean relocate)
11091 Elf_Internal_Shdr * relsec;
11092 bfd_size_type bytes;
11094 unsigned char * data;
11095 unsigned char * start;
11097 start = (unsigned char *) get_section_contents (section, file);
11101 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
11105 apply_relocations (file, section, start);
11109 /* If the section being dumped has relocations against it the user might
11110 be expecting these relocations to have been applied. Check for this
11111 case and issue a warning message in order to avoid confusion.
11112 FIXME: Maybe we ought to have an option that dumps a section with
11113 relocs applied ? */
11114 for (relsec = section_headers;
11115 relsec < section_headers + elf_header.e_shnum;
11118 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
11119 || relsec->sh_info >= elf_header.e_shnum
11120 || section_headers + relsec->sh_info != section
11121 || relsec->sh_size == 0
11122 || relsec->sh_link >= elf_header.e_shnum)
11125 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
11130 addr = section->sh_addr;
11131 bytes = section->sh_size;
11140 lbytes = (bytes > 16 ? 16 : bytes);
11142 printf (" 0x%8.8lx ", (unsigned long) addr);
11144 for (j = 0; j < 16; j++)
11147 printf ("%2.2x", data[j]);
11155 for (j = 0; j < lbytes; j++)
11158 if (k >= ' ' && k < 0x7f)
11176 /* Uncompresses a section that was compressed using zlib, in place. */
11179 uncompress_section_contents (unsigned char **buffer ATTRIBUTE_UNUSED,
11180 dwarf_size_type *size ATTRIBUTE_UNUSED)
11182 #ifndef HAVE_ZLIB_H
11185 dwarf_size_type compressed_size = *size;
11186 unsigned char * compressed_buffer = *buffer;
11187 dwarf_size_type uncompressed_size;
11188 unsigned char * uncompressed_buffer;
11191 dwarf_size_type header_size = 12;
11193 /* Read the zlib header. In this case, it should be "ZLIB" followed
11194 by the uncompressed section size, 8 bytes in big-endian order. */
11195 if (compressed_size < header_size
11196 || ! streq ((char *) compressed_buffer, "ZLIB"))
11199 uncompressed_size = compressed_buffer[4]; uncompressed_size <<= 8;
11200 uncompressed_size += compressed_buffer[5]; uncompressed_size <<= 8;
11201 uncompressed_size += compressed_buffer[6]; uncompressed_size <<= 8;
11202 uncompressed_size += compressed_buffer[7]; uncompressed_size <<= 8;
11203 uncompressed_size += compressed_buffer[8]; uncompressed_size <<= 8;
11204 uncompressed_size += compressed_buffer[9]; uncompressed_size <<= 8;
11205 uncompressed_size += compressed_buffer[10]; uncompressed_size <<= 8;
11206 uncompressed_size += compressed_buffer[11];
11208 /* It is possible the section consists of several compressed
11209 buffers concatenated together, so we uncompress in a loop. */
11210 strm.zalloc = NULL;
11212 strm.opaque = NULL;
11213 strm.avail_in = compressed_size - header_size;
11214 strm.next_in = (Bytef *) compressed_buffer + header_size;
11215 strm.avail_out = uncompressed_size;
11216 uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
11218 rc = inflateInit (& strm);
11219 while (strm.avail_in > 0)
11223 strm.next_out = ((Bytef *) uncompressed_buffer
11224 + (uncompressed_size - strm.avail_out));
11225 rc = inflate (&strm, Z_FINISH);
11226 if (rc != Z_STREAM_END)
11228 rc = inflateReset (& strm);
11230 rc = inflateEnd (& strm);
11232 || strm.avail_out != 0)
11235 free (compressed_buffer);
11236 *buffer = uncompressed_buffer;
11237 *size = uncompressed_size;
11241 free (uncompressed_buffer);
11242 /* Indicate decompression failure. */
11245 #endif /* HAVE_ZLIB_H */
11249 load_specific_debug_section (enum dwarf_section_display_enum debug,
11250 Elf_Internal_Shdr * sec, void * file)
11252 struct dwarf_section * section = &debug_displays [debug].section;
11255 /* If it is already loaded, do nothing. */
11256 if (section->start != NULL)
11259 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
11260 section->address = sec->sh_addr;
11261 section->start = (unsigned char *) get_data (NULL, (FILE *) file,
11263 sec->sh_size, buf);
11264 if (section->start == NULL)
11268 section->size = sec->sh_size;
11269 if (uncompress_section_contents (§ion->start, §ion->size))
11270 sec->sh_size = section->size;
11273 if (section->start == NULL)
11276 if (debug_displays [debug].relocate)
11277 apply_relocations ((FILE *) file, sec, section->start);
11282 /* If this is not NULL, load_debug_section will only look for sections
11283 within the list of sections given here. */
11284 unsigned int *section_subset = NULL;
11287 load_debug_section (enum dwarf_section_display_enum debug, void * file)
11289 struct dwarf_section * section = &debug_displays [debug].section;
11290 Elf_Internal_Shdr * sec;
11292 /* Locate the debug section. */
11293 sec = find_section_in_set (section->uncompressed_name, section_subset);
11295 section->name = section->uncompressed_name;
11298 sec = find_section_in_set (section->compressed_name, section_subset);
11300 section->name = section->compressed_name;
11305 /* If we're loading from a subset of sections, and we've loaded
11306 a section matching this name before, it's likely that it's a
11308 if (section_subset != NULL)
11309 free_debug_section (debug);
11311 return load_specific_debug_section (debug, sec, (FILE *) file);
11315 free_debug_section (enum dwarf_section_display_enum debug)
11317 struct dwarf_section * section = &debug_displays [debug].section;
11319 if (section->start == NULL)
11322 free ((char *) section->start);
11323 section->start = NULL;
11324 section->address = 0;
11329 display_debug_section (int shndx, Elf_Internal_Shdr * section, FILE * file)
11331 char * name = SECTION_NAME (section);
11332 bfd_size_type length;
11336 length = section->sh_size;
11339 printf (_("\nSection '%s' has no debugging data.\n"), name);
11342 if (section->sh_type == SHT_NOBITS)
11344 /* There is no point in dumping the contents of a debugging section
11345 which has the NOBITS type - the bits in the file will be random.
11346 This can happen when a file containing a .eh_frame section is
11347 stripped with the --only-keep-debug command line option. */
11348 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"), name);
11352 if (const_strneq (name, ".gnu.linkonce.wi."))
11353 name = ".debug_info";
11355 /* See if we know how to display the contents of this section. */
11356 for (i = 0; i < max; i++)
11357 if (streq (debug_displays[i].section.uncompressed_name, name)
11358 || (i == line && const_strneq (name, ".debug_line."))
11359 || streq (debug_displays[i].section.compressed_name, name))
11361 struct dwarf_section * sec = &debug_displays [i].section;
11362 int secondary = (section != find_section (name));
11365 free_debug_section ((enum dwarf_section_display_enum) i);
11367 if (i == line && const_strneq (name, ".debug_line."))
11369 else if (streq (sec->uncompressed_name, name))
11370 sec->name = sec->uncompressed_name;
11372 sec->name = sec->compressed_name;
11373 if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
11376 /* If this debug section is part of a CU/TU set in a .dwp file,
11377 restrict load_debug_section to the sections in that set. */
11378 section_subset = find_cu_tu_set (file, shndx);
11380 result &= debug_displays[i].display (sec, file);
11382 section_subset = NULL;
11384 if (secondary || (i != info && i != abbrev))
11385 free_debug_section ((enum dwarf_section_display_enum) i);
11393 printf (_("Unrecognized debug section: %s\n"), name);
11400 /* Set DUMP_SECTS for all sections where dumps were requested
11401 based on section name. */
11404 initialise_dumps_byname (void)
11406 struct dump_list_entry * cur;
11408 for (cur = dump_sects_byname; cur; cur = cur->next)
11413 for (i = 0, any = 0; i < elf_header.e_shnum; i++)
11414 if (streq (SECTION_NAME (section_headers + i), cur->name))
11416 request_dump_bynumber (i, cur->type);
11421 warn (_("Section '%s' was not dumped because it does not exist!\n"),
11427 process_section_contents (FILE * file)
11429 Elf_Internal_Shdr * section;
11435 initialise_dumps_byname ();
11437 for (i = 0, section = section_headers;
11438 i < elf_header.e_shnum && i < num_dump_sects;
11441 #ifdef SUPPORT_DISASSEMBLY
11442 if (dump_sects[i] & DISASS_DUMP)
11443 disassemble_section (section, file);
11445 if (dump_sects[i] & HEX_DUMP)
11446 dump_section_as_bytes (section, file, FALSE);
11448 if (dump_sects[i] & RELOC_DUMP)
11449 dump_section_as_bytes (section, file, TRUE);
11451 if (dump_sects[i] & STRING_DUMP)
11452 dump_section_as_strings (section, file);
11454 if (dump_sects[i] & DEBUG_DUMP)
11455 display_debug_section (i, section, file);
11458 /* Check to see if the user requested a
11459 dump of a section that does not exist. */
11460 while (i++ < num_dump_sects)
11462 warn (_("Section %d was not dumped because it does not exist!\n"), i);
11466 process_mips_fpe_exception (int mask)
11471 if (mask & OEX_FPU_INEX)
11472 fputs ("INEX", stdout), first = 0;
11473 if (mask & OEX_FPU_UFLO)
11474 printf ("%sUFLO", first ? "" : "|"), first = 0;
11475 if (mask & OEX_FPU_OFLO)
11476 printf ("%sOFLO", first ? "" : "|"), first = 0;
11477 if (mask & OEX_FPU_DIV0)
11478 printf ("%sDIV0", first ? "" : "|"), first = 0;
11479 if (mask & OEX_FPU_INVAL)
11480 printf ("%sINVAL", first ? "" : "|");
11483 fputs ("0", stdout);
11486 /* Display's the value of TAG at location P. If TAG is
11487 greater than 0 it is assumed to be an unknown tag, and
11488 a message is printed to this effect. Otherwise it is
11489 assumed that a message has already been printed.
11491 If the bottom bit of TAG is set it assumed to have a
11492 string value, otherwise it is assumed to have an integer
11495 Returns an updated P pointing to the first unread byte
11496 beyond the end of TAG's value.
11498 Reads at or beyond END will not be made. */
11500 static unsigned char *
11501 display_tag_value (int tag,
11503 const unsigned char * const end)
11508 printf (" Tag_unknown_%d: ", tag);
11512 warn (_("corrupt tag\n"));
11516 /* FIXME: we could read beyond END here. */
11517 printf ("\"%s\"\n", p);
11518 p += strlen ((char *) p) + 1;
11524 val = read_uleb128 (p, &len, end);
11526 printf ("%ld (0x%lx)\n", val, val);
11532 /* ARM EABI attributes section. */
11537 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
11539 const char ** table;
11540 } arm_attr_public_tag;
11542 static const char * arm_attr_tag_CPU_arch[] =
11543 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
11544 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8"};
11545 static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
11546 static const char * arm_attr_tag_THUMB_ISA_use[] =
11547 {"No", "Thumb-1", "Thumb-2"};
11548 static const char * arm_attr_tag_FP_arch[] =
11549 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
11551 static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
11552 static const char * arm_attr_tag_Advanced_SIMD_arch[] =
11553 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
11554 static const char * arm_attr_tag_PCS_config[] =
11555 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
11556 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
11557 static const char * arm_attr_tag_ABI_PCS_R9_use[] =
11558 {"V6", "SB", "TLS", "Unused"};
11559 static const char * arm_attr_tag_ABI_PCS_RW_data[] =
11560 {"Absolute", "PC-relative", "SB-relative", "None"};
11561 static const char * arm_attr_tag_ABI_PCS_RO_data[] =
11562 {"Absolute", "PC-relative", "None"};
11563 static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
11564 {"None", "direct", "GOT-indirect"};
11565 static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
11566 {"None", "??? 1", "2", "??? 3", "4"};
11567 static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
11568 static const char * arm_attr_tag_ABI_FP_denormal[] =
11569 {"Unused", "Needed", "Sign only"};
11570 static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
11571 static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
11572 static const char * arm_attr_tag_ABI_FP_number_model[] =
11573 {"Unused", "Finite", "RTABI", "IEEE 754"};
11574 static const char * arm_attr_tag_ABI_enum_size[] =
11575 {"Unused", "small", "int", "forced to int"};
11576 static const char * arm_attr_tag_ABI_HardFP_use[] =
11577 {"As Tag_FP_arch", "SP only", "DP only", "SP and DP"};
11578 static const char * arm_attr_tag_ABI_VFP_args[] =
11579 {"AAPCS", "VFP registers", "custom"};
11580 static const char * arm_attr_tag_ABI_WMMX_args[] =
11581 {"AAPCS", "WMMX registers", "custom"};
11582 static const char * arm_attr_tag_ABI_optimization_goals[] =
11583 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
11584 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
11585 static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
11586 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
11587 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
11588 static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
11589 static const char * arm_attr_tag_FP_HP_extension[] =
11590 {"Not Allowed", "Allowed"};
11591 static const char * arm_attr_tag_ABI_FP_16bit_format[] =
11592 {"None", "IEEE 754", "Alternative Format"};
11593 static const char * arm_attr_tag_MPextension_use[] =
11594 {"Not Allowed", "Allowed"};
11595 static const char * arm_attr_tag_DIV_use[] =
11596 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
11597 "Allowed in v7-A with integer division extension"};
11598 static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
11599 static const char * arm_attr_tag_Virtualization_use[] =
11600 {"Not Allowed", "TrustZone", "Virtualization Extensions",
11601 "TrustZone and Virtualization Extensions"};
11602 static const char * arm_attr_tag_MPextension_use_legacy[] =
11603 {"Not Allowed", "Allowed"};
11605 #define LOOKUP(id, name) \
11606 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
11607 static arm_attr_public_tag arm_attr_public_tags[] =
11609 {4, "CPU_raw_name", 1, NULL},
11610 {5, "CPU_name", 1, NULL},
11611 LOOKUP(6, CPU_arch),
11612 {7, "CPU_arch_profile", 0, NULL},
11613 LOOKUP(8, ARM_ISA_use),
11614 LOOKUP(9, THUMB_ISA_use),
11615 LOOKUP(10, FP_arch),
11616 LOOKUP(11, WMMX_arch),
11617 LOOKUP(12, Advanced_SIMD_arch),
11618 LOOKUP(13, PCS_config),
11619 LOOKUP(14, ABI_PCS_R9_use),
11620 LOOKUP(15, ABI_PCS_RW_data),
11621 LOOKUP(16, ABI_PCS_RO_data),
11622 LOOKUP(17, ABI_PCS_GOT_use),
11623 LOOKUP(18, ABI_PCS_wchar_t),
11624 LOOKUP(19, ABI_FP_rounding),
11625 LOOKUP(20, ABI_FP_denormal),
11626 LOOKUP(21, ABI_FP_exceptions),
11627 LOOKUP(22, ABI_FP_user_exceptions),
11628 LOOKUP(23, ABI_FP_number_model),
11629 {24, "ABI_align_needed", 0, NULL},
11630 {25, "ABI_align_preserved", 0, NULL},
11631 LOOKUP(26, ABI_enum_size),
11632 LOOKUP(27, ABI_HardFP_use),
11633 LOOKUP(28, ABI_VFP_args),
11634 LOOKUP(29, ABI_WMMX_args),
11635 LOOKUP(30, ABI_optimization_goals),
11636 LOOKUP(31, ABI_FP_optimization_goals),
11637 {32, "compatibility", 0, NULL},
11638 LOOKUP(34, CPU_unaligned_access),
11639 LOOKUP(36, FP_HP_extension),
11640 LOOKUP(38, ABI_FP_16bit_format),
11641 LOOKUP(42, MPextension_use),
11642 LOOKUP(44, DIV_use),
11643 {64, "nodefaults", 0, NULL},
11644 {65, "also_compatible_with", 0, NULL},
11645 LOOKUP(66, T2EE_use),
11646 {67, "conformance", 1, NULL},
11647 LOOKUP(68, Virtualization_use),
11648 LOOKUP(70, MPextension_use_legacy)
11652 static unsigned char *
11653 display_arm_attribute (unsigned char * p,
11654 const unsigned char * const end)
11659 arm_attr_public_tag * attr;
11663 tag = read_uleb128 (p, &len, end);
11666 for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
11668 if (arm_attr_public_tags[i].tag == tag)
11670 attr = &arm_attr_public_tags[i];
11677 printf (" Tag_%s: ", attr->name);
11678 switch (attr->type)
11683 case 7: /* Tag_CPU_arch_profile. */
11684 val = read_uleb128 (p, &len, end);
11688 case 0: printf (_("None\n")); break;
11689 case 'A': printf (_("Application\n")); break;
11690 case 'R': printf (_("Realtime\n")); break;
11691 case 'M': printf (_("Microcontroller\n")); break;
11692 case 'S': printf (_("Application or Realtime\n")); break;
11693 default: printf ("??? (%d)\n", val); break;
11697 case 24: /* Tag_align_needed. */
11698 val = read_uleb128 (p, &len, end);
11702 case 0: printf (_("None\n")); break;
11703 case 1: printf (_("8-byte\n")); break;
11704 case 2: printf (_("4-byte\n")); break;
11705 case 3: printf ("??? 3\n"); break;
11708 printf (_("8-byte and up to %d-byte extended\n"),
11711 printf ("??? (%d)\n", val);
11716 case 25: /* Tag_align_preserved. */
11717 val = read_uleb128 (p, &len, end);
11721 case 0: printf (_("None\n")); break;
11722 case 1: printf (_("8-byte, except leaf SP\n")); break;
11723 case 2: printf (_("8-byte\n")); break;
11724 case 3: printf ("??? 3\n"); break;
11727 printf (_("8-byte and up to %d-byte extended\n"),
11730 printf ("??? (%d)\n", val);
11735 case 32: /* Tag_compatibility. */
11736 val = read_uleb128 (p, &len, end);
11738 printf (_("flag = %d, vendor = %s\n"), val, p);
11739 p += strlen ((char *) p) + 1;
11742 case 64: /* Tag_nodefaults. */
11744 printf (_("True\n"));
11747 case 65: /* Tag_also_compatible_with. */
11748 val = read_uleb128 (p, &len, end);
11750 if (val == 6 /* Tag_CPU_arch. */)
11752 val = read_uleb128 (p, &len, end);
11754 if ((unsigned int)val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
11755 printf ("??? (%d)\n", val);
11757 printf ("%s\n", arm_attr_tag_CPU_arch[val]);
11761 while (*(p++) != '\0' /* NUL terminator. */);
11770 return display_tag_value (-1, p, end);
11772 return display_tag_value (0, p, end);
11775 assert (attr->type & 0x80);
11776 val = read_uleb128 (p, &len, end);
11778 type = attr->type & 0x7f;
11780 printf ("??? (%d)\n", val);
11782 printf ("%s\n", attr->table[val]);
11787 return display_tag_value (tag, p, end);
11790 static unsigned char *
11791 display_gnu_attribute (unsigned char * p,
11792 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const),
11793 const unsigned char * const end)
11799 tag = read_uleb128 (p, &len, end);
11802 /* Tag_compatibility is the only generic GNU attribute defined at
11806 val = read_uleb128 (p, &len, end);
11810 printf (_("flag = %d, vendor = <corrupt>\n"), val);
11811 warn (_("corrupt vendor attribute\n"));
11815 printf (_("flag = %d, vendor = %s\n"), val, p);
11816 p += strlen ((char *) p) + 1;
11821 if ((tag & 2) == 0 && display_proc_gnu_attribute)
11822 return display_proc_gnu_attribute (p, tag, end);
11824 return display_tag_value (tag, p, end);
11827 static unsigned char *
11828 display_power_gnu_attribute (unsigned char * p,
11830 const unsigned char * const end)
11835 if (tag == Tag_GNU_Power_ABI_FP)
11837 val = read_uleb128 (p, &len, end);
11839 printf (" Tag_GNU_Power_ABI_FP: ");
11844 printf (_("Hard or soft float\n"));
11847 printf (_("Hard float\n"));
11850 printf (_("Soft float\n"));
11853 printf (_("Single-precision hard float\n"));
11856 printf ("??? (%d)\n", val);
11862 if (tag == Tag_GNU_Power_ABI_Vector)
11864 val = read_uleb128 (p, &len, end);
11866 printf (" Tag_GNU_Power_ABI_Vector: ");
11870 printf (_("Any\n"));
11873 printf (_("Generic\n"));
11876 printf ("AltiVec\n");
11882 printf ("??? (%d)\n", val);
11888 if (tag == Tag_GNU_Power_ABI_Struct_Return)
11892 warn (_("corrupt Tag_GNU_Power_ABI_Struct_Return"));
11896 val = read_uleb128 (p, &len, end);
11898 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
11902 printf (_("Any\n"));
11905 printf ("r3/r4\n");
11908 printf (_("Memory\n"));
11911 printf ("??? (%d)\n", val);
11917 return display_tag_value (tag & 1, p, end);
11921 display_sparc_hwcaps (int mask)
11926 if (mask & ELF_SPARC_HWCAP_MUL32)
11927 fputs ("mul32", stdout), first = 0;
11928 if (mask & ELF_SPARC_HWCAP_DIV32)
11929 printf ("%sdiv32", first ? "" : "|"), first = 0;
11930 if (mask & ELF_SPARC_HWCAP_FSMULD)
11931 printf ("%sfsmuld", first ? "" : "|"), first = 0;
11932 if (mask & ELF_SPARC_HWCAP_V8PLUS)
11933 printf ("%sv8plus", first ? "" : "|"), first = 0;
11934 if (mask & ELF_SPARC_HWCAP_POPC)
11935 printf ("%spopc", first ? "" : "|"), first = 0;
11936 if (mask & ELF_SPARC_HWCAP_VIS)
11937 printf ("%svis", first ? "" : "|"), first = 0;
11938 if (mask & ELF_SPARC_HWCAP_VIS2)
11939 printf ("%svis2", first ? "" : "|"), first = 0;
11940 if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
11941 printf ("%sASIBlkInit", first ? "" : "|"), first = 0;
11942 if (mask & ELF_SPARC_HWCAP_FMAF)
11943 printf ("%sfmaf", first ? "" : "|"), first = 0;
11944 if (mask & ELF_SPARC_HWCAP_VIS3)
11945 printf ("%svis3", first ? "" : "|"), first = 0;
11946 if (mask & ELF_SPARC_HWCAP_HPC)
11947 printf ("%shpc", first ? "" : "|"), first = 0;
11948 if (mask & ELF_SPARC_HWCAP_RANDOM)
11949 printf ("%srandom", first ? "" : "|"), first = 0;
11950 if (mask & ELF_SPARC_HWCAP_TRANS)
11951 printf ("%strans", first ? "" : "|"), first = 0;
11952 if (mask & ELF_SPARC_HWCAP_FJFMAU)
11953 printf ("%sfjfmau", first ? "" : "|"), first = 0;
11954 if (mask & ELF_SPARC_HWCAP_IMA)
11955 printf ("%sima", first ? "" : "|"), first = 0;
11956 if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
11957 printf ("%scspare", first ? "" : "|"), first = 0;
11960 fputc('0', stdout);
11961 fputc('\n', stdout);
11964 static unsigned char *
11965 display_sparc_gnu_attribute (unsigned char * p,
11967 const unsigned char * const end)
11969 if (tag == Tag_GNU_Sparc_HWCAPS)
11974 val = read_uleb128 (p, &len, end);
11976 printf (" Tag_GNU_Sparc_HWCAPS: ");
11977 display_sparc_hwcaps (val);
11981 return display_tag_value (tag, p, end);
11984 static unsigned char *
11985 display_mips_gnu_attribute (unsigned char * p,
11987 const unsigned char * const end)
11989 if (tag == Tag_GNU_MIPS_ABI_FP)
11994 val = read_uleb128 (p, &len, end);
11996 printf (" Tag_GNU_MIPS_ABI_FP: ");
12000 case Val_GNU_MIPS_ABI_FP_ANY:
12001 printf (_("Hard or soft float\n"));
12003 case Val_GNU_MIPS_ABI_FP_DOUBLE:
12004 printf (_("Hard float (double precision)\n"));
12006 case Val_GNU_MIPS_ABI_FP_SINGLE:
12007 printf (_("Hard float (single precision)\n"));
12009 case Val_GNU_MIPS_ABI_FP_SOFT:
12010 printf (_("Soft float\n"));
12012 case Val_GNU_MIPS_ABI_FP_64:
12013 printf (_("Hard float (MIPS32r2 64-bit FPU)\n"));
12016 printf ("??? (%d)\n", val);
12022 if (tag == Tag_GNU_MIPS_ABI_MSA)
12027 val = read_uleb128 (p, &len, end);
12029 printf (" Tag_GNU_MIPS_ABI_MSA: ");
12033 case Val_GNU_MIPS_ABI_MSA_ANY:
12034 printf (_("Any MSA or not\n"));
12036 case Val_GNU_MIPS_ABI_MSA_128:
12037 printf (_("128-bit MSA\n"));
12040 printf ("??? (%d)\n", val);
12046 return display_tag_value (tag & 1, p, end);
12049 static unsigned char *
12050 display_tic6x_attribute (unsigned char * p,
12051 const unsigned char * const end)
12057 tag = read_uleb128 (p, &len, end);
12063 val = read_uleb128 (p, &len, end);
12065 printf (" Tag_ISA: ");
12069 case C6XABI_Tag_ISA_none:
12070 printf (_("None\n"));
12072 case C6XABI_Tag_ISA_C62X:
12075 case C6XABI_Tag_ISA_C67X:
12078 case C6XABI_Tag_ISA_C67XP:
12079 printf ("C67x+\n");
12081 case C6XABI_Tag_ISA_C64X:
12084 case C6XABI_Tag_ISA_C64XP:
12085 printf ("C64x+\n");
12087 case C6XABI_Tag_ISA_C674X:
12088 printf ("C674x\n");
12091 printf ("??? (%d)\n", val);
12096 case Tag_ABI_wchar_t:
12097 val = read_uleb128 (p, &len, end);
12099 printf (" Tag_ABI_wchar_t: ");
12103 printf (_("Not used\n"));
12106 printf (_("2 bytes\n"));
12109 printf (_("4 bytes\n"));
12112 printf ("??? (%d)\n", val);
12117 case Tag_ABI_stack_align_needed:
12118 val = read_uleb128 (p, &len, end);
12120 printf (" Tag_ABI_stack_align_needed: ");
12124 printf (_("8-byte\n"));
12127 printf (_("16-byte\n"));
12130 printf ("??? (%d)\n", val);
12135 case Tag_ABI_stack_align_preserved:
12136 val = read_uleb128 (p, &len, end);
12138 printf (" Tag_ABI_stack_align_preserved: ");
12142 printf (_("8-byte\n"));
12145 printf (_("16-byte\n"));
12148 printf ("??? (%d)\n", val);
12154 val = read_uleb128 (p, &len, end);
12156 printf (" Tag_ABI_DSBT: ");
12160 printf (_("DSBT addressing not used\n"));
12163 printf (_("DSBT addressing used\n"));
12166 printf ("??? (%d)\n", val);
12172 val = read_uleb128 (p, &len, end);
12174 printf (" Tag_ABI_PID: ");
12178 printf (_("Data addressing position-dependent\n"));
12181 printf (_("Data addressing position-independent, GOT near DP\n"));
12184 printf (_("Data addressing position-independent, GOT far from DP\n"));
12187 printf ("??? (%d)\n", val);
12193 val = read_uleb128 (p, &len, end);
12195 printf (" Tag_ABI_PIC: ");
12199 printf (_("Code addressing position-dependent\n"));
12202 printf (_("Code addressing position-independent\n"));
12205 printf ("??? (%d)\n", val);
12210 case Tag_ABI_array_object_alignment:
12211 val = read_uleb128 (p, &len, end);
12213 printf (" Tag_ABI_array_object_alignment: ");
12217 printf (_("8-byte\n"));
12220 printf (_("4-byte\n"));
12223 printf (_("16-byte\n"));
12226 printf ("??? (%d)\n", val);
12231 case Tag_ABI_array_object_align_expected:
12232 val = read_uleb128 (p, &len, end);
12234 printf (" Tag_ABI_array_object_align_expected: ");
12238 printf (_("8-byte\n"));
12241 printf (_("4-byte\n"));
12244 printf (_("16-byte\n"));
12247 printf ("??? (%d)\n", val);
12252 case Tag_ABI_compatibility:
12253 val = read_uleb128 (p, &len, end);
12255 printf (" Tag_ABI_compatibility: ");
12256 printf (_("flag = %d, vendor = %s\n"), val, p);
12257 p += strlen ((char *) p) + 1;
12260 case Tag_ABI_conformance:
12261 printf (" Tag_ABI_conformance: ");
12262 printf ("\"%s\"\n", p);
12263 p += strlen ((char *) p) + 1;
12267 return display_tag_value (tag, p, end);
12271 display_raw_attribute (unsigned char * p, unsigned char * end)
12273 unsigned long addr = 0;
12274 size_t bytes = end - p;
12280 int lbytes = (bytes > 16 ? 16 : bytes);
12282 printf (" 0x%8.8lx ", addr);
12284 for (j = 0; j < 16; j++)
12287 printf ("%2.2x", p[j]);
12295 for (j = 0; j < lbytes; j++)
12298 if (k >= ' ' && k < 0x7f)
12314 static unsigned char *
12315 display_msp430x_attribute (unsigned char * p,
12316 const unsigned char * const end)
12322 tag = read_uleb128 (p, & len, end);
12327 case OFBA_MSPABI_Tag_ISA:
12328 val = read_uleb128 (p, &len, end);
12330 printf (" Tag_ISA: ");
12333 case 0: printf (_("None\n")); break;
12334 case 1: printf (_("MSP430\n")); break;
12335 case 2: printf (_("MSP430X\n")); break;
12336 default: printf ("??? (%d)\n", val); break;
12340 case OFBA_MSPABI_Tag_Code_Model:
12341 val = read_uleb128 (p, &len, end);
12343 printf (" Tag_Code_Model: ");
12346 case 0: printf (_("None\n")); break;
12347 case 1: printf (_("Small\n")); break;
12348 case 2: printf (_("Large\n")); break;
12349 default: printf ("??? (%d)\n", val); break;
12353 case OFBA_MSPABI_Tag_Data_Model:
12354 val = read_uleb128 (p, &len, end);
12356 printf (" Tag_Data_Model: ");
12359 case 0: printf (_("None\n")); break;
12360 case 1: printf (_("Small\n")); break;
12361 case 2: printf (_("Large\n")); break;
12362 case 3: printf (_("Restricted Large\n")); break;
12363 default: printf ("??? (%d)\n", val); break;
12368 printf (_(" <unknown tag %d>: "), tag);
12372 printf ("\"%s\"\n", p);
12373 p += strlen ((char *) p) + 1;
12377 val = read_uleb128 (p, &len, end);
12379 printf ("%d (0x%x)\n", val, val);
12388 process_attributes (FILE * file,
12389 const char * public_name,
12390 unsigned int proc_type,
12391 unsigned char * (* display_pub_attribute) (unsigned char *, const unsigned char * const),
12392 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int, const unsigned char * const))
12394 Elf_Internal_Shdr * sect;
12395 unsigned char * contents;
12397 unsigned char * end;
12398 bfd_vma section_len;
12402 /* Find the section header so that we get the size. */
12403 for (i = 0, sect = section_headers;
12404 i < elf_header.e_shnum;
12407 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
12410 contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
12411 sect->sh_size, _("attributes"));
12412 if (contents == NULL)
12418 len = sect->sh_size - 1;
12424 bfd_boolean public_section;
12425 bfd_boolean gnu_section;
12427 section_len = byte_get (p, 4);
12430 if (section_len > len)
12432 printf (_("ERROR: Bad section length (%d > %d)\n"),
12433 (int) section_len, (int) len);
12437 len -= section_len;
12438 printf (_("Attribute Section: %s\n"), p);
12440 if (public_name && streq ((char *) p, public_name))
12441 public_section = TRUE;
12443 public_section = FALSE;
12445 if (streq ((char *) p, "gnu"))
12446 gnu_section = TRUE;
12448 gnu_section = FALSE;
12450 namelen = strlen ((char *) p) + 1;
12452 section_len -= namelen + 4;
12454 while (section_len > 0)
12460 size = byte_get (p, 4);
12461 if (size > section_len)
12463 printf (_("ERROR: Bad subsection length (%d > %d)\n"),
12464 (int) size, (int) section_len);
12465 size = section_len;
12468 section_len -= size;
12469 end = p + size - 1;
12475 printf (_("File Attributes\n"));
12478 printf (_("Section Attributes:"));
12481 printf (_("Symbol Attributes:"));
12487 val = read_uleb128 (p, &j, end);
12491 printf (" %d", val);
12496 printf (_("Unknown tag: %d\n"), tag);
12497 public_section = FALSE;
12501 if (public_section)
12504 p = display_pub_attribute (p, end);
12506 else if (gnu_section)
12509 p = display_gnu_attribute (p,
12510 display_proc_gnu_attribute,
12515 printf (_(" Unknown section contexts\n"));
12516 display_raw_attribute (p, end);
12523 printf (_("Unknown format '%c'\n"), *p);
12531 process_arm_specific (FILE * file)
12533 return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
12534 display_arm_attribute, NULL);
12538 process_power_specific (FILE * file)
12540 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
12541 display_power_gnu_attribute);
12545 process_sparc_specific (FILE * file)
12547 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
12548 display_sparc_gnu_attribute);
12552 process_tic6x_specific (FILE * file)
12554 return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
12555 display_tic6x_attribute, NULL);
12559 process_msp430x_specific (FILE * file)
12561 return process_attributes (file, "mspabi", SHT_MSP430_ATTRIBUTES,
12562 display_msp430x_attribute, NULL);
12565 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
12566 Print the Address, Access and Initial fields of an entry at VMA ADDR
12567 and return the VMA of the next entry. */
12570 print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
12573 print_vma (addr, LONG_HEX);
12575 if (addr < pltgot + 0xfff0)
12576 printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
12578 printf ("%10s", "");
12581 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
12586 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
12587 print_vma (entry, LONG_HEX);
12589 return addr + (is_32bit_elf ? 4 : 8);
12592 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
12593 PLTGOT. Print the Address and Initial fields of an entry at VMA
12594 ADDR and return the VMA of the next entry. */
12597 print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
12600 print_vma (addr, LONG_HEX);
12603 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
12608 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
12609 print_vma (entry, LONG_HEX);
12611 return addr + (is_32bit_elf ? 4 : 8);
12615 process_mips_specific (FILE * file)
12617 Elf_Internal_Dyn * entry;
12618 size_t liblist_offset = 0;
12619 size_t liblistno = 0;
12620 size_t conflictsno = 0;
12621 size_t options_offset = 0;
12622 size_t conflicts_offset = 0;
12623 size_t pltrelsz = 0;
12625 bfd_vma pltgot = 0;
12626 bfd_vma mips_pltgot = 0;
12627 bfd_vma jmprel = 0;
12628 bfd_vma local_gotno = 0;
12629 bfd_vma gotsym = 0;
12630 bfd_vma symtabno = 0;
12632 process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
12633 display_mips_gnu_attribute);
12635 /* We have a lot of special sections. Thanks SGI! */
12636 if (dynamic_section == NULL)
12637 /* No information available. */
12640 for (entry = dynamic_section; entry->d_tag != DT_NULL; ++entry)
12641 switch (entry->d_tag)
12643 case DT_MIPS_LIBLIST:
12645 = offset_from_vma (file, entry->d_un.d_val,
12646 liblistno * sizeof (Elf32_External_Lib));
12648 case DT_MIPS_LIBLISTNO:
12649 liblistno = entry->d_un.d_val;
12651 case DT_MIPS_OPTIONS:
12652 options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
12654 case DT_MIPS_CONFLICT:
12656 = offset_from_vma (file, entry->d_un.d_val,
12657 conflictsno * sizeof (Elf32_External_Conflict));
12659 case DT_MIPS_CONFLICTNO:
12660 conflictsno = entry->d_un.d_val;
12663 pltgot = entry->d_un.d_ptr;
12665 case DT_MIPS_LOCAL_GOTNO:
12666 local_gotno = entry->d_un.d_val;
12668 case DT_MIPS_GOTSYM:
12669 gotsym = entry->d_un.d_val;
12671 case DT_MIPS_SYMTABNO:
12672 symtabno = entry->d_un.d_val;
12674 case DT_MIPS_PLTGOT:
12675 mips_pltgot = entry->d_un.d_ptr;
12678 pltrel = entry->d_un.d_val;
12681 pltrelsz = entry->d_un.d_val;
12684 jmprel = entry->d_un.d_ptr;
12690 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
12692 Elf32_External_Lib * elib;
12695 elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
12697 sizeof (Elf32_External_Lib),
12698 _("liblist section data"));
12701 printf (_("\nSection '.liblist' contains %lu entries:\n"),
12702 (unsigned long) liblistno);
12703 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
12706 for (cnt = 0; cnt < liblistno; ++cnt)
12713 liblist.l_name = BYTE_GET (elib[cnt].l_name);
12714 atime = BYTE_GET (elib[cnt].l_time_stamp);
12715 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
12716 liblist.l_version = BYTE_GET (elib[cnt].l_version);
12717 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
12719 tmp = gmtime (&atime);
12720 snprintf (timebuf, sizeof (timebuf),
12721 "%04u-%02u-%02uT%02u:%02u:%02u",
12722 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
12723 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
12725 printf ("%3lu: ", (unsigned long) cnt);
12726 if (VALID_DYNAMIC_NAME (liblist.l_name))
12727 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
12729 printf (_("<corrupt: %9ld>"), liblist.l_name);
12730 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
12731 liblist.l_version);
12733 if (liblist.l_flags == 0)
12737 static const struct
12744 { " EXACT_MATCH", LL_EXACT_MATCH },
12745 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
12746 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
12747 { " EXPORTS", LL_EXPORTS },
12748 { " DELAY_LOAD", LL_DELAY_LOAD },
12749 { " DELTA", LL_DELTA }
12751 int flags = liblist.l_flags;
12754 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
12755 if ((flags & l_flags_vals[fcnt].bit) != 0)
12757 fputs (l_flags_vals[fcnt].name, stdout);
12758 flags ^= l_flags_vals[fcnt].bit;
12761 printf (" %#x", (unsigned int) flags);
12771 if (options_offset != 0)
12773 Elf_External_Options * eopt;
12774 Elf_Internal_Shdr * sect = section_headers;
12775 Elf_Internal_Options * iopt;
12776 Elf_Internal_Options * option;
12780 /* Find the section header so that we get the size. */
12781 while (sect->sh_type != SHT_MIPS_OPTIONS)
12784 eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
12785 sect->sh_size, _("options"));
12788 iopt = (Elf_Internal_Options *)
12789 cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
12792 error (_("Out of memory\n"));
12799 while (offset < sect->sh_size)
12801 Elf_External_Options * eoption;
12803 eoption = (Elf_External_Options *) ((char *) eopt + offset);
12805 option->kind = BYTE_GET (eoption->kind);
12806 option->size = BYTE_GET (eoption->size);
12807 option->section = BYTE_GET (eoption->section);
12808 option->info = BYTE_GET (eoption->info);
12810 offset += option->size;
12816 printf (_("\nSection '%s' contains %d entries:\n"),
12817 SECTION_NAME (sect), cnt);
12825 switch (option->kind)
12828 /* This shouldn't happen. */
12829 printf (" NULL %d %lx", option->section, option->info);
12832 printf (" REGINFO ");
12833 if (elf_header.e_machine == EM_MIPS)
12836 Elf32_External_RegInfo * ereg;
12837 Elf32_RegInfo reginfo;
12839 ereg = (Elf32_External_RegInfo *) (option + 1);
12840 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
12841 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
12842 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
12843 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
12844 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
12845 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
12847 printf ("GPR %08lx GP 0x%lx\n",
12848 reginfo.ri_gprmask,
12849 (unsigned long) reginfo.ri_gp_value);
12850 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
12851 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
12852 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
12857 Elf64_External_RegInfo * ereg;
12858 Elf64_Internal_RegInfo reginfo;
12860 ereg = (Elf64_External_RegInfo *) (option + 1);
12861 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
12862 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
12863 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
12864 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
12865 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
12866 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
12868 printf ("GPR %08lx GP 0x",
12869 reginfo.ri_gprmask);
12870 printf_vma (reginfo.ri_gp_value);
12873 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
12874 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
12875 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
12879 case ODK_EXCEPTIONS:
12880 fputs (" EXCEPTIONS fpe_min(", stdout);
12881 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
12882 fputs (") fpe_max(", stdout);
12883 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
12884 fputs (")", stdout);
12886 if (option->info & OEX_PAGE0)
12887 fputs (" PAGE0", stdout);
12888 if (option->info & OEX_SMM)
12889 fputs (" SMM", stdout);
12890 if (option->info & OEX_FPDBUG)
12891 fputs (" FPDBUG", stdout);
12892 if (option->info & OEX_DISMISS)
12893 fputs (" DISMISS", stdout);
12896 fputs (" PAD ", stdout);
12897 if (option->info & OPAD_PREFIX)
12898 fputs (" PREFIX", stdout);
12899 if (option->info & OPAD_POSTFIX)
12900 fputs (" POSTFIX", stdout);
12901 if (option->info & OPAD_SYMBOL)
12902 fputs (" SYMBOL", stdout);
12905 fputs (" HWPATCH ", stdout);
12906 if (option->info & OHW_R4KEOP)
12907 fputs (" R4KEOP", stdout);
12908 if (option->info & OHW_R8KPFETCH)
12909 fputs (" R8KPFETCH", stdout);
12910 if (option->info & OHW_R5KEOP)
12911 fputs (" R5KEOP", stdout);
12912 if (option->info & OHW_R5KCVTL)
12913 fputs (" R5KCVTL", stdout);
12916 fputs (" FILL ", stdout);
12917 /* XXX Print content of info word? */
12920 fputs (" TAGS ", stdout);
12921 /* XXX Print content of info word? */
12924 fputs (" HWAND ", stdout);
12925 if (option->info & OHWA0_R4KEOP_CHECKED)
12926 fputs (" R4KEOP_CHECKED", stdout);
12927 if (option->info & OHWA0_R4KEOP_CLEAN)
12928 fputs (" R4KEOP_CLEAN", stdout);
12931 fputs (" HWOR ", stdout);
12932 if (option->info & OHWA0_R4KEOP_CHECKED)
12933 fputs (" R4KEOP_CHECKED", stdout);
12934 if (option->info & OHWA0_R4KEOP_CLEAN)
12935 fputs (" R4KEOP_CLEAN", stdout);
12938 printf (" GP_GROUP %#06lx self-contained %#06lx",
12939 option->info & OGP_GROUP,
12940 (option->info & OGP_SELF) >> 16);
12943 printf (" IDENT %#06lx self-contained %#06lx",
12944 option->info & OGP_GROUP,
12945 (option->info & OGP_SELF) >> 16);
12948 /* This shouldn't happen. */
12949 printf (" %3d ??? %d %lx",
12950 option->kind, option->section, option->info);
12954 len = sizeof (* eopt);
12955 while (len < option->size)
12956 if (((char *) option)[len] >= ' '
12957 && ((char *) option)[len] < 0x7f)
12958 printf ("%c", ((char *) option)[len++]);
12960 printf ("\\%03o", ((char *) option)[len++]);
12962 fputs ("\n", stdout);
12970 if (conflicts_offset != 0 && conflictsno != 0)
12972 Elf32_Conflict * iconf;
12975 if (dynamic_symbols == NULL)
12977 error (_("conflict list found without a dynamic symbol table\n"));
12981 iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
12984 error (_("Out of memory\n"));
12990 Elf32_External_Conflict * econf32;
12992 econf32 = (Elf32_External_Conflict *)
12993 get_data (NULL, file, conflicts_offset, conflictsno,
12994 sizeof (* econf32), _("conflict"));
12998 for (cnt = 0; cnt < conflictsno; ++cnt)
12999 iconf[cnt] = BYTE_GET (econf32[cnt]);
13005 Elf64_External_Conflict * econf64;
13007 econf64 = (Elf64_External_Conflict *)
13008 get_data (NULL, file, conflicts_offset, conflictsno,
13009 sizeof (* econf64), _("conflict"));
13013 for (cnt = 0; cnt < conflictsno; ++cnt)
13014 iconf[cnt] = BYTE_GET (econf64[cnt]);
13019 printf (_("\nSection '.conflict' contains %lu entries:\n"),
13020 (unsigned long) conflictsno);
13021 puts (_(" Num: Index Value Name"));
13023 for (cnt = 0; cnt < conflictsno; ++cnt)
13025 Elf_Internal_Sym * psym = & dynamic_symbols[iconf[cnt]];
13027 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
13028 print_vma (psym->st_value, FULL_HEX);
13030 if (VALID_DYNAMIC_NAME (psym->st_name))
13031 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
13033 printf (_("<corrupt: %14ld>"), psym->st_name);
13040 if (pltgot != 0 && local_gotno != 0)
13042 bfd_vma ent, local_end, global_end;
13044 unsigned char * data;
13048 addr_size = (is_32bit_elf ? 4 : 8);
13049 local_end = pltgot + local_gotno * addr_size;
13050 global_end = local_end + (symtabno - gotsym) * addr_size;
13052 offset = offset_from_vma (file, pltgot, global_end - pltgot);
13053 data = (unsigned char *) get_data (NULL, file, offset,
13054 global_end - pltgot, 1,
13055 _("Global Offset Table data"));
13059 printf (_("\nPrimary GOT:\n"));
13060 printf (_(" Canonical gp value: "));
13061 print_vma (pltgot + 0x7ff0, LONG_HEX);
13064 printf (_(" Reserved entries:\n"));
13065 printf (_(" %*s %10s %*s Purpose\n"),
13066 addr_size * 2, _("Address"), _("Access"),
13067 addr_size * 2, _("Initial"));
13068 ent = print_mips_got_entry (data, pltgot, ent);
13069 printf (_(" Lazy resolver\n"));
13071 && (byte_get (data + ent - pltgot, addr_size)
13072 >> (addr_size * 8 - 1)) != 0)
13074 ent = print_mips_got_entry (data, pltgot, ent);
13075 printf (_(" Module pointer (GNU extension)\n"));
13079 if (ent < local_end)
13081 printf (_(" Local entries:\n"));
13082 printf (" %*s %10s %*s\n",
13083 addr_size * 2, _("Address"), _("Access"),
13084 addr_size * 2, _("Initial"));
13085 while (ent < local_end)
13087 ent = print_mips_got_entry (data, pltgot, ent);
13093 if (gotsym < symtabno)
13097 printf (_(" Global entries:\n"));
13098 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
13099 addr_size * 2, _("Address"),
13101 addr_size * 2, _("Initial"),
13102 addr_size * 2, _("Sym.Val."),
13104 /* Note for translators: "Ndx" = abbreviated form of "Index". */
13105 _("Ndx"), _("Name"));
13107 sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
13108 for (i = gotsym; i < symtabno; i++)
13110 Elf_Internal_Sym * psym;
13112 psym = dynamic_symbols + i;
13113 ent = print_mips_got_entry (data, pltgot, ent);
13115 print_vma (psym->st_value, LONG_HEX);
13116 printf (" %-7s %3s ",
13117 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
13118 get_symbol_index_type (psym->st_shndx));
13119 if (VALID_DYNAMIC_NAME (psym->st_name))
13120 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
13122 printf (_("<corrupt: %14ld>"), psym->st_name);
13132 if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
13135 size_t offset, rel_offset;
13136 unsigned long count, i;
13137 unsigned char * data;
13138 int addr_size, sym_width;
13139 Elf_Internal_Rela * rels;
13141 rel_offset = offset_from_vma (file, jmprel, pltrelsz);
13142 if (pltrel == DT_RELA)
13144 if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
13149 if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
13154 addr_size = (is_32bit_elf ? 4 : 8);
13155 end = mips_pltgot + (2 + count) * addr_size;
13157 offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
13158 data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
13159 1, _("Procedure Linkage Table data"));
13163 printf ("\nPLT GOT:\n\n");
13164 printf (_(" Reserved entries:\n"));
13165 printf (_(" %*s %*s Purpose\n"),
13166 addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
13167 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
13168 printf (_(" PLT lazy resolver\n"));
13169 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
13170 printf (_(" Module pointer\n"));
13173 printf (_(" Entries:\n"));
13174 printf (" %*s %*s %*s %-7s %3s %s\n",
13175 addr_size * 2, _("Address"),
13176 addr_size * 2, _("Initial"),
13177 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
13178 sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
13179 for (i = 0; i < count; i++)
13181 Elf_Internal_Sym * psym;
13183 psym = dynamic_symbols + get_reloc_symindex (rels[i].r_info);
13184 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
13186 print_vma (psym->st_value, LONG_HEX);
13187 printf (" %-7s %3s ",
13188 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
13189 get_symbol_index_type (psym->st_shndx));
13190 if (VALID_DYNAMIC_NAME (psym->st_name))
13191 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
13193 printf (_("<corrupt: %14ld>"), psym->st_name);
13207 process_nds32_specific (FILE * file)
13209 Elf_Internal_Shdr *sect = NULL;
13211 sect = find_section (".nds32_e_flags");
13214 unsigned int *flag;
13216 printf ("\nNDS32 elf flags section:\n");
13217 flag = get_data (NULL, file, sect->sh_offset, 1,
13218 sect->sh_size, _("NDS32 elf flags section"));
13220 switch ((*flag) & 0x3)
13223 printf ("(VEC_SIZE):\tNo entry.\n");
13226 printf ("(VEC_SIZE):\t4 bytes\n");
13229 printf ("(VEC_SIZE):\t16 bytes\n");
13232 printf ("(VEC_SIZE):\treserved\n");
13241 process_gnu_liblist (FILE * file)
13243 Elf_Internal_Shdr * section;
13244 Elf_Internal_Shdr * string_sec;
13245 Elf32_External_Lib * elib;
13247 size_t strtab_size;
13254 for (i = 0, section = section_headers;
13255 i < elf_header.e_shnum;
13258 switch (section->sh_type)
13260 case SHT_GNU_LIBLIST:
13261 if (section->sh_link >= elf_header.e_shnum)
13264 elib = (Elf32_External_Lib *)
13265 get_data (NULL, file, section->sh_offset, 1, section->sh_size,
13266 _("liblist section data"));
13270 string_sec = section_headers + section->sh_link;
13272 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
13273 string_sec->sh_size,
13274 _("liblist string table"));
13276 || section->sh_entsize != sizeof (Elf32_External_Lib))
13282 strtab_size = string_sec->sh_size;
13284 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
13285 SECTION_NAME (section),
13286 (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
13288 puts (_(" Library Time Stamp Checksum Version Flags"));
13290 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
13298 liblist.l_name = BYTE_GET (elib[cnt].l_name);
13299 atime = BYTE_GET (elib[cnt].l_time_stamp);
13300 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
13301 liblist.l_version = BYTE_GET (elib[cnt].l_version);
13302 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
13304 tmp = gmtime (&atime);
13305 snprintf (timebuf, sizeof (timebuf),
13306 "%04u-%02u-%02uT%02u:%02u:%02u",
13307 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
13308 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
13310 printf ("%3lu: ", (unsigned long) cnt);
13312 printf ("%-20s", liblist.l_name < strtab_size
13313 ? strtab + liblist.l_name : _("<corrupt>"));
13315 printf ("%-20.20s", liblist.l_name < strtab_size
13316 ? strtab + liblist.l_name : _("<corrupt>"));
13317 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
13318 liblist.l_version, liblist.l_flags);
13329 static const char *
13330 get_note_type (unsigned e_type)
13332 static char buff[64];
13334 if (elf_header.e_type == ET_CORE)
13338 return _("NT_AUXV (auxiliary vector)");
13340 return _("NT_PRSTATUS (prstatus structure)");
13342 return _("NT_FPREGSET (floating point registers)");
13344 return _("NT_PRPSINFO (prpsinfo structure)");
13345 case NT_TASKSTRUCT:
13346 return _("NT_TASKSTRUCT (task structure)");
13348 return _("NT_PRXFPREG (user_xfpregs structure)");
13350 return _("NT_PPC_VMX (ppc Altivec registers)");
13352 return _("NT_PPC_VSX (ppc VSX registers)");
13354 return _("NT_386_TLS (x86 TLS information)");
13355 case NT_386_IOPERM:
13356 return _("NT_386_IOPERM (x86 I/O permissions)");
13357 case NT_X86_XSTATE:
13358 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
13359 case NT_S390_HIGH_GPRS:
13360 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
13361 case NT_S390_TIMER:
13362 return _("NT_S390_TIMER (s390 timer register)");
13363 case NT_S390_TODCMP:
13364 return _("NT_S390_TODCMP (s390 TOD comparator register)");
13365 case NT_S390_TODPREG:
13366 return _("NT_S390_TODPREG (s390 TOD programmable register)");
13368 return _("NT_S390_CTRS (s390 control registers)");
13369 case NT_S390_PREFIX:
13370 return _("NT_S390_PREFIX (s390 prefix register)");
13371 case NT_S390_LAST_BREAK:
13372 return _("NT_S390_LAST_BREAK (s390 last breaking event address)");
13373 case NT_S390_SYSTEM_CALL:
13374 return _("NT_S390_SYSTEM_CALL (s390 system call restart data)");
13376 return _("NT_S390_TDB (s390 transaction diagnostic block)");
13378 return _("NT_ARM_VFP (arm VFP registers)");
13380 return _("NT_ARM_TLS (AArch TLS registers)");
13381 case NT_ARM_HW_BREAK:
13382 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
13383 case NT_ARM_HW_WATCH:
13384 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
13386 return _("NT_PSTATUS (pstatus structure)");
13388 return _("NT_FPREGS (floating point registers)");
13390 return _("NT_PSINFO (psinfo structure)");
13392 return _("NT_LWPSTATUS (lwpstatus_t structure)");
13394 return _("NT_LWPSINFO (lwpsinfo_t structure)");
13395 case NT_WIN32PSTATUS:
13396 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
13398 return _("NT_SIGINFO (siginfo_t data)");
13400 return _("NT_FILE (mapped files)");
13408 return _("NT_VERSION (version)");
13410 return _("NT_ARCH (architecture)");
13415 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
13420 print_core_note (Elf_Internal_Note *pnote)
13422 unsigned int addr_size = is_32bit_elf ? 4 : 8;
13423 bfd_vma count, page_size;
13424 unsigned char *descdata, *filenames, *descend;
13426 if (pnote->type != NT_FILE)
13432 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
13433 /* Still "successful". */
13438 if (pnote->descsz < 2 * addr_size)
13440 printf (_(" Malformed note - too short for header\n"));
13444 descdata = (unsigned char *) pnote->descdata;
13445 descend = descdata + pnote->descsz;
13447 if (descdata[pnote->descsz - 1] != '\0')
13449 printf (_(" Malformed note - does not end with \\0\n"));
13453 count = byte_get (descdata, addr_size);
13454 descdata += addr_size;
13456 page_size = byte_get (descdata, addr_size);
13457 descdata += addr_size;
13459 if (pnote->descsz < 2 * addr_size + count * 3 * addr_size)
13461 printf (_(" Malformed note - too short for supplied file count\n"));
13465 printf (_(" Page size: "));
13466 print_vma (page_size, DEC);
13469 printf (_(" %*s%*s%*s\n"),
13470 (int) (2 + 2 * addr_size), _("Start"),
13471 (int) (4 + 2 * addr_size), _("End"),
13472 (int) (4 + 2 * addr_size), _("Page Offset"));
13473 filenames = descdata + count * 3 * addr_size;
13474 while (--count > 0)
13476 bfd_vma start, end, file_ofs;
13478 if (filenames == descend)
13480 printf (_(" Malformed note - filenames end too early\n"));
13484 start = byte_get (descdata, addr_size);
13485 descdata += addr_size;
13486 end = byte_get (descdata, addr_size);
13487 descdata += addr_size;
13488 file_ofs = byte_get (descdata, addr_size);
13489 descdata += addr_size;
13492 print_vma (start, FULL_HEX);
13494 print_vma (end, FULL_HEX);
13496 print_vma (file_ofs, FULL_HEX);
13497 printf ("\n %s\n", filenames);
13499 filenames += 1 + strlen ((char *) filenames);
13505 static const char *
13506 get_gnu_elf_note_type (unsigned e_type)
13508 static char buff[64];
13512 case NT_GNU_ABI_TAG:
13513 return _("NT_GNU_ABI_TAG (ABI version tag)");
13515 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
13516 case NT_GNU_BUILD_ID:
13517 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
13518 case NT_GNU_GOLD_VERSION:
13519 return _("NT_GNU_GOLD_VERSION (gold version)");
13524 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
13529 print_gnu_note (Elf_Internal_Note *pnote)
13531 switch (pnote->type)
13533 case NT_GNU_BUILD_ID:
13537 printf (_(" Build ID: "));
13538 for (i = 0; i < pnote->descsz; ++i)
13539 printf ("%02x", pnote->descdata[i] & 0xff);
13544 case NT_GNU_ABI_TAG:
13546 unsigned long os, major, minor, subminor;
13547 const char *osname;
13549 os = byte_get ((unsigned char *) pnote->descdata, 4);
13550 major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
13551 minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
13552 subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
13556 case GNU_ABI_TAG_LINUX:
13559 case GNU_ABI_TAG_HURD:
13562 case GNU_ABI_TAG_SOLARIS:
13563 osname = "Solaris";
13565 case GNU_ABI_TAG_FREEBSD:
13566 osname = "FreeBSD";
13568 case GNU_ABI_TAG_NETBSD:
13572 osname = "Unknown";
13576 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname,
13577 major, minor, subminor);
13581 case NT_GNU_GOLD_VERSION:
13585 printf (_(" Version: "));
13586 for (i = 0; i < pnote->descsz && pnote->descdata[i] != '\0'; ++i)
13587 printf ("%c", pnote->descdata[i]);
13596 static const char *
13597 get_netbsd_elfcore_note_type (unsigned e_type)
13599 static char buff[64];
13601 if (e_type == NT_NETBSDCORE_PROCINFO)
13603 /* NetBSD core "procinfo" structure. */
13604 return _("NetBSD procinfo structure");
13607 /* As of Jan 2002 there are no other machine-independent notes
13608 defined for NetBSD core files. If the note type is less
13609 than the start of the machine-dependent note types, we don't
13612 if (e_type < NT_NETBSDCORE_FIRSTMACH)
13614 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
13618 switch (elf_header.e_machine)
13620 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
13621 and PT_GETFPREGS == mach+2. */
13626 case EM_SPARC32PLUS:
13630 case NT_NETBSDCORE_FIRSTMACH + 0:
13631 return _("PT_GETREGS (reg structure)");
13632 case NT_NETBSDCORE_FIRSTMACH + 2:
13633 return _("PT_GETFPREGS (fpreg structure)");
13639 /* On all other arch's, PT_GETREGS == mach+1 and
13640 PT_GETFPREGS == mach+3. */
13644 case NT_NETBSDCORE_FIRSTMACH + 1:
13645 return _("PT_GETREGS (reg structure)");
13646 case NT_NETBSDCORE_FIRSTMACH + 3:
13647 return _("PT_GETFPREGS (fpreg structure)");
13653 snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
13654 e_type - NT_NETBSDCORE_FIRSTMACH);
13658 static const char *
13659 get_stapsdt_note_type (unsigned e_type)
13661 static char buff[64];
13666 return _("NT_STAPSDT (SystemTap probe descriptors)");
13672 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
13677 print_stapsdt_note (Elf_Internal_Note *pnote)
13679 int addr_size = is_32bit_elf ? 4 : 8;
13680 char *data = pnote->descdata;
13681 char *data_end = pnote->descdata + pnote->descsz;
13682 bfd_vma pc, base_addr, semaphore;
13683 char *provider, *probe, *arg_fmt;
13685 pc = byte_get ((unsigned char *) data, addr_size);
13687 base_addr = byte_get ((unsigned char *) data, addr_size);
13689 semaphore = byte_get ((unsigned char *) data, addr_size);
13693 data += strlen (data) + 1;
13695 data += strlen (data) + 1;
13697 data += strlen (data) + 1;
13699 printf (_(" Provider: %s\n"), provider);
13700 printf (_(" Name: %s\n"), probe);
13701 printf (_(" Location: "));
13702 print_vma (pc, FULL_HEX);
13703 printf (_(", Base: "));
13704 print_vma (base_addr, FULL_HEX);
13705 printf (_(", Semaphore: "));
13706 print_vma (semaphore, FULL_HEX);
13708 printf (_(" Arguments: %s\n"), arg_fmt);
13710 return data == data_end;
13713 static const char *
13714 get_ia64_vms_note_type (unsigned e_type)
13716 static char buff[64];
13721 return _("NT_VMS_MHD (module header)");
13723 return _("NT_VMS_LNM (language name)");
13725 return _("NT_VMS_SRC (source files)");
13727 return "NT_VMS_TITLE";
13729 return _("NT_VMS_EIDC (consistency check)");
13730 case NT_VMS_FPMODE:
13731 return _("NT_VMS_FPMODE (FP mode)");
13732 case NT_VMS_LINKTIME:
13733 return "NT_VMS_LINKTIME";
13734 case NT_VMS_IMGNAM:
13735 return _("NT_VMS_IMGNAM (image name)");
13737 return _("NT_VMS_IMGID (image id)");
13738 case NT_VMS_LINKID:
13739 return _("NT_VMS_LINKID (link id)");
13740 case NT_VMS_IMGBID:
13741 return _("NT_VMS_IMGBID (build id)");
13742 case NT_VMS_GSTNAM:
13743 return _("NT_VMS_GSTNAM (sym table name)");
13744 case NT_VMS_ORIG_DYN:
13745 return "NT_VMS_ORIG_DYN";
13746 case NT_VMS_PATCHTIME:
13747 return "NT_VMS_PATCHTIME";
13749 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
13755 print_ia64_vms_note (Elf_Internal_Note * pnote)
13757 switch (pnote->type)
13760 if (pnote->descsz > 36)
13762 size_t l = strlen (pnote->descdata + 34);
13763 printf (_(" Creation date : %.17s\n"), pnote->descdata);
13764 printf (_(" Last patch date: %.17s\n"), pnote->descdata + 17);
13765 printf (_(" Module name : %s\n"), pnote->descdata + 34);
13766 printf (_(" Module version : %s\n"), pnote->descdata + 34 + l + 1);
13769 printf (_(" Invalid size\n"));
13772 printf (_(" Language: %s\n"), pnote->descdata);
13775 case NT_VMS_FPMODE:
13776 printf (_(" Floating Point mode: "));
13777 printf ("0x%016" BFD_VMA_FMT "x\n",
13778 (bfd_vma)byte_get ((unsigned char *)pnote->descdata, 8));
13780 case NT_VMS_LINKTIME:
13781 printf (_(" Link time: "));
13783 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
13786 case NT_VMS_PATCHTIME:
13787 printf (_(" Patch time: "));
13789 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
13792 case NT_VMS_ORIG_DYN:
13793 printf (_(" Major id: %u, minor id: %u\n"),
13794 (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
13795 (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
13796 printf (_(" Last modified : "));
13798 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
13799 printf (_("\n Link flags : "));
13800 printf ("0x%016" BFD_VMA_FMT "x\n",
13801 (bfd_vma)byte_get ((unsigned char *)pnote->descdata + 16, 8));
13802 printf (_(" Header flags: 0x%08x\n"),
13803 (unsigned)byte_get ((unsigned char *)pnote->descdata + 24, 4));
13804 printf (_(" Image id : %s\n"), pnote->descdata + 32);
13807 case NT_VMS_IMGNAM:
13808 printf (_(" Image name: %s\n"), pnote->descdata);
13810 case NT_VMS_GSTNAM:
13811 printf (_(" Global symbol table name: %s\n"), pnote->descdata);
13814 printf (_(" Image id: %s\n"), pnote->descdata);
13816 case NT_VMS_LINKID:
13817 printf (_(" Linker id: %s\n"), pnote->descdata);
13825 /* Note that by the ELF standard, the name field is already null byte
13826 terminated, and namesz includes the terminating null byte.
13827 I.E. the value of namesz for the name "FSF" is 4.
13829 If the value of namesz is zero, there is no name present. */
13831 process_note (Elf_Internal_Note * pnote)
13833 const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
13836 if (pnote->namesz == 0)
13837 /* If there is no note name, then use the default set of
13838 note type strings. */
13839 nt = get_note_type (pnote->type);
13841 else if (const_strneq (pnote->namedata, "GNU"))
13842 /* GNU-specific object file notes. */
13843 nt = get_gnu_elf_note_type (pnote->type);
13845 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
13846 /* NetBSD-specific core file notes. */
13847 nt = get_netbsd_elfcore_note_type (pnote->type);
13849 else if (strneq (pnote->namedata, "SPU/", 4))
13851 /* SPU-specific core file notes. */
13852 nt = pnote->namedata + 4;
13856 else if (const_strneq (pnote->namedata, "IPF/VMS"))
13857 /* VMS/ia64-specific file notes. */
13858 nt = get_ia64_vms_note_type (pnote->type);
13860 else if (const_strneq (pnote->namedata, "stapsdt"))
13861 nt = get_stapsdt_note_type (pnote->type);
13864 /* Don't recognize this note name; just use the default set of
13865 note type strings. */
13866 nt = get_note_type (pnote->type);
13868 printf (" %-20s 0x%08lx\t%s\n", name, pnote->descsz, nt);
13870 if (const_strneq (pnote->namedata, "IPF/VMS"))
13871 return print_ia64_vms_note (pnote);
13872 else if (const_strneq (pnote->namedata, "GNU"))
13873 return print_gnu_note (pnote);
13874 else if (const_strneq (pnote->namedata, "stapsdt"))
13875 return print_stapsdt_note (pnote);
13876 else if (const_strneq (pnote->namedata, "CORE"))
13877 return print_core_note (pnote);
13884 process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
13886 Elf_External_Note * pnotes;
13887 Elf_External_Note * external;
13893 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
13895 if (pnotes == NULL)
13900 printf (_("\nDisplaying notes found at file offset 0x%08lx with length 0x%08lx:\n"),
13901 (unsigned long) offset, (unsigned long) length);
13902 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
13904 while ((char *) external < (char *) pnotes + length)
13906 Elf_Internal_Note inote;
13909 char * temp = NULL;
13910 size_t data_remaining = ((char *) pnotes + length) - (char *) external;
13912 if (!is_ia64_vms ())
13914 /* PR binutils/15191
13915 Make sure that there is enough data to read. */
13916 min_notesz = offsetof (Elf_External_Note, name);
13917 if (data_remaining < min_notesz)
13919 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
13920 (int) data_remaining);
13923 inote.type = BYTE_GET (external->type);
13924 inote.namesz = BYTE_GET (external->namesz);
13925 inote.namedata = external->name;
13926 inote.descsz = BYTE_GET (external->descsz);
13927 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
13928 inote.descpos = offset + (inote.descdata - (char *) pnotes);
13929 next = inote.descdata + align_power (inote.descsz, 2);
13933 Elf64_External_VMS_Note *vms_external;
13935 /* PR binutils/15191
13936 Make sure that there is enough data to read. */
13937 min_notesz = offsetof (Elf64_External_VMS_Note, name);
13938 if (data_remaining < min_notesz)
13940 warn (_("Corrupt note: only %d bytes remain, not enough for a full note\n"),
13941 (int) data_remaining);
13945 vms_external = (Elf64_External_VMS_Note *) external;
13946 inote.type = BYTE_GET (vms_external->type);
13947 inote.namesz = BYTE_GET (vms_external->namesz);
13948 inote.namedata = vms_external->name;
13949 inote.descsz = BYTE_GET (vms_external->descsz);
13950 inote.descdata = inote.namedata + align_power (inote.namesz, 3);
13951 inote.descpos = offset + (inote.descdata - (char *) pnotes);
13952 next = inote.descdata + align_power (inote.descsz, 3);
13955 if (inote.descdata < (char *) external + min_notesz
13956 || next < (char *) external + min_notesz
13957 || data_remaining < (size_t)(next - (char *) external))
13959 warn (_("note with invalid namesz and/or descsz found at offset 0x%lx\n"),
13960 (unsigned long) ((char *) external - (char *) pnotes));
13961 warn (_(" type: 0x%lx, namesize: 0x%08lx, descsize: 0x%08lx\n"),
13962 inote.type, inote.namesz, inote.descsz);
13966 external = (Elf_External_Note *) next;
13968 /* Verify that name is null terminated. It appears that at least
13969 one version of Linux (RedHat 6.0) generates corefiles that don't
13970 comply with the ELF spec by failing to include the null byte in
13972 if (inote.namedata[inote.namesz - 1] != '\0')
13974 temp = (char *) malloc (inote.namesz + 1);
13978 error (_("Out of memory\n"));
13983 strncpy (temp, inote.namedata, inote.namesz);
13984 temp[inote.namesz] = 0;
13986 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
13987 inote.namedata = temp;
13990 res &= process_note (& inote);
14005 process_corefile_note_segments (FILE * file)
14007 Elf_Internal_Phdr * segment;
14011 if (! get_program_headers (file))
14014 for (i = 0, segment = program_headers;
14015 i < elf_header.e_phnum;
14018 if (segment->p_type == PT_NOTE)
14019 res &= process_corefile_note_segment (file,
14020 (bfd_vma) segment->p_offset,
14021 (bfd_vma) segment->p_filesz);
14028 process_note_sections (FILE * file)
14030 Elf_Internal_Shdr * section;
14034 for (i = 0, section = section_headers;
14035 i < elf_header.e_shnum && section != NULL;
14037 if (section->sh_type == SHT_NOTE)
14038 res &= process_corefile_note_segment (file,
14039 (bfd_vma) section->sh_offset,
14040 (bfd_vma) section->sh_size);
14046 process_notes (FILE * file)
14048 /* If we have not been asked to display the notes then do nothing. */
14052 if (elf_header.e_type != ET_CORE)
14053 return process_note_sections (file);
14055 /* No program headers means no NOTE segment. */
14056 if (elf_header.e_phnum > 0)
14057 return process_corefile_note_segments (file);
14059 printf (_("No note segments present in the core file.\n"));
14064 process_arch_specific (FILE * file)
14069 switch (elf_header.e_machine)
14072 return process_arm_specific (file);
14074 case EM_MIPS_RS3_LE:
14075 return process_mips_specific (file);
14078 return process_nds32_specific (file);
14081 return process_power_specific (file);
14084 case EM_SPARC32PLUS:
14086 return process_sparc_specific (file);
14089 return process_tic6x_specific (file);
14092 return process_msp430x_specific (file);
14100 get_file_header (FILE * file)
14102 /* Read in the identity array. */
14103 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
14106 /* Determine how to read the rest of the header. */
14107 switch (elf_header.e_ident[EI_DATA])
14109 default: /* fall through */
14110 case ELFDATANONE: /* fall through */
14112 byte_get = byte_get_little_endian;
14113 byte_put = byte_put_little_endian;
14116 byte_get = byte_get_big_endian;
14117 byte_put = byte_put_big_endian;
14121 /* For now we only support 32 bit and 64 bit ELF files. */
14122 is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
14124 /* Read in the rest of the header. */
14127 Elf32_External_Ehdr ehdr32;
14129 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
14132 elf_header.e_type = BYTE_GET (ehdr32.e_type);
14133 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
14134 elf_header.e_version = BYTE_GET (ehdr32.e_version);
14135 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
14136 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
14137 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
14138 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
14139 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
14140 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
14141 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
14142 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
14143 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
14144 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
14148 Elf64_External_Ehdr ehdr64;
14150 /* If we have been compiled with sizeof (bfd_vma) == 4, then
14151 we will not be able to cope with the 64bit data found in
14152 64 ELF files. Detect this now and abort before we start
14153 overwriting things. */
14154 if (sizeof (bfd_vma) < 8)
14156 error (_("This instance of readelf has been built without support for a\n\
14157 64 bit data type and so it cannot read 64 bit ELF files.\n"));
14161 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
14164 elf_header.e_type = BYTE_GET (ehdr64.e_type);
14165 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
14166 elf_header.e_version = BYTE_GET (ehdr64.e_version);
14167 elf_header.e_entry = BYTE_GET (ehdr64.e_entry);
14168 elf_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
14169 elf_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
14170 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
14171 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
14172 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
14173 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
14174 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
14175 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
14176 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
14179 if (elf_header.e_shoff)
14181 /* There may be some extensions in the first section header. Don't
14182 bomb if we can't read it. */
14184 get_32bit_section_headers (file, 1);
14186 get_64bit_section_headers (file, 1);
14192 /* Process one ELF object file according to the command line options.
14193 This file may actually be stored in an archive. The file is
14194 positioned at the start of the ELF object. */
14197 process_object (char * file_name, FILE * file)
14201 if (! get_file_header (file))
14203 error (_("%s: Failed to read file header\n"), file_name);
14207 /* Initialise per file variables. */
14208 for (i = ARRAY_SIZE (version_info); i--;)
14209 version_info[i] = 0;
14211 for (i = ARRAY_SIZE (dynamic_info); i--;)
14212 dynamic_info[i] = 0;
14213 dynamic_info_DT_GNU_HASH = 0;
14215 /* Process the file. */
14217 printf (_("\nFile: %s\n"), file_name);
14219 /* Initialise the dump_sects array from the cmdline_dump_sects array.
14220 Note we do this even if cmdline_dump_sects is empty because we
14221 must make sure that the dump_sets array is zeroed out before each
14222 object file is processed. */
14223 if (num_dump_sects > num_cmdline_dump_sects)
14224 memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
14226 if (num_cmdline_dump_sects > 0)
14228 if (num_dump_sects == 0)
14229 /* A sneaky way of allocating the dump_sects array. */
14230 request_dump_bynumber (num_cmdline_dump_sects, 0);
14232 assert (num_dump_sects >= num_cmdline_dump_sects);
14233 memcpy (dump_sects, cmdline_dump_sects,
14234 num_cmdline_dump_sects * sizeof (* dump_sects));
14237 if (! process_file_header ())
14240 if (! process_section_headers (file))
14242 /* Without loaded section headers we cannot process lots of
14244 do_unwind = do_version = do_dump = do_arch = 0;
14246 if (! do_using_dynamic)
14247 do_syms = do_dyn_syms = do_reloc = 0;
14250 if (! process_section_groups (file))
14252 /* Without loaded section groups we cannot process unwind. */
14256 if (process_program_headers (file))
14257 process_dynamic_section (file);
14259 process_relocs (file);
14261 process_unwind (file);
14263 process_symbol_table (file);
14265 process_syminfo (file);
14267 process_version_sections (file);
14269 process_section_contents (file);
14271 process_notes (file);
14273 process_gnu_liblist (file);
14275 process_arch_specific (file);
14277 if (program_headers)
14279 free (program_headers);
14280 program_headers = NULL;
14283 if (section_headers)
14285 free (section_headers);
14286 section_headers = NULL;
14291 free (string_table);
14292 string_table = NULL;
14293 string_table_length = 0;
14296 if (dynamic_strings)
14298 free (dynamic_strings);
14299 dynamic_strings = NULL;
14300 dynamic_strings_length = 0;
14303 if (dynamic_symbols)
14305 free (dynamic_symbols);
14306 dynamic_symbols = NULL;
14307 num_dynamic_syms = 0;
14310 if (dynamic_syminfo)
14312 free (dynamic_syminfo);
14313 dynamic_syminfo = NULL;
14316 if (dynamic_section)
14318 free (dynamic_section);
14319 dynamic_section = NULL;
14322 if (section_headers_groups)
14324 free (section_headers_groups);
14325 section_headers_groups = NULL;
14328 if (section_groups)
14330 struct group_list * g;
14331 struct group_list * next;
14333 for (i = 0; i < group_count; i++)
14335 for (g = section_groups [i].root; g != NULL; g = next)
14342 free (section_groups);
14343 section_groups = NULL;
14346 free_debug_memory ();
14351 /* Process an ELF archive.
14352 On entry the file is positioned just after the ARMAG string. */
14355 process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
14357 struct archive_info arch;
14358 struct archive_info nested_arch;
14364 /* The ARCH structure is used to hold information about this archive. */
14365 arch.file_name = NULL;
14367 arch.index_array = NULL;
14368 arch.sym_table = NULL;
14369 arch.longnames = NULL;
14371 /* The NESTED_ARCH structure is used as a single-item cache of information
14372 about a nested archive (when members of a thin archive reside within
14373 another regular archive file). */
14374 nested_arch.file_name = NULL;
14375 nested_arch.file = NULL;
14376 nested_arch.index_array = NULL;
14377 nested_arch.sym_table = NULL;
14378 nested_arch.longnames = NULL;
14380 if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
14386 if (do_archive_index)
14388 if (arch.sym_table == NULL)
14389 error (_("%s: unable to dump the index as none was found\n"), file_name);
14393 unsigned long current_pos;
14395 printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
14396 file_name, (long) arch.index_num, arch.sym_size);
14397 current_pos = ftell (file);
14399 for (i = l = 0; i < arch.index_num; i++)
14401 if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
14403 char * member_name;
14405 member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
14407 if (member_name != NULL)
14409 char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
14411 if (qualified_name != NULL)
14413 printf (_("Contents of binary %s at offset "), qualified_name);
14414 (void) print_vma (arch.index_array[i], PREFIX_HEX);
14416 free (qualified_name);
14421 if (l >= arch.sym_size)
14423 error (_("%s: end of the symbol table reached before the end of the index\n"),
14427 printf ("\t%s\n", arch.sym_table + l);
14428 l += strlen (arch.sym_table + l) + 1;
14431 if (arch.uses_64bit_indicies)
14436 if (l < arch.sym_size)
14437 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
14438 file_name, arch.sym_size - l);
14440 if (fseek (file, current_pos, SEEK_SET) != 0)
14442 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
14448 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
14449 && !do_segments && !do_header && !do_dump && !do_version
14450 && !do_histogram && !do_debugging && !do_arch && !do_notes
14451 && !do_section_groups && !do_dyn_syms)
14453 ret = 0; /* Archive index only. */
14464 char * qualified_name;
14466 /* Read the next archive header. */
14467 if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
14469 error (_("%s: failed to seek to next archive header\n"), file_name);
14472 got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
14473 if (got != sizeof arch.arhdr)
14477 error (_("%s: failed to read archive header\n"), file_name);
14481 if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
14483 error (_("%s: did not find a valid archive header\n"), arch.file_name);
14488 arch.next_arhdr_offset += sizeof arch.arhdr;
14490 archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
14491 if (archive_file_size & 01)
14492 ++archive_file_size;
14494 name = get_archive_member_name (&arch, &nested_arch);
14497 error (_("%s: bad archive file name\n"), file_name);
14501 namelen = strlen (name);
14503 qualified_name = make_qualified_name (&arch, &nested_arch, name);
14504 if (qualified_name == NULL)
14506 error (_("%s: bad archive file name\n"), file_name);
14511 if (is_thin_archive && arch.nested_member_origin == 0)
14513 /* This is a proxy for an external member of a thin archive. */
14514 FILE * member_file;
14515 char * member_file_name = adjust_relative_path (file_name, name, namelen);
14516 if (member_file_name == NULL)
14522 member_file = fopen (member_file_name, "rb");
14523 if (member_file == NULL)
14525 error (_("Input file '%s' is not readable.\n"), member_file_name);
14526 free (member_file_name);
14531 archive_file_offset = arch.nested_member_origin;
14533 ret |= process_object (qualified_name, member_file);
14535 fclose (member_file);
14536 free (member_file_name);
14538 else if (is_thin_archive)
14540 /* PR 15140: Allow for corrupt thin archives. */
14541 if (nested_arch.file == NULL)
14543 error (_("%s: contains corrupt thin archive: %s\n"),
14549 /* This is a proxy for a member of a nested archive. */
14550 archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
14552 /* The nested archive file will have been opened and setup by
14553 get_archive_member_name. */
14554 if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
14556 error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
14561 ret |= process_object (qualified_name, nested_arch.file);
14565 archive_file_offset = arch.next_arhdr_offset;
14566 arch.next_arhdr_offset += archive_file_size;
14568 ret |= process_object (qualified_name, file);
14571 if (dump_sects != NULL)
14575 num_dump_sects = 0;
14578 free (qualified_name);
14582 if (nested_arch.file != NULL)
14583 fclose (nested_arch.file);
14584 release_archive (&nested_arch);
14585 release_archive (&arch);
14591 process_file (char * file_name)
14594 struct stat statbuf;
14595 char armag[SARMAG];
14598 if (stat (file_name, &statbuf) < 0)
14600 if (errno == ENOENT)
14601 error (_("'%s': No such file\n"), file_name);
14603 error (_("Could not locate '%s'. System error message: %s\n"),
14604 file_name, strerror (errno));
14608 if (! S_ISREG (statbuf.st_mode))
14610 error (_("'%s' is not an ordinary file\n"), file_name);
14614 file = fopen (file_name, "rb");
14617 error (_("Input file '%s' is not readable.\n"), file_name);
14621 if (fread (armag, SARMAG, 1, file) != 1)
14623 error (_("%s: Failed to read file's magic number\n"), file_name);
14628 if (memcmp (armag, ARMAG, SARMAG) == 0)
14629 ret = process_archive (file_name, file, FALSE);
14630 else if (memcmp (armag, ARMAGT, SARMAG) == 0)
14631 ret = process_archive (file_name, file, TRUE);
14634 if (do_archive_index)
14635 error (_("File %s is not an archive so its index cannot be displayed.\n"),
14639 archive_file_size = archive_file_offset = 0;
14640 ret = process_object (file_name, file);
14648 #ifdef SUPPORT_DISASSEMBLY
14649 /* Needed by the i386 disassembler. For extra credit, someone could
14650 fix this so that we insert symbolic addresses here, esp for GOT/PLT
14654 print_address (unsigned int addr, FILE * outfile)
14656 fprintf (outfile,"0x%8.8x", addr);
14659 /* Needed by the i386 disassembler. */
14661 db_task_printsym (unsigned int addr)
14663 print_address (addr, stderr);
14668 main (int argc, char ** argv)
14672 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
14673 setlocale (LC_MESSAGES, "");
14675 #if defined (HAVE_SETLOCALE)
14676 setlocale (LC_CTYPE, "");
14678 bindtextdomain (PACKAGE, LOCALEDIR);
14679 textdomain (PACKAGE);
14681 expandargv (&argc, &argv);
14683 parse_args (argc, argv);
14685 if (num_dump_sects > 0)
14687 /* Make a copy of the dump_sects array. */
14688 cmdline_dump_sects = (dump_type *)
14689 malloc (num_dump_sects * sizeof (* dump_sects));
14690 if (cmdline_dump_sects == NULL)
14691 error (_("Out of memory allocating dump request table.\n"));
14694 memcpy (cmdline_dump_sects, dump_sects,
14695 num_dump_sects * sizeof (* dump_sects));
14696 num_cmdline_dump_sects = num_dump_sects;
14700 if (optind < (argc - 1))
14704 while (optind < argc)
14705 err |= process_file (argv[optind++]);
14707 if (dump_sects != NULL)
14709 if (cmdline_dump_sects != NULL)
14710 free (cmdline_dump_sects);