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_LINUX: return "UNIX - Linux";
2616 case ELFOSABI_HURD: return "GNU/Hurd";
2617 case ELFOSABI_SOLARIS: return "UNIX - Solaris";
2618 case ELFOSABI_AIX: return "UNIX - AIX";
2619 case ELFOSABI_IRIX: return "UNIX - IRIX";
2620 case ELFOSABI_FREEBSD: return "UNIX - FreeBSD";
2621 case ELFOSABI_TRU64: return "UNIX - TRU64";
2622 case ELFOSABI_MODESTO: return "Novell - Modesto";
2623 case ELFOSABI_OPENBSD: return "UNIX - OpenBSD";
2624 case ELFOSABI_OPENVMS: return "VMS - OpenVMS";
2625 case ELFOSABI_NSK: return "HP - Non-Stop Kernel";
2626 case ELFOSABI_AROS: return "AROS";
2627 case ELFOSABI_FENIXOS: return "FenixOS";
2630 switch (elf_header.e_machine)
2635 case ELFOSABI_ARM: return "ARM";
2645 case ELFOSABI_STANDALONE: return _("Standalone App");
2654 case ELFOSABI_C6000_ELFABI: return _("Bare-metal C6000");
2655 case ELFOSABI_C6000_LINUX: return "Linux C6000";
2664 snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
2670 get_arm_segment_type (unsigned long type)
2684 get_mips_segment_type (unsigned long type)
2688 case PT_MIPS_REGINFO:
2690 case PT_MIPS_RTPROC:
2692 case PT_MIPS_OPTIONS:
2702 get_parisc_segment_type (unsigned long type)
2706 case PT_HP_TLS: return "HP_TLS";
2707 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
2708 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
2709 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
2710 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
2711 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
2712 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
2713 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
2714 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
2715 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
2716 case PT_HP_PARALLEL: return "HP_PARALLEL";
2717 case PT_HP_FASTBIND: return "HP_FASTBIND";
2718 case PT_HP_OPT_ANNOT: return "HP_OPT_ANNOT";
2719 case PT_HP_HSL_ANNOT: return "HP_HSL_ANNOT";
2720 case PT_HP_STACK: return "HP_STACK";
2721 case PT_HP_CORE_UTSNAME: return "HP_CORE_UTSNAME";
2722 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
2723 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
2724 case PT_PARISC_WEAKORDER: return "PARISC_WEAKORDER";
2733 get_ia64_segment_type (unsigned long type)
2737 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
2738 case PT_IA_64_UNWIND: return "IA_64_UNWIND";
2739 case PT_HP_TLS: return "HP_TLS";
2740 case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
2741 case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
2742 case PT_IA_64_HP_STACK: return "HP_STACK";
2751 get_tic6x_segment_type (unsigned long type)
2755 case PT_C6000_PHATTR: return "C6000_PHATTR";
2764 get_segment_type (unsigned long p_type)
2766 static char buff[32];
2770 case PT_NULL: return "NULL";
2771 case PT_LOAD: return "LOAD";
2772 case PT_DYNAMIC: return "DYNAMIC";
2773 case PT_INTERP: return "INTERP";
2774 case PT_NOTE: return "NOTE";
2775 case PT_SHLIB: return "SHLIB";
2776 case PT_PHDR: return "PHDR";
2777 case PT_TLS: return "TLS";
2779 case PT_GNU_EH_FRAME:
2780 return "GNU_EH_FRAME";
2781 case PT_GNU_STACK: return "GNU_STACK";
2782 case PT_GNU_RELRO: return "GNU_RELRO";
2785 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
2787 const char * result;
2789 switch (elf_header.e_machine)
2792 result = get_arm_segment_type (p_type);
2795 case EM_MIPS_RS3_LE:
2796 result = get_mips_segment_type (p_type);
2799 result = get_parisc_segment_type (p_type);
2802 result = get_ia64_segment_type (p_type);
2805 result = get_tic6x_segment_type (p_type);
2815 sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
2817 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
2819 const char * result;
2821 switch (elf_header.e_machine)
2824 result = get_parisc_segment_type (p_type);
2827 result = get_ia64_segment_type (p_type);
2837 sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
2840 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
2847 get_mips_section_type_name (unsigned int sh_type)
2851 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
2852 case SHT_MIPS_MSYM: return "MIPS_MSYM";
2853 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
2854 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
2855 case SHT_MIPS_UCODE: return "MIPS_UCODE";
2856 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
2857 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
2858 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
2859 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
2860 case SHT_MIPS_RELD: return "MIPS_RELD";
2861 case SHT_MIPS_IFACE: return "MIPS_IFACE";
2862 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
2863 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
2864 case SHT_MIPS_SHDR: return "MIPS_SHDR";
2865 case SHT_MIPS_FDESC: return "MIPS_FDESC";
2866 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
2867 case SHT_MIPS_DENSE: return "MIPS_DENSE";
2868 case SHT_MIPS_PDESC: return "MIPS_PDESC";
2869 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
2870 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
2871 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
2872 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
2873 case SHT_MIPS_LINE: return "MIPS_LINE";
2874 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
2875 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
2876 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
2877 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
2878 case SHT_MIPS_DWARF: return "MIPS_DWARF";
2879 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
2880 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
2881 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
2882 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
2883 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
2884 case SHT_MIPS_XLATE: return "MIPS_XLATE";
2885 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
2886 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
2887 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
2888 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
2889 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
2897 get_parisc_section_type_name (unsigned int sh_type)
2901 case SHT_PARISC_EXT: return "PARISC_EXT";
2902 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
2903 case SHT_PARISC_DOC: return "PARISC_DOC";
2904 case SHT_PARISC_ANNOT: return "PARISC_ANNOT";
2905 case SHT_PARISC_SYMEXTN: return "PARISC_SYMEXTN";
2906 case SHT_PARISC_STUBS: return "PARISC_STUBS";
2907 case SHT_PARISC_DLKM: return "PARISC_DLKM";
2915 get_ia64_section_type_name (unsigned int sh_type)
2917 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
2918 if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
2919 return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
2923 case SHT_IA_64_EXT: return "IA_64_EXT";
2924 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
2925 case SHT_IA_64_PRIORITY_INIT: return "IA_64_PRIORITY_INIT";
2926 case SHT_IA_64_VMS_TRACE: return "VMS_TRACE";
2927 case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
2928 case SHT_IA_64_VMS_DEBUG: return "VMS_DEBUG";
2929 case SHT_IA_64_VMS_DEBUG_STR: return "VMS_DEBUG_STR";
2930 case SHT_IA_64_VMS_LINKAGES: return "VMS_LINKAGES";
2931 case SHT_IA_64_VMS_SYMBOL_VECTOR: return "VMS_SYMBOL_VECTOR";
2932 case SHT_IA_64_VMS_FIXUP: return "VMS_FIXUP";
2940 get_x86_64_section_type_name (unsigned int sh_type)
2944 case SHT_X86_64_UNWIND: return "X86_64_UNWIND";
2952 get_arm_section_type_name (unsigned int sh_type)
2956 case SHT_ARM_EXIDX: return "ARM_EXIDX";
2957 case SHT_ARM_PREEMPTMAP: return "ARM_PREEMPTMAP";
2958 case SHT_ARM_ATTRIBUTES: return "ARM_ATTRIBUTES";
2959 case SHT_ARM_DEBUGOVERLAY: return "ARM_DEBUGOVERLAY";
2960 case SHT_ARM_OVERLAYSECTION: return "ARM_OVERLAYSECTION";
2968 get_tic6x_section_type_name (unsigned int sh_type)
2972 case SHT_C6000_UNWIND:
2973 return "C6000_UNWIND";
2974 case SHT_C6000_PREEMPTMAP:
2975 return "C6000_PREEMPTMAP";
2976 case SHT_C6000_ATTRIBUTES:
2977 return "C6000_ATTRIBUTES";
2982 case SHT_TI_HANDLER:
2983 return "TI_HANDLER";
2984 case SHT_TI_INITINFO:
2985 return "TI_INITINFO";
2986 case SHT_TI_PHATTRS:
2987 return "TI_PHATTRS";
2995 get_section_type_name (unsigned int sh_type)
2997 static char buff[32];
3001 case SHT_NULL: return "NULL";
3002 case SHT_PROGBITS: return "PROGBITS";
3003 case SHT_SYMTAB: return "SYMTAB";
3004 case SHT_STRTAB: return "STRTAB";
3005 case SHT_RELA: return "RELA";
3006 case SHT_HASH: return "HASH";
3007 case SHT_DYNAMIC: return "DYNAMIC";
3008 case SHT_NOTE: return "NOTE";
3009 case SHT_NOBITS: return "NOBITS";
3010 case SHT_REL: return "REL";
3011 case SHT_SHLIB: return "SHLIB";
3012 case SHT_DYNSYM: return "DYNSYM";
3013 case SHT_INIT_ARRAY: return "INIT_ARRAY";
3014 case SHT_FINI_ARRAY: return "FINI_ARRAY";
3015 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
3016 case SHT_GNU_HASH: return "GNU_HASH";
3017 case SHT_GROUP: return "GROUP";
3018 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICIES";
3019 case SHT_GNU_verdef: return "VERDEF";
3020 case SHT_GNU_verneed: return "VERNEED";
3021 case SHT_GNU_versym: return "VERSYM";
3022 case 0x6ffffff0: return "VERSYM";
3023 case 0x6ffffffc: return "VERDEF";
3024 case 0x7ffffffd: return "AUXILIARY";
3025 case 0x7fffffff: return "FILTER";
3026 case SHT_GNU_LIBLIST: return "GNU_LIBLIST";
3029 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
3031 const char * result;
3033 switch (elf_header.e_machine)
3036 case EM_MIPS_RS3_LE:
3037 result = get_mips_section_type_name (sh_type);
3040 result = get_parisc_section_type_name (sh_type);
3043 result = get_ia64_section_type_name (sh_type);
3047 result = get_x86_64_section_type_name (sh_type);
3050 result = get_arm_section_type_name (sh_type);
3053 result = get_tic6x_section_type_name (sh_type);
3063 sprintf (buff, "LOPROC+%x", sh_type - SHT_LOPROC);
3065 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
3067 const char * result;
3069 switch (elf_header.e_machine)
3072 result = get_ia64_section_type_name (sh_type);
3082 sprintf (buff, "LOOS+%x", sh_type - SHT_LOOS);
3084 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
3085 sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER);
3087 /* This message is probably going to be displayed in a 15
3088 character wide field, so put the hex value first. */
3089 snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
3095 #define OPTION_DEBUG_DUMP 512
3096 #define OPTION_DYN_SYMS 513
3097 #define OPTION_DWARF_DEPTH 514
3098 #define OPTION_DWARF_START 515
3100 static struct option options[] =
3102 {"all", no_argument, 0, 'a'},
3103 {"file-header", no_argument, 0, 'h'},
3104 {"program-headers", no_argument, 0, 'l'},
3105 {"headers", no_argument, 0, 'e'},
3106 {"histogram", no_argument, 0, 'I'},
3107 {"segments", no_argument, 0, 'l'},
3108 {"sections", no_argument, 0, 'S'},
3109 {"section-headers", no_argument, 0, 'S'},
3110 {"section-groups", no_argument, 0, 'g'},
3111 {"section-details", no_argument, 0, 't'},
3112 {"full-section-name",no_argument, 0, 'N'},
3113 {"symbols", no_argument, 0, 's'},
3114 {"syms", no_argument, 0, 's'},
3115 {"dyn-syms", no_argument, 0, OPTION_DYN_SYMS},
3116 {"relocs", no_argument, 0, 'r'},
3117 {"notes", no_argument, 0, 'n'},
3118 {"dynamic", no_argument, 0, 'd'},
3119 {"arch-specific", no_argument, 0, 'A'},
3120 {"version-info", no_argument, 0, 'V'},
3121 {"use-dynamic", no_argument, 0, 'D'},
3122 {"unwind", no_argument, 0, 'u'},
3123 {"archive-index", no_argument, 0, 'c'},
3124 {"hex-dump", required_argument, 0, 'x'},
3125 {"relocated-dump", required_argument, 0, 'R'},
3126 {"string-dump", required_argument, 0, 'p'},
3127 #ifdef SUPPORT_DISASSEMBLY
3128 {"instruction-dump", required_argument, 0, 'i'},
3130 {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
3132 {"dwarf-depth", required_argument, 0, OPTION_DWARF_DEPTH},
3133 {"dwarf-start", required_argument, 0, OPTION_DWARF_START},
3135 {"version", no_argument, 0, 'v'},
3136 {"wide", no_argument, 0, 'W'},
3137 {"help", no_argument, 0, 'H'},
3138 {0, no_argument, 0, 0}
3142 usage (FILE * stream)
3144 fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
3145 fprintf (stream, _(" Display information about the contents of ELF format files\n"));
3146 fprintf (stream, _(" Options are:\n\
3147 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3148 -h --file-header Display the ELF file header\n\
3149 -l --program-headers Display the program headers\n\
3150 --segments An alias for --program-headers\n\
3151 -S --section-headers Display the sections' header\n\
3152 --sections An alias for --section-headers\n\
3153 -g --section-groups Display the section groups\n\
3154 -t --section-details Display the section details\n\
3155 -e --headers Equivalent to: -h -l -S\n\
3156 -s --syms Display the symbol table\n\
3157 --symbols An alias for --syms\n\
3158 --dyn-syms Display the dynamic symbol table\n\
3159 -n --notes Display the core notes (if present)\n\
3160 -r --relocs Display the relocations (if present)\n\
3161 -u --unwind Display the unwind info (if present)\n\
3162 -d --dynamic Display the dynamic section (if present)\n\
3163 -V --version-info Display the version sections (if present)\n\
3164 -A --arch-specific Display architecture specific information (if any).\n\
3165 -c --archive-index Display the symbol/file index in an archive\n\
3166 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
3167 -x --hex-dump=<number|name>\n\
3168 Dump the contents of section <number|name> as bytes\n\
3169 -p --string-dump=<number|name>\n\
3170 Dump the contents of section <number|name> as strings\n\
3171 -R --relocated-dump=<number|name>\n\
3172 Dump the contents of section <number|name> as relocated bytes\n\
3173 -w[lLiaprmfFsoRt] or\n\
3174 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
3175 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
3176 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges]\n\
3177 Display the contents of DWARF2 debug sections\n"));
3178 fprintf (stream, _("\
3179 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
3180 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
3182 #ifdef SUPPORT_DISASSEMBLY
3183 fprintf (stream, _("\
3184 -i --instruction-dump=<number|name>\n\
3185 Disassemble the contents of section <number|name>\n"));
3187 fprintf (stream, _("\
3188 -I --histogram Display histogram of bucket list lengths\n\
3189 -W --wide Allow output width to exceed 80 characters\n\
3190 @<file> Read options from <file>\n\
3191 -H --help Display this information\n\
3192 -v --version Display the version number of readelf\n"));
3194 if (REPORT_BUGS_TO[0] && stream == stdout)
3195 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
3197 exit (stream == stdout ? 0 : 1);
3200 /* Record the fact that the user wants the contents of section number
3201 SECTION to be displayed using the method(s) encoded as flags bits
3202 in TYPE. Note, TYPE can be zero if we are creating the array for
3206 request_dump_bynumber (unsigned int section, dump_type type)
3208 if (section >= num_dump_sects)
3210 dump_type * new_dump_sects;
3212 new_dump_sects = (dump_type *) calloc (section + 1,
3213 sizeof (* dump_sects));
3215 if (new_dump_sects == NULL)
3216 error (_("Out of memory allocating dump request table.\n"));
3219 /* Copy current flag settings. */
3220 memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
3224 dump_sects = new_dump_sects;
3225 num_dump_sects = section + 1;
3230 dump_sects[section] |= type;
3235 /* Request a dump by section name. */
3238 request_dump_byname (const char * section, dump_type type)
3240 struct dump_list_entry * new_request;
3242 new_request = (struct dump_list_entry *)
3243 malloc (sizeof (struct dump_list_entry));
3245 error (_("Out of memory allocating dump request table.\n"));
3247 new_request->name = strdup (section);
3248 if (!new_request->name)
3249 error (_("Out of memory allocating dump request table.\n"));
3251 new_request->type = type;
3253 new_request->next = dump_sects_byname;
3254 dump_sects_byname = new_request;
3258 request_dump (dump_type type)
3264 section = strtoul (optarg, & cp, 0);
3266 if (! *cp && section >= 0)
3267 request_dump_bynumber (section, type);
3269 request_dump_byname (optarg, type);
3274 parse_args (int argc, char ** argv)
3281 while ((c = getopt_long
3282 (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options, NULL)) != EOF)
3300 do_section_groups++;
3308 do_section_groups++;
3313 do_section_details++;
3357 request_dump (HEX_DUMP);
3360 request_dump (STRING_DUMP);
3363 request_dump (RELOC_DUMP);
3370 dwarf_select_sections_all ();
3375 dwarf_select_sections_by_letters (optarg);
3378 case OPTION_DEBUG_DUMP:
3385 dwarf_select_sections_by_names (optarg);
3388 case OPTION_DWARF_DEPTH:
3392 dwarf_cutoff_level = strtoul (optarg, & cp, 0);
3395 case OPTION_DWARF_START:
3399 dwarf_start_die = strtoul (optarg, & cp, 0);
3402 case OPTION_DYN_SYMS:
3405 #ifdef SUPPORT_DISASSEMBLY
3407 request_dump (DISASS_DUMP);
3411 print_version (program_name);
3420 /* xgettext:c-format */
3421 error (_("Invalid option '-%c'\n"), c);
3428 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
3429 && !do_segments && !do_header && !do_dump && !do_version
3430 && !do_histogram && !do_debugging && !do_arch && !do_notes
3431 && !do_section_groups && !do_archive_index
3436 warn (_("Nothing to do.\n"));
3442 get_elf_class (unsigned int elf_class)
3444 static char buff[32];
3448 case ELFCLASSNONE: return _("none");
3449 case ELFCLASS32: return "ELF32";
3450 case ELFCLASS64: return "ELF64";
3452 snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
3458 get_data_encoding (unsigned int encoding)
3460 static char buff[32];
3464 case ELFDATANONE: return _("none");
3465 case ELFDATA2LSB: return _("2's complement, little endian");
3466 case ELFDATA2MSB: return _("2's complement, big endian");
3468 snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
3473 /* Decode the data held in 'elf_header'. */
3476 process_file_header (void)
3478 if ( elf_header.e_ident[EI_MAG0] != ELFMAG0
3479 || elf_header.e_ident[EI_MAG1] != ELFMAG1
3480 || elf_header.e_ident[EI_MAG2] != ELFMAG2
3481 || elf_header.e_ident[EI_MAG3] != ELFMAG3)
3484 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3488 init_dwarf_regnames (elf_header.e_machine);
3494 printf (_("ELF Header:\n"));
3495 printf (_(" Magic: "));
3496 for (i = 0; i < EI_NIDENT; i++)
3497 printf ("%2.2x ", elf_header.e_ident[i]);
3499 printf (_(" Class: %s\n"),
3500 get_elf_class (elf_header.e_ident[EI_CLASS]));
3501 printf (_(" Data: %s\n"),
3502 get_data_encoding (elf_header.e_ident[EI_DATA]));
3503 printf (_(" Version: %d %s\n"),
3504 elf_header.e_ident[EI_VERSION],
3505 (elf_header.e_ident[EI_VERSION] == EV_CURRENT
3507 : (elf_header.e_ident[EI_VERSION] != EV_NONE
3508 ? _("<unknown: %lx>")
3510 printf (_(" OS/ABI: %s\n"),
3511 get_osabi_name (elf_header.e_ident[EI_OSABI]));
3512 printf (_(" ABI Version: %d\n"),
3513 elf_header.e_ident[EI_ABIVERSION]);
3514 printf (_(" Type: %s\n"),
3515 get_file_type (elf_header.e_type));
3516 printf (_(" Machine: %s\n"),
3517 get_machine_name (elf_header.e_machine));
3518 printf (_(" Version: 0x%lx\n"),
3519 (unsigned long) elf_header.e_version);
3521 printf (_(" Entry point address: "));
3522 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
3523 printf (_("\n Start of program headers: "));
3524 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
3525 printf (_(" (bytes into file)\n Start of section headers: "));
3526 print_vma ((bfd_vma) elf_header.e_shoff, DEC);
3527 printf (_(" (bytes into file)\n"));
3529 printf (_(" Flags: 0x%lx%s\n"),
3530 (unsigned long) elf_header.e_flags,
3531 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
3532 printf (_(" Size of this header: %ld (bytes)\n"),
3533 (long) elf_header.e_ehsize);
3534 printf (_(" Size of program headers: %ld (bytes)\n"),
3535 (long) elf_header.e_phentsize);
3536 printf (_(" Number of program headers: %ld"),
3537 (long) elf_header.e_phnum);
3538 if (section_headers != NULL
3539 && elf_header.e_phnum == PN_XNUM
3540 && section_headers[0].sh_info != 0)
3541 printf (" (%ld)", (long) section_headers[0].sh_info);
3542 putc ('\n', stdout);
3543 printf (_(" Size of section headers: %ld (bytes)\n"),
3544 (long) elf_header.e_shentsize);
3545 printf (_(" Number of section headers: %ld"),
3546 (long) elf_header.e_shnum);
3547 if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
3548 printf (" (%ld)", (long) section_headers[0].sh_size);
3549 putc ('\n', stdout);
3550 printf (_(" Section header string table index: %ld"),
3551 (long) elf_header.e_shstrndx);
3552 if (section_headers != NULL
3553 && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
3554 printf (" (%u)", section_headers[0].sh_link);
3555 else if (elf_header.e_shstrndx != SHN_UNDEF
3556 && elf_header.e_shstrndx >= elf_header.e_shnum)
3557 printf (_(" <corrupt: out of range>"));
3558 putc ('\n', stdout);
3561 if (section_headers != NULL)
3563 if (elf_header.e_phnum == PN_XNUM
3564 && section_headers[0].sh_info != 0)
3565 elf_header.e_phnum = section_headers[0].sh_info;
3566 if (elf_header.e_shnum == SHN_UNDEF)
3567 elf_header.e_shnum = section_headers[0].sh_size;
3568 if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
3569 elf_header.e_shstrndx = section_headers[0].sh_link;
3570 else if (elf_header.e_shstrndx >= elf_header.e_shnum)
3571 elf_header.e_shstrndx = SHN_UNDEF;
3572 free (section_headers);
3573 section_headers = NULL;
3581 get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
3583 Elf32_External_Phdr * phdrs;
3584 Elf32_External_Phdr * external;
3585 Elf_Internal_Phdr * internal;
3588 phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
3589 elf_header.e_phentsize,
3591 _("program headers"));
3595 for (i = 0, internal = pheaders, external = phdrs;
3596 i < elf_header.e_phnum;
3597 i++, internal++, external++)
3599 internal->p_type = BYTE_GET (external->p_type);
3600 internal->p_offset = BYTE_GET (external->p_offset);
3601 internal->p_vaddr = BYTE_GET (external->p_vaddr);
3602 internal->p_paddr = BYTE_GET (external->p_paddr);
3603 internal->p_filesz = BYTE_GET (external->p_filesz);
3604 internal->p_memsz = BYTE_GET (external->p_memsz);
3605 internal->p_flags = BYTE_GET (external->p_flags);
3606 internal->p_align = BYTE_GET (external->p_align);
3615 get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
3617 Elf64_External_Phdr * phdrs;
3618 Elf64_External_Phdr * external;
3619 Elf_Internal_Phdr * internal;
3622 phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
3623 elf_header.e_phentsize,
3625 _("program headers"));
3629 for (i = 0, internal = pheaders, external = phdrs;
3630 i < elf_header.e_phnum;
3631 i++, internal++, external++)
3633 internal->p_type = BYTE_GET (external->p_type);
3634 internal->p_flags = BYTE_GET (external->p_flags);
3635 internal->p_offset = BYTE_GET (external->p_offset);
3636 internal->p_vaddr = BYTE_GET (external->p_vaddr);
3637 internal->p_paddr = BYTE_GET (external->p_paddr);
3638 internal->p_filesz = BYTE_GET (external->p_filesz);
3639 internal->p_memsz = BYTE_GET (external->p_memsz);
3640 internal->p_align = BYTE_GET (external->p_align);
3648 /* Returns 1 if the program headers were read into `program_headers'. */
3651 get_program_headers (FILE * file)
3653 Elf_Internal_Phdr * phdrs;
3655 /* Check cache of prior read. */
3656 if (program_headers != NULL)
3659 phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
3660 sizeof (Elf_Internal_Phdr));
3664 error (_("Out of memory\n"));
3669 ? get_32bit_program_headers (file, phdrs)
3670 : get_64bit_program_headers (file, phdrs))
3672 program_headers = phdrs;
3680 /* Returns 1 if the program headers were loaded. */
3683 process_program_headers (FILE * file)
3685 Elf_Internal_Phdr * segment;
3688 if (elf_header.e_phnum == 0)
3690 /* PR binutils/12467. */
3691 if (elf_header.e_phoff != 0)
3692 warn (_("possibly corrupt ELF header - it has a non-zero program"
3693 " header offset, but no program headers"));
3694 else if (do_segments)
3695 printf (_("\nThere are no program headers in this file.\n"));
3699 if (do_segments && !do_header)
3701 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
3702 printf (_("Entry point "));
3703 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
3704 printf (_("\nThere are %d program headers, starting at offset "),
3705 elf_header.e_phnum);
3706 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
3710 if (! get_program_headers (file))
3715 if (elf_header.e_phnum > 1)
3716 printf (_("\nProgram Headers:\n"));
3718 printf (_("\nProgram Headers:\n"));
3722 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3725 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3729 (_(" Type Offset VirtAddr PhysAddr\n"));
3731 (_(" FileSiz MemSiz Flags Align\n"));
3738 for (i = 0, segment = program_headers;
3739 i < elf_header.e_phnum;
3744 printf (" %-14.14s ", get_segment_type (segment->p_type));
3748 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
3749 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
3750 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
3751 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
3752 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
3754 (segment->p_flags & PF_R ? 'R' : ' '),
3755 (segment->p_flags & PF_W ? 'W' : ' '),
3756 (segment->p_flags & PF_X ? 'E' : ' '));
3757 printf ("%#lx", (unsigned long) segment->p_align);
3761 if ((unsigned long) segment->p_offset == segment->p_offset)
3762 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
3765 print_vma (segment->p_offset, FULL_HEX);
3769 print_vma (segment->p_vaddr, FULL_HEX);
3771 print_vma (segment->p_paddr, FULL_HEX);
3774 if ((unsigned long) segment->p_filesz == segment->p_filesz)
3775 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
3778 print_vma (segment->p_filesz, FULL_HEX);
3782 if ((unsigned long) segment->p_memsz == segment->p_memsz)
3783 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
3786 print_vma (segment->p_offset, FULL_HEX);
3790 (segment->p_flags & PF_R ? 'R' : ' '),
3791 (segment->p_flags & PF_W ? 'W' : ' '),
3792 (segment->p_flags & PF_X ? 'E' : ' '));
3794 if ((unsigned long) segment->p_align == segment->p_align)
3795 printf ("%#lx", (unsigned long) segment->p_align);
3798 print_vma (segment->p_align, PREFIX_HEX);
3803 print_vma (segment->p_offset, FULL_HEX);
3805 print_vma (segment->p_vaddr, FULL_HEX);
3807 print_vma (segment->p_paddr, FULL_HEX);
3809 print_vma (segment->p_filesz, FULL_HEX);
3811 print_vma (segment->p_memsz, FULL_HEX);
3813 (segment->p_flags & PF_R ? 'R' : ' '),
3814 (segment->p_flags & PF_W ? 'W' : ' '),
3815 (segment->p_flags & PF_X ? 'E' : ' '));
3816 print_vma (segment->p_align, HEX);
3820 switch (segment->p_type)
3824 error (_("more than one dynamic segment\n"));
3826 /* By default, assume that the .dynamic section is the first
3827 section in the DYNAMIC segment. */
3828 dynamic_addr = segment->p_offset;
3829 dynamic_size = segment->p_filesz;
3831 /* Try to locate the .dynamic section. If there is
3832 a section header table, we can easily locate it. */
3833 if (section_headers != NULL)
3835 Elf_Internal_Shdr * sec;
3837 sec = find_section (".dynamic");
3838 if (sec == NULL || sec->sh_size == 0)
3840 /* A corresponding .dynamic section is expected, but on
3841 IA-64/OpenVMS it is OK for it to be missing. */
3842 if (!is_ia64_vms ())
3843 error (_("no .dynamic section in the dynamic segment\n"));
3847 if (sec->sh_type == SHT_NOBITS)
3853 dynamic_addr = sec->sh_offset;
3854 dynamic_size = sec->sh_size;
3856 if (dynamic_addr < segment->p_offset
3857 || dynamic_addr > segment->p_offset + segment->p_filesz)
3858 warn (_("the .dynamic section is not contained"
3859 " within the dynamic segment\n"));
3860 else if (dynamic_addr > segment->p_offset)
3861 warn (_("the .dynamic section is not the first section"
3862 " in the dynamic segment.\n"));
3867 if (fseek (file, archive_file_offset + (long) segment->p_offset,
3869 error (_("Unable to find program interpreter name\n"));
3873 int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX);
3875 if (ret >= (int) sizeof (fmt) || ret < 0)
3876 error (_("Internal error: failed to create format string to display program interpreter\n"));
3878 program_interpreter[0] = 0;
3879 if (fscanf (file, fmt, program_interpreter) <= 0)
3880 error (_("Unable to read program interpreter name\n"));
3883 printf (_("\n [Requesting program interpreter: %s]"),
3884 program_interpreter);
3890 putc ('\n', stdout);
3893 if (do_segments && section_headers != NULL && string_table != NULL)
3895 printf (_("\n Section to Segment mapping:\n"));
3896 printf (_(" Segment Sections...\n"));
3898 for (i = 0; i < elf_header.e_phnum; i++)
3901 Elf_Internal_Shdr * section;
3903 segment = program_headers + i;
3904 section = section_headers + 1;
3906 printf (" %2.2d ", i);
3908 for (j = 1; j < elf_header.e_shnum; j++, section++)
3910 if (!ELF_TBSS_SPECIAL (section, segment)
3911 && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
3912 printf ("%s ", SECTION_NAME (section));
3923 /* Find the file offset corresponding to VMA by using the program headers. */
3926 offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
3928 Elf_Internal_Phdr * seg;
3930 if (! get_program_headers (file))
3932 warn (_("Cannot interpret virtual addresses without program headers.\n"));
3936 for (seg = program_headers;
3937 seg < program_headers + elf_header.e_phnum;
3940 if (seg->p_type != PT_LOAD)
3943 if (vma >= (seg->p_vaddr & -seg->p_align)
3944 && vma + size <= seg->p_vaddr + seg->p_filesz)
3945 return vma - seg->p_vaddr + seg->p_offset;
3948 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
3949 (unsigned long) vma);
3955 get_32bit_section_headers (FILE * file, unsigned int num)
3957 Elf32_External_Shdr * shdrs;
3958 Elf_Internal_Shdr * internal;
3961 shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
3962 elf_header.e_shentsize, num,
3963 _("section headers"));
3967 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
3968 sizeof (Elf_Internal_Shdr));
3970 if (section_headers == NULL)
3972 error (_("Out of memory\n"));
3976 for (i = 0, internal = section_headers;
3980 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
3981 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
3982 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
3983 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
3984 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
3985 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
3986 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
3987 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
3988 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
3989 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
3998 get_64bit_section_headers (FILE * file, unsigned int num)
4000 Elf64_External_Shdr * shdrs;
4001 Elf_Internal_Shdr * internal;
4004 shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
4005 elf_header.e_shentsize, num,
4006 _("section headers"));
4010 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4011 sizeof (Elf_Internal_Shdr));
4013 if (section_headers == NULL)
4015 error (_("Out of memory\n"));
4019 for (i = 0, internal = section_headers;
4023 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4024 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
4025 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4026 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4027 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4028 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
4029 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4030 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
4031 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
4032 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4040 static Elf_Internal_Sym *
4041 get_32bit_elf_symbols (FILE * file, Elf_Internal_Shdr * section)
4043 unsigned long number;
4044 Elf32_External_Sym * esyms = NULL;
4045 Elf_External_Sym_Shndx * shndx;
4046 Elf_Internal_Sym * isyms = NULL;
4047 Elf_Internal_Sym * psym;
4050 /* Run some sanity checks first. */
4051 if (section->sh_entsize == 0)
4053 error (_("sh_entsize is zero\n"));
4057 number = section->sh_size / section->sh_entsize;
4059 if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
4061 error (_("Invalid sh_entsize\n"));
4065 esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4066 section->sh_size, _("symbols"));
4071 if (symtab_shndx_hdr != NULL
4072 && (symtab_shndx_hdr->sh_link
4073 == (unsigned long) (section - section_headers)))
4075 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4076 symtab_shndx_hdr->sh_offset,
4077 1, symtab_shndx_hdr->sh_size,
4083 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
4087 error (_("Out of memory\n"));
4091 for (j = 0, psym = isyms; j < number; j++, psym++)
4093 psym->st_name = BYTE_GET (esyms[j].st_name);
4094 psym->st_value = BYTE_GET (esyms[j].st_value);
4095 psym->st_size = BYTE_GET (esyms[j].st_size);
4096 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4097 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
4099 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4100 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4101 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
4102 psym->st_info = BYTE_GET (esyms[j].st_info);
4103 psym->st_other = BYTE_GET (esyms[j].st_other);
4115 static Elf_Internal_Sym *
4116 get_64bit_elf_symbols (FILE * file, Elf_Internal_Shdr * section)
4118 unsigned long number;
4119 Elf64_External_Sym * esyms;
4120 Elf_External_Sym_Shndx * shndx;
4121 Elf_Internal_Sym * isyms;
4122 Elf_Internal_Sym * psym;
4125 /* Run some sanity checks first. */
4126 if (section->sh_entsize == 0)
4128 error (_("sh_entsize is zero\n"));
4132 number = section->sh_size / section->sh_entsize;
4134 if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
4136 error (_("Invalid sh_entsize\n"));
4140 esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4141 section->sh_size, _("symbols"));
4146 if (symtab_shndx_hdr != NULL
4147 && (symtab_shndx_hdr->sh_link
4148 == (unsigned long) (section - section_headers)))
4150 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4151 symtab_shndx_hdr->sh_offset,
4152 1, symtab_shndx_hdr->sh_size,
4161 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
4165 error (_("Out of memory\n"));
4172 for (j = 0, psym = isyms;
4176 psym->st_name = BYTE_GET (esyms[j].st_name);
4177 psym->st_info = BYTE_GET (esyms[j].st_info);
4178 psym->st_other = BYTE_GET (esyms[j].st_other);
4179 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4180 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
4182 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4183 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4184 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
4185 psym->st_value = BYTE_GET (esyms[j].st_value);
4186 psym->st_size = BYTE_GET (esyms[j].st_size);
4197 get_elf_section_flags (bfd_vma sh_flags)
4199 static char buff[1024];
4201 int field_size = is_32bit_elf ? 8 : 16;
4203 int size = sizeof (buff) - (field_size + 4 + 1);
4204 bfd_vma os_flags = 0;
4205 bfd_vma proc_flags = 0;
4206 bfd_vma unknown_flags = 0;
4214 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
4215 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
4216 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
4217 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
4218 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
4219 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
4220 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
4221 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
4222 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
4223 /* 9 */ { STRING_COMMA_LEN ("TLS") },
4224 /* IA-64 specific. */
4225 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
4226 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
4227 /* IA-64 OpenVMS specific. */
4228 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
4229 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
4230 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
4231 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
4232 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
4233 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
4235 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
4236 /* SPARC specific. */
4237 /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
4240 if (do_section_details)
4242 sprintf (buff, "[%*.*lx]: ",
4243 field_size, field_size, (unsigned long) sh_flags);
4244 p += field_size + 4;
4251 flag = sh_flags & - sh_flags;
4254 if (do_section_details)
4258 case SHF_WRITE: sindex = 0; break;
4259 case SHF_ALLOC: sindex = 1; break;
4260 case SHF_EXECINSTR: sindex = 2; break;
4261 case SHF_MERGE: sindex = 3; break;
4262 case SHF_STRINGS: sindex = 4; break;
4263 case SHF_INFO_LINK: sindex = 5; break;
4264 case SHF_LINK_ORDER: sindex = 6; break;
4265 case SHF_OS_NONCONFORMING: sindex = 7; break;
4266 case SHF_GROUP: sindex = 8; break;
4267 case SHF_TLS: sindex = 9; break;
4268 case SHF_EXCLUDE: sindex = 18; break;
4272 switch (elf_header.e_machine)
4275 if (flag == SHF_IA_64_SHORT)
4277 else if (flag == SHF_IA_64_NORECOV)
4280 else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
4283 case SHF_IA_64_VMS_GLOBAL: sindex = 12; break;
4284 case SHF_IA_64_VMS_OVERLAID: sindex = 13; break;
4285 case SHF_IA_64_VMS_SHARED: sindex = 14; break;
4286 case SHF_IA_64_VMS_VECTOR: sindex = 15; break;
4287 case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
4288 case SHF_IA_64_VMS_PROTECTED: sindex = 17; break;
4298 case EM_OLD_SPARCV9:
4299 case EM_SPARC32PLUS:
4302 if (flag == SHF_ORDERED)
4312 if (p != buff + field_size + 4)
4314 if (size < (10 + 2))
4321 size -= flags [sindex].len;
4322 p = stpcpy (p, flags [sindex].str);
4324 else if (flag & SHF_MASKOS)
4326 else if (flag & SHF_MASKPROC)
4329 unknown_flags |= flag;
4335 case SHF_WRITE: *p = 'W'; break;
4336 case SHF_ALLOC: *p = 'A'; break;
4337 case SHF_EXECINSTR: *p = 'X'; break;
4338 case SHF_MERGE: *p = 'M'; break;
4339 case SHF_STRINGS: *p = 'S'; break;
4340 case SHF_INFO_LINK: *p = 'I'; break;
4341 case SHF_LINK_ORDER: *p = 'L'; break;
4342 case SHF_OS_NONCONFORMING: *p = 'O'; break;
4343 case SHF_GROUP: *p = 'G'; break;
4344 case SHF_TLS: *p = 'T'; break;
4345 case SHF_EXCLUDE: *p = 'E'; break;
4348 if ((elf_header.e_machine == EM_X86_64
4349 || elf_header.e_machine == EM_L1OM)
4350 && flag == SHF_X86_64_LARGE)
4352 else if (flag & SHF_MASKOS)
4355 sh_flags &= ~ SHF_MASKOS;
4357 else if (flag & SHF_MASKPROC)
4360 sh_flags &= ~ SHF_MASKPROC;
4370 if (do_section_details)
4374 size -= 5 + field_size;
4375 if (p != buff + field_size + 4)
4383 sprintf (p, "OS (%*.*lx)", field_size, field_size,
4384 (unsigned long) os_flags);
4385 p += 5 + field_size;
4389 size -= 7 + field_size;
4390 if (p != buff + field_size + 4)
4398 sprintf (p, "PROC (%*.*lx)", field_size, field_size,
4399 (unsigned long) proc_flags);
4400 p += 7 + field_size;
4404 size -= 10 + field_size;
4405 if (p != buff + field_size + 4)
4413 sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
4414 (unsigned long) unknown_flags);
4415 p += 10 + field_size;
4424 process_section_headers (FILE * file)
4426 Elf_Internal_Shdr * section;
4429 section_headers = NULL;
4431 if (elf_header.e_shnum == 0)
4433 /* PR binutils/12467. */
4434 if (elf_header.e_shoff != 0)
4435 warn (_("possibly corrupt ELF file header - it has a non-zero"
4436 " section header offset, but no section headers\n"));
4437 else if (do_sections)
4438 printf (_("\nThere are no sections in this file.\n"));
4443 if (do_sections && !do_header)
4444 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
4445 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
4449 if (! get_32bit_section_headers (file, elf_header.e_shnum))
4452 else if (! get_64bit_section_headers (file, elf_header.e_shnum))
4455 /* Read in the string table, so that we have names to display. */
4456 if (elf_header.e_shstrndx != SHN_UNDEF
4457 && elf_header.e_shstrndx < elf_header.e_shnum)
4459 section = section_headers + elf_header.e_shstrndx;
4461 if (section->sh_size != 0)
4463 string_table = (char *) get_data (NULL, file, section->sh_offset,
4464 1, section->sh_size,
4467 string_table_length = string_table != NULL ? section->sh_size : 0;
4471 /* Scan the sections for the dynamic symbol table
4472 and dynamic string table and debug sections. */
4473 dynamic_symbols = NULL;
4474 dynamic_strings = NULL;
4475 dynamic_syminfo = NULL;
4476 symtab_shndx_hdr = NULL;
4478 eh_addr_size = is_32bit_elf ? 4 : 8;
4479 switch (elf_header.e_machine)
4482 case EM_MIPS_RS3_LE:
4483 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
4484 FDE addresses. However, the ABI also has a semi-official ILP32
4485 variant for which the normal FDE address size rules apply.
4487 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
4488 section, where XX is the size of longs in bits. Unfortunately,
4489 earlier compilers provided no way of distinguishing ILP32 objects
4490 from LP64 objects, so if there's any doubt, we should assume that
4491 the official LP64 form is being used. */
4492 if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
4493 && find_section (".gcc_compiled_long32") == NULL)
4499 switch (elf_header.e_flags & EF_H8_MACH)
4501 case E_H8_MACH_H8300:
4502 case E_H8_MACH_H8300HN:
4503 case E_H8_MACH_H8300SN:
4504 case E_H8_MACH_H8300SXN:
4507 case E_H8_MACH_H8300H:
4508 case E_H8_MACH_H8300S:
4509 case E_H8_MACH_H8300SX:
4517 switch (elf_header.e_flags & EF_M32C_CPU_MASK)
4519 case EF_M32C_CPU_M16C:
4526 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
4529 size_t expected_entsize \
4530 = is_32bit_elf ? size32 : size64; \
4531 if (section->sh_entsize != expected_entsize) \
4532 error (_("Section %d has invalid sh_entsize %lx (expected %lx)\n"), \
4533 i, (unsigned long int) section->sh_entsize, \
4534 (unsigned long int) expected_entsize); \
4535 section->sh_entsize = expected_entsize; \
4538 #define CHECK_ENTSIZE(section, i, type) \
4539 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
4540 sizeof (Elf64_External_##type))
4542 for (i = 0, section = section_headers;
4543 i < elf_header.e_shnum;
4546 char * name = SECTION_NAME (section);
4548 if (section->sh_type == SHT_DYNSYM)
4550 if (dynamic_symbols != NULL)
4552 error (_("File contains multiple dynamic symbol tables\n"));
4556 CHECK_ENTSIZE (section, i, Sym);
4557 num_dynamic_syms = section->sh_size / section->sh_entsize;
4558 dynamic_symbols = GET_ELF_SYMBOLS (file, section);
4560 else if (section->sh_type == SHT_STRTAB
4561 && streq (name, ".dynstr"))
4563 if (dynamic_strings != NULL)
4565 error (_("File contains multiple dynamic string tables\n"));
4569 dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
4570 1, section->sh_size,
4571 _("dynamic strings"));
4572 dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
4574 else if (section->sh_type == SHT_SYMTAB_SHNDX)
4576 if (symtab_shndx_hdr != NULL)
4578 error (_("File contains multiple symtab shndx tables\n"));
4581 symtab_shndx_hdr = section;
4583 else if (section->sh_type == SHT_SYMTAB)
4584 CHECK_ENTSIZE (section, i, Sym);
4585 else if (section->sh_type == SHT_GROUP)
4586 CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
4587 else if (section->sh_type == SHT_REL)
4588 CHECK_ENTSIZE (section, i, Rel);
4589 else if (section->sh_type == SHT_RELA)
4590 CHECK_ENTSIZE (section, i, Rela);
4591 else if ((do_debugging || do_debug_info || do_debug_abbrevs
4592 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
4593 || do_debug_aranges || do_debug_frames || do_debug_macinfo
4594 || do_debug_str || do_debug_loc || do_debug_ranges)
4595 && (const_strneq (name, ".debug_")
4596 || const_strneq (name, ".zdebug_")))
4599 name += sizeof (".zdebug_") - 1;
4601 name += sizeof (".debug_") - 1;
4604 || (do_debug_info && streq (name, "info"))
4605 || (do_debug_info && streq (name, "types"))
4606 || (do_debug_abbrevs && streq (name, "abbrev"))
4607 || (do_debug_lines && streq (name, "line"))
4608 || (do_debug_pubnames && streq (name, "pubnames"))
4609 || (do_debug_pubtypes && streq (name, "pubtypes"))
4610 || (do_debug_aranges && streq (name, "aranges"))
4611 || (do_debug_ranges && streq (name, "ranges"))
4612 || (do_debug_frames && streq (name, "frame"))
4613 || (do_debug_macinfo && streq (name, "macinfo"))
4614 || (do_debug_str && streq (name, "str"))
4615 || (do_debug_loc && streq (name, "loc"))
4617 request_dump_bynumber (i, DEBUG_DUMP);
4619 /* Linkonce section to be combined with .debug_info at link time. */
4620 else if ((do_debugging || do_debug_info)
4621 && const_strneq (name, ".gnu.linkonce.wi."))
4622 request_dump_bynumber (i, DEBUG_DUMP);
4623 else if (do_debug_frames && streq (name, ".eh_frame"))
4624 request_dump_bynumber (i, DEBUG_DUMP);
4625 else if (do_gdb_index && streq (name, ".gdb_index"))
4626 request_dump_bynumber (i, DEBUG_DUMP);
4627 /* Trace sections for Itanium VMS. */
4628 else if ((do_debugging || do_trace_info || do_trace_abbrevs
4629 || do_trace_aranges)
4630 && const_strneq (name, ".trace_"))
4632 name += sizeof (".trace_") - 1;
4635 || (do_trace_info && streq (name, "info"))
4636 || (do_trace_abbrevs && streq (name, "abbrev"))
4637 || (do_trace_aranges && streq (name, "aranges"))
4639 request_dump_bynumber (i, DEBUG_DUMP);
4647 if (elf_header.e_shnum > 1)
4648 printf (_("\nSection Headers:\n"));
4650 printf (_("\nSection Header:\n"));
4654 if (do_section_details)
4656 printf (_(" [Nr] Name\n"));
4657 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
4661 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
4665 if (do_section_details)
4667 printf (_(" [Nr] Name\n"));
4668 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
4672 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
4676 if (do_section_details)
4678 printf (_(" [Nr] Name\n"));
4679 printf (_(" Type Address Offset Link\n"));
4680 printf (_(" Size EntSize Info Align\n"));
4684 printf (_(" [Nr] Name Type Address Offset\n"));
4685 printf (_(" Size EntSize Flags Link Info Align\n"));
4689 if (do_section_details)
4690 printf (_(" Flags\n"));
4692 for (i = 0, section = section_headers;
4693 i < elf_header.e_shnum;
4696 if (do_section_details)
4698 printf (" [%2u] %s\n",
4700 SECTION_NAME (section));
4701 if (is_32bit_elf || do_wide)
4702 printf (" %-15.15s ",
4703 get_section_type_name (section->sh_type));
4706 printf ((do_wide ? " [%2u] %-17s %-15s "
4707 : " [%2u] %-17.17s %-15.15s "),
4709 SECTION_NAME (section),
4710 get_section_type_name (section->sh_type));
4714 const char * link_too_big = NULL;
4716 print_vma (section->sh_addr, LONG_HEX);
4718 printf ( " %6.6lx %6.6lx %2.2lx",
4719 (unsigned long) section->sh_offset,
4720 (unsigned long) section->sh_size,
4721 (unsigned long) section->sh_entsize);
4723 if (do_section_details)
4724 fputs (" ", stdout);
4726 printf (" %3s ", get_elf_section_flags (section->sh_flags));
4728 if (section->sh_link >= elf_header.e_shnum)
4731 /* The sh_link value is out of range. Normally this indicates
4732 an error but it can have special values in Solaris binaries. */
4733 switch (elf_header.e_machine)
4739 case EM_OLD_SPARCV9:
4740 case EM_SPARC32PLUS:
4743 if (section->sh_link == (SHN_BEFORE & 0xffff))
4744 link_too_big = "BEFORE";
4745 else if (section->sh_link == (SHN_AFTER & 0xffff))
4746 link_too_big = "AFTER";
4753 if (do_section_details)
4755 if (link_too_big != NULL && * link_too_big)
4756 printf ("<%s> ", link_too_big);
4758 printf ("%2u ", section->sh_link);
4759 printf ("%3u %2lu\n", section->sh_info,
4760 (unsigned long) section->sh_addralign);
4763 printf ("%2u %3u %2lu\n",
4766 (unsigned long) section->sh_addralign);
4768 if (link_too_big && ! * link_too_big)
4769 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
4770 i, section->sh_link);
4774 print_vma (section->sh_addr, LONG_HEX);
4776 if ((long) section->sh_offset == section->sh_offset)
4777 printf (" %6.6lx", (unsigned long) section->sh_offset);
4781 print_vma (section->sh_offset, LONG_HEX);
4784 if ((unsigned long) section->sh_size == section->sh_size)
4785 printf (" %6.6lx", (unsigned long) section->sh_size);
4789 print_vma (section->sh_size, LONG_HEX);
4792 if ((unsigned long) section->sh_entsize == section->sh_entsize)
4793 printf (" %2.2lx", (unsigned long) section->sh_entsize);
4797 print_vma (section->sh_entsize, LONG_HEX);
4800 if (do_section_details)
4801 fputs (" ", stdout);
4803 printf (" %3s ", get_elf_section_flags (section->sh_flags));
4805 printf ("%2u %3u ", section->sh_link, section->sh_info);
4807 if ((unsigned long) section->sh_addralign == section->sh_addralign)
4808 printf ("%2lu\n", (unsigned long) section->sh_addralign);
4811 print_vma (section->sh_addralign, DEC);
4815 else if (do_section_details)
4817 printf (" %-15.15s ",
4818 get_section_type_name (section->sh_type));
4819 print_vma (section->sh_addr, LONG_HEX);
4820 if ((long) section->sh_offset == section->sh_offset)
4821 printf (" %16.16lx", (unsigned long) section->sh_offset);
4825 print_vma (section->sh_offset, LONG_HEX);
4827 printf (" %u\n ", section->sh_link);
4828 print_vma (section->sh_size, LONG_HEX);
4830 print_vma (section->sh_entsize, LONG_HEX);
4832 printf (" %-16u %lu\n",
4834 (unsigned long) section->sh_addralign);
4839 print_vma (section->sh_addr, LONG_HEX);
4840 if ((long) section->sh_offset == section->sh_offset)
4841 printf (" %8.8lx", (unsigned long) section->sh_offset);
4845 print_vma (section->sh_offset, LONG_HEX);
4848 print_vma (section->sh_size, LONG_HEX);
4850 print_vma (section->sh_entsize, LONG_HEX);
4852 printf (" %3s ", get_elf_section_flags (section->sh_flags));
4854 printf (" %2u %3u %lu\n",
4857 (unsigned long) section->sh_addralign);
4860 if (do_section_details)
4861 printf (" %s\n", get_elf_section_flags (section->sh_flags));
4864 if (!do_section_details)
4866 if (elf_header.e_machine == EM_X86_64
4867 || elf_header.e_machine == EM_L1OM)
4868 printf (_("Key to Flags:\n\
4869 W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
4870 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
4871 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
4873 printf (_("Key to Flags:\n\
4874 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
4875 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
4876 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
4883 get_group_flags (unsigned int flags)
4885 static char buff[32];
4895 snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x] "), flags);
4902 process_section_groups (FILE * file)
4904 Elf_Internal_Shdr * section;
4906 struct group * group;
4907 Elf_Internal_Shdr * symtab_sec;
4908 Elf_Internal_Shdr * strtab_sec;
4909 Elf_Internal_Sym * symtab;
4913 /* Don't process section groups unless needed. */
4914 if (!do_unwind && !do_section_groups)
4917 if (elf_header.e_shnum == 0)
4919 if (do_section_groups)
4920 printf (_("\nThere are no sections to group in this file.\n"));
4925 if (section_headers == NULL)
4927 error (_("Section headers are not available!\n"));
4931 section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
4932 sizeof (struct group *));
4934 if (section_headers_groups == NULL)
4936 error (_("Out of memory\n"));
4940 /* Scan the sections for the group section. */
4942 for (i = 0, section = section_headers;
4943 i < elf_header.e_shnum;
4945 if (section->sh_type == SHT_GROUP)
4948 if (group_count == 0)
4950 if (do_section_groups)
4951 printf (_("\nThere are no section groups in this file.\n"));
4956 section_groups = (struct group *) calloc (group_count, sizeof (struct group));
4958 if (section_groups == NULL)
4960 error (_("Out of memory\n"));
4969 for (i = 0, section = section_headers, group = section_groups;
4970 i < elf_header.e_shnum;
4973 if (section->sh_type == SHT_GROUP)
4975 char * name = SECTION_NAME (section);
4977 unsigned char * start;
4978 unsigned char * indices;
4979 unsigned int entry, j, size;
4980 Elf_Internal_Shdr * sec;
4981 Elf_Internal_Sym * sym;
4983 /* Get the symbol table. */
4984 if (section->sh_link >= elf_header.e_shnum
4985 || ((sec = section_headers + section->sh_link)->sh_type
4988 error (_("Bad sh_link in group section `%s'\n"), name);
4992 if (symtab_sec != sec)
4997 symtab = GET_ELF_SYMBOLS (file, symtab_sec);
5002 error (_("Corrupt header in group section `%s'\n"), name);
5006 sym = symtab + section->sh_info;
5008 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
5010 if (sym->st_shndx == 0
5011 || sym->st_shndx >= elf_header.e_shnum)
5013 error (_("Bad sh_info in group section `%s'\n"), name);
5017 group_name = SECTION_NAME (section_headers + sym->st_shndx);
5026 /* Get the string table. */
5027 if (symtab_sec->sh_link >= elf_header.e_shnum)
5036 != (sec = section_headers + symtab_sec->sh_link))
5041 strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
5042 1, strtab_sec->sh_size,
5044 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
5046 group_name = sym->st_name < strtab_size
5047 ? strtab + sym->st_name : _("<corrupt>");
5050 start = (unsigned char *) get_data (NULL, file, section->sh_offset,
5051 1, section->sh_size,
5057 size = (section->sh_size / section->sh_entsize) - 1;
5058 entry = byte_get (indices, 4);
5061 if (do_section_groups)
5063 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
5064 get_group_flags (entry), i, name, group_name, size);
5066 printf (_(" [Index] Name\n"));
5069 group->group_index = i;
5071 for (j = 0; j < size; j++)
5073 struct group_list * g;
5075 entry = byte_get (indices, 4);
5078 if (entry >= elf_header.e_shnum)
5080 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
5081 entry, i, elf_header.e_shnum - 1);
5085 if (section_headers_groups [entry] != NULL)
5089 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
5091 section_headers_groups [entry]->group_index);
5096 /* Intel C/C++ compiler may put section 0 in a
5097 section group. We just warn it the first time
5098 and ignore it afterwards. */
5099 static int warned = 0;
5102 error (_("section 0 in group section [%5u]\n"),
5103 section_headers_groups [entry]->group_index);
5109 section_headers_groups [entry] = group;
5111 if (do_section_groups)
5113 sec = section_headers + entry;
5114 printf (" [%5u] %s\n", entry, SECTION_NAME (sec));
5117 g = (struct group_list *) xmalloc (sizeof (struct group_list));
5118 g->section_index = entry;
5119 g->next = group->root;
5137 /* Data used to display dynamic fixups. */
5139 struct ia64_vms_dynfixup
5141 bfd_vma needed_ident; /* Library ident number. */
5142 bfd_vma needed; /* Index in the dstrtab of the library name. */
5143 bfd_vma fixup_needed; /* Index of the library. */
5144 bfd_vma fixup_rela_cnt; /* Number of fixups. */
5145 bfd_vma fixup_rela_off; /* Fixups offset in the dynamic segment. */
5148 /* Data used to display dynamic relocations. */
5150 struct ia64_vms_dynimgrela
5152 bfd_vma img_rela_cnt; /* Number of relocations. */
5153 bfd_vma img_rela_off; /* Reloc offset in the dynamic segment. */
5156 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
5160 dump_ia64_vms_dynamic_fixups (FILE *file, struct ia64_vms_dynfixup *fixup,
5161 const char *strtab, unsigned int strtab_sz)
5163 Elf64_External_VMS_IMAGE_FIXUP *imfs;
5165 const char *lib_name;
5167 imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
5168 1, fixup->fixup_rela_cnt * sizeof (*imfs),
5169 _("dynamic section image fixups"));
5173 if (fixup->needed < strtab_sz)
5174 lib_name = strtab + fixup->needed;
5177 warn ("corrupt library name index of 0x%lx found in dynamic entry",
5178 (unsigned long) fixup->needed);
5181 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
5182 (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
5184 (_("Seg Offset Type SymVec DataType\n"));
5186 for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
5191 printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
5192 printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
5193 type = BYTE_GET (imfs [i].type);
5194 rtype = elf_ia64_reloc_type (type);
5196 printf (" 0x%08x ", type);
5198 printf (" %-32s ", rtype);
5199 printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
5200 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
5206 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
5209 dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
5211 Elf64_External_VMS_IMAGE_RELA *imrs;
5214 imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
5215 1, imgrela->img_rela_cnt * sizeof (*imrs),
5216 _("dynamic section image relas"));
5220 printf (_("\nImage relocs\n"));
5222 (_("Seg Offset Type Addend Seg Sym Off\n"));
5224 for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
5229 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
5230 printf ("%08" BFD_VMA_FMT "x ",
5231 (bfd_vma) BYTE_GET (imrs [i].rela_offset));
5232 type = BYTE_GET (imrs [i].type);
5233 rtype = elf_ia64_reloc_type (type);
5235 printf ("0x%08x ", type);
5237 printf ("%-31s ", rtype);
5238 print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
5239 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
5240 printf ("%08" BFD_VMA_FMT "x\n",
5241 (bfd_vma) BYTE_GET (imrs [i].sym_offset));
5247 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
5250 process_ia64_vms_dynamic_relocs (FILE *file)
5252 struct ia64_vms_dynfixup fixup;
5253 struct ia64_vms_dynimgrela imgrela;
5254 Elf_Internal_Dyn *entry;
5256 bfd_vma strtab_off = 0;
5257 bfd_vma strtab_sz = 0;
5258 char *strtab = NULL;
5260 memset (&fixup, 0, sizeof (fixup));
5261 memset (&imgrela, 0, sizeof (imgrela));
5263 /* Note: the order of the entries is specified by the OpenVMS specs. */
5264 for (entry = dynamic_section;
5265 entry < dynamic_section + dynamic_nent;
5268 switch (entry->d_tag)
5270 case DT_IA_64_VMS_STRTAB_OFFSET:
5271 strtab_off = entry->d_un.d_val;
5274 strtab_sz = entry->d_un.d_val;
5276 strtab = get_data (NULL, file, dynamic_addr + strtab_off,
5277 1, strtab_sz, _("dynamic string section"));
5280 case DT_IA_64_VMS_NEEDED_IDENT:
5281 fixup.needed_ident = entry->d_un.d_val;
5284 fixup.needed = entry->d_un.d_val;
5286 case DT_IA_64_VMS_FIXUP_NEEDED:
5287 fixup.fixup_needed = entry->d_un.d_val;
5289 case DT_IA_64_VMS_FIXUP_RELA_CNT:
5290 fixup.fixup_rela_cnt = entry->d_un.d_val;
5292 case DT_IA_64_VMS_FIXUP_RELA_OFF:
5293 fixup.fixup_rela_off = entry->d_un.d_val;
5295 dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz);
5298 case DT_IA_64_VMS_IMG_RELA_CNT:
5299 imgrela.img_rela_cnt = entry->d_un.d_val;
5301 case DT_IA_64_VMS_IMG_RELA_OFF:
5302 imgrela.img_rela_off = entry->d_un.d_val;
5304 dump_ia64_vms_dynamic_relocs (file, &imgrela);
5324 } dynamic_relocations [] =
5326 { "REL", DT_REL, DT_RELSZ, FALSE },
5327 { "RELA", DT_RELA, DT_RELASZ, TRUE },
5328 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
5331 /* Process the reloc section. */
5334 process_relocs (FILE * file)
5336 unsigned long rel_size;
5337 unsigned long rel_offset;
5343 if (do_using_dynamic)
5347 int has_dynamic_reloc;
5350 has_dynamic_reloc = 0;
5352 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
5354 is_rela = dynamic_relocations [i].rela;
5355 name = dynamic_relocations [i].name;
5356 rel_size = dynamic_info [dynamic_relocations [i].size];
5357 rel_offset = dynamic_info [dynamic_relocations [i].reloc];
5359 has_dynamic_reloc |= rel_size;
5361 if (is_rela == UNKNOWN)
5363 if (dynamic_relocations [i].reloc == DT_JMPREL)
5364 switch (dynamic_info[DT_PLTREL])
5378 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
5379 name, rel_offset, rel_size);
5381 dump_relocations (file,
5382 offset_from_vma (file, rel_offset, rel_size),
5384 dynamic_symbols, num_dynamic_syms,
5385 dynamic_strings, dynamic_strings_length, is_rela);
5390 has_dynamic_reloc |= process_ia64_vms_dynamic_relocs (file);
5392 if (! has_dynamic_reloc)
5393 printf (_("\nThere are no dynamic relocations in this file.\n"));
5397 Elf_Internal_Shdr * section;
5401 for (i = 0, section = section_headers;
5402 i < elf_header.e_shnum;
5405 if ( section->sh_type != SHT_RELA
5406 && section->sh_type != SHT_REL)
5409 rel_offset = section->sh_offset;
5410 rel_size = section->sh_size;
5414 Elf_Internal_Shdr * strsec;
5417 printf (_("\nRelocation section "));
5419 if (string_table == NULL)
5420 printf ("%d", section->sh_name);
5422 printf (_("'%s'"), SECTION_NAME (section));
5424 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5425 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
5427 is_rela = section->sh_type == SHT_RELA;
5429 if (section->sh_link != 0
5430 && section->sh_link < elf_header.e_shnum)
5432 Elf_Internal_Shdr * symsec;
5433 Elf_Internal_Sym * symtab;
5434 unsigned long nsyms;
5435 unsigned long strtablen = 0;
5436 char * strtab = NULL;
5438 symsec = section_headers + section->sh_link;
5439 if (symsec->sh_type != SHT_SYMTAB
5440 && symsec->sh_type != SHT_DYNSYM)
5443 nsyms = symsec->sh_size / symsec->sh_entsize;
5444 symtab = GET_ELF_SYMBOLS (file, symsec);
5449 if (symsec->sh_link != 0
5450 && symsec->sh_link < elf_header.e_shnum)
5452 strsec = section_headers + symsec->sh_link;
5454 strtab = (char *) get_data (NULL, file, strsec->sh_offset,
5457 strtablen = strtab == NULL ? 0 : strsec->sh_size;
5460 dump_relocations (file, rel_offset, rel_size,
5461 symtab, nsyms, strtab, strtablen, is_rela);
5467 dump_relocations (file, rel_offset, rel_size,
5468 NULL, 0, NULL, 0, is_rela);
5475 printf (_("\nThere are no relocations in this file.\n"));
5481 /* Process the unwind section. */
5483 #include "unwind-ia64.h"
5485 /* An absolute address consists of a section and an offset. If the
5486 section is NULL, the offset itself is the address, otherwise, the
5487 address equals to LOAD_ADDRESS(section) + offset. */
5491 unsigned short section;
5495 #define ABSADDR(a) \
5497 ? section_headers [(a).section].sh_addr + (a).offset \
5500 struct ia64_unw_table_entry
5502 struct absaddr start;
5504 struct absaddr info;
5507 struct ia64_unw_aux_info
5510 struct ia64_unw_table_entry *table; /* Unwind table. */
5511 unsigned long table_len; /* Length of unwind table. */
5512 unsigned char * info; /* Unwind info. */
5513 unsigned long info_size; /* Size of unwind info. */
5514 bfd_vma info_addr; /* starting address of unwind info. */
5515 bfd_vma seg_base; /* Starting address of segment. */
5516 Elf_Internal_Sym * symtab; /* The symbol table. */
5517 unsigned long nsyms; /* Number of symbols. */
5518 char * strtab; /* The string table. */
5519 unsigned long strtab_size; /* Size of string table. */
5523 find_symbol_for_address (Elf_Internal_Sym * symtab,
5524 unsigned long nsyms,
5525 const char * strtab,
5526 unsigned long strtab_size,
5527 struct absaddr addr,
5528 const char ** symname,
5531 bfd_vma dist = 0x100000;
5532 Elf_Internal_Sym * sym;
5533 Elf_Internal_Sym * best = NULL;
5536 REMOVE_ARCH_BITS (addr.offset);
5538 for (i = 0, sym = symtab; i < nsyms; ++i, ++sym)
5540 bfd_vma value = sym->st_value;
5542 REMOVE_ARCH_BITS (value);
5544 if (ELF_ST_TYPE (sym->st_info) == STT_FUNC
5545 && sym->st_name != 0
5546 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
5547 && addr.offset >= value
5548 && addr.offset - value < dist)
5551 dist = addr.offset - value;
5558 *symname = (best->st_name >= strtab_size
5559 ? _("<corrupt>") : strtab + best->st_name);
5564 *offset = addr.offset;
5568 dump_ia64_unwind (struct ia64_unw_aux_info * aux)
5570 struct ia64_unw_table_entry * tp;
5573 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
5577 const unsigned char * dp;
5578 const unsigned char * head;
5579 const char * procname;
5581 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
5582 aux->strtab_size, tp->start, &procname, &offset);
5584 fputs ("\n<", stdout);
5588 fputs (procname, stdout);
5591 printf ("+%lx", (unsigned long) offset);
5594 fputs (">: [", stdout);
5595 print_vma (tp->start.offset, PREFIX_HEX);
5596 fputc ('-', stdout);
5597 print_vma (tp->end.offset, PREFIX_HEX);
5598 printf ("], info at +0x%lx\n",
5599 (unsigned long) (tp->info.offset - aux->seg_base));
5601 head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
5602 stamp = byte_get ((unsigned char *) head, sizeof (stamp));
5604 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
5605 (unsigned) UNW_VER (stamp),
5606 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
5607 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
5608 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
5609 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
5611 if (UNW_VER (stamp) != 1)
5613 printf (_("\tUnknown version.\n"));
5618 for (dp = head + 8; dp < head + 8 + eh_addr_size * UNW_LENGTH (stamp);)
5619 dp = unw_decode (dp, in_body, & in_body);
5624 slurp_ia64_unwind_table (FILE * file,
5625 struct ia64_unw_aux_info * aux,
5626 Elf_Internal_Shdr * sec)
5628 unsigned long size, nrelas, i;
5629 Elf_Internal_Phdr * seg;
5630 struct ia64_unw_table_entry * tep;
5631 Elf_Internal_Shdr * relsec;
5632 Elf_Internal_Rela * rela;
5633 Elf_Internal_Rela * rp;
5634 unsigned char * table;
5636 Elf_Internal_Sym * sym;
5637 const char * relname;
5639 /* First, find the starting address of the segment that includes
5642 if (elf_header.e_phnum)
5644 if (! get_program_headers (file))
5647 for (seg = program_headers;
5648 seg < program_headers + elf_header.e_phnum;
5651 if (seg->p_type != PT_LOAD)
5654 if (sec->sh_addr >= seg->p_vaddr
5655 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
5657 aux->seg_base = seg->p_vaddr;
5663 /* Second, build the unwind table from the contents of the unwind section: */
5664 size = sec->sh_size;
5665 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
5670 aux->table = (struct ia64_unw_table_entry *)
5671 xcmalloc (size / (3 * eh_addr_size), sizeof (aux->table[0]));
5673 for (tp = table; tp < table + size; ++tep)
5675 tep->start.section = SHN_UNDEF;
5676 tep->end.section = SHN_UNDEF;
5677 tep->info.section = SHN_UNDEF;
5678 tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
5679 tep->end.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
5680 tep->info.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
5681 tep->start.offset += aux->seg_base;
5682 tep->end.offset += aux->seg_base;
5683 tep->info.offset += aux->seg_base;
5687 /* Third, apply any relocations to the unwind table: */
5688 for (relsec = section_headers;
5689 relsec < section_headers + elf_header.e_shnum;
5692 if (relsec->sh_type != SHT_RELA
5693 || relsec->sh_info >= elf_header.e_shnum
5694 || section_headers + relsec->sh_info != sec)
5697 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
5701 for (rp = rela; rp < rela + nrelas; ++rp)
5703 relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
5704 sym = aux->symtab + get_reloc_symindex (rp->r_info);
5706 if (! const_strneq (relname, "R_IA64_SEGREL"))
5708 warn (_("Skipping unexpected relocation type %s\n"), relname);
5712 i = rp->r_offset / (3 * eh_addr_size);
5714 switch (rp->r_offset/eh_addr_size % 3)
5717 aux->table[i].start.section = sym->st_shndx;
5718 aux->table[i].start.offset = rp->r_addend + sym->st_value;
5721 aux->table[i].end.section = sym->st_shndx;
5722 aux->table[i].end.offset = rp->r_addend + sym->st_value;
5725 aux->table[i].info.section = sym->st_shndx;
5726 aux->table[i].info.offset = rp->r_addend + sym->st_value;
5736 aux->table_len = size / (3 * eh_addr_size);
5741 ia64_process_unwind (FILE * file)
5743 Elf_Internal_Shdr * sec;
5744 Elf_Internal_Shdr * unwsec = NULL;
5745 Elf_Internal_Shdr * strsec;
5746 unsigned long i, unwcount = 0, unwstart = 0;
5747 struct ia64_unw_aux_info aux;
5749 memset (& aux, 0, sizeof (aux));
5751 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
5753 if (sec->sh_type == SHT_SYMTAB
5754 && sec->sh_link < elf_header.e_shnum)
5756 aux.nsyms = sec->sh_size / sec->sh_entsize;
5757 aux.symtab = GET_ELF_SYMBOLS (file, sec);
5759 strsec = section_headers + sec->sh_link;
5760 assert (aux.strtab == NULL);
5761 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
5764 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
5766 else if (sec->sh_type == SHT_IA_64_UNWIND)
5771 printf (_("\nThere are no unwind sections in this file.\n"));
5773 while (unwcount-- > 0)
5778 for (i = unwstart, sec = section_headers + unwstart;
5779 i < elf_header.e_shnum; ++i, ++sec)
5780 if (sec->sh_type == SHT_IA_64_UNWIND)
5787 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
5789 if ((unwsec->sh_flags & SHF_GROUP) != 0)
5791 /* We need to find which section group it is in. */
5792 struct group_list * g = section_headers_groups [i]->root;
5794 for (; g != NULL; g = g->next)
5796 sec = section_headers + g->section_index;
5798 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
5803 i = elf_header.e_shnum;
5805 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
5807 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
5808 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
5809 suffix = SECTION_NAME (unwsec) + len;
5810 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
5812 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
5813 && streq (SECTION_NAME (sec) + len2, suffix))
5818 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
5819 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
5820 len = sizeof (ELF_STRING_ia64_unwind) - 1;
5821 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
5823 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
5824 suffix = SECTION_NAME (unwsec) + len;
5825 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
5827 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
5828 && streq (SECTION_NAME (sec) + len2, suffix))
5832 if (i == elf_header.e_shnum)
5834 printf (_("\nCould not find unwind info section for "));
5836 if (string_table == NULL)
5837 printf ("%d", unwsec->sh_name);
5839 printf (_("'%s'"), SECTION_NAME (unwsec));
5843 aux.info_addr = sec->sh_addr;
5844 aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
5847 aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
5849 printf (_("\nUnwind section "));
5851 if (string_table == NULL)
5852 printf ("%d", unwsec->sh_name);
5854 printf (_("'%s'"), SECTION_NAME (unwsec));
5856 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5857 (unsigned long) unwsec->sh_offset,
5858 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
5860 (void) slurp_ia64_unwind_table (file, & aux, unwsec);
5862 if (aux.table_len > 0)
5863 dump_ia64_unwind (& aux);
5866 free ((char *) aux.table);
5868 free ((char *) aux.info);
5877 free ((char *) aux.strtab);
5882 struct hppa_unw_table_entry
5884 struct absaddr start;
5886 unsigned int Cannot_unwind:1; /* 0 */
5887 unsigned int Millicode:1; /* 1 */
5888 unsigned int Millicode_save_sr0:1; /* 2 */
5889 unsigned int Region_description:2; /* 3..4 */
5890 unsigned int reserved1:1; /* 5 */
5891 unsigned int Entry_SR:1; /* 6 */
5892 unsigned int Entry_FR:4; /* number saved */ /* 7..10 */
5893 unsigned int Entry_GR:5; /* number saved */ /* 11..15 */
5894 unsigned int Args_stored:1; /* 16 */
5895 unsigned int Variable_Frame:1; /* 17 */
5896 unsigned int Separate_Package_Body:1; /* 18 */
5897 unsigned int Frame_Extension_Millicode:1; /* 19 */
5898 unsigned int Stack_Overflow_Check:1; /* 20 */
5899 unsigned int Two_Instruction_SP_Increment:1; /* 21 */
5900 unsigned int Ada_Region:1; /* 22 */
5901 unsigned int cxx_info:1; /* 23 */
5902 unsigned int cxx_try_catch:1; /* 24 */
5903 unsigned int sched_entry_seq:1; /* 25 */
5904 unsigned int reserved2:1; /* 26 */
5905 unsigned int Save_SP:1; /* 27 */
5906 unsigned int Save_RP:1; /* 28 */
5907 unsigned int Save_MRP_in_frame:1; /* 29 */
5908 unsigned int extn_ptr_defined:1; /* 30 */
5909 unsigned int Cleanup_defined:1; /* 31 */
5911 unsigned int MPE_XL_interrupt_marker:1; /* 0 */
5912 unsigned int HP_UX_interrupt_marker:1; /* 1 */
5913 unsigned int Large_frame:1; /* 2 */
5914 unsigned int Pseudo_SP_Set:1; /* 3 */
5915 unsigned int reserved4:1; /* 4 */
5916 unsigned int Total_frame_size:27; /* 5..31 */
5919 struct hppa_unw_aux_info
5921 struct hppa_unw_table_entry *table; /* Unwind table. */
5922 unsigned long table_len; /* Length of unwind table. */
5923 bfd_vma seg_base; /* Starting address of segment. */
5924 Elf_Internal_Sym * symtab; /* The symbol table. */
5925 unsigned long nsyms; /* Number of symbols. */
5926 char * strtab; /* The string table. */
5927 unsigned long strtab_size; /* Size of string table. */
5931 dump_hppa_unwind (struct hppa_unw_aux_info * aux)
5933 struct hppa_unw_table_entry * tp;
5935 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
5938 const char * procname;
5940 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
5941 aux->strtab_size, tp->start, &procname,
5944 fputs ("\n<", stdout);
5948 fputs (procname, stdout);
5951 printf ("+%lx", (unsigned long) offset);
5954 fputs (">: [", stdout);
5955 print_vma (tp->start.offset, PREFIX_HEX);
5956 fputc ('-', stdout);
5957 print_vma (tp->end.offset, PREFIX_HEX);
5960 #define PF(_m) if (tp->_m) printf (#_m " ");
5961 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
5964 PF(Millicode_save_sr0);
5965 /* PV(Region_description); */
5971 PF(Separate_Package_Body);
5972 PF(Frame_Extension_Millicode);
5973 PF(Stack_Overflow_Check);
5974 PF(Two_Instruction_SP_Increment);
5978 PF(sched_entry_seq);
5981 PF(Save_MRP_in_frame);
5982 PF(extn_ptr_defined);
5983 PF(Cleanup_defined);
5984 PF(MPE_XL_interrupt_marker);
5985 PF(HP_UX_interrupt_marker);
5988 PV(Total_frame_size);
5997 slurp_hppa_unwind_table (FILE * file,
5998 struct hppa_unw_aux_info * aux,
5999 Elf_Internal_Shdr * sec)
6001 unsigned long size, unw_ent_size, nentries, nrelas, i;
6002 Elf_Internal_Phdr * seg;
6003 struct hppa_unw_table_entry * tep;
6004 Elf_Internal_Shdr * relsec;
6005 Elf_Internal_Rela * rela;
6006 Elf_Internal_Rela * rp;
6007 unsigned char * table;
6009 Elf_Internal_Sym * sym;
6010 const char * relname;
6012 /* First, find the starting address of the segment that includes
6015 if (elf_header.e_phnum)
6017 if (! get_program_headers (file))
6020 for (seg = program_headers;
6021 seg < program_headers + elf_header.e_phnum;
6024 if (seg->p_type != PT_LOAD)
6027 if (sec->sh_addr >= seg->p_vaddr
6028 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
6030 aux->seg_base = seg->p_vaddr;
6036 /* Second, build the unwind table from the contents of the unwind
6038 size = sec->sh_size;
6039 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
6045 nentries = size / unw_ent_size;
6046 size = unw_ent_size * nentries;
6048 tep = aux->table = (struct hppa_unw_table_entry *)
6049 xcmalloc (nentries, sizeof (aux->table[0]));
6051 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
6053 unsigned int tmp1, tmp2;
6055 tep->start.section = SHN_UNDEF;
6056 tep->end.section = SHN_UNDEF;
6058 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
6059 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
6060 tmp1 = byte_get ((unsigned char *) tp + 8, 4);
6061 tmp2 = byte_get ((unsigned char *) tp + 12, 4);
6063 tep->start.offset += aux->seg_base;
6064 tep->end.offset += aux->seg_base;
6066 tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
6067 tep->Millicode = (tmp1 >> 30) & 0x1;
6068 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
6069 tep->Region_description = (tmp1 >> 27) & 0x3;
6070 tep->reserved1 = (tmp1 >> 26) & 0x1;
6071 tep->Entry_SR = (tmp1 >> 25) & 0x1;
6072 tep->Entry_FR = (tmp1 >> 21) & 0xf;
6073 tep->Entry_GR = (tmp1 >> 16) & 0x1f;
6074 tep->Args_stored = (tmp1 >> 15) & 0x1;
6075 tep->Variable_Frame = (tmp1 >> 14) & 0x1;
6076 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
6077 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
6078 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
6079 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
6080 tep->Ada_Region = (tmp1 >> 9) & 0x1;
6081 tep->cxx_info = (tmp1 >> 8) & 0x1;
6082 tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
6083 tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
6084 tep->reserved2 = (tmp1 >> 5) & 0x1;
6085 tep->Save_SP = (tmp1 >> 4) & 0x1;
6086 tep->Save_RP = (tmp1 >> 3) & 0x1;
6087 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
6088 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
6089 tep->Cleanup_defined = tmp1 & 0x1;
6091 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
6092 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
6093 tep->Large_frame = (tmp2 >> 29) & 0x1;
6094 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
6095 tep->reserved4 = (tmp2 >> 27) & 0x1;
6096 tep->Total_frame_size = tmp2 & 0x7ffffff;
6100 /* Third, apply any relocations to the unwind table. */
6101 for (relsec = section_headers;
6102 relsec < section_headers + elf_header.e_shnum;
6105 if (relsec->sh_type != SHT_RELA
6106 || relsec->sh_info >= elf_header.e_shnum
6107 || section_headers + relsec->sh_info != sec)
6110 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6114 for (rp = rela; rp < rela + nrelas; ++rp)
6116 relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
6117 sym = aux->symtab + get_reloc_symindex (rp->r_info);
6119 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
6120 if (! const_strneq (relname, "R_PARISC_SEGREL"))
6122 warn (_("Skipping unexpected relocation type %s\n"), relname);
6126 i = rp->r_offset / unw_ent_size;
6128 switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
6131 aux->table[i].start.section = sym->st_shndx;
6132 aux->table[i].start.offset = sym->st_value + rp->r_addend;
6135 aux->table[i].end.section = sym->st_shndx;
6136 aux->table[i].end.offset = sym->st_value + rp->r_addend;
6146 aux->table_len = nentries;
6152 hppa_process_unwind (FILE * file)
6154 struct hppa_unw_aux_info aux;
6155 Elf_Internal_Shdr * unwsec = NULL;
6156 Elf_Internal_Shdr * strsec;
6157 Elf_Internal_Shdr * sec;
6160 memset (& aux, 0, sizeof (aux));
6162 if (string_table == NULL)
6165 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6167 if (sec->sh_type == SHT_SYMTAB
6168 && sec->sh_link < elf_header.e_shnum)
6170 aux.nsyms = sec->sh_size / sec->sh_entsize;
6171 aux.symtab = GET_ELF_SYMBOLS (file, sec);
6173 strsec = section_headers + sec->sh_link;
6174 assert (aux.strtab == NULL);
6175 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6178 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
6180 else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
6185 printf (_("\nThere are no unwind sections in this file.\n"));
6187 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6189 if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
6191 printf (_("\nUnwind section "));
6192 printf (_("'%s'"), SECTION_NAME (sec));
6194 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6195 (unsigned long) sec->sh_offset,
6196 (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
6198 slurp_hppa_unwind_table (file, &aux, sec);
6199 if (aux.table_len > 0)
6200 dump_hppa_unwind (&aux);
6203 free ((char *) aux.table);
6211 free ((char *) aux.strtab);
6218 unsigned char *data;
6220 Elf_Internal_Shdr *sec;
6221 Elf_Internal_Rela *rela;
6222 unsigned long nrelas;
6223 unsigned int rel_type;
6225 Elf_Internal_Rela *next_rela;
6228 struct arm_unw_aux_info
6232 Elf_Internal_Sym *symtab; /* The symbol table. */
6233 unsigned long nsyms; /* Number of symbols. */
6234 char *strtab; /* The string table. */
6235 unsigned long strtab_size; /* Size of string table. */
6239 arm_print_vma_and_name (struct arm_unw_aux_info *aux,
6240 bfd_vma fn, struct absaddr addr)
6242 const char *procname;
6245 if (addr.section == SHN_UNDEF)
6248 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6249 aux->strtab_size, addr, &procname,
6252 print_vma (fn, PREFIX_HEX);
6256 fputs (" <", stdout);
6257 fputs (procname, stdout);
6260 printf ("+0x%lx", (unsigned long) sym_offset);
6261 fputc ('>', stdout);
6268 arm_free_section (struct arm_section *arm_sec)
6270 if (arm_sec->data != NULL)
6271 free (arm_sec->data);
6273 if (arm_sec->rela != NULL)
6274 free (arm_sec->rela);
6278 arm_section_get_word (struct arm_unw_aux_info *aux,
6279 struct arm_section *arm_sec,
6280 Elf_Internal_Shdr *sec, bfd_vma word_offset,
6281 unsigned int *wordp, struct absaddr *addr)
6283 Elf_Internal_Rela *rp;
6284 Elf_Internal_Sym *sym;
6285 const char * relname;
6287 bfd_boolean wrapped;
6289 addr->section = SHN_UNDEF;
6292 if (sec != arm_sec->sec)
6294 Elf_Internal_Shdr *relsec;
6296 arm_free_section (arm_sec);
6299 arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
6300 sec->sh_size, _("unwind data"));
6301 arm_sec->rela = NULL;
6302 arm_sec->nrelas = 0;
6304 for (relsec = section_headers;
6305 relsec < section_headers + elf_header.e_shnum;
6308 if (relsec->sh_info >= elf_header.e_shnum
6309 || section_headers + relsec->sh_info != sec)
6312 if (relsec->sh_type == SHT_REL)
6314 if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
6316 & arm_sec->rela, & arm_sec->nrelas))
6320 else if (relsec->sh_type == SHT_RELA)
6322 if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
6324 & arm_sec->rela, & arm_sec->nrelas))
6330 arm_sec->next_rela = arm_sec->rela;
6333 if (arm_sec->data == NULL)
6336 word = byte_get (arm_sec->data + word_offset, 4);
6339 for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
6341 bfd_vma prelval, offset;
6343 if (rp->r_offset > word_offset && !wrapped)
6348 if (rp->r_offset > word_offset)
6351 if (rp->r_offset & 3)
6353 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
6354 (unsigned long) rp->r_offset);
6358 if (rp->r_offset < word_offset)
6361 switch (elf_header.e_machine)
6364 relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
6368 relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
6375 if (streq (relname, "R_ARM_NONE")
6376 || streq (relname, "R_C6000_NONE"))
6379 if (!(streq (relname, "R_ARM_PREL31")
6380 || streq (relname, "R_C6000_PREL31")))
6382 warn (_("Skipping unexpected relocation type %s\n"), relname);
6386 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
6388 if (arm_sec->rel_type == SHT_REL)
6390 offset = word & 0x7fffffff;
6391 if (offset & 0x40000000)
6392 offset |= ~ (bfd_vma) 0x7fffffff;
6395 offset = rp->r_addend;
6397 offset += sym->st_value;
6398 prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
6400 if (streq (relname, "R_C6000_PREL31"))
6403 word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
6404 addr->section = sym->st_shndx;
6405 addr->offset = offset;
6410 arm_sec->next_rela = rp;
6415 static const char *tic6x_unwind_regnames[16] = {
6416 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
6417 "A14", "A13", "A12", "A11", "A10",
6418 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"};
6421 decode_tic6x_unwind_regmask (unsigned int mask)
6425 for (i = 12; mask; mask >>= 1, i--)
6429 fputs (tic6x_unwind_regnames[i], stdout);
6431 fputs (", ", stdout);
6437 if (remaining == 0 && more_words) \
6440 if (!arm_section_get_word (aux, data_arm_sec, data_sec, \
6441 data_offset, &word, &addr)) \
6447 #define GET_OP(OP) \
6452 (OP) = word >> 24; \
6457 printf (_("[Truncated opcode]\n")); \
6460 printf ("0x%02x ", OP)
6463 decode_arm_unwind_bytecode (struct arm_unw_aux_info *aux,
6464 unsigned int word, unsigned int remaining,
6465 unsigned int more_words,
6466 bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
6467 struct arm_section *data_arm_sec)
6469 struct absaddr addr;
6471 /* Decode the unwinding instructions. */
6474 unsigned int op, op2;
6483 printf (" 0x%02x ", op);
6485 if ((op & 0xc0) == 0x00)
6487 int offset = ((op & 0x3f) << 2) + 4;
6489 printf (" vsp = vsp + %d", offset);
6491 else if ((op & 0xc0) == 0x40)
6493 int offset = ((op & 0x3f) << 2) + 4;
6495 printf (" vsp = vsp - %d", offset);
6497 else if ((op & 0xf0) == 0x80)
6500 if (op == 0x80 && op2 == 0)
6501 printf (_("Refuse to unwind"));
6504 unsigned int mask = ((op & 0x0f) << 8) | op2;
6509 for (i = 0; i < 12; i++)
6510 if (mask & (1 << i))
6516 printf ("r%d", 4 + i);
6521 else if ((op & 0xf0) == 0x90)
6523 if (op == 0x9d || op == 0x9f)
6524 printf (_(" [Reserved]"));
6526 printf (" vsp = r%d", op & 0x0f);
6528 else if ((op & 0xf0) == 0xa0)
6530 int end = 4 + (op & 0x07);
6535 for (i = 4; i <= end; i++)
6551 else if (op == 0xb0)
6552 printf (_(" finish"));
6553 else if (op == 0xb1)
6556 if (op2 == 0 || (op2 & 0xf0) != 0)
6557 printf (_("[Spare]"));
6560 unsigned int mask = op2 & 0x0f;
6565 for (i = 0; i < 12; i++)
6566 if (mask & (1 << i))
6577 else if (op == 0xb2)
6579 unsigned char buf[9];
6580 unsigned int i, len;
6581 unsigned long offset;
6583 for (i = 0; i < sizeof (buf); i++)
6586 if ((buf[i] & 0x80) == 0)
6589 assert (i < sizeof (buf));
6590 offset = read_uleb128 (buf, &len);
6591 assert (len == i + 1);
6592 offset = offset * 4 + 0x204;
6593 printf ("vsp = vsp + %ld", offset);
6595 else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
6597 unsigned int first, last;
6604 printf ("pop {D%d", first);
6606 printf ("-D%d", first + last);
6609 else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
6611 unsigned int count = op & 0x07;
6615 printf ("-D%d", 8 + count);
6618 else if (op >= 0xc0 && op <= 0xc5)
6620 unsigned int count = op & 0x07;
6622 printf (" pop {wR10");
6624 printf ("-wR%d", 10 + count);
6627 else if (op == 0xc6)
6629 unsigned int first, last;
6634 printf ("pop {wR%d", first);
6636 printf ("-wR%d", first + last);
6639 else if (op == 0xc7)
6642 if (op2 == 0 || (op2 & 0xf0) != 0)
6643 printf (_("[Spare]"));
6646 unsigned int mask = op2 & 0x0f;
6651 for (i = 0; i < 4; i++)
6652 if (mask & (1 << i))
6658 printf ("wCGR%d", i);
6664 printf (_(" [unsupported opcode]"));
6670 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info *aux,
6671 unsigned int word, unsigned int remaining,
6672 unsigned int more_words,
6673 bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
6674 struct arm_section *data_arm_sec)
6676 struct absaddr addr;
6678 /* Decode the unwinding instructions. */
6681 unsigned int op, op2;
6690 printf (_(" 0x%02x "), op);
6692 if ((op & 0xc0) == 0x00)
6694 int offset = ((op & 0x3f) << 3) + 8;
6695 printf (_(" sp = sp + %d"), offset);
6697 else if ((op & 0xc0) == 0x80)
6700 if (op == 0x80 && op2 == 0)
6701 printf (_("Refuse to unwind"));
6704 unsigned int mask = ((op & 0x1f) << 8) | op2;
6706 printf ("pop compact {");
6710 decode_tic6x_unwind_regmask (mask);
6714 else if ((op & 0xf0) == 0xc0)
6721 unsigned int offset;
6725 /* Scan entire instruction first so that GET_OP output is not
6726 interleaved with disassembly. */
6728 for (i = 0; nregs < (op & 0xf); i++)
6734 regpos[nregs].offset = i * 2;
6735 regpos[nregs].reg = reg;
6742 regpos[nregs].offset = i * 2 + 1;
6743 regpos[nregs].reg = reg;
6748 printf (_("pop frame {"));
6750 for (i = i * 2; i > 0; i--)
6752 if (regpos[reg].offset == i - 1)
6754 name = tic6x_unwind_regnames[regpos[reg].reg];
6761 fputs (name, stdout);
6768 else if (op == 0xd0)
6769 printf (" MOV FP, SP");
6770 else if (op == 0xd1)
6771 printf (" __c6xabi_pop_rts");
6772 else if (op == 0xd2)
6774 unsigned char buf[9];
6775 unsigned int i, len;
6776 unsigned long offset;
6777 for (i = 0; i < sizeof (buf); i++)
6780 if ((buf[i] & 0x80) == 0)
6783 assert (i < sizeof (buf));
6784 offset = read_uleb128 (buf, &len);
6785 assert (len == i + 1);
6786 offset = offset * 8 + 0x408;
6787 printf (_("sp = sp + %ld"), offset);
6789 else if ((op & 0xf0) == 0xe0)
6791 if ((op & 0x0f) == 7)
6794 printf (" MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
6798 printf (_(" [unsupported opcode]"));
6805 expand_prel31 (bfd_vma word, bfd_vma where)
6809 offset = word & 0x7fffffff;
6810 if (offset & 0x40000000)
6811 offset |= ~ (bfd_vma) 0x7fffffff;
6813 if (elf_header.e_machine == EM_TI_C6000)
6816 return offset + where;
6820 decode_arm_unwind (struct arm_unw_aux_info *aux,
6821 unsigned int word, unsigned int remaining,
6822 bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
6823 struct arm_section *data_arm_sec)
6826 unsigned int more_words = 0;
6827 struct absaddr addr;
6831 /* Fetch the first word. */
6832 if (!arm_section_get_word (aux, data_arm_sec, data_sec, data_offset,
6838 if ((word & 0x80000000) == 0)
6840 /* Expand prel31 for personality routine. */
6842 const char *procname;
6844 fn = expand_prel31 (word, data_sec->sh_addr + data_offset);
6845 printf (_(" Personality routine: "));
6846 procname = arm_print_vma_and_name (aux, fn, addr);
6847 fputc ('\n', stdout);
6849 /* The GCC personality routines use the standard compact
6850 encoding, starting with one byte giving the number of
6852 if (procname != NULL
6853 && (const_strneq (procname, "__gcc_personality_v0")
6854 || const_strneq (procname, "__gxx_personality_v0")
6855 || const_strneq (procname, "__gcj_personality_v0")
6856 || const_strneq (procname, "__gnu_objc_personality_v0")))
6863 printf (_(" [Truncated data]\n"));
6866 more_words = word >> 24;
6877 per_index = (word >> 24) & 0x7f;
6878 printf (_(" Compact model %d\n"), per_index);
6885 else if (per_index < 3)
6887 more_words = (word >> 16) & 0xff;
6893 switch (elf_header.e_machine)
6898 decode_arm_unwind_bytecode (aux, word, remaining, more_words,
6899 data_offset, data_sec, data_arm_sec);
6902 printf (" [reserved]\n");
6908 decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
6909 data_offset, data_sec, data_arm_sec);
6911 else if (per_index < 5)
6913 if (((word >> 17) & 0x7f) == 0x7f)
6914 printf (_(" Restore stack from frame pointer\n"));
6916 printf (_(" Stack increment %d\n"), (word >> 14) & 0x1fc);
6917 printf (_(" Registers restored: "));
6919 printf (" (compact) ");
6920 decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
6922 printf (_(" Return register: %s\n"),
6923 tic6x_unwind_regnames[word & 0xf]);
6926 printf (" [reserved]\n");
6933 /* Decode the descriptors. Not implemented. */
6937 dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
6939 struct arm_section exidx_arm_sec, extab_arm_sec;
6940 unsigned int i, exidx_len;
6942 memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
6943 memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
6944 exidx_len = exidx_sec->sh_size / 8;
6946 for (i = 0; i < exidx_len; i++)
6948 unsigned int exidx_fn, exidx_entry;
6949 struct absaddr fn_addr, entry_addr;
6952 fputc ('\n', stdout);
6954 if (!arm_section_get_word (aux, &exidx_arm_sec, exidx_sec,
6955 8 * i, &exidx_fn, &fn_addr)
6956 || !arm_section_get_word (aux, &exidx_arm_sec, exidx_sec,
6957 8 * i + 4, &exidx_entry, &entry_addr))
6959 arm_free_section (&exidx_arm_sec);
6960 arm_free_section (&extab_arm_sec);
6964 fn = expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
6966 arm_print_vma_and_name (aux, fn, entry_addr);
6967 fputs (": ", stdout);
6969 if (exidx_entry == 1)
6971 print_vma (exidx_entry, PREFIX_HEX);
6972 fputs (" [cantunwind]\n", stdout);
6974 else if (exidx_entry & 0x80000000)
6976 print_vma (exidx_entry, PREFIX_HEX);
6977 fputc ('\n', stdout);
6978 decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
6982 bfd_vma table, table_offset = 0;
6983 Elf_Internal_Shdr *table_sec;
6985 fputs ("@", stdout);
6986 table = expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
6987 print_vma (table, PREFIX_HEX);
6990 /* Locate the matching .ARM.extab. */
6991 if (entry_addr.section != SHN_UNDEF
6992 && entry_addr.section < elf_header.e_shnum)
6994 table_sec = section_headers + entry_addr.section;
6995 table_offset = entry_addr.offset;
6999 table_sec = find_section_by_address (table);
7000 if (table_sec != NULL)
7001 table_offset = table - table_sec->sh_addr;
7003 if (table_sec == NULL)
7005 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
7006 (unsigned long) table);
7009 decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
7016 arm_free_section (&exidx_arm_sec);
7017 arm_free_section (&extab_arm_sec);
7020 /* Used for both ARM and C6X unwinding tables. */
7022 arm_process_unwind (FILE *file)
7024 struct arm_unw_aux_info aux;
7025 Elf_Internal_Shdr *unwsec = NULL;
7026 Elf_Internal_Shdr *strsec;
7027 Elf_Internal_Shdr *sec;
7029 unsigned int sec_type;
7031 memset (& aux, 0, sizeof (aux));
7034 switch (elf_header.e_machine)
7037 sec_type = SHT_ARM_EXIDX;
7041 sec_type = SHT_C6000_UNWIND;
7048 if (string_table == NULL)
7051 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7053 if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
7055 aux.nsyms = sec->sh_size / sec->sh_entsize;
7056 aux.symtab = GET_ELF_SYMBOLS (file, sec);
7058 strsec = section_headers + sec->sh_link;
7059 assert (aux.strtab == NULL);
7060 aux.strtab = get_data (NULL, file, strsec->sh_offset,
7061 1, strsec->sh_size, _("string table"));
7062 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7064 else if (sec->sh_type == sec_type)
7069 printf (_("\nThere are no unwind sections in this file.\n"));
7071 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7073 if (sec->sh_type == sec_type)
7075 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
7077 (unsigned long) sec->sh_offset,
7078 (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
7080 dump_arm_unwind (&aux, sec);
7087 free ((char *) aux.strtab);
7093 process_unwind (FILE * file)
7095 struct unwind_handler
7098 int (* handler)(FILE *);
7101 { EM_ARM, arm_process_unwind },
7102 { EM_IA_64, ia64_process_unwind },
7103 { EM_PARISC, hppa_process_unwind },
7104 { EM_TI_C6000, arm_process_unwind },
7112 for (i = 0; handlers[i].handler != NULL; i++)
7113 if (elf_header.e_machine == handlers[i].machtype)
7114 return handlers[i].handler (file);
7116 printf (_("\nThere are no unwind sections in this file.\n"));
7121 dynamic_section_mips_val (Elf_Internal_Dyn * entry)
7123 switch (entry->d_tag)
7126 if (entry->d_un.d_val == 0)
7127 printf (_("NONE\n"));
7130 static const char * opts[] =
7132 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
7133 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
7134 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
7135 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
7141 for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
7142 if (entry->d_un.d_val & (1 << cnt))
7144 printf ("%s%s", first ? "" : " ", opts[cnt]);
7151 case DT_MIPS_IVERSION:
7152 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
7153 printf (_("Interface Version: %s\n"), GET_DYNAMIC_NAME (entry->d_un.d_val));
7155 printf (_("<corrupt: %ld>\n"), (long) entry->d_un.d_ptr);
7158 case DT_MIPS_TIME_STAMP:
7163 time_t atime = entry->d_un.d_val;
7164 tmp = gmtime (&atime);
7165 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
7166 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
7167 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
7168 printf (_("Time Stamp: %s\n"), timebuf);
7172 case DT_MIPS_RLD_VERSION:
7173 case DT_MIPS_LOCAL_GOTNO:
7174 case DT_MIPS_CONFLICTNO:
7175 case DT_MIPS_LIBLISTNO:
7176 case DT_MIPS_SYMTABNO:
7177 case DT_MIPS_UNREFEXTNO:
7178 case DT_MIPS_HIPAGENO:
7179 case DT_MIPS_DELTA_CLASS_NO:
7180 case DT_MIPS_DELTA_INSTANCE_NO:
7181 case DT_MIPS_DELTA_RELOC_NO:
7182 case DT_MIPS_DELTA_SYM_NO:
7183 case DT_MIPS_DELTA_CLASSSYM_NO:
7184 case DT_MIPS_COMPACT_SIZE:
7185 printf ("%ld\n", (long) entry->d_un.d_ptr);
7189 printf ("%#lx\n", (unsigned long) entry->d_un.d_ptr);
7194 dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
7196 switch (entry->d_tag)
7198 case DT_HP_DLD_FLAGS:
7207 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
7208 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
7209 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
7210 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
7211 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
7212 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
7213 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
7214 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
7215 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
7216 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
7217 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
7218 { DT_HP_GST, "HP_GST" },
7219 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
7220 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
7221 { DT_HP_NODELETE, "HP_NODELETE" },
7222 { DT_HP_GROUP, "HP_GROUP" },
7223 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
7227 bfd_vma val = entry->d_un.d_val;
7229 for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
7230 if (val & flags[cnt].bit)
7234 fputs (flags[cnt].str, stdout);
7236 val ^= flags[cnt].bit;
7239 if (val != 0 || first)
7243 print_vma (val, HEX);
7249 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7257 /* VMS vs Unix time offset and factor. */
7259 #define VMS_EPOCH_OFFSET 35067168000000000LL
7260 #define VMS_GRANULARITY_FACTOR 10000000
7262 /* Display a VMS time in a human readable format. */
7265 print_vms_time (bfd_int64_t vmstime)
7270 unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
7271 tm = gmtime (&unxtime);
7272 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
7273 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
7274 tm->tm_hour, tm->tm_min, tm->tm_sec);
7279 dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
7281 switch (entry->d_tag)
7283 case DT_IA_64_PLT_RESERVE:
7284 /* First 3 slots reserved. */
7285 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7287 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
7290 case DT_IA_64_VMS_LINKTIME:
7292 print_vms_time (entry->d_un.d_val);
7296 case DT_IA_64_VMS_LNKFLAGS:
7297 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7298 if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
7299 printf (" CALL_DEBUG");
7300 if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
7301 printf (" NOP0BUFS");
7302 if (entry->d_un.d_val & VMS_LF_P0IMAGE)
7303 printf (" P0IMAGE");
7304 if (entry->d_un.d_val & VMS_LF_MKTHREADS)
7305 printf (" MKTHREADS");
7306 if (entry->d_un.d_val & VMS_LF_UPCALLS)
7307 printf (" UPCALLS");
7308 if (entry->d_un.d_val & VMS_LF_IMGSTA)
7310 if (entry->d_un.d_val & VMS_LF_INITIALIZE)
7311 printf (" INITIALIZE");
7312 if (entry->d_un.d_val & VMS_LF_MAIN)
7314 if (entry->d_un.d_val & VMS_LF_EXE_INIT)
7315 printf (" EXE_INIT");
7316 if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
7317 printf (" TBK_IN_IMG");
7318 if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
7319 printf (" DBG_IN_IMG");
7320 if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
7321 printf (" TBK_IN_DSF");
7322 if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
7323 printf (" DBG_IN_DSF");
7324 if (entry->d_un.d_val & VMS_LF_SIGNATURES)
7325 printf (" SIGNATURES");
7326 if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
7327 printf (" REL_SEG_OFF");
7331 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7338 get_32bit_dynamic_section (FILE * file)
7340 Elf32_External_Dyn * edyn;
7341 Elf32_External_Dyn * ext;
7342 Elf_Internal_Dyn * entry;
7344 edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
7345 dynamic_size, _("dynamic section"));
7349 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
7350 might not have the luxury of section headers. Look for the DT_NULL
7351 terminator to determine the number of entries. */
7352 for (ext = edyn, dynamic_nent = 0;
7353 (char *) ext < (char *) edyn + dynamic_size;
7357 if (BYTE_GET (ext->d_tag) == DT_NULL)
7361 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
7363 if (dynamic_section == NULL)
7365 error (_("Out of memory\n"));
7370 for (ext = edyn, entry = dynamic_section;
7371 entry < dynamic_section + dynamic_nent;
7374 entry->d_tag = BYTE_GET (ext->d_tag);
7375 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
7384 get_64bit_dynamic_section (FILE * file)
7386 Elf64_External_Dyn * edyn;
7387 Elf64_External_Dyn * ext;
7388 Elf_Internal_Dyn * entry;
7390 edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
7391 dynamic_size, _("dynamic section"));
7395 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
7396 might not have the luxury of section headers. Look for the DT_NULL
7397 terminator to determine the number of entries. */
7398 for (ext = edyn, dynamic_nent = 0;
7399 (char *) ext < (char *) edyn + dynamic_size;
7403 if (BYTE_GET (ext->d_tag) == DT_NULL)
7407 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
7409 if (dynamic_section == NULL)
7411 error (_("Out of memory\n"));
7416 for (ext = edyn, entry = dynamic_section;
7417 entry < dynamic_section + dynamic_nent;
7420 entry->d_tag = BYTE_GET (ext->d_tag);
7421 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
7430 print_dynamic_flags (bfd_vma flags)
7438 flag = flags & - flags;
7448 case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
7449 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
7450 case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
7451 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
7452 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
7453 default: fputs (_("unknown"), stdout); break;
7459 /* Parse and display the contents of the dynamic section. */
7462 process_dynamic_section (FILE * file)
7464 Elf_Internal_Dyn * entry;
7466 if (dynamic_size == 0)
7469 printf (_("\nThere is no dynamic section in this file.\n"));
7476 if (! get_32bit_dynamic_section (file))
7479 else if (! get_64bit_dynamic_section (file))
7482 /* Find the appropriate symbol table. */
7483 if (dynamic_symbols == NULL)
7485 for (entry = dynamic_section;
7486 entry < dynamic_section + dynamic_nent;
7489 Elf_Internal_Shdr section;
7491 if (entry->d_tag != DT_SYMTAB)
7494 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
7496 /* Since we do not know how big the symbol table is,
7497 we default to reading in the entire file (!) and
7498 processing that. This is overkill, I know, but it
7500 section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
7502 if (archive_file_offset != 0)
7503 section.sh_size = archive_file_size - section.sh_offset;
7506 if (fseek (file, 0, SEEK_END))
7507 error (_("Unable to seek to end of file!\n"));
7509 section.sh_size = ftell (file) - section.sh_offset;
7513 section.sh_entsize = sizeof (Elf32_External_Sym);
7515 section.sh_entsize = sizeof (Elf64_External_Sym);
7517 num_dynamic_syms = section.sh_size / section.sh_entsize;
7518 if (num_dynamic_syms < 1)
7520 error (_("Unable to determine the number of symbols to load\n"));
7524 dynamic_symbols = GET_ELF_SYMBOLS (file, §ion);
7528 /* Similarly find a string table. */
7529 if (dynamic_strings == NULL)
7531 for (entry = dynamic_section;
7532 entry < dynamic_section + dynamic_nent;
7535 unsigned long offset;
7538 if (entry->d_tag != DT_STRTAB)
7541 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
7543 /* Since we do not know how big the string table is,
7544 we default to reading in the entire file (!) and
7545 processing that. This is overkill, I know, but it
7548 offset = offset_from_vma (file, entry->d_un.d_val, 0);
7550 if (archive_file_offset != 0)
7551 str_tab_len = archive_file_size - offset;
7554 if (fseek (file, 0, SEEK_END))
7555 error (_("Unable to seek to end of file\n"));
7556 str_tab_len = ftell (file) - offset;
7559 if (str_tab_len < 1)
7562 (_("Unable to determine the length of the dynamic string table\n"));
7566 dynamic_strings = (char *) get_data (NULL, file, offset, 1,
7568 _("dynamic string table"));
7569 dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
7574 /* And find the syminfo section if available. */
7575 if (dynamic_syminfo == NULL)
7577 unsigned long syminsz = 0;
7579 for (entry = dynamic_section;
7580 entry < dynamic_section + dynamic_nent;
7583 if (entry->d_tag == DT_SYMINENT)
7585 /* Note: these braces are necessary to avoid a syntax
7586 error from the SunOS4 C compiler. */
7587 assert (sizeof (Elf_External_Syminfo) == entry->d_un.d_val);
7589 else if (entry->d_tag == DT_SYMINSZ)
7590 syminsz = entry->d_un.d_val;
7591 else if (entry->d_tag == DT_SYMINFO)
7592 dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
7596 if (dynamic_syminfo_offset != 0 && syminsz != 0)
7598 Elf_External_Syminfo * extsyminfo;
7599 Elf_External_Syminfo * extsym;
7600 Elf_Internal_Syminfo * syminfo;
7602 /* There is a syminfo section. Read the data. */
7603 extsyminfo = (Elf_External_Syminfo *)
7604 get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
7605 _("symbol information"));
7609 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
7610 if (dynamic_syminfo == NULL)
7612 error (_("Out of memory\n"));
7616 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
7617 for (syminfo = dynamic_syminfo, extsym = extsyminfo;
7618 syminfo < dynamic_syminfo + dynamic_syminfo_nent;
7619 ++syminfo, ++extsym)
7621 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
7622 syminfo->si_flags = BYTE_GET (extsym->si_flags);
7629 if (do_dynamic && dynamic_addr)
7630 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
7631 dynamic_addr, dynamic_nent);
7633 printf (_(" Tag Type Name/Value\n"));
7635 for (entry = dynamic_section;
7636 entry < dynamic_section + dynamic_nent;
7644 print_vma (entry->d_tag, FULL_HEX);
7645 dtype = get_dynamic_type (entry->d_tag);
7646 printf (" (%s)%*s", dtype,
7647 ((is_32bit_elf ? 27 : 19)
7648 - (int) strlen (dtype)),
7652 switch (entry->d_tag)
7656 print_dynamic_flags (entry->d_un.d_val);
7666 switch (entry->d_tag)
7669 printf (_("Auxiliary library"));
7673 printf (_("Filter library"));
7677 printf (_("Configuration file"));
7681 printf (_("Dependency audit library"));
7685 printf (_("Audit library"));
7689 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
7690 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
7694 print_vma (entry->d_un.d_val, PREFIX_HEX);
7703 printf (_("Flags:"));
7705 if (entry->d_un.d_val == 0)
7706 printf (_(" None\n"));
7709 unsigned long int val = entry->d_un.d_val;
7711 if (val & DTF_1_PARINIT)
7713 printf (" PARINIT");
7714 val ^= DTF_1_PARINIT;
7716 if (val & DTF_1_CONFEXP)
7718 printf (" CONFEXP");
7719 val ^= DTF_1_CONFEXP;
7722 printf (" %lx", val);
7731 printf (_("Flags:"));
7733 if (entry->d_un.d_val == 0)
7734 printf (_(" None\n"));
7737 unsigned long int val = entry->d_un.d_val;
7739 if (val & DF_P1_LAZYLOAD)
7741 printf (" LAZYLOAD");
7742 val ^= DF_P1_LAZYLOAD;
7744 if (val & DF_P1_GROUPPERM)
7746 printf (" GROUPPERM");
7747 val ^= DF_P1_GROUPPERM;
7750 printf (" %lx", val);
7759 printf (_("Flags:"));
7760 if (entry->d_un.d_val == 0)
7761 printf (_(" None\n"));
7764 unsigned long int val = entry->d_un.d_val;
7771 if (val & DF_1_GLOBAL)
7776 if (val & DF_1_GROUP)
7781 if (val & DF_1_NODELETE)
7783 printf (" NODELETE");
7784 val ^= DF_1_NODELETE;
7786 if (val & DF_1_LOADFLTR)
7788 printf (" LOADFLTR");
7789 val ^= DF_1_LOADFLTR;
7791 if (val & DF_1_INITFIRST)
7793 printf (" INITFIRST");
7794 val ^= DF_1_INITFIRST;
7796 if (val & DF_1_NOOPEN)
7801 if (val & DF_1_ORIGIN)
7806 if (val & DF_1_DIRECT)
7811 if (val & DF_1_TRANS)
7816 if (val & DF_1_INTERPOSE)
7818 printf (" INTERPOSE");
7819 val ^= DF_1_INTERPOSE;
7821 if (val & DF_1_NODEFLIB)
7823 printf (" NODEFLIB");
7824 val ^= DF_1_NODEFLIB;
7826 if (val & DF_1_NODUMP)
7831 if (val & DF_1_CONLFAT)
7833 printf (" CONLFAT");
7834 val ^= DF_1_CONLFAT;
7837 printf (" %lx", val);
7844 dynamic_info[entry->d_tag] = entry->d_un.d_val;
7846 puts (get_dynamic_type (entry->d_un.d_val));
7866 dynamic_info[entry->d_tag] = entry->d_un.d_val;
7872 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
7873 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
7879 switch (entry->d_tag)
7882 printf (_("Shared library: [%s]"), name);
7884 if (streq (name, program_interpreter))
7885 printf (_(" program interpreter"));
7889 printf (_("Library soname: [%s]"), name);
7893 printf (_("Library rpath: [%s]"), name);
7897 printf (_("Library runpath: [%s]"), name);
7901 print_vma (entry->d_un.d_val, PREFIX_HEX);
7906 print_vma (entry->d_un.d_val, PREFIX_HEX);
7919 dynamic_info[entry->d_tag] = entry->d_un.d_val;
7923 case DT_INIT_ARRAYSZ:
7924 case DT_FINI_ARRAYSZ:
7925 case DT_GNU_CONFLICTSZ:
7926 case DT_GNU_LIBLISTSZ:
7929 print_vma (entry->d_un.d_val, UNSIGNED);
7930 printf (_(" (bytes)\n"));
7940 print_vma (entry->d_un.d_val, UNSIGNED);
7953 if (entry->d_tag == DT_USED
7954 && VALID_DYNAMIC_NAME (entry->d_un.d_val))
7956 char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
7960 printf (_("Not needed object: [%s]\n"), name);
7965 print_vma (entry->d_un.d_val, PREFIX_HEX);
7971 /* The value of this entry is ignored. */
7976 case DT_GNU_PRELINKED:
7980 time_t atime = entry->d_un.d_val;
7982 tmp = gmtime (&atime);
7983 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
7984 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
7985 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
7991 dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
7994 print_vma (entry->d_un.d_val, PREFIX_HEX);
8000 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
8001 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
8006 switch (elf_header.e_machine)
8009 case EM_MIPS_RS3_LE:
8010 dynamic_section_mips_val (entry);
8013 dynamic_section_parisc_val (entry);
8016 dynamic_section_ia64_val (entry);
8019 print_vma (entry->d_un.d_val, PREFIX_HEX);
8031 get_ver_flags (unsigned int flags)
8033 static char buff[32];
8040 if (flags & VER_FLG_BASE)
8041 strcat (buff, "BASE ");
8043 if (flags & VER_FLG_WEAK)
8045 if (flags & VER_FLG_BASE)
8046 strcat (buff, "| ");
8048 strcat (buff, "WEAK ");
8051 if (flags & VER_FLG_INFO)
8053 if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
8054 strcat (buff, "| ");
8056 strcat (buff, "INFO ");
8059 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
8060 strcat (buff, _("| <unknown>"));
8065 /* Display the contents of the version sections. */
8068 process_version_sections (FILE * file)
8070 Elf_Internal_Shdr * section;
8077 for (i = 0, section = section_headers;
8078 i < elf_header.e_shnum;
8081 switch (section->sh_type)
8083 case SHT_GNU_verdef:
8085 Elf_External_Verdef * edefs;
8093 (_("\nVersion definition section '%s' contains %u entries:\n"),
8094 SECTION_NAME (section), section->sh_info);
8096 printf (_(" Addr: 0x"));
8097 printf_vma (section->sh_addr);
8098 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
8099 (unsigned long) section->sh_offset, section->sh_link,
8100 section->sh_link < elf_header.e_shnum
8101 ? SECTION_NAME (section_headers + section->sh_link)
8104 edefs = (Elf_External_Verdef *)
8105 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
8106 _("version definition section"));
8109 endbuf = (char *) edefs + section->sh_size;
8111 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
8114 Elf_External_Verdef * edef;
8115 Elf_Internal_Verdef ent;
8116 Elf_External_Verdaux * eaux;
8117 Elf_Internal_Verdaux aux;
8121 /* Check for negative or very large indicies. */
8122 if ((unsigned char *) edefs + idx < (unsigned char *) edefs)
8125 vstart = ((char *) edefs) + idx;
8126 if (vstart + sizeof (*edef) > endbuf)
8129 edef = (Elf_External_Verdef *) vstart;
8131 ent.vd_version = BYTE_GET (edef->vd_version);
8132 ent.vd_flags = BYTE_GET (edef->vd_flags);
8133 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
8134 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
8135 ent.vd_hash = BYTE_GET (edef->vd_hash);
8136 ent.vd_aux = BYTE_GET (edef->vd_aux);
8137 ent.vd_next = BYTE_GET (edef->vd_next);
8139 printf (_(" %#06x: Rev: %d Flags: %s"),
8140 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
8142 printf (_(" Index: %d Cnt: %d "),
8143 ent.vd_ndx, ent.vd_cnt);
8145 /* Check for overflow. */
8146 if ((unsigned char *)(vstart + ent.vd_aux) < (unsigned char *) vstart
8147 || (unsigned char *)(vstart + ent.vd_aux) > (unsigned char *) endbuf)
8150 vstart += ent.vd_aux;
8152 eaux = (Elf_External_Verdaux *) vstart;
8154 aux.vda_name = BYTE_GET (eaux->vda_name);
8155 aux.vda_next = BYTE_GET (eaux->vda_next);
8157 if (VALID_DYNAMIC_NAME (aux.vda_name))
8158 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
8160 printf (_("Name index: %ld\n"), aux.vda_name);
8162 isum = idx + ent.vd_aux;
8164 for (j = 1; j < ent.vd_cnt; j++)
8166 /* Check for overflow. */
8167 if ((unsigned char *)(vstart + aux.vda_next) < (unsigned char *) vstart
8168 || (unsigned char *)(vstart + aux.vda_next) > (unsigned char *) endbuf)
8171 isum += aux.vda_next;
8172 vstart += aux.vda_next;
8174 eaux = (Elf_External_Verdaux *) vstart;
8175 if (vstart + sizeof (*eaux) > endbuf)
8178 aux.vda_name = BYTE_GET (eaux->vda_name);
8179 aux.vda_next = BYTE_GET (eaux->vda_next);
8181 if (VALID_DYNAMIC_NAME (aux.vda_name))
8182 printf (_(" %#06x: Parent %d: %s\n"),
8183 isum, j, GET_DYNAMIC_NAME (aux.vda_name));
8185 printf (_(" %#06x: Parent %d, name index: %ld\n"),
8186 isum, j, aux.vda_name);
8190 printf (_(" Version def aux past end of section\n"));
8195 if (cnt < section->sh_info)
8196 printf (_(" Version definition past end of section\n"));
8202 case SHT_GNU_verneed:
8204 Elf_External_Verneed * eneed;
8211 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
8212 SECTION_NAME (section), section->sh_info);
8214 printf (_(" Addr: 0x"));
8215 printf_vma (section->sh_addr);
8216 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
8217 (unsigned long) section->sh_offset, section->sh_link,
8218 section->sh_link < elf_header.e_shnum
8219 ? SECTION_NAME (section_headers + section->sh_link)
8222 eneed = (Elf_External_Verneed *) get_data (NULL, file,
8223 section->sh_offset, 1,
8225 _("version need section"));
8228 endbuf = (char *) eneed + section->sh_size;
8230 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
8232 Elf_External_Verneed * entry;
8233 Elf_Internal_Verneed ent;
8238 if ((unsigned char *) eneed + idx < (unsigned char *) eneed)
8241 vstart = ((char *) eneed) + idx;
8242 if (vstart + sizeof (*entry) > endbuf)
8245 entry = (Elf_External_Verneed *) vstart;
8247 ent.vn_version = BYTE_GET (entry->vn_version);
8248 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
8249 ent.vn_file = BYTE_GET (entry->vn_file);
8250 ent.vn_aux = BYTE_GET (entry->vn_aux);
8251 ent.vn_next = BYTE_GET (entry->vn_next);
8253 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
8255 if (VALID_DYNAMIC_NAME (ent.vn_file))
8256 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
8258 printf (_(" File: %lx"), ent.vn_file);
8260 printf (_(" Cnt: %d\n"), ent.vn_cnt);
8262 /* Check for overflow. */
8263 if ((unsigned char *)(vstart + ent.vn_aux) < (unsigned char *) vstart
8264 || (unsigned char *)(vstart + ent.vn_aux) > (unsigned char *) endbuf)
8267 vstart += ent.vn_aux;
8269 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
8271 Elf_External_Vernaux * eaux;
8272 Elf_Internal_Vernaux aux;
8274 if (vstart + sizeof (*eaux) > endbuf)
8276 eaux = (Elf_External_Vernaux *) vstart;
8278 aux.vna_hash = BYTE_GET (eaux->vna_hash);
8279 aux.vna_flags = BYTE_GET (eaux->vna_flags);
8280 aux.vna_other = BYTE_GET (eaux->vna_other);
8281 aux.vna_name = BYTE_GET (eaux->vna_name);
8282 aux.vna_next = BYTE_GET (eaux->vna_next);
8284 if (VALID_DYNAMIC_NAME (aux.vna_name))
8285 printf (_(" %#06x: Name: %s"),
8286 isum, GET_DYNAMIC_NAME (aux.vna_name));
8288 printf (_(" %#06x: Name index: %lx"),
8289 isum, aux.vna_name);
8291 printf (_(" Flags: %s Version: %d\n"),
8292 get_ver_flags (aux.vna_flags), aux.vna_other);
8294 /* Check for overflow. */
8295 if ((unsigned char *)(vstart + aux.vna_next) < (unsigned char *) vstart
8296 || (unsigned char *)(vstart + aux.vna_next) > (unsigned char *) endbuf)
8299 isum += aux.vna_next;
8300 vstart += aux.vna_next;
8303 printf (_(" Version need aux past end of section\n"));
8307 if (cnt < section->sh_info)
8308 printf (_(" Version need past end of section\n"));
8314 case SHT_GNU_versym:
8316 Elf_Internal_Shdr * link_section;
8319 unsigned char * edata;
8320 unsigned short * data;
8322 Elf_Internal_Sym * symbols;
8323 Elf_Internal_Shdr * string_sec;
8326 if (section->sh_link >= elf_header.e_shnum)
8329 link_section = section_headers + section->sh_link;
8330 total = section->sh_size / sizeof (Elf_External_Versym);
8332 if (link_section->sh_link >= elf_header.e_shnum)
8337 symbols = GET_ELF_SYMBOLS (file, link_section);
8338 if (symbols == NULL)
8341 string_sec = section_headers + link_section->sh_link;
8343 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
8344 string_sec->sh_size,
8345 _("version string table"));
8352 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
8353 SECTION_NAME (section), total);
8355 printf (_(" Addr: "));
8356 printf_vma (section->sh_addr);
8357 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
8358 (unsigned long) section->sh_offset, section->sh_link,
8359 SECTION_NAME (link_section));
8361 off = offset_from_vma (file,
8362 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
8363 total * sizeof (short));
8364 edata = (unsigned char *) get_data (NULL, file, off, total,
8366 _("version symbol data"));
8374 data = (short unsigned int *) cmalloc (total, sizeof (short));
8376 for (cnt = total; cnt --;)
8377 data[cnt] = byte_get (edata + cnt * sizeof (short),
8382 for (cnt = 0; cnt < total; cnt += 4)
8385 int check_def, check_need;
8388 printf (" %03x:", cnt);
8390 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
8391 switch (data[cnt + j])
8394 fputs (_(" 0 (*local*) "), stdout);
8398 fputs (_(" 1 (*global*) "), stdout);
8402 nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
8403 data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
8405 /* If this index value is greater than the size of the symbols
8406 array, break to avoid an out-of-bounds read, */
8407 if ((unsigned long)(cnt + j) >=
8408 ((unsigned long)link_section->sh_size /
8409 (unsigned long)link_section->sh_entsize))
8411 warn (_("invalid index into symbol array\n"));
8417 if (symbols[cnt + j].st_shndx >= elf_header.e_shnum
8418 || section_headers[symbols[cnt + j].st_shndx].sh_type
8421 if (symbols[cnt + j].st_shndx == SHN_UNDEF)
8428 && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
8430 Elf_Internal_Verneed ivn;
8431 unsigned long offset;
8433 offset = offset_from_vma
8434 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
8435 sizeof (Elf_External_Verneed));
8439 Elf_Internal_Vernaux ivna;
8440 Elf_External_Verneed evn;
8441 Elf_External_Vernaux evna;
8442 unsigned long a_off;
8444 if (get_data (&evn, file, offset, sizeof (evn), 1,
8445 _("version need")) == NULL)
8448 ivn.vn_aux = BYTE_GET (evn.vn_aux);
8449 ivn.vn_next = BYTE_GET (evn.vn_next);
8451 a_off = offset + ivn.vn_aux;
8455 if (get_data (&evna, file, a_off, sizeof (evna),
8456 1, _("version need aux (2)")) == NULL)
8463 ivna.vna_next = BYTE_GET (evna.vna_next);
8464 ivna.vna_other = BYTE_GET (evna.vna_other);
8467 a_off += ivna.vna_next;
8469 while (ivna.vna_other != data[cnt + j]
8470 && ivna.vna_next != 0);
8472 if (ivna.vna_other == data[cnt + j])
8474 ivna.vna_name = BYTE_GET (evna.vna_name);
8476 if (ivna.vna_name >= string_sec->sh_size)
8477 name = _("*invalid*");
8479 name = strtab + ivna.vna_name;
8480 nn += printf ("(%s%-*s",
8482 12 - (int) strlen (name),
8488 offset += ivn.vn_next;
8490 while (ivn.vn_next);
8493 if (check_def && data[cnt + j] != 0x8001
8494 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
8496 Elf_Internal_Verdef ivd;
8497 Elf_External_Verdef evd;
8498 unsigned long offset;
8500 offset = offset_from_vma
8501 (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
8506 if (get_data (&evd, file, offset, sizeof (evd), 1,
8507 _("version def")) == NULL)
8514 ivd.vd_next = BYTE_GET (evd.vd_next);
8515 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
8518 offset += ivd.vd_next;
8520 while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
8521 && ivd.vd_next != 0);
8523 if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
8525 Elf_External_Verdaux evda;
8526 Elf_Internal_Verdaux ivda;
8528 ivd.vd_aux = BYTE_GET (evd.vd_aux);
8530 if (get_data (&evda, file,
8531 offset - ivd.vd_next + ivd.vd_aux,
8533 _("version def aux")) == NULL)
8536 ivda.vda_name = BYTE_GET (evda.vda_name);
8538 if (ivda.vda_name >= string_sec->sh_size)
8539 name = _("*invalid*");
8541 name = strtab + ivda.vda_name;
8542 nn += printf ("(%s%-*s",
8544 12 - (int) strlen (name),
8550 printf ("%*c", 18 - nn, ' ');
8568 printf (_("\nNo version information found in this file.\n"));
8574 get_symbol_binding (unsigned int binding)
8576 static char buff[32];
8580 case STB_LOCAL: return "LOCAL";
8581 case STB_GLOBAL: return "GLOBAL";
8582 case STB_WEAK: return "WEAK";
8584 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
8585 snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
8587 else if (binding >= STB_LOOS && binding <= STB_HIOS)
8589 if (binding == STB_GNU_UNIQUE
8590 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_LINUX
8591 /* GNU/Linux is still using the default value 0. */
8592 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
8594 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
8597 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
8603 get_symbol_type (unsigned int type)
8605 static char buff[32];
8609 case STT_NOTYPE: return "NOTYPE";
8610 case STT_OBJECT: return "OBJECT";
8611 case STT_FUNC: return "FUNC";
8612 case STT_SECTION: return "SECTION";
8613 case STT_FILE: return "FILE";
8614 case STT_COMMON: return "COMMON";
8615 case STT_TLS: return "TLS";
8616 case STT_RELC: return "RELC";
8617 case STT_SRELC: return "SRELC";
8619 if (type >= STT_LOPROC && type <= STT_HIPROC)
8621 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
8622 return "THUMB_FUNC";
8624 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
8627 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
8628 return "PARISC_MILLI";
8630 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
8632 else if (type >= STT_LOOS && type <= STT_HIOS)
8634 if (elf_header.e_machine == EM_PARISC)
8636 if (type == STT_HP_OPAQUE)
8638 if (type == STT_HP_STUB)
8642 if (type == STT_GNU_IFUNC
8643 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_LINUX
8644 /* GNU/Linux is still using the default value 0. */
8645 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
8648 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
8651 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
8657 get_symbol_visibility (unsigned int visibility)
8661 case STV_DEFAULT: return "DEFAULT";
8662 case STV_INTERNAL: return "INTERNAL";
8663 case STV_HIDDEN: return "HIDDEN";
8664 case STV_PROTECTED: return "PROTECTED";
8670 get_mips_symbol_other (unsigned int other)
8674 case STO_OPTIONAL: return "OPTIONAL";
8675 case STO_MIPS16: return "MIPS16";
8676 case STO_MIPS_PLT: return "MIPS PLT";
8677 case STO_MIPS_PIC: return "MIPS PIC";
8678 default: return NULL;
8683 get_ia64_symbol_other (unsigned int other)
8687 static char res[32];
8691 /* Function types is for images and .STB files only. */
8692 switch (elf_header.e_type)
8696 switch (VMS_ST_FUNC_TYPE (other))
8698 case VMS_SFT_CODE_ADDR:
8699 strcat (res, " CA");
8701 case VMS_SFT_SYMV_IDX:
8702 strcat (res, " VEC");
8705 strcat (res, " FD");
8707 case VMS_SFT_RESERVE:
8708 strcat (res, " RSV");
8717 switch (VMS_ST_LINKAGE (other))
8719 case VMS_STL_IGNORE:
8720 strcat (res, " IGN");
8722 case VMS_STL_RESERVE:
8723 strcat (res, " RSV");
8726 strcat (res, " STD");
8729 strcat (res, " LNK");
8744 get_symbol_other (unsigned int other)
8746 const char * result = NULL;
8747 static char buff [32];
8752 switch (elf_header.e_machine)
8755 result = get_mips_symbol_other (other);
8758 result = get_ia64_symbol_other (other);
8767 snprintf (buff, sizeof buff, _("<other>: %x"), other);
8772 get_symbol_index_type (unsigned int type)
8774 static char buff[32];
8778 case SHN_UNDEF: return "UND";
8779 case SHN_ABS: return "ABS";
8780 case SHN_COMMON: return "COM";
8782 if (type == SHN_IA_64_ANSI_COMMON
8783 && elf_header.e_machine == EM_IA_64
8784 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
8786 else if ((elf_header.e_machine == EM_X86_64
8787 || elf_header.e_machine == EM_L1OM)
8788 && type == SHN_X86_64_LCOMMON)
8790 else if ((type == SHN_MIPS_SCOMMON
8791 && elf_header.e_machine == EM_MIPS)
8792 || (type == SHN_TIC6X_SCOMMON
8793 && elf_header.e_machine == EM_TI_C6000))
8795 else if (type == SHN_MIPS_SUNDEFINED
8796 && elf_header.e_machine == EM_MIPS)
8798 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
8799 sprintf (buff, "PRC[0x%04x]", type & 0xffff);
8800 else if (type >= SHN_LOOS && type <= SHN_HIOS)
8801 sprintf (buff, "OS [0x%04x]", type & 0xffff);
8802 else if (type >= SHN_LORESERVE)
8803 sprintf (buff, "RSV[0x%04x]", type & 0xffff);
8805 sprintf (buff, "%3d", type);
8813 get_dynamic_data (FILE * file, unsigned int number, unsigned int ent_size)
8815 unsigned char * e_data;
8818 e_data = (unsigned char *) cmalloc (number, ent_size);
8822 error (_("Out of memory\n"));
8826 if (fread (e_data, ent_size, number, file) != number)
8828 error (_("Unable to read in dynamic data\n"));
8832 i_data = (bfd_vma *) cmalloc (number, sizeof (*i_data));
8836 error (_("Out of memory\n"));
8842 i_data[number] = byte_get (e_data + number * ent_size, ent_size);
8850 print_dynamic_symbol (bfd_vma si, unsigned long hn)
8852 Elf_Internal_Sym * psym;
8855 psym = dynamic_symbols + si;
8857 n = print_vma (si, DEC_5);
8859 fputs (" " + n, stdout);
8860 printf (" %3lu: ", hn);
8861 print_vma (psym->st_value, LONG_HEX);
8863 print_vma (psym->st_size, DEC_5);
8865 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
8866 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
8867 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
8868 /* Check to see if any other bits in the st_other field are set.
8869 Note - displaying this information disrupts the layout of the
8870 table being generated, but for the moment this case is very
8872 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
8873 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
8874 printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
8875 if (VALID_DYNAMIC_NAME (psym->st_name))
8876 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
8878 printf (_(" <corrupt: %14ld>"), psym->st_name);
8882 /* Dump the symbol table. */
8884 process_symbol_table (FILE * file)
8886 Elf_Internal_Shdr * section;
8887 bfd_vma nbuckets = 0;
8888 bfd_vma nchains = 0;
8889 bfd_vma * buckets = NULL;
8890 bfd_vma * chains = NULL;
8891 bfd_vma ngnubuckets = 0;
8892 bfd_vma * gnubuckets = NULL;
8893 bfd_vma * gnuchains = NULL;
8894 bfd_vma gnusymidx = 0;
8896 if (!do_syms && !do_dyn_syms && !do_histogram)
8899 if (dynamic_info[DT_HASH]
8901 || (do_using_dynamic
8903 && dynamic_strings != NULL)))
8905 unsigned char nb[8];
8906 unsigned char nc[8];
8907 int hash_ent_size = 4;
8909 if ((elf_header.e_machine == EM_ALPHA
8910 || elf_header.e_machine == EM_S390
8911 || elf_header.e_machine == EM_S390_OLD)
8912 && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
8916 (archive_file_offset
8917 + offset_from_vma (file, dynamic_info[DT_HASH],
8918 sizeof nb + sizeof nc)),
8921 error (_("Unable to seek to start of dynamic information\n"));
8925 if (fread (nb, hash_ent_size, 1, file) != 1)
8927 error (_("Failed to read in number of buckets\n"));
8931 if (fread (nc, hash_ent_size, 1, file) != 1)
8933 error (_("Failed to read in number of chains\n"));
8937 nbuckets = byte_get (nb, hash_ent_size);
8938 nchains = byte_get (nc, hash_ent_size);
8940 buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
8941 chains = get_dynamic_data (file, nchains, hash_ent_size);
8944 if (buckets == NULL || chains == NULL)
8946 if (do_using_dynamic)
8957 if (dynamic_info_DT_GNU_HASH
8959 || (do_using_dynamic
8961 && dynamic_strings != NULL)))
8963 unsigned char nb[16];
8964 bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
8965 bfd_vma buckets_vma;
8968 (archive_file_offset
8969 + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
8973 error (_("Unable to seek to start of dynamic information\n"));
8977 if (fread (nb, 16, 1, file) != 1)
8979 error (_("Failed to read in number of buckets\n"));
8983 ngnubuckets = byte_get (nb, 4);
8984 gnusymidx = byte_get (nb + 4, 4);
8985 bitmaskwords = byte_get (nb + 8, 4);
8986 buckets_vma = dynamic_info_DT_GNU_HASH + 16;
8988 buckets_vma += bitmaskwords * 4;
8990 buckets_vma += bitmaskwords * 8;
8993 (archive_file_offset
8994 + offset_from_vma (file, buckets_vma, 4)),
8997 error (_("Unable to seek to start of dynamic information\n"));
9001 gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
9003 if (gnubuckets == NULL)
9006 for (i = 0; i < ngnubuckets; i++)
9007 if (gnubuckets[i] != 0)
9009 if (gnubuckets[i] < gnusymidx)
9012 if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
9013 maxchain = gnubuckets[i];
9016 if (maxchain == 0xffffffff)
9019 maxchain -= gnusymidx;
9022 (archive_file_offset
9023 + offset_from_vma (file, buckets_vma
9024 + 4 * (ngnubuckets + maxchain), 4)),
9027 error (_("Unable to seek to start of dynamic information\n"));
9033 if (fread (nb, 4, 1, file) != 1)
9035 error (_("Failed to determine last chain length\n"));
9039 if (maxchain + 1 == 0)
9044 while ((byte_get (nb, 4) & 1) == 0);
9047 (archive_file_offset
9048 + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
9051 error (_("Unable to seek to start of dynamic information\n"));
9055 gnuchains = get_dynamic_data (file, maxchain, 4);
9058 if (gnuchains == NULL)
9063 if (do_using_dynamic)
9068 if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
9071 && dynamic_strings != NULL)
9075 if (dynamic_info[DT_HASH])
9079 printf (_("\nSymbol table for image:\n"));
9081 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9083 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9085 for (hn = 0; hn < nbuckets; hn++)
9090 for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
9091 print_dynamic_symbol (si, hn);
9095 if (dynamic_info_DT_GNU_HASH)
9097 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
9099 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9101 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9103 for (hn = 0; hn < ngnubuckets; ++hn)
9104 if (gnubuckets[hn] != 0)
9106 bfd_vma si = gnubuckets[hn];
9107 bfd_vma off = si - gnusymidx;
9111 print_dynamic_symbol (si, hn);
9114 while ((gnuchains[off++] & 1) == 0);
9118 else if (do_dyn_syms || (do_syms && !do_using_dynamic))
9122 for (i = 0, section = section_headers;
9123 i < elf_header.e_shnum;
9127 char * strtab = NULL;
9128 unsigned long int strtab_size = 0;
9129 Elf_Internal_Sym * symtab;
9130 Elf_Internal_Sym * psym;
9132 if ((section->sh_type != SHT_SYMTAB
9133 && section->sh_type != SHT_DYNSYM)
9135 && section->sh_type == SHT_SYMTAB))
9138 if (section->sh_entsize == 0)
9140 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
9141 SECTION_NAME (section));
9145 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
9146 SECTION_NAME (section),
9147 (unsigned long) (section->sh_size / section->sh_entsize));
9150 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
9152 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
9154 symtab = GET_ELF_SYMBOLS (file, section);
9158 if (section->sh_link == elf_header.e_shstrndx)
9160 strtab = string_table;
9161 strtab_size = string_table_length;
9163 else if (section->sh_link < elf_header.e_shnum)
9165 Elf_Internal_Shdr * string_sec;
9167 string_sec = section_headers + section->sh_link;
9169 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
9170 1, string_sec->sh_size,
9172 strtab_size = strtab != NULL ? string_sec->sh_size : 0;
9175 for (si = 0, psym = symtab;
9176 si < section->sh_size / section->sh_entsize;
9179 printf ("%6d: ", si);
9180 print_vma (psym->st_value, LONG_HEX);
9182 print_vma (psym->st_size, DEC_5);
9183 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
9184 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
9185 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
9186 /* Check to see if any other bits in the st_other field are set.
9187 Note - displaying this information disrupts the layout of the
9188 table being generated, but for the moment this case is very rare. */
9189 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
9190 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
9191 printf (" %4s ", get_symbol_index_type (psym->st_shndx));
9192 print_symbol (25, psym->st_name < strtab_size
9193 ? strtab + psym->st_name : _("<corrupt>"));
9195 if (section->sh_type == SHT_DYNSYM
9196 && version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
9198 unsigned char data[2];
9199 unsigned short vers_data;
9200 unsigned long offset;
9204 offset = offset_from_vma
9205 (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
9206 sizeof data + si * sizeof (vers_data));
9208 if (get_data (&data, file, offset + si * sizeof (vers_data),
9209 sizeof (data), 1, _("version data")) == NULL)
9212 vers_data = byte_get (data, 2);
9214 is_nobits = (psym->st_shndx < elf_header.e_shnum
9215 && section_headers[psym->st_shndx].sh_type
9218 check_def = (psym->st_shndx != SHN_UNDEF);
9220 if ((vers_data & VERSYM_HIDDEN) || vers_data > 1)
9222 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
9223 && (is_nobits || ! check_def))
9225 Elf_External_Verneed evn;
9226 Elf_Internal_Verneed ivn;
9227 Elf_Internal_Vernaux ivna;
9229 /* We must test both. */
9230 offset = offset_from_vma
9231 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
9236 unsigned long vna_off;
9238 if (get_data (&evn, file, offset, sizeof (evn), 1,
9239 _("version need")) == NULL)
9247 ivn.vn_aux = BYTE_GET (evn.vn_aux);
9248 ivn.vn_next = BYTE_GET (evn.vn_next);
9250 vna_off = offset + ivn.vn_aux;
9254 Elf_External_Vernaux evna;
9256 if (get_data (&evna, file, vna_off,
9258 _("version need aux (3)")) == NULL)
9266 ivna.vna_other = BYTE_GET (evna.vna_other);
9267 ivna.vna_next = BYTE_GET (evna.vna_next);
9268 ivna.vna_name = BYTE_GET (evna.vna_name);
9271 vna_off += ivna.vna_next;
9273 while (ivna.vna_other != vers_data
9274 && ivna.vna_next != 0);
9276 if (ivna.vna_other == vers_data)
9279 offset += ivn.vn_next;
9281 while (ivn.vn_next != 0);
9283 if (ivna.vna_other == vers_data)
9286 ivna.vna_name < strtab_size
9287 ? strtab + ivna.vna_name : _("<corrupt>"),
9291 else if (! is_nobits)
9292 error (_("bad dynamic symbol\n"));
9299 if (vers_data != 0x8001
9300 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
9302 Elf_Internal_Verdef ivd;
9303 Elf_Internal_Verdaux ivda;
9304 Elf_External_Verdaux evda;
9307 off = offset_from_vma
9309 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
9310 sizeof (Elf_External_Verdef));
9314 Elf_External_Verdef evd;
9316 if (get_data (&evd, file, off, sizeof (evd),
9317 1, _("version def")) == NULL)
9325 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
9326 ivd.vd_aux = BYTE_GET (evd.vd_aux);
9327 ivd.vd_next = BYTE_GET (evd.vd_next);
9332 while (ivd.vd_ndx != (vers_data & VERSYM_VERSION)
9333 && ivd.vd_next != 0);
9338 if (get_data (&evda, file, off, sizeof (evda),
9339 1, _("version def aux")) == NULL)
9342 ivda.vda_name = BYTE_GET (evda.vda_name);
9344 if (psym->st_name != ivda.vda_name)
9345 printf ((vers_data & VERSYM_HIDDEN)
9347 ivda.vda_name < strtab_size
9348 ? strtab + ivda.vda_name : _("<corrupt>"));
9358 if (strtab != string_table)
9364 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
9366 if (do_histogram && buckets != NULL)
9368 unsigned long * lengths;
9369 unsigned long * counts;
9372 unsigned long maxlength = 0;
9373 unsigned long nzero_counts = 0;
9374 unsigned long nsyms = 0;
9376 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
9377 (unsigned long) nbuckets);
9378 printf (_(" Length Number %% of total Coverage\n"));
9380 lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
9381 if (lengths == NULL)
9383 error (_("Out of memory\n"));
9386 for (hn = 0; hn < nbuckets; ++hn)
9388 for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
9391 if (maxlength < ++lengths[hn])
9396 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
9399 error (_("Out of memory\n"));
9403 for (hn = 0; hn < nbuckets; ++hn)
9404 ++counts[lengths[hn]];
9409 printf (" 0 %-10lu (%5.1f%%)\n",
9410 counts[0], (counts[0] * 100.0) / nbuckets);
9411 for (i = 1; i <= maxlength; ++i)
9413 nzero_counts += counts[i] * i;
9414 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
9415 i, counts[i], (counts[i] * 100.0) / nbuckets,
9416 (nzero_counts * 100.0) / nsyms);
9424 if (buckets != NULL)
9430 if (do_histogram && gnubuckets != NULL)
9432 unsigned long * lengths;
9433 unsigned long * counts;
9435 unsigned long maxlength = 0;
9436 unsigned long nzero_counts = 0;
9437 unsigned long nsyms = 0;
9439 lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
9440 if (lengths == NULL)
9442 error (_("Out of memory\n"));
9446 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
9447 (unsigned long) ngnubuckets);
9448 printf (_(" Length Number %% of total Coverage\n"));
9450 for (hn = 0; hn < ngnubuckets; ++hn)
9451 if (gnubuckets[hn] != 0)
9453 bfd_vma off, length = 1;
9455 for (off = gnubuckets[hn] - gnusymidx;
9456 (gnuchains[off] & 1) == 0; ++off)
9458 lengths[hn] = length;
9459 if (length > maxlength)
9464 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
9467 error (_("Out of memory\n"));
9471 for (hn = 0; hn < ngnubuckets; ++hn)
9472 ++counts[lengths[hn]];
9474 if (ngnubuckets > 0)
9477 printf (" 0 %-10lu (%5.1f%%)\n",
9478 counts[0], (counts[0] * 100.0) / ngnubuckets);
9479 for (j = 1; j <= maxlength; ++j)
9481 nzero_counts += counts[j] * j;
9482 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
9483 j, counts[j], (counts[j] * 100.0) / ngnubuckets,
9484 (nzero_counts * 100.0) / nsyms);
9498 process_syminfo (FILE * file ATTRIBUTE_UNUSED)
9502 if (dynamic_syminfo == NULL
9504 /* No syminfo, this is ok. */
9507 /* There better should be a dynamic symbol section. */
9508 if (dynamic_symbols == NULL || dynamic_strings == NULL)
9512 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
9513 dynamic_syminfo_offset, dynamic_syminfo_nent);
9515 printf (_(" Num: Name BoundTo Flags\n"));
9516 for (i = 0; i < dynamic_syminfo_nent; ++i)
9518 unsigned short int flags = dynamic_syminfo[i].si_flags;
9520 printf ("%4d: ", i);
9521 if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
9522 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
9524 printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
9527 switch (dynamic_syminfo[i].si_boundto)
9529 case SYMINFO_BT_SELF:
9530 fputs ("SELF ", stdout);
9532 case SYMINFO_BT_PARENT:
9533 fputs ("PARENT ", stdout);
9536 if (dynamic_syminfo[i].si_boundto > 0
9537 && dynamic_syminfo[i].si_boundto < dynamic_nent
9538 && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
9540 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
9544 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
9548 if (flags & SYMINFO_FLG_DIRECT)
9550 if (flags & SYMINFO_FLG_PASSTHRU)
9551 printf (" PASSTHRU");
9552 if (flags & SYMINFO_FLG_COPY)
9554 if (flags & SYMINFO_FLG_LAZYLOAD)
9555 printf (" LAZYLOAD");
9563 /* Check to see if the given reloc needs to be handled in a target specific
9564 manner. If so then process the reloc and return TRUE otherwise return
9568 target_specific_reloc_handling (Elf_Internal_Rela * reloc,
9569 unsigned char * start,
9570 Elf_Internal_Sym * symtab)
9572 unsigned int reloc_type = get_reloc_type (reloc->r_info);
9574 switch (elf_header.e_machine)
9577 case EM_CYGNUS_MN10300:
9579 static Elf_Internal_Sym * saved_sym = NULL;
9583 case 34: /* R_MN10300_ALIGN */
9585 case 33: /* R_MN10300_SYM_DIFF */
9586 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
9588 case 1: /* R_MN10300_32 */
9589 case 2: /* R_MN10300_16 */
9590 if (saved_sym != NULL)
9594 value = reloc->r_addend
9595 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
9596 - saved_sym->st_value);
9598 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
9605 if (saved_sym != NULL)
9606 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc"));
9616 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
9617 DWARF debug sections. This is a target specific test. Note - we do not
9618 go through the whole including-target-headers-multiple-times route, (as
9619 we have already done with <elf/h8.h>) because this would become very
9620 messy and even then this function would have to contain target specific
9621 information (the names of the relocs instead of their numeric values).
9622 FIXME: This is not the correct way to solve this problem. The proper way
9623 is to have target specific reloc sizing and typing functions created by
9624 the reloc-macros.h header, in the same way that it already creates the
9625 reloc naming functions. */
9628 is_32bit_abs_reloc (unsigned int reloc_type)
9630 switch (elf_header.e_machine)
9634 return reloc_type == 1; /* R_386_32. */
9636 return reloc_type == 1; /* R_68K_32. */
9638 return reloc_type == 1; /* R_860_32. */
9640 return reloc_type == 2; /* R_960_32. */
9642 return reloc_type == 1; /* R_ALPHA_REFLONG. */
9644 return reloc_type == 1; /* R_ARC_32. */
9646 return reloc_type == 2; /* R_ARM_ABS32 */
9649 return reloc_type == 1;
9651 return reloc_type == 0x12; /* R_byte4_data. */
9653 return reloc_type == 3; /* R_CRIS_32. */
9656 return reloc_type == 3; /* R_CR16_NUM32. */
9658 return reloc_type == 15; /* R_CRX_NUM32. */
9660 return reloc_type == 1;
9661 case EM_CYGNUS_D10V:
9663 return reloc_type == 6; /* R_D10V_32. */
9664 case EM_CYGNUS_D30V:
9666 return reloc_type == 12; /* R_D30V_32_NORMAL. */
9668 return reloc_type == 3; /* R_DLX_RELOC_32. */
9669 case EM_CYGNUS_FR30:
9671 return reloc_type == 3; /* R_FR30_32. */
9675 return reloc_type == 1; /* R_H8_DIR32. */
9677 return reloc_type == 0x65; /* R_IA64_SECREL32LSB. */
9680 return reloc_type == 2; /* R_IP2K_32. */
9682 return reloc_type == 2; /* R_IQ2000_32. */
9683 case EM_LATTICEMICO32:
9684 return reloc_type == 3; /* R_LM32_32. */
9687 return reloc_type == 3; /* R_M32C_32. */
9689 return reloc_type == 34; /* R_M32R_32_RELA. */
9691 return reloc_type == 1; /* R_MCORE_ADDR32. */
9693 return reloc_type == 4; /* R_MEP_32. */
9695 return reloc_type == 1; /* R_MICROBLAZE_32. */
9697 return reloc_type == 2; /* R_MIPS_32. */
9699 return reloc_type == 4; /* R_MMIX_32. */
9700 case EM_CYGNUS_MN10200:
9702 return reloc_type == 1; /* R_MN10200_32. */
9703 case EM_CYGNUS_MN10300:
9705 return reloc_type == 1; /* R_MN10300_32. */
9707 return reloc_type == 1; /* R_MOXIE_32. */
9710 return reloc_type == 1; /* R_MSP43_32. */
9712 return reloc_type == 2; /* R_MT_32. */
9713 case EM_ALTERA_NIOS2:
9715 return reloc_type == 1; /* R_NIOS_32. */
9718 return reloc_type == 1; /* R_OR32_32. */
9720 return (reloc_type == 1 /* R_PARISC_DIR32. */
9721 || reloc_type == 41); /* R_PARISC_SECREL32. */
9724 return reloc_type == 1; /* R_PJ_DATA_DIR32. */
9726 return reloc_type == 1; /* R_PPC64_ADDR32. */
9728 return reloc_type == 1; /* R_PPC_ADDR32. */
9730 return reloc_type == 1; /* R_RX_DIR32. */
9732 return reloc_type == 1; /* R_I370_ADDR31. */
9735 return reloc_type == 4; /* R_S390_32. */
9737 return reloc_type == 8; /* R_SCORE_ABS32. */
9739 return reloc_type == 1; /* R_SH_DIR32. */
9740 case EM_SPARC32PLUS:
9743 return reloc_type == 3 /* R_SPARC_32. */
9744 || reloc_type == 23; /* R_SPARC_UA32. */
9746 return reloc_type == 6; /* R_SPU_ADDR32 */
9748 return reloc_type == 1; /* R_C6000_ABS32. */
9750 return reloc_type == 2; /* R_TILEGX_32. */
9752 return reloc_type == 1; /* R_TILEPRO_32. */
9753 case EM_CYGNUS_V850:
9755 return reloc_type == 6; /* R_V850_ABS32. */
9757 return reloc_type == 1; /* R_VAX_32. */
9760 return reloc_type == 10; /* R_X86_64_32. */
9763 return reloc_type == 3; /* R_XC16C_ABS_32. */
9765 return reloc_type == 1; /* R_XSTROMY16_32. */
9768 return reloc_type == 1; /* R_XTENSA_32. */
9770 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
9771 elf_header.e_machine);
9776 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9777 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
9780 is_32bit_pcrel_reloc (unsigned int reloc_type)
9782 switch (elf_header.e_machine)
9786 return reloc_type == 2; /* R_386_PC32. */
9788 return reloc_type == 4; /* R_68K_PC32. */
9790 return reloc_type == 10; /* R_ALPHA_SREL32. */
9792 return reloc_type == 3; /* R_ARM_REL32 */
9794 return reloc_type == 2; /* R_MICROBLAZE_32_PCREL. */
9796 return reloc_type == 9; /* R_PARISC_PCREL32. */
9798 return reloc_type == 26; /* R_PPC_REL32. */
9800 return reloc_type == 26; /* R_PPC64_REL32. */
9803 return reloc_type == 5; /* R_390_PC32. */
9805 return reloc_type == 2; /* R_SH_REL32. */
9806 case EM_SPARC32PLUS:
9809 return reloc_type == 6; /* R_SPARC_DISP32. */
9811 return reloc_type == 13; /* R_SPU_REL32. */
9813 return reloc_type == 6; /* R_TILEGX_32_PCREL. */
9815 return reloc_type == 4; /* R_TILEPRO_32_PCREL. */
9818 return reloc_type == 2; /* R_X86_64_PC32. */
9821 return reloc_type == 14; /* R_XTENSA_32_PCREL. */
9823 /* Do not abort or issue an error message here. Not all targets use
9824 pc-relative 32-bit relocs in their DWARF debug information and we
9825 have already tested for target coverage in is_32bit_abs_reloc. A
9826 more helpful warning message will be generated by apply_relocations
9827 anyway, so just return. */
9832 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9833 a 64-bit absolute RELA relocation used in DWARF debug sections. */
9836 is_64bit_abs_reloc (unsigned int reloc_type)
9838 switch (elf_header.e_machine)
9841 return reloc_type == 2; /* R_ALPHA_REFQUAD. */
9843 return reloc_type == 0x27; /* R_IA64_DIR64LSB. */
9845 return reloc_type == 80; /* R_PARISC_DIR64. */
9847 return reloc_type == 38; /* R_PPC64_ADDR64. */
9848 case EM_SPARC32PLUS:
9851 return reloc_type == 54; /* R_SPARC_UA64. */
9854 return reloc_type == 1; /* R_X86_64_64. */
9857 return reloc_type == 22; /* R_S390_64. */
9859 return reloc_type == 1; /* R_TILEGX_64. */
9861 return reloc_type == 18; /* R_MIPS_64. */
9867 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
9868 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
9871 is_64bit_pcrel_reloc (unsigned int reloc_type)
9873 switch (elf_header.e_machine)
9876 return reloc_type == 11; /* R_ALPHA_SREL64. */
9878 return reloc_type == 0x4f; /* R_IA64_PCREL64LSB. */
9880 return reloc_type == 72; /* R_PARISC_PCREL64. */
9882 return reloc_type == 44; /* R_PPC64_REL64. */
9883 case EM_SPARC32PLUS:
9886 return reloc_type == 46; /* R_SPARC_DISP64. */
9889 return reloc_type == 24; /* R_X86_64_PC64. */
9892 return reloc_type == 23; /* R_S390_PC64. */
9894 return reloc_type == 5; /* R_TILEGX_64_PCREL. */
9900 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9901 a 24-bit absolute RELA relocation used in DWARF debug sections. */
9904 is_24bit_abs_reloc (unsigned int reloc_type)
9906 switch (elf_header.e_machine)
9908 case EM_CYGNUS_MN10200:
9910 return reloc_type == 4; /* R_MN10200_24. */
9916 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9917 a 16-bit absolute RELA relocation used in DWARF debug sections. */
9920 is_16bit_abs_reloc (unsigned int reloc_type)
9922 switch (elf_header.e_machine)
9926 return reloc_type == 4; /* R_AVR_16. */
9927 case EM_CYGNUS_D10V:
9929 return reloc_type == 3; /* R_D10V_16. */
9933 return reloc_type == R_H8_DIR16;
9936 return reloc_type == 1; /* R_IP2K_16. */
9939 return reloc_type == 1; /* R_M32C_16 */
9942 return reloc_type == 5; /* R_MSP430_16_BYTE. */
9943 case EM_ALTERA_NIOS2:
9945 return reloc_type == 9; /* R_NIOS_16. */
9947 return reloc_type == 2; /* R_C6000_ABS16. */
9950 return reloc_type == 2; /* R_XC16C_ABS_16. */
9956 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
9957 relocation entries (possibly formerly used for SHT_GROUP sections). */
9960 is_none_reloc (unsigned int reloc_type)
9962 switch (elf_header.e_machine)
9964 case EM_68K: /* R_68K_NONE. */
9965 case EM_386: /* R_386_NONE. */
9966 case EM_SPARC32PLUS:
9968 case EM_SPARC: /* R_SPARC_NONE. */
9969 case EM_MIPS: /* R_MIPS_NONE. */
9970 case EM_PARISC: /* R_PARISC_NONE. */
9971 case EM_ALPHA: /* R_ALPHA_NONE. */
9972 case EM_PPC: /* R_PPC_NONE. */
9973 case EM_PPC64: /* R_PPC64_NONE. */
9974 case EM_ARM: /* R_ARM_NONE. */
9975 case EM_IA_64: /* R_IA64_NONE. */
9976 case EM_SH: /* R_SH_NONE. */
9978 case EM_S390: /* R_390_NONE. */
9979 case EM_CRIS: /* R_CRIS_NONE. */
9980 case EM_X86_64: /* R_X86_64_NONE. */
9981 case EM_L1OM: /* R_X86_64_NONE. */
9982 case EM_MN10300: /* R_MN10300_NONE. */
9983 case EM_MOXIE: /* R_MOXIE_NONE. */
9984 case EM_M32R: /* R_M32R_NONE. */
9985 case EM_TI_C6000:/* R_C6000_NONE. */
9986 case EM_TILEGX: /* R_TILEGX_NONE. */
9987 case EM_TILEPRO: /* R_TILEPRO_NONE. */
9989 case EM_C166: /* R_XC16X_NONE. */
9990 return reloc_type == 0;
9993 return (reloc_type == 0 /* R_XTENSA_NONE. */
9994 || reloc_type == 17 /* R_XTENSA_DIFF8. */
9995 || reloc_type == 18 /* R_XTENSA_DIFF16. */
9996 || reloc_type == 19 /* R_XTENSA_DIFF32. */);
10001 /* Apply relocations to a section.
10002 Note: So far support has been added only for those relocations
10003 which can be found in debug sections.
10004 FIXME: Add support for more relocations ? */
10007 apply_relocations (void * file,
10008 Elf_Internal_Shdr * section,
10009 unsigned char * start)
10011 Elf_Internal_Shdr * relsec;
10012 unsigned char * end = start + section->sh_size;
10014 if (elf_header.e_type != ET_REL)
10017 /* Find the reloc section associated with the section. */
10018 for (relsec = section_headers;
10019 relsec < section_headers + elf_header.e_shnum;
10022 bfd_boolean is_rela;
10023 unsigned long num_relocs;
10024 Elf_Internal_Rela * relocs;
10025 Elf_Internal_Rela * rp;
10026 Elf_Internal_Shdr * symsec;
10027 Elf_Internal_Sym * symtab;
10028 Elf_Internal_Sym * sym;
10030 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
10031 || relsec->sh_info >= elf_header.e_shnum
10032 || section_headers + relsec->sh_info != section
10033 || relsec->sh_size == 0
10034 || relsec->sh_link >= elf_header.e_shnum)
10037 is_rela = relsec->sh_type == SHT_RELA;
10041 if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
10042 relsec->sh_size, & relocs, & num_relocs))
10047 if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
10048 relsec->sh_size, & relocs, & num_relocs))
10052 /* SH uses RELA but uses in place value instead of the addend field. */
10053 if (elf_header.e_machine == EM_SH)
10056 symsec = section_headers + relsec->sh_link;
10057 symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec);
10059 for (rp = relocs; rp < relocs + num_relocs; ++rp)
10062 unsigned int reloc_type;
10063 unsigned int reloc_size;
10064 unsigned char * rloc;
10066 reloc_type = get_reloc_type (rp->r_info);
10068 if (target_specific_reloc_handling (rp, start, symtab))
10070 else if (is_none_reloc (reloc_type))
10072 else if (is_32bit_abs_reloc (reloc_type)
10073 || is_32bit_pcrel_reloc (reloc_type))
10075 else if (is_64bit_abs_reloc (reloc_type)
10076 || is_64bit_pcrel_reloc (reloc_type))
10078 else if (is_24bit_abs_reloc (reloc_type))
10080 else if (is_16bit_abs_reloc (reloc_type))
10084 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
10085 reloc_type, SECTION_NAME (section));
10089 rloc = start + rp->r_offset;
10090 if ((rloc + reloc_size) > end)
10092 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
10093 (unsigned long) rp->r_offset,
10094 SECTION_NAME (section));
10098 sym = symtab + get_reloc_symindex (rp->r_info);
10100 /* If the reloc has a symbol associated with it,
10101 make sure that it is of an appropriate type.
10103 Relocations against symbols without type can happen.
10104 Gcc -feliminate-dwarf2-dups may generate symbols
10105 without type for debug info.
10107 Icc generates relocations against function symbols
10108 instead of local labels.
10110 Relocations against object symbols can happen, eg when
10111 referencing a global array. For an example of this see
10112 the _clz.o binary in libgcc.a. */
10114 && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
10116 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
10117 get_symbol_type (ELF_ST_TYPE (sym->st_info)),
10118 (long int)(rp - relocs),
10119 SECTION_NAME (relsec));
10125 addend += rp->r_addend;
10126 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
10127 partial_inplace. */
10129 || (elf_header.e_machine == EM_XTENSA
10130 && reloc_type == 1)
10131 || ((elf_header.e_machine == EM_PJ
10132 || elf_header.e_machine == EM_PJ_OLD)
10133 && reloc_type == 1)
10134 || ((elf_header.e_machine == EM_D30V
10135 || elf_header.e_machine == EM_CYGNUS_D30V)
10136 && reloc_type == 12))
10137 addend += byte_get (rloc, reloc_size);
10139 if (is_32bit_pcrel_reloc (reloc_type)
10140 || is_64bit_pcrel_reloc (reloc_type))
10142 /* On HPPA, all pc-relative relocations are biased by 8. */
10143 if (elf_header.e_machine == EM_PARISC)
10145 byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
10149 byte_put (rloc, addend + sym->st_value, reloc_size);
10158 #ifdef SUPPORT_DISASSEMBLY
10160 disassemble_section (Elf_Internal_Shdr * section, FILE * file)
10162 printf (_("\nAssembly dump of section %s\n"),
10163 SECTION_NAME (section));
10165 /* XXX -- to be done --- XXX */
10171 /* Reads in the contents of SECTION from FILE, returning a pointer
10172 to a malloc'ed buffer or NULL if something went wrong. */
10175 get_section_contents (Elf_Internal_Shdr * section, FILE * file)
10177 bfd_size_type num_bytes;
10179 num_bytes = section->sh_size;
10181 if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
10183 printf (_("\nSection '%s' has no data to dump.\n"),
10184 SECTION_NAME (section));
10188 return (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
10189 _("section contents"));
10194 dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
10196 Elf_Internal_Shdr * relsec;
10197 bfd_size_type num_bytes;
10201 char * name = SECTION_NAME (section);
10202 bfd_boolean some_strings_shown;
10204 start = get_section_contents (section, file);
10208 printf (_("\nString dump of section '%s':\n"), name);
10210 /* If the section being dumped has relocations against it the user might
10211 be expecting these relocations to have been applied. Check for this
10212 case and issue a warning message in order to avoid confusion.
10213 FIXME: Maybe we ought to have an option that dumps a section with
10214 relocs applied ? */
10215 for (relsec = section_headers;
10216 relsec < section_headers + elf_header.e_shnum;
10219 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
10220 || relsec->sh_info >= elf_header.e_shnum
10221 || section_headers + relsec->sh_info != section
10222 || relsec->sh_size == 0
10223 || relsec->sh_link >= elf_header.e_shnum)
10226 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
10230 num_bytes = section->sh_size;
10232 end = start + num_bytes;
10233 some_strings_shown = FALSE;
10237 while (!ISPRINT (* data))
10238 if (++ data >= end)
10244 /* PR 11128: Use two separate invocations in order to work
10245 around bugs in the Solaris 8 implementation of printf. */
10246 printf (" [%6tx] ", data - start);
10247 printf ("%s\n", data);
10249 printf (" [%6Ix] %s\n", (size_t) (data - start), data);
10251 data += strlen (data);
10252 some_strings_shown = TRUE;
10256 if (! some_strings_shown)
10257 printf (_(" No strings found in this section."));
10265 dump_section_as_bytes (Elf_Internal_Shdr * section,
10267 bfd_boolean relocate)
10269 Elf_Internal_Shdr * relsec;
10270 bfd_size_type bytes;
10272 unsigned char * data;
10273 unsigned char * start;
10275 start = (unsigned char *) get_section_contents (section, file);
10279 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
10283 apply_relocations (file, section, start);
10287 /* If the section being dumped has relocations against it the user might
10288 be expecting these relocations to have been applied. Check for this
10289 case and issue a warning message in order to avoid confusion.
10290 FIXME: Maybe we ought to have an option that dumps a section with
10291 relocs applied ? */
10292 for (relsec = section_headers;
10293 relsec < section_headers + elf_header.e_shnum;
10296 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
10297 || relsec->sh_info >= elf_header.e_shnum
10298 || section_headers + relsec->sh_info != section
10299 || relsec->sh_size == 0
10300 || relsec->sh_link >= elf_header.e_shnum)
10303 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
10308 addr = section->sh_addr;
10309 bytes = section->sh_size;
10318 lbytes = (bytes > 16 ? 16 : bytes);
10320 printf (" 0x%8.8lx ", (unsigned long) addr);
10322 for (j = 0; j < 16; j++)
10325 printf ("%2.2x", data[j]);
10333 for (j = 0; j < lbytes; j++)
10336 if (k >= ' ' && k < 0x7f)
10354 /* Uncompresses a section that was compressed using zlib, in place. */
10357 uncompress_section_contents (unsigned char **buffer ATTRIBUTE_UNUSED,
10358 dwarf_size_type *size ATTRIBUTE_UNUSED)
10360 #ifndef HAVE_ZLIB_H
10363 dwarf_size_type compressed_size = *size;
10364 unsigned char * compressed_buffer = *buffer;
10365 dwarf_size_type uncompressed_size;
10366 unsigned char * uncompressed_buffer;
10369 dwarf_size_type header_size = 12;
10371 /* Read the zlib header. In this case, it should be "ZLIB" followed
10372 by the uncompressed section size, 8 bytes in big-endian order. */
10373 if (compressed_size < header_size
10374 || ! streq ((char *) compressed_buffer, "ZLIB"))
10377 uncompressed_size = compressed_buffer[4]; uncompressed_size <<= 8;
10378 uncompressed_size += compressed_buffer[5]; uncompressed_size <<= 8;
10379 uncompressed_size += compressed_buffer[6]; uncompressed_size <<= 8;
10380 uncompressed_size += compressed_buffer[7]; uncompressed_size <<= 8;
10381 uncompressed_size += compressed_buffer[8]; uncompressed_size <<= 8;
10382 uncompressed_size += compressed_buffer[9]; uncompressed_size <<= 8;
10383 uncompressed_size += compressed_buffer[10]; uncompressed_size <<= 8;
10384 uncompressed_size += compressed_buffer[11];
10386 /* It is possible the section consists of several compressed
10387 buffers concatenated together, so we uncompress in a loop. */
10388 strm.zalloc = NULL;
10390 strm.opaque = NULL;
10391 strm.avail_in = compressed_size - header_size;
10392 strm.next_in = (Bytef *) compressed_buffer + header_size;
10393 strm.avail_out = uncompressed_size;
10394 uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
10396 rc = inflateInit (& strm);
10397 while (strm.avail_in > 0)
10401 strm.next_out = ((Bytef *) uncompressed_buffer
10402 + (uncompressed_size - strm.avail_out));
10403 rc = inflate (&strm, Z_FINISH);
10404 if (rc != Z_STREAM_END)
10406 rc = inflateReset (& strm);
10408 rc = inflateEnd (& strm);
10410 || strm.avail_out != 0)
10413 free (compressed_buffer);
10414 *buffer = uncompressed_buffer;
10415 *size = uncompressed_size;
10419 free (uncompressed_buffer);
10420 /* Indicate decompression failure. */
10423 #endif /* HAVE_ZLIB_H */
10427 load_specific_debug_section (enum dwarf_section_display_enum debug,
10428 Elf_Internal_Shdr * sec, void * file)
10430 struct dwarf_section * section = &debug_displays [debug].section;
10433 /* If it is already loaded, do nothing. */
10434 if (section->start != NULL)
10437 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
10438 section->address = sec->sh_addr;
10439 section->start = (unsigned char *) get_data (NULL, (FILE *) file,
10441 sec->sh_size, buf);
10442 if (section->start == NULL)
10446 section->size = sec->sh_size;
10447 if (uncompress_section_contents (§ion->start, §ion->size))
10448 sec->sh_size = section->size;
10451 if (section->start == NULL)
10454 if (debug_displays [debug].relocate)
10455 apply_relocations ((FILE *) file, sec, section->start);
10461 load_debug_section (enum dwarf_section_display_enum debug, void * file)
10463 struct dwarf_section * section = &debug_displays [debug].section;
10464 Elf_Internal_Shdr * sec;
10466 /* Locate the debug section. */
10467 sec = find_section (section->uncompressed_name);
10469 section->name = section->uncompressed_name;
10472 sec = find_section (section->compressed_name);
10474 section->name = section->compressed_name;
10479 return load_specific_debug_section (debug, sec, (FILE *) file);
10483 free_debug_section (enum dwarf_section_display_enum debug)
10485 struct dwarf_section * section = &debug_displays [debug].section;
10487 if (section->start == NULL)
10490 free ((char *) section->start);
10491 section->start = NULL;
10492 section->address = 0;
10497 display_debug_section (Elf_Internal_Shdr * section, FILE * file)
10499 char * name = SECTION_NAME (section);
10500 bfd_size_type length;
10504 length = section->sh_size;
10507 printf (_("\nSection '%s' has no debugging data.\n"), name);
10510 if (section->sh_type == SHT_NOBITS)
10512 /* There is no point in dumping the contents of a debugging section
10513 which has the NOBITS type - the bits in the file will be random.
10514 This can happen when a file containing a .eh_frame section is
10515 stripped with the --only-keep-debug command line option. */
10516 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"), name);
10520 if (const_strneq (name, ".gnu.linkonce.wi."))
10521 name = ".debug_info";
10523 /* See if we know how to display the contents of this section. */
10524 for (i = 0; i < max; i++)
10525 if (streq (debug_displays[i].section.uncompressed_name, name)
10526 || streq (debug_displays[i].section.compressed_name, name))
10528 struct dwarf_section * sec = &debug_displays [i].section;
10529 int secondary = (section != find_section (name));
10532 free_debug_section ((enum dwarf_section_display_enum) i);
10534 if (streq (sec->uncompressed_name, name))
10535 sec->name = sec->uncompressed_name;
10537 sec->name = sec->compressed_name;
10538 if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
10541 result &= debug_displays[i].display (sec, file);
10543 if (secondary || (i != info && i != abbrev))
10544 free_debug_section ((enum dwarf_section_display_enum) i);
10552 printf (_("Unrecognized debug section: %s\n"), name);
10559 /* Set DUMP_SECTS for all sections where dumps were requested
10560 based on section name. */
10563 initialise_dumps_byname (void)
10565 struct dump_list_entry * cur;
10567 for (cur = dump_sects_byname; cur; cur = cur->next)
10572 for (i = 0, any = 0; i < elf_header.e_shnum; i++)
10573 if (streq (SECTION_NAME (section_headers + i), cur->name))
10575 request_dump_bynumber (i, cur->type);
10580 warn (_("Section '%s' was not dumped because it does not exist!\n"),
10586 process_section_contents (FILE * file)
10588 Elf_Internal_Shdr * section;
10594 initialise_dumps_byname ();
10596 for (i = 0, section = section_headers;
10597 i < elf_header.e_shnum && i < num_dump_sects;
10600 #ifdef SUPPORT_DISASSEMBLY
10601 if (dump_sects[i] & DISASS_DUMP)
10602 disassemble_section (section, file);
10604 if (dump_sects[i] & HEX_DUMP)
10605 dump_section_as_bytes (section, file, FALSE);
10607 if (dump_sects[i] & RELOC_DUMP)
10608 dump_section_as_bytes (section, file, TRUE);
10610 if (dump_sects[i] & STRING_DUMP)
10611 dump_section_as_strings (section, file);
10613 if (dump_sects[i] & DEBUG_DUMP)
10614 display_debug_section (section, file);
10617 /* Check to see if the user requested a
10618 dump of a section that does not exist. */
10619 while (i++ < num_dump_sects)
10621 warn (_("Section %d was not dumped because it does not exist!\n"), i);
10625 process_mips_fpe_exception (int mask)
10630 if (mask & OEX_FPU_INEX)
10631 fputs ("INEX", stdout), first = 0;
10632 if (mask & OEX_FPU_UFLO)
10633 printf ("%sUFLO", first ? "" : "|"), first = 0;
10634 if (mask & OEX_FPU_OFLO)
10635 printf ("%sOFLO", first ? "" : "|"), first = 0;
10636 if (mask & OEX_FPU_DIV0)
10637 printf ("%sDIV0", first ? "" : "|"), first = 0;
10638 if (mask & OEX_FPU_INVAL)
10639 printf ("%sINVAL", first ? "" : "|");
10642 fputs ("0", stdout);
10645 /* ARM EABI attributes section. */
10650 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
10652 const char ** table;
10653 } arm_attr_public_tag;
10655 static const char * arm_attr_tag_CPU_arch[] =
10656 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
10657 "v6K", "v7", "v6-M", "v6S-M", "v7E-M"};
10658 static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
10659 static const char * arm_attr_tag_THUMB_ISA_use[] =
10660 {"No", "Thumb-1", "Thumb-2"};
10661 static const char * arm_attr_tag_FP_arch[] =
10662 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16"};
10663 static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
10664 static const char * arm_attr_tag_Advanced_SIMD_arch[] =
10665 {"No", "NEONv1", "NEONv1 with Fused-MAC"};
10666 static const char * arm_attr_tag_PCS_config[] =
10667 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
10668 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
10669 static const char * arm_attr_tag_ABI_PCS_R9_use[] =
10670 {"V6", "SB", "TLS", "Unused"};
10671 static const char * arm_attr_tag_ABI_PCS_RW_data[] =
10672 {"Absolute", "PC-relative", "SB-relative", "None"};
10673 static const char * arm_attr_tag_ABI_PCS_RO_data[] =
10674 {"Absolute", "PC-relative", "None"};
10675 static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
10676 {"None", "direct", "GOT-indirect"};
10677 static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
10678 {"None", "??? 1", "2", "??? 3", "4"};
10679 static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
10680 static const char * arm_attr_tag_ABI_FP_denormal[] =
10681 {"Unused", "Needed", "Sign only"};
10682 static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
10683 static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
10684 static const char * arm_attr_tag_ABI_FP_number_model[] =
10685 {"Unused", "Finite", "RTABI", "IEEE 754"};
10686 static const char * arm_attr_tag_ABI_enum_size[] =
10687 {"Unused", "small", "int", "forced to int"};
10688 static const char * arm_attr_tag_ABI_HardFP_use[] =
10689 {"As Tag_FP_arch", "SP only", "DP only", "SP and DP"};
10690 static const char * arm_attr_tag_ABI_VFP_args[] =
10691 {"AAPCS", "VFP registers", "custom"};
10692 static const char * arm_attr_tag_ABI_WMMX_args[] =
10693 {"AAPCS", "WMMX registers", "custom"};
10694 static const char * arm_attr_tag_ABI_optimization_goals[] =
10695 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
10696 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
10697 static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
10698 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
10699 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
10700 static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
10701 static const char * arm_attr_tag_FP_HP_extension[] =
10702 {"Not Allowed", "Allowed"};
10703 static const char * arm_attr_tag_ABI_FP_16bit_format[] =
10704 {"None", "IEEE 754", "Alternative Format"};
10705 static const char * arm_attr_tag_MPextension_use[] =
10706 {"Not Allowed", "Allowed"};
10707 static const char * arm_attr_tag_DIV_use[] =
10708 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
10709 "Allowed in v7-A with integer division extension"};
10710 static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
10711 static const char * arm_attr_tag_Virtualization_use[] =
10712 {"Not Allowed", "TrustZone", "Virtualization Extensions",
10713 "TrustZone and Virtualization Extensions"};
10714 static const char * arm_attr_tag_MPextension_use_legacy[] =
10715 {"Not Allowed", "Allowed"};
10717 #define LOOKUP(id, name) \
10718 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
10719 static arm_attr_public_tag arm_attr_public_tags[] =
10721 {4, "CPU_raw_name", 1, NULL},
10722 {5, "CPU_name", 1, NULL},
10723 LOOKUP(6, CPU_arch),
10724 {7, "CPU_arch_profile", 0, NULL},
10725 LOOKUP(8, ARM_ISA_use),
10726 LOOKUP(9, THUMB_ISA_use),
10727 LOOKUP(10, FP_arch),
10728 LOOKUP(11, WMMX_arch),
10729 LOOKUP(12, Advanced_SIMD_arch),
10730 LOOKUP(13, PCS_config),
10731 LOOKUP(14, ABI_PCS_R9_use),
10732 LOOKUP(15, ABI_PCS_RW_data),
10733 LOOKUP(16, ABI_PCS_RO_data),
10734 LOOKUP(17, ABI_PCS_GOT_use),
10735 LOOKUP(18, ABI_PCS_wchar_t),
10736 LOOKUP(19, ABI_FP_rounding),
10737 LOOKUP(20, ABI_FP_denormal),
10738 LOOKUP(21, ABI_FP_exceptions),
10739 LOOKUP(22, ABI_FP_user_exceptions),
10740 LOOKUP(23, ABI_FP_number_model),
10741 {24, "ABI_align_needed", 0, NULL},
10742 {25, "ABI_align_preserved", 0, NULL},
10743 LOOKUP(26, ABI_enum_size),
10744 LOOKUP(27, ABI_HardFP_use),
10745 LOOKUP(28, ABI_VFP_args),
10746 LOOKUP(29, ABI_WMMX_args),
10747 LOOKUP(30, ABI_optimization_goals),
10748 LOOKUP(31, ABI_FP_optimization_goals),
10749 {32, "compatibility", 0, NULL},
10750 LOOKUP(34, CPU_unaligned_access),
10751 LOOKUP(36, FP_HP_extension),
10752 LOOKUP(38, ABI_FP_16bit_format),
10753 LOOKUP(42, MPextension_use),
10754 LOOKUP(44, DIV_use),
10755 {64, "nodefaults", 0, NULL},
10756 {65, "also_compatible_with", 0, NULL},
10757 LOOKUP(66, T2EE_use),
10758 {67, "conformance", 1, NULL},
10759 LOOKUP(68, Virtualization_use),
10760 LOOKUP(70, MPextension_use_legacy)
10764 static unsigned char *
10765 display_arm_attribute (unsigned char * p)
10770 arm_attr_public_tag * attr;
10774 tag = read_uleb128 (p, &len);
10777 for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
10779 if (arm_attr_public_tags[i].tag == tag)
10781 attr = &arm_attr_public_tags[i];
10788 printf (" Tag_%s: ", attr->name);
10789 switch (attr->type)
10794 case 7: /* Tag_CPU_arch_profile. */
10795 val = read_uleb128 (p, &len);
10799 case 0: printf (_("None\n")); break;
10800 case 'A': printf (_("Application\n")); break;
10801 case 'R': printf (_("Realtime\n")); break;
10802 case 'M': printf (_("Microcontroller\n")); break;
10803 case 'S': printf (_("Application or Realtime\n")); break;
10804 default: printf ("??? (%d)\n", val); break;
10808 case 24: /* Tag_align_needed. */
10809 val = read_uleb128 (p, &len);
10813 case 0: printf (_("None\n")); break;
10814 case 1: printf (_("8-byte\n")); break;
10815 case 2: printf (_("4-byte\n")); break;
10816 case 3: printf ("??? 3\n"); break;
10819 printf (_("8-byte and up to %d-byte extended\n"),
10822 printf ("??? (%d)\n", val);
10827 case 25: /* Tag_align_preserved. */
10828 val = read_uleb128 (p, &len);
10832 case 0: printf (_("None\n")); break;
10833 case 1: printf (_("8-byte, except leaf SP\n")); break;
10834 case 2: printf (_("8-byte\n")); break;
10835 case 3: printf ("??? 3\n"); break;
10838 printf (_("8-byte and up to %d-byte extended\n"),
10841 printf ("??? (%d)\n", val);
10846 case 32: /* Tag_compatibility. */
10847 val = read_uleb128 (p, &len);
10849 printf (_("flag = %d, vendor = %s\n"), val, p);
10850 p += strlen ((char *) p) + 1;
10853 case 64: /* Tag_nodefaults. */
10855 printf (_("True\n"));
10858 case 65: /* Tag_also_compatible_with. */
10859 val = read_uleb128 (p, &len);
10861 if (val == 6 /* Tag_CPU_arch. */)
10863 val = read_uleb128 (p, &len);
10865 if ((unsigned int)val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
10866 printf ("??? (%d)\n", val);
10868 printf ("%s\n", arm_attr_tag_CPU_arch[val]);
10872 while (*(p++) != '\0' /* NUL terminator. */);
10886 assert (attr->type & 0x80);
10887 val = read_uleb128 (p, &len);
10889 type = attr->type & 0x7f;
10891 printf ("??? (%d)\n", val);
10893 printf ("%s\n", attr->table[val]);
10900 type = 1; /* String. */
10902 type = 2; /* uleb128. */
10903 printf (" Tag_unknown_%d: ", tag);
10908 printf ("\"%s\"\n", p);
10909 p += strlen ((char *) p) + 1;
10913 val = read_uleb128 (p, &len);
10915 printf ("%d (0x%x)\n", val, val);
10921 static unsigned char *
10922 display_gnu_attribute (unsigned char * p,
10923 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int))
10930 tag = read_uleb128 (p, &len);
10933 /* Tag_compatibility is the only generic GNU attribute defined at
10937 val = read_uleb128 (p, &len);
10939 printf (_("flag = %d, vendor = %s\n"), val, p);
10940 p += strlen ((char *) p) + 1;
10944 if ((tag & 2) == 0 && display_proc_gnu_attribute)
10945 return display_proc_gnu_attribute (p, tag);
10948 type = 1; /* String. */
10950 type = 2; /* uleb128. */
10951 printf (" Tag_unknown_%d: ", tag);
10955 printf ("\"%s\"\n", p);
10956 p += strlen ((char *) p) + 1;
10960 val = read_uleb128 (p, &len);
10962 printf ("%d (0x%x)\n", val, val);
10968 static unsigned char *
10969 display_power_gnu_attribute (unsigned char * p, int tag)
10975 if (tag == Tag_GNU_Power_ABI_FP)
10977 val = read_uleb128 (p, &len);
10979 printf (" Tag_GNU_Power_ABI_FP: ");
10984 printf (_("Hard or soft float\n"));
10987 printf (_("Hard float\n"));
10990 printf (_("Soft float\n"));
10993 printf (_("Single-precision hard float\n"));
10996 printf ("??? (%d)\n", val);
11002 if (tag == Tag_GNU_Power_ABI_Vector)
11004 val = read_uleb128 (p, &len);
11006 printf (" Tag_GNU_Power_ABI_Vector: ");
11010 printf (_("Any\n"));
11013 printf (_("Generic\n"));
11016 printf ("AltiVec\n");
11022 printf ("??? (%d)\n", val);
11028 if (tag == Tag_GNU_Power_ABI_Struct_Return)
11030 val = read_uleb128 (p, &len);
11032 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
11036 printf (_("Any\n"));
11039 printf ("r3/r4\n");
11042 printf (_("Memory\n"));
11045 printf ("??? (%d)\n", val);
11052 type = 1; /* String. */
11054 type = 2; /* uleb128. */
11055 printf (" Tag_unknown_%d: ", tag);
11059 printf ("\"%s\"\n", p);
11060 p += strlen ((char *) p) + 1;
11064 val = read_uleb128 (p, &len);
11066 printf ("%d (0x%x)\n", val, val);
11072 static unsigned char *
11073 display_mips_gnu_attribute (unsigned char * p, int tag)
11079 if (tag == Tag_GNU_MIPS_ABI_FP)
11081 val = read_uleb128 (p, &len);
11083 printf (" Tag_GNU_MIPS_ABI_FP: ");
11088 printf (_("Hard or soft float\n"));
11091 printf (_("Hard float (double precision)\n"));
11094 printf (_("Hard float (single precision)\n"));
11097 printf (_("Soft float\n"));
11100 printf (_("Hard float (MIPS32r2 64-bit FPU)\n"));
11103 printf ("??? (%d)\n", val);
11110 type = 1; /* String. */
11112 type = 2; /* uleb128. */
11113 printf (" Tag_unknown_%d: ", tag);
11117 printf ("\"%s\"\n", p);
11118 p += strlen ((char *) p) + 1;
11122 val = read_uleb128 (p, &len);
11124 printf ("%d (0x%x)\n", val, val);
11130 static unsigned char *
11131 display_tic6x_attribute (unsigned char * p)
11137 tag = read_uleb128 (p, &len);
11143 val = read_uleb128 (p, &len);
11145 printf (" Tag_ISA: ");
11149 case C6XABI_Tag_ISA_none:
11150 printf (_("None\n"));
11152 case C6XABI_Tag_ISA_C62X:
11155 case C6XABI_Tag_ISA_C67X:
11158 case C6XABI_Tag_ISA_C67XP:
11159 printf ("C67x+\n");
11161 case C6XABI_Tag_ISA_C64X:
11164 case C6XABI_Tag_ISA_C64XP:
11165 printf ("C64x+\n");
11167 case C6XABI_Tag_ISA_C674X:
11168 printf ("C674x\n");
11171 printf ("??? (%d)\n", val);
11176 case Tag_ABI_wchar_t:
11177 val = read_uleb128 (p, &len);
11179 printf (" Tag_ABI_wchar_t: ");
11183 printf (_("Not used\n"));
11186 printf (_("2 bytes\n"));
11189 printf (_("4 bytes\n"));
11192 printf ("??? (%d)\n", val);
11197 case Tag_ABI_stack_align_needed:
11198 val = read_uleb128 (p, &len);
11200 printf (" Tag_ABI_stack_align_needed: ");
11204 printf (_("8-byte\n"));
11207 printf (_("16-byte\n"));
11210 printf ("??? (%d)\n", val);
11215 case Tag_ABI_stack_align_preserved:
11216 val = read_uleb128 (p, &len);
11218 printf (" Tag_ABI_stack_align_preserved: ");
11222 printf (_("8-byte\n"));
11225 printf (_("16-byte\n"));
11228 printf ("??? (%d)\n", val);
11234 val = read_uleb128 (p, &len);
11236 printf (" Tag_ABI_DSBT: ");
11240 printf (_("DSBT addressing not used\n"));
11243 printf (_("DSBT addressing used\n"));
11246 printf ("??? (%d)\n", val);
11252 val = read_uleb128 (p, &len);
11254 printf (" Tag_ABI_PID: ");
11258 printf (_("Data addressing position-dependent\n"));
11261 printf (_("Data addressing position-independent, GOT near DP\n"));
11264 printf (_("Data addressing position-independent, GOT far from DP\n"));
11267 printf ("??? (%d)\n", val);
11273 val = read_uleb128 (p, &len);
11275 printf (" Tag_ABI_PIC: ");
11279 printf (_("Code addressing position-dependent\n"));
11282 printf (_("Code addressing position-independent\n"));
11285 printf ("??? (%d)\n", val);
11290 case Tag_ABI_array_object_alignment:
11291 val = read_uleb128 (p, &len);
11293 printf (" Tag_ABI_array_object_alignment: ");
11297 printf (_("8-byte\n"));
11300 printf (_("4-byte\n"));
11303 printf (_("16-byte\n"));
11306 printf ("??? (%d)\n", val);
11311 case Tag_ABI_array_object_align_expected:
11312 val = read_uleb128 (p, &len);
11314 printf (" Tag_ABI_array_object_align_expected: ");
11318 printf (_("8-byte\n"));
11321 printf (_("4-byte\n"));
11324 printf (_("16-byte\n"));
11327 printf ("??? (%d)\n", val);
11332 case Tag_ABI_compatibility:
11333 val = read_uleb128 (p, &len);
11335 printf (" Tag_ABI_compatibility: ");
11336 printf (_("flag = %d, vendor = %s\n"), val, p);
11337 p += strlen ((char *) p) + 1;
11340 case Tag_ABI_conformance:
11341 printf (" Tag_ABI_conformance: ");
11342 printf ("\"%s\"\n", p);
11343 p += strlen ((char *) p) + 1;
11347 printf (" Tag_unknown_%d: ", tag);
11351 printf ("\"%s\"\n", p);
11352 p += strlen ((char *) p) + 1;
11356 val = read_uleb128 (p, &len);
11358 printf ("%d (0x%x)\n", val, val);
11365 process_attributes (FILE * file,
11366 const char * public_name,
11367 unsigned int proc_type,
11368 unsigned char * (* display_pub_attribute) (unsigned char *),
11369 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int))
11371 Elf_Internal_Shdr * sect;
11372 unsigned char * contents;
11374 unsigned char * end;
11375 bfd_vma section_len;
11379 /* Find the section header so that we get the size. */
11380 for (i = 0, sect = section_headers;
11381 i < elf_header.e_shnum;
11384 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
11387 contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
11388 sect->sh_size, _("attributes"));
11389 if (contents == NULL)
11395 len = sect->sh_size - 1;
11401 bfd_boolean public_section;
11402 bfd_boolean gnu_section;
11404 section_len = byte_get (p, 4);
11407 if (section_len > len)
11409 printf (_("ERROR: Bad section length (%d > %d)\n"),
11410 (int) section_len, (int) len);
11414 len -= section_len;
11415 printf (_("Attribute Section: %s\n"), p);
11417 if (public_name && streq ((char *) p, public_name))
11418 public_section = TRUE;
11420 public_section = FALSE;
11422 if (streq ((char *) p, "gnu"))
11423 gnu_section = TRUE;
11425 gnu_section = FALSE;
11427 namelen = strlen ((char *) p) + 1;
11429 section_len -= namelen + 4;
11431 while (section_len > 0)
11437 size = byte_get (p, 4);
11438 if (size > section_len)
11440 printf (_("ERROR: Bad subsection length (%d > %d)\n"),
11441 (int) size, (int) section_len);
11442 size = section_len;
11445 section_len -= size;
11446 end = p + size - 1;
11452 printf (_("File Attributes\n"));
11455 printf (_("Section Attributes:"));
11458 printf (_("Symbol Attributes:"));
11464 val = read_uleb128 (p, &j);
11468 printf (" %d", val);
11473 printf (_("Unknown tag: %d\n"), tag);
11474 public_section = FALSE;
11478 if (public_section)
11481 p = display_pub_attribute (p);
11483 else if (gnu_section)
11486 p = display_gnu_attribute (p,
11487 display_proc_gnu_attribute);
11491 /* ??? Do something sensible, like dump hex. */
11492 printf (_(" Unknown section contexts\n"));
11499 printf (_("Unknown format '%c'\n"), *p);
11507 process_arm_specific (FILE * file)
11509 return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
11510 display_arm_attribute, NULL);
11514 process_power_specific (FILE * file)
11516 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
11517 display_power_gnu_attribute);
11521 process_tic6x_specific (FILE * file)
11523 return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
11524 display_tic6x_attribute, NULL);
11527 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
11528 Print the Address, Access and Initial fields of an entry at VMA ADDR
11529 and return the VMA of the next entry. */
11532 print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
11535 print_vma (addr, LONG_HEX);
11537 if (addr < pltgot + 0xfff0)
11538 printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
11540 printf ("%10s", "");
11543 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
11548 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
11549 print_vma (entry, LONG_HEX);
11551 return addr + (is_32bit_elf ? 4 : 8);
11554 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
11555 PLTGOT. Print the Address and Initial fields of an entry at VMA
11556 ADDR and return the VMA of the next entry. */
11559 print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
11562 print_vma (addr, LONG_HEX);
11565 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
11570 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
11571 print_vma (entry, LONG_HEX);
11573 return addr + (is_32bit_elf ? 4 : 8);
11577 process_mips_specific (FILE * file)
11579 Elf_Internal_Dyn * entry;
11580 size_t liblist_offset = 0;
11581 size_t liblistno = 0;
11582 size_t conflictsno = 0;
11583 size_t options_offset = 0;
11584 size_t conflicts_offset = 0;
11585 size_t pltrelsz = 0;
11587 bfd_vma pltgot = 0;
11588 bfd_vma mips_pltgot = 0;
11589 bfd_vma jmprel = 0;
11590 bfd_vma local_gotno = 0;
11591 bfd_vma gotsym = 0;
11592 bfd_vma symtabno = 0;
11594 process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
11595 display_mips_gnu_attribute);
11597 /* We have a lot of special sections. Thanks SGI! */
11598 if (dynamic_section == NULL)
11599 /* No information available. */
11602 for (entry = dynamic_section; entry->d_tag != DT_NULL; ++entry)
11603 switch (entry->d_tag)
11605 case DT_MIPS_LIBLIST:
11607 = offset_from_vma (file, entry->d_un.d_val,
11608 liblistno * sizeof (Elf32_External_Lib));
11610 case DT_MIPS_LIBLISTNO:
11611 liblistno = entry->d_un.d_val;
11613 case DT_MIPS_OPTIONS:
11614 options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
11616 case DT_MIPS_CONFLICT:
11618 = offset_from_vma (file, entry->d_un.d_val,
11619 conflictsno * sizeof (Elf32_External_Conflict));
11621 case DT_MIPS_CONFLICTNO:
11622 conflictsno = entry->d_un.d_val;
11625 pltgot = entry->d_un.d_ptr;
11627 case DT_MIPS_LOCAL_GOTNO:
11628 local_gotno = entry->d_un.d_val;
11630 case DT_MIPS_GOTSYM:
11631 gotsym = entry->d_un.d_val;
11633 case DT_MIPS_SYMTABNO:
11634 symtabno = entry->d_un.d_val;
11636 case DT_MIPS_PLTGOT:
11637 mips_pltgot = entry->d_un.d_ptr;
11640 pltrel = entry->d_un.d_val;
11643 pltrelsz = entry->d_un.d_val;
11646 jmprel = entry->d_un.d_ptr;
11652 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
11654 Elf32_External_Lib * elib;
11657 elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
11659 sizeof (Elf32_External_Lib),
11663 printf (_("\nSection '.liblist' contains %lu entries:\n"),
11664 (unsigned long) liblistno);
11665 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
11668 for (cnt = 0; cnt < liblistno; ++cnt)
11675 liblist.l_name = BYTE_GET (elib[cnt].l_name);
11676 atime = BYTE_GET (elib[cnt].l_time_stamp);
11677 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
11678 liblist.l_version = BYTE_GET (elib[cnt].l_version);
11679 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
11681 tmp = gmtime (&atime);
11682 snprintf (timebuf, sizeof (timebuf),
11683 "%04u-%02u-%02uT%02u:%02u:%02u",
11684 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
11685 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
11687 printf ("%3lu: ", (unsigned long) cnt);
11688 if (VALID_DYNAMIC_NAME (liblist.l_name))
11689 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
11691 printf (_("<corrupt: %9ld>"), liblist.l_name);
11692 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
11693 liblist.l_version);
11695 if (liblist.l_flags == 0)
11699 static const struct
11706 { " EXACT_MATCH", LL_EXACT_MATCH },
11707 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
11708 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
11709 { " EXPORTS", LL_EXPORTS },
11710 { " DELAY_LOAD", LL_DELAY_LOAD },
11711 { " DELTA", LL_DELTA }
11713 int flags = liblist.l_flags;
11716 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
11717 if ((flags & l_flags_vals[fcnt].bit) != 0)
11719 fputs (l_flags_vals[fcnt].name, stdout);
11720 flags ^= l_flags_vals[fcnt].bit;
11723 printf (" %#x", (unsigned int) flags);
11733 if (options_offset != 0)
11735 Elf_External_Options * eopt;
11736 Elf_Internal_Shdr * sect = section_headers;
11737 Elf_Internal_Options * iopt;
11738 Elf_Internal_Options * option;
11742 /* Find the section header so that we get the size. */
11743 while (sect->sh_type != SHT_MIPS_OPTIONS)
11746 eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
11747 sect->sh_size, _("options"));
11750 iopt = (Elf_Internal_Options *)
11751 cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
11754 error (_("Out of memory\n"));
11761 while (offset < sect->sh_size)
11763 Elf_External_Options * eoption;
11765 eoption = (Elf_External_Options *) ((char *) eopt + offset);
11767 option->kind = BYTE_GET (eoption->kind);
11768 option->size = BYTE_GET (eoption->size);
11769 option->section = BYTE_GET (eoption->section);
11770 option->info = BYTE_GET (eoption->info);
11772 offset += option->size;
11778 printf (_("\nSection '%s' contains %d entries:\n"),
11779 SECTION_NAME (sect), cnt);
11787 switch (option->kind)
11790 /* This shouldn't happen. */
11791 printf (" NULL %d %lx", option->section, option->info);
11794 printf (" REGINFO ");
11795 if (elf_header.e_machine == EM_MIPS)
11798 Elf32_External_RegInfo * ereg;
11799 Elf32_RegInfo reginfo;
11801 ereg = (Elf32_External_RegInfo *) (option + 1);
11802 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
11803 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
11804 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
11805 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
11806 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
11807 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
11809 printf ("GPR %08lx GP 0x%lx\n",
11810 reginfo.ri_gprmask,
11811 (unsigned long) reginfo.ri_gp_value);
11812 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
11813 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
11814 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
11819 Elf64_External_RegInfo * ereg;
11820 Elf64_Internal_RegInfo reginfo;
11822 ereg = (Elf64_External_RegInfo *) (option + 1);
11823 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
11824 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
11825 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
11826 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
11827 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
11828 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
11830 printf ("GPR %08lx GP 0x",
11831 reginfo.ri_gprmask);
11832 printf_vma (reginfo.ri_gp_value);
11835 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
11836 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
11837 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
11841 case ODK_EXCEPTIONS:
11842 fputs (" EXCEPTIONS fpe_min(", stdout);
11843 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
11844 fputs (") fpe_max(", stdout);
11845 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
11846 fputs (")", stdout);
11848 if (option->info & OEX_PAGE0)
11849 fputs (" PAGE0", stdout);
11850 if (option->info & OEX_SMM)
11851 fputs (" SMM", stdout);
11852 if (option->info & OEX_FPDBUG)
11853 fputs (" FPDBUG", stdout);
11854 if (option->info & OEX_DISMISS)
11855 fputs (" DISMISS", stdout);
11858 fputs (" PAD ", stdout);
11859 if (option->info & OPAD_PREFIX)
11860 fputs (" PREFIX", stdout);
11861 if (option->info & OPAD_POSTFIX)
11862 fputs (" POSTFIX", stdout);
11863 if (option->info & OPAD_SYMBOL)
11864 fputs (" SYMBOL", stdout);
11867 fputs (" HWPATCH ", stdout);
11868 if (option->info & OHW_R4KEOP)
11869 fputs (" R4KEOP", stdout);
11870 if (option->info & OHW_R8KPFETCH)
11871 fputs (" R8KPFETCH", stdout);
11872 if (option->info & OHW_R5KEOP)
11873 fputs (" R5KEOP", stdout);
11874 if (option->info & OHW_R5KCVTL)
11875 fputs (" R5KCVTL", stdout);
11878 fputs (" FILL ", stdout);
11879 /* XXX Print content of info word? */
11882 fputs (" TAGS ", stdout);
11883 /* XXX Print content of info word? */
11886 fputs (" HWAND ", stdout);
11887 if (option->info & OHWA0_R4KEOP_CHECKED)
11888 fputs (" R4KEOP_CHECKED", stdout);
11889 if (option->info & OHWA0_R4KEOP_CLEAN)
11890 fputs (" R4KEOP_CLEAN", stdout);
11893 fputs (" HWOR ", stdout);
11894 if (option->info & OHWA0_R4KEOP_CHECKED)
11895 fputs (" R4KEOP_CHECKED", stdout);
11896 if (option->info & OHWA0_R4KEOP_CLEAN)
11897 fputs (" R4KEOP_CLEAN", stdout);
11900 printf (" GP_GROUP %#06lx self-contained %#06lx",
11901 option->info & OGP_GROUP,
11902 (option->info & OGP_SELF) >> 16);
11905 printf (" IDENT %#06lx self-contained %#06lx",
11906 option->info & OGP_GROUP,
11907 (option->info & OGP_SELF) >> 16);
11910 /* This shouldn't happen. */
11911 printf (" %3d ??? %d %lx",
11912 option->kind, option->section, option->info);
11916 len = sizeof (* eopt);
11917 while (len < option->size)
11918 if (((char *) option)[len] >= ' '
11919 && ((char *) option)[len] < 0x7f)
11920 printf ("%c", ((char *) option)[len++]);
11922 printf ("\\%03o", ((char *) option)[len++]);
11924 fputs ("\n", stdout);
11932 if (conflicts_offset != 0 && conflictsno != 0)
11934 Elf32_Conflict * iconf;
11937 if (dynamic_symbols == NULL)
11939 error (_("conflict list found without a dynamic symbol table\n"));
11943 iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
11946 error (_("Out of memory\n"));
11952 Elf32_External_Conflict * econf32;
11954 econf32 = (Elf32_External_Conflict *)
11955 get_data (NULL, file, conflicts_offset, conflictsno,
11956 sizeof (* econf32), _("conflict"));
11960 for (cnt = 0; cnt < conflictsno; ++cnt)
11961 iconf[cnt] = BYTE_GET (econf32[cnt]);
11967 Elf64_External_Conflict * econf64;
11969 econf64 = (Elf64_External_Conflict *)
11970 get_data (NULL, file, conflicts_offset, conflictsno,
11971 sizeof (* econf64), _("conflict"));
11975 for (cnt = 0; cnt < conflictsno; ++cnt)
11976 iconf[cnt] = BYTE_GET (econf64[cnt]);
11981 printf (_("\nSection '.conflict' contains %lu entries:\n"),
11982 (unsigned long) conflictsno);
11983 puts (_(" Num: Index Value Name"));
11985 for (cnt = 0; cnt < conflictsno; ++cnt)
11987 Elf_Internal_Sym * psym = & dynamic_symbols[iconf[cnt]];
11989 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
11990 print_vma (psym->st_value, FULL_HEX);
11992 if (VALID_DYNAMIC_NAME (psym->st_name))
11993 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
11995 printf (_("<corrupt: %14ld>"), psym->st_name);
12002 if (pltgot != 0 && local_gotno != 0)
12004 bfd_vma ent, local_end, global_end;
12006 unsigned char * data;
12010 addr_size = (is_32bit_elf ? 4 : 8);
12011 local_end = pltgot + local_gotno * addr_size;
12012 global_end = local_end + (symtabno - gotsym) * addr_size;
12014 offset = offset_from_vma (file, pltgot, global_end - pltgot);
12015 data = (unsigned char *) get_data (NULL, file, offset,
12016 global_end - pltgot, 1, _("GOT"));
12020 printf (_("\nPrimary GOT:\n"));
12021 printf (_(" Canonical gp value: "));
12022 print_vma (pltgot + 0x7ff0, LONG_HEX);
12025 printf (_(" Reserved entries:\n"));
12026 printf (_(" %*s %10s %*s Purpose\n"),
12027 addr_size * 2, _("Address"), _("Access"),
12028 addr_size * 2, _("Initial"));
12029 ent = print_mips_got_entry (data, pltgot, ent);
12030 printf (_(" Lazy resolver\n"));
12032 && (byte_get (data + ent - pltgot, addr_size)
12033 >> (addr_size * 8 - 1)) != 0)
12035 ent = print_mips_got_entry (data, pltgot, ent);
12036 printf (_(" Module pointer (GNU extension)\n"));
12040 if (ent < local_end)
12042 printf (_(" Local entries:\n"));
12043 printf (" %*s %10s %*s\n",
12044 addr_size * 2, _("Address"), _("Access"),
12045 addr_size * 2, _("Initial"));
12046 while (ent < local_end)
12048 ent = print_mips_got_entry (data, pltgot, ent);
12054 if (gotsym < symtabno)
12058 printf (_(" Global entries:\n"));
12059 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
12060 addr_size * 2, _("Address"), _("Access"),
12061 addr_size * 2, _("Initial"),
12062 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
12063 sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
12064 for (i = gotsym; i < symtabno; i++)
12066 Elf_Internal_Sym * psym;
12068 psym = dynamic_symbols + i;
12069 ent = print_mips_got_entry (data, pltgot, ent);
12071 print_vma (psym->st_value, LONG_HEX);
12072 printf (" %-7s %3s ",
12073 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
12074 get_symbol_index_type (psym->st_shndx));
12075 if (VALID_DYNAMIC_NAME (psym->st_name))
12076 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
12078 printf (_("<corrupt: %14ld>"), psym->st_name);
12088 if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
12091 size_t offset, rel_offset;
12092 unsigned long count, i;
12093 unsigned char * data;
12094 int addr_size, sym_width;
12095 Elf_Internal_Rela * rels;
12097 rel_offset = offset_from_vma (file, jmprel, pltrelsz);
12098 if (pltrel == DT_RELA)
12100 if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
12105 if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
12110 addr_size = (is_32bit_elf ? 4 : 8);
12111 end = mips_pltgot + (2 + count) * addr_size;
12113 offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
12114 data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
12119 printf (_("\nPLT GOT:\n\n"));
12120 printf (_(" Reserved entries:\n"));
12121 printf (_(" %*s %*s Purpose\n"),
12122 addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
12123 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
12124 printf (_(" PLT lazy resolver\n"));
12125 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
12126 printf (_(" Module pointer\n"));
12129 printf (_(" Entries:\n"));
12130 printf (" %*s %*s %*s %-7s %3s %s\n",
12131 addr_size * 2, _("Address"),
12132 addr_size * 2, _("Initial"),
12133 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
12134 sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
12135 for (i = 0; i < count; i++)
12137 Elf_Internal_Sym * psym;
12139 psym = dynamic_symbols + get_reloc_symindex (rels[i].r_info);
12140 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
12142 print_vma (psym->st_value, LONG_HEX);
12143 printf (" %-7s %3s ",
12144 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
12145 get_symbol_index_type (psym->st_shndx));
12146 if (VALID_DYNAMIC_NAME (psym->st_name))
12147 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
12149 printf (_("<corrupt: %14ld>"), psym->st_name);
12163 process_gnu_liblist (FILE * file)
12165 Elf_Internal_Shdr * section;
12166 Elf_Internal_Shdr * string_sec;
12167 Elf32_External_Lib * elib;
12169 size_t strtab_size;
12176 for (i = 0, section = section_headers;
12177 i < elf_header.e_shnum;
12180 switch (section->sh_type)
12182 case SHT_GNU_LIBLIST:
12183 if (section->sh_link >= elf_header.e_shnum)
12186 elib = (Elf32_External_Lib *)
12187 get_data (NULL, file, section->sh_offset, 1, section->sh_size,
12192 string_sec = section_headers + section->sh_link;
12194 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
12195 string_sec->sh_size,
12196 _("liblist string table"));
12198 || section->sh_entsize != sizeof (Elf32_External_Lib))
12204 strtab_size = string_sec->sh_size;
12206 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
12207 SECTION_NAME (section),
12208 (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
12210 puts (_(" Library Time Stamp Checksum Version Flags"));
12212 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
12220 liblist.l_name = BYTE_GET (elib[cnt].l_name);
12221 atime = BYTE_GET (elib[cnt].l_time_stamp);
12222 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
12223 liblist.l_version = BYTE_GET (elib[cnt].l_version);
12224 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
12226 tmp = gmtime (&atime);
12227 snprintf (timebuf, sizeof (timebuf),
12228 "%04u-%02u-%02uT%02u:%02u:%02u",
12229 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
12230 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
12232 printf ("%3lu: ", (unsigned long) cnt);
12234 printf ("%-20s", liblist.l_name < strtab_size
12235 ? strtab + liblist.l_name : _("<corrupt>"));
12237 printf ("%-20.20s", liblist.l_name < strtab_size
12238 ? strtab + liblist.l_name : _("<corrupt>"));
12239 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
12240 liblist.l_version, liblist.l_flags);
12251 static const char *
12252 get_note_type (unsigned e_type)
12254 static char buff[64];
12256 if (elf_header.e_type == ET_CORE)
12260 return _("NT_AUXV (auxiliary vector)");
12262 return _("NT_PRSTATUS (prstatus structure)");
12264 return _("NT_FPREGSET (floating point registers)");
12266 return _("NT_PRPSINFO (prpsinfo structure)");
12267 case NT_TASKSTRUCT:
12268 return _("NT_TASKSTRUCT (task structure)");
12270 return _("NT_PRXFPREG (user_xfpregs structure)");
12272 return _("NT_PPC_VMX (ppc Altivec registers)");
12274 return _("NT_PPC_VSX (ppc VSX registers)");
12275 case NT_X86_XSTATE:
12276 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
12277 case NT_S390_HIGH_GPRS:
12278 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
12279 case NT_S390_TIMER:
12280 return _("NT_S390_TIMER (s390 timer register)");
12281 case NT_S390_TODCMP:
12282 return _("NT_S390_TODCMP (s390 TOD comparator register)");
12283 case NT_S390_TODPREG:
12284 return _("NT_S390_TODPREG (s390 TOD programmable register)");
12286 return _("NT_S390_CTRS (s390 control registers)");
12287 case NT_S390_PREFIX:
12288 return _("NT_S390_PREFIX (s390 prefix register)");
12290 return _("NT_ARM_VFP (arm VFP registers)");
12292 return _("NT_PSTATUS (pstatus structure)");
12294 return _("NT_FPREGS (floating point registers)");
12296 return _("NT_PSINFO (psinfo structure)");
12298 return _("NT_LWPSTATUS (lwpstatus_t structure)");
12300 return _("NT_LWPSINFO (lwpsinfo_t structure)");
12301 case NT_WIN32PSTATUS:
12302 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
12310 return _("NT_VERSION (version)");
12312 return _("NT_ARCH (architecture)");
12317 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
12321 static const char *
12322 get_gnu_elf_note_type (unsigned e_type)
12324 static char buff[64];
12328 case NT_GNU_ABI_TAG:
12329 return _("NT_GNU_ABI_TAG (ABI version tag)");
12331 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
12332 case NT_GNU_BUILD_ID:
12333 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
12334 case NT_GNU_GOLD_VERSION:
12335 return _("NT_GNU_GOLD_VERSION (gold version)");
12340 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
12345 print_gnu_note (Elf_Internal_Note *pnote)
12347 switch (pnote->type)
12349 case NT_GNU_BUILD_ID:
12353 printf (_(" Build ID: "));
12354 for (i = 0; i < pnote->descsz; ++i)
12355 printf ("%02x", pnote->descdata[i] & 0xff);
12360 case NT_GNU_ABI_TAG:
12362 unsigned long os, major, minor, subminor;
12363 const char *osname;
12365 os = byte_get ((unsigned char *) pnote->descdata, 4);
12366 major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
12367 minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
12368 subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
12372 case GNU_ABI_TAG_LINUX:
12375 case GNU_ABI_TAG_HURD:
12378 case GNU_ABI_TAG_SOLARIS:
12379 osname = "Solaris";
12381 case GNU_ABI_TAG_FREEBSD:
12382 osname = "FreeBSD";
12384 case GNU_ABI_TAG_NETBSD:
12388 osname = "Unknown";
12392 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname,
12393 major, minor, subminor);
12401 static const char *
12402 get_netbsd_elfcore_note_type (unsigned e_type)
12404 static char buff[64];
12406 if (e_type == NT_NETBSDCORE_PROCINFO)
12408 /* NetBSD core "procinfo" structure. */
12409 return _("NetBSD procinfo structure");
12412 /* As of Jan 2002 there are no other machine-independent notes
12413 defined for NetBSD core files. If the note type is less
12414 than the start of the machine-dependent note types, we don't
12417 if (e_type < NT_NETBSDCORE_FIRSTMACH)
12419 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
12423 switch (elf_header.e_machine)
12425 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
12426 and PT_GETFPREGS == mach+2. */
12431 case EM_SPARC32PLUS:
12435 case NT_NETBSDCORE_FIRSTMACH + 0:
12436 return _("PT_GETREGS (reg structure)");
12437 case NT_NETBSDCORE_FIRSTMACH + 2:
12438 return _("PT_GETFPREGS (fpreg structure)");
12444 /* On all other arch's, PT_GETREGS == mach+1 and
12445 PT_GETFPREGS == mach+3. */
12449 case NT_NETBSDCORE_FIRSTMACH + 1:
12450 return _("PT_GETREGS (reg structure)");
12451 case NT_NETBSDCORE_FIRSTMACH + 3:
12452 return _("PT_GETFPREGS (fpreg structure)");
12458 snprintf (buff, sizeof (buff), _("PT_FIRSTMACH+%d"),
12459 e_type - NT_NETBSDCORE_FIRSTMACH);
12463 static const char *
12464 get_stapsdt_note_type (unsigned e_type)
12466 static char buff[64];
12471 return _("NT_STAPSDT (SystemTap probe descriptors)");
12477 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
12482 print_stapsdt_note (Elf_Internal_Note *pnote)
12484 int addr_size = is_32bit_elf ? 4 : 8;
12485 char *data = pnote->descdata;
12486 char *data_end = pnote->descdata + pnote->descsz;
12487 bfd_vma pc, base_addr, semaphore;
12488 char *provider, *probe, *arg_fmt;
12490 pc = byte_get ((unsigned char *) data, addr_size);
12492 base_addr = byte_get ((unsigned char *) data, addr_size);
12494 semaphore = byte_get ((unsigned char *) data, addr_size);
12498 data += strlen (data) + 1;
12500 data += strlen (data) + 1;
12502 data += strlen (data) + 1;
12504 printf (_(" Provider: %s\n"), provider);
12505 printf (_(" Name: %s\n"), probe);
12506 printf (_(" Location: "));
12507 print_vma (pc, FULL_HEX);
12508 printf (_(", Base: "));
12509 print_vma (base_addr, FULL_HEX);
12510 printf (_(", Semaphore: "));
12511 print_vma (semaphore, FULL_HEX);
12513 printf (_(" Arguments: %s\n"), arg_fmt);
12515 return data == data_end;
12518 static const char *
12519 get_ia64_vms_note_type (unsigned e_type)
12521 static char buff[64];
12526 return _("NT_VMS_MHD (module header)");
12528 return _("NT_VMS_LNM (language name)");
12530 return _("NT_VMS_SRC (source files)");
12532 return _("NT_VMS_TITLE");
12534 return _("NT_VMS_EIDC (consistency check)");
12535 case NT_VMS_FPMODE:
12536 return _("NT_VMS_FPMODE (FP mode)");
12537 case NT_VMS_LINKTIME:
12538 return _("NT_VMS_LINKTIME");
12539 case NT_VMS_IMGNAM:
12540 return _("NT_VMS_IMGNAM (image name)");
12542 return _("NT_VMS_IMGID (image id)");
12543 case NT_VMS_LINKID:
12544 return _("NT_VMS_LINKID (link id)");
12545 case NT_VMS_IMGBID:
12546 return _("NT_VMS_IMGBID (build id)");
12547 case NT_VMS_GSTNAM:
12548 return _("NT_VMS_GSTNAM (sym table name)");
12549 case NT_VMS_ORIG_DYN:
12550 return _("NT_VMS_ORIG_DYN");
12551 case NT_VMS_PATCHTIME:
12552 return _("NT_VMS_PATCHTIME");
12554 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
12560 print_ia64_vms_note (Elf_Internal_Note * pnote)
12562 switch (pnote->type)
12565 if (pnote->descsz > 36)
12567 size_t l = strlen (pnote->descdata + 34);
12568 printf (_(" Creation date : %.17s\n"), pnote->descdata);
12569 printf (_(" Last patch date: %.17s\n"), pnote->descdata + 17);
12570 printf (_(" Module name : %s\n"), pnote->descdata + 34);
12571 printf (_(" Module version : %s\n"), pnote->descdata + 34 + l + 1);
12574 printf (_(" Invalid size\n"));
12577 printf (_(" Language: %s\n"), pnote->descdata);
12580 case NT_VMS_FPMODE:
12581 printf (_(" FP mode: 0x%016" BFD_VMA_FMT "x\n"),
12582 (bfd_vma)byte_get ((unsigned char *)pnote->descdata, 8));
12584 case NT_VMS_LINKTIME:
12585 printf (_(" Link time: "));
12587 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
12590 case NT_VMS_PATCHTIME:
12591 printf (_(" Patch time: "));
12593 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
12596 case NT_VMS_ORIG_DYN:
12597 printf (_(" Major id: %u, minor id: %u\n"),
12598 (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
12599 (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
12600 printf (_(" Manip date : "));
12602 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
12604 " Link flags : 0x%016" BFD_VMA_FMT "x\n"),
12605 (bfd_vma)byte_get ((unsigned char *)pnote->descdata + 16, 8));
12606 printf (_(" Header flags: 0x%08x\n"),
12607 (unsigned)byte_get ((unsigned char *)pnote->descdata + 24, 4));
12608 printf (_(" Image id : %s\n"), pnote->descdata + 32);
12611 case NT_VMS_IMGNAM:
12612 printf (_(" Image name: %s\n"), pnote->descdata);
12614 case NT_VMS_GSTNAM:
12615 printf (_(" Global symbol table name: %s\n"), pnote->descdata);
12618 printf (_(" Image id: %s\n"), pnote->descdata);
12620 case NT_VMS_LINKID:
12621 printf (_(" Linker id: %s\n"), pnote->descdata);
12629 /* Note that by the ELF standard, the name field is already null byte
12630 terminated, and namesz includes the terminating null byte.
12631 I.E. the value of namesz for the name "FSF" is 4.
12633 If the value of namesz is zero, there is no name present. */
12635 process_note (Elf_Internal_Note * pnote)
12637 const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
12640 if (pnote->namesz == 0)
12641 /* If there is no note name, then use the default set of
12642 note type strings. */
12643 nt = get_note_type (pnote->type);
12645 else if (const_strneq (pnote->namedata, "GNU"))
12646 /* GNU-specific object file notes. */
12647 nt = get_gnu_elf_note_type (pnote->type);
12649 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
12650 /* NetBSD-specific core file notes. */
12651 nt = get_netbsd_elfcore_note_type (pnote->type);
12653 else if (strneq (pnote->namedata, "SPU/", 4))
12655 /* SPU-specific core file notes. */
12656 nt = pnote->namedata + 4;
12660 else if (const_strneq (pnote->namedata, "IPF/VMS"))
12661 /* VMS/ia64-specific file notes. */
12662 nt = get_ia64_vms_note_type (pnote->type);
12664 else if (const_strneq (pnote->namedata, "stapsdt"))
12665 nt = get_stapsdt_note_type (pnote->type);
12668 /* Don't recognize this note name; just use the default set of
12669 note type strings. */
12670 nt = get_note_type (pnote->type);
12672 printf (" %-20s 0x%08lx\t%s\n", name, pnote->descsz, nt);
12674 if (const_strneq (pnote->namedata, "IPF/VMS"))
12675 return print_ia64_vms_note (pnote);
12676 else if (const_strneq (pnote->namedata, "GNU"))
12677 return print_gnu_note (pnote);
12678 else if (const_strneq (pnote->namedata, "stapsdt"))
12679 return print_stapsdt_note (pnote);
12686 process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
12688 Elf_External_Note * pnotes;
12689 Elf_External_Note * external;
12695 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
12697 if (pnotes == NULL)
12702 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
12703 (unsigned long) offset, (unsigned long) length);
12704 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
12706 while (external < (Elf_External_Note *) ((char *) pnotes + length))
12708 Elf_External_Note * next;
12709 Elf_Internal_Note inote;
12710 char * temp = NULL;
12712 if (!is_ia64_vms ())
12714 inote.type = BYTE_GET (external->type);
12715 inote.namesz = BYTE_GET (external->namesz);
12716 inote.namedata = external->name;
12717 inote.descsz = BYTE_GET (external->descsz);
12718 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
12719 inote.descpos = offset + (inote.descdata - (char *) pnotes);
12721 next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
12725 Elf64_External_VMS_Note *vms_external;
12727 vms_external = (Elf64_External_VMS_Note *)external;
12728 inote.type = BYTE_GET (vms_external->type);
12729 inote.namesz = BYTE_GET (vms_external->namesz);
12730 inote.namedata = vms_external->name;
12731 inote.descsz = BYTE_GET (vms_external->descsz);
12732 inote.descdata = inote.namedata + align_power (inote.namesz, 3);
12733 inote.descpos = offset + (inote.descdata - (char *) pnotes);
12735 next = (Elf_External_Note *)
12736 (inote.descdata + align_power (inote.descsz, 3));
12739 if ( ((char *) next > ((char *) pnotes) + length)
12740 || ((char *) next < (char *) pnotes))
12742 warn (_("corrupt note found at offset %lx into core notes\n"),
12743 (unsigned long) ((char *) external - (char *) pnotes));
12744 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
12745 inote.type, inote.namesz, inote.descsz);
12751 /* Prevent out-of-bounds indexing. */
12752 if (inote.namedata + inote.namesz >= (char *) pnotes + length
12753 || inote.namedata + inote.namesz < inote.namedata)
12755 warn (_("corrupt note found at offset %lx into core notes\n"),
12756 (unsigned long) ((char *) external - (char *) pnotes));
12757 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
12758 inote.type, inote.namesz, inote.descsz);
12762 /* Verify that name is null terminated. It appears that at least
12763 one version of Linux (RedHat 6.0) generates corefiles that don't
12764 comply with the ELF spec by failing to include the null byte in
12766 if (inote.namedata[inote.namesz] != '\0')
12768 temp = (char *) malloc (inote.namesz + 1);
12772 error (_("Out of memory\n"));
12777 strncpy (temp, inote.namedata, inote.namesz);
12778 temp[inote.namesz] = 0;
12780 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
12781 inote.namedata = temp;
12784 res &= process_note (& inote);
12799 process_corefile_note_segments (FILE * file)
12801 Elf_Internal_Phdr * segment;
12805 if (! get_program_headers (file))
12808 for (i = 0, segment = program_headers;
12809 i < elf_header.e_phnum;
12812 if (segment->p_type == PT_NOTE)
12813 res &= process_corefile_note_segment (file,
12814 (bfd_vma) segment->p_offset,
12815 (bfd_vma) segment->p_filesz);
12822 process_note_sections (FILE * file)
12824 Elf_Internal_Shdr * section;
12828 for (i = 0, section = section_headers;
12829 i < elf_header.e_shnum;
12831 if (section->sh_type == SHT_NOTE)
12832 res &= process_corefile_note_segment (file,
12833 (bfd_vma) section->sh_offset,
12834 (bfd_vma) section->sh_size);
12840 process_notes (FILE * file)
12842 /* If we have not been asked to display the notes then do nothing. */
12846 if (elf_header.e_type != ET_CORE)
12847 return process_note_sections (file);
12849 /* No program headers means no NOTE segment. */
12850 if (elf_header.e_phnum > 0)
12851 return process_corefile_note_segments (file);
12853 printf (_("No note segments present in the core file.\n"));
12858 process_arch_specific (FILE * file)
12863 switch (elf_header.e_machine)
12866 return process_arm_specific (file);
12868 case EM_MIPS_RS3_LE:
12869 return process_mips_specific (file);
12872 return process_power_specific (file);
12875 return process_tic6x_specific (file);
12884 get_file_header (FILE * file)
12886 /* Read in the identity array. */
12887 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
12890 /* Determine how to read the rest of the header. */
12891 switch (elf_header.e_ident[EI_DATA])
12893 default: /* fall through */
12894 case ELFDATANONE: /* fall through */
12896 byte_get = byte_get_little_endian;
12897 byte_put = byte_put_little_endian;
12900 byte_get = byte_get_big_endian;
12901 byte_put = byte_put_big_endian;
12905 /* For now we only support 32 bit and 64 bit ELF files. */
12906 is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
12908 /* Read in the rest of the header. */
12911 Elf32_External_Ehdr ehdr32;
12913 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
12916 elf_header.e_type = BYTE_GET (ehdr32.e_type);
12917 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
12918 elf_header.e_version = BYTE_GET (ehdr32.e_version);
12919 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
12920 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
12921 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
12922 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
12923 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
12924 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
12925 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
12926 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
12927 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
12928 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
12932 Elf64_External_Ehdr ehdr64;
12934 /* If we have been compiled with sizeof (bfd_vma) == 4, then
12935 we will not be able to cope with the 64bit data found in
12936 64 ELF files. Detect this now and abort before we start
12937 overwriting things. */
12938 if (sizeof (bfd_vma) < 8)
12940 error (_("This instance of readelf has been built without support for a\n\
12941 64 bit data type and so it cannot read 64 bit ELF files.\n"));
12945 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
12948 elf_header.e_type = BYTE_GET (ehdr64.e_type);
12949 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
12950 elf_header.e_version = BYTE_GET (ehdr64.e_version);
12951 elf_header.e_entry = BYTE_GET (ehdr64.e_entry);
12952 elf_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
12953 elf_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
12954 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
12955 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
12956 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
12957 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
12958 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
12959 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
12960 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
12963 if (elf_header.e_shoff)
12965 /* There may be some extensions in the first section header. Don't
12966 bomb if we can't read it. */
12968 get_32bit_section_headers (file, 1);
12970 get_64bit_section_headers (file, 1);
12976 /* Process one ELF object file according to the command line options.
12977 This file may actually be stored in an archive. The file is
12978 positioned at the start of the ELF object. */
12981 process_object (char * file_name, FILE * file)
12985 if (! get_file_header (file))
12987 error (_("%s: Failed to read file header\n"), file_name);
12991 /* Initialise per file variables. */
12992 for (i = ARRAY_SIZE (version_info); i--;)
12993 version_info[i] = 0;
12995 for (i = ARRAY_SIZE (dynamic_info); i--;)
12996 dynamic_info[i] = 0;
12997 dynamic_info_DT_GNU_HASH = 0;
12999 /* Process the file. */
13001 printf (_("\nFile: %s\n"), file_name);
13003 /* Initialise the dump_sects array from the cmdline_dump_sects array.
13004 Note we do this even if cmdline_dump_sects is empty because we
13005 must make sure that the dump_sets array is zeroed out before each
13006 object file is processed. */
13007 if (num_dump_sects > num_cmdline_dump_sects)
13008 memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
13010 if (num_cmdline_dump_sects > 0)
13012 if (num_dump_sects == 0)
13013 /* A sneaky way of allocating the dump_sects array. */
13014 request_dump_bynumber (num_cmdline_dump_sects, 0);
13016 assert (num_dump_sects >= num_cmdline_dump_sects);
13017 memcpy (dump_sects, cmdline_dump_sects,
13018 num_cmdline_dump_sects * sizeof (* dump_sects));
13021 if (! process_file_header ())
13024 if (! process_section_headers (file))
13026 /* Without loaded section headers we cannot process lots of
13028 do_unwind = do_version = do_dump = do_arch = 0;
13030 if (! do_using_dynamic)
13031 do_syms = do_dyn_syms = do_reloc = 0;
13034 if (! process_section_groups (file))
13036 /* Without loaded section groups we cannot process unwind. */
13040 if (process_program_headers (file))
13041 process_dynamic_section (file);
13043 process_relocs (file);
13045 process_unwind (file);
13047 process_symbol_table (file);
13049 process_syminfo (file);
13051 process_version_sections (file);
13053 process_section_contents (file);
13055 process_notes (file);
13057 process_gnu_liblist (file);
13059 process_arch_specific (file);
13061 if (program_headers)
13063 free (program_headers);
13064 program_headers = NULL;
13067 if (section_headers)
13069 free (section_headers);
13070 section_headers = NULL;
13075 free (string_table);
13076 string_table = NULL;
13077 string_table_length = 0;
13080 if (dynamic_strings)
13082 free (dynamic_strings);
13083 dynamic_strings = NULL;
13084 dynamic_strings_length = 0;
13087 if (dynamic_symbols)
13089 free (dynamic_symbols);
13090 dynamic_symbols = NULL;
13091 num_dynamic_syms = 0;
13094 if (dynamic_syminfo)
13096 free (dynamic_syminfo);
13097 dynamic_syminfo = NULL;
13100 if (dynamic_section)
13102 free (dynamic_section);
13103 dynamic_section = NULL;
13106 if (section_headers_groups)
13108 free (section_headers_groups);
13109 section_headers_groups = NULL;
13112 if (section_groups)
13114 struct group_list * g;
13115 struct group_list * next;
13117 for (i = 0; i < group_count; i++)
13119 for (g = section_groups [i].root; g != NULL; g = next)
13126 free (section_groups);
13127 section_groups = NULL;
13130 free_debug_memory ();
13135 /* Process an ELF archive.
13136 On entry the file is positioned just after the ARMAG string. */
13139 process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
13141 struct archive_info arch;
13142 struct archive_info nested_arch;
13148 /* The ARCH structure is used to hold information about this archive. */
13149 arch.file_name = NULL;
13151 arch.index_array = NULL;
13152 arch.sym_table = NULL;
13153 arch.longnames = NULL;
13155 /* The NESTED_ARCH structure is used as a single-item cache of information
13156 about a nested archive (when members of a thin archive reside within
13157 another regular archive file). */
13158 nested_arch.file_name = NULL;
13159 nested_arch.file = NULL;
13160 nested_arch.index_array = NULL;
13161 nested_arch.sym_table = NULL;
13162 nested_arch.longnames = NULL;
13164 if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
13170 if (do_archive_index)
13172 if (arch.sym_table == NULL)
13173 error (_("%s: unable to dump the index as none was found\n"), file_name);
13177 unsigned long current_pos;
13179 printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
13180 file_name, arch.index_num, arch.sym_size);
13181 current_pos = ftell (file);
13183 for (i = l = 0; i < arch.index_num; i++)
13185 if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
13187 char * member_name;
13189 member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
13191 if (member_name != NULL)
13193 char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
13195 if (qualified_name != NULL)
13197 printf (_("Binary %s contains:\n"), qualified_name);
13198 free (qualified_name);
13203 if (l >= arch.sym_size)
13205 error (_("%s: end of the symbol table reached before the end of the index\n"),
13209 printf ("\t%s\n", arch.sym_table + l);
13210 l += strlen (arch.sym_table + l) + 1;
13215 if (l < arch.sym_size)
13216 error (_("%s: symbols remain in the index symbol table, but without corresponding entries in the index table\n"),
13219 if (fseek (file, current_pos, SEEK_SET) != 0)
13221 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
13227 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
13228 && !do_segments && !do_header && !do_dump && !do_version
13229 && !do_histogram && !do_debugging && !do_arch && !do_notes
13230 && !do_section_groups && !do_dyn_syms)
13232 ret = 0; /* Archive index only. */
13243 char * qualified_name;
13245 /* Read the next archive header. */
13246 if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
13248 error (_("%s: failed to seek to next archive header\n"), file_name);
13251 got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
13252 if (got != sizeof arch.arhdr)
13256 error (_("%s: failed to read archive header\n"), file_name);
13260 if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
13262 error (_("%s: did not find a valid archive header\n"), arch.file_name);
13267 arch.next_arhdr_offset += sizeof arch.arhdr;
13269 archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
13270 if (archive_file_size & 01)
13271 ++archive_file_size;
13273 name = get_archive_member_name (&arch, &nested_arch);
13276 error (_("%s: bad archive file name\n"), file_name);
13280 namelen = strlen (name);
13282 qualified_name = make_qualified_name (&arch, &nested_arch, name);
13283 if (qualified_name == NULL)
13285 error (_("%s: bad archive file name\n"), file_name);
13290 if (is_thin_archive && arch.nested_member_origin == 0)
13292 /* This is a proxy for an external member of a thin archive. */
13293 FILE * member_file;
13294 char * member_file_name = adjust_relative_path (file_name, name, namelen);
13295 if (member_file_name == NULL)
13301 member_file = fopen (member_file_name, "rb");
13302 if (member_file == NULL)
13304 error (_("Input file '%s' is not readable.\n"), member_file_name);
13305 free (member_file_name);
13310 archive_file_offset = arch.nested_member_origin;
13312 ret |= process_object (qualified_name, member_file);
13314 fclose (member_file);
13315 free (member_file_name);
13317 else if (is_thin_archive)
13319 /* This is a proxy for a member of a nested archive. */
13320 archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
13322 /* The nested archive file will have been opened and setup by
13323 get_archive_member_name. */
13324 if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
13326 error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
13331 ret |= process_object (qualified_name, nested_arch.file);
13335 archive_file_offset = arch.next_arhdr_offset;
13336 arch.next_arhdr_offset += archive_file_size;
13338 ret |= process_object (qualified_name, file);
13341 if (dump_sects != NULL)
13345 num_dump_sects = 0;
13348 free (qualified_name);
13352 if (nested_arch.file != NULL)
13353 fclose (nested_arch.file);
13354 release_archive (&nested_arch);
13355 release_archive (&arch);
13361 process_file (char * file_name)
13364 struct stat statbuf;
13365 char armag[SARMAG];
13368 if (stat (file_name, &statbuf) < 0)
13370 if (errno == ENOENT)
13371 error (_("'%s': No such file\n"), file_name);
13373 error (_("Could not locate '%s'. System error message: %s\n"),
13374 file_name, strerror (errno));
13378 if (! S_ISREG (statbuf.st_mode))
13380 error (_("'%s' is not an ordinary file\n"), file_name);
13384 file = fopen (file_name, "rb");
13387 error (_("Input file '%s' is not readable.\n"), file_name);
13391 if (fread (armag, SARMAG, 1, file) != 1)
13393 error (_("%s: Failed to read file's magic number\n"), file_name);
13398 if (memcmp (armag, ARMAG, SARMAG) == 0)
13399 ret = process_archive (file_name, file, FALSE);
13400 else if (memcmp (armag, ARMAGT, SARMAG) == 0)
13401 ret = process_archive (file_name, file, TRUE);
13404 if (do_archive_index)
13405 error (_("File %s is not an archive so its index cannot be displayed.\n"),
13409 archive_file_size = archive_file_offset = 0;
13410 ret = process_object (file_name, file);
13418 #ifdef SUPPORT_DISASSEMBLY
13419 /* Needed by the i386 disassembler. For extra credit, someone could
13420 fix this so that we insert symbolic addresses here, esp for GOT/PLT
13424 print_address (unsigned int addr, FILE * outfile)
13426 fprintf (outfile,"0x%8.8x", addr);
13429 /* Needed by the i386 disassembler. */
13431 db_task_printsym (unsigned int addr)
13433 print_address (addr, stderr);
13438 main (int argc, char ** argv)
13442 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
13443 setlocale (LC_MESSAGES, "");
13445 #if defined (HAVE_SETLOCALE)
13446 setlocale (LC_CTYPE, "");
13448 bindtextdomain (PACKAGE, LOCALEDIR);
13449 textdomain (PACKAGE);
13451 expandargv (&argc, &argv);
13453 parse_args (argc, argv);
13455 if (num_dump_sects > 0)
13457 /* Make a copy of the dump_sects array. */
13458 cmdline_dump_sects = (dump_type *)
13459 malloc (num_dump_sects * sizeof (* dump_sects));
13460 if (cmdline_dump_sects == NULL)
13461 error (_("Out of memory allocating dump request table.\n"));
13464 memcpy (cmdline_dump_sects, dump_sects,
13465 num_dump_sects * sizeof (* dump_sects));
13466 num_cmdline_dump_sects = num_dump_sects;
13470 if (optind < (argc - 1))
13474 while (optind < argc)
13475 err |= process_file (argv[optind++]);
13477 if (dump_sects != NULL)
13479 if (cmdline_dump_sects != NULL)
13480 free (cmdline_dump_sects);