1 /* readelf.c -- display contents of an ELF format file
2 Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
4 Free Software Foundation, Inc.
6 Originally developed by Eric Youngdale <eric@andante.jic.com>
7 Modifications by Nick Clifton <nickc@redhat.com>
9 This file is part of GNU Binutils.
11 This program is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 3 of the License, or
14 (at your option) any later version.
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
21 You should have received a copy of the GNU General Public License
22 along with this program; if not, write to the Free Software
23 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
26 /* The difference between readelf and objdump:
28 Both programs are capable of displaying the contents of ELF format files,
29 so why does the binutils project have two file dumpers ?
31 The reason is that objdump sees an ELF file through a BFD filter of the
32 world; if BFD has a bug where, say, it disagrees about a machine constant
33 in e_flags, then the odds are good that it will remain internally
34 consistent. The linker sees it the BFD way, objdump sees it the BFD way,
35 GAS sees it the BFD way. There was need for a tool to go find out what
36 the file actually says.
38 This is why the readelf program does not link against the BFD library - it
39 exists as an independent program to help verify the correct working of BFD.
41 There is also the case that readelf can provide more information about an
42 ELF file than is provided by objdump. In particular it can display DWARF
43 debugging information which (at the moment) objdump cannot. */
55 /* Define BFD64 here, even if our default architecture is 32 bit ELF
56 as this will allow us to read in and parse 64bit and 32bit ELF files.
57 Only do this if we believe that the compiler can support a 64 bit
58 data type. For now we only rely on GCC being able to do this. */
67 #include "elf/common.h"
68 #include "elf/external.h"
69 #include "elf/internal.h"
72 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
73 we can obtain the H8 reloc numbers. We need these for the
74 get_reloc_size() function. We include h8.h again after defining
75 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
80 /* Undo the effects of #including reloc-macros.h. */
82 #undef START_RELOC_NUMBERS
86 #undef END_RELOC_NUMBERS
87 #undef _RELOC_MACROS_H
89 /* The following headers use the elf/reloc-macros.h file to
90 automatically generate relocation recognition functions
91 such as elf_mips_reloc_type() */
93 #define RELOC_MACROS_GEN_FUNC
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/fr30.h"
109 #include "elf/hppa.h"
110 #include "elf/i386.h"
111 #include "elf/i370.h"
112 #include "elf/i860.h"
113 #include "elf/i960.h"
114 #include "elf/ia64.h"
115 #include "elf/ip2k.h"
116 #include "elf/lm32.h"
117 #include "elf/iq2000.h"
118 #include "elf/m32c.h"
119 #include "elf/m32r.h"
120 #include "elf/m68k.h"
121 #include "elf/m68hc11.h"
122 #include "elf/mcore.h"
124 #include "elf/microblaze.h"
125 #include "elf/mips.h"
126 #include "elf/mmix.h"
127 #include "elf/mn10200.h"
128 #include "elf/mn10300.h"
129 #include "elf/moxie.h"
131 #include "elf/msp430.h"
132 #include "elf/or32.h"
135 #include "elf/ppc64.h"
137 #include "elf/s390.h"
138 #include "elf/score.h"
140 #include "elf/sparc.h"
142 #include "elf/tic6x.h"
143 #include "elf/v850.h"
145 #include "elf/x86-64.h"
146 #include "elf/xc16x.h"
147 #include "elf/xstormy16.h"
148 #include "elf/xtensa.h"
151 #include "libiberty.h"
152 #include "safe-ctype.h"
153 #include "filenames.h"
155 char * program_name = "readelf";
156 static long archive_file_offset;
157 static unsigned long archive_file_size;
158 static unsigned long dynamic_addr;
159 static bfd_size_type dynamic_size;
160 static unsigned int dynamic_nent;
161 static char * dynamic_strings;
162 static unsigned long dynamic_strings_length;
163 static char * string_table;
164 static unsigned long string_table_length;
165 static unsigned long num_dynamic_syms;
166 static Elf_Internal_Sym * dynamic_symbols;
167 static Elf_Internal_Syminfo * dynamic_syminfo;
168 static unsigned long dynamic_syminfo_offset;
169 static unsigned int dynamic_syminfo_nent;
170 static char program_interpreter[PATH_MAX];
171 static bfd_vma dynamic_info[DT_ENCODING];
172 static bfd_vma dynamic_info_DT_GNU_HASH;
173 static bfd_vma version_info[16];
174 static Elf_Internal_Ehdr elf_header;
175 static Elf_Internal_Shdr * section_headers;
176 static Elf_Internal_Phdr * program_headers;
177 static Elf_Internal_Dyn * dynamic_section;
178 static Elf_Internal_Shdr * symtab_shndx_hdr;
179 static int show_name;
180 static int do_dynamic;
182 static int do_dyn_syms;
184 static int do_sections;
185 static int do_section_groups;
186 static int do_section_details;
187 static int do_segments;
188 static int do_unwind;
189 static int do_using_dynamic;
190 static int do_header;
192 static int do_version;
193 static int do_histogram;
194 static int do_debugging;
197 static int do_archive_index;
198 static int is_32bit_elf;
202 struct group_list * next;
203 unsigned int section_index;
208 struct group_list * root;
209 unsigned int group_index;
212 static size_t group_count;
213 static struct group * section_groups;
214 static struct group ** section_headers_groups;
217 /* Flag bits indicating particular types of dump. */
218 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
219 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
220 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
221 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
222 #define RELOC_DUMP (1 << 4) /* The -R command line switch. */
224 typedef unsigned char dump_type;
226 /* A linked list of the section names for which dumps were requested. */
227 struct dump_list_entry
231 struct dump_list_entry * next;
233 static struct dump_list_entry * dump_sects_byname;
235 /* A dynamic array of flags indicating for which sections a dump
236 has been requested via command line switches. */
237 static dump_type * cmdline_dump_sects = NULL;
238 static unsigned int num_cmdline_dump_sects = 0;
240 /* A dynamic array of flags indicating for which sections a dump of
241 some kind has been requested. It is reset on a per-object file
242 basis and then initialised from the cmdline_dump_sects array,
243 the results of interpreting the -w switch, and the
244 dump_sects_byname list. */
245 static dump_type * dump_sects = NULL;
246 static unsigned int num_dump_sects = 0;
249 /* How to print a vma value. */
250 typedef enum print_mode
264 #define SECTION_NAME(X) \
265 ((X) == NULL ? _("<none>") \
266 : string_table == NULL ? _("<no-name>") \
267 : ((X)->sh_name >= string_table_length ? _("<corrupt>") \
268 : string_table + (X)->sh_name))
270 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
272 #define GET_ELF_SYMBOLS(file, section) \
273 (is_32bit_elf ? get_32bit_elf_symbols (file, section) \
274 : get_64bit_elf_symbols (file, section))
276 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
277 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
278 already been called and verified that the string exists. */
279 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
281 #define REMOVE_ARCH_BITS(ADDR) \
284 if (elf_header.e_machine == EM_ARM) \
290 get_data (void * var, FILE * file, long offset, size_t size, size_t nmemb,
295 if (size == 0 || nmemb == 0)
298 if (fseek (file, archive_file_offset + offset, SEEK_SET))
300 error (_("Unable to seek to 0x%lx for %s\n"),
301 (unsigned long) archive_file_offset + offset, reason);
308 /* Check for overflow. */
309 if (nmemb < (~(size_t) 0 - 1) / size)
310 /* + 1 so that we can '\0' terminate invalid string table sections. */
311 mvar = malloc (size * nmemb + 1);
315 error (_("Out of memory allocating 0x%lx bytes for %s\n"),
316 (unsigned long)(size * nmemb), reason);
320 ((char *) mvar)[size * nmemb] = '\0';
323 if (fread (mvar, size, nmemb, file) != nmemb)
325 error (_("Unable to read in 0x%lx bytes of %s\n"),
326 (unsigned long)(size * nmemb), reason);
335 /* Print a VMA value. */
338 print_vma (bfd_vma vma, print_mode mode)
351 return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
358 return printf ("%5" BFD_VMA_FMT "d", vma);
366 return nc + printf ("%" BFD_VMA_FMT "x", vma);
369 return printf ("%" BFD_VMA_FMT "d", vma);
372 return printf ("%" BFD_VMA_FMT "u", vma);
377 /* Display a symbol on stdout. Handles the display of non-printing characters.
379 If DO_WIDE is not true then format the symbol to be at most WIDTH characters,
380 truncating as necessary. If WIDTH is negative then format the string to be
381 exactly - WIDTH characters, truncating or padding as necessary.
383 Returns the number of emitted characters. */
386 print_symbol (int width, const char *symbol)
389 bfd_boolean extra_padding = FALSE;
390 unsigned int num_printed = 0;
394 /* Set the width to a very large value. This simplifies the
400 /* Keep the width positive. This also helps. */
402 extra_padding = TRUE;
411 /* Look for non-printing symbols inside the symbol's name.
412 This test is triggered in particular by the names generated
413 by the assembler for local labels. */
424 printf ("%.*s", len, symbol);
430 if (*c == 0 || width == 0)
433 /* Now display the non-printing character, if
434 there is room left in which to dipslay it. */
435 if ((unsigned char) *c < 32)
440 printf ("^%c", *c + 0x40);
450 printf ("<0x%.2x>", (unsigned char) *c);
459 if (extra_padding && width > 0)
461 /* Fill in the remaining spaces. */
462 printf ("%-*s", width, " ");
469 /* Return a pointer to section NAME, or NULL if no such section exists. */
471 static Elf_Internal_Shdr *
472 find_section (const char * name)
476 for (i = 0; i < elf_header.e_shnum; i++)
477 if (streq (SECTION_NAME (section_headers + i), name))
478 return section_headers + i;
483 /* Return a pointer to a section containing ADDR, or NULL if no such
486 static Elf_Internal_Shdr *
487 find_section_by_address (bfd_vma addr)
491 for (i = 0; i < elf_header.e_shnum; i++)
493 Elf_Internal_Shdr *sec = section_headers + i;
494 if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
501 /* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
505 read_uleb128 (unsigned char *data, unsigned int *length_return)
507 return read_leb128 (data, length_return, 0);
510 /* Return true if the current file is for IA-64 machine and OpenVMS ABI.
511 This OS has so many departures from the ELF standard that we test it at
517 return elf_header.e_machine == EM_IA_64
518 && elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
521 /* Guess the relocation size commonly used by the specific machines. */
524 guess_is_rela (unsigned int e_machine)
528 /* Targets that use REL relocations. */
544 /* Targets that use RELA relocations. */
548 case EM_ALTERA_NIOS2:
568 case EM_LATTICEMICO32:
576 case EM_CYGNUS_MN10200:
578 case EM_CYGNUS_MN10300:
604 case EM_MICROBLAZE_OLD:
625 warn (_("Don't know about relocations on this machine architecture\n"));
631 slurp_rela_relocs (FILE * file,
632 unsigned long rel_offset,
633 unsigned long rel_size,
634 Elf_Internal_Rela ** relasp,
635 unsigned long * nrelasp)
637 Elf_Internal_Rela * relas;
638 unsigned long nrelas;
643 Elf32_External_Rela * erelas;
645 erelas = (Elf32_External_Rela *) get_data (NULL, file, rel_offset, 1,
646 rel_size, _("relocs"));
650 nrelas = rel_size / sizeof (Elf32_External_Rela);
652 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
653 sizeof (Elf_Internal_Rela));
658 error (_("out of memory parsing relocs\n"));
662 for (i = 0; i < nrelas; i++)
664 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
665 relas[i].r_info = BYTE_GET (erelas[i].r_info);
666 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
673 Elf64_External_Rela * erelas;
675 erelas = (Elf64_External_Rela *) get_data (NULL, file, rel_offset, 1,
676 rel_size, _("relocs"));
680 nrelas = rel_size / sizeof (Elf64_External_Rela);
682 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
683 sizeof (Elf_Internal_Rela));
688 error (_("out of memory parsing relocs\n"));
692 for (i = 0; i < nrelas; i++)
694 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
695 relas[i].r_info = BYTE_GET (erelas[i].r_info);
696 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
698 /* The #ifdef BFD64 below is to prevent a compile time
699 warning. We know that if we do not have a 64 bit data
700 type that we will never execute this code anyway. */
702 if (elf_header.e_machine == EM_MIPS
703 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
705 /* In little-endian objects, r_info isn't really a
706 64-bit little-endian value: it has a 32-bit
707 little-endian symbol index followed by four
708 individual byte fields. Reorder INFO
710 bfd_vma inf = relas[i].r_info;
711 inf = (((inf & 0xffffffff) << 32)
712 | ((inf >> 56) & 0xff)
713 | ((inf >> 40) & 0xff00)
714 | ((inf >> 24) & 0xff0000)
715 | ((inf >> 8) & 0xff000000));
716 relas[i].r_info = inf;
729 slurp_rel_relocs (FILE * file,
730 unsigned long rel_offset,
731 unsigned long rel_size,
732 Elf_Internal_Rela ** relsp,
733 unsigned long * nrelsp)
735 Elf_Internal_Rela * rels;
741 Elf32_External_Rel * erels;
743 erels = (Elf32_External_Rel *) get_data (NULL, file, rel_offset, 1,
744 rel_size, _("relocs"));
748 nrels = rel_size / sizeof (Elf32_External_Rel);
750 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
755 error (_("out of memory parsing relocs\n"));
759 for (i = 0; i < nrels; i++)
761 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
762 rels[i].r_info = BYTE_GET (erels[i].r_info);
763 rels[i].r_addend = 0;
770 Elf64_External_Rel * erels;
772 erels = (Elf64_External_Rel *) get_data (NULL, file, rel_offset, 1,
773 rel_size, _("relocs"));
777 nrels = rel_size / sizeof (Elf64_External_Rel);
779 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
784 error (_("out of memory parsing relocs\n"));
788 for (i = 0; i < nrels; i++)
790 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
791 rels[i].r_info = BYTE_GET (erels[i].r_info);
792 rels[i].r_addend = 0;
794 /* The #ifdef BFD64 below is to prevent a compile time
795 warning. We know that if we do not have a 64 bit data
796 type that we will never execute this code anyway. */
798 if (elf_header.e_machine == EM_MIPS
799 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
801 /* In little-endian objects, r_info isn't really a
802 64-bit little-endian value: it has a 32-bit
803 little-endian symbol index followed by four
804 individual byte fields. Reorder INFO
806 bfd_vma inf = rels[i].r_info;
807 inf = (((inf & 0xffffffff) << 32)
808 | ((inf >> 56) & 0xff)
809 | ((inf >> 40) & 0xff00)
810 | ((inf >> 24) & 0xff0000)
811 | ((inf >> 8) & 0xff000000));
812 rels[i].r_info = inf;
824 /* Returns the reloc type extracted from the reloc info field. */
827 get_reloc_type (bfd_vma reloc_info)
830 return ELF32_R_TYPE (reloc_info);
832 switch (elf_header.e_machine)
835 /* Note: We assume that reloc_info has already been adjusted for us. */
836 return ELF64_MIPS_R_TYPE (reloc_info);
839 return ELF64_R_TYPE_ID (reloc_info);
842 return ELF64_R_TYPE (reloc_info);
846 /* Return the symbol index extracted from the reloc info field. */
849 get_reloc_symindex (bfd_vma reloc_info)
851 return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
854 /* Display the contents of the relocation data found at the specified
858 dump_relocations (FILE * file,
859 unsigned long rel_offset,
860 unsigned long rel_size,
861 Elf_Internal_Sym * symtab,
864 unsigned long strtablen,
868 Elf_Internal_Rela * rels;
870 if (is_rela == UNKNOWN)
871 is_rela = guess_is_rela (elf_header.e_machine);
875 if (!slurp_rela_relocs (file, rel_offset, rel_size, &rels, &rel_size))
880 if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
889 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
891 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
896 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
898 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
906 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
908 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
913 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
915 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
919 for (i = 0; i < rel_size; i++)
924 bfd_vma symtab_index;
927 offset = rels[i].r_offset;
928 inf = rels[i].r_info;
930 type = get_reloc_type (inf);
931 symtab_index = get_reloc_symindex (inf);
935 printf ("%8.8lx %8.8lx ",
936 (unsigned long) offset & 0xffffffff,
937 (unsigned long) inf & 0xffffffff);
941 #if BFD_HOST_64BIT_LONG
943 ? "%16.16lx %16.16lx "
944 : "%12.12lx %12.12lx ",
946 #elif BFD_HOST_64BIT_LONG_LONG
949 ? "%16.16llx %16.16llx "
950 : "%12.12llx %12.12llx ",
954 ? "%16.16I64x %16.16I64x "
955 : "%12.12I64x %12.12I64x ",
960 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
961 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
962 _bfd_int64_high (offset),
963 _bfd_int64_low (offset),
964 _bfd_int64_high (inf),
965 _bfd_int64_low (inf));
969 switch (elf_header.e_machine)
977 rtype = elf_m32r_reloc_type (type);
982 rtype = elf_i386_reloc_type (type);
987 rtype = elf_m68hc11_reloc_type (type);
991 rtype = elf_m68k_reloc_type (type);
995 rtype = elf_i960_reloc_type (type);
1000 rtype = elf_avr_reloc_type (type);
1003 case EM_OLD_SPARCV9:
1004 case EM_SPARC32PLUS:
1007 rtype = elf_sparc_reloc_type (type);
1011 rtype = elf_spu_reloc_type (type);
1015 case EM_CYGNUS_V850:
1016 rtype = v850_reloc_type (type);
1020 case EM_CYGNUS_D10V:
1021 rtype = elf_d10v_reloc_type (type);
1025 case EM_CYGNUS_D30V:
1026 rtype = elf_d30v_reloc_type (type);
1030 rtype = elf_dlx_reloc_type (type);
1034 rtype = elf_sh_reloc_type (type);
1038 case EM_CYGNUS_MN10300:
1039 rtype = elf_mn10300_reloc_type (type);
1043 case EM_CYGNUS_MN10200:
1044 rtype = elf_mn10200_reloc_type (type);
1048 case EM_CYGNUS_FR30:
1049 rtype = elf_fr30_reloc_type (type);
1053 rtype = elf_frv_reloc_type (type);
1057 rtype = elf_mcore_reloc_type (type);
1061 rtype = elf_mmix_reloc_type (type);
1065 rtype = elf_moxie_reloc_type (type);
1070 rtype = elf_msp430_reloc_type (type);
1074 rtype = elf_ppc_reloc_type (type);
1078 rtype = elf_ppc64_reloc_type (type);
1082 case EM_MIPS_RS3_LE:
1083 rtype = elf_mips_reloc_type (type);
1087 rtype = elf_alpha_reloc_type (type);
1091 rtype = elf_arm_reloc_type (type);
1095 rtype = elf_arc_reloc_type (type);
1099 rtype = elf_hppa_reloc_type (type);
1105 rtype = elf_h8_reloc_type (type);
1110 rtype = elf_or32_reloc_type (type);
1115 rtype = elf_pj_reloc_type (type);
1118 rtype = elf_ia64_reloc_type (type);
1122 rtype = elf_cris_reloc_type (type);
1126 rtype = elf_i860_reloc_type (type);
1131 rtype = elf_x86_64_reloc_type (type);
1135 rtype = i370_reloc_type (type);
1140 rtype = elf_s390_reloc_type (type);
1144 rtype = elf_score_reloc_type (type);
1148 rtype = elf_xstormy16_reloc_type (type);
1152 rtype = elf_crx_reloc_type (type);
1156 rtype = elf_vax_reloc_type (type);
1161 rtype = elf_ip2k_reloc_type (type);
1165 rtype = elf_iq2000_reloc_type (type);
1170 rtype = elf_xtensa_reloc_type (type);
1173 case EM_LATTICEMICO32:
1174 rtype = elf_lm32_reloc_type (type);
1179 rtype = elf_m32c_reloc_type (type);
1183 rtype = elf_mt_reloc_type (type);
1187 rtype = elf_bfin_reloc_type (type);
1191 rtype = elf_mep_reloc_type (type);
1196 rtype = elf_cr16_reloc_type (type);
1200 case EM_MICROBLAZE_OLD:
1201 rtype = elf_microblaze_reloc_type (type);
1205 rtype = elf_rx_reloc_type (type);
1210 rtype = elf_xc16x_reloc_type (type);
1214 rtype = elf_tic6x_reloc_type (type);
1219 printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
1221 printf (do_wide ? "%-22.22s" : "%-17.17s", rtype);
1223 if (elf_header.e_machine == EM_ALPHA
1225 && streq (rtype, "R_ALPHA_LITUSE")
1228 switch (rels[i].r_addend)
1230 case LITUSE_ALPHA_ADDR: rtype = "ADDR"; break;
1231 case LITUSE_ALPHA_BASE: rtype = "BASE"; break;
1232 case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1233 case LITUSE_ALPHA_JSR: rtype = "JSR"; break;
1234 case LITUSE_ALPHA_TLSGD: rtype = "TLSGD"; break;
1235 case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1236 case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1237 default: rtype = NULL;
1240 printf (" (%s)", rtype);
1244 printf (_("<unknown addend: %lx>"),
1245 (unsigned long) rels[i].r_addend);
1248 else if (symtab_index)
1250 if (symtab == NULL || symtab_index >= nsyms)
1251 printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index);
1254 Elf_Internal_Sym * psym;
1256 psym = symtab + symtab_index;
1260 if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1264 unsigned int width = is_32bit_elf ? 8 : 14;
1266 /* Relocations against GNU_IFUNC symbols do not use the value
1267 of the symbol as the address to relocate against. Instead
1268 they invoke the function named by the symbol and use its
1269 result as the address for relocation.
1271 To indicate this to the user, do not display the value of
1272 the symbol in the "Symbols's Value" field. Instead show
1273 its name followed by () as a hint that the symbol is
1277 || psym->st_name == 0
1278 || psym->st_name >= strtablen)
1281 name = strtab + psym->st_name;
1283 len = print_symbol (width, name);
1284 printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1288 print_vma (psym->st_value, LONG_HEX);
1290 printf (is_32bit_elf ? " " : " ");
1293 if (psym->st_name == 0)
1295 const char * sec_name = "<null>";
1298 if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1300 if (psym->st_shndx < elf_header.e_shnum)
1302 = SECTION_NAME (section_headers + psym->st_shndx);
1303 else if (psym->st_shndx == SHN_ABS)
1305 else if (psym->st_shndx == SHN_COMMON)
1306 sec_name = "COMMON";
1307 else if (elf_header.e_machine == EM_MIPS
1308 && psym->st_shndx == SHN_MIPS_SCOMMON)
1309 sec_name = "SCOMMON";
1310 else if (elf_header.e_machine == EM_MIPS
1311 && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1312 sec_name = "SUNDEF";
1313 else if ((elf_header.e_machine == EM_X86_64
1314 || elf_header.e_machine == EM_L1OM)
1315 && psym->st_shndx == SHN_X86_64_LCOMMON)
1316 sec_name = "LARGE_COMMON";
1317 else if (elf_header.e_machine == EM_IA_64
1318 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1319 && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1320 sec_name = "ANSI_COM";
1321 else if (is_ia64_vms ()
1322 && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1323 sec_name = "VMS_SYMVEC";
1326 sprintf (name_buf, "<section 0x%x>",
1327 (unsigned int) psym->st_shndx);
1328 sec_name = name_buf;
1331 print_symbol (22, sec_name);
1333 else if (strtab == NULL)
1334 printf (_("<string table index: %3ld>"), psym->st_name);
1335 else if (psym->st_name >= strtablen)
1336 printf (_("<corrupt string table index: %3ld>"), psym->st_name);
1338 print_symbol (22, strtab + psym->st_name);
1342 bfd_signed_vma off = rels[i].r_addend;
1345 printf (" - %" BFD_VMA_FMT "x", - off);
1347 printf (" + %" BFD_VMA_FMT "x", off);
1353 printf ("%*c", is_32bit_elf ?
1354 (do_wide ? 34 : 28) : (do_wide ? 26 : 20), ' ');
1355 print_vma (rels[i].r_addend, LONG_HEX);
1358 if (elf_header.e_machine == EM_SPARCV9
1360 && streq (rtype, "R_SPARC_OLO10"))
1361 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
1366 if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
1368 bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1369 bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
1370 const char * rtype2 = elf_mips_reloc_type (type2);
1371 const char * rtype3 = elf_mips_reloc_type (type3);
1373 printf (" Type2: ");
1376 printf (_("unrecognized: %-7lx"),
1377 (unsigned long) type2 & 0xffffffff);
1379 printf ("%-17.17s", rtype2);
1381 printf ("\n Type3: ");
1384 printf (_("unrecognized: %-7lx"),
1385 (unsigned long) type3 & 0xffffffff);
1387 printf ("%-17.17s", rtype3);
1398 get_mips_dynamic_type (unsigned long type)
1402 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1403 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1404 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1405 case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1406 case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1407 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1408 case DT_MIPS_MSYM: return "MIPS_MSYM";
1409 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1410 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1411 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1412 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1413 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1414 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1415 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1416 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1417 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1418 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1419 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1420 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1421 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1422 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1423 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1424 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1425 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1426 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1427 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1428 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1429 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1430 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1431 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1432 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1433 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1434 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1435 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1436 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1437 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1438 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1439 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1440 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1441 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1442 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1443 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1444 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
1445 case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1446 case DT_MIPS_RWPLT: return "MIPS_RWPLT";
1453 get_sparc64_dynamic_type (unsigned long type)
1457 case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1464 get_ppc_dynamic_type (unsigned long type)
1468 case DT_PPC_GOT: return "PPC_GOT";
1469 case DT_PPC_TLSOPT: return "PPC_TLSOPT";
1476 get_ppc64_dynamic_type (unsigned long type)
1480 case DT_PPC64_GLINK: return "PPC64_GLINK";
1481 case DT_PPC64_OPD: return "PPC64_OPD";
1482 case DT_PPC64_OPDSZ: return "PPC64_OPDSZ";
1483 case DT_PPC64_TLSOPT: return "PPC64_TLSOPT";
1490 get_parisc_dynamic_type (unsigned long type)
1494 case DT_HP_LOAD_MAP: return "HP_LOAD_MAP";
1495 case DT_HP_DLD_FLAGS: return "HP_DLD_FLAGS";
1496 case DT_HP_DLD_HOOK: return "HP_DLD_HOOK";
1497 case DT_HP_UX10_INIT: return "HP_UX10_INIT";
1498 case DT_HP_UX10_INITSZ: return "HP_UX10_INITSZ";
1499 case DT_HP_PREINIT: return "HP_PREINIT";
1500 case DT_HP_PREINITSZ: return "HP_PREINITSZ";
1501 case DT_HP_NEEDED: return "HP_NEEDED";
1502 case DT_HP_TIME_STAMP: return "HP_TIME_STAMP";
1503 case DT_HP_CHECKSUM: return "HP_CHECKSUM";
1504 case DT_HP_GST_SIZE: return "HP_GST_SIZE";
1505 case DT_HP_GST_VERSION: return "HP_GST_VERSION";
1506 case DT_HP_GST_HASHVAL: return "HP_GST_HASHVAL";
1507 case DT_HP_EPLTREL: return "HP_GST_EPLTREL";
1508 case DT_HP_EPLTRELSZ: return "HP_GST_EPLTRELSZ";
1509 case DT_HP_FILTERED: return "HP_FILTERED";
1510 case DT_HP_FILTER_TLS: return "HP_FILTER_TLS";
1511 case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1512 case DT_HP_LAZYLOAD: return "HP_LAZYLOAD";
1513 case DT_HP_BIND_NOW_COUNT: return "HP_BIND_NOW_COUNT";
1514 case DT_PLT: return "PLT";
1515 case DT_PLT_SIZE: return "PLT_SIZE";
1516 case DT_DLT: return "DLT";
1517 case DT_DLT_SIZE: return "DLT_SIZE";
1524 get_ia64_dynamic_type (unsigned long type)
1528 case DT_IA_64_PLT_RESERVE: return "IA_64_PLT_RESERVE";
1529 case DT_IA_64_VMS_SUBTYPE: return "VMS_SUBTYPE";
1530 case DT_IA_64_VMS_IMGIOCNT: return "VMS_IMGIOCNT";
1531 case DT_IA_64_VMS_LNKFLAGS: return "VMS_LNKFLAGS";
1532 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1533 case DT_IA_64_VMS_IDENT: return "VMS_IDENT";
1534 case DT_IA_64_VMS_NEEDED_IDENT: return "VMS_NEEDED_IDENT";
1535 case DT_IA_64_VMS_IMG_RELA_CNT: return "VMS_IMG_RELA_CNT";
1536 case DT_IA_64_VMS_SEG_RELA_CNT: return "VMS_SEG_RELA_CNT";
1537 case DT_IA_64_VMS_FIXUP_RELA_CNT: return "VMS_FIXUP_RELA_CNT";
1538 case DT_IA_64_VMS_FIXUP_NEEDED: return "VMS_FIXUP_NEEDED";
1539 case DT_IA_64_VMS_SYMVEC_CNT: return "VMS_SYMVEC_CNT";
1540 case DT_IA_64_VMS_XLATED: return "VMS_XLATED";
1541 case DT_IA_64_VMS_STACKSIZE: return "VMS_STACKSIZE";
1542 case DT_IA_64_VMS_UNWINDSZ: return "VMS_UNWINDSZ";
1543 case DT_IA_64_VMS_UNWIND_CODSEG: return "VMS_UNWIND_CODSEG";
1544 case DT_IA_64_VMS_UNWIND_INFOSEG: return "VMS_UNWIND_INFOSEG";
1545 case DT_IA_64_VMS_LINKTIME: return "VMS_LINKTIME";
1546 case DT_IA_64_VMS_SEG_NO: return "VMS_SEG_NO";
1547 case DT_IA_64_VMS_SYMVEC_OFFSET: return "VMS_SYMVEC_OFFSET";
1548 case DT_IA_64_VMS_SYMVEC_SEG: return "VMS_SYMVEC_SEG";
1549 case DT_IA_64_VMS_UNWIND_OFFSET: return "VMS_UNWIND_OFFSET";
1550 case DT_IA_64_VMS_UNWIND_SEG: return "VMS_UNWIND_SEG";
1551 case DT_IA_64_VMS_STRTAB_OFFSET: return "VMS_STRTAB_OFFSET";
1552 case DT_IA_64_VMS_SYSVER_OFFSET: return "VMS_SYSVER_OFFSET";
1553 case DT_IA_64_VMS_IMG_RELA_OFF: return "VMS_IMG_RELA_OFF";
1554 case DT_IA_64_VMS_SEG_RELA_OFF: return "VMS_SEG_RELA_OFF";
1555 case DT_IA_64_VMS_FIXUP_RELA_OFF: return "VMS_FIXUP_RELA_OFF";
1556 case DT_IA_64_VMS_PLTGOT_OFFSET: return "VMS_PLTGOT_OFFSET";
1557 case DT_IA_64_VMS_PLTGOT_SEG: return "VMS_PLTGOT_SEG";
1558 case DT_IA_64_VMS_FPMODE: return "VMS_FPMODE";
1565 get_alpha_dynamic_type (unsigned long type)
1569 case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
1576 get_score_dynamic_type (unsigned long type)
1580 case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
1581 case DT_SCORE_LOCAL_GOTNO: return "SCORE_LOCAL_GOTNO";
1582 case DT_SCORE_SYMTABNO: return "SCORE_SYMTABNO";
1583 case DT_SCORE_GOTSYM: return "SCORE_GOTSYM";
1584 case DT_SCORE_UNREFEXTNO: return "SCORE_UNREFEXTNO";
1585 case DT_SCORE_HIPAGENO: return "SCORE_HIPAGENO";
1592 get_tic6x_dynamic_type (unsigned long type)
1596 case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
1597 case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
1598 case DT_C6000_DSBT_BASE: return "C6000_DSBT_BASE";
1599 case DT_C6000_DSBT_SIZE: return "C6000_DSBT_SIZE";
1600 case DT_C6000_PREEMPTMAP: return "C6000_PREEMPTMAP";
1601 case DT_C6000_DSBT_INDEX: return "C6000_DSBT_INDEX";
1608 get_dynamic_type (unsigned long type)
1610 static char buff[64];
1614 case DT_NULL: return "NULL";
1615 case DT_NEEDED: return "NEEDED";
1616 case DT_PLTRELSZ: return "PLTRELSZ";
1617 case DT_PLTGOT: return "PLTGOT";
1618 case DT_HASH: return "HASH";
1619 case DT_STRTAB: return "STRTAB";
1620 case DT_SYMTAB: return "SYMTAB";
1621 case DT_RELA: return "RELA";
1622 case DT_RELASZ: return "RELASZ";
1623 case DT_RELAENT: return "RELAENT";
1624 case DT_STRSZ: return "STRSZ";
1625 case DT_SYMENT: return "SYMENT";
1626 case DT_INIT: return "INIT";
1627 case DT_FINI: return "FINI";
1628 case DT_SONAME: return "SONAME";
1629 case DT_RPATH: return "RPATH";
1630 case DT_SYMBOLIC: return "SYMBOLIC";
1631 case DT_REL: return "REL";
1632 case DT_RELSZ: return "RELSZ";
1633 case DT_RELENT: return "RELENT";
1634 case DT_PLTREL: return "PLTREL";
1635 case DT_DEBUG: return "DEBUG";
1636 case DT_TEXTREL: return "TEXTREL";
1637 case DT_JMPREL: return "JMPREL";
1638 case DT_BIND_NOW: return "BIND_NOW";
1639 case DT_INIT_ARRAY: return "INIT_ARRAY";
1640 case DT_FINI_ARRAY: return "FINI_ARRAY";
1641 case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
1642 case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
1643 case DT_RUNPATH: return "RUNPATH";
1644 case DT_FLAGS: return "FLAGS";
1646 case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1647 case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
1649 case DT_CHECKSUM: return "CHECKSUM";
1650 case DT_PLTPADSZ: return "PLTPADSZ";
1651 case DT_MOVEENT: return "MOVEENT";
1652 case DT_MOVESZ: return "MOVESZ";
1653 case DT_FEATURE: return "FEATURE";
1654 case DT_POSFLAG_1: return "POSFLAG_1";
1655 case DT_SYMINSZ: return "SYMINSZ";
1656 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
1658 case DT_ADDRRNGLO: return "ADDRRNGLO";
1659 case DT_CONFIG: return "CONFIG";
1660 case DT_DEPAUDIT: return "DEPAUDIT";
1661 case DT_AUDIT: return "AUDIT";
1662 case DT_PLTPAD: return "PLTPAD";
1663 case DT_MOVETAB: return "MOVETAB";
1664 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
1666 case DT_VERSYM: return "VERSYM";
1668 case DT_TLSDESC_GOT: return "TLSDESC_GOT";
1669 case DT_TLSDESC_PLT: return "TLSDESC_PLT";
1670 case DT_RELACOUNT: return "RELACOUNT";
1671 case DT_RELCOUNT: return "RELCOUNT";
1672 case DT_FLAGS_1: return "FLAGS_1";
1673 case DT_VERDEF: return "VERDEF";
1674 case DT_VERDEFNUM: return "VERDEFNUM";
1675 case DT_VERNEED: return "VERNEED";
1676 case DT_VERNEEDNUM: return "VERNEEDNUM";
1678 case DT_AUXILIARY: return "AUXILIARY";
1679 case DT_USED: return "USED";
1680 case DT_FILTER: return "FILTER";
1682 case DT_GNU_PRELINKED: return "GNU_PRELINKED";
1683 case DT_GNU_CONFLICT: return "GNU_CONFLICT";
1684 case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
1685 case DT_GNU_LIBLIST: return "GNU_LIBLIST";
1686 case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
1687 case DT_GNU_HASH: return "GNU_HASH";
1690 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1692 const char * result;
1694 switch (elf_header.e_machine)
1697 case EM_MIPS_RS3_LE:
1698 result = get_mips_dynamic_type (type);
1701 result = get_sparc64_dynamic_type (type);
1704 result = get_ppc_dynamic_type (type);
1707 result = get_ppc64_dynamic_type (type);
1710 result = get_ia64_dynamic_type (type);
1713 result = get_alpha_dynamic_type (type);
1716 result = get_score_dynamic_type (type);
1719 result = get_tic6x_dynamic_type (type);
1729 snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
1731 else if (((type >= DT_LOOS) && (type <= DT_HIOS))
1732 || (elf_header.e_machine == EM_PARISC
1733 && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
1735 const char * result;
1737 switch (elf_header.e_machine)
1740 result = get_parisc_dynamic_type (type);
1743 result = get_ia64_dynamic_type (type);
1753 snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
1757 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
1764 get_file_type (unsigned e_type)
1766 static char buff[32];
1770 case ET_NONE: return _("NONE (None)");
1771 case ET_REL: return _("REL (Relocatable file)");
1772 case ET_EXEC: return _("EXEC (Executable file)");
1773 case ET_DYN: return _("DYN (Shared object file)");
1774 case ET_CORE: return _("CORE (Core file)");
1777 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
1778 snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
1779 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
1780 snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
1782 snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
1788 get_machine_name (unsigned e_machine)
1790 static char buff[64]; /* XXX */
1794 case EM_NONE: return _("None");
1795 case EM_M32: return "WE32100";
1796 case EM_SPARC: return "Sparc";
1797 case EM_SPU: return "SPU";
1798 case EM_386: return "Intel 80386";
1799 case EM_68K: return "MC68000";
1800 case EM_88K: return "MC88000";
1801 case EM_486: return "Intel 80486";
1802 case EM_860: return "Intel 80860";
1803 case EM_MIPS: return "MIPS R3000";
1804 case EM_S370: return "IBM System/370";
1805 case EM_MIPS_RS3_LE: return "MIPS R4000 big-endian";
1806 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
1807 case EM_PARISC: return "HPPA";
1808 case EM_PPC_OLD: return "Power PC (old)";
1809 case EM_SPARC32PLUS: return "Sparc v8+" ;
1810 case EM_960: return "Intel 90860";
1811 case EM_PPC: return "PowerPC";
1812 case EM_PPC64: return "PowerPC64";
1813 case EM_V800: return "NEC V800";
1814 case EM_FR20: return "Fujitsu FR20";
1815 case EM_RH32: return "TRW RH32";
1816 case EM_MCORE: return "MCORE";
1817 case EM_ARM: return "ARM";
1818 case EM_OLD_ALPHA: return "Digital Alpha (old)";
1819 case EM_SH: return "Renesas / SuperH SH";
1820 case EM_SPARCV9: return "Sparc v9";
1821 case EM_TRICORE: return "Siemens Tricore";
1822 case EM_ARC: return "ARC";
1823 case EM_H8_300: return "Renesas H8/300";
1824 case EM_H8_300H: return "Renesas H8/300H";
1825 case EM_H8S: return "Renesas H8S";
1826 case EM_H8_500: return "Renesas H8/500";
1827 case EM_IA_64: return "Intel IA-64";
1828 case EM_MIPS_X: return "Stanford MIPS-X";
1829 case EM_COLDFIRE: return "Motorola Coldfire";
1830 case EM_68HC12: return "Motorola M68HC12";
1831 case EM_ALPHA: return "Alpha";
1832 case EM_CYGNUS_D10V:
1833 case EM_D10V: return "d10v";
1834 case EM_CYGNUS_D30V:
1835 case EM_D30V: return "d30v";
1836 case EM_CYGNUS_M32R:
1837 case EM_M32R: return "Renesas M32R (formerly Mitsubishi M32r)";
1838 case EM_CYGNUS_V850:
1839 case EM_V850: return "Renesas v850";
1840 case EM_CYGNUS_MN10300:
1841 case EM_MN10300: return "mn10300";
1842 case EM_CYGNUS_MN10200:
1843 case EM_MN10200: return "mn10200";
1844 case EM_MOXIE: return "Moxie";
1845 case EM_CYGNUS_FR30:
1846 case EM_FR30: return "Fujitsu FR30";
1847 case EM_CYGNUS_FRV: return "Fujitsu FR-V";
1849 case EM_PJ: return "picoJava";
1850 case EM_MMA: return "Fujitsu Multimedia Accelerator";
1851 case EM_PCP: return "Siemens PCP";
1852 case EM_NCPU: return "Sony nCPU embedded RISC processor";
1853 case EM_NDR1: return "Denso NDR1 microprocesspr";
1854 case EM_STARCORE: return "Motorola Star*Core processor";
1855 case EM_ME16: return "Toyota ME16 processor";
1856 case EM_ST100: return "STMicroelectronics ST100 processor";
1857 case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
1858 case EM_PDSP: return "Sony DSP processor";
1859 case EM_PDP10: return "Digital Equipment Corp. PDP-10";
1860 case EM_PDP11: return "Digital Equipment Corp. PDP-11";
1861 case EM_FX66: return "Siemens FX66 microcontroller";
1862 case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1863 case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
1864 case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
1865 case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
1866 case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
1867 case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
1868 case EM_SVX: return "Silicon Graphics SVx";
1869 case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
1870 case EM_VAX: return "Digital VAX";
1872 case EM_AVR: return "Atmel AVR 8-bit microcontroller";
1873 case EM_CRIS: return "Axis Communications 32-bit embedded processor";
1874 case EM_JAVELIN: return "Infineon Technologies 32-bit embedded cpu";
1875 case EM_FIREPATH: return "Element 14 64-bit DSP processor";
1876 case EM_ZSP: return "LSI Logic's 16-bit DSP processor";
1877 case EM_MMIX: return "Donald Knuth's educational 64-bit processor";
1878 case EM_HUANY: return "Harvard Universitys's machine-independent object format";
1879 case EM_PRISM: return "Vitesse Prism";
1880 case EM_X86_64: return "Advanced Micro Devices X86-64";
1881 case EM_L1OM: return "Intel L1OM";
1883 case EM_S390: return "IBM S/390";
1884 case EM_SCORE: return "SUNPLUS S+Core";
1885 case EM_XSTORMY16: return "Sanyo XStormy16 CPU core";
1887 case EM_OR32: return "OpenRISC";
1888 case EM_ARC_A5: return "ARC International ARCompact processor";
1889 case EM_CRX: return "National Semiconductor CRX microprocessor";
1890 case EM_DLX: return "OpenDLX";
1892 case EM_IP2K: return "Ubicom IP2xxx 8-bit microcontrollers";
1893 case EM_IQ2000: return "Vitesse IQ2000";
1895 case EM_XTENSA: return "Tensilica Xtensa Processor";
1896 case EM_VIDEOCORE: return "Alphamosaic VideoCore processor";
1897 case EM_TMM_GPP: return "Thompson Multimedia General Purpose Processor";
1898 case EM_NS32K: return "National Semiconductor 32000 series";
1899 case EM_TPC: return "Tenor Network TPC processor";
1900 case EM_ST200: return "STMicroelectronics ST200 microcontroller";
1901 case EM_MAX: return "MAX Processor";
1902 case EM_CR: return "National Semiconductor CompactRISC";
1903 case EM_F2MC16: return "Fujitsu F2MC16";
1904 case EM_MSP430: return "Texas Instruments msp430 microcontroller";
1905 case EM_LATTICEMICO32: return "Lattice Mico32";
1907 case EM_M32C: return "Renesas M32c";
1908 case EM_MT: return "Morpho Techologies MT processor";
1909 case EM_BLACKFIN: return "Analog Devices Blackfin";
1910 case EM_SE_C33: return "S1C33 Family of Seiko Epson processors";
1911 case EM_SEP: return "Sharp embedded microprocessor";
1912 case EM_ARCA: return "Arca RISC microprocessor";
1913 case EM_UNICORE: return "Unicore";
1914 case EM_EXCESS: return "eXcess 16/32/64-bit configurable embedded CPU";
1915 case EM_DXP: return "Icera Semiconductor Inc. Deep Execution Processor";
1916 case EM_NIOS32: return "Altera Nios";
1917 case EM_ALTERA_NIOS2: return "Altera Nios II";
1919 case EM_XC16X: return "Infineon Technologies xc16x";
1920 case EM_M16C: return "Renesas M16C series microprocessors";
1921 case EM_DSPIC30F: return "Microchip Technology dsPIC30F Digital Signal Controller";
1922 case EM_CE: return "Freescale Communication Engine RISC core";
1923 case EM_TSK3000: return "Altium TSK3000 core";
1924 case EM_RS08: return "Freescale RS08 embedded processor";
1925 case EM_ECOG2: return "Cyan Technology eCOG2 microprocessor";
1926 case EM_DSP24: return "New Japan Radio (NJR) 24-bit DSP Processor";
1927 case EM_VIDEOCORE3: return "Broadcom VideoCore III processor";
1928 case EM_SE_C17: return "Seiko Epson C17 family";
1929 case EM_TI_C6000: return "Texas Instruments TMS320C6000 DSP family";
1930 case EM_TI_C2000: return "Texas Instruments TMS320C2000 DSP family";
1931 case EM_TI_C5500: return "Texas Instruments TMS320C55x DSP family";
1932 case EM_MMDSP_PLUS: return "STMicroelectronics 64bit VLIW Data Signal Processor";
1933 case EM_CYPRESS_M8C: return "Cypress M8C microprocessor";
1934 case EM_R32C: return "Renesas R32C series microprocessors";
1935 case EM_TRIMEDIA: return "NXP Semiconductors TriMedia architecture family";
1936 case EM_QDSP6: return "QUALCOMM DSP6 Processor";
1937 case EM_8051: return "Intel 8051 and variants";
1938 case EM_STXP7X: return "STMicroelectronics STxP7x family";
1939 case EM_NDS32: return "Andes Technology compact code size embedded RISC processor family";
1940 case EM_ECOG1X: return "Cyan Technology eCOG1X family";
1941 case EM_MAXQ30: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
1942 case EM_XIMO16: return "New Japan Radio (NJR) 16-bit DSP Processor";
1943 case EM_MANIK: return "M2000 Reconfigurable RISC Microprocessor";
1944 case EM_CRAYNV2: return "Cray Inc. NV2 vector architecture";
1945 case EM_CYGNUS_MEP: return "Toshiba MeP Media Engine";
1947 case EM_CR16_OLD: return "National Semiconductor's CR16";
1948 case EM_MICROBLAZE: return "Xilinx MicroBlaze";
1949 case EM_MICROBLAZE_OLD: return "Xilinx MicroBlaze";
1950 case EM_RX: return "Renesas RX";
1951 case EM_METAG: return "Imagination Technologies META processor architecture";
1952 case EM_MCST_ELBRUS: return "MCST Elbrus general purpose hardware architecture";
1953 case EM_ECOG16: return "Cyan Technology eCOG16 family";
1954 case EM_ETPU: return "Freescale Extended Time Processing Unit";
1955 case EM_SLE9X: return "Infineon Technologies SLE9X core";
1956 case EM_AVR32: return "Atmel Corporation 32-bit microprocessor family";
1957 case EM_STM8: return "STMicroeletronics STM8 8-bit microcontroller";
1958 case EM_TILE64: return "Tilera TILE64 multicore architecture family";
1959 case EM_TILEPRO: return "Tilera TILEPro multicore architecture family";
1960 case EM_CUDA: return "NVIDIA CUDA architecture";
1962 snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
1968 decode_ARM_machine_flags (unsigned e_flags, char buf[])
1973 eabi = EF_ARM_EABI_VERSION (e_flags);
1974 e_flags &= ~ EF_ARM_EABIMASK;
1976 /* Handle "generic" ARM flags. */
1977 if (e_flags & EF_ARM_RELEXEC)
1979 strcat (buf, ", relocatable executable");
1980 e_flags &= ~ EF_ARM_RELEXEC;
1983 if (e_flags & EF_ARM_HASENTRY)
1985 strcat (buf, ", has entry point");
1986 e_flags &= ~ EF_ARM_HASENTRY;
1989 /* Now handle EABI specific flags. */
1993 strcat (buf, ", <unrecognized EABI>");
1998 case EF_ARM_EABI_VER1:
1999 strcat (buf, ", Version1 EABI");
2004 /* Process flags one bit at a time. */
2005 flag = e_flags & - e_flags;
2010 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2011 strcat (buf, ", sorted symbol tables");
2021 case EF_ARM_EABI_VER2:
2022 strcat (buf, ", Version2 EABI");
2027 /* Process flags one bit at a time. */
2028 flag = e_flags & - e_flags;
2033 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2034 strcat (buf, ", sorted symbol tables");
2037 case EF_ARM_DYNSYMSUSESEGIDX:
2038 strcat (buf, ", dynamic symbols use segment index");
2041 case EF_ARM_MAPSYMSFIRST:
2042 strcat (buf, ", mapping symbols precede others");
2052 case EF_ARM_EABI_VER3:
2053 strcat (buf, ", Version3 EABI");
2056 case EF_ARM_EABI_VER4:
2057 strcat (buf, ", Version4 EABI");
2060 case EF_ARM_EABI_VER5:
2061 strcat (buf, ", Version5 EABI");
2067 /* Process flags one bit at a time. */
2068 flag = e_flags & - e_flags;
2074 strcat (buf, ", BE8");
2078 strcat (buf, ", LE8");
2088 case EF_ARM_EABI_UNKNOWN:
2089 strcat (buf, ", GNU EABI");
2094 /* Process flags one bit at a time. */
2095 flag = e_flags & - e_flags;
2100 case EF_ARM_INTERWORK:
2101 strcat (buf, ", interworking enabled");
2104 case EF_ARM_APCS_26:
2105 strcat (buf, ", uses APCS/26");
2108 case EF_ARM_APCS_FLOAT:
2109 strcat (buf, ", uses APCS/float");
2113 strcat (buf, ", position independent");
2117 strcat (buf, ", 8 bit structure alignment");
2120 case EF_ARM_NEW_ABI:
2121 strcat (buf, ", uses new ABI");
2124 case EF_ARM_OLD_ABI:
2125 strcat (buf, ", uses old ABI");
2128 case EF_ARM_SOFT_FLOAT:
2129 strcat (buf, ", software FP");
2132 case EF_ARM_VFP_FLOAT:
2133 strcat (buf, ", VFP");
2136 case EF_ARM_MAVERICK_FLOAT:
2137 strcat (buf, ", Maverick FP");
2148 strcat (buf,_(", <unknown>"));
2152 get_machine_flags (unsigned e_flags, unsigned e_machine)
2154 static char buf[1024];
2166 decode_ARM_machine_flags (e_flags, buf);
2170 if (e_flags & EF_BFIN_PIC)
2171 strcat (buf, ", PIC");
2173 if (e_flags & EF_BFIN_FDPIC)
2174 strcat (buf, ", FDPIC");
2176 if (e_flags & EF_BFIN_CODE_IN_L1)
2177 strcat (buf, ", code in L1");
2179 if (e_flags & EF_BFIN_DATA_IN_L1)
2180 strcat (buf, ", data in L1");
2185 switch (e_flags & EF_FRV_CPU_MASK)
2187 case EF_FRV_CPU_GENERIC:
2191 strcat (buf, ", fr???");
2194 case EF_FRV_CPU_FR300:
2195 strcat (buf, ", fr300");
2198 case EF_FRV_CPU_FR400:
2199 strcat (buf, ", fr400");
2201 case EF_FRV_CPU_FR405:
2202 strcat (buf, ", fr405");
2205 case EF_FRV_CPU_FR450:
2206 strcat (buf, ", fr450");
2209 case EF_FRV_CPU_FR500:
2210 strcat (buf, ", fr500");
2212 case EF_FRV_CPU_FR550:
2213 strcat (buf, ", fr550");
2216 case EF_FRV_CPU_SIMPLE:
2217 strcat (buf, ", simple");
2219 case EF_FRV_CPU_TOMCAT:
2220 strcat (buf, ", tomcat");
2226 if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
2227 strcat (buf, ", m68000");
2228 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
2229 strcat (buf, ", cpu32");
2230 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
2231 strcat (buf, ", fido_a");
2234 char const * isa = _("unknown");
2235 char const * mac = _("unknown mac");
2236 char const * additional = NULL;
2238 switch (e_flags & EF_M68K_CF_ISA_MASK)
2240 case EF_M68K_CF_ISA_A_NODIV:
2242 additional = ", nodiv";
2244 case EF_M68K_CF_ISA_A:
2247 case EF_M68K_CF_ISA_A_PLUS:
2250 case EF_M68K_CF_ISA_B_NOUSP:
2252 additional = ", nousp";
2254 case EF_M68K_CF_ISA_B:
2257 case EF_M68K_CF_ISA_C:
2260 case EF_M68K_CF_ISA_C_NODIV:
2262 additional = ", nodiv";
2265 strcat (buf, ", cf, isa ");
2268 strcat (buf, additional);
2269 if (e_flags & EF_M68K_CF_FLOAT)
2270 strcat (buf, ", float");
2271 switch (e_flags & EF_M68K_CF_MAC_MASK)
2276 case EF_M68K_CF_MAC:
2279 case EF_M68K_CF_EMAC:
2282 case EF_M68K_CF_EMAC_B:
2295 if (e_flags & EF_PPC_EMB)
2296 strcat (buf, ", emb");
2298 if (e_flags & EF_PPC_RELOCATABLE)
2299 strcat (buf, _(", relocatable"));
2301 if (e_flags & EF_PPC_RELOCATABLE_LIB)
2302 strcat (buf, _(", relocatable-lib"));
2306 case EM_CYGNUS_V850:
2307 switch (e_flags & EF_V850_ARCH)
2309 case E_V850E2V3_ARCH:
2310 strcat (buf, ", v850e2v3");
2313 strcat (buf, ", v850e2");
2316 strcat (buf, ", v850e1");
2319 strcat (buf, ", v850e");
2322 strcat (buf, ", v850");
2325 strcat (buf, _(", unknown v850 architecture variant"));
2331 case EM_CYGNUS_M32R:
2332 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
2333 strcat (buf, ", m32r");
2337 case EM_MIPS_RS3_LE:
2338 if (e_flags & EF_MIPS_NOREORDER)
2339 strcat (buf, ", noreorder");
2341 if (e_flags & EF_MIPS_PIC)
2342 strcat (buf, ", pic");
2344 if (e_flags & EF_MIPS_CPIC)
2345 strcat (buf, ", cpic");
2347 if (e_flags & EF_MIPS_UCODE)
2348 strcat (buf, ", ugen_reserved");
2350 if (e_flags & EF_MIPS_ABI2)
2351 strcat (buf, ", abi2");
2353 if (e_flags & EF_MIPS_OPTIONS_FIRST)
2354 strcat (buf, ", odk first");
2356 if (e_flags & EF_MIPS_32BITMODE)
2357 strcat (buf, ", 32bitmode");
2359 switch ((e_flags & EF_MIPS_MACH))
2361 case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
2362 case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
2363 case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
2364 case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
2365 case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
2366 case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
2367 case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
2368 case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
2369 case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); break;
2370 case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
2371 case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
2372 case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
2373 case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
2374 case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
2375 case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
2376 case E_MIPS_MACH_XLR: strcat (buf, ", xlr"); break;
2378 /* We simply ignore the field in this case to avoid confusion:
2379 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2382 default: strcat (buf, _(", unknown CPU")); break;
2385 switch ((e_flags & EF_MIPS_ABI))
2387 case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
2388 case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
2389 case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
2390 case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
2392 /* We simply ignore the field in this case to avoid confusion:
2393 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2394 This means it is likely to be an o32 file, but not for
2397 default: strcat (buf, _(", unknown ABI")); break;
2400 if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
2401 strcat (buf, ", mdmx");
2403 if (e_flags & EF_MIPS_ARCH_ASE_M16)
2404 strcat (buf, ", mips16");
2406 switch ((e_flags & EF_MIPS_ARCH))
2408 case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
2409 case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
2410 case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
2411 case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
2412 case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
2413 case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
2414 case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
2415 case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
2416 case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
2417 default: strcat (buf, _(", unknown ISA")); break;
2420 if (e_flags & EF_SH_PIC)
2421 strcat (buf, ", pic");
2423 if (e_flags & EF_SH_FDPIC)
2424 strcat (buf, ", fdpic");
2428 switch ((e_flags & EF_SH_MACH_MASK))
2430 case EF_SH1: strcat (buf, ", sh1"); break;
2431 case EF_SH2: strcat (buf, ", sh2"); break;
2432 case EF_SH3: strcat (buf, ", sh3"); break;
2433 case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
2434 case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
2435 case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
2436 case EF_SH3E: strcat (buf, ", sh3e"); break;
2437 case EF_SH4: strcat (buf, ", sh4"); break;
2438 case EF_SH5: strcat (buf, ", sh5"); break;
2439 case EF_SH2E: strcat (buf, ", sh2e"); break;
2440 case EF_SH4A: strcat (buf, ", sh4a"); break;
2441 case EF_SH2A: strcat (buf, ", sh2a"); break;
2442 case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
2443 case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
2444 case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
2445 case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
2446 case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
2447 case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
2448 case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
2449 case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
2450 case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
2451 default: strcat (buf, _(", unknown ISA")); break;
2457 if (e_flags & EF_SPARC_32PLUS)
2458 strcat (buf, ", v8+");
2460 if (e_flags & EF_SPARC_SUN_US1)
2461 strcat (buf, ", ultrasparcI");
2463 if (e_flags & EF_SPARC_SUN_US3)
2464 strcat (buf, ", ultrasparcIII");
2466 if (e_flags & EF_SPARC_HAL_R1)
2467 strcat (buf, ", halr1");
2469 if (e_flags & EF_SPARC_LEDATA)
2470 strcat (buf, ", ledata");
2472 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
2473 strcat (buf, ", tso");
2475 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
2476 strcat (buf, ", pso");
2478 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
2479 strcat (buf, ", rmo");
2483 switch (e_flags & EF_PARISC_ARCH)
2485 case EFA_PARISC_1_0:
2486 strcpy (buf, ", PA-RISC 1.0");
2488 case EFA_PARISC_1_1:
2489 strcpy (buf, ", PA-RISC 1.1");
2491 case EFA_PARISC_2_0:
2492 strcpy (buf, ", PA-RISC 2.0");
2497 if (e_flags & EF_PARISC_TRAPNIL)
2498 strcat (buf, ", trapnil");
2499 if (e_flags & EF_PARISC_EXT)
2500 strcat (buf, ", ext");
2501 if (e_flags & EF_PARISC_LSB)
2502 strcat (buf, ", lsb");
2503 if (e_flags & EF_PARISC_WIDE)
2504 strcat (buf, ", wide");
2505 if (e_flags & EF_PARISC_NO_KABP)
2506 strcat (buf, ", no kabp");
2507 if (e_flags & EF_PARISC_LAZYSWAP)
2508 strcat (buf, ", lazyswap");
2513 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
2514 strcat (buf, ", new calling convention");
2516 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
2517 strcat (buf, ", gnu calling convention");
2521 if ((e_flags & EF_IA_64_ABI64))
2522 strcat (buf, ", 64-bit");
2524 strcat (buf, ", 32-bit");
2525 if ((e_flags & EF_IA_64_REDUCEDFP))
2526 strcat (buf, ", reduced fp model");
2527 if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
2528 strcat (buf, ", no function descriptors, constant gp");
2529 else if ((e_flags & EF_IA_64_CONS_GP))
2530 strcat (buf, ", constant gp");
2531 if ((e_flags & EF_IA_64_ABSOLUTE))
2532 strcat (buf, ", absolute");
2533 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
2535 if ((e_flags & EF_IA_64_VMS_LINKAGES))
2536 strcat (buf, ", vms_linkages");
2537 switch ((e_flags & EF_IA_64_VMS_COMCOD))
2539 case EF_IA_64_VMS_COMCOD_SUCCESS:
2541 case EF_IA_64_VMS_COMCOD_WARNING:
2542 strcat (buf, ", warning");
2544 case EF_IA_64_VMS_COMCOD_ERROR:
2545 strcat (buf, ", error");
2547 case EF_IA_64_VMS_COMCOD_ABORT:
2548 strcat (buf, ", abort");
2557 if ((e_flags & EF_VAX_NONPIC))
2558 strcat (buf, ", non-PIC");
2559 if ((e_flags & EF_VAX_DFLOAT))
2560 strcat (buf, ", D-Float");
2561 if ((e_flags & EF_VAX_GFLOAT))
2562 strcat (buf, ", G-Float");
2566 if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
2567 strcat (buf, ", 64-bit doubles");
2568 if (e_flags & E_FLAG_RX_DSP)
2569 strcat (buf, ", dsp");
2572 if (e_flags & EF_S390_HIGH_GPRS)
2573 strcat (buf, ", highgprs");
2576 if ((e_flags & EF_C6000_REL))
2577 strcat (buf, ", relocatable module");
2585 get_osabi_name (unsigned int osabi)
2587 static char buff[32];
2591 case ELFOSABI_NONE: return "UNIX - System V";
2592 case ELFOSABI_HPUX: return "UNIX - HP-UX";
2593 case ELFOSABI_NETBSD: return "UNIX - NetBSD";
2594 case ELFOSABI_LINUX: return "UNIX - Linux";
2595 case ELFOSABI_HURD: return "GNU/Hurd";
2596 case ELFOSABI_SOLARIS: return "UNIX - Solaris";
2597 case ELFOSABI_AIX: return "UNIX - AIX";
2598 case ELFOSABI_IRIX: return "UNIX - IRIX";
2599 case ELFOSABI_FREEBSD: return "UNIX - FreeBSD";
2600 case ELFOSABI_TRU64: return "UNIX - TRU64";
2601 case ELFOSABI_MODESTO: return "Novell - Modesto";
2602 case ELFOSABI_OPENBSD: return "UNIX - OpenBSD";
2603 case ELFOSABI_OPENVMS: return "VMS - OpenVMS";
2604 case ELFOSABI_NSK: return "HP - Non-Stop Kernel";
2605 case ELFOSABI_AROS: return "AROS";
2606 case ELFOSABI_FENIXOS: return "FenixOS";
2609 switch (elf_header.e_machine)
2614 case ELFOSABI_ARM: return "ARM";
2624 case ELFOSABI_STANDALONE: return _("Standalone App");
2633 case ELFOSABI_C6000_ELFABI: return _("Bare-metal C6000");
2634 case ELFOSABI_C6000_LINUX: return "Linux C6000";
2643 snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
2649 get_arm_segment_type (unsigned long type)
2663 get_mips_segment_type (unsigned long type)
2667 case PT_MIPS_REGINFO:
2669 case PT_MIPS_RTPROC:
2671 case PT_MIPS_OPTIONS:
2681 get_parisc_segment_type (unsigned long type)
2685 case PT_HP_TLS: return "HP_TLS";
2686 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
2687 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
2688 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
2689 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
2690 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
2691 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
2692 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
2693 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
2694 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
2695 case PT_HP_PARALLEL: return "HP_PARALLEL";
2696 case PT_HP_FASTBIND: return "HP_FASTBIND";
2697 case PT_HP_OPT_ANNOT: return "HP_OPT_ANNOT";
2698 case PT_HP_HSL_ANNOT: return "HP_HSL_ANNOT";
2699 case PT_HP_STACK: return "HP_STACK";
2700 case PT_HP_CORE_UTSNAME: return "HP_CORE_UTSNAME";
2701 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
2702 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
2703 case PT_PARISC_WEAKORDER: return "PARISC_WEAKORDER";
2712 get_ia64_segment_type (unsigned long type)
2716 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
2717 case PT_IA_64_UNWIND: return "IA_64_UNWIND";
2718 case PT_HP_TLS: return "HP_TLS";
2719 case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
2720 case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
2721 case PT_IA_64_HP_STACK: return "HP_STACK";
2730 get_tic6x_segment_type (unsigned long type)
2734 case PT_C6000_PHATTR: return "C6000_PHATTR";
2743 get_segment_type (unsigned long p_type)
2745 static char buff[32];
2749 case PT_NULL: return "NULL";
2750 case PT_LOAD: return "LOAD";
2751 case PT_DYNAMIC: return "DYNAMIC";
2752 case PT_INTERP: return "INTERP";
2753 case PT_NOTE: return "NOTE";
2754 case PT_SHLIB: return "SHLIB";
2755 case PT_PHDR: return "PHDR";
2756 case PT_TLS: return "TLS";
2758 case PT_GNU_EH_FRAME:
2759 return "GNU_EH_FRAME";
2760 case PT_GNU_STACK: return "GNU_STACK";
2761 case PT_GNU_RELRO: return "GNU_RELRO";
2764 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
2766 const char * result;
2768 switch (elf_header.e_machine)
2771 result = get_arm_segment_type (p_type);
2774 case EM_MIPS_RS3_LE:
2775 result = get_mips_segment_type (p_type);
2778 result = get_parisc_segment_type (p_type);
2781 result = get_ia64_segment_type (p_type);
2784 result = get_tic6x_segment_type (p_type);
2794 sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
2796 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
2798 const char * result;
2800 switch (elf_header.e_machine)
2803 result = get_parisc_segment_type (p_type);
2806 result = get_ia64_segment_type (p_type);
2816 sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
2819 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
2826 get_mips_section_type_name (unsigned int sh_type)
2830 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
2831 case SHT_MIPS_MSYM: return "MIPS_MSYM";
2832 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
2833 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
2834 case SHT_MIPS_UCODE: return "MIPS_UCODE";
2835 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
2836 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
2837 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
2838 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
2839 case SHT_MIPS_RELD: return "MIPS_RELD";
2840 case SHT_MIPS_IFACE: return "MIPS_IFACE";
2841 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
2842 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
2843 case SHT_MIPS_SHDR: return "MIPS_SHDR";
2844 case SHT_MIPS_FDESC: return "MIPS_FDESC";
2845 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
2846 case SHT_MIPS_DENSE: return "MIPS_DENSE";
2847 case SHT_MIPS_PDESC: return "MIPS_PDESC";
2848 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
2849 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
2850 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
2851 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
2852 case SHT_MIPS_LINE: return "MIPS_LINE";
2853 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
2854 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
2855 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
2856 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
2857 case SHT_MIPS_DWARF: return "MIPS_DWARF";
2858 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
2859 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
2860 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
2861 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
2862 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
2863 case SHT_MIPS_XLATE: return "MIPS_XLATE";
2864 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
2865 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
2866 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
2867 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
2868 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
2876 get_parisc_section_type_name (unsigned int sh_type)
2880 case SHT_PARISC_EXT: return "PARISC_EXT";
2881 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
2882 case SHT_PARISC_DOC: return "PARISC_DOC";
2883 case SHT_PARISC_ANNOT: return "PARISC_ANNOT";
2884 case SHT_PARISC_SYMEXTN: return "PARISC_SYMEXTN";
2885 case SHT_PARISC_STUBS: return "PARISC_STUBS";
2886 case SHT_PARISC_DLKM: return "PARISC_DLKM";
2894 get_ia64_section_type_name (unsigned int sh_type)
2896 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
2897 if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
2898 return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
2902 case SHT_IA_64_EXT: return "IA_64_EXT";
2903 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
2904 case SHT_IA_64_PRIORITY_INIT: return "IA_64_PRIORITY_INIT";
2905 case SHT_IA_64_VMS_TRACE: return "VMS_TRACE";
2906 case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
2907 case SHT_IA_64_VMS_DEBUG: return "VMS_DEBUG";
2908 case SHT_IA_64_VMS_DEBUG_STR: return "VMS_DEBUG_STR";
2909 case SHT_IA_64_VMS_LINKAGES: return "VMS_LINKAGES";
2910 case SHT_IA_64_VMS_SYMBOL_VECTOR: return "VMS_SYMBOL_VECTOR";
2911 case SHT_IA_64_VMS_FIXUP: return "VMS_FIXUP";
2919 get_x86_64_section_type_name (unsigned int sh_type)
2923 case SHT_X86_64_UNWIND: return "X86_64_UNWIND";
2931 get_arm_section_type_name (unsigned int sh_type)
2935 case SHT_ARM_EXIDX: return "ARM_EXIDX";
2936 case SHT_ARM_PREEMPTMAP: return "ARM_PREEMPTMAP";
2937 case SHT_ARM_ATTRIBUTES: return "ARM_ATTRIBUTES";
2938 case SHT_ARM_DEBUGOVERLAY: return "ARM_DEBUGOVERLAY";
2939 case SHT_ARM_OVERLAYSECTION: return "ARM_OVERLAYSECTION";
2947 get_tic6x_section_type_name (unsigned int sh_type)
2951 case SHT_C6000_UNWIND:
2952 return "C6000_UNWIND";
2953 case SHT_C6000_PREEMPTMAP:
2954 return "C6000_PREEMPTMAP";
2955 case SHT_C6000_ATTRIBUTES:
2956 return "C6000_ATTRIBUTES";
2961 case SHT_TI_HANDLER:
2962 return "TI_HANDLER";
2963 case SHT_TI_INITINFO:
2964 return "TI_INITINFO";
2965 case SHT_TI_PHATTRS:
2966 return "TI_PHATTRS";
2974 get_section_type_name (unsigned int sh_type)
2976 static char buff[32];
2980 case SHT_NULL: return "NULL";
2981 case SHT_PROGBITS: return "PROGBITS";
2982 case SHT_SYMTAB: return "SYMTAB";
2983 case SHT_STRTAB: return "STRTAB";
2984 case SHT_RELA: return "RELA";
2985 case SHT_HASH: return "HASH";
2986 case SHT_DYNAMIC: return "DYNAMIC";
2987 case SHT_NOTE: return "NOTE";
2988 case SHT_NOBITS: return "NOBITS";
2989 case SHT_REL: return "REL";
2990 case SHT_SHLIB: return "SHLIB";
2991 case SHT_DYNSYM: return "DYNSYM";
2992 case SHT_INIT_ARRAY: return "INIT_ARRAY";
2993 case SHT_FINI_ARRAY: return "FINI_ARRAY";
2994 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
2995 case SHT_GNU_HASH: return "GNU_HASH";
2996 case SHT_GROUP: return "GROUP";
2997 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICIES";
2998 case SHT_GNU_verdef: return "VERDEF";
2999 case SHT_GNU_verneed: return "VERNEED";
3000 case SHT_GNU_versym: return "VERSYM";
3001 case 0x6ffffff0: return "VERSYM";
3002 case 0x6ffffffc: return "VERDEF";
3003 case 0x7ffffffd: return "AUXILIARY";
3004 case 0x7fffffff: return "FILTER";
3005 case SHT_GNU_LIBLIST: return "GNU_LIBLIST";
3008 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
3010 const char * result;
3012 switch (elf_header.e_machine)
3015 case EM_MIPS_RS3_LE:
3016 result = get_mips_section_type_name (sh_type);
3019 result = get_parisc_section_type_name (sh_type);
3022 result = get_ia64_section_type_name (sh_type);
3026 result = get_x86_64_section_type_name (sh_type);
3029 result = get_arm_section_type_name (sh_type);
3032 result = get_tic6x_section_type_name (sh_type);
3042 sprintf (buff, "LOPROC+%x", sh_type - SHT_LOPROC);
3044 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
3046 const char * result;
3048 switch (elf_header.e_machine)
3051 result = get_ia64_section_type_name (sh_type);
3061 sprintf (buff, "LOOS+%x", sh_type - SHT_LOOS);
3063 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
3064 sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER);
3066 snprintf (buff, sizeof (buff), _("<unknown>: %x"), sh_type);
3072 #define OPTION_DEBUG_DUMP 512
3073 #define OPTION_DYN_SYMS 513
3075 static struct option options[] =
3077 {"all", no_argument, 0, 'a'},
3078 {"file-header", no_argument, 0, 'h'},
3079 {"program-headers", no_argument, 0, 'l'},
3080 {"headers", no_argument, 0, 'e'},
3081 {"histogram", no_argument, 0, 'I'},
3082 {"segments", no_argument, 0, 'l'},
3083 {"sections", no_argument, 0, 'S'},
3084 {"section-headers", no_argument, 0, 'S'},
3085 {"section-groups", no_argument, 0, 'g'},
3086 {"section-details", no_argument, 0, 't'},
3087 {"full-section-name",no_argument, 0, 'N'},
3088 {"symbols", no_argument, 0, 's'},
3089 {"syms", no_argument, 0, 's'},
3090 {"dyn-syms", no_argument, 0, OPTION_DYN_SYMS},
3091 {"relocs", no_argument, 0, 'r'},
3092 {"notes", no_argument, 0, 'n'},
3093 {"dynamic", no_argument, 0, 'd'},
3094 {"arch-specific", no_argument, 0, 'A'},
3095 {"version-info", no_argument, 0, 'V'},
3096 {"use-dynamic", no_argument, 0, 'D'},
3097 {"unwind", no_argument, 0, 'u'},
3098 {"archive-index", no_argument, 0, 'c'},
3099 {"hex-dump", required_argument, 0, 'x'},
3100 {"relocated-dump", required_argument, 0, 'R'},
3101 {"string-dump", required_argument, 0, 'p'},
3102 #ifdef SUPPORT_DISASSEMBLY
3103 {"instruction-dump", required_argument, 0, 'i'},
3105 {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
3107 {"version", no_argument, 0, 'v'},
3108 {"wide", no_argument, 0, 'W'},
3109 {"help", no_argument, 0, 'H'},
3110 {0, no_argument, 0, 0}
3114 usage (FILE * stream)
3116 fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
3117 fprintf (stream, _(" Display information about the contents of ELF format files\n"));
3118 fprintf (stream, _(" Options are:\n\
3119 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3120 -h --file-header Display the ELF file header\n\
3121 -l --program-headers Display the program headers\n\
3122 --segments An alias for --program-headers\n\
3123 -S --section-headers Display the sections' header\n\
3124 --sections An alias for --section-headers\n\
3125 -g --section-groups Display the section groups\n\
3126 -t --section-details Display the section details\n\
3127 -e --headers Equivalent to: -h -l -S\n\
3128 -s --syms Display the symbol table\n\
3129 --symbols An alias for --syms\n\
3130 --dyn-syms Display the dynamic symbol table\n\
3131 -n --notes Display the core notes (if present)\n\
3132 -r --relocs Display the relocations (if present)\n\
3133 -u --unwind Display the unwind info (if present)\n\
3134 -d --dynamic Display the dynamic section (if present)\n\
3135 -V --version-info Display the version sections (if present)\n\
3136 -A --arch-specific Display architecture specific information (if any).\n\
3137 -c --archive-index Display the symbol/file index in an archive\n\
3138 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
3139 -x --hex-dump=<number|name>\n\
3140 Dump the contents of section <number|name> as bytes\n\
3141 -p --string-dump=<number|name>\n\
3142 Dump the contents of section <number|name> as strings\n\
3143 -R --relocated-dump=<number|name>\n\
3144 Dump the contents of section <number|name> as relocated bytes\n\
3145 -w[lLiaprmfFsoRt] or\n\
3146 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
3147 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
3148 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges]\n\
3149 Display the contents of DWARF2 debug sections\n"));
3150 #ifdef SUPPORT_DISASSEMBLY
3151 fprintf (stream, _("\
3152 -i --instruction-dump=<number|name>\n\
3153 Disassemble the contents of section <number|name>\n"));
3155 fprintf (stream, _("\
3156 -I --histogram Display histogram of bucket list lengths\n\
3157 -W --wide Allow output width to exceed 80 characters\n\
3158 @<file> Read options from <file>\n\
3159 -H --help Display this information\n\
3160 -v --version Display the version number of readelf\n"));
3162 if (REPORT_BUGS_TO[0] && stream == stdout)
3163 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
3165 exit (stream == stdout ? 0 : 1);
3168 /* Record the fact that the user wants the contents of section number
3169 SECTION to be displayed using the method(s) encoded as flags bits
3170 in TYPE. Note, TYPE can be zero if we are creating the array for
3174 request_dump_bynumber (unsigned int section, dump_type type)
3176 if (section >= num_dump_sects)
3178 dump_type * new_dump_sects;
3180 new_dump_sects = (dump_type *) calloc (section + 1,
3181 sizeof (* dump_sects));
3183 if (new_dump_sects == NULL)
3184 error (_("Out of memory allocating dump request table.\n"));
3187 /* Copy current flag settings. */
3188 memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
3192 dump_sects = new_dump_sects;
3193 num_dump_sects = section + 1;
3198 dump_sects[section] |= type;
3203 /* Request a dump by section name. */
3206 request_dump_byname (const char * section, dump_type type)
3208 struct dump_list_entry * new_request;
3210 new_request = (struct dump_list_entry *)
3211 malloc (sizeof (struct dump_list_entry));
3213 error (_("Out of memory allocating dump request table.\n"));
3215 new_request->name = strdup (section);
3216 if (!new_request->name)
3217 error (_("Out of memory allocating dump request table.\n"));
3219 new_request->type = type;
3221 new_request->next = dump_sects_byname;
3222 dump_sects_byname = new_request;
3226 request_dump (dump_type type)
3232 section = strtoul (optarg, & cp, 0);
3234 if (! *cp && section >= 0)
3235 request_dump_bynumber (section, type);
3237 request_dump_byname (optarg, type);
3242 parse_args (int argc, char ** argv)
3249 while ((c = getopt_long
3250 (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options, NULL)) != EOF)
3268 do_section_groups++;
3276 do_section_groups++;
3281 do_section_details++;
3325 request_dump (HEX_DUMP);
3328 request_dump (STRING_DUMP);
3331 request_dump (RELOC_DUMP);
3338 dwarf_select_sections_all ();
3343 dwarf_select_sections_by_letters (optarg);
3346 case OPTION_DEBUG_DUMP:
3353 dwarf_select_sections_by_names (optarg);
3356 case OPTION_DYN_SYMS:
3359 #ifdef SUPPORT_DISASSEMBLY
3361 request_dump (DISASS_DUMP);
3365 print_version (program_name);
3374 /* xgettext:c-format */
3375 error (_("Invalid option '-%c'\n"), c);
3382 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
3383 && !do_segments && !do_header && !do_dump && !do_version
3384 && !do_histogram && !do_debugging && !do_arch && !do_notes
3385 && !do_section_groups && !do_archive_index
3390 warn (_("Nothing to do.\n"));
3396 get_elf_class (unsigned int elf_class)
3398 static char buff[32];
3402 case ELFCLASSNONE: return _("none");
3403 case ELFCLASS32: return "ELF32";
3404 case ELFCLASS64: return "ELF64";
3406 snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
3412 get_data_encoding (unsigned int encoding)
3414 static char buff[32];
3418 case ELFDATANONE: return _("none");
3419 case ELFDATA2LSB: return _("2's complement, little endian");
3420 case ELFDATA2MSB: return _("2's complement, big endian");
3422 snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
3427 /* Decode the data held in 'elf_header'. */
3430 process_file_header (void)
3432 if ( elf_header.e_ident[EI_MAG0] != ELFMAG0
3433 || elf_header.e_ident[EI_MAG1] != ELFMAG1
3434 || elf_header.e_ident[EI_MAG2] != ELFMAG2
3435 || elf_header.e_ident[EI_MAG3] != ELFMAG3)
3438 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3442 init_dwarf_regnames (elf_header.e_machine);
3448 printf (_("ELF Header:\n"));
3449 printf (_(" Magic: "));
3450 for (i = 0; i < EI_NIDENT; i++)
3451 printf ("%2.2x ", elf_header.e_ident[i]);
3453 printf (_(" Class: %s\n"),
3454 get_elf_class (elf_header.e_ident[EI_CLASS]));
3455 printf (_(" Data: %s\n"),
3456 get_data_encoding (elf_header.e_ident[EI_DATA]));
3457 printf (_(" Version: %d %s\n"),
3458 elf_header.e_ident[EI_VERSION],
3459 (elf_header.e_ident[EI_VERSION] == EV_CURRENT
3461 : (elf_header.e_ident[EI_VERSION] != EV_NONE
3462 ? _("<unknown: %lx>")
3464 printf (_(" OS/ABI: %s\n"),
3465 get_osabi_name (elf_header.e_ident[EI_OSABI]));
3466 printf (_(" ABI Version: %d\n"),
3467 elf_header.e_ident[EI_ABIVERSION]);
3468 printf (_(" Type: %s\n"),
3469 get_file_type (elf_header.e_type));
3470 printf (_(" Machine: %s\n"),
3471 get_machine_name (elf_header.e_machine));
3472 printf (_(" Version: 0x%lx\n"),
3473 (unsigned long) elf_header.e_version);
3475 printf (_(" Entry point address: "));
3476 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
3477 printf (_("\n Start of program headers: "));
3478 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
3479 printf (_(" (bytes into file)\n Start of section headers: "));
3480 print_vma ((bfd_vma) elf_header.e_shoff, DEC);
3481 printf (_(" (bytes into file)\n"));
3483 printf (_(" Flags: 0x%lx%s\n"),
3484 (unsigned long) elf_header.e_flags,
3485 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
3486 printf (_(" Size of this header: %ld (bytes)\n"),
3487 (long) elf_header.e_ehsize);
3488 printf (_(" Size of program headers: %ld (bytes)\n"),
3489 (long) elf_header.e_phentsize);
3490 printf (_(" Number of program headers: %ld"),
3491 (long) elf_header.e_phnum);
3492 if (section_headers != NULL
3493 && elf_header.e_phnum == PN_XNUM
3494 && section_headers[0].sh_info != 0)
3495 printf (" (%ld)", (long) section_headers[0].sh_info);
3496 putc ('\n', stdout);
3497 printf (_(" Size of section headers: %ld (bytes)\n"),
3498 (long) elf_header.e_shentsize);
3499 printf (_(" Number of section headers: %ld"),
3500 (long) elf_header.e_shnum);
3501 if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
3502 printf (" (%ld)", (long) section_headers[0].sh_size);
3503 putc ('\n', stdout);
3504 printf (_(" Section header string table index: %ld"),
3505 (long) elf_header.e_shstrndx);
3506 if (section_headers != NULL
3507 && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
3508 printf (" (%u)", section_headers[0].sh_link);
3509 else if (elf_header.e_shstrndx != SHN_UNDEF
3510 && elf_header.e_shstrndx >= elf_header.e_shnum)
3511 printf (_(" <corrupt: out of range>"));
3512 putc ('\n', stdout);
3515 if (section_headers != NULL)
3517 if (elf_header.e_phnum == PN_XNUM
3518 && section_headers[0].sh_info != 0)
3519 elf_header.e_phnum = section_headers[0].sh_info;
3520 if (elf_header.e_shnum == SHN_UNDEF)
3521 elf_header.e_shnum = section_headers[0].sh_size;
3522 if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
3523 elf_header.e_shstrndx = section_headers[0].sh_link;
3524 else if (elf_header.e_shstrndx >= elf_header.e_shnum)
3525 elf_header.e_shstrndx = SHN_UNDEF;
3526 free (section_headers);
3527 section_headers = NULL;
3535 get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
3537 Elf32_External_Phdr * phdrs;
3538 Elf32_External_Phdr * external;
3539 Elf_Internal_Phdr * internal;
3542 phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
3543 elf_header.e_phentsize,
3545 _("program headers"));
3549 for (i = 0, internal = pheaders, external = phdrs;
3550 i < elf_header.e_phnum;
3551 i++, internal++, external++)
3553 internal->p_type = BYTE_GET (external->p_type);
3554 internal->p_offset = BYTE_GET (external->p_offset);
3555 internal->p_vaddr = BYTE_GET (external->p_vaddr);
3556 internal->p_paddr = BYTE_GET (external->p_paddr);
3557 internal->p_filesz = BYTE_GET (external->p_filesz);
3558 internal->p_memsz = BYTE_GET (external->p_memsz);
3559 internal->p_flags = BYTE_GET (external->p_flags);
3560 internal->p_align = BYTE_GET (external->p_align);
3569 get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
3571 Elf64_External_Phdr * phdrs;
3572 Elf64_External_Phdr * external;
3573 Elf_Internal_Phdr * internal;
3576 phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
3577 elf_header.e_phentsize,
3579 _("program headers"));
3583 for (i = 0, internal = pheaders, external = phdrs;
3584 i < elf_header.e_phnum;
3585 i++, internal++, external++)
3587 internal->p_type = BYTE_GET (external->p_type);
3588 internal->p_flags = BYTE_GET (external->p_flags);
3589 internal->p_offset = BYTE_GET (external->p_offset);
3590 internal->p_vaddr = BYTE_GET (external->p_vaddr);
3591 internal->p_paddr = BYTE_GET (external->p_paddr);
3592 internal->p_filesz = BYTE_GET (external->p_filesz);
3593 internal->p_memsz = BYTE_GET (external->p_memsz);
3594 internal->p_align = BYTE_GET (external->p_align);
3602 /* Returns 1 if the program headers were read into `program_headers'. */
3605 get_program_headers (FILE * file)
3607 Elf_Internal_Phdr * phdrs;
3609 /* Check cache of prior read. */
3610 if (program_headers != NULL)
3613 phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
3614 sizeof (Elf_Internal_Phdr));
3618 error (_("Out of memory\n"));
3623 ? get_32bit_program_headers (file, phdrs)
3624 : get_64bit_program_headers (file, phdrs))
3626 program_headers = phdrs;
3634 /* Returns 1 if the program headers were loaded. */
3637 process_program_headers (FILE * file)
3639 Elf_Internal_Phdr * segment;
3642 if (elf_header.e_phnum == 0)
3644 /* PR binutils/12467. */
3645 if (elf_header.e_phoff != 0)
3646 warn (_("possibly corrupt ELF header - it has a non-zero program"
3647 " header offset, but no program headers"));
3648 else if (do_segments)
3649 printf (_("\nThere are no program headers in this file.\n"));
3653 if (do_segments && !do_header)
3655 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
3656 printf (_("Entry point "));
3657 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
3658 printf (_("\nThere are %d program headers, starting at offset "),
3659 elf_header.e_phnum);
3660 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
3664 if (! get_program_headers (file))
3669 if (elf_header.e_phnum > 1)
3670 printf (_("\nProgram Headers:\n"));
3672 printf (_("\nProgram Headers:\n"));
3676 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3679 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3683 (_(" Type Offset VirtAddr PhysAddr\n"));
3685 (_(" FileSiz MemSiz Flags Align\n"));
3692 for (i = 0, segment = program_headers;
3693 i < elf_header.e_phnum;
3698 printf (" %-14.14s ", get_segment_type (segment->p_type));
3702 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
3703 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
3704 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
3705 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
3706 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
3708 (segment->p_flags & PF_R ? 'R' : ' '),
3709 (segment->p_flags & PF_W ? 'W' : ' '),
3710 (segment->p_flags & PF_X ? 'E' : ' '));
3711 printf ("%#lx", (unsigned long) segment->p_align);
3715 if ((unsigned long) segment->p_offset == segment->p_offset)
3716 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
3719 print_vma (segment->p_offset, FULL_HEX);
3723 print_vma (segment->p_vaddr, FULL_HEX);
3725 print_vma (segment->p_paddr, FULL_HEX);
3728 if ((unsigned long) segment->p_filesz == segment->p_filesz)
3729 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
3732 print_vma (segment->p_filesz, FULL_HEX);
3736 if ((unsigned long) segment->p_memsz == segment->p_memsz)
3737 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
3740 print_vma (segment->p_offset, FULL_HEX);
3744 (segment->p_flags & PF_R ? 'R' : ' '),
3745 (segment->p_flags & PF_W ? 'W' : ' '),
3746 (segment->p_flags & PF_X ? 'E' : ' '));
3748 if ((unsigned long) segment->p_align == segment->p_align)
3749 printf ("%#lx", (unsigned long) segment->p_align);
3752 print_vma (segment->p_align, PREFIX_HEX);
3757 print_vma (segment->p_offset, FULL_HEX);
3759 print_vma (segment->p_vaddr, FULL_HEX);
3761 print_vma (segment->p_paddr, FULL_HEX);
3763 print_vma (segment->p_filesz, FULL_HEX);
3765 print_vma (segment->p_memsz, FULL_HEX);
3767 (segment->p_flags & PF_R ? 'R' : ' '),
3768 (segment->p_flags & PF_W ? 'W' : ' '),
3769 (segment->p_flags & PF_X ? 'E' : ' '));
3770 print_vma (segment->p_align, HEX);
3774 switch (segment->p_type)
3778 error (_("more than one dynamic segment\n"));
3780 /* By default, assume that the .dynamic section is the first
3781 section in the DYNAMIC segment. */
3782 dynamic_addr = segment->p_offset;
3783 dynamic_size = segment->p_filesz;
3785 /* Try to locate the .dynamic section. If there is
3786 a section header table, we can easily locate it. */
3787 if (section_headers != NULL)
3789 Elf_Internal_Shdr * sec;
3791 sec = find_section (".dynamic");
3792 if (sec == NULL || sec->sh_size == 0)
3794 /* A corresponding .dynamic section is expected, but on
3795 IA-64/OpenVMS it is OK for it to be missing. */
3796 if (!is_ia64_vms ())
3797 error (_("no .dynamic section in the dynamic segment\n"));
3801 if (sec->sh_type == SHT_NOBITS)
3807 dynamic_addr = sec->sh_offset;
3808 dynamic_size = sec->sh_size;
3810 if (dynamic_addr < segment->p_offset
3811 || dynamic_addr > segment->p_offset + segment->p_filesz)
3812 warn (_("the .dynamic section is not contained"
3813 " within the dynamic segment\n"));
3814 else if (dynamic_addr > segment->p_offset)
3815 warn (_("the .dynamic section is not the first section"
3816 " in the dynamic segment.\n"));
3821 if (fseek (file, archive_file_offset + (long) segment->p_offset,
3823 error (_("Unable to find program interpreter name\n"));
3827 int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX);
3829 if (ret >= (int) sizeof (fmt) || ret < 0)
3830 error (_("Internal error: failed to create format string to display program interpreter\n"));
3832 program_interpreter[0] = 0;
3833 if (fscanf (file, fmt, program_interpreter) <= 0)
3834 error (_("Unable to read program interpreter name\n"));
3837 printf (_("\n [Requesting program interpreter: %s]"),
3838 program_interpreter);
3844 putc ('\n', stdout);
3847 if (do_segments && section_headers != NULL && string_table != NULL)
3849 printf (_("\n Section to Segment mapping:\n"));
3850 printf (_(" Segment Sections...\n"));
3852 for (i = 0; i < elf_header.e_phnum; i++)
3855 Elf_Internal_Shdr * section;
3857 segment = program_headers + i;
3858 section = section_headers + 1;
3860 printf (" %2.2d ", i);
3862 for (j = 1; j < elf_header.e_shnum; j++, section++)
3864 if (!ELF_TBSS_SPECIAL (section, segment)
3865 && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
3866 printf ("%s ", SECTION_NAME (section));
3877 /* Find the file offset corresponding to VMA by using the program headers. */
3880 offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
3882 Elf_Internal_Phdr * seg;
3884 if (! get_program_headers (file))
3886 warn (_("Cannot interpret virtual addresses without program headers.\n"));
3890 for (seg = program_headers;
3891 seg < program_headers + elf_header.e_phnum;
3894 if (seg->p_type != PT_LOAD)
3897 if (vma >= (seg->p_vaddr & -seg->p_align)
3898 && vma + size <= seg->p_vaddr + seg->p_filesz)
3899 return vma - seg->p_vaddr + seg->p_offset;
3902 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
3903 (unsigned long) vma);
3909 get_32bit_section_headers (FILE * file, unsigned int num)
3911 Elf32_External_Shdr * shdrs;
3912 Elf_Internal_Shdr * internal;
3915 shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
3916 elf_header.e_shentsize, num,
3917 _("section headers"));
3921 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
3922 sizeof (Elf_Internal_Shdr));
3924 if (section_headers == NULL)
3926 error (_("Out of memory\n"));
3930 for (i = 0, internal = section_headers;
3934 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
3935 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
3936 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
3937 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
3938 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
3939 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
3940 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
3941 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
3942 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
3943 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
3952 get_64bit_section_headers (FILE * file, unsigned int num)
3954 Elf64_External_Shdr * shdrs;
3955 Elf_Internal_Shdr * internal;
3958 shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
3959 elf_header.e_shentsize, num,
3960 _("section headers"));
3964 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
3965 sizeof (Elf_Internal_Shdr));
3967 if (section_headers == NULL)
3969 error (_("Out of memory\n"));
3973 for (i = 0, internal = section_headers;
3977 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
3978 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
3979 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
3980 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
3981 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
3982 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
3983 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
3984 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
3985 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
3986 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
3994 static Elf_Internal_Sym *
3995 get_32bit_elf_symbols (FILE * file, Elf_Internal_Shdr * section)
3997 unsigned long number;
3998 Elf32_External_Sym * esyms = NULL;
3999 Elf_External_Sym_Shndx * shndx;
4000 Elf_Internal_Sym * isyms = NULL;
4001 Elf_Internal_Sym * psym;
4004 /* Run some sanity checks first. */
4005 if (section->sh_entsize == 0)
4007 error (_("sh_entsize is zero\n"));
4011 number = section->sh_size / section->sh_entsize;
4013 if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
4015 error (_("Invalid sh_entsize\n"));
4019 esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4020 section->sh_size, _("symbols"));
4025 if (symtab_shndx_hdr != NULL
4026 && (symtab_shndx_hdr->sh_link
4027 == (unsigned long) (section - section_headers)))
4029 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4030 symtab_shndx_hdr->sh_offset,
4031 1, symtab_shndx_hdr->sh_size,
4037 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
4041 error (_("Out of memory\n"));
4045 for (j = 0, psym = isyms; j < number; j++, psym++)
4047 psym->st_name = BYTE_GET (esyms[j].st_name);
4048 psym->st_value = BYTE_GET (esyms[j].st_value);
4049 psym->st_size = BYTE_GET (esyms[j].st_size);
4050 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4051 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
4053 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4054 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4055 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
4056 psym->st_info = BYTE_GET (esyms[j].st_info);
4057 psym->st_other = BYTE_GET (esyms[j].st_other);
4069 static Elf_Internal_Sym *
4070 get_64bit_elf_symbols (FILE * file, Elf_Internal_Shdr * section)
4072 unsigned long number;
4073 Elf64_External_Sym * esyms;
4074 Elf_External_Sym_Shndx * shndx;
4075 Elf_Internal_Sym * isyms;
4076 Elf_Internal_Sym * psym;
4079 /* Run some sanity checks first. */
4080 if (section->sh_entsize == 0)
4082 error (_("sh_entsize is zero\n"));
4086 number = section->sh_size / section->sh_entsize;
4088 if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
4090 error (_("Invalid sh_entsize\n"));
4094 esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4095 section->sh_size, _("symbols"));
4100 if (symtab_shndx_hdr != NULL
4101 && (symtab_shndx_hdr->sh_link
4102 == (unsigned long) (section - section_headers)))
4104 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4105 symtab_shndx_hdr->sh_offset,
4106 1, symtab_shndx_hdr->sh_size,
4115 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
4119 error (_("Out of memory\n"));
4126 for (j = 0, psym = isyms;
4130 psym->st_name = BYTE_GET (esyms[j].st_name);
4131 psym->st_info = BYTE_GET (esyms[j].st_info);
4132 psym->st_other = BYTE_GET (esyms[j].st_other);
4133 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4134 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
4136 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4137 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4138 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
4139 psym->st_value = BYTE_GET (esyms[j].st_value);
4140 psym->st_size = BYTE_GET (esyms[j].st_size);
4151 get_elf_section_flags (bfd_vma sh_flags)
4153 static char buff[1024];
4155 int field_size = is_32bit_elf ? 8 : 16;
4157 int size = sizeof (buff) - (field_size + 4 + 1);
4158 bfd_vma os_flags = 0;
4159 bfd_vma proc_flags = 0;
4160 bfd_vma unknown_flags = 0;
4168 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
4169 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
4170 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
4171 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
4172 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
4173 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
4174 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
4175 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
4176 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
4177 /* 9 */ { STRING_COMMA_LEN ("TLS") },
4178 /* IA-64 specific. */
4179 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
4180 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
4181 /* IA-64 OpenVMS specific. */
4182 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
4183 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
4184 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
4185 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
4186 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
4187 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
4189 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
4190 /* SPARC specific. */
4191 /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
4194 if (do_section_details)
4196 sprintf (buff, "[%*.*lx]: ",
4197 field_size, field_size, (unsigned long) sh_flags);
4198 p += field_size + 4;
4205 flag = sh_flags & - sh_flags;
4208 if (do_section_details)
4212 case SHF_WRITE: sindex = 0; break;
4213 case SHF_ALLOC: sindex = 1; break;
4214 case SHF_EXECINSTR: sindex = 2; break;
4215 case SHF_MERGE: sindex = 3; break;
4216 case SHF_STRINGS: sindex = 4; break;
4217 case SHF_INFO_LINK: sindex = 5; break;
4218 case SHF_LINK_ORDER: sindex = 6; break;
4219 case SHF_OS_NONCONFORMING: sindex = 7; break;
4220 case SHF_GROUP: sindex = 8; break;
4221 case SHF_TLS: sindex = 9; break;
4222 case SHF_EXCLUDE: sindex = 18; break;
4226 switch (elf_header.e_machine)
4229 if (flag == SHF_IA_64_SHORT)
4231 else if (flag == SHF_IA_64_NORECOV)
4234 else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
4237 case SHF_IA_64_VMS_GLOBAL: sindex = 12; break;
4238 case SHF_IA_64_VMS_OVERLAID: sindex = 13; break;
4239 case SHF_IA_64_VMS_SHARED: sindex = 14; break;
4240 case SHF_IA_64_VMS_VECTOR: sindex = 15; break;
4241 case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
4242 case SHF_IA_64_VMS_PROTECTED: sindex = 17; break;
4252 case EM_OLD_SPARCV9:
4253 case EM_SPARC32PLUS:
4256 if (flag == SHF_ORDERED)
4266 if (p != buff + field_size + 4)
4268 if (size < (10 + 2))
4275 size -= flags [sindex].len;
4276 p = stpcpy (p, flags [sindex].str);
4278 else if (flag & SHF_MASKOS)
4280 else if (flag & SHF_MASKPROC)
4283 unknown_flags |= flag;
4289 case SHF_WRITE: *p = 'W'; break;
4290 case SHF_ALLOC: *p = 'A'; break;
4291 case SHF_EXECINSTR: *p = 'X'; break;
4292 case SHF_MERGE: *p = 'M'; break;
4293 case SHF_STRINGS: *p = 'S'; break;
4294 case SHF_INFO_LINK: *p = 'I'; break;
4295 case SHF_LINK_ORDER: *p = 'L'; break;
4296 case SHF_OS_NONCONFORMING: *p = 'O'; break;
4297 case SHF_GROUP: *p = 'G'; break;
4298 case SHF_TLS: *p = 'T'; break;
4299 case SHF_EXCLUDE: *p = 'E'; break;
4302 if ((elf_header.e_machine == EM_X86_64
4303 || elf_header.e_machine == EM_L1OM)
4304 && flag == SHF_X86_64_LARGE)
4306 else if (flag & SHF_MASKOS)
4309 sh_flags &= ~ SHF_MASKOS;
4311 else if (flag & SHF_MASKPROC)
4314 sh_flags &= ~ SHF_MASKPROC;
4324 if (do_section_details)
4328 size -= 5 + field_size;
4329 if (p != buff + field_size + 4)
4337 sprintf (p, "OS (%*.*lx)", field_size, field_size,
4338 (unsigned long) os_flags);
4339 p += 5 + field_size;
4343 size -= 7 + field_size;
4344 if (p != buff + field_size + 4)
4352 sprintf (p, "PROC (%*.*lx)", field_size, field_size,
4353 (unsigned long) proc_flags);
4354 p += 7 + field_size;
4358 size -= 10 + field_size;
4359 if (p != buff + field_size + 4)
4367 sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
4368 (unsigned long) unknown_flags);
4369 p += 10 + field_size;
4378 process_section_headers (FILE * file)
4380 Elf_Internal_Shdr * section;
4383 section_headers = NULL;
4385 if (elf_header.e_shnum == 0)
4387 /* PR binutils/12467. */
4388 if (elf_header.e_shoff != 0)
4389 warn (_("possibly corrupt ELF file header - it has a non-zero"
4390 " section header offset, but no section headers\n"));
4391 else if (do_sections)
4392 printf (_("\nThere are no sections in this file.\n"));
4397 if (do_sections && !do_header)
4398 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
4399 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
4403 if (! get_32bit_section_headers (file, elf_header.e_shnum))
4406 else if (! get_64bit_section_headers (file, elf_header.e_shnum))
4409 /* Read in the string table, so that we have names to display. */
4410 if (elf_header.e_shstrndx != SHN_UNDEF
4411 && elf_header.e_shstrndx < elf_header.e_shnum)
4413 section = section_headers + elf_header.e_shstrndx;
4415 if (section->sh_size != 0)
4417 string_table = (char *) get_data (NULL, file, section->sh_offset,
4418 1, section->sh_size,
4421 string_table_length = string_table != NULL ? section->sh_size : 0;
4425 /* Scan the sections for the dynamic symbol table
4426 and dynamic string table and debug sections. */
4427 dynamic_symbols = NULL;
4428 dynamic_strings = NULL;
4429 dynamic_syminfo = NULL;
4430 symtab_shndx_hdr = NULL;
4432 eh_addr_size = is_32bit_elf ? 4 : 8;
4433 switch (elf_header.e_machine)
4436 case EM_MIPS_RS3_LE:
4437 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
4438 FDE addresses. However, the ABI also has a semi-official ILP32
4439 variant for which the normal FDE address size rules apply.
4441 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
4442 section, where XX is the size of longs in bits. Unfortunately,
4443 earlier compilers provided no way of distinguishing ILP32 objects
4444 from LP64 objects, so if there's any doubt, we should assume that
4445 the official LP64 form is being used. */
4446 if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
4447 && find_section (".gcc_compiled_long32") == NULL)
4453 switch (elf_header.e_flags & EF_H8_MACH)
4455 case E_H8_MACH_H8300:
4456 case E_H8_MACH_H8300HN:
4457 case E_H8_MACH_H8300SN:
4458 case E_H8_MACH_H8300SXN:
4461 case E_H8_MACH_H8300H:
4462 case E_H8_MACH_H8300S:
4463 case E_H8_MACH_H8300SX:
4471 switch (elf_header.e_flags & EF_M32C_CPU_MASK)
4473 case EF_M32C_CPU_M16C:
4480 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
4483 size_t expected_entsize \
4484 = is_32bit_elf ? size32 : size64; \
4485 if (section->sh_entsize != expected_entsize) \
4486 error (_("Section %d has invalid sh_entsize %lx (expected %lx)\n"), \
4487 i, (unsigned long int) section->sh_entsize, \
4488 (unsigned long int) expected_entsize); \
4489 section->sh_entsize = expected_entsize; \
4492 #define CHECK_ENTSIZE(section, i, type) \
4493 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
4494 sizeof (Elf64_External_##type))
4496 for (i = 0, section = section_headers;
4497 i < elf_header.e_shnum;
4500 char * name = SECTION_NAME (section);
4502 if (section->sh_type == SHT_DYNSYM)
4504 if (dynamic_symbols != NULL)
4506 error (_("File contains multiple dynamic symbol tables\n"));
4510 CHECK_ENTSIZE (section, i, Sym);
4511 num_dynamic_syms = section->sh_size / section->sh_entsize;
4512 dynamic_symbols = GET_ELF_SYMBOLS (file, section);
4514 else if (section->sh_type == SHT_STRTAB
4515 && streq (name, ".dynstr"))
4517 if (dynamic_strings != NULL)
4519 error (_("File contains multiple dynamic string tables\n"));
4523 dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
4524 1, section->sh_size,
4525 _("dynamic strings"));
4526 dynamic_strings_length = section->sh_size;
4528 else if (section->sh_type == SHT_SYMTAB_SHNDX)
4530 if (symtab_shndx_hdr != NULL)
4532 error (_("File contains multiple symtab shndx tables\n"));
4535 symtab_shndx_hdr = section;
4537 else if (section->sh_type == SHT_SYMTAB)
4538 CHECK_ENTSIZE (section, i, Sym);
4539 else if (section->sh_type == SHT_GROUP)
4540 CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
4541 else if (section->sh_type == SHT_REL)
4542 CHECK_ENTSIZE (section, i, Rel);
4543 else if (section->sh_type == SHT_RELA)
4544 CHECK_ENTSIZE (section, i, Rela);
4545 else if ((do_debugging || do_debug_info || do_debug_abbrevs
4546 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
4547 || do_debug_aranges || do_debug_frames || do_debug_macinfo
4548 || do_debug_str || do_debug_loc || do_debug_ranges)
4549 && (const_strneq (name, ".debug_")
4550 || const_strneq (name, ".zdebug_")))
4553 name += sizeof (".zdebug_") - 1;
4555 name += sizeof (".debug_") - 1;
4558 || (do_debug_info && streq (name, "info"))
4559 || (do_debug_info && streq (name, "types"))
4560 || (do_debug_abbrevs && streq (name, "abbrev"))
4561 || (do_debug_lines && streq (name, "line"))
4562 || (do_debug_pubnames && streq (name, "pubnames"))
4563 || (do_debug_pubtypes && streq (name, "pubtypes"))
4564 || (do_debug_aranges && streq (name, "aranges"))
4565 || (do_debug_ranges && streq (name, "ranges"))
4566 || (do_debug_frames && streq (name, "frame"))
4567 || (do_debug_macinfo && streq (name, "macinfo"))
4568 || (do_debug_str && streq (name, "str"))
4569 || (do_debug_loc && streq (name, "loc"))
4571 request_dump_bynumber (i, DEBUG_DUMP);
4573 /* Linkonce section to be combined with .debug_info at link time. */
4574 else if ((do_debugging || do_debug_info)
4575 && const_strneq (name, ".gnu.linkonce.wi."))
4576 request_dump_bynumber (i, DEBUG_DUMP);
4577 else if (do_debug_frames && streq (name, ".eh_frame"))
4578 request_dump_bynumber (i, DEBUG_DUMP);
4579 else if (do_gdb_index && streq (name, ".gdb_index"))
4580 request_dump_bynumber (i, DEBUG_DUMP);
4581 /* Trace sections for Itanium VMS. */
4582 else if ((do_debugging || do_trace_info || do_trace_abbrevs
4583 || do_trace_aranges)
4584 && const_strneq (name, ".trace_"))
4586 name += sizeof (".trace_") - 1;
4589 || (do_trace_info && streq (name, "info"))
4590 || (do_trace_abbrevs && streq (name, "abbrev"))
4591 || (do_trace_aranges && streq (name, "aranges"))
4593 request_dump_bynumber (i, DEBUG_DUMP);
4601 if (elf_header.e_shnum > 1)
4602 printf (_("\nSection Headers:\n"));
4604 printf (_("\nSection Header:\n"));
4608 if (do_section_details)
4610 printf (_(" [Nr] Name\n"));
4611 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
4615 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
4619 if (do_section_details)
4621 printf (_(" [Nr] Name\n"));
4622 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
4626 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
4630 if (do_section_details)
4632 printf (_(" [Nr] Name\n"));
4633 printf (_(" Type Address Offset Link\n"));
4634 printf (_(" Size EntSize Info Align\n"));
4638 printf (_(" [Nr] Name Type Address Offset\n"));
4639 printf (_(" Size EntSize Flags Link Info Align\n"));
4643 if (do_section_details)
4644 printf (_(" Flags\n"));
4646 for (i = 0, section = section_headers;
4647 i < elf_header.e_shnum;
4650 if (do_section_details)
4652 printf (" [%2u] %s\n",
4654 SECTION_NAME (section));
4655 if (is_32bit_elf || do_wide)
4656 printf (" %-15.15s ",
4657 get_section_type_name (section->sh_type));
4660 printf ((do_wide ? " [%2u] %-17s %-15s "
4661 : " [%2u] %-17.17s %-15.15s "),
4663 SECTION_NAME (section),
4664 get_section_type_name (section->sh_type));
4668 const char * link_too_big = NULL;
4670 print_vma (section->sh_addr, LONG_HEX);
4672 printf ( " %6.6lx %6.6lx %2.2lx",
4673 (unsigned long) section->sh_offset,
4674 (unsigned long) section->sh_size,
4675 (unsigned long) section->sh_entsize);
4677 if (do_section_details)
4678 fputs (" ", stdout);
4680 printf (" %3s ", get_elf_section_flags (section->sh_flags));
4682 if (section->sh_link >= elf_header.e_shnum)
4685 /* The sh_link value is out of range. Normally this indicates
4686 an error but it can have special values in Solaris binaries. */
4687 switch (elf_header.e_machine)
4693 case EM_OLD_SPARCV9:
4694 case EM_SPARC32PLUS:
4697 if (section->sh_link == (SHN_BEFORE & 0xffff))
4698 link_too_big = "BEFORE";
4699 else if (section->sh_link == (SHN_AFTER & 0xffff))
4700 link_too_big = "AFTER";
4707 if (do_section_details)
4709 if (link_too_big != NULL && * link_too_big)
4710 printf ("<%s> ", link_too_big);
4712 printf ("%2u ", section->sh_link);
4713 printf ("%3u %2lu\n", section->sh_info,
4714 (unsigned long) section->sh_addralign);
4717 printf ("%2u %3u %2lu\n",
4720 (unsigned long) section->sh_addralign);
4722 if (link_too_big && ! * link_too_big)
4723 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
4724 i, section->sh_link);
4728 print_vma (section->sh_addr, LONG_HEX);
4730 if ((long) section->sh_offset == section->sh_offset)
4731 printf (" %6.6lx", (unsigned long) section->sh_offset);
4735 print_vma (section->sh_offset, LONG_HEX);
4738 if ((unsigned long) section->sh_size == section->sh_size)
4739 printf (" %6.6lx", (unsigned long) section->sh_size);
4743 print_vma (section->sh_size, LONG_HEX);
4746 if ((unsigned long) section->sh_entsize == section->sh_entsize)
4747 printf (" %2.2lx", (unsigned long) section->sh_entsize);
4751 print_vma (section->sh_entsize, LONG_HEX);
4754 if (do_section_details)
4755 fputs (" ", stdout);
4757 printf (" %3s ", get_elf_section_flags (section->sh_flags));
4759 printf ("%2u %3u ", section->sh_link, section->sh_info);
4761 if ((unsigned long) section->sh_addralign == section->sh_addralign)
4762 printf ("%2lu\n", (unsigned long) section->sh_addralign);
4765 print_vma (section->sh_addralign, DEC);
4769 else if (do_section_details)
4771 printf (" %-15.15s ",
4772 get_section_type_name (section->sh_type));
4773 print_vma (section->sh_addr, LONG_HEX);
4774 if ((long) section->sh_offset == section->sh_offset)
4775 printf (" %16.16lx", (unsigned long) section->sh_offset);
4779 print_vma (section->sh_offset, LONG_HEX);
4781 printf (" %u\n ", section->sh_link);
4782 print_vma (section->sh_size, LONG_HEX);
4784 print_vma (section->sh_entsize, LONG_HEX);
4786 printf (" %-16u %lu\n",
4788 (unsigned long) section->sh_addralign);
4793 print_vma (section->sh_addr, LONG_HEX);
4794 if ((long) section->sh_offset == section->sh_offset)
4795 printf (" %8.8lx", (unsigned long) section->sh_offset);
4799 print_vma (section->sh_offset, LONG_HEX);
4802 print_vma (section->sh_size, LONG_HEX);
4804 print_vma (section->sh_entsize, LONG_HEX);
4806 printf (" %3s ", get_elf_section_flags (section->sh_flags));
4808 printf (" %2u %3u %lu\n",
4811 (unsigned long) section->sh_addralign);
4814 if (do_section_details)
4815 printf (" %s\n", get_elf_section_flags (section->sh_flags));
4818 if (!do_section_details)
4820 if (elf_header.e_machine == EM_X86_64
4821 || elf_header.e_machine == EM_L1OM)
4822 printf (_("Key to Flags:\n\
4823 W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
4824 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
4825 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
4827 printf (_("Key to Flags:\n\
4828 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
4829 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
4830 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
4837 get_group_flags (unsigned int flags)
4839 static char buff[32];
4849 snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x] "), flags);
4856 process_section_groups (FILE * file)
4858 Elf_Internal_Shdr * section;
4860 struct group * group;
4861 Elf_Internal_Shdr * symtab_sec;
4862 Elf_Internal_Shdr * strtab_sec;
4863 Elf_Internal_Sym * symtab;
4867 /* Don't process section groups unless needed. */
4868 if (!do_unwind && !do_section_groups)
4871 if (elf_header.e_shnum == 0)
4873 if (do_section_groups)
4874 printf (_("\nThere are no sections to group in this file.\n"));
4879 if (section_headers == NULL)
4881 error (_("Section headers are not available!\n"));
4885 section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
4886 sizeof (struct group *));
4888 if (section_headers_groups == NULL)
4890 error (_("Out of memory\n"));
4894 /* Scan the sections for the group section. */
4896 for (i = 0, section = section_headers;
4897 i < elf_header.e_shnum;
4899 if (section->sh_type == SHT_GROUP)
4902 if (group_count == 0)
4904 if (do_section_groups)
4905 printf (_("\nThere are no section groups in this file.\n"));
4910 section_groups = (struct group *) calloc (group_count, sizeof (struct group));
4912 if (section_groups == NULL)
4914 error (_("Out of memory\n"));
4923 for (i = 0, section = section_headers, group = section_groups;
4924 i < elf_header.e_shnum;
4927 if (section->sh_type == SHT_GROUP)
4929 char * name = SECTION_NAME (section);
4931 unsigned char * start;
4932 unsigned char * indices;
4933 unsigned int entry, j, size;
4934 Elf_Internal_Shdr * sec;
4935 Elf_Internal_Sym * sym;
4937 /* Get the symbol table. */
4938 if (section->sh_link >= elf_header.e_shnum
4939 || ((sec = section_headers + section->sh_link)->sh_type
4942 error (_("Bad sh_link in group section `%s'\n"), name);
4946 if (symtab_sec != sec)
4951 symtab = GET_ELF_SYMBOLS (file, symtab_sec);
4956 error (_("Corrupt header in group section `%s'\n"), name);
4960 sym = symtab + section->sh_info;
4962 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
4964 if (sym->st_shndx == 0
4965 || sym->st_shndx >= elf_header.e_shnum)
4967 error (_("Bad sh_info in group section `%s'\n"), name);
4971 group_name = SECTION_NAME (section_headers + sym->st_shndx);
4980 /* Get the string table. */
4981 if (symtab_sec->sh_link >= elf_header.e_shnum)
4990 != (sec = section_headers + symtab_sec->sh_link))
4995 strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
4996 1, strtab_sec->sh_size,
4998 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
5000 group_name = sym->st_name < strtab_size
5001 ? strtab + sym->st_name : _("<corrupt>");
5004 start = (unsigned char *) get_data (NULL, file, section->sh_offset,
5005 1, section->sh_size,
5009 size = (section->sh_size / section->sh_entsize) - 1;
5010 entry = byte_get (indices, 4);
5013 if (do_section_groups)
5015 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
5016 get_group_flags (entry), i, name, group_name, size);
5018 printf (_(" [Index] Name\n"));
5021 group->group_index = i;
5023 for (j = 0; j < size; j++)
5025 struct group_list * g;
5027 entry = byte_get (indices, 4);
5030 if (entry >= elf_header.e_shnum)
5032 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
5033 entry, i, elf_header.e_shnum - 1);
5037 if (section_headers_groups [entry] != NULL)
5041 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
5043 section_headers_groups [entry]->group_index);
5048 /* Intel C/C++ compiler may put section 0 in a
5049 section group. We just warn it the first time
5050 and ignore it afterwards. */
5051 static int warned = 0;
5054 error (_("section 0 in group section [%5u]\n"),
5055 section_headers_groups [entry]->group_index);
5061 section_headers_groups [entry] = group;
5063 if (do_section_groups)
5065 sec = section_headers + entry;
5066 printf (" [%5u] %s\n", entry, SECTION_NAME (sec));
5069 g = (struct group_list *) xmalloc (sizeof (struct group_list));
5070 g->section_index = entry;
5071 g->next = group->root;
5089 /* Data used to display dynamic fixups. */
5091 struct ia64_vms_dynfixup
5093 bfd_vma needed_ident; /* Library ident number. */
5094 bfd_vma needed; /* Index in the dstrtab of the library name. */
5095 bfd_vma fixup_needed; /* Index of the library. */
5096 bfd_vma fixup_rela_cnt; /* Number of fixups. */
5097 bfd_vma fixup_rela_off; /* Fixups offset in the dynamic segment. */
5100 /* Data used to display dynamic relocations. */
5102 struct ia64_vms_dynimgrela
5104 bfd_vma img_rela_cnt; /* Number of relocations. */
5105 bfd_vma img_rela_off; /* Reloc offset in the dynamic segment. */
5108 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
5112 dump_ia64_vms_dynamic_fixups (FILE *file, struct ia64_vms_dynfixup *fixup,
5113 const char *strtab, unsigned int strtab_sz)
5115 Elf64_External_VMS_IMAGE_FIXUP *imfs;
5117 const char *lib_name;
5119 imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
5120 1, fixup->fixup_rela_cnt * sizeof (*imfs),
5121 _("dynamic section image fixups"));
5125 if (fixup->needed < strtab_sz)
5126 lib_name = strtab + fixup->needed;
5129 warn ("corrupt library name index of 0x%lx found in dynamic entry",
5130 (unsigned long) fixup->needed);
5133 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
5134 (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
5136 (_("Seg Offset Type SymVec DataType\n"));
5138 for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
5143 printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
5144 printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
5145 type = BYTE_GET (imfs [i].type);
5146 rtype = elf_ia64_reloc_type (type);
5148 printf (" 0x%08x ", type);
5150 printf (" %-32s ", rtype);
5151 printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
5152 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
5158 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
5161 dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
5163 Elf64_External_VMS_IMAGE_RELA *imrs;
5166 imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
5167 1, imgrela->img_rela_cnt * sizeof (*imrs),
5168 _("dynamic section image relas"));
5172 printf (_("\nImage relocs\n"));
5174 (_("Seg Offset Type Addend Seg Sym Off\n"));
5176 for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
5181 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
5182 printf ("%08" BFD_VMA_FMT "x ",
5183 (bfd_vma) BYTE_GET (imrs [i].rela_offset));
5184 type = BYTE_GET (imrs [i].type);
5185 rtype = elf_ia64_reloc_type (type);
5187 printf ("0x%08x ", type);
5189 printf ("%-31s ", rtype);
5190 print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
5191 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
5192 printf ("%08" BFD_VMA_FMT "x\n",
5193 (bfd_vma) BYTE_GET (imrs [i].sym_offset));
5199 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
5202 process_ia64_vms_dynamic_relocs (FILE *file)
5204 struct ia64_vms_dynfixup fixup;
5205 struct ia64_vms_dynimgrela imgrela;
5206 Elf_Internal_Dyn *entry;
5208 bfd_vma strtab_off = 0;
5209 bfd_vma strtab_sz = 0;
5210 char *strtab = NULL;
5212 memset (&fixup, 0, sizeof (fixup));
5213 memset (&imgrela, 0, sizeof (imgrela));
5215 /* Note: the order of the entries is specified by the OpenVMS specs. */
5216 for (entry = dynamic_section;
5217 entry < dynamic_section + dynamic_nent;
5220 switch (entry->d_tag)
5222 case DT_IA_64_VMS_STRTAB_OFFSET:
5223 strtab_off = entry->d_un.d_val;
5226 strtab_sz = entry->d_un.d_val;
5228 strtab = get_data (NULL, file, dynamic_addr + strtab_off,
5229 1, strtab_sz, _("dynamic string section"));
5232 case DT_IA_64_VMS_NEEDED_IDENT:
5233 fixup.needed_ident = entry->d_un.d_val;
5236 fixup.needed = entry->d_un.d_val;
5238 case DT_IA_64_VMS_FIXUP_NEEDED:
5239 fixup.fixup_needed = entry->d_un.d_val;
5241 case DT_IA_64_VMS_FIXUP_RELA_CNT:
5242 fixup.fixup_rela_cnt = entry->d_un.d_val;
5244 case DT_IA_64_VMS_FIXUP_RELA_OFF:
5245 fixup.fixup_rela_off = entry->d_un.d_val;
5247 dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz);
5250 case DT_IA_64_VMS_IMG_RELA_CNT:
5251 imgrela.img_rela_cnt = entry->d_un.d_val;
5253 case DT_IA_64_VMS_IMG_RELA_OFF:
5254 imgrela.img_rela_off = entry->d_un.d_val;
5256 dump_ia64_vms_dynamic_relocs (file, &imgrela);
5276 } dynamic_relocations [] =
5278 { "REL", DT_REL, DT_RELSZ, FALSE },
5279 { "RELA", DT_RELA, DT_RELASZ, TRUE },
5280 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
5283 /* Process the reloc section. */
5286 process_relocs (FILE * file)
5288 unsigned long rel_size;
5289 unsigned long rel_offset;
5295 if (do_using_dynamic)
5299 int has_dynamic_reloc;
5302 has_dynamic_reloc = 0;
5304 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
5306 is_rela = dynamic_relocations [i].rela;
5307 name = dynamic_relocations [i].name;
5308 rel_size = dynamic_info [dynamic_relocations [i].size];
5309 rel_offset = dynamic_info [dynamic_relocations [i].reloc];
5311 has_dynamic_reloc |= rel_size;
5313 if (is_rela == UNKNOWN)
5315 if (dynamic_relocations [i].reloc == DT_JMPREL)
5316 switch (dynamic_info[DT_PLTREL])
5330 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
5331 name, rel_offset, rel_size);
5333 dump_relocations (file,
5334 offset_from_vma (file, rel_offset, rel_size),
5336 dynamic_symbols, num_dynamic_syms,
5337 dynamic_strings, dynamic_strings_length, is_rela);
5342 has_dynamic_reloc |= process_ia64_vms_dynamic_relocs (file);
5344 if (! has_dynamic_reloc)
5345 printf (_("\nThere are no dynamic relocations in this file.\n"));
5349 Elf_Internal_Shdr * section;
5353 for (i = 0, section = section_headers;
5354 i < elf_header.e_shnum;
5357 if ( section->sh_type != SHT_RELA
5358 && section->sh_type != SHT_REL)
5361 rel_offset = section->sh_offset;
5362 rel_size = section->sh_size;
5366 Elf_Internal_Shdr * strsec;
5369 printf (_("\nRelocation section "));
5371 if (string_table == NULL)
5372 printf ("%d", section->sh_name);
5374 printf (_("'%s'"), SECTION_NAME (section));
5376 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5377 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
5379 is_rela = section->sh_type == SHT_RELA;
5381 if (section->sh_link != 0
5382 && section->sh_link < elf_header.e_shnum)
5384 Elf_Internal_Shdr * symsec;
5385 Elf_Internal_Sym * symtab;
5386 unsigned long nsyms;
5387 unsigned long strtablen = 0;
5388 char * strtab = NULL;
5390 symsec = section_headers + section->sh_link;
5391 if (symsec->sh_type != SHT_SYMTAB
5392 && symsec->sh_type != SHT_DYNSYM)
5395 nsyms = symsec->sh_size / symsec->sh_entsize;
5396 symtab = GET_ELF_SYMBOLS (file, symsec);
5401 if (symsec->sh_link != 0
5402 && symsec->sh_link < elf_header.e_shnum)
5404 strsec = section_headers + symsec->sh_link;
5406 strtab = (char *) get_data (NULL, file, strsec->sh_offset,
5409 strtablen = strtab == NULL ? 0 : strsec->sh_size;
5412 dump_relocations (file, rel_offset, rel_size,
5413 symtab, nsyms, strtab, strtablen, is_rela);
5419 dump_relocations (file, rel_offset, rel_size,
5420 NULL, 0, NULL, 0, is_rela);
5427 printf (_("\nThere are no relocations in this file.\n"));
5433 /* Process the unwind section. */
5435 #include "unwind-ia64.h"
5437 /* An absolute address consists of a section and an offset. If the
5438 section is NULL, the offset itself is the address, otherwise, the
5439 address equals to LOAD_ADDRESS(section) + offset. */
5443 unsigned short section;
5447 #define ABSADDR(a) \
5449 ? section_headers [(a).section].sh_addr + (a).offset \
5452 struct ia64_unw_table_entry
5454 struct absaddr start;
5456 struct absaddr info;
5459 struct ia64_unw_aux_info
5462 struct ia64_unw_table_entry *table; /* Unwind table. */
5463 unsigned long table_len; /* Length of unwind table. */
5464 unsigned char * info; /* Unwind info. */
5465 unsigned long info_size; /* Size of unwind info. */
5466 bfd_vma info_addr; /* starting address of unwind info. */
5467 bfd_vma seg_base; /* Starting address of segment. */
5468 Elf_Internal_Sym * symtab; /* The symbol table. */
5469 unsigned long nsyms; /* Number of symbols. */
5470 char * strtab; /* The string table. */
5471 unsigned long strtab_size; /* Size of string table. */
5475 find_symbol_for_address (Elf_Internal_Sym * symtab,
5476 unsigned long nsyms,
5477 const char * strtab,
5478 unsigned long strtab_size,
5479 struct absaddr addr,
5480 const char ** symname,
5483 bfd_vma dist = 0x100000;
5484 Elf_Internal_Sym * sym;
5485 Elf_Internal_Sym * best = NULL;
5488 REMOVE_ARCH_BITS (addr.offset);
5490 for (i = 0, sym = symtab; i < nsyms; ++i, ++sym)
5492 bfd_vma value = sym->st_value;
5494 REMOVE_ARCH_BITS (value);
5496 if (ELF_ST_TYPE (sym->st_info) == STT_FUNC
5497 && sym->st_name != 0
5498 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
5499 && addr.offset >= value
5500 && addr.offset - value < dist)
5503 dist = addr.offset - value;
5510 *symname = (best->st_name >= strtab_size
5511 ? _("<corrupt>") : strtab + best->st_name);
5516 *offset = addr.offset;
5520 dump_ia64_unwind (struct ia64_unw_aux_info * aux)
5522 struct ia64_unw_table_entry * tp;
5525 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
5529 const unsigned char * dp;
5530 const unsigned char * head;
5531 const char * procname;
5533 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
5534 aux->strtab_size, tp->start, &procname, &offset);
5536 fputs ("\n<", stdout);
5540 fputs (procname, stdout);
5543 printf ("+%lx", (unsigned long) offset);
5546 fputs (">: [", stdout);
5547 print_vma (tp->start.offset, PREFIX_HEX);
5548 fputc ('-', stdout);
5549 print_vma (tp->end.offset, PREFIX_HEX);
5550 printf ("], info at +0x%lx\n",
5551 (unsigned long) (tp->info.offset - aux->seg_base));
5553 head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
5554 stamp = byte_get ((unsigned char *) head, sizeof (stamp));
5556 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
5557 (unsigned) UNW_VER (stamp),
5558 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
5559 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
5560 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
5561 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
5563 if (UNW_VER (stamp) != 1)
5565 printf (_("\tUnknown version.\n"));
5570 for (dp = head + 8; dp < head + 8 + eh_addr_size * UNW_LENGTH (stamp);)
5571 dp = unw_decode (dp, in_body, & in_body);
5576 slurp_ia64_unwind_table (FILE * file,
5577 struct ia64_unw_aux_info * aux,
5578 Elf_Internal_Shdr * sec)
5580 unsigned long size, nrelas, i;
5581 Elf_Internal_Phdr * seg;
5582 struct ia64_unw_table_entry * tep;
5583 Elf_Internal_Shdr * relsec;
5584 Elf_Internal_Rela * rela;
5585 Elf_Internal_Rela * rp;
5586 unsigned char * table;
5588 Elf_Internal_Sym * sym;
5589 const char * relname;
5591 /* First, find the starting address of the segment that includes
5594 if (elf_header.e_phnum)
5596 if (! get_program_headers (file))
5599 for (seg = program_headers;
5600 seg < program_headers + elf_header.e_phnum;
5603 if (seg->p_type != PT_LOAD)
5606 if (sec->sh_addr >= seg->p_vaddr
5607 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
5609 aux->seg_base = seg->p_vaddr;
5615 /* Second, build the unwind table from the contents of the unwind section: */
5616 size = sec->sh_size;
5617 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
5622 aux->table = (struct ia64_unw_table_entry *)
5623 xcmalloc (size / (3 * eh_addr_size), sizeof (aux->table[0]));
5625 for (tp = table; tp < table + size; ++tep)
5627 tep->start.section = SHN_UNDEF;
5628 tep->end.section = SHN_UNDEF;
5629 tep->info.section = SHN_UNDEF;
5630 tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
5631 tep->end.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
5632 tep->info.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
5633 tep->start.offset += aux->seg_base;
5634 tep->end.offset += aux->seg_base;
5635 tep->info.offset += aux->seg_base;
5639 /* Third, apply any relocations to the unwind table: */
5640 for (relsec = section_headers;
5641 relsec < section_headers + elf_header.e_shnum;
5644 if (relsec->sh_type != SHT_RELA
5645 || relsec->sh_info >= elf_header.e_shnum
5646 || section_headers + relsec->sh_info != sec)
5649 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
5653 for (rp = rela; rp < rela + nrelas; ++rp)
5655 relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
5656 sym = aux->symtab + get_reloc_symindex (rp->r_info);
5658 if (! const_strneq (relname, "R_IA64_SEGREL"))
5660 warn (_("Skipping unexpected relocation type %s\n"), relname);
5664 i = rp->r_offset / (3 * eh_addr_size);
5666 switch (rp->r_offset/eh_addr_size % 3)
5669 aux->table[i].start.section = sym->st_shndx;
5670 aux->table[i].start.offset = rp->r_addend + sym->st_value;
5673 aux->table[i].end.section = sym->st_shndx;
5674 aux->table[i].end.offset = rp->r_addend + sym->st_value;
5677 aux->table[i].info.section = sym->st_shndx;
5678 aux->table[i].info.offset = rp->r_addend + sym->st_value;
5688 aux->table_len = size / (3 * eh_addr_size);
5693 ia64_process_unwind (FILE * file)
5695 Elf_Internal_Shdr * sec;
5696 Elf_Internal_Shdr * unwsec = NULL;
5697 Elf_Internal_Shdr * strsec;
5698 unsigned long i, unwcount = 0, unwstart = 0;
5699 struct ia64_unw_aux_info aux;
5701 memset (& aux, 0, sizeof (aux));
5703 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
5705 if (sec->sh_type == SHT_SYMTAB
5706 && sec->sh_link < elf_header.e_shnum)
5708 aux.nsyms = sec->sh_size / sec->sh_entsize;
5709 aux.symtab = GET_ELF_SYMBOLS (file, sec);
5711 strsec = section_headers + sec->sh_link;
5712 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
5715 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
5717 else if (sec->sh_type == SHT_IA_64_UNWIND)
5722 printf (_("\nThere are no unwind sections in this file.\n"));
5724 while (unwcount-- > 0)
5729 for (i = unwstart, sec = section_headers + unwstart;
5730 i < elf_header.e_shnum; ++i, ++sec)
5731 if (sec->sh_type == SHT_IA_64_UNWIND)
5738 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
5740 if ((unwsec->sh_flags & SHF_GROUP) != 0)
5742 /* We need to find which section group it is in. */
5743 struct group_list * g = section_headers_groups [i]->root;
5745 for (; g != NULL; g = g->next)
5747 sec = section_headers + g->section_index;
5749 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
5754 i = elf_header.e_shnum;
5756 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
5758 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
5759 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
5760 suffix = SECTION_NAME (unwsec) + len;
5761 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
5763 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
5764 && streq (SECTION_NAME (sec) + len2, suffix))
5769 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
5770 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
5771 len = sizeof (ELF_STRING_ia64_unwind) - 1;
5772 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
5774 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
5775 suffix = SECTION_NAME (unwsec) + len;
5776 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
5778 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
5779 && streq (SECTION_NAME (sec) + len2, suffix))
5783 if (i == elf_header.e_shnum)
5785 printf (_("\nCould not find unwind info section for "));
5787 if (string_table == NULL)
5788 printf ("%d", unwsec->sh_name);
5790 printf (_("'%s'"), SECTION_NAME (unwsec));
5794 aux.info_size = sec->sh_size;
5795 aux.info_addr = sec->sh_addr;
5796 aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
5800 printf (_("\nUnwind section "));
5802 if (string_table == NULL)
5803 printf ("%d", unwsec->sh_name);
5805 printf (_("'%s'"), SECTION_NAME (unwsec));
5807 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5808 (unsigned long) unwsec->sh_offset,
5809 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
5811 (void) slurp_ia64_unwind_table (file, & aux, unwsec);
5813 if (aux.table_len > 0)
5814 dump_ia64_unwind (& aux);
5817 free ((char *) aux.table);
5819 free ((char *) aux.info);
5828 free ((char *) aux.strtab);
5833 struct hppa_unw_table_entry
5835 struct absaddr start;
5837 unsigned int Cannot_unwind:1; /* 0 */
5838 unsigned int Millicode:1; /* 1 */
5839 unsigned int Millicode_save_sr0:1; /* 2 */
5840 unsigned int Region_description:2; /* 3..4 */
5841 unsigned int reserved1:1; /* 5 */
5842 unsigned int Entry_SR:1; /* 6 */
5843 unsigned int Entry_FR:4; /* number saved */ /* 7..10 */
5844 unsigned int Entry_GR:5; /* number saved */ /* 11..15 */
5845 unsigned int Args_stored:1; /* 16 */
5846 unsigned int Variable_Frame:1; /* 17 */
5847 unsigned int Separate_Package_Body:1; /* 18 */
5848 unsigned int Frame_Extension_Millicode:1; /* 19 */
5849 unsigned int Stack_Overflow_Check:1; /* 20 */
5850 unsigned int Two_Instruction_SP_Increment:1; /* 21 */
5851 unsigned int Ada_Region:1; /* 22 */
5852 unsigned int cxx_info:1; /* 23 */
5853 unsigned int cxx_try_catch:1; /* 24 */
5854 unsigned int sched_entry_seq:1; /* 25 */
5855 unsigned int reserved2:1; /* 26 */
5856 unsigned int Save_SP:1; /* 27 */
5857 unsigned int Save_RP:1; /* 28 */
5858 unsigned int Save_MRP_in_frame:1; /* 29 */
5859 unsigned int extn_ptr_defined:1; /* 30 */
5860 unsigned int Cleanup_defined:1; /* 31 */
5862 unsigned int MPE_XL_interrupt_marker:1; /* 0 */
5863 unsigned int HP_UX_interrupt_marker:1; /* 1 */
5864 unsigned int Large_frame:1; /* 2 */
5865 unsigned int Pseudo_SP_Set:1; /* 3 */
5866 unsigned int reserved4:1; /* 4 */
5867 unsigned int Total_frame_size:27; /* 5..31 */
5870 struct hppa_unw_aux_info
5872 struct hppa_unw_table_entry *table; /* Unwind table. */
5873 unsigned long table_len; /* Length of unwind table. */
5874 bfd_vma seg_base; /* Starting address of segment. */
5875 Elf_Internal_Sym * symtab; /* The symbol table. */
5876 unsigned long nsyms; /* Number of symbols. */
5877 char * strtab; /* The string table. */
5878 unsigned long strtab_size; /* Size of string table. */
5882 dump_hppa_unwind (struct hppa_unw_aux_info * aux)
5884 struct hppa_unw_table_entry * tp;
5886 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
5889 const char * procname;
5891 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
5892 aux->strtab_size, tp->start, &procname,
5895 fputs ("\n<", stdout);
5899 fputs (procname, stdout);
5902 printf ("+%lx", (unsigned long) offset);
5905 fputs (">: [", stdout);
5906 print_vma (tp->start.offset, PREFIX_HEX);
5907 fputc ('-', stdout);
5908 print_vma (tp->end.offset, PREFIX_HEX);
5911 #define PF(_m) if (tp->_m) printf (#_m " ");
5912 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
5915 PF(Millicode_save_sr0);
5916 /* PV(Region_description); */
5922 PF(Separate_Package_Body);
5923 PF(Frame_Extension_Millicode);
5924 PF(Stack_Overflow_Check);
5925 PF(Two_Instruction_SP_Increment);
5929 PF(sched_entry_seq);
5932 PF(Save_MRP_in_frame);
5933 PF(extn_ptr_defined);
5934 PF(Cleanup_defined);
5935 PF(MPE_XL_interrupt_marker);
5936 PF(HP_UX_interrupt_marker);
5939 PV(Total_frame_size);
5948 slurp_hppa_unwind_table (FILE * file,
5949 struct hppa_unw_aux_info * aux,
5950 Elf_Internal_Shdr * sec)
5952 unsigned long size, unw_ent_size, nentries, nrelas, i;
5953 Elf_Internal_Phdr * seg;
5954 struct hppa_unw_table_entry * tep;
5955 Elf_Internal_Shdr * relsec;
5956 Elf_Internal_Rela * rela;
5957 Elf_Internal_Rela * rp;
5958 unsigned char * table;
5960 Elf_Internal_Sym * sym;
5961 const char * relname;
5963 /* First, find the starting address of the segment that includes
5966 if (elf_header.e_phnum)
5968 if (! get_program_headers (file))
5971 for (seg = program_headers;
5972 seg < program_headers + elf_header.e_phnum;
5975 if (seg->p_type != PT_LOAD)
5978 if (sec->sh_addr >= seg->p_vaddr
5979 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
5981 aux->seg_base = seg->p_vaddr;
5987 /* Second, build the unwind table from the contents of the unwind
5989 size = sec->sh_size;
5990 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
5996 nentries = size / unw_ent_size;
5997 size = unw_ent_size * nentries;
5999 tep = aux->table = (struct hppa_unw_table_entry *)
6000 xcmalloc (nentries, sizeof (aux->table[0]));
6002 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
6004 unsigned int tmp1, tmp2;
6006 tep->start.section = SHN_UNDEF;
6007 tep->end.section = SHN_UNDEF;
6009 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
6010 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
6011 tmp1 = byte_get ((unsigned char *) tp + 8, 4);
6012 tmp2 = byte_get ((unsigned char *) tp + 12, 4);
6014 tep->start.offset += aux->seg_base;
6015 tep->end.offset += aux->seg_base;
6017 tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
6018 tep->Millicode = (tmp1 >> 30) & 0x1;
6019 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
6020 tep->Region_description = (tmp1 >> 27) & 0x3;
6021 tep->reserved1 = (tmp1 >> 26) & 0x1;
6022 tep->Entry_SR = (tmp1 >> 25) & 0x1;
6023 tep->Entry_FR = (tmp1 >> 21) & 0xf;
6024 tep->Entry_GR = (tmp1 >> 16) & 0x1f;
6025 tep->Args_stored = (tmp1 >> 15) & 0x1;
6026 tep->Variable_Frame = (tmp1 >> 14) & 0x1;
6027 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
6028 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
6029 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
6030 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
6031 tep->Ada_Region = (tmp1 >> 9) & 0x1;
6032 tep->cxx_info = (tmp1 >> 8) & 0x1;
6033 tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
6034 tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
6035 tep->reserved2 = (tmp1 >> 5) & 0x1;
6036 tep->Save_SP = (tmp1 >> 4) & 0x1;
6037 tep->Save_RP = (tmp1 >> 3) & 0x1;
6038 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
6039 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
6040 tep->Cleanup_defined = tmp1 & 0x1;
6042 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
6043 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
6044 tep->Large_frame = (tmp2 >> 29) & 0x1;
6045 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
6046 tep->reserved4 = (tmp2 >> 27) & 0x1;
6047 tep->Total_frame_size = tmp2 & 0x7ffffff;
6051 /* Third, apply any relocations to the unwind table. */
6052 for (relsec = section_headers;
6053 relsec < section_headers + elf_header.e_shnum;
6056 if (relsec->sh_type != SHT_RELA
6057 || relsec->sh_info >= elf_header.e_shnum
6058 || section_headers + relsec->sh_info != sec)
6061 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6065 for (rp = rela; rp < rela + nrelas; ++rp)
6067 relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
6068 sym = aux->symtab + get_reloc_symindex (rp->r_info);
6070 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
6071 if (! const_strneq (relname, "R_PARISC_SEGREL"))
6073 warn (_("Skipping unexpected relocation type %s\n"), relname);
6077 i = rp->r_offset / unw_ent_size;
6079 switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
6082 aux->table[i].start.section = sym->st_shndx;
6083 aux->table[i].start.offset = sym->st_value + rp->r_addend;
6086 aux->table[i].end.section = sym->st_shndx;
6087 aux->table[i].end.offset = sym->st_value + rp->r_addend;
6097 aux->table_len = nentries;
6103 hppa_process_unwind (FILE * file)
6105 struct hppa_unw_aux_info aux;
6106 Elf_Internal_Shdr * unwsec = NULL;
6107 Elf_Internal_Shdr * strsec;
6108 Elf_Internal_Shdr * sec;
6111 memset (& aux, 0, sizeof (aux));
6113 if (string_table == NULL)
6116 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6118 if (sec->sh_type == SHT_SYMTAB
6119 && sec->sh_link < elf_header.e_shnum)
6121 aux.nsyms = sec->sh_size / sec->sh_entsize;
6122 aux.symtab = GET_ELF_SYMBOLS (file, sec);
6124 strsec = section_headers + sec->sh_link;
6125 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6128 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
6130 else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
6135 printf (_("\nThere are no unwind sections in this file.\n"));
6137 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6139 if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
6141 printf (_("\nUnwind section "));
6142 printf (_("'%s'"), SECTION_NAME (sec));
6144 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6145 (unsigned long) sec->sh_offset,
6146 (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
6148 slurp_hppa_unwind_table (file, &aux, sec);
6149 if (aux.table_len > 0)
6150 dump_hppa_unwind (&aux);
6153 free ((char *) aux.table);
6161 free ((char *) aux.strtab);
6168 unsigned char *data;
6170 Elf_Internal_Shdr *sec;
6171 Elf_Internal_Rela *rela;
6172 unsigned long nrelas;
6173 unsigned int rel_type;
6175 Elf_Internal_Rela *next_rela;
6178 struct arm_unw_aux_info
6182 Elf_Internal_Sym *symtab; /* The symbol table. */
6183 unsigned long nsyms; /* Number of symbols. */
6184 char *strtab; /* The string table. */
6185 unsigned long strtab_size; /* Size of string table. */
6189 arm_print_vma_and_name (struct arm_unw_aux_info *aux,
6190 bfd_vma fn, struct absaddr addr)
6192 const char *procname;
6195 if (addr.section == SHN_UNDEF)
6198 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6199 aux->strtab_size, addr, &procname,
6202 print_vma (fn, PREFIX_HEX);
6206 fputs (" <", stdout);
6207 fputs (procname, stdout);
6210 printf ("+0x%lx", (unsigned long) sym_offset);
6211 fputc ('>', stdout);
6218 arm_free_section (struct arm_section *arm_sec)
6220 if (arm_sec->data != NULL)
6221 free (arm_sec->data);
6223 if (arm_sec->rela != NULL)
6224 free (arm_sec->rela);
6228 arm_section_get_word (struct arm_unw_aux_info *aux,
6229 struct arm_section *arm_sec,
6230 Elf_Internal_Shdr *sec, bfd_vma word_offset,
6231 unsigned int *wordp, struct absaddr *addr)
6233 Elf_Internal_Rela *rp;
6234 Elf_Internal_Sym *sym;
6235 const char * relname;
6237 bfd_boolean wrapped;
6239 addr->section = SHN_UNDEF;
6242 if (sec != arm_sec->sec)
6244 Elf_Internal_Shdr *relsec;
6246 arm_free_section (arm_sec);
6249 arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
6250 sec->sh_size, _("unwind data"));
6252 arm_sec->rela = NULL;
6253 arm_sec->nrelas = 0;
6255 for (relsec = section_headers;
6256 relsec < section_headers + elf_header.e_shnum;
6259 if (relsec->sh_info >= elf_header.e_shnum
6260 || section_headers + relsec->sh_info != sec)
6263 if (relsec->sh_type == SHT_REL)
6265 if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
6267 & arm_sec->rela, & arm_sec->nrelas))
6271 else if (relsec->sh_type == SHT_RELA)
6273 if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
6275 & arm_sec->rela, & arm_sec->nrelas))
6281 arm_sec->next_rela = arm_sec->rela;
6284 if (arm_sec->data == NULL)
6287 word = byte_get (arm_sec->data + word_offset, 4);
6290 for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
6292 bfd_vma prelval, offset;
6294 if (rp->r_offset > word_offset && !wrapped)
6299 if (rp->r_offset > word_offset)
6302 if (rp->r_offset & 3)
6304 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
6305 (unsigned long) rp->r_offset);
6309 if (rp->r_offset < word_offset)
6312 relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
6314 if (streq (relname, "R_ARM_NONE"))
6317 if (! streq (relname, "R_ARM_PREL31"))
6319 warn (_("Skipping unexpected relocation type %s\n"), relname);
6323 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
6325 if (arm_sec->rel_type == SHT_REL)
6327 offset = word & 0x7fffffff;
6328 if (offset & 0x40000000)
6329 offset |= ~ (bfd_vma) 0x7fffffff;
6332 offset = rp->r_addend;
6334 offset += sym->st_value;
6335 prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
6337 word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
6338 addr->section = sym->st_shndx;
6339 addr->offset = offset;
6344 arm_sec->next_rela = rp;
6350 decode_arm_unwind (struct arm_unw_aux_info *aux,
6351 unsigned int word, unsigned int remaining,
6352 bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
6353 struct arm_section *data_arm_sec)
6356 unsigned int more_words;
6357 struct absaddr addr;
6360 if (remaining == 0 && more_words) \
6363 if (!arm_section_get_word (aux, data_arm_sec, data_sec, \
6364 data_offset, &word, &addr)) \
6370 #define GET_OP(OP) \
6375 (OP) = word >> 24; \
6380 printf (_("[Truncated opcode]\n")); \
6383 printf ("0x%02x ", OP)
6387 /* Fetch the first word. */
6388 if (!arm_section_get_word (aux, data_arm_sec, data_sec, data_offset,
6394 if ((word & 0x80000000) == 0)
6396 /* Expand prel31 for personality routine. */
6398 const char *procname;
6401 if (fn & 0x40000000)
6402 fn |= ~ (bfd_vma) 0x7fffffff;
6403 fn = fn + data_sec->sh_addr + data_offset;
6405 printf (_(" Personality routine: "));
6406 procname = arm_print_vma_and_name (aux, fn, addr);
6407 fputc ('\n', stdout);
6409 /* The GCC personality routines use the standard compact
6410 encoding, starting with one byte giving the number of
6412 if (procname != NULL
6413 && (const_strneq (procname, "__gcc_personality_v0")
6414 || const_strneq (procname, "__gxx_personality_v0")
6415 || const_strneq (procname, "__gcj_personality_v0")
6416 || const_strneq (procname, "__gnu_objc_personality_v0")))
6423 printf (_(" [Truncated data]\n"));
6426 more_words = word >> 24;
6435 per_index = (word >> 24) & 0x7f;
6436 if (per_index != 0 && per_index != 1 && per_index != 2)
6438 printf (_(" [reserved compact index %d]\n"), per_index);
6442 printf (_(" Compact model %d\n"), per_index);
6451 more_words = (word >> 16) & 0xff;
6457 /* Decode the unwinding instructions. */
6460 unsigned int op, op2;
6469 printf (" 0x%02x ", op);
6471 if ((op & 0xc0) == 0x00)
6473 int offset = ((op & 0x3f) << 2) + 4;
6475 printf (" vsp = vsp + %d", offset);
6477 else if ((op & 0xc0) == 0x40)
6479 int offset = ((op & 0x3f) << 2) + 4;
6481 printf (" vsp = vsp - %d", offset);
6483 else if ((op & 0xf0) == 0x80)
6486 if (op == 0x80 && op2 == 0)
6487 printf (_("Refuse to unwind"));
6490 unsigned int mask = ((op & 0x0f) << 8) | op2;
6495 for (i = 0; i < 12; i++)
6496 if (mask & (1 << i))
6502 printf ("r%d", 4 + i);
6507 else if ((op & 0xf0) == 0x90)
6509 if (op == 0x9d || op == 0x9f)
6510 printf (_(" [Reserved]"));
6512 printf (" vsp = r%d", op & 0x0f);
6514 else if ((op & 0xf0) == 0xa0)
6516 int end = 4 + (op & 0x07);
6521 for (i = 4; i <= end; i++)
6537 else if (op == 0xb0)
6538 printf (_(" finish"));
6539 else if (op == 0xb1)
6542 if (op2 == 0 || (op2 & 0xf0) != 0)
6543 printf (_("[Spare]"));
6546 unsigned int mask = op2 & 0x0f;
6551 for (i = 0; i < 12; i++)
6552 if (mask & (1 << i))
6563 else if (op == 0xb2)
6565 unsigned char buf[9];
6566 unsigned int i, len;
6567 unsigned long offset;
6569 for (i = 0; i < sizeof (buf); i++)
6572 if ((buf[i] & 0x80) == 0)
6575 assert (i < sizeof (buf));
6576 offset = read_uleb128 (buf, &len);
6577 assert (len == i + 1);
6578 offset = offset * 4 + 0x204;
6579 printf ("vsp = vsp + %ld", offset);
6581 else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
6583 unsigned int first, last;
6590 printf ("pop {D%d", first);
6592 printf ("-D%d", first + last);
6595 else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
6597 unsigned int count = op & 0x07;
6601 printf ("-D%d", 8 + count);
6604 else if (op >= 0xc0 && op <= 0xc5)
6606 unsigned int count = op & 0x07;
6608 printf (" pop {wR10");
6610 printf ("-wR%d", 10 + count);
6613 else if (op == 0xc6)
6615 unsigned int first, last;
6620 printf ("pop {wR%d", first);
6622 printf ("-wR%d", first + last);
6625 else if (op == 0xc7)
6628 if (op2 == 0 || (op2 & 0xf0) != 0)
6629 printf (_("[Spare]"));
6632 unsigned int mask = op2 & 0x0f;
6637 for (i = 0; i < 4; i++)
6638 if (mask & (1 << i))
6644 printf ("wCGR%d", i);
6650 printf (_(" [unsupported opcode]"));
6654 /* Decode the descriptors. Not implemented. */
6658 dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
6660 struct arm_section exidx_arm_sec, extab_arm_sec;
6661 unsigned int i, exidx_len;
6663 memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
6664 memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
6665 exidx_len = exidx_sec->sh_size / 8;
6667 for (i = 0; i < exidx_len; i++)
6669 unsigned int exidx_fn, exidx_entry;
6670 struct absaddr fn_addr, entry_addr;
6673 fputc ('\n', stdout);
6675 if (!arm_section_get_word (aux, &exidx_arm_sec, exidx_sec,
6676 8 * i, &exidx_fn, &fn_addr)
6677 || !arm_section_get_word (aux, &exidx_arm_sec, exidx_sec,
6678 8 * i + 4, &exidx_entry, &entry_addr))
6680 arm_free_section (&exidx_arm_sec);
6681 arm_free_section (&extab_arm_sec);
6685 fn = exidx_fn & 0x7fffffff;
6686 if (fn & 0x40000000)
6687 fn |= ~ (bfd_vma) 0x7fffffff;
6688 fn = fn + exidx_sec->sh_addr + 8 * i;
6690 arm_print_vma_and_name (aux, fn, entry_addr);
6691 fputs (": ", stdout);
6693 if (exidx_entry == 1)
6695 print_vma (exidx_entry, PREFIX_HEX);
6696 fputs (" [cantunwind]\n", stdout);
6698 else if (exidx_entry & 0x80000000)
6700 print_vma (exidx_entry, PREFIX_HEX);
6701 fputc ('\n', stdout);
6702 decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
6706 bfd_vma table, table_offset = 0;
6707 Elf_Internal_Shdr *table_sec;
6709 fputs ("@", stdout);
6710 table = exidx_entry;
6711 if (table & 0x40000000)
6712 table |= ~ (bfd_vma) 0x7fffffff;
6713 table = table + exidx_sec->sh_addr + 8 * i + 4;
6714 print_vma (table, PREFIX_HEX);
6717 /* Locate the matching .ARM.extab. */
6718 if (entry_addr.section != SHN_UNDEF
6719 && entry_addr.section < elf_header.e_shnum)
6721 table_sec = section_headers + entry_addr.section;
6722 table_offset = entry_addr.offset;
6726 table_sec = find_section_by_address (table);
6727 if (table_sec != NULL)
6728 table_offset = table - table_sec->sh_addr;
6730 if (table_sec == NULL)
6732 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
6733 (unsigned long) table);
6736 decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
6743 arm_free_section (&exidx_arm_sec);
6744 arm_free_section (&extab_arm_sec);
6748 arm_process_unwind (FILE *file)
6750 struct arm_unw_aux_info aux;
6751 Elf_Internal_Shdr *unwsec = NULL;
6752 Elf_Internal_Shdr *strsec;
6753 Elf_Internal_Shdr *sec;
6756 memset (& aux, 0, sizeof (aux));
6759 if (string_table == NULL)
6762 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6764 if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
6766 aux.nsyms = sec->sh_size / sec->sh_entsize;
6767 aux.symtab = GET_ELF_SYMBOLS (file, sec);
6769 strsec = section_headers + sec->sh_link;
6770 aux.strtab = get_data (NULL, file, strsec->sh_offset,
6771 1, strsec->sh_size, _("string table"));
6772 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
6774 else if (sec->sh_type == SHT_ARM_EXIDX)
6779 printf (_("\nThere are no unwind sections in this file.\n"));
6781 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6783 if (sec->sh_type == SHT_ARM_EXIDX)
6785 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
6787 (unsigned long) sec->sh_offset,
6788 (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
6790 dump_arm_unwind (&aux, sec);
6797 free ((char *) aux.strtab);
6803 process_unwind (FILE * file)
6805 struct unwind_handler
6808 int (* handler)(FILE *);
6811 { EM_ARM, arm_process_unwind },
6812 { EM_IA_64, ia64_process_unwind },
6813 { EM_PARISC, hppa_process_unwind },
6821 for (i = 0; handlers[i].handler != NULL; i++)
6822 if (elf_header.e_machine == handlers[i].machtype)
6823 return handlers[i].handler (file);
6825 printf (_("\nThere are no unwind sections in this file.\n"));
6830 dynamic_section_mips_val (Elf_Internal_Dyn * entry)
6832 switch (entry->d_tag)
6835 if (entry->d_un.d_val == 0)
6836 printf (_("NONE\n"));
6839 static const char * opts[] =
6841 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
6842 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
6843 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
6844 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
6850 for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
6851 if (entry->d_un.d_val & (1 << cnt))
6853 printf ("%s%s", first ? "" : " ", opts[cnt]);
6860 case DT_MIPS_IVERSION:
6861 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
6862 printf (_("Interface Version: %s\n"), GET_DYNAMIC_NAME (entry->d_un.d_val));
6864 printf (_("<corrupt: %ld>\n"), (long) entry->d_un.d_ptr);
6867 case DT_MIPS_TIME_STAMP:
6872 time_t atime = entry->d_un.d_val;
6873 tmp = gmtime (&atime);
6874 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
6875 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
6876 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
6877 printf (_("Time Stamp: %s\n"), timebuf);
6881 case DT_MIPS_RLD_VERSION:
6882 case DT_MIPS_LOCAL_GOTNO:
6883 case DT_MIPS_CONFLICTNO:
6884 case DT_MIPS_LIBLISTNO:
6885 case DT_MIPS_SYMTABNO:
6886 case DT_MIPS_UNREFEXTNO:
6887 case DT_MIPS_HIPAGENO:
6888 case DT_MIPS_DELTA_CLASS_NO:
6889 case DT_MIPS_DELTA_INSTANCE_NO:
6890 case DT_MIPS_DELTA_RELOC_NO:
6891 case DT_MIPS_DELTA_SYM_NO:
6892 case DT_MIPS_DELTA_CLASSSYM_NO:
6893 case DT_MIPS_COMPACT_SIZE:
6894 printf ("%ld\n", (long) entry->d_un.d_ptr);
6898 printf ("%#lx\n", (unsigned long) entry->d_un.d_ptr);
6903 dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
6905 switch (entry->d_tag)
6907 case DT_HP_DLD_FLAGS:
6916 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
6917 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
6918 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
6919 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
6920 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
6921 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
6922 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
6923 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
6924 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
6925 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
6926 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
6927 { DT_HP_GST, "HP_GST" },
6928 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
6929 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
6930 { DT_HP_NODELETE, "HP_NODELETE" },
6931 { DT_HP_GROUP, "HP_GROUP" },
6932 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
6936 bfd_vma val = entry->d_un.d_val;
6938 for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
6939 if (val & flags[cnt].bit)
6943 fputs (flags[cnt].str, stdout);
6945 val ^= flags[cnt].bit;
6948 if (val != 0 || first)
6952 print_vma (val, HEX);
6958 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
6966 /* VMS vs Unix time offset and factor. */
6968 #define VMS_EPOCH_OFFSET 35067168000000000LL
6969 #define VMS_GRANULARITY_FACTOR 10000000
6971 /* Display a VMS time in a human readable format. */
6974 print_vms_time (bfd_int64_t vmstime)
6979 unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
6980 tm = gmtime (&unxtime);
6981 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
6982 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
6983 tm->tm_hour, tm->tm_min, tm->tm_sec);
6988 dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
6990 switch (entry->d_tag)
6992 case DT_IA_64_PLT_RESERVE:
6993 /* First 3 slots reserved. */
6994 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
6996 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
6999 case DT_IA_64_VMS_LINKTIME:
7001 print_vms_time (entry->d_un.d_val);
7005 case DT_IA_64_VMS_LNKFLAGS:
7006 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7007 if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
7008 printf (" CALL_DEBUG");
7009 if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
7010 printf (" NOP0BUFS");
7011 if (entry->d_un.d_val & VMS_LF_P0IMAGE)
7012 printf (" P0IMAGE");
7013 if (entry->d_un.d_val & VMS_LF_MKTHREADS)
7014 printf (" MKTHREADS");
7015 if (entry->d_un.d_val & VMS_LF_UPCALLS)
7016 printf (" UPCALLS");
7017 if (entry->d_un.d_val & VMS_LF_IMGSTA)
7019 if (entry->d_un.d_val & VMS_LF_INITIALIZE)
7020 printf (" INITIALIZE");
7021 if (entry->d_un.d_val & VMS_LF_MAIN)
7023 if (entry->d_un.d_val & VMS_LF_EXE_INIT)
7024 printf (" EXE_INIT");
7025 if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
7026 printf (" TBK_IN_IMG");
7027 if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
7028 printf (" DBG_IN_IMG");
7029 if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
7030 printf (" TBK_IN_DSF");
7031 if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
7032 printf (" DBG_IN_DSF");
7033 if (entry->d_un.d_val & VMS_LF_SIGNATURES)
7034 printf (" SIGNATURES");
7035 if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
7036 printf (" REL_SEG_OFF");
7040 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7047 get_32bit_dynamic_section (FILE * file)
7049 Elf32_External_Dyn * edyn;
7050 Elf32_External_Dyn * ext;
7051 Elf_Internal_Dyn * entry;
7053 edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
7054 dynamic_size, _("dynamic section"));
7058 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
7059 might not have the luxury of section headers. Look for the DT_NULL
7060 terminator to determine the number of entries. */
7061 for (ext = edyn, dynamic_nent = 0;
7062 (char *) ext < (char *) edyn + dynamic_size;
7066 if (BYTE_GET (ext->d_tag) == DT_NULL)
7070 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
7072 if (dynamic_section == NULL)
7074 error (_("Out of memory\n"));
7079 for (ext = edyn, entry = dynamic_section;
7080 entry < dynamic_section + dynamic_nent;
7083 entry->d_tag = BYTE_GET (ext->d_tag);
7084 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
7093 get_64bit_dynamic_section (FILE * file)
7095 Elf64_External_Dyn * edyn;
7096 Elf64_External_Dyn * ext;
7097 Elf_Internal_Dyn * entry;
7099 edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
7100 dynamic_size, _("dynamic section"));
7104 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
7105 might not have the luxury of section headers. Look for the DT_NULL
7106 terminator to determine the number of entries. */
7107 for (ext = edyn, dynamic_nent = 0;
7108 (char *) ext < (char *) edyn + dynamic_size;
7112 if (BYTE_GET (ext->d_tag) == DT_NULL)
7116 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
7118 if (dynamic_section == NULL)
7120 error (_("Out of memory\n"));
7125 for (ext = edyn, entry = dynamic_section;
7126 entry < dynamic_section + dynamic_nent;
7129 entry->d_tag = BYTE_GET (ext->d_tag);
7130 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
7139 print_dynamic_flags (bfd_vma flags)
7147 flag = flags & - flags;
7157 case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
7158 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
7159 case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
7160 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
7161 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
7162 default: fputs (_("unknown"), stdout); break;
7168 /* Parse and display the contents of the dynamic section. */
7171 process_dynamic_section (FILE * file)
7173 Elf_Internal_Dyn * entry;
7175 if (dynamic_size == 0)
7178 printf (_("\nThere is no dynamic section in this file.\n"));
7185 if (! get_32bit_dynamic_section (file))
7188 else if (! get_64bit_dynamic_section (file))
7191 /* Find the appropriate symbol table. */
7192 if (dynamic_symbols == NULL)
7194 for (entry = dynamic_section;
7195 entry < dynamic_section + dynamic_nent;
7198 Elf_Internal_Shdr section;
7200 if (entry->d_tag != DT_SYMTAB)
7203 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
7205 /* Since we do not know how big the symbol table is,
7206 we default to reading in the entire file (!) and
7207 processing that. This is overkill, I know, but it
7209 section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
7211 if (archive_file_offset != 0)
7212 section.sh_size = archive_file_size - section.sh_offset;
7215 if (fseek (file, 0, SEEK_END))
7216 error (_("Unable to seek to end of file!\n"));
7218 section.sh_size = ftell (file) - section.sh_offset;
7222 section.sh_entsize = sizeof (Elf32_External_Sym);
7224 section.sh_entsize = sizeof (Elf64_External_Sym);
7226 num_dynamic_syms = section.sh_size / section.sh_entsize;
7227 if (num_dynamic_syms < 1)
7229 error (_("Unable to determine the number of symbols to load\n"));
7233 dynamic_symbols = GET_ELF_SYMBOLS (file, §ion);
7237 /* Similarly find a string table. */
7238 if (dynamic_strings == NULL)
7240 for (entry = dynamic_section;
7241 entry < dynamic_section + dynamic_nent;
7244 unsigned long offset;
7247 if (entry->d_tag != DT_STRTAB)
7250 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
7252 /* Since we do not know how big the string table is,
7253 we default to reading in the entire file (!) and
7254 processing that. This is overkill, I know, but it
7257 offset = offset_from_vma (file, entry->d_un.d_val, 0);
7259 if (archive_file_offset != 0)
7260 str_tab_len = archive_file_size - offset;
7263 if (fseek (file, 0, SEEK_END))
7264 error (_("Unable to seek to end of file\n"));
7265 str_tab_len = ftell (file) - offset;
7268 if (str_tab_len < 1)
7271 (_("Unable to determine the length of the dynamic string table\n"));
7275 dynamic_strings = (char *) get_data (NULL, file, offset, 1,
7277 _("dynamic string table"));
7278 dynamic_strings_length = str_tab_len;
7283 /* And find the syminfo section if available. */
7284 if (dynamic_syminfo == NULL)
7286 unsigned long syminsz = 0;
7288 for (entry = dynamic_section;
7289 entry < dynamic_section + dynamic_nent;
7292 if (entry->d_tag == DT_SYMINENT)
7294 /* Note: these braces are necessary to avoid a syntax
7295 error from the SunOS4 C compiler. */
7296 assert (sizeof (Elf_External_Syminfo) == entry->d_un.d_val);
7298 else if (entry->d_tag == DT_SYMINSZ)
7299 syminsz = entry->d_un.d_val;
7300 else if (entry->d_tag == DT_SYMINFO)
7301 dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
7305 if (dynamic_syminfo_offset != 0 && syminsz != 0)
7307 Elf_External_Syminfo * extsyminfo;
7308 Elf_External_Syminfo * extsym;
7309 Elf_Internal_Syminfo * syminfo;
7311 /* There is a syminfo section. Read the data. */
7312 extsyminfo = (Elf_External_Syminfo *)
7313 get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
7314 _("symbol information"));
7318 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
7319 if (dynamic_syminfo == NULL)
7321 error (_("Out of memory\n"));
7325 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
7326 for (syminfo = dynamic_syminfo, extsym = extsyminfo;
7327 syminfo < dynamic_syminfo + dynamic_syminfo_nent;
7328 ++syminfo, ++extsym)
7330 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
7331 syminfo->si_flags = BYTE_GET (extsym->si_flags);
7338 if (do_dynamic && dynamic_addr)
7339 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
7340 dynamic_addr, dynamic_nent);
7342 printf (_(" Tag Type Name/Value\n"));
7344 for (entry = dynamic_section;
7345 entry < dynamic_section + dynamic_nent;
7353 print_vma (entry->d_tag, FULL_HEX);
7354 dtype = get_dynamic_type (entry->d_tag);
7355 printf (" (%s)%*s", dtype,
7356 ((is_32bit_elf ? 27 : 19)
7357 - (int) strlen (dtype)),
7361 switch (entry->d_tag)
7365 print_dynamic_flags (entry->d_un.d_val);
7375 switch (entry->d_tag)
7378 printf (_("Auxiliary library"));
7382 printf (_("Filter library"));
7386 printf (_("Configuration file"));
7390 printf (_("Dependency audit library"));
7394 printf (_("Audit library"));
7398 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
7399 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
7403 print_vma (entry->d_un.d_val, PREFIX_HEX);
7412 printf (_("Flags:"));
7414 if (entry->d_un.d_val == 0)
7415 printf (_(" None\n"));
7418 unsigned long int val = entry->d_un.d_val;
7420 if (val & DTF_1_PARINIT)
7422 printf (" PARINIT");
7423 val ^= DTF_1_PARINIT;
7425 if (val & DTF_1_CONFEXP)
7427 printf (" CONFEXP");
7428 val ^= DTF_1_CONFEXP;
7431 printf (" %lx", val);
7440 printf (_("Flags:"));
7442 if (entry->d_un.d_val == 0)
7443 printf (_(" None\n"));
7446 unsigned long int val = entry->d_un.d_val;
7448 if (val & DF_P1_LAZYLOAD)
7450 printf (" LAZYLOAD");
7451 val ^= DF_P1_LAZYLOAD;
7453 if (val & DF_P1_GROUPPERM)
7455 printf (" GROUPPERM");
7456 val ^= DF_P1_GROUPPERM;
7459 printf (" %lx", val);
7468 printf (_("Flags:"));
7469 if (entry->d_un.d_val == 0)
7470 printf (_(" None\n"));
7473 unsigned long int val = entry->d_un.d_val;
7480 if (val & DF_1_GLOBAL)
7485 if (val & DF_1_GROUP)
7490 if (val & DF_1_NODELETE)
7492 printf (" NODELETE");
7493 val ^= DF_1_NODELETE;
7495 if (val & DF_1_LOADFLTR)
7497 printf (" LOADFLTR");
7498 val ^= DF_1_LOADFLTR;
7500 if (val & DF_1_INITFIRST)
7502 printf (" INITFIRST");
7503 val ^= DF_1_INITFIRST;
7505 if (val & DF_1_NOOPEN)
7510 if (val & DF_1_ORIGIN)
7515 if (val & DF_1_DIRECT)
7520 if (val & DF_1_TRANS)
7525 if (val & DF_1_INTERPOSE)
7527 printf (" INTERPOSE");
7528 val ^= DF_1_INTERPOSE;
7530 if (val & DF_1_NODEFLIB)
7532 printf (" NODEFLIB");
7533 val ^= DF_1_NODEFLIB;
7535 if (val & DF_1_NODUMP)
7540 if (val & DF_1_CONLFAT)
7542 printf (" CONLFAT");
7543 val ^= DF_1_CONLFAT;
7546 printf (" %lx", val);
7553 dynamic_info[entry->d_tag] = entry->d_un.d_val;
7555 puts (get_dynamic_type (entry->d_un.d_val));
7575 dynamic_info[entry->d_tag] = entry->d_un.d_val;
7581 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
7582 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
7588 switch (entry->d_tag)
7591 printf (_("Shared library: [%s]"), name);
7593 if (streq (name, program_interpreter))
7594 printf (_(" program interpreter"));
7598 printf (_("Library soname: [%s]"), name);
7602 printf (_("Library rpath: [%s]"), name);
7606 printf (_("Library runpath: [%s]"), name);
7610 print_vma (entry->d_un.d_val, PREFIX_HEX);
7615 print_vma (entry->d_un.d_val, PREFIX_HEX);
7628 dynamic_info[entry->d_tag] = entry->d_un.d_val;
7632 case DT_INIT_ARRAYSZ:
7633 case DT_FINI_ARRAYSZ:
7634 case DT_GNU_CONFLICTSZ:
7635 case DT_GNU_LIBLISTSZ:
7638 print_vma (entry->d_un.d_val, UNSIGNED);
7639 printf (_(" (bytes)\n"));
7649 print_vma (entry->d_un.d_val, UNSIGNED);
7662 if (entry->d_tag == DT_USED
7663 && VALID_DYNAMIC_NAME (entry->d_un.d_val))
7665 char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
7669 printf (_("Not needed object: [%s]\n"), name);
7674 print_vma (entry->d_un.d_val, PREFIX_HEX);
7680 /* The value of this entry is ignored. */
7685 case DT_GNU_PRELINKED:
7689 time_t atime = entry->d_un.d_val;
7691 tmp = gmtime (&atime);
7692 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
7693 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
7694 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
7700 dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
7703 print_vma (entry->d_un.d_val, PREFIX_HEX);
7709 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
7710 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
7715 switch (elf_header.e_machine)
7718 case EM_MIPS_RS3_LE:
7719 dynamic_section_mips_val (entry);
7722 dynamic_section_parisc_val (entry);
7725 dynamic_section_ia64_val (entry);
7728 print_vma (entry->d_un.d_val, PREFIX_HEX);
7740 get_ver_flags (unsigned int flags)
7742 static char buff[32];
7749 if (flags & VER_FLG_BASE)
7750 strcat (buff, "BASE ");
7752 if (flags & VER_FLG_WEAK)
7754 if (flags & VER_FLG_BASE)
7755 strcat (buff, "| ");
7757 strcat (buff, "WEAK ");
7760 if (flags & VER_FLG_INFO)
7762 if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
7763 strcat (buff, "| ");
7765 strcat (buff, "INFO ");
7768 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
7769 strcat (buff, _("| <unknown>"));
7774 /* Display the contents of the version sections. */
7777 process_version_sections (FILE * file)
7779 Elf_Internal_Shdr * section;
7786 for (i = 0, section = section_headers;
7787 i < elf_header.e_shnum;
7790 switch (section->sh_type)
7792 case SHT_GNU_verdef:
7794 Elf_External_Verdef * edefs;
7802 (_("\nVersion definition section '%s' contains %u entries:\n"),
7803 SECTION_NAME (section), section->sh_info);
7805 printf (_(" Addr: 0x"));
7806 printf_vma (section->sh_addr);
7807 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
7808 (unsigned long) section->sh_offset, section->sh_link,
7809 section->sh_link < elf_header.e_shnum
7810 ? SECTION_NAME (section_headers + section->sh_link)
7813 edefs = (Elf_External_Verdef *)
7814 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
7815 _("version definition section"));
7816 endbuf = (char *) edefs + section->sh_size;
7820 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
7823 Elf_External_Verdef * edef;
7824 Elf_Internal_Verdef ent;
7825 Elf_External_Verdaux * eaux;
7826 Elf_Internal_Verdaux aux;
7830 /* Check for negative or very large indicies. */
7831 if ((unsigned char *) edefs + idx < (unsigned char *) edefs)
7834 vstart = ((char *) edefs) + idx;
7835 if (vstart + sizeof (*edef) > endbuf)
7838 edef = (Elf_External_Verdef *) vstart;
7840 ent.vd_version = BYTE_GET (edef->vd_version);
7841 ent.vd_flags = BYTE_GET (edef->vd_flags);
7842 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
7843 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
7844 ent.vd_hash = BYTE_GET (edef->vd_hash);
7845 ent.vd_aux = BYTE_GET (edef->vd_aux);
7846 ent.vd_next = BYTE_GET (edef->vd_next);
7848 printf (_(" %#06x: Rev: %d Flags: %s"),
7849 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
7851 printf (_(" Index: %d Cnt: %d "),
7852 ent.vd_ndx, ent.vd_cnt);
7854 /* Check for overflow. */
7855 if ((unsigned char *)(vstart + ent.vd_aux) < (unsigned char *) vstart
7856 || (unsigned char *)(vstart + ent.vd_aux) > (unsigned char *) endbuf)
7859 vstart += ent.vd_aux;
7861 eaux = (Elf_External_Verdaux *) vstart;
7863 aux.vda_name = BYTE_GET (eaux->vda_name);
7864 aux.vda_next = BYTE_GET (eaux->vda_next);
7866 if (VALID_DYNAMIC_NAME (aux.vda_name))
7867 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
7869 printf (_("Name index: %ld\n"), aux.vda_name);
7871 isum = idx + ent.vd_aux;
7873 for (j = 1; j < ent.vd_cnt; j++)
7875 /* Check for overflow. */
7876 if ((unsigned char *)(vstart + aux.vda_next) < (unsigned char *) vstart
7877 || (unsigned char *)(vstart + aux.vda_next) > (unsigned char *) endbuf)
7880 isum += aux.vda_next;
7881 vstart += aux.vda_next;
7883 eaux = (Elf_External_Verdaux *) vstart;
7884 if (vstart + sizeof (*eaux) > endbuf)
7887 aux.vda_name = BYTE_GET (eaux->vda_name);
7888 aux.vda_next = BYTE_GET (eaux->vda_next);
7890 if (VALID_DYNAMIC_NAME (aux.vda_name))
7891 printf (_(" %#06x: Parent %d: %s\n"),
7892 isum, j, GET_DYNAMIC_NAME (aux.vda_name));
7894 printf (_(" %#06x: Parent %d, name index: %ld\n"),
7895 isum, j, aux.vda_name);
7899 printf (_(" Version def aux past end of section\n"));
7904 if (cnt < section->sh_info)
7905 printf (_(" Version definition past end of section\n"));
7911 case SHT_GNU_verneed:
7913 Elf_External_Verneed * eneed;
7920 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
7921 SECTION_NAME (section), section->sh_info);
7923 printf (_(" Addr: 0x"));
7924 printf_vma (section->sh_addr);
7925 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
7926 (unsigned long) section->sh_offset, section->sh_link,
7927 section->sh_link < elf_header.e_shnum
7928 ? SECTION_NAME (section_headers + section->sh_link)
7931 eneed = (Elf_External_Verneed *) get_data (NULL, file,
7932 section->sh_offset, 1,
7934 _("version need section"));
7935 endbuf = (char *) eneed + section->sh_size;
7939 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
7941 Elf_External_Verneed * entry;
7942 Elf_Internal_Verneed ent;
7947 if ((unsigned char *) eneed + idx < (unsigned char *) eneed)
7950 vstart = ((char *) eneed) + idx;
7951 if (vstart + sizeof (*entry) > endbuf)
7954 entry = (Elf_External_Verneed *) vstart;
7956 ent.vn_version = BYTE_GET (entry->vn_version);
7957 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
7958 ent.vn_file = BYTE_GET (entry->vn_file);
7959 ent.vn_aux = BYTE_GET (entry->vn_aux);
7960 ent.vn_next = BYTE_GET (entry->vn_next);
7962 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
7964 if (VALID_DYNAMIC_NAME (ent.vn_file))
7965 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
7967 printf (_(" File: %lx"), ent.vn_file);
7969 printf (_(" Cnt: %d\n"), ent.vn_cnt);
7971 /* Check for overflow. */
7972 if ((unsigned char *)(vstart + ent.vn_aux) < (unsigned char *) vstart
7973 || (unsigned char *)(vstart + ent.vn_aux) > (unsigned char *) endbuf)
7976 vstart += ent.vn_aux;
7978 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
7980 Elf_External_Vernaux * eaux;
7981 Elf_Internal_Vernaux aux;
7983 if (vstart + sizeof (*eaux) > endbuf)
7985 eaux = (Elf_External_Vernaux *) vstart;
7987 aux.vna_hash = BYTE_GET (eaux->vna_hash);
7988 aux.vna_flags = BYTE_GET (eaux->vna_flags);
7989 aux.vna_other = BYTE_GET (eaux->vna_other);
7990 aux.vna_name = BYTE_GET (eaux->vna_name);
7991 aux.vna_next = BYTE_GET (eaux->vna_next);
7993 if (VALID_DYNAMIC_NAME (aux.vna_name))
7994 printf (_(" %#06x: Name: %s"),
7995 isum, GET_DYNAMIC_NAME (aux.vna_name));
7997 printf (_(" %#06x: Name index: %lx"),
7998 isum, aux.vna_name);
8000 printf (_(" Flags: %s Version: %d\n"),
8001 get_ver_flags (aux.vna_flags), aux.vna_other);
8003 /* Check for overflow. */
8004 if ((unsigned char *)(vstart + aux.vna_next) < (unsigned char *) vstart
8005 || (unsigned char *)(vstart + aux.vna_next) > (unsigned char *) endbuf)
8008 isum += aux.vna_next;
8009 vstart += aux.vna_next;
8012 printf (_(" Version need aux past end of section\n"));
8016 if (cnt < section->sh_info)
8017 printf (_(" Version need past end of section\n"));
8023 case SHT_GNU_versym:
8025 Elf_Internal_Shdr * link_section;
8028 unsigned char * edata;
8029 unsigned short * data;
8031 Elf_Internal_Sym * symbols;
8032 Elf_Internal_Shdr * string_sec;
8035 if (section->sh_link >= elf_header.e_shnum)
8038 link_section = section_headers + section->sh_link;
8039 total = section->sh_size / sizeof (Elf_External_Versym);
8041 if (link_section->sh_link >= elf_header.e_shnum)
8046 symbols = GET_ELF_SYMBOLS (file, link_section);
8047 if (symbols == NULL)
8050 string_sec = section_headers + link_section->sh_link;
8052 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
8053 string_sec->sh_size,
8054 _("version string table"));
8058 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
8059 SECTION_NAME (section), total);
8061 printf (_(" Addr: "));
8062 printf_vma (section->sh_addr);
8063 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
8064 (unsigned long) section->sh_offset, section->sh_link,
8065 SECTION_NAME (link_section));
8067 off = offset_from_vma (file,
8068 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
8069 total * sizeof (short));
8070 edata = (unsigned char *) get_data (NULL, file, off, total,
8072 _("version symbol data"));
8079 data = (short unsigned int *) cmalloc (total, sizeof (short));
8081 for (cnt = total; cnt --;)
8082 data[cnt] = byte_get (edata + cnt * sizeof (short),
8087 for (cnt = 0; cnt < total; cnt += 4)
8090 int check_def, check_need;
8093 printf (" %03x:", cnt);
8095 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
8096 switch (data[cnt + j])
8099 fputs (_(" 0 (*local*) "), stdout);
8103 fputs (_(" 1 (*global*) "), stdout);
8107 nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
8108 data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
8110 /* If this index value is greater than the size of the symbols
8111 array, break to avoid an out-of-bounds read, */
8112 if ((unsigned long)(cnt + j) >=
8113 ((unsigned long)link_section->sh_size /
8114 (unsigned long)link_section->sh_entsize))
8116 warn (_("invalid index into symbol array\n"));
8122 if (symbols[cnt + j].st_shndx >= elf_header.e_shnum
8123 || section_headers[symbols[cnt + j].st_shndx].sh_type
8126 if (symbols[cnt + j].st_shndx == SHN_UNDEF)
8133 && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
8135 Elf_Internal_Verneed ivn;
8136 unsigned long offset;
8138 offset = offset_from_vma
8139 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
8140 sizeof (Elf_External_Verneed));
8144 Elf_Internal_Vernaux ivna;
8145 Elf_External_Verneed evn;
8146 Elf_External_Vernaux evna;
8147 unsigned long a_off;
8149 get_data (&evn, file, offset, sizeof (evn), 1,
8152 ivn.vn_aux = BYTE_GET (evn.vn_aux);
8153 ivn.vn_next = BYTE_GET (evn.vn_next);
8155 a_off = offset + ivn.vn_aux;
8159 get_data (&evna, file, a_off, sizeof (evna),
8160 1, _("version need aux (2)"));
8162 ivna.vna_next = BYTE_GET (evna.vna_next);
8163 ivna.vna_other = BYTE_GET (evna.vna_other);
8165 a_off += ivna.vna_next;
8167 while (ivna.vna_other != data[cnt + j]
8168 && ivna.vna_next != 0);
8170 if (ivna.vna_other == data[cnt + j])
8172 ivna.vna_name = BYTE_GET (evna.vna_name);
8174 if (ivna.vna_name >= string_sec->sh_size)
8175 name = _("*invalid*");
8177 name = strtab + ivna.vna_name;
8178 nn += printf ("(%s%-*s",
8180 12 - (int) strlen (name),
8186 offset += ivn.vn_next;
8188 while (ivn.vn_next);
8191 if (check_def && data[cnt + j] != 0x8001
8192 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
8194 Elf_Internal_Verdef ivd;
8195 Elf_External_Verdef evd;
8196 unsigned long offset;
8198 offset = offset_from_vma
8199 (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
8204 get_data (&evd, file, offset, sizeof (evd), 1,
8207 ivd.vd_next = BYTE_GET (evd.vd_next);
8208 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
8210 offset += ivd.vd_next;
8212 while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
8213 && ivd.vd_next != 0);
8215 if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
8217 Elf_External_Verdaux evda;
8218 Elf_Internal_Verdaux ivda;
8220 ivd.vd_aux = BYTE_GET (evd.vd_aux);
8222 get_data (&evda, file,
8223 offset - ivd.vd_next + ivd.vd_aux,
8225 _("version def aux"));
8227 ivda.vda_name = BYTE_GET (evda.vda_name);
8229 if (ivda.vda_name >= string_sec->sh_size)
8230 name = _("*invalid*");
8232 name = strtab + ivda.vda_name;
8233 nn += printf ("(%s%-*s",
8235 12 - (int) strlen (name),
8241 printf ("%*c", 18 - nn, ' ');
8259 printf (_("\nNo version information found in this file.\n"));
8265 get_symbol_binding (unsigned int binding)
8267 static char buff[32];
8271 case STB_LOCAL: return "LOCAL";
8272 case STB_GLOBAL: return "GLOBAL";
8273 case STB_WEAK: return "WEAK";
8275 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
8276 snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
8278 else if (binding >= STB_LOOS && binding <= STB_HIOS)
8280 if (binding == STB_GNU_UNIQUE
8281 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_LINUX
8282 /* GNU/Linux is still using the default value 0. */
8283 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
8285 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
8288 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
8294 get_symbol_type (unsigned int type)
8296 static char buff[32];
8300 case STT_NOTYPE: return "NOTYPE";
8301 case STT_OBJECT: return "OBJECT";
8302 case STT_FUNC: return "FUNC";
8303 case STT_SECTION: return "SECTION";
8304 case STT_FILE: return "FILE";
8305 case STT_COMMON: return "COMMON";
8306 case STT_TLS: return "TLS";
8307 case STT_RELC: return "RELC";
8308 case STT_SRELC: return "SRELC";
8310 if (type >= STT_LOPROC && type <= STT_HIPROC)
8312 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
8313 return "THUMB_FUNC";
8315 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
8318 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
8319 return "PARISC_MILLI";
8321 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
8323 else if (type >= STT_LOOS && type <= STT_HIOS)
8325 if (elf_header.e_machine == EM_PARISC)
8327 if (type == STT_HP_OPAQUE)
8329 if (type == STT_HP_STUB)
8333 if (type == STT_GNU_IFUNC
8334 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_LINUX
8335 /* GNU/Linux is still using the default value 0. */
8336 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
8339 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
8342 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
8348 get_symbol_visibility (unsigned int visibility)
8352 case STV_DEFAULT: return "DEFAULT";
8353 case STV_INTERNAL: return "INTERNAL";
8354 case STV_HIDDEN: return "HIDDEN";
8355 case STV_PROTECTED: return "PROTECTED";
8361 get_mips_symbol_other (unsigned int other)
8365 case STO_OPTIONAL: return "OPTIONAL";
8366 case STO_MIPS16: return "MIPS16";
8367 case STO_MIPS_PLT: return "MIPS PLT";
8368 case STO_MIPS_PIC: return "MIPS PIC";
8369 default: return NULL;
8374 get_ia64_symbol_other (unsigned int other)
8378 static char res[32];
8382 /* Function types is for images and .STB files only. */
8383 switch (elf_header.e_type)
8387 switch (VMS_ST_FUNC_TYPE (other))
8389 case VMS_SFT_CODE_ADDR:
8390 strcat (res, " CA");
8392 case VMS_SFT_SYMV_IDX:
8393 strcat (res, " VEC");
8396 strcat (res, " FD");
8398 case VMS_SFT_RESERVE:
8399 strcat (res, " RSV");
8408 switch (VMS_ST_LINKAGE (other))
8410 case VMS_STL_IGNORE:
8411 strcat (res, " IGN");
8413 case VMS_STL_RESERVE:
8414 strcat (res, " RSV");
8417 strcat (res, " STD");
8420 strcat (res, " LNK");
8435 get_symbol_other (unsigned int other)
8437 const char * result = NULL;
8438 static char buff [32];
8443 switch (elf_header.e_machine)
8446 result = get_mips_symbol_other (other);
8449 result = get_ia64_symbol_other (other);
8458 snprintf (buff, sizeof buff, _("<other>: %x"), other);
8463 get_symbol_index_type (unsigned int type)
8465 static char buff[32];
8469 case SHN_UNDEF: return "UND";
8470 case SHN_ABS: return "ABS";
8471 case SHN_COMMON: return "COM";
8473 if (type == SHN_IA_64_ANSI_COMMON
8474 && elf_header.e_machine == EM_IA_64
8475 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
8477 else if ((elf_header.e_machine == EM_X86_64
8478 || elf_header.e_machine == EM_L1OM)
8479 && type == SHN_X86_64_LCOMMON)
8481 else if (type == SHN_MIPS_SCOMMON
8482 && elf_header.e_machine == EM_MIPS)
8484 else if (type == SHN_MIPS_SUNDEFINED
8485 && elf_header.e_machine == EM_MIPS)
8487 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
8488 sprintf (buff, "PRC[0x%04x]", type & 0xffff);
8489 else if (type >= SHN_LOOS && type <= SHN_HIOS)
8490 sprintf (buff, "OS [0x%04x]", type & 0xffff);
8491 else if (type >= SHN_LORESERVE)
8492 sprintf (buff, "RSV[0x%04x]", type & 0xffff);
8494 sprintf (buff, "%3d", type);
8502 get_dynamic_data (FILE * file, unsigned int number, unsigned int ent_size)
8504 unsigned char * e_data;
8507 e_data = (unsigned char *) cmalloc (number, ent_size);
8511 error (_("Out of memory\n"));
8515 if (fread (e_data, ent_size, number, file) != number)
8517 error (_("Unable to read in dynamic data\n"));
8521 i_data = (bfd_vma *) cmalloc (number, sizeof (*i_data));
8525 error (_("Out of memory\n"));
8531 i_data[number] = byte_get (e_data + number * ent_size, ent_size);
8539 print_dynamic_symbol (bfd_vma si, unsigned long hn)
8541 Elf_Internal_Sym * psym;
8544 psym = dynamic_symbols + si;
8546 n = print_vma (si, DEC_5);
8548 fputs (" " + n, stdout);
8549 printf (" %3lu: ", hn);
8550 print_vma (psym->st_value, LONG_HEX);
8552 print_vma (psym->st_size, DEC_5);
8554 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
8555 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
8556 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
8557 /* Check to see if any other bits in the st_other field are set.
8558 Note - displaying this information disrupts the layout of the
8559 table being generated, but for the moment this case is very
8561 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
8562 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
8563 printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
8564 if (VALID_DYNAMIC_NAME (psym->st_name))
8565 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
8567 printf (_(" <corrupt: %14ld>"), psym->st_name);
8571 /* Dump the symbol table. */
8573 process_symbol_table (FILE * file)
8575 Elf_Internal_Shdr * section;
8576 bfd_vma nbuckets = 0;
8577 bfd_vma nchains = 0;
8578 bfd_vma * buckets = NULL;
8579 bfd_vma * chains = NULL;
8580 bfd_vma ngnubuckets = 0;
8581 bfd_vma * gnubuckets = NULL;
8582 bfd_vma * gnuchains = NULL;
8583 bfd_vma gnusymidx = 0;
8585 if (!do_syms && !do_dyn_syms && !do_histogram)
8588 if (dynamic_info[DT_HASH]
8590 || (do_using_dynamic
8592 && dynamic_strings != NULL)))
8594 unsigned char nb[8];
8595 unsigned char nc[8];
8596 int hash_ent_size = 4;
8598 if ((elf_header.e_machine == EM_ALPHA
8599 || elf_header.e_machine == EM_S390
8600 || elf_header.e_machine == EM_S390_OLD)
8601 && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
8605 (archive_file_offset
8606 + offset_from_vma (file, dynamic_info[DT_HASH],
8607 sizeof nb + sizeof nc)),
8610 error (_("Unable to seek to start of dynamic information\n"));
8614 if (fread (nb, hash_ent_size, 1, file) != 1)
8616 error (_("Failed to read in number of buckets\n"));
8620 if (fread (nc, hash_ent_size, 1, file) != 1)
8622 error (_("Failed to read in number of chains\n"));
8626 nbuckets = byte_get (nb, hash_ent_size);
8627 nchains = byte_get (nc, hash_ent_size);
8629 buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
8630 chains = get_dynamic_data (file, nchains, hash_ent_size);
8633 if (buckets == NULL || chains == NULL)
8635 if (do_using_dynamic)
8646 if (dynamic_info_DT_GNU_HASH
8648 || (do_using_dynamic
8650 && dynamic_strings != NULL)))
8652 unsigned char nb[16];
8653 bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
8654 bfd_vma buckets_vma;
8657 (archive_file_offset
8658 + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
8662 error (_("Unable to seek to start of dynamic information\n"));
8666 if (fread (nb, 16, 1, file) != 1)
8668 error (_("Failed to read in number of buckets\n"));
8672 ngnubuckets = byte_get (nb, 4);
8673 gnusymidx = byte_get (nb + 4, 4);
8674 bitmaskwords = byte_get (nb + 8, 4);
8675 buckets_vma = dynamic_info_DT_GNU_HASH + 16;
8677 buckets_vma += bitmaskwords * 4;
8679 buckets_vma += bitmaskwords * 8;
8682 (archive_file_offset
8683 + offset_from_vma (file, buckets_vma, 4)),
8686 error (_("Unable to seek to start of dynamic information\n"));
8690 gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
8692 if (gnubuckets == NULL)
8695 for (i = 0; i < ngnubuckets; i++)
8696 if (gnubuckets[i] != 0)
8698 if (gnubuckets[i] < gnusymidx)
8701 if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
8702 maxchain = gnubuckets[i];
8705 if (maxchain == 0xffffffff)
8708 maxchain -= gnusymidx;
8711 (archive_file_offset
8712 + offset_from_vma (file, buckets_vma
8713 + 4 * (ngnubuckets + maxchain), 4)),
8716 error (_("Unable to seek to start of dynamic information\n"));
8722 if (fread (nb, 4, 1, file) != 1)
8724 error (_("Failed to determine last chain length\n"));
8728 if (maxchain + 1 == 0)
8733 while ((byte_get (nb, 4) & 1) == 0);
8736 (archive_file_offset
8737 + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
8740 error (_("Unable to seek to start of dynamic information\n"));
8744 gnuchains = get_dynamic_data (file, maxchain, 4);
8747 if (gnuchains == NULL)
8752 if (do_using_dynamic)
8757 if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
8760 && dynamic_strings != NULL)
8764 if (dynamic_info[DT_HASH])
8768 printf (_("\nSymbol table for image:\n"));
8770 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
8772 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
8774 for (hn = 0; hn < nbuckets; hn++)
8779 for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
8780 print_dynamic_symbol (si, hn);
8784 if (dynamic_info_DT_GNU_HASH)
8786 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
8788 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
8790 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
8792 for (hn = 0; hn < ngnubuckets; ++hn)
8793 if (gnubuckets[hn] != 0)
8795 bfd_vma si = gnubuckets[hn];
8796 bfd_vma off = si - gnusymidx;
8800 print_dynamic_symbol (si, hn);
8803 while ((gnuchains[off++] & 1) == 0);
8807 else if (do_dyn_syms || (do_syms && !do_using_dynamic))
8811 for (i = 0, section = section_headers;
8812 i < elf_header.e_shnum;
8816 char * strtab = NULL;
8817 unsigned long int strtab_size = 0;
8818 Elf_Internal_Sym * symtab;
8819 Elf_Internal_Sym * psym;
8821 if ((section->sh_type != SHT_SYMTAB
8822 && section->sh_type != SHT_DYNSYM)
8824 && section->sh_type == SHT_SYMTAB))
8827 if (section->sh_entsize == 0)
8829 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
8830 SECTION_NAME (section));
8834 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
8835 SECTION_NAME (section),
8836 (unsigned long) (section->sh_size / section->sh_entsize));
8839 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
8841 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
8843 symtab = GET_ELF_SYMBOLS (file, section);
8847 if (section->sh_link == elf_header.e_shstrndx)
8849 strtab = string_table;
8850 strtab_size = string_table_length;
8852 else if (section->sh_link < elf_header.e_shnum)
8854 Elf_Internal_Shdr * string_sec;
8856 string_sec = section_headers + section->sh_link;
8858 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
8859 1, string_sec->sh_size,
8861 strtab_size = strtab != NULL ? string_sec->sh_size : 0;
8864 for (si = 0, psym = symtab;
8865 si < section->sh_size / section->sh_entsize;
8868 printf ("%6d: ", si);
8869 print_vma (psym->st_value, LONG_HEX);
8871 print_vma (psym->st_size, DEC_5);
8872 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
8873 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
8874 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
8875 /* Check to see if any other bits in the st_other field are set.
8876 Note - displaying this information disrupts the layout of the
8877 table being generated, but for the moment this case is very rare. */
8878 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
8879 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
8880 printf (" %4s ", get_symbol_index_type (psym->st_shndx));
8881 print_symbol (25, psym->st_name < strtab_size
8882 ? strtab + psym->st_name : _("<corrupt>"));
8884 if (section->sh_type == SHT_DYNSYM &&
8885 version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
8887 unsigned char data[2];
8888 unsigned short vers_data;
8889 unsigned long offset;
8893 offset = offset_from_vma
8894 (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
8895 sizeof data + si * sizeof (vers_data));
8897 get_data (&data, file, offset + si * sizeof (vers_data),
8898 sizeof (data), 1, _("version data"));
8900 vers_data = byte_get (data, 2);
8902 is_nobits = (psym->st_shndx < elf_header.e_shnum
8903 && section_headers[psym->st_shndx].sh_type
8906 check_def = (psym->st_shndx != SHN_UNDEF);
8908 if ((vers_data & VERSYM_HIDDEN) || vers_data > 1)
8910 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
8911 && (is_nobits || ! check_def))
8913 Elf_External_Verneed evn;
8914 Elf_Internal_Verneed ivn;
8915 Elf_Internal_Vernaux ivna;
8917 /* We must test both. */
8918 offset = offset_from_vma
8919 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
8924 unsigned long vna_off;
8926 get_data (&evn, file, offset, sizeof (evn), 1,
8929 ivn.vn_aux = BYTE_GET (evn.vn_aux);
8930 ivn.vn_next = BYTE_GET (evn.vn_next);
8932 vna_off = offset + ivn.vn_aux;
8936 Elf_External_Vernaux evna;
8938 get_data (&evna, file, vna_off,
8940 _("version need aux (3)"));
8942 ivna.vna_other = BYTE_GET (evna.vna_other);
8943 ivna.vna_next = BYTE_GET (evna.vna_next);
8944 ivna.vna_name = BYTE_GET (evna.vna_name);
8946 vna_off += ivna.vna_next;
8948 while (ivna.vna_other != vers_data
8949 && ivna.vna_next != 0);
8951 if (ivna.vna_other == vers_data)
8954 offset += ivn.vn_next;
8956 while (ivn.vn_next != 0);
8958 if (ivna.vna_other == vers_data)
8961 ivna.vna_name < strtab_size
8962 ? strtab + ivna.vna_name : _("<corrupt>"),
8966 else if (! is_nobits)
8967 error (_("bad dynamic symbol\n"));
8974 if (vers_data != 0x8001
8975 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
8977 Elf_Internal_Verdef ivd;
8978 Elf_Internal_Verdaux ivda;
8979 Elf_External_Verdaux evda;
8982 off = offset_from_vma
8984 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
8985 sizeof (Elf_External_Verdef));
8989 Elf_External_Verdef evd;
8991 get_data (&evd, file, off, sizeof (evd),
8992 1, _("version def"));
8994 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
8995 ivd.vd_aux = BYTE_GET (evd.vd_aux);
8996 ivd.vd_next = BYTE_GET (evd.vd_next);
9000 while (ivd.vd_ndx != (vers_data & VERSYM_VERSION)
9001 && ivd.vd_next != 0);
9006 get_data (&evda, file, off, sizeof (evda),
9007 1, _("version def aux"));
9009 ivda.vda_name = BYTE_GET (evda.vda_name);
9011 if (psym->st_name != ivda.vda_name)
9012 printf ((vers_data & VERSYM_HIDDEN)
9014 ivda.vda_name < strtab_size
9015 ? strtab + ivda.vda_name : _("<corrupt>"));
9025 if (strtab != string_table)
9031 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
9033 if (do_histogram && buckets != NULL)
9035 unsigned long * lengths;
9036 unsigned long * counts;
9039 unsigned long maxlength = 0;
9040 unsigned long nzero_counts = 0;
9041 unsigned long nsyms = 0;
9043 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
9044 (unsigned long) nbuckets);
9045 printf (_(" Length Number %% of total Coverage\n"));
9047 lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
9048 if (lengths == NULL)
9050 error (_("Out of memory\n"));
9053 for (hn = 0; hn < nbuckets; ++hn)
9055 for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
9058 if (maxlength < ++lengths[hn])
9063 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
9066 error (_("Out of memory\n"));
9070 for (hn = 0; hn < nbuckets; ++hn)
9071 ++counts[lengths[hn]];
9076 printf (" 0 %-10lu (%5.1f%%)\n",
9077 counts[0], (counts[0] * 100.0) / nbuckets);
9078 for (i = 1; i <= maxlength; ++i)
9080 nzero_counts += counts[i] * i;
9081 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
9082 i, counts[i], (counts[i] * 100.0) / nbuckets,
9083 (nzero_counts * 100.0) / nsyms);
9091 if (buckets != NULL)
9097 if (do_histogram && gnubuckets != NULL)
9099 unsigned long * lengths;
9100 unsigned long * counts;
9102 unsigned long maxlength = 0;
9103 unsigned long nzero_counts = 0;
9104 unsigned long nsyms = 0;
9106 lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
9107 if (lengths == NULL)
9109 error (_("Out of memory\n"));
9113 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
9114 (unsigned long) ngnubuckets);
9115 printf (_(" Length Number %% of total Coverage\n"));
9117 for (hn = 0; hn < ngnubuckets; ++hn)
9118 if (gnubuckets[hn] != 0)
9120 bfd_vma off, length = 1;
9122 for (off = gnubuckets[hn] - gnusymidx;
9123 (gnuchains[off] & 1) == 0; ++off)
9125 lengths[hn] = length;
9126 if (length > maxlength)
9131 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
9134 error (_("Out of memory\n"));
9138 for (hn = 0; hn < ngnubuckets; ++hn)
9139 ++counts[lengths[hn]];
9141 if (ngnubuckets > 0)
9144 printf (" 0 %-10lu (%5.1f%%)\n",
9145 counts[0], (counts[0] * 100.0) / ngnubuckets);
9146 for (j = 1; j <= maxlength; ++j)
9148 nzero_counts += counts[j] * j;
9149 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
9150 j, counts[j], (counts[j] * 100.0) / ngnubuckets,
9151 (nzero_counts * 100.0) / nsyms);
9165 process_syminfo (FILE * file ATTRIBUTE_UNUSED)
9169 if (dynamic_syminfo == NULL
9171 /* No syminfo, this is ok. */
9174 /* There better should be a dynamic symbol section. */
9175 if (dynamic_symbols == NULL || dynamic_strings == NULL)
9179 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
9180 dynamic_syminfo_offset, dynamic_syminfo_nent);
9182 printf (_(" Num: Name BoundTo Flags\n"));
9183 for (i = 0; i < dynamic_syminfo_nent; ++i)
9185 unsigned short int flags = dynamic_syminfo[i].si_flags;
9187 printf ("%4d: ", i);
9188 if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
9189 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
9191 printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
9194 switch (dynamic_syminfo[i].si_boundto)
9196 case SYMINFO_BT_SELF:
9197 fputs ("SELF ", stdout);
9199 case SYMINFO_BT_PARENT:
9200 fputs ("PARENT ", stdout);
9203 if (dynamic_syminfo[i].si_boundto > 0
9204 && dynamic_syminfo[i].si_boundto < dynamic_nent
9205 && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
9207 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
9211 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
9215 if (flags & SYMINFO_FLG_DIRECT)
9217 if (flags & SYMINFO_FLG_PASSTHRU)
9218 printf (" PASSTHRU");
9219 if (flags & SYMINFO_FLG_COPY)
9221 if (flags & SYMINFO_FLG_LAZYLOAD)
9222 printf (" LAZYLOAD");
9230 /* Check to see if the given reloc needs to be handled in a target specific
9231 manner. If so then process the reloc and return TRUE otherwise return
9235 target_specific_reloc_handling (Elf_Internal_Rela * reloc,
9236 unsigned char * start,
9237 Elf_Internal_Sym * symtab)
9239 unsigned int reloc_type = get_reloc_type (reloc->r_info);
9241 switch (elf_header.e_machine)
9244 case EM_CYGNUS_MN10300:
9246 static Elf_Internal_Sym * saved_sym = NULL;
9250 case 34: /* R_MN10300_ALIGN */
9252 case 33: /* R_MN10300_SYM_DIFF */
9253 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
9255 case 1: /* R_MN10300_32 */
9256 case 2: /* R_MN10300_16 */
9257 if (saved_sym != NULL)
9261 value = reloc->r_addend
9262 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
9263 - saved_sym->st_value);
9265 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
9272 if (saved_sym != NULL)
9273 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc"));
9283 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
9284 DWARF debug sections. This is a target specific test. Note - we do not
9285 go through the whole including-target-headers-multiple-times route, (as
9286 we have already done with <elf/h8.h>) because this would become very
9287 messy and even then this function would have to contain target specific
9288 information (the names of the relocs instead of their numeric values).
9289 FIXME: This is not the correct way to solve this problem. The proper way
9290 is to have target specific reloc sizing and typing functions created by
9291 the reloc-macros.h header, in the same way that it already creates the
9292 reloc naming functions. */
9295 is_32bit_abs_reloc (unsigned int reloc_type)
9297 switch (elf_header.e_machine)
9301 return reloc_type == 1; /* R_386_32. */
9303 return reloc_type == 1; /* R_68K_32. */
9305 return reloc_type == 1; /* R_860_32. */
9307 return reloc_type == 2; /* R_960_32. */
9309 return reloc_type == 1; /* R_ALPHA_REFLONG. */
9311 return reloc_type == 1; /* R_ARC_32. */
9313 return reloc_type == 2; /* R_ARM_ABS32 */
9316 return reloc_type == 1;
9318 return reloc_type == 0x12; /* R_byte4_data. */
9320 return reloc_type == 3; /* R_CRIS_32. */
9323 return reloc_type == 3; /* R_CR16_NUM32. */
9325 return reloc_type == 15; /* R_CRX_NUM32. */
9327 return reloc_type == 1;
9328 case EM_CYGNUS_D10V:
9330 return reloc_type == 6; /* R_D10V_32. */
9331 case EM_CYGNUS_D30V:
9333 return reloc_type == 12; /* R_D30V_32_NORMAL. */
9335 return reloc_type == 3; /* R_DLX_RELOC_32. */
9336 case EM_CYGNUS_FR30:
9338 return reloc_type == 3; /* R_FR30_32. */
9342 return reloc_type == 1; /* R_H8_DIR32. */
9344 return reloc_type == 0x65; /* R_IA64_SECREL32LSB. */
9347 return reloc_type == 2; /* R_IP2K_32. */
9349 return reloc_type == 2; /* R_IQ2000_32. */
9350 case EM_LATTICEMICO32:
9351 return reloc_type == 3; /* R_LM32_32. */
9354 return reloc_type == 3; /* R_M32C_32. */
9356 return reloc_type == 34; /* R_M32R_32_RELA. */
9358 return reloc_type == 1; /* R_MCORE_ADDR32. */
9360 return reloc_type == 4; /* R_MEP_32. */
9362 return reloc_type == 1; /* R_MICROBLAZE_32. */
9364 return reloc_type == 2; /* R_MIPS_32. */
9366 return reloc_type == 4; /* R_MMIX_32. */
9367 case EM_CYGNUS_MN10200:
9369 return reloc_type == 1; /* R_MN10200_32. */
9370 case EM_CYGNUS_MN10300:
9372 return reloc_type == 1; /* R_MN10300_32. */
9374 return reloc_type == 1; /* R_MOXIE_32. */
9377 return reloc_type == 1; /* R_MSP43_32. */
9379 return reloc_type == 2; /* R_MT_32. */
9380 case EM_ALTERA_NIOS2:
9382 return reloc_type == 1; /* R_NIOS_32. */
9385 return reloc_type == 1; /* R_OR32_32. */
9387 return (reloc_type == 1 /* R_PARISC_DIR32. */
9388 || reloc_type == 41); /* R_PARISC_SECREL32. */
9391 return reloc_type == 1; /* R_PJ_DATA_DIR32. */
9393 return reloc_type == 1; /* R_PPC64_ADDR32. */
9395 return reloc_type == 1; /* R_PPC_ADDR32. */
9397 return reloc_type == 1; /* R_RX_DIR32. */
9399 return reloc_type == 1; /* R_I370_ADDR31. */
9402 return reloc_type == 4; /* R_S390_32. */
9404 return reloc_type == 8; /* R_SCORE_ABS32. */
9406 return reloc_type == 1; /* R_SH_DIR32. */
9407 case EM_SPARC32PLUS:
9410 return reloc_type == 3 /* R_SPARC_32. */
9411 || reloc_type == 23; /* R_SPARC_UA32. */
9413 return reloc_type == 6; /* R_SPU_ADDR32 */
9415 return reloc_type == 1; /* R_C6000_ABS32. */
9416 case EM_CYGNUS_V850:
9418 return reloc_type == 6; /* R_V850_ABS32. */
9420 return reloc_type == 1; /* R_VAX_32. */
9423 return reloc_type == 10; /* R_X86_64_32. */
9426 return reloc_type == 3; /* R_XC16C_ABS_32. */
9428 return reloc_type == 1; /* R_XSTROMY16_32. */
9431 return reloc_type == 1; /* R_XTENSA_32. */
9433 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
9434 elf_header.e_machine);
9439 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9440 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
9443 is_32bit_pcrel_reloc (unsigned int reloc_type)
9445 switch (elf_header.e_machine)
9449 return reloc_type == 2; /* R_386_PC32. */
9451 return reloc_type == 4; /* R_68K_PC32. */
9453 return reloc_type == 10; /* R_ALPHA_SREL32. */
9455 return reloc_type == 3; /* R_ARM_REL32 */
9457 return reloc_type == 2; /* R_MICROBLAZE_32_PCREL. */
9459 return reloc_type == 9; /* R_PARISC_PCREL32. */
9461 return reloc_type == 26; /* R_PPC_REL32. */
9463 return reloc_type == 26; /* R_PPC64_REL32. */
9466 return reloc_type == 5; /* R_390_PC32. */
9468 return reloc_type == 2; /* R_SH_REL32. */
9469 case EM_SPARC32PLUS:
9472 return reloc_type == 6; /* R_SPARC_DISP32. */
9474 return reloc_type == 13; /* R_SPU_REL32. */
9477 return reloc_type == 2; /* R_X86_64_PC32. */
9480 return reloc_type == 14; /* R_XTENSA_32_PCREL. */
9482 /* Do not abort or issue an error message here. Not all targets use
9483 pc-relative 32-bit relocs in their DWARF debug information and we
9484 have already tested for target coverage in is_32bit_abs_reloc. A
9485 more helpful warning message will be generated by apply_relocations
9486 anyway, so just return. */
9491 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9492 a 64-bit absolute RELA relocation used in DWARF debug sections. */
9495 is_64bit_abs_reloc (unsigned int reloc_type)
9497 switch (elf_header.e_machine)
9500 return reloc_type == 2; /* R_ALPHA_REFQUAD. */
9502 return reloc_type == 0x27; /* R_IA64_DIR64LSB. */
9504 return reloc_type == 80; /* R_PARISC_DIR64. */
9506 return reloc_type == 38; /* R_PPC64_ADDR64. */
9507 case EM_SPARC32PLUS:
9510 return reloc_type == 54; /* R_SPARC_UA64. */
9513 return reloc_type == 1; /* R_X86_64_64. */
9516 return reloc_type == 22; /* R_S390_64 */
9518 return reloc_type == 18; /* R_MIPS_64 */
9524 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
9525 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
9528 is_64bit_pcrel_reloc (unsigned int reloc_type)
9530 switch (elf_header.e_machine)
9533 return reloc_type == 11; /* R_ALPHA_SREL64 */
9535 return reloc_type == 0x4f; /* R_IA64_PCREL64LSB */
9537 return reloc_type == 72; /* R_PARISC_PCREL64 */
9539 return reloc_type == 44; /* R_PPC64_REL64 */
9540 case EM_SPARC32PLUS:
9543 return reloc_type == 46; /* R_SPARC_DISP64 */
9546 return reloc_type == 24; /* R_X86_64_PC64 */
9549 return reloc_type == 23; /* R_S390_PC64 */
9555 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9556 a 24-bit absolute RELA relocation used in DWARF debug sections. */
9559 is_24bit_abs_reloc (unsigned int reloc_type)
9561 switch (elf_header.e_machine)
9563 case EM_CYGNUS_MN10200:
9565 return reloc_type == 4; /* R_MN10200_24. */
9571 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9572 a 16-bit absolute RELA relocation used in DWARF debug sections. */
9575 is_16bit_abs_reloc (unsigned int reloc_type)
9577 switch (elf_header.e_machine)
9581 return reloc_type == 4; /* R_AVR_16. */
9582 case EM_CYGNUS_D10V:
9584 return reloc_type == 3; /* R_D10V_16. */
9588 return reloc_type == R_H8_DIR16;
9591 return reloc_type == 1; /* R_IP2K_16. */
9594 return reloc_type == 1; /* R_M32C_16 */
9597 return reloc_type == 5; /* R_MSP430_16_BYTE. */
9598 case EM_ALTERA_NIOS2:
9600 return reloc_type == 9; /* R_NIOS_16. */
9602 return reloc_type == 2; /* R_C6000_ABS16. */
9605 return reloc_type == 2; /* R_XC16C_ABS_16. */
9611 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
9612 relocation entries (possibly formerly used for SHT_GROUP sections). */
9615 is_none_reloc (unsigned int reloc_type)
9617 switch (elf_header.e_machine)
9619 case EM_68K: /* R_68K_NONE. */
9620 case EM_386: /* R_386_NONE. */
9621 case EM_SPARC32PLUS:
9623 case EM_SPARC: /* R_SPARC_NONE. */
9624 case EM_MIPS: /* R_MIPS_NONE. */
9625 case EM_PARISC: /* R_PARISC_NONE. */
9626 case EM_ALPHA: /* R_ALPHA_NONE. */
9627 case EM_PPC: /* R_PPC_NONE. */
9628 case EM_PPC64: /* R_PPC64_NONE. */
9629 case EM_ARM: /* R_ARM_NONE. */
9630 case EM_IA_64: /* R_IA64_NONE. */
9631 case EM_SH: /* R_SH_NONE. */
9633 case EM_S390: /* R_390_NONE. */
9634 case EM_CRIS: /* R_CRIS_NONE. */
9635 case EM_X86_64: /* R_X86_64_NONE. */
9636 case EM_L1OM: /* R_X86_64_NONE. */
9637 case EM_MN10300: /* R_MN10300_NONE. */
9638 case EM_MOXIE: /* R_MOXIE_NONE. */
9639 case EM_M32R: /* R_M32R_NONE. */
9640 case EM_TI_C6000:/* R_C6000_NONE. */
9642 case EM_C166: /* R_XC16X_NONE. */
9643 return reloc_type == 0;
9646 return (reloc_type == 0 /* R_XTENSA_NONE. */
9647 || reloc_type == 17 /* R_XTENSA_DIFF8. */
9648 || reloc_type == 18 /* R_XTENSA_DIFF16. */
9649 || reloc_type == 19 /* R_XTENSA_DIFF32. */);
9654 /* Apply relocations to a section.
9655 Note: So far support has been added only for those relocations
9656 which can be found in debug sections.
9657 FIXME: Add support for more relocations ? */
9660 apply_relocations (void * file,
9661 Elf_Internal_Shdr * section,
9662 unsigned char * start)
9664 Elf_Internal_Shdr * relsec;
9665 unsigned char * end = start + section->sh_size;
9667 if (elf_header.e_type != ET_REL)
9670 /* Find the reloc section associated with the section. */
9671 for (relsec = section_headers;
9672 relsec < section_headers + elf_header.e_shnum;
9675 bfd_boolean is_rela;
9676 unsigned long num_relocs;
9677 Elf_Internal_Rela * relocs;
9678 Elf_Internal_Rela * rp;
9679 Elf_Internal_Shdr * symsec;
9680 Elf_Internal_Sym * symtab;
9681 Elf_Internal_Sym * sym;
9683 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
9684 || relsec->sh_info >= elf_header.e_shnum
9685 || section_headers + relsec->sh_info != section
9686 || relsec->sh_size == 0
9687 || relsec->sh_link >= elf_header.e_shnum)
9690 is_rela = relsec->sh_type == SHT_RELA;
9694 if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
9695 relsec->sh_size, & relocs, & num_relocs))
9700 if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
9701 relsec->sh_size, & relocs, & num_relocs))
9705 /* SH uses RELA but uses in place value instead of the addend field. */
9706 if (elf_header.e_machine == EM_SH)
9709 symsec = section_headers + relsec->sh_link;
9710 symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec);
9712 for (rp = relocs; rp < relocs + num_relocs; ++rp)
9715 unsigned int reloc_type;
9716 unsigned int reloc_size;
9717 unsigned char * rloc;
9719 reloc_type = get_reloc_type (rp->r_info);
9721 if (target_specific_reloc_handling (rp, start, symtab))
9723 else if (is_none_reloc (reloc_type))
9725 else if (is_32bit_abs_reloc (reloc_type)
9726 || is_32bit_pcrel_reloc (reloc_type))
9728 else if (is_64bit_abs_reloc (reloc_type)
9729 || is_64bit_pcrel_reloc (reloc_type))
9731 else if (is_24bit_abs_reloc (reloc_type))
9733 else if (is_16bit_abs_reloc (reloc_type))
9737 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
9738 reloc_type, SECTION_NAME (section));
9742 rloc = start + rp->r_offset;
9743 if ((rloc + reloc_size) > end)
9745 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
9746 (unsigned long) rp->r_offset,
9747 SECTION_NAME (section));
9751 sym = symtab + get_reloc_symindex (rp->r_info);
9753 /* If the reloc has a symbol associated with it,
9754 make sure that it is of an appropriate type.
9756 Relocations against symbols without type can happen.
9757 Gcc -feliminate-dwarf2-dups may generate symbols
9758 without type for debug info.
9760 Icc generates relocations against function symbols
9761 instead of local labels.
9763 Relocations against object symbols can happen, eg when
9764 referencing a global array. For an example of this see
9765 the _clz.o binary in libgcc.a. */
9767 && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
9769 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
9770 get_symbol_type (ELF_ST_TYPE (sym->st_info)),
9771 (long int)(rp - relocs),
9772 SECTION_NAME (relsec));
9778 addend += rp->r_addend;
9779 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
9782 || (elf_header.e_machine == EM_XTENSA
9784 || ((elf_header.e_machine == EM_PJ
9785 || elf_header.e_machine == EM_PJ_OLD)
9787 || ((elf_header.e_machine == EM_D30V
9788 || elf_header.e_machine == EM_CYGNUS_D30V)
9789 && reloc_type == 12))
9790 addend += byte_get (rloc, reloc_size);
9792 if (is_32bit_pcrel_reloc (reloc_type)
9793 || is_64bit_pcrel_reloc (reloc_type))
9795 /* On HPPA, all pc-relative relocations are biased by 8. */
9796 if (elf_header.e_machine == EM_PARISC)
9798 byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
9802 byte_put (rloc, addend + sym->st_value, reloc_size);
9811 #ifdef SUPPORT_DISASSEMBLY
9813 disassemble_section (Elf_Internal_Shdr * section, FILE * file)
9815 printf (_("\nAssembly dump of section %s\n"),
9816 SECTION_NAME (section));
9818 /* XXX -- to be done --- XXX */
9824 /* Reads in the contents of SECTION from FILE, returning a pointer
9825 to a malloc'ed buffer or NULL if something went wrong. */
9828 get_section_contents (Elf_Internal_Shdr * section, FILE * file)
9830 bfd_size_type num_bytes;
9832 num_bytes = section->sh_size;
9834 if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
9836 printf (_("\nSection '%s' has no data to dump.\n"),
9837 SECTION_NAME (section));
9841 return (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
9842 _("section contents"));
9847 dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
9849 Elf_Internal_Shdr * relsec;
9850 bfd_size_type num_bytes;
9854 char * name = SECTION_NAME (section);
9855 bfd_boolean some_strings_shown;
9857 start = get_section_contents (section, file);
9861 printf (_("\nString dump of section '%s':\n"), name);
9863 /* If the section being dumped has relocations against it the user might
9864 be expecting these relocations to have been applied. Check for this
9865 case and issue a warning message in order to avoid confusion.
9866 FIXME: Maybe we ought to have an option that dumps a section with
9868 for (relsec = section_headers;
9869 relsec < section_headers + elf_header.e_shnum;
9872 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
9873 || relsec->sh_info >= elf_header.e_shnum
9874 || section_headers + relsec->sh_info != section
9875 || relsec->sh_size == 0
9876 || relsec->sh_link >= elf_header.e_shnum)
9879 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
9883 num_bytes = section->sh_size;
9885 end = start + num_bytes;
9886 some_strings_shown = FALSE;
9890 while (!ISPRINT (* data))
9897 /* PR 11128: Use two separate invocations in order to work
9898 around bugs in the Solaris 8 implementation of printf. */
9899 printf (" [%6tx] ", data - start);
9900 printf ("%s\n", data);
9902 printf (" [%6Ix] %s\n", (size_t) (data - start), data);
9904 data += strlen (data);
9905 some_strings_shown = TRUE;
9909 if (! some_strings_shown)
9910 printf (_(" No strings found in this section."));
9918 dump_section_as_bytes (Elf_Internal_Shdr * section,
9920 bfd_boolean relocate)
9922 Elf_Internal_Shdr * relsec;
9923 bfd_size_type bytes;
9925 unsigned char * data;
9926 unsigned char * start;
9928 start = (unsigned char *) get_section_contents (section, file);
9932 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
9936 apply_relocations (file, section, start);
9940 /* If the section being dumped has relocations against it the user might
9941 be expecting these relocations to have been applied. Check for this
9942 case and issue a warning message in order to avoid confusion.
9943 FIXME: Maybe we ought to have an option that dumps a section with
9945 for (relsec = section_headers;
9946 relsec < section_headers + elf_header.e_shnum;
9949 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
9950 || relsec->sh_info >= elf_header.e_shnum
9951 || section_headers + relsec->sh_info != section
9952 || relsec->sh_size == 0
9953 || relsec->sh_link >= elf_header.e_shnum)
9956 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
9961 addr = section->sh_addr;
9962 bytes = section->sh_size;
9971 lbytes = (bytes > 16 ? 16 : bytes);
9973 printf (" 0x%8.8lx ", (unsigned long) addr);
9975 for (j = 0; j < 16; j++)
9978 printf ("%2.2x", data[j]);
9986 for (j = 0; j < lbytes; j++)
9989 if (k >= ' ' && k < 0x7f)
10007 /* Uncompresses a section that was compressed using zlib, in place. */
10010 uncompress_section_contents (unsigned char **buffer ATTRIBUTE_UNUSED,
10011 dwarf_size_type *size ATTRIBUTE_UNUSED)
10013 #ifndef HAVE_ZLIB_H
10016 dwarf_size_type compressed_size = *size;
10017 unsigned char * compressed_buffer = *buffer;
10018 dwarf_size_type uncompressed_size;
10019 unsigned char * uncompressed_buffer;
10022 dwarf_size_type header_size = 12;
10024 /* Read the zlib header. In this case, it should be "ZLIB" followed
10025 by the uncompressed section size, 8 bytes in big-endian order. */
10026 if (compressed_size < header_size
10027 || ! streq ((char *) compressed_buffer, "ZLIB"))
10030 uncompressed_size = compressed_buffer[4]; uncompressed_size <<= 8;
10031 uncompressed_size += compressed_buffer[5]; uncompressed_size <<= 8;
10032 uncompressed_size += compressed_buffer[6]; uncompressed_size <<= 8;
10033 uncompressed_size += compressed_buffer[7]; uncompressed_size <<= 8;
10034 uncompressed_size += compressed_buffer[8]; uncompressed_size <<= 8;
10035 uncompressed_size += compressed_buffer[9]; uncompressed_size <<= 8;
10036 uncompressed_size += compressed_buffer[10]; uncompressed_size <<= 8;
10037 uncompressed_size += compressed_buffer[11];
10039 /* It is possible the section consists of several compressed
10040 buffers concatenated together, so we uncompress in a loop. */
10041 strm.zalloc = NULL;
10043 strm.opaque = NULL;
10044 strm.avail_in = compressed_size - header_size;
10045 strm.next_in = (Bytef *) compressed_buffer + header_size;
10046 strm.avail_out = uncompressed_size;
10047 uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
10049 rc = inflateInit (& strm);
10050 while (strm.avail_in > 0)
10054 strm.next_out = ((Bytef *) uncompressed_buffer
10055 + (uncompressed_size - strm.avail_out));
10056 rc = inflate (&strm, Z_FINISH);
10057 if (rc != Z_STREAM_END)
10059 rc = inflateReset (& strm);
10061 rc = inflateEnd (& strm);
10063 || strm.avail_out != 0)
10066 free (compressed_buffer);
10067 *buffer = uncompressed_buffer;
10068 *size = uncompressed_size;
10072 free (uncompressed_buffer);
10073 /* Indicate decompression failure. */
10076 #endif /* HAVE_ZLIB_H */
10080 load_specific_debug_section (enum dwarf_section_display_enum debug,
10081 Elf_Internal_Shdr * sec, void * file)
10083 struct dwarf_section * section = &debug_displays [debug].section;
10086 /* If it is already loaded, do nothing. */
10087 if (section->start != NULL)
10090 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
10091 section->address = sec->sh_addr;
10092 section->size = sec->sh_size;
10093 section->start = (unsigned char *) get_data (NULL, (FILE *) file,
10095 sec->sh_size, buf);
10096 if (uncompress_section_contents (§ion->start, §ion->size))
10097 sec->sh_size = section->size;
10099 if (section->start == NULL)
10102 if (debug_displays [debug].relocate)
10103 apply_relocations ((FILE *) file, sec, section->start);
10109 load_debug_section (enum dwarf_section_display_enum debug, void * file)
10111 struct dwarf_section * section = &debug_displays [debug].section;
10112 Elf_Internal_Shdr * sec;
10114 /* Locate the debug section. */
10115 sec = find_section (section->uncompressed_name);
10117 section->name = section->uncompressed_name;
10120 sec = find_section (section->compressed_name);
10122 section->name = section->compressed_name;
10127 return load_specific_debug_section (debug, sec, (FILE *) file);
10131 free_debug_section (enum dwarf_section_display_enum debug)
10133 struct dwarf_section * section = &debug_displays [debug].section;
10135 if (section->start == NULL)
10138 free ((char *) section->start);
10139 section->start = NULL;
10140 section->address = 0;
10145 display_debug_section (Elf_Internal_Shdr * section, FILE * file)
10147 char * name = SECTION_NAME (section);
10148 bfd_size_type length;
10152 length = section->sh_size;
10155 printf (_("\nSection '%s' has no debugging data.\n"), name);
10158 if (section->sh_type == SHT_NOBITS)
10160 /* There is no point in dumping the contents of a debugging section
10161 which has the NOBITS type - the bits in the file will be random.
10162 This can happen when a file containing a .eh_frame section is
10163 stripped with the --only-keep-debug command line option. */
10164 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"), name);
10168 if (const_strneq (name, ".gnu.linkonce.wi."))
10169 name = ".debug_info";
10171 /* See if we know how to display the contents of this section. */
10172 for (i = 0; i < max; i++)
10173 if (streq (debug_displays[i].section.uncompressed_name, name)
10174 || streq (debug_displays[i].section.compressed_name, name))
10176 struct dwarf_section * sec = &debug_displays [i].section;
10177 int secondary = (section != find_section (name));
10180 free_debug_section ((enum dwarf_section_display_enum) i);
10182 if (streq (sec->uncompressed_name, name))
10183 sec->name = sec->uncompressed_name;
10185 sec->name = sec->compressed_name;
10186 if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
10189 result &= debug_displays[i].display (sec, file);
10191 if (secondary || (i != info && i != abbrev))
10192 free_debug_section ((enum dwarf_section_display_enum) i);
10200 printf (_("Unrecognized debug section: %s\n"), name);
10207 /* Set DUMP_SECTS for all sections where dumps were requested
10208 based on section name. */
10211 initialise_dumps_byname (void)
10213 struct dump_list_entry * cur;
10215 for (cur = dump_sects_byname; cur; cur = cur->next)
10220 for (i = 0, any = 0; i < elf_header.e_shnum; i++)
10221 if (streq (SECTION_NAME (section_headers + i), cur->name))
10223 request_dump_bynumber (i, cur->type);
10228 warn (_("Section '%s' was not dumped because it does not exist!\n"),
10234 process_section_contents (FILE * file)
10236 Elf_Internal_Shdr * section;
10242 initialise_dumps_byname ();
10244 for (i = 0, section = section_headers;
10245 i < elf_header.e_shnum && i < num_dump_sects;
10248 #ifdef SUPPORT_DISASSEMBLY
10249 if (dump_sects[i] & DISASS_DUMP)
10250 disassemble_section (section, file);
10252 if (dump_sects[i] & HEX_DUMP)
10253 dump_section_as_bytes (section, file, FALSE);
10255 if (dump_sects[i] & RELOC_DUMP)
10256 dump_section_as_bytes (section, file, TRUE);
10258 if (dump_sects[i] & STRING_DUMP)
10259 dump_section_as_strings (section, file);
10261 if (dump_sects[i] & DEBUG_DUMP)
10262 display_debug_section (section, file);
10265 /* Check to see if the user requested a
10266 dump of a section that does not exist. */
10267 while (i++ < num_dump_sects)
10269 warn (_("Section %d was not dumped because it does not exist!\n"), i);
10273 process_mips_fpe_exception (int mask)
10278 if (mask & OEX_FPU_INEX)
10279 fputs ("INEX", stdout), first = 0;
10280 if (mask & OEX_FPU_UFLO)
10281 printf ("%sUFLO", first ? "" : "|"), first = 0;
10282 if (mask & OEX_FPU_OFLO)
10283 printf ("%sOFLO", first ? "" : "|"), first = 0;
10284 if (mask & OEX_FPU_DIV0)
10285 printf ("%sDIV0", first ? "" : "|"), first = 0;
10286 if (mask & OEX_FPU_INVAL)
10287 printf ("%sINVAL", first ? "" : "|");
10290 fputs ("0", stdout);
10293 /* ARM EABI attributes section. */
10298 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
10300 const char ** table;
10301 } arm_attr_public_tag;
10303 static const char * arm_attr_tag_CPU_arch[] =
10304 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
10305 "v6K", "v7", "v6-M", "v6S-M", "v7E-M"};
10306 static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
10307 static const char * arm_attr_tag_THUMB_ISA_use[] =
10308 {"No", "Thumb-1", "Thumb-2"};
10309 static const char * arm_attr_tag_FP_arch[] =
10310 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16"};
10311 static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
10312 static const char * arm_attr_tag_Advanced_SIMD_arch[] =
10313 {"No", "NEONv1", "NEONv1 with Fused-MAC"};
10314 static const char * arm_attr_tag_PCS_config[] =
10315 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
10316 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
10317 static const char * arm_attr_tag_ABI_PCS_R9_use[] =
10318 {"V6", "SB", "TLS", "Unused"};
10319 static const char * arm_attr_tag_ABI_PCS_RW_data[] =
10320 {"Absolute", "PC-relative", "SB-relative", "None"};
10321 static const char * arm_attr_tag_ABI_PCS_RO_data[] =
10322 {"Absolute", "PC-relative", "None"};
10323 static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
10324 {"None", "direct", "GOT-indirect"};
10325 static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
10326 {"None", "??? 1", "2", "??? 3", "4"};
10327 static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
10328 static const char * arm_attr_tag_ABI_FP_denormal[] =
10329 {"Unused", "Needed", "Sign only"};
10330 static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
10331 static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
10332 static const char * arm_attr_tag_ABI_FP_number_model[] =
10333 {"Unused", "Finite", "RTABI", "IEEE 754"};
10334 static const char * arm_attr_tag_ABI_enum_size[] =
10335 {"Unused", "small", "int", "forced to int"};
10336 static const char * arm_attr_tag_ABI_HardFP_use[] =
10337 {"As Tag_FP_arch", "SP only", "DP only", "SP and DP"};
10338 static const char * arm_attr_tag_ABI_VFP_args[] =
10339 {"AAPCS", "VFP registers", "custom"};
10340 static const char * arm_attr_tag_ABI_WMMX_args[] =
10341 {"AAPCS", "WMMX registers", "custom"};
10342 static const char * arm_attr_tag_ABI_optimization_goals[] =
10343 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
10344 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
10345 static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
10346 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
10347 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
10348 static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
10349 static const char * arm_attr_tag_FP_HP_extension[] =
10350 {"Not Allowed", "Allowed"};
10351 static const char * arm_attr_tag_ABI_FP_16bit_format[] =
10352 {"None", "IEEE 754", "Alternative Format"};
10353 static const char * arm_attr_tag_MPextension_use[] =
10354 {"Not Allowed", "Allowed"};
10355 static const char * arm_attr_tag_DIV_use[] =
10356 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
10357 "Allowed in v7-A with integer division extension"};
10358 static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
10359 static const char * arm_attr_tag_Virtualization_use[] =
10360 {"Not Allowed", "TrustZone", "Virtualization Extensions",
10361 "TrustZone and Virtualization Extensions"};
10362 static const char * arm_attr_tag_MPextension_use_legacy[] =
10363 {"Not Allowed", "Allowed"};
10365 #define LOOKUP(id, name) \
10366 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
10367 static arm_attr_public_tag arm_attr_public_tags[] =
10369 {4, "CPU_raw_name", 1, NULL},
10370 {5, "CPU_name", 1, NULL},
10371 LOOKUP(6, CPU_arch),
10372 {7, "CPU_arch_profile", 0, NULL},
10373 LOOKUP(8, ARM_ISA_use),
10374 LOOKUP(9, THUMB_ISA_use),
10375 LOOKUP(10, FP_arch),
10376 LOOKUP(11, WMMX_arch),
10377 LOOKUP(12, Advanced_SIMD_arch),
10378 LOOKUP(13, PCS_config),
10379 LOOKUP(14, ABI_PCS_R9_use),
10380 LOOKUP(15, ABI_PCS_RW_data),
10381 LOOKUP(16, ABI_PCS_RO_data),
10382 LOOKUP(17, ABI_PCS_GOT_use),
10383 LOOKUP(18, ABI_PCS_wchar_t),
10384 LOOKUP(19, ABI_FP_rounding),
10385 LOOKUP(20, ABI_FP_denormal),
10386 LOOKUP(21, ABI_FP_exceptions),
10387 LOOKUP(22, ABI_FP_user_exceptions),
10388 LOOKUP(23, ABI_FP_number_model),
10389 {24, "ABI_align_needed", 0, NULL},
10390 {25, "ABI_align_preserved", 0, NULL},
10391 LOOKUP(26, ABI_enum_size),
10392 LOOKUP(27, ABI_HardFP_use),
10393 LOOKUP(28, ABI_VFP_args),
10394 LOOKUP(29, ABI_WMMX_args),
10395 LOOKUP(30, ABI_optimization_goals),
10396 LOOKUP(31, ABI_FP_optimization_goals),
10397 {32, "compatibility", 0, NULL},
10398 LOOKUP(34, CPU_unaligned_access),
10399 LOOKUP(36, FP_HP_extension),
10400 LOOKUP(38, ABI_FP_16bit_format),
10401 LOOKUP(42, MPextension_use),
10402 LOOKUP(44, DIV_use),
10403 {64, "nodefaults", 0, NULL},
10404 {65, "also_compatible_with", 0, NULL},
10405 LOOKUP(66, T2EE_use),
10406 {67, "conformance", 1, NULL},
10407 LOOKUP(68, Virtualization_use),
10408 LOOKUP(70, MPextension_use_legacy)
10412 static unsigned char *
10413 display_arm_attribute (unsigned char * p)
10418 arm_attr_public_tag * attr;
10422 tag = read_uleb128 (p, &len);
10425 for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
10427 if (arm_attr_public_tags[i].tag == tag)
10429 attr = &arm_attr_public_tags[i];
10436 printf (" Tag_%s: ", attr->name);
10437 switch (attr->type)
10442 case 7: /* Tag_CPU_arch_profile. */
10443 val = read_uleb128 (p, &len);
10447 case 0: printf (_("None\n")); break;
10448 case 'A': printf (_("Application\n")); break;
10449 case 'R': printf (_("Realtime\n")); break;
10450 case 'M': printf (_("Microcontroller\n")); break;
10451 case 'S': printf (_("Application or Realtime\n")); break;
10452 default: printf ("??? (%d)\n", val); break;
10456 case 24: /* Tag_align_needed. */
10457 val = read_uleb128 (p, &len);
10461 case 0: printf (_("None\n")); break;
10462 case 1: printf (_("8-byte\n")); break;
10463 case 2: printf (_("4-byte\n")); break;
10464 case 3: printf ("??? 3\n"); break;
10467 printf (_("8-byte and up to %d-byte extended\n"),
10470 printf ("??? (%d)\n", val);
10475 case 25: /* Tag_align_preserved. */
10476 val = read_uleb128 (p, &len);
10480 case 0: printf (_("None\n")); break;
10481 case 1: printf (_("8-byte, except leaf SP\n")); break;
10482 case 2: printf (_("8-byte\n")); break;
10483 case 3: printf ("??? 3\n"); break;
10486 printf (_("8-byte and up to %d-byte extended\n"),
10489 printf ("??? (%d)\n", val);
10494 case 32: /* Tag_compatibility. */
10495 val = read_uleb128 (p, &len);
10497 printf (_("flag = %d, vendor = %s\n"), val, p);
10498 p += strlen ((char *) p) + 1;
10501 case 64: /* Tag_nodefaults. */
10503 printf (_("True\n"));
10506 case 65: /* Tag_also_compatible_with. */
10507 val = read_uleb128 (p, &len);
10509 if (val == 6 /* Tag_CPU_arch. */)
10511 val = read_uleb128 (p, &len);
10513 if ((unsigned int)val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
10514 printf ("??? (%d)\n", val);
10516 printf ("%s\n", arm_attr_tag_CPU_arch[val]);
10520 while (*(p++) != '\0' /* NUL terminator. */);
10534 assert (attr->type & 0x80);
10535 val = read_uleb128 (p, &len);
10537 type = attr->type & 0x7f;
10539 printf ("??? (%d)\n", val);
10541 printf ("%s\n", attr->table[val]);
10548 type = 1; /* String. */
10550 type = 2; /* uleb128. */
10551 printf (" Tag_unknown_%d: ", tag);
10556 printf ("\"%s\"\n", p);
10557 p += strlen ((char *) p) + 1;
10561 val = read_uleb128 (p, &len);
10563 printf ("%d (0x%x)\n", val, val);
10569 static unsigned char *
10570 display_gnu_attribute (unsigned char * p,
10571 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int))
10578 tag = read_uleb128 (p, &len);
10581 /* Tag_compatibility is the only generic GNU attribute defined at
10585 val = read_uleb128 (p, &len);
10587 printf (_("flag = %d, vendor = %s\n"), val, p);
10588 p += strlen ((char *) p) + 1;
10592 if ((tag & 2) == 0 && display_proc_gnu_attribute)
10593 return display_proc_gnu_attribute (p, tag);
10596 type = 1; /* String. */
10598 type = 2; /* uleb128. */
10599 printf (" Tag_unknown_%d: ", tag);
10603 printf ("\"%s\"\n", p);
10604 p += strlen ((char *) p) + 1;
10608 val = read_uleb128 (p, &len);
10610 printf ("%d (0x%x)\n", val, val);
10616 static unsigned char *
10617 display_power_gnu_attribute (unsigned char * p, int tag)
10623 if (tag == Tag_GNU_Power_ABI_FP)
10625 val = read_uleb128 (p, &len);
10627 printf (" Tag_GNU_Power_ABI_FP: ");
10632 printf (_("Hard or soft float\n"));
10635 printf (_("Hard float\n"));
10638 printf (_("Soft float\n"));
10641 printf (_("Single-precision hard float\n"));
10644 printf ("??? (%d)\n", val);
10650 if (tag == Tag_GNU_Power_ABI_Vector)
10652 val = read_uleb128 (p, &len);
10654 printf (" Tag_GNU_Power_ABI_Vector: ");
10658 printf (_("Any\n"));
10661 printf (_("Generic\n"));
10664 printf ("AltiVec\n");
10670 printf ("??? (%d)\n", val);
10676 if (tag == Tag_GNU_Power_ABI_Struct_Return)
10678 val = read_uleb128 (p, &len);
10680 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
10684 printf (_("Any\n"));
10687 printf ("r3/r4\n");
10690 printf (_("Memory\n"));
10693 printf ("??? (%d)\n", val);
10700 type = 1; /* String. */
10702 type = 2; /* uleb128. */
10703 printf (" Tag_unknown_%d: ", tag);
10707 printf ("\"%s\"\n", p);
10708 p += strlen ((char *) p) + 1;
10712 val = read_uleb128 (p, &len);
10714 printf ("%d (0x%x)\n", val, val);
10720 static unsigned char *
10721 display_mips_gnu_attribute (unsigned char * p, int tag)
10727 if (tag == Tag_GNU_MIPS_ABI_FP)
10729 val = read_uleb128 (p, &len);
10731 printf (" Tag_GNU_MIPS_ABI_FP: ");
10736 printf (_("Hard or soft float\n"));
10739 printf (_("Hard float (double precision)\n"));
10742 printf (_("Hard float (single precision)\n"));
10745 printf (_("Soft float\n"));
10748 printf (_("Hard float (MIPS32r2 64-bit FPU)\n"));
10751 printf ("??? (%d)\n", val);
10758 type = 1; /* String. */
10760 type = 2; /* uleb128. */
10761 printf (" Tag_unknown_%d: ", tag);
10765 printf ("\"%s\"\n", p);
10766 p += strlen ((char *) p) + 1;
10770 val = read_uleb128 (p, &len);
10772 printf ("%d (0x%x)\n", val, val);
10778 static unsigned char *
10779 display_tic6x_attribute (unsigned char * p)
10785 tag = read_uleb128 (p, &len);
10791 val = read_uleb128 (p, &len);
10793 printf (" Tag_ISA: ");
10797 case C6XABI_Tag_ISA_none:
10798 printf (_("None\n"));
10800 case C6XABI_Tag_ISA_C62X:
10803 case C6XABI_Tag_ISA_C67X:
10806 case C6XABI_Tag_ISA_C67XP:
10807 printf ("C67x+\n");
10809 case C6XABI_Tag_ISA_C64X:
10812 case C6XABI_Tag_ISA_C64XP:
10813 printf ("C64x+\n");
10815 case C6XABI_Tag_ISA_C674X:
10816 printf ("C674x\n");
10819 printf ("??? (%d)\n", val);
10824 case Tag_ABI_wchar_t:
10825 val = read_uleb128 (p, &len);
10827 printf (" Tag_ABI_wchar_t: ");
10831 printf (_("Not used\n"));
10834 printf (_("2 bytes\n"));
10837 printf (_("4 bytes\n"));
10840 printf ("??? (%d)\n", val);
10845 case Tag_ABI_stack_align_needed:
10846 val = read_uleb128 (p, &len);
10848 printf (" Tag_ABI_stack_align_needed: ");
10852 printf (_("8-byte\n"));
10855 printf (_("16-byte\n"));
10858 printf ("??? (%d)\n", val);
10863 case Tag_ABI_stack_align_preserved:
10864 val = read_uleb128 (p, &len);
10866 printf (" Tag_ABI_stack_align_preserved: ");
10870 printf (_("8-byte\n"));
10873 printf (_("16-byte\n"));
10876 printf ("??? (%d)\n", val);
10882 val = read_uleb128 (p, &len);
10884 printf (" Tag_ABI_DSBT: ");
10888 printf (_("DSBT addressing not used\n"));
10891 printf (_("DSBT addressing used\n"));
10894 printf ("??? (%d)\n", val);
10900 val = read_uleb128 (p, &len);
10902 printf (" Tag_ABI_PID: ");
10906 printf (_("Data addressing position-dependent\n"));
10909 printf (_("Data addressing position-independent, GOT near DP\n"));
10912 printf (_("Data addressing position-independent, GOT far from DP\n"));
10915 printf ("??? (%d)\n", val);
10921 val = read_uleb128 (p, &len);
10923 printf (" Tag_ABI_PIC: ");
10927 printf (_("Code addressing position-dependent\n"));
10930 printf (_("Code addressing position-independent\n"));
10933 printf ("??? (%d)\n", val);
10938 case Tag_ABI_array_object_alignment:
10939 val = read_uleb128 (p, &len);
10941 printf (" Tag_ABI_array_object_alignment: ");
10945 printf (_("8-byte\n"));
10948 printf (_("4-byte\n"));
10951 printf (_("16-byte\n"));
10954 printf ("??? (%d)\n", val);
10959 case Tag_ABI_array_object_align_expected:
10960 val = read_uleb128 (p, &len);
10962 printf (" Tag_ABI_array_object_align_expected: ");
10966 printf (_("8-byte\n"));
10969 printf (_("4-byte\n"));
10972 printf (_("16-byte\n"));
10975 printf ("??? (%d)\n", val);
10980 case Tag_ABI_compatibility:
10981 val = read_uleb128 (p, &len);
10983 printf (" Tag_ABI_compatibility: ");
10984 printf (_("flag = %d, vendor = %s\n"), val, p);
10985 p += strlen ((char *) p) + 1;
10988 case Tag_ABI_conformance:
10989 printf (" Tag_ABI_conformance: ");
10990 printf ("\"%s\"\n", p);
10991 p += strlen ((char *) p) + 1;
10995 printf (" Tag_unknown_%d: ", tag);
10999 printf ("\"%s\"\n", p);
11000 p += strlen ((char *) p) + 1;
11004 val = read_uleb128 (p, &len);
11006 printf ("%d (0x%x)\n", val, val);
11013 process_attributes (FILE * file,
11014 const char * public_name,
11015 unsigned int proc_type,
11016 unsigned char * (* display_pub_attribute) (unsigned char *),
11017 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int))
11019 Elf_Internal_Shdr * sect;
11020 unsigned char * contents;
11022 unsigned char * end;
11023 bfd_vma section_len;
11027 /* Find the section header so that we get the size. */
11028 for (i = 0, sect = section_headers;
11029 i < elf_header.e_shnum;
11032 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
11035 contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
11036 sect->sh_size, _("attributes"));
11037 if (contents == NULL)
11043 len = sect->sh_size - 1;
11049 bfd_boolean public_section;
11050 bfd_boolean gnu_section;
11052 section_len = byte_get (p, 4);
11055 if (section_len > len)
11057 printf (_("ERROR: Bad section length (%d > %d)\n"),
11058 (int) section_len, (int) len);
11062 len -= section_len;
11063 printf (_("Attribute Section: %s\n"), p);
11065 if (public_name && streq ((char *) p, public_name))
11066 public_section = TRUE;
11068 public_section = FALSE;
11070 if (streq ((char *) p, "gnu"))
11071 gnu_section = TRUE;
11073 gnu_section = FALSE;
11075 namelen = strlen ((char *) p) + 1;
11077 section_len -= namelen + 4;
11079 while (section_len > 0)
11085 size = byte_get (p, 4);
11086 if (size > section_len)
11088 printf (_("ERROR: Bad subsection length (%d > %d)\n"),
11089 (int) size, (int) section_len);
11090 size = section_len;
11093 section_len -= size;
11094 end = p + size - 1;
11100 printf (_("File Attributes\n"));
11103 printf (_("Section Attributes:"));
11106 printf (_("Symbol Attributes:"));
11112 val = read_uleb128 (p, &j);
11116 printf (" %d", val);
11121 printf (_("Unknown tag: %d\n"), tag);
11122 public_section = FALSE;
11126 if (public_section)
11129 p = display_pub_attribute (p);
11131 else if (gnu_section)
11134 p = display_gnu_attribute (p,
11135 display_proc_gnu_attribute);
11139 /* ??? Do something sensible, like dump hex. */
11140 printf (_(" Unknown section contexts\n"));
11147 printf (_("Unknown format '%c'\n"), *p);
11155 process_arm_specific (FILE * file)
11157 return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
11158 display_arm_attribute, NULL);
11162 process_power_specific (FILE * file)
11164 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
11165 display_power_gnu_attribute);
11169 process_tic6x_specific (FILE * file)
11171 return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
11172 display_tic6x_attribute, NULL);
11175 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
11176 Print the Address, Access and Initial fields of an entry at VMA ADDR
11177 and return the VMA of the next entry. */
11180 print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
11183 print_vma (addr, LONG_HEX);
11185 if (addr < pltgot + 0xfff0)
11186 printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
11188 printf ("%10s", "");
11191 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
11196 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
11197 print_vma (entry, LONG_HEX);
11199 return addr + (is_32bit_elf ? 4 : 8);
11202 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
11203 PLTGOT. Print the Address and Initial fields of an entry at VMA
11204 ADDR and return the VMA of the next entry. */
11207 print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
11210 print_vma (addr, LONG_HEX);
11213 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
11218 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
11219 print_vma (entry, LONG_HEX);
11221 return addr + (is_32bit_elf ? 4 : 8);
11225 process_mips_specific (FILE * file)
11227 Elf_Internal_Dyn * entry;
11228 size_t liblist_offset = 0;
11229 size_t liblistno = 0;
11230 size_t conflictsno = 0;
11231 size_t options_offset = 0;
11232 size_t conflicts_offset = 0;
11233 size_t pltrelsz = 0;
11235 bfd_vma pltgot = 0;
11236 bfd_vma mips_pltgot = 0;
11237 bfd_vma jmprel = 0;
11238 bfd_vma local_gotno = 0;
11239 bfd_vma gotsym = 0;
11240 bfd_vma symtabno = 0;
11242 process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
11243 display_mips_gnu_attribute);
11245 /* We have a lot of special sections. Thanks SGI! */
11246 if (dynamic_section == NULL)
11247 /* No information available. */
11250 for (entry = dynamic_section; entry->d_tag != DT_NULL; ++entry)
11251 switch (entry->d_tag)
11253 case DT_MIPS_LIBLIST:
11255 = offset_from_vma (file, entry->d_un.d_val,
11256 liblistno * sizeof (Elf32_External_Lib));
11258 case DT_MIPS_LIBLISTNO:
11259 liblistno = entry->d_un.d_val;
11261 case DT_MIPS_OPTIONS:
11262 options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
11264 case DT_MIPS_CONFLICT:
11266 = offset_from_vma (file, entry->d_un.d_val,
11267 conflictsno * sizeof (Elf32_External_Conflict));
11269 case DT_MIPS_CONFLICTNO:
11270 conflictsno = entry->d_un.d_val;
11273 pltgot = entry->d_un.d_ptr;
11275 case DT_MIPS_LOCAL_GOTNO:
11276 local_gotno = entry->d_un.d_val;
11278 case DT_MIPS_GOTSYM:
11279 gotsym = entry->d_un.d_val;
11281 case DT_MIPS_SYMTABNO:
11282 symtabno = entry->d_un.d_val;
11284 case DT_MIPS_PLTGOT:
11285 mips_pltgot = entry->d_un.d_ptr;
11288 pltrel = entry->d_un.d_val;
11291 pltrelsz = entry->d_un.d_val;
11294 jmprel = entry->d_un.d_ptr;
11300 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
11302 Elf32_External_Lib * elib;
11305 elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
11307 sizeof (Elf32_External_Lib),
11311 printf (_("\nSection '.liblist' contains %lu entries:\n"),
11312 (unsigned long) liblistno);
11313 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
11316 for (cnt = 0; cnt < liblistno; ++cnt)
11323 liblist.l_name = BYTE_GET (elib[cnt].l_name);
11324 atime = BYTE_GET (elib[cnt].l_time_stamp);
11325 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
11326 liblist.l_version = BYTE_GET (elib[cnt].l_version);
11327 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
11329 tmp = gmtime (&atime);
11330 snprintf (timebuf, sizeof (timebuf),
11331 "%04u-%02u-%02uT%02u:%02u:%02u",
11332 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
11333 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
11335 printf ("%3lu: ", (unsigned long) cnt);
11336 if (VALID_DYNAMIC_NAME (liblist.l_name))
11337 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
11339 printf (_("<corrupt: %9ld>"), liblist.l_name);
11340 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
11341 liblist.l_version);
11343 if (liblist.l_flags == 0)
11347 static const struct
11354 { " EXACT_MATCH", LL_EXACT_MATCH },
11355 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
11356 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
11357 { " EXPORTS", LL_EXPORTS },
11358 { " DELAY_LOAD", LL_DELAY_LOAD },
11359 { " DELTA", LL_DELTA }
11361 int flags = liblist.l_flags;
11364 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
11365 if ((flags & l_flags_vals[fcnt].bit) != 0)
11367 fputs (l_flags_vals[fcnt].name, stdout);
11368 flags ^= l_flags_vals[fcnt].bit;
11371 printf (" %#x", (unsigned int) flags);
11381 if (options_offset != 0)
11383 Elf_External_Options * eopt;
11384 Elf_Internal_Shdr * sect = section_headers;
11385 Elf_Internal_Options * iopt;
11386 Elf_Internal_Options * option;
11390 /* Find the section header so that we get the size. */
11391 while (sect->sh_type != SHT_MIPS_OPTIONS)
11394 eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
11395 sect->sh_size, _("options"));
11398 iopt = (Elf_Internal_Options *)
11399 cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
11402 error (_("Out of memory\n"));
11409 while (offset < sect->sh_size)
11411 Elf_External_Options * eoption;
11413 eoption = (Elf_External_Options *) ((char *) eopt + offset);
11415 option->kind = BYTE_GET (eoption->kind);
11416 option->size = BYTE_GET (eoption->size);
11417 option->section = BYTE_GET (eoption->section);
11418 option->info = BYTE_GET (eoption->info);
11420 offset += option->size;
11426 printf (_("\nSection '%s' contains %d entries:\n"),
11427 SECTION_NAME (sect), cnt);
11435 switch (option->kind)
11438 /* This shouldn't happen. */
11439 printf (" NULL %d %lx", option->section, option->info);
11442 printf (" REGINFO ");
11443 if (elf_header.e_machine == EM_MIPS)
11446 Elf32_External_RegInfo * ereg;
11447 Elf32_RegInfo reginfo;
11449 ereg = (Elf32_External_RegInfo *) (option + 1);
11450 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
11451 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
11452 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
11453 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
11454 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
11455 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
11457 printf ("GPR %08lx GP 0x%lx\n",
11458 reginfo.ri_gprmask,
11459 (unsigned long) reginfo.ri_gp_value);
11460 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
11461 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
11462 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
11467 Elf64_External_RegInfo * ereg;
11468 Elf64_Internal_RegInfo reginfo;
11470 ereg = (Elf64_External_RegInfo *) (option + 1);
11471 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
11472 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
11473 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
11474 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
11475 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
11476 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
11478 printf ("GPR %08lx GP 0x",
11479 reginfo.ri_gprmask);
11480 printf_vma (reginfo.ri_gp_value);
11483 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
11484 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
11485 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
11489 case ODK_EXCEPTIONS:
11490 fputs (" EXCEPTIONS fpe_min(", stdout);
11491 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
11492 fputs (") fpe_max(", stdout);
11493 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
11494 fputs (")", stdout);
11496 if (option->info & OEX_PAGE0)
11497 fputs (" PAGE0", stdout);
11498 if (option->info & OEX_SMM)
11499 fputs (" SMM", stdout);
11500 if (option->info & OEX_FPDBUG)
11501 fputs (" FPDBUG", stdout);
11502 if (option->info & OEX_DISMISS)
11503 fputs (" DISMISS", stdout);
11506 fputs (" PAD ", stdout);
11507 if (option->info & OPAD_PREFIX)
11508 fputs (" PREFIX", stdout);
11509 if (option->info & OPAD_POSTFIX)
11510 fputs (" POSTFIX", stdout);
11511 if (option->info & OPAD_SYMBOL)
11512 fputs (" SYMBOL", stdout);
11515 fputs (" HWPATCH ", stdout);
11516 if (option->info & OHW_R4KEOP)
11517 fputs (" R4KEOP", stdout);
11518 if (option->info & OHW_R8KPFETCH)
11519 fputs (" R8KPFETCH", stdout);
11520 if (option->info & OHW_R5KEOP)
11521 fputs (" R5KEOP", stdout);
11522 if (option->info & OHW_R5KCVTL)
11523 fputs (" R5KCVTL", stdout);
11526 fputs (" FILL ", stdout);
11527 /* XXX Print content of info word? */
11530 fputs (" TAGS ", stdout);
11531 /* XXX Print content of info word? */
11534 fputs (" HWAND ", stdout);
11535 if (option->info & OHWA0_R4KEOP_CHECKED)
11536 fputs (" R4KEOP_CHECKED", stdout);
11537 if (option->info & OHWA0_R4KEOP_CLEAN)
11538 fputs (" R4KEOP_CLEAN", stdout);
11541 fputs (" HWOR ", stdout);
11542 if (option->info & OHWA0_R4KEOP_CHECKED)
11543 fputs (" R4KEOP_CHECKED", stdout);
11544 if (option->info & OHWA0_R4KEOP_CLEAN)
11545 fputs (" R4KEOP_CLEAN", stdout);
11548 printf (" GP_GROUP %#06lx self-contained %#06lx",
11549 option->info & OGP_GROUP,
11550 (option->info & OGP_SELF) >> 16);
11553 printf (" IDENT %#06lx self-contained %#06lx",
11554 option->info & OGP_GROUP,
11555 (option->info & OGP_SELF) >> 16);
11558 /* This shouldn't happen. */
11559 printf (" %3d ??? %d %lx",
11560 option->kind, option->section, option->info);
11564 len = sizeof (* eopt);
11565 while (len < option->size)
11566 if (((char *) option)[len] >= ' '
11567 && ((char *) option)[len] < 0x7f)
11568 printf ("%c", ((char *) option)[len++]);
11570 printf ("\\%03o", ((char *) option)[len++]);
11572 fputs ("\n", stdout);
11580 if (conflicts_offset != 0 && conflictsno != 0)
11582 Elf32_Conflict * iconf;
11585 if (dynamic_symbols == NULL)
11587 error (_("conflict list found without a dynamic symbol table\n"));
11591 iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
11594 error (_("Out of memory\n"));
11600 Elf32_External_Conflict * econf32;
11602 econf32 = (Elf32_External_Conflict *)
11603 get_data (NULL, file, conflicts_offset, conflictsno,
11604 sizeof (* econf32), _("conflict"));
11608 for (cnt = 0; cnt < conflictsno; ++cnt)
11609 iconf[cnt] = BYTE_GET (econf32[cnt]);
11615 Elf64_External_Conflict * econf64;
11617 econf64 = (Elf64_External_Conflict *)
11618 get_data (NULL, file, conflicts_offset, conflictsno,
11619 sizeof (* econf64), _("conflict"));
11623 for (cnt = 0; cnt < conflictsno; ++cnt)
11624 iconf[cnt] = BYTE_GET (econf64[cnt]);
11629 printf (_("\nSection '.conflict' contains %lu entries:\n"),
11630 (unsigned long) conflictsno);
11631 puts (_(" Num: Index Value Name"));
11633 for (cnt = 0; cnt < conflictsno; ++cnt)
11635 Elf_Internal_Sym * psym = & dynamic_symbols[iconf[cnt]];
11637 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
11638 print_vma (psym->st_value, FULL_HEX);
11640 if (VALID_DYNAMIC_NAME (psym->st_name))
11641 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
11643 printf (_("<corrupt: %14ld>"), psym->st_name);
11650 if (pltgot != 0 && local_gotno != 0)
11652 bfd_vma ent, local_end, global_end;
11654 unsigned char * data;
11658 addr_size = (is_32bit_elf ? 4 : 8);
11659 local_end = pltgot + local_gotno * addr_size;
11660 global_end = local_end + (symtabno - gotsym) * addr_size;
11662 offset = offset_from_vma (file, pltgot, global_end - pltgot);
11663 data = (unsigned char *) get_data (NULL, file, offset,
11664 global_end - pltgot, 1, _("GOT"));
11665 printf (_("\nPrimary GOT:\n"));
11666 printf (_(" Canonical gp value: "));
11667 print_vma (pltgot + 0x7ff0, LONG_HEX);
11670 printf (_(" Reserved entries:\n"));
11671 printf (_(" %*s %10s %*s Purpose\n"),
11672 addr_size * 2, _("Address"), _("Access"),
11673 addr_size * 2, _("Initial"));
11674 ent = print_mips_got_entry (data, pltgot, ent);
11675 printf (_(" Lazy resolver\n"));
11677 && (byte_get (data + ent - pltgot, addr_size)
11678 >> (addr_size * 8 - 1)) != 0)
11680 ent = print_mips_got_entry (data, pltgot, ent);
11681 printf (_(" Module pointer (GNU extension)\n"));
11685 if (ent < local_end)
11687 printf (_(" Local entries:\n"));
11688 printf (" %*s %10s %*s\n",
11689 addr_size * 2, _("Address"), _("Access"),
11690 addr_size * 2, _("Initial"));
11691 while (ent < local_end)
11693 ent = print_mips_got_entry (data, pltgot, ent);
11699 if (gotsym < symtabno)
11703 printf (_(" Global entries:\n"));
11704 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
11705 addr_size * 2, _("Address"), _("Access"),
11706 addr_size * 2, _("Initial"),
11707 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
11708 sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
11709 for (i = gotsym; i < symtabno; i++)
11711 Elf_Internal_Sym * psym;
11713 psym = dynamic_symbols + i;
11714 ent = print_mips_got_entry (data, pltgot, ent);
11716 print_vma (psym->st_value, LONG_HEX);
11717 printf (" %-7s %3s ",
11718 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
11719 get_symbol_index_type (psym->st_shndx));
11720 if (VALID_DYNAMIC_NAME (psym->st_name))
11721 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
11723 printf (_("<corrupt: %14ld>"), psym->st_name);
11733 if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
11736 size_t offset, rel_offset;
11737 unsigned long count, i;
11738 unsigned char * data;
11739 int addr_size, sym_width;
11740 Elf_Internal_Rela * rels;
11742 rel_offset = offset_from_vma (file, jmprel, pltrelsz);
11743 if (pltrel == DT_RELA)
11745 if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
11750 if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
11755 addr_size = (is_32bit_elf ? 4 : 8);
11756 end = mips_pltgot + (2 + count) * addr_size;
11758 offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
11759 data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
11761 printf (_("\nPLT GOT:\n\n"));
11762 printf (_(" Reserved entries:\n"));
11763 printf (_(" %*s %*s Purpose\n"),
11764 addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
11765 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
11766 printf (_(" PLT lazy resolver\n"));
11767 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
11768 printf (_(" Module pointer\n"));
11771 printf (_(" Entries:\n"));
11772 printf (" %*s %*s %*s %-7s %3s %s\n",
11773 addr_size * 2, _("Address"),
11774 addr_size * 2, _("Initial"),
11775 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
11776 sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
11777 for (i = 0; i < count; i++)
11779 Elf_Internal_Sym * psym;
11781 psym = dynamic_symbols + get_reloc_symindex (rels[i].r_info);
11782 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
11784 print_vma (psym->st_value, LONG_HEX);
11785 printf (" %-7s %3s ",
11786 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
11787 get_symbol_index_type (psym->st_shndx));
11788 if (VALID_DYNAMIC_NAME (psym->st_name))
11789 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
11791 printf (_("<corrupt: %14ld>"), psym->st_name);
11805 process_gnu_liblist (FILE * file)
11807 Elf_Internal_Shdr * section;
11808 Elf_Internal_Shdr * string_sec;
11809 Elf32_External_Lib * elib;
11811 size_t strtab_size;
11818 for (i = 0, section = section_headers;
11819 i < elf_header.e_shnum;
11822 switch (section->sh_type)
11824 case SHT_GNU_LIBLIST:
11825 if (section->sh_link >= elf_header.e_shnum)
11828 elib = (Elf32_External_Lib *)
11829 get_data (NULL, file, section->sh_offset, 1, section->sh_size,
11834 string_sec = section_headers + section->sh_link;
11836 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
11837 string_sec->sh_size,
11838 _("liblist string table"));
11839 strtab_size = string_sec->sh_size;
11842 || section->sh_entsize != sizeof (Elf32_External_Lib))
11848 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
11849 SECTION_NAME (section),
11850 (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
11852 puts (_(" Library Time Stamp Checksum Version Flags"));
11854 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
11862 liblist.l_name = BYTE_GET (elib[cnt].l_name);
11863 atime = BYTE_GET (elib[cnt].l_time_stamp);
11864 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
11865 liblist.l_version = BYTE_GET (elib[cnt].l_version);
11866 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
11868 tmp = gmtime (&atime);
11869 snprintf (timebuf, sizeof (timebuf),
11870 "%04u-%02u-%02uT%02u:%02u:%02u",
11871 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
11872 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
11874 printf ("%3lu: ", (unsigned long) cnt);
11876 printf ("%-20s", liblist.l_name < strtab_size
11877 ? strtab + liblist.l_name : _("<corrupt>"));
11879 printf ("%-20.20s", liblist.l_name < strtab_size
11880 ? strtab + liblist.l_name : _("<corrupt>"));
11881 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
11882 liblist.l_version, liblist.l_flags);
11892 static const char *
11893 get_note_type (unsigned e_type)
11895 static char buff[64];
11897 if (elf_header.e_type == ET_CORE)
11901 return _("NT_AUXV (auxiliary vector)");
11903 return _("NT_PRSTATUS (prstatus structure)");
11905 return _("NT_FPREGSET (floating point registers)");
11907 return _("NT_PRPSINFO (prpsinfo structure)");
11908 case NT_TASKSTRUCT:
11909 return _("NT_TASKSTRUCT (task structure)");
11911 return _("NT_PRXFPREG (user_xfpregs structure)");
11913 return _("NT_PPC_VMX (ppc Altivec registers)");
11915 return _("NT_PPC_VSX (ppc VSX registers)");
11916 case NT_X86_XSTATE:
11917 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
11918 case NT_S390_HIGH_GPRS:
11919 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
11920 case NT_S390_TIMER:
11921 return _("NT_S390_TIMER (s390 timer register)");
11922 case NT_S390_TODCMP:
11923 return _("NT_S390_TODCMP (s390 TOD comparator register)");
11924 case NT_S390_TODPREG:
11925 return _("NT_S390_TODPREG (s390 TOD programmable register)");
11927 return _("NT_S390_CTRS (s390 control registers)");
11928 case NT_S390_PREFIX:
11929 return _("NT_S390_PREFIX (s390 prefix register)");
11931 return _("NT_PSTATUS (pstatus structure)");
11933 return _("NT_FPREGS (floating point registers)");
11935 return _("NT_PSINFO (psinfo structure)");
11937 return _("NT_LWPSTATUS (lwpstatus_t structure)");
11939 return _("NT_LWPSINFO (lwpsinfo_t structure)");
11940 case NT_WIN32PSTATUS:
11941 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
11949 return _("NT_VERSION (version)");
11951 return _("NT_ARCH (architecture)");
11956 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
11960 static const char *
11961 get_gnu_elf_note_type (unsigned e_type)
11963 static char buff[64];
11967 case NT_GNU_ABI_TAG:
11968 return _("NT_GNU_ABI_TAG (ABI version tag)");
11970 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
11971 case NT_GNU_BUILD_ID:
11972 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
11973 case NT_GNU_GOLD_VERSION:
11974 return _("NT_GNU_GOLD_VERSION (gold version)");
11979 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
11983 static const char *
11984 get_netbsd_elfcore_note_type (unsigned e_type)
11986 static char buff[64];
11988 if (e_type == NT_NETBSDCORE_PROCINFO)
11990 /* NetBSD core "procinfo" structure. */
11991 return _("NetBSD procinfo structure");
11994 /* As of Jan 2002 there are no other machine-independent notes
11995 defined for NetBSD core files. If the note type is less
11996 than the start of the machine-dependent note types, we don't
11999 if (e_type < NT_NETBSDCORE_FIRSTMACH)
12001 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
12005 switch (elf_header.e_machine)
12007 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
12008 and PT_GETFPREGS == mach+2. */
12013 case EM_SPARC32PLUS:
12017 case NT_NETBSDCORE_FIRSTMACH + 0:
12018 return _("PT_GETREGS (reg structure)");
12019 case NT_NETBSDCORE_FIRSTMACH + 2:
12020 return _("PT_GETFPREGS (fpreg structure)");
12026 /* On all other arch's, PT_GETREGS == mach+1 and
12027 PT_GETFPREGS == mach+3. */
12031 case NT_NETBSDCORE_FIRSTMACH + 1:
12032 return _("PT_GETREGS (reg structure)");
12033 case NT_NETBSDCORE_FIRSTMACH + 3:
12034 return _("PT_GETFPREGS (fpreg structure)");
12040 snprintf (buff, sizeof (buff), _("PT_FIRSTMACH+%d"),
12041 e_type - NT_NETBSDCORE_FIRSTMACH);
12045 /* Note that by the ELF standard, the name field is already null byte
12046 terminated, and namesz includes the terminating null byte.
12047 I.E. the value of namesz for the name "FSF" is 4.
12049 If the value of namesz is zero, there is no name present. */
12051 process_note (Elf_Internal_Note * pnote)
12053 const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
12056 if (pnote->namesz == 0)
12057 /* If there is no note name, then use the default set of
12058 note type strings. */
12059 nt = get_note_type (pnote->type);
12061 else if (const_strneq (pnote->namedata, "GNU"))
12062 /* GNU-specific object file notes. */
12063 nt = get_gnu_elf_note_type (pnote->type);
12065 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
12066 /* NetBSD-specific core file notes. */
12067 nt = get_netbsd_elfcore_note_type (pnote->type);
12069 else if (strneq (pnote->namedata, "SPU/", 4))
12071 /* SPU-specific core file notes. */
12072 nt = pnote->namedata + 4;
12077 /* Don't recognize this note name; just use the default set of
12078 note type strings. */
12079 nt = get_note_type (pnote->type);
12081 printf (" %s\t\t0x%08lx\t%s\n", name, pnote->descsz, nt);
12087 process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
12089 Elf_External_Note * pnotes;
12090 Elf_External_Note * external;
12096 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
12098 if (pnotes == NULL)
12103 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
12104 (unsigned long) offset, (unsigned long) length);
12105 printf (_(" Owner\t\tData size\tDescription\n"));
12107 while (external < (Elf_External_Note *) ((char *) pnotes + length))
12109 Elf_External_Note * next;
12110 Elf_Internal_Note inote;
12111 char * temp = NULL;
12113 inote.type = BYTE_GET (external->type);
12114 inote.namesz = BYTE_GET (external->namesz);
12115 inote.namedata = external->name;
12116 inote.descsz = BYTE_GET (external->descsz);
12117 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
12118 inote.descpos = offset + (inote.descdata - (char *) pnotes);
12120 next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
12122 if ( ((char *) next > ((char *) pnotes) + length)
12123 || ((char *) next < (char *) pnotes))
12125 warn (_("corrupt note found at offset %lx into core notes\n"),
12126 (unsigned long) ((char *) external - (char *) pnotes));
12127 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
12128 inote.type, inote.namesz, inote.descsz);
12134 /* Prevent out-of-bounds indexing. */
12135 if (inote.namedata + inote.namesz >= (char *) pnotes + length
12136 || inote.namedata + inote.namesz < inote.namedata)
12138 warn (_("corrupt note found at offset %lx into core notes\n"),
12139 (unsigned long) ((char *) external - (char *) pnotes));
12140 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
12141 inote.type, inote.namesz, inote.descsz);
12145 /* Verify that name is null terminated. It appears that at least
12146 one version of Linux (RedHat 6.0) generates corefiles that don't
12147 comply with the ELF spec by failing to include the null byte in
12149 if (inote.namedata[inote.namesz] != '\0')
12151 temp = (char *) malloc (inote.namesz + 1);
12155 error (_("Out of memory\n"));
12160 strncpy (temp, inote.namedata, inote.namesz);
12161 temp[inote.namesz] = 0;
12163 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
12164 inote.namedata = temp;
12167 res &= process_note (& inote);
12182 process_corefile_note_segments (FILE * file)
12184 Elf_Internal_Phdr * segment;
12188 if (! get_program_headers (file))
12191 for (i = 0, segment = program_headers;
12192 i < elf_header.e_phnum;
12195 if (segment->p_type == PT_NOTE)
12196 res &= process_corefile_note_segment (file,
12197 (bfd_vma) segment->p_offset,
12198 (bfd_vma) segment->p_filesz);
12205 process_note_sections (FILE * file)
12207 Elf_Internal_Shdr * section;
12211 for (i = 0, section = section_headers;
12212 i < elf_header.e_shnum;
12214 if (section->sh_type == SHT_NOTE)
12215 res &= process_corefile_note_segment (file,
12216 (bfd_vma) section->sh_offset,
12217 (bfd_vma) section->sh_size);
12223 process_notes (FILE * file)
12225 /* If we have not been asked to display the notes then do nothing. */
12229 if (elf_header.e_type != ET_CORE)
12230 return process_note_sections (file);
12232 /* No program headers means no NOTE segment. */
12233 if (elf_header.e_phnum > 0)
12234 return process_corefile_note_segments (file);
12236 printf (_("No note segments present in the core file.\n"));
12241 process_arch_specific (FILE * file)
12246 switch (elf_header.e_machine)
12249 return process_arm_specific (file);
12251 case EM_MIPS_RS3_LE:
12252 return process_mips_specific (file);
12255 return process_power_specific (file);
12258 return process_tic6x_specific (file);
12267 get_file_header (FILE * file)
12269 /* Read in the identity array. */
12270 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
12273 /* Determine how to read the rest of the header. */
12274 switch (elf_header.e_ident[EI_DATA])
12276 default: /* fall through */
12277 case ELFDATANONE: /* fall through */
12279 byte_get = byte_get_little_endian;
12280 byte_put = byte_put_little_endian;
12283 byte_get = byte_get_big_endian;
12284 byte_put = byte_put_big_endian;
12288 /* For now we only support 32 bit and 64 bit ELF files. */
12289 is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
12291 /* Read in the rest of the header. */
12294 Elf32_External_Ehdr ehdr32;
12296 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
12299 elf_header.e_type = BYTE_GET (ehdr32.e_type);
12300 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
12301 elf_header.e_version = BYTE_GET (ehdr32.e_version);
12302 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
12303 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
12304 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
12305 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
12306 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
12307 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
12308 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
12309 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
12310 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
12311 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
12315 Elf64_External_Ehdr ehdr64;
12317 /* If we have been compiled with sizeof (bfd_vma) == 4, then
12318 we will not be able to cope with the 64bit data found in
12319 64 ELF files. Detect this now and abort before we start
12320 overwriting things. */
12321 if (sizeof (bfd_vma) < 8)
12323 error (_("This instance of readelf has been built without support for a\n\
12324 64 bit data type and so it cannot read 64 bit ELF files.\n"));
12328 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
12331 elf_header.e_type = BYTE_GET (ehdr64.e_type);
12332 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
12333 elf_header.e_version = BYTE_GET (ehdr64.e_version);
12334 elf_header.e_entry = BYTE_GET (ehdr64.e_entry);
12335 elf_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
12336 elf_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
12337 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
12338 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
12339 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
12340 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
12341 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
12342 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
12343 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
12346 if (elf_header.e_shoff)
12348 /* There may be some extensions in the first section header. Don't
12349 bomb if we can't read it. */
12351 get_32bit_section_headers (file, 1);
12353 get_64bit_section_headers (file, 1);
12359 /* Process one ELF object file according to the command line options.
12360 This file may actually be stored in an archive. The file is
12361 positioned at the start of the ELF object. */
12364 process_object (char * file_name, FILE * file)
12368 if (! get_file_header (file))
12370 error (_("%s: Failed to read file header\n"), file_name);
12374 /* Initialise per file variables. */
12375 for (i = ARRAY_SIZE (version_info); i--;)
12376 version_info[i] = 0;
12378 for (i = ARRAY_SIZE (dynamic_info); i--;)
12379 dynamic_info[i] = 0;
12380 dynamic_info_DT_GNU_HASH = 0;
12382 /* Process the file. */
12384 printf (_("\nFile: %s\n"), file_name);
12386 /* Initialise the dump_sects array from the cmdline_dump_sects array.
12387 Note we do this even if cmdline_dump_sects is empty because we
12388 must make sure that the dump_sets array is zeroed out before each
12389 object file is processed. */
12390 if (num_dump_sects > num_cmdline_dump_sects)
12391 memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
12393 if (num_cmdline_dump_sects > 0)
12395 if (num_dump_sects == 0)
12396 /* A sneaky way of allocating the dump_sects array. */
12397 request_dump_bynumber (num_cmdline_dump_sects, 0);
12399 assert (num_dump_sects >= num_cmdline_dump_sects);
12400 memcpy (dump_sects, cmdline_dump_sects,
12401 num_cmdline_dump_sects * sizeof (* dump_sects));
12404 if (! process_file_header ())
12407 if (! process_section_headers (file))
12409 /* Without loaded section headers we cannot process lots of
12411 do_unwind = do_version = do_dump = do_arch = 0;
12413 if (! do_using_dynamic)
12414 do_syms = do_dyn_syms = do_reloc = 0;
12417 if (! process_section_groups (file))
12419 /* Without loaded section groups we cannot process unwind. */
12423 if (process_program_headers (file))
12424 process_dynamic_section (file);
12426 process_relocs (file);
12428 process_unwind (file);
12430 process_symbol_table (file);
12432 process_syminfo (file);
12434 process_version_sections (file);
12436 process_section_contents (file);
12438 process_notes (file);
12440 process_gnu_liblist (file);
12442 process_arch_specific (file);
12444 if (program_headers)
12446 free (program_headers);
12447 program_headers = NULL;
12450 if (section_headers)
12452 free (section_headers);
12453 section_headers = NULL;
12458 free (string_table);
12459 string_table = NULL;
12460 string_table_length = 0;
12463 if (dynamic_strings)
12465 free (dynamic_strings);
12466 dynamic_strings = NULL;
12467 dynamic_strings_length = 0;
12470 if (dynamic_symbols)
12472 free (dynamic_symbols);
12473 dynamic_symbols = NULL;
12474 num_dynamic_syms = 0;
12477 if (dynamic_syminfo)
12479 free (dynamic_syminfo);
12480 dynamic_syminfo = NULL;
12483 if (dynamic_section)
12485 free (dynamic_section);
12486 dynamic_section = NULL;
12489 if (section_headers_groups)
12491 free (section_headers_groups);
12492 section_headers_groups = NULL;
12495 if (section_groups)
12497 struct group_list * g;
12498 struct group_list * next;
12500 for (i = 0; i < group_count; i++)
12502 for (g = section_groups [i].root; g != NULL; g = next)
12509 free (section_groups);
12510 section_groups = NULL;
12513 free_debug_memory ();
12518 /* Process an ELF archive.
12519 On entry the file is positioned just after the ARMAG string. */
12522 process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
12524 struct archive_info arch;
12525 struct archive_info nested_arch;
12531 /* The ARCH structure is used to hold information about this archive. */
12532 arch.file_name = NULL;
12534 arch.index_array = NULL;
12535 arch.sym_table = NULL;
12536 arch.longnames = NULL;
12538 /* The NESTED_ARCH structure is used as a single-item cache of information
12539 about a nested archive (when members of a thin archive reside within
12540 another regular archive file). */
12541 nested_arch.file_name = NULL;
12542 nested_arch.file = NULL;
12543 nested_arch.index_array = NULL;
12544 nested_arch.sym_table = NULL;
12545 nested_arch.longnames = NULL;
12547 if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
12553 if (do_archive_index)
12555 if (arch.sym_table == NULL)
12556 error (_("%s: unable to dump the index as none was found\n"), file_name);
12560 unsigned long current_pos;
12562 printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
12563 file_name, arch.index_num, arch.sym_size);
12564 current_pos = ftell (file);
12566 for (i = l = 0; i < arch.index_num; i++)
12568 if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
12570 char * member_name;
12572 member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
12574 if (member_name != NULL)
12576 char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
12578 if (qualified_name != NULL)
12580 printf (_("Binary %s contains:\n"), qualified_name);
12581 free (qualified_name);
12586 if (l >= arch.sym_size)
12588 error (_("%s: end of the symbol table reached before the end of the index\n"),
12592 printf ("\t%s\n", arch.sym_table + l);
12593 l += strlen (arch.sym_table + l) + 1;
12598 if (l < arch.sym_size)
12599 error (_("%s: symbols remain in the index symbol table, but without corresponding entries in the index table\n"),
12602 if (fseek (file, current_pos, SEEK_SET) != 0)
12604 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
12610 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
12611 && !do_segments && !do_header && !do_dump && !do_version
12612 && !do_histogram && !do_debugging && !do_arch && !do_notes
12613 && !do_section_groups && !do_dyn_syms)
12615 ret = 0; /* Archive index only. */
12626 char * qualified_name;
12628 /* Read the next archive header. */
12629 if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
12631 error (_("%s: failed to seek to next archive header\n"), file_name);
12634 got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
12635 if (got != sizeof arch.arhdr)
12639 error (_("%s: failed to read archive header\n"), file_name);
12643 if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
12645 error (_("%s: did not find a valid archive header\n"), arch.file_name);
12650 arch.next_arhdr_offset += sizeof arch.arhdr;
12652 archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
12653 if (archive_file_size & 01)
12654 ++archive_file_size;
12656 name = get_archive_member_name (&arch, &nested_arch);
12659 error (_("%s: bad archive file name\n"), file_name);
12663 namelen = strlen (name);
12665 qualified_name = make_qualified_name (&arch, &nested_arch, name);
12666 if (qualified_name == NULL)
12668 error (_("%s: bad archive file name\n"), file_name);
12673 if (is_thin_archive && arch.nested_member_origin == 0)
12675 /* This is a proxy for an external member of a thin archive. */
12676 FILE * member_file;
12677 char * member_file_name = adjust_relative_path (file_name, name, namelen);
12678 if (member_file_name == NULL)
12684 member_file = fopen (member_file_name, "rb");
12685 if (member_file == NULL)
12687 error (_("Input file '%s' is not readable.\n"), member_file_name);
12688 free (member_file_name);
12693 archive_file_offset = arch.nested_member_origin;
12695 ret |= process_object (qualified_name, member_file);
12697 fclose (member_file);
12698 free (member_file_name);
12700 else if (is_thin_archive)
12702 /* This is a proxy for a member of a nested archive. */
12703 archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
12705 /* The nested archive file will have been opened and setup by
12706 get_archive_member_name. */
12707 if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
12709 error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
12714 ret |= process_object (qualified_name, nested_arch.file);
12718 archive_file_offset = arch.next_arhdr_offset;
12719 arch.next_arhdr_offset += archive_file_size;
12721 ret |= process_object (qualified_name, file);
12724 if (dump_sects != NULL)
12728 num_dump_sects = 0;
12731 free (qualified_name);
12735 if (nested_arch.file != NULL)
12736 fclose (nested_arch.file);
12737 release_archive (&nested_arch);
12738 release_archive (&arch);
12744 process_file (char * file_name)
12747 struct stat statbuf;
12748 char armag[SARMAG];
12751 if (stat (file_name, &statbuf) < 0)
12753 if (errno == ENOENT)
12754 error (_("'%s': No such file\n"), file_name);
12756 error (_("Could not locate '%s'. System error message: %s\n"),
12757 file_name, strerror (errno));
12761 if (! S_ISREG (statbuf.st_mode))
12763 error (_("'%s' is not an ordinary file\n"), file_name);
12767 file = fopen (file_name, "rb");
12770 error (_("Input file '%s' is not readable.\n"), file_name);
12774 if (fread (armag, SARMAG, 1, file) != 1)
12776 error (_("%s: Failed to read file's magic number\n"), file_name);
12781 if (memcmp (armag, ARMAG, SARMAG) == 0)
12782 ret = process_archive (file_name, file, FALSE);
12783 else if (memcmp (armag, ARMAGT, SARMAG) == 0)
12784 ret = process_archive (file_name, file, TRUE);
12787 if (do_archive_index)
12788 error (_("File %s is not an archive so its index cannot be displayed.\n"),
12792 archive_file_size = archive_file_offset = 0;
12793 ret = process_object (file_name, file);
12801 #ifdef SUPPORT_DISASSEMBLY
12802 /* Needed by the i386 disassembler. For extra credit, someone could
12803 fix this so that we insert symbolic addresses here, esp for GOT/PLT
12807 print_address (unsigned int addr, FILE * outfile)
12809 fprintf (outfile,"0x%8.8x", addr);
12812 /* Needed by the i386 disassembler. */
12814 db_task_printsym (unsigned int addr)
12816 print_address (addr, stderr);
12821 main (int argc, char ** argv)
12825 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
12826 setlocale (LC_MESSAGES, "");
12828 #if defined (HAVE_SETLOCALE)
12829 setlocale (LC_CTYPE, "");
12831 bindtextdomain (PACKAGE, LOCALEDIR);
12832 textdomain (PACKAGE);
12834 expandargv (&argc, &argv);
12836 parse_args (argc, argv);
12838 if (num_dump_sects > 0)
12840 /* Make a copy of the dump_sects array. */
12841 cmdline_dump_sects = (dump_type *)
12842 malloc (num_dump_sects * sizeof (* dump_sects));
12843 if (cmdline_dump_sects == NULL)
12844 error (_("Out of memory allocating dump request table.\n"));
12847 memcpy (cmdline_dump_sects, dump_sects,
12848 num_dump_sects * sizeof (* dump_sects));
12849 num_cmdline_dump_sects = num_dump_sects;
12853 if (optind < (argc - 1))
12857 while (optind < argc)
12858 err |= process_file (argv[optind++]);
12860 if (dump_sects != NULL)
12862 if (cmdline_dump_sects != NULL)
12863 free (cmdline_dump_sects);