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) \
289 /* Retrieve NMEMB structures, each SIZE bytes long from FILE starting at OFFSET.
290 Put the retrieved data into VAR, if it is not NULL. Otherwise allocate a buffer
291 using malloc and fill that. In either case return the pointer to the start of
292 the retrieved data or NULL if something went wrong. If something does go wrong
293 emit an error message using REASON as part of the context. */
296 get_data (void * var, FILE * file, long offset, size_t size, size_t nmemb,
301 if (size == 0 || nmemb == 0)
304 if (fseek (file, archive_file_offset + offset, SEEK_SET))
306 error (_("Unable to seek to 0x%lx for %s\n"),
307 (unsigned long) archive_file_offset + offset, reason);
314 /* Check for overflow. */
315 if (nmemb < (~(size_t) 0 - 1) / size)
316 /* + 1 so that we can '\0' terminate invalid string table sections. */
317 mvar = malloc (size * nmemb + 1);
321 error (_("Out of memory allocating 0x%lx bytes for %s\n"),
322 (unsigned long)(size * nmemb), reason);
326 ((char *) mvar)[size * nmemb] = '\0';
329 if (fread (mvar, size, nmemb, file) != nmemb)
331 error (_("Unable to read in 0x%lx bytes of %s\n"),
332 (unsigned long)(size * nmemb), reason);
341 /* Print a VMA value. */
344 print_vma (bfd_vma vma, print_mode mode)
357 return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
364 return printf ("%5" BFD_VMA_FMT "d", vma);
372 return nc + printf ("%" BFD_VMA_FMT "x", vma);
375 return printf ("%" BFD_VMA_FMT "d", vma);
378 return printf ("%" BFD_VMA_FMT "u", vma);
383 /* Display a symbol on stdout. Handles the display of non-printing characters.
385 If DO_WIDE is not true then format the symbol to be at most WIDTH characters,
386 truncating as necessary. If WIDTH is negative then format the string to be
387 exactly - WIDTH characters, truncating or padding as necessary.
389 Returns the number of emitted characters. */
392 print_symbol (int width, const char *symbol)
395 bfd_boolean extra_padding = FALSE;
396 unsigned int num_printed = 0;
400 /* Set the width to a very large value. This simplifies the
406 /* Keep the width positive. This also helps. */
408 extra_padding = TRUE;
417 /* Look for non-printing symbols inside the symbol's name.
418 This test is triggered in particular by the names generated
419 by the assembler for local labels. */
430 printf ("%.*s", len, symbol);
436 if (*c == 0 || width == 0)
439 /* Now display the non-printing character, if
440 there is room left in which to dipslay it. */
441 if ((unsigned char) *c < 32)
446 printf ("^%c", *c + 0x40);
456 printf ("<0x%.2x>", (unsigned char) *c);
465 if (extra_padding && width > 0)
467 /* Fill in the remaining spaces. */
468 printf ("%-*s", width, " ");
475 /* Return a pointer to section NAME, or NULL if no such section exists. */
477 static Elf_Internal_Shdr *
478 find_section (const char * name)
482 for (i = 0; i < elf_header.e_shnum; i++)
483 if (streq (SECTION_NAME (section_headers + i), name))
484 return section_headers + i;
489 /* Return a pointer to a section containing ADDR, or NULL if no such
492 static Elf_Internal_Shdr *
493 find_section_by_address (bfd_vma addr)
497 for (i = 0; i < elf_header.e_shnum; i++)
499 Elf_Internal_Shdr *sec = section_headers + i;
500 if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
507 /* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
511 read_uleb128 (unsigned char *data, unsigned int *length_return)
513 return read_leb128 (data, length_return, 0);
516 /* Return true if the current file is for IA-64 machine and OpenVMS ABI.
517 This OS has so many departures from the ELF standard that we test it at
523 return elf_header.e_machine == EM_IA_64
524 && elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
527 /* Guess the relocation size commonly used by the specific machines. */
530 guess_is_rela (unsigned int e_machine)
534 /* Targets that use REL relocations. */
550 /* Targets that use RELA relocations. */
554 case EM_ALTERA_NIOS2:
574 case EM_LATTICEMICO32:
582 case EM_CYGNUS_MN10200:
584 case EM_CYGNUS_MN10300:
610 case EM_MICROBLAZE_OLD:
631 warn (_("Don't know about relocations on this machine architecture\n"));
637 slurp_rela_relocs (FILE * file,
638 unsigned long rel_offset,
639 unsigned long rel_size,
640 Elf_Internal_Rela ** relasp,
641 unsigned long * nrelasp)
643 Elf_Internal_Rela * relas;
644 unsigned long nrelas;
649 Elf32_External_Rela * erelas;
651 erelas = (Elf32_External_Rela *) get_data (NULL, file, rel_offset, 1,
652 rel_size, _("relocs"));
656 nrelas = rel_size / sizeof (Elf32_External_Rela);
658 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
659 sizeof (Elf_Internal_Rela));
664 error (_("out of memory parsing relocs\n"));
668 for (i = 0; i < nrelas; i++)
670 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
671 relas[i].r_info = BYTE_GET (erelas[i].r_info);
672 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
679 Elf64_External_Rela * erelas;
681 erelas = (Elf64_External_Rela *) get_data (NULL, file, rel_offset, 1,
682 rel_size, _("relocs"));
686 nrelas = rel_size / sizeof (Elf64_External_Rela);
688 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
689 sizeof (Elf_Internal_Rela));
694 error (_("out of memory parsing relocs\n"));
698 for (i = 0; i < nrelas; i++)
700 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
701 relas[i].r_info = BYTE_GET (erelas[i].r_info);
702 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
704 /* The #ifdef BFD64 below is to prevent a compile time
705 warning. We know that if we do not have a 64 bit data
706 type that we will never execute this code anyway. */
708 if (elf_header.e_machine == EM_MIPS
709 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
711 /* In little-endian objects, r_info isn't really a
712 64-bit little-endian value: it has a 32-bit
713 little-endian symbol index followed by four
714 individual byte fields. Reorder INFO
716 bfd_vma inf = relas[i].r_info;
717 inf = (((inf & 0xffffffff) << 32)
718 | ((inf >> 56) & 0xff)
719 | ((inf >> 40) & 0xff00)
720 | ((inf >> 24) & 0xff0000)
721 | ((inf >> 8) & 0xff000000));
722 relas[i].r_info = inf;
735 slurp_rel_relocs (FILE * file,
736 unsigned long rel_offset,
737 unsigned long rel_size,
738 Elf_Internal_Rela ** relsp,
739 unsigned long * nrelsp)
741 Elf_Internal_Rela * rels;
747 Elf32_External_Rel * erels;
749 erels = (Elf32_External_Rel *) get_data (NULL, file, rel_offset, 1,
750 rel_size, _("relocs"));
754 nrels = rel_size / sizeof (Elf32_External_Rel);
756 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
761 error (_("out of memory parsing relocs\n"));
765 for (i = 0; i < nrels; i++)
767 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
768 rels[i].r_info = BYTE_GET (erels[i].r_info);
769 rels[i].r_addend = 0;
776 Elf64_External_Rel * erels;
778 erels = (Elf64_External_Rel *) get_data (NULL, file, rel_offset, 1,
779 rel_size, _("relocs"));
783 nrels = rel_size / sizeof (Elf64_External_Rel);
785 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
790 error (_("out of memory parsing relocs\n"));
794 for (i = 0; i < nrels; i++)
796 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
797 rels[i].r_info = BYTE_GET (erels[i].r_info);
798 rels[i].r_addend = 0;
800 /* The #ifdef BFD64 below is to prevent a compile time
801 warning. We know that if we do not have a 64 bit data
802 type that we will never execute this code anyway. */
804 if (elf_header.e_machine == EM_MIPS
805 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
807 /* In little-endian objects, r_info isn't really a
808 64-bit little-endian value: it has a 32-bit
809 little-endian symbol index followed by four
810 individual byte fields. Reorder INFO
812 bfd_vma inf = rels[i].r_info;
813 inf = (((inf & 0xffffffff) << 32)
814 | ((inf >> 56) & 0xff)
815 | ((inf >> 40) & 0xff00)
816 | ((inf >> 24) & 0xff0000)
817 | ((inf >> 8) & 0xff000000));
818 rels[i].r_info = inf;
830 /* Returns the reloc type extracted from the reloc info field. */
833 get_reloc_type (bfd_vma reloc_info)
836 return ELF32_R_TYPE (reloc_info);
838 switch (elf_header.e_machine)
841 /* Note: We assume that reloc_info has already been adjusted for us. */
842 return ELF64_MIPS_R_TYPE (reloc_info);
845 return ELF64_R_TYPE_ID (reloc_info);
848 return ELF64_R_TYPE (reloc_info);
852 /* Return the symbol index extracted from the reloc info field. */
855 get_reloc_symindex (bfd_vma reloc_info)
857 return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
860 /* Display the contents of the relocation data found at the specified
864 dump_relocations (FILE * file,
865 unsigned long rel_offset,
866 unsigned long rel_size,
867 Elf_Internal_Sym * symtab,
870 unsigned long strtablen,
874 Elf_Internal_Rela * rels;
876 if (is_rela == UNKNOWN)
877 is_rela = guess_is_rela (elf_header.e_machine);
881 if (!slurp_rela_relocs (file, rel_offset, rel_size, &rels, &rel_size))
886 if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
895 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
897 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
902 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
904 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
912 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
914 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
919 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
921 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
925 for (i = 0; i < rel_size; i++)
930 bfd_vma symtab_index;
933 offset = rels[i].r_offset;
934 inf = rels[i].r_info;
936 type = get_reloc_type (inf);
937 symtab_index = get_reloc_symindex (inf);
941 printf ("%8.8lx %8.8lx ",
942 (unsigned long) offset & 0xffffffff,
943 (unsigned long) inf & 0xffffffff);
947 #if BFD_HOST_64BIT_LONG
949 ? "%16.16lx %16.16lx "
950 : "%12.12lx %12.12lx ",
952 #elif BFD_HOST_64BIT_LONG_LONG
955 ? "%16.16llx %16.16llx "
956 : "%12.12llx %12.12llx ",
960 ? "%16.16I64x %16.16I64x "
961 : "%12.12I64x %12.12I64x ",
966 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
967 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
968 _bfd_int64_high (offset),
969 _bfd_int64_low (offset),
970 _bfd_int64_high (inf),
971 _bfd_int64_low (inf));
975 switch (elf_header.e_machine)
983 rtype = elf_m32r_reloc_type (type);
988 rtype = elf_i386_reloc_type (type);
993 rtype = elf_m68hc11_reloc_type (type);
997 rtype = elf_m68k_reloc_type (type);
1001 rtype = elf_i960_reloc_type (type);
1006 rtype = elf_avr_reloc_type (type);
1009 case EM_OLD_SPARCV9:
1010 case EM_SPARC32PLUS:
1013 rtype = elf_sparc_reloc_type (type);
1017 rtype = elf_spu_reloc_type (type);
1021 case EM_CYGNUS_V850:
1022 rtype = v850_reloc_type (type);
1026 case EM_CYGNUS_D10V:
1027 rtype = elf_d10v_reloc_type (type);
1031 case EM_CYGNUS_D30V:
1032 rtype = elf_d30v_reloc_type (type);
1036 rtype = elf_dlx_reloc_type (type);
1040 rtype = elf_sh_reloc_type (type);
1044 case EM_CYGNUS_MN10300:
1045 rtype = elf_mn10300_reloc_type (type);
1049 case EM_CYGNUS_MN10200:
1050 rtype = elf_mn10200_reloc_type (type);
1054 case EM_CYGNUS_FR30:
1055 rtype = elf_fr30_reloc_type (type);
1059 rtype = elf_frv_reloc_type (type);
1063 rtype = elf_mcore_reloc_type (type);
1067 rtype = elf_mmix_reloc_type (type);
1071 rtype = elf_moxie_reloc_type (type);
1076 rtype = elf_msp430_reloc_type (type);
1080 rtype = elf_ppc_reloc_type (type);
1084 rtype = elf_ppc64_reloc_type (type);
1088 case EM_MIPS_RS3_LE:
1089 rtype = elf_mips_reloc_type (type);
1093 rtype = elf_alpha_reloc_type (type);
1097 rtype = elf_arm_reloc_type (type);
1101 rtype = elf_arc_reloc_type (type);
1105 rtype = elf_hppa_reloc_type (type);
1111 rtype = elf_h8_reloc_type (type);
1116 rtype = elf_or32_reloc_type (type);
1121 rtype = elf_pj_reloc_type (type);
1124 rtype = elf_ia64_reloc_type (type);
1128 rtype = elf_cris_reloc_type (type);
1132 rtype = elf_i860_reloc_type (type);
1137 rtype = elf_x86_64_reloc_type (type);
1141 rtype = i370_reloc_type (type);
1146 rtype = elf_s390_reloc_type (type);
1150 rtype = elf_score_reloc_type (type);
1154 rtype = elf_xstormy16_reloc_type (type);
1158 rtype = elf_crx_reloc_type (type);
1162 rtype = elf_vax_reloc_type (type);
1167 rtype = elf_ip2k_reloc_type (type);
1171 rtype = elf_iq2000_reloc_type (type);
1176 rtype = elf_xtensa_reloc_type (type);
1179 case EM_LATTICEMICO32:
1180 rtype = elf_lm32_reloc_type (type);
1185 rtype = elf_m32c_reloc_type (type);
1189 rtype = elf_mt_reloc_type (type);
1193 rtype = elf_bfin_reloc_type (type);
1197 rtype = elf_mep_reloc_type (type);
1202 rtype = elf_cr16_reloc_type (type);
1206 case EM_MICROBLAZE_OLD:
1207 rtype = elf_microblaze_reloc_type (type);
1211 rtype = elf_rx_reloc_type (type);
1216 rtype = elf_xc16x_reloc_type (type);
1220 rtype = elf_tic6x_reloc_type (type);
1225 printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
1227 printf (do_wide ? "%-22.22s" : "%-17.17s", rtype);
1229 if (elf_header.e_machine == EM_ALPHA
1231 && streq (rtype, "R_ALPHA_LITUSE")
1234 switch (rels[i].r_addend)
1236 case LITUSE_ALPHA_ADDR: rtype = "ADDR"; break;
1237 case LITUSE_ALPHA_BASE: rtype = "BASE"; break;
1238 case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1239 case LITUSE_ALPHA_JSR: rtype = "JSR"; break;
1240 case LITUSE_ALPHA_TLSGD: rtype = "TLSGD"; break;
1241 case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1242 case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1243 default: rtype = NULL;
1246 printf (" (%s)", rtype);
1250 printf (_("<unknown addend: %lx>"),
1251 (unsigned long) rels[i].r_addend);
1254 else if (symtab_index)
1256 if (symtab == NULL || symtab_index >= nsyms)
1257 printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index);
1260 Elf_Internal_Sym * psym;
1262 psym = symtab + symtab_index;
1266 if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1270 unsigned int width = is_32bit_elf ? 8 : 14;
1272 /* Relocations against GNU_IFUNC symbols do not use the value
1273 of the symbol as the address to relocate against. Instead
1274 they invoke the function named by the symbol and use its
1275 result as the address for relocation.
1277 To indicate this to the user, do not display the value of
1278 the symbol in the "Symbols's Value" field. Instead show
1279 its name followed by () as a hint that the symbol is
1283 || psym->st_name == 0
1284 || psym->st_name >= strtablen)
1287 name = strtab + psym->st_name;
1289 len = print_symbol (width, name);
1290 printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1294 print_vma (psym->st_value, LONG_HEX);
1296 printf (is_32bit_elf ? " " : " ");
1299 if (psym->st_name == 0)
1301 const char * sec_name = "<null>";
1304 if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1306 if (psym->st_shndx < elf_header.e_shnum)
1308 = SECTION_NAME (section_headers + psym->st_shndx);
1309 else if (psym->st_shndx == SHN_ABS)
1311 else if (psym->st_shndx == SHN_COMMON)
1312 sec_name = "COMMON";
1313 else if ((elf_header.e_machine == EM_MIPS
1314 && psym->st_shndx == SHN_MIPS_SCOMMON)
1315 || (elf_header.e_machine == EM_TI_C6000
1316 && psym->st_shndx == SHN_TIC6X_SCOMMON))
1317 sec_name = "SCOMMON";
1318 else if (elf_header.e_machine == EM_MIPS
1319 && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1320 sec_name = "SUNDEF";
1321 else if ((elf_header.e_machine == EM_X86_64
1322 || elf_header.e_machine == EM_L1OM)
1323 && psym->st_shndx == SHN_X86_64_LCOMMON)
1324 sec_name = "LARGE_COMMON";
1325 else if (elf_header.e_machine == EM_IA_64
1326 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1327 && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1328 sec_name = "ANSI_COM";
1329 else if (is_ia64_vms ()
1330 && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1331 sec_name = "VMS_SYMVEC";
1334 sprintf (name_buf, "<section 0x%x>",
1335 (unsigned int) psym->st_shndx);
1336 sec_name = name_buf;
1339 print_symbol (22, sec_name);
1341 else if (strtab == NULL)
1342 printf (_("<string table index: %3ld>"), psym->st_name);
1343 else if (psym->st_name >= strtablen)
1344 printf (_("<corrupt string table index: %3ld>"), psym->st_name);
1346 print_symbol (22, strtab + psym->st_name);
1350 bfd_signed_vma off = rels[i].r_addend;
1353 printf (" - %" BFD_VMA_FMT "x", - off);
1355 printf (" + %" BFD_VMA_FMT "x", off);
1361 printf ("%*c", is_32bit_elf ?
1362 (do_wide ? 34 : 28) : (do_wide ? 26 : 20), ' ');
1363 print_vma (rels[i].r_addend, LONG_HEX);
1366 if (elf_header.e_machine == EM_SPARCV9
1368 && streq (rtype, "R_SPARC_OLO10"))
1369 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
1374 if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
1376 bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1377 bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
1378 const char * rtype2 = elf_mips_reloc_type (type2);
1379 const char * rtype3 = elf_mips_reloc_type (type3);
1381 printf (" Type2: ");
1384 printf (_("unrecognized: %-7lx"),
1385 (unsigned long) type2 & 0xffffffff);
1387 printf ("%-17.17s", rtype2);
1389 printf ("\n Type3: ");
1392 printf (_("unrecognized: %-7lx"),
1393 (unsigned long) type3 & 0xffffffff);
1395 printf ("%-17.17s", rtype3);
1406 get_mips_dynamic_type (unsigned long type)
1410 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1411 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1412 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1413 case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1414 case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1415 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1416 case DT_MIPS_MSYM: return "MIPS_MSYM";
1417 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1418 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1419 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1420 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1421 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1422 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1423 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1424 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1425 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1426 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1427 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1428 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1429 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1430 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1431 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1432 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1433 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1434 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1435 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1436 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1437 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1438 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1439 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1440 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1441 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1442 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1443 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1444 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1445 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1446 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1447 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1448 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1449 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1450 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1451 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1452 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
1453 case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1454 case DT_MIPS_RWPLT: return "MIPS_RWPLT";
1461 get_sparc64_dynamic_type (unsigned long type)
1465 case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1472 get_ppc_dynamic_type (unsigned long type)
1476 case DT_PPC_GOT: return "PPC_GOT";
1477 case DT_PPC_TLSOPT: return "PPC_TLSOPT";
1484 get_ppc64_dynamic_type (unsigned long type)
1488 case DT_PPC64_GLINK: return "PPC64_GLINK";
1489 case DT_PPC64_OPD: return "PPC64_OPD";
1490 case DT_PPC64_OPDSZ: return "PPC64_OPDSZ";
1491 case DT_PPC64_TLSOPT: return "PPC64_TLSOPT";
1498 get_parisc_dynamic_type (unsigned long type)
1502 case DT_HP_LOAD_MAP: return "HP_LOAD_MAP";
1503 case DT_HP_DLD_FLAGS: return "HP_DLD_FLAGS";
1504 case DT_HP_DLD_HOOK: return "HP_DLD_HOOK";
1505 case DT_HP_UX10_INIT: return "HP_UX10_INIT";
1506 case DT_HP_UX10_INITSZ: return "HP_UX10_INITSZ";
1507 case DT_HP_PREINIT: return "HP_PREINIT";
1508 case DT_HP_PREINITSZ: return "HP_PREINITSZ";
1509 case DT_HP_NEEDED: return "HP_NEEDED";
1510 case DT_HP_TIME_STAMP: return "HP_TIME_STAMP";
1511 case DT_HP_CHECKSUM: return "HP_CHECKSUM";
1512 case DT_HP_GST_SIZE: return "HP_GST_SIZE";
1513 case DT_HP_GST_VERSION: return "HP_GST_VERSION";
1514 case DT_HP_GST_HASHVAL: return "HP_GST_HASHVAL";
1515 case DT_HP_EPLTREL: return "HP_GST_EPLTREL";
1516 case DT_HP_EPLTRELSZ: return "HP_GST_EPLTRELSZ";
1517 case DT_HP_FILTERED: return "HP_FILTERED";
1518 case DT_HP_FILTER_TLS: return "HP_FILTER_TLS";
1519 case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1520 case DT_HP_LAZYLOAD: return "HP_LAZYLOAD";
1521 case DT_HP_BIND_NOW_COUNT: return "HP_BIND_NOW_COUNT";
1522 case DT_PLT: return "PLT";
1523 case DT_PLT_SIZE: return "PLT_SIZE";
1524 case DT_DLT: return "DLT";
1525 case DT_DLT_SIZE: return "DLT_SIZE";
1532 get_ia64_dynamic_type (unsigned long type)
1536 case DT_IA_64_PLT_RESERVE: return "IA_64_PLT_RESERVE";
1537 case DT_IA_64_VMS_SUBTYPE: return "VMS_SUBTYPE";
1538 case DT_IA_64_VMS_IMGIOCNT: return "VMS_IMGIOCNT";
1539 case DT_IA_64_VMS_LNKFLAGS: return "VMS_LNKFLAGS";
1540 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1541 case DT_IA_64_VMS_IDENT: return "VMS_IDENT";
1542 case DT_IA_64_VMS_NEEDED_IDENT: return "VMS_NEEDED_IDENT";
1543 case DT_IA_64_VMS_IMG_RELA_CNT: return "VMS_IMG_RELA_CNT";
1544 case DT_IA_64_VMS_SEG_RELA_CNT: return "VMS_SEG_RELA_CNT";
1545 case DT_IA_64_VMS_FIXUP_RELA_CNT: return "VMS_FIXUP_RELA_CNT";
1546 case DT_IA_64_VMS_FIXUP_NEEDED: return "VMS_FIXUP_NEEDED";
1547 case DT_IA_64_VMS_SYMVEC_CNT: return "VMS_SYMVEC_CNT";
1548 case DT_IA_64_VMS_XLATED: return "VMS_XLATED";
1549 case DT_IA_64_VMS_STACKSIZE: return "VMS_STACKSIZE";
1550 case DT_IA_64_VMS_UNWINDSZ: return "VMS_UNWINDSZ";
1551 case DT_IA_64_VMS_UNWIND_CODSEG: return "VMS_UNWIND_CODSEG";
1552 case DT_IA_64_VMS_UNWIND_INFOSEG: return "VMS_UNWIND_INFOSEG";
1553 case DT_IA_64_VMS_LINKTIME: return "VMS_LINKTIME";
1554 case DT_IA_64_VMS_SEG_NO: return "VMS_SEG_NO";
1555 case DT_IA_64_VMS_SYMVEC_OFFSET: return "VMS_SYMVEC_OFFSET";
1556 case DT_IA_64_VMS_SYMVEC_SEG: return "VMS_SYMVEC_SEG";
1557 case DT_IA_64_VMS_UNWIND_OFFSET: return "VMS_UNWIND_OFFSET";
1558 case DT_IA_64_VMS_UNWIND_SEG: return "VMS_UNWIND_SEG";
1559 case DT_IA_64_VMS_STRTAB_OFFSET: return "VMS_STRTAB_OFFSET";
1560 case DT_IA_64_VMS_SYSVER_OFFSET: return "VMS_SYSVER_OFFSET";
1561 case DT_IA_64_VMS_IMG_RELA_OFF: return "VMS_IMG_RELA_OFF";
1562 case DT_IA_64_VMS_SEG_RELA_OFF: return "VMS_SEG_RELA_OFF";
1563 case DT_IA_64_VMS_FIXUP_RELA_OFF: return "VMS_FIXUP_RELA_OFF";
1564 case DT_IA_64_VMS_PLTGOT_OFFSET: return "VMS_PLTGOT_OFFSET";
1565 case DT_IA_64_VMS_PLTGOT_SEG: return "VMS_PLTGOT_SEG";
1566 case DT_IA_64_VMS_FPMODE: return "VMS_FPMODE";
1573 get_alpha_dynamic_type (unsigned long type)
1577 case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
1584 get_score_dynamic_type (unsigned long type)
1588 case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
1589 case DT_SCORE_LOCAL_GOTNO: return "SCORE_LOCAL_GOTNO";
1590 case DT_SCORE_SYMTABNO: return "SCORE_SYMTABNO";
1591 case DT_SCORE_GOTSYM: return "SCORE_GOTSYM";
1592 case DT_SCORE_UNREFEXTNO: return "SCORE_UNREFEXTNO";
1593 case DT_SCORE_HIPAGENO: return "SCORE_HIPAGENO";
1600 get_tic6x_dynamic_type (unsigned long type)
1604 case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
1605 case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
1606 case DT_C6000_DSBT_BASE: return "C6000_DSBT_BASE";
1607 case DT_C6000_DSBT_SIZE: return "C6000_DSBT_SIZE";
1608 case DT_C6000_PREEMPTMAP: return "C6000_PREEMPTMAP";
1609 case DT_C6000_DSBT_INDEX: return "C6000_DSBT_INDEX";
1616 get_dynamic_type (unsigned long type)
1618 static char buff[64];
1622 case DT_NULL: return "NULL";
1623 case DT_NEEDED: return "NEEDED";
1624 case DT_PLTRELSZ: return "PLTRELSZ";
1625 case DT_PLTGOT: return "PLTGOT";
1626 case DT_HASH: return "HASH";
1627 case DT_STRTAB: return "STRTAB";
1628 case DT_SYMTAB: return "SYMTAB";
1629 case DT_RELA: return "RELA";
1630 case DT_RELASZ: return "RELASZ";
1631 case DT_RELAENT: return "RELAENT";
1632 case DT_STRSZ: return "STRSZ";
1633 case DT_SYMENT: return "SYMENT";
1634 case DT_INIT: return "INIT";
1635 case DT_FINI: return "FINI";
1636 case DT_SONAME: return "SONAME";
1637 case DT_RPATH: return "RPATH";
1638 case DT_SYMBOLIC: return "SYMBOLIC";
1639 case DT_REL: return "REL";
1640 case DT_RELSZ: return "RELSZ";
1641 case DT_RELENT: return "RELENT";
1642 case DT_PLTREL: return "PLTREL";
1643 case DT_DEBUG: return "DEBUG";
1644 case DT_TEXTREL: return "TEXTREL";
1645 case DT_JMPREL: return "JMPREL";
1646 case DT_BIND_NOW: return "BIND_NOW";
1647 case DT_INIT_ARRAY: return "INIT_ARRAY";
1648 case DT_FINI_ARRAY: return "FINI_ARRAY";
1649 case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
1650 case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
1651 case DT_RUNPATH: return "RUNPATH";
1652 case DT_FLAGS: return "FLAGS";
1654 case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1655 case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
1657 case DT_CHECKSUM: return "CHECKSUM";
1658 case DT_PLTPADSZ: return "PLTPADSZ";
1659 case DT_MOVEENT: return "MOVEENT";
1660 case DT_MOVESZ: return "MOVESZ";
1661 case DT_FEATURE: return "FEATURE";
1662 case DT_POSFLAG_1: return "POSFLAG_1";
1663 case DT_SYMINSZ: return "SYMINSZ";
1664 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
1666 case DT_ADDRRNGLO: return "ADDRRNGLO";
1667 case DT_CONFIG: return "CONFIG";
1668 case DT_DEPAUDIT: return "DEPAUDIT";
1669 case DT_AUDIT: return "AUDIT";
1670 case DT_PLTPAD: return "PLTPAD";
1671 case DT_MOVETAB: return "MOVETAB";
1672 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
1674 case DT_VERSYM: return "VERSYM";
1676 case DT_TLSDESC_GOT: return "TLSDESC_GOT";
1677 case DT_TLSDESC_PLT: return "TLSDESC_PLT";
1678 case DT_RELACOUNT: return "RELACOUNT";
1679 case DT_RELCOUNT: return "RELCOUNT";
1680 case DT_FLAGS_1: return "FLAGS_1";
1681 case DT_VERDEF: return "VERDEF";
1682 case DT_VERDEFNUM: return "VERDEFNUM";
1683 case DT_VERNEED: return "VERNEED";
1684 case DT_VERNEEDNUM: return "VERNEEDNUM";
1686 case DT_AUXILIARY: return "AUXILIARY";
1687 case DT_USED: return "USED";
1688 case DT_FILTER: return "FILTER";
1690 case DT_GNU_PRELINKED: return "GNU_PRELINKED";
1691 case DT_GNU_CONFLICT: return "GNU_CONFLICT";
1692 case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
1693 case DT_GNU_LIBLIST: return "GNU_LIBLIST";
1694 case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
1695 case DT_GNU_HASH: return "GNU_HASH";
1698 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1700 const char * result;
1702 switch (elf_header.e_machine)
1705 case EM_MIPS_RS3_LE:
1706 result = get_mips_dynamic_type (type);
1709 result = get_sparc64_dynamic_type (type);
1712 result = get_ppc_dynamic_type (type);
1715 result = get_ppc64_dynamic_type (type);
1718 result = get_ia64_dynamic_type (type);
1721 result = get_alpha_dynamic_type (type);
1724 result = get_score_dynamic_type (type);
1727 result = get_tic6x_dynamic_type (type);
1737 snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
1739 else if (((type >= DT_LOOS) && (type <= DT_HIOS))
1740 || (elf_header.e_machine == EM_PARISC
1741 && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
1743 const char * result;
1745 switch (elf_header.e_machine)
1748 result = get_parisc_dynamic_type (type);
1751 result = get_ia64_dynamic_type (type);
1761 snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
1765 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
1772 get_file_type (unsigned e_type)
1774 static char buff[32];
1778 case ET_NONE: return _("NONE (None)");
1779 case ET_REL: return _("REL (Relocatable file)");
1780 case ET_EXEC: return _("EXEC (Executable file)");
1781 case ET_DYN: return _("DYN (Shared object file)");
1782 case ET_CORE: return _("CORE (Core file)");
1785 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
1786 snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
1787 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
1788 snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
1790 snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
1796 get_machine_name (unsigned e_machine)
1798 static char buff[64]; /* XXX */
1802 case EM_NONE: return _("None");
1803 case EM_M32: return "WE32100";
1804 case EM_SPARC: return "Sparc";
1805 case EM_SPU: return "SPU";
1806 case EM_386: return "Intel 80386";
1807 case EM_68K: return "MC68000";
1808 case EM_88K: return "MC88000";
1809 case EM_486: return "Intel 80486";
1810 case EM_860: return "Intel 80860";
1811 case EM_MIPS: return "MIPS R3000";
1812 case EM_S370: return "IBM System/370";
1813 case EM_MIPS_RS3_LE: return "MIPS R4000 big-endian";
1814 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
1815 case EM_PARISC: return "HPPA";
1816 case EM_PPC_OLD: return "Power PC (old)";
1817 case EM_SPARC32PLUS: return "Sparc v8+" ;
1818 case EM_960: return "Intel 90860";
1819 case EM_PPC: return "PowerPC";
1820 case EM_PPC64: return "PowerPC64";
1821 case EM_V800: return "NEC V800";
1822 case EM_FR20: return "Fujitsu FR20";
1823 case EM_RH32: return "TRW RH32";
1824 case EM_MCORE: return "MCORE";
1825 case EM_ARM: return "ARM";
1826 case EM_OLD_ALPHA: return "Digital Alpha (old)";
1827 case EM_SH: return "Renesas / SuperH SH";
1828 case EM_SPARCV9: return "Sparc v9";
1829 case EM_TRICORE: return "Siemens Tricore";
1830 case EM_ARC: return "ARC";
1831 case EM_H8_300: return "Renesas H8/300";
1832 case EM_H8_300H: return "Renesas H8/300H";
1833 case EM_H8S: return "Renesas H8S";
1834 case EM_H8_500: return "Renesas H8/500";
1835 case EM_IA_64: return "Intel IA-64";
1836 case EM_MIPS_X: return "Stanford MIPS-X";
1837 case EM_COLDFIRE: return "Motorola Coldfire";
1838 case EM_68HC12: return "Motorola M68HC12";
1839 case EM_ALPHA: return "Alpha";
1840 case EM_CYGNUS_D10V:
1841 case EM_D10V: return "d10v";
1842 case EM_CYGNUS_D30V:
1843 case EM_D30V: return "d30v";
1844 case EM_CYGNUS_M32R:
1845 case EM_M32R: return "Renesas M32R (formerly Mitsubishi M32r)";
1846 case EM_CYGNUS_V850:
1847 case EM_V850: return "Renesas v850";
1848 case EM_CYGNUS_MN10300:
1849 case EM_MN10300: return "mn10300";
1850 case EM_CYGNUS_MN10200:
1851 case EM_MN10200: return "mn10200";
1852 case EM_MOXIE: return "Moxie";
1853 case EM_CYGNUS_FR30:
1854 case EM_FR30: return "Fujitsu FR30";
1855 case EM_CYGNUS_FRV: return "Fujitsu FR-V";
1857 case EM_PJ: return "picoJava";
1858 case EM_MMA: return "Fujitsu Multimedia Accelerator";
1859 case EM_PCP: return "Siemens PCP";
1860 case EM_NCPU: return "Sony nCPU embedded RISC processor";
1861 case EM_NDR1: return "Denso NDR1 microprocesspr";
1862 case EM_STARCORE: return "Motorola Star*Core processor";
1863 case EM_ME16: return "Toyota ME16 processor";
1864 case EM_ST100: return "STMicroelectronics ST100 processor";
1865 case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
1866 case EM_PDSP: return "Sony DSP processor";
1867 case EM_PDP10: return "Digital Equipment Corp. PDP-10";
1868 case EM_PDP11: return "Digital Equipment Corp. PDP-11";
1869 case EM_FX66: return "Siemens FX66 microcontroller";
1870 case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1871 case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
1872 case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
1873 case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
1874 case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
1875 case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
1876 case EM_SVX: return "Silicon Graphics SVx";
1877 case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
1878 case EM_VAX: return "Digital VAX";
1880 case EM_AVR: return "Atmel AVR 8-bit microcontroller";
1881 case EM_CRIS: return "Axis Communications 32-bit embedded processor";
1882 case EM_JAVELIN: return "Infineon Technologies 32-bit embedded cpu";
1883 case EM_FIREPATH: return "Element 14 64-bit DSP processor";
1884 case EM_ZSP: return "LSI Logic's 16-bit DSP processor";
1885 case EM_MMIX: return "Donald Knuth's educational 64-bit processor";
1886 case EM_HUANY: return "Harvard Universitys's machine-independent object format";
1887 case EM_PRISM: return "Vitesse Prism";
1888 case EM_X86_64: return "Advanced Micro Devices X86-64";
1889 case EM_L1OM: return "Intel L1OM";
1891 case EM_S390: return "IBM S/390";
1892 case EM_SCORE: return "SUNPLUS S+Core";
1893 case EM_XSTORMY16: return "Sanyo XStormy16 CPU core";
1895 case EM_OR32: return "OpenRISC";
1896 case EM_ARC_A5: return "ARC International ARCompact processor";
1897 case EM_CRX: return "National Semiconductor CRX microprocessor";
1898 case EM_DLX: return "OpenDLX";
1900 case EM_IP2K: return "Ubicom IP2xxx 8-bit microcontrollers";
1901 case EM_IQ2000: return "Vitesse IQ2000";
1903 case EM_XTENSA: return "Tensilica Xtensa Processor";
1904 case EM_VIDEOCORE: return "Alphamosaic VideoCore processor";
1905 case EM_TMM_GPP: return "Thompson Multimedia General Purpose Processor";
1906 case EM_NS32K: return "National Semiconductor 32000 series";
1907 case EM_TPC: return "Tenor Network TPC processor";
1908 case EM_ST200: return "STMicroelectronics ST200 microcontroller";
1909 case EM_MAX: return "MAX Processor";
1910 case EM_CR: return "National Semiconductor CompactRISC";
1911 case EM_F2MC16: return "Fujitsu F2MC16";
1912 case EM_MSP430: return "Texas Instruments msp430 microcontroller";
1913 case EM_LATTICEMICO32: return "Lattice Mico32";
1915 case EM_M32C: return "Renesas M32c";
1916 case EM_MT: return "Morpho Techologies MT processor";
1917 case EM_BLACKFIN: return "Analog Devices Blackfin";
1918 case EM_SE_C33: return "S1C33 Family of Seiko Epson processors";
1919 case EM_SEP: return "Sharp embedded microprocessor";
1920 case EM_ARCA: return "Arca RISC microprocessor";
1921 case EM_UNICORE: return "Unicore";
1922 case EM_EXCESS: return "eXcess 16/32/64-bit configurable embedded CPU";
1923 case EM_DXP: return "Icera Semiconductor Inc. Deep Execution Processor";
1924 case EM_NIOS32: return "Altera Nios";
1925 case EM_ALTERA_NIOS2: return "Altera Nios II";
1927 case EM_XC16X: return "Infineon Technologies xc16x";
1928 case EM_M16C: return "Renesas M16C series microprocessors";
1929 case EM_DSPIC30F: return "Microchip Technology dsPIC30F Digital Signal Controller";
1930 case EM_CE: return "Freescale Communication Engine RISC core";
1931 case EM_TSK3000: return "Altium TSK3000 core";
1932 case EM_RS08: return "Freescale RS08 embedded processor";
1933 case EM_ECOG2: return "Cyan Technology eCOG2 microprocessor";
1934 case EM_DSP24: return "New Japan Radio (NJR) 24-bit DSP Processor";
1935 case EM_VIDEOCORE3: return "Broadcom VideoCore III processor";
1936 case EM_SE_C17: return "Seiko Epson C17 family";
1937 case EM_TI_C6000: return "Texas Instruments TMS320C6000 DSP family";
1938 case EM_TI_C2000: return "Texas Instruments TMS320C2000 DSP family";
1939 case EM_TI_C5500: return "Texas Instruments TMS320C55x DSP family";
1940 case EM_MMDSP_PLUS: return "STMicroelectronics 64bit VLIW Data Signal Processor";
1941 case EM_CYPRESS_M8C: return "Cypress M8C microprocessor";
1942 case EM_R32C: return "Renesas R32C series microprocessors";
1943 case EM_TRIMEDIA: return "NXP Semiconductors TriMedia architecture family";
1944 case EM_QDSP6: return "QUALCOMM DSP6 Processor";
1945 case EM_8051: return "Intel 8051 and variants";
1946 case EM_STXP7X: return "STMicroelectronics STxP7x family";
1947 case EM_NDS32: return "Andes Technology compact code size embedded RISC processor family";
1948 case EM_ECOG1X: return "Cyan Technology eCOG1X family";
1949 case EM_MAXQ30: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
1950 case EM_XIMO16: return "New Japan Radio (NJR) 16-bit DSP Processor";
1951 case EM_MANIK: return "M2000 Reconfigurable RISC Microprocessor";
1952 case EM_CRAYNV2: return "Cray Inc. NV2 vector architecture";
1953 case EM_CYGNUS_MEP: return "Toshiba MeP Media Engine";
1955 case EM_CR16_OLD: return "National Semiconductor's CR16";
1956 case EM_MICROBLAZE: return "Xilinx MicroBlaze";
1957 case EM_MICROBLAZE_OLD: return "Xilinx MicroBlaze";
1958 case EM_RX: return "Renesas RX";
1959 case EM_METAG: return "Imagination Technologies META processor architecture";
1960 case EM_MCST_ELBRUS: return "MCST Elbrus general purpose hardware architecture";
1961 case EM_ECOG16: return "Cyan Technology eCOG16 family";
1962 case EM_ETPU: return "Freescale Extended Time Processing Unit";
1963 case EM_SLE9X: return "Infineon Technologies SLE9X core";
1964 case EM_AVR32: return "Atmel Corporation 32-bit microprocessor family";
1965 case EM_STM8: return "STMicroeletronics STM8 8-bit microcontroller";
1966 case EM_TILE64: return "Tilera TILE64 multicore architecture family";
1967 case EM_TILEPRO: return "Tilera TILEPro multicore architecture family";
1968 case EM_CUDA: return "NVIDIA CUDA architecture";
1970 snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
1976 decode_ARM_machine_flags (unsigned e_flags, char buf[])
1981 eabi = EF_ARM_EABI_VERSION (e_flags);
1982 e_flags &= ~ EF_ARM_EABIMASK;
1984 /* Handle "generic" ARM flags. */
1985 if (e_flags & EF_ARM_RELEXEC)
1987 strcat (buf, ", relocatable executable");
1988 e_flags &= ~ EF_ARM_RELEXEC;
1991 if (e_flags & EF_ARM_HASENTRY)
1993 strcat (buf, ", has entry point");
1994 e_flags &= ~ EF_ARM_HASENTRY;
1997 /* Now handle EABI specific flags. */
2001 strcat (buf, ", <unrecognized EABI>");
2006 case EF_ARM_EABI_VER1:
2007 strcat (buf, ", Version1 EABI");
2012 /* Process flags one bit at a time. */
2013 flag = e_flags & - e_flags;
2018 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2019 strcat (buf, ", sorted symbol tables");
2029 case EF_ARM_EABI_VER2:
2030 strcat (buf, ", Version2 EABI");
2035 /* Process flags one bit at a time. */
2036 flag = e_flags & - e_flags;
2041 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2042 strcat (buf, ", sorted symbol tables");
2045 case EF_ARM_DYNSYMSUSESEGIDX:
2046 strcat (buf, ", dynamic symbols use segment index");
2049 case EF_ARM_MAPSYMSFIRST:
2050 strcat (buf, ", mapping symbols precede others");
2060 case EF_ARM_EABI_VER3:
2061 strcat (buf, ", Version3 EABI");
2064 case EF_ARM_EABI_VER4:
2065 strcat (buf, ", Version4 EABI");
2068 case EF_ARM_EABI_VER5:
2069 strcat (buf, ", Version5 EABI");
2075 /* Process flags one bit at a time. */
2076 flag = e_flags & - e_flags;
2082 strcat (buf, ", BE8");
2086 strcat (buf, ", LE8");
2096 case EF_ARM_EABI_UNKNOWN:
2097 strcat (buf, ", GNU EABI");
2102 /* Process flags one bit at a time. */
2103 flag = e_flags & - e_flags;
2108 case EF_ARM_INTERWORK:
2109 strcat (buf, ", interworking enabled");
2112 case EF_ARM_APCS_26:
2113 strcat (buf, ", uses APCS/26");
2116 case EF_ARM_APCS_FLOAT:
2117 strcat (buf, ", uses APCS/float");
2121 strcat (buf, ", position independent");
2125 strcat (buf, ", 8 bit structure alignment");
2128 case EF_ARM_NEW_ABI:
2129 strcat (buf, ", uses new ABI");
2132 case EF_ARM_OLD_ABI:
2133 strcat (buf, ", uses old ABI");
2136 case EF_ARM_SOFT_FLOAT:
2137 strcat (buf, ", software FP");
2140 case EF_ARM_VFP_FLOAT:
2141 strcat (buf, ", VFP");
2144 case EF_ARM_MAVERICK_FLOAT:
2145 strcat (buf, ", Maverick FP");
2156 strcat (buf,_(", <unknown>"));
2160 get_machine_flags (unsigned e_flags, unsigned e_machine)
2162 static char buf[1024];
2174 decode_ARM_machine_flags (e_flags, buf);
2178 if (e_flags & EF_BFIN_PIC)
2179 strcat (buf, ", PIC");
2181 if (e_flags & EF_BFIN_FDPIC)
2182 strcat (buf, ", FDPIC");
2184 if (e_flags & EF_BFIN_CODE_IN_L1)
2185 strcat (buf, ", code in L1");
2187 if (e_flags & EF_BFIN_DATA_IN_L1)
2188 strcat (buf, ", data in L1");
2193 switch (e_flags & EF_FRV_CPU_MASK)
2195 case EF_FRV_CPU_GENERIC:
2199 strcat (buf, ", fr???");
2202 case EF_FRV_CPU_FR300:
2203 strcat (buf, ", fr300");
2206 case EF_FRV_CPU_FR400:
2207 strcat (buf, ", fr400");
2209 case EF_FRV_CPU_FR405:
2210 strcat (buf, ", fr405");
2213 case EF_FRV_CPU_FR450:
2214 strcat (buf, ", fr450");
2217 case EF_FRV_CPU_FR500:
2218 strcat (buf, ", fr500");
2220 case EF_FRV_CPU_FR550:
2221 strcat (buf, ", fr550");
2224 case EF_FRV_CPU_SIMPLE:
2225 strcat (buf, ", simple");
2227 case EF_FRV_CPU_TOMCAT:
2228 strcat (buf, ", tomcat");
2234 if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
2235 strcat (buf, ", m68000");
2236 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
2237 strcat (buf, ", cpu32");
2238 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
2239 strcat (buf, ", fido_a");
2242 char const * isa = _("unknown");
2243 char const * mac = _("unknown mac");
2244 char const * additional = NULL;
2246 switch (e_flags & EF_M68K_CF_ISA_MASK)
2248 case EF_M68K_CF_ISA_A_NODIV:
2250 additional = ", nodiv";
2252 case EF_M68K_CF_ISA_A:
2255 case EF_M68K_CF_ISA_A_PLUS:
2258 case EF_M68K_CF_ISA_B_NOUSP:
2260 additional = ", nousp";
2262 case EF_M68K_CF_ISA_B:
2265 case EF_M68K_CF_ISA_C:
2268 case EF_M68K_CF_ISA_C_NODIV:
2270 additional = ", nodiv";
2273 strcat (buf, ", cf, isa ");
2276 strcat (buf, additional);
2277 if (e_flags & EF_M68K_CF_FLOAT)
2278 strcat (buf, ", float");
2279 switch (e_flags & EF_M68K_CF_MAC_MASK)
2284 case EF_M68K_CF_MAC:
2287 case EF_M68K_CF_EMAC:
2290 case EF_M68K_CF_EMAC_B:
2303 if (e_flags & EF_PPC_EMB)
2304 strcat (buf, ", emb");
2306 if (e_flags & EF_PPC_RELOCATABLE)
2307 strcat (buf, _(", relocatable"));
2309 if (e_flags & EF_PPC_RELOCATABLE_LIB)
2310 strcat (buf, _(", relocatable-lib"));
2314 case EM_CYGNUS_V850:
2315 switch (e_flags & EF_V850_ARCH)
2317 case E_V850E2V3_ARCH:
2318 strcat (buf, ", v850e2v3");
2321 strcat (buf, ", v850e2");
2324 strcat (buf, ", v850e1");
2327 strcat (buf, ", v850e");
2330 strcat (buf, ", v850");
2333 strcat (buf, _(", unknown v850 architecture variant"));
2339 case EM_CYGNUS_M32R:
2340 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
2341 strcat (buf, ", m32r");
2345 case EM_MIPS_RS3_LE:
2346 if (e_flags & EF_MIPS_NOREORDER)
2347 strcat (buf, ", noreorder");
2349 if (e_flags & EF_MIPS_PIC)
2350 strcat (buf, ", pic");
2352 if (e_flags & EF_MIPS_CPIC)
2353 strcat (buf, ", cpic");
2355 if (e_flags & EF_MIPS_UCODE)
2356 strcat (buf, ", ugen_reserved");
2358 if (e_flags & EF_MIPS_ABI2)
2359 strcat (buf, ", abi2");
2361 if (e_flags & EF_MIPS_OPTIONS_FIRST)
2362 strcat (buf, ", odk first");
2364 if (e_flags & EF_MIPS_32BITMODE)
2365 strcat (buf, ", 32bitmode");
2367 switch ((e_flags & EF_MIPS_MACH))
2369 case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
2370 case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
2371 case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
2372 case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
2373 case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
2374 case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
2375 case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
2376 case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
2377 case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); break;
2378 case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
2379 case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
2380 case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
2381 case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
2382 case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
2383 case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
2384 case E_MIPS_MACH_XLR: strcat (buf, ", xlr"); break;
2386 /* We simply ignore the field in this case to avoid confusion:
2387 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2390 default: strcat (buf, _(", unknown CPU")); break;
2393 switch ((e_flags & EF_MIPS_ABI))
2395 case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
2396 case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
2397 case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
2398 case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
2400 /* We simply ignore the field in this case to avoid confusion:
2401 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2402 This means it is likely to be an o32 file, but not for
2405 default: strcat (buf, _(", unknown ABI")); break;
2408 if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
2409 strcat (buf, ", mdmx");
2411 if (e_flags & EF_MIPS_ARCH_ASE_M16)
2412 strcat (buf, ", mips16");
2414 switch ((e_flags & EF_MIPS_ARCH))
2416 case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
2417 case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
2418 case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
2419 case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
2420 case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
2421 case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
2422 case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
2423 case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
2424 case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
2425 default: strcat (buf, _(", unknown ISA")); break;
2428 if (e_flags & EF_SH_PIC)
2429 strcat (buf, ", pic");
2431 if (e_flags & EF_SH_FDPIC)
2432 strcat (buf, ", fdpic");
2436 switch ((e_flags & EF_SH_MACH_MASK))
2438 case EF_SH1: strcat (buf, ", sh1"); break;
2439 case EF_SH2: strcat (buf, ", sh2"); break;
2440 case EF_SH3: strcat (buf, ", sh3"); break;
2441 case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
2442 case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
2443 case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
2444 case EF_SH3E: strcat (buf, ", sh3e"); break;
2445 case EF_SH4: strcat (buf, ", sh4"); break;
2446 case EF_SH5: strcat (buf, ", sh5"); break;
2447 case EF_SH2E: strcat (buf, ", sh2e"); break;
2448 case EF_SH4A: strcat (buf, ", sh4a"); break;
2449 case EF_SH2A: strcat (buf, ", sh2a"); break;
2450 case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
2451 case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
2452 case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
2453 case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
2454 case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
2455 case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
2456 case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
2457 case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
2458 case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
2459 default: strcat (buf, _(", unknown ISA")); break;
2465 if (e_flags & EF_SPARC_32PLUS)
2466 strcat (buf, ", v8+");
2468 if (e_flags & EF_SPARC_SUN_US1)
2469 strcat (buf, ", ultrasparcI");
2471 if (e_flags & EF_SPARC_SUN_US3)
2472 strcat (buf, ", ultrasparcIII");
2474 if (e_flags & EF_SPARC_HAL_R1)
2475 strcat (buf, ", halr1");
2477 if (e_flags & EF_SPARC_LEDATA)
2478 strcat (buf, ", ledata");
2480 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
2481 strcat (buf, ", tso");
2483 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
2484 strcat (buf, ", pso");
2486 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
2487 strcat (buf, ", rmo");
2491 switch (e_flags & EF_PARISC_ARCH)
2493 case EFA_PARISC_1_0:
2494 strcpy (buf, ", PA-RISC 1.0");
2496 case EFA_PARISC_1_1:
2497 strcpy (buf, ", PA-RISC 1.1");
2499 case EFA_PARISC_2_0:
2500 strcpy (buf, ", PA-RISC 2.0");
2505 if (e_flags & EF_PARISC_TRAPNIL)
2506 strcat (buf, ", trapnil");
2507 if (e_flags & EF_PARISC_EXT)
2508 strcat (buf, ", ext");
2509 if (e_flags & EF_PARISC_LSB)
2510 strcat (buf, ", lsb");
2511 if (e_flags & EF_PARISC_WIDE)
2512 strcat (buf, ", wide");
2513 if (e_flags & EF_PARISC_NO_KABP)
2514 strcat (buf, ", no kabp");
2515 if (e_flags & EF_PARISC_LAZYSWAP)
2516 strcat (buf, ", lazyswap");
2521 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
2522 strcat (buf, ", new calling convention");
2524 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
2525 strcat (buf, ", gnu calling convention");
2529 if ((e_flags & EF_IA_64_ABI64))
2530 strcat (buf, ", 64-bit");
2532 strcat (buf, ", 32-bit");
2533 if ((e_flags & EF_IA_64_REDUCEDFP))
2534 strcat (buf, ", reduced fp model");
2535 if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
2536 strcat (buf, ", no function descriptors, constant gp");
2537 else if ((e_flags & EF_IA_64_CONS_GP))
2538 strcat (buf, ", constant gp");
2539 if ((e_flags & EF_IA_64_ABSOLUTE))
2540 strcat (buf, ", absolute");
2541 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
2543 if ((e_flags & EF_IA_64_VMS_LINKAGES))
2544 strcat (buf, ", vms_linkages");
2545 switch ((e_flags & EF_IA_64_VMS_COMCOD))
2547 case EF_IA_64_VMS_COMCOD_SUCCESS:
2549 case EF_IA_64_VMS_COMCOD_WARNING:
2550 strcat (buf, ", warning");
2552 case EF_IA_64_VMS_COMCOD_ERROR:
2553 strcat (buf, ", error");
2555 case EF_IA_64_VMS_COMCOD_ABORT:
2556 strcat (buf, ", abort");
2565 if ((e_flags & EF_VAX_NONPIC))
2566 strcat (buf, ", non-PIC");
2567 if ((e_flags & EF_VAX_DFLOAT))
2568 strcat (buf, ", D-Float");
2569 if ((e_flags & EF_VAX_GFLOAT))
2570 strcat (buf, ", G-Float");
2574 if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
2575 strcat (buf, ", 64-bit doubles");
2576 if (e_flags & E_FLAG_RX_DSP)
2577 strcat (buf, ", dsp");
2580 if (e_flags & EF_S390_HIGH_GPRS)
2581 strcat (buf, ", highgprs");
2584 if ((e_flags & EF_C6000_REL))
2585 strcat (buf, ", relocatable module");
2593 get_osabi_name (unsigned int osabi)
2595 static char buff[32];
2599 case ELFOSABI_NONE: return "UNIX - System V";
2600 case ELFOSABI_HPUX: return "UNIX - HP-UX";
2601 case ELFOSABI_NETBSD: return "UNIX - NetBSD";
2602 case ELFOSABI_LINUX: return "UNIX - Linux";
2603 case ELFOSABI_HURD: return "GNU/Hurd";
2604 case ELFOSABI_SOLARIS: return "UNIX - Solaris";
2605 case ELFOSABI_AIX: return "UNIX - AIX";
2606 case ELFOSABI_IRIX: return "UNIX - IRIX";
2607 case ELFOSABI_FREEBSD: return "UNIX - FreeBSD";
2608 case ELFOSABI_TRU64: return "UNIX - TRU64";
2609 case ELFOSABI_MODESTO: return "Novell - Modesto";
2610 case ELFOSABI_OPENBSD: return "UNIX - OpenBSD";
2611 case ELFOSABI_OPENVMS: return "VMS - OpenVMS";
2612 case ELFOSABI_NSK: return "HP - Non-Stop Kernel";
2613 case ELFOSABI_AROS: return "AROS";
2614 case ELFOSABI_FENIXOS: return "FenixOS";
2617 switch (elf_header.e_machine)
2622 case ELFOSABI_ARM: return "ARM";
2632 case ELFOSABI_STANDALONE: return _("Standalone App");
2641 case ELFOSABI_C6000_ELFABI: return _("Bare-metal C6000");
2642 case ELFOSABI_C6000_LINUX: return "Linux C6000";
2651 snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
2657 get_arm_segment_type (unsigned long type)
2671 get_mips_segment_type (unsigned long type)
2675 case PT_MIPS_REGINFO:
2677 case PT_MIPS_RTPROC:
2679 case PT_MIPS_OPTIONS:
2689 get_parisc_segment_type (unsigned long type)
2693 case PT_HP_TLS: return "HP_TLS";
2694 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
2695 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
2696 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
2697 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
2698 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
2699 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
2700 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
2701 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
2702 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
2703 case PT_HP_PARALLEL: return "HP_PARALLEL";
2704 case PT_HP_FASTBIND: return "HP_FASTBIND";
2705 case PT_HP_OPT_ANNOT: return "HP_OPT_ANNOT";
2706 case PT_HP_HSL_ANNOT: return "HP_HSL_ANNOT";
2707 case PT_HP_STACK: return "HP_STACK";
2708 case PT_HP_CORE_UTSNAME: return "HP_CORE_UTSNAME";
2709 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
2710 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
2711 case PT_PARISC_WEAKORDER: return "PARISC_WEAKORDER";
2720 get_ia64_segment_type (unsigned long type)
2724 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
2725 case PT_IA_64_UNWIND: return "IA_64_UNWIND";
2726 case PT_HP_TLS: return "HP_TLS";
2727 case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
2728 case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
2729 case PT_IA_64_HP_STACK: return "HP_STACK";
2738 get_tic6x_segment_type (unsigned long type)
2742 case PT_C6000_PHATTR: return "C6000_PHATTR";
2751 get_segment_type (unsigned long p_type)
2753 static char buff[32];
2757 case PT_NULL: return "NULL";
2758 case PT_LOAD: return "LOAD";
2759 case PT_DYNAMIC: return "DYNAMIC";
2760 case PT_INTERP: return "INTERP";
2761 case PT_NOTE: return "NOTE";
2762 case PT_SHLIB: return "SHLIB";
2763 case PT_PHDR: return "PHDR";
2764 case PT_TLS: return "TLS";
2766 case PT_GNU_EH_FRAME:
2767 return "GNU_EH_FRAME";
2768 case PT_GNU_STACK: return "GNU_STACK";
2769 case PT_GNU_RELRO: return "GNU_RELRO";
2772 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
2774 const char * result;
2776 switch (elf_header.e_machine)
2779 result = get_arm_segment_type (p_type);
2782 case EM_MIPS_RS3_LE:
2783 result = get_mips_segment_type (p_type);
2786 result = get_parisc_segment_type (p_type);
2789 result = get_ia64_segment_type (p_type);
2792 result = get_tic6x_segment_type (p_type);
2802 sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
2804 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
2806 const char * result;
2808 switch (elf_header.e_machine)
2811 result = get_parisc_segment_type (p_type);
2814 result = get_ia64_segment_type (p_type);
2824 sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
2827 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
2834 get_mips_section_type_name (unsigned int sh_type)
2838 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
2839 case SHT_MIPS_MSYM: return "MIPS_MSYM";
2840 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
2841 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
2842 case SHT_MIPS_UCODE: return "MIPS_UCODE";
2843 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
2844 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
2845 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
2846 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
2847 case SHT_MIPS_RELD: return "MIPS_RELD";
2848 case SHT_MIPS_IFACE: return "MIPS_IFACE";
2849 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
2850 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
2851 case SHT_MIPS_SHDR: return "MIPS_SHDR";
2852 case SHT_MIPS_FDESC: return "MIPS_FDESC";
2853 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
2854 case SHT_MIPS_DENSE: return "MIPS_DENSE";
2855 case SHT_MIPS_PDESC: return "MIPS_PDESC";
2856 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
2857 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
2858 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
2859 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
2860 case SHT_MIPS_LINE: return "MIPS_LINE";
2861 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
2862 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
2863 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
2864 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
2865 case SHT_MIPS_DWARF: return "MIPS_DWARF";
2866 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
2867 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
2868 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
2869 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
2870 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
2871 case SHT_MIPS_XLATE: return "MIPS_XLATE";
2872 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
2873 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
2874 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
2875 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
2876 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
2884 get_parisc_section_type_name (unsigned int sh_type)
2888 case SHT_PARISC_EXT: return "PARISC_EXT";
2889 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
2890 case SHT_PARISC_DOC: return "PARISC_DOC";
2891 case SHT_PARISC_ANNOT: return "PARISC_ANNOT";
2892 case SHT_PARISC_SYMEXTN: return "PARISC_SYMEXTN";
2893 case SHT_PARISC_STUBS: return "PARISC_STUBS";
2894 case SHT_PARISC_DLKM: return "PARISC_DLKM";
2902 get_ia64_section_type_name (unsigned int sh_type)
2904 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
2905 if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
2906 return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
2910 case SHT_IA_64_EXT: return "IA_64_EXT";
2911 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
2912 case SHT_IA_64_PRIORITY_INIT: return "IA_64_PRIORITY_INIT";
2913 case SHT_IA_64_VMS_TRACE: return "VMS_TRACE";
2914 case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
2915 case SHT_IA_64_VMS_DEBUG: return "VMS_DEBUG";
2916 case SHT_IA_64_VMS_DEBUG_STR: return "VMS_DEBUG_STR";
2917 case SHT_IA_64_VMS_LINKAGES: return "VMS_LINKAGES";
2918 case SHT_IA_64_VMS_SYMBOL_VECTOR: return "VMS_SYMBOL_VECTOR";
2919 case SHT_IA_64_VMS_FIXUP: return "VMS_FIXUP";
2927 get_x86_64_section_type_name (unsigned int sh_type)
2931 case SHT_X86_64_UNWIND: return "X86_64_UNWIND";
2939 get_arm_section_type_name (unsigned int sh_type)
2943 case SHT_ARM_EXIDX: return "ARM_EXIDX";
2944 case SHT_ARM_PREEMPTMAP: return "ARM_PREEMPTMAP";
2945 case SHT_ARM_ATTRIBUTES: return "ARM_ATTRIBUTES";
2946 case SHT_ARM_DEBUGOVERLAY: return "ARM_DEBUGOVERLAY";
2947 case SHT_ARM_OVERLAYSECTION: return "ARM_OVERLAYSECTION";
2955 get_tic6x_section_type_name (unsigned int sh_type)
2959 case SHT_C6000_UNWIND:
2960 return "C6000_UNWIND";
2961 case SHT_C6000_PREEMPTMAP:
2962 return "C6000_PREEMPTMAP";
2963 case SHT_C6000_ATTRIBUTES:
2964 return "C6000_ATTRIBUTES";
2969 case SHT_TI_HANDLER:
2970 return "TI_HANDLER";
2971 case SHT_TI_INITINFO:
2972 return "TI_INITINFO";
2973 case SHT_TI_PHATTRS:
2974 return "TI_PHATTRS";
2982 get_section_type_name (unsigned int sh_type)
2984 static char buff[32];
2988 case SHT_NULL: return "NULL";
2989 case SHT_PROGBITS: return "PROGBITS";
2990 case SHT_SYMTAB: return "SYMTAB";
2991 case SHT_STRTAB: return "STRTAB";
2992 case SHT_RELA: return "RELA";
2993 case SHT_HASH: return "HASH";
2994 case SHT_DYNAMIC: return "DYNAMIC";
2995 case SHT_NOTE: return "NOTE";
2996 case SHT_NOBITS: return "NOBITS";
2997 case SHT_REL: return "REL";
2998 case SHT_SHLIB: return "SHLIB";
2999 case SHT_DYNSYM: return "DYNSYM";
3000 case SHT_INIT_ARRAY: return "INIT_ARRAY";
3001 case SHT_FINI_ARRAY: return "FINI_ARRAY";
3002 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
3003 case SHT_GNU_HASH: return "GNU_HASH";
3004 case SHT_GROUP: return "GROUP";
3005 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICIES";
3006 case SHT_GNU_verdef: return "VERDEF";
3007 case SHT_GNU_verneed: return "VERNEED";
3008 case SHT_GNU_versym: return "VERSYM";
3009 case 0x6ffffff0: return "VERSYM";
3010 case 0x6ffffffc: return "VERDEF";
3011 case 0x7ffffffd: return "AUXILIARY";
3012 case 0x7fffffff: return "FILTER";
3013 case SHT_GNU_LIBLIST: return "GNU_LIBLIST";
3016 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
3018 const char * result;
3020 switch (elf_header.e_machine)
3023 case EM_MIPS_RS3_LE:
3024 result = get_mips_section_type_name (sh_type);
3027 result = get_parisc_section_type_name (sh_type);
3030 result = get_ia64_section_type_name (sh_type);
3034 result = get_x86_64_section_type_name (sh_type);
3037 result = get_arm_section_type_name (sh_type);
3040 result = get_tic6x_section_type_name (sh_type);
3050 sprintf (buff, "LOPROC+%x", sh_type - SHT_LOPROC);
3052 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
3054 const char * result;
3056 switch (elf_header.e_machine)
3059 result = get_ia64_section_type_name (sh_type);
3069 sprintf (buff, "LOOS+%x", sh_type - SHT_LOOS);
3071 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
3072 sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER);
3074 snprintf (buff, sizeof (buff), _("<unknown>: %x"), sh_type);
3080 #define OPTION_DEBUG_DUMP 512
3081 #define OPTION_DYN_SYMS 513
3082 #define OPTION_DWARF_DEPTH 514
3083 #define OPTION_DWARF_START 515
3085 static struct option options[] =
3087 {"all", no_argument, 0, 'a'},
3088 {"file-header", no_argument, 0, 'h'},
3089 {"program-headers", no_argument, 0, 'l'},
3090 {"headers", no_argument, 0, 'e'},
3091 {"histogram", no_argument, 0, 'I'},
3092 {"segments", no_argument, 0, 'l'},
3093 {"sections", no_argument, 0, 'S'},
3094 {"section-headers", no_argument, 0, 'S'},
3095 {"section-groups", no_argument, 0, 'g'},
3096 {"section-details", no_argument, 0, 't'},
3097 {"full-section-name",no_argument, 0, 'N'},
3098 {"symbols", no_argument, 0, 's'},
3099 {"syms", no_argument, 0, 's'},
3100 {"dyn-syms", no_argument, 0, OPTION_DYN_SYMS},
3101 {"relocs", no_argument, 0, 'r'},
3102 {"notes", no_argument, 0, 'n'},
3103 {"dynamic", no_argument, 0, 'd'},
3104 {"arch-specific", no_argument, 0, 'A'},
3105 {"version-info", no_argument, 0, 'V'},
3106 {"use-dynamic", no_argument, 0, 'D'},
3107 {"unwind", no_argument, 0, 'u'},
3108 {"archive-index", no_argument, 0, 'c'},
3109 {"hex-dump", required_argument, 0, 'x'},
3110 {"relocated-dump", required_argument, 0, 'R'},
3111 {"string-dump", required_argument, 0, 'p'},
3112 #ifdef SUPPORT_DISASSEMBLY
3113 {"instruction-dump", required_argument, 0, 'i'},
3115 {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
3117 {"dwarf-depth", required_argument, 0, OPTION_DWARF_DEPTH},
3118 {"dwarf-start", required_argument, 0, OPTION_DWARF_START},
3120 {"version", no_argument, 0, 'v'},
3121 {"wide", no_argument, 0, 'W'},
3122 {"help", no_argument, 0, 'H'},
3123 {0, no_argument, 0, 0}
3127 usage (FILE * stream)
3129 fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
3130 fprintf (stream, _(" Display information about the contents of ELF format files\n"));
3131 fprintf (stream, _(" Options are:\n\
3132 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3133 -h --file-header Display the ELF file header\n\
3134 -l --program-headers Display the program headers\n\
3135 --segments An alias for --program-headers\n\
3136 -S --section-headers Display the sections' header\n\
3137 --sections An alias for --section-headers\n\
3138 -g --section-groups Display the section groups\n\
3139 -t --section-details Display the section details\n\
3140 -e --headers Equivalent to: -h -l -S\n\
3141 -s --syms Display the symbol table\n\
3142 --symbols An alias for --syms\n\
3143 --dyn-syms Display the dynamic symbol table\n\
3144 -n --notes Display the core notes (if present)\n\
3145 -r --relocs Display the relocations (if present)\n\
3146 -u --unwind Display the unwind info (if present)\n\
3147 -d --dynamic Display the dynamic section (if present)\n\
3148 -V --version-info Display the version sections (if present)\n\
3149 -A --arch-specific Display architecture specific information (if any).\n\
3150 -c --archive-index Display the symbol/file index in an archive\n\
3151 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
3152 -x --hex-dump=<number|name>\n\
3153 Dump the contents of section <number|name> as bytes\n\
3154 -p --string-dump=<number|name>\n\
3155 Dump the contents of section <number|name> as strings\n\
3156 -R --relocated-dump=<number|name>\n\
3157 Dump the contents of section <number|name> as relocated bytes\n\
3158 -w[lLiaprmfFsoRt] or\n\
3159 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
3160 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
3161 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges]\n\
3162 Display the contents of DWARF2 debug sections\n"));
3163 fprintf (stream, _("\
3164 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
3165 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
3167 #ifdef SUPPORT_DISASSEMBLY
3168 fprintf (stream, _("\
3169 -i --instruction-dump=<number|name>\n\
3170 Disassemble the contents of section <number|name>\n"));
3172 fprintf (stream, _("\
3173 -I --histogram Display histogram of bucket list lengths\n\
3174 -W --wide Allow output width to exceed 80 characters\n\
3175 @<file> Read options from <file>\n\
3176 -H --help Display this information\n\
3177 -v --version Display the version number of readelf\n"));
3179 if (REPORT_BUGS_TO[0] && stream == stdout)
3180 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
3182 exit (stream == stdout ? 0 : 1);
3185 /* Record the fact that the user wants the contents of section number
3186 SECTION to be displayed using the method(s) encoded as flags bits
3187 in TYPE. Note, TYPE can be zero if we are creating the array for
3191 request_dump_bynumber (unsigned int section, dump_type type)
3193 if (section >= num_dump_sects)
3195 dump_type * new_dump_sects;
3197 new_dump_sects = (dump_type *) calloc (section + 1,
3198 sizeof (* dump_sects));
3200 if (new_dump_sects == NULL)
3201 error (_("Out of memory allocating dump request table.\n"));
3204 /* Copy current flag settings. */
3205 memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
3209 dump_sects = new_dump_sects;
3210 num_dump_sects = section + 1;
3215 dump_sects[section] |= type;
3220 /* Request a dump by section name. */
3223 request_dump_byname (const char * section, dump_type type)
3225 struct dump_list_entry * new_request;
3227 new_request = (struct dump_list_entry *)
3228 malloc (sizeof (struct dump_list_entry));
3230 error (_("Out of memory allocating dump request table.\n"));
3232 new_request->name = strdup (section);
3233 if (!new_request->name)
3234 error (_("Out of memory allocating dump request table.\n"));
3236 new_request->type = type;
3238 new_request->next = dump_sects_byname;
3239 dump_sects_byname = new_request;
3243 request_dump (dump_type type)
3249 section = strtoul (optarg, & cp, 0);
3251 if (! *cp && section >= 0)
3252 request_dump_bynumber (section, type);
3254 request_dump_byname (optarg, type);
3259 parse_args (int argc, char ** argv)
3266 while ((c = getopt_long
3267 (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options, NULL)) != EOF)
3285 do_section_groups++;
3293 do_section_groups++;
3298 do_section_details++;
3342 request_dump (HEX_DUMP);
3345 request_dump (STRING_DUMP);
3348 request_dump (RELOC_DUMP);
3355 dwarf_select_sections_all ();
3360 dwarf_select_sections_by_letters (optarg);
3363 case OPTION_DEBUG_DUMP:
3370 dwarf_select_sections_by_names (optarg);
3373 case OPTION_DWARF_DEPTH:
3377 dwarf_cutoff_level = strtoul (optarg, & cp, 0);
3380 case OPTION_DWARF_START:
3384 dwarf_start_die = strtoul (optarg, & cp, 0);
3387 case OPTION_DYN_SYMS:
3390 #ifdef SUPPORT_DISASSEMBLY
3392 request_dump (DISASS_DUMP);
3396 print_version (program_name);
3405 /* xgettext:c-format */
3406 error (_("Invalid option '-%c'\n"), c);
3413 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
3414 && !do_segments && !do_header && !do_dump && !do_version
3415 && !do_histogram && !do_debugging && !do_arch && !do_notes
3416 && !do_section_groups && !do_archive_index
3421 warn (_("Nothing to do.\n"));
3427 get_elf_class (unsigned int elf_class)
3429 static char buff[32];
3433 case ELFCLASSNONE: return _("none");
3434 case ELFCLASS32: return "ELF32";
3435 case ELFCLASS64: return "ELF64";
3437 snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
3443 get_data_encoding (unsigned int encoding)
3445 static char buff[32];
3449 case ELFDATANONE: return _("none");
3450 case ELFDATA2LSB: return _("2's complement, little endian");
3451 case ELFDATA2MSB: return _("2's complement, big endian");
3453 snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
3458 /* Decode the data held in 'elf_header'. */
3461 process_file_header (void)
3463 if ( elf_header.e_ident[EI_MAG0] != ELFMAG0
3464 || elf_header.e_ident[EI_MAG1] != ELFMAG1
3465 || elf_header.e_ident[EI_MAG2] != ELFMAG2
3466 || elf_header.e_ident[EI_MAG3] != ELFMAG3)
3469 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3473 init_dwarf_regnames (elf_header.e_machine);
3479 printf (_("ELF Header:\n"));
3480 printf (_(" Magic: "));
3481 for (i = 0; i < EI_NIDENT; i++)
3482 printf ("%2.2x ", elf_header.e_ident[i]);
3484 printf (_(" Class: %s\n"),
3485 get_elf_class (elf_header.e_ident[EI_CLASS]));
3486 printf (_(" Data: %s\n"),
3487 get_data_encoding (elf_header.e_ident[EI_DATA]));
3488 printf (_(" Version: %d %s\n"),
3489 elf_header.e_ident[EI_VERSION],
3490 (elf_header.e_ident[EI_VERSION] == EV_CURRENT
3492 : (elf_header.e_ident[EI_VERSION] != EV_NONE
3493 ? _("<unknown: %lx>")
3495 printf (_(" OS/ABI: %s\n"),
3496 get_osabi_name (elf_header.e_ident[EI_OSABI]));
3497 printf (_(" ABI Version: %d\n"),
3498 elf_header.e_ident[EI_ABIVERSION]);
3499 printf (_(" Type: %s\n"),
3500 get_file_type (elf_header.e_type));
3501 printf (_(" Machine: %s\n"),
3502 get_machine_name (elf_header.e_machine));
3503 printf (_(" Version: 0x%lx\n"),
3504 (unsigned long) elf_header.e_version);
3506 printf (_(" Entry point address: "));
3507 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
3508 printf (_("\n Start of program headers: "));
3509 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
3510 printf (_(" (bytes into file)\n Start of section headers: "));
3511 print_vma ((bfd_vma) elf_header.e_shoff, DEC);
3512 printf (_(" (bytes into file)\n"));
3514 printf (_(" Flags: 0x%lx%s\n"),
3515 (unsigned long) elf_header.e_flags,
3516 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
3517 printf (_(" Size of this header: %ld (bytes)\n"),
3518 (long) elf_header.e_ehsize);
3519 printf (_(" Size of program headers: %ld (bytes)\n"),
3520 (long) elf_header.e_phentsize);
3521 printf (_(" Number of program headers: %ld"),
3522 (long) elf_header.e_phnum);
3523 if (section_headers != NULL
3524 && elf_header.e_phnum == PN_XNUM
3525 && section_headers[0].sh_info != 0)
3526 printf (" (%ld)", (long) section_headers[0].sh_info);
3527 putc ('\n', stdout);
3528 printf (_(" Size of section headers: %ld (bytes)\n"),
3529 (long) elf_header.e_shentsize);
3530 printf (_(" Number of section headers: %ld"),
3531 (long) elf_header.e_shnum);
3532 if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
3533 printf (" (%ld)", (long) section_headers[0].sh_size);
3534 putc ('\n', stdout);
3535 printf (_(" Section header string table index: %ld"),
3536 (long) elf_header.e_shstrndx);
3537 if (section_headers != NULL
3538 && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
3539 printf (" (%u)", section_headers[0].sh_link);
3540 else if (elf_header.e_shstrndx != SHN_UNDEF
3541 && elf_header.e_shstrndx >= elf_header.e_shnum)
3542 printf (_(" <corrupt: out of range>"));
3543 putc ('\n', stdout);
3546 if (section_headers != NULL)
3548 if (elf_header.e_phnum == PN_XNUM
3549 && section_headers[0].sh_info != 0)
3550 elf_header.e_phnum = section_headers[0].sh_info;
3551 if (elf_header.e_shnum == SHN_UNDEF)
3552 elf_header.e_shnum = section_headers[0].sh_size;
3553 if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
3554 elf_header.e_shstrndx = section_headers[0].sh_link;
3555 else if (elf_header.e_shstrndx >= elf_header.e_shnum)
3556 elf_header.e_shstrndx = SHN_UNDEF;
3557 free (section_headers);
3558 section_headers = NULL;
3566 get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
3568 Elf32_External_Phdr * phdrs;
3569 Elf32_External_Phdr * external;
3570 Elf_Internal_Phdr * internal;
3573 phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
3574 elf_header.e_phentsize,
3576 _("program headers"));
3580 for (i = 0, internal = pheaders, external = phdrs;
3581 i < elf_header.e_phnum;
3582 i++, internal++, external++)
3584 internal->p_type = BYTE_GET (external->p_type);
3585 internal->p_offset = BYTE_GET (external->p_offset);
3586 internal->p_vaddr = BYTE_GET (external->p_vaddr);
3587 internal->p_paddr = BYTE_GET (external->p_paddr);
3588 internal->p_filesz = BYTE_GET (external->p_filesz);
3589 internal->p_memsz = BYTE_GET (external->p_memsz);
3590 internal->p_flags = BYTE_GET (external->p_flags);
3591 internal->p_align = BYTE_GET (external->p_align);
3600 get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
3602 Elf64_External_Phdr * phdrs;
3603 Elf64_External_Phdr * external;
3604 Elf_Internal_Phdr * internal;
3607 phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
3608 elf_header.e_phentsize,
3610 _("program headers"));
3614 for (i = 0, internal = pheaders, external = phdrs;
3615 i < elf_header.e_phnum;
3616 i++, internal++, external++)
3618 internal->p_type = BYTE_GET (external->p_type);
3619 internal->p_flags = BYTE_GET (external->p_flags);
3620 internal->p_offset = BYTE_GET (external->p_offset);
3621 internal->p_vaddr = BYTE_GET (external->p_vaddr);
3622 internal->p_paddr = BYTE_GET (external->p_paddr);
3623 internal->p_filesz = BYTE_GET (external->p_filesz);
3624 internal->p_memsz = BYTE_GET (external->p_memsz);
3625 internal->p_align = BYTE_GET (external->p_align);
3633 /* Returns 1 if the program headers were read into `program_headers'. */
3636 get_program_headers (FILE * file)
3638 Elf_Internal_Phdr * phdrs;
3640 /* Check cache of prior read. */
3641 if (program_headers != NULL)
3644 phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
3645 sizeof (Elf_Internal_Phdr));
3649 error (_("Out of memory\n"));
3654 ? get_32bit_program_headers (file, phdrs)
3655 : get_64bit_program_headers (file, phdrs))
3657 program_headers = phdrs;
3665 /* Returns 1 if the program headers were loaded. */
3668 process_program_headers (FILE * file)
3670 Elf_Internal_Phdr * segment;
3673 if (elf_header.e_phnum == 0)
3675 /* PR binutils/12467. */
3676 if (elf_header.e_phoff != 0)
3677 warn (_("possibly corrupt ELF header - it has a non-zero program"
3678 " header offset, but no program headers"));
3679 else if (do_segments)
3680 printf (_("\nThere are no program headers in this file.\n"));
3684 if (do_segments && !do_header)
3686 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
3687 printf (_("Entry point "));
3688 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
3689 printf (_("\nThere are %d program headers, starting at offset "),
3690 elf_header.e_phnum);
3691 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
3695 if (! get_program_headers (file))
3700 if (elf_header.e_phnum > 1)
3701 printf (_("\nProgram Headers:\n"));
3703 printf (_("\nProgram Headers:\n"));
3707 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3710 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3714 (_(" Type Offset VirtAddr PhysAddr\n"));
3716 (_(" FileSiz MemSiz Flags Align\n"));
3723 for (i = 0, segment = program_headers;
3724 i < elf_header.e_phnum;
3729 printf (" %-14.14s ", get_segment_type (segment->p_type));
3733 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
3734 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
3735 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
3736 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
3737 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
3739 (segment->p_flags & PF_R ? 'R' : ' '),
3740 (segment->p_flags & PF_W ? 'W' : ' '),
3741 (segment->p_flags & PF_X ? 'E' : ' '));
3742 printf ("%#lx", (unsigned long) segment->p_align);
3746 if ((unsigned long) segment->p_offset == segment->p_offset)
3747 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
3750 print_vma (segment->p_offset, FULL_HEX);
3754 print_vma (segment->p_vaddr, FULL_HEX);
3756 print_vma (segment->p_paddr, FULL_HEX);
3759 if ((unsigned long) segment->p_filesz == segment->p_filesz)
3760 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
3763 print_vma (segment->p_filesz, FULL_HEX);
3767 if ((unsigned long) segment->p_memsz == segment->p_memsz)
3768 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
3771 print_vma (segment->p_offset, FULL_HEX);
3775 (segment->p_flags & PF_R ? 'R' : ' '),
3776 (segment->p_flags & PF_W ? 'W' : ' '),
3777 (segment->p_flags & PF_X ? 'E' : ' '));
3779 if ((unsigned long) segment->p_align == segment->p_align)
3780 printf ("%#lx", (unsigned long) segment->p_align);
3783 print_vma (segment->p_align, PREFIX_HEX);
3788 print_vma (segment->p_offset, FULL_HEX);
3790 print_vma (segment->p_vaddr, FULL_HEX);
3792 print_vma (segment->p_paddr, FULL_HEX);
3794 print_vma (segment->p_filesz, FULL_HEX);
3796 print_vma (segment->p_memsz, FULL_HEX);
3798 (segment->p_flags & PF_R ? 'R' : ' '),
3799 (segment->p_flags & PF_W ? 'W' : ' '),
3800 (segment->p_flags & PF_X ? 'E' : ' '));
3801 print_vma (segment->p_align, HEX);
3805 switch (segment->p_type)
3809 error (_("more than one dynamic segment\n"));
3811 /* By default, assume that the .dynamic section is the first
3812 section in the DYNAMIC segment. */
3813 dynamic_addr = segment->p_offset;
3814 dynamic_size = segment->p_filesz;
3816 /* Try to locate the .dynamic section. If there is
3817 a section header table, we can easily locate it. */
3818 if (section_headers != NULL)
3820 Elf_Internal_Shdr * sec;
3822 sec = find_section (".dynamic");
3823 if (sec == NULL || sec->sh_size == 0)
3825 /* A corresponding .dynamic section is expected, but on
3826 IA-64/OpenVMS it is OK for it to be missing. */
3827 if (!is_ia64_vms ())
3828 error (_("no .dynamic section in the dynamic segment\n"));
3832 if (sec->sh_type == SHT_NOBITS)
3838 dynamic_addr = sec->sh_offset;
3839 dynamic_size = sec->sh_size;
3841 if (dynamic_addr < segment->p_offset
3842 || dynamic_addr > segment->p_offset + segment->p_filesz)
3843 warn (_("the .dynamic section is not contained"
3844 " within the dynamic segment\n"));
3845 else if (dynamic_addr > segment->p_offset)
3846 warn (_("the .dynamic section is not the first section"
3847 " in the dynamic segment.\n"));
3852 if (fseek (file, archive_file_offset + (long) segment->p_offset,
3854 error (_("Unable to find program interpreter name\n"));
3858 int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX);
3860 if (ret >= (int) sizeof (fmt) || ret < 0)
3861 error (_("Internal error: failed to create format string to display program interpreter\n"));
3863 program_interpreter[0] = 0;
3864 if (fscanf (file, fmt, program_interpreter) <= 0)
3865 error (_("Unable to read program interpreter name\n"));
3868 printf (_("\n [Requesting program interpreter: %s]"),
3869 program_interpreter);
3875 putc ('\n', stdout);
3878 if (do_segments && section_headers != NULL && string_table != NULL)
3880 printf (_("\n Section to Segment mapping:\n"));
3881 printf (_(" Segment Sections...\n"));
3883 for (i = 0; i < elf_header.e_phnum; i++)
3886 Elf_Internal_Shdr * section;
3888 segment = program_headers + i;
3889 section = section_headers + 1;
3891 printf (" %2.2d ", i);
3893 for (j = 1; j < elf_header.e_shnum; j++, section++)
3895 if (!ELF_TBSS_SPECIAL (section, segment)
3896 && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
3897 printf ("%s ", SECTION_NAME (section));
3908 /* Find the file offset corresponding to VMA by using the program headers. */
3911 offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
3913 Elf_Internal_Phdr * seg;
3915 if (! get_program_headers (file))
3917 warn (_("Cannot interpret virtual addresses without program headers.\n"));
3921 for (seg = program_headers;
3922 seg < program_headers + elf_header.e_phnum;
3925 if (seg->p_type != PT_LOAD)
3928 if (vma >= (seg->p_vaddr & -seg->p_align)
3929 && vma + size <= seg->p_vaddr + seg->p_filesz)
3930 return vma - seg->p_vaddr + seg->p_offset;
3933 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
3934 (unsigned long) vma);
3940 get_32bit_section_headers (FILE * file, unsigned int num)
3942 Elf32_External_Shdr * shdrs;
3943 Elf_Internal_Shdr * internal;
3946 shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
3947 elf_header.e_shentsize, num,
3948 _("section headers"));
3952 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
3953 sizeof (Elf_Internal_Shdr));
3955 if (section_headers == NULL)
3957 error (_("Out of memory\n"));
3961 for (i = 0, internal = section_headers;
3965 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
3966 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
3967 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
3968 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
3969 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
3970 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
3971 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
3972 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
3973 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
3974 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
3983 get_64bit_section_headers (FILE * file, unsigned int num)
3985 Elf64_External_Shdr * shdrs;
3986 Elf_Internal_Shdr * internal;
3989 shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
3990 elf_header.e_shentsize, num,
3991 _("section headers"));
3995 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
3996 sizeof (Elf_Internal_Shdr));
3998 if (section_headers == NULL)
4000 error (_("Out of memory\n"));
4004 for (i = 0, internal = section_headers;
4008 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4009 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
4010 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4011 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4012 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4013 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
4014 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4015 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
4016 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
4017 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4025 static Elf_Internal_Sym *
4026 get_32bit_elf_symbols (FILE * file, Elf_Internal_Shdr * section)
4028 unsigned long number;
4029 Elf32_External_Sym * esyms = NULL;
4030 Elf_External_Sym_Shndx * shndx;
4031 Elf_Internal_Sym * isyms = NULL;
4032 Elf_Internal_Sym * psym;
4035 /* Run some sanity checks first. */
4036 if (section->sh_entsize == 0)
4038 error (_("sh_entsize is zero\n"));
4042 number = section->sh_size / section->sh_entsize;
4044 if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
4046 error (_("Invalid sh_entsize\n"));
4050 esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4051 section->sh_size, _("symbols"));
4056 if (symtab_shndx_hdr != NULL
4057 && (symtab_shndx_hdr->sh_link
4058 == (unsigned long) (section - section_headers)))
4060 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4061 symtab_shndx_hdr->sh_offset,
4062 1, symtab_shndx_hdr->sh_size,
4068 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
4072 error (_("Out of memory\n"));
4076 for (j = 0, psym = isyms; j < number; j++, psym++)
4078 psym->st_name = BYTE_GET (esyms[j].st_name);
4079 psym->st_value = BYTE_GET (esyms[j].st_value);
4080 psym->st_size = BYTE_GET (esyms[j].st_size);
4081 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4082 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
4084 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4085 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4086 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
4087 psym->st_info = BYTE_GET (esyms[j].st_info);
4088 psym->st_other = BYTE_GET (esyms[j].st_other);
4100 static Elf_Internal_Sym *
4101 get_64bit_elf_symbols (FILE * file, Elf_Internal_Shdr * section)
4103 unsigned long number;
4104 Elf64_External_Sym * esyms;
4105 Elf_External_Sym_Shndx * shndx;
4106 Elf_Internal_Sym * isyms;
4107 Elf_Internal_Sym * psym;
4110 /* Run some sanity checks first. */
4111 if (section->sh_entsize == 0)
4113 error (_("sh_entsize is zero\n"));
4117 number = section->sh_size / section->sh_entsize;
4119 if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
4121 error (_("Invalid sh_entsize\n"));
4125 esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4126 section->sh_size, _("symbols"));
4131 if (symtab_shndx_hdr != NULL
4132 && (symtab_shndx_hdr->sh_link
4133 == (unsigned long) (section - section_headers)))
4135 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4136 symtab_shndx_hdr->sh_offset,
4137 1, symtab_shndx_hdr->sh_size,
4146 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
4150 error (_("Out of memory\n"));
4157 for (j = 0, psym = isyms;
4161 psym->st_name = BYTE_GET (esyms[j].st_name);
4162 psym->st_info = BYTE_GET (esyms[j].st_info);
4163 psym->st_other = BYTE_GET (esyms[j].st_other);
4164 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4165 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
4167 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4168 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4169 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
4170 psym->st_value = BYTE_GET (esyms[j].st_value);
4171 psym->st_size = BYTE_GET (esyms[j].st_size);
4182 get_elf_section_flags (bfd_vma sh_flags)
4184 static char buff[1024];
4186 int field_size = is_32bit_elf ? 8 : 16;
4188 int size = sizeof (buff) - (field_size + 4 + 1);
4189 bfd_vma os_flags = 0;
4190 bfd_vma proc_flags = 0;
4191 bfd_vma unknown_flags = 0;
4199 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
4200 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
4201 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
4202 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
4203 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
4204 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
4205 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
4206 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
4207 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
4208 /* 9 */ { STRING_COMMA_LEN ("TLS") },
4209 /* IA-64 specific. */
4210 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
4211 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
4212 /* IA-64 OpenVMS specific. */
4213 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
4214 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
4215 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
4216 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
4217 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
4218 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
4220 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
4221 /* SPARC specific. */
4222 /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
4225 if (do_section_details)
4227 sprintf (buff, "[%*.*lx]: ",
4228 field_size, field_size, (unsigned long) sh_flags);
4229 p += field_size + 4;
4236 flag = sh_flags & - sh_flags;
4239 if (do_section_details)
4243 case SHF_WRITE: sindex = 0; break;
4244 case SHF_ALLOC: sindex = 1; break;
4245 case SHF_EXECINSTR: sindex = 2; break;
4246 case SHF_MERGE: sindex = 3; break;
4247 case SHF_STRINGS: sindex = 4; break;
4248 case SHF_INFO_LINK: sindex = 5; break;
4249 case SHF_LINK_ORDER: sindex = 6; break;
4250 case SHF_OS_NONCONFORMING: sindex = 7; break;
4251 case SHF_GROUP: sindex = 8; break;
4252 case SHF_TLS: sindex = 9; break;
4253 case SHF_EXCLUDE: sindex = 18; break;
4257 switch (elf_header.e_machine)
4260 if (flag == SHF_IA_64_SHORT)
4262 else if (flag == SHF_IA_64_NORECOV)
4265 else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
4268 case SHF_IA_64_VMS_GLOBAL: sindex = 12; break;
4269 case SHF_IA_64_VMS_OVERLAID: sindex = 13; break;
4270 case SHF_IA_64_VMS_SHARED: sindex = 14; break;
4271 case SHF_IA_64_VMS_VECTOR: sindex = 15; break;
4272 case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
4273 case SHF_IA_64_VMS_PROTECTED: sindex = 17; break;
4283 case EM_OLD_SPARCV9:
4284 case EM_SPARC32PLUS:
4287 if (flag == SHF_ORDERED)
4297 if (p != buff + field_size + 4)
4299 if (size < (10 + 2))
4306 size -= flags [sindex].len;
4307 p = stpcpy (p, flags [sindex].str);
4309 else if (flag & SHF_MASKOS)
4311 else if (flag & SHF_MASKPROC)
4314 unknown_flags |= flag;
4320 case SHF_WRITE: *p = 'W'; break;
4321 case SHF_ALLOC: *p = 'A'; break;
4322 case SHF_EXECINSTR: *p = 'X'; break;
4323 case SHF_MERGE: *p = 'M'; break;
4324 case SHF_STRINGS: *p = 'S'; break;
4325 case SHF_INFO_LINK: *p = 'I'; break;
4326 case SHF_LINK_ORDER: *p = 'L'; break;
4327 case SHF_OS_NONCONFORMING: *p = 'O'; break;
4328 case SHF_GROUP: *p = 'G'; break;
4329 case SHF_TLS: *p = 'T'; break;
4330 case SHF_EXCLUDE: *p = 'E'; break;
4333 if ((elf_header.e_machine == EM_X86_64
4334 || elf_header.e_machine == EM_L1OM)
4335 && flag == SHF_X86_64_LARGE)
4337 else if (flag & SHF_MASKOS)
4340 sh_flags &= ~ SHF_MASKOS;
4342 else if (flag & SHF_MASKPROC)
4345 sh_flags &= ~ SHF_MASKPROC;
4355 if (do_section_details)
4359 size -= 5 + field_size;
4360 if (p != buff + field_size + 4)
4368 sprintf (p, "OS (%*.*lx)", field_size, field_size,
4369 (unsigned long) os_flags);
4370 p += 5 + field_size;
4374 size -= 7 + field_size;
4375 if (p != buff + field_size + 4)
4383 sprintf (p, "PROC (%*.*lx)", field_size, field_size,
4384 (unsigned long) proc_flags);
4385 p += 7 + field_size;
4389 size -= 10 + field_size;
4390 if (p != buff + field_size + 4)
4398 sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
4399 (unsigned long) unknown_flags);
4400 p += 10 + field_size;
4409 process_section_headers (FILE * file)
4411 Elf_Internal_Shdr * section;
4414 section_headers = NULL;
4416 if (elf_header.e_shnum == 0)
4418 /* PR binutils/12467. */
4419 if (elf_header.e_shoff != 0)
4420 warn (_("possibly corrupt ELF file header - it has a non-zero"
4421 " section header offset, but no section headers\n"));
4422 else if (do_sections)
4423 printf (_("\nThere are no sections in this file.\n"));
4428 if (do_sections && !do_header)
4429 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
4430 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
4434 if (! get_32bit_section_headers (file, elf_header.e_shnum))
4437 else if (! get_64bit_section_headers (file, elf_header.e_shnum))
4440 /* Read in the string table, so that we have names to display. */
4441 if (elf_header.e_shstrndx != SHN_UNDEF
4442 && elf_header.e_shstrndx < elf_header.e_shnum)
4444 section = section_headers + elf_header.e_shstrndx;
4446 if (section->sh_size != 0)
4448 string_table = (char *) get_data (NULL, file, section->sh_offset,
4449 1, section->sh_size,
4452 string_table_length = string_table != NULL ? section->sh_size : 0;
4456 /* Scan the sections for the dynamic symbol table
4457 and dynamic string table and debug sections. */
4458 dynamic_symbols = NULL;
4459 dynamic_strings = NULL;
4460 dynamic_syminfo = NULL;
4461 symtab_shndx_hdr = NULL;
4463 eh_addr_size = is_32bit_elf ? 4 : 8;
4464 switch (elf_header.e_machine)
4467 case EM_MIPS_RS3_LE:
4468 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
4469 FDE addresses. However, the ABI also has a semi-official ILP32
4470 variant for which the normal FDE address size rules apply.
4472 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
4473 section, where XX is the size of longs in bits. Unfortunately,
4474 earlier compilers provided no way of distinguishing ILP32 objects
4475 from LP64 objects, so if there's any doubt, we should assume that
4476 the official LP64 form is being used. */
4477 if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
4478 && find_section (".gcc_compiled_long32") == NULL)
4484 switch (elf_header.e_flags & EF_H8_MACH)
4486 case E_H8_MACH_H8300:
4487 case E_H8_MACH_H8300HN:
4488 case E_H8_MACH_H8300SN:
4489 case E_H8_MACH_H8300SXN:
4492 case E_H8_MACH_H8300H:
4493 case E_H8_MACH_H8300S:
4494 case E_H8_MACH_H8300SX:
4502 switch (elf_header.e_flags & EF_M32C_CPU_MASK)
4504 case EF_M32C_CPU_M16C:
4511 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
4514 size_t expected_entsize \
4515 = is_32bit_elf ? size32 : size64; \
4516 if (section->sh_entsize != expected_entsize) \
4517 error (_("Section %d has invalid sh_entsize %lx (expected %lx)\n"), \
4518 i, (unsigned long int) section->sh_entsize, \
4519 (unsigned long int) expected_entsize); \
4520 section->sh_entsize = expected_entsize; \
4523 #define CHECK_ENTSIZE(section, i, type) \
4524 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
4525 sizeof (Elf64_External_##type))
4527 for (i = 0, section = section_headers;
4528 i < elf_header.e_shnum;
4531 char * name = SECTION_NAME (section);
4533 if (section->sh_type == SHT_DYNSYM)
4535 if (dynamic_symbols != NULL)
4537 error (_("File contains multiple dynamic symbol tables\n"));
4541 CHECK_ENTSIZE (section, i, Sym);
4542 num_dynamic_syms = section->sh_size / section->sh_entsize;
4543 dynamic_symbols = GET_ELF_SYMBOLS (file, section);
4545 else if (section->sh_type == SHT_STRTAB
4546 && streq (name, ".dynstr"))
4548 if (dynamic_strings != NULL)
4550 error (_("File contains multiple dynamic string tables\n"));
4554 dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
4555 1, section->sh_size,
4556 _("dynamic strings"));
4557 dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
4559 else if (section->sh_type == SHT_SYMTAB_SHNDX)
4561 if (symtab_shndx_hdr != NULL)
4563 error (_("File contains multiple symtab shndx tables\n"));
4566 symtab_shndx_hdr = section;
4568 else if (section->sh_type == SHT_SYMTAB)
4569 CHECK_ENTSIZE (section, i, Sym);
4570 else if (section->sh_type == SHT_GROUP)
4571 CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
4572 else if (section->sh_type == SHT_REL)
4573 CHECK_ENTSIZE (section, i, Rel);
4574 else if (section->sh_type == SHT_RELA)
4575 CHECK_ENTSIZE (section, i, Rela);
4576 else if ((do_debugging || do_debug_info || do_debug_abbrevs
4577 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
4578 || do_debug_aranges || do_debug_frames || do_debug_macinfo
4579 || do_debug_str || do_debug_loc || do_debug_ranges)
4580 && (const_strneq (name, ".debug_")
4581 || const_strneq (name, ".zdebug_")))
4584 name += sizeof (".zdebug_") - 1;
4586 name += sizeof (".debug_") - 1;
4589 || (do_debug_info && streq (name, "info"))
4590 || (do_debug_info && streq (name, "types"))
4591 || (do_debug_abbrevs && streq (name, "abbrev"))
4592 || (do_debug_lines && streq (name, "line"))
4593 || (do_debug_pubnames && streq (name, "pubnames"))
4594 || (do_debug_pubtypes && streq (name, "pubtypes"))
4595 || (do_debug_aranges && streq (name, "aranges"))
4596 || (do_debug_ranges && streq (name, "ranges"))
4597 || (do_debug_frames && streq (name, "frame"))
4598 || (do_debug_macinfo && streq (name, "macinfo"))
4599 || (do_debug_str && streq (name, "str"))
4600 || (do_debug_loc && streq (name, "loc"))
4602 request_dump_bynumber (i, DEBUG_DUMP);
4604 /* Linkonce section to be combined with .debug_info at link time. */
4605 else if ((do_debugging || do_debug_info)
4606 && const_strneq (name, ".gnu.linkonce.wi."))
4607 request_dump_bynumber (i, DEBUG_DUMP);
4608 else if (do_debug_frames && streq (name, ".eh_frame"))
4609 request_dump_bynumber (i, DEBUG_DUMP);
4610 else if (do_gdb_index && streq (name, ".gdb_index"))
4611 request_dump_bynumber (i, DEBUG_DUMP);
4612 /* Trace sections for Itanium VMS. */
4613 else if ((do_debugging || do_trace_info || do_trace_abbrevs
4614 || do_trace_aranges)
4615 && const_strneq (name, ".trace_"))
4617 name += sizeof (".trace_") - 1;
4620 || (do_trace_info && streq (name, "info"))
4621 || (do_trace_abbrevs && streq (name, "abbrev"))
4622 || (do_trace_aranges && streq (name, "aranges"))
4624 request_dump_bynumber (i, DEBUG_DUMP);
4632 if (elf_header.e_shnum > 1)
4633 printf (_("\nSection Headers:\n"));
4635 printf (_("\nSection Header:\n"));
4639 if (do_section_details)
4641 printf (_(" [Nr] Name\n"));
4642 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
4646 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
4650 if (do_section_details)
4652 printf (_(" [Nr] Name\n"));
4653 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
4657 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
4661 if (do_section_details)
4663 printf (_(" [Nr] Name\n"));
4664 printf (_(" Type Address Offset Link\n"));
4665 printf (_(" Size EntSize Info Align\n"));
4669 printf (_(" [Nr] Name Type Address Offset\n"));
4670 printf (_(" Size EntSize Flags Link Info Align\n"));
4674 if (do_section_details)
4675 printf (_(" Flags\n"));
4677 for (i = 0, section = section_headers;
4678 i < elf_header.e_shnum;
4681 if (do_section_details)
4683 printf (" [%2u] %s\n",
4685 SECTION_NAME (section));
4686 if (is_32bit_elf || do_wide)
4687 printf (" %-15.15s ",
4688 get_section_type_name (section->sh_type));
4691 printf ((do_wide ? " [%2u] %-17s %-15s "
4692 : " [%2u] %-17.17s %-15.15s "),
4694 SECTION_NAME (section),
4695 get_section_type_name (section->sh_type));
4699 const char * link_too_big = NULL;
4701 print_vma (section->sh_addr, LONG_HEX);
4703 printf ( " %6.6lx %6.6lx %2.2lx",
4704 (unsigned long) section->sh_offset,
4705 (unsigned long) section->sh_size,
4706 (unsigned long) section->sh_entsize);
4708 if (do_section_details)
4709 fputs (" ", stdout);
4711 printf (" %3s ", get_elf_section_flags (section->sh_flags));
4713 if (section->sh_link >= elf_header.e_shnum)
4716 /* The sh_link value is out of range. Normally this indicates
4717 an error but it can have special values in Solaris binaries. */
4718 switch (elf_header.e_machine)
4724 case EM_OLD_SPARCV9:
4725 case EM_SPARC32PLUS:
4728 if (section->sh_link == (SHN_BEFORE & 0xffff))
4729 link_too_big = "BEFORE";
4730 else if (section->sh_link == (SHN_AFTER & 0xffff))
4731 link_too_big = "AFTER";
4738 if (do_section_details)
4740 if (link_too_big != NULL && * link_too_big)
4741 printf ("<%s> ", link_too_big);
4743 printf ("%2u ", section->sh_link);
4744 printf ("%3u %2lu\n", section->sh_info,
4745 (unsigned long) section->sh_addralign);
4748 printf ("%2u %3u %2lu\n",
4751 (unsigned long) section->sh_addralign);
4753 if (link_too_big && ! * link_too_big)
4754 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
4755 i, section->sh_link);
4759 print_vma (section->sh_addr, LONG_HEX);
4761 if ((long) section->sh_offset == section->sh_offset)
4762 printf (" %6.6lx", (unsigned long) section->sh_offset);
4766 print_vma (section->sh_offset, LONG_HEX);
4769 if ((unsigned long) section->sh_size == section->sh_size)
4770 printf (" %6.6lx", (unsigned long) section->sh_size);
4774 print_vma (section->sh_size, LONG_HEX);
4777 if ((unsigned long) section->sh_entsize == section->sh_entsize)
4778 printf (" %2.2lx", (unsigned long) section->sh_entsize);
4782 print_vma (section->sh_entsize, LONG_HEX);
4785 if (do_section_details)
4786 fputs (" ", stdout);
4788 printf (" %3s ", get_elf_section_flags (section->sh_flags));
4790 printf ("%2u %3u ", section->sh_link, section->sh_info);
4792 if ((unsigned long) section->sh_addralign == section->sh_addralign)
4793 printf ("%2lu\n", (unsigned long) section->sh_addralign);
4796 print_vma (section->sh_addralign, DEC);
4800 else if (do_section_details)
4802 printf (" %-15.15s ",
4803 get_section_type_name (section->sh_type));
4804 print_vma (section->sh_addr, LONG_HEX);
4805 if ((long) section->sh_offset == section->sh_offset)
4806 printf (" %16.16lx", (unsigned long) section->sh_offset);
4810 print_vma (section->sh_offset, LONG_HEX);
4812 printf (" %u\n ", section->sh_link);
4813 print_vma (section->sh_size, LONG_HEX);
4815 print_vma (section->sh_entsize, LONG_HEX);
4817 printf (" %-16u %lu\n",
4819 (unsigned long) section->sh_addralign);
4824 print_vma (section->sh_addr, LONG_HEX);
4825 if ((long) section->sh_offset == section->sh_offset)
4826 printf (" %8.8lx", (unsigned long) section->sh_offset);
4830 print_vma (section->sh_offset, LONG_HEX);
4833 print_vma (section->sh_size, LONG_HEX);
4835 print_vma (section->sh_entsize, LONG_HEX);
4837 printf (" %3s ", get_elf_section_flags (section->sh_flags));
4839 printf (" %2u %3u %lu\n",
4842 (unsigned long) section->sh_addralign);
4845 if (do_section_details)
4846 printf (" %s\n", get_elf_section_flags (section->sh_flags));
4849 if (!do_section_details)
4851 if (elf_header.e_machine == EM_X86_64
4852 || elf_header.e_machine == EM_L1OM)
4853 printf (_("Key to Flags:\n\
4854 W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
4855 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
4856 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
4858 printf (_("Key to Flags:\n\
4859 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
4860 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
4861 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
4868 get_group_flags (unsigned int flags)
4870 static char buff[32];
4880 snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x] "), flags);
4887 process_section_groups (FILE * file)
4889 Elf_Internal_Shdr * section;
4891 struct group * group;
4892 Elf_Internal_Shdr * symtab_sec;
4893 Elf_Internal_Shdr * strtab_sec;
4894 Elf_Internal_Sym * symtab;
4898 /* Don't process section groups unless needed. */
4899 if (!do_unwind && !do_section_groups)
4902 if (elf_header.e_shnum == 0)
4904 if (do_section_groups)
4905 printf (_("\nThere are no sections to group in this file.\n"));
4910 if (section_headers == NULL)
4912 error (_("Section headers are not available!\n"));
4916 section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
4917 sizeof (struct group *));
4919 if (section_headers_groups == NULL)
4921 error (_("Out of memory\n"));
4925 /* Scan the sections for the group section. */
4927 for (i = 0, section = section_headers;
4928 i < elf_header.e_shnum;
4930 if (section->sh_type == SHT_GROUP)
4933 if (group_count == 0)
4935 if (do_section_groups)
4936 printf (_("\nThere are no section groups in this file.\n"));
4941 section_groups = (struct group *) calloc (group_count, sizeof (struct group));
4943 if (section_groups == NULL)
4945 error (_("Out of memory\n"));
4954 for (i = 0, section = section_headers, group = section_groups;
4955 i < elf_header.e_shnum;
4958 if (section->sh_type == SHT_GROUP)
4960 char * name = SECTION_NAME (section);
4962 unsigned char * start;
4963 unsigned char * indices;
4964 unsigned int entry, j, size;
4965 Elf_Internal_Shdr * sec;
4966 Elf_Internal_Sym * sym;
4968 /* Get the symbol table. */
4969 if (section->sh_link >= elf_header.e_shnum
4970 || ((sec = section_headers + section->sh_link)->sh_type
4973 error (_("Bad sh_link in group section `%s'\n"), name);
4977 if (symtab_sec != sec)
4982 symtab = GET_ELF_SYMBOLS (file, symtab_sec);
4987 error (_("Corrupt header in group section `%s'\n"), name);
4991 sym = symtab + section->sh_info;
4993 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
4995 if (sym->st_shndx == 0
4996 || sym->st_shndx >= elf_header.e_shnum)
4998 error (_("Bad sh_info in group section `%s'\n"), name);
5002 group_name = SECTION_NAME (section_headers + sym->st_shndx);
5011 /* Get the string table. */
5012 if (symtab_sec->sh_link >= elf_header.e_shnum)
5021 != (sec = section_headers + symtab_sec->sh_link))
5026 strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
5027 1, strtab_sec->sh_size,
5029 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
5031 group_name = sym->st_name < strtab_size
5032 ? strtab + sym->st_name : _("<corrupt>");
5035 start = (unsigned char *) get_data (NULL, file, section->sh_offset,
5036 1, section->sh_size,
5042 size = (section->sh_size / section->sh_entsize) - 1;
5043 entry = byte_get (indices, 4);
5046 if (do_section_groups)
5048 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
5049 get_group_flags (entry), i, name, group_name, size);
5051 printf (_(" [Index] Name\n"));
5054 group->group_index = i;
5056 for (j = 0; j < size; j++)
5058 struct group_list * g;
5060 entry = byte_get (indices, 4);
5063 if (entry >= elf_header.e_shnum)
5065 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
5066 entry, i, elf_header.e_shnum - 1);
5070 if (section_headers_groups [entry] != NULL)
5074 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
5076 section_headers_groups [entry]->group_index);
5081 /* Intel C/C++ compiler may put section 0 in a
5082 section group. We just warn it the first time
5083 and ignore it afterwards. */
5084 static int warned = 0;
5087 error (_("section 0 in group section [%5u]\n"),
5088 section_headers_groups [entry]->group_index);
5094 section_headers_groups [entry] = group;
5096 if (do_section_groups)
5098 sec = section_headers + entry;
5099 printf (" [%5u] %s\n", entry, SECTION_NAME (sec));
5102 g = (struct group_list *) xmalloc (sizeof (struct group_list));
5103 g->section_index = entry;
5104 g->next = group->root;
5122 /* Data used to display dynamic fixups. */
5124 struct ia64_vms_dynfixup
5126 bfd_vma needed_ident; /* Library ident number. */
5127 bfd_vma needed; /* Index in the dstrtab of the library name. */
5128 bfd_vma fixup_needed; /* Index of the library. */
5129 bfd_vma fixup_rela_cnt; /* Number of fixups. */
5130 bfd_vma fixup_rela_off; /* Fixups offset in the dynamic segment. */
5133 /* Data used to display dynamic relocations. */
5135 struct ia64_vms_dynimgrela
5137 bfd_vma img_rela_cnt; /* Number of relocations. */
5138 bfd_vma img_rela_off; /* Reloc offset in the dynamic segment. */
5141 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
5145 dump_ia64_vms_dynamic_fixups (FILE *file, struct ia64_vms_dynfixup *fixup,
5146 const char *strtab, unsigned int strtab_sz)
5148 Elf64_External_VMS_IMAGE_FIXUP *imfs;
5150 const char *lib_name;
5152 imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
5153 1, fixup->fixup_rela_cnt * sizeof (*imfs),
5154 _("dynamic section image fixups"));
5158 if (fixup->needed < strtab_sz)
5159 lib_name = strtab + fixup->needed;
5162 warn ("corrupt library name index of 0x%lx found in dynamic entry",
5163 (unsigned long) fixup->needed);
5166 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
5167 (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
5169 (_("Seg Offset Type SymVec DataType\n"));
5171 for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
5176 printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
5177 printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
5178 type = BYTE_GET (imfs [i].type);
5179 rtype = elf_ia64_reloc_type (type);
5181 printf (" 0x%08x ", type);
5183 printf (" %-32s ", rtype);
5184 printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
5185 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
5191 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
5194 dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
5196 Elf64_External_VMS_IMAGE_RELA *imrs;
5199 imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
5200 1, imgrela->img_rela_cnt * sizeof (*imrs),
5201 _("dynamic section image relas"));
5205 printf (_("\nImage relocs\n"));
5207 (_("Seg Offset Type Addend Seg Sym Off\n"));
5209 for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
5214 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
5215 printf ("%08" BFD_VMA_FMT "x ",
5216 (bfd_vma) BYTE_GET (imrs [i].rela_offset));
5217 type = BYTE_GET (imrs [i].type);
5218 rtype = elf_ia64_reloc_type (type);
5220 printf ("0x%08x ", type);
5222 printf ("%-31s ", rtype);
5223 print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
5224 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
5225 printf ("%08" BFD_VMA_FMT "x\n",
5226 (bfd_vma) BYTE_GET (imrs [i].sym_offset));
5232 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
5235 process_ia64_vms_dynamic_relocs (FILE *file)
5237 struct ia64_vms_dynfixup fixup;
5238 struct ia64_vms_dynimgrela imgrela;
5239 Elf_Internal_Dyn *entry;
5241 bfd_vma strtab_off = 0;
5242 bfd_vma strtab_sz = 0;
5243 char *strtab = NULL;
5245 memset (&fixup, 0, sizeof (fixup));
5246 memset (&imgrela, 0, sizeof (imgrela));
5248 /* Note: the order of the entries is specified by the OpenVMS specs. */
5249 for (entry = dynamic_section;
5250 entry < dynamic_section + dynamic_nent;
5253 switch (entry->d_tag)
5255 case DT_IA_64_VMS_STRTAB_OFFSET:
5256 strtab_off = entry->d_un.d_val;
5259 strtab_sz = entry->d_un.d_val;
5261 strtab = get_data (NULL, file, dynamic_addr + strtab_off,
5262 1, strtab_sz, _("dynamic string section"));
5265 case DT_IA_64_VMS_NEEDED_IDENT:
5266 fixup.needed_ident = entry->d_un.d_val;
5269 fixup.needed = entry->d_un.d_val;
5271 case DT_IA_64_VMS_FIXUP_NEEDED:
5272 fixup.fixup_needed = entry->d_un.d_val;
5274 case DT_IA_64_VMS_FIXUP_RELA_CNT:
5275 fixup.fixup_rela_cnt = entry->d_un.d_val;
5277 case DT_IA_64_VMS_FIXUP_RELA_OFF:
5278 fixup.fixup_rela_off = entry->d_un.d_val;
5280 dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz);
5283 case DT_IA_64_VMS_IMG_RELA_CNT:
5284 imgrela.img_rela_cnt = entry->d_un.d_val;
5286 case DT_IA_64_VMS_IMG_RELA_OFF:
5287 imgrela.img_rela_off = entry->d_un.d_val;
5289 dump_ia64_vms_dynamic_relocs (file, &imgrela);
5309 } dynamic_relocations [] =
5311 { "REL", DT_REL, DT_RELSZ, FALSE },
5312 { "RELA", DT_RELA, DT_RELASZ, TRUE },
5313 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
5316 /* Process the reloc section. */
5319 process_relocs (FILE * file)
5321 unsigned long rel_size;
5322 unsigned long rel_offset;
5328 if (do_using_dynamic)
5332 int has_dynamic_reloc;
5335 has_dynamic_reloc = 0;
5337 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
5339 is_rela = dynamic_relocations [i].rela;
5340 name = dynamic_relocations [i].name;
5341 rel_size = dynamic_info [dynamic_relocations [i].size];
5342 rel_offset = dynamic_info [dynamic_relocations [i].reloc];
5344 has_dynamic_reloc |= rel_size;
5346 if (is_rela == UNKNOWN)
5348 if (dynamic_relocations [i].reloc == DT_JMPREL)
5349 switch (dynamic_info[DT_PLTREL])
5363 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
5364 name, rel_offset, rel_size);
5366 dump_relocations (file,
5367 offset_from_vma (file, rel_offset, rel_size),
5369 dynamic_symbols, num_dynamic_syms,
5370 dynamic_strings, dynamic_strings_length, is_rela);
5375 has_dynamic_reloc |= process_ia64_vms_dynamic_relocs (file);
5377 if (! has_dynamic_reloc)
5378 printf (_("\nThere are no dynamic relocations in this file.\n"));
5382 Elf_Internal_Shdr * section;
5386 for (i = 0, section = section_headers;
5387 i < elf_header.e_shnum;
5390 if ( section->sh_type != SHT_RELA
5391 && section->sh_type != SHT_REL)
5394 rel_offset = section->sh_offset;
5395 rel_size = section->sh_size;
5399 Elf_Internal_Shdr * strsec;
5402 printf (_("\nRelocation section "));
5404 if (string_table == NULL)
5405 printf ("%d", section->sh_name);
5407 printf (_("'%s'"), SECTION_NAME (section));
5409 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5410 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
5412 is_rela = section->sh_type == SHT_RELA;
5414 if (section->sh_link != 0
5415 && section->sh_link < elf_header.e_shnum)
5417 Elf_Internal_Shdr * symsec;
5418 Elf_Internal_Sym * symtab;
5419 unsigned long nsyms;
5420 unsigned long strtablen = 0;
5421 char * strtab = NULL;
5423 symsec = section_headers + section->sh_link;
5424 if (symsec->sh_type != SHT_SYMTAB
5425 && symsec->sh_type != SHT_DYNSYM)
5428 nsyms = symsec->sh_size / symsec->sh_entsize;
5429 symtab = GET_ELF_SYMBOLS (file, symsec);
5434 if (symsec->sh_link != 0
5435 && symsec->sh_link < elf_header.e_shnum)
5437 strsec = section_headers + symsec->sh_link;
5439 strtab = (char *) get_data (NULL, file, strsec->sh_offset,
5442 strtablen = strtab == NULL ? 0 : strsec->sh_size;
5445 dump_relocations (file, rel_offset, rel_size,
5446 symtab, nsyms, strtab, strtablen, is_rela);
5452 dump_relocations (file, rel_offset, rel_size,
5453 NULL, 0, NULL, 0, is_rela);
5460 printf (_("\nThere are no relocations in this file.\n"));
5466 /* Process the unwind section. */
5468 #include "unwind-ia64.h"
5470 /* An absolute address consists of a section and an offset. If the
5471 section is NULL, the offset itself is the address, otherwise, the
5472 address equals to LOAD_ADDRESS(section) + offset. */
5476 unsigned short section;
5480 #define ABSADDR(a) \
5482 ? section_headers [(a).section].sh_addr + (a).offset \
5485 struct ia64_unw_table_entry
5487 struct absaddr start;
5489 struct absaddr info;
5492 struct ia64_unw_aux_info
5495 struct ia64_unw_table_entry *table; /* Unwind table. */
5496 unsigned long table_len; /* Length of unwind table. */
5497 unsigned char * info; /* Unwind info. */
5498 unsigned long info_size; /* Size of unwind info. */
5499 bfd_vma info_addr; /* starting address of unwind info. */
5500 bfd_vma seg_base; /* Starting address of segment. */
5501 Elf_Internal_Sym * symtab; /* The symbol table. */
5502 unsigned long nsyms; /* Number of symbols. */
5503 char * strtab; /* The string table. */
5504 unsigned long strtab_size; /* Size of string table. */
5508 find_symbol_for_address (Elf_Internal_Sym * symtab,
5509 unsigned long nsyms,
5510 const char * strtab,
5511 unsigned long strtab_size,
5512 struct absaddr addr,
5513 const char ** symname,
5516 bfd_vma dist = 0x100000;
5517 Elf_Internal_Sym * sym;
5518 Elf_Internal_Sym * best = NULL;
5521 REMOVE_ARCH_BITS (addr.offset);
5523 for (i = 0, sym = symtab; i < nsyms; ++i, ++sym)
5525 bfd_vma value = sym->st_value;
5527 REMOVE_ARCH_BITS (value);
5529 if (ELF_ST_TYPE (sym->st_info) == STT_FUNC
5530 && sym->st_name != 0
5531 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
5532 && addr.offset >= value
5533 && addr.offset - value < dist)
5536 dist = addr.offset - value;
5543 *symname = (best->st_name >= strtab_size
5544 ? _("<corrupt>") : strtab + best->st_name);
5549 *offset = addr.offset;
5553 dump_ia64_unwind (struct ia64_unw_aux_info * aux)
5555 struct ia64_unw_table_entry * tp;
5558 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
5562 const unsigned char * dp;
5563 const unsigned char * head;
5564 const char * procname;
5566 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
5567 aux->strtab_size, tp->start, &procname, &offset);
5569 fputs ("\n<", stdout);
5573 fputs (procname, stdout);
5576 printf ("+%lx", (unsigned long) offset);
5579 fputs (">: [", stdout);
5580 print_vma (tp->start.offset, PREFIX_HEX);
5581 fputc ('-', stdout);
5582 print_vma (tp->end.offset, PREFIX_HEX);
5583 printf ("], info at +0x%lx\n",
5584 (unsigned long) (tp->info.offset - aux->seg_base));
5586 head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
5587 stamp = byte_get ((unsigned char *) head, sizeof (stamp));
5589 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
5590 (unsigned) UNW_VER (stamp),
5591 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
5592 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
5593 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
5594 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
5596 if (UNW_VER (stamp) != 1)
5598 printf (_("\tUnknown version.\n"));
5603 for (dp = head + 8; dp < head + 8 + eh_addr_size * UNW_LENGTH (stamp);)
5604 dp = unw_decode (dp, in_body, & in_body);
5609 slurp_ia64_unwind_table (FILE * file,
5610 struct ia64_unw_aux_info * aux,
5611 Elf_Internal_Shdr * sec)
5613 unsigned long size, nrelas, i;
5614 Elf_Internal_Phdr * seg;
5615 struct ia64_unw_table_entry * tep;
5616 Elf_Internal_Shdr * relsec;
5617 Elf_Internal_Rela * rela;
5618 Elf_Internal_Rela * rp;
5619 unsigned char * table;
5621 Elf_Internal_Sym * sym;
5622 const char * relname;
5624 /* First, find the starting address of the segment that includes
5627 if (elf_header.e_phnum)
5629 if (! get_program_headers (file))
5632 for (seg = program_headers;
5633 seg < program_headers + elf_header.e_phnum;
5636 if (seg->p_type != PT_LOAD)
5639 if (sec->sh_addr >= seg->p_vaddr
5640 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
5642 aux->seg_base = seg->p_vaddr;
5648 /* Second, build the unwind table from the contents of the unwind section: */
5649 size = sec->sh_size;
5650 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
5655 aux->table = (struct ia64_unw_table_entry *)
5656 xcmalloc (size / (3 * eh_addr_size), sizeof (aux->table[0]));
5658 for (tp = table; tp < table + size; ++tep)
5660 tep->start.section = SHN_UNDEF;
5661 tep->end.section = SHN_UNDEF;
5662 tep->info.section = SHN_UNDEF;
5663 tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
5664 tep->end.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
5665 tep->info.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
5666 tep->start.offset += aux->seg_base;
5667 tep->end.offset += aux->seg_base;
5668 tep->info.offset += aux->seg_base;
5672 /* Third, apply any relocations to the unwind table: */
5673 for (relsec = section_headers;
5674 relsec < section_headers + elf_header.e_shnum;
5677 if (relsec->sh_type != SHT_RELA
5678 || relsec->sh_info >= elf_header.e_shnum
5679 || section_headers + relsec->sh_info != sec)
5682 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
5686 for (rp = rela; rp < rela + nrelas; ++rp)
5688 relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
5689 sym = aux->symtab + get_reloc_symindex (rp->r_info);
5691 if (! const_strneq (relname, "R_IA64_SEGREL"))
5693 warn (_("Skipping unexpected relocation type %s\n"), relname);
5697 i = rp->r_offset / (3 * eh_addr_size);
5699 switch (rp->r_offset/eh_addr_size % 3)
5702 aux->table[i].start.section = sym->st_shndx;
5703 aux->table[i].start.offset = rp->r_addend + sym->st_value;
5706 aux->table[i].end.section = sym->st_shndx;
5707 aux->table[i].end.offset = rp->r_addend + sym->st_value;
5710 aux->table[i].info.section = sym->st_shndx;
5711 aux->table[i].info.offset = rp->r_addend + sym->st_value;
5721 aux->table_len = size / (3 * eh_addr_size);
5726 ia64_process_unwind (FILE * file)
5728 Elf_Internal_Shdr * sec;
5729 Elf_Internal_Shdr * unwsec = NULL;
5730 Elf_Internal_Shdr * strsec;
5731 unsigned long i, unwcount = 0, unwstart = 0;
5732 struct ia64_unw_aux_info aux;
5734 memset (& aux, 0, sizeof (aux));
5736 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
5738 if (sec->sh_type == SHT_SYMTAB
5739 && sec->sh_link < elf_header.e_shnum)
5741 aux.nsyms = sec->sh_size / sec->sh_entsize;
5742 aux.symtab = GET_ELF_SYMBOLS (file, sec);
5744 strsec = section_headers + sec->sh_link;
5745 assert (aux.strtab == NULL);
5746 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
5749 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
5751 else if (sec->sh_type == SHT_IA_64_UNWIND)
5756 printf (_("\nThere are no unwind sections in this file.\n"));
5758 while (unwcount-- > 0)
5763 for (i = unwstart, sec = section_headers + unwstart;
5764 i < elf_header.e_shnum; ++i, ++sec)
5765 if (sec->sh_type == SHT_IA_64_UNWIND)
5772 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
5774 if ((unwsec->sh_flags & SHF_GROUP) != 0)
5776 /* We need to find which section group it is in. */
5777 struct group_list * g = section_headers_groups [i]->root;
5779 for (; g != NULL; g = g->next)
5781 sec = section_headers + g->section_index;
5783 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
5788 i = elf_header.e_shnum;
5790 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
5792 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
5793 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
5794 suffix = SECTION_NAME (unwsec) + len;
5795 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
5797 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
5798 && streq (SECTION_NAME (sec) + len2, suffix))
5803 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
5804 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
5805 len = sizeof (ELF_STRING_ia64_unwind) - 1;
5806 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
5808 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
5809 suffix = SECTION_NAME (unwsec) + len;
5810 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
5812 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
5813 && streq (SECTION_NAME (sec) + len2, suffix))
5817 if (i == elf_header.e_shnum)
5819 printf (_("\nCould not find unwind info section for "));
5821 if (string_table == NULL)
5822 printf ("%d", unwsec->sh_name);
5824 printf (_("'%s'"), SECTION_NAME (unwsec));
5828 aux.info_addr = sec->sh_addr;
5829 aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
5832 aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
5834 printf (_("\nUnwind section "));
5836 if (string_table == NULL)
5837 printf ("%d", unwsec->sh_name);
5839 printf (_("'%s'"), SECTION_NAME (unwsec));
5841 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5842 (unsigned long) unwsec->sh_offset,
5843 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
5845 (void) slurp_ia64_unwind_table (file, & aux, unwsec);
5847 if (aux.table_len > 0)
5848 dump_ia64_unwind (& aux);
5851 free ((char *) aux.table);
5853 free ((char *) aux.info);
5862 free ((char *) aux.strtab);
5867 struct hppa_unw_table_entry
5869 struct absaddr start;
5871 unsigned int Cannot_unwind:1; /* 0 */
5872 unsigned int Millicode:1; /* 1 */
5873 unsigned int Millicode_save_sr0:1; /* 2 */
5874 unsigned int Region_description:2; /* 3..4 */
5875 unsigned int reserved1:1; /* 5 */
5876 unsigned int Entry_SR:1; /* 6 */
5877 unsigned int Entry_FR:4; /* number saved */ /* 7..10 */
5878 unsigned int Entry_GR:5; /* number saved */ /* 11..15 */
5879 unsigned int Args_stored:1; /* 16 */
5880 unsigned int Variable_Frame:1; /* 17 */
5881 unsigned int Separate_Package_Body:1; /* 18 */
5882 unsigned int Frame_Extension_Millicode:1; /* 19 */
5883 unsigned int Stack_Overflow_Check:1; /* 20 */
5884 unsigned int Two_Instruction_SP_Increment:1; /* 21 */
5885 unsigned int Ada_Region:1; /* 22 */
5886 unsigned int cxx_info:1; /* 23 */
5887 unsigned int cxx_try_catch:1; /* 24 */
5888 unsigned int sched_entry_seq:1; /* 25 */
5889 unsigned int reserved2:1; /* 26 */
5890 unsigned int Save_SP:1; /* 27 */
5891 unsigned int Save_RP:1; /* 28 */
5892 unsigned int Save_MRP_in_frame:1; /* 29 */
5893 unsigned int extn_ptr_defined:1; /* 30 */
5894 unsigned int Cleanup_defined:1; /* 31 */
5896 unsigned int MPE_XL_interrupt_marker:1; /* 0 */
5897 unsigned int HP_UX_interrupt_marker:1; /* 1 */
5898 unsigned int Large_frame:1; /* 2 */
5899 unsigned int Pseudo_SP_Set:1; /* 3 */
5900 unsigned int reserved4:1; /* 4 */
5901 unsigned int Total_frame_size:27; /* 5..31 */
5904 struct hppa_unw_aux_info
5906 struct hppa_unw_table_entry *table; /* Unwind table. */
5907 unsigned long table_len; /* Length of unwind table. */
5908 bfd_vma seg_base; /* Starting address of segment. */
5909 Elf_Internal_Sym * symtab; /* The symbol table. */
5910 unsigned long nsyms; /* Number of symbols. */
5911 char * strtab; /* The string table. */
5912 unsigned long strtab_size; /* Size of string table. */
5916 dump_hppa_unwind (struct hppa_unw_aux_info * aux)
5918 struct hppa_unw_table_entry * tp;
5920 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
5923 const char * procname;
5925 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
5926 aux->strtab_size, tp->start, &procname,
5929 fputs ("\n<", stdout);
5933 fputs (procname, stdout);
5936 printf ("+%lx", (unsigned long) offset);
5939 fputs (">: [", stdout);
5940 print_vma (tp->start.offset, PREFIX_HEX);
5941 fputc ('-', stdout);
5942 print_vma (tp->end.offset, PREFIX_HEX);
5945 #define PF(_m) if (tp->_m) printf (#_m " ");
5946 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
5949 PF(Millicode_save_sr0);
5950 /* PV(Region_description); */
5956 PF(Separate_Package_Body);
5957 PF(Frame_Extension_Millicode);
5958 PF(Stack_Overflow_Check);
5959 PF(Two_Instruction_SP_Increment);
5963 PF(sched_entry_seq);
5966 PF(Save_MRP_in_frame);
5967 PF(extn_ptr_defined);
5968 PF(Cleanup_defined);
5969 PF(MPE_XL_interrupt_marker);
5970 PF(HP_UX_interrupt_marker);
5973 PV(Total_frame_size);
5982 slurp_hppa_unwind_table (FILE * file,
5983 struct hppa_unw_aux_info * aux,
5984 Elf_Internal_Shdr * sec)
5986 unsigned long size, unw_ent_size, nentries, nrelas, i;
5987 Elf_Internal_Phdr * seg;
5988 struct hppa_unw_table_entry * tep;
5989 Elf_Internal_Shdr * relsec;
5990 Elf_Internal_Rela * rela;
5991 Elf_Internal_Rela * rp;
5992 unsigned char * table;
5994 Elf_Internal_Sym * sym;
5995 const char * relname;
5997 /* First, find the starting address of the segment that includes
6000 if (elf_header.e_phnum)
6002 if (! get_program_headers (file))
6005 for (seg = program_headers;
6006 seg < program_headers + elf_header.e_phnum;
6009 if (seg->p_type != PT_LOAD)
6012 if (sec->sh_addr >= seg->p_vaddr
6013 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
6015 aux->seg_base = seg->p_vaddr;
6021 /* Second, build the unwind table from the contents of the unwind
6023 size = sec->sh_size;
6024 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
6030 nentries = size / unw_ent_size;
6031 size = unw_ent_size * nentries;
6033 tep = aux->table = (struct hppa_unw_table_entry *)
6034 xcmalloc (nentries, sizeof (aux->table[0]));
6036 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
6038 unsigned int tmp1, tmp2;
6040 tep->start.section = SHN_UNDEF;
6041 tep->end.section = SHN_UNDEF;
6043 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
6044 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
6045 tmp1 = byte_get ((unsigned char *) tp + 8, 4);
6046 tmp2 = byte_get ((unsigned char *) tp + 12, 4);
6048 tep->start.offset += aux->seg_base;
6049 tep->end.offset += aux->seg_base;
6051 tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
6052 tep->Millicode = (tmp1 >> 30) & 0x1;
6053 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
6054 tep->Region_description = (tmp1 >> 27) & 0x3;
6055 tep->reserved1 = (tmp1 >> 26) & 0x1;
6056 tep->Entry_SR = (tmp1 >> 25) & 0x1;
6057 tep->Entry_FR = (tmp1 >> 21) & 0xf;
6058 tep->Entry_GR = (tmp1 >> 16) & 0x1f;
6059 tep->Args_stored = (tmp1 >> 15) & 0x1;
6060 tep->Variable_Frame = (tmp1 >> 14) & 0x1;
6061 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
6062 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
6063 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
6064 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
6065 tep->Ada_Region = (tmp1 >> 9) & 0x1;
6066 tep->cxx_info = (tmp1 >> 8) & 0x1;
6067 tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
6068 tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
6069 tep->reserved2 = (tmp1 >> 5) & 0x1;
6070 tep->Save_SP = (tmp1 >> 4) & 0x1;
6071 tep->Save_RP = (tmp1 >> 3) & 0x1;
6072 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
6073 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
6074 tep->Cleanup_defined = tmp1 & 0x1;
6076 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
6077 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
6078 tep->Large_frame = (tmp2 >> 29) & 0x1;
6079 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
6080 tep->reserved4 = (tmp2 >> 27) & 0x1;
6081 tep->Total_frame_size = tmp2 & 0x7ffffff;
6085 /* Third, apply any relocations to the unwind table. */
6086 for (relsec = section_headers;
6087 relsec < section_headers + elf_header.e_shnum;
6090 if (relsec->sh_type != SHT_RELA
6091 || relsec->sh_info >= elf_header.e_shnum
6092 || section_headers + relsec->sh_info != sec)
6095 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6099 for (rp = rela; rp < rela + nrelas; ++rp)
6101 relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
6102 sym = aux->symtab + get_reloc_symindex (rp->r_info);
6104 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
6105 if (! const_strneq (relname, "R_PARISC_SEGREL"))
6107 warn (_("Skipping unexpected relocation type %s\n"), relname);
6111 i = rp->r_offset / unw_ent_size;
6113 switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
6116 aux->table[i].start.section = sym->st_shndx;
6117 aux->table[i].start.offset = sym->st_value + rp->r_addend;
6120 aux->table[i].end.section = sym->st_shndx;
6121 aux->table[i].end.offset = sym->st_value + rp->r_addend;
6131 aux->table_len = nentries;
6137 hppa_process_unwind (FILE * file)
6139 struct hppa_unw_aux_info aux;
6140 Elf_Internal_Shdr * unwsec = NULL;
6141 Elf_Internal_Shdr * strsec;
6142 Elf_Internal_Shdr * sec;
6145 memset (& aux, 0, sizeof (aux));
6147 if (string_table == NULL)
6150 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6152 if (sec->sh_type == SHT_SYMTAB
6153 && sec->sh_link < elf_header.e_shnum)
6155 aux.nsyms = sec->sh_size / sec->sh_entsize;
6156 aux.symtab = GET_ELF_SYMBOLS (file, sec);
6158 strsec = section_headers + sec->sh_link;
6159 assert (aux.strtab == NULL);
6160 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6163 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
6165 else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
6170 printf (_("\nThere are no unwind sections in this file.\n"));
6172 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6174 if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
6176 printf (_("\nUnwind section "));
6177 printf (_("'%s'"), SECTION_NAME (sec));
6179 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6180 (unsigned long) sec->sh_offset,
6181 (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
6183 slurp_hppa_unwind_table (file, &aux, sec);
6184 if (aux.table_len > 0)
6185 dump_hppa_unwind (&aux);
6188 free ((char *) aux.table);
6196 free ((char *) aux.strtab);
6203 unsigned char *data;
6205 Elf_Internal_Shdr *sec;
6206 Elf_Internal_Rela *rela;
6207 unsigned long nrelas;
6208 unsigned int rel_type;
6210 Elf_Internal_Rela *next_rela;
6213 struct arm_unw_aux_info
6217 Elf_Internal_Sym *symtab; /* The symbol table. */
6218 unsigned long nsyms; /* Number of symbols. */
6219 char *strtab; /* The string table. */
6220 unsigned long strtab_size; /* Size of string table. */
6224 arm_print_vma_and_name (struct arm_unw_aux_info *aux,
6225 bfd_vma fn, struct absaddr addr)
6227 const char *procname;
6230 if (addr.section == SHN_UNDEF)
6233 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6234 aux->strtab_size, addr, &procname,
6237 print_vma (fn, PREFIX_HEX);
6241 fputs (" <", stdout);
6242 fputs (procname, stdout);
6245 printf ("+0x%lx", (unsigned long) sym_offset);
6246 fputc ('>', stdout);
6253 arm_free_section (struct arm_section *arm_sec)
6255 if (arm_sec->data != NULL)
6256 free (arm_sec->data);
6258 if (arm_sec->rela != NULL)
6259 free (arm_sec->rela);
6263 arm_section_get_word (struct arm_unw_aux_info *aux,
6264 struct arm_section *arm_sec,
6265 Elf_Internal_Shdr *sec, bfd_vma word_offset,
6266 unsigned int *wordp, struct absaddr *addr)
6268 Elf_Internal_Rela *rp;
6269 Elf_Internal_Sym *sym;
6270 const char * relname;
6272 bfd_boolean wrapped;
6274 addr->section = SHN_UNDEF;
6277 if (sec != arm_sec->sec)
6279 Elf_Internal_Shdr *relsec;
6281 arm_free_section (arm_sec);
6284 arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
6285 sec->sh_size, _("unwind data"));
6286 arm_sec->rela = NULL;
6287 arm_sec->nrelas = 0;
6289 for (relsec = section_headers;
6290 relsec < section_headers + elf_header.e_shnum;
6293 if (relsec->sh_info >= elf_header.e_shnum
6294 || section_headers + relsec->sh_info != sec)
6297 if (relsec->sh_type == SHT_REL)
6299 if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
6301 & arm_sec->rela, & arm_sec->nrelas))
6305 else if (relsec->sh_type == SHT_RELA)
6307 if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
6309 & arm_sec->rela, & arm_sec->nrelas))
6315 arm_sec->next_rela = arm_sec->rela;
6318 if (arm_sec->data == NULL)
6321 word = byte_get (arm_sec->data + word_offset, 4);
6324 for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
6326 bfd_vma prelval, offset;
6328 if (rp->r_offset > word_offset && !wrapped)
6333 if (rp->r_offset > word_offset)
6336 if (rp->r_offset & 3)
6338 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
6339 (unsigned long) rp->r_offset);
6343 if (rp->r_offset < word_offset)
6346 switch (elf_header.e_machine)
6349 relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
6353 relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
6360 if (streq (relname, "R_ARM_NONE")
6361 || streq (relname, "R_C6000_NONE"))
6364 if (!(streq (relname, "R_ARM_PREL31")
6365 || streq (relname, "R_C6000_PREL31")))
6367 warn (_("Skipping unexpected relocation type %s\n"), relname);
6371 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
6373 if (arm_sec->rel_type == SHT_REL)
6375 offset = word & 0x7fffffff;
6376 if (offset & 0x40000000)
6377 offset |= ~ (bfd_vma) 0x7fffffff;
6380 offset = rp->r_addend;
6382 offset += sym->st_value;
6383 prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
6385 if (streq (relname, "R_C6000_PREL31"))
6388 word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
6389 addr->section = sym->st_shndx;
6390 addr->offset = offset;
6395 arm_sec->next_rela = rp;
6400 static const char *tic6x_unwind_regnames[16] = {
6401 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
6402 "A14", "A13", "A12", "A11", "A10",
6403 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"};
6406 decode_tic6x_unwind_regmask (unsigned int mask)
6410 for (i = 12; mask; mask >>= 1, i--)
6414 fputs (tic6x_unwind_regnames[i], stdout);
6416 fputs (", ", stdout);
6422 if (remaining == 0 && more_words) \
6425 if (!arm_section_get_word (aux, data_arm_sec, data_sec, \
6426 data_offset, &word, &addr)) \
6432 #define GET_OP(OP) \
6437 (OP) = word >> 24; \
6442 printf (_("[Truncated opcode]\n")); \
6445 printf ("0x%02x ", OP)
6448 decode_arm_unwind_bytecode (struct arm_unw_aux_info *aux,
6449 unsigned int word, unsigned int remaining,
6450 unsigned int more_words,
6451 bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
6452 struct arm_section *data_arm_sec)
6454 struct absaddr addr;
6456 /* Decode the unwinding instructions. */
6459 unsigned int op, op2;
6468 printf (" 0x%02x ", op);
6470 if ((op & 0xc0) == 0x00)
6472 int offset = ((op & 0x3f) << 2) + 4;
6474 printf (" vsp = vsp + %d", offset);
6476 else if ((op & 0xc0) == 0x40)
6478 int offset = ((op & 0x3f) << 2) + 4;
6480 printf (" vsp = vsp - %d", offset);
6482 else if ((op & 0xf0) == 0x80)
6485 if (op == 0x80 && op2 == 0)
6486 printf (_("Refuse to unwind"));
6489 unsigned int mask = ((op & 0x0f) << 8) | op2;
6494 for (i = 0; i < 12; i++)
6495 if (mask & (1 << i))
6501 printf ("r%d", 4 + i);
6506 else if ((op & 0xf0) == 0x90)
6508 if (op == 0x9d || op == 0x9f)
6509 printf (_(" [Reserved]"));
6511 printf (" vsp = r%d", op & 0x0f);
6513 else if ((op & 0xf0) == 0xa0)
6515 int end = 4 + (op & 0x07);
6520 for (i = 4; i <= end; i++)
6536 else if (op == 0xb0)
6537 printf (_(" finish"));
6538 else if (op == 0xb1)
6541 if (op2 == 0 || (op2 & 0xf0) != 0)
6542 printf (_("[Spare]"));
6545 unsigned int mask = op2 & 0x0f;
6550 for (i = 0; i < 12; i++)
6551 if (mask & (1 << i))
6562 else if (op == 0xb2)
6564 unsigned char buf[9];
6565 unsigned int i, len;
6566 unsigned long offset;
6568 for (i = 0; i < sizeof (buf); i++)
6571 if ((buf[i] & 0x80) == 0)
6574 assert (i < sizeof (buf));
6575 offset = read_uleb128 (buf, &len);
6576 assert (len == i + 1);
6577 offset = offset * 4 + 0x204;
6578 printf ("vsp = vsp + %ld", offset);
6580 else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
6582 unsigned int first, last;
6589 printf ("pop {D%d", first);
6591 printf ("-D%d", first + last);
6594 else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
6596 unsigned int count = op & 0x07;
6600 printf ("-D%d", 8 + count);
6603 else if (op >= 0xc0 && op <= 0xc5)
6605 unsigned int count = op & 0x07;
6607 printf (" pop {wR10");
6609 printf ("-wR%d", 10 + count);
6612 else if (op == 0xc6)
6614 unsigned int first, last;
6619 printf ("pop {wR%d", first);
6621 printf ("-wR%d", first + last);
6624 else if (op == 0xc7)
6627 if (op2 == 0 || (op2 & 0xf0) != 0)
6628 printf (_("[Spare]"));
6631 unsigned int mask = op2 & 0x0f;
6636 for (i = 0; i < 4; i++)
6637 if (mask & (1 << i))
6643 printf ("wCGR%d", i);
6649 printf (_(" [unsupported opcode]"));
6655 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info *aux,
6656 unsigned int word, unsigned int remaining,
6657 unsigned int more_words,
6658 bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
6659 struct arm_section *data_arm_sec)
6661 struct absaddr addr;
6663 /* Decode the unwinding instructions. */
6666 unsigned int op, op2;
6675 printf (_(" 0x%02x "), op);
6677 if ((op & 0xc0) == 0x00)
6679 int offset = ((op & 0x3f) << 3) + 8;
6680 printf (_(" sp = sp + %d"), offset);
6682 else if ((op & 0xc0) == 0x80)
6685 if (op == 0x80 && op2 == 0)
6686 printf (_("Refuse to unwind"));
6689 unsigned int mask = ((op & 0x1f) << 8) | op2;
6691 printf ("pop compact {");
6695 decode_tic6x_unwind_regmask (mask);
6699 else if ((op & 0xf0) == 0xc0)
6706 unsigned int offset;
6710 /* Scan entire instruction first so that GET_OP output is not
6711 interleaved with disassembly. */
6713 for (i = 0; nregs < (op & 0xf); i++)
6719 regpos[nregs].offset = i * 2;
6720 regpos[nregs].reg = reg;
6727 regpos[nregs].offset = i * 2 + 1;
6728 regpos[nregs].reg = reg;
6733 printf (_("pop frame {"));
6735 for (i = i * 2; i > 0; i--)
6737 if (regpos[reg].offset == i - 1)
6739 name = tic6x_unwind_regnames[regpos[reg].reg];
6746 fputs (name, stdout);
6753 else if (op == 0xd0)
6754 printf (" MOV FP, SP");
6755 else if (op == 0xd1)
6756 printf (" __c6xabi_pop_rts");
6757 else if (op == 0xd2)
6759 unsigned char buf[9];
6760 unsigned int i, len;
6761 unsigned long offset;
6762 for (i = 0; i < sizeof (buf); i++)
6765 if ((buf[i] & 0x80) == 0)
6768 assert (i < sizeof (buf));
6769 offset = read_uleb128 (buf, &len);
6770 assert (len == i + 1);
6771 offset = offset * 8 + 0x408;
6772 printf (_("sp = sp + %ld"), offset);
6774 else if ((op & 0xf0) == 0xe0)
6776 if ((op & 0x0f) == 7)
6779 printf (" MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
6783 printf (_(" [unsupported opcode]"));
6790 expand_prel31 (bfd_vma word, bfd_vma where)
6794 offset = word & 0x7fffffff;
6795 if (offset & 0x40000000)
6796 offset |= ~ (bfd_vma) 0x7fffffff;
6798 if (elf_header.e_machine == EM_TI_C6000)
6801 return offset + where;
6805 decode_arm_unwind (struct arm_unw_aux_info *aux,
6806 unsigned int word, unsigned int remaining,
6807 bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
6808 struct arm_section *data_arm_sec)
6811 unsigned int more_words = 0;
6812 struct absaddr addr;
6816 /* Fetch the first word. */
6817 if (!arm_section_get_word (aux, data_arm_sec, data_sec, data_offset,
6823 if ((word & 0x80000000) == 0)
6825 /* Expand prel31 for personality routine. */
6827 const char *procname;
6829 fn = expand_prel31 (word, data_sec->sh_addr + data_offset);
6830 printf (_(" Personality routine: "));
6831 procname = arm_print_vma_and_name (aux, fn, addr);
6832 fputc ('\n', stdout);
6834 /* The GCC personality routines use the standard compact
6835 encoding, starting with one byte giving the number of
6837 if (procname != NULL
6838 && (const_strneq (procname, "__gcc_personality_v0")
6839 || const_strneq (procname, "__gxx_personality_v0")
6840 || const_strneq (procname, "__gcj_personality_v0")
6841 || const_strneq (procname, "__gnu_objc_personality_v0")))
6848 printf (_(" [Truncated data]\n"));
6851 more_words = word >> 24;
6862 per_index = (word >> 24) & 0x7f;
6863 printf (_(" Compact model %d\n"), per_index);
6870 else if (per_index < 3)
6872 more_words = (word >> 16) & 0xff;
6878 switch (elf_header.e_machine)
6883 decode_arm_unwind_bytecode (aux, word, remaining, more_words,
6884 data_offset, data_sec, data_arm_sec);
6887 printf (" [reserved]\n");
6893 decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
6894 data_offset, data_sec, data_arm_sec);
6896 else if (per_index < 5)
6898 if (((word >> 17) & 0x7f) == 0x7f)
6899 printf (_(" Restore stack from frame pointer\n"));
6901 printf (_(" Stack increment %d\n"), (word >> 14) & 0x1fc);
6902 printf (_(" Registers restored: "));
6904 printf (" (compact) ");
6905 decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
6907 printf (_(" Return register: %s\n"),
6908 tic6x_unwind_regnames[word & 0xf]);
6911 printf (" [reserved]\n");
6918 /* Decode the descriptors. Not implemented. */
6922 dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
6924 struct arm_section exidx_arm_sec, extab_arm_sec;
6925 unsigned int i, exidx_len;
6927 memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
6928 memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
6929 exidx_len = exidx_sec->sh_size / 8;
6931 for (i = 0; i < exidx_len; i++)
6933 unsigned int exidx_fn, exidx_entry;
6934 struct absaddr fn_addr, entry_addr;
6937 fputc ('\n', stdout);
6939 if (!arm_section_get_word (aux, &exidx_arm_sec, exidx_sec,
6940 8 * i, &exidx_fn, &fn_addr)
6941 || !arm_section_get_word (aux, &exidx_arm_sec, exidx_sec,
6942 8 * i + 4, &exidx_entry, &entry_addr))
6944 arm_free_section (&exidx_arm_sec);
6945 arm_free_section (&extab_arm_sec);
6949 fn = expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
6951 arm_print_vma_and_name (aux, fn, entry_addr);
6952 fputs (": ", stdout);
6954 if (exidx_entry == 1)
6956 print_vma (exidx_entry, PREFIX_HEX);
6957 fputs (" [cantunwind]\n", stdout);
6959 else if (exidx_entry & 0x80000000)
6961 print_vma (exidx_entry, PREFIX_HEX);
6962 fputc ('\n', stdout);
6963 decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
6967 bfd_vma table, table_offset = 0;
6968 Elf_Internal_Shdr *table_sec;
6970 fputs ("@", stdout);
6971 table = expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
6972 print_vma (table, PREFIX_HEX);
6975 /* Locate the matching .ARM.extab. */
6976 if (entry_addr.section != SHN_UNDEF
6977 && entry_addr.section < elf_header.e_shnum)
6979 table_sec = section_headers + entry_addr.section;
6980 table_offset = entry_addr.offset;
6984 table_sec = find_section_by_address (table);
6985 if (table_sec != NULL)
6986 table_offset = table - table_sec->sh_addr;
6988 if (table_sec == NULL)
6990 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
6991 (unsigned long) table);
6994 decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
7001 arm_free_section (&exidx_arm_sec);
7002 arm_free_section (&extab_arm_sec);
7005 /* Used for both ARM and C6X unwinding tables. */
7007 arm_process_unwind (FILE *file)
7009 struct arm_unw_aux_info aux;
7010 Elf_Internal_Shdr *unwsec = NULL;
7011 Elf_Internal_Shdr *strsec;
7012 Elf_Internal_Shdr *sec;
7014 unsigned int sec_type;
7016 memset (& aux, 0, sizeof (aux));
7019 switch (elf_header.e_machine)
7022 sec_type = SHT_ARM_EXIDX;
7026 sec_type = SHT_C6000_UNWIND;
7033 if (string_table == NULL)
7036 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7038 if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
7040 aux.nsyms = sec->sh_size / sec->sh_entsize;
7041 aux.symtab = GET_ELF_SYMBOLS (file, sec);
7043 strsec = section_headers + sec->sh_link;
7044 assert (aux.strtab == NULL);
7045 aux.strtab = get_data (NULL, file, strsec->sh_offset,
7046 1, strsec->sh_size, _("string table"));
7047 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7049 else if (sec->sh_type == sec_type)
7054 printf (_("\nThere are no unwind sections in this file.\n"));
7056 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7058 if (sec->sh_type == sec_type)
7060 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
7062 (unsigned long) sec->sh_offset,
7063 (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
7065 dump_arm_unwind (&aux, sec);
7072 free ((char *) aux.strtab);
7078 process_unwind (FILE * file)
7080 struct unwind_handler
7083 int (* handler)(FILE *);
7086 { EM_ARM, arm_process_unwind },
7087 { EM_IA_64, ia64_process_unwind },
7088 { EM_PARISC, hppa_process_unwind },
7089 { EM_TI_C6000, arm_process_unwind },
7097 for (i = 0; handlers[i].handler != NULL; i++)
7098 if (elf_header.e_machine == handlers[i].machtype)
7099 return handlers[i].handler (file);
7101 printf (_("\nThere are no unwind sections in this file.\n"));
7106 dynamic_section_mips_val (Elf_Internal_Dyn * entry)
7108 switch (entry->d_tag)
7111 if (entry->d_un.d_val == 0)
7112 printf (_("NONE\n"));
7115 static const char * opts[] =
7117 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
7118 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
7119 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
7120 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
7126 for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
7127 if (entry->d_un.d_val & (1 << cnt))
7129 printf ("%s%s", first ? "" : " ", opts[cnt]);
7136 case DT_MIPS_IVERSION:
7137 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
7138 printf (_("Interface Version: %s\n"), GET_DYNAMIC_NAME (entry->d_un.d_val));
7140 printf (_("<corrupt: %ld>\n"), (long) entry->d_un.d_ptr);
7143 case DT_MIPS_TIME_STAMP:
7148 time_t atime = entry->d_un.d_val;
7149 tmp = gmtime (&atime);
7150 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
7151 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
7152 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
7153 printf (_("Time Stamp: %s\n"), timebuf);
7157 case DT_MIPS_RLD_VERSION:
7158 case DT_MIPS_LOCAL_GOTNO:
7159 case DT_MIPS_CONFLICTNO:
7160 case DT_MIPS_LIBLISTNO:
7161 case DT_MIPS_SYMTABNO:
7162 case DT_MIPS_UNREFEXTNO:
7163 case DT_MIPS_HIPAGENO:
7164 case DT_MIPS_DELTA_CLASS_NO:
7165 case DT_MIPS_DELTA_INSTANCE_NO:
7166 case DT_MIPS_DELTA_RELOC_NO:
7167 case DT_MIPS_DELTA_SYM_NO:
7168 case DT_MIPS_DELTA_CLASSSYM_NO:
7169 case DT_MIPS_COMPACT_SIZE:
7170 printf ("%ld\n", (long) entry->d_un.d_ptr);
7174 printf ("%#lx\n", (unsigned long) entry->d_un.d_ptr);
7179 dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
7181 switch (entry->d_tag)
7183 case DT_HP_DLD_FLAGS:
7192 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
7193 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
7194 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
7195 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
7196 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
7197 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
7198 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
7199 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
7200 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
7201 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
7202 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
7203 { DT_HP_GST, "HP_GST" },
7204 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
7205 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
7206 { DT_HP_NODELETE, "HP_NODELETE" },
7207 { DT_HP_GROUP, "HP_GROUP" },
7208 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
7212 bfd_vma val = entry->d_un.d_val;
7214 for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
7215 if (val & flags[cnt].bit)
7219 fputs (flags[cnt].str, stdout);
7221 val ^= flags[cnt].bit;
7224 if (val != 0 || first)
7228 print_vma (val, HEX);
7234 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7242 /* VMS vs Unix time offset and factor. */
7244 #define VMS_EPOCH_OFFSET 35067168000000000LL
7245 #define VMS_GRANULARITY_FACTOR 10000000
7247 /* Display a VMS time in a human readable format. */
7250 print_vms_time (bfd_int64_t vmstime)
7255 unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
7256 tm = gmtime (&unxtime);
7257 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
7258 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
7259 tm->tm_hour, tm->tm_min, tm->tm_sec);
7264 dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
7266 switch (entry->d_tag)
7268 case DT_IA_64_PLT_RESERVE:
7269 /* First 3 slots reserved. */
7270 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7272 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
7275 case DT_IA_64_VMS_LINKTIME:
7277 print_vms_time (entry->d_un.d_val);
7281 case DT_IA_64_VMS_LNKFLAGS:
7282 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7283 if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
7284 printf (" CALL_DEBUG");
7285 if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
7286 printf (" NOP0BUFS");
7287 if (entry->d_un.d_val & VMS_LF_P0IMAGE)
7288 printf (" P0IMAGE");
7289 if (entry->d_un.d_val & VMS_LF_MKTHREADS)
7290 printf (" MKTHREADS");
7291 if (entry->d_un.d_val & VMS_LF_UPCALLS)
7292 printf (" UPCALLS");
7293 if (entry->d_un.d_val & VMS_LF_IMGSTA)
7295 if (entry->d_un.d_val & VMS_LF_INITIALIZE)
7296 printf (" INITIALIZE");
7297 if (entry->d_un.d_val & VMS_LF_MAIN)
7299 if (entry->d_un.d_val & VMS_LF_EXE_INIT)
7300 printf (" EXE_INIT");
7301 if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
7302 printf (" TBK_IN_IMG");
7303 if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
7304 printf (" DBG_IN_IMG");
7305 if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
7306 printf (" TBK_IN_DSF");
7307 if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
7308 printf (" DBG_IN_DSF");
7309 if (entry->d_un.d_val & VMS_LF_SIGNATURES)
7310 printf (" SIGNATURES");
7311 if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
7312 printf (" REL_SEG_OFF");
7316 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7323 get_32bit_dynamic_section (FILE * file)
7325 Elf32_External_Dyn * edyn;
7326 Elf32_External_Dyn * ext;
7327 Elf_Internal_Dyn * entry;
7329 edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
7330 dynamic_size, _("dynamic section"));
7334 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
7335 might not have the luxury of section headers. Look for the DT_NULL
7336 terminator to determine the number of entries. */
7337 for (ext = edyn, dynamic_nent = 0;
7338 (char *) ext < (char *) edyn + dynamic_size;
7342 if (BYTE_GET (ext->d_tag) == DT_NULL)
7346 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
7348 if (dynamic_section == NULL)
7350 error (_("Out of memory\n"));
7355 for (ext = edyn, entry = dynamic_section;
7356 entry < dynamic_section + dynamic_nent;
7359 entry->d_tag = BYTE_GET (ext->d_tag);
7360 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
7369 get_64bit_dynamic_section (FILE * file)
7371 Elf64_External_Dyn * edyn;
7372 Elf64_External_Dyn * ext;
7373 Elf_Internal_Dyn * entry;
7375 edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
7376 dynamic_size, _("dynamic section"));
7380 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
7381 might not have the luxury of section headers. Look for the DT_NULL
7382 terminator to determine the number of entries. */
7383 for (ext = edyn, dynamic_nent = 0;
7384 (char *) ext < (char *) edyn + dynamic_size;
7388 if (BYTE_GET (ext->d_tag) == DT_NULL)
7392 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
7394 if (dynamic_section == NULL)
7396 error (_("Out of memory\n"));
7401 for (ext = edyn, entry = dynamic_section;
7402 entry < dynamic_section + dynamic_nent;
7405 entry->d_tag = BYTE_GET (ext->d_tag);
7406 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
7415 print_dynamic_flags (bfd_vma flags)
7423 flag = flags & - flags;
7433 case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
7434 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
7435 case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
7436 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
7437 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
7438 default: fputs (_("unknown"), stdout); break;
7444 /* Parse and display the contents of the dynamic section. */
7447 process_dynamic_section (FILE * file)
7449 Elf_Internal_Dyn * entry;
7451 if (dynamic_size == 0)
7454 printf (_("\nThere is no dynamic section in this file.\n"));
7461 if (! get_32bit_dynamic_section (file))
7464 else if (! get_64bit_dynamic_section (file))
7467 /* Find the appropriate symbol table. */
7468 if (dynamic_symbols == NULL)
7470 for (entry = dynamic_section;
7471 entry < dynamic_section + dynamic_nent;
7474 Elf_Internal_Shdr section;
7476 if (entry->d_tag != DT_SYMTAB)
7479 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
7481 /* Since we do not know how big the symbol table is,
7482 we default to reading in the entire file (!) and
7483 processing that. This is overkill, I know, but it
7485 section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
7487 if (archive_file_offset != 0)
7488 section.sh_size = archive_file_size - section.sh_offset;
7491 if (fseek (file, 0, SEEK_END))
7492 error (_("Unable to seek to end of file!\n"));
7494 section.sh_size = ftell (file) - section.sh_offset;
7498 section.sh_entsize = sizeof (Elf32_External_Sym);
7500 section.sh_entsize = sizeof (Elf64_External_Sym);
7502 num_dynamic_syms = section.sh_size / section.sh_entsize;
7503 if (num_dynamic_syms < 1)
7505 error (_("Unable to determine the number of symbols to load\n"));
7509 dynamic_symbols = GET_ELF_SYMBOLS (file, §ion);
7513 /* Similarly find a string table. */
7514 if (dynamic_strings == NULL)
7516 for (entry = dynamic_section;
7517 entry < dynamic_section + dynamic_nent;
7520 unsigned long offset;
7523 if (entry->d_tag != DT_STRTAB)
7526 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
7528 /* Since we do not know how big the string table is,
7529 we default to reading in the entire file (!) and
7530 processing that. This is overkill, I know, but it
7533 offset = offset_from_vma (file, entry->d_un.d_val, 0);
7535 if (archive_file_offset != 0)
7536 str_tab_len = archive_file_size - offset;
7539 if (fseek (file, 0, SEEK_END))
7540 error (_("Unable to seek to end of file\n"));
7541 str_tab_len = ftell (file) - offset;
7544 if (str_tab_len < 1)
7547 (_("Unable to determine the length of the dynamic string table\n"));
7551 dynamic_strings = (char *) get_data (NULL, file, offset, 1,
7553 _("dynamic string table"));
7554 dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
7559 /* And find the syminfo section if available. */
7560 if (dynamic_syminfo == NULL)
7562 unsigned long syminsz = 0;
7564 for (entry = dynamic_section;
7565 entry < dynamic_section + dynamic_nent;
7568 if (entry->d_tag == DT_SYMINENT)
7570 /* Note: these braces are necessary to avoid a syntax
7571 error from the SunOS4 C compiler. */
7572 assert (sizeof (Elf_External_Syminfo) == entry->d_un.d_val);
7574 else if (entry->d_tag == DT_SYMINSZ)
7575 syminsz = entry->d_un.d_val;
7576 else if (entry->d_tag == DT_SYMINFO)
7577 dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
7581 if (dynamic_syminfo_offset != 0 && syminsz != 0)
7583 Elf_External_Syminfo * extsyminfo;
7584 Elf_External_Syminfo * extsym;
7585 Elf_Internal_Syminfo * syminfo;
7587 /* There is a syminfo section. Read the data. */
7588 extsyminfo = (Elf_External_Syminfo *)
7589 get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
7590 _("symbol information"));
7594 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
7595 if (dynamic_syminfo == NULL)
7597 error (_("Out of memory\n"));
7601 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
7602 for (syminfo = dynamic_syminfo, extsym = extsyminfo;
7603 syminfo < dynamic_syminfo + dynamic_syminfo_nent;
7604 ++syminfo, ++extsym)
7606 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
7607 syminfo->si_flags = BYTE_GET (extsym->si_flags);
7614 if (do_dynamic && dynamic_addr)
7615 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
7616 dynamic_addr, dynamic_nent);
7618 printf (_(" Tag Type Name/Value\n"));
7620 for (entry = dynamic_section;
7621 entry < dynamic_section + dynamic_nent;
7629 print_vma (entry->d_tag, FULL_HEX);
7630 dtype = get_dynamic_type (entry->d_tag);
7631 printf (" (%s)%*s", dtype,
7632 ((is_32bit_elf ? 27 : 19)
7633 - (int) strlen (dtype)),
7637 switch (entry->d_tag)
7641 print_dynamic_flags (entry->d_un.d_val);
7651 switch (entry->d_tag)
7654 printf (_("Auxiliary library"));
7658 printf (_("Filter library"));
7662 printf (_("Configuration file"));
7666 printf (_("Dependency audit library"));
7670 printf (_("Audit library"));
7674 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
7675 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
7679 print_vma (entry->d_un.d_val, PREFIX_HEX);
7688 printf (_("Flags:"));
7690 if (entry->d_un.d_val == 0)
7691 printf (_(" None\n"));
7694 unsigned long int val = entry->d_un.d_val;
7696 if (val & DTF_1_PARINIT)
7698 printf (" PARINIT");
7699 val ^= DTF_1_PARINIT;
7701 if (val & DTF_1_CONFEXP)
7703 printf (" CONFEXP");
7704 val ^= DTF_1_CONFEXP;
7707 printf (" %lx", val);
7716 printf (_("Flags:"));
7718 if (entry->d_un.d_val == 0)
7719 printf (_(" None\n"));
7722 unsigned long int val = entry->d_un.d_val;
7724 if (val & DF_P1_LAZYLOAD)
7726 printf (" LAZYLOAD");
7727 val ^= DF_P1_LAZYLOAD;
7729 if (val & DF_P1_GROUPPERM)
7731 printf (" GROUPPERM");
7732 val ^= DF_P1_GROUPPERM;
7735 printf (" %lx", val);
7744 printf (_("Flags:"));
7745 if (entry->d_un.d_val == 0)
7746 printf (_(" None\n"));
7749 unsigned long int val = entry->d_un.d_val;
7756 if (val & DF_1_GLOBAL)
7761 if (val & DF_1_GROUP)
7766 if (val & DF_1_NODELETE)
7768 printf (" NODELETE");
7769 val ^= DF_1_NODELETE;
7771 if (val & DF_1_LOADFLTR)
7773 printf (" LOADFLTR");
7774 val ^= DF_1_LOADFLTR;
7776 if (val & DF_1_INITFIRST)
7778 printf (" INITFIRST");
7779 val ^= DF_1_INITFIRST;
7781 if (val & DF_1_NOOPEN)
7786 if (val & DF_1_ORIGIN)
7791 if (val & DF_1_DIRECT)
7796 if (val & DF_1_TRANS)
7801 if (val & DF_1_INTERPOSE)
7803 printf (" INTERPOSE");
7804 val ^= DF_1_INTERPOSE;
7806 if (val & DF_1_NODEFLIB)
7808 printf (" NODEFLIB");
7809 val ^= DF_1_NODEFLIB;
7811 if (val & DF_1_NODUMP)
7816 if (val & DF_1_CONLFAT)
7818 printf (" CONLFAT");
7819 val ^= DF_1_CONLFAT;
7822 printf (" %lx", val);
7829 dynamic_info[entry->d_tag] = entry->d_un.d_val;
7831 puts (get_dynamic_type (entry->d_un.d_val));
7851 dynamic_info[entry->d_tag] = entry->d_un.d_val;
7857 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
7858 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
7864 switch (entry->d_tag)
7867 printf (_("Shared library: [%s]"), name);
7869 if (streq (name, program_interpreter))
7870 printf (_(" program interpreter"));
7874 printf (_("Library soname: [%s]"), name);
7878 printf (_("Library rpath: [%s]"), name);
7882 printf (_("Library runpath: [%s]"), name);
7886 print_vma (entry->d_un.d_val, PREFIX_HEX);
7891 print_vma (entry->d_un.d_val, PREFIX_HEX);
7904 dynamic_info[entry->d_tag] = entry->d_un.d_val;
7908 case DT_INIT_ARRAYSZ:
7909 case DT_FINI_ARRAYSZ:
7910 case DT_GNU_CONFLICTSZ:
7911 case DT_GNU_LIBLISTSZ:
7914 print_vma (entry->d_un.d_val, UNSIGNED);
7915 printf (_(" (bytes)\n"));
7925 print_vma (entry->d_un.d_val, UNSIGNED);
7938 if (entry->d_tag == DT_USED
7939 && VALID_DYNAMIC_NAME (entry->d_un.d_val))
7941 char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
7945 printf (_("Not needed object: [%s]\n"), name);
7950 print_vma (entry->d_un.d_val, PREFIX_HEX);
7956 /* The value of this entry is ignored. */
7961 case DT_GNU_PRELINKED:
7965 time_t atime = entry->d_un.d_val;
7967 tmp = gmtime (&atime);
7968 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
7969 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
7970 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
7976 dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
7979 print_vma (entry->d_un.d_val, PREFIX_HEX);
7985 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
7986 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
7991 switch (elf_header.e_machine)
7994 case EM_MIPS_RS3_LE:
7995 dynamic_section_mips_val (entry);
7998 dynamic_section_parisc_val (entry);
8001 dynamic_section_ia64_val (entry);
8004 print_vma (entry->d_un.d_val, PREFIX_HEX);
8016 get_ver_flags (unsigned int flags)
8018 static char buff[32];
8025 if (flags & VER_FLG_BASE)
8026 strcat (buff, "BASE ");
8028 if (flags & VER_FLG_WEAK)
8030 if (flags & VER_FLG_BASE)
8031 strcat (buff, "| ");
8033 strcat (buff, "WEAK ");
8036 if (flags & VER_FLG_INFO)
8038 if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
8039 strcat (buff, "| ");
8041 strcat (buff, "INFO ");
8044 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
8045 strcat (buff, _("| <unknown>"));
8050 /* Display the contents of the version sections. */
8053 process_version_sections (FILE * file)
8055 Elf_Internal_Shdr * section;
8062 for (i = 0, section = section_headers;
8063 i < elf_header.e_shnum;
8066 switch (section->sh_type)
8068 case SHT_GNU_verdef:
8070 Elf_External_Verdef * edefs;
8078 (_("\nVersion definition section '%s' contains %u entries:\n"),
8079 SECTION_NAME (section), section->sh_info);
8081 printf (_(" Addr: 0x"));
8082 printf_vma (section->sh_addr);
8083 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
8084 (unsigned long) section->sh_offset, section->sh_link,
8085 section->sh_link < elf_header.e_shnum
8086 ? SECTION_NAME (section_headers + section->sh_link)
8089 edefs = (Elf_External_Verdef *)
8090 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
8091 _("version definition section"));
8094 endbuf = (char *) edefs + section->sh_size;
8096 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
8099 Elf_External_Verdef * edef;
8100 Elf_Internal_Verdef ent;
8101 Elf_External_Verdaux * eaux;
8102 Elf_Internal_Verdaux aux;
8106 /* Check for negative or very large indicies. */
8107 if ((unsigned char *) edefs + idx < (unsigned char *) edefs)
8110 vstart = ((char *) edefs) + idx;
8111 if (vstart + sizeof (*edef) > endbuf)
8114 edef = (Elf_External_Verdef *) vstart;
8116 ent.vd_version = BYTE_GET (edef->vd_version);
8117 ent.vd_flags = BYTE_GET (edef->vd_flags);
8118 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
8119 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
8120 ent.vd_hash = BYTE_GET (edef->vd_hash);
8121 ent.vd_aux = BYTE_GET (edef->vd_aux);
8122 ent.vd_next = BYTE_GET (edef->vd_next);
8124 printf (_(" %#06x: Rev: %d Flags: %s"),
8125 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
8127 printf (_(" Index: %d Cnt: %d "),
8128 ent.vd_ndx, ent.vd_cnt);
8130 /* Check for overflow. */
8131 if ((unsigned char *)(vstart + ent.vd_aux) < (unsigned char *) vstart
8132 || (unsigned char *)(vstart + ent.vd_aux) > (unsigned char *) endbuf)
8135 vstart += ent.vd_aux;
8137 eaux = (Elf_External_Verdaux *) vstart;
8139 aux.vda_name = BYTE_GET (eaux->vda_name);
8140 aux.vda_next = BYTE_GET (eaux->vda_next);
8142 if (VALID_DYNAMIC_NAME (aux.vda_name))
8143 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
8145 printf (_("Name index: %ld\n"), aux.vda_name);
8147 isum = idx + ent.vd_aux;
8149 for (j = 1; j < ent.vd_cnt; j++)
8151 /* Check for overflow. */
8152 if ((unsigned char *)(vstart + aux.vda_next) < (unsigned char *) vstart
8153 || (unsigned char *)(vstart + aux.vda_next) > (unsigned char *) endbuf)
8156 isum += aux.vda_next;
8157 vstart += aux.vda_next;
8159 eaux = (Elf_External_Verdaux *) vstart;
8160 if (vstart + sizeof (*eaux) > endbuf)
8163 aux.vda_name = BYTE_GET (eaux->vda_name);
8164 aux.vda_next = BYTE_GET (eaux->vda_next);
8166 if (VALID_DYNAMIC_NAME (aux.vda_name))
8167 printf (_(" %#06x: Parent %d: %s\n"),
8168 isum, j, GET_DYNAMIC_NAME (aux.vda_name));
8170 printf (_(" %#06x: Parent %d, name index: %ld\n"),
8171 isum, j, aux.vda_name);
8175 printf (_(" Version def aux past end of section\n"));
8180 if (cnt < section->sh_info)
8181 printf (_(" Version definition past end of section\n"));
8187 case SHT_GNU_verneed:
8189 Elf_External_Verneed * eneed;
8196 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
8197 SECTION_NAME (section), section->sh_info);
8199 printf (_(" Addr: 0x"));
8200 printf_vma (section->sh_addr);
8201 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
8202 (unsigned long) section->sh_offset, section->sh_link,
8203 section->sh_link < elf_header.e_shnum
8204 ? SECTION_NAME (section_headers + section->sh_link)
8207 eneed = (Elf_External_Verneed *) get_data (NULL, file,
8208 section->sh_offset, 1,
8210 _("version need section"));
8213 endbuf = (char *) eneed + section->sh_size;
8215 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
8217 Elf_External_Verneed * entry;
8218 Elf_Internal_Verneed ent;
8223 if ((unsigned char *) eneed + idx < (unsigned char *) eneed)
8226 vstart = ((char *) eneed) + idx;
8227 if (vstart + sizeof (*entry) > endbuf)
8230 entry = (Elf_External_Verneed *) vstart;
8232 ent.vn_version = BYTE_GET (entry->vn_version);
8233 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
8234 ent.vn_file = BYTE_GET (entry->vn_file);
8235 ent.vn_aux = BYTE_GET (entry->vn_aux);
8236 ent.vn_next = BYTE_GET (entry->vn_next);
8238 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
8240 if (VALID_DYNAMIC_NAME (ent.vn_file))
8241 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
8243 printf (_(" File: %lx"), ent.vn_file);
8245 printf (_(" Cnt: %d\n"), ent.vn_cnt);
8247 /* Check for overflow. */
8248 if ((unsigned char *)(vstart + ent.vn_aux) < (unsigned char *) vstart
8249 || (unsigned char *)(vstart + ent.vn_aux) > (unsigned char *) endbuf)
8252 vstart += ent.vn_aux;
8254 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
8256 Elf_External_Vernaux * eaux;
8257 Elf_Internal_Vernaux aux;
8259 if (vstart + sizeof (*eaux) > endbuf)
8261 eaux = (Elf_External_Vernaux *) vstart;
8263 aux.vna_hash = BYTE_GET (eaux->vna_hash);
8264 aux.vna_flags = BYTE_GET (eaux->vna_flags);
8265 aux.vna_other = BYTE_GET (eaux->vna_other);
8266 aux.vna_name = BYTE_GET (eaux->vna_name);
8267 aux.vna_next = BYTE_GET (eaux->vna_next);
8269 if (VALID_DYNAMIC_NAME (aux.vna_name))
8270 printf (_(" %#06x: Name: %s"),
8271 isum, GET_DYNAMIC_NAME (aux.vna_name));
8273 printf (_(" %#06x: Name index: %lx"),
8274 isum, aux.vna_name);
8276 printf (_(" Flags: %s Version: %d\n"),
8277 get_ver_flags (aux.vna_flags), aux.vna_other);
8279 /* Check for overflow. */
8280 if ((unsigned char *)(vstart + aux.vna_next) < (unsigned char *) vstart
8281 || (unsigned char *)(vstart + aux.vna_next) > (unsigned char *) endbuf)
8284 isum += aux.vna_next;
8285 vstart += aux.vna_next;
8288 printf (_(" Version need aux past end of section\n"));
8292 if (cnt < section->sh_info)
8293 printf (_(" Version need past end of section\n"));
8299 case SHT_GNU_versym:
8301 Elf_Internal_Shdr * link_section;
8304 unsigned char * edata;
8305 unsigned short * data;
8307 Elf_Internal_Sym * symbols;
8308 Elf_Internal_Shdr * string_sec;
8311 if (section->sh_link >= elf_header.e_shnum)
8314 link_section = section_headers + section->sh_link;
8315 total = section->sh_size / sizeof (Elf_External_Versym);
8317 if (link_section->sh_link >= elf_header.e_shnum)
8322 symbols = GET_ELF_SYMBOLS (file, link_section);
8323 if (symbols == NULL)
8326 string_sec = section_headers + link_section->sh_link;
8328 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
8329 string_sec->sh_size,
8330 _("version string table"));
8337 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
8338 SECTION_NAME (section), total);
8340 printf (_(" Addr: "));
8341 printf_vma (section->sh_addr);
8342 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
8343 (unsigned long) section->sh_offset, section->sh_link,
8344 SECTION_NAME (link_section));
8346 off = offset_from_vma (file,
8347 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
8348 total * sizeof (short));
8349 edata = (unsigned char *) get_data (NULL, file, off, total,
8351 _("version symbol data"));
8359 data = (short unsigned int *) cmalloc (total, sizeof (short));
8361 for (cnt = total; cnt --;)
8362 data[cnt] = byte_get (edata + cnt * sizeof (short),
8367 for (cnt = 0; cnt < total; cnt += 4)
8370 int check_def, check_need;
8373 printf (" %03x:", cnt);
8375 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
8376 switch (data[cnt + j])
8379 fputs (_(" 0 (*local*) "), stdout);
8383 fputs (_(" 1 (*global*) "), stdout);
8387 nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
8388 data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
8390 /* If this index value is greater than the size of the symbols
8391 array, break to avoid an out-of-bounds read, */
8392 if ((unsigned long)(cnt + j) >=
8393 ((unsigned long)link_section->sh_size /
8394 (unsigned long)link_section->sh_entsize))
8396 warn (_("invalid index into symbol array\n"));
8402 if (symbols[cnt + j].st_shndx >= elf_header.e_shnum
8403 || section_headers[symbols[cnt + j].st_shndx].sh_type
8406 if (symbols[cnt + j].st_shndx == SHN_UNDEF)
8413 && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
8415 Elf_Internal_Verneed ivn;
8416 unsigned long offset;
8418 offset = offset_from_vma
8419 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
8420 sizeof (Elf_External_Verneed));
8424 Elf_Internal_Vernaux ivna;
8425 Elf_External_Verneed evn;
8426 Elf_External_Vernaux evna;
8427 unsigned long a_off;
8429 if (get_data (&evn, file, offset, sizeof (evn), 1,
8430 _("version need")) == NULL)
8433 ivn.vn_aux = BYTE_GET (evn.vn_aux);
8434 ivn.vn_next = BYTE_GET (evn.vn_next);
8436 a_off = offset + ivn.vn_aux;
8440 if (get_data (&evna, file, a_off, sizeof (evna),
8441 1, _("version need aux (2)")) == NULL)
8448 ivna.vna_next = BYTE_GET (evna.vna_next);
8449 ivna.vna_other = BYTE_GET (evna.vna_other);
8452 a_off += ivna.vna_next;
8454 while (ivna.vna_other != data[cnt + j]
8455 && ivna.vna_next != 0);
8457 if (ivna.vna_other == data[cnt + j])
8459 ivna.vna_name = BYTE_GET (evna.vna_name);
8461 if (ivna.vna_name >= string_sec->sh_size)
8462 name = _("*invalid*");
8464 name = strtab + ivna.vna_name;
8465 nn += printf ("(%s%-*s",
8467 12 - (int) strlen (name),
8473 offset += ivn.vn_next;
8475 while (ivn.vn_next);
8478 if (check_def && data[cnt + j] != 0x8001
8479 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
8481 Elf_Internal_Verdef ivd;
8482 Elf_External_Verdef evd;
8483 unsigned long offset;
8485 offset = offset_from_vma
8486 (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
8491 if (get_data (&evd, file, offset, sizeof (evd), 1,
8492 _("version def")) == NULL)
8499 ivd.vd_next = BYTE_GET (evd.vd_next);
8500 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
8503 offset += ivd.vd_next;
8505 while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
8506 && ivd.vd_next != 0);
8508 if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
8510 Elf_External_Verdaux evda;
8511 Elf_Internal_Verdaux ivda;
8513 ivd.vd_aux = BYTE_GET (evd.vd_aux);
8515 if (get_data (&evda, file,
8516 offset - ivd.vd_next + ivd.vd_aux,
8518 _("version def aux")) == NULL)
8521 ivda.vda_name = BYTE_GET (evda.vda_name);
8523 if (ivda.vda_name >= string_sec->sh_size)
8524 name = _("*invalid*");
8526 name = strtab + ivda.vda_name;
8527 nn += printf ("(%s%-*s",
8529 12 - (int) strlen (name),
8535 printf ("%*c", 18 - nn, ' ');
8553 printf (_("\nNo version information found in this file.\n"));
8559 get_symbol_binding (unsigned int binding)
8561 static char buff[32];
8565 case STB_LOCAL: return "LOCAL";
8566 case STB_GLOBAL: return "GLOBAL";
8567 case STB_WEAK: return "WEAK";
8569 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
8570 snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
8572 else if (binding >= STB_LOOS && binding <= STB_HIOS)
8574 if (binding == STB_GNU_UNIQUE
8575 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_LINUX
8576 /* GNU/Linux is still using the default value 0. */
8577 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
8579 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
8582 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
8588 get_symbol_type (unsigned int type)
8590 static char buff[32];
8594 case STT_NOTYPE: return "NOTYPE";
8595 case STT_OBJECT: return "OBJECT";
8596 case STT_FUNC: return "FUNC";
8597 case STT_SECTION: return "SECTION";
8598 case STT_FILE: return "FILE";
8599 case STT_COMMON: return "COMMON";
8600 case STT_TLS: return "TLS";
8601 case STT_RELC: return "RELC";
8602 case STT_SRELC: return "SRELC";
8604 if (type >= STT_LOPROC && type <= STT_HIPROC)
8606 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
8607 return "THUMB_FUNC";
8609 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
8612 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
8613 return "PARISC_MILLI";
8615 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
8617 else if (type >= STT_LOOS && type <= STT_HIOS)
8619 if (elf_header.e_machine == EM_PARISC)
8621 if (type == STT_HP_OPAQUE)
8623 if (type == STT_HP_STUB)
8627 if (type == STT_GNU_IFUNC
8628 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_LINUX
8629 /* GNU/Linux is still using the default value 0. */
8630 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
8633 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
8636 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
8642 get_symbol_visibility (unsigned int visibility)
8646 case STV_DEFAULT: return "DEFAULT";
8647 case STV_INTERNAL: return "INTERNAL";
8648 case STV_HIDDEN: return "HIDDEN";
8649 case STV_PROTECTED: return "PROTECTED";
8655 get_mips_symbol_other (unsigned int other)
8659 case STO_OPTIONAL: return "OPTIONAL";
8660 case STO_MIPS16: return "MIPS16";
8661 case STO_MIPS_PLT: return "MIPS PLT";
8662 case STO_MIPS_PIC: return "MIPS PIC";
8663 default: return NULL;
8668 get_ia64_symbol_other (unsigned int other)
8672 static char res[32];
8676 /* Function types is for images and .STB files only. */
8677 switch (elf_header.e_type)
8681 switch (VMS_ST_FUNC_TYPE (other))
8683 case VMS_SFT_CODE_ADDR:
8684 strcat (res, " CA");
8686 case VMS_SFT_SYMV_IDX:
8687 strcat (res, " VEC");
8690 strcat (res, " FD");
8692 case VMS_SFT_RESERVE:
8693 strcat (res, " RSV");
8702 switch (VMS_ST_LINKAGE (other))
8704 case VMS_STL_IGNORE:
8705 strcat (res, " IGN");
8707 case VMS_STL_RESERVE:
8708 strcat (res, " RSV");
8711 strcat (res, " STD");
8714 strcat (res, " LNK");
8729 get_symbol_other (unsigned int other)
8731 const char * result = NULL;
8732 static char buff [32];
8737 switch (elf_header.e_machine)
8740 result = get_mips_symbol_other (other);
8743 result = get_ia64_symbol_other (other);
8752 snprintf (buff, sizeof buff, _("<other>: %x"), other);
8757 get_symbol_index_type (unsigned int type)
8759 static char buff[32];
8763 case SHN_UNDEF: return "UND";
8764 case SHN_ABS: return "ABS";
8765 case SHN_COMMON: return "COM";
8767 if (type == SHN_IA_64_ANSI_COMMON
8768 && elf_header.e_machine == EM_IA_64
8769 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
8771 else if ((elf_header.e_machine == EM_X86_64
8772 || elf_header.e_machine == EM_L1OM)
8773 && type == SHN_X86_64_LCOMMON)
8775 else if ((type == SHN_MIPS_SCOMMON
8776 && elf_header.e_machine == EM_MIPS)
8777 || (type == SHN_TIC6X_SCOMMON
8778 && elf_header.e_machine == EM_TI_C6000))
8780 else if (type == SHN_MIPS_SUNDEFINED
8781 && elf_header.e_machine == EM_MIPS)
8783 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
8784 sprintf (buff, "PRC[0x%04x]", type & 0xffff);
8785 else if (type >= SHN_LOOS && type <= SHN_HIOS)
8786 sprintf (buff, "OS [0x%04x]", type & 0xffff);
8787 else if (type >= SHN_LORESERVE)
8788 sprintf (buff, "RSV[0x%04x]", type & 0xffff);
8790 sprintf (buff, "%3d", type);
8798 get_dynamic_data (FILE * file, unsigned int number, unsigned int ent_size)
8800 unsigned char * e_data;
8803 e_data = (unsigned char *) cmalloc (number, ent_size);
8807 error (_("Out of memory\n"));
8811 if (fread (e_data, ent_size, number, file) != number)
8813 error (_("Unable to read in dynamic data\n"));
8817 i_data = (bfd_vma *) cmalloc (number, sizeof (*i_data));
8821 error (_("Out of memory\n"));
8827 i_data[number] = byte_get (e_data + number * ent_size, ent_size);
8835 print_dynamic_symbol (bfd_vma si, unsigned long hn)
8837 Elf_Internal_Sym * psym;
8840 psym = dynamic_symbols + si;
8842 n = print_vma (si, DEC_5);
8844 fputs (" " + n, stdout);
8845 printf (" %3lu: ", hn);
8846 print_vma (psym->st_value, LONG_HEX);
8848 print_vma (psym->st_size, DEC_5);
8850 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
8851 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
8852 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
8853 /* Check to see if any other bits in the st_other field are set.
8854 Note - displaying this information disrupts the layout of the
8855 table being generated, but for the moment this case is very
8857 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
8858 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
8859 printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
8860 if (VALID_DYNAMIC_NAME (psym->st_name))
8861 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
8863 printf (_(" <corrupt: %14ld>"), psym->st_name);
8867 /* Dump the symbol table. */
8869 process_symbol_table (FILE * file)
8871 Elf_Internal_Shdr * section;
8872 bfd_vma nbuckets = 0;
8873 bfd_vma nchains = 0;
8874 bfd_vma * buckets = NULL;
8875 bfd_vma * chains = NULL;
8876 bfd_vma ngnubuckets = 0;
8877 bfd_vma * gnubuckets = NULL;
8878 bfd_vma * gnuchains = NULL;
8879 bfd_vma gnusymidx = 0;
8881 if (!do_syms && !do_dyn_syms && !do_histogram)
8884 if (dynamic_info[DT_HASH]
8886 || (do_using_dynamic
8888 && dynamic_strings != NULL)))
8890 unsigned char nb[8];
8891 unsigned char nc[8];
8892 int hash_ent_size = 4;
8894 if ((elf_header.e_machine == EM_ALPHA
8895 || elf_header.e_machine == EM_S390
8896 || elf_header.e_machine == EM_S390_OLD)
8897 && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
8901 (archive_file_offset
8902 + offset_from_vma (file, dynamic_info[DT_HASH],
8903 sizeof nb + sizeof nc)),
8906 error (_("Unable to seek to start of dynamic information\n"));
8910 if (fread (nb, hash_ent_size, 1, file) != 1)
8912 error (_("Failed to read in number of buckets\n"));
8916 if (fread (nc, hash_ent_size, 1, file) != 1)
8918 error (_("Failed to read in number of chains\n"));
8922 nbuckets = byte_get (nb, hash_ent_size);
8923 nchains = byte_get (nc, hash_ent_size);
8925 buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
8926 chains = get_dynamic_data (file, nchains, hash_ent_size);
8929 if (buckets == NULL || chains == NULL)
8931 if (do_using_dynamic)
8942 if (dynamic_info_DT_GNU_HASH
8944 || (do_using_dynamic
8946 && dynamic_strings != NULL)))
8948 unsigned char nb[16];
8949 bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
8950 bfd_vma buckets_vma;
8953 (archive_file_offset
8954 + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
8958 error (_("Unable to seek to start of dynamic information\n"));
8962 if (fread (nb, 16, 1, file) != 1)
8964 error (_("Failed to read in number of buckets\n"));
8968 ngnubuckets = byte_get (nb, 4);
8969 gnusymidx = byte_get (nb + 4, 4);
8970 bitmaskwords = byte_get (nb + 8, 4);
8971 buckets_vma = dynamic_info_DT_GNU_HASH + 16;
8973 buckets_vma += bitmaskwords * 4;
8975 buckets_vma += bitmaskwords * 8;
8978 (archive_file_offset
8979 + offset_from_vma (file, buckets_vma, 4)),
8982 error (_("Unable to seek to start of dynamic information\n"));
8986 gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
8988 if (gnubuckets == NULL)
8991 for (i = 0; i < ngnubuckets; i++)
8992 if (gnubuckets[i] != 0)
8994 if (gnubuckets[i] < gnusymidx)
8997 if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
8998 maxchain = gnubuckets[i];
9001 if (maxchain == 0xffffffff)
9004 maxchain -= gnusymidx;
9007 (archive_file_offset
9008 + offset_from_vma (file, buckets_vma
9009 + 4 * (ngnubuckets + maxchain), 4)),
9012 error (_("Unable to seek to start of dynamic information\n"));
9018 if (fread (nb, 4, 1, file) != 1)
9020 error (_("Failed to determine last chain length\n"));
9024 if (maxchain + 1 == 0)
9029 while ((byte_get (nb, 4) & 1) == 0);
9032 (archive_file_offset
9033 + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
9036 error (_("Unable to seek to start of dynamic information\n"));
9040 gnuchains = get_dynamic_data (file, maxchain, 4);
9043 if (gnuchains == NULL)
9048 if (do_using_dynamic)
9053 if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
9056 && dynamic_strings != NULL)
9060 if (dynamic_info[DT_HASH])
9064 printf (_("\nSymbol table for image:\n"));
9066 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9068 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9070 for (hn = 0; hn < nbuckets; hn++)
9075 for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
9076 print_dynamic_symbol (si, hn);
9080 if (dynamic_info_DT_GNU_HASH)
9082 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
9084 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9086 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9088 for (hn = 0; hn < ngnubuckets; ++hn)
9089 if (gnubuckets[hn] != 0)
9091 bfd_vma si = gnubuckets[hn];
9092 bfd_vma off = si - gnusymidx;
9096 print_dynamic_symbol (si, hn);
9099 while ((gnuchains[off++] & 1) == 0);
9103 else if (do_dyn_syms || (do_syms && !do_using_dynamic))
9107 for (i = 0, section = section_headers;
9108 i < elf_header.e_shnum;
9112 char * strtab = NULL;
9113 unsigned long int strtab_size = 0;
9114 Elf_Internal_Sym * symtab;
9115 Elf_Internal_Sym * psym;
9117 if ((section->sh_type != SHT_SYMTAB
9118 && section->sh_type != SHT_DYNSYM)
9120 && section->sh_type == SHT_SYMTAB))
9123 if (section->sh_entsize == 0)
9125 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
9126 SECTION_NAME (section));
9130 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
9131 SECTION_NAME (section),
9132 (unsigned long) (section->sh_size / section->sh_entsize));
9135 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
9137 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
9139 symtab = GET_ELF_SYMBOLS (file, section);
9143 if (section->sh_link == elf_header.e_shstrndx)
9145 strtab = string_table;
9146 strtab_size = string_table_length;
9148 else if (section->sh_link < elf_header.e_shnum)
9150 Elf_Internal_Shdr * string_sec;
9152 string_sec = section_headers + section->sh_link;
9154 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
9155 1, string_sec->sh_size,
9157 strtab_size = strtab != NULL ? string_sec->sh_size : 0;
9160 for (si = 0, psym = symtab;
9161 si < section->sh_size / section->sh_entsize;
9164 printf ("%6d: ", si);
9165 print_vma (psym->st_value, LONG_HEX);
9167 print_vma (psym->st_size, DEC_5);
9168 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
9169 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
9170 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
9171 /* Check to see if any other bits in the st_other field are set.
9172 Note - displaying this information disrupts the layout of the
9173 table being generated, but for the moment this case is very rare. */
9174 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
9175 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
9176 printf (" %4s ", get_symbol_index_type (psym->st_shndx));
9177 print_symbol (25, psym->st_name < strtab_size
9178 ? strtab + psym->st_name : _("<corrupt>"));
9180 if (section->sh_type == SHT_DYNSYM
9181 && version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
9183 unsigned char data[2];
9184 unsigned short vers_data;
9185 unsigned long offset;
9189 offset = offset_from_vma
9190 (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
9191 sizeof data + si * sizeof (vers_data));
9193 if (get_data (&data, file, offset + si * sizeof (vers_data),
9194 sizeof (data), 1, _("version data")) == NULL)
9197 vers_data = byte_get (data, 2);
9199 is_nobits = (psym->st_shndx < elf_header.e_shnum
9200 && section_headers[psym->st_shndx].sh_type
9203 check_def = (psym->st_shndx != SHN_UNDEF);
9205 if ((vers_data & VERSYM_HIDDEN) || vers_data > 1)
9207 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
9208 && (is_nobits || ! check_def))
9210 Elf_External_Verneed evn;
9211 Elf_Internal_Verneed ivn;
9212 Elf_Internal_Vernaux ivna;
9214 /* We must test both. */
9215 offset = offset_from_vma
9216 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
9221 unsigned long vna_off;
9223 if (get_data (&evn, file, offset, sizeof (evn), 1,
9224 _("version need")) == NULL)
9232 ivn.vn_aux = BYTE_GET (evn.vn_aux);
9233 ivn.vn_next = BYTE_GET (evn.vn_next);
9235 vna_off = offset + ivn.vn_aux;
9239 Elf_External_Vernaux evna;
9241 if (get_data (&evna, file, vna_off,
9243 _("version need aux (3)")) == NULL)
9251 ivna.vna_other = BYTE_GET (evna.vna_other);
9252 ivna.vna_next = BYTE_GET (evna.vna_next);
9253 ivna.vna_name = BYTE_GET (evna.vna_name);
9256 vna_off += ivna.vna_next;
9258 while (ivna.vna_other != vers_data
9259 && ivna.vna_next != 0);
9261 if (ivna.vna_other == vers_data)
9264 offset += ivn.vn_next;
9266 while (ivn.vn_next != 0);
9268 if (ivna.vna_other == vers_data)
9271 ivna.vna_name < strtab_size
9272 ? strtab + ivna.vna_name : _("<corrupt>"),
9276 else if (! is_nobits)
9277 error (_("bad dynamic symbol\n"));
9284 if (vers_data != 0x8001
9285 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
9287 Elf_Internal_Verdef ivd;
9288 Elf_Internal_Verdaux ivda;
9289 Elf_External_Verdaux evda;
9292 off = offset_from_vma
9294 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
9295 sizeof (Elf_External_Verdef));
9299 Elf_External_Verdef evd;
9301 if (get_data (&evd, file, off, sizeof (evd),
9302 1, _("version def")) == NULL)
9310 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
9311 ivd.vd_aux = BYTE_GET (evd.vd_aux);
9312 ivd.vd_next = BYTE_GET (evd.vd_next);
9317 while (ivd.vd_ndx != (vers_data & VERSYM_VERSION)
9318 && ivd.vd_next != 0);
9323 if (get_data (&evda, file, off, sizeof (evda),
9324 1, _("version def aux")) == NULL)
9327 ivda.vda_name = BYTE_GET (evda.vda_name);
9329 if (psym->st_name != ivda.vda_name)
9330 printf ((vers_data & VERSYM_HIDDEN)
9332 ivda.vda_name < strtab_size
9333 ? strtab + ivda.vda_name : _("<corrupt>"));
9343 if (strtab != string_table)
9349 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
9351 if (do_histogram && buckets != NULL)
9353 unsigned long * lengths;
9354 unsigned long * counts;
9357 unsigned long maxlength = 0;
9358 unsigned long nzero_counts = 0;
9359 unsigned long nsyms = 0;
9361 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
9362 (unsigned long) nbuckets);
9363 printf (_(" Length Number %% of total Coverage\n"));
9365 lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
9366 if (lengths == NULL)
9368 error (_("Out of memory\n"));
9371 for (hn = 0; hn < nbuckets; ++hn)
9373 for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
9376 if (maxlength < ++lengths[hn])
9381 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
9384 error (_("Out of memory\n"));
9388 for (hn = 0; hn < nbuckets; ++hn)
9389 ++counts[lengths[hn]];
9394 printf (" 0 %-10lu (%5.1f%%)\n",
9395 counts[0], (counts[0] * 100.0) / nbuckets);
9396 for (i = 1; i <= maxlength; ++i)
9398 nzero_counts += counts[i] * i;
9399 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
9400 i, counts[i], (counts[i] * 100.0) / nbuckets,
9401 (nzero_counts * 100.0) / nsyms);
9409 if (buckets != NULL)
9415 if (do_histogram && gnubuckets != NULL)
9417 unsigned long * lengths;
9418 unsigned long * counts;
9420 unsigned long maxlength = 0;
9421 unsigned long nzero_counts = 0;
9422 unsigned long nsyms = 0;
9424 lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
9425 if (lengths == NULL)
9427 error (_("Out of memory\n"));
9431 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
9432 (unsigned long) ngnubuckets);
9433 printf (_(" Length Number %% of total Coverage\n"));
9435 for (hn = 0; hn < ngnubuckets; ++hn)
9436 if (gnubuckets[hn] != 0)
9438 bfd_vma off, length = 1;
9440 for (off = gnubuckets[hn] - gnusymidx;
9441 (gnuchains[off] & 1) == 0; ++off)
9443 lengths[hn] = length;
9444 if (length > maxlength)
9449 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
9452 error (_("Out of memory\n"));
9456 for (hn = 0; hn < ngnubuckets; ++hn)
9457 ++counts[lengths[hn]];
9459 if (ngnubuckets > 0)
9462 printf (" 0 %-10lu (%5.1f%%)\n",
9463 counts[0], (counts[0] * 100.0) / ngnubuckets);
9464 for (j = 1; j <= maxlength; ++j)
9466 nzero_counts += counts[j] * j;
9467 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
9468 j, counts[j], (counts[j] * 100.0) / ngnubuckets,
9469 (nzero_counts * 100.0) / nsyms);
9483 process_syminfo (FILE * file ATTRIBUTE_UNUSED)
9487 if (dynamic_syminfo == NULL
9489 /* No syminfo, this is ok. */
9492 /* There better should be a dynamic symbol section. */
9493 if (dynamic_symbols == NULL || dynamic_strings == NULL)
9497 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
9498 dynamic_syminfo_offset, dynamic_syminfo_nent);
9500 printf (_(" Num: Name BoundTo Flags\n"));
9501 for (i = 0; i < dynamic_syminfo_nent; ++i)
9503 unsigned short int flags = dynamic_syminfo[i].si_flags;
9505 printf ("%4d: ", i);
9506 if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
9507 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
9509 printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
9512 switch (dynamic_syminfo[i].si_boundto)
9514 case SYMINFO_BT_SELF:
9515 fputs ("SELF ", stdout);
9517 case SYMINFO_BT_PARENT:
9518 fputs ("PARENT ", stdout);
9521 if (dynamic_syminfo[i].si_boundto > 0
9522 && dynamic_syminfo[i].si_boundto < dynamic_nent
9523 && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
9525 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
9529 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
9533 if (flags & SYMINFO_FLG_DIRECT)
9535 if (flags & SYMINFO_FLG_PASSTHRU)
9536 printf (" PASSTHRU");
9537 if (flags & SYMINFO_FLG_COPY)
9539 if (flags & SYMINFO_FLG_LAZYLOAD)
9540 printf (" LAZYLOAD");
9548 /* Check to see if the given reloc needs to be handled in a target specific
9549 manner. If so then process the reloc and return TRUE otherwise return
9553 target_specific_reloc_handling (Elf_Internal_Rela * reloc,
9554 unsigned char * start,
9555 Elf_Internal_Sym * symtab)
9557 unsigned int reloc_type = get_reloc_type (reloc->r_info);
9559 switch (elf_header.e_machine)
9562 case EM_CYGNUS_MN10300:
9564 static Elf_Internal_Sym * saved_sym = NULL;
9568 case 34: /* R_MN10300_ALIGN */
9570 case 33: /* R_MN10300_SYM_DIFF */
9571 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
9573 case 1: /* R_MN10300_32 */
9574 case 2: /* R_MN10300_16 */
9575 if (saved_sym != NULL)
9579 value = reloc->r_addend
9580 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
9581 - saved_sym->st_value);
9583 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
9590 if (saved_sym != NULL)
9591 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc"));
9601 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
9602 DWARF debug sections. This is a target specific test. Note - we do not
9603 go through the whole including-target-headers-multiple-times route, (as
9604 we have already done with <elf/h8.h>) because this would become very
9605 messy and even then this function would have to contain target specific
9606 information (the names of the relocs instead of their numeric values).
9607 FIXME: This is not the correct way to solve this problem. The proper way
9608 is to have target specific reloc sizing and typing functions created by
9609 the reloc-macros.h header, in the same way that it already creates the
9610 reloc naming functions. */
9613 is_32bit_abs_reloc (unsigned int reloc_type)
9615 switch (elf_header.e_machine)
9619 return reloc_type == 1; /* R_386_32. */
9621 return reloc_type == 1; /* R_68K_32. */
9623 return reloc_type == 1; /* R_860_32. */
9625 return reloc_type == 2; /* R_960_32. */
9627 return reloc_type == 1; /* R_ALPHA_REFLONG. */
9629 return reloc_type == 1; /* R_ARC_32. */
9631 return reloc_type == 2; /* R_ARM_ABS32 */
9634 return reloc_type == 1;
9636 return reloc_type == 0x12; /* R_byte4_data. */
9638 return reloc_type == 3; /* R_CRIS_32. */
9641 return reloc_type == 3; /* R_CR16_NUM32. */
9643 return reloc_type == 15; /* R_CRX_NUM32. */
9645 return reloc_type == 1;
9646 case EM_CYGNUS_D10V:
9648 return reloc_type == 6; /* R_D10V_32. */
9649 case EM_CYGNUS_D30V:
9651 return reloc_type == 12; /* R_D30V_32_NORMAL. */
9653 return reloc_type == 3; /* R_DLX_RELOC_32. */
9654 case EM_CYGNUS_FR30:
9656 return reloc_type == 3; /* R_FR30_32. */
9660 return reloc_type == 1; /* R_H8_DIR32. */
9662 return reloc_type == 0x65; /* R_IA64_SECREL32LSB. */
9665 return reloc_type == 2; /* R_IP2K_32. */
9667 return reloc_type == 2; /* R_IQ2000_32. */
9668 case EM_LATTICEMICO32:
9669 return reloc_type == 3; /* R_LM32_32. */
9672 return reloc_type == 3; /* R_M32C_32. */
9674 return reloc_type == 34; /* R_M32R_32_RELA. */
9676 return reloc_type == 1; /* R_MCORE_ADDR32. */
9678 return reloc_type == 4; /* R_MEP_32. */
9680 return reloc_type == 1; /* R_MICROBLAZE_32. */
9682 return reloc_type == 2; /* R_MIPS_32. */
9684 return reloc_type == 4; /* R_MMIX_32. */
9685 case EM_CYGNUS_MN10200:
9687 return reloc_type == 1; /* R_MN10200_32. */
9688 case EM_CYGNUS_MN10300:
9690 return reloc_type == 1; /* R_MN10300_32. */
9692 return reloc_type == 1; /* R_MOXIE_32. */
9695 return reloc_type == 1; /* R_MSP43_32. */
9697 return reloc_type == 2; /* R_MT_32. */
9698 case EM_ALTERA_NIOS2:
9700 return reloc_type == 1; /* R_NIOS_32. */
9703 return reloc_type == 1; /* R_OR32_32. */
9705 return (reloc_type == 1 /* R_PARISC_DIR32. */
9706 || reloc_type == 41); /* R_PARISC_SECREL32. */
9709 return reloc_type == 1; /* R_PJ_DATA_DIR32. */
9711 return reloc_type == 1; /* R_PPC64_ADDR32. */
9713 return reloc_type == 1; /* R_PPC_ADDR32. */
9715 return reloc_type == 1; /* R_RX_DIR32. */
9717 return reloc_type == 1; /* R_I370_ADDR31. */
9720 return reloc_type == 4; /* R_S390_32. */
9722 return reloc_type == 8; /* R_SCORE_ABS32. */
9724 return reloc_type == 1; /* R_SH_DIR32. */
9725 case EM_SPARC32PLUS:
9728 return reloc_type == 3 /* R_SPARC_32. */
9729 || reloc_type == 23; /* R_SPARC_UA32. */
9731 return reloc_type == 6; /* R_SPU_ADDR32 */
9733 return reloc_type == 1; /* R_C6000_ABS32. */
9734 case EM_CYGNUS_V850:
9736 return reloc_type == 6; /* R_V850_ABS32. */
9738 return reloc_type == 1; /* R_VAX_32. */
9741 return reloc_type == 10; /* R_X86_64_32. */
9744 return reloc_type == 3; /* R_XC16C_ABS_32. */
9746 return reloc_type == 1; /* R_XSTROMY16_32. */
9749 return reloc_type == 1; /* R_XTENSA_32. */
9751 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
9752 elf_header.e_machine);
9757 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9758 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
9761 is_32bit_pcrel_reloc (unsigned int reloc_type)
9763 switch (elf_header.e_machine)
9767 return reloc_type == 2; /* R_386_PC32. */
9769 return reloc_type == 4; /* R_68K_PC32. */
9771 return reloc_type == 10; /* R_ALPHA_SREL32. */
9773 return reloc_type == 3; /* R_ARM_REL32 */
9775 return reloc_type == 2; /* R_MICROBLAZE_32_PCREL. */
9777 return reloc_type == 9; /* R_PARISC_PCREL32. */
9779 return reloc_type == 26; /* R_PPC_REL32. */
9781 return reloc_type == 26; /* R_PPC64_REL32. */
9784 return reloc_type == 5; /* R_390_PC32. */
9786 return reloc_type == 2; /* R_SH_REL32. */
9787 case EM_SPARC32PLUS:
9790 return reloc_type == 6; /* R_SPARC_DISP32. */
9792 return reloc_type == 13; /* R_SPU_REL32. */
9795 return reloc_type == 2; /* R_X86_64_PC32. */
9798 return reloc_type == 14; /* R_XTENSA_32_PCREL. */
9800 /* Do not abort or issue an error message here. Not all targets use
9801 pc-relative 32-bit relocs in their DWARF debug information and we
9802 have already tested for target coverage in is_32bit_abs_reloc. A
9803 more helpful warning message will be generated by apply_relocations
9804 anyway, so just return. */
9809 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9810 a 64-bit absolute RELA relocation used in DWARF debug sections. */
9813 is_64bit_abs_reloc (unsigned int reloc_type)
9815 switch (elf_header.e_machine)
9818 return reloc_type == 2; /* R_ALPHA_REFQUAD. */
9820 return reloc_type == 0x27; /* R_IA64_DIR64LSB. */
9822 return reloc_type == 80; /* R_PARISC_DIR64. */
9824 return reloc_type == 38; /* R_PPC64_ADDR64. */
9825 case EM_SPARC32PLUS:
9828 return reloc_type == 54; /* R_SPARC_UA64. */
9831 return reloc_type == 1; /* R_X86_64_64. */
9834 return reloc_type == 22; /* R_S390_64 */
9836 return reloc_type == 18; /* R_MIPS_64 */
9842 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
9843 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
9846 is_64bit_pcrel_reloc (unsigned int reloc_type)
9848 switch (elf_header.e_machine)
9851 return reloc_type == 11; /* R_ALPHA_SREL64 */
9853 return reloc_type == 0x4f; /* R_IA64_PCREL64LSB */
9855 return reloc_type == 72; /* R_PARISC_PCREL64 */
9857 return reloc_type == 44; /* R_PPC64_REL64 */
9858 case EM_SPARC32PLUS:
9861 return reloc_type == 46; /* R_SPARC_DISP64 */
9864 return reloc_type == 24; /* R_X86_64_PC64 */
9867 return reloc_type == 23; /* R_S390_PC64 */
9873 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9874 a 24-bit absolute RELA relocation used in DWARF debug sections. */
9877 is_24bit_abs_reloc (unsigned int reloc_type)
9879 switch (elf_header.e_machine)
9881 case EM_CYGNUS_MN10200:
9883 return reloc_type == 4; /* R_MN10200_24. */
9889 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9890 a 16-bit absolute RELA relocation used in DWARF debug sections. */
9893 is_16bit_abs_reloc (unsigned int reloc_type)
9895 switch (elf_header.e_machine)
9899 return reloc_type == 4; /* R_AVR_16. */
9900 case EM_CYGNUS_D10V:
9902 return reloc_type == 3; /* R_D10V_16. */
9906 return reloc_type == R_H8_DIR16;
9909 return reloc_type == 1; /* R_IP2K_16. */
9912 return reloc_type == 1; /* R_M32C_16 */
9915 return reloc_type == 5; /* R_MSP430_16_BYTE. */
9916 case EM_ALTERA_NIOS2:
9918 return reloc_type == 9; /* R_NIOS_16. */
9920 return reloc_type == 2; /* R_C6000_ABS16. */
9923 return reloc_type == 2; /* R_XC16C_ABS_16. */
9929 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
9930 relocation entries (possibly formerly used for SHT_GROUP sections). */
9933 is_none_reloc (unsigned int reloc_type)
9935 switch (elf_header.e_machine)
9937 case EM_68K: /* R_68K_NONE. */
9938 case EM_386: /* R_386_NONE. */
9939 case EM_SPARC32PLUS:
9941 case EM_SPARC: /* R_SPARC_NONE. */
9942 case EM_MIPS: /* R_MIPS_NONE. */
9943 case EM_PARISC: /* R_PARISC_NONE. */
9944 case EM_ALPHA: /* R_ALPHA_NONE. */
9945 case EM_PPC: /* R_PPC_NONE. */
9946 case EM_PPC64: /* R_PPC64_NONE. */
9947 case EM_ARM: /* R_ARM_NONE. */
9948 case EM_IA_64: /* R_IA64_NONE. */
9949 case EM_SH: /* R_SH_NONE. */
9951 case EM_S390: /* R_390_NONE. */
9952 case EM_CRIS: /* R_CRIS_NONE. */
9953 case EM_X86_64: /* R_X86_64_NONE. */
9954 case EM_L1OM: /* R_X86_64_NONE. */
9955 case EM_MN10300: /* R_MN10300_NONE. */
9956 case EM_MOXIE: /* R_MOXIE_NONE. */
9957 case EM_M32R: /* R_M32R_NONE. */
9958 case EM_TI_C6000:/* R_C6000_NONE. */
9960 case EM_C166: /* R_XC16X_NONE. */
9961 return reloc_type == 0;
9964 return (reloc_type == 0 /* R_XTENSA_NONE. */
9965 || reloc_type == 17 /* R_XTENSA_DIFF8. */
9966 || reloc_type == 18 /* R_XTENSA_DIFF16. */
9967 || reloc_type == 19 /* R_XTENSA_DIFF32. */);
9972 /* Apply relocations to a section.
9973 Note: So far support has been added only for those relocations
9974 which can be found in debug sections.
9975 FIXME: Add support for more relocations ? */
9978 apply_relocations (void * file,
9979 Elf_Internal_Shdr * section,
9980 unsigned char * start)
9982 Elf_Internal_Shdr * relsec;
9983 unsigned char * end = start + section->sh_size;
9985 if (elf_header.e_type != ET_REL)
9988 /* Find the reloc section associated with the section. */
9989 for (relsec = section_headers;
9990 relsec < section_headers + elf_header.e_shnum;
9993 bfd_boolean is_rela;
9994 unsigned long num_relocs;
9995 Elf_Internal_Rela * relocs;
9996 Elf_Internal_Rela * rp;
9997 Elf_Internal_Shdr * symsec;
9998 Elf_Internal_Sym * symtab;
9999 Elf_Internal_Sym * sym;
10001 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
10002 || relsec->sh_info >= elf_header.e_shnum
10003 || section_headers + relsec->sh_info != section
10004 || relsec->sh_size == 0
10005 || relsec->sh_link >= elf_header.e_shnum)
10008 is_rela = relsec->sh_type == SHT_RELA;
10012 if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
10013 relsec->sh_size, & relocs, & num_relocs))
10018 if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
10019 relsec->sh_size, & relocs, & num_relocs))
10023 /* SH uses RELA but uses in place value instead of the addend field. */
10024 if (elf_header.e_machine == EM_SH)
10027 symsec = section_headers + relsec->sh_link;
10028 symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec);
10030 for (rp = relocs; rp < relocs + num_relocs; ++rp)
10033 unsigned int reloc_type;
10034 unsigned int reloc_size;
10035 unsigned char * rloc;
10037 reloc_type = get_reloc_type (rp->r_info);
10039 if (target_specific_reloc_handling (rp, start, symtab))
10041 else if (is_none_reloc (reloc_type))
10043 else if (is_32bit_abs_reloc (reloc_type)
10044 || is_32bit_pcrel_reloc (reloc_type))
10046 else if (is_64bit_abs_reloc (reloc_type)
10047 || is_64bit_pcrel_reloc (reloc_type))
10049 else if (is_24bit_abs_reloc (reloc_type))
10051 else if (is_16bit_abs_reloc (reloc_type))
10055 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
10056 reloc_type, SECTION_NAME (section));
10060 rloc = start + rp->r_offset;
10061 if ((rloc + reloc_size) > end)
10063 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
10064 (unsigned long) rp->r_offset,
10065 SECTION_NAME (section));
10069 sym = symtab + get_reloc_symindex (rp->r_info);
10071 /* If the reloc has a symbol associated with it,
10072 make sure that it is of an appropriate type.
10074 Relocations against symbols without type can happen.
10075 Gcc -feliminate-dwarf2-dups may generate symbols
10076 without type for debug info.
10078 Icc generates relocations against function symbols
10079 instead of local labels.
10081 Relocations against object symbols can happen, eg when
10082 referencing a global array. For an example of this see
10083 the _clz.o binary in libgcc.a. */
10085 && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
10087 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
10088 get_symbol_type (ELF_ST_TYPE (sym->st_info)),
10089 (long int)(rp - relocs),
10090 SECTION_NAME (relsec));
10096 addend += rp->r_addend;
10097 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
10098 partial_inplace. */
10100 || (elf_header.e_machine == EM_XTENSA
10101 && reloc_type == 1)
10102 || ((elf_header.e_machine == EM_PJ
10103 || elf_header.e_machine == EM_PJ_OLD)
10104 && reloc_type == 1)
10105 || ((elf_header.e_machine == EM_D30V
10106 || elf_header.e_machine == EM_CYGNUS_D30V)
10107 && reloc_type == 12))
10108 addend += byte_get (rloc, reloc_size);
10110 if (is_32bit_pcrel_reloc (reloc_type)
10111 || is_64bit_pcrel_reloc (reloc_type))
10113 /* On HPPA, all pc-relative relocations are biased by 8. */
10114 if (elf_header.e_machine == EM_PARISC)
10116 byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
10120 byte_put (rloc, addend + sym->st_value, reloc_size);
10129 #ifdef SUPPORT_DISASSEMBLY
10131 disassemble_section (Elf_Internal_Shdr * section, FILE * file)
10133 printf (_("\nAssembly dump of section %s\n"),
10134 SECTION_NAME (section));
10136 /* XXX -- to be done --- XXX */
10142 /* Reads in the contents of SECTION from FILE, returning a pointer
10143 to a malloc'ed buffer or NULL if something went wrong. */
10146 get_section_contents (Elf_Internal_Shdr * section, FILE * file)
10148 bfd_size_type num_bytes;
10150 num_bytes = section->sh_size;
10152 if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
10154 printf (_("\nSection '%s' has no data to dump.\n"),
10155 SECTION_NAME (section));
10159 return (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
10160 _("section contents"));
10165 dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
10167 Elf_Internal_Shdr * relsec;
10168 bfd_size_type num_bytes;
10172 char * name = SECTION_NAME (section);
10173 bfd_boolean some_strings_shown;
10175 start = get_section_contents (section, file);
10179 printf (_("\nString dump of section '%s':\n"), name);
10181 /* If the section being dumped has relocations against it the user might
10182 be expecting these relocations to have been applied. Check for this
10183 case and issue a warning message in order to avoid confusion.
10184 FIXME: Maybe we ought to have an option that dumps a section with
10185 relocs applied ? */
10186 for (relsec = section_headers;
10187 relsec < section_headers + elf_header.e_shnum;
10190 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
10191 || relsec->sh_info >= elf_header.e_shnum
10192 || section_headers + relsec->sh_info != section
10193 || relsec->sh_size == 0
10194 || relsec->sh_link >= elf_header.e_shnum)
10197 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
10201 num_bytes = section->sh_size;
10203 end = start + num_bytes;
10204 some_strings_shown = FALSE;
10208 while (!ISPRINT (* data))
10209 if (++ data >= end)
10215 /* PR 11128: Use two separate invocations in order to work
10216 around bugs in the Solaris 8 implementation of printf. */
10217 printf (" [%6tx] ", data - start);
10218 printf ("%s\n", data);
10220 printf (" [%6Ix] %s\n", (size_t) (data - start), data);
10222 data += strlen (data);
10223 some_strings_shown = TRUE;
10227 if (! some_strings_shown)
10228 printf (_(" No strings found in this section."));
10236 dump_section_as_bytes (Elf_Internal_Shdr * section,
10238 bfd_boolean relocate)
10240 Elf_Internal_Shdr * relsec;
10241 bfd_size_type bytes;
10243 unsigned char * data;
10244 unsigned char * start;
10246 start = (unsigned char *) get_section_contents (section, file);
10250 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
10254 apply_relocations (file, section, start);
10258 /* If the section being dumped has relocations against it the user might
10259 be expecting these relocations to have been applied. Check for this
10260 case and issue a warning message in order to avoid confusion.
10261 FIXME: Maybe we ought to have an option that dumps a section with
10262 relocs applied ? */
10263 for (relsec = section_headers;
10264 relsec < section_headers + elf_header.e_shnum;
10267 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
10268 || relsec->sh_info >= elf_header.e_shnum
10269 || section_headers + relsec->sh_info != section
10270 || relsec->sh_size == 0
10271 || relsec->sh_link >= elf_header.e_shnum)
10274 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
10279 addr = section->sh_addr;
10280 bytes = section->sh_size;
10289 lbytes = (bytes > 16 ? 16 : bytes);
10291 printf (" 0x%8.8lx ", (unsigned long) addr);
10293 for (j = 0; j < 16; j++)
10296 printf ("%2.2x", data[j]);
10304 for (j = 0; j < lbytes; j++)
10307 if (k >= ' ' && k < 0x7f)
10325 /* Uncompresses a section that was compressed using zlib, in place. */
10328 uncompress_section_contents (unsigned char **buffer ATTRIBUTE_UNUSED,
10329 dwarf_size_type *size ATTRIBUTE_UNUSED)
10331 #ifndef HAVE_ZLIB_H
10334 dwarf_size_type compressed_size = *size;
10335 unsigned char * compressed_buffer = *buffer;
10336 dwarf_size_type uncompressed_size;
10337 unsigned char * uncompressed_buffer;
10340 dwarf_size_type header_size = 12;
10342 /* Read the zlib header. In this case, it should be "ZLIB" followed
10343 by the uncompressed section size, 8 bytes in big-endian order. */
10344 if (compressed_size < header_size
10345 || ! streq ((char *) compressed_buffer, "ZLIB"))
10348 uncompressed_size = compressed_buffer[4]; uncompressed_size <<= 8;
10349 uncompressed_size += compressed_buffer[5]; uncompressed_size <<= 8;
10350 uncompressed_size += compressed_buffer[6]; uncompressed_size <<= 8;
10351 uncompressed_size += compressed_buffer[7]; uncompressed_size <<= 8;
10352 uncompressed_size += compressed_buffer[8]; uncompressed_size <<= 8;
10353 uncompressed_size += compressed_buffer[9]; uncompressed_size <<= 8;
10354 uncompressed_size += compressed_buffer[10]; uncompressed_size <<= 8;
10355 uncompressed_size += compressed_buffer[11];
10357 /* It is possible the section consists of several compressed
10358 buffers concatenated together, so we uncompress in a loop. */
10359 strm.zalloc = NULL;
10361 strm.opaque = NULL;
10362 strm.avail_in = compressed_size - header_size;
10363 strm.next_in = (Bytef *) compressed_buffer + header_size;
10364 strm.avail_out = uncompressed_size;
10365 uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
10367 rc = inflateInit (& strm);
10368 while (strm.avail_in > 0)
10372 strm.next_out = ((Bytef *) uncompressed_buffer
10373 + (uncompressed_size - strm.avail_out));
10374 rc = inflate (&strm, Z_FINISH);
10375 if (rc != Z_STREAM_END)
10377 rc = inflateReset (& strm);
10379 rc = inflateEnd (& strm);
10381 || strm.avail_out != 0)
10384 free (compressed_buffer);
10385 *buffer = uncompressed_buffer;
10386 *size = uncompressed_size;
10390 free (uncompressed_buffer);
10391 /* Indicate decompression failure. */
10394 #endif /* HAVE_ZLIB_H */
10398 load_specific_debug_section (enum dwarf_section_display_enum debug,
10399 Elf_Internal_Shdr * sec, void * file)
10401 struct dwarf_section * section = &debug_displays [debug].section;
10404 /* If it is already loaded, do nothing. */
10405 if (section->start != NULL)
10408 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
10409 section->address = sec->sh_addr;
10410 section->start = (unsigned char *) get_data (NULL, (FILE *) file,
10412 sec->sh_size, buf);
10413 if (section->start == NULL)
10417 section->size = sec->sh_size;
10418 if (uncompress_section_contents (§ion->start, §ion->size))
10419 sec->sh_size = section->size;
10422 if (section->start == NULL)
10425 if (debug_displays [debug].relocate)
10426 apply_relocations ((FILE *) file, sec, section->start);
10432 load_debug_section (enum dwarf_section_display_enum debug, void * file)
10434 struct dwarf_section * section = &debug_displays [debug].section;
10435 Elf_Internal_Shdr * sec;
10437 /* Locate the debug section. */
10438 sec = find_section (section->uncompressed_name);
10440 section->name = section->uncompressed_name;
10443 sec = find_section (section->compressed_name);
10445 section->name = section->compressed_name;
10450 return load_specific_debug_section (debug, sec, (FILE *) file);
10454 free_debug_section (enum dwarf_section_display_enum debug)
10456 struct dwarf_section * section = &debug_displays [debug].section;
10458 if (section->start == NULL)
10461 free ((char *) section->start);
10462 section->start = NULL;
10463 section->address = 0;
10468 display_debug_section (Elf_Internal_Shdr * section, FILE * file)
10470 char * name = SECTION_NAME (section);
10471 bfd_size_type length;
10475 length = section->sh_size;
10478 printf (_("\nSection '%s' has no debugging data.\n"), name);
10481 if (section->sh_type == SHT_NOBITS)
10483 /* There is no point in dumping the contents of a debugging section
10484 which has the NOBITS type - the bits in the file will be random.
10485 This can happen when a file containing a .eh_frame section is
10486 stripped with the --only-keep-debug command line option. */
10487 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"), name);
10491 if (const_strneq (name, ".gnu.linkonce.wi."))
10492 name = ".debug_info";
10494 /* See if we know how to display the contents of this section. */
10495 for (i = 0; i < max; i++)
10496 if (streq (debug_displays[i].section.uncompressed_name, name)
10497 || streq (debug_displays[i].section.compressed_name, name))
10499 struct dwarf_section * sec = &debug_displays [i].section;
10500 int secondary = (section != find_section (name));
10503 free_debug_section ((enum dwarf_section_display_enum) i);
10505 if (streq (sec->uncompressed_name, name))
10506 sec->name = sec->uncompressed_name;
10508 sec->name = sec->compressed_name;
10509 if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
10512 result &= debug_displays[i].display (sec, file);
10514 if (secondary || (i != info && i != abbrev))
10515 free_debug_section ((enum dwarf_section_display_enum) i);
10523 printf (_("Unrecognized debug section: %s\n"), name);
10530 /* Set DUMP_SECTS for all sections where dumps were requested
10531 based on section name. */
10534 initialise_dumps_byname (void)
10536 struct dump_list_entry * cur;
10538 for (cur = dump_sects_byname; cur; cur = cur->next)
10543 for (i = 0, any = 0; i < elf_header.e_shnum; i++)
10544 if (streq (SECTION_NAME (section_headers + i), cur->name))
10546 request_dump_bynumber (i, cur->type);
10551 warn (_("Section '%s' was not dumped because it does not exist!\n"),
10557 process_section_contents (FILE * file)
10559 Elf_Internal_Shdr * section;
10565 initialise_dumps_byname ();
10567 for (i = 0, section = section_headers;
10568 i < elf_header.e_shnum && i < num_dump_sects;
10571 #ifdef SUPPORT_DISASSEMBLY
10572 if (dump_sects[i] & DISASS_DUMP)
10573 disassemble_section (section, file);
10575 if (dump_sects[i] & HEX_DUMP)
10576 dump_section_as_bytes (section, file, FALSE);
10578 if (dump_sects[i] & RELOC_DUMP)
10579 dump_section_as_bytes (section, file, TRUE);
10581 if (dump_sects[i] & STRING_DUMP)
10582 dump_section_as_strings (section, file);
10584 if (dump_sects[i] & DEBUG_DUMP)
10585 display_debug_section (section, file);
10588 /* Check to see if the user requested a
10589 dump of a section that does not exist. */
10590 while (i++ < num_dump_sects)
10592 warn (_("Section %d was not dumped because it does not exist!\n"), i);
10596 process_mips_fpe_exception (int mask)
10601 if (mask & OEX_FPU_INEX)
10602 fputs ("INEX", stdout), first = 0;
10603 if (mask & OEX_FPU_UFLO)
10604 printf ("%sUFLO", first ? "" : "|"), first = 0;
10605 if (mask & OEX_FPU_OFLO)
10606 printf ("%sOFLO", first ? "" : "|"), first = 0;
10607 if (mask & OEX_FPU_DIV0)
10608 printf ("%sDIV0", first ? "" : "|"), first = 0;
10609 if (mask & OEX_FPU_INVAL)
10610 printf ("%sINVAL", first ? "" : "|");
10613 fputs ("0", stdout);
10616 /* ARM EABI attributes section. */
10621 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
10623 const char ** table;
10624 } arm_attr_public_tag;
10626 static const char * arm_attr_tag_CPU_arch[] =
10627 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
10628 "v6K", "v7", "v6-M", "v6S-M", "v7E-M"};
10629 static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
10630 static const char * arm_attr_tag_THUMB_ISA_use[] =
10631 {"No", "Thumb-1", "Thumb-2"};
10632 static const char * arm_attr_tag_FP_arch[] =
10633 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16"};
10634 static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
10635 static const char * arm_attr_tag_Advanced_SIMD_arch[] =
10636 {"No", "NEONv1", "NEONv1 with Fused-MAC"};
10637 static const char * arm_attr_tag_PCS_config[] =
10638 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
10639 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
10640 static const char * arm_attr_tag_ABI_PCS_R9_use[] =
10641 {"V6", "SB", "TLS", "Unused"};
10642 static const char * arm_attr_tag_ABI_PCS_RW_data[] =
10643 {"Absolute", "PC-relative", "SB-relative", "None"};
10644 static const char * arm_attr_tag_ABI_PCS_RO_data[] =
10645 {"Absolute", "PC-relative", "None"};
10646 static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
10647 {"None", "direct", "GOT-indirect"};
10648 static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
10649 {"None", "??? 1", "2", "??? 3", "4"};
10650 static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
10651 static const char * arm_attr_tag_ABI_FP_denormal[] =
10652 {"Unused", "Needed", "Sign only"};
10653 static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
10654 static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
10655 static const char * arm_attr_tag_ABI_FP_number_model[] =
10656 {"Unused", "Finite", "RTABI", "IEEE 754"};
10657 static const char * arm_attr_tag_ABI_enum_size[] =
10658 {"Unused", "small", "int", "forced to int"};
10659 static const char * arm_attr_tag_ABI_HardFP_use[] =
10660 {"As Tag_FP_arch", "SP only", "DP only", "SP and DP"};
10661 static const char * arm_attr_tag_ABI_VFP_args[] =
10662 {"AAPCS", "VFP registers", "custom"};
10663 static const char * arm_attr_tag_ABI_WMMX_args[] =
10664 {"AAPCS", "WMMX registers", "custom"};
10665 static const char * arm_attr_tag_ABI_optimization_goals[] =
10666 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
10667 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
10668 static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
10669 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
10670 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
10671 static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
10672 static const char * arm_attr_tag_FP_HP_extension[] =
10673 {"Not Allowed", "Allowed"};
10674 static const char * arm_attr_tag_ABI_FP_16bit_format[] =
10675 {"None", "IEEE 754", "Alternative Format"};
10676 static const char * arm_attr_tag_MPextension_use[] =
10677 {"Not Allowed", "Allowed"};
10678 static const char * arm_attr_tag_DIV_use[] =
10679 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
10680 "Allowed in v7-A with integer division extension"};
10681 static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
10682 static const char * arm_attr_tag_Virtualization_use[] =
10683 {"Not Allowed", "TrustZone", "Virtualization Extensions",
10684 "TrustZone and Virtualization Extensions"};
10685 static const char * arm_attr_tag_MPextension_use_legacy[] =
10686 {"Not Allowed", "Allowed"};
10688 #define LOOKUP(id, name) \
10689 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
10690 static arm_attr_public_tag arm_attr_public_tags[] =
10692 {4, "CPU_raw_name", 1, NULL},
10693 {5, "CPU_name", 1, NULL},
10694 LOOKUP(6, CPU_arch),
10695 {7, "CPU_arch_profile", 0, NULL},
10696 LOOKUP(8, ARM_ISA_use),
10697 LOOKUP(9, THUMB_ISA_use),
10698 LOOKUP(10, FP_arch),
10699 LOOKUP(11, WMMX_arch),
10700 LOOKUP(12, Advanced_SIMD_arch),
10701 LOOKUP(13, PCS_config),
10702 LOOKUP(14, ABI_PCS_R9_use),
10703 LOOKUP(15, ABI_PCS_RW_data),
10704 LOOKUP(16, ABI_PCS_RO_data),
10705 LOOKUP(17, ABI_PCS_GOT_use),
10706 LOOKUP(18, ABI_PCS_wchar_t),
10707 LOOKUP(19, ABI_FP_rounding),
10708 LOOKUP(20, ABI_FP_denormal),
10709 LOOKUP(21, ABI_FP_exceptions),
10710 LOOKUP(22, ABI_FP_user_exceptions),
10711 LOOKUP(23, ABI_FP_number_model),
10712 {24, "ABI_align_needed", 0, NULL},
10713 {25, "ABI_align_preserved", 0, NULL},
10714 LOOKUP(26, ABI_enum_size),
10715 LOOKUP(27, ABI_HardFP_use),
10716 LOOKUP(28, ABI_VFP_args),
10717 LOOKUP(29, ABI_WMMX_args),
10718 LOOKUP(30, ABI_optimization_goals),
10719 LOOKUP(31, ABI_FP_optimization_goals),
10720 {32, "compatibility", 0, NULL},
10721 LOOKUP(34, CPU_unaligned_access),
10722 LOOKUP(36, FP_HP_extension),
10723 LOOKUP(38, ABI_FP_16bit_format),
10724 LOOKUP(42, MPextension_use),
10725 LOOKUP(44, DIV_use),
10726 {64, "nodefaults", 0, NULL},
10727 {65, "also_compatible_with", 0, NULL},
10728 LOOKUP(66, T2EE_use),
10729 {67, "conformance", 1, NULL},
10730 LOOKUP(68, Virtualization_use),
10731 LOOKUP(70, MPextension_use_legacy)
10735 static unsigned char *
10736 display_arm_attribute (unsigned char * p)
10741 arm_attr_public_tag * attr;
10745 tag = read_uleb128 (p, &len);
10748 for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
10750 if (arm_attr_public_tags[i].tag == tag)
10752 attr = &arm_attr_public_tags[i];
10759 printf (" Tag_%s: ", attr->name);
10760 switch (attr->type)
10765 case 7: /* Tag_CPU_arch_profile. */
10766 val = read_uleb128 (p, &len);
10770 case 0: printf (_("None\n")); break;
10771 case 'A': printf (_("Application\n")); break;
10772 case 'R': printf (_("Realtime\n")); break;
10773 case 'M': printf (_("Microcontroller\n")); break;
10774 case 'S': printf (_("Application or Realtime\n")); break;
10775 default: printf ("??? (%d)\n", val); break;
10779 case 24: /* Tag_align_needed. */
10780 val = read_uleb128 (p, &len);
10784 case 0: printf (_("None\n")); break;
10785 case 1: printf (_("8-byte\n")); break;
10786 case 2: printf (_("4-byte\n")); break;
10787 case 3: printf ("??? 3\n"); break;
10790 printf (_("8-byte and up to %d-byte extended\n"),
10793 printf ("??? (%d)\n", val);
10798 case 25: /* Tag_align_preserved. */
10799 val = read_uleb128 (p, &len);
10803 case 0: printf (_("None\n")); break;
10804 case 1: printf (_("8-byte, except leaf SP\n")); break;
10805 case 2: printf (_("8-byte\n")); break;
10806 case 3: printf ("??? 3\n"); break;
10809 printf (_("8-byte and up to %d-byte extended\n"),
10812 printf ("??? (%d)\n", val);
10817 case 32: /* Tag_compatibility. */
10818 val = read_uleb128 (p, &len);
10820 printf (_("flag = %d, vendor = %s\n"), val, p);
10821 p += strlen ((char *) p) + 1;
10824 case 64: /* Tag_nodefaults. */
10826 printf (_("True\n"));
10829 case 65: /* Tag_also_compatible_with. */
10830 val = read_uleb128 (p, &len);
10832 if (val == 6 /* Tag_CPU_arch. */)
10834 val = read_uleb128 (p, &len);
10836 if ((unsigned int)val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
10837 printf ("??? (%d)\n", val);
10839 printf ("%s\n", arm_attr_tag_CPU_arch[val]);
10843 while (*(p++) != '\0' /* NUL terminator. */);
10857 assert (attr->type & 0x80);
10858 val = read_uleb128 (p, &len);
10860 type = attr->type & 0x7f;
10862 printf ("??? (%d)\n", val);
10864 printf ("%s\n", attr->table[val]);
10871 type = 1; /* String. */
10873 type = 2; /* uleb128. */
10874 printf (" Tag_unknown_%d: ", tag);
10879 printf ("\"%s\"\n", p);
10880 p += strlen ((char *) p) + 1;
10884 val = read_uleb128 (p, &len);
10886 printf ("%d (0x%x)\n", val, val);
10892 static unsigned char *
10893 display_gnu_attribute (unsigned char * p,
10894 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int))
10901 tag = read_uleb128 (p, &len);
10904 /* Tag_compatibility is the only generic GNU attribute defined at
10908 val = read_uleb128 (p, &len);
10910 printf (_("flag = %d, vendor = %s\n"), val, p);
10911 p += strlen ((char *) p) + 1;
10915 if ((tag & 2) == 0 && display_proc_gnu_attribute)
10916 return display_proc_gnu_attribute (p, tag);
10919 type = 1; /* String. */
10921 type = 2; /* uleb128. */
10922 printf (" Tag_unknown_%d: ", tag);
10926 printf ("\"%s\"\n", p);
10927 p += strlen ((char *) p) + 1;
10931 val = read_uleb128 (p, &len);
10933 printf ("%d (0x%x)\n", val, val);
10939 static unsigned char *
10940 display_power_gnu_attribute (unsigned char * p, int tag)
10946 if (tag == Tag_GNU_Power_ABI_FP)
10948 val = read_uleb128 (p, &len);
10950 printf (" Tag_GNU_Power_ABI_FP: ");
10955 printf (_("Hard or soft float\n"));
10958 printf (_("Hard float\n"));
10961 printf (_("Soft float\n"));
10964 printf (_("Single-precision hard float\n"));
10967 printf ("??? (%d)\n", val);
10973 if (tag == Tag_GNU_Power_ABI_Vector)
10975 val = read_uleb128 (p, &len);
10977 printf (" Tag_GNU_Power_ABI_Vector: ");
10981 printf (_("Any\n"));
10984 printf (_("Generic\n"));
10987 printf ("AltiVec\n");
10993 printf ("??? (%d)\n", val);
10999 if (tag == Tag_GNU_Power_ABI_Struct_Return)
11001 val = read_uleb128 (p, &len);
11003 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
11007 printf (_("Any\n"));
11010 printf ("r3/r4\n");
11013 printf (_("Memory\n"));
11016 printf ("??? (%d)\n", val);
11023 type = 1; /* String. */
11025 type = 2; /* uleb128. */
11026 printf (" Tag_unknown_%d: ", tag);
11030 printf ("\"%s\"\n", p);
11031 p += strlen ((char *) p) + 1;
11035 val = read_uleb128 (p, &len);
11037 printf ("%d (0x%x)\n", val, val);
11043 static unsigned char *
11044 display_mips_gnu_attribute (unsigned char * p, int tag)
11050 if (tag == Tag_GNU_MIPS_ABI_FP)
11052 val = read_uleb128 (p, &len);
11054 printf (" Tag_GNU_MIPS_ABI_FP: ");
11059 printf (_("Hard or soft float\n"));
11062 printf (_("Hard float (double precision)\n"));
11065 printf (_("Hard float (single precision)\n"));
11068 printf (_("Soft float\n"));
11071 printf (_("Hard float (MIPS32r2 64-bit FPU)\n"));
11074 printf ("??? (%d)\n", val);
11081 type = 1; /* String. */
11083 type = 2; /* uleb128. */
11084 printf (" Tag_unknown_%d: ", tag);
11088 printf ("\"%s\"\n", p);
11089 p += strlen ((char *) p) + 1;
11093 val = read_uleb128 (p, &len);
11095 printf ("%d (0x%x)\n", val, val);
11101 static unsigned char *
11102 display_tic6x_attribute (unsigned char * p)
11108 tag = read_uleb128 (p, &len);
11114 val = read_uleb128 (p, &len);
11116 printf (" Tag_ISA: ");
11120 case C6XABI_Tag_ISA_none:
11121 printf (_("None\n"));
11123 case C6XABI_Tag_ISA_C62X:
11126 case C6XABI_Tag_ISA_C67X:
11129 case C6XABI_Tag_ISA_C67XP:
11130 printf ("C67x+\n");
11132 case C6XABI_Tag_ISA_C64X:
11135 case C6XABI_Tag_ISA_C64XP:
11136 printf ("C64x+\n");
11138 case C6XABI_Tag_ISA_C674X:
11139 printf ("C674x\n");
11142 printf ("??? (%d)\n", val);
11147 case Tag_ABI_wchar_t:
11148 val = read_uleb128 (p, &len);
11150 printf (" Tag_ABI_wchar_t: ");
11154 printf (_("Not used\n"));
11157 printf (_("2 bytes\n"));
11160 printf (_("4 bytes\n"));
11163 printf ("??? (%d)\n", val);
11168 case Tag_ABI_stack_align_needed:
11169 val = read_uleb128 (p, &len);
11171 printf (" Tag_ABI_stack_align_needed: ");
11175 printf (_("8-byte\n"));
11178 printf (_("16-byte\n"));
11181 printf ("??? (%d)\n", val);
11186 case Tag_ABI_stack_align_preserved:
11187 val = read_uleb128 (p, &len);
11189 printf (" Tag_ABI_stack_align_preserved: ");
11193 printf (_("8-byte\n"));
11196 printf (_("16-byte\n"));
11199 printf ("??? (%d)\n", val);
11205 val = read_uleb128 (p, &len);
11207 printf (" Tag_ABI_DSBT: ");
11211 printf (_("DSBT addressing not used\n"));
11214 printf (_("DSBT addressing used\n"));
11217 printf ("??? (%d)\n", val);
11223 val = read_uleb128 (p, &len);
11225 printf (" Tag_ABI_PID: ");
11229 printf (_("Data addressing position-dependent\n"));
11232 printf (_("Data addressing position-independent, GOT near DP\n"));
11235 printf (_("Data addressing position-independent, GOT far from DP\n"));
11238 printf ("??? (%d)\n", val);
11244 val = read_uleb128 (p, &len);
11246 printf (" Tag_ABI_PIC: ");
11250 printf (_("Code addressing position-dependent\n"));
11253 printf (_("Code addressing position-independent\n"));
11256 printf ("??? (%d)\n", val);
11261 case Tag_ABI_array_object_alignment:
11262 val = read_uleb128 (p, &len);
11264 printf (" Tag_ABI_array_object_alignment: ");
11268 printf (_("8-byte\n"));
11271 printf (_("4-byte\n"));
11274 printf (_("16-byte\n"));
11277 printf ("??? (%d)\n", val);
11282 case Tag_ABI_array_object_align_expected:
11283 val = read_uleb128 (p, &len);
11285 printf (" Tag_ABI_array_object_align_expected: ");
11289 printf (_("8-byte\n"));
11292 printf (_("4-byte\n"));
11295 printf (_("16-byte\n"));
11298 printf ("??? (%d)\n", val);
11303 case Tag_ABI_compatibility:
11304 val = read_uleb128 (p, &len);
11306 printf (" Tag_ABI_compatibility: ");
11307 printf (_("flag = %d, vendor = %s\n"), val, p);
11308 p += strlen ((char *) p) + 1;
11311 case Tag_ABI_conformance:
11312 printf (" Tag_ABI_conformance: ");
11313 printf ("\"%s\"\n", p);
11314 p += strlen ((char *) p) + 1;
11318 printf (" Tag_unknown_%d: ", tag);
11322 printf ("\"%s\"\n", p);
11323 p += strlen ((char *) p) + 1;
11327 val = read_uleb128 (p, &len);
11329 printf ("%d (0x%x)\n", val, val);
11336 process_attributes (FILE * file,
11337 const char * public_name,
11338 unsigned int proc_type,
11339 unsigned char * (* display_pub_attribute) (unsigned char *),
11340 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int))
11342 Elf_Internal_Shdr * sect;
11343 unsigned char * contents;
11345 unsigned char * end;
11346 bfd_vma section_len;
11350 /* Find the section header so that we get the size. */
11351 for (i = 0, sect = section_headers;
11352 i < elf_header.e_shnum;
11355 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
11358 contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
11359 sect->sh_size, _("attributes"));
11360 if (contents == NULL)
11366 len = sect->sh_size - 1;
11372 bfd_boolean public_section;
11373 bfd_boolean gnu_section;
11375 section_len = byte_get (p, 4);
11378 if (section_len > len)
11380 printf (_("ERROR: Bad section length (%d > %d)\n"),
11381 (int) section_len, (int) len);
11385 len -= section_len;
11386 printf (_("Attribute Section: %s\n"), p);
11388 if (public_name && streq ((char *) p, public_name))
11389 public_section = TRUE;
11391 public_section = FALSE;
11393 if (streq ((char *) p, "gnu"))
11394 gnu_section = TRUE;
11396 gnu_section = FALSE;
11398 namelen = strlen ((char *) p) + 1;
11400 section_len -= namelen + 4;
11402 while (section_len > 0)
11408 size = byte_get (p, 4);
11409 if (size > section_len)
11411 printf (_("ERROR: Bad subsection length (%d > %d)\n"),
11412 (int) size, (int) section_len);
11413 size = section_len;
11416 section_len -= size;
11417 end = p + size - 1;
11423 printf (_("File Attributes\n"));
11426 printf (_("Section Attributes:"));
11429 printf (_("Symbol Attributes:"));
11435 val = read_uleb128 (p, &j);
11439 printf (" %d", val);
11444 printf (_("Unknown tag: %d\n"), tag);
11445 public_section = FALSE;
11449 if (public_section)
11452 p = display_pub_attribute (p);
11454 else if (gnu_section)
11457 p = display_gnu_attribute (p,
11458 display_proc_gnu_attribute);
11462 /* ??? Do something sensible, like dump hex. */
11463 printf (_(" Unknown section contexts\n"));
11470 printf (_("Unknown format '%c'\n"), *p);
11478 process_arm_specific (FILE * file)
11480 return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
11481 display_arm_attribute, NULL);
11485 process_power_specific (FILE * file)
11487 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
11488 display_power_gnu_attribute);
11492 process_tic6x_specific (FILE * file)
11494 return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
11495 display_tic6x_attribute, NULL);
11498 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
11499 Print the Address, Access and Initial fields of an entry at VMA ADDR
11500 and return the VMA of the next entry. */
11503 print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
11506 print_vma (addr, LONG_HEX);
11508 if (addr < pltgot + 0xfff0)
11509 printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
11511 printf ("%10s", "");
11514 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
11519 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
11520 print_vma (entry, LONG_HEX);
11522 return addr + (is_32bit_elf ? 4 : 8);
11525 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
11526 PLTGOT. Print the Address and Initial fields of an entry at VMA
11527 ADDR and return the VMA of the next entry. */
11530 print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
11533 print_vma (addr, LONG_HEX);
11536 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
11541 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
11542 print_vma (entry, LONG_HEX);
11544 return addr + (is_32bit_elf ? 4 : 8);
11548 process_mips_specific (FILE * file)
11550 Elf_Internal_Dyn * entry;
11551 size_t liblist_offset = 0;
11552 size_t liblistno = 0;
11553 size_t conflictsno = 0;
11554 size_t options_offset = 0;
11555 size_t conflicts_offset = 0;
11556 size_t pltrelsz = 0;
11558 bfd_vma pltgot = 0;
11559 bfd_vma mips_pltgot = 0;
11560 bfd_vma jmprel = 0;
11561 bfd_vma local_gotno = 0;
11562 bfd_vma gotsym = 0;
11563 bfd_vma symtabno = 0;
11565 process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
11566 display_mips_gnu_attribute);
11568 /* We have a lot of special sections. Thanks SGI! */
11569 if (dynamic_section == NULL)
11570 /* No information available. */
11573 for (entry = dynamic_section; entry->d_tag != DT_NULL; ++entry)
11574 switch (entry->d_tag)
11576 case DT_MIPS_LIBLIST:
11578 = offset_from_vma (file, entry->d_un.d_val,
11579 liblistno * sizeof (Elf32_External_Lib));
11581 case DT_MIPS_LIBLISTNO:
11582 liblistno = entry->d_un.d_val;
11584 case DT_MIPS_OPTIONS:
11585 options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
11587 case DT_MIPS_CONFLICT:
11589 = offset_from_vma (file, entry->d_un.d_val,
11590 conflictsno * sizeof (Elf32_External_Conflict));
11592 case DT_MIPS_CONFLICTNO:
11593 conflictsno = entry->d_un.d_val;
11596 pltgot = entry->d_un.d_ptr;
11598 case DT_MIPS_LOCAL_GOTNO:
11599 local_gotno = entry->d_un.d_val;
11601 case DT_MIPS_GOTSYM:
11602 gotsym = entry->d_un.d_val;
11604 case DT_MIPS_SYMTABNO:
11605 symtabno = entry->d_un.d_val;
11607 case DT_MIPS_PLTGOT:
11608 mips_pltgot = entry->d_un.d_ptr;
11611 pltrel = entry->d_un.d_val;
11614 pltrelsz = entry->d_un.d_val;
11617 jmprel = entry->d_un.d_ptr;
11623 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
11625 Elf32_External_Lib * elib;
11628 elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
11630 sizeof (Elf32_External_Lib),
11634 printf (_("\nSection '.liblist' contains %lu entries:\n"),
11635 (unsigned long) liblistno);
11636 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
11639 for (cnt = 0; cnt < liblistno; ++cnt)
11646 liblist.l_name = BYTE_GET (elib[cnt].l_name);
11647 atime = BYTE_GET (elib[cnt].l_time_stamp);
11648 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
11649 liblist.l_version = BYTE_GET (elib[cnt].l_version);
11650 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
11652 tmp = gmtime (&atime);
11653 snprintf (timebuf, sizeof (timebuf),
11654 "%04u-%02u-%02uT%02u:%02u:%02u",
11655 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
11656 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
11658 printf ("%3lu: ", (unsigned long) cnt);
11659 if (VALID_DYNAMIC_NAME (liblist.l_name))
11660 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
11662 printf (_("<corrupt: %9ld>"), liblist.l_name);
11663 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
11664 liblist.l_version);
11666 if (liblist.l_flags == 0)
11670 static const struct
11677 { " EXACT_MATCH", LL_EXACT_MATCH },
11678 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
11679 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
11680 { " EXPORTS", LL_EXPORTS },
11681 { " DELAY_LOAD", LL_DELAY_LOAD },
11682 { " DELTA", LL_DELTA }
11684 int flags = liblist.l_flags;
11687 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
11688 if ((flags & l_flags_vals[fcnt].bit) != 0)
11690 fputs (l_flags_vals[fcnt].name, stdout);
11691 flags ^= l_flags_vals[fcnt].bit;
11694 printf (" %#x", (unsigned int) flags);
11704 if (options_offset != 0)
11706 Elf_External_Options * eopt;
11707 Elf_Internal_Shdr * sect = section_headers;
11708 Elf_Internal_Options * iopt;
11709 Elf_Internal_Options * option;
11713 /* Find the section header so that we get the size. */
11714 while (sect->sh_type != SHT_MIPS_OPTIONS)
11717 eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
11718 sect->sh_size, _("options"));
11721 iopt = (Elf_Internal_Options *)
11722 cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
11725 error (_("Out of memory\n"));
11732 while (offset < sect->sh_size)
11734 Elf_External_Options * eoption;
11736 eoption = (Elf_External_Options *) ((char *) eopt + offset);
11738 option->kind = BYTE_GET (eoption->kind);
11739 option->size = BYTE_GET (eoption->size);
11740 option->section = BYTE_GET (eoption->section);
11741 option->info = BYTE_GET (eoption->info);
11743 offset += option->size;
11749 printf (_("\nSection '%s' contains %d entries:\n"),
11750 SECTION_NAME (sect), cnt);
11758 switch (option->kind)
11761 /* This shouldn't happen. */
11762 printf (" NULL %d %lx", option->section, option->info);
11765 printf (" REGINFO ");
11766 if (elf_header.e_machine == EM_MIPS)
11769 Elf32_External_RegInfo * ereg;
11770 Elf32_RegInfo reginfo;
11772 ereg = (Elf32_External_RegInfo *) (option + 1);
11773 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
11774 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
11775 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
11776 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
11777 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
11778 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
11780 printf ("GPR %08lx GP 0x%lx\n",
11781 reginfo.ri_gprmask,
11782 (unsigned long) reginfo.ri_gp_value);
11783 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
11784 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
11785 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
11790 Elf64_External_RegInfo * ereg;
11791 Elf64_Internal_RegInfo reginfo;
11793 ereg = (Elf64_External_RegInfo *) (option + 1);
11794 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
11795 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
11796 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
11797 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
11798 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
11799 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
11801 printf ("GPR %08lx GP 0x",
11802 reginfo.ri_gprmask);
11803 printf_vma (reginfo.ri_gp_value);
11806 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
11807 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
11808 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
11812 case ODK_EXCEPTIONS:
11813 fputs (" EXCEPTIONS fpe_min(", stdout);
11814 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
11815 fputs (") fpe_max(", stdout);
11816 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
11817 fputs (")", stdout);
11819 if (option->info & OEX_PAGE0)
11820 fputs (" PAGE0", stdout);
11821 if (option->info & OEX_SMM)
11822 fputs (" SMM", stdout);
11823 if (option->info & OEX_FPDBUG)
11824 fputs (" FPDBUG", stdout);
11825 if (option->info & OEX_DISMISS)
11826 fputs (" DISMISS", stdout);
11829 fputs (" PAD ", stdout);
11830 if (option->info & OPAD_PREFIX)
11831 fputs (" PREFIX", stdout);
11832 if (option->info & OPAD_POSTFIX)
11833 fputs (" POSTFIX", stdout);
11834 if (option->info & OPAD_SYMBOL)
11835 fputs (" SYMBOL", stdout);
11838 fputs (" HWPATCH ", stdout);
11839 if (option->info & OHW_R4KEOP)
11840 fputs (" R4KEOP", stdout);
11841 if (option->info & OHW_R8KPFETCH)
11842 fputs (" R8KPFETCH", stdout);
11843 if (option->info & OHW_R5KEOP)
11844 fputs (" R5KEOP", stdout);
11845 if (option->info & OHW_R5KCVTL)
11846 fputs (" R5KCVTL", stdout);
11849 fputs (" FILL ", stdout);
11850 /* XXX Print content of info word? */
11853 fputs (" TAGS ", stdout);
11854 /* XXX Print content of info word? */
11857 fputs (" HWAND ", stdout);
11858 if (option->info & OHWA0_R4KEOP_CHECKED)
11859 fputs (" R4KEOP_CHECKED", stdout);
11860 if (option->info & OHWA0_R4KEOP_CLEAN)
11861 fputs (" R4KEOP_CLEAN", stdout);
11864 fputs (" HWOR ", stdout);
11865 if (option->info & OHWA0_R4KEOP_CHECKED)
11866 fputs (" R4KEOP_CHECKED", stdout);
11867 if (option->info & OHWA0_R4KEOP_CLEAN)
11868 fputs (" R4KEOP_CLEAN", stdout);
11871 printf (" GP_GROUP %#06lx self-contained %#06lx",
11872 option->info & OGP_GROUP,
11873 (option->info & OGP_SELF) >> 16);
11876 printf (" IDENT %#06lx self-contained %#06lx",
11877 option->info & OGP_GROUP,
11878 (option->info & OGP_SELF) >> 16);
11881 /* This shouldn't happen. */
11882 printf (" %3d ??? %d %lx",
11883 option->kind, option->section, option->info);
11887 len = sizeof (* eopt);
11888 while (len < option->size)
11889 if (((char *) option)[len] >= ' '
11890 && ((char *) option)[len] < 0x7f)
11891 printf ("%c", ((char *) option)[len++]);
11893 printf ("\\%03o", ((char *) option)[len++]);
11895 fputs ("\n", stdout);
11903 if (conflicts_offset != 0 && conflictsno != 0)
11905 Elf32_Conflict * iconf;
11908 if (dynamic_symbols == NULL)
11910 error (_("conflict list found without a dynamic symbol table\n"));
11914 iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
11917 error (_("Out of memory\n"));
11923 Elf32_External_Conflict * econf32;
11925 econf32 = (Elf32_External_Conflict *)
11926 get_data (NULL, file, conflicts_offset, conflictsno,
11927 sizeof (* econf32), _("conflict"));
11931 for (cnt = 0; cnt < conflictsno; ++cnt)
11932 iconf[cnt] = BYTE_GET (econf32[cnt]);
11938 Elf64_External_Conflict * econf64;
11940 econf64 = (Elf64_External_Conflict *)
11941 get_data (NULL, file, conflicts_offset, conflictsno,
11942 sizeof (* econf64), _("conflict"));
11946 for (cnt = 0; cnt < conflictsno; ++cnt)
11947 iconf[cnt] = BYTE_GET (econf64[cnt]);
11952 printf (_("\nSection '.conflict' contains %lu entries:\n"),
11953 (unsigned long) conflictsno);
11954 puts (_(" Num: Index Value Name"));
11956 for (cnt = 0; cnt < conflictsno; ++cnt)
11958 Elf_Internal_Sym * psym = & dynamic_symbols[iconf[cnt]];
11960 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
11961 print_vma (psym->st_value, FULL_HEX);
11963 if (VALID_DYNAMIC_NAME (psym->st_name))
11964 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
11966 printf (_("<corrupt: %14ld>"), psym->st_name);
11973 if (pltgot != 0 && local_gotno != 0)
11975 bfd_vma ent, local_end, global_end;
11977 unsigned char * data;
11981 addr_size = (is_32bit_elf ? 4 : 8);
11982 local_end = pltgot + local_gotno * addr_size;
11983 global_end = local_end + (symtabno - gotsym) * addr_size;
11985 offset = offset_from_vma (file, pltgot, global_end - pltgot);
11986 data = (unsigned char *) get_data (NULL, file, offset,
11987 global_end - pltgot, 1, _("GOT"));
11991 printf (_("\nPrimary GOT:\n"));
11992 printf (_(" Canonical gp value: "));
11993 print_vma (pltgot + 0x7ff0, LONG_HEX);
11996 printf (_(" Reserved entries:\n"));
11997 printf (_(" %*s %10s %*s Purpose\n"),
11998 addr_size * 2, _("Address"), _("Access"),
11999 addr_size * 2, _("Initial"));
12000 ent = print_mips_got_entry (data, pltgot, ent);
12001 printf (_(" Lazy resolver\n"));
12003 && (byte_get (data + ent - pltgot, addr_size)
12004 >> (addr_size * 8 - 1)) != 0)
12006 ent = print_mips_got_entry (data, pltgot, ent);
12007 printf (_(" Module pointer (GNU extension)\n"));
12011 if (ent < local_end)
12013 printf (_(" Local entries:\n"));
12014 printf (" %*s %10s %*s\n",
12015 addr_size * 2, _("Address"), _("Access"),
12016 addr_size * 2, _("Initial"));
12017 while (ent < local_end)
12019 ent = print_mips_got_entry (data, pltgot, ent);
12025 if (gotsym < symtabno)
12029 printf (_(" Global entries:\n"));
12030 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
12031 addr_size * 2, _("Address"), _("Access"),
12032 addr_size * 2, _("Initial"),
12033 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
12034 sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
12035 for (i = gotsym; i < symtabno; i++)
12037 Elf_Internal_Sym * psym;
12039 psym = dynamic_symbols + i;
12040 ent = print_mips_got_entry (data, pltgot, ent);
12042 print_vma (psym->st_value, LONG_HEX);
12043 printf (" %-7s %3s ",
12044 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
12045 get_symbol_index_type (psym->st_shndx));
12046 if (VALID_DYNAMIC_NAME (psym->st_name))
12047 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
12049 printf (_("<corrupt: %14ld>"), psym->st_name);
12059 if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
12062 size_t offset, rel_offset;
12063 unsigned long count, i;
12064 unsigned char * data;
12065 int addr_size, sym_width;
12066 Elf_Internal_Rela * rels;
12068 rel_offset = offset_from_vma (file, jmprel, pltrelsz);
12069 if (pltrel == DT_RELA)
12071 if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
12076 if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
12081 addr_size = (is_32bit_elf ? 4 : 8);
12082 end = mips_pltgot + (2 + count) * addr_size;
12084 offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
12085 data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
12090 printf (_("\nPLT GOT:\n\n"));
12091 printf (_(" Reserved entries:\n"));
12092 printf (_(" %*s %*s Purpose\n"),
12093 addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
12094 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
12095 printf (_(" PLT lazy resolver\n"));
12096 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
12097 printf (_(" Module pointer\n"));
12100 printf (_(" Entries:\n"));
12101 printf (" %*s %*s %*s %-7s %3s %s\n",
12102 addr_size * 2, _("Address"),
12103 addr_size * 2, _("Initial"),
12104 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
12105 sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
12106 for (i = 0; i < count; i++)
12108 Elf_Internal_Sym * psym;
12110 psym = dynamic_symbols + get_reloc_symindex (rels[i].r_info);
12111 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
12113 print_vma (psym->st_value, LONG_HEX);
12114 printf (" %-7s %3s ",
12115 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
12116 get_symbol_index_type (psym->st_shndx));
12117 if (VALID_DYNAMIC_NAME (psym->st_name))
12118 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
12120 printf (_("<corrupt: %14ld>"), psym->st_name);
12134 process_gnu_liblist (FILE * file)
12136 Elf_Internal_Shdr * section;
12137 Elf_Internal_Shdr * string_sec;
12138 Elf32_External_Lib * elib;
12140 size_t strtab_size;
12147 for (i = 0, section = section_headers;
12148 i < elf_header.e_shnum;
12151 switch (section->sh_type)
12153 case SHT_GNU_LIBLIST:
12154 if (section->sh_link >= elf_header.e_shnum)
12157 elib = (Elf32_External_Lib *)
12158 get_data (NULL, file, section->sh_offset, 1, section->sh_size,
12163 string_sec = section_headers + section->sh_link;
12165 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
12166 string_sec->sh_size,
12167 _("liblist string table"));
12169 || section->sh_entsize != sizeof (Elf32_External_Lib))
12175 strtab_size = string_sec->sh_size;
12177 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
12178 SECTION_NAME (section),
12179 (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
12181 puts (_(" Library Time Stamp Checksum Version Flags"));
12183 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
12191 liblist.l_name = BYTE_GET (elib[cnt].l_name);
12192 atime = BYTE_GET (elib[cnt].l_time_stamp);
12193 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
12194 liblist.l_version = BYTE_GET (elib[cnt].l_version);
12195 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
12197 tmp = gmtime (&atime);
12198 snprintf (timebuf, sizeof (timebuf),
12199 "%04u-%02u-%02uT%02u:%02u:%02u",
12200 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
12201 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
12203 printf ("%3lu: ", (unsigned long) cnt);
12205 printf ("%-20s", liblist.l_name < strtab_size
12206 ? strtab + liblist.l_name : _("<corrupt>"));
12208 printf ("%-20.20s", liblist.l_name < strtab_size
12209 ? strtab + liblist.l_name : _("<corrupt>"));
12210 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
12211 liblist.l_version, liblist.l_flags);
12222 static const char *
12223 get_note_type (unsigned e_type)
12225 static char buff[64];
12227 if (elf_header.e_type == ET_CORE)
12231 return _("NT_AUXV (auxiliary vector)");
12233 return _("NT_PRSTATUS (prstatus structure)");
12235 return _("NT_FPREGSET (floating point registers)");
12237 return _("NT_PRPSINFO (prpsinfo structure)");
12238 case NT_TASKSTRUCT:
12239 return _("NT_TASKSTRUCT (task structure)");
12241 return _("NT_PRXFPREG (user_xfpregs structure)");
12243 return _("NT_PPC_VMX (ppc Altivec registers)");
12245 return _("NT_PPC_VSX (ppc VSX registers)");
12246 case NT_X86_XSTATE:
12247 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
12248 case NT_S390_HIGH_GPRS:
12249 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
12250 case NT_S390_TIMER:
12251 return _("NT_S390_TIMER (s390 timer register)");
12252 case NT_S390_TODCMP:
12253 return _("NT_S390_TODCMP (s390 TOD comparator register)");
12254 case NT_S390_TODPREG:
12255 return _("NT_S390_TODPREG (s390 TOD programmable register)");
12257 return _("NT_S390_CTRS (s390 control registers)");
12258 case NT_S390_PREFIX:
12259 return _("NT_S390_PREFIX (s390 prefix register)");
12261 return _("NT_PSTATUS (pstatus structure)");
12263 return _("NT_FPREGS (floating point registers)");
12265 return _("NT_PSINFO (psinfo structure)");
12267 return _("NT_LWPSTATUS (lwpstatus_t structure)");
12269 return _("NT_LWPSINFO (lwpsinfo_t structure)");
12270 case NT_WIN32PSTATUS:
12271 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
12279 return _("NT_VERSION (version)");
12281 return _("NT_ARCH (architecture)");
12286 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
12290 static const char *
12291 get_gnu_elf_note_type (unsigned e_type)
12293 static char buff[64];
12297 case NT_GNU_ABI_TAG:
12298 return _("NT_GNU_ABI_TAG (ABI version tag)");
12300 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
12301 case NT_GNU_BUILD_ID:
12302 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
12303 case NT_GNU_GOLD_VERSION:
12304 return _("NT_GNU_GOLD_VERSION (gold version)");
12309 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
12314 print_gnu_note (Elf_Internal_Note *pnote)
12316 switch (pnote->type)
12318 case NT_GNU_BUILD_ID:
12322 printf (_(" Build ID: "));
12323 for (i = 0; i < pnote->descsz; ++i)
12324 printf ("%02x", pnote->descdata[i] & 0xff);
12329 case NT_GNU_ABI_TAG:
12331 unsigned long os, major, minor, subminor;
12332 const char *osname;
12334 os = byte_get ((unsigned char *) pnote->descdata, 4);
12335 major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
12336 minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
12337 subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
12341 case GNU_ABI_TAG_LINUX:
12344 case GNU_ABI_TAG_HURD:
12347 case GNU_ABI_TAG_SOLARIS:
12348 osname = "Solaris";
12350 case GNU_ABI_TAG_FREEBSD:
12351 osname = "FreeBSD";
12353 case GNU_ABI_TAG_NETBSD:
12357 osname = "Unknown";
12361 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname,
12362 major, minor, subminor);
12370 static const char *
12371 get_netbsd_elfcore_note_type (unsigned e_type)
12373 static char buff[64];
12375 if (e_type == NT_NETBSDCORE_PROCINFO)
12377 /* NetBSD core "procinfo" structure. */
12378 return _("NetBSD procinfo structure");
12381 /* As of Jan 2002 there are no other machine-independent notes
12382 defined for NetBSD core files. If the note type is less
12383 than the start of the machine-dependent note types, we don't
12386 if (e_type < NT_NETBSDCORE_FIRSTMACH)
12388 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
12392 switch (elf_header.e_machine)
12394 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
12395 and PT_GETFPREGS == mach+2. */
12400 case EM_SPARC32PLUS:
12404 case NT_NETBSDCORE_FIRSTMACH + 0:
12405 return _("PT_GETREGS (reg structure)");
12406 case NT_NETBSDCORE_FIRSTMACH + 2:
12407 return _("PT_GETFPREGS (fpreg structure)");
12413 /* On all other arch's, PT_GETREGS == mach+1 and
12414 PT_GETFPREGS == mach+3. */
12418 case NT_NETBSDCORE_FIRSTMACH + 1:
12419 return _("PT_GETREGS (reg structure)");
12420 case NT_NETBSDCORE_FIRSTMACH + 3:
12421 return _("PT_GETFPREGS (fpreg structure)");
12427 snprintf (buff, sizeof (buff), _("PT_FIRSTMACH+%d"),
12428 e_type - NT_NETBSDCORE_FIRSTMACH);
12432 static const char *
12433 get_stapsdt_note_type (unsigned e_type)
12435 static char buff[64];
12440 return _("NT_STAPSDT (SystemTap probe descriptors)");
12446 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
12451 print_stapsdt_note (Elf_Internal_Note *pnote)
12453 int addr_size = is_32bit_elf ? 4 : 8;
12454 char *data = pnote->descdata;
12455 char *data_end = pnote->descdata + pnote->descsz;
12456 bfd_vma pc, base_addr, semaphore;
12457 char *provider, *probe, *arg_fmt;
12459 pc = byte_get ((unsigned char *) data, addr_size);
12461 base_addr = byte_get ((unsigned char *) data, addr_size);
12463 semaphore = byte_get ((unsigned char *) data, addr_size);
12467 data += strlen (data) + 1;
12469 data += strlen (data) + 1;
12471 data += strlen (data) + 1;
12473 printf (_(" Provider: %s\n"), provider);
12474 printf (_(" Name: %s\n"), probe);
12475 printf (_(" Location: "));
12476 print_vma (pc, FULL_HEX);
12477 printf (_(", Base: "));
12478 print_vma (base_addr, FULL_HEX);
12479 printf (_(", Semaphore: "));
12480 print_vma (semaphore, FULL_HEX);
12482 printf (_(" Arguments: %s\n"), arg_fmt);
12484 return data == data_end;
12487 static const char *
12488 get_ia64_vms_note_type (unsigned e_type)
12490 static char buff[64];
12495 return _("NT_VMS_MHD (module header)");
12497 return _("NT_VMS_LNM (language name)");
12499 return _("NT_VMS_SRC (source files)");
12501 return _("NT_VMS_TITLE");
12503 return _("NT_VMS_EIDC (consistency check)");
12504 case NT_VMS_FPMODE:
12505 return _("NT_VMS_FPMODE (FP mode)");
12506 case NT_VMS_LINKTIME:
12507 return _("NT_VMS_LINKTIME");
12508 case NT_VMS_IMGNAM:
12509 return _("NT_VMS_IMGNAM (image name)");
12511 return _("NT_VMS_IMGID (image id)");
12512 case NT_VMS_LINKID:
12513 return _("NT_VMS_LINKID (link id)");
12514 case NT_VMS_IMGBID:
12515 return _("NT_VMS_IMGBID (build id)");
12516 case NT_VMS_GSTNAM:
12517 return _("NT_VMS_GSTNAM (sym table name)");
12518 case NT_VMS_ORIG_DYN:
12519 return _("NT_VMS_ORIG_DYN");
12520 case NT_VMS_PATCHTIME:
12521 return _("NT_VMS_PATCHTIME");
12523 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
12529 print_ia64_vms_note (Elf_Internal_Note * pnote)
12531 switch (pnote->type)
12534 if (pnote->descsz > 36)
12536 size_t l = strlen (pnote->descdata + 34);
12537 printf (_(" Creation date : %.17s\n"), pnote->descdata);
12538 printf (_(" Last patch date: %.17s\n"), pnote->descdata + 17);
12539 printf (_(" Module name : %s\n"), pnote->descdata + 34);
12540 printf (_(" Module version : %s\n"), pnote->descdata + 34 + l + 1);
12543 printf (_(" Invalid size\n"));
12546 printf (_(" Language: %s\n"), pnote->descdata);
12549 case NT_VMS_FPMODE:
12550 printf (_(" FP mode: 0x%016" BFD_VMA_FMT "x\n"),
12551 (bfd_vma)byte_get ((unsigned char *)pnote->descdata, 8));
12553 case NT_VMS_LINKTIME:
12554 printf (_(" Link time: "));
12556 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
12559 case NT_VMS_PATCHTIME:
12560 printf (_(" Patch time: "));
12562 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
12565 case NT_VMS_ORIG_DYN:
12566 printf (_(" Major id: %u, minor id: %u\n"),
12567 (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
12568 (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
12569 printf (_(" Manip date : "));
12571 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
12573 " Link flags : 0x%016" BFD_VMA_FMT "x\n"),
12574 (bfd_vma)byte_get ((unsigned char *)pnote->descdata + 16, 8));
12575 printf (_(" Header flags: 0x%08x\n"),
12576 (unsigned)byte_get ((unsigned char *)pnote->descdata + 24, 4));
12577 printf (_(" Image id : %s\n"), pnote->descdata + 32);
12580 case NT_VMS_IMGNAM:
12581 printf (_(" Image name: %s\n"), pnote->descdata);
12583 case NT_VMS_GSTNAM:
12584 printf (_(" Global symbol table name: %s\n"), pnote->descdata);
12587 printf (_(" Image id: %s\n"), pnote->descdata);
12589 case NT_VMS_LINKID:
12590 printf (_(" Linker id: %s\n"), pnote->descdata);
12598 /* Note that by the ELF standard, the name field is already null byte
12599 terminated, and namesz includes the terminating null byte.
12600 I.E. the value of namesz for the name "FSF" is 4.
12602 If the value of namesz is zero, there is no name present. */
12604 process_note (Elf_Internal_Note * pnote)
12606 const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
12609 if (pnote->namesz == 0)
12610 /* If there is no note name, then use the default set of
12611 note type strings. */
12612 nt = get_note_type (pnote->type);
12614 else if (const_strneq (pnote->namedata, "GNU"))
12615 /* GNU-specific object file notes. */
12616 nt = get_gnu_elf_note_type (pnote->type);
12618 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
12619 /* NetBSD-specific core file notes. */
12620 nt = get_netbsd_elfcore_note_type (pnote->type);
12622 else if (strneq (pnote->namedata, "SPU/", 4))
12624 /* SPU-specific core file notes. */
12625 nt = pnote->namedata + 4;
12629 else if (const_strneq (pnote->namedata, "IPF/VMS"))
12630 /* VMS/ia64-specific file notes. */
12631 nt = get_ia64_vms_note_type (pnote->type);
12633 else if (const_strneq (pnote->namedata, "stapsdt"))
12634 nt = get_stapsdt_note_type (pnote->type);
12637 /* Don't recognize this note name; just use the default set of
12638 note type strings. */
12639 nt = get_note_type (pnote->type);
12641 printf (" %-20s 0x%08lx\t%s\n", name, pnote->descsz, nt);
12643 if (const_strneq (pnote->namedata, "IPF/VMS"))
12644 return print_ia64_vms_note (pnote);
12645 else if (const_strneq (pnote->namedata, "GNU"))
12646 return print_gnu_note (pnote);
12647 else if (const_strneq (pnote->namedata, "stapsdt"))
12648 return print_stapsdt_note (pnote);
12655 process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
12657 Elf_External_Note * pnotes;
12658 Elf_External_Note * external;
12664 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
12666 if (pnotes == NULL)
12671 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
12672 (unsigned long) offset, (unsigned long) length);
12673 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
12675 while (external < (Elf_External_Note *) ((char *) pnotes + length))
12677 Elf_External_Note * next;
12678 Elf_Internal_Note inote;
12679 char * temp = NULL;
12681 if (!is_ia64_vms ())
12683 inote.type = BYTE_GET (external->type);
12684 inote.namesz = BYTE_GET (external->namesz);
12685 inote.namedata = external->name;
12686 inote.descsz = BYTE_GET (external->descsz);
12687 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
12688 inote.descpos = offset + (inote.descdata - (char *) pnotes);
12690 next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
12694 Elf64_External_VMS_Note *vms_external;
12696 vms_external = (Elf64_External_VMS_Note *)external;
12697 inote.type = BYTE_GET (vms_external->type);
12698 inote.namesz = BYTE_GET (vms_external->namesz);
12699 inote.namedata = vms_external->name;
12700 inote.descsz = BYTE_GET (vms_external->descsz);
12701 inote.descdata = inote.namedata + align_power (inote.namesz, 3);
12702 inote.descpos = offset + (inote.descdata - (char *) pnotes);
12704 next = (Elf_External_Note *)
12705 (inote.descdata + align_power (inote.descsz, 3));
12708 if ( ((char *) next > ((char *) pnotes) + length)
12709 || ((char *) next < (char *) pnotes))
12711 warn (_("corrupt note found at offset %lx into core notes\n"),
12712 (unsigned long) ((char *) external - (char *) pnotes));
12713 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
12714 inote.type, inote.namesz, inote.descsz);
12720 /* Prevent out-of-bounds indexing. */
12721 if (inote.namedata + inote.namesz >= (char *) pnotes + length
12722 || inote.namedata + inote.namesz < inote.namedata)
12724 warn (_("corrupt note found at offset %lx into core notes\n"),
12725 (unsigned long) ((char *) external - (char *) pnotes));
12726 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
12727 inote.type, inote.namesz, inote.descsz);
12731 /* Verify that name is null terminated. It appears that at least
12732 one version of Linux (RedHat 6.0) generates corefiles that don't
12733 comply with the ELF spec by failing to include the null byte in
12735 if (inote.namedata[inote.namesz] != '\0')
12737 temp = (char *) malloc (inote.namesz + 1);
12741 error (_("Out of memory\n"));
12746 strncpy (temp, inote.namedata, inote.namesz);
12747 temp[inote.namesz] = 0;
12749 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
12750 inote.namedata = temp;
12753 res &= process_note (& inote);
12768 process_corefile_note_segments (FILE * file)
12770 Elf_Internal_Phdr * segment;
12774 if (! get_program_headers (file))
12777 for (i = 0, segment = program_headers;
12778 i < elf_header.e_phnum;
12781 if (segment->p_type == PT_NOTE)
12782 res &= process_corefile_note_segment (file,
12783 (bfd_vma) segment->p_offset,
12784 (bfd_vma) segment->p_filesz);
12791 process_note_sections (FILE * file)
12793 Elf_Internal_Shdr * section;
12797 for (i = 0, section = section_headers;
12798 i < elf_header.e_shnum;
12800 if (section->sh_type == SHT_NOTE)
12801 res &= process_corefile_note_segment (file,
12802 (bfd_vma) section->sh_offset,
12803 (bfd_vma) section->sh_size);
12809 process_notes (FILE * file)
12811 /* If we have not been asked to display the notes then do nothing. */
12815 if (elf_header.e_type != ET_CORE)
12816 return process_note_sections (file);
12818 /* No program headers means no NOTE segment. */
12819 if (elf_header.e_phnum > 0)
12820 return process_corefile_note_segments (file);
12822 printf (_("No note segments present in the core file.\n"));
12827 process_arch_specific (FILE * file)
12832 switch (elf_header.e_machine)
12835 return process_arm_specific (file);
12837 case EM_MIPS_RS3_LE:
12838 return process_mips_specific (file);
12841 return process_power_specific (file);
12844 return process_tic6x_specific (file);
12853 get_file_header (FILE * file)
12855 /* Read in the identity array. */
12856 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
12859 /* Determine how to read the rest of the header. */
12860 switch (elf_header.e_ident[EI_DATA])
12862 default: /* fall through */
12863 case ELFDATANONE: /* fall through */
12865 byte_get = byte_get_little_endian;
12866 byte_put = byte_put_little_endian;
12869 byte_get = byte_get_big_endian;
12870 byte_put = byte_put_big_endian;
12874 /* For now we only support 32 bit and 64 bit ELF files. */
12875 is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
12877 /* Read in the rest of the header. */
12880 Elf32_External_Ehdr ehdr32;
12882 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
12885 elf_header.e_type = BYTE_GET (ehdr32.e_type);
12886 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
12887 elf_header.e_version = BYTE_GET (ehdr32.e_version);
12888 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
12889 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
12890 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
12891 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
12892 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
12893 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
12894 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
12895 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
12896 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
12897 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
12901 Elf64_External_Ehdr ehdr64;
12903 /* If we have been compiled with sizeof (bfd_vma) == 4, then
12904 we will not be able to cope with the 64bit data found in
12905 64 ELF files. Detect this now and abort before we start
12906 overwriting things. */
12907 if (sizeof (bfd_vma) < 8)
12909 error (_("This instance of readelf has been built without support for a\n\
12910 64 bit data type and so it cannot read 64 bit ELF files.\n"));
12914 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
12917 elf_header.e_type = BYTE_GET (ehdr64.e_type);
12918 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
12919 elf_header.e_version = BYTE_GET (ehdr64.e_version);
12920 elf_header.e_entry = BYTE_GET (ehdr64.e_entry);
12921 elf_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
12922 elf_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
12923 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
12924 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
12925 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
12926 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
12927 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
12928 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
12929 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
12932 if (elf_header.e_shoff)
12934 /* There may be some extensions in the first section header. Don't
12935 bomb if we can't read it. */
12937 get_32bit_section_headers (file, 1);
12939 get_64bit_section_headers (file, 1);
12945 /* Process one ELF object file according to the command line options.
12946 This file may actually be stored in an archive. The file is
12947 positioned at the start of the ELF object. */
12950 process_object (char * file_name, FILE * file)
12954 if (! get_file_header (file))
12956 error (_("%s: Failed to read file header\n"), file_name);
12960 /* Initialise per file variables. */
12961 for (i = ARRAY_SIZE (version_info); i--;)
12962 version_info[i] = 0;
12964 for (i = ARRAY_SIZE (dynamic_info); i--;)
12965 dynamic_info[i] = 0;
12966 dynamic_info_DT_GNU_HASH = 0;
12968 /* Process the file. */
12970 printf (_("\nFile: %s\n"), file_name);
12972 /* Initialise the dump_sects array from the cmdline_dump_sects array.
12973 Note we do this even if cmdline_dump_sects is empty because we
12974 must make sure that the dump_sets array is zeroed out before each
12975 object file is processed. */
12976 if (num_dump_sects > num_cmdline_dump_sects)
12977 memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
12979 if (num_cmdline_dump_sects > 0)
12981 if (num_dump_sects == 0)
12982 /* A sneaky way of allocating the dump_sects array. */
12983 request_dump_bynumber (num_cmdline_dump_sects, 0);
12985 assert (num_dump_sects >= num_cmdline_dump_sects);
12986 memcpy (dump_sects, cmdline_dump_sects,
12987 num_cmdline_dump_sects * sizeof (* dump_sects));
12990 if (! process_file_header ())
12993 if (! process_section_headers (file))
12995 /* Without loaded section headers we cannot process lots of
12997 do_unwind = do_version = do_dump = do_arch = 0;
12999 if (! do_using_dynamic)
13000 do_syms = do_dyn_syms = do_reloc = 0;
13003 if (! process_section_groups (file))
13005 /* Without loaded section groups we cannot process unwind. */
13009 if (process_program_headers (file))
13010 process_dynamic_section (file);
13012 process_relocs (file);
13014 process_unwind (file);
13016 process_symbol_table (file);
13018 process_syminfo (file);
13020 process_version_sections (file);
13022 process_section_contents (file);
13024 process_notes (file);
13026 process_gnu_liblist (file);
13028 process_arch_specific (file);
13030 if (program_headers)
13032 free (program_headers);
13033 program_headers = NULL;
13036 if (section_headers)
13038 free (section_headers);
13039 section_headers = NULL;
13044 free (string_table);
13045 string_table = NULL;
13046 string_table_length = 0;
13049 if (dynamic_strings)
13051 free (dynamic_strings);
13052 dynamic_strings = NULL;
13053 dynamic_strings_length = 0;
13056 if (dynamic_symbols)
13058 free (dynamic_symbols);
13059 dynamic_symbols = NULL;
13060 num_dynamic_syms = 0;
13063 if (dynamic_syminfo)
13065 free (dynamic_syminfo);
13066 dynamic_syminfo = NULL;
13069 if (dynamic_section)
13071 free (dynamic_section);
13072 dynamic_section = NULL;
13075 if (section_headers_groups)
13077 free (section_headers_groups);
13078 section_headers_groups = NULL;
13081 if (section_groups)
13083 struct group_list * g;
13084 struct group_list * next;
13086 for (i = 0; i < group_count; i++)
13088 for (g = section_groups [i].root; g != NULL; g = next)
13095 free (section_groups);
13096 section_groups = NULL;
13099 free_debug_memory ();
13104 /* Process an ELF archive.
13105 On entry the file is positioned just after the ARMAG string. */
13108 process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
13110 struct archive_info arch;
13111 struct archive_info nested_arch;
13117 /* The ARCH structure is used to hold information about this archive. */
13118 arch.file_name = NULL;
13120 arch.index_array = NULL;
13121 arch.sym_table = NULL;
13122 arch.longnames = NULL;
13124 /* The NESTED_ARCH structure is used as a single-item cache of information
13125 about a nested archive (when members of a thin archive reside within
13126 another regular archive file). */
13127 nested_arch.file_name = NULL;
13128 nested_arch.file = NULL;
13129 nested_arch.index_array = NULL;
13130 nested_arch.sym_table = NULL;
13131 nested_arch.longnames = NULL;
13133 if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
13139 if (do_archive_index)
13141 if (arch.sym_table == NULL)
13142 error (_("%s: unable to dump the index as none was found\n"), file_name);
13146 unsigned long current_pos;
13148 printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
13149 file_name, arch.index_num, arch.sym_size);
13150 current_pos = ftell (file);
13152 for (i = l = 0; i < arch.index_num; i++)
13154 if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
13156 char * member_name;
13158 member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
13160 if (member_name != NULL)
13162 char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
13164 if (qualified_name != NULL)
13166 printf (_("Binary %s contains:\n"), qualified_name);
13167 free (qualified_name);
13172 if (l >= arch.sym_size)
13174 error (_("%s: end of the symbol table reached before the end of the index\n"),
13178 printf ("\t%s\n", arch.sym_table + l);
13179 l += strlen (arch.sym_table + l) + 1;
13184 if (l < arch.sym_size)
13185 error (_("%s: symbols remain in the index symbol table, but without corresponding entries in the index table\n"),
13188 if (fseek (file, current_pos, SEEK_SET) != 0)
13190 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
13196 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
13197 && !do_segments && !do_header && !do_dump && !do_version
13198 && !do_histogram && !do_debugging && !do_arch && !do_notes
13199 && !do_section_groups && !do_dyn_syms)
13201 ret = 0; /* Archive index only. */
13212 char * qualified_name;
13214 /* Read the next archive header. */
13215 if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
13217 error (_("%s: failed to seek to next archive header\n"), file_name);
13220 got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
13221 if (got != sizeof arch.arhdr)
13225 error (_("%s: failed to read archive header\n"), file_name);
13229 if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
13231 error (_("%s: did not find a valid archive header\n"), arch.file_name);
13236 arch.next_arhdr_offset += sizeof arch.arhdr;
13238 archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
13239 if (archive_file_size & 01)
13240 ++archive_file_size;
13242 name = get_archive_member_name (&arch, &nested_arch);
13245 error (_("%s: bad archive file name\n"), file_name);
13249 namelen = strlen (name);
13251 qualified_name = make_qualified_name (&arch, &nested_arch, name);
13252 if (qualified_name == NULL)
13254 error (_("%s: bad archive file name\n"), file_name);
13259 if (is_thin_archive && arch.nested_member_origin == 0)
13261 /* This is a proxy for an external member of a thin archive. */
13262 FILE * member_file;
13263 char * member_file_name = adjust_relative_path (file_name, name, namelen);
13264 if (member_file_name == NULL)
13270 member_file = fopen (member_file_name, "rb");
13271 if (member_file == NULL)
13273 error (_("Input file '%s' is not readable.\n"), member_file_name);
13274 free (member_file_name);
13279 archive_file_offset = arch.nested_member_origin;
13281 ret |= process_object (qualified_name, member_file);
13283 fclose (member_file);
13284 free (member_file_name);
13286 else if (is_thin_archive)
13288 /* This is a proxy for a member of a nested archive. */
13289 archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
13291 /* The nested archive file will have been opened and setup by
13292 get_archive_member_name. */
13293 if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
13295 error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
13300 ret |= process_object (qualified_name, nested_arch.file);
13304 archive_file_offset = arch.next_arhdr_offset;
13305 arch.next_arhdr_offset += archive_file_size;
13307 ret |= process_object (qualified_name, file);
13310 if (dump_sects != NULL)
13314 num_dump_sects = 0;
13317 free (qualified_name);
13321 if (nested_arch.file != NULL)
13322 fclose (nested_arch.file);
13323 release_archive (&nested_arch);
13324 release_archive (&arch);
13330 process_file (char * file_name)
13333 struct stat statbuf;
13334 char armag[SARMAG];
13337 if (stat (file_name, &statbuf) < 0)
13339 if (errno == ENOENT)
13340 error (_("'%s': No such file\n"), file_name);
13342 error (_("Could not locate '%s'. System error message: %s\n"),
13343 file_name, strerror (errno));
13347 if (! S_ISREG (statbuf.st_mode))
13349 error (_("'%s' is not an ordinary file\n"), file_name);
13353 file = fopen (file_name, "rb");
13356 error (_("Input file '%s' is not readable.\n"), file_name);
13360 if (fread (armag, SARMAG, 1, file) != 1)
13362 error (_("%s: Failed to read file's magic number\n"), file_name);
13367 if (memcmp (armag, ARMAG, SARMAG) == 0)
13368 ret = process_archive (file_name, file, FALSE);
13369 else if (memcmp (armag, ARMAGT, SARMAG) == 0)
13370 ret = process_archive (file_name, file, TRUE);
13373 if (do_archive_index)
13374 error (_("File %s is not an archive so its index cannot be displayed.\n"),
13378 archive_file_size = archive_file_offset = 0;
13379 ret = process_object (file_name, file);
13387 #ifdef SUPPORT_DISASSEMBLY
13388 /* Needed by the i386 disassembler. For extra credit, someone could
13389 fix this so that we insert symbolic addresses here, esp for GOT/PLT
13393 print_address (unsigned int addr, FILE * outfile)
13395 fprintf (outfile,"0x%8.8x", addr);
13398 /* Needed by the i386 disassembler. */
13400 db_task_printsym (unsigned int addr)
13402 print_address (addr, stderr);
13407 main (int argc, char ** argv)
13411 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
13412 setlocale (LC_MESSAGES, "");
13414 #if defined (HAVE_SETLOCALE)
13415 setlocale (LC_CTYPE, "");
13417 bindtextdomain (PACKAGE, LOCALEDIR);
13418 textdomain (PACKAGE);
13420 expandargv (&argc, &argv);
13422 parse_args (argc, argv);
13424 if (num_dump_sects > 0)
13426 /* Make a copy of the dump_sects array. */
13427 cmdline_dump_sects = (dump_type *)
13428 malloc (num_dump_sects * sizeof (* dump_sects));
13429 if (cmdline_dump_sects == NULL)
13430 error (_("Out of memory allocating dump request table.\n"));
13433 memcpy (cmdline_dump_sects, dump_sects,
13434 num_dump_sects * sizeof (* dump_sects));
13435 num_cmdline_dump_sects = num_dump_sects;
13439 if (optind < (argc - 1))
13443 while (optind < argc)
13444 err |= process_file (argv[optind++]);
13446 if (dump_sects != NULL)
13448 if (cmdline_dump_sects != NULL)
13449 free (cmdline_dump_sects);