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/tilegx.h"
144 #include "elf/tilepro.h"
145 #include "elf/v850.h"
147 #include "elf/x86-64.h"
148 #include "elf/xc16x.h"
149 #include "elf/xstormy16.h"
150 #include "elf/xtensa.h"
153 #include "libiberty.h"
154 #include "safe-ctype.h"
155 #include "filenames.h"
157 char * program_name = "readelf";
158 static long archive_file_offset;
159 static unsigned long archive_file_size;
160 static unsigned long dynamic_addr;
161 static bfd_size_type dynamic_size;
162 static unsigned int dynamic_nent;
163 static char * dynamic_strings;
164 static unsigned long dynamic_strings_length;
165 static char * string_table;
166 static unsigned long string_table_length;
167 static unsigned long num_dynamic_syms;
168 static Elf_Internal_Sym * dynamic_symbols;
169 static Elf_Internal_Syminfo * dynamic_syminfo;
170 static unsigned long dynamic_syminfo_offset;
171 static unsigned int dynamic_syminfo_nent;
172 static char program_interpreter[PATH_MAX];
173 static bfd_vma dynamic_info[DT_ENCODING];
174 static bfd_vma dynamic_info_DT_GNU_HASH;
175 static bfd_vma version_info[16];
176 static Elf_Internal_Ehdr elf_header;
177 static Elf_Internal_Shdr * section_headers;
178 static Elf_Internal_Phdr * program_headers;
179 static Elf_Internal_Dyn * dynamic_section;
180 static Elf_Internal_Shdr * symtab_shndx_hdr;
181 static int show_name;
182 static int do_dynamic;
184 static int do_dyn_syms;
186 static int do_sections;
187 static int do_section_groups;
188 static int do_section_details;
189 static int do_segments;
190 static int do_unwind;
191 static int do_using_dynamic;
192 static int do_header;
194 static int do_version;
195 static int do_histogram;
196 static int do_debugging;
199 static int do_archive_index;
200 static int is_32bit_elf;
204 struct group_list * next;
205 unsigned int section_index;
210 struct group_list * root;
211 unsigned int group_index;
214 static size_t group_count;
215 static struct group * section_groups;
216 static struct group ** section_headers_groups;
219 /* Flag bits indicating particular types of dump. */
220 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
221 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
222 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
223 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
224 #define RELOC_DUMP (1 << 4) /* The -R command line switch. */
226 typedef unsigned char dump_type;
228 /* A linked list of the section names for which dumps were requested. */
229 struct dump_list_entry
233 struct dump_list_entry * next;
235 static struct dump_list_entry * dump_sects_byname;
237 /* A dynamic array of flags indicating for which sections a dump
238 has been requested via command line switches. */
239 static dump_type * cmdline_dump_sects = NULL;
240 static unsigned int num_cmdline_dump_sects = 0;
242 /* A dynamic array of flags indicating for which sections a dump of
243 some kind has been requested. It is reset on a per-object file
244 basis and then initialised from the cmdline_dump_sects array,
245 the results of interpreting the -w switch, and the
246 dump_sects_byname list. */
247 static dump_type * dump_sects = NULL;
248 static unsigned int num_dump_sects = 0;
251 /* How to print a vma value. */
252 typedef enum print_mode
266 #define SECTION_NAME(X) \
267 ((X) == NULL ? _("<none>") \
268 : string_table == NULL ? _("<no-name>") \
269 : ((X)->sh_name >= string_table_length ? _("<corrupt>") \
270 : string_table + (X)->sh_name))
272 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
274 #define GET_ELF_SYMBOLS(file, section) \
275 (is_32bit_elf ? get_32bit_elf_symbols (file, section) \
276 : get_64bit_elf_symbols (file, section))
278 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
279 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
280 already been called and verified that the string exists. */
281 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
283 #define REMOVE_ARCH_BITS(ADDR) \
286 if (elf_header.e_machine == EM_ARM) \
291 /* Retrieve NMEMB structures, each SIZE bytes long from FILE starting at OFFSET.
292 Put the retrieved data into VAR, if it is not NULL. Otherwise allocate a buffer
293 using malloc and fill that. In either case return the pointer to the start of
294 the retrieved data or NULL if something went wrong. If something does go wrong
295 emit an error message using REASON as part of the context. */
298 get_data (void * var, FILE * file, long offset, size_t size, size_t nmemb,
303 if (size == 0 || nmemb == 0)
306 if (fseek (file, archive_file_offset + offset, SEEK_SET))
308 error (_("Unable to seek to 0x%lx for %s\n"),
309 (unsigned long) archive_file_offset + offset, reason);
316 /* Check for overflow. */
317 if (nmemb < (~(size_t) 0 - 1) / size)
318 /* + 1 so that we can '\0' terminate invalid string table sections. */
319 mvar = malloc (size * nmemb + 1);
323 error (_("Out of memory allocating 0x%lx bytes for %s\n"),
324 (unsigned long)(size * nmemb), reason);
328 ((char *) mvar)[size * nmemb] = '\0';
331 if (fread (mvar, size, nmemb, file) != nmemb)
333 error (_("Unable to read in 0x%lx bytes of %s\n"),
334 (unsigned long)(size * nmemb), reason);
343 /* Print a VMA value. */
346 print_vma (bfd_vma vma, print_mode mode)
359 return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
366 return printf ("%5" BFD_VMA_FMT "d", vma);
374 return nc + printf ("%" BFD_VMA_FMT "x", vma);
377 return printf ("%" BFD_VMA_FMT "d", vma);
380 return printf ("%" BFD_VMA_FMT "u", vma);
385 /* Display a symbol on stdout. Handles the display of non-printing characters.
387 If DO_WIDE is not true then format the symbol to be at most WIDTH characters,
388 truncating as necessary. If WIDTH is negative then format the string to be
389 exactly - WIDTH characters, truncating or padding as necessary.
391 Returns the number of emitted characters. */
394 print_symbol (int width, const char *symbol)
397 bfd_boolean extra_padding = FALSE;
398 unsigned int num_printed = 0;
402 /* Set the width to a very large value. This simplifies the
408 /* Keep the width positive. This also helps. */
410 extra_padding = TRUE;
419 /* Look for non-printing symbols inside the symbol's name.
420 This test is triggered in particular by the names generated
421 by the assembler for local labels. */
432 printf ("%.*s", len, symbol);
438 if (*c == 0 || width == 0)
441 /* Now display the non-printing character, if
442 there is room left in which to dipslay it. */
443 if ((unsigned char) *c < 32)
448 printf ("^%c", *c + 0x40);
458 printf ("<0x%.2x>", (unsigned char) *c);
467 if (extra_padding && width > 0)
469 /* Fill in the remaining spaces. */
470 printf ("%-*s", width, " ");
477 /* Return a pointer to section NAME, or NULL if no such section exists. */
479 static Elf_Internal_Shdr *
480 find_section (const char * name)
484 for (i = 0; i < elf_header.e_shnum; i++)
485 if (streq (SECTION_NAME (section_headers + i), name))
486 return section_headers + i;
491 /* Return a pointer to a section containing ADDR, or NULL if no such
494 static Elf_Internal_Shdr *
495 find_section_by_address (bfd_vma addr)
499 for (i = 0; i < elf_header.e_shnum; i++)
501 Elf_Internal_Shdr *sec = section_headers + i;
502 if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
509 /* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
513 read_uleb128 (unsigned char *data, unsigned int *length_return)
515 return read_leb128 (data, length_return, 0);
518 /* Return true if the current file is for IA-64 machine and OpenVMS ABI.
519 This OS has so many departures from the ELF standard that we test it at
525 return elf_header.e_machine == EM_IA_64
526 && elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
529 /* Guess the relocation size commonly used by the specific machines. */
532 guess_is_rela (unsigned int e_machine)
536 /* Targets that use REL relocations. */
552 /* Targets that use RELA relocations. */
556 case EM_ALTERA_NIOS2:
576 case EM_LATTICEMICO32:
584 case EM_CYGNUS_MN10200:
586 case EM_CYGNUS_MN10300:
614 case EM_MICROBLAZE_OLD:
635 warn (_("Don't know about relocations on this machine architecture\n"));
641 slurp_rela_relocs (FILE * file,
642 unsigned long rel_offset,
643 unsigned long rel_size,
644 Elf_Internal_Rela ** relasp,
645 unsigned long * nrelasp)
647 Elf_Internal_Rela * relas;
648 unsigned long nrelas;
653 Elf32_External_Rela * erelas;
655 erelas = (Elf32_External_Rela *) get_data (NULL, file, rel_offset, 1,
656 rel_size, _("relocs"));
660 nrelas = rel_size / sizeof (Elf32_External_Rela);
662 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
663 sizeof (Elf_Internal_Rela));
668 error (_("out of memory parsing relocs\n"));
672 for (i = 0; i < nrelas; i++)
674 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
675 relas[i].r_info = BYTE_GET (erelas[i].r_info);
676 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
683 Elf64_External_Rela * erelas;
685 erelas = (Elf64_External_Rela *) get_data (NULL, file, rel_offset, 1,
686 rel_size, _("relocs"));
690 nrelas = rel_size / sizeof (Elf64_External_Rela);
692 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
693 sizeof (Elf_Internal_Rela));
698 error (_("out of memory parsing relocs\n"));
702 for (i = 0; i < nrelas; i++)
704 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
705 relas[i].r_info = BYTE_GET (erelas[i].r_info);
706 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
708 /* The #ifdef BFD64 below is to prevent a compile time
709 warning. We know that if we do not have a 64 bit data
710 type that we will never execute this code anyway. */
712 if (elf_header.e_machine == EM_MIPS
713 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
715 /* In little-endian objects, r_info isn't really a
716 64-bit little-endian value: it has a 32-bit
717 little-endian symbol index followed by four
718 individual byte fields. Reorder INFO
720 bfd_vma inf = relas[i].r_info;
721 inf = (((inf & 0xffffffff) << 32)
722 | ((inf >> 56) & 0xff)
723 | ((inf >> 40) & 0xff00)
724 | ((inf >> 24) & 0xff0000)
725 | ((inf >> 8) & 0xff000000));
726 relas[i].r_info = inf;
739 slurp_rel_relocs (FILE * file,
740 unsigned long rel_offset,
741 unsigned long rel_size,
742 Elf_Internal_Rela ** relsp,
743 unsigned long * nrelsp)
745 Elf_Internal_Rela * rels;
751 Elf32_External_Rel * erels;
753 erels = (Elf32_External_Rel *) get_data (NULL, file, rel_offset, 1,
754 rel_size, _("relocs"));
758 nrels = rel_size / sizeof (Elf32_External_Rel);
760 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
765 error (_("out of memory parsing relocs\n"));
769 for (i = 0; i < nrels; i++)
771 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
772 rels[i].r_info = BYTE_GET (erels[i].r_info);
773 rels[i].r_addend = 0;
780 Elf64_External_Rel * erels;
782 erels = (Elf64_External_Rel *) get_data (NULL, file, rel_offset, 1,
783 rel_size, _("relocs"));
787 nrels = rel_size / sizeof (Elf64_External_Rel);
789 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
794 error (_("out of memory parsing relocs\n"));
798 for (i = 0; i < nrels; i++)
800 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
801 rels[i].r_info = BYTE_GET (erels[i].r_info);
802 rels[i].r_addend = 0;
804 /* The #ifdef BFD64 below is to prevent a compile time
805 warning. We know that if we do not have a 64 bit data
806 type that we will never execute this code anyway. */
808 if (elf_header.e_machine == EM_MIPS
809 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
811 /* In little-endian objects, r_info isn't really a
812 64-bit little-endian value: it has a 32-bit
813 little-endian symbol index followed by four
814 individual byte fields. Reorder INFO
816 bfd_vma inf = rels[i].r_info;
817 inf = (((inf & 0xffffffff) << 32)
818 | ((inf >> 56) & 0xff)
819 | ((inf >> 40) & 0xff00)
820 | ((inf >> 24) & 0xff0000)
821 | ((inf >> 8) & 0xff000000));
822 rels[i].r_info = inf;
834 /* Returns the reloc type extracted from the reloc info field. */
837 get_reloc_type (bfd_vma reloc_info)
840 return ELF32_R_TYPE (reloc_info);
842 switch (elf_header.e_machine)
845 /* Note: We assume that reloc_info has already been adjusted for us. */
846 return ELF64_MIPS_R_TYPE (reloc_info);
849 return ELF64_R_TYPE_ID (reloc_info);
852 return ELF64_R_TYPE (reloc_info);
856 /* Return the symbol index extracted from the reloc info field. */
859 get_reloc_symindex (bfd_vma reloc_info)
861 return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
864 /* Display the contents of the relocation data found at the specified
868 dump_relocations (FILE * file,
869 unsigned long rel_offset,
870 unsigned long rel_size,
871 Elf_Internal_Sym * symtab,
874 unsigned long strtablen,
878 Elf_Internal_Rela * rels;
880 if (is_rela == UNKNOWN)
881 is_rela = guess_is_rela (elf_header.e_machine);
885 if (!slurp_rela_relocs (file, rel_offset, rel_size, &rels, &rel_size))
890 if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
899 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
901 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
906 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
908 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
916 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
918 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
923 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
925 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
929 for (i = 0; i < rel_size; i++)
934 bfd_vma symtab_index;
937 offset = rels[i].r_offset;
938 inf = rels[i].r_info;
940 type = get_reloc_type (inf);
941 symtab_index = get_reloc_symindex (inf);
945 printf ("%8.8lx %8.8lx ",
946 (unsigned long) offset & 0xffffffff,
947 (unsigned long) inf & 0xffffffff);
951 #if BFD_HOST_64BIT_LONG
953 ? "%16.16lx %16.16lx "
954 : "%12.12lx %12.12lx ",
956 #elif BFD_HOST_64BIT_LONG_LONG
959 ? "%16.16llx %16.16llx "
960 : "%12.12llx %12.12llx ",
964 ? "%16.16I64x %16.16I64x "
965 : "%12.12I64x %12.12I64x ",
970 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
971 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
972 _bfd_int64_high (offset),
973 _bfd_int64_low (offset),
974 _bfd_int64_high (inf),
975 _bfd_int64_low (inf));
979 switch (elf_header.e_machine)
987 rtype = elf_m32r_reloc_type (type);
992 rtype = elf_i386_reloc_type (type);
997 rtype = elf_m68hc11_reloc_type (type);
1001 rtype = elf_m68k_reloc_type (type);
1005 rtype = elf_i960_reloc_type (type);
1010 rtype = elf_avr_reloc_type (type);
1013 case EM_OLD_SPARCV9:
1014 case EM_SPARC32PLUS:
1017 rtype = elf_sparc_reloc_type (type);
1021 rtype = elf_spu_reloc_type (type);
1025 case EM_CYGNUS_V850:
1026 rtype = v850_reloc_type (type);
1030 case EM_CYGNUS_D10V:
1031 rtype = elf_d10v_reloc_type (type);
1035 case EM_CYGNUS_D30V:
1036 rtype = elf_d30v_reloc_type (type);
1040 rtype = elf_dlx_reloc_type (type);
1044 rtype = elf_sh_reloc_type (type);
1048 case EM_CYGNUS_MN10300:
1049 rtype = elf_mn10300_reloc_type (type);
1053 case EM_CYGNUS_MN10200:
1054 rtype = elf_mn10200_reloc_type (type);
1058 case EM_CYGNUS_FR30:
1059 rtype = elf_fr30_reloc_type (type);
1063 rtype = elf_frv_reloc_type (type);
1067 rtype = elf_mcore_reloc_type (type);
1071 rtype = elf_mmix_reloc_type (type);
1075 rtype = elf_moxie_reloc_type (type);
1080 rtype = elf_msp430_reloc_type (type);
1084 rtype = elf_ppc_reloc_type (type);
1088 rtype = elf_ppc64_reloc_type (type);
1092 case EM_MIPS_RS3_LE:
1093 rtype = elf_mips_reloc_type (type);
1097 rtype = elf_alpha_reloc_type (type);
1101 rtype = elf_arm_reloc_type (type);
1105 rtype = elf_arc_reloc_type (type);
1109 rtype = elf_hppa_reloc_type (type);
1115 rtype = elf_h8_reloc_type (type);
1120 rtype = elf_or32_reloc_type (type);
1125 rtype = elf_pj_reloc_type (type);
1128 rtype = elf_ia64_reloc_type (type);
1132 rtype = elf_cris_reloc_type (type);
1136 rtype = elf_i860_reloc_type (type);
1141 rtype = elf_x86_64_reloc_type (type);
1145 rtype = i370_reloc_type (type);
1150 rtype = elf_s390_reloc_type (type);
1154 rtype = elf_score_reloc_type (type);
1158 rtype = elf_xstormy16_reloc_type (type);
1162 rtype = elf_crx_reloc_type (type);
1166 rtype = elf_vax_reloc_type (type);
1171 rtype = elf_ip2k_reloc_type (type);
1175 rtype = elf_iq2000_reloc_type (type);
1180 rtype = elf_xtensa_reloc_type (type);
1183 case EM_LATTICEMICO32:
1184 rtype = elf_lm32_reloc_type (type);
1189 rtype = elf_m32c_reloc_type (type);
1193 rtype = elf_mt_reloc_type (type);
1197 rtype = elf_bfin_reloc_type (type);
1201 rtype = elf_mep_reloc_type (type);
1206 rtype = elf_cr16_reloc_type (type);
1210 case EM_MICROBLAZE_OLD:
1211 rtype = elf_microblaze_reloc_type (type);
1215 rtype = elf_rx_reloc_type (type);
1220 rtype = elf_xc16x_reloc_type (type);
1224 rtype = elf_tic6x_reloc_type (type);
1228 rtype = elf_tilegx_reloc_type (type);
1232 rtype = elf_tilepro_reloc_type (type);
1237 printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
1239 printf (do_wide ? "%-22.22s" : "%-17.17s", rtype);
1241 if (elf_header.e_machine == EM_ALPHA
1243 && streq (rtype, "R_ALPHA_LITUSE")
1246 switch (rels[i].r_addend)
1248 case LITUSE_ALPHA_ADDR: rtype = "ADDR"; break;
1249 case LITUSE_ALPHA_BASE: rtype = "BASE"; break;
1250 case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1251 case LITUSE_ALPHA_JSR: rtype = "JSR"; break;
1252 case LITUSE_ALPHA_TLSGD: rtype = "TLSGD"; break;
1253 case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1254 case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1255 default: rtype = NULL;
1258 printf (" (%s)", rtype);
1262 printf (_("<unknown addend: %lx>"),
1263 (unsigned long) rels[i].r_addend);
1266 else if (symtab_index)
1268 if (symtab == NULL || symtab_index >= nsyms)
1269 printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index);
1272 Elf_Internal_Sym * psym;
1274 psym = symtab + symtab_index;
1278 if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1282 unsigned int width = is_32bit_elf ? 8 : 14;
1284 /* Relocations against GNU_IFUNC symbols do not use the value
1285 of the symbol as the address to relocate against. Instead
1286 they invoke the function named by the symbol and use its
1287 result as the address for relocation.
1289 To indicate this to the user, do not display the value of
1290 the symbol in the "Symbols's Value" field. Instead show
1291 its name followed by () as a hint that the symbol is
1295 || psym->st_name == 0
1296 || psym->st_name >= strtablen)
1299 name = strtab + psym->st_name;
1301 len = print_symbol (width, name);
1302 printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1306 print_vma (psym->st_value, LONG_HEX);
1308 printf (is_32bit_elf ? " " : " ");
1311 if (psym->st_name == 0)
1313 const char * sec_name = "<null>";
1316 if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1318 if (psym->st_shndx < elf_header.e_shnum)
1320 = SECTION_NAME (section_headers + psym->st_shndx);
1321 else if (psym->st_shndx == SHN_ABS)
1323 else if (psym->st_shndx == SHN_COMMON)
1324 sec_name = "COMMON";
1325 else if ((elf_header.e_machine == EM_MIPS
1326 && psym->st_shndx == SHN_MIPS_SCOMMON)
1327 || (elf_header.e_machine == EM_TI_C6000
1328 && psym->st_shndx == SHN_TIC6X_SCOMMON))
1329 sec_name = "SCOMMON";
1330 else if (elf_header.e_machine == EM_MIPS
1331 && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1332 sec_name = "SUNDEF";
1333 else if ((elf_header.e_machine == EM_X86_64
1334 || elf_header.e_machine == EM_L1OM)
1335 && psym->st_shndx == SHN_X86_64_LCOMMON)
1336 sec_name = "LARGE_COMMON";
1337 else if (elf_header.e_machine == EM_IA_64
1338 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1339 && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1340 sec_name = "ANSI_COM";
1341 else if (is_ia64_vms ()
1342 && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1343 sec_name = "VMS_SYMVEC";
1346 sprintf (name_buf, "<section 0x%x>",
1347 (unsigned int) psym->st_shndx);
1348 sec_name = name_buf;
1351 print_symbol (22, sec_name);
1353 else if (strtab == NULL)
1354 printf (_("<string table index: %3ld>"), psym->st_name);
1355 else if (psym->st_name >= strtablen)
1356 printf (_("<corrupt string table index: %3ld>"), psym->st_name);
1358 print_symbol (22, strtab + psym->st_name);
1362 bfd_signed_vma off = rels[i].r_addend;
1365 printf (" - %" BFD_VMA_FMT "x", - off);
1367 printf (" + %" BFD_VMA_FMT "x", off);
1373 printf ("%*c", is_32bit_elf ?
1374 (do_wide ? 34 : 28) : (do_wide ? 26 : 20), ' ');
1375 print_vma (rels[i].r_addend, LONG_HEX);
1378 if (elf_header.e_machine == EM_SPARCV9
1380 && streq (rtype, "R_SPARC_OLO10"))
1381 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
1386 if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
1388 bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1389 bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
1390 const char * rtype2 = elf_mips_reloc_type (type2);
1391 const char * rtype3 = elf_mips_reloc_type (type3);
1393 printf (" Type2: ");
1396 printf (_("unrecognized: %-7lx"),
1397 (unsigned long) type2 & 0xffffffff);
1399 printf ("%-17.17s", rtype2);
1401 printf ("\n Type3: ");
1404 printf (_("unrecognized: %-7lx"),
1405 (unsigned long) type3 & 0xffffffff);
1407 printf ("%-17.17s", rtype3);
1418 get_mips_dynamic_type (unsigned long type)
1422 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1423 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1424 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1425 case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1426 case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1427 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1428 case DT_MIPS_MSYM: return "MIPS_MSYM";
1429 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1430 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1431 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1432 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1433 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1434 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1435 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1436 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1437 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1438 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1439 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1440 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1441 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1442 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1443 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1444 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1445 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1446 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1447 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1448 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1449 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1450 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1451 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1452 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1453 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1454 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1455 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1456 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1457 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1458 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1459 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1460 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1461 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1462 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1463 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1464 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
1465 case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1466 case DT_MIPS_RWPLT: return "MIPS_RWPLT";
1473 get_sparc64_dynamic_type (unsigned long type)
1477 case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1484 get_ppc_dynamic_type (unsigned long type)
1488 case DT_PPC_GOT: return "PPC_GOT";
1489 case DT_PPC_TLSOPT: return "PPC_TLSOPT";
1496 get_ppc64_dynamic_type (unsigned long type)
1500 case DT_PPC64_GLINK: return "PPC64_GLINK";
1501 case DT_PPC64_OPD: return "PPC64_OPD";
1502 case DT_PPC64_OPDSZ: return "PPC64_OPDSZ";
1503 case DT_PPC64_TLSOPT: return "PPC64_TLSOPT";
1510 get_parisc_dynamic_type (unsigned long type)
1514 case DT_HP_LOAD_MAP: return "HP_LOAD_MAP";
1515 case DT_HP_DLD_FLAGS: return "HP_DLD_FLAGS";
1516 case DT_HP_DLD_HOOK: return "HP_DLD_HOOK";
1517 case DT_HP_UX10_INIT: return "HP_UX10_INIT";
1518 case DT_HP_UX10_INITSZ: return "HP_UX10_INITSZ";
1519 case DT_HP_PREINIT: return "HP_PREINIT";
1520 case DT_HP_PREINITSZ: return "HP_PREINITSZ";
1521 case DT_HP_NEEDED: return "HP_NEEDED";
1522 case DT_HP_TIME_STAMP: return "HP_TIME_STAMP";
1523 case DT_HP_CHECKSUM: return "HP_CHECKSUM";
1524 case DT_HP_GST_SIZE: return "HP_GST_SIZE";
1525 case DT_HP_GST_VERSION: return "HP_GST_VERSION";
1526 case DT_HP_GST_HASHVAL: return "HP_GST_HASHVAL";
1527 case DT_HP_EPLTREL: return "HP_GST_EPLTREL";
1528 case DT_HP_EPLTRELSZ: return "HP_GST_EPLTRELSZ";
1529 case DT_HP_FILTERED: return "HP_FILTERED";
1530 case DT_HP_FILTER_TLS: return "HP_FILTER_TLS";
1531 case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1532 case DT_HP_LAZYLOAD: return "HP_LAZYLOAD";
1533 case DT_HP_BIND_NOW_COUNT: return "HP_BIND_NOW_COUNT";
1534 case DT_PLT: return "PLT";
1535 case DT_PLT_SIZE: return "PLT_SIZE";
1536 case DT_DLT: return "DLT";
1537 case DT_DLT_SIZE: return "DLT_SIZE";
1544 get_ia64_dynamic_type (unsigned long type)
1548 case DT_IA_64_PLT_RESERVE: return "IA_64_PLT_RESERVE";
1549 case DT_IA_64_VMS_SUBTYPE: return "VMS_SUBTYPE";
1550 case DT_IA_64_VMS_IMGIOCNT: return "VMS_IMGIOCNT";
1551 case DT_IA_64_VMS_LNKFLAGS: return "VMS_LNKFLAGS";
1552 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1553 case DT_IA_64_VMS_IDENT: return "VMS_IDENT";
1554 case DT_IA_64_VMS_NEEDED_IDENT: return "VMS_NEEDED_IDENT";
1555 case DT_IA_64_VMS_IMG_RELA_CNT: return "VMS_IMG_RELA_CNT";
1556 case DT_IA_64_VMS_SEG_RELA_CNT: return "VMS_SEG_RELA_CNT";
1557 case DT_IA_64_VMS_FIXUP_RELA_CNT: return "VMS_FIXUP_RELA_CNT";
1558 case DT_IA_64_VMS_FIXUP_NEEDED: return "VMS_FIXUP_NEEDED";
1559 case DT_IA_64_VMS_SYMVEC_CNT: return "VMS_SYMVEC_CNT";
1560 case DT_IA_64_VMS_XLATED: return "VMS_XLATED";
1561 case DT_IA_64_VMS_STACKSIZE: return "VMS_STACKSIZE";
1562 case DT_IA_64_VMS_UNWINDSZ: return "VMS_UNWINDSZ";
1563 case DT_IA_64_VMS_UNWIND_CODSEG: return "VMS_UNWIND_CODSEG";
1564 case DT_IA_64_VMS_UNWIND_INFOSEG: return "VMS_UNWIND_INFOSEG";
1565 case DT_IA_64_VMS_LINKTIME: return "VMS_LINKTIME";
1566 case DT_IA_64_VMS_SEG_NO: return "VMS_SEG_NO";
1567 case DT_IA_64_VMS_SYMVEC_OFFSET: return "VMS_SYMVEC_OFFSET";
1568 case DT_IA_64_VMS_SYMVEC_SEG: return "VMS_SYMVEC_SEG";
1569 case DT_IA_64_VMS_UNWIND_OFFSET: return "VMS_UNWIND_OFFSET";
1570 case DT_IA_64_VMS_UNWIND_SEG: return "VMS_UNWIND_SEG";
1571 case DT_IA_64_VMS_STRTAB_OFFSET: return "VMS_STRTAB_OFFSET";
1572 case DT_IA_64_VMS_SYSVER_OFFSET: return "VMS_SYSVER_OFFSET";
1573 case DT_IA_64_VMS_IMG_RELA_OFF: return "VMS_IMG_RELA_OFF";
1574 case DT_IA_64_VMS_SEG_RELA_OFF: return "VMS_SEG_RELA_OFF";
1575 case DT_IA_64_VMS_FIXUP_RELA_OFF: return "VMS_FIXUP_RELA_OFF";
1576 case DT_IA_64_VMS_PLTGOT_OFFSET: return "VMS_PLTGOT_OFFSET";
1577 case DT_IA_64_VMS_PLTGOT_SEG: return "VMS_PLTGOT_SEG";
1578 case DT_IA_64_VMS_FPMODE: return "VMS_FPMODE";
1585 get_alpha_dynamic_type (unsigned long type)
1589 case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
1596 get_score_dynamic_type (unsigned long type)
1600 case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
1601 case DT_SCORE_LOCAL_GOTNO: return "SCORE_LOCAL_GOTNO";
1602 case DT_SCORE_SYMTABNO: return "SCORE_SYMTABNO";
1603 case DT_SCORE_GOTSYM: return "SCORE_GOTSYM";
1604 case DT_SCORE_UNREFEXTNO: return "SCORE_UNREFEXTNO";
1605 case DT_SCORE_HIPAGENO: return "SCORE_HIPAGENO";
1612 get_tic6x_dynamic_type (unsigned long type)
1616 case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
1617 case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
1618 case DT_C6000_DSBT_BASE: return "C6000_DSBT_BASE";
1619 case DT_C6000_DSBT_SIZE: return "C6000_DSBT_SIZE";
1620 case DT_C6000_PREEMPTMAP: return "C6000_PREEMPTMAP";
1621 case DT_C6000_DSBT_INDEX: return "C6000_DSBT_INDEX";
1628 get_dynamic_type (unsigned long type)
1630 static char buff[64];
1634 case DT_NULL: return "NULL";
1635 case DT_NEEDED: return "NEEDED";
1636 case DT_PLTRELSZ: return "PLTRELSZ";
1637 case DT_PLTGOT: return "PLTGOT";
1638 case DT_HASH: return "HASH";
1639 case DT_STRTAB: return "STRTAB";
1640 case DT_SYMTAB: return "SYMTAB";
1641 case DT_RELA: return "RELA";
1642 case DT_RELASZ: return "RELASZ";
1643 case DT_RELAENT: return "RELAENT";
1644 case DT_STRSZ: return "STRSZ";
1645 case DT_SYMENT: return "SYMENT";
1646 case DT_INIT: return "INIT";
1647 case DT_FINI: return "FINI";
1648 case DT_SONAME: return "SONAME";
1649 case DT_RPATH: return "RPATH";
1650 case DT_SYMBOLIC: return "SYMBOLIC";
1651 case DT_REL: return "REL";
1652 case DT_RELSZ: return "RELSZ";
1653 case DT_RELENT: return "RELENT";
1654 case DT_PLTREL: return "PLTREL";
1655 case DT_DEBUG: return "DEBUG";
1656 case DT_TEXTREL: return "TEXTREL";
1657 case DT_JMPREL: return "JMPREL";
1658 case DT_BIND_NOW: return "BIND_NOW";
1659 case DT_INIT_ARRAY: return "INIT_ARRAY";
1660 case DT_FINI_ARRAY: return "FINI_ARRAY";
1661 case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
1662 case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
1663 case DT_RUNPATH: return "RUNPATH";
1664 case DT_FLAGS: return "FLAGS";
1666 case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1667 case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
1669 case DT_CHECKSUM: return "CHECKSUM";
1670 case DT_PLTPADSZ: return "PLTPADSZ";
1671 case DT_MOVEENT: return "MOVEENT";
1672 case DT_MOVESZ: return "MOVESZ";
1673 case DT_FEATURE: return "FEATURE";
1674 case DT_POSFLAG_1: return "POSFLAG_1";
1675 case DT_SYMINSZ: return "SYMINSZ";
1676 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
1678 case DT_ADDRRNGLO: return "ADDRRNGLO";
1679 case DT_CONFIG: return "CONFIG";
1680 case DT_DEPAUDIT: return "DEPAUDIT";
1681 case DT_AUDIT: return "AUDIT";
1682 case DT_PLTPAD: return "PLTPAD";
1683 case DT_MOVETAB: return "MOVETAB";
1684 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
1686 case DT_VERSYM: return "VERSYM";
1688 case DT_TLSDESC_GOT: return "TLSDESC_GOT";
1689 case DT_TLSDESC_PLT: return "TLSDESC_PLT";
1690 case DT_RELACOUNT: return "RELACOUNT";
1691 case DT_RELCOUNT: return "RELCOUNT";
1692 case DT_FLAGS_1: return "FLAGS_1";
1693 case DT_VERDEF: return "VERDEF";
1694 case DT_VERDEFNUM: return "VERDEFNUM";
1695 case DT_VERNEED: return "VERNEED";
1696 case DT_VERNEEDNUM: return "VERNEEDNUM";
1698 case DT_AUXILIARY: return "AUXILIARY";
1699 case DT_USED: return "USED";
1700 case DT_FILTER: return "FILTER";
1702 case DT_GNU_PRELINKED: return "GNU_PRELINKED";
1703 case DT_GNU_CONFLICT: return "GNU_CONFLICT";
1704 case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
1705 case DT_GNU_LIBLIST: return "GNU_LIBLIST";
1706 case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
1707 case DT_GNU_HASH: return "GNU_HASH";
1710 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1712 const char * result;
1714 switch (elf_header.e_machine)
1717 case EM_MIPS_RS3_LE:
1718 result = get_mips_dynamic_type (type);
1721 result = get_sparc64_dynamic_type (type);
1724 result = get_ppc_dynamic_type (type);
1727 result = get_ppc64_dynamic_type (type);
1730 result = get_ia64_dynamic_type (type);
1733 result = get_alpha_dynamic_type (type);
1736 result = get_score_dynamic_type (type);
1739 result = get_tic6x_dynamic_type (type);
1749 snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
1751 else if (((type >= DT_LOOS) && (type <= DT_HIOS))
1752 || (elf_header.e_machine == EM_PARISC
1753 && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
1755 const char * result;
1757 switch (elf_header.e_machine)
1760 result = get_parisc_dynamic_type (type);
1763 result = get_ia64_dynamic_type (type);
1773 snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
1777 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
1784 get_file_type (unsigned e_type)
1786 static char buff[32];
1790 case ET_NONE: return _("NONE (None)");
1791 case ET_REL: return _("REL (Relocatable file)");
1792 case ET_EXEC: return _("EXEC (Executable file)");
1793 case ET_DYN: return _("DYN (Shared object file)");
1794 case ET_CORE: return _("CORE (Core file)");
1797 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
1798 snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
1799 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
1800 snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
1802 snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
1808 get_machine_name (unsigned e_machine)
1810 static char buff[64]; /* XXX */
1814 case EM_NONE: return _("None");
1815 case EM_M32: return "WE32100";
1816 case EM_SPARC: return "Sparc";
1817 case EM_SPU: return "SPU";
1818 case EM_386: return "Intel 80386";
1819 case EM_68K: return "MC68000";
1820 case EM_88K: return "MC88000";
1821 case EM_486: return "Intel 80486";
1822 case EM_860: return "Intel 80860";
1823 case EM_MIPS: return "MIPS R3000";
1824 case EM_S370: return "IBM System/370";
1825 case EM_MIPS_RS3_LE: return "MIPS R4000 big-endian";
1826 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
1827 case EM_PARISC: return "HPPA";
1828 case EM_PPC_OLD: return "Power PC (old)";
1829 case EM_SPARC32PLUS: return "Sparc v8+" ;
1830 case EM_960: return "Intel 90860";
1831 case EM_PPC: return "PowerPC";
1832 case EM_PPC64: return "PowerPC64";
1833 case EM_V800: return "NEC V800";
1834 case EM_FR20: return "Fujitsu FR20";
1835 case EM_RH32: return "TRW RH32";
1836 case EM_MCORE: return "MCORE";
1837 case EM_ARM: return "ARM";
1838 case EM_OLD_ALPHA: return "Digital Alpha (old)";
1839 case EM_SH: return "Renesas / SuperH SH";
1840 case EM_SPARCV9: return "Sparc v9";
1841 case EM_TRICORE: return "Siemens Tricore";
1842 case EM_ARC: return "ARC";
1843 case EM_H8_300: return "Renesas H8/300";
1844 case EM_H8_300H: return "Renesas H8/300H";
1845 case EM_H8S: return "Renesas H8S";
1846 case EM_H8_500: return "Renesas H8/500";
1847 case EM_IA_64: return "Intel IA-64";
1848 case EM_MIPS_X: return "Stanford MIPS-X";
1849 case EM_COLDFIRE: return "Motorola Coldfire";
1850 case EM_68HC12: return "Motorola M68HC12";
1851 case EM_ALPHA: return "Alpha";
1852 case EM_CYGNUS_D10V:
1853 case EM_D10V: return "d10v";
1854 case EM_CYGNUS_D30V:
1855 case EM_D30V: return "d30v";
1856 case EM_CYGNUS_M32R:
1857 case EM_M32R: return "Renesas M32R (formerly Mitsubishi M32r)";
1858 case EM_CYGNUS_V850:
1859 case EM_V850: return "Renesas v850";
1860 case EM_CYGNUS_MN10300:
1861 case EM_MN10300: return "mn10300";
1862 case EM_CYGNUS_MN10200:
1863 case EM_MN10200: return "mn10200";
1864 case EM_MOXIE: return "Moxie";
1865 case EM_CYGNUS_FR30:
1866 case EM_FR30: return "Fujitsu FR30";
1867 case EM_CYGNUS_FRV: return "Fujitsu FR-V";
1869 case EM_PJ: return "picoJava";
1870 case EM_MMA: return "Fujitsu Multimedia Accelerator";
1871 case EM_PCP: return "Siemens PCP";
1872 case EM_NCPU: return "Sony nCPU embedded RISC processor";
1873 case EM_NDR1: return "Denso NDR1 microprocesspr";
1874 case EM_STARCORE: return "Motorola Star*Core processor";
1875 case EM_ME16: return "Toyota ME16 processor";
1876 case EM_ST100: return "STMicroelectronics ST100 processor";
1877 case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
1878 case EM_PDSP: return "Sony DSP processor";
1879 case EM_PDP10: return "Digital Equipment Corp. PDP-10";
1880 case EM_PDP11: return "Digital Equipment Corp. PDP-11";
1881 case EM_FX66: return "Siemens FX66 microcontroller";
1882 case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1883 case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
1884 case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
1885 case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
1886 case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
1887 case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
1888 case EM_SVX: return "Silicon Graphics SVx";
1889 case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
1890 case EM_VAX: return "Digital VAX";
1892 case EM_AVR: return "Atmel AVR 8-bit microcontroller";
1893 case EM_CRIS: return "Axis Communications 32-bit embedded processor";
1894 case EM_JAVELIN: return "Infineon Technologies 32-bit embedded cpu";
1895 case EM_FIREPATH: return "Element 14 64-bit DSP processor";
1896 case EM_ZSP: return "LSI Logic's 16-bit DSP processor";
1897 case EM_MMIX: return "Donald Knuth's educational 64-bit processor";
1898 case EM_HUANY: return "Harvard Universitys's machine-independent object format";
1899 case EM_PRISM: return "Vitesse Prism";
1900 case EM_X86_64: return "Advanced Micro Devices X86-64";
1901 case EM_L1OM: return "Intel L1OM";
1903 case EM_S390: return "IBM S/390";
1904 case EM_SCORE: return "SUNPLUS S+Core";
1905 case EM_XSTORMY16: return "Sanyo XStormy16 CPU core";
1907 case EM_OR32: return "OpenRISC";
1908 case EM_ARC_A5: return "ARC International ARCompact processor";
1909 case EM_CRX: return "National Semiconductor CRX microprocessor";
1910 case EM_DLX: return "OpenDLX";
1912 case EM_IP2K: return "Ubicom IP2xxx 8-bit microcontrollers";
1913 case EM_IQ2000: return "Vitesse IQ2000";
1915 case EM_XTENSA: return "Tensilica Xtensa Processor";
1916 case EM_VIDEOCORE: return "Alphamosaic VideoCore processor";
1917 case EM_TMM_GPP: return "Thompson Multimedia General Purpose Processor";
1918 case EM_NS32K: return "National Semiconductor 32000 series";
1919 case EM_TPC: return "Tenor Network TPC processor";
1920 case EM_ST200: return "STMicroelectronics ST200 microcontroller";
1921 case EM_MAX: return "MAX Processor";
1922 case EM_CR: return "National Semiconductor CompactRISC";
1923 case EM_F2MC16: return "Fujitsu F2MC16";
1924 case EM_MSP430: return "Texas Instruments msp430 microcontroller";
1925 case EM_LATTICEMICO32: return "Lattice Mico32";
1927 case EM_M32C: return "Renesas M32c";
1928 case EM_MT: return "Morpho Techologies MT processor";
1929 case EM_BLACKFIN: return "Analog Devices Blackfin";
1930 case EM_SE_C33: return "S1C33 Family of Seiko Epson processors";
1931 case EM_SEP: return "Sharp embedded microprocessor";
1932 case EM_ARCA: return "Arca RISC microprocessor";
1933 case EM_UNICORE: return "Unicore";
1934 case EM_EXCESS: return "eXcess 16/32/64-bit configurable embedded CPU";
1935 case EM_DXP: return "Icera Semiconductor Inc. Deep Execution Processor";
1936 case EM_NIOS32: return "Altera Nios";
1937 case EM_ALTERA_NIOS2: return "Altera Nios II";
1939 case EM_XC16X: return "Infineon Technologies xc16x";
1940 case EM_M16C: return "Renesas M16C series microprocessors";
1941 case EM_DSPIC30F: return "Microchip Technology dsPIC30F Digital Signal Controller";
1942 case EM_CE: return "Freescale Communication Engine RISC core";
1943 case EM_TSK3000: return "Altium TSK3000 core";
1944 case EM_RS08: return "Freescale RS08 embedded processor";
1945 case EM_ECOG2: return "Cyan Technology eCOG2 microprocessor";
1946 case EM_DSP24: return "New Japan Radio (NJR) 24-bit DSP Processor";
1947 case EM_VIDEOCORE3: return "Broadcom VideoCore III processor";
1948 case EM_SE_C17: return "Seiko Epson C17 family";
1949 case EM_TI_C6000: return "Texas Instruments TMS320C6000 DSP family";
1950 case EM_TI_C2000: return "Texas Instruments TMS320C2000 DSP family";
1951 case EM_TI_C5500: return "Texas Instruments TMS320C55x DSP family";
1952 case EM_MMDSP_PLUS: return "STMicroelectronics 64bit VLIW Data Signal Processor";
1953 case EM_CYPRESS_M8C: return "Cypress M8C microprocessor";
1954 case EM_R32C: return "Renesas R32C series microprocessors";
1955 case EM_TRIMEDIA: return "NXP Semiconductors TriMedia architecture family";
1956 case EM_QDSP6: return "QUALCOMM DSP6 Processor";
1957 case EM_8051: return "Intel 8051 and variants";
1958 case EM_STXP7X: return "STMicroelectronics STxP7x family";
1959 case EM_NDS32: return "Andes Technology compact code size embedded RISC processor family";
1960 case EM_ECOG1X: return "Cyan Technology eCOG1X family";
1961 case EM_MAXQ30: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
1962 case EM_XIMO16: return "New Japan Radio (NJR) 16-bit DSP Processor";
1963 case EM_MANIK: return "M2000 Reconfigurable RISC Microprocessor";
1964 case EM_CRAYNV2: return "Cray Inc. NV2 vector architecture";
1965 case EM_CYGNUS_MEP: return "Toshiba MeP Media Engine";
1967 case EM_CR16_OLD: return "National Semiconductor's CR16";
1968 case EM_MICROBLAZE: return "Xilinx MicroBlaze";
1969 case EM_MICROBLAZE_OLD: return "Xilinx MicroBlaze";
1970 case EM_RX: return "Renesas RX";
1971 case EM_METAG: return "Imagination Technologies META processor architecture";
1972 case EM_MCST_ELBRUS: return "MCST Elbrus general purpose hardware architecture";
1973 case EM_ECOG16: return "Cyan Technology eCOG16 family";
1974 case EM_ETPU: return "Freescale Extended Time Processing Unit";
1975 case EM_SLE9X: return "Infineon Technologies SLE9X core";
1976 case EM_AVR32: return "Atmel Corporation 32-bit microprocessor family";
1977 case EM_STM8: return "STMicroeletronics STM8 8-bit microcontroller";
1978 case EM_TILE64: return "Tilera TILE64 multicore architecture family";
1979 case EM_TILEPRO: return "Tilera TILEPro multicore architecture family";
1980 case EM_TILEGX: return "Tilera TILE-Gx multicore architecture family";
1981 case EM_CUDA: return "NVIDIA CUDA architecture";
1983 snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
1989 decode_ARM_machine_flags (unsigned e_flags, char buf[])
1994 eabi = EF_ARM_EABI_VERSION (e_flags);
1995 e_flags &= ~ EF_ARM_EABIMASK;
1997 /* Handle "generic" ARM flags. */
1998 if (e_flags & EF_ARM_RELEXEC)
2000 strcat (buf, ", relocatable executable");
2001 e_flags &= ~ EF_ARM_RELEXEC;
2004 if (e_flags & EF_ARM_HASENTRY)
2006 strcat (buf, ", has entry point");
2007 e_flags &= ~ EF_ARM_HASENTRY;
2010 /* Now handle EABI specific flags. */
2014 strcat (buf, ", <unrecognized EABI>");
2019 case EF_ARM_EABI_VER1:
2020 strcat (buf, ", Version1 EABI");
2025 /* Process flags one bit at a time. */
2026 flag = e_flags & - e_flags;
2031 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2032 strcat (buf, ", sorted symbol tables");
2042 case EF_ARM_EABI_VER2:
2043 strcat (buf, ", Version2 EABI");
2048 /* Process flags one bit at a time. */
2049 flag = e_flags & - e_flags;
2054 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2055 strcat (buf, ", sorted symbol tables");
2058 case EF_ARM_DYNSYMSUSESEGIDX:
2059 strcat (buf, ", dynamic symbols use segment index");
2062 case EF_ARM_MAPSYMSFIRST:
2063 strcat (buf, ", mapping symbols precede others");
2073 case EF_ARM_EABI_VER3:
2074 strcat (buf, ", Version3 EABI");
2077 case EF_ARM_EABI_VER4:
2078 strcat (buf, ", Version4 EABI");
2081 case EF_ARM_EABI_VER5:
2082 strcat (buf, ", Version5 EABI");
2088 /* Process flags one bit at a time. */
2089 flag = e_flags & - e_flags;
2095 strcat (buf, ", BE8");
2099 strcat (buf, ", LE8");
2109 case EF_ARM_EABI_UNKNOWN:
2110 strcat (buf, ", GNU EABI");
2115 /* Process flags one bit at a time. */
2116 flag = e_flags & - e_flags;
2121 case EF_ARM_INTERWORK:
2122 strcat (buf, ", interworking enabled");
2125 case EF_ARM_APCS_26:
2126 strcat (buf, ", uses APCS/26");
2129 case EF_ARM_APCS_FLOAT:
2130 strcat (buf, ", uses APCS/float");
2134 strcat (buf, ", position independent");
2138 strcat (buf, ", 8 bit structure alignment");
2141 case EF_ARM_NEW_ABI:
2142 strcat (buf, ", uses new ABI");
2145 case EF_ARM_OLD_ABI:
2146 strcat (buf, ", uses old ABI");
2149 case EF_ARM_SOFT_FLOAT:
2150 strcat (buf, ", software FP");
2153 case EF_ARM_VFP_FLOAT:
2154 strcat (buf, ", VFP");
2157 case EF_ARM_MAVERICK_FLOAT:
2158 strcat (buf, ", Maverick FP");
2169 strcat (buf,_(", <unknown>"));
2173 get_machine_flags (unsigned e_flags, unsigned e_machine)
2175 static char buf[1024];
2187 decode_ARM_machine_flags (e_flags, buf);
2191 if (e_flags & EF_BFIN_PIC)
2192 strcat (buf, ", PIC");
2194 if (e_flags & EF_BFIN_FDPIC)
2195 strcat (buf, ", FDPIC");
2197 if (e_flags & EF_BFIN_CODE_IN_L1)
2198 strcat (buf, ", code in L1");
2200 if (e_flags & EF_BFIN_DATA_IN_L1)
2201 strcat (buf, ", data in L1");
2206 switch (e_flags & EF_FRV_CPU_MASK)
2208 case EF_FRV_CPU_GENERIC:
2212 strcat (buf, ", fr???");
2215 case EF_FRV_CPU_FR300:
2216 strcat (buf, ", fr300");
2219 case EF_FRV_CPU_FR400:
2220 strcat (buf, ", fr400");
2222 case EF_FRV_CPU_FR405:
2223 strcat (buf, ", fr405");
2226 case EF_FRV_CPU_FR450:
2227 strcat (buf, ", fr450");
2230 case EF_FRV_CPU_FR500:
2231 strcat (buf, ", fr500");
2233 case EF_FRV_CPU_FR550:
2234 strcat (buf, ", fr550");
2237 case EF_FRV_CPU_SIMPLE:
2238 strcat (buf, ", simple");
2240 case EF_FRV_CPU_TOMCAT:
2241 strcat (buf, ", tomcat");
2247 if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
2248 strcat (buf, ", m68000");
2249 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
2250 strcat (buf, ", cpu32");
2251 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
2252 strcat (buf, ", fido_a");
2255 char const * isa = _("unknown");
2256 char const * mac = _("unknown mac");
2257 char const * additional = NULL;
2259 switch (e_flags & EF_M68K_CF_ISA_MASK)
2261 case EF_M68K_CF_ISA_A_NODIV:
2263 additional = ", nodiv";
2265 case EF_M68K_CF_ISA_A:
2268 case EF_M68K_CF_ISA_A_PLUS:
2271 case EF_M68K_CF_ISA_B_NOUSP:
2273 additional = ", nousp";
2275 case EF_M68K_CF_ISA_B:
2278 case EF_M68K_CF_ISA_C:
2281 case EF_M68K_CF_ISA_C_NODIV:
2283 additional = ", nodiv";
2286 strcat (buf, ", cf, isa ");
2289 strcat (buf, additional);
2290 if (e_flags & EF_M68K_CF_FLOAT)
2291 strcat (buf, ", float");
2292 switch (e_flags & EF_M68K_CF_MAC_MASK)
2297 case EF_M68K_CF_MAC:
2300 case EF_M68K_CF_EMAC:
2303 case EF_M68K_CF_EMAC_B:
2316 if (e_flags & EF_PPC_EMB)
2317 strcat (buf, ", emb");
2319 if (e_flags & EF_PPC_RELOCATABLE)
2320 strcat (buf, _(", relocatable"));
2322 if (e_flags & EF_PPC_RELOCATABLE_LIB)
2323 strcat (buf, _(", relocatable-lib"));
2327 case EM_CYGNUS_V850:
2328 switch (e_flags & EF_V850_ARCH)
2330 case E_V850E2V3_ARCH:
2331 strcat (buf, ", v850e2v3");
2334 strcat (buf, ", v850e2");
2337 strcat (buf, ", v850e1");
2340 strcat (buf, ", v850e");
2343 strcat (buf, ", v850");
2346 strcat (buf, _(", unknown v850 architecture variant"));
2352 case EM_CYGNUS_M32R:
2353 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
2354 strcat (buf, ", m32r");
2358 case EM_MIPS_RS3_LE:
2359 if (e_flags & EF_MIPS_NOREORDER)
2360 strcat (buf, ", noreorder");
2362 if (e_flags & EF_MIPS_PIC)
2363 strcat (buf, ", pic");
2365 if (e_flags & EF_MIPS_CPIC)
2366 strcat (buf, ", cpic");
2368 if (e_flags & EF_MIPS_UCODE)
2369 strcat (buf, ", ugen_reserved");
2371 if (e_flags & EF_MIPS_ABI2)
2372 strcat (buf, ", abi2");
2374 if (e_flags & EF_MIPS_OPTIONS_FIRST)
2375 strcat (buf, ", odk first");
2377 if (e_flags & EF_MIPS_32BITMODE)
2378 strcat (buf, ", 32bitmode");
2380 switch ((e_flags & EF_MIPS_MACH))
2382 case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
2383 case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
2384 case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
2385 case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
2386 case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
2387 case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
2388 case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
2389 case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
2390 case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); break;
2391 case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
2392 case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
2393 case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
2394 case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
2395 case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
2396 case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
2397 case E_MIPS_MACH_XLR: strcat (buf, ", xlr"); break;
2399 /* We simply ignore the field in this case to avoid confusion:
2400 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2403 default: strcat (buf, _(", unknown CPU")); break;
2406 switch ((e_flags & EF_MIPS_ABI))
2408 case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
2409 case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
2410 case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
2411 case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
2413 /* We simply ignore the field in this case to avoid confusion:
2414 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2415 This means it is likely to be an o32 file, but not for
2418 default: strcat (buf, _(", unknown ABI")); break;
2421 if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
2422 strcat (buf, ", mdmx");
2424 if (e_flags & EF_MIPS_ARCH_ASE_M16)
2425 strcat (buf, ", mips16");
2427 switch ((e_flags & EF_MIPS_ARCH))
2429 case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
2430 case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
2431 case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
2432 case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
2433 case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
2434 case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
2435 case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
2436 case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
2437 case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
2438 default: strcat (buf, _(", unknown ISA")); break;
2441 if (e_flags & EF_SH_PIC)
2442 strcat (buf, ", pic");
2444 if (e_flags & EF_SH_FDPIC)
2445 strcat (buf, ", fdpic");
2449 switch ((e_flags & EF_SH_MACH_MASK))
2451 case EF_SH1: strcat (buf, ", sh1"); break;
2452 case EF_SH2: strcat (buf, ", sh2"); break;
2453 case EF_SH3: strcat (buf, ", sh3"); break;
2454 case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
2455 case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
2456 case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
2457 case EF_SH3E: strcat (buf, ", sh3e"); break;
2458 case EF_SH4: strcat (buf, ", sh4"); break;
2459 case EF_SH5: strcat (buf, ", sh5"); break;
2460 case EF_SH2E: strcat (buf, ", sh2e"); break;
2461 case EF_SH4A: strcat (buf, ", sh4a"); break;
2462 case EF_SH2A: strcat (buf, ", sh2a"); break;
2463 case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
2464 case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
2465 case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
2466 case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
2467 case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
2468 case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
2469 case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
2470 case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
2471 case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
2472 default: strcat (buf, _(", unknown ISA")); break;
2478 if (e_flags & EF_SPARC_32PLUS)
2479 strcat (buf, ", v8+");
2481 if (e_flags & EF_SPARC_SUN_US1)
2482 strcat (buf, ", ultrasparcI");
2484 if (e_flags & EF_SPARC_SUN_US3)
2485 strcat (buf, ", ultrasparcIII");
2487 if (e_flags & EF_SPARC_HAL_R1)
2488 strcat (buf, ", halr1");
2490 if (e_flags & EF_SPARC_LEDATA)
2491 strcat (buf, ", ledata");
2493 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
2494 strcat (buf, ", tso");
2496 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
2497 strcat (buf, ", pso");
2499 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
2500 strcat (buf, ", rmo");
2504 switch (e_flags & EF_PARISC_ARCH)
2506 case EFA_PARISC_1_0:
2507 strcpy (buf, ", PA-RISC 1.0");
2509 case EFA_PARISC_1_1:
2510 strcpy (buf, ", PA-RISC 1.1");
2512 case EFA_PARISC_2_0:
2513 strcpy (buf, ", PA-RISC 2.0");
2518 if (e_flags & EF_PARISC_TRAPNIL)
2519 strcat (buf, ", trapnil");
2520 if (e_flags & EF_PARISC_EXT)
2521 strcat (buf, ", ext");
2522 if (e_flags & EF_PARISC_LSB)
2523 strcat (buf, ", lsb");
2524 if (e_flags & EF_PARISC_WIDE)
2525 strcat (buf, ", wide");
2526 if (e_flags & EF_PARISC_NO_KABP)
2527 strcat (buf, ", no kabp");
2528 if (e_flags & EF_PARISC_LAZYSWAP)
2529 strcat (buf, ", lazyswap");
2534 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
2535 strcat (buf, ", new calling convention");
2537 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
2538 strcat (buf, ", gnu calling convention");
2542 if ((e_flags & EF_IA_64_ABI64))
2543 strcat (buf, ", 64-bit");
2545 strcat (buf, ", 32-bit");
2546 if ((e_flags & EF_IA_64_REDUCEDFP))
2547 strcat (buf, ", reduced fp model");
2548 if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
2549 strcat (buf, ", no function descriptors, constant gp");
2550 else if ((e_flags & EF_IA_64_CONS_GP))
2551 strcat (buf, ", constant gp");
2552 if ((e_flags & EF_IA_64_ABSOLUTE))
2553 strcat (buf, ", absolute");
2554 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
2556 if ((e_flags & EF_IA_64_VMS_LINKAGES))
2557 strcat (buf, ", vms_linkages");
2558 switch ((e_flags & EF_IA_64_VMS_COMCOD))
2560 case EF_IA_64_VMS_COMCOD_SUCCESS:
2562 case EF_IA_64_VMS_COMCOD_WARNING:
2563 strcat (buf, ", warning");
2565 case EF_IA_64_VMS_COMCOD_ERROR:
2566 strcat (buf, ", error");
2568 case EF_IA_64_VMS_COMCOD_ABORT:
2569 strcat (buf, ", abort");
2578 if ((e_flags & EF_VAX_NONPIC))
2579 strcat (buf, ", non-PIC");
2580 if ((e_flags & EF_VAX_DFLOAT))
2581 strcat (buf, ", D-Float");
2582 if ((e_flags & EF_VAX_GFLOAT))
2583 strcat (buf, ", G-Float");
2587 if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
2588 strcat (buf, ", 64-bit doubles");
2589 if (e_flags & E_FLAG_RX_DSP)
2590 strcat (buf, ", dsp");
2593 if (e_flags & EF_S390_HIGH_GPRS)
2594 strcat (buf, ", highgprs");
2597 if ((e_flags & EF_C6000_REL))
2598 strcat (buf, ", relocatable module");
2606 get_osabi_name (unsigned int osabi)
2608 static char buff[32];
2612 case ELFOSABI_NONE: return "UNIX - System V";
2613 case ELFOSABI_HPUX: return "UNIX - HP-UX";
2614 case ELFOSABI_NETBSD: return "UNIX - NetBSD";
2615 case ELFOSABI_GNU: return "UNIX - GNU";
2616 case ELFOSABI_SOLARIS: return "UNIX - Solaris";
2617 case ELFOSABI_AIX: return "UNIX - AIX";
2618 case ELFOSABI_IRIX: return "UNIX - IRIX";
2619 case ELFOSABI_FREEBSD: return "UNIX - FreeBSD";
2620 case ELFOSABI_TRU64: return "UNIX - TRU64";
2621 case ELFOSABI_MODESTO: return "Novell - Modesto";
2622 case ELFOSABI_OPENBSD: return "UNIX - OpenBSD";
2623 case ELFOSABI_OPENVMS: return "VMS - OpenVMS";
2624 case ELFOSABI_NSK: return "HP - Non-Stop Kernel";
2625 case ELFOSABI_AROS: return "AROS";
2626 case ELFOSABI_FENIXOS: return "FenixOS";
2629 switch (elf_header.e_machine)
2634 case ELFOSABI_ARM: return "ARM";
2644 case ELFOSABI_STANDALONE: return _("Standalone App");
2653 case ELFOSABI_C6000_ELFABI: return _("Bare-metal C6000");
2654 case ELFOSABI_C6000_LINUX: return "Linux C6000";
2663 snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
2669 get_arm_segment_type (unsigned long type)
2683 get_mips_segment_type (unsigned long type)
2687 case PT_MIPS_REGINFO:
2689 case PT_MIPS_RTPROC:
2691 case PT_MIPS_OPTIONS:
2701 get_parisc_segment_type (unsigned long type)
2705 case PT_HP_TLS: return "HP_TLS";
2706 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
2707 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
2708 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
2709 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
2710 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
2711 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
2712 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
2713 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
2714 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
2715 case PT_HP_PARALLEL: return "HP_PARALLEL";
2716 case PT_HP_FASTBIND: return "HP_FASTBIND";
2717 case PT_HP_OPT_ANNOT: return "HP_OPT_ANNOT";
2718 case PT_HP_HSL_ANNOT: return "HP_HSL_ANNOT";
2719 case PT_HP_STACK: return "HP_STACK";
2720 case PT_HP_CORE_UTSNAME: return "HP_CORE_UTSNAME";
2721 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
2722 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
2723 case PT_PARISC_WEAKORDER: return "PARISC_WEAKORDER";
2732 get_ia64_segment_type (unsigned long type)
2736 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
2737 case PT_IA_64_UNWIND: return "IA_64_UNWIND";
2738 case PT_HP_TLS: return "HP_TLS";
2739 case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
2740 case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
2741 case PT_IA_64_HP_STACK: return "HP_STACK";
2750 get_tic6x_segment_type (unsigned long type)
2754 case PT_C6000_PHATTR: return "C6000_PHATTR";
2763 get_segment_type (unsigned long p_type)
2765 static char buff[32];
2769 case PT_NULL: return "NULL";
2770 case PT_LOAD: return "LOAD";
2771 case PT_DYNAMIC: return "DYNAMIC";
2772 case PT_INTERP: return "INTERP";
2773 case PT_NOTE: return "NOTE";
2774 case PT_SHLIB: return "SHLIB";
2775 case PT_PHDR: return "PHDR";
2776 case PT_TLS: return "TLS";
2778 case PT_GNU_EH_FRAME:
2779 return "GNU_EH_FRAME";
2780 case PT_GNU_STACK: return "GNU_STACK";
2781 case PT_GNU_RELRO: return "GNU_RELRO";
2784 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
2786 const char * result;
2788 switch (elf_header.e_machine)
2791 result = get_arm_segment_type (p_type);
2794 case EM_MIPS_RS3_LE:
2795 result = get_mips_segment_type (p_type);
2798 result = get_parisc_segment_type (p_type);
2801 result = get_ia64_segment_type (p_type);
2804 result = get_tic6x_segment_type (p_type);
2814 sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
2816 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
2818 const char * result;
2820 switch (elf_header.e_machine)
2823 result = get_parisc_segment_type (p_type);
2826 result = get_ia64_segment_type (p_type);
2836 sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
2839 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
2846 get_mips_section_type_name (unsigned int sh_type)
2850 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
2851 case SHT_MIPS_MSYM: return "MIPS_MSYM";
2852 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
2853 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
2854 case SHT_MIPS_UCODE: return "MIPS_UCODE";
2855 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
2856 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
2857 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
2858 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
2859 case SHT_MIPS_RELD: return "MIPS_RELD";
2860 case SHT_MIPS_IFACE: return "MIPS_IFACE";
2861 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
2862 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
2863 case SHT_MIPS_SHDR: return "MIPS_SHDR";
2864 case SHT_MIPS_FDESC: return "MIPS_FDESC";
2865 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
2866 case SHT_MIPS_DENSE: return "MIPS_DENSE";
2867 case SHT_MIPS_PDESC: return "MIPS_PDESC";
2868 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
2869 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
2870 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
2871 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
2872 case SHT_MIPS_LINE: return "MIPS_LINE";
2873 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
2874 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
2875 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
2876 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
2877 case SHT_MIPS_DWARF: return "MIPS_DWARF";
2878 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
2879 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
2880 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
2881 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
2882 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
2883 case SHT_MIPS_XLATE: return "MIPS_XLATE";
2884 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
2885 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
2886 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
2887 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
2888 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
2896 get_parisc_section_type_name (unsigned int sh_type)
2900 case SHT_PARISC_EXT: return "PARISC_EXT";
2901 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
2902 case SHT_PARISC_DOC: return "PARISC_DOC";
2903 case SHT_PARISC_ANNOT: return "PARISC_ANNOT";
2904 case SHT_PARISC_SYMEXTN: return "PARISC_SYMEXTN";
2905 case SHT_PARISC_STUBS: return "PARISC_STUBS";
2906 case SHT_PARISC_DLKM: return "PARISC_DLKM";
2914 get_ia64_section_type_name (unsigned int sh_type)
2916 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
2917 if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
2918 return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
2922 case SHT_IA_64_EXT: return "IA_64_EXT";
2923 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
2924 case SHT_IA_64_PRIORITY_INIT: return "IA_64_PRIORITY_INIT";
2925 case SHT_IA_64_VMS_TRACE: return "VMS_TRACE";
2926 case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
2927 case SHT_IA_64_VMS_DEBUG: return "VMS_DEBUG";
2928 case SHT_IA_64_VMS_DEBUG_STR: return "VMS_DEBUG_STR";
2929 case SHT_IA_64_VMS_LINKAGES: return "VMS_LINKAGES";
2930 case SHT_IA_64_VMS_SYMBOL_VECTOR: return "VMS_SYMBOL_VECTOR";
2931 case SHT_IA_64_VMS_FIXUP: return "VMS_FIXUP";
2939 get_x86_64_section_type_name (unsigned int sh_type)
2943 case SHT_X86_64_UNWIND: return "X86_64_UNWIND";
2951 get_arm_section_type_name (unsigned int sh_type)
2955 case SHT_ARM_EXIDX: return "ARM_EXIDX";
2956 case SHT_ARM_PREEMPTMAP: return "ARM_PREEMPTMAP";
2957 case SHT_ARM_ATTRIBUTES: return "ARM_ATTRIBUTES";
2958 case SHT_ARM_DEBUGOVERLAY: return "ARM_DEBUGOVERLAY";
2959 case SHT_ARM_OVERLAYSECTION: return "ARM_OVERLAYSECTION";
2967 get_tic6x_section_type_name (unsigned int sh_type)
2971 case SHT_C6000_UNWIND:
2972 return "C6000_UNWIND";
2973 case SHT_C6000_PREEMPTMAP:
2974 return "C6000_PREEMPTMAP";
2975 case SHT_C6000_ATTRIBUTES:
2976 return "C6000_ATTRIBUTES";
2981 case SHT_TI_HANDLER:
2982 return "TI_HANDLER";
2983 case SHT_TI_INITINFO:
2984 return "TI_INITINFO";
2985 case SHT_TI_PHATTRS:
2986 return "TI_PHATTRS";
2994 get_section_type_name (unsigned int sh_type)
2996 static char buff[32];
3000 case SHT_NULL: return "NULL";
3001 case SHT_PROGBITS: return "PROGBITS";
3002 case SHT_SYMTAB: return "SYMTAB";
3003 case SHT_STRTAB: return "STRTAB";
3004 case SHT_RELA: return "RELA";
3005 case SHT_HASH: return "HASH";
3006 case SHT_DYNAMIC: return "DYNAMIC";
3007 case SHT_NOTE: return "NOTE";
3008 case SHT_NOBITS: return "NOBITS";
3009 case SHT_REL: return "REL";
3010 case SHT_SHLIB: return "SHLIB";
3011 case SHT_DYNSYM: return "DYNSYM";
3012 case SHT_INIT_ARRAY: return "INIT_ARRAY";
3013 case SHT_FINI_ARRAY: return "FINI_ARRAY";
3014 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
3015 case SHT_GNU_HASH: return "GNU_HASH";
3016 case SHT_GROUP: return "GROUP";
3017 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICIES";
3018 case SHT_GNU_verdef: return "VERDEF";
3019 case SHT_GNU_verneed: return "VERNEED";
3020 case SHT_GNU_versym: return "VERSYM";
3021 case 0x6ffffff0: return "VERSYM";
3022 case 0x6ffffffc: return "VERDEF";
3023 case 0x7ffffffd: return "AUXILIARY";
3024 case 0x7fffffff: return "FILTER";
3025 case SHT_GNU_LIBLIST: return "GNU_LIBLIST";
3028 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
3030 const char * result;
3032 switch (elf_header.e_machine)
3035 case EM_MIPS_RS3_LE:
3036 result = get_mips_section_type_name (sh_type);
3039 result = get_parisc_section_type_name (sh_type);
3042 result = get_ia64_section_type_name (sh_type);
3046 result = get_x86_64_section_type_name (sh_type);
3049 result = get_arm_section_type_name (sh_type);
3052 result = get_tic6x_section_type_name (sh_type);
3062 sprintf (buff, "LOPROC+%x", sh_type - SHT_LOPROC);
3064 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
3066 const char * result;
3068 switch (elf_header.e_machine)
3071 result = get_ia64_section_type_name (sh_type);
3081 sprintf (buff, "LOOS+%x", sh_type - SHT_LOOS);
3083 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
3084 sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER);
3086 /* This message is probably going to be displayed in a 15
3087 character wide field, so put the hex value first. */
3088 snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
3094 #define OPTION_DEBUG_DUMP 512
3095 #define OPTION_DYN_SYMS 513
3096 #define OPTION_DWARF_DEPTH 514
3097 #define OPTION_DWARF_START 515
3099 static struct option options[] =
3101 {"all", no_argument, 0, 'a'},
3102 {"file-header", no_argument, 0, 'h'},
3103 {"program-headers", no_argument, 0, 'l'},
3104 {"headers", no_argument, 0, 'e'},
3105 {"histogram", no_argument, 0, 'I'},
3106 {"segments", no_argument, 0, 'l'},
3107 {"sections", no_argument, 0, 'S'},
3108 {"section-headers", no_argument, 0, 'S'},
3109 {"section-groups", no_argument, 0, 'g'},
3110 {"section-details", no_argument, 0, 't'},
3111 {"full-section-name",no_argument, 0, 'N'},
3112 {"symbols", no_argument, 0, 's'},
3113 {"syms", no_argument, 0, 's'},
3114 {"dyn-syms", no_argument, 0, OPTION_DYN_SYMS},
3115 {"relocs", no_argument, 0, 'r'},
3116 {"notes", no_argument, 0, 'n'},
3117 {"dynamic", no_argument, 0, 'd'},
3118 {"arch-specific", no_argument, 0, 'A'},
3119 {"version-info", no_argument, 0, 'V'},
3120 {"use-dynamic", no_argument, 0, 'D'},
3121 {"unwind", no_argument, 0, 'u'},
3122 {"archive-index", no_argument, 0, 'c'},
3123 {"hex-dump", required_argument, 0, 'x'},
3124 {"relocated-dump", required_argument, 0, 'R'},
3125 {"string-dump", required_argument, 0, 'p'},
3126 #ifdef SUPPORT_DISASSEMBLY
3127 {"instruction-dump", required_argument, 0, 'i'},
3129 {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
3131 {"dwarf-depth", required_argument, 0, OPTION_DWARF_DEPTH},
3132 {"dwarf-start", required_argument, 0, OPTION_DWARF_START},
3134 {"version", no_argument, 0, 'v'},
3135 {"wide", no_argument, 0, 'W'},
3136 {"help", no_argument, 0, 'H'},
3137 {0, no_argument, 0, 0}
3141 usage (FILE * stream)
3143 fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
3144 fprintf (stream, _(" Display information about the contents of ELF format files\n"));
3145 fprintf (stream, _(" Options are:\n\
3146 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3147 -h --file-header Display the ELF file header\n\
3148 -l --program-headers Display the program headers\n\
3149 --segments An alias for --program-headers\n\
3150 -S --section-headers Display the sections' header\n\
3151 --sections An alias for --section-headers\n\
3152 -g --section-groups Display the section groups\n\
3153 -t --section-details Display the section details\n\
3154 -e --headers Equivalent to: -h -l -S\n\
3155 -s --syms Display the symbol table\n\
3156 --symbols An alias for --syms\n\
3157 --dyn-syms Display the dynamic symbol table\n\
3158 -n --notes Display the core notes (if present)\n\
3159 -r --relocs Display the relocations (if present)\n\
3160 -u --unwind Display the unwind info (if present)\n\
3161 -d --dynamic Display the dynamic section (if present)\n\
3162 -V --version-info Display the version sections (if present)\n\
3163 -A --arch-specific Display architecture specific information (if any).\n\
3164 -c --archive-index Display the symbol/file index in an archive\n\
3165 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
3166 -x --hex-dump=<number|name>\n\
3167 Dump the contents of section <number|name> as bytes\n\
3168 -p --string-dump=<number|name>\n\
3169 Dump the contents of section <number|name> as strings\n\
3170 -R --relocated-dump=<number|name>\n\
3171 Dump the contents of section <number|name> as relocated bytes\n\
3172 -w[lLiaprmfFsoRt] or\n\
3173 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
3174 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
3175 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges]\n\
3176 Display the contents of DWARF2 debug sections\n"));
3177 fprintf (stream, _("\
3178 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
3179 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
3181 #ifdef SUPPORT_DISASSEMBLY
3182 fprintf (stream, _("\
3183 -i --instruction-dump=<number|name>\n\
3184 Disassemble the contents of section <number|name>\n"));
3186 fprintf (stream, _("\
3187 -I --histogram Display histogram of bucket list lengths\n\
3188 -W --wide Allow output width to exceed 80 characters\n\
3189 @<file> Read options from <file>\n\
3190 -H --help Display this information\n\
3191 -v --version Display the version number of readelf\n"));
3193 if (REPORT_BUGS_TO[0] && stream == stdout)
3194 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
3196 exit (stream == stdout ? 0 : 1);
3199 /* Record the fact that the user wants the contents of section number
3200 SECTION to be displayed using the method(s) encoded as flags bits
3201 in TYPE. Note, TYPE can be zero if we are creating the array for
3205 request_dump_bynumber (unsigned int section, dump_type type)
3207 if (section >= num_dump_sects)
3209 dump_type * new_dump_sects;
3211 new_dump_sects = (dump_type *) calloc (section + 1,
3212 sizeof (* dump_sects));
3214 if (new_dump_sects == NULL)
3215 error (_("Out of memory allocating dump request table.\n"));
3218 /* Copy current flag settings. */
3219 memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
3223 dump_sects = new_dump_sects;
3224 num_dump_sects = section + 1;
3229 dump_sects[section] |= type;
3234 /* Request a dump by section name. */
3237 request_dump_byname (const char * section, dump_type type)
3239 struct dump_list_entry * new_request;
3241 new_request = (struct dump_list_entry *)
3242 malloc (sizeof (struct dump_list_entry));
3244 error (_("Out of memory allocating dump request table.\n"));
3246 new_request->name = strdup (section);
3247 if (!new_request->name)
3248 error (_("Out of memory allocating dump request table.\n"));
3250 new_request->type = type;
3252 new_request->next = dump_sects_byname;
3253 dump_sects_byname = new_request;
3257 request_dump (dump_type type)
3263 section = strtoul (optarg, & cp, 0);
3265 if (! *cp && section >= 0)
3266 request_dump_bynumber (section, type);
3268 request_dump_byname (optarg, type);
3273 parse_args (int argc, char ** argv)
3280 while ((c = getopt_long
3281 (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options, NULL)) != EOF)
3299 do_section_groups++;
3307 do_section_groups++;
3312 do_section_details++;
3356 request_dump (HEX_DUMP);
3359 request_dump (STRING_DUMP);
3362 request_dump (RELOC_DUMP);
3369 dwarf_select_sections_all ();
3374 dwarf_select_sections_by_letters (optarg);
3377 case OPTION_DEBUG_DUMP:
3384 dwarf_select_sections_by_names (optarg);
3387 case OPTION_DWARF_DEPTH:
3391 dwarf_cutoff_level = strtoul (optarg, & cp, 0);
3394 case OPTION_DWARF_START:
3398 dwarf_start_die = strtoul (optarg, & cp, 0);
3401 case OPTION_DYN_SYMS:
3404 #ifdef SUPPORT_DISASSEMBLY
3406 request_dump (DISASS_DUMP);
3410 print_version (program_name);
3419 /* xgettext:c-format */
3420 error (_("Invalid option '-%c'\n"), c);
3427 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
3428 && !do_segments && !do_header && !do_dump && !do_version
3429 && !do_histogram && !do_debugging && !do_arch && !do_notes
3430 && !do_section_groups && !do_archive_index
3435 warn (_("Nothing to do.\n"));
3441 get_elf_class (unsigned int elf_class)
3443 static char buff[32];
3447 case ELFCLASSNONE: return _("none");
3448 case ELFCLASS32: return "ELF32";
3449 case ELFCLASS64: return "ELF64";
3451 snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
3457 get_data_encoding (unsigned int encoding)
3459 static char buff[32];
3463 case ELFDATANONE: return _("none");
3464 case ELFDATA2LSB: return _("2's complement, little endian");
3465 case ELFDATA2MSB: return _("2's complement, big endian");
3467 snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
3472 /* Decode the data held in 'elf_header'. */
3475 process_file_header (void)
3477 if ( elf_header.e_ident[EI_MAG0] != ELFMAG0
3478 || elf_header.e_ident[EI_MAG1] != ELFMAG1
3479 || elf_header.e_ident[EI_MAG2] != ELFMAG2
3480 || elf_header.e_ident[EI_MAG3] != ELFMAG3)
3483 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3487 init_dwarf_regnames (elf_header.e_machine);
3493 printf (_("ELF Header:\n"));
3494 printf (_(" Magic: "));
3495 for (i = 0; i < EI_NIDENT; i++)
3496 printf ("%2.2x ", elf_header.e_ident[i]);
3498 printf (_(" Class: %s\n"),
3499 get_elf_class (elf_header.e_ident[EI_CLASS]));
3500 printf (_(" Data: %s\n"),
3501 get_data_encoding (elf_header.e_ident[EI_DATA]));
3502 printf (_(" Version: %d %s\n"),
3503 elf_header.e_ident[EI_VERSION],
3504 (elf_header.e_ident[EI_VERSION] == EV_CURRENT
3506 : (elf_header.e_ident[EI_VERSION] != EV_NONE
3507 ? _("<unknown: %lx>")
3509 printf (_(" OS/ABI: %s\n"),
3510 get_osabi_name (elf_header.e_ident[EI_OSABI]));
3511 printf (_(" ABI Version: %d\n"),
3512 elf_header.e_ident[EI_ABIVERSION]);
3513 printf (_(" Type: %s\n"),
3514 get_file_type (elf_header.e_type));
3515 printf (_(" Machine: %s\n"),
3516 get_machine_name (elf_header.e_machine));
3517 printf (_(" Version: 0x%lx\n"),
3518 (unsigned long) elf_header.e_version);
3520 printf (_(" Entry point address: "));
3521 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
3522 printf (_("\n Start of program headers: "));
3523 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
3524 printf (_(" (bytes into file)\n Start of section headers: "));
3525 print_vma ((bfd_vma) elf_header.e_shoff, DEC);
3526 printf (_(" (bytes into file)\n"));
3528 printf (_(" Flags: 0x%lx%s\n"),
3529 (unsigned long) elf_header.e_flags,
3530 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
3531 printf (_(" Size of this header: %ld (bytes)\n"),
3532 (long) elf_header.e_ehsize);
3533 printf (_(" Size of program headers: %ld (bytes)\n"),
3534 (long) elf_header.e_phentsize);
3535 printf (_(" Number of program headers: %ld"),
3536 (long) elf_header.e_phnum);
3537 if (section_headers != NULL
3538 && elf_header.e_phnum == PN_XNUM
3539 && section_headers[0].sh_info != 0)
3540 printf (" (%ld)", (long) section_headers[0].sh_info);
3541 putc ('\n', stdout);
3542 printf (_(" Size of section headers: %ld (bytes)\n"),
3543 (long) elf_header.e_shentsize);
3544 printf (_(" Number of section headers: %ld"),
3545 (long) elf_header.e_shnum);
3546 if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
3547 printf (" (%ld)", (long) section_headers[0].sh_size);
3548 putc ('\n', stdout);
3549 printf (_(" Section header string table index: %ld"),
3550 (long) elf_header.e_shstrndx);
3551 if (section_headers != NULL
3552 && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
3553 printf (" (%u)", section_headers[0].sh_link);
3554 else if (elf_header.e_shstrndx != SHN_UNDEF
3555 && elf_header.e_shstrndx >= elf_header.e_shnum)
3556 printf (_(" <corrupt: out of range>"));
3557 putc ('\n', stdout);
3560 if (section_headers != NULL)
3562 if (elf_header.e_phnum == PN_XNUM
3563 && section_headers[0].sh_info != 0)
3564 elf_header.e_phnum = section_headers[0].sh_info;
3565 if (elf_header.e_shnum == SHN_UNDEF)
3566 elf_header.e_shnum = section_headers[0].sh_size;
3567 if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
3568 elf_header.e_shstrndx = section_headers[0].sh_link;
3569 else if (elf_header.e_shstrndx >= elf_header.e_shnum)
3570 elf_header.e_shstrndx = SHN_UNDEF;
3571 free (section_headers);
3572 section_headers = NULL;
3580 get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
3582 Elf32_External_Phdr * phdrs;
3583 Elf32_External_Phdr * external;
3584 Elf_Internal_Phdr * internal;
3587 phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
3588 elf_header.e_phentsize,
3590 _("program headers"));
3594 for (i = 0, internal = pheaders, external = phdrs;
3595 i < elf_header.e_phnum;
3596 i++, internal++, external++)
3598 internal->p_type = BYTE_GET (external->p_type);
3599 internal->p_offset = BYTE_GET (external->p_offset);
3600 internal->p_vaddr = BYTE_GET (external->p_vaddr);
3601 internal->p_paddr = BYTE_GET (external->p_paddr);
3602 internal->p_filesz = BYTE_GET (external->p_filesz);
3603 internal->p_memsz = BYTE_GET (external->p_memsz);
3604 internal->p_flags = BYTE_GET (external->p_flags);
3605 internal->p_align = BYTE_GET (external->p_align);
3614 get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
3616 Elf64_External_Phdr * phdrs;
3617 Elf64_External_Phdr * external;
3618 Elf_Internal_Phdr * internal;
3621 phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
3622 elf_header.e_phentsize,
3624 _("program headers"));
3628 for (i = 0, internal = pheaders, external = phdrs;
3629 i < elf_header.e_phnum;
3630 i++, internal++, external++)
3632 internal->p_type = BYTE_GET (external->p_type);
3633 internal->p_flags = BYTE_GET (external->p_flags);
3634 internal->p_offset = BYTE_GET (external->p_offset);
3635 internal->p_vaddr = BYTE_GET (external->p_vaddr);
3636 internal->p_paddr = BYTE_GET (external->p_paddr);
3637 internal->p_filesz = BYTE_GET (external->p_filesz);
3638 internal->p_memsz = BYTE_GET (external->p_memsz);
3639 internal->p_align = BYTE_GET (external->p_align);
3647 /* Returns 1 if the program headers were read into `program_headers'. */
3650 get_program_headers (FILE * file)
3652 Elf_Internal_Phdr * phdrs;
3654 /* Check cache of prior read. */
3655 if (program_headers != NULL)
3658 phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
3659 sizeof (Elf_Internal_Phdr));
3663 error (_("Out of memory\n"));
3668 ? get_32bit_program_headers (file, phdrs)
3669 : get_64bit_program_headers (file, phdrs))
3671 program_headers = phdrs;
3679 /* Returns 1 if the program headers were loaded. */
3682 process_program_headers (FILE * file)
3684 Elf_Internal_Phdr * segment;
3687 if (elf_header.e_phnum == 0)
3689 /* PR binutils/12467. */
3690 if (elf_header.e_phoff != 0)
3691 warn (_("possibly corrupt ELF header - it has a non-zero program"
3692 " header offset, but no program headers"));
3693 else if (do_segments)
3694 printf (_("\nThere are no program headers in this file.\n"));
3698 if (do_segments && !do_header)
3700 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
3701 printf (_("Entry point "));
3702 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
3703 printf (_("\nThere are %d program headers, starting at offset "),
3704 elf_header.e_phnum);
3705 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
3709 if (! get_program_headers (file))
3714 if (elf_header.e_phnum > 1)
3715 printf (_("\nProgram Headers:\n"));
3717 printf (_("\nProgram Headers:\n"));
3721 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3724 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3728 (_(" Type Offset VirtAddr PhysAddr\n"));
3730 (_(" FileSiz MemSiz Flags Align\n"));
3737 for (i = 0, segment = program_headers;
3738 i < elf_header.e_phnum;
3743 printf (" %-14.14s ", get_segment_type (segment->p_type));
3747 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
3748 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
3749 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
3750 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
3751 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
3753 (segment->p_flags & PF_R ? 'R' : ' '),
3754 (segment->p_flags & PF_W ? 'W' : ' '),
3755 (segment->p_flags & PF_X ? 'E' : ' '));
3756 printf ("%#lx", (unsigned long) segment->p_align);
3760 if ((unsigned long) segment->p_offset == segment->p_offset)
3761 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
3764 print_vma (segment->p_offset, FULL_HEX);
3768 print_vma (segment->p_vaddr, FULL_HEX);
3770 print_vma (segment->p_paddr, FULL_HEX);
3773 if ((unsigned long) segment->p_filesz == segment->p_filesz)
3774 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
3777 print_vma (segment->p_filesz, FULL_HEX);
3781 if ((unsigned long) segment->p_memsz == segment->p_memsz)
3782 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
3785 print_vma (segment->p_offset, FULL_HEX);
3789 (segment->p_flags & PF_R ? 'R' : ' '),
3790 (segment->p_flags & PF_W ? 'W' : ' '),
3791 (segment->p_flags & PF_X ? 'E' : ' '));
3793 if ((unsigned long) segment->p_align == segment->p_align)
3794 printf ("%#lx", (unsigned long) segment->p_align);
3797 print_vma (segment->p_align, PREFIX_HEX);
3802 print_vma (segment->p_offset, FULL_HEX);
3804 print_vma (segment->p_vaddr, FULL_HEX);
3806 print_vma (segment->p_paddr, FULL_HEX);
3808 print_vma (segment->p_filesz, FULL_HEX);
3810 print_vma (segment->p_memsz, FULL_HEX);
3812 (segment->p_flags & PF_R ? 'R' : ' '),
3813 (segment->p_flags & PF_W ? 'W' : ' '),
3814 (segment->p_flags & PF_X ? 'E' : ' '));
3815 print_vma (segment->p_align, HEX);
3819 switch (segment->p_type)
3823 error (_("more than one dynamic segment\n"));
3825 /* By default, assume that the .dynamic section is the first
3826 section in the DYNAMIC segment. */
3827 dynamic_addr = segment->p_offset;
3828 dynamic_size = segment->p_filesz;
3830 /* Try to locate the .dynamic section. If there is
3831 a section header table, we can easily locate it. */
3832 if (section_headers != NULL)
3834 Elf_Internal_Shdr * sec;
3836 sec = find_section (".dynamic");
3837 if (sec == NULL || sec->sh_size == 0)
3839 /* A corresponding .dynamic section is expected, but on
3840 IA-64/OpenVMS it is OK for it to be missing. */
3841 if (!is_ia64_vms ())
3842 error (_("no .dynamic section in the dynamic segment\n"));
3846 if (sec->sh_type == SHT_NOBITS)
3852 dynamic_addr = sec->sh_offset;
3853 dynamic_size = sec->sh_size;
3855 if (dynamic_addr < segment->p_offset
3856 || dynamic_addr > segment->p_offset + segment->p_filesz)
3857 warn (_("the .dynamic section is not contained"
3858 " within the dynamic segment\n"));
3859 else if (dynamic_addr > segment->p_offset)
3860 warn (_("the .dynamic section is not the first section"
3861 " in the dynamic segment.\n"));
3866 if (fseek (file, archive_file_offset + (long) segment->p_offset,
3868 error (_("Unable to find program interpreter name\n"));
3872 int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX);
3874 if (ret >= (int) sizeof (fmt) || ret < 0)
3875 error (_("Internal error: failed to create format string to display program interpreter\n"));
3877 program_interpreter[0] = 0;
3878 if (fscanf (file, fmt, program_interpreter) <= 0)
3879 error (_("Unable to read program interpreter name\n"));
3882 printf (_("\n [Requesting program interpreter: %s]"),
3883 program_interpreter);
3889 putc ('\n', stdout);
3892 if (do_segments && section_headers != NULL && string_table != NULL)
3894 printf (_("\n Section to Segment mapping:\n"));
3895 printf (_(" Segment Sections...\n"));
3897 for (i = 0; i < elf_header.e_phnum; i++)
3900 Elf_Internal_Shdr * section;
3902 segment = program_headers + i;
3903 section = section_headers + 1;
3905 printf (" %2.2d ", i);
3907 for (j = 1; j < elf_header.e_shnum; j++, section++)
3909 if (!ELF_TBSS_SPECIAL (section, segment)
3910 && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
3911 printf ("%s ", SECTION_NAME (section));
3922 /* Find the file offset corresponding to VMA by using the program headers. */
3925 offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
3927 Elf_Internal_Phdr * seg;
3929 if (! get_program_headers (file))
3931 warn (_("Cannot interpret virtual addresses without program headers.\n"));
3935 for (seg = program_headers;
3936 seg < program_headers + elf_header.e_phnum;
3939 if (seg->p_type != PT_LOAD)
3942 if (vma >= (seg->p_vaddr & -seg->p_align)
3943 && vma + size <= seg->p_vaddr + seg->p_filesz)
3944 return vma - seg->p_vaddr + seg->p_offset;
3947 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
3948 (unsigned long) vma);
3954 get_32bit_section_headers (FILE * file, unsigned int num)
3956 Elf32_External_Shdr * shdrs;
3957 Elf_Internal_Shdr * internal;
3960 shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
3961 elf_header.e_shentsize, num,
3962 _("section headers"));
3966 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
3967 sizeof (Elf_Internal_Shdr));
3969 if (section_headers == NULL)
3971 error (_("Out of memory\n"));
3975 for (i = 0, internal = section_headers;
3979 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
3980 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
3981 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
3982 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
3983 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
3984 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
3985 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
3986 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
3987 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
3988 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
3997 get_64bit_section_headers (FILE * file, unsigned int num)
3999 Elf64_External_Shdr * shdrs;
4000 Elf_Internal_Shdr * internal;
4003 shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
4004 elf_header.e_shentsize, num,
4005 _("section headers"));
4009 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4010 sizeof (Elf_Internal_Shdr));
4012 if (section_headers == NULL)
4014 error (_("Out of memory\n"));
4018 for (i = 0, internal = section_headers;
4022 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4023 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
4024 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4025 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4026 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4027 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
4028 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4029 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
4030 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
4031 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4039 static Elf_Internal_Sym *
4040 get_32bit_elf_symbols (FILE * file, Elf_Internal_Shdr * section)
4042 unsigned long number;
4043 Elf32_External_Sym * esyms = NULL;
4044 Elf_External_Sym_Shndx * shndx;
4045 Elf_Internal_Sym * isyms = NULL;
4046 Elf_Internal_Sym * psym;
4049 /* Run some sanity checks first. */
4050 if (section->sh_entsize == 0)
4052 error (_("sh_entsize is zero\n"));
4056 number = section->sh_size / section->sh_entsize;
4058 if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
4060 error (_("Invalid sh_entsize\n"));
4064 esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4065 section->sh_size, _("symbols"));
4070 if (symtab_shndx_hdr != NULL
4071 && (symtab_shndx_hdr->sh_link
4072 == (unsigned long) (section - section_headers)))
4074 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4075 symtab_shndx_hdr->sh_offset,
4076 1, symtab_shndx_hdr->sh_size,
4082 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
4086 error (_("Out of memory\n"));
4090 for (j = 0, psym = isyms; j < number; j++, psym++)
4092 psym->st_name = BYTE_GET (esyms[j].st_name);
4093 psym->st_value = BYTE_GET (esyms[j].st_value);
4094 psym->st_size = BYTE_GET (esyms[j].st_size);
4095 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4096 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
4098 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4099 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4100 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
4101 psym->st_info = BYTE_GET (esyms[j].st_info);
4102 psym->st_other = BYTE_GET (esyms[j].st_other);
4114 static Elf_Internal_Sym *
4115 get_64bit_elf_symbols (FILE * file, Elf_Internal_Shdr * section)
4117 unsigned long number;
4118 Elf64_External_Sym * esyms;
4119 Elf_External_Sym_Shndx * shndx;
4120 Elf_Internal_Sym * isyms;
4121 Elf_Internal_Sym * psym;
4124 /* Run some sanity checks first. */
4125 if (section->sh_entsize == 0)
4127 error (_("sh_entsize is zero\n"));
4131 number = section->sh_size / section->sh_entsize;
4133 if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
4135 error (_("Invalid sh_entsize\n"));
4139 esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4140 section->sh_size, _("symbols"));
4145 if (symtab_shndx_hdr != NULL
4146 && (symtab_shndx_hdr->sh_link
4147 == (unsigned long) (section - section_headers)))
4149 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4150 symtab_shndx_hdr->sh_offset,
4151 1, symtab_shndx_hdr->sh_size,
4160 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
4164 error (_("Out of memory\n"));
4171 for (j = 0, psym = isyms;
4175 psym->st_name = BYTE_GET (esyms[j].st_name);
4176 psym->st_info = BYTE_GET (esyms[j].st_info);
4177 psym->st_other = BYTE_GET (esyms[j].st_other);
4178 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4179 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
4181 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4182 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4183 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
4184 psym->st_value = BYTE_GET (esyms[j].st_value);
4185 psym->st_size = BYTE_GET (esyms[j].st_size);
4196 get_elf_section_flags (bfd_vma sh_flags)
4198 static char buff[1024];
4200 int field_size = is_32bit_elf ? 8 : 16;
4202 int size = sizeof (buff) - (field_size + 4 + 1);
4203 bfd_vma os_flags = 0;
4204 bfd_vma proc_flags = 0;
4205 bfd_vma unknown_flags = 0;
4213 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
4214 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
4215 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
4216 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
4217 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
4218 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
4219 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
4220 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
4221 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
4222 /* 9 */ { STRING_COMMA_LEN ("TLS") },
4223 /* IA-64 specific. */
4224 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
4225 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
4226 /* IA-64 OpenVMS specific. */
4227 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
4228 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
4229 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
4230 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
4231 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
4232 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
4234 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
4235 /* SPARC specific. */
4236 /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
4239 if (do_section_details)
4241 sprintf (buff, "[%*.*lx]: ",
4242 field_size, field_size, (unsigned long) sh_flags);
4243 p += field_size + 4;
4250 flag = sh_flags & - sh_flags;
4253 if (do_section_details)
4257 case SHF_WRITE: sindex = 0; break;
4258 case SHF_ALLOC: sindex = 1; break;
4259 case SHF_EXECINSTR: sindex = 2; break;
4260 case SHF_MERGE: sindex = 3; break;
4261 case SHF_STRINGS: sindex = 4; break;
4262 case SHF_INFO_LINK: sindex = 5; break;
4263 case SHF_LINK_ORDER: sindex = 6; break;
4264 case SHF_OS_NONCONFORMING: sindex = 7; break;
4265 case SHF_GROUP: sindex = 8; break;
4266 case SHF_TLS: sindex = 9; break;
4267 case SHF_EXCLUDE: sindex = 18; break;
4271 switch (elf_header.e_machine)
4274 if (flag == SHF_IA_64_SHORT)
4276 else if (flag == SHF_IA_64_NORECOV)
4279 else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
4282 case SHF_IA_64_VMS_GLOBAL: sindex = 12; break;
4283 case SHF_IA_64_VMS_OVERLAID: sindex = 13; break;
4284 case SHF_IA_64_VMS_SHARED: sindex = 14; break;
4285 case SHF_IA_64_VMS_VECTOR: sindex = 15; break;
4286 case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
4287 case SHF_IA_64_VMS_PROTECTED: sindex = 17; break;
4297 case EM_OLD_SPARCV9:
4298 case EM_SPARC32PLUS:
4301 if (flag == SHF_ORDERED)
4311 if (p != buff + field_size + 4)
4313 if (size < (10 + 2))
4320 size -= flags [sindex].len;
4321 p = stpcpy (p, flags [sindex].str);
4323 else if (flag & SHF_MASKOS)
4325 else if (flag & SHF_MASKPROC)
4328 unknown_flags |= flag;
4334 case SHF_WRITE: *p = 'W'; break;
4335 case SHF_ALLOC: *p = 'A'; break;
4336 case SHF_EXECINSTR: *p = 'X'; break;
4337 case SHF_MERGE: *p = 'M'; break;
4338 case SHF_STRINGS: *p = 'S'; break;
4339 case SHF_INFO_LINK: *p = 'I'; break;
4340 case SHF_LINK_ORDER: *p = 'L'; break;
4341 case SHF_OS_NONCONFORMING: *p = 'O'; break;
4342 case SHF_GROUP: *p = 'G'; break;
4343 case SHF_TLS: *p = 'T'; break;
4344 case SHF_EXCLUDE: *p = 'E'; break;
4347 if ((elf_header.e_machine == EM_X86_64
4348 || elf_header.e_machine == EM_L1OM)
4349 && flag == SHF_X86_64_LARGE)
4351 else if (flag & SHF_MASKOS)
4354 sh_flags &= ~ SHF_MASKOS;
4356 else if (flag & SHF_MASKPROC)
4359 sh_flags &= ~ SHF_MASKPROC;
4369 if (do_section_details)
4373 size -= 5 + field_size;
4374 if (p != buff + field_size + 4)
4382 sprintf (p, "OS (%*.*lx)", field_size, field_size,
4383 (unsigned long) os_flags);
4384 p += 5 + field_size;
4388 size -= 7 + field_size;
4389 if (p != buff + field_size + 4)
4397 sprintf (p, "PROC (%*.*lx)", field_size, field_size,
4398 (unsigned long) proc_flags);
4399 p += 7 + field_size;
4403 size -= 10 + field_size;
4404 if (p != buff + field_size + 4)
4412 sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
4413 (unsigned long) unknown_flags);
4414 p += 10 + field_size;
4423 process_section_headers (FILE * file)
4425 Elf_Internal_Shdr * section;
4428 section_headers = NULL;
4430 if (elf_header.e_shnum == 0)
4432 /* PR binutils/12467. */
4433 if (elf_header.e_shoff != 0)
4434 warn (_("possibly corrupt ELF file header - it has a non-zero"
4435 " section header offset, but no section headers\n"));
4436 else if (do_sections)
4437 printf (_("\nThere are no sections in this file.\n"));
4442 if (do_sections && !do_header)
4443 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
4444 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
4448 if (! get_32bit_section_headers (file, elf_header.e_shnum))
4451 else if (! get_64bit_section_headers (file, elf_header.e_shnum))
4454 /* Read in the string table, so that we have names to display. */
4455 if (elf_header.e_shstrndx != SHN_UNDEF
4456 && elf_header.e_shstrndx < elf_header.e_shnum)
4458 section = section_headers + elf_header.e_shstrndx;
4460 if (section->sh_size != 0)
4462 string_table = (char *) get_data (NULL, file, section->sh_offset,
4463 1, section->sh_size,
4466 string_table_length = string_table != NULL ? section->sh_size : 0;
4470 /* Scan the sections for the dynamic symbol table
4471 and dynamic string table and debug sections. */
4472 dynamic_symbols = NULL;
4473 dynamic_strings = NULL;
4474 dynamic_syminfo = NULL;
4475 symtab_shndx_hdr = NULL;
4477 eh_addr_size = is_32bit_elf ? 4 : 8;
4478 switch (elf_header.e_machine)
4481 case EM_MIPS_RS3_LE:
4482 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
4483 FDE addresses. However, the ABI also has a semi-official ILP32
4484 variant for which the normal FDE address size rules apply.
4486 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
4487 section, where XX is the size of longs in bits. Unfortunately,
4488 earlier compilers provided no way of distinguishing ILP32 objects
4489 from LP64 objects, so if there's any doubt, we should assume that
4490 the official LP64 form is being used. */
4491 if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
4492 && find_section (".gcc_compiled_long32") == NULL)
4498 switch (elf_header.e_flags & EF_H8_MACH)
4500 case E_H8_MACH_H8300:
4501 case E_H8_MACH_H8300HN:
4502 case E_H8_MACH_H8300SN:
4503 case E_H8_MACH_H8300SXN:
4506 case E_H8_MACH_H8300H:
4507 case E_H8_MACH_H8300S:
4508 case E_H8_MACH_H8300SX:
4516 switch (elf_header.e_flags & EF_M32C_CPU_MASK)
4518 case EF_M32C_CPU_M16C:
4525 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
4528 size_t expected_entsize \
4529 = is_32bit_elf ? size32 : size64; \
4530 if (section->sh_entsize != expected_entsize) \
4531 error (_("Section %d has invalid sh_entsize %lx (expected %lx)\n"), \
4532 i, (unsigned long int) section->sh_entsize, \
4533 (unsigned long int) expected_entsize); \
4534 section->sh_entsize = expected_entsize; \
4537 #define CHECK_ENTSIZE(section, i, type) \
4538 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
4539 sizeof (Elf64_External_##type))
4541 for (i = 0, section = section_headers;
4542 i < elf_header.e_shnum;
4545 char * name = SECTION_NAME (section);
4547 if (section->sh_type == SHT_DYNSYM)
4549 if (dynamic_symbols != NULL)
4551 error (_("File contains multiple dynamic symbol tables\n"));
4555 CHECK_ENTSIZE (section, i, Sym);
4556 num_dynamic_syms = section->sh_size / section->sh_entsize;
4557 dynamic_symbols = GET_ELF_SYMBOLS (file, section);
4559 else if (section->sh_type == SHT_STRTAB
4560 && streq (name, ".dynstr"))
4562 if (dynamic_strings != NULL)
4564 error (_("File contains multiple dynamic string tables\n"));
4568 dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
4569 1, section->sh_size,
4570 _("dynamic strings"));
4571 dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
4573 else if (section->sh_type == SHT_SYMTAB_SHNDX)
4575 if (symtab_shndx_hdr != NULL)
4577 error (_("File contains multiple symtab shndx tables\n"));
4580 symtab_shndx_hdr = section;
4582 else if (section->sh_type == SHT_SYMTAB)
4583 CHECK_ENTSIZE (section, i, Sym);
4584 else if (section->sh_type == SHT_GROUP)
4585 CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
4586 else if (section->sh_type == SHT_REL)
4587 CHECK_ENTSIZE (section, i, Rel);
4588 else if (section->sh_type == SHT_RELA)
4589 CHECK_ENTSIZE (section, i, Rela);
4590 else if ((do_debugging || do_debug_info || do_debug_abbrevs
4591 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
4592 || do_debug_aranges || do_debug_frames || do_debug_macinfo
4593 || do_debug_str || do_debug_loc || do_debug_ranges)
4594 && (const_strneq (name, ".debug_")
4595 || const_strneq (name, ".zdebug_")))
4598 name += sizeof (".zdebug_") - 1;
4600 name += sizeof (".debug_") - 1;
4603 || (do_debug_info && streq (name, "info"))
4604 || (do_debug_info && streq (name, "types"))
4605 || (do_debug_abbrevs && streq (name, "abbrev"))
4606 || (do_debug_lines && streq (name, "line"))
4607 || (do_debug_pubnames && streq (name, "pubnames"))
4608 || (do_debug_pubtypes && streq (name, "pubtypes"))
4609 || (do_debug_aranges && streq (name, "aranges"))
4610 || (do_debug_ranges && streq (name, "ranges"))
4611 || (do_debug_frames && streq (name, "frame"))
4612 || (do_debug_macinfo && streq (name, "macinfo"))
4613 || (do_debug_str && streq (name, "str"))
4614 || (do_debug_loc && streq (name, "loc"))
4616 request_dump_bynumber (i, DEBUG_DUMP);
4618 /* Linkonce section to be combined with .debug_info at link time. */
4619 else if ((do_debugging || do_debug_info)
4620 && const_strneq (name, ".gnu.linkonce.wi."))
4621 request_dump_bynumber (i, DEBUG_DUMP);
4622 else if (do_debug_frames && streq (name, ".eh_frame"))
4623 request_dump_bynumber (i, DEBUG_DUMP);
4624 else if (do_gdb_index && streq (name, ".gdb_index"))
4625 request_dump_bynumber (i, DEBUG_DUMP);
4626 /* Trace sections for Itanium VMS. */
4627 else if ((do_debugging || do_trace_info || do_trace_abbrevs
4628 || do_trace_aranges)
4629 && const_strneq (name, ".trace_"))
4631 name += sizeof (".trace_") - 1;
4634 || (do_trace_info && streq (name, "info"))
4635 || (do_trace_abbrevs && streq (name, "abbrev"))
4636 || (do_trace_aranges && streq (name, "aranges"))
4638 request_dump_bynumber (i, DEBUG_DUMP);
4646 if (elf_header.e_shnum > 1)
4647 printf (_("\nSection Headers:\n"));
4649 printf (_("\nSection Header:\n"));
4653 if (do_section_details)
4655 printf (_(" [Nr] Name\n"));
4656 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
4660 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
4664 if (do_section_details)
4666 printf (_(" [Nr] Name\n"));
4667 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
4671 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
4675 if (do_section_details)
4677 printf (_(" [Nr] Name\n"));
4678 printf (_(" Type Address Offset Link\n"));
4679 printf (_(" Size EntSize Info Align\n"));
4683 printf (_(" [Nr] Name Type Address Offset\n"));
4684 printf (_(" Size EntSize Flags Link Info Align\n"));
4688 if (do_section_details)
4689 printf (_(" Flags\n"));
4691 for (i = 0, section = section_headers;
4692 i < elf_header.e_shnum;
4695 if (do_section_details)
4697 printf (" [%2u] %s\n",
4699 SECTION_NAME (section));
4700 if (is_32bit_elf || do_wide)
4701 printf (" %-15.15s ",
4702 get_section_type_name (section->sh_type));
4705 printf ((do_wide ? " [%2u] %-17s %-15s "
4706 : " [%2u] %-17.17s %-15.15s "),
4708 SECTION_NAME (section),
4709 get_section_type_name (section->sh_type));
4713 const char * link_too_big = NULL;
4715 print_vma (section->sh_addr, LONG_HEX);
4717 printf ( " %6.6lx %6.6lx %2.2lx",
4718 (unsigned long) section->sh_offset,
4719 (unsigned long) section->sh_size,
4720 (unsigned long) section->sh_entsize);
4722 if (do_section_details)
4723 fputs (" ", stdout);
4725 printf (" %3s ", get_elf_section_flags (section->sh_flags));
4727 if (section->sh_link >= elf_header.e_shnum)
4730 /* The sh_link value is out of range. Normally this indicates
4731 an error but it can have special values in Solaris binaries. */
4732 switch (elf_header.e_machine)
4738 case EM_OLD_SPARCV9:
4739 case EM_SPARC32PLUS:
4742 if (section->sh_link == (SHN_BEFORE & 0xffff))
4743 link_too_big = "BEFORE";
4744 else if (section->sh_link == (SHN_AFTER & 0xffff))
4745 link_too_big = "AFTER";
4752 if (do_section_details)
4754 if (link_too_big != NULL && * link_too_big)
4755 printf ("<%s> ", link_too_big);
4757 printf ("%2u ", section->sh_link);
4758 printf ("%3u %2lu\n", section->sh_info,
4759 (unsigned long) section->sh_addralign);
4762 printf ("%2u %3u %2lu\n",
4765 (unsigned long) section->sh_addralign);
4767 if (link_too_big && ! * link_too_big)
4768 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
4769 i, section->sh_link);
4773 print_vma (section->sh_addr, LONG_HEX);
4775 if ((long) section->sh_offset == section->sh_offset)
4776 printf (" %6.6lx", (unsigned long) section->sh_offset);
4780 print_vma (section->sh_offset, LONG_HEX);
4783 if ((unsigned long) section->sh_size == section->sh_size)
4784 printf (" %6.6lx", (unsigned long) section->sh_size);
4788 print_vma (section->sh_size, LONG_HEX);
4791 if ((unsigned long) section->sh_entsize == section->sh_entsize)
4792 printf (" %2.2lx", (unsigned long) section->sh_entsize);
4796 print_vma (section->sh_entsize, LONG_HEX);
4799 if (do_section_details)
4800 fputs (" ", stdout);
4802 printf (" %3s ", get_elf_section_flags (section->sh_flags));
4804 printf ("%2u %3u ", section->sh_link, section->sh_info);
4806 if ((unsigned long) section->sh_addralign == section->sh_addralign)
4807 printf ("%2lu\n", (unsigned long) section->sh_addralign);
4810 print_vma (section->sh_addralign, DEC);
4814 else if (do_section_details)
4816 printf (" %-15.15s ",
4817 get_section_type_name (section->sh_type));
4818 print_vma (section->sh_addr, LONG_HEX);
4819 if ((long) section->sh_offset == section->sh_offset)
4820 printf (" %16.16lx", (unsigned long) section->sh_offset);
4824 print_vma (section->sh_offset, LONG_HEX);
4826 printf (" %u\n ", section->sh_link);
4827 print_vma (section->sh_size, LONG_HEX);
4829 print_vma (section->sh_entsize, LONG_HEX);
4831 printf (" %-16u %lu\n",
4833 (unsigned long) section->sh_addralign);
4838 print_vma (section->sh_addr, LONG_HEX);
4839 if ((long) section->sh_offset == section->sh_offset)
4840 printf (" %8.8lx", (unsigned long) section->sh_offset);
4844 print_vma (section->sh_offset, LONG_HEX);
4847 print_vma (section->sh_size, LONG_HEX);
4849 print_vma (section->sh_entsize, LONG_HEX);
4851 printf (" %3s ", get_elf_section_flags (section->sh_flags));
4853 printf (" %2u %3u %lu\n",
4856 (unsigned long) section->sh_addralign);
4859 if (do_section_details)
4860 printf (" %s\n", get_elf_section_flags (section->sh_flags));
4863 if (!do_section_details)
4865 if (elf_header.e_machine == EM_X86_64
4866 || elf_header.e_machine == EM_L1OM)
4867 printf (_("Key to Flags:\n\
4868 W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
4869 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
4870 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
4872 printf (_("Key to Flags:\n\
4873 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
4874 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
4875 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
4882 get_group_flags (unsigned int flags)
4884 static char buff[32];
4894 snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x] "), flags);
4901 process_section_groups (FILE * file)
4903 Elf_Internal_Shdr * section;
4905 struct group * group;
4906 Elf_Internal_Shdr * symtab_sec;
4907 Elf_Internal_Shdr * strtab_sec;
4908 Elf_Internal_Sym * symtab;
4912 /* Don't process section groups unless needed. */
4913 if (!do_unwind && !do_section_groups)
4916 if (elf_header.e_shnum == 0)
4918 if (do_section_groups)
4919 printf (_("\nThere are no sections to group in this file.\n"));
4924 if (section_headers == NULL)
4926 error (_("Section headers are not available!\n"));
4930 section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
4931 sizeof (struct group *));
4933 if (section_headers_groups == NULL)
4935 error (_("Out of memory\n"));
4939 /* Scan the sections for the group section. */
4941 for (i = 0, section = section_headers;
4942 i < elf_header.e_shnum;
4944 if (section->sh_type == SHT_GROUP)
4947 if (group_count == 0)
4949 if (do_section_groups)
4950 printf (_("\nThere are no section groups in this file.\n"));
4955 section_groups = (struct group *) calloc (group_count, sizeof (struct group));
4957 if (section_groups == NULL)
4959 error (_("Out of memory\n"));
4968 for (i = 0, section = section_headers, group = section_groups;
4969 i < elf_header.e_shnum;
4972 if (section->sh_type == SHT_GROUP)
4974 char * name = SECTION_NAME (section);
4976 unsigned char * start;
4977 unsigned char * indices;
4978 unsigned int entry, j, size;
4979 Elf_Internal_Shdr * sec;
4980 Elf_Internal_Sym * sym;
4982 /* Get the symbol table. */
4983 if (section->sh_link >= elf_header.e_shnum
4984 || ((sec = section_headers + section->sh_link)->sh_type
4987 error (_("Bad sh_link in group section `%s'\n"), name);
4991 if (symtab_sec != sec)
4996 symtab = GET_ELF_SYMBOLS (file, symtab_sec);
5001 error (_("Corrupt header in group section `%s'\n"), name);
5005 sym = symtab + section->sh_info;
5007 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
5009 if (sym->st_shndx == 0
5010 || sym->st_shndx >= elf_header.e_shnum)
5012 error (_("Bad sh_info in group section `%s'\n"), name);
5016 group_name = SECTION_NAME (section_headers + sym->st_shndx);
5025 /* Get the string table. */
5026 if (symtab_sec->sh_link >= elf_header.e_shnum)
5035 != (sec = section_headers + symtab_sec->sh_link))
5040 strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
5041 1, strtab_sec->sh_size,
5043 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
5045 group_name = sym->st_name < strtab_size
5046 ? strtab + sym->st_name : _("<corrupt>");
5049 start = (unsigned char *) get_data (NULL, file, section->sh_offset,
5050 1, section->sh_size,
5056 size = (section->sh_size / section->sh_entsize) - 1;
5057 entry = byte_get (indices, 4);
5060 if (do_section_groups)
5062 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
5063 get_group_flags (entry), i, name, group_name, size);
5065 printf (_(" [Index] Name\n"));
5068 group->group_index = i;
5070 for (j = 0; j < size; j++)
5072 struct group_list * g;
5074 entry = byte_get (indices, 4);
5077 if (entry >= elf_header.e_shnum)
5079 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
5080 entry, i, elf_header.e_shnum - 1);
5084 if (section_headers_groups [entry] != NULL)
5088 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
5090 section_headers_groups [entry]->group_index);
5095 /* Intel C/C++ compiler may put section 0 in a
5096 section group. We just warn it the first time
5097 and ignore it afterwards. */
5098 static int warned = 0;
5101 error (_("section 0 in group section [%5u]\n"),
5102 section_headers_groups [entry]->group_index);
5108 section_headers_groups [entry] = group;
5110 if (do_section_groups)
5112 sec = section_headers + entry;
5113 printf (" [%5u] %s\n", entry, SECTION_NAME (sec));
5116 g = (struct group_list *) xmalloc (sizeof (struct group_list));
5117 g->section_index = entry;
5118 g->next = group->root;
5136 /* Data used to display dynamic fixups. */
5138 struct ia64_vms_dynfixup
5140 bfd_vma needed_ident; /* Library ident number. */
5141 bfd_vma needed; /* Index in the dstrtab of the library name. */
5142 bfd_vma fixup_needed; /* Index of the library. */
5143 bfd_vma fixup_rela_cnt; /* Number of fixups. */
5144 bfd_vma fixup_rela_off; /* Fixups offset in the dynamic segment. */
5147 /* Data used to display dynamic relocations. */
5149 struct ia64_vms_dynimgrela
5151 bfd_vma img_rela_cnt; /* Number of relocations. */
5152 bfd_vma img_rela_off; /* Reloc offset in the dynamic segment. */
5155 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
5159 dump_ia64_vms_dynamic_fixups (FILE *file, struct ia64_vms_dynfixup *fixup,
5160 const char *strtab, unsigned int strtab_sz)
5162 Elf64_External_VMS_IMAGE_FIXUP *imfs;
5164 const char *lib_name;
5166 imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
5167 1, fixup->fixup_rela_cnt * sizeof (*imfs),
5168 _("dynamic section image fixups"));
5172 if (fixup->needed < strtab_sz)
5173 lib_name = strtab + fixup->needed;
5176 warn ("corrupt library name index of 0x%lx found in dynamic entry",
5177 (unsigned long) fixup->needed);
5180 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
5181 (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
5183 (_("Seg Offset Type SymVec DataType\n"));
5185 for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
5190 printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
5191 printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
5192 type = BYTE_GET (imfs [i].type);
5193 rtype = elf_ia64_reloc_type (type);
5195 printf (" 0x%08x ", type);
5197 printf (" %-32s ", rtype);
5198 printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
5199 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
5205 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
5208 dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
5210 Elf64_External_VMS_IMAGE_RELA *imrs;
5213 imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
5214 1, imgrela->img_rela_cnt * sizeof (*imrs),
5215 _("dynamic section image relas"));
5219 printf (_("\nImage relocs\n"));
5221 (_("Seg Offset Type Addend Seg Sym Off\n"));
5223 for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
5228 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
5229 printf ("%08" BFD_VMA_FMT "x ",
5230 (bfd_vma) BYTE_GET (imrs [i].rela_offset));
5231 type = BYTE_GET (imrs [i].type);
5232 rtype = elf_ia64_reloc_type (type);
5234 printf ("0x%08x ", type);
5236 printf ("%-31s ", rtype);
5237 print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
5238 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
5239 printf ("%08" BFD_VMA_FMT "x\n",
5240 (bfd_vma) BYTE_GET (imrs [i].sym_offset));
5246 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
5249 process_ia64_vms_dynamic_relocs (FILE *file)
5251 struct ia64_vms_dynfixup fixup;
5252 struct ia64_vms_dynimgrela imgrela;
5253 Elf_Internal_Dyn *entry;
5255 bfd_vma strtab_off = 0;
5256 bfd_vma strtab_sz = 0;
5257 char *strtab = NULL;
5259 memset (&fixup, 0, sizeof (fixup));
5260 memset (&imgrela, 0, sizeof (imgrela));
5262 /* Note: the order of the entries is specified by the OpenVMS specs. */
5263 for (entry = dynamic_section;
5264 entry < dynamic_section + dynamic_nent;
5267 switch (entry->d_tag)
5269 case DT_IA_64_VMS_STRTAB_OFFSET:
5270 strtab_off = entry->d_un.d_val;
5273 strtab_sz = entry->d_un.d_val;
5275 strtab = get_data (NULL, file, dynamic_addr + strtab_off,
5276 1, strtab_sz, _("dynamic string section"));
5279 case DT_IA_64_VMS_NEEDED_IDENT:
5280 fixup.needed_ident = entry->d_un.d_val;
5283 fixup.needed = entry->d_un.d_val;
5285 case DT_IA_64_VMS_FIXUP_NEEDED:
5286 fixup.fixup_needed = entry->d_un.d_val;
5288 case DT_IA_64_VMS_FIXUP_RELA_CNT:
5289 fixup.fixup_rela_cnt = entry->d_un.d_val;
5291 case DT_IA_64_VMS_FIXUP_RELA_OFF:
5292 fixup.fixup_rela_off = entry->d_un.d_val;
5294 dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz);
5297 case DT_IA_64_VMS_IMG_RELA_CNT:
5298 imgrela.img_rela_cnt = entry->d_un.d_val;
5300 case DT_IA_64_VMS_IMG_RELA_OFF:
5301 imgrela.img_rela_off = entry->d_un.d_val;
5303 dump_ia64_vms_dynamic_relocs (file, &imgrela);
5323 } dynamic_relocations [] =
5325 { "REL", DT_REL, DT_RELSZ, FALSE },
5326 { "RELA", DT_RELA, DT_RELASZ, TRUE },
5327 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
5330 /* Process the reloc section. */
5333 process_relocs (FILE * file)
5335 unsigned long rel_size;
5336 unsigned long rel_offset;
5342 if (do_using_dynamic)
5346 int has_dynamic_reloc;
5349 has_dynamic_reloc = 0;
5351 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
5353 is_rela = dynamic_relocations [i].rela;
5354 name = dynamic_relocations [i].name;
5355 rel_size = dynamic_info [dynamic_relocations [i].size];
5356 rel_offset = dynamic_info [dynamic_relocations [i].reloc];
5358 has_dynamic_reloc |= rel_size;
5360 if (is_rela == UNKNOWN)
5362 if (dynamic_relocations [i].reloc == DT_JMPREL)
5363 switch (dynamic_info[DT_PLTREL])
5377 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
5378 name, rel_offset, rel_size);
5380 dump_relocations (file,
5381 offset_from_vma (file, rel_offset, rel_size),
5383 dynamic_symbols, num_dynamic_syms,
5384 dynamic_strings, dynamic_strings_length, is_rela);
5389 has_dynamic_reloc |= process_ia64_vms_dynamic_relocs (file);
5391 if (! has_dynamic_reloc)
5392 printf (_("\nThere are no dynamic relocations in this file.\n"));
5396 Elf_Internal_Shdr * section;
5400 for (i = 0, section = section_headers;
5401 i < elf_header.e_shnum;
5404 if ( section->sh_type != SHT_RELA
5405 && section->sh_type != SHT_REL)
5408 rel_offset = section->sh_offset;
5409 rel_size = section->sh_size;
5413 Elf_Internal_Shdr * strsec;
5416 printf (_("\nRelocation section "));
5418 if (string_table == NULL)
5419 printf ("%d", section->sh_name);
5421 printf (_("'%s'"), SECTION_NAME (section));
5423 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5424 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
5426 is_rela = section->sh_type == SHT_RELA;
5428 if (section->sh_link != 0
5429 && section->sh_link < elf_header.e_shnum)
5431 Elf_Internal_Shdr * symsec;
5432 Elf_Internal_Sym * symtab;
5433 unsigned long nsyms;
5434 unsigned long strtablen = 0;
5435 char * strtab = NULL;
5437 symsec = section_headers + section->sh_link;
5438 if (symsec->sh_type != SHT_SYMTAB
5439 && symsec->sh_type != SHT_DYNSYM)
5442 nsyms = symsec->sh_size / symsec->sh_entsize;
5443 symtab = GET_ELF_SYMBOLS (file, symsec);
5448 if (symsec->sh_link != 0
5449 && symsec->sh_link < elf_header.e_shnum)
5451 strsec = section_headers + symsec->sh_link;
5453 strtab = (char *) get_data (NULL, file, strsec->sh_offset,
5456 strtablen = strtab == NULL ? 0 : strsec->sh_size;
5459 dump_relocations (file, rel_offset, rel_size,
5460 symtab, nsyms, strtab, strtablen, is_rela);
5466 dump_relocations (file, rel_offset, rel_size,
5467 NULL, 0, NULL, 0, is_rela);
5474 printf (_("\nThere are no relocations in this file.\n"));
5480 /* Process the unwind section. */
5482 #include "unwind-ia64.h"
5484 /* An absolute address consists of a section and an offset. If the
5485 section is NULL, the offset itself is the address, otherwise, the
5486 address equals to LOAD_ADDRESS(section) + offset. */
5490 unsigned short section;
5494 #define ABSADDR(a) \
5496 ? section_headers [(a).section].sh_addr + (a).offset \
5499 struct ia64_unw_table_entry
5501 struct absaddr start;
5503 struct absaddr info;
5506 struct ia64_unw_aux_info
5509 struct ia64_unw_table_entry *table; /* Unwind table. */
5510 unsigned long table_len; /* Length of unwind table. */
5511 unsigned char * info; /* Unwind info. */
5512 unsigned long info_size; /* Size of unwind info. */
5513 bfd_vma info_addr; /* starting address of unwind info. */
5514 bfd_vma seg_base; /* Starting address of segment. */
5515 Elf_Internal_Sym * symtab; /* The symbol table. */
5516 unsigned long nsyms; /* Number of symbols. */
5517 char * strtab; /* The string table. */
5518 unsigned long strtab_size; /* Size of string table. */
5522 find_symbol_for_address (Elf_Internal_Sym * symtab,
5523 unsigned long nsyms,
5524 const char * strtab,
5525 unsigned long strtab_size,
5526 struct absaddr addr,
5527 const char ** symname,
5530 bfd_vma dist = 0x100000;
5531 Elf_Internal_Sym * sym;
5532 Elf_Internal_Sym * best = NULL;
5535 REMOVE_ARCH_BITS (addr.offset);
5537 for (i = 0, sym = symtab; i < nsyms; ++i, ++sym)
5539 bfd_vma value = sym->st_value;
5541 REMOVE_ARCH_BITS (value);
5543 if (ELF_ST_TYPE (sym->st_info) == STT_FUNC
5544 && sym->st_name != 0
5545 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
5546 && addr.offset >= value
5547 && addr.offset - value < dist)
5550 dist = addr.offset - value;
5557 *symname = (best->st_name >= strtab_size
5558 ? _("<corrupt>") : strtab + best->st_name);
5563 *offset = addr.offset;
5567 dump_ia64_unwind (struct ia64_unw_aux_info * aux)
5569 struct ia64_unw_table_entry * tp;
5572 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
5576 const unsigned char * dp;
5577 const unsigned char * head;
5578 const char * procname;
5580 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
5581 aux->strtab_size, tp->start, &procname, &offset);
5583 fputs ("\n<", stdout);
5587 fputs (procname, stdout);
5590 printf ("+%lx", (unsigned long) offset);
5593 fputs (">: [", stdout);
5594 print_vma (tp->start.offset, PREFIX_HEX);
5595 fputc ('-', stdout);
5596 print_vma (tp->end.offset, PREFIX_HEX);
5597 printf ("], info at +0x%lx\n",
5598 (unsigned long) (tp->info.offset - aux->seg_base));
5600 head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
5601 stamp = byte_get ((unsigned char *) head, sizeof (stamp));
5603 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
5604 (unsigned) UNW_VER (stamp),
5605 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
5606 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
5607 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
5608 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
5610 if (UNW_VER (stamp) != 1)
5612 printf (_("\tUnknown version.\n"));
5617 for (dp = head + 8; dp < head + 8 + eh_addr_size * UNW_LENGTH (stamp);)
5618 dp = unw_decode (dp, in_body, & in_body);
5623 slurp_ia64_unwind_table (FILE * file,
5624 struct ia64_unw_aux_info * aux,
5625 Elf_Internal_Shdr * sec)
5627 unsigned long size, nrelas, i;
5628 Elf_Internal_Phdr * seg;
5629 struct ia64_unw_table_entry * tep;
5630 Elf_Internal_Shdr * relsec;
5631 Elf_Internal_Rela * rela;
5632 Elf_Internal_Rela * rp;
5633 unsigned char * table;
5635 Elf_Internal_Sym * sym;
5636 const char * relname;
5638 /* First, find the starting address of the segment that includes
5641 if (elf_header.e_phnum)
5643 if (! get_program_headers (file))
5646 for (seg = program_headers;
5647 seg < program_headers + elf_header.e_phnum;
5650 if (seg->p_type != PT_LOAD)
5653 if (sec->sh_addr >= seg->p_vaddr
5654 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
5656 aux->seg_base = seg->p_vaddr;
5662 /* Second, build the unwind table from the contents of the unwind section: */
5663 size = sec->sh_size;
5664 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
5669 aux->table = (struct ia64_unw_table_entry *)
5670 xcmalloc (size / (3 * eh_addr_size), sizeof (aux->table[0]));
5672 for (tp = table; tp < table + size; ++tep)
5674 tep->start.section = SHN_UNDEF;
5675 tep->end.section = SHN_UNDEF;
5676 tep->info.section = SHN_UNDEF;
5677 tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
5678 tep->end.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
5679 tep->info.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
5680 tep->start.offset += aux->seg_base;
5681 tep->end.offset += aux->seg_base;
5682 tep->info.offset += aux->seg_base;
5686 /* Third, apply any relocations to the unwind table: */
5687 for (relsec = section_headers;
5688 relsec < section_headers + elf_header.e_shnum;
5691 if (relsec->sh_type != SHT_RELA
5692 || relsec->sh_info >= elf_header.e_shnum
5693 || section_headers + relsec->sh_info != sec)
5696 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
5700 for (rp = rela; rp < rela + nrelas; ++rp)
5702 relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
5703 sym = aux->symtab + get_reloc_symindex (rp->r_info);
5705 if (! const_strneq (relname, "R_IA64_SEGREL"))
5707 warn (_("Skipping unexpected relocation type %s\n"), relname);
5711 i = rp->r_offset / (3 * eh_addr_size);
5713 switch (rp->r_offset/eh_addr_size % 3)
5716 aux->table[i].start.section = sym->st_shndx;
5717 aux->table[i].start.offset = rp->r_addend + sym->st_value;
5720 aux->table[i].end.section = sym->st_shndx;
5721 aux->table[i].end.offset = rp->r_addend + sym->st_value;
5724 aux->table[i].info.section = sym->st_shndx;
5725 aux->table[i].info.offset = rp->r_addend + sym->st_value;
5735 aux->table_len = size / (3 * eh_addr_size);
5740 ia64_process_unwind (FILE * file)
5742 Elf_Internal_Shdr * sec;
5743 Elf_Internal_Shdr * unwsec = NULL;
5744 Elf_Internal_Shdr * strsec;
5745 unsigned long i, unwcount = 0, unwstart = 0;
5746 struct ia64_unw_aux_info aux;
5748 memset (& aux, 0, sizeof (aux));
5750 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
5752 if (sec->sh_type == SHT_SYMTAB
5753 && sec->sh_link < elf_header.e_shnum)
5755 aux.nsyms = sec->sh_size / sec->sh_entsize;
5756 aux.symtab = GET_ELF_SYMBOLS (file, sec);
5758 strsec = section_headers + sec->sh_link;
5759 assert (aux.strtab == NULL);
5760 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
5763 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
5765 else if (sec->sh_type == SHT_IA_64_UNWIND)
5770 printf (_("\nThere are no unwind sections in this file.\n"));
5772 while (unwcount-- > 0)
5777 for (i = unwstart, sec = section_headers + unwstart;
5778 i < elf_header.e_shnum; ++i, ++sec)
5779 if (sec->sh_type == SHT_IA_64_UNWIND)
5786 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
5788 if ((unwsec->sh_flags & SHF_GROUP) != 0)
5790 /* We need to find which section group it is in. */
5791 struct group_list * g = section_headers_groups [i]->root;
5793 for (; g != NULL; g = g->next)
5795 sec = section_headers + g->section_index;
5797 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
5802 i = elf_header.e_shnum;
5804 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
5806 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
5807 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
5808 suffix = SECTION_NAME (unwsec) + len;
5809 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
5811 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
5812 && streq (SECTION_NAME (sec) + len2, suffix))
5817 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
5818 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
5819 len = sizeof (ELF_STRING_ia64_unwind) - 1;
5820 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
5822 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
5823 suffix = SECTION_NAME (unwsec) + len;
5824 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
5826 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
5827 && streq (SECTION_NAME (sec) + len2, suffix))
5831 if (i == elf_header.e_shnum)
5833 printf (_("\nCould not find unwind info section for "));
5835 if (string_table == NULL)
5836 printf ("%d", unwsec->sh_name);
5838 printf (_("'%s'"), SECTION_NAME (unwsec));
5842 aux.info_addr = sec->sh_addr;
5843 aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
5846 aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
5848 printf (_("\nUnwind section "));
5850 if (string_table == NULL)
5851 printf ("%d", unwsec->sh_name);
5853 printf (_("'%s'"), SECTION_NAME (unwsec));
5855 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5856 (unsigned long) unwsec->sh_offset,
5857 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
5859 (void) slurp_ia64_unwind_table (file, & aux, unwsec);
5861 if (aux.table_len > 0)
5862 dump_ia64_unwind (& aux);
5865 free ((char *) aux.table);
5867 free ((char *) aux.info);
5876 free ((char *) aux.strtab);
5881 struct hppa_unw_table_entry
5883 struct absaddr start;
5885 unsigned int Cannot_unwind:1; /* 0 */
5886 unsigned int Millicode:1; /* 1 */
5887 unsigned int Millicode_save_sr0:1; /* 2 */
5888 unsigned int Region_description:2; /* 3..4 */
5889 unsigned int reserved1:1; /* 5 */
5890 unsigned int Entry_SR:1; /* 6 */
5891 unsigned int Entry_FR:4; /* number saved */ /* 7..10 */
5892 unsigned int Entry_GR:5; /* number saved */ /* 11..15 */
5893 unsigned int Args_stored:1; /* 16 */
5894 unsigned int Variable_Frame:1; /* 17 */
5895 unsigned int Separate_Package_Body:1; /* 18 */
5896 unsigned int Frame_Extension_Millicode:1; /* 19 */
5897 unsigned int Stack_Overflow_Check:1; /* 20 */
5898 unsigned int Two_Instruction_SP_Increment:1; /* 21 */
5899 unsigned int Ada_Region:1; /* 22 */
5900 unsigned int cxx_info:1; /* 23 */
5901 unsigned int cxx_try_catch:1; /* 24 */
5902 unsigned int sched_entry_seq:1; /* 25 */
5903 unsigned int reserved2:1; /* 26 */
5904 unsigned int Save_SP:1; /* 27 */
5905 unsigned int Save_RP:1; /* 28 */
5906 unsigned int Save_MRP_in_frame:1; /* 29 */
5907 unsigned int extn_ptr_defined:1; /* 30 */
5908 unsigned int Cleanup_defined:1; /* 31 */
5910 unsigned int MPE_XL_interrupt_marker:1; /* 0 */
5911 unsigned int HP_UX_interrupt_marker:1; /* 1 */
5912 unsigned int Large_frame:1; /* 2 */
5913 unsigned int Pseudo_SP_Set:1; /* 3 */
5914 unsigned int reserved4:1; /* 4 */
5915 unsigned int Total_frame_size:27; /* 5..31 */
5918 struct hppa_unw_aux_info
5920 struct hppa_unw_table_entry *table; /* Unwind table. */
5921 unsigned long table_len; /* Length of unwind table. */
5922 bfd_vma seg_base; /* Starting address of segment. */
5923 Elf_Internal_Sym * symtab; /* The symbol table. */
5924 unsigned long nsyms; /* Number of symbols. */
5925 char * strtab; /* The string table. */
5926 unsigned long strtab_size; /* Size of string table. */
5930 dump_hppa_unwind (struct hppa_unw_aux_info * aux)
5932 struct hppa_unw_table_entry * tp;
5934 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
5937 const char * procname;
5939 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
5940 aux->strtab_size, tp->start, &procname,
5943 fputs ("\n<", stdout);
5947 fputs (procname, stdout);
5950 printf ("+%lx", (unsigned long) offset);
5953 fputs (">: [", stdout);
5954 print_vma (tp->start.offset, PREFIX_HEX);
5955 fputc ('-', stdout);
5956 print_vma (tp->end.offset, PREFIX_HEX);
5959 #define PF(_m) if (tp->_m) printf (#_m " ");
5960 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
5963 PF(Millicode_save_sr0);
5964 /* PV(Region_description); */
5970 PF(Separate_Package_Body);
5971 PF(Frame_Extension_Millicode);
5972 PF(Stack_Overflow_Check);
5973 PF(Two_Instruction_SP_Increment);
5977 PF(sched_entry_seq);
5980 PF(Save_MRP_in_frame);
5981 PF(extn_ptr_defined);
5982 PF(Cleanup_defined);
5983 PF(MPE_XL_interrupt_marker);
5984 PF(HP_UX_interrupt_marker);
5987 PV(Total_frame_size);
5996 slurp_hppa_unwind_table (FILE * file,
5997 struct hppa_unw_aux_info * aux,
5998 Elf_Internal_Shdr * sec)
6000 unsigned long size, unw_ent_size, nentries, nrelas, i;
6001 Elf_Internal_Phdr * seg;
6002 struct hppa_unw_table_entry * tep;
6003 Elf_Internal_Shdr * relsec;
6004 Elf_Internal_Rela * rela;
6005 Elf_Internal_Rela * rp;
6006 unsigned char * table;
6008 Elf_Internal_Sym * sym;
6009 const char * relname;
6011 /* First, find the starting address of the segment that includes
6014 if (elf_header.e_phnum)
6016 if (! get_program_headers (file))
6019 for (seg = program_headers;
6020 seg < program_headers + elf_header.e_phnum;
6023 if (seg->p_type != PT_LOAD)
6026 if (sec->sh_addr >= seg->p_vaddr
6027 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
6029 aux->seg_base = seg->p_vaddr;
6035 /* Second, build the unwind table from the contents of the unwind
6037 size = sec->sh_size;
6038 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
6044 nentries = size / unw_ent_size;
6045 size = unw_ent_size * nentries;
6047 tep = aux->table = (struct hppa_unw_table_entry *)
6048 xcmalloc (nentries, sizeof (aux->table[0]));
6050 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
6052 unsigned int tmp1, tmp2;
6054 tep->start.section = SHN_UNDEF;
6055 tep->end.section = SHN_UNDEF;
6057 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
6058 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
6059 tmp1 = byte_get ((unsigned char *) tp + 8, 4);
6060 tmp2 = byte_get ((unsigned char *) tp + 12, 4);
6062 tep->start.offset += aux->seg_base;
6063 tep->end.offset += aux->seg_base;
6065 tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
6066 tep->Millicode = (tmp1 >> 30) & 0x1;
6067 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
6068 tep->Region_description = (tmp1 >> 27) & 0x3;
6069 tep->reserved1 = (tmp1 >> 26) & 0x1;
6070 tep->Entry_SR = (tmp1 >> 25) & 0x1;
6071 tep->Entry_FR = (tmp1 >> 21) & 0xf;
6072 tep->Entry_GR = (tmp1 >> 16) & 0x1f;
6073 tep->Args_stored = (tmp1 >> 15) & 0x1;
6074 tep->Variable_Frame = (tmp1 >> 14) & 0x1;
6075 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
6076 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
6077 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
6078 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
6079 tep->Ada_Region = (tmp1 >> 9) & 0x1;
6080 tep->cxx_info = (tmp1 >> 8) & 0x1;
6081 tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
6082 tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
6083 tep->reserved2 = (tmp1 >> 5) & 0x1;
6084 tep->Save_SP = (tmp1 >> 4) & 0x1;
6085 tep->Save_RP = (tmp1 >> 3) & 0x1;
6086 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
6087 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
6088 tep->Cleanup_defined = tmp1 & 0x1;
6090 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
6091 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
6092 tep->Large_frame = (tmp2 >> 29) & 0x1;
6093 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
6094 tep->reserved4 = (tmp2 >> 27) & 0x1;
6095 tep->Total_frame_size = tmp2 & 0x7ffffff;
6099 /* Third, apply any relocations to the unwind table. */
6100 for (relsec = section_headers;
6101 relsec < section_headers + elf_header.e_shnum;
6104 if (relsec->sh_type != SHT_RELA
6105 || relsec->sh_info >= elf_header.e_shnum
6106 || section_headers + relsec->sh_info != sec)
6109 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6113 for (rp = rela; rp < rela + nrelas; ++rp)
6115 relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
6116 sym = aux->symtab + get_reloc_symindex (rp->r_info);
6118 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
6119 if (! const_strneq (relname, "R_PARISC_SEGREL"))
6121 warn (_("Skipping unexpected relocation type %s\n"), relname);
6125 i = rp->r_offset / unw_ent_size;
6127 switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
6130 aux->table[i].start.section = sym->st_shndx;
6131 aux->table[i].start.offset = sym->st_value + rp->r_addend;
6134 aux->table[i].end.section = sym->st_shndx;
6135 aux->table[i].end.offset = sym->st_value + rp->r_addend;
6145 aux->table_len = nentries;
6151 hppa_process_unwind (FILE * file)
6153 struct hppa_unw_aux_info aux;
6154 Elf_Internal_Shdr * unwsec = NULL;
6155 Elf_Internal_Shdr * strsec;
6156 Elf_Internal_Shdr * sec;
6159 memset (& aux, 0, sizeof (aux));
6161 if (string_table == NULL)
6164 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6166 if (sec->sh_type == SHT_SYMTAB
6167 && sec->sh_link < elf_header.e_shnum)
6169 aux.nsyms = sec->sh_size / sec->sh_entsize;
6170 aux.symtab = GET_ELF_SYMBOLS (file, sec);
6172 strsec = section_headers + sec->sh_link;
6173 assert (aux.strtab == NULL);
6174 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6177 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
6179 else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
6184 printf (_("\nThere are no unwind sections in this file.\n"));
6186 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6188 if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
6190 printf (_("\nUnwind section "));
6191 printf (_("'%s'"), SECTION_NAME (sec));
6193 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6194 (unsigned long) sec->sh_offset,
6195 (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
6197 slurp_hppa_unwind_table (file, &aux, sec);
6198 if (aux.table_len > 0)
6199 dump_hppa_unwind (&aux);
6202 free ((char *) aux.table);
6210 free ((char *) aux.strtab);
6217 unsigned char *data;
6219 Elf_Internal_Shdr *sec;
6220 Elf_Internal_Rela *rela;
6221 unsigned long nrelas;
6222 unsigned int rel_type;
6224 Elf_Internal_Rela *next_rela;
6227 struct arm_unw_aux_info
6231 Elf_Internal_Sym *symtab; /* The symbol table. */
6232 unsigned long nsyms; /* Number of symbols. */
6233 char *strtab; /* The string table. */
6234 unsigned long strtab_size; /* Size of string table. */
6238 arm_print_vma_and_name (struct arm_unw_aux_info *aux,
6239 bfd_vma fn, struct absaddr addr)
6241 const char *procname;
6244 if (addr.section == SHN_UNDEF)
6247 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6248 aux->strtab_size, addr, &procname,
6251 print_vma (fn, PREFIX_HEX);
6255 fputs (" <", stdout);
6256 fputs (procname, stdout);
6259 printf ("+0x%lx", (unsigned long) sym_offset);
6260 fputc ('>', stdout);
6267 arm_free_section (struct arm_section *arm_sec)
6269 if (arm_sec->data != NULL)
6270 free (arm_sec->data);
6272 if (arm_sec->rela != NULL)
6273 free (arm_sec->rela);
6277 arm_section_get_word (struct arm_unw_aux_info *aux,
6278 struct arm_section *arm_sec,
6279 Elf_Internal_Shdr *sec, bfd_vma word_offset,
6280 unsigned int *wordp, struct absaddr *addr)
6282 Elf_Internal_Rela *rp;
6283 Elf_Internal_Sym *sym;
6284 const char * relname;
6286 bfd_boolean wrapped;
6288 addr->section = SHN_UNDEF;
6291 if (sec != arm_sec->sec)
6293 Elf_Internal_Shdr *relsec;
6295 arm_free_section (arm_sec);
6298 arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
6299 sec->sh_size, _("unwind data"));
6300 arm_sec->rela = NULL;
6301 arm_sec->nrelas = 0;
6303 for (relsec = section_headers;
6304 relsec < section_headers + elf_header.e_shnum;
6307 if (relsec->sh_info >= elf_header.e_shnum
6308 || section_headers + relsec->sh_info != sec)
6311 if (relsec->sh_type == SHT_REL)
6313 if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
6315 & arm_sec->rela, & arm_sec->nrelas))
6319 else if (relsec->sh_type == SHT_RELA)
6321 if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
6323 & arm_sec->rela, & arm_sec->nrelas))
6329 arm_sec->next_rela = arm_sec->rela;
6332 if (arm_sec->data == NULL)
6335 word = byte_get (arm_sec->data + word_offset, 4);
6338 for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
6340 bfd_vma prelval, offset;
6342 if (rp->r_offset > word_offset && !wrapped)
6347 if (rp->r_offset > word_offset)
6350 if (rp->r_offset & 3)
6352 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
6353 (unsigned long) rp->r_offset);
6357 if (rp->r_offset < word_offset)
6360 switch (elf_header.e_machine)
6363 relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
6367 relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
6374 if (streq (relname, "R_ARM_NONE")
6375 || streq (relname, "R_C6000_NONE"))
6378 if (!(streq (relname, "R_ARM_PREL31")
6379 || streq (relname, "R_C6000_PREL31")))
6381 warn (_("Skipping unexpected relocation type %s\n"), relname);
6385 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
6387 if (arm_sec->rel_type == SHT_REL)
6389 offset = word & 0x7fffffff;
6390 if (offset & 0x40000000)
6391 offset |= ~ (bfd_vma) 0x7fffffff;
6394 offset = rp->r_addend;
6396 offset += sym->st_value;
6397 prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
6399 if (streq (relname, "R_C6000_PREL31"))
6402 word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
6403 addr->section = sym->st_shndx;
6404 addr->offset = offset;
6409 arm_sec->next_rela = rp;
6414 static const char *tic6x_unwind_regnames[16] = {
6415 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
6416 "A14", "A13", "A12", "A11", "A10",
6417 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"};
6420 decode_tic6x_unwind_regmask (unsigned int mask)
6424 for (i = 12; mask; mask >>= 1, i--)
6428 fputs (tic6x_unwind_regnames[i], stdout);
6430 fputs (", ", stdout);
6436 if (remaining == 0 && more_words) \
6439 if (!arm_section_get_word (aux, data_arm_sec, data_sec, \
6440 data_offset, &word, &addr)) \
6446 #define GET_OP(OP) \
6451 (OP) = word >> 24; \
6456 printf (_("[Truncated opcode]\n")); \
6459 printf ("0x%02x ", OP)
6462 decode_arm_unwind_bytecode (struct arm_unw_aux_info *aux,
6463 unsigned int word, unsigned int remaining,
6464 unsigned int more_words,
6465 bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
6466 struct arm_section *data_arm_sec)
6468 struct absaddr addr;
6470 /* Decode the unwinding instructions. */
6473 unsigned int op, op2;
6482 printf (" 0x%02x ", op);
6484 if ((op & 0xc0) == 0x00)
6486 int offset = ((op & 0x3f) << 2) + 4;
6488 printf (" vsp = vsp + %d", offset);
6490 else if ((op & 0xc0) == 0x40)
6492 int offset = ((op & 0x3f) << 2) + 4;
6494 printf (" vsp = vsp - %d", offset);
6496 else if ((op & 0xf0) == 0x80)
6499 if (op == 0x80 && op2 == 0)
6500 printf (_("Refuse to unwind"));
6503 unsigned int mask = ((op & 0x0f) << 8) | op2;
6508 for (i = 0; i < 12; i++)
6509 if (mask & (1 << i))
6515 printf ("r%d", 4 + i);
6520 else if ((op & 0xf0) == 0x90)
6522 if (op == 0x9d || op == 0x9f)
6523 printf (_(" [Reserved]"));
6525 printf (" vsp = r%d", op & 0x0f);
6527 else if ((op & 0xf0) == 0xa0)
6529 int end = 4 + (op & 0x07);
6534 for (i = 4; i <= end; i++)
6550 else if (op == 0xb0)
6551 printf (_(" finish"));
6552 else if (op == 0xb1)
6555 if (op2 == 0 || (op2 & 0xf0) != 0)
6556 printf (_("[Spare]"));
6559 unsigned int mask = op2 & 0x0f;
6564 for (i = 0; i < 12; i++)
6565 if (mask & (1 << i))
6576 else if (op == 0xb2)
6578 unsigned char buf[9];
6579 unsigned int i, len;
6580 unsigned long offset;
6582 for (i = 0; i < sizeof (buf); i++)
6585 if ((buf[i] & 0x80) == 0)
6588 assert (i < sizeof (buf));
6589 offset = read_uleb128 (buf, &len);
6590 assert (len == i + 1);
6591 offset = offset * 4 + 0x204;
6592 printf ("vsp = vsp + %ld", offset);
6594 else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
6596 unsigned int first, last;
6603 printf ("pop {D%d", first);
6605 printf ("-D%d", first + last);
6608 else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
6610 unsigned int count = op & 0x07;
6614 printf ("-D%d", 8 + count);
6617 else if (op >= 0xc0 && op <= 0xc5)
6619 unsigned int count = op & 0x07;
6621 printf (" pop {wR10");
6623 printf ("-wR%d", 10 + count);
6626 else if (op == 0xc6)
6628 unsigned int first, last;
6633 printf ("pop {wR%d", first);
6635 printf ("-wR%d", first + last);
6638 else if (op == 0xc7)
6641 if (op2 == 0 || (op2 & 0xf0) != 0)
6642 printf (_("[Spare]"));
6645 unsigned int mask = op2 & 0x0f;
6650 for (i = 0; i < 4; i++)
6651 if (mask & (1 << i))
6657 printf ("wCGR%d", i);
6663 printf (_(" [unsupported opcode]"));
6669 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info *aux,
6670 unsigned int word, unsigned int remaining,
6671 unsigned int more_words,
6672 bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
6673 struct arm_section *data_arm_sec)
6675 struct absaddr addr;
6677 /* Decode the unwinding instructions. */
6680 unsigned int op, op2;
6689 printf (_(" 0x%02x "), op);
6691 if ((op & 0xc0) == 0x00)
6693 int offset = ((op & 0x3f) << 3) + 8;
6694 printf (_(" sp = sp + %d"), offset);
6696 else if ((op & 0xc0) == 0x80)
6699 if (op == 0x80 && op2 == 0)
6700 printf (_("Refuse to unwind"));
6703 unsigned int mask = ((op & 0x1f) << 8) | op2;
6705 printf ("pop compact {");
6709 decode_tic6x_unwind_regmask (mask);
6713 else if ((op & 0xf0) == 0xc0)
6720 unsigned int offset;
6724 /* Scan entire instruction first so that GET_OP output is not
6725 interleaved with disassembly. */
6727 for (i = 0; nregs < (op & 0xf); i++)
6733 regpos[nregs].offset = i * 2;
6734 regpos[nregs].reg = reg;
6741 regpos[nregs].offset = i * 2 + 1;
6742 regpos[nregs].reg = reg;
6747 printf (_("pop frame {"));
6749 for (i = i * 2; i > 0; i--)
6751 if (regpos[reg].offset == i - 1)
6753 name = tic6x_unwind_regnames[regpos[reg].reg];
6760 fputs (name, stdout);
6767 else if (op == 0xd0)
6768 printf (" MOV FP, SP");
6769 else if (op == 0xd1)
6770 printf (" __c6xabi_pop_rts");
6771 else if (op == 0xd2)
6773 unsigned char buf[9];
6774 unsigned int i, len;
6775 unsigned long offset;
6776 for (i = 0; i < sizeof (buf); i++)
6779 if ((buf[i] & 0x80) == 0)
6782 assert (i < sizeof (buf));
6783 offset = read_uleb128 (buf, &len);
6784 assert (len == i + 1);
6785 offset = offset * 8 + 0x408;
6786 printf (_("sp = sp + %ld"), offset);
6788 else if ((op & 0xf0) == 0xe0)
6790 if ((op & 0x0f) == 7)
6793 printf (" MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
6797 printf (_(" [unsupported opcode]"));
6804 expand_prel31 (bfd_vma word, bfd_vma where)
6808 offset = word & 0x7fffffff;
6809 if (offset & 0x40000000)
6810 offset |= ~ (bfd_vma) 0x7fffffff;
6812 if (elf_header.e_machine == EM_TI_C6000)
6815 return offset + where;
6819 decode_arm_unwind (struct arm_unw_aux_info *aux,
6820 unsigned int word, unsigned int remaining,
6821 bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
6822 struct arm_section *data_arm_sec)
6825 unsigned int more_words = 0;
6826 struct absaddr addr;
6830 /* Fetch the first word. */
6831 if (!arm_section_get_word (aux, data_arm_sec, data_sec, data_offset,
6837 if ((word & 0x80000000) == 0)
6839 /* Expand prel31 for personality routine. */
6841 const char *procname;
6843 fn = expand_prel31 (word, data_sec->sh_addr + data_offset);
6844 printf (_(" Personality routine: "));
6845 procname = arm_print_vma_and_name (aux, fn, addr);
6846 fputc ('\n', stdout);
6848 /* The GCC personality routines use the standard compact
6849 encoding, starting with one byte giving the number of
6851 if (procname != NULL
6852 && (const_strneq (procname, "__gcc_personality_v0")
6853 || const_strneq (procname, "__gxx_personality_v0")
6854 || const_strneq (procname, "__gcj_personality_v0")
6855 || const_strneq (procname, "__gnu_objc_personality_v0")))
6862 printf (_(" [Truncated data]\n"));
6865 more_words = word >> 24;
6876 per_index = (word >> 24) & 0x7f;
6877 printf (_(" Compact model %d\n"), per_index);
6884 else if (per_index < 3)
6886 more_words = (word >> 16) & 0xff;
6892 switch (elf_header.e_machine)
6897 decode_arm_unwind_bytecode (aux, word, remaining, more_words,
6898 data_offset, data_sec, data_arm_sec);
6901 printf (" [reserved]\n");
6907 decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
6908 data_offset, data_sec, data_arm_sec);
6910 else if (per_index < 5)
6912 if (((word >> 17) & 0x7f) == 0x7f)
6913 printf (_(" Restore stack from frame pointer\n"));
6915 printf (_(" Stack increment %d\n"), (word >> 14) & 0x1fc);
6916 printf (_(" Registers restored: "));
6918 printf (" (compact) ");
6919 decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
6921 printf (_(" Return register: %s\n"),
6922 tic6x_unwind_regnames[word & 0xf]);
6925 printf (" [reserved]\n");
6932 /* Decode the descriptors. Not implemented. */
6936 dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
6938 struct arm_section exidx_arm_sec, extab_arm_sec;
6939 unsigned int i, exidx_len;
6941 memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
6942 memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
6943 exidx_len = exidx_sec->sh_size / 8;
6945 for (i = 0; i < exidx_len; i++)
6947 unsigned int exidx_fn, exidx_entry;
6948 struct absaddr fn_addr, entry_addr;
6951 fputc ('\n', stdout);
6953 if (!arm_section_get_word (aux, &exidx_arm_sec, exidx_sec,
6954 8 * i, &exidx_fn, &fn_addr)
6955 || !arm_section_get_word (aux, &exidx_arm_sec, exidx_sec,
6956 8 * i + 4, &exidx_entry, &entry_addr))
6958 arm_free_section (&exidx_arm_sec);
6959 arm_free_section (&extab_arm_sec);
6963 fn = expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
6965 arm_print_vma_and_name (aux, fn, entry_addr);
6966 fputs (": ", stdout);
6968 if (exidx_entry == 1)
6970 print_vma (exidx_entry, PREFIX_HEX);
6971 fputs (" [cantunwind]\n", stdout);
6973 else if (exidx_entry & 0x80000000)
6975 print_vma (exidx_entry, PREFIX_HEX);
6976 fputc ('\n', stdout);
6977 decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
6981 bfd_vma table, table_offset = 0;
6982 Elf_Internal_Shdr *table_sec;
6984 fputs ("@", stdout);
6985 table = expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
6986 print_vma (table, PREFIX_HEX);
6989 /* Locate the matching .ARM.extab. */
6990 if (entry_addr.section != SHN_UNDEF
6991 && entry_addr.section < elf_header.e_shnum)
6993 table_sec = section_headers + entry_addr.section;
6994 table_offset = entry_addr.offset;
6998 table_sec = find_section_by_address (table);
6999 if (table_sec != NULL)
7000 table_offset = table - table_sec->sh_addr;
7002 if (table_sec == NULL)
7004 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
7005 (unsigned long) table);
7008 decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
7015 arm_free_section (&exidx_arm_sec);
7016 arm_free_section (&extab_arm_sec);
7019 /* Used for both ARM and C6X unwinding tables. */
7021 arm_process_unwind (FILE *file)
7023 struct arm_unw_aux_info aux;
7024 Elf_Internal_Shdr *unwsec = NULL;
7025 Elf_Internal_Shdr *strsec;
7026 Elf_Internal_Shdr *sec;
7028 unsigned int sec_type;
7030 memset (& aux, 0, sizeof (aux));
7033 switch (elf_header.e_machine)
7036 sec_type = SHT_ARM_EXIDX;
7040 sec_type = SHT_C6000_UNWIND;
7047 if (string_table == NULL)
7050 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7052 if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
7054 aux.nsyms = sec->sh_size / sec->sh_entsize;
7055 aux.symtab = GET_ELF_SYMBOLS (file, sec);
7057 strsec = section_headers + sec->sh_link;
7058 assert (aux.strtab == NULL);
7059 aux.strtab = get_data (NULL, file, strsec->sh_offset,
7060 1, strsec->sh_size, _("string table"));
7061 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7063 else if (sec->sh_type == sec_type)
7068 printf (_("\nThere are no unwind sections in this file.\n"));
7070 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7072 if (sec->sh_type == sec_type)
7074 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
7076 (unsigned long) sec->sh_offset,
7077 (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
7079 dump_arm_unwind (&aux, sec);
7086 free ((char *) aux.strtab);
7092 process_unwind (FILE * file)
7094 struct unwind_handler
7097 int (* handler)(FILE *);
7100 { EM_ARM, arm_process_unwind },
7101 { EM_IA_64, ia64_process_unwind },
7102 { EM_PARISC, hppa_process_unwind },
7103 { EM_TI_C6000, arm_process_unwind },
7111 for (i = 0; handlers[i].handler != NULL; i++)
7112 if (elf_header.e_machine == handlers[i].machtype)
7113 return handlers[i].handler (file);
7115 printf (_("\nThere are no unwind sections in this file.\n"));
7120 dynamic_section_mips_val (Elf_Internal_Dyn * entry)
7122 switch (entry->d_tag)
7125 if (entry->d_un.d_val == 0)
7126 printf (_("NONE\n"));
7129 static const char * opts[] =
7131 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
7132 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
7133 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
7134 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
7140 for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
7141 if (entry->d_un.d_val & (1 << cnt))
7143 printf ("%s%s", first ? "" : " ", opts[cnt]);
7150 case DT_MIPS_IVERSION:
7151 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
7152 printf (_("Interface Version: %s\n"), GET_DYNAMIC_NAME (entry->d_un.d_val));
7154 printf (_("<corrupt: %ld>\n"), (long) entry->d_un.d_ptr);
7157 case DT_MIPS_TIME_STAMP:
7162 time_t atime = entry->d_un.d_val;
7163 tmp = gmtime (&atime);
7164 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
7165 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
7166 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
7167 printf (_("Time Stamp: %s\n"), timebuf);
7171 case DT_MIPS_RLD_VERSION:
7172 case DT_MIPS_LOCAL_GOTNO:
7173 case DT_MIPS_CONFLICTNO:
7174 case DT_MIPS_LIBLISTNO:
7175 case DT_MIPS_SYMTABNO:
7176 case DT_MIPS_UNREFEXTNO:
7177 case DT_MIPS_HIPAGENO:
7178 case DT_MIPS_DELTA_CLASS_NO:
7179 case DT_MIPS_DELTA_INSTANCE_NO:
7180 case DT_MIPS_DELTA_RELOC_NO:
7181 case DT_MIPS_DELTA_SYM_NO:
7182 case DT_MIPS_DELTA_CLASSSYM_NO:
7183 case DT_MIPS_COMPACT_SIZE:
7184 printf ("%ld\n", (long) entry->d_un.d_ptr);
7188 printf ("%#lx\n", (unsigned long) entry->d_un.d_ptr);
7193 dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
7195 switch (entry->d_tag)
7197 case DT_HP_DLD_FLAGS:
7206 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
7207 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
7208 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
7209 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
7210 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
7211 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
7212 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
7213 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
7214 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
7215 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
7216 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
7217 { DT_HP_GST, "HP_GST" },
7218 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
7219 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
7220 { DT_HP_NODELETE, "HP_NODELETE" },
7221 { DT_HP_GROUP, "HP_GROUP" },
7222 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
7226 bfd_vma val = entry->d_un.d_val;
7228 for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
7229 if (val & flags[cnt].bit)
7233 fputs (flags[cnt].str, stdout);
7235 val ^= flags[cnt].bit;
7238 if (val != 0 || first)
7242 print_vma (val, HEX);
7248 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7256 /* VMS vs Unix time offset and factor. */
7258 #define VMS_EPOCH_OFFSET 35067168000000000LL
7259 #define VMS_GRANULARITY_FACTOR 10000000
7261 /* Display a VMS time in a human readable format. */
7264 print_vms_time (bfd_int64_t vmstime)
7269 unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
7270 tm = gmtime (&unxtime);
7271 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
7272 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
7273 tm->tm_hour, tm->tm_min, tm->tm_sec);
7278 dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
7280 switch (entry->d_tag)
7282 case DT_IA_64_PLT_RESERVE:
7283 /* First 3 slots reserved. */
7284 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7286 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
7289 case DT_IA_64_VMS_LINKTIME:
7291 print_vms_time (entry->d_un.d_val);
7295 case DT_IA_64_VMS_LNKFLAGS:
7296 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7297 if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
7298 printf (" CALL_DEBUG");
7299 if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
7300 printf (" NOP0BUFS");
7301 if (entry->d_un.d_val & VMS_LF_P0IMAGE)
7302 printf (" P0IMAGE");
7303 if (entry->d_un.d_val & VMS_LF_MKTHREADS)
7304 printf (" MKTHREADS");
7305 if (entry->d_un.d_val & VMS_LF_UPCALLS)
7306 printf (" UPCALLS");
7307 if (entry->d_un.d_val & VMS_LF_IMGSTA)
7309 if (entry->d_un.d_val & VMS_LF_INITIALIZE)
7310 printf (" INITIALIZE");
7311 if (entry->d_un.d_val & VMS_LF_MAIN)
7313 if (entry->d_un.d_val & VMS_LF_EXE_INIT)
7314 printf (" EXE_INIT");
7315 if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
7316 printf (" TBK_IN_IMG");
7317 if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
7318 printf (" DBG_IN_IMG");
7319 if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
7320 printf (" TBK_IN_DSF");
7321 if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
7322 printf (" DBG_IN_DSF");
7323 if (entry->d_un.d_val & VMS_LF_SIGNATURES)
7324 printf (" SIGNATURES");
7325 if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
7326 printf (" REL_SEG_OFF");
7330 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7337 get_32bit_dynamic_section (FILE * file)
7339 Elf32_External_Dyn * edyn;
7340 Elf32_External_Dyn * ext;
7341 Elf_Internal_Dyn * entry;
7343 edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
7344 dynamic_size, _("dynamic section"));
7348 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
7349 might not have the luxury of section headers. Look for the DT_NULL
7350 terminator to determine the number of entries. */
7351 for (ext = edyn, dynamic_nent = 0;
7352 (char *) ext < (char *) edyn + dynamic_size;
7356 if (BYTE_GET (ext->d_tag) == DT_NULL)
7360 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
7362 if (dynamic_section == NULL)
7364 error (_("Out of memory\n"));
7369 for (ext = edyn, entry = dynamic_section;
7370 entry < dynamic_section + dynamic_nent;
7373 entry->d_tag = BYTE_GET (ext->d_tag);
7374 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
7383 get_64bit_dynamic_section (FILE * file)
7385 Elf64_External_Dyn * edyn;
7386 Elf64_External_Dyn * ext;
7387 Elf_Internal_Dyn * entry;
7389 edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
7390 dynamic_size, _("dynamic section"));
7394 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
7395 might not have the luxury of section headers. Look for the DT_NULL
7396 terminator to determine the number of entries. */
7397 for (ext = edyn, dynamic_nent = 0;
7398 (char *) ext < (char *) edyn + dynamic_size;
7402 if (BYTE_GET (ext->d_tag) == DT_NULL)
7406 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
7408 if (dynamic_section == NULL)
7410 error (_("Out of memory\n"));
7415 for (ext = edyn, entry = dynamic_section;
7416 entry < dynamic_section + dynamic_nent;
7419 entry->d_tag = BYTE_GET (ext->d_tag);
7420 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
7429 print_dynamic_flags (bfd_vma flags)
7437 flag = flags & - flags;
7447 case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
7448 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
7449 case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
7450 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
7451 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
7452 default: fputs (_("unknown"), stdout); break;
7458 /* Parse and display the contents of the dynamic section. */
7461 process_dynamic_section (FILE * file)
7463 Elf_Internal_Dyn * entry;
7465 if (dynamic_size == 0)
7468 printf (_("\nThere is no dynamic section in this file.\n"));
7475 if (! get_32bit_dynamic_section (file))
7478 else if (! get_64bit_dynamic_section (file))
7481 /* Find the appropriate symbol table. */
7482 if (dynamic_symbols == NULL)
7484 for (entry = dynamic_section;
7485 entry < dynamic_section + dynamic_nent;
7488 Elf_Internal_Shdr section;
7490 if (entry->d_tag != DT_SYMTAB)
7493 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
7495 /* Since we do not know how big the symbol table is,
7496 we default to reading in the entire file (!) and
7497 processing that. This is overkill, I know, but it
7499 section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
7501 if (archive_file_offset != 0)
7502 section.sh_size = archive_file_size - section.sh_offset;
7505 if (fseek (file, 0, SEEK_END))
7506 error (_("Unable to seek to end of file!\n"));
7508 section.sh_size = ftell (file) - section.sh_offset;
7512 section.sh_entsize = sizeof (Elf32_External_Sym);
7514 section.sh_entsize = sizeof (Elf64_External_Sym);
7516 num_dynamic_syms = section.sh_size / section.sh_entsize;
7517 if (num_dynamic_syms < 1)
7519 error (_("Unable to determine the number of symbols to load\n"));
7523 dynamic_symbols = GET_ELF_SYMBOLS (file, §ion);
7527 /* Similarly find a string table. */
7528 if (dynamic_strings == NULL)
7530 for (entry = dynamic_section;
7531 entry < dynamic_section + dynamic_nent;
7534 unsigned long offset;
7537 if (entry->d_tag != DT_STRTAB)
7540 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
7542 /* Since we do not know how big the string table is,
7543 we default to reading in the entire file (!) and
7544 processing that. This is overkill, I know, but it
7547 offset = offset_from_vma (file, entry->d_un.d_val, 0);
7549 if (archive_file_offset != 0)
7550 str_tab_len = archive_file_size - offset;
7553 if (fseek (file, 0, SEEK_END))
7554 error (_("Unable to seek to end of file\n"));
7555 str_tab_len = ftell (file) - offset;
7558 if (str_tab_len < 1)
7561 (_("Unable to determine the length of the dynamic string table\n"));
7565 dynamic_strings = (char *) get_data (NULL, file, offset, 1,
7567 _("dynamic string table"));
7568 dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
7573 /* And find the syminfo section if available. */
7574 if (dynamic_syminfo == NULL)
7576 unsigned long syminsz = 0;
7578 for (entry = dynamic_section;
7579 entry < dynamic_section + dynamic_nent;
7582 if (entry->d_tag == DT_SYMINENT)
7584 /* Note: these braces are necessary to avoid a syntax
7585 error from the SunOS4 C compiler. */
7586 assert (sizeof (Elf_External_Syminfo) == entry->d_un.d_val);
7588 else if (entry->d_tag == DT_SYMINSZ)
7589 syminsz = entry->d_un.d_val;
7590 else if (entry->d_tag == DT_SYMINFO)
7591 dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
7595 if (dynamic_syminfo_offset != 0 && syminsz != 0)
7597 Elf_External_Syminfo * extsyminfo;
7598 Elf_External_Syminfo * extsym;
7599 Elf_Internal_Syminfo * syminfo;
7601 /* There is a syminfo section. Read the data. */
7602 extsyminfo = (Elf_External_Syminfo *)
7603 get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
7604 _("symbol information"));
7608 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
7609 if (dynamic_syminfo == NULL)
7611 error (_("Out of memory\n"));
7615 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
7616 for (syminfo = dynamic_syminfo, extsym = extsyminfo;
7617 syminfo < dynamic_syminfo + dynamic_syminfo_nent;
7618 ++syminfo, ++extsym)
7620 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
7621 syminfo->si_flags = BYTE_GET (extsym->si_flags);
7628 if (do_dynamic && dynamic_addr)
7629 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
7630 dynamic_addr, dynamic_nent);
7632 printf (_(" Tag Type Name/Value\n"));
7634 for (entry = dynamic_section;
7635 entry < dynamic_section + dynamic_nent;
7643 print_vma (entry->d_tag, FULL_HEX);
7644 dtype = get_dynamic_type (entry->d_tag);
7645 printf (" (%s)%*s", dtype,
7646 ((is_32bit_elf ? 27 : 19)
7647 - (int) strlen (dtype)),
7651 switch (entry->d_tag)
7655 print_dynamic_flags (entry->d_un.d_val);
7665 switch (entry->d_tag)
7668 printf (_("Auxiliary library"));
7672 printf (_("Filter library"));
7676 printf (_("Configuration file"));
7680 printf (_("Dependency audit library"));
7684 printf (_("Audit library"));
7688 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
7689 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
7693 print_vma (entry->d_un.d_val, PREFIX_HEX);
7702 printf (_("Flags:"));
7704 if (entry->d_un.d_val == 0)
7705 printf (_(" None\n"));
7708 unsigned long int val = entry->d_un.d_val;
7710 if (val & DTF_1_PARINIT)
7712 printf (" PARINIT");
7713 val ^= DTF_1_PARINIT;
7715 if (val & DTF_1_CONFEXP)
7717 printf (" CONFEXP");
7718 val ^= DTF_1_CONFEXP;
7721 printf (" %lx", val);
7730 printf (_("Flags:"));
7732 if (entry->d_un.d_val == 0)
7733 printf (_(" None\n"));
7736 unsigned long int val = entry->d_un.d_val;
7738 if (val & DF_P1_LAZYLOAD)
7740 printf (" LAZYLOAD");
7741 val ^= DF_P1_LAZYLOAD;
7743 if (val & DF_P1_GROUPPERM)
7745 printf (" GROUPPERM");
7746 val ^= DF_P1_GROUPPERM;
7749 printf (" %lx", val);
7758 printf (_("Flags:"));
7759 if (entry->d_un.d_val == 0)
7760 printf (_(" None\n"));
7763 unsigned long int val = entry->d_un.d_val;
7770 if (val & DF_1_GLOBAL)
7775 if (val & DF_1_GROUP)
7780 if (val & DF_1_NODELETE)
7782 printf (" NODELETE");
7783 val ^= DF_1_NODELETE;
7785 if (val & DF_1_LOADFLTR)
7787 printf (" LOADFLTR");
7788 val ^= DF_1_LOADFLTR;
7790 if (val & DF_1_INITFIRST)
7792 printf (" INITFIRST");
7793 val ^= DF_1_INITFIRST;
7795 if (val & DF_1_NOOPEN)
7800 if (val & DF_1_ORIGIN)
7805 if (val & DF_1_DIRECT)
7810 if (val & DF_1_TRANS)
7815 if (val & DF_1_INTERPOSE)
7817 printf (" INTERPOSE");
7818 val ^= DF_1_INTERPOSE;
7820 if (val & DF_1_NODEFLIB)
7822 printf (" NODEFLIB");
7823 val ^= DF_1_NODEFLIB;
7825 if (val & DF_1_NODUMP)
7830 if (val & DF_1_CONLFAT)
7832 printf (" CONLFAT");
7833 val ^= DF_1_CONLFAT;
7836 printf (" %lx", val);
7843 dynamic_info[entry->d_tag] = entry->d_un.d_val;
7845 puts (get_dynamic_type (entry->d_un.d_val));
7865 dynamic_info[entry->d_tag] = entry->d_un.d_val;
7871 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
7872 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
7878 switch (entry->d_tag)
7881 printf (_("Shared library: [%s]"), name);
7883 if (streq (name, program_interpreter))
7884 printf (_(" program interpreter"));
7888 printf (_("Library soname: [%s]"), name);
7892 printf (_("Library rpath: [%s]"), name);
7896 printf (_("Library runpath: [%s]"), name);
7900 print_vma (entry->d_un.d_val, PREFIX_HEX);
7905 print_vma (entry->d_un.d_val, PREFIX_HEX);
7918 dynamic_info[entry->d_tag] = entry->d_un.d_val;
7922 case DT_INIT_ARRAYSZ:
7923 case DT_FINI_ARRAYSZ:
7924 case DT_GNU_CONFLICTSZ:
7925 case DT_GNU_LIBLISTSZ:
7928 print_vma (entry->d_un.d_val, UNSIGNED);
7929 printf (_(" (bytes)\n"));
7939 print_vma (entry->d_un.d_val, UNSIGNED);
7952 if (entry->d_tag == DT_USED
7953 && VALID_DYNAMIC_NAME (entry->d_un.d_val))
7955 char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
7959 printf (_("Not needed object: [%s]\n"), name);
7964 print_vma (entry->d_un.d_val, PREFIX_HEX);
7970 /* The value of this entry is ignored. */
7975 case DT_GNU_PRELINKED:
7979 time_t atime = entry->d_un.d_val;
7981 tmp = gmtime (&atime);
7982 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
7983 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
7984 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
7990 dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
7993 print_vma (entry->d_un.d_val, PREFIX_HEX);
7999 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
8000 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
8005 switch (elf_header.e_machine)
8008 case EM_MIPS_RS3_LE:
8009 dynamic_section_mips_val (entry);
8012 dynamic_section_parisc_val (entry);
8015 dynamic_section_ia64_val (entry);
8018 print_vma (entry->d_un.d_val, PREFIX_HEX);
8030 get_ver_flags (unsigned int flags)
8032 static char buff[32];
8039 if (flags & VER_FLG_BASE)
8040 strcat (buff, "BASE ");
8042 if (flags & VER_FLG_WEAK)
8044 if (flags & VER_FLG_BASE)
8045 strcat (buff, "| ");
8047 strcat (buff, "WEAK ");
8050 if (flags & VER_FLG_INFO)
8052 if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
8053 strcat (buff, "| ");
8055 strcat (buff, "INFO ");
8058 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
8059 strcat (buff, _("| <unknown>"));
8064 /* Display the contents of the version sections. */
8067 process_version_sections (FILE * file)
8069 Elf_Internal_Shdr * section;
8076 for (i = 0, section = section_headers;
8077 i < elf_header.e_shnum;
8080 switch (section->sh_type)
8082 case SHT_GNU_verdef:
8084 Elf_External_Verdef * edefs;
8092 (_("\nVersion definition section '%s' contains %u entries:\n"),
8093 SECTION_NAME (section), section->sh_info);
8095 printf (_(" Addr: 0x"));
8096 printf_vma (section->sh_addr);
8097 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
8098 (unsigned long) section->sh_offset, section->sh_link,
8099 section->sh_link < elf_header.e_shnum
8100 ? SECTION_NAME (section_headers + section->sh_link)
8103 edefs = (Elf_External_Verdef *)
8104 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
8105 _("version definition section"));
8108 endbuf = (char *) edefs + section->sh_size;
8110 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
8113 Elf_External_Verdef * edef;
8114 Elf_Internal_Verdef ent;
8115 Elf_External_Verdaux * eaux;
8116 Elf_Internal_Verdaux aux;
8120 /* Check for negative or very large indicies. */
8121 if ((unsigned char *) edefs + idx < (unsigned char *) edefs)
8124 vstart = ((char *) edefs) + idx;
8125 if (vstart + sizeof (*edef) > endbuf)
8128 edef = (Elf_External_Verdef *) vstart;
8130 ent.vd_version = BYTE_GET (edef->vd_version);
8131 ent.vd_flags = BYTE_GET (edef->vd_flags);
8132 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
8133 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
8134 ent.vd_hash = BYTE_GET (edef->vd_hash);
8135 ent.vd_aux = BYTE_GET (edef->vd_aux);
8136 ent.vd_next = BYTE_GET (edef->vd_next);
8138 printf (_(" %#06x: Rev: %d Flags: %s"),
8139 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
8141 printf (_(" Index: %d Cnt: %d "),
8142 ent.vd_ndx, ent.vd_cnt);
8144 /* Check for overflow. */
8145 if ((unsigned char *)(vstart + ent.vd_aux) < (unsigned char *) vstart
8146 || (unsigned char *)(vstart + ent.vd_aux) > (unsigned char *) endbuf)
8149 vstart += ent.vd_aux;
8151 eaux = (Elf_External_Verdaux *) vstart;
8153 aux.vda_name = BYTE_GET (eaux->vda_name);
8154 aux.vda_next = BYTE_GET (eaux->vda_next);
8156 if (VALID_DYNAMIC_NAME (aux.vda_name))
8157 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
8159 printf (_("Name index: %ld\n"), aux.vda_name);
8161 isum = idx + ent.vd_aux;
8163 for (j = 1; j < ent.vd_cnt; j++)
8165 /* Check for overflow. */
8166 if ((unsigned char *)(vstart + aux.vda_next) < (unsigned char *) vstart
8167 || (unsigned char *)(vstart + aux.vda_next) > (unsigned char *) endbuf)
8170 isum += aux.vda_next;
8171 vstart += aux.vda_next;
8173 eaux = (Elf_External_Verdaux *) vstart;
8174 if (vstart + sizeof (*eaux) > endbuf)
8177 aux.vda_name = BYTE_GET (eaux->vda_name);
8178 aux.vda_next = BYTE_GET (eaux->vda_next);
8180 if (VALID_DYNAMIC_NAME (aux.vda_name))
8181 printf (_(" %#06x: Parent %d: %s\n"),
8182 isum, j, GET_DYNAMIC_NAME (aux.vda_name));
8184 printf (_(" %#06x: Parent %d, name index: %ld\n"),
8185 isum, j, aux.vda_name);
8189 printf (_(" Version def aux past end of section\n"));
8194 if (cnt < section->sh_info)
8195 printf (_(" Version definition past end of section\n"));
8201 case SHT_GNU_verneed:
8203 Elf_External_Verneed * eneed;
8210 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
8211 SECTION_NAME (section), section->sh_info);
8213 printf (_(" Addr: 0x"));
8214 printf_vma (section->sh_addr);
8215 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
8216 (unsigned long) section->sh_offset, section->sh_link,
8217 section->sh_link < elf_header.e_shnum
8218 ? SECTION_NAME (section_headers + section->sh_link)
8221 eneed = (Elf_External_Verneed *) get_data (NULL, file,
8222 section->sh_offset, 1,
8224 _("version need section"));
8227 endbuf = (char *) eneed + section->sh_size;
8229 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
8231 Elf_External_Verneed * entry;
8232 Elf_Internal_Verneed ent;
8237 if ((unsigned char *) eneed + idx < (unsigned char *) eneed)
8240 vstart = ((char *) eneed) + idx;
8241 if (vstart + sizeof (*entry) > endbuf)
8244 entry = (Elf_External_Verneed *) vstart;
8246 ent.vn_version = BYTE_GET (entry->vn_version);
8247 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
8248 ent.vn_file = BYTE_GET (entry->vn_file);
8249 ent.vn_aux = BYTE_GET (entry->vn_aux);
8250 ent.vn_next = BYTE_GET (entry->vn_next);
8252 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
8254 if (VALID_DYNAMIC_NAME (ent.vn_file))
8255 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
8257 printf (_(" File: %lx"), ent.vn_file);
8259 printf (_(" Cnt: %d\n"), ent.vn_cnt);
8261 /* Check for overflow. */
8262 if ((unsigned char *)(vstart + ent.vn_aux) < (unsigned char *) vstart
8263 || (unsigned char *)(vstart + ent.vn_aux) > (unsigned char *) endbuf)
8266 vstart += ent.vn_aux;
8268 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
8270 Elf_External_Vernaux * eaux;
8271 Elf_Internal_Vernaux aux;
8273 if (vstart + sizeof (*eaux) > endbuf)
8275 eaux = (Elf_External_Vernaux *) vstart;
8277 aux.vna_hash = BYTE_GET (eaux->vna_hash);
8278 aux.vna_flags = BYTE_GET (eaux->vna_flags);
8279 aux.vna_other = BYTE_GET (eaux->vna_other);
8280 aux.vna_name = BYTE_GET (eaux->vna_name);
8281 aux.vna_next = BYTE_GET (eaux->vna_next);
8283 if (VALID_DYNAMIC_NAME (aux.vna_name))
8284 printf (_(" %#06x: Name: %s"),
8285 isum, GET_DYNAMIC_NAME (aux.vna_name));
8287 printf (_(" %#06x: Name index: %lx"),
8288 isum, aux.vna_name);
8290 printf (_(" Flags: %s Version: %d\n"),
8291 get_ver_flags (aux.vna_flags), aux.vna_other);
8293 /* Check for overflow. */
8294 if ((unsigned char *)(vstart + aux.vna_next) < (unsigned char *) vstart
8295 || (unsigned char *)(vstart + aux.vna_next) > (unsigned char *) endbuf)
8298 isum += aux.vna_next;
8299 vstart += aux.vna_next;
8302 printf (_(" Version need aux past end of section\n"));
8306 if (cnt < section->sh_info)
8307 printf (_(" Version need past end of section\n"));
8313 case SHT_GNU_versym:
8315 Elf_Internal_Shdr * link_section;
8318 unsigned char * edata;
8319 unsigned short * data;
8321 Elf_Internal_Sym * symbols;
8322 Elf_Internal_Shdr * string_sec;
8325 if (section->sh_link >= elf_header.e_shnum)
8328 link_section = section_headers + section->sh_link;
8329 total = section->sh_size / sizeof (Elf_External_Versym);
8331 if (link_section->sh_link >= elf_header.e_shnum)
8336 symbols = GET_ELF_SYMBOLS (file, link_section);
8337 if (symbols == NULL)
8340 string_sec = section_headers + link_section->sh_link;
8342 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
8343 string_sec->sh_size,
8344 _("version string table"));
8351 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
8352 SECTION_NAME (section), total);
8354 printf (_(" Addr: "));
8355 printf_vma (section->sh_addr);
8356 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
8357 (unsigned long) section->sh_offset, section->sh_link,
8358 SECTION_NAME (link_section));
8360 off = offset_from_vma (file,
8361 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
8362 total * sizeof (short));
8363 edata = (unsigned char *) get_data (NULL, file, off, total,
8365 _("version symbol data"));
8373 data = (short unsigned int *) cmalloc (total, sizeof (short));
8375 for (cnt = total; cnt --;)
8376 data[cnt] = byte_get (edata + cnt * sizeof (short),
8381 for (cnt = 0; cnt < total; cnt += 4)
8384 int check_def, check_need;
8387 printf (" %03x:", cnt);
8389 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
8390 switch (data[cnt + j])
8393 fputs (_(" 0 (*local*) "), stdout);
8397 fputs (_(" 1 (*global*) "), stdout);
8401 nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
8402 data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
8404 /* If this index value is greater than the size of the symbols
8405 array, break to avoid an out-of-bounds read, */
8406 if ((unsigned long)(cnt + j) >=
8407 ((unsigned long)link_section->sh_size /
8408 (unsigned long)link_section->sh_entsize))
8410 warn (_("invalid index into symbol array\n"));
8416 if (symbols[cnt + j].st_shndx >= elf_header.e_shnum
8417 || section_headers[symbols[cnt + j].st_shndx].sh_type
8420 if (symbols[cnt + j].st_shndx == SHN_UNDEF)
8427 && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
8429 Elf_Internal_Verneed ivn;
8430 unsigned long offset;
8432 offset = offset_from_vma
8433 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
8434 sizeof (Elf_External_Verneed));
8438 Elf_Internal_Vernaux ivna;
8439 Elf_External_Verneed evn;
8440 Elf_External_Vernaux evna;
8441 unsigned long a_off;
8443 if (get_data (&evn, file, offset, sizeof (evn), 1,
8444 _("version need")) == NULL)
8447 ivn.vn_aux = BYTE_GET (evn.vn_aux);
8448 ivn.vn_next = BYTE_GET (evn.vn_next);
8450 a_off = offset + ivn.vn_aux;
8454 if (get_data (&evna, file, a_off, sizeof (evna),
8455 1, _("version need aux (2)")) == NULL)
8462 ivna.vna_next = BYTE_GET (evna.vna_next);
8463 ivna.vna_other = BYTE_GET (evna.vna_other);
8466 a_off += ivna.vna_next;
8468 while (ivna.vna_other != data[cnt + j]
8469 && ivna.vna_next != 0);
8471 if (ivna.vna_other == data[cnt + j])
8473 ivna.vna_name = BYTE_GET (evna.vna_name);
8475 if (ivna.vna_name >= string_sec->sh_size)
8476 name = _("*invalid*");
8478 name = strtab + ivna.vna_name;
8479 nn += printf ("(%s%-*s",
8481 12 - (int) strlen (name),
8487 offset += ivn.vn_next;
8489 while (ivn.vn_next);
8492 if (check_def && data[cnt + j] != 0x8001
8493 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
8495 Elf_Internal_Verdef ivd;
8496 Elf_External_Verdef evd;
8497 unsigned long offset;
8499 offset = offset_from_vma
8500 (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
8505 if (get_data (&evd, file, offset, sizeof (evd), 1,
8506 _("version def")) == NULL)
8513 ivd.vd_next = BYTE_GET (evd.vd_next);
8514 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
8517 offset += ivd.vd_next;
8519 while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
8520 && ivd.vd_next != 0);
8522 if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
8524 Elf_External_Verdaux evda;
8525 Elf_Internal_Verdaux ivda;
8527 ivd.vd_aux = BYTE_GET (evd.vd_aux);
8529 if (get_data (&evda, file,
8530 offset - ivd.vd_next + ivd.vd_aux,
8532 _("version def aux")) == NULL)
8535 ivda.vda_name = BYTE_GET (evda.vda_name);
8537 if (ivda.vda_name >= string_sec->sh_size)
8538 name = _("*invalid*");
8540 name = strtab + ivda.vda_name;
8541 nn += printf ("(%s%-*s",
8543 12 - (int) strlen (name),
8549 printf ("%*c", 18 - nn, ' ');
8567 printf (_("\nNo version information found in this file.\n"));
8573 get_symbol_binding (unsigned int binding)
8575 static char buff[32];
8579 case STB_LOCAL: return "LOCAL";
8580 case STB_GLOBAL: return "GLOBAL";
8581 case STB_WEAK: return "WEAK";
8583 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
8584 snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
8586 else if (binding >= STB_LOOS && binding <= STB_HIOS)
8588 if (binding == STB_GNU_UNIQUE
8589 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
8590 /* GNU is still using the default value 0. */
8591 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
8593 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
8596 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
8602 get_symbol_type (unsigned int type)
8604 static char buff[32];
8608 case STT_NOTYPE: return "NOTYPE";
8609 case STT_OBJECT: return "OBJECT";
8610 case STT_FUNC: return "FUNC";
8611 case STT_SECTION: return "SECTION";
8612 case STT_FILE: return "FILE";
8613 case STT_COMMON: return "COMMON";
8614 case STT_TLS: return "TLS";
8615 case STT_RELC: return "RELC";
8616 case STT_SRELC: return "SRELC";
8618 if (type >= STT_LOPROC && type <= STT_HIPROC)
8620 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
8621 return "THUMB_FUNC";
8623 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
8626 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
8627 return "PARISC_MILLI";
8629 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
8631 else if (type >= STT_LOOS && type <= STT_HIOS)
8633 if (elf_header.e_machine == EM_PARISC)
8635 if (type == STT_HP_OPAQUE)
8637 if (type == STT_HP_STUB)
8641 if (type == STT_GNU_IFUNC
8642 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
8643 /* GNU is still using the default value 0. */
8644 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
8647 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
8650 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
8656 get_symbol_visibility (unsigned int visibility)
8660 case STV_DEFAULT: return "DEFAULT";
8661 case STV_INTERNAL: return "INTERNAL";
8662 case STV_HIDDEN: return "HIDDEN";
8663 case STV_PROTECTED: return "PROTECTED";
8669 get_mips_symbol_other (unsigned int other)
8673 case STO_OPTIONAL: return "OPTIONAL";
8674 case STO_MIPS16: return "MIPS16";
8675 case STO_MIPS_PLT: return "MIPS PLT";
8676 case STO_MIPS_PIC: return "MIPS PIC";
8677 default: return NULL;
8682 get_ia64_symbol_other (unsigned int other)
8686 static char res[32];
8690 /* Function types is for images and .STB files only. */
8691 switch (elf_header.e_type)
8695 switch (VMS_ST_FUNC_TYPE (other))
8697 case VMS_SFT_CODE_ADDR:
8698 strcat (res, " CA");
8700 case VMS_SFT_SYMV_IDX:
8701 strcat (res, " VEC");
8704 strcat (res, " FD");
8706 case VMS_SFT_RESERVE:
8707 strcat (res, " RSV");
8716 switch (VMS_ST_LINKAGE (other))
8718 case VMS_STL_IGNORE:
8719 strcat (res, " IGN");
8721 case VMS_STL_RESERVE:
8722 strcat (res, " RSV");
8725 strcat (res, " STD");
8728 strcat (res, " LNK");
8743 get_symbol_other (unsigned int other)
8745 const char * result = NULL;
8746 static char buff [32];
8751 switch (elf_header.e_machine)
8754 result = get_mips_symbol_other (other);
8757 result = get_ia64_symbol_other (other);
8766 snprintf (buff, sizeof buff, _("<other>: %x"), other);
8771 get_symbol_index_type (unsigned int type)
8773 static char buff[32];
8777 case SHN_UNDEF: return "UND";
8778 case SHN_ABS: return "ABS";
8779 case SHN_COMMON: return "COM";
8781 if (type == SHN_IA_64_ANSI_COMMON
8782 && elf_header.e_machine == EM_IA_64
8783 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
8785 else if ((elf_header.e_machine == EM_X86_64
8786 || elf_header.e_machine == EM_L1OM)
8787 && type == SHN_X86_64_LCOMMON)
8789 else if ((type == SHN_MIPS_SCOMMON
8790 && elf_header.e_machine == EM_MIPS)
8791 || (type == SHN_TIC6X_SCOMMON
8792 && elf_header.e_machine == EM_TI_C6000))
8794 else if (type == SHN_MIPS_SUNDEFINED
8795 && elf_header.e_machine == EM_MIPS)
8797 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
8798 sprintf (buff, "PRC[0x%04x]", type & 0xffff);
8799 else if (type >= SHN_LOOS && type <= SHN_HIOS)
8800 sprintf (buff, "OS [0x%04x]", type & 0xffff);
8801 else if (type >= SHN_LORESERVE)
8802 sprintf (buff, "RSV[0x%04x]", type & 0xffff);
8804 sprintf (buff, "%3d", type);
8812 get_dynamic_data (FILE * file, unsigned int number, unsigned int ent_size)
8814 unsigned char * e_data;
8817 e_data = (unsigned char *) cmalloc (number, ent_size);
8821 error (_("Out of memory\n"));
8825 if (fread (e_data, ent_size, number, file) != number)
8827 error (_("Unable to read in dynamic data\n"));
8831 i_data = (bfd_vma *) cmalloc (number, sizeof (*i_data));
8835 error (_("Out of memory\n"));
8841 i_data[number] = byte_get (e_data + number * ent_size, ent_size);
8849 print_dynamic_symbol (bfd_vma si, unsigned long hn)
8851 Elf_Internal_Sym * psym;
8854 psym = dynamic_symbols + si;
8856 n = print_vma (si, DEC_5);
8858 fputs (" " + n, stdout);
8859 printf (" %3lu: ", hn);
8860 print_vma (psym->st_value, LONG_HEX);
8862 print_vma (psym->st_size, DEC_5);
8864 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
8865 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
8866 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
8867 /* Check to see if any other bits in the st_other field are set.
8868 Note - displaying this information disrupts the layout of the
8869 table being generated, but for the moment this case is very
8871 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
8872 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
8873 printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
8874 if (VALID_DYNAMIC_NAME (psym->st_name))
8875 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
8877 printf (_(" <corrupt: %14ld>"), psym->st_name);
8881 /* Dump the symbol table. */
8883 process_symbol_table (FILE * file)
8885 Elf_Internal_Shdr * section;
8886 bfd_vma nbuckets = 0;
8887 bfd_vma nchains = 0;
8888 bfd_vma * buckets = NULL;
8889 bfd_vma * chains = NULL;
8890 bfd_vma ngnubuckets = 0;
8891 bfd_vma * gnubuckets = NULL;
8892 bfd_vma * gnuchains = NULL;
8893 bfd_vma gnusymidx = 0;
8895 if (!do_syms && !do_dyn_syms && !do_histogram)
8898 if (dynamic_info[DT_HASH]
8900 || (do_using_dynamic
8902 && dynamic_strings != NULL)))
8904 unsigned char nb[8];
8905 unsigned char nc[8];
8906 int hash_ent_size = 4;
8908 if ((elf_header.e_machine == EM_ALPHA
8909 || elf_header.e_machine == EM_S390
8910 || elf_header.e_machine == EM_S390_OLD)
8911 && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
8915 (archive_file_offset
8916 + offset_from_vma (file, dynamic_info[DT_HASH],
8917 sizeof nb + sizeof nc)),
8920 error (_("Unable to seek to start of dynamic information\n"));
8924 if (fread (nb, hash_ent_size, 1, file) != 1)
8926 error (_("Failed to read in number of buckets\n"));
8930 if (fread (nc, hash_ent_size, 1, file) != 1)
8932 error (_("Failed to read in number of chains\n"));
8936 nbuckets = byte_get (nb, hash_ent_size);
8937 nchains = byte_get (nc, hash_ent_size);
8939 buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
8940 chains = get_dynamic_data (file, nchains, hash_ent_size);
8943 if (buckets == NULL || chains == NULL)
8945 if (do_using_dynamic)
8956 if (dynamic_info_DT_GNU_HASH
8958 || (do_using_dynamic
8960 && dynamic_strings != NULL)))
8962 unsigned char nb[16];
8963 bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
8964 bfd_vma buckets_vma;
8967 (archive_file_offset
8968 + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
8972 error (_("Unable to seek to start of dynamic information\n"));
8976 if (fread (nb, 16, 1, file) != 1)
8978 error (_("Failed to read in number of buckets\n"));
8982 ngnubuckets = byte_get (nb, 4);
8983 gnusymidx = byte_get (nb + 4, 4);
8984 bitmaskwords = byte_get (nb + 8, 4);
8985 buckets_vma = dynamic_info_DT_GNU_HASH + 16;
8987 buckets_vma += bitmaskwords * 4;
8989 buckets_vma += bitmaskwords * 8;
8992 (archive_file_offset
8993 + offset_from_vma (file, buckets_vma, 4)),
8996 error (_("Unable to seek to start of dynamic information\n"));
9000 gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
9002 if (gnubuckets == NULL)
9005 for (i = 0; i < ngnubuckets; i++)
9006 if (gnubuckets[i] != 0)
9008 if (gnubuckets[i] < gnusymidx)
9011 if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
9012 maxchain = gnubuckets[i];
9015 if (maxchain == 0xffffffff)
9018 maxchain -= gnusymidx;
9021 (archive_file_offset
9022 + offset_from_vma (file, buckets_vma
9023 + 4 * (ngnubuckets + maxchain), 4)),
9026 error (_("Unable to seek to start of dynamic information\n"));
9032 if (fread (nb, 4, 1, file) != 1)
9034 error (_("Failed to determine last chain length\n"));
9038 if (maxchain + 1 == 0)
9043 while ((byte_get (nb, 4) & 1) == 0);
9046 (archive_file_offset
9047 + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
9050 error (_("Unable to seek to start of dynamic information\n"));
9054 gnuchains = get_dynamic_data (file, maxchain, 4);
9057 if (gnuchains == NULL)
9062 if (do_using_dynamic)
9067 if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
9070 && dynamic_strings != NULL)
9074 if (dynamic_info[DT_HASH])
9078 printf (_("\nSymbol table for image:\n"));
9080 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9082 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9084 for (hn = 0; hn < nbuckets; hn++)
9089 for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
9090 print_dynamic_symbol (si, hn);
9094 if (dynamic_info_DT_GNU_HASH)
9096 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
9098 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9100 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9102 for (hn = 0; hn < ngnubuckets; ++hn)
9103 if (gnubuckets[hn] != 0)
9105 bfd_vma si = gnubuckets[hn];
9106 bfd_vma off = si - gnusymidx;
9110 print_dynamic_symbol (si, hn);
9113 while ((gnuchains[off++] & 1) == 0);
9117 else if (do_dyn_syms || (do_syms && !do_using_dynamic))
9121 for (i = 0, section = section_headers;
9122 i < elf_header.e_shnum;
9126 char * strtab = NULL;
9127 unsigned long int strtab_size = 0;
9128 Elf_Internal_Sym * symtab;
9129 Elf_Internal_Sym * psym;
9131 if ((section->sh_type != SHT_SYMTAB
9132 && section->sh_type != SHT_DYNSYM)
9134 && section->sh_type == SHT_SYMTAB))
9137 if (section->sh_entsize == 0)
9139 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
9140 SECTION_NAME (section));
9144 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
9145 SECTION_NAME (section),
9146 (unsigned long) (section->sh_size / section->sh_entsize));
9149 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
9151 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
9153 symtab = GET_ELF_SYMBOLS (file, section);
9157 if (section->sh_link == elf_header.e_shstrndx)
9159 strtab = string_table;
9160 strtab_size = string_table_length;
9162 else if (section->sh_link < elf_header.e_shnum)
9164 Elf_Internal_Shdr * string_sec;
9166 string_sec = section_headers + section->sh_link;
9168 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
9169 1, string_sec->sh_size,
9171 strtab_size = strtab != NULL ? string_sec->sh_size : 0;
9174 for (si = 0, psym = symtab;
9175 si < section->sh_size / section->sh_entsize;
9178 printf ("%6d: ", si);
9179 print_vma (psym->st_value, LONG_HEX);
9181 print_vma (psym->st_size, DEC_5);
9182 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
9183 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
9184 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
9185 /* Check to see if any other bits in the st_other field are set.
9186 Note - displaying this information disrupts the layout of the
9187 table being generated, but for the moment this case is very rare. */
9188 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
9189 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
9190 printf (" %4s ", get_symbol_index_type (psym->st_shndx));
9191 print_symbol (25, psym->st_name < strtab_size
9192 ? strtab + psym->st_name : _("<corrupt>"));
9194 if (section->sh_type == SHT_DYNSYM
9195 && version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
9197 unsigned char data[2];
9198 unsigned short vers_data;
9199 unsigned long offset;
9203 offset = offset_from_vma
9204 (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
9205 sizeof data + si * sizeof (vers_data));
9207 if (get_data (&data, file, offset + si * sizeof (vers_data),
9208 sizeof (data), 1, _("version data")) == NULL)
9211 vers_data = byte_get (data, 2);
9213 is_nobits = (psym->st_shndx < elf_header.e_shnum
9214 && section_headers[psym->st_shndx].sh_type
9217 check_def = (psym->st_shndx != SHN_UNDEF);
9219 if ((vers_data & VERSYM_HIDDEN) || vers_data > 1)
9221 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
9222 && (is_nobits || ! check_def))
9224 Elf_External_Verneed evn;
9225 Elf_Internal_Verneed ivn;
9226 Elf_Internal_Vernaux ivna;
9228 /* We must test both. */
9229 offset = offset_from_vma
9230 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
9235 unsigned long vna_off;
9237 if (get_data (&evn, file, offset, sizeof (evn), 1,
9238 _("version need")) == NULL)
9246 ivn.vn_aux = BYTE_GET (evn.vn_aux);
9247 ivn.vn_next = BYTE_GET (evn.vn_next);
9249 vna_off = offset + ivn.vn_aux;
9253 Elf_External_Vernaux evna;
9255 if (get_data (&evna, file, vna_off,
9257 _("version need aux (3)")) == NULL)
9265 ivna.vna_other = BYTE_GET (evna.vna_other);
9266 ivna.vna_next = BYTE_GET (evna.vna_next);
9267 ivna.vna_name = BYTE_GET (evna.vna_name);
9270 vna_off += ivna.vna_next;
9272 while (ivna.vna_other != vers_data
9273 && ivna.vna_next != 0);
9275 if (ivna.vna_other == vers_data)
9278 offset += ivn.vn_next;
9280 while (ivn.vn_next != 0);
9282 if (ivna.vna_other == vers_data)
9285 ivna.vna_name < strtab_size
9286 ? strtab + ivna.vna_name : _("<corrupt>"),
9290 else if (! is_nobits)
9291 error (_("bad dynamic symbol\n"));
9298 if (vers_data != 0x8001
9299 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
9301 Elf_Internal_Verdef ivd;
9302 Elf_Internal_Verdaux ivda;
9303 Elf_External_Verdaux evda;
9306 off = offset_from_vma
9308 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
9309 sizeof (Elf_External_Verdef));
9313 Elf_External_Verdef evd;
9315 if (get_data (&evd, file, off, sizeof (evd),
9316 1, _("version def")) == NULL)
9324 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
9325 ivd.vd_aux = BYTE_GET (evd.vd_aux);
9326 ivd.vd_next = BYTE_GET (evd.vd_next);
9331 while (ivd.vd_ndx != (vers_data & VERSYM_VERSION)
9332 && ivd.vd_next != 0);
9337 if (get_data (&evda, file, off, sizeof (evda),
9338 1, _("version def aux")) == NULL)
9341 ivda.vda_name = BYTE_GET (evda.vda_name);
9343 if (psym->st_name != ivda.vda_name)
9344 printf ((vers_data & VERSYM_HIDDEN)
9346 ivda.vda_name < strtab_size
9347 ? strtab + ivda.vda_name : _("<corrupt>"));
9357 if (strtab != string_table)
9363 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
9365 if (do_histogram && buckets != NULL)
9367 unsigned long * lengths;
9368 unsigned long * counts;
9371 unsigned long maxlength = 0;
9372 unsigned long nzero_counts = 0;
9373 unsigned long nsyms = 0;
9375 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
9376 (unsigned long) nbuckets);
9377 printf (_(" Length Number %% of total Coverage\n"));
9379 lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
9380 if (lengths == NULL)
9382 error (_("Out of memory\n"));
9385 for (hn = 0; hn < nbuckets; ++hn)
9387 for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
9390 if (maxlength < ++lengths[hn])
9395 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
9398 error (_("Out of memory\n"));
9402 for (hn = 0; hn < nbuckets; ++hn)
9403 ++counts[lengths[hn]];
9408 printf (" 0 %-10lu (%5.1f%%)\n",
9409 counts[0], (counts[0] * 100.0) / nbuckets);
9410 for (i = 1; i <= maxlength; ++i)
9412 nzero_counts += counts[i] * i;
9413 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
9414 i, counts[i], (counts[i] * 100.0) / nbuckets,
9415 (nzero_counts * 100.0) / nsyms);
9423 if (buckets != NULL)
9429 if (do_histogram && gnubuckets != NULL)
9431 unsigned long * lengths;
9432 unsigned long * counts;
9434 unsigned long maxlength = 0;
9435 unsigned long nzero_counts = 0;
9436 unsigned long nsyms = 0;
9438 lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
9439 if (lengths == NULL)
9441 error (_("Out of memory\n"));
9445 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
9446 (unsigned long) ngnubuckets);
9447 printf (_(" Length Number %% of total Coverage\n"));
9449 for (hn = 0; hn < ngnubuckets; ++hn)
9450 if (gnubuckets[hn] != 0)
9452 bfd_vma off, length = 1;
9454 for (off = gnubuckets[hn] - gnusymidx;
9455 (gnuchains[off] & 1) == 0; ++off)
9457 lengths[hn] = length;
9458 if (length > maxlength)
9463 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
9466 error (_("Out of memory\n"));
9470 for (hn = 0; hn < ngnubuckets; ++hn)
9471 ++counts[lengths[hn]];
9473 if (ngnubuckets > 0)
9476 printf (" 0 %-10lu (%5.1f%%)\n",
9477 counts[0], (counts[0] * 100.0) / ngnubuckets);
9478 for (j = 1; j <= maxlength; ++j)
9480 nzero_counts += counts[j] * j;
9481 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
9482 j, counts[j], (counts[j] * 100.0) / ngnubuckets,
9483 (nzero_counts * 100.0) / nsyms);
9497 process_syminfo (FILE * file ATTRIBUTE_UNUSED)
9501 if (dynamic_syminfo == NULL
9503 /* No syminfo, this is ok. */
9506 /* There better should be a dynamic symbol section. */
9507 if (dynamic_symbols == NULL || dynamic_strings == NULL)
9511 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
9512 dynamic_syminfo_offset, dynamic_syminfo_nent);
9514 printf (_(" Num: Name BoundTo Flags\n"));
9515 for (i = 0; i < dynamic_syminfo_nent; ++i)
9517 unsigned short int flags = dynamic_syminfo[i].si_flags;
9519 printf ("%4d: ", i);
9520 if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
9521 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
9523 printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
9526 switch (dynamic_syminfo[i].si_boundto)
9528 case SYMINFO_BT_SELF:
9529 fputs ("SELF ", stdout);
9531 case SYMINFO_BT_PARENT:
9532 fputs ("PARENT ", stdout);
9535 if (dynamic_syminfo[i].si_boundto > 0
9536 && dynamic_syminfo[i].si_boundto < dynamic_nent
9537 && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
9539 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
9543 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
9547 if (flags & SYMINFO_FLG_DIRECT)
9549 if (flags & SYMINFO_FLG_PASSTHRU)
9550 printf (" PASSTHRU");
9551 if (flags & SYMINFO_FLG_COPY)
9553 if (flags & SYMINFO_FLG_LAZYLOAD)
9554 printf (" LAZYLOAD");
9562 /* Check to see if the given reloc needs to be handled in a target specific
9563 manner. If so then process the reloc and return TRUE otherwise return
9567 target_specific_reloc_handling (Elf_Internal_Rela * reloc,
9568 unsigned char * start,
9569 Elf_Internal_Sym * symtab)
9571 unsigned int reloc_type = get_reloc_type (reloc->r_info);
9573 switch (elf_header.e_machine)
9576 case EM_CYGNUS_MN10300:
9578 static Elf_Internal_Sym * saved_sym = NULL;
9582 case 34: /* R_MN10300_ALIGN */
9584 case 33: /* R_MN10300_SYM_DIFF */
9585 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
9587 case 1: /* R_MN10300_32 */
9588 case 2: /* R_MN10300_16 */
9589 if (saved_sym != NULL)
9593 value = reloc->r_addend
9594 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
9595 - saved_sym->st_value);
9597 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
9604 if (saved_sym != NULL)
9605 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc"));
9615 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
9616 DWARF debug sections. This is a target specific test. Note - we do not
9617 go through the whole including-target-headers-multiple-times route, (as
9618 we have already done with <elf/h8.h>) because this would become very
9619 messy and even then this function would have to contain target specific
9620 information (the names of the relocs instead of their numeric values).
9621 FIXME: This is not the correct way to solve this problem. The proper way
9622 is to have target specific reloc sizing and typing functions created by
9623 the reloc-macros.h header, in the same way that it already creates the
9624 reloc naming functions. */
9627 is_32bit_abs_reloc (unsigned int reloc_type)
9629 switch (elf_header.e_machine)
9633 return reloc_type == 1; /* R_386_32. */
9635 return reloc_type == 1; /* R_68K_32. */
9637 return reloc_type == 1; /* R_860_32. */
9639 return reloc_type == 2; /* R_960_32. */
9641 return reloc_type == 1; /* R_ALPHA_REFLONG. */
9643 return reloc_type == 1; /* R_ARC_32. */
9645 return reloc_type == 2; /* R_ARM_ABS32 */
9648 return reloc_type == 1;
9650 return reloc_type == 0x12; /* R_byte4_data. */
9652 return reloc_type == 3; /* R_CRIS_32. */
9655 return reloc_type == 3; /* R_CR16_NUM32. */
9657 return reloc_type == 15; /* R_CRX_NUM32. */
9659 return reloc_type == 1;
9660 case EM_CYGNUS_D10V:
9662 return reloc_type == 6; /* R_D10V_32. */
9663 case EM_CYGNUS_D30V:
9665 return reloc_type == 12; /* R_D30V_32_NORMAL. */
9667 return reloc_type == 3; /* R_DLX_RELOC_32. */
9668 case EM_CYGNUS_FR30:
9670 return reloc_type == 3; /* R_FR30_32. */
9674 return reloc_type == 1; /* R_H8_DIR32. */
9676 return reloc_type == 0x65; /* R_IA64_SECREL32LSB. */
9679 return reloc_type == 2; /* R_IP2K_32. */
9681 return reloc_type == 2; /* R_IQ2000_32. */
9682 case EM_LATTICEMICO32:
9683 return reloc_type == 3; /* R_LM32_32. */
9686 return reloc_type == 3; /* R_M32C_32. */
9688 return reloc_type == 34; /* R_M32R_32_RELA. */
9690 return reloc_type == 1; /* R_MCORE_ADDR32. */
9692 return reloc_type == 4; /* R_MEP_32. */
9694 return reloc_type == 1; /* R_MICROBLAZE_32. */
9696 return reloc_type == 2; /* R_MIPS_32. */
9698 return reloc_type == 4; /* R_MMIX_32. */
9699 case EM_CYGNUS_MN10200:
9701 return reloc_type == 1; /* R_MN10200_32. */
9702 case EM_CYGNUS_MN10300:
9704 return reloc_type == 1; /* R_MN10300_32. */
9706 return reloc_type == 1; /* R_MOXIE_32. */
9709 return reloc_type == 1; /* R_MSP43_32. */
9711 return reloc_type == 2; /* R_MT_32. */
9712 case EM_ALTERA_NIOS2:
9714 return reloc_type == 1; /* R_NIOS_32. */
9717 return reloc_type == 1; /* R_OR32_32. */
9719 return (reloc_type == 1 /* R_PARISC_DIR32. */
9720 || reloc_type == 41); /* R_PARISC_SECREL32. */
9723 return reloc_type == 1; /* R_PJ_DATA_DIR32. */
9725 return reloc_type == 1; /* R_PPC64_ADDR32. */
9727 return reloc_type == 1; /* R_PPC_ADDR32. */
9729 return reloc_type == 1; /* R_RX_DIR32. */
9731 return reloc_type == 1; /* R_I370_ADDR31. */
9734 return reloc_type == 4; /* R_S390_32. */
9736 return reloc_type == 8; /* R_SCORE_ABS32. */
9738 return reloc_type == 1; /* R_SH_DIR32. */
9739 case EM_SPARC32PLUS:
9742 return reloc_type == 3 /* R_SPARC_32. */
9743 || reloc_type == 23; /* R_SPARC_UA32. */
9745 return reloc_type == 6; /* R_SPU_ADDR32 */
9747 return reloc_type == 1; /* R_C6000_ABS32. */
9749 return reloc_type == 2; /* R_TILEGX_32. */
9751 return reloc_type == 1; /* R_TILEPRO_32. */
9752 case EM_CYGNUS_V850:
9754 return reloc_type == 6; /* R_V850_ABS32. */
9756 return reloc_type == 1; /* R_VAX_32. */
9759 return reloc_type == 10; /* R_X86_64_32. */
9762 return reloc_type == 3; /* R_XC16C_ABS_32. */
9764 return reloc_type == 1; /* R_XSTROMY16_32. */
9767 return reloc_type == 1; /* R_XTENSA_32. */
9769 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
9770 elf_header.e_machine);
9775 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9776 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
9779 is_32bit_pcrel_reloc (unsigned int reloc_type)
9781 switch (elf_header.e_machine)
9785 return reloc_type == 2; /* R_386_PC32. */
9787 return reloc_type == 4; /* R_68K_PC32. */
9789 return reloc_type == 10; /* R_ALPHA_SREL32. */
9791 return reloc_type == 3; /* R_ARM_REL32 */
9793 return reloc_type == 2; /* R_MICROBLAZE_32_PCREL. */
9795 return reloc_type == 9; /* R_PARISC_PCREL32. */
9797 return reloc_type == 26; /* R_PPC_REL32. */
9799 return reloc_type == 26; /* R_PPC64_REL32. */
9802 return reloc_type == 5; /* R_390_PC32. */
9804 return reloc_type == 2; /* R_SH_REL32. */
9805 case EM_SPARC32PLUS:
9808 return reloc_type == 6; /* R_SPARC_DISP32. */
9810 return reloc_type == 13; /* R_SPU_REL32. */
9812 return reloc_type == 6; /* R_TILEGX_32_PCREL. */
9814 return reloc_type == 4; /* R_TILEPRO_32_PCREL. */
9817 return reloc_type == 2; /* R_X86_64_PC32. */
9820 return reloc_type == 14; /* R_XTENSA_32_PCREL. */
9822 /* Do not abort or issue an error message here. Not all targets use
9823 pc-relative 32-bit relocs in their DWARF debug information and we
9824 have already tested for target coverage in is_32bit_abs_reloc. A
9825 more helpful warning message will be generated by apply_relocations
9826 anyway, so just return. */
9831 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9832 a 64-bit absolute RELA relocation used in DWARF debug sections. */
9835 is_64bit_abs_reloc (unsigned int reloc_type)
9837 switch (elf_header.e_machine)
9840 return reloc_type == 2; /* R_ALPHA_REFQUAD. */
9842 return reloc_type == 0x27; /* R_IA64_DIR64LSB. */
9844 return reloc_type == 80; /* R_PARISC_DIR64. */
9846 return reloc_type == 38; /* R_PPC64_ADDR64. */
9847 case EM_SPARC32PLUS:
9850 return reloc_type == 54; /* R_SPARC_UA64. */
9853 return reloc_type == 1; /* R_X86_64_64. */
9856 return reloc_type == 22; /* R_S390_64. */
9858 return reloc_type == 1; /* R_TILEGX_64. */
9860 return reloc_type == 18; /* R_MIPS_64. */
9866 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
9867 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
9870 is_64bit_pcrel_reloc (unsigned int reloc_type)
9872 switch (elf_header.e_machine)
9875 return reloc_type == 11; /* R_ALPHA_SREL64. */
9877 return reloc_type == 0x4f; /* R_IA64_PCREL64LSB. */
9879 return reloc_type == 72; /* R_PARISC_PCREL64. */
9881 return reloc_type == 44; /* R_PPC64_REL64. */
9882 case EM_SPARC32PLUS:
9885 return reloc_type == 46; /* R_SPARC_DISP64. */
9888 return reloc_type == 24; /* R_X86_64_PC64. */
9891 return reloc_type == 23; /* R_S390_PC64. */
9893 return reloc_type == 5; /* R_TILEGX_64_PCREL. */
9899 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9900 a 24-bit absolute RELA relocation used in DWARF debug sections. */
9903 is_24bit_abs_reloc (unsigned int reloc_type)
9905 switch (elf_header.e_machine)
9907 case EM_CYGNUS_MN10200:
9909 return reloc_type == 4; /* R_MN10200_24. */
9915 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9916 a 16-bit absolute RELA relocation used in DWARF debug sections. */
9919 is_16bit_abs_reloc (unsigned int reloc_type)
9921 switch (elf_header.e_machine)
9925 return reloc_type == 4; /* R_AVR_16. */
9926 case EM_CYGNUS_D10V:
9928 return reloc_type == 3; /* R_D10V_16. */
9932 return reloc_type == R_H8_DIR16;
9935 return reloc_type == 1; /* R_IP2K_16. */
9938 return reloc_type == 1; /* R_M32C_16 */
9941 return reloc_type == 5; /* R_MSP430_16_BYTE. */
9942 case EM_ALTERA_NIOS2:
9944 return reloc_type == 9; /* R_NIOS_16. */
9946 return reloc_type == 2; /* R_C6000_ABS16. */
9949 return reloc_type == 2; /* R_XC16C_ABS_16. */
9955 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
9956 relocation entries (possibly formerly used for SHT_GROUP sections). */
9959 is_none_reloc (unsigned int reloc_type)
9961 switch (elf_header.e_machine)
9963 case EM_68K: /* R_68K_NONE. */
9964 case EM_386: /* R_386_NONE. */
9965 case EM_SPARC32PLUS:
9967 case EM_SPARC: /* R_SPARC_NONE. */
9968 case EM_MIPS: /* R_MIPS_NONE. */
9969 case EM_PARISC: /* R_PARISC_NONE. */
9970 case EM_ALPHA: /* R_ALPHA_NONE. */
9971 case EM_PPC: /* R_PPC_NONE. */
9972 case EM_PPC64: /* R_PPC64_NONE. */
9973 case EM_ARM: /* R_ARM_NONE. */
9974 case EM_IA_64: /* R_IA64_NONE. */
9975 case EM_SH: /* R_SH_NONE. */
9977 case EM_S390: /* R_390_NONE. */
9978 case EM_CRIS: /* R_CRIS_NONE. */
9979 case EM_X86_64: /* R_X86_64_NONE. */
9980 case EM_L1OM: /* R_X86_64_NONE. */
9981 case EM_MN10300: /* R_MN10300_NONE. */
9982 case EM_MOXIE: /* R_MOXIE_NONE. */
9983 case EM_M32R: /* R_M32R_NONE. */
9984 case EM_TI_C6000:/* R_C6000_NONE. */
9985 case EM_TILEGX: /* R_TILEGX_NONE. */
9986 case EM_TILEPRO: /* R_TILEPRO_NONE. */
9988 case EM_C166: /* R_XC16X_NONE. */
9989 return reloc_type == 0;
9992 return (reloc_type == 0 /* R_XTENSA_NONE. */
9993 || reloc_type == 17 /* R_XTENSA_DIFF8. */
9994 || reloc_type == 18 /* R_XTENSA_DIFF16. */
9995 || reloc_type == 19 /* R_XTENSA_DIFF32. */);
10000 /* Apply relocations to a section.
10001 Note: So far support has been added only for those relocations
10002 which can be found in debug sections.
10003 FIXME: Add support for more relocations ? */
10006 apply_relocations (void * file,
10007 Elf_Internal_Shdr * section,
10008 unsigned char * start)
10010 Elf_Internal_Shdr * relsec;
10011 unsigned char * end = start + section->sh_size;
10013 if (elf_header.e_type != ET_REL)
10016 /* Find the reloc section associated with the section. */
10017 for (relsec = section_headers;
10018 relsec < section_headers + elf_header.e_shnum;
10021 bfd_boolean is_rela;
10022 unsigned long num_relocs;
10023 Elf_Internal_Rela * relocs;
10024 Elf_Internal_Rela * rp;
10025 Elf_Internal_Shdr * symsec;
10026 Elf_Internal_Sym * symtab;
10027 Elf_Internal_Sym * sym;
10029 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
10030 || relsec->sh_info >= elf_header.e_shnum
10031 || section_headers + relsec->sh_info != section
10032 || relsec->sh_size == 0
10033 || relsec->sh_link >= elf_header.e_shnum)
10036 is_rela = relsec->sh_type == SHT_RELA;
10040 if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
10041 relsec->sh_size, & relocs, & num_relocs))
10046 if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
10047 relsec->sh_size, & relocs, & num_relocs))
10051 /* SH uses RELA but uses in place value instead of the addend field. */
10052 if (elf_header.e_machine == EM_SH)
10055 symsec = section_headers + relsec->sh_link;
10056 symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec);
10058 for (rp = relocs; rp < relocs + num_relocs; ++rp)
10061 unsigned int reloc_type;
10062 unsigned int reloc_size;
10063 unsigned char * rloc;
10065 reloc_type = get_reloc_type (rp->r_info);
10067 if (target_specific_reloc_handling (rp, start, symtab))
10069 else if (is_none_reloc (reloc_type))
10071 else if (is_32bit_abs_reloc (reloc_type)
10072 || is_32bit_pcrel_reloc (reloc_type))
10074 else if (is_64bit_abs_reloc (reloc_type)
10075 || is_64bit_pcrel_reloc (reloc_type))
10077 else if (is_24bit_abs_reloc (reloc_type))
10079 else if (is_16bit_abs_reloc (reloc_type))
10083 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
10084 reloc_type, SECTION_NAME (section));
10088 rloc = start + rp->r_offset;
10089 if ((rloc + reloc_size) > end)
10091 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
10092 (unsigned long) rp->r_offset,
10093 SECTION_NAME (section));
10097 sym = symtab + get_reloc_symindex (rp->r_info);
10099 /* If the reloc has a symbol associated with it,
10100 make sure that it is of an appropriate type.
10102 Relocations against symbols without type can happen.
10103 Gcc -feliminate-dwarf2-dups may generate symbols
10104 without type for debug info.
10106 Icc generates relocations against function symbols
10107 instead of local labels.
10109 Relocations against object symbols can happen, eg when
10110 referencing a global array. For an example of this see
10111 the _clz.o binary in libgcc.a. */
10113 && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
10115 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
10116 get_symbol_type (ELF_ST_TYPE (sym->st_info)),
10117 (long int)(rp - relocs),
10118 SECTION_NAME (relsec));
10124 addend += rp->r_addend;
10125 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
10126 partial_inplace. */
10128 || (elf_header.e_machine == EM_XTENSA
10129 && reloc_type == 1)
10130 || ((elf_header.e_machine == EM_PJ
10131 || elf_header.e_machine == EM_PJ_OLD)
10132 && reloc_type == 1)
10133 || ((elf_header.e_machine == EM_D30V
10134 || elf_header.e_machine == EM_CYGNUS_D30V)
10135 && reloc_type == 12))
10136 addend += byte_get (rloc, reloc_size);
10138 if (is_32bit_pcrel_reloc (reloc_type)
10139 || is_64bit_pcrel_reloc (reloc_type))
10141 /* On HPPA, all pc-relative relocations are biased by 8. */
10142 if (elf_header.e_machine == EM_PARISC)
10144 byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
10148 byte_put (rloc, addend + sym->st_value, reloc_size);
10157 #ifdef SUPPORT_DISASSEMBLY
10159 disassemble_section (Elf_Internal_Shdr * section, FILE * file)
10161 printf (_("\nAssembly dump of section %s\n"),
10162 SECTION_NAME (section));
10164 /* XXX -- to be done --- XXX */
10170 /* Reads in the contents of SECTION from FILE, returning a pointer
10171 to a malloc'ed buffer or NULL if something went wrong. */
10174 get_section_contents (Elf_Internal_Shdr * section, FILE * file)
10176 bfd_size_type num_bytes;
10178 num_bytes = section->sh_size;
10180 if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
10182 printf (_("\nSection '%s' has no data to dump.\n"),
10183 SECTION_NAME (section));
10187 return (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
10188 _("section contents"));
10193 dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
10195 Elf_Internal_Shdr * relsec;
10196 bfd_size_type num_bytes;
10200 char * name = SECTION_NAME (section);
10201 bfd_boolean some_strings_shown;
10203 start = get_section_contents (section, file);
10207 printf (_("\nString dump of section '%s':\n"), name);
10209 /* If the section being dumped has relocations against it the user might
10210 be expecting these relocations to have been applied. Check for this
10211 case and issue a warning message in order to avoid confusion.
10212 FIXME: Maybe we ought to have an option that dumps a section with
10213 relocs applied ? */
10214 for (relsec = section_headers;
10215 relsec < section_headers + elf_header.e_shnum;
10218 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
10219 || relsec->sh_info >= elf_header.e_shnum
10220 || section_headers + relsec->sh_info != section
10221 || relsec->sh_size == 0
10222 || relsec->sh_link >= elf_header.e_shnum)
10225 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
10229 num_bytes = section->sh_size;
10231 end = start + num_bytes;
10232 some_strings_shown = FALSE;
10236 while (!ISPRINT (* data))
10237 if (++ data >= end)
10243 /* PR 11128: Use two separate invocations in order to work
10244 around bugs in the Solaris 8 implementation of printf. */
10245 printf (" [%6tx] ", data - start);
10246 printf ("%s\n", data);
10248 printf (" [%6Ix] %s\n", (size_t) (data - start), data);
10250 data += strlen (data);
10251 some_strings_shown = TRUE;
10255 if (! some_strings_shown)
10256 printf (_(" No strings found in this section."));
10264 dump_section_as_bytes (Elf_Internal_Shdr * section,
10266 bfd_boolean relocate)
10268 Elf_Internal_Shdr * relsec;
10269 bfd_size_type bytes;
10271 unsigned char * data;
10272 unsigned char * start;
10274 start = (unsigned char *) get_section_contents (section, file);
10278 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
10282 apply_relocations (file, section, start);
10286 /* If the section being dumped has relocations against it the user might
10287 be expecting these relocations to have been applied. Check for this
10288 case and issue a warning message in order to avoid confusion.
10289 FIXME: Maybe we ought to have an option that dumps a section with
10290 relocs applied ? */
10291 for (relsec = section_headers;
10292 relsec < section_headers + elf_header.e_shnum;
10295 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
10296 || relsec->sh_info >= elf_header.e_shnum
10297 || section_headers + relsec->sh_info != section
10298 || relsec->sh_size == 0
10299 || relsec->sh_link >= elf_header.e_shnum)
10302 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
10307 addr = section->sh_addr;
10308 bytes = section->sh_size;
10317 lbytes = (bytes > 16 ? 16 : bytes);
10319 printf (" 0x%8.8lx ", (unsigned long) addr);
10321 for (j = 0; j < 16; j++)
10324 printf ("%2.2x", data[j]);
10332 for (j = 0; j < lbytes; j++)
10335 if (k >= ' ' && k < 0x7f)
10353 /* Uncompresses a section that was compressed using zlib, in place. */
10356 uncompress_section_contents (unsigned char **buffer ATTRIBUTE_UNUSED,
10357 dwarf_size_type *size ATTRIBUTE_UNUSED)
10359 #ifndef HAVE_ZLIB_H
10362 dwarf_size_type compressed_size = *size;
10363 unsigned char * compressed_buffer = *buffer;
10364 dwarf_size_type uncompressed_size;
10365 unsigned char * uncompressed_buffer;
10368 dwarf_size_type header_size = 12;
10370 /* Read the zlib header. In this case, it should be "ZLIB" followed
10371 by the uncompressed section size, 8 bytes in big-endian order. */
10372 if (compressed_size < header_size
10373 || ! streq ((char *) compressed_buffer, "ZLIB"))
10376 uncompressed_size = compressed_buffer[4]; uncompressed_size <<= 8;
10377 uncompressed_size += compressed_buffer[5]; uncompressed_size <<= 8;
10378 uncompressed_size += compressed_buffer[6]; uncompressed_size <<= 8;
10379 uncompressed_size += compressed_buffer[7]; uncompressed_size <<= 8;
10380 uncompressed_size += compressed_buffer[8]; uncompressed_size <<= 8;
10381 uncompressed_size += compressed_buffer[9]; uncompressed_size <<= 8;
10382 uncompressed_size += compressed_buffer[10]; uncompressed_size <<= 8;
10383 uncompressed_size += compressed_buffer[11];
10385 /* It is possible the section consists of several compressed
10386 buffers concatenated together, so we uncompress in a loop. */
10387 strm.zalloc = NULL;
10389 strm.opaque = NULL;
10390 strm.avail_in = compressed_size - header_size;
10391 strm.next_in = (Bytef *) compressed_buffer + header_size;
10392 strm.avail_out = uncompressed_size;
10393 uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
10395 rc = inflateInit (& strm);
10396 while (strm.avail_in > 0)
10400 strm.next_out = ((Bytef *) uncompressed_buffer
10401 + (uncompressed_size - strm.avail_out));
10402 rc = inflate (&strm, Z_FINISH);
10403 if (rc != Z_STREAM_END)
10405 rc = inflateReset (& strm);
10407 rc = inflateEnd (& strm);
10409 || strm.avail_out != 0)
10412 free (compressed_buffer);
10413 *buffer = uncompressed_buffer;
10414 *size = uncompressed_size;
10418 free (uncompressed_buffer);
10419 /* Indicate decompression failure. */
10422 #endif /* HAVE_ZLIB_H */
10426 load_specific_debug_section (enum dwarf_section_display_enum debug,
10427 Elf_Internal_Shdr * sec, void * file)
10429 struct dwarf_section * section = &debug_displays [debug].section;
10432 /* If it is already loaded, do nothing. */
10433 if (section->start != NULL)
10436 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
10437 section->address = sec->sh_addr;
10438 section->start = (unsigned char *) get_data (NULL, (FILE *) file,
10440 sec->sh_size, buf);
10441 if (section->start == NULL)
10445 section->size = sec->sh_size;
10446 if (uncompress_section_contents (§ion->start, §ion->size))
10447 sec->sh_size = section->size;
10450 if (section->start == NULL)
10453 if (debug_displays [debug].relocate)
10454 apply_relocations ((FILE *) file, sec, section->start);
10460 load_debug_section (enum dwarf_section_display_enum debug, void * file)
10462 struct dwarf_section * section = &debug_displays [debug].section;
10463 Elf_Internal_Shdr * sec;
10465 /* Locate the debug section. */
10466 sec = find_section (section->uncompressed_name);
10468 section->name = section->uncompressed_name;
10471 sec = find_section (section->compressed_name);
10473 section->name = section->compressed_name;
10478 return load_specific_debug_section (debug, sec, (FILE *) file);
10482 free_debug_section (enum dwarf_section_display_enum debug)
10484 struct dwarf_section * section = &debug_displays [debug].section;
10486 if (section->start == NULL)
10489 free ((char *) section->start);
10490 section->start = NULL;
10491 section->address = 0;
10496 display_debug_section (Elf_Internal_Shdr * section, FILE * file)
10498 char * name = SECTION_NAME (section);
10499 bfd_size_type length;
10503 length = section->sh_size;
10506 printf (_("\nSection '%s' has no debugging data.\n"), name);
10509 if (section->sh_type == SHT_NOBITS)
10511 /* There is no point in dumping the contents of a debugging section
10512 which has the NOBITS type - the bits in the file will be random.
10513 This can happen when a file containing a .eh_frame section is
10514 stripped with the --only-keep-debug command line option. */
10515 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"), name);
10519 if (const_strneq (name, ".gnu.linkonce.wi."))
10520 name = ".debug_info";
10522 /* See if we know how to display the contents of this section. */
10523 for (i = 0; i < max; i++)
10524 if (streq (debug_displays[i].section.uncompressed_name, name)
10525 || streq (debug_displays[i].section.compressed_name, name))
10527 struct dwarf_section * sec = &debug_displays [i].section;
10528 int secondary = (section != find_section (name));
10531 free_debug_section ((enum dwarf_section_display_enum) i);
10533 if (streq (sec->uncompressed_name, name))
10534 sec->name = sec->uncompressed_name;
10536 sec->name = sec->compressed_name;
10537 if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
10540 result &= debug_displays[i].display (sec, file);
10542 if (secondary || (i != info && i != abbrev))
10543 free_debug_section ((enum dwarf_section_display_enum) i);
10551 printf (_("Unrecognized debug section: %s\n"), name);
10558 /* Set DUMP_SECTS for all sections where dumps were requested
10559 based on section name. */
10562 initialise_dumps_byname (void)
10564 struct dump_list_entry * cur;
10566 for (cur = dump_sects_byname; cur; cur = cur->next)
10571 for (i = 0, any = 0; i < elf_header.e_shnum; i++)
10572 if (streq (SECTION_NAME (section_headers + i), cur->name))
10574 request_dump_bynumber (i, cur->type);
10579 warn (_("Section '%s' was not dumped because it does not exist!\n"),
10585 process_section_contents (FILE * file)
10587 Elf_Internal_Shdr * section;
10593 initialise_dumps_byname ();
10595 for (i = 0, section = section_headers;
10596 i < elf_header.e_shnum && i < num_dump_sects;
10599 #ifdef SUPPORT_DISASSEMBLY
10600 if (dump_sects[i] & DISASS_DUMP)
10601 disassemble_section (section, file);
10603 if (dump_sects[i] & HEX_DUMP)
10604 dump_section_as_bytes (section, file, FALSE);
10606 if (dump_sects[i] & RELOC_DUMP)
10607 dump_section_as_bytes (section, file, TRUE);
10609 if (dump_sects[i] & STRING_DUMP)
10610 dump_section_as_strings (section, file);
10612 if (dump_sects[i] & DEBUG_DUMP)
10613 display_debug_section (section, file);
10616 /* Check to see if the user requested a
10617 dump of a section that does not exist. */
10618 while (i++ < num_dump_sects)
10620 warn (_("Section %d was not dumped because it does not exist!\n"), i);
10624 process_mips_fpe_exception (int mask)
10629 if (mask & OEX_FPU_INEX)
10630 fputs ("INEX", stdout), first = 0;
10631 if (mask & OEX_FPU_UFLO)
10632 printf ("%sUFLO", first ? "" : "|"), first = 0;
10633 if (mask & OEX_FPU_OFLO)
10634 printf ("%sOFLO", first ? "" : "|"), first = 0;
10635 if (mask & OEX_FPU_DIV0)
10636 printf ("%sDIV0", first ? "" : "|"), first = 0;
10637 if (mask & OEX_FPU_INVAL)
10638 printf ("%sINVAL", first ? "" : "|");
10641 fputs ("0", stdout);
10644 /* ARM EABI attributes section. */
10649 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
10651 const char ** table;
10652 } arm_attr_public_tag;
10654 static const char * arm_attr_tag_CPU_arch[] =
10655 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
10656 "v6K", "v7", "v6-M", "v6S-M", "v7E-M"};
10657 static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
10658 static const char * arm_attr_tag_THUMB_ISA_use[] =
10659 {"No", "Thumb-1", "Thumb-2"};
10660 static const char * arm_attr_tag_FP_arch[] =
10661 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16"};
10662 static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
10663 static const char * arm_attr_tag_Advanced_SIMD_arch[] =
10664 {"No", "NEONv1", "NEONv1 with Fused-MAC"};
10665 static const char * arm_attr_tag_PCS_config[] =
10666 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
10667 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
10668 static const char * arm_attr_tag_ABI_PCS_R9_use[] =
10669 {"V6", "SB", "TLS", "Unused"};
10670 static const char * arm_attr_tag_ABI_PCS_RW_data[] =
10671 {"Absolute", "PC-relative", "SB-relative", "None"};
10672 static const char * arm_attr_tag_ABI_PCS_RO_data[] =
10673 {"Absolute", "PC-relative", "None"};
10674 static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
10675 {"None", "direct", "GOT-indirect"};
10676 static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
10677 {"None", "??? 1", "2", "??? 3", "4"};
10678 static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
10679 static const char * arm_attr_tag_ABI_FP_denormal[] =
10680 {"Unused", "Needed", "Sign only"};
10681 static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
10682 static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
10683 static const char * arm_attr_tag_ABI_FP_number_model[] =
10684 {"Unused", "Finite", "RTABI", "IEEE 754"};
10685 static const char * arm_attr_tag_ABI_enum_size[] =
10686 {"Unused", "small", "int", "forced to int"};
10687 static const char * arm_attr_tag_ABI_HardFP_use[] =
10688 {"As Tag_FP_arch", "SP only", "DP only", "SP and DP"};
10689 static const char * arm_attr_tag_ABI_VFP_args[] =
10690 {"AAPCS", "VFP registers", "custom"};
10691 static const char * arm_attr_tag_ABI_WMMX_args[] =
10692 {"AAPCS", "WMMX registers", "custom"};
10693 static const char * arm_attr_tag_ABI_optimization_goals[] =
10694 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
10695 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
10696 static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
10697 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
10698 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
10699 static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
10700 static const char * arm_attr_tag_FP_HP_extension[] =
10701 {"Not Allowed", "Allowed"};
10702 static const char * arm_attr_tag_ABI_FP_16bit_format[] =
10703 {"None", "IEEE 754", "Alternative Format"};
10704 static const char * arm_attr_tag_MPextension_use[] =
10705 {"Not Allowed", "Allowed"};
10706 static const char * arm_attr_tag_DIV_use[] =
10707 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
10708 "Allowed in v7-A with integer division extension"};
10709 static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
10710 static const char * arm_attr_tag_Virtualization_use[] =
10711 {"Not Allowed", "TrustZone", "Virtualization Extensions",
10712 "TrustZone and Virtualization Extensions"};
10713 static const char * arm_attr_tag_MPextension_use_legacy[] =
10714 {"Not Allowed", "Allowed"};
10716 #define LOOKUP(id, name) \
10717 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
10718 static arm_attr_public_tag arm_attr_public_tags[] =
10720 {4, "CPU_raw_name", 1, NULL},
10721 {5, "CPU_name", 1, NULL},
10722 LOOKUP(6, CPU_arch),
10723 {7, "CPU_arch_profile", 0, NULL},
10724 LOOKUP(8, ARM_ISA_use),
10725 LOOKUP(9, THUMB_ISA_use),
10726 LOOKUP(10, FP_arch),
10727 LOOKUP(11, WMMX_arch),
10728 LOOKUP(12, Advanced_SIMD_arch),
10729 LOOKUP(13, PCS_config),
10730 LOOKUP(14, ABI_PCS_R9_use),
10731 LOOKUP(15, ABI_PCS_RW_data),
10732 LOOKUP(16, ABI_PCS_RO_data),
10733 LOOKUP(17, ABI_PCS_GOT_use),
10734 LOOKUP(18, ABI_PCS_wchar_t),
10735 LOOKUP(19, ABI_FP_rounding),
10736 LOOKUP(20, ABI_FP_denormal),
10737 LOOKUP(21, ABI_FP_exceptions),
10738 LOOKUP(22, ABI_FP_user_exceptions),
10739 LOOKUP(23, ABI_FP_number_model),
10740 {24, "ABI_align_needed", 0, NULL},
10741 {25, "ABI_align_preserved", 0, NULL},
10742 LOOKUP(26, ABI_enum_size),
10743 LOOKUP(27, ABI_HardFP_use),
10744 LOOKUP(28, ABI_VFP_args),
10745 LOOKUP(29, ABI_WMMX_args),
10746 LOOKUP(30, ABI_optimization_goals),
10747 LOOKUP(31, ABI_FP_optimization_goals),
10748 {32, "compatibility", 0, NULL},
10749 LOOKUP(34, CPU_unaligned_access),
10750 LOOKUP(36, FP_HP_extension),
10751 LOOKUP(38, ABI_FP_16bit_format),
10752 LOOKUP(42, MPextension_use),
10753 LOOKUP(44, DIV_use),
10754 {64, "nodefaults", 0, NULL},
10755 {65, "also_compatible_with", 0, NULL},
10756 LOOKUP(66, T2EE_use),
10757 {67, "conformance", 1, NULL},
10758 LOOKUP(68, Virtualization_use),
10759 LOOKUP(70, MPextension_use_legacy)
10763 static unsigned char *
10764 display_arm_attribute (unsigned char * p)
10769 arm_attr_public_tag * attr;
10773 tag = read_uleb128 (p, &len);
10776 for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
10778 if (arm_attr_public_tags[i].tag == tag)
10780 attr = &arm_attr_public_tags[i];
10787 printf (" Tag_%s: ", attr->name);
10788 switch (attr->type)
10793 case 7: /* Tag_CPU_arch_profile. */
10794 val = read_uleb128 (p, &len);
10798 case 0: printf (_("None\n")); break;
10799 case 'A': printf (_("Application\n")); break;
10800 case 'R': printf (_("Realtime\n")); break;
10801 case 'M': printf (_("Microcontroller\n")); break;
10802 case 'S': printf (_("Application or Realtime\n")); break;
10803 default: printf ("??? (%d)\n", val); break;
10807 case 24: /* Tag_align_needed. */
10808 val = read_uleb128 (p, &len);
10812 case 0: printf (_("None\n")); break;
10813 case 1: printf (_("8-byte\n")); break;
10814 case 2: printf (_("4-byte\n")); break;
10815 case 3: printf ("??? 3\n"); break;
10818 printf (_("8-byte and up to %d-byte extended\n"),
10821 printf ("??? (%d)\n", val);
10826 case 25: /* Tag_align_preserved. */
10827 val = read_uleb128 (p, &len);
10831 case 0: printf (_("None\n")); break;
10832 case 1: printf (_("8-byte, except leaf SP\n")); break;
10833 case 2: printf (_("8-byte\n")); break;
10834 case 3: printf ("??? 3\n"); break;
10837 printf (_("8-byte and up to %d-byte extended\n"),
10840 printf ("??? (%d)\n", val);
10845 case 32: /* Tag_compatibility. */
10846 val = read_uleb128 (p, &len);
10848 printf (_("flag = %d, vendor = %s\n"), val, p);
10849 p += strlen ((char *) p) + 1;
10852 case 64: /* Tag_nodefaults. */
10854 printf (_("True\n"));
10857 case 65: /* Tag_also_compatible_with. */
10858 val = read_uleb128 (p, &len);
10860 if (val == 6 /* Tag_CPU_arch. */)
10862 val = read_uleb128 (p, &len);
10864 if ((unsigned int)val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
10865 printf ("??? (%d)\n", val);
10867 printf ("%s\n", arm_attr_tag_CPU_arch[val]);
10871 while (*(p++) != '\0' /* NUL terminator. */);
10885 assert (attr->type & 0x80);
10886 val = read_uleb128 (p, &len);
10888 type = attr->type & 0x7f;
10890 printf ("??? (%d)\n", val);
10892 printf ("%s\n", attr->table[val]);
10899 type = 1; /* String. */
10901 type = 2; /* uleb128. */
10902 printf (" Tag_unknown_%d: ", tag);
10907 printf ("\"%s\"\n", p);
10908 p += strlen ((char *) p) + 1;
10912 val = read_uleb128 (p, &len);
10914 printf ("%d (0x%x)\n", val, val);
10920 static unsigned char *
10921 display_gnu_attribute (unsigned char * p,
10922 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int))
10929 tag = read_uleb128 (p, &len);
10932 /* Tag_compatibility is the only generic GNU attribute defined at
10936 val = read_uleb128 (p, &len);
10938 printf (_("flag = %d, vendor = %s\n"), val, p);
10939 p += strlen ((char *) p) + 1;
10943 if ((tag & 2) == 0 && display_proc_gnu_attribute)
10944 return display_proc_gnu_attribute (p, tag);
10947 type = 1; /* String. */
10949 type = 2; /* uleb128. */
10950 printf (" Tag_unknown_%d: ", tag);
10954 printf ("\"%s\"\n", p);
10955 p += strlen ((char *) p) + 1;
10959 val = read_uleb128 (p, &len);
10961 printf ("%d (0x%x)\n", val, val);
10967 static unsigned char *
10968 display_power_gnu_attribute (unsigned char * p, int tag)
10974 if (tag == Tag_GNU_Power_ABI_FP)
10976 val = read_uleb128 (p, &len);
10978 printf (" Tag_GNU_Power_ABI_FP: ");
10983 printf (_("Hard or soft float\n"));
10986 printf (_("Hard float\n"));
10989 printf (_("Soft float\n"));
10992 printf (_("Single-precision hard float\n"));
10995 printf ("??? (%d)\n", val);
11001 if (tag == Tag_GNU_Power_ABI_Vector)
11003 val = read_uleb128 (p, &len);
11005 printf (" Tag_GNU_Power_ABI_Vector: ");
11009 printf (_("Any\n"));
11012 printf (_("Generic\n"));
11015 printf ("AltiVec\n");
11021 printf ("??? (%d)\n", val);
11027 if (tag == Tag_GNU_Power_ABI_Struct_Return)
11029 val = read_uleb128 (p, &len);
11031 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
11035 printf (_("Any\n"));
11038 printf ("r3/r4\n");
11041 printf (_("Memory\n"));
11044 printf ("??? (%d)\n", val);
11051 type = 1; /* String. */
11053 type = 2; /* uleb128. */
11054 printf (" Tag_unknown_%d: ", tag);
11058 printf ("\"%s\"\n", p);
11059 p += strlen ((char *) p) + 1;
11063 val = read_uleb128 (p, &len);
11065 printf ("%d (0x%x)\n", val, val);
11071 static unsigned char *
11072 display_mips_gnu_attribute (unsigned char * p, int tag)
11078 if (tag == Tag_GNU_MIPS_ABI_FP)
11080 val = read_uleb128 (p, &len);
11082 printf (" Tag_GNU_MIPS_ABI_FP: ");
11087 printf (_("Hard or soft float\n"));
11090 printf (_("Hard float (double precision)\n"));
11093 printf (_("Hard float (single precision)\n"));
11096 printf (_("Soft float\n"));
11099 printf (_("Hard float (MIPS32r2 64-bit FPU)\n"));
11102 printf ("??? (%d)\n", val);
11109 type = 1; /* String. */
11111 type = 2; /* uleb128. */
11112 printf (" Tag_unknown_%d: ", tag);
11116 printf ("\"%s\"\n", p);
11117 p += strlen ((char *) p) + 1;
11121 val = read_uleb128 (p, &len);
11123 printf ("%d (0x%x)\n", val, val);
11129 static unsigned char *
11130 display_tic6x_attribute (unsigned char * p)
11136 tag = read_uleb128 (p, &len);
11142 val = read_uleb128 (p, &len);
11144 printf (" Tag_ISA: ");
11148 case C6XABI_Tag_ISA_none:
11149 printf (_("None\n"));
11151 case C6XABI_Tag_ISA_C62X:
11154 case C6XABI_Tag_ISA_C67X:
11157 case C6XABI_Tag_ISA_C67XP:
11158 printf ("C67x+\n");
11160 case C6XABI_Tag_ISA_C64X:
11163 case C6XABI_Tag_ISA_C64XP:
11164 printf ("C64x+\n");
11166 case C6XABI_Tag_ISA_C674X:
11167 printf ("C674x\n");
11170 printf ("??? (%d)\n", val);
11175 case Tag_ABI_wchar_t:
11176 val = read_uleb128 (p, &len);
11178 printf (" Tag_ABI_wchar_t: ");
11182 printf (_("Not used\n"));
11185 printf (_("2 bytes\n"));
11188 printf (_("4 bytes\n"));
11191 printf ("??? (%d)\n", val);
11196 case Tag_ABI_stack_align_needed:
11197 val = read_uleb128 (p, &len);
11199 printf (" Tag_ABI_stack_align_needed: ");
11203 printf (_("8-byte\n"));
11206 printf (_("16-byte\n"));
11209 printf ("??? (%d)\n", val);
11214 case Tag_ABI_stack_align_preserved:
11215 val = read_uleb128 (p, &len);
11217 printf (" Tag_ABI_stack_align_preserved: ");
11221 printf (_("8-byte\n"));
11224 printf (_("16-byte\n"));
11227 printf ("??? (%d)\n", val);
11233 val = read_uleb128 (p, &len);
11235 printf (" Tag_ABI_DSBT: ");
11239 printf (_("DSBT addressing not used\n"));
11242 printf (_("DSBT addressing used\n"));
11245 printf ("??? (%d)\n", val);
11251 val = read_uleb128 (p, &len);
11253 printf (" Tag_ABI_PID: ");
11257 printf (_("Data addressing position-dependent\n"));
11260 printf (_("Data addressing position-independent, GOT near DP\n"));
11263 printf (_("Data addressing position-independent, GOT far from DP\n"));
11266 printf ("??? (%d)\n", val);
11272 val = read_uleb128 (p, &len);
11274 printf (" Tag_ABI_PIC: ");
11278 printf (_("Code addressing position-dependent\n"));
11281 printf (_("Code addressing position-independent\n"));
11284 printf ("??? (%d)\n", val);
11289 case Tag_ABI_array_object_alignment:
11290 val = read_uleb128 (p, &len);
11292 printf (" Tag_ABI_array_object_alignment: ");
11296 printf (_("8-byte\n"));
11299 printf (_("4-byte\n"));
11302 printf (_("16-byte\n"));
11305 printf ("??? (%d)\n", val);
11310 case Tag_ABI_array_object_align_expected:
11311 val = read_uleb128 (p, &len);
11313 printf (" Tag_ABI_array_object_align_expected: ");
11317 printf (_("8-byte\n"));
11320 printf (_("4-byte\n"));
11323 printf (_("16-byte\n"));
11326 printf ("??? (%d)\n", val);
11331 case Tag_ABI_compatibility:
11332 val = read_uleb128 (p, &len);
11334 printf (" Tag_ABI_compatibility: ");
11335 printf (_("flag = %d, vendor = %s\n"), val, p);
11336 p += strlen ((char *) p) + 1;
11339 case Tag_ABI_conformance:
11340 printf (" Tag_ABI_conformance: ");
11341 printf ("\"%s\"\n", p);
11342 p += strlen ((char *) p) + 1;
11346 printf (" Tag_unknown_%d: ", tag);
11350 printf ("\"%s\"\n", p);
11351 p += strlen ((char *) p) + 1;
11355 val = read_uleb128 (p, &len);
11357 printf ("%d (0x%x)\n", val, val);
11364 process_attributes (FILE * file,
11365 const char * public_name,
11366 unsigned int proc_type,
11367 unsigned char * (* display_pub_attribute) (unsigned char *),
11368 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int))
11370 Elf_Internal_Shdr * sect;
11371 unsigned char * contents;
11373 unsigned char * end;
11374 bfd_vma section_len;
11378 /* Find the section header so that we get the size. */
11379 for (i = 0, sect = section_headers;
11380 i < elf_header.e_shnum;
11383 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
11386 contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
11387 sect->sh_size, _("attributes"));
11388 if (contents == NULL)
11394 len = sect->sh_size - 1;
11400 bfd_boolean public_section;
11401 bfd_boolean gnu_section;
11403 section_len = byte_get (p, 4);
11406 if (section_len > len)
11408 printf (_("ERROR: Bad section length (%d > %d)\n"),
11409 (int) section_len, (int) len);
11413 len -= section_len;
11414 printf (_("Attribute Section: %s\n"), p);
11416 if (public_name && streq ((char *) p, public_name))
11417 public_section = TRUE;
11419 public_section = FALSE;
11421 if (streq ((char *) p, "gnu"))
11422 gnu_section = TRUE;
11424 gnu_section = FALSE;
11426 namelen = strlen ((char *) p) + 1;
11428 section_len -= namelen + 4;
11430 while (section_len > 0)
11436 size = byte_get (p, 4);
11437 if (size > section_len)
11439 printf (_("ERROR: Bad subsection length (%d > %d)\n"),
11440 (int) size, (int) section_len);
11441 size = section_len;
11444 section_len -= size;
11445 end = p + size - 1;
11451 printf (_("File Attributes\n"));
11454 printf (_("Section Attributes:"));
11457 printf (_("Symbol Attributes:"));
11463 val = read_uleb128 (p, &j);
11467 printf (" %d", val);
11472 printf (_("Unknown tag: %d\n"), tag);
11473 public_section = FALSE;
11477 if (public_section)
11480 p = display_pub_attribute (p);
11482 else if (gnu_section)
11485 p = display_gnu_attribute (p,
11486 display_proc_gnu_attribute);
11490 /* ??? Do something sensible, like dump hex. */
11491 printf (_(" Unknown section contexts\n"));
11498 printf (_("Unknown format '%c'\n"), *p);
11506 process_arm_specific (FILE * file)
11508 return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
11509 display_arm_attribute, NULL);
11513 process_power_specific (FILE * file)
11515 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
11516 display_power_gnu_attribute);
11520 process_tic6x_specific (FILE * file)
11522 return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
11523 display_tic6x_attribute, NULL);
11526 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
11527 Print the Address, Access and Initial fields of an entry at VMA ADDR
11528 and return the VMA of the next entry. */
11531 print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
11534 print_vma (addr, LONG_HEX);
11536 if (addr < pltgot + 0xfff0)
11537 printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
11539 printf ("%10s", "");
11542 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
11547 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
11548 print_vma (entry, LONG_HEX);
11550 return addr + (is_32bit_elf ? 4 : 8);
11553 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
11554 PLTGOT. Print the Address and Initial fields of an entry at VMA
11555 ADDR and return the VMA of the next entry. */
11558 print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
11561 print_vma (addr, LONG_HEX);
11564 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
11569 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
11570 print_vma (entry, LONG_HEX);
11572 return addr + (is_32bit_elf ? 4 : 8);
11576 process_mips_specific (FILE * file)
11578 Elf_Internal_Dyn * entry;
11579 size_t liblist_offset = 0;
11580 size_t liblistno = 0;
11581 size_t conflictsno = 0;
11582 size_t options_offset = 0;
11583 size_t conflicts_offset = 0;
11584 size_t pltrelsz = 0;
11586 bfd_vma pltgot = 0;
11587 bfd_vma mips_pltgot = 0;
11588 bfd_vma jmprel = 0;
11589 bfd_vma local_gotno = 0;
11590 bfd_vma gotsym = 0;
11591 bfd_vma symtabno = 0;
11593 process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
11594 display_mips_gnu_attribute);
11596 /* We have a lot of special sections. Thanks SGI! */
11597 if (dynamic_section == NULL)
11598 /* No information available. */
11601 for (entry = dynamic_section; entry->d_tag != DT_NULL; ++entry)
11602 switch (entry->d_tag)
11604 case DT_MIPS_LIBLIST:
11606 = offset_from_vma (file, entry->d_un.d_val,
11607 liblistno * sizeof (Elf32_External_Lib));
11609 case DT_MIPS_LIBLISTNO:
11610 liblistno = entry->d_un.d_val;
11612 case DT_MIPS_OPTIONS:
11613 options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
11615 case DT_MIPS_CONFLICT:
11617 = offset_from_vma (file, entry->d_un.d_val,
11618 conflictsno * sizeof (Elf32_External_Conflict));
11620 case DT_MIPS_CONFLICTNO:
11621 conflictsno = entry->d_un.d_val;
11624 pltgot = entry->d_un.d_ptr;
11626 case DT_MIPS_LOCAL_GOTNO:
11627 local_gotno = entry->d_un.d_val;
11629 case DT_MIPS_GOTSYM:
11630 gotsym = entry->d_un.d_val;
11632 case DT_MIPS_SYMTABNO:
11633 symtabno = entry->d_un.d_val;
11635 case DT_MIPS_PLTGOT:
11636 mips_pltgot = entry->d_un.d_ptr;
11639 pltrel = entry->d_un.d_val;
11642 pltrelsz = entry->d_un.d_val;
11645 jmprel = entry->d_un.d_ptr;
11651 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
11653 Elf32_External_Lib * elib;
11656 elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
11658 sizeof (Elf32_External_Lib),
11662 printf (_("\nSection '.liblist' contains %lu entries:\n"),
11663 (unsigned long) liblistno);
11664 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
11667 for (cnt = 0; cnt < liblistno; ++cnt)
11674 liblist.l_name = BYTE_GET (elib[cnt].l_name);
11675 atime = BYTE_GET (elib[cnt].l_time_stamp);
11676 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
11677 liblist.l_version = BYTE_GET (elib[cnt].l_version);
11678 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
11680 tmp = gmtime (&atime);
11681 snprintf (timebuf, sizeof (timebuf),
11682 "%04u-%02u-%02uT%02u:%02u:%02u",
11683 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
11684 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
11686 printf ("%3lu: ", (unsigned long) cnt);
11687 if (VALID_DYNAMIC_NAME (liblist.l_name))
11688 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
11690 printf (_("<corrupt: %9ld>"), liblist.l_name);
11691 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
11692 liblist.l_version);
11694 if (liblist.l_flags == 0)
11698 static const struct
11705 { " EXACT_MATCH", LL_EXACT_MATCH },
11706 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
11707 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
11708 { " EXPORTS", LL_EXPORTS },
11709 { " DELAY_LOAD", LL_DELAY_LOAD },
11710 { " DELTA", LL_DELTA }
11712 int flags = liblist.l_flags;
11715 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
11716 if ((flags & l_flags_vals[fcnt].bit) != 0)
11718 fputs (l_flags_vals[fcnt].name, stdout);
11719 flags ^= l_flags_vals[fcnt].bit;
11722 printf (" %#x", (unsigned int) flags);
11732 if (options_offset != 0)
11734 Elf_External_Options * eopt;
11735 Elf_Internal_Shdr * sect = section_headers;
11736 Elf_Internal_Options * iopt;
11737 Elf_Internal_Options * option;
11741 /* Find the section header so that we get the size. */
11742 while (sect->sh_type != SHT_MIPS_OPTIONS)
11745 eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
11746 sect->sh_size, _("options"));
11749 iopt = (Elf_Internal_Options *)
11750 cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
11753 error (_("Out of memory\n"));
11760 while (offset < sect->sh_size)
11762 Elf_External_Options * eoption;
11764 eoption = (Elf_External_Options *) ((char *) eopt + offset);
11766 option->kind = BYTE_GET (eoption->kind);
11767 option->size = BYTE_GET (eoption->size);
11768 option->section = BYTE_GET (eoption->section);
11769 option->info = BYTE_GET (eoption->info);
11771 offset += option->size;
11777 printf (_("\nSection '%s' contains %d entries:\n"),
11778 SECTION_NAME (sect), cnt);
11786 switch (option->kind)
11789 /* This shouldn't happen. */
11790 printf (" NULL %d %lx", option->section, option->info);
11793 printf (" REGINFO ");
11794 if (elf_header.e_machine == EM_MIPS)
11797 Elf32_External_RegInfo * ereg;
11798 Elf32_RegInfo reginfo;
11800 ereg = (Elf32_External_RegInfo *) (option + 1);
11801 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
11802 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
11803 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
11804 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
11805 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
11806 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
11808 printf ("GPR %08lx GP 0x%lx\n",
11809 reginfo.ri_gprmask,
11810 (unsigned long) reginfo.ri_gp_value);
11811 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
11812 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
11813 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
11818 Elf64_External_RegInfo * ereg;
11819 Elf64_Internal_RegInfo reginfo;
11821 ereg = (Elf64_External_RegInfo *) (option + 1);
11822 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
11823 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
11824 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
11825 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
11826 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
11827 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
11829 printf ("GPR %08lx GP 0x",
11830 reginfo.ri_gprmask);
11831 printf_vma (reginfo.ri_gp_value);
11834 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
11835 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
11836 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
11840 case ODK_EXCEPTIONS:
11841 fputs (" EXCEPTIONS fpe_min(", stdout);
11842 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
11843 fputs (") fpe_max(", stdout);
11844 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
11845 fputs (")", stdout);
11847 if (option->info & OEX_PAGE0)
11848 fputs (" PAGE0", stdout);
11849 if (option->info & OEX_SMM)
11850 fputs (" SMM", stdout);
11851 if (option->info & OEX_FPDBUG)
11852 fputs (" FPDBUG", stdout);
11853 if (option->info & OEX_DISMISS)
11854 fputs (" DISMISS", stdout);
11857 fputs (" PAD ", stdout);
11858 if (option->info & OPAD_PREFIX)
11859 fputs (" PREFIX", stdout);
11860 if (option->info & OPAD_POSTFIX)
11861 fputs (" POSTFIX", stdout);
11862 if (option->info & OPAD_SYMBOL)
11863 fputs (" SYMBOL", stdout);
11866 fputs (" HWPATCH ", stdout);
11867 if (option->info & OHW_R4KEOP)
11868 fputs (" R4KEOP", stdout);
11869 if (option->info & OHW_R8KPFETCH)
11870 fputs (" R8KPFETCH", stdout);
11871 if (option->info & OHW_R5KEOP)
11872 fputs (" R5KEOP", stdout);
11873 if (option->info & OHW_R5KCVTL)
11874 fputs (" R5KCVTL", stdout);
11877 fputs (" FILL ", stdout);
11878 /* XXX Print content of info word? */
11881 fputs (" TAGS ", stdout);
11882 /* XXX Print content of info word? */
11885 fputs (" HWAND ", stdout);
11886 if (option->info & OHWA0_R4KEOP_CHECKED)
11887 fputs (" R4KEOP_CHECKED", stdout);
11888 if (option->info & OHWA0_R4KEOP_CLEAN)
11889 fputs (" R4KEOP_CLEAN", stdout);
11892 fputs (" HWOR ", stdout);
11893 if (option->info & OHWA0_R4KEOP_CHECKED)
11894 fputs (" R4KEOP_CHECKED", stdout);
11895 if (option->info & OHWA0_R4KEOP_CLEAN)
11896 fputs (" R4KEOP_CLEAN", stdout);
11899 printf (" GP_GROUP %#06lx self-contained %#06lx",
11900 option->info & OGP_GROUP,
11901 (option->info & OGP_SELF) >> 16);
11904 printf (" IDENT %#06lx self-contained %#06lx",
11905 option->info & OGP_GROUP,
11906 (option->info & OGP_SELF) >> 16);
11909 /* This shouldn't happen. */
11910 printf (" %3d ??? %d %lx",
11911 option->kind, option->section, option->info);
11915 len = sizeof (* eopt);
11916 while (len < option->size)
11917 if (((char *) option)[len] >= ' '
11918 && ((char *) option)[len] < 0x7f)
11919 printf ("%c", ((char *) option)[len++]);
11921 printf ("\\%03o", ((char *) option)[len++]);
11923 fputs ("\n", stdout);
11931 if (conflicts_offset != 0 && conflictsno != 0)
11933 Elf32_Conflict * iconf;
11936 if (dynamic_symbols == NULL)
11938 error (_("conflict list found without a dynamic symbol table\n"));
11942 iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
11945 error (_("Out of memory\n"));
11951 Elf32_External_Conflict * econf32;
11953 econf32 = (Elf32_External_Conflict *)
11954 get_data (NULL, file, conflicts_offset, conflictsno,
11955 sizeof (* econf32), _("conflict"));
11959 for (cnt = 0; cnt < conflictsno; ++cnt)
11960 iconf[cnt] = BYTE_GET (econf32[cnt]);
11966 Elf64_External_Conflict * econf64;
11968 econf64 = (Elf64_External_Conflict *)
11969 get_data (NULL, file, conflicts_offset, conflictsno,
11970 sizeof (* econf64), _("conflict"));
11974 for (cnt = 0; cnt < conflictsno; ++cnt)
11975 iconf[cnt] = BYTE_GET (econf64[cnt]);
11980 printf (_("\nSection '.conflict' contains %lu entries:\n"),
11981 (unsigned long) conflictsno);
11982 puts (_(" Num: Index Value Name"));
11984 for (cnt = 0; cnt < conflictsno; ++cnt)
11986 Elf_Internal_Sym * psym = & dynamic_symbols[iconf[cnt]];
11988 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
11989 print_vma (psym->st_value, FULL_HEX);
11991 if (VALID_DYNAMIC_NAME (psym->st_name))
11992 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
11994 printf (_("<corrupt: %14ld>"), psym->st_name);
12001 if (pltgot != 0 && local_gotno != 0)
12003 bfd_vma ent, local_end, global_end;
12005 unsigned char * data;
12009 addr_size = (is_32bit_elf ? 4 : 8);
12010 local_end = pltgot + local_gotno * addr_size;
12011 global_end = local_end + (symtabno - gotsym) * addr_size;
12013 offset = offset_from_vma (file, pltgot, global_end - pltgot);
12014 data = (unsigned char *) get_data (NULL, file, offset,
12015 global_end - pltgot, 1, _("GOT"));
12019 printf (_("\nPrimary GOT:\n"));
12020 printf (_(" Canonical gp value: "));
12021 print_vma (pltgot + 0x7ff0, LONG_HEX);
12024 printf (_(" Reserved entries:\n"));
12025 printf (_(" %*s %10s %*s Purpose\n"),
12026 addr_size * 2, _("Address"), _("Access"),
12027 addr_size * 2, _("Initial"));
12028 ent = print_mips_got_entry (data, pltgot, ent);
12029 printf (_(" Lazy resolver\n"));
12031 && (byte_get (data + ent - pltgot, addr_size)
12032 >> (addr_size * 8 - 1)) != 0)
12034 ent = print_mips_got_entry (data, pltgot, ent);
12035 printf (_(" Module pointer (GNU extension)\n"));
12039 if (ent < local_end)
12041 printf (_(" Local entries:\n"));
12042 printf (" %*s %10s %*s\n",
12043 addr_size * 2, _("Address"), _("Access"),
12044 addr_size * 2, _("Initial"));
12045 while (ent < local_end)
12047 ent = print_mips_got_entry (data, pltgot, ent);
12053 if (gotsym < symtabno)
12057 printf (_(" Global entries:\n"));
12058 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
12059 addr_size * 2, _("Address"), _("Access"),
12060 addr_size * 2, _("Initial"),
12061 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
12062 sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
12063 for (i = gotsym; i < symtabno; i++)
12065 Elf_Internal_Sym * psym;
12067 psym = dynamic_symbols + i;
12068 ent = print_mips_got_entry (data, pltgot, ent);
12070 print_vma (psym->st_value, LONG_HEX);
12071 printf (" %-7s %3s ",
12072 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
12073 get_symbol_index_type (psym->st_shndx));
12074 if (VALID_DYNAMIC_NAME (psym->st_name))
12075 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
12077 printf (_("<corrupt: %14ld>"), psym->st_name);
12087 if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
12090 size_t offset, rel_offset;
12091 unsigned long count, i;
12092 unsigned char * data;
12093 int addr_size, sym_width;
12094 Elf_Internal_Rela * rels;
12096 rel_offset = offset_from_vma (file, jmprel, pltrelsz);
12097 if (pltrel == DT_RELA)
12099 if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
12104 if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
12109 addr_size = (is_32bit_elf ? 4 : 8);
12110 end = mips_pltgot + (2 + count) * addr_size;
12112 offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
12113 data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
12118 printf (_("\nPLT GOT:\n\n"));
12119 printf (_(" Reserved entries:\n"));
12120 printf (_(" %*s %*s Purpose\n"),
12121 addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
12122 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
12123 printf (_(" PLT lazy resolver\n"));
12124 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
12125 printf (_(" Module pointer\n"));
12128 printf (_(" Entries:\n"));
12129 printf (" %*s %*s %*s %-7s %3s %s\n",
12130 addr_size * 2, _("Address"),
12131 addr_size * 2, _("Initial"),
12132 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
12133 sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
12134 for (i = 0; i < count; i++)
12136 Elf_Internal_Sym * psym;
12138 psym = dynamic_symbols + get_reloc_symindex (rels[i].r_info);
12139 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
12141 print_vma (psym->st_value, LONG_HEX);
12142 printf (" %-7s %3s ",
12143 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
12144 get_symbol_index_type (psym->st_shndx));
12145 if (VALID_DYNAMIC_NAME (psym->st_name))
12146 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
12148 printf (_("<corrupt: %14ld>"), psym->st_name);
12162 process_gnu_liblist (FILE * file)
12164 Elf_Internal_Shdr * section;
12165 Elf_Internal_Shdr * string_sec;
12166 Elf32_External_Lib * elib;
12168 size_t strtab_size;
12175 for (i = 0, section = section_headers;
12176 i < elf_header.e_shnum;
12179 switch (section->sh_type)
12181 case SHT_GNU_LIBLIST:
12182 if (section->sh_link >= elf_header.e_shnum)
12185 elib = (Elf32_External_Lib *)
12186 get_data (NULL, file, section->sh_offset, 1, section->sh_size,
12191 string_sec = section_headers + section->sh_link;
12193 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
12194 string_sec->sh_size,
12195 _("liblist string table"));
12197 || section->sh_entsize != sizeof (Elf32_External_Lib))
12203 strtab_size = string_sec->sh_size;
12205 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
12206 SECTION_NAME (section),
12207 (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
12209 puts (_(" Library Time Stamp Checksum Version Flags"));
12211 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
12219 liblist.l_name = BYTE_GET (elib[cnt].l_name);
12220 atime = BYTE_GET (elib[cnt].l_time_stamp);
12221 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
12222 liblist.l_version = BYTE_GET (elib[cnt].l_version);
12223 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
12225 tmp = gmtime (&atime);
12226 snprintf (timebuf, sizeof (timebuf),
12227 "%04u-%02u-%02uT%02u:%02u:%02u",
12228 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
12229 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
12231 printf ("%3lu: ", (unsigned long) cnt);
12233 printf ("%-20s", liblist.l_name < strtab_size
12234 ? strtab + liblist.l_name : _("<corrupt>"));
12236 printf ("%-20.20s", liblist.l_name < strtab_size
12237 ? strtab + liblist.l_name : _("<corrupt>"));
12238 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
12239 liblist.l_version, liblist.l_flags);
12250 static const char *
12251 get_note_type (unsigned e_type)
12253 static char buff[64];
12255 if (elf_header.e_type == ET_CORE)
12259 return _("NT_AUXV (auxiliary vector)");
12261 return _("NT_PRSTATUS (prstatus structure)");
12263 return _("NT_FPREGSET (floating point registers)");
12265 return _("NT_PRPSINFO (prpsinfo structure)");
12266 case NT_TASKSTRUCT:
12267 return _("NT_TASKSTRUCT (task structure)");
12269 return _("NT_PRXFPREG (user_xfpregs structure)");
12271 return _("NT_PPC_VMX (ppc Altivec registers)");
12273 return _("NT_PPC_VSX (ppc VSX registers)");
12274 case NT_X86_XSTATE:
12275 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
12276 case NT_S390_HIGH_GPRS:
12277 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
12278 case NT_S390_TIMER:
12279 return _("NT_S390_TIMER (s390 timer register)");
12280 case NT_S390_TODCMP:
12281 return _("NT_S390_TODCMP (s390 TOD comparator register)");
12282 case NT_S390_TODPREG:
12283 return _("NT_S390_TODPREG (s390 TOD programmable register)");
12285 return _("NT_S390_CTRS (s390 control registers)");
12286 case NT_S390_PREFIX:
12287 return _("NT_S390_PREFIX (s390 prefix register)");
12289 return _("NT_ARM_VFP (arm VFP registers)");
12291 return _("NT_PSTATUS (pstatus structure)");
12293 return _("NT_FPREGS (floating point registers)");
12295 return _("NT_PSINFO (psinfo structure)");
12297 return _("NT_LWPSTATUS (lwpstatus_t structure)");
12299 return _("NT_LWPSINFO (lwpsinfo_t structure)");
12300 case NT_WIN32PSTATUS:
12301 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
12309 return _("NT_VERSION (version)");
12311 return _("NT_ARCH (architecture)");
12316 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
12320 static const char *
12321 get_gnu_elf_note_type (unsigned e_type)
12323 static char buff[64];
12327 case NT_GNU_ABI_TAG:
12328 return _("NT_GNU_ABI_TAG (ABI version tag)");
12330 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
12331 case NT_GNU_BUILD_ID:
12332 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
12333 case NT_GNU_GOLD_VERSION:
12334 return _("NT_GNU_GOLD_VERSION (gold version)");
12339 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
12344 print_gnu_note (Elf_Internal_Note *pnote)
12346 switch (pnote->type)
12348 case NT_GNU_BUILD_ID:
12352 printf (_(" Build ID: "));
12353 for (i = 0; i < pnote->descsz; ++i)
12354 printf ("%02x", pnote->descdata[i] & 0xff);
12359 case NT_GNU_ABI_TAG:
12361 unsigned long os, major, minor, subminor;
12362 const char *osname;
12364 os = byte_get ((unsigned char *) pnote->descdata, 4);
12365 major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
12366 minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
12367 subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
12371 case GNU_ABI_TAG_LINUX:
12374 case GNU_ABI_TAG_HURD:
12377 case GNU_ABI_TAG_SOLARIS:
12378 osname = "Solaris";
12380 case GNU_ABI_TAG_FREEBSD:
12381 osname = "FreeBSD";
12383 case GNU_ABI_TAG_NETBSD:
12387 osname = "Unknown";
12391 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname,
12392 major, minor, subminor);
12400 static const char *
12401 get_netbsd_elfcore_note_type (unsigned e_type)
12403 static char buff[64];
12405 if (e_type == NT_NETBSDCORE_PROCINFO)
12407 /* NetBSD core "procinfo" structure. */
12408 return _("NetBSD procinfo structure");
12411 /* As of Jan 2002 there are no other machine-independent notes
12412 defined for NetBSD core files. If the note type is less
12413 than the start of the machine-dependent note types, we don't
12416 if (e_type < NT_NETBSDCORE_FIRSTMACH)
12418 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
12422 switch (elf_header.e_machine)
12424 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
12425 and PT_GETFPREGS == mach+2. */
12430 case EM_SPARC32PLUS:
12434 case NT_NETBSDCORE_FIRSTMACH + 0:
12435 return _("PT_GETREGS (reg structure)");
12436 case NT_NETBSDCORE_FIRSTMACH + 2:
12437 return _("PT_GETFPREGS (fpreg structure)");
12443 /* On all other arch's, PT_GETREGS == mach+1 and
12444 PT_GETFPREGS == mach+3. */
12448 case NT_NETBSDCORE_FIRSTMACH + 1:
12449 return _("PT_GETREGS (reg structure)");
12450 case NT_NETBSDCORE_FIRSTMACH + 3:
12451 return _("PT_GETFPREGS (fpreg structure)");
12457 snprintf (buff, sizeof (buff), _("PT_FIRSTMACH+%d"),
12458 e_type - NT_NETBSDCORE_FIRSTMACH);
12462 static const char *
12463 get_stapsdt_note_type (unsigned e_type)
12465 static char buff[64];
12470 return _("NT_STAPSDT (SystemTap probe descriptors)");
12476 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
12481 print_stapsdt_note (Elf_Internal_Note *pnote)
12483 int addr_size = is_32bit_elf ? 4 : 8;
12484 char *data = pnote->descdata;
12485 char *data_end = pnote->descdata + pnote->descsz;
12486 bfd_vma pc, base_addr, semaphore;
12487 char *provider, *probe, *arg_fmt;
12489 pc = byte_get ((unsigned char *) data, addr_size);
12491 base_addr = byte_get ((unsigned char *) data, addr_size);
12493 semaphore = byte_get ((unsigned char *) data, addr_size);
12497 data += strlen (data) + 1;
12499 data += strlen (data) + 1;
12501 data += strlen (data) + 1;
12503 printf (_(" Provider: %s\n"), provider);
12504 printf (_(" Name: %s\n"), probe);
12505 printf (_(" Location: "));
12506 print_vma (pc, FULL_HEX);
12507 printf (_(", Base: "));
12508 print_vma (base_addr, FULL_HEX);
12509 printf (_(", Semaphore: "));
12510 print_vma (semaphore, FULL_HEX);
12512 printf (_(" Arguments: %s\n"), arg_fmt);
12514 return data == data_end;
12517 static const char *
12518 get_ia64_vms_note_type (unsigned e_type)
12520 static char buff[64];
12525 return _("NT_VMS_MHD (module header)");
12527 return _("NT_VMS_LNM (language name)");
12529 return _("NT_VMS_SRC (source files)");
12531 return _("NT_VMS_TITLE");
12533 return _("NT_VMS_EIDC (consistency check)");
12534 case NT_VMS_FPMODE:
12535 return _("NT_VMS_FPMODE (FP mode)");
12536 case NT_VMS_LINKTIME:
12537 return _("NT_VMS_LINKTIME");
12538 case NT_VMS_IMGNAM:
12539 return _("NT_VMS_IMGNAM (image name)");
12541 return _("NT_VMS_IMGID (image id)");
12542 case NT_VMS_LINKID:
12543 return _("NT_VMS_LINKID (link id)");
12544 case NT_VMS_IMGBID:
12545 return _("NT_VMS_IMGBID (build id)");
12546 case NT_VMS_GSTNAM:
12547 return _("NT_VMS_GSTNAM (sym table name)");
12548 case NT_VMS_ORIG_DYN:
12549 return _("NT_VMS_ORIG_DYN");
12550 case NT_VMS_PATCHTIME:
12551 return _("NT_VMS_PATCHTIME");
12553 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
12559 print_ia64_vms_note (Elf_Internal_Note * pnote)
12561 switch (pnote->type)
12564 if (pnote->descsz > 36)
12566 size_t l = strlen (pnote->descdata + 34);
12567 printf (_(" Creation date : %.17s\n"), pnote->descdata);
12568 printf (_(" Last patch date: %.17s\n"), pnote->descdata + 17);
12569 printf (_(" Module name : %s\n"), pnote->descdata + 34);
12570 printf (_(" Module version : %s\n"), pnote->descdata + 34 + l + 1);
12573 printf (_(" Invalid size\n"));
12576 printf (_(" Language: %s\n"), pnote->descdata);
12579 case NT_VMS_FPMODE:
12580 printf (_(" FP mode: 0x%016" BFD_VMA_FMT "x\n"),
12581 (bfd_vma)byte_get ((unsigned char *)pnote->descdata, 8));
12583 case NT_VMS_LINKTIME:
12584 printf (_(" Link time: "));
12586 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
12589 case NT_VMS_PATCHTIME:
12590 printf (_(" Patch time: "));
12592 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
12595 case NT_VMS_ORIG_DYN:
12596 printf (_(" Major id: %u, minor id: %u\n"),
12597 (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
12598 (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
12599 printf (_(" Manip date : "));
12601 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
12603 " Link flags : 0x%016" BFD_VMA_FMT "x\n"),
12604 (bfd_vma)byte_get ((unsigned char *)pnote->descdata + 16, 8));
12605 printf (_(" Header flags: 0x%08x\n"),
12606 (unsigned)byte_get ((unsigned char *)pnote->descdata + 24, 4));
12607 printf (_(" Image id : %s\n"), pnote->descdata + 32);
12610 case NT_VMS_IMGNAM:
12611 printf (_(" Image name: %s\n"), pnote->descdata);
12613 case NT_VMS_GSTNAM:
12614 printf (_(" Global symbol table name: %s\n"), pnote->descdata);
12617 printf (_(" Image id: %s\n"), pnote->descdata);
12619 case NT_VMS_LINKID:
12620 printf (_(" Linker id: %s\n"), pnote->descdata);
12628 /* Note that by the ELF standard, the name field is already null byte
12629 terminated, and namesz includes the terminating null byte.
12630 I.E. the value of namesz for the name "FSF" is 4.
12632 If the value of namesz is zero, there is no name present. */
12634 process_note (Elf_Internal_Note * pnote)
12636 const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
12639 if (pnote->namesz == 0)
12640 /* If there is no note name, then use the default set of
12641 note type strings. */
12642 nt = get_note_type (pnote->type);
12644 else if (const_strneq (pnote->namedata, "GNU"))
12645 /* GNU-specific object file notes. */
12646 nt = get_gnu_elf_note_type (pnote->type);
12648 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
12649 /* NetBSD-specific core file notes. */
12650 nt = get_netbsd_elfcore_note_type (pnote->type);
12652 else if (strneq (pnote->namedata, "SPU/", 4))
12654 /* SPU-specific core file notes. */
12655 nt = pnote->namedata + 4;
12659 else if (const_strneq (pnote->namedata, "IPF/VMS"))
12660 /* VMS/ia64-specific file notes. */
12661 nt = get_ia64_vms_note_type (pnote->type);
12663 else if (const_strneq (pnote->namedata, "stapsdt"))
12664 nt = get_stapsdt_note_type (pnote->type);
12667 /* Don't recognize this note name; just use the default set of
12668 note type strings. */
12669 nt = get_note_type (pnote->type);
12671 printf (" %-20s 0x%08lx\t%s\n", name, pnote->descsz, nt);
12673 if (const_strneq (pnote->namedata, "IPF/VMS"))
12674 return print_ia64_vms_note (pnote);
12675 else if (const_strneq (pnote->namedata, "GNU"))
12676 return print_gnu_note (pnote);
12677 else if (const_strneq (pnote->namedata, "stapsdt"))
12678 return print_stapsdt_note (pnote);
12685 process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
12687 Elf_External_Note * pnotes;
12688 Elf_External_Note * external;
12694 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
12696 if (pnotes == NULL)
12701 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
12702 (unsigned long) offset, (unsigned long) length);
12703 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
12705 while (external < (Elf_External_Note *) ((char *) pnotes + length))
12707 Elf_External_Note * next;
12708 Elf_Internal_Note inote;
12709 char * temp = NULL;
12711 if (!is_ia64_vms ())
12713 inote.type = BYTE_GET (external->type);
12714 inote.namesz = BYTE_GET (external->namesz);
12715 inote.namedata = external->name;
12716 inote.descsz = BYTE_GET (external->descsz);
12717 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
12718 inote.descpos = offset + (inote.descdata - (char *) pnotes);
12720 next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
12724 Elf64_External_VMS_Note *vms_external;
12726 vms_external = (Elf64_External_VMS_Note *)external;
12727 inote.type = BYTE_GET (vms_external->type);
12728 inote.namesz = BYTE_GET (vms_external->namesz);
12729 inote.namedata = vms_external->name;
12730 inote.descsz = BYTE_GET (vms_external->descsz);
12731 inote.descdata = inote.namedata + align_power (inote.namesz, 3);
12732 inote.descpos = offset + (inote.descdata - (char *) pnotes);
12734 next = (Elf_External_Note *)
12735 (inote.descdata + align_power (inote.descsz, 3));
12738 if ( ((char *) next > ((char *) pnotes) + length)
12739 || ((char *) next < (char *) pnotes))
12741 warn (_("corrupt note found at offset %lx into core notes\n"),
12742 (unsigned long) ((char *) external - (char *) pnotes));
12743 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
12744 inote.type, inote.namesz, inote.descsz);
12750 /* Prevent out-of-bounds indexing. */
12751 if (inote.namedata + inote.namesz >= (char *) pnotes + length
12752 || inote.namedata + inote.namesz < inote.namedata)
12754 warn (_("corrupt note found at offset %lx into core notes\n"),
12755 (unsigned long) ((char *) external - (char *) pnotes));
12756 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
12757 inote.type, inote.namesz, inote.descsz);
12761 /* Verify that name is null terminated. It appears that at least
12762 one version of Linux (RedHat 6.0) generates corefiles that don't
12763 comply with the ELF spec by failing to include the null byte in
12765 if (inote.namedata[inote.namesz] != '\0')
12767 temp = (char *) malloc (inote.namesz + 1);
12771 error (_("Out of memory\n"));
12776 strncpy (temp, inote.namedata, inote.namesz);
12777 temp[inote.namesz] = 0;
12779 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
12780 inote.namedata = temp;
12783 res &= process_note (& inote);
12798 process_corefile_note_segments (FILE * file)
12800 Elf_Internal_Phdr * segment;
12804 if (! get_program_headers (file))
12807 for (i = 0, segment = program_headers;
12808 i < elf_header.e_phnum;
12811 if (segment->p_type == PT_NOTE)
12812 res &= process_corefile_note_segment (file,
12813 (bfd_vma) segment->p_offset,
12814 (bfd_vma) segment->p_filesz);
12821 process_note_sections (FILE * file)
12823 Elf_Internal_Shdr * section;
12827 for (i = 0, section = section_headers;
12828 i < elf_header.e_shnum;
12830 if (section->sh_type == SHT_NOTE)
12831 res &= process_corefile_note_segment (file,
12832 (bfd_vma) section->sh_offset,
12833 (bfd_vma) section->sh_size);
12839 process_notes (FILE * file)
12841 /* If we have not been asked to display the notes then do nothing. */
12845 if (elf_header.e_type != ET_CORE)
12846 return process_note_sections (file);
12848 /* No program headers means no NOTE segment. */
12849 if (elf_header.e_phnum > 0)
12850 return process_corefile_note_segments (file);
12852 printf (_("No note segments present in the core file.\n"));
12857 process_arch_specific (FILE * file)
12862 switch (elf_header.e_machine)
12865 return process_arm_specific (file);
12867 case EM_MIPS_RS3_LE:
12868 return process_mips_specific (file);
12871 return process_power_specific (file);
12874 return process_tic6x_specific (file);
12883 get_file_header (FILE * file)
12885 /* Read in the identity array. */
12886 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
12889 /* Determine how to read the rest of the header. */
12890 switch (elf_header.e_ident[EI_DATA])
12892 default: /* fall through */
12893 case ELFDATANONE: /* fall through */
12895 byte_get = byte_get_little_endian;
12896 byte_put = byte_put_little_endian;
12899 byte_get = byte_get_big_endian;
12900 byte_put = byte_put_big_endian;
12904 /* For now we only support 32 bit and 64 bit ELF files. */
12905 is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
12907 /* Read in the rest of the header. */
12910 Elf32_External_Ehdr ehdr32;
12912 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
12915 elf_header.e_type = BYTE_GET (ehdr32.e_type);
12916 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
12917 elf_header.e_version = BYTE_GET (ehdr32.e_version);
12918 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
12919 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
12920 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
12921 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
12922 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
12923 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
12924 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
12925 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
12926 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
12927 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
12931 Elf64_External_Ehdr ehdr64;
12933 /* If we have been compiled with sizeof (bfd_vma) == 4, then
12934 we will not be able to cope with the 64bit data found in
12935 64 ELF files. Detect this now and abort before we start
12936 overwriting things. */
12937 if (sizeof (bfd_vma) < 8)
12939 error (_("This instance of readelf has been built without support for a\n\
12940 64 bit data type and so it cannot read 64 bit ELF files.\n"));
12944 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
12947 elf_header.e_type = BYTE_GET (ehdr64.e_type);
12948 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
12949 elf_header.e_version = BYTE_GET (ehdr64.e_version);
12950 elf_header.e_entry = BYTE_GET (ehdr64.e_entry);
12951 elf_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
12952 elf_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
12953 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
12954 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
12955 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
12956 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
12957 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
12958 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
12959 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
12962 if (elf_header.e_shoff)
12964 /* There may be some extensions in the first section header. Don't
12965 bomb if we can't read it. */
12967 get_32bit_section_headers (file, 1);
12969 get_64bit_section_headers (file, 1);
12975 /* Process one ELF object file according to the command line options.
12976 This file may actually be stored in an archive. The file is
12977 positioned at the start of the ELF object. */
12980 process_object (char * file_name, FILE * file)
12984 if (! get_file_header (file))
12986 error (_("%s: Failed to read file header\n"), file_name);
12990 /* Initialise per file variables. */
12991 for (i = ARRAY_SIZE (version_info); i--;)
12992 version_info[i] = 0;
12994 for (i = ARRAY_SIZE (dynamic_info); i--;)
12995 dynamic_info[i] = 0;
12996 dynamic_info_DT_GNU_HASH = 0;
12998 /* Process the file. */
13000 printf (_("\nFile: %s\n"), file_name);
13002 /* Initialise the dump_sects array from the cmdline_dump_sects array.
13003 Note we do this even if cmdline_dump_sects is empty because we
13004 must make sure that the dump_sets array is zeroed out before each
13005 object file is processed. */
13006 if (num_dump_sects > num_cmdline_dump_sects)
13007 memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
13009 if (num_cmdline_dump_sects > 0)
13011 if (num_dump_sects == 0)
13012 /* A sneaky way of allocating the dump_sects array. */
13013 request_dump_bynumber (num_cmdline_dump_sects, 0);
13015 assert (num_dump_sects >= num_cmdline_dump_sects);
13016 memcpy (dump_sects, cmdline_dump_sects,
13017 num_cmdline_dump_sects * sizeof (* dump_sects));
13020 if (! process_file_header ())
13023 if (! process_section_headers (file))
13025 /* Without loaded section headers we cannot process lots of
13027 do_unwind = do_version = do_dump = do_arch = 0;
13029 if (! do_using_dynamic)
13030 do_syms = do_dyn_syms = do_reloc = 0;
13033 if (! process_section_groups (file))
13035 /* Without loaded section groups we cannot process unwind. */
13039 if (process_program_headers (file))
13040 process_dynamic_section (file);
13042 process_relocs (file);
13044 process_unwind (file);
13046 process_symbol_table (file);
13048 process_syminfo (file);
13050 process_version_sections (file);
13052 process_section_contents (file);
13054 process_notes (file);
13056 process_gnu_liblist (file);
13058 process_arch_specific (file);
13060 if (program_headers)
13062 free (program_headers);
13063 program_headers = NULL;
13066 if (section_headers)
13068 free (section_headers);
13069 section_headers = NULL;
13074 free (string_table);
13075 string_table = NULL;
13076 string_table_length = 0;
13079 if (dynamic_strings)
13081 free (dynamic_strings);
13082 dynamic_strings = NULL;
13083 dynamic_strings_length = 0;
13086 if (dynamic_symbols)
13088 free (dynamic_symbols);
13089 dynamic_symbols = NULL;
13090 num_dynamic_syms = 0;
13093 if (dynamic_syminfo)
13095 free (dynamic_syminfo);
13096 dynamic_syminfo = NULL;
13099 if (dynamic_section)
13101 free (dynamic_section);
13102 dynamic_section = NULL;
13105 if (section_headers_groups)
13107 free (section_headers_groups);
13108 section_headers_groups = NULL;
13111 if (section_groups)
13113 struct group_list * g;
13114 struct group_list * next;
13116 for (i = 0; i < group_count; i++)
13118 for (g = section_groups [i].root; g != NULL; g = next)
13125 free (section_groups);
13126 section_groups = NULL;
13129 free_debug_memory ();
13134 /* Process an ELF archive.
13135 On entry the file is positioned just after the ARMAG string. */
13138 process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
13140 struct archive_info arch;
13141 struct archive_info nested_arch;
13147 /* The ARCH structure is used to hold information about this archive. */
13148 arch.file_name = NULL;
13150 arch.index_array = NULL;
13151 arch.sym_table = NULL;
13152 arch.longnames = NULL;
13154 /* The NESTED_ARCH structure is used as a single-item cache of information
13155 about a nested archive (when members of a thin archive reside within
13156 another regular archive file). */
13157 nested_arch.file_name = NULL;
13158 nested_arch.file = NULL;
13159 nested_arch.index_array = NULL;
13160 nested_arch.sym_table = NULL;
13161 nested_arch.longnames = NULL;
13163 if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
13169 if (do_archive_index)
13171 if (arch.sym_table == NULL)
13172 error (_("%s: unable to dump the index as none was found\n"), file_name);
13176 unsigned long current_pos;
13178 printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
13179 file_name, arch.index_num, arch.sym_size);
13180 current_pos = ftell (file);
13182 for (i = l = 0; i < arch.index_num; i++)
13184 if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
13186 char * member_name;
13188 member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
13190 if (member_name != NULL)
13192 char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
13194 if (qualified_name != NULL)
13196 printf (_("Binary %s contains:\n"), qualified_name);
13197 free (qualified_name);
13202 if (l >= arch.sym_size)
13204 error (_("%s: end of the symbol table reached before the end of the index\n"),
13208 printf ("\t%s\n", arch.sym_table + l);
13209 l += strlen (arch.sym_table + l) + 1;
13214 if (l < arch.sym_size)
13215 error (_("%s: symbols remain in the index symbol table, but without corresponding entries in the index table\n"),
13218 if (fseek (file, current_pos, SEEK_SET) != 0)
13220 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
13226 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
13227 && !do_segments && !do_header && !do_dump && !do_version
13228 && !do_histogram && !do_debugging && !do_arch && !do_notes
13229 && !do_section_groups && !do_dyn_syms)
13231 ret = 0; /* Archive index only. */
13242 char * qualified_name;
13244 /* Read the next archive header. */
13245 if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
13247 error (_("%s: failed to seek to next archive header\n"), file_name);
13250 got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
13251 if (got != sizeof arch.arhdr)
13255 error (_("%s: failed to read archive header\n"), file_name);
13259 if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
13261 error (_("%s: did not find a valid archive header\n"), arch.file_name);
13266 arch.next_arhdr_offset += sizeof arch.arhdr;
13268 archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
13269 if (archive_file_size & 01)
13270 ++archive_file_size;
13272 name = get_archive_member_name (&arch, &nested_arch);
13275 error (_("%s: bad archive file name\n"), file_name);
13279 namelen = strlen (name);
13281 qualified_name = make_qualified_name (&arch, &nested_arch, name);
13282 if (qualified_name == NULL)
13284 error (_("%s: bad archive file name\n"), file_name);
13289 if (is_thin_archive && arch.nested_member_origin == 0)
13291 /* This is a proxy for an external member of a thin archive. */
13292 FILE * member_file;
13293 char * member_file_name = adjust_relative_path (file_name, name, namelen);
13294 if (member_file_name == NULL)
13300 member_file = fopen (member_file_name, "rb");
13301 if (member_file == NULL)
13303 error (_("Input file '%s' is not readable.\n"), member_file_name);
13304 free (member_file_name);
13309 archive_file_offset = arch.nested_member_origin;
13311 ret |= process_object (qualified_name, member_file);
13313 fclose (member_file);
13314 free (member_file_name);
13316 else if (is_thin_archive)
13318 /* This is a proxy for a member of a nested archive. */
13319 archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
13321 /* The nested archive file will have been opened and setup by
13322 get_archive_member_name. */
13323 if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
13325 error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
13330 ret |= process_object (qualified_name, nested_arch.file);
13334 archive_file_offset = arch.next_arhdr_offset;
13335 arch.next_arhdr_offset += archive_file_size;
13337 ret |= process_object (qualified_name, file);
13340 if (dump_sects != NULL)
13344 num_dump_sects = 0;
13347 free (qualified_name);
13351 if (nested_arch.file != NULL)
13352 fclose (nested_arch.file);
13353 release_archive (&nested_arch);
13354 release_archive (&arch);
13360 process_file (char * file_name)
13363 struct stat statbuf;
13364 char armag[SARMAG];
13367 if (stat (file_name, &statbuf) < 0)
13369 if (errno == ENOENT)
13370 error (_("'%s': No such file\n"), file_name);
13372 error (_("Could not locate '%s'. System error message: %s\n"),
13373 file_name, strerror (errno));
13377 if (! S_ISREG (statbuf.st_mode))
13379 error (_("'%s' is not an ordinary file\n"), file_name);
13383 file = fopen (file_name, "rb");
13386 error (_("Input file '%s' is not readable.\n"), file_name);
13390 if (fread (armag, SARMAG, 1, file) != 1)
13392 error (_("%s: Failed to read file's magic number\n"), file_name);
13397 if (memcmp (armag, ARMAG, SARMAG) == 0)
13398 ret = process_archive (file_name, file, FALSE);
13399 else if (memcmp (armag, ARMAGT, SARMAG) == 0)
13400 ret = process_archive (file_name, file, TRUE);
13403 if (do_archive_index)
13404 error (_("File %s is not an archive so its index cannot be displayed.\n"),
13408 archive_file_size = archive_file_offset = 0;
13409 ret = process_object (file_name, file);
13417 #ifdef SUPPORT_DISASSEMBLY
13418 /* Needed by the i386 disassembler. For extra credit, someone could
13419 fix this so that we insert symbolic addresses here, esp for GOT/PLT
13423 print_address (unsigned int addr, FILE * outfile)
13425 fprintf (outfile,"0x%8.8x", addr);
13428 /* Needed by the i386 disassembler. */
13430 db_task_printsym (unsigned int addr)
13432 print_address (addr, stderr);
13437 main (int argc, char ** argv)
13441 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
13442 setlocale (LC_MESSAGES, "");
13444 #if defined (HAVE_SETLOCALE)
13445 setlocale (LC_CTYPE, "");
13447 bindtextdomain (PACKAGE, LOCALEDIR);
13448 textdomain (PACKAGE);
13450 expandargv (&argc, &argv);
13452 parse_args (argc, argv);
13454 if (num_dump_sects > 0)
13456 /* Make a copy of the dump_sects array. */
13457 cmdline_dump_sects = (dump_type *)
13458 malloc (num_dump_sects * sizeof (* dump_sects));
13459 if (cmdline_dump_sects == NULL)
13460 error (_("Out of memory allocating dump request table.\n"));
13463 memcpy (cmdline_dump_sects, dump_sects,
13464 num_dump_sects * sizeof (* dump_sects));
13465 num_cmdline_dump_sects = num_dump_sects;
13469 if (optind < (argc - 1))
13473 while (optind < argc)
13474 err |= process_file (argv[optind++]);
13476 if (dump_sects != NULL)
13478 if (cmdline_dump_sects != NULL)
13479 free (cmdline_dump_sects);