1 /* readelf.c -- display contents of an ELF format file
2 Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
3 2008, 2009, 2010, 2011, 2012
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. */
53 /* Define BFD64 here, even if our default architecture is 32 bit ELF
54 as this will allow us to read in and parse 64bit and 32bit ELF files.
55 Only do this if we believe that the compiler can support a 64 bit
56 data type. For now we only rely on GCC being able to do this. */
65 #include "elf/common.h"
66 #include "elf/external.h"
67 #include "elf/internal.h"
70 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
71 we can obtain the H8 reloc numbers. We need these for the
72 get_reloc_size() function. We include h8.h again after defining
73 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
78 /* Undo the effects of #including reloc-macros.h. */
80 #undef START_RELOC_NUMBERS
84 #undef END_RELOC_NUMBERS
85 #undef _RELOC_MACROS_H
87 /* The following headers use the elf/reloc-macros.h file to
88 automatically generate relocation recognition functions
89 such as elf_mips_reloc_type() */
91 #define RELOC_MACROS_GEN_FUNC
93 #include "elf/alpha.h"
101 #include "elf/d10v.h"
102 #include "elf/d30v.h"
104 #include "elf/epiphany.h"
105 #include "elf/fr30.h"
108 #include "elf/hppa.h"
109 #include "elf/i386.h"
110 #include "elf/i370.h"
111 #include "elf/i860.h"
112 #include "elf/i960.h"
113 #include "elf/ia64.h"
114 #include "elf/ip2k.h"
115 #include "elf/lm32.h"
116 #include "elf/iq2000.h"
117 #include "elf/m32c.h"
118 #include "elf/m32r.h"
119 #include "elf/m68k.h"
120 #include "elf/m68hc11.h"
121 #include "elf/mcore.h"
123 #include "elf/microblaze.h"
124 #include "elf/mips.h"
125 #include "elf/mmix.h"
126 #include "elf/mn10200.h"
127 #include "elf/mn10300.h"
128 #include "elf/moxie.h"
130 #include "elf/msp430.h"
131 #include "elf/or32.h"
134 #include "elf/ppc64.h"
135 #include "elf/rl78.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/xgate.h"
150 #include "elf/xstormy16.h"
151 #include "elf/xtensa.h"
154 #include "libiberty.h"
155 #include "safe-ctype.h"
156 #include "filenames.h"
158 char * program_name = "readelf";
159 static long archive_file_offset;
160 static unsigned long archive_file_size;
161 static unsigned long dynamic_addr;
162 static bfd_size_type dynamic_size;
163 static unsigned int dynamic_nent;
164 static char * dynamic_strings;
165 static unsigned long dynamic_strings_length;
166 static char * string_table;
167 static unsigned long string_table_length;
168 static unsigned long num_dynamic_syms;
169 static Elf_Internal_Sym * dynamic_symbols;
170 static Elf_Internal_Syminfo * dynamic_syminfo;
171 static unsigned long dynamic_syminfo_offset;
172 static unsigned int dynamic_syminfo_nent;
173 static char program_interpreter[PATH_MAX];
174 static bfd_vma dynamic_info[DT_ENCODING];
175 static bfd_vma dynamic_info_DT_GNU_HASH;
176 static bfd_vma version_info[16];
177 static Elf_Internal_Ehdr elf_header;
178 static Elf_Internal_Shdr * section_headers;
179 static Elf_Internal_Phdr * program_headers;
180 static Elf_Internal_Dyn * dynamic_section;
181 static Elf_Internal_Shdr * symtab_shndx_hdr;
182 static int show_name;
183 static int do_dynamic;
185 static int do_dyn_syms;
187 static int do_sections;
188 static int do_section_groups;
189 static int do_section_details;
190 static int do_segments;
191 static int do_unwind;
192 static int do_using_dynamic;
193 static int do_header;
195 static int do_version;
196 static int do_histogram;
197 static int do_debugging;
200 static int do_archive_index;
201 static int is_32bit_elf;
205 struct group_list * next;
206 unsigned int section_index;
211 struct group_list * root;
212 unsigned int group_index;
215 static size_t group_count;
216 static struct group * section_groups;
217 static struct group ** section_headers_groups;
220 /* Flag bits indicating particular types of dump. */
221 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
222 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
223 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
224 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
225 #define RELOC_DUMP (1 << 4) /* The -R command line switch. */
227 typedef unsigned char dump_type;
229 /* A linked list of the section names for which dumps were requested. */
230 struct dump_list_entry
234 struct dump_list_entry * next;
236 static struct dump_list_entry * dump_sects_byname;
238 /* A dynamic array of flags indicating for which sections a dump
239 has been requested via command line switches. */
240 static dump_type * cmdline_dump_sects = NULL;
241 static unsigned int num_cmdline_dump_sects = 0;
243 /* A dynamic array of flags indicating for which sections a dump of
244 some kind has been requested. It is reset on a per-object file
245 basis and then initialised from the cmdline_dump_sects array,
246 the results of interpreting the -w switch, and the
247 dump_sects_byname list. */
248 static dump_type * dump_sects = NULL;
249 static unsigned int num_dump_sects = 0;
252 /* How to print a vma value. */
253 typedef enum print_mode
267 #define SECTION_NAME(X) \
268 ((X) == NULL ? _("<none>") \
269 : string_table == NULL ? _("<no-name>") \
270 : ((X)->sh_name >= string_table_length ? _("<corrupt>") \
271 : string_table + (X)->sh_name))
273 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
275 #define GET_ELF_SYMBOLS(file, section, sym_count) \
276 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
277 : get_64bit_elf_symbols (file, section, sym_count))
279 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
280 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
281 already been called and verified that the string exists. */
282 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
284 #define REMOVE_ARCH_BITS(ADDR) \
287 if (elf_header.e_machine == EM_ARM) \
292 /* Retrieve NMEMB structures, each SIZE bytes long from FILE starting at OFFSET.
293 Put the retrieved data into VAR, if it is not NULL. Otherwise allocate a buffer
294 using malloc and fill that. In either case return the pointer to the start of
295 the retrieved data or NULL if something went wrong. If something does go wrong
296 emit an error message using REASON as part of the context. */
299 get_data (void * var, FILE * file, long offset, size_t size, size_t nmemb,
304 if (size == 0 || nmemb == 0)
307 if (fseek (file, archive_file_offset + offset, SEEK_SET))
309 error (_("Unable to seek to 0x%lx for %s\n"),
310 (unsigned long) archive_file_offset + offset, reason);
317 /* Check for overflow. */
318 if (nmemb < (~(size_t) 0 - 1) / size)
319 /* + 1 so that we can '\0' terminate invalid string table sections. */
320 mvar = malloc (size * nmemb + 1);
324 error (_("Out of memory allocating 0x%lx bytes for %s\n"),
325 (unsigned long)(size * nmemb), reason);
329 ((char *) mvar)[size * nmemb] = '\0';
332 if (fread (mvar, size, nmemb, file) != nmemb)
334 error (_("Unable to read in 0x%lx bytes of %s\n"),
335 (unsigned long)(size * nmemb), reason);
344 /* Print a VMA value. */
347 print_vma (bfd_vma vma, print_mode mode)
360 return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
367 return printf ("%5" BFD_VMA_FMT "d", vma);
375 return nc + printf ("%" BFD_VMA_FMT "x", vma);
378 return printf ("%" BFD_VMA_FMT "d", vma);
381 return printf ("%" BFD_VMA_FMT "u", vma);
386 /* Display a symbol on stdout. Handles the display of non-printing characters.
388 If DO_WIDE is not true then format the symbol to be at most WIDTH characters,
389 truncating as necessary. If WIDTH is negative then format the string to be
390 exactly - WIDTH characters, truncating or padding as necessary.
392 Returns the number of emitted characters. */
395 print_symbol (int width, const char *symbol)
398 bfd_boolean extra_padding = FALSE;
399 unsigned int num_printed = 0;
403 /* Set the width to a very large value. This simplifies the
409 /* Keep the width positive. This also helps. */
411 extra_padding = TRUE;
420 /* Look for non-printing symbols inside the symbol's name.
421 This test is triggered in particular by the names generated
422 by the assembler for local labels. */
433 printf ("%.*s", len, symbol);
439 if (*c == 0 || width == 0)
442 /* Now display the non-printing character, if
443 there is room left in which to dipslay it. */
444 if ((unsigned char) *c < 32)
449 printf ("^%c", *c + 0x40);
459 printf ("<0x%.2x>", (unsigned char) *c);
468 if (extra_padding && width > 0)
470 /* Fill in the remaining spaces. */
471 printf ("%-*s", width, " ");
478 /* Return a pointer to section NAME, or NULL if no such section exists. */
480 static Elf_Internal_Shdr *
481 find_section (const char * name)
485 for (i = 0; i < elf_header.e_shnum; i++)
486 if (streq (SECTION_NAME (section_headers + i), name))
487 return section_headers + i;
492 /* Return a pointer to a section containing ADDR, or NULL if no such
495 static Elf_Internal_Shdr *
496 find_section_by_address (bfd_vma addr)
500 for (i = 0; i < elf_header.e_shnum; i++)
502 Elf_Internal_Shdr *sec = section_headers + i;
503 if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
510 /* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
514 read_uleb128 (unsigned char *data, unsigned int *length_return)
516 return read_leb128 (data, length_return, 0);
519 /* Return true if the current file is for IA-64 machine and OpenVMS ABI.
520 This OS has so many departures from the ELF standard that we test it at
526 return elf_header.e_machine == EM_IA_64
527 && elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
530 /* Guess the relocation size commonly used by the specific machines. */
533 guess_is_rela (unsigned int e_machine)
537 /* Targets that use REL relocations. */
554 /* Targets that use RELA relocations. */
557 case EM_ADAPTEVA_EPIPHANY:
559 case EM_ALTERA_NIOS2:
578 case EM_LATTICEMICO32:
586 case EM_CYGNUS_MN10200:
588 case EM_CYGNUS_MN10300:
618 case EM_MICROBLAZE_OLD:
639 warn (_("Don't know about relocations on this machine architecture\n"));
645 slurp_rela_relocs (FILE * file,
646 unsigned long rel_offset,
647 unsigned long rel_size,
648 Elf_Internal_Rela ** relasp,
649 unsigned long * nrelasp)
651 Elf_Internal_Rela * relas;
652 unsigned long nrelas;
657 Elf32_External_Rela * erelas;
659 erelas = (Elf32_External_Rela *) get_data (NULL, file, rel_offset, 1,
660 rel_size, _("32-bit relocation data"));
664 nrelas = rel_size / sizeof (Elf32_External_Rela);
666 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
667 sizeof (Elf_Internal_Rela));
672 error (_("out of memory parsing relocs\n"));
676 for (i = 0; i < nrelas; i++)
678 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
679 relas[i].r_info = BYTE_GET (erelas[i].r_info);
680 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
687 Elf64_External_Rela * erelas;
689 erelas = (Elf64_External_Rela *) get_data (NULL, file, rel_offset, 1,
690 rel_size, _("64-bit relocation data"));
694 nrelas = rel_size / sizeof (Elf64_External_Rela);
696 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
697 sizeof (Elf_Internal_Rela));
702 error (_("out of memory parsing relocs\n"));
706 for (i = 0; i < nrelas; i++)
708 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
709 relas[i].r_info = BYTE_GET (erelas[i].r_info);
710 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
712 /* The #ifdef BFD64 below is to prevent a compile time
713 warning. We know that if we do not have a 64 bit data
714 type that we will never execute this code anyway. */
716 if (elf_header.e_machine == EM_MIPS
717 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
719 /* In little-endian objects, r_info isn't really a
720 64-bit little-endian value: it has a 32-bit
721 little-endian symbol index followed by four
722 individual byte fields. Reorder INFO
724 bfd_vma inf = relas[i].r_info;
725 inf = (((inf & 0xffffffff) << 32)
726 | ((inf >> 56) & 0xff)
727 | ((inf >> 40) & 0xff00)
728 | ((inf >> 24) & 0xff0000)
729 | ((inf >> 8) & 0xff000000));
730 relas[i].r_info = inf;
743 slurp_rel_relocs (FILE * file,
744 unsigned long rel_offset,
745 unsigned long rel_size,
746 Elf_Internal_Rela ** relsp,
747 unsigned long * nrelsp)
749 Elf_Internal_Rela * rels;
755 Elf32_External_Rel * erels;
757 erels = (Elf32_External_Rel *) get_data (NULL, file, rel_offset, 1,
758 rel_size, _("32-bit relocation data"));
762 nrels = rel_size / sizeof (Elf32_External_Rel);
764 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
769 error (_("out of memory parsing relocs\n"));
773 for (i = 0; i < nrels; i++)
775 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
776 rels[i].r_info = BYTE_GET (erels[i].r_info);
777 rels[i].r_addend = 0;
784 Elf64_External_Rel * erels;
786 erels = (Elf64_External_Rel *) get_data (NULL, file, rel_offset, 1,
787 rel_size, _("64-bit relocation data"));
791 nrels = rel_size / sizeof (Elf64_External_Rel);
793 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
798 error (_("out of memory parsing relocs\n"));
802 for (i = 0; i < nrels; i++)
804 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
805 rels[i].r_info = BYTE_GET (erels[i].r_info);
806 rels[i].r_addend = 0;
808 /* The #ifdef BFD64 below is to prevent a compile time
809 warning. We know that if we do not have a 64 bit data
810 type that we will never execute this code anyway. */
812 if (elf_header.e_machine == EM_MIPS
813 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
815 /* In little-endian objects, r_info isn't really a
816 64-bit little-endian value: it has a 32-bit
817 little-endian symbol index followed by four
818 individual byte fields. Reorder INFO
820 bfd_vma inf = rels[i].r_info;
821 inf = (((inf & 0xffffffff) << 32)
822 | ((inf >> 56) & 0xff)
823 | ((inf >> 40) & 0xff00)
824 | ((inf >> 24) & 0xff0000)
825 | ((inf >> 8) & 0xff000000));
826 rels[i].r_info = inf;
838 /* Returns the reloc type extracted from the reloc info field. */
841 get_reloc_type (bfd_vma reloc_info)
844 return ELF32_R_TYPE (reloc_info);
846 switch (elf_header.e_machine)
849 /* Note: We assume that reloc_info has already been adjusted for us. */
850 return ELF64_MIPS_R_TYPE (reloc_info);
853 return ELF64_R_TYPE_ID (reloc_info);
856 return ELF64_R_TYPE (reloc_info);
860 /* Return the symbol index extracted from the reloc info field. */
863 get_reloc_symindex (bfd_vma reloc_info)
865 return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
868 /* Display the contents of the relocation data found at the specified
872 dump_relocations (FILE * file,
873 unsigned long rel_offset,
874 unsigned long rel_size,
875 Elf_Internal_Sym * symtab,
878 unsigned long strtablen,
882 Elf_Internal_Rela * rels;
884 if (is_rela == UNKNOWN)
885 is_rela = guess_is_rela (elf_header.e_machine);
889 if (!slurp_rela_relocs (file, rel_offset, rel_size, &rels, &rel_size))
894 if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
903 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
905 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
910 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
912 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
920 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
922 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
927 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
929 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
933 for (i = 0; i < rel_size; i++)
938 bfd_vma symtab_index;
941 offset = rels[i].r_offset;
942 inf = rels[i].r_info;
944 type = get_reloc_type (inf);
945 symtab_index = get_reloc_symindex (inf);
949 printf ("%8.8lx %8.8lx ",
950 (unsigned long) offset & 0xffffffff,
951 (unsigned long) inf & 0xffffffff);
955 #if BFD_HOST_64BIT_LONG
957 ? "%16.16lx %16.16lx "
958 : "%12.12lx %12.12lx ",
960 #elif BFD_HOST_64BIT_LONG_LONG
963 ? "%16.16llx %16.16llx "
964 : "%12.12llx %12.12llx ",
968 ? "%16.16I64x %16.16I64x "
969 : "%12.12I64x %12.12I64x ",
974 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
975 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
976 _bfd_int64_high (offset),
977 _bfd_int64_low (offset),
978 _bfd_int64_high (inf),
979 _bfd_int64_low (inf));
983 switch (elf_header.e_machine)
991 rtype = elf_m32r_reloc_type (type);
996 rtype = elf_i386_reloc_type (type);
1001 rtype = elf_m68hc11_reloc_type (type);
1005 rtype = elf_m68k_reloc_type (type);
1009 rtype = elf_i960_reloc_type (type);
1014 rtype = elf_avr_reloc_type (type);
1017 case EM_OLD_SPARCV9:
1018 case EM_SPARC32PLUS:
1021 rtype = elf_sparc_reloc_type (type);
1025 rtype = elf_spu_reloc_type (type);
1029 case EM_CYGNUS_V850:
1030 rtype = v850_reloc_type (type);
1034 case EM_CYGNUS_D10V:
1035 rtype = elf_d10v_reloc_type (type);
1039 case EM_CYGNUS_D30V:
1040 rtype = elf_d30v_reloc_type (type);
1044 rtype = elf_dlx_reloc_type (type);
1048 rtype = elf_sh_reloc_type (type);
1052 case EM_CYGNUS_MN10300:
1053 rtype = elf_mn10300_reloc_type (type);
1057 case EM_CYGNUS_MN10200:
1058 rtype = elf_mn10200_reloc_type (type);
1062 case EM_CYGNUS_FR30:
1063 rtype = elf_fr30_reloc_type (type);
1067 rtype = elf_frv_reloc_type (type);
1071 rtype = elf_mcore_reloc_type (type);
1075 rtype = elf_mmix_reloc_type (type);
1079 rtype = elf_moxie_reloc_type (type);
1084 rtype = elf_msp430_reloc_type (type);
1088 rtype = elf_ppc_reloc_type (type);
1092 rtype = elf_ppc64_reloc_type (type);
1096 case EM_MIPS_RS3_LE:
1097 rtype = elf_mips_reloc_type (type);
1101 rtype = elf_alpha_reloc_type (type);
1105 rtype = elf_arm_reloc_type (type);
1109 rtype = elf_arc_reloc_type (type);
1113 rtype = elf_hppa_reloc_type (type);
1119 rtype = elf_h8_reloc_type (type);
1124 rtype = elf_or32_reloc_type (type);
1129 rtype = elf_pj_reloc_type (type);
1132 rtype = elf_ia64_reloc_type (type);
1136 rtype = elf_cris_reloc_type (type);
1140 rtype = elf_i860_reloc_type (type);
1146 rtype = elf_x86_64_reloc_type (type);
1150 rtype = i370_reloc_type (type);
1155 rtype = elf_s390_reloc_type (type);
1159 rtype = elf_score_reloc_type (type);
1163 rtype = elf_xstormy16_reloc_type (type);
1167 rtype = elf_crx_reloc_type (type);
1171 rtype = elf_vax_reloc_type (type);
1174 case EM_ADAPTEVA_EPIPHANY:
1175 rtype = elf_epiphany_reloc_type (type);
1180 rtype = elf_ip2k_reloc_type (type);
1184 rtype = elf_iq2000_reloc_type (type);
1189 rtype = elf_xtensa_reloc_type (type);
1192 case EM_LATTICEMICO32:
1193 rtype = elf_lm32_reloc_type (type);
1198 rtype = elf_m32c_reloc_type (type);
1202 rtype = elf_mt_reloc_type (type);
1206 rtype = elf_bfin_reloc_type (type);
1210 rtype = elf_mep_reloc_type (type);
1214 rtype = elf_cr16_reloc_type (type);
1218 case EM_MICROBLAZE_OLD:
1219 rtype = elf_microblaze_reloc_type (type);
1223 rtype = elf_rl78_reloc_type (type);
1227 rtype = elf_rx_reloc_type (type);
1232 rtype = elf_xc16x_reloc_type (type);
1236 rtype = elf_tic6x_reloc_type (type);
1240 rtype = elf_tilegx_reloc_type (type);
1244 rtype = elf_tilepro_reloc_type (type);
1248 rtype = elf_xgate_reloc_type (type);
1253 printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
1255 printf (do_wide ? "%-22.22s" : "%-17.17s", rtype);
1257 if (elf_header.e_machine == EM_ALPHA
1259 && streq (rtype, "R_ALPHA_LITUSE")
1262 switch (rels[i].r_addend)
1264 case LITUSE_ALPHA_ADDR: rtype = "ADDR"; break;
1265 case LITUSE_ALPHA_BASE: rtype = "BASE"; break;
1266 case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1267 case LITUSE_ALPHA_JSR: rtype = "JSR"; break;
1268 case LITUSE_ALPHA_TLSGD: rtype = "TLSGD"; break;
1269 case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1270 case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1271 default: rtype = NULL;
1274 printf (" (%s)", rtype);
1278 printf (_("<unknown addend: %lx>"),
1279 (unsigned long) rels[i].r_addend);
1282 else if (symtab_index)
1284 if (symtab == NULL || symtab_index >= nsyms)
1285 printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index);
1288 Elf_Internal_Sym * psym;
1290 psym = symtab + symtab_index;
1294 if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1298 unsigned int width = is_32bit_elf ? 8 : 14;
1300 /* Relocations against GNU_IFUNC symbols do not use the value
1301 of the symbol as the address to relocate against. Instead
1302 they invoke the function named by the symbol and use its
1303 result as the address for relocation.
1305 To indicate this to the user, do not display the value of
1306 the symbol in the "Symbols's Value" field. Instead show
1307 its name followed by () as a hint that the symbol is
1311 || psym->st_name == 0
1312 || psym->st_name >= strtablen)
1315 name = strtab + psym->st_name;
1317 len = print_symbol (width, name);
1318 printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1322 print_vma (psym->st_value, LONG_HEX);
1324 printf (is_32bit_elf ? " " : " ");
1327 if (psym->st_name == 0)
1329 const char * sec_name = "<null>";
1332 if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1334 if (psym->st_shndx < elf_header.e_shnum)
1336 = SECTION_NAME (section_headers + psym->st_shndx);
1337 else if (psym->st_shndx == SHN_ABS)
1339 else if (psym->st_shndx == SHN_COMMON)
1340 sec_name = "COMMON";
1341 else if ((elf_header.e_machine == EM_MIPS
1342 && psym->st_shndx == SHN_MIPS_SCOMMON)
1343 || (elf_header.e_machine == EM_TI_C6000
1344 && psym->st_shndx == SHN_TIC6X_SCOMMON))
1345 sec_name = "SCOMMON";
1346 else if (elf_header.e_machine == EM_MIPS
1347 && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1348 sec_name = "SUNDEF";
1349 else if ((elf_header.e_machine == EM_X86_64
1350 || elf_header.e_machine == EM_L1OM
1351 || elf_header.e_machine == EM_K1OM)
1352 && psym->st_shndx == SHN_X86_64_LCOMMON)
1353 sec_name = "LARGE_COMMON";
1354 else if (elf_header.e_machine == EM_IA_64
1355 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1356 && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1357 sec_name = "ANSI_COM";
1358 else if (is_ia64_vms ()
1359 && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1360 sec_name = "VMS_SYMVEC";
1363 sprintf (name_buf, "<section 0x%x>",
1364 (unsigned int) psym->st_shndx);
1365 sec_name = name_buf;
1368 print_symbol (22, sec_name);
1370 else if (strtab == NULL)
1371 printf (_("<string table index: %3ld>"), psym->st_name);
1372 else if (psym->st_name >= strtablen)
1373 printf (_("<corrupt string table index: %3ld>"), psym->st_name);
1375 print_symbol (22, strtab + psym->st_name);
1379 bfd_signed_vma off = rels[i].r_addend;
1382 printf (" - %" BFD_VMA_FMT "x", - off);
1384 printf (" + %" BFD_VMA_FMT "x", off);
1390 bfd_signed_vma off = rels[i].r_addend;
1392 printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
1394 printf ("-%" BFD_VMA_FMT "x", - off);
1396 printf ("%" BFD_VMA_FMT "x", off);
1399 if (elf_header.e_machine == EM_SPARCV9
1401 && streq (rtype, "R_SPARC_OLO10"))
1402 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
1407 if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
1409 bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1410 bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
1411 const char * rtype2 = elf_mips_reloc_type (type2);
1412 const char * rtype3 = elf_mips_reloc_type (type3);
1414 printf (" Type2: ");
1417 printf (_("unrecognized: %-7lx"),
1418 (unsigned long) type2 & 0xffffffff);
1420 printf ("%-17.17s", rtype2);
1422 printf ("\n Type3: ");
1425 printf (_("unrecognized: %-7lx"),
1426 (unsigned long) type3 & 0xffffffff);
1428 printf ("%-17.17s", rtype3);
1439 get_mips_dynamic_type (unsigned long type)
1443 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1444 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1445 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1446 case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1447 case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1448 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1449 case DT_MIPS_MSYM: return "MIPS_MSYM";
1450 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1451 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1452 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1453 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1454 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1455 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1456 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1457 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1458 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1459 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1460 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1461 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1462 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1463 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1464 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1465 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1466 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1467 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1468 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1469 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1470 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1471 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1472 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1473 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1474 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1475 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1476 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1477 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1478 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1479 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1480 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1481 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1482 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1483 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1484 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1485 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
1486 case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1487 case DT_MIPS_RWPLT: return "MIPS_RWPLT";
1494 get_sparc64_dynamic_type (unsigned long type)
1498 case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1505 get_ppc_dynamic_type (unsigned long type)
1509 case DT_PPC_GOT: return "PPC_GOT";
1510 case DT_PPC_TLSOPT: return "PPC_TLSOPT";
1517 get_ppc64_dynamic_type (unsigned long type)
1521 case DT_PPC64_GLINK: return "PPC64_GLINK";
1522 case DT_PPC64_OPD: return "PPC64_OPD";
1523 case DT_PPC64_OPDSZ: return "PPC64_OPDSZ";
1524 case DT_PPC64_TLSOPT: return "PPC64_TLSOPT";
1531 get_parisc_dynamic_type (unsigned long type)
1535 case DT_HP_LOAD_MAP: return "HP_LOAD_MAP";
1536 case DT_HP_DLD_FLAGS: return "HP_DLD_FLAGS";
1537 case DT_HP_DLD_HOOK: return "HP_DLD_HOOK";
1538 case DT_HP_UX10_INIT: return "HP_UX10_INIT";
1539 case DT_HP_UX10_INITSZ: return "HP_UX10_INITSZ";
1540 case DT_HP_PREINIT: return "HP_PREINIT";
1541 case DT_HP_PREINITSZ: return "HP_PREINITSZ";
1542 case DT_HP_NEEDED: return "HP_NEEDED";
1543 case DT_HP_TIME_STAMP: return "HP_TIME_STAMP";
1544 case DT_HP_CHECKSUM: return "HP_CHECKSUM";
1545 case DT_HP_GST_SIZE: return "HP_GST_SIZE";
1546 case DT_HP_GST_VERSION: return "HP_GST_VERSION";
1547 case DT_HP_GST_HASHVAL: return "HP_GST_HASHVAL";
1548 case DT_HP_EPLTREL: return "HP_GST_EPLTREL";
1549 case DT_HP_EPLTRELSZ: return "HP_GST_EPLTRELSZ";
1550 case DT_HP_FILTERED: return "HP_FILTERED";
1551 case DT_HP_FILTER_TLS: return "HP_FILTER_TLS";
1552 case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1553 case DT_HP_LAZYLOAD: return "HP_LAZYLOAD";
1554 case DT_HP_BIND_NOW_COUNT: return "HP_BIND_NOW_COUNT";
1555 case DT_PLT: return "PLT";
1556 case DT_PLT_SIZE: return "PLT_SIZE";
1557 case DT_DLT: return "DLT";
1558 case DT_DLT_SIZE: return "DLT_SIZE";
1565 get_ia64_dynamic_type (unsigned long type)
1569 case DT_IA_64_PLT_RESERVE: return "IA_64_PLT_RESERVE";
1570 case DT_IA_64_VMS_SUBTYPE: return "VMS_SUBTYPE";
1571 case DT_IA_64_VMS_IMGIOCNT: return "VMS_IMGIOCNT";
1572 case DT_IA_64_VMS_LNKFLAGS: return "VMS_LNKFLAGS";
1573 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1574 case DT_IA_64_VMS_IDENT: return "VMS_IDENT";
1575 case DT_IA_64_VMS_NEEDED_IDENT: return "VMS_NEEDED_IDENT";
1576 case DT_IA_64_VMS_IMG_RELA_CNT: return "VMS_IMG_RELA_CNT";
1577 case DT_IA_64_VMS_SEG_RELA_CNT: return "VMS_SEG_RELA_CNT";
1578 case DT_IA_64_VMS_FIXUP_RELA_CNT: return "VMS_FIXUP_RELA_CNT";
1579 case DT_IA_64_VMS_FIXUP_NEEDED: return "VMS_FIXUP_NEEDED";
1580 case DT_IA_64_VMS_SYMVEC_CNT: return "VMS_SYMVEC_CNT";
1581 case DT_IA_64_VMS_XLATED: return "VMS_XLATED";
1582 case DT_IA_64_VMS_STACKSIZE: return "VMS_STACKSIZE";
1583 case DT_IA_64_VMS_UNWINDSZ: return "VMS_UNWINDSZ";
1584 case DT_IA_64_VMS_UNWIND_CODSEG: return "VMS_UNWIND_CODSEG";
1585 case DT_IA_64_VMS_UNWIND_INFOSEG: return "VMS_UNWIND_INFOSEG";
1586 case DT_IA_64_VMS_LINKTIME: return "VMS_LINKTIME";
1587 case DT_IA_64_VMS_SEG_NO: return "VMS_SEG_NO";
1588 case DT_IA_64_VMS_SYMVEC_OFFSET: return "VMS_SYMVEC_OFFSET";
1589 case DT_IA_64_VMS_SYMVEC_SEG: return "VMS_SYMVEC_SEG";
1590 case DT_IA_64_VMS_UNWIND_OFFSET: return "VMS_UNWIND_OFFSET";
1591 case DT_IA_64_VMS_UNWIND_SEG: return "VMS_UNWIND_SEG";
1592 case DT_IA_64_VMS_STRTAB_OFFSET: return "VMS_STRTAB_OFFSET";
1593 case DT_IA_64_VMS_SYSVER_OFFSET: return "VMS_SYSVER_OFFSET";
1594 case DT_IA_64_VMS_IMG_RELA_OFF: return "VMS_IMG_RELA_OFF";
1595 case DT_IA_64_VMS_SEG_RELA_OFF: return "VMS_SEG_RELA_OFF";
1596 case DT_IA_64_VMS_FIXUP_RELA_OFF: return "VMS_FIXUP_RELA_OFF";
1597 case DT_IA_64_VMS_PLTGOT_OFFSET: return "VMS_PLTGOT_OFFSET";
1598 case DT_IA_64_VMS_PLTGOT_SEG: return "VMS_PLTGOT_SEG";
1599 case DT_IA_64_VMS_FPMODE: return "VMS_FPMODE";
1606 get_alpha_dynamic_type (unsigned long type)
1610 case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
1617 get_score_dynamic_type (unsigned long type)
1621 case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
1622 case DT_SCORE_LOCAL_GOTNO: return "SCORE_LOCAL_GOTNO";
1623 case DT_SCORE_SYMTABNO: return "SCORE_SYMTABNO";
1624 case DT_SCORE_GOTSYM: return "SCORE_GOTSYM";
1625 case DT_SCORE_UNREFEXTNO: return "SCORE_UNREFEXTNO";
1626 case DT_SCORE_HIPAGENO: return "SCORE_HIPAGENO";
1633 get_tic6x_dynamic_type (unsigned long type)
1637 case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
1638 case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
1639 case DT_C6000_DSBT_BASE: return "C6000_DSBT_BASE";
1640 case DT_C6000_DSBT_SIZE: return "C6000_DSBT_SIZE";
1641 case DT_C6000_PREEMPTMAP: return "C6000_PREEMPTMAP";
1642 case DT_C6000_DSBT_INDEX: return "C6000_DSBT_INDEX";
1649 get_dynamic_type (unsigned long type)
1651 static char buff[64];
1655 case DT_NULL: return "NULL";
1656 case DT_NEEDED: return "NEEDED";
1657 case DT_PLTRELSZ: return "PLTRELSZ";
1658 case DT_PLTGOT: return "PLTGOT";
1659 case DT_HASH: return "HASH";
1660 case DT_STRTAB: return "STRTAB";
1661 case DT_SYMTAB: return "SYMTAB";
1662 case DT_RELA: return "RELA";
1663 case DT_RELASZ: return "RELASZ";
1664 case DT_RELAENT: return "RELAENT";
1665 case DT_STRSZ: return "STRSZ";
1666 case DT_SYMENT: return "SYMENT";
1667 case DT_INIT: return "INIT";
1668 case DT_FINI: return "FINI";
1669 case DT_SONAME: return "SONAME";
1670 case DT_RPATH: return "RPATH";
1671 case DT_SYMBOLIC: return "SYMBOLIC";
1672 case DT_REL: return "REL";
1673 case DT_RELSZ: return "RELSZ";
1674 case DT_RELENT: return "RELENT";
1675 case DT_PLTREL: return "PLTREL";
1676 case DT_DEBUG: return "DEBUG";
1677 case DT_TEXTREL: return "TEXTREL";
1678 case DT_JMPREL: return "JMPREL";
1679 case DT_BIND_NOW: return "BIND_NOW";
1680 case DT_INIT_ARRAY: return "INIT_ARRAY";
1681 case DT_FINI_ARRAY: return "FINI_ARRAY";
1682 case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
1683 case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
1684 case DT_RUNPATH: return "RUNPATH";
1685 case DT_FLAGS: return "FLAGS";
1687 case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1688 case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
1690 case DT_CHECKSUM: return "CHECKSUM";
1691 case DT_PLTPADSZ: return "PLTPADSZ";
1692 case DT_MOVEENT: return "MOVEENT";
1693 case DT_MOVESZ: return "MOVESZ";
1694 case DT_FEATURE: return "FEATURE";
1695 case DT_POSFLAG_1: return "POSFLAG_1";
1696 case DT_SYMINSZ: return "SYMINSZ";
1697 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
1699 case DT_ADDRRNGLO: return "ADDRRNGLO";
1700 case DT_CONFIG: return "CONFIG";
1701 case DT_DEPAUDIT: return "DEPAUDIT";
1702 case DT_AUDIT: return "AUDIT";
1703 case DT_PLTPAD: return "PLTPAD";
1704 case DT_MOVETAB: return "MOVETAB";
1705 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
1707 case DT_VERSYM: return "VERSYM";
1709 case DT_TLSDESC_GOT: return "TLSDESC_GOT";
1710 case DT_TLSDESC_PLT: return "TLSDESC_PLT";
1711 case DT_RELACOUNT: return "RELACOUNT";
1712 case DT_RELCOUNT: return "RELCOUNT";
1713 case DT_FLAGS_1: return "FLAGS_1";
1714 case DT_VERDEF: return "VERDEF";
1715 case DT_VERDEFNUM: return "VERDEFNUM";
1716 case DT_VERNEED: return "VERNEED";
1717 case DT_VERNEEDNUM: return "VERNEEDNUM";
1719 case DT_AUXILIARY: return "AUXILIARY";
1720 case DT_USED: return "USED";
1721 case DT_FILTER: return "FILTER";
1723 case DT_GNU_PRELINKED: return "GNU_PRELINKED";
1724 case DT_GNU_CONFLICT: return "GNU_CONFLICT";
1725 case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
1726 case DT_GNU_LIBLIST: return "GNU_LIBLIST";
1727 case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
1728 case DT_GNU_HASH: return "GNU_HASH";
1731 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1733 const char * result;
1735 switch (elf_header.e_machine)
1738 case EM_MIPS_RS3_LE:
1739 result = get_mips_dynamic_type (type);
1742 result = get_sparc64_dynamic_type (type);
1745 result = get_ppc_dynamic_type (type);
1748 result = get_ppc64_dynamic_type (type);
1751 result = get_ia64_dynamic_type (type);
1754 result = get_alpha_dynamic_type (type);
1757 result = get_score_dynamic_type (type);
1760 result = get_tic6x_dynamic_type (type);
1770 snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
1772 else if (((type >= DT_LOOS) && (type <= DT_HIOS))
1773 || (elf_header.e_machine == EM_PARISC
1774 && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
1776 const char * result;
1778 switch (elf_header.e_machine)
1781 result = get_parisc_dynamic_type (type);
1784 result = get_ia64_dynamic_type (type);
1794 snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
1798 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
1805 get_file_type (unsigned e_type)
1807 static char buff[32];
1811 case ET_NONE: return _("NONE (None)");
1812 case ET_REL: return _("REL (Relocatable file)");
1813 case ET_EXEC: return _("EXEC (Executable file)");
1814 case ET_DYN: return _("DYN (Shared object file)");
1815 case ET_CORE: return _("CORE (Core file)");
1818 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
1819 snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
1820 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
1821 snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
1823 snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
1829 get_machine_name (unsigned e_machine)
1831 static char buff[64]; /* XXX */
1835 case EM_NONE: return _("None");
1836 case EM_M32: return "WE32100";
1837 case EM_SPARC: return "Sparc";
1838 case EM_SPU: return "SPU";
1839 case EM_386: return "Intel 80386";
1840 case EM_68K: return "MC68000";
1841 case EM_88K: return "MC88000";
1842 case EM_486: return "Intel 80486";
1843 case EM_860: return "Intel 80860";
1844 case EM_MIPS: return "MIPS R3000";
1845 case EM_S370: return "IBM System/370";
1846 case EM_MIPS_RS3_LE: return "MIPS R4000 big-endian";
1847 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
1848 case EM_PARISC: return "HPPA";
1849 case EM_PPC_OLD: return "Power PC (old)";
1850 case EM_SPARC32PLUS: return "Sparc v8+" ;
1851 case EM_960: return "Intel 90860";
1852 case EM_PPC: return "PowerPC";
1853 case EM_PPC64: return "PowerPC64";
1854 case EM_V800: return "NEC V800";
1855 case EM_FR20: return "Fujitsu FR20";
1856 case EM_RH32: return "TRW RH32";
1857 case EM_MCORE: return "MCORE";
1858 case EM_ARM: return "ARM";
1859 case EM_OLD_ALPHA: return "Digital Alpha (old)";
1860 case EM_SH: return "Renesas / SuperH SH";
1861 case EM_SPARCV9: return "Sparc v9";
1862 case EM_TRICORE: return "Siemens Tricore";
1863 case EM_ARC: return "ARC";
1864 case EM_H8_300: return "Renesas H8/300";
1865 case EM_H8_300H: return "Renesas H8/300H";
1866 case EM_H8S: return "Renesas H8S";
1867 case EM_H8_500: return "Renesas H8/500";
1868 case EM_IA_64: return "Intel IA-64";
1869 case EM_MIPS_X: return "Stanford MIPS-X";
1870 case EM_COLDFIRE: return "Motorola Coldfire";
1871 case EM_ALPHA: return "Alpha";
1872 case EM_CYGNUS_D10V:
1873 case EM_D10V: return "d10v";
1874 case EM_CYGNUS_D30V:
1875 case EM_D30V: return "d30v";
1876 case EM_CYGNUS_M32R:
1877 case EM_M32R: return "Renesas M32R (formerly Mitsubishi M32r)";
1878 case EM_CYGNUS_V850:
1879 case EM_V850: return "Renesas V850";
1880 case EM_CYGNUS_MN10300:
1881 case EM_MN10300: return "mn10300";
1882 case EM_CYGNUS_MN10200:
1883 case EM_MN10200: return "mn10200";
1884 case EM_MOXIE: return "Moxie";
1885 case EM_CYGNUS_FR30:
1886 case EM_FR30: return "Fujitsu FR30";
1887 case EM_CYGNUS_FRV: return "Fujitsu FR-V";
1889 case EM_PJ: return "picoJava";
1890 case EM_MMA: return "Fujitsu Multimedia Accelerator";
1891 case EM_PCP: return "Siemens PCP";
1892 case EM_NCPU: return "Sony nCPU embedded RISC processor";
1893 case EM_NDR1: return "Denso NDR1 microprocesspr";
1894 case EM_STARCORE: return "Motorola Star*Core processor";
1895 case EM_ME16: return "Toyota ME16 processor";
1896 case EM_ST100: return "STMicroelectronics ST100 processor";
1897 case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
1898 case EM_PDSP: return "Sony DSP processor";
1899 case EM_PDP10: return "Digital Equipment Corp. PDP-10";
1900 case EM_PDP11: return "Digital Equipment Corp. PDP-11";
1901 case EM_FX66: return "Siemens FX66 microcontroller";
1902 case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1903 case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
1904 case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
1905 case EM_68HC12: return "Motorola MC68HC12 Microcontroller";
1906 case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
1907 case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
1908 case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
1909 case EM_SVX: return "Silicon Graphics SVx";
1910 case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
1911 case EM_VAX: return "Digital VAX";
1913 case EM_AVR: return "Atmel AVR 8-bit microcontroller";
1914 case EM_CRIS: return "Axis Communications 32-bit embedded processor";
1915 case EM_JAVELIN: return "Infineon Technologies 32-bit embedded cpu";
1916 case EM_FIREPATH: return "Element 14 64-bit DSP processor";
1917 case EM_ZSP: return "LSI Logic's 16-bit DSP processor";
1918 case EM_MMIX: return "Donald Knuth's educational 64-bit processor";
1919 case EM_HUANY: return "Harvard Universitys's machine-independent object format";
1920 case EM_PRISM: return "Vitesse Prism";
1921 case EM_X86_64: return "Advanced Micro Devices X86-64";
1922 case EM_L1OM: return "Intel L1OM";
1923 case EM_K1OM: return "Intel K1OM";
1925 case EM_S390: return "IBM S/390";
1926 case EM_SCORE: return "SUNPLUS S+Core";
1927 case EM_XSTORMY16: return "Sanyo XStormy16 CPU core";
1929 case EM_OR32: return "OpenRISC";
1930 case EM_ARC_A5: return "ARC International ARCompact processor";
1931 case EM_CRX: return "National Semiconductor CRX microprocessor";
1932 case EM_ADAPTEVA_EPIPHANY: return "Adapteva EPIPHANY";
1933 case EM_DLX: return "OpenDLX";
1935 case EM_IP2K: return "Ubicom IP2xxx 8-bit microcontrollers";
1936 case EM_IQ2000: return "Vitesse IQ2000";
1938 case EM_XTENSA: return "Tensilica Xtensa Processor";
1939 case EM_VIDEOCORE: return "Alphamosaic VideoCore processor";
1940 case EM_TMM_GPP: return "Thompson Multimedia General Purpose Processor";
1941 case EM_NS32K: return "National Semiconductor 32000 series";
1942 case EM_TPC: return "Tenor Network TPC processor";
1943 case EM_ST200: return "STMicroelectronics ST200 microcontroller";
1944 case EM_MAX: return "MAX Processor";
1945 case EM_CR: return "National Semiconductor CompactRISC";
1946 case EM_F2MC16: return "Fujitsu F2MC16";
1947 case EM_MSP430: return "Texas Instruments msp430 microcontroller";
1948 case EM_LATTICEMICO32: return "Lattice Mico32";
1950 case EM_M32C: return "Renesas M32c";
1951 case EM_MT: return "Morpho Techologies MT processor";
1952 case EM_BLACKFIN: return "Analog Devices Blackfin";
1953 case EM_SE_C33: return "S1C33 Family of Seiko Epson processors";
1954 case EM_SEP: return "Sharp embedded microprocessor";
1955 case EM_ARCA: return "Arca RISC microprocessor";
1956 case EM_UNICORE: return "Unicore";
1957 case EM_EXCESS: return "eXcess 16/32/64-bit configurable embedded CPU";
1958 case EM_DXP: return "Icera Semiconductor Inc. Deep Execution Processor";
1959 case EM_NIOS32: return "Altera Nios";
1960 case EM_ALTERA_NIOS2: return "Altera Nios II";
1962 case EM_XC16X: return "Infineon Technologies xc16x";
1963 case EM_M16C: return "Renesas M16C series microprocessors";
1964 case EM_DSPIC30F: return "Microchip Technology dsPIC30F Digital Signal Controller";
1965 case EM_CE: return "Freescale Communication Engine RISC core";
1966 case EM_TSK3000: return "Altium TSK3000 core";
1967 case EM_RS08: return "Freescale RS08 embedded processor";
1968 case EM_ECOG2: return "Cyan Technology eCOG2 microprocessor";
1969 case EM_DSP24: return "New Japan Radio (NJR) 24-bit DSP Processor";
1970 case EM_VIDEOCORE3: return "Broadcom VideoCore III processor";
1971 case EM_SE_C17: return "Seiko Epson C17 family";
1972 case EM_TI_C6000: return "Texas Instruments TMS320C6000 DSP family";
1973 case EM_TI_C2000: return "Texas Instruments TMS320C2000 DSP family";
1974 case EM_TI_C5500: return "Texas Instruments TMS320C55x DSP family";
1975 case EM_MMDSP_PLUS: return "STMicroelectronics 64bit VLIW Data Signal Processor";
1976 case EM_CYPRESS_M8C: return "Cypress M8C microprocessor";
1977 case EM_R32C: return "Renesas R32C series microprocessors";
1978 case EM_TRIMEDIA: return "NXP Semiconductors TriMedia architecture family";
1979 case EM_QDSP6: return "QUALCOMM DSP6 Processor";
1980 case EM_8051: return "Intel 8051 and variants";
1981 case EM_STXP7X: return "STMicroelectronics STxP7x family";
1982 case EM_NDS32: return "Andes Technology compact code size embedded RISC processor family";
1983 case EM_ECOG1X: return "Cyan Technology eCOG1X family";
1984 case EM_MAXQ30: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
1985 case EM_XIMO16: return "New Japan Radio (NJR) 16-bit DSP Processor";
1986 case EM_MANIK: return "M2000 Reconfigurable RISC Microprocessor";
1987 case EM_CRAYNV2: return "Cray Inc. NV2 vector architecture";
1988 case EM_CYGNUS_MEP: return "Toshiba MeP Media Engine";
1991 case EM_MICROBLAZE_OLD: return "Xilinx MicroBlaze";
1992 case EM_RL78: return "Renesas RL78";
1993 case EM_RX: return "Renesas RX";
1994 case EM_METAG: return "Imagination Technologies META processor architecture";
1995 case EM_MCST_ELBRUS: return "MCST Elbrus general purpose hardware architecture";
1996 case EM_ECOG16: return "Cyan Technology eCOG16 family";
1997 case EM_ETPU: return "Freescale Extended Time Processing Unit";
1998 case EM_SLE9X: return "Infineon Technologies SLE9X core";
1999 case EM_AVR32: return "Atmel Corporation 32-bit microprocessor family";
2000 case EM_STM8: return "STMicroeletronics STM8 8-bit microcontroller";
2001 case EM_TILE64: return "Tilera TILE64 multicore architecture family";
2002 case EM_TILEPRO: return "Tilera TILEPro multicore architecture family";
2003 case EM_TILEGX: return "Tilera TILE-Gx multicore architecture family";
2004 case EM_CUDA: return "NVIDIA CUDA architecture";
2005 case EM_XGATE: return "Motorola XGATE embedded processor";
2007 snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
2013 decode_ARM_machine_flags (unsigned e_flags, char buf[])
2018 eabi = EF_ARM_EABI_VERSION (e_flags);
2019 e_flags &= ~ EF_ARM_EABIMASK;
2021 /* Handle "generic" ARM flags. */
2022 if (e_flags & EF_ARM_RELEXEC)
2024 strcat (buf, ", relocatable executable");
2025 e_flags &= ~ EF_ARM_RELEXEC;
2028 if (e_flags & EF_ARM_HASENTRY)
2030 strcat (buf, ", has entry point");
2031 e_flags &= ~ EF_ARM_HASENTRY;
2034 /* Now handle EABI specific flags. */
2038 strcat (buf, ", <unrecognized EABI>");
2043 case EF_ARM_EABI_VER1:
2044 strcat (buf, ", Version1 EABI");
2049 /* Process flags one bit at a time. */
2050 flag = e_flags & - e_flags;
2055 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2056 strcat (buf, ", sorted symbol tables");
2066 case EF_ARM_EABI_VER2:
2067 strcat (buf, ", Version2 EABI");
2072 /* Process flags one bit at a time. */
2073 flag = e_flags & - e_flags;
2078 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2079 strcat (buf, ", sorted symbol tables");
2082 case EF_ARM_DYNSYMSUSESEGIDX:
2083 strcat (buf, ", dynamic symbols use segment index");
2086 case EF_ARM_MAPSYMSFIRST:
2087 strcat (buf, ", mapping symbols precede others");
2097 case EF_ARM_EABI_VER3:
2098 strcat (buf, ", Version3 EABI");
2101 case EF_ARM_EABI_VER4:
2102 strcat (buf, ", Version4 EABI");
2105 case EF_ARM_EABI_VER5:
2106 strcat (buf, ", Version5 EABI");
2112 /* Process flags one bit at a time. */
2113 flag = e_flags & - e_flags;
2119 strcat (buf, ", BE8");
2123 strcat (buf, ", LE8");
2133 case EF_ARM_EABI_UNKNOWN:
2134 strcat (buf, ", GNU EABI");
2139 /* Process flags one bit at a time. */
2140 flag = e_flags & - e_flags;
2145 case EF_ARM_INTERWORK:
2146 strcat (buf, ", interworking enabled");
2149 case EF_ARM_APCS_26:
2150 strcat (buf, ", uses APCS/26");
2153 case EF_ARM_APCS_FLOAT:
2154 strcat (buf, ", uses APCS/float");
2158 strcat (buf, ", position independent");
2162 strcat (buf, ", 8 bit structure alignment");
2165 case EF_ARM_NEW_ABI:
2166 strcat (buf, ", uses new ABI");
2169 case EF_ARM_OLD_ABI:
2170 strcat (buf, ", uses old ABI");
2173 case EF_ARM_SOFT_FLOAT:
2174 strcat (buf, ", software FP");
2177 case EF_ARM_VFP_FLOAT:
2178 strcat (buf, ", VFP");
2181 case EF_ARM_MAVERICK_FLOAT:
2182 strcat (buf, ", Maverick FP");
2193 strcat (buf,_(", <unknown>"));
2197 get_machine_flags (unsigned e_flags, unsigned e_machine)
2199 static char buf[1024];
2211 decode_ARM_machine_flags (e_flags, buf);
2215 if (e_flags & EF_BFIN_PIC)
2216 strcat (buf, ", PIC");
2218 if (e_flags & EF_BFIN_FDPIC)
2219 strcat (buf, ", FDPIC");
2221 if (e_flags & EF_BFIN_CODE_IN_L1)
2222 strcat (buf, ", code in L1");
2224 if (e_flags & EF_BFIN_DATA_IN_L1)
2225 strcat (buf, ", data in L1");
2230 switch (e_flags & EF_FRV_CPU_MASK)
2232 case EF_FRV_CPU_GENERIC:
2236 strcat (buf, ", fr???");
2239 case EF_FRV_CPU_FR300:
2240 strcat (buf, ", fr300");
2243 case EF_FRV_CPU_FR400:
2244 strcat (buf, ", fr400");
2246 case EF_FRV_CPU_FR405:
2247 strcat (buf, ", fr405");
2250 case EF_FRV_CPU_FR450:
2251 strcat (buf, ", fr450");
2254 case EF_FRV_CPU_FR500:
2255 strcat (buf, ", fr500");
2257 case EF_FRV_CPU_FR550:
2258 strcat (buf, ", fr550");
2261 case EF_FRV_CPU_SIMPLE:
2262 strcat (buf, ", simple");
2264 case EF_FRV_CPU_TOMCAT:
2265 strcat (buf, ", tomcat");
2271 if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
2272 strcat (buf, ", m68000");
2273 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
2274 strcat (buf, ", cpu32");
2275 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
2276 strcat (buf, ", fido_a");
2279 char const * isa = _("unknown");
2280 char const * mac = _("unknown mac");
2281 char const * additional = NULL;
2283 switch (e_flags & EF_M68K_CF_ISA_MASK)
2285 case EF_M68K_CF_ISA_A_NODIV:
2287 additional = ", nodiv";
2289 case EF_M68K_CF_ISA_A:
2292 case EF_M68K_CF_ISA_A_PLUS:
2295 case EF_M68K_CF_ISA_B_NOUSP:
2297 additional = ", nousp";
2299 case EF_M68K_CF_ISA_B:
2302 case EF_M68K_CF_ISA_C:
2305 case EF_M68K_CF_ISA_C_NODIV:
2307 additional = ", nodiv";
2310 strcat (buf, ", cf, isa ");
2313 strcat (buf, additional);
2314 if (e_flags & EF_M68K_CF_FLOAT)
2315 strcat (buf, ", float");
2316 switch (e_flags & EF_M68K_CF_MAC_MASK)
2321 case EF_M68K_CF_MAC:
2324 case EF_M68K_CF_EMAC:
2327 case EF_M68K_CF_EMAC_B:
2340 if (e_flags & EF_PPC_EMB)
2341 strcat (buf, ", emb");
2343 if (e_flags & EF_PPC_RELOCATABLE)
2344 strcat (buf, _(", relocatable"));
2346 if (e_flags & EF_PPC_RELOCATABLE_LIB)
2347 strcat (buf, _(", relocatable-lib"));
2351 case EM_CYGNUS_V850:
2352 switch (e_flags & EF_V850_ARCH)
2354 case E_V850E2V3_ARCH:
2355 strcat (buf, ", v850e2v3");
2358 strcat (buf, ", v850e2");
2361 strcat (buf, ", v850e1");
2364 strcat (buf, ", v850e");
2367 strcat (buf, ", v850");
2370 strcat (buf, _(", unknown v850 architecture variant"));
2376 case EM_CYGNUS_M32R:
2377 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
2378 strcat (buf, ", m32r");
2382 case EM_MIPS_RS3_LE:
2383 if (e_flags & EF_MIPS_NOREORDER)
2384 strcat (buf, ", noreorder");
2386 if (e_flags & EF_MIPS_PIC)
2387 strcat (buf, ", pic");
2389 if (e_flags & EF_MIPS_CPIC)
2390 strcat (buf, ", cpic");
2392 if (e_flags & EF_MIPS_UCODE)
2393 strcat (buf, ", ugen_reserved");
2395 if (e_flags & EF_MIPS_ABI2)
2396 strcat (buf, ", abi2");
2398 if (e_flags & EF_MIPS_OPTIONS_FIRST)
2399 strcat (buf, ", odk first");
2401 if (e_flags & EF_MIPS_32BITMODE)
2402 strcat (buf, ", 32bitmode");
2404 switch ((e_flags & EF_MIPS_MACH))
2406 case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
2407 case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
2408 case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
2409 case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
2410 case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
2411 case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
2412 case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
2413 case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
2414 case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); break;
2415 case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
2416 case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
2417 case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
2418 case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
2419 case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
2420 case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
2421 case E_MIPS_MACH_XLR: strcat (buf, ", xlr"); break;
2423 /* We simply ignore the field in this case to avoid confusion:
2424 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2427 default: strcat (buf, _(", unknown CPU")); break;
2430 switch ((e_flags & EF_MIPS_ABI))
2432 case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
2433 case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
2434 case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
2435 case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
2437 /* We simply ignore the field in this case to avoid confusion:
2438 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2439 This means it is likely to be an o32 file, but not for
2442 default: strcat (buf, _(", unknown ABI")); break;
2445 if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
2446 strcat (buf, ", mdmx");
2448 if (e_flags & EF_MIPS_ARCH_ASE_M16)
2449 strcat (buf, ", mips16");
2451 if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
2452 strcat (buf, ", micromips");
2454 switch ((e_flags & EF_MIPS_ARCH))
2456 case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
2457 case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
2458 case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
2459 case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
2460 case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
2461 case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
2462 case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
2463 case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
2464 case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
2465 default: strcat (buf, _(", unknown ISA")); break;
2468 if (e_flags & EF_SH_PIC)
2469 strcat (buf, ", pic");
2471 if (e_flags & EF_SH_FDPIC)
2472 strcat (buf, ", fdpic");
2476 switch ((e_flags & EF_SH_MACH_MASK))
2478 case EF_SH1: strcat (buf, ", sh1"); break;
2479 case EF_SH2: strcat (buf, ", sh2"); break;
2480 case EF_SH3: strcat (buf, ", sh3"); break;
2481 case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
2482 case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
2483 case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
2484 case EF_SH3E: strcat (buf, ", sh3e"); break;
2485 case EF_SH4: strcat (buf, ", sh4"); break;
2486 case EF_SH5: strcat (buf, ", sh5"); break;
2487 case EF_SH2E: strcat (buf, ", sh2e"); break;
2488 case EF_SH4A: strcat (buf, ", sh4a"); break;
2489 case EF_SH2A: strcat (buf, ", sh2a"); break;
2490 case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
2491 case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
2492 case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
2493 case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
2494 case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
2495 case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
2496 case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
2497 case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
2498 case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
2499 default: strcat (buf, _(", unknown ISA")); break;
2505 if (e_flags & EF_SPARC_32PLUS)
2506 strcat (buf, ", v8+");
2508 if (e_flags & EF_SPARC_SUN_US1)
2509 strcat (buf, ", ultrasparcI");
2511 if (e_flags & EF_SPARC_SUN_US3)
2512 strcat (buf, ", ultrasparcIII");
2514 if (e_flags & EF_SPARC_HAL_R1)
2515 strcat (buf, ", halr1");
2517 if (e_flags & EF_SPARC_LEDATA)
2518 strcat (buf, ", ledata");
2520 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
2521 strcat (buf, ", tso");
2523 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
2524 strcat (buf, ", pso");
2526 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
2527 strcat (buf, ", rmo");
2531 switch (e_flags & EF_PARISC_ARCH)
2533 case EFA_PARISC_1_0:
2534 strcpy (buf, ", PA-RISC 1.0");
2536 case EFA_PARISC_1_1:
2537 strcpy (buf, ", PA-RISC 1.1");
2539 case EFA_PARISC_2_0:
2540 strcpy (buf, ", PA-RISC 2.0");
2545 if (e_flags & EF_PARISC_TRAPNIL)
2546 strcat (buf, ", trapnil");
2547 if (e_flags & EF_PARISC_EXT)
2548 strcat (buf, ", ext");
2549 if (e_flags & EF_PARISC_LSB)
2550 strcat (buf, ", lsb");
2551 if (e_flags & EF_PARISC_WIDE)
2552 strcat (buf, ", wide");
2553 if (e_flags & EF_PARISC_NO_KABP)
2554 strcat (buf, ", no kabp");
2555 if (e_flags & EF_PARISC_LAZYSWAP)
2556 strcat (buf, ", lazyswap");
2561 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
2562 strcat (buf, ", new calling convention");
2564 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
2565 strcat (buf, ", gnu calling convention");
2569 if ((e_flags & EF_IA_64_ABI64))
2570 strcat (buf, ", 64-bit");
2572 strcat (buf, ", 32-bit");
2573 if ((e_flags & EF_IA_64_REDUCEDFP))
2574 strcat (buf, ", reduced fp model");
2575 if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
2576 strcat (buf, ", no function descriptors, constant gp");
2577 else if ((e_flags & EF_IA_64_CONS_GP))
2578 strcat (buf, ", constant gp");
2579 if ((e_flags & EF_IA_64_ABSOLUTE))
2580 strcat (buf, ", absolute");
2581 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
2583 if ((e_flags & EF_IA_64_VMS_LINKAGES))
2584 strcat (buf, ", vms_linkages");
2585 switch ((e_flags & EF_IA_64_VMS_COMCOD))
2587 case EF_IA_64_VMS_COMCOD_SUCCESS:
2589 case EF_IA_64_VMS_COMCOD_WARNING:
2590 strcat (buf, ", warning");
2592 case EF_IA_64_VMS_COMCOD_ERROR:
2593 strcat (buf, ", error");
2595 case EF_IA_64_VMS_COMCOD_ABORT:
2596 strcat (buf, ", abort");
2605 if ((e_flags & EF_VAX_NONPIC))
2606 strcat (buf, ", non-PIC");
2607 if ((e_flags & EF_VAX_DFLOAT))
2608 strcat (buf, ", D-Float");
2609 if ((e_flags & EF_VAX_GFLOAT))
2610 strcat (buf, ", G-Float");
2614 if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
2615 strcat (buf, ", 64-bit doubles");
2616 if (e_flags & E_FLAG_RX_DSP)
2617 strcat (buf, ", dsp");
2618 if (e_flags & E_FLAG_RX_PID)
2619 strcat (buf, ", pid");
2623 if (e_flags & EF_S390_HIGH_GPRS)
2624 strcat (buf, ", highgprs");
2628 if ((e_flags & EF_C6000_REL))
2629 strcat (buf, ", relocatable module");
2638 get_osabi_name (unsigned int osabi)
2640 static char buff[32];
2644 case ELFOSABI_NONE: return "UNIX - System V";
2645 case ELFOSABI_HPUX: return "UNIX - HP-UX";
2646 case ELFOSABI_NETBSD: return "UNIX - NetBSD";
2647 case ELFOSABI_GNU: return "UNIX - GNU";
2648 case ELFOSABI_SOLARIS: return "UNIX - Solaris";
2649 case ELFOSABI_AIX: return "UNIX - AIX";
2650 case ELFOSABI_IRIX: return "UNIX - IRIX";
2651 case ELFOSABI_FREEBSD: return "UNIX - FreeBSD";
2652 case ELFOSABI_TRU64: return "UNIX - TRU64";
2653 case ELFOSABI_MODESTO: return "Novell - Modesto";
2654 case ELFOSABI_OPENBSD: return "UNIX - OpenBSD";
2655 case ELFOSABI_OPENVMS: return "VMS - OpenVMS";
2656 case ELFOSABI_NSK: return "HP - Non-Stop Kernel";
2657 case ELFOSABI_AROS: return "AROS";
2658 case ELFOSABI_FENIXOS: return "FenixOS";
2661 switch (elf_header.e_machine)
2666 case ELFOSABI_ARM: return "ARM";
2676 case ELFOSABI_STANDALONE: return _("Standalone App");
2685 case ELFOSABI_C6000_ELFABI: return _("Bare-metal C6000");
2686 case ELFOSABI_C6000_LINUX: return "Linux C6000";
2695 snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
2701 get_arm_segment_type (unsigned long type)
2715 get_mips_segment_type (unsigned long type)
2719 case PT_MIPS_REGINFO:
2721 case PT_MIPS_RTPROC:
2723 case PT_MIPS_OPTIONS:
2733 get_parisc_segment_type (unsigned long type)
2737 case PT_HP_TLS: return "HP_TLS";
2738 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
2739 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
2740 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
2741 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
2742 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
2743 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
2744 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
2745 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
2746 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
2747 case PT_HP_PARALLEL: return "HP_PARALLEL";
2748 case PT_HP_FASTBIND: return "HP_FASTBIND";
2749 case PT_HP_OPT_ANNOT: return "HP_OPT_ANNOT";
2750 case PT_HP_HSL_ANNOT: return "HP_HSL_ANNOT";
2751 case PT_HP_STACK: return "HP_STACK";
2752 case PT_HP_CORE_UTSNAME: return "HP_CORE_UTSNAME";
2753 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
2754 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
2755 case PT_PARISC_WEAKORDER: return "PARISC_WEAKORDER";
2764 get_ia64_segment_type (unsigned long type)
2768 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
2769 case PT_IA_64_UNWIND: return "IA_64_UNWIND";
2770 case PT_HP_TLS: return "HP_TLS";
2771 case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
2772 case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
2773 case PT_IA_64_HP_STACK: return "HP_STACK";
2782 get_tic6x_segment_type (unsigned long type)
2786 case PT_C6000_PHATTR: return "C6000_PHATTR";
2795 get_segment_type (unsigned long p_type)
2797 static char buff[32];
2801 case PT_NULL: return "NULL";
2802 case PT_LOAD: return "LOAD";
2803 case PT_DYNAMIC: return "DYNAMIC";
2804 case PT_INTERP: return "INTERP";
2805 case PT_NOTE: return "NOTE";
2806 case PT_SHLIB: return "SHLIB";
2807 case PT_PHDR: return "PHDR";
2808 case PT_TLS: return "TLS";
2810 case PT_GNU_EH_FRAME:
2811 return "GNU_EH_FRAME";
2812 case PT_GNU_STACK: return "GNU_STACK";
2813 case PT_GNU_RELRO: return "GNU_RELRO";
2816 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
2818 const char * result;
2820 switch (elf_header.e_machine)
2823 result = get_arm_segment_type (p_type);
2826 case EM_MIPS_RS3_LE:
2827 result = get_mips_segment_type (p_type);
2830 result = get_parisc_segment_type (p_type);
2833 result = get_ia64_segment_type (p_type);
2836 result = get_tic6x_segment_type (p_type);
2846 sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
2848 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
2850 const char * result;
2852 switch (elf_header.e_machine)
2855 result = get_parisc_segment_type (p_type);
2858 result = get_ia64_segment_type (p_type);
2868 sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
2871 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
2878 get_mips_section_type_name (unsigned int sh_type)
2882 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
2883 case SHT_MIPS_MSYM: return "MIPS_MSYM";
2884 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
2885 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
2886 case SHT_MIPS_UCODE: return "MIPS_UCODE";
2887 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
2888 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
2889 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
2890 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
2891 case SHT_MIPS_RELD: return "MIPS_RELD";
2892 case SHT_MIPS_IFACE: return "MIPS_IFACE";
2893 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
2894 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
2895 case SHT_MIPS_SHDR: return "MIPS_SHDR";
2896 case SHT_MIPS_FDESC: return "MIPS_FDESC";
2897 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
2898 case SHT_MIPS_DENSE: return "MIPS_DENSE";
2899 case SHT_MIPS_PDESC: return "MIPS_PDESC";
2900 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
2901 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
2902 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
2903 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
2904 case SHT_MIPS_LINE: return "MIPS_LINE";
2905 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
2906 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
2907 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
2908 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
2909 case SHT_MIPS_DWARF: return "MIPS_DWARF";
2910 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
2911 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
2912 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
2913 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
2914 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
2915 case SHT_MIPS_XLATE: return "MIPS_XLATE";
2916 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
2917 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
2918 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
2919 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
2920 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
2928 get_parisc_section_type_name (unsigned int sh_type)
2932 case SHT_PARISC_EXT: return "PARISC_EXT";
2933 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
2934 case SHT_PARISC_DOC: return "PARISC_DOC";
2935 case SHT_PARISC_ANNOT: return "PARISC_ANNOT";
2936 case SHT_PARISC_SYMEXTN: return "PARISC_SYMEXTN";
2937 case SHT_PARISC_STUBS: return "PARISC_STUBS";
2938 case SHT_PARISC_DLKM: return "PARISC_DLKM";
2946 get_ia64_section_type_name (unsigned int sh_type)
2948 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
2949 if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
2950 return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
2954 case SHT_IA_64_EXT: return "IA_64_EXT";
2955 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
2956 case SHT_IA_64_PRIORITY_INIT: return "IA_64_PRIORITY_INIT";
2957 case SHT_IA_64_VMS_TRACE: return "VMS_TRACE";
2958 case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
2959 case SHT_IA_64_VMS_DEBUG: return "VMS_DEBUG";
2960 case SHT_IA_64_VMS_DEBUG_STR: return "VMS_DEBUG_STR";
2961 case SHT_IA_64_VMS_LINKAGES: return "VMS_LINKAGES";
2962 case SHT_IA_64_VMS_SYMBOL_VECTOR: return "VMS_SYMBOL_VECTOR";
2963 case SHT_IA_64_VMS_FIXUP: return "VMS_FIXUP";
2971 get_x86_64_section_type_name (unsigned int sh_type)
2975 case SHT_X86_64_UNWIND: return "X86_64_UNWIND";
2983 get_arm_section_type_name (unsigned int sh_type)
2987 case SHT_ARM_EXIDX: return "ARM_EXIDX";
2988 case SHT_ARM_PREEMPTMAP: return "ARM_PREEMPTMAP";
2989 case SHT_ARM_ATTRIBUTES: return "ARM_ATTRIBUTES";
2990 case SHT_ARM_DEBUGOVERLAY: return "ARM_DEBUGOVERLAY";
2991 case SHT_ARM_OVERLAYSECTION: return "ARM_OVERLAYSECTION";
2999 get_tic6x_section_type_name (unsigned int sh_type)
3003 case SHT_C6000_UNWIND:
3004 return "C6000_UNWIND";
3005 case SHT_C6000_PREEMPTMAP:
3006 return "C6000_PREEMPTMAP";
3007 case SHT_C6000_ATTRIBUTES:
3008 return "C6000_ATTRIBUTES";
3013 case SHT_TI_HANDLER:
3014 return "TI_HANDLER";
3015 case SHT_TI_INITINFO:
3016 return "TI_INITINFO";
3017 case SHT_TI_PHATTRS:
3018 return "TI_PHATTRS";
3026 get_section_type_name (unsigned int sh_type)
3028 static char buff[32];
3032 case SHT_NULL: return "NULL";
3033 case SHT_PROGBITS: return "PROGBITS";
3034 case SHT_SYMTAB: return "SYMTAB";
3035 case SHT_STRTAB: return "STRTAB";
3036 case SHT_RELA: return "RELA";
3037 case SHT_HASH: return "HASH";
3038 case SHT_DYNAMIC: return "DYNAMIC";
3039 case SHT_NOTE: return "NOTE";
3040 case SHT_NOBITS: return "NOBITS";
3041 case SHT_REL: return "REL";
3042 case SHT_SHLIB: return "SHLIB";
3043 case SHT_DYNSYM: return "DYNSYM";
3044 case SHT_INIT_ARRAY: return "INIT_ARRAY";
3045 case SHT_FINI_ARRAY: return "FINI_ARRAY";
3046 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
3047 case SHT_GNU_HASH: return "GNU_HASH";
3048 case SHT_GROUP: return "GROUP";
3049 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICIES";
3050 case SHT_GNU_verdef: return "VERDEF";
3051 case SHT_GNU_verneed: return "VERNEED";
3052 case SHT_GNU_versym: return "VERSYM";
3053 case 0x6ffffff0: return "VERSYM";
3054 case 0x6ffffffc: return "VERDEF";
3055 case 0x7ffffffd: return "AUXILIARY";
3056 case 0x7fffffff: return "FILTER";
3057 case SHT_GNU_LIBLIST: return "GNU_LIBLIST";
3060 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
3062 const char * result;
3064 switch (elf_header.e_machine)
3067 case EM_MIPS_RS3_LE:
3068 result = get_mips_section_type_name (sh_type);
3071 result = get_parisc_section_type_name (sh_type);
3074 result = get_ia64_section_type_name (sh_type);
3079 result = get_x86_64_section_type_name (sh_type);
3082 result = get_arm_section_type_name (sh_type);
3085 result = get_tic6x_section_type_name (sh_type);
3095 sprintf (buff, "LOPROC+%x", sh_type - SHT_LOPROC);
3097 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
3099 const char * result;
3101 switch (elf_header.e_machine)
3104 result = get_ia64_section_type_name (sh_type);
3114 sprintf (buff, "LOOS+%x", sh_type - SHT_LOOS);
3116 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
3117 sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER);
3119 /* This message is probably going to be displayed in a 15
3120 character wide field, so put the hex value first. */
3121 snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
3127 #define OPTION_DEBUG_DUMP 512
3128 #define OPTION_DYN_SYMS 513
3129 #define OPTION_DWARF_DEPTH 514
3130 #define OPTION_DWARF_START 515
3131 #define OPTION_DWARF_CHECK 516
3133 static struct option options[] =
3135 {"all", no_argument, 0, 'a'},
3136 {"file-header", no_argument, 0, 'h'},
3137 {"program-headers", no_argument, 0, 'l'},
3138 {"headers", no_argument, 0, 'e'},
3139 {"histogram", no_argument, 0, 'I'},
3140 {"segments", no_argument, 0, 'l'},
3141 {"sections", no_argument, 0, 'S'},
3142 {"section-headers", no_argument, 0, 'S'},
3143 {"section-groups", no_argument, 0, 'g'},
3144 {"section-details", no_argument, 0, 't'},
3145 {"full-section-name",no_argument, 0, 'N'},
3146 {"symbols", no_argument, 0, 's'},
3147 {"syms", no_argument, 0, 's'},
3148 {"dyn-syms", no_argument, 0, OPTION_DYN_SYMS},
3149 {"relocs", no_argument, 0, 'r'},
3150 {"notes", no_argument, 0, 'n'},
3151 {"dynamic", no_argument, 0, 'd'},
3152 {"arch-specific", no_argument, 0, 'A'},
3153 {"version-info", no_argument, 0, 'V'},
3154 {"use-dynamic", no_argument, 0, 'D'},
3155 {"unwind", no_argument, 0, 'u'},
3156 {"archive-index", no_argument, 0, 'c'},
3157 {"hex-dump", required_argument, 0, 'x'},
3158 {"relocated-dump", required_argument, 0, 'R'},
3159 {"string-dump", required_argument, 0, 'p'},
3160 #ifdef SUPPORT_DISASSEMBLY
3161 {"instruction-dump", required_argument, 0, 'i'},
3163 {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
3165 {"dwarf-depth", required_argument, 0, OPTION_DWARF_DEPTH},
3166 {"dwarf-start", required_argument, 0, OPTION_DWARF_START},
3167 {"dwarf-check", no_argument, 0, OPTION_DWARF_CHECK},
3169 {"version", no_argument, 0, 'v'},
3170 {"wide", no_argument, 0, 'W'},
3171 {"help", no_argument, 0, 'H'},
3172 {0, no_argument, 0, 0}
3176 usage (FILE * stream)
3178 fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
3179 fprintf (stream, _(" Display information about the contents of ELF format files\n"));
3180 fprintf (stream, _(" Options are:\n\
3181 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3182 -h --file-header Display the ELF file header\n\
3183 -l --program-headers Display the program headers\n\
3184 --segments An alias for --program-headers\n\
3185 -S --section-headers Display the sections' header\n\
3186 --sections An alias for --section-headers\n\
3187 -g --section-groups Display the section groups\n\
3188 -t --section-details Display the section details\n\
3189 -e --headers Equivalent to: -h -l -S\n\
3190 -s --syms Display the symbol table\n\
3191 --symbols An alias for --syms\n\
3192 --dyn-syms Display the dynamic symbol table\n\
3193 -n --notes Display the core notes (if present)\n\
3194 -r --relocs Display the relocations (if present)\n\
3195 -u --unwind Display the unwind info (if present)\n\
3196 -d --dynamic Display the dynamic section (if present)\n\
3197 -V --version-info Display the version sections (if present)\n\
3198 -A --arch-specific Display architecture specific information (if any)\n\
3199 -c --archive-index Display the symbol/file index in an archive\n\
3200 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
3201 -x --hex-dump=<number|name>\n\
3202 Dump the contents of section <number|name> as bytes\n\
3203 -p --string-dump=<number|name>\n\
3204 Dump the contents of section <number|name> as strings\n\
3205 -R --relocated-dump=<number|name>\n\
3206 Dump the contents of section <number|name> as relocated bytes\n\
3207 -w[lLiaprmfFsoRt] or\n\
3208 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
3209 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
3210 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges]\n\
3211 Display the contents of DWARF2 debug sections\n"));
3212 fprintf (stream, _("\
3213 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
3214 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
3216 #ifdef SUPPORT_DISASSEMBLY
3217 fprintf (stream, _("\
3218 -i --instruction-dump=<number|name>\n\
3219 Disassemble the contents of section <number|name>\n"));
3221 fprintf (stream, _("\
3222 -I --histogram Display histogram of bucket list lengths\n\
3223 -W --wide Allow output width to exceed 80 characters\n\
3224 @<file> Read options from <file>\n\
3225 -H --help Display this information\n\
3226 -v --version Display the version number of readelf\n"));
3228 if (REPORT_BUGS_TO[0] && stream == stdout)
3229 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
3231 exit (stream == stdout ? 0 : 1);
3234 /* Record the fact that the user wants the contents of section number
3235 SECTION to be displayed using the method(s) encoded as flags bits
3236 in TYPE. Note, TYPE can be zero if we are creating the array for
3240 request_dump_bynumber (unsigned int section, dump_type type)
3242 if (section >= num_dump_sects)
3244 dump_type * new_dump_sects;
3246 new_dump_sects = (dump_type *) calloc (section + 1,
3247 sizeof (* dump_sects));
3249 if (new_dump_sects == NULL)
3250 error (_("Out of memory allocating dump request table.\n"));
3253 /* Copy current flag settings. */
3254 memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
3258 dump_sects = new_dump_sects;
3259 num_dump_sects = section + 1;
3264 dump_sects[section] |= type;
3269 /* Request a dump by section name. */
3272 request_dump_byname (const char * section, dump_type type)
3274 struct dump_list_entry * new_request;
3276 new_request = (struct dump_list_entry *)
3277 malloc (sizeof (struct dump_list_entry));
3279 error (_("Out of memory allocating dump request table.\n"));
3281 new_request->name = strdup (section);
3282 if (!new_request->name)
3283 error (_("Out of memory allocating dump request table.\n"));
3285 new_request->type = type;
3287 new_request->next = dump_sects_byname;
3288 dump_sects_byname = new_request;
3292 request_dump (dump_type type)
3298 section = strtoul (optarg, & cp, 0);
3300 if (! *cp && section >= 0)
3301 request_dump_bynumber (section, type);
3303 request_dump_byname (optarg, type);
3308 parse_args (int argc, char ** argv)
3315 while ((c = getopt_long
3316 (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options, NULL)) != EOF)
3334 do_section_groups++;
3342 do_section_groups++;
3347 do_section_details++;
3391 request_dump (HEX_DUMP);
3394 request_dump (STRING_DUMP);
3397 request_dump (RELOC_DUMP);
3404 dwarf_select_sections_all ();
3409 dwarf_select_sections_by_letters (optarg);
3412 case OPTION_DEBUG_DUMP:
3419 dwarf_select_sections_by_names (optarg);
3422 case OPTION_DWARF_DEPTH:
3426 dwarf_cutoff_level = strtoul (optarg, & cp, 0);
3429 case OPTION_DWARF_START:
3433 dwarf_start_die = strtoul (optarg, & cp, 0);
3436 case OPTION_DWARF_CHECK:
3439 case OPTION_DYN_SYMS:
3442 #ifdef SUPPORT_DISASSEMBLY
3444 request_dump (DISASS_DUMP);
3448 print_version (program_name);
3457 /* xgettext:c-format */
3458 error (_("Invalid option '-%c'\n"), c);
3465 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
3466 && !do_segments && !do_header && !do_dump && !do_version
3467 && !do_histogram && !do_debugging && !do_arch && !do_notes
3468 && !do_section_groups && !do_archive_index
3473 warn (_("Nothing to do.\n"));
3479 get_elf_class (unsigned int elf_class)
3481 static char buff[32];
3485 case ELFCLASSNONE: return _("none");
3486 case ELFCLASS32: return "ELF32";
3487 case ELFCLASS64: return "ELF64";
3489 snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
3495 get_data_encoding (unsigned int encoding)
3497 static char buff[32];
3501 case ELFDATANONE: return _("none");
3502 case ELFDATA2LSB: return _("2's complement, little endian");
3503 case ELFDATA2MSB: return _("2's complement, big endian");
3505 snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
3510 /* Decode the data held in 'elf_header'. */
3513 process_file_header (void)
3515 if ( elf_header.e_ident[EI_MAG0] != ELFMAG0
3516 || elf_header.e_ident[EI_MAG1] != ELFMAG1
3517 || elf_header.e_ident[EI_MAG2] != ELFMAG2
3518 || elf_header.e_ident[EI_MAG3] != ELFMAG3)
3521 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3525 init_dwarf_regnames (elf_header.e_machine);
3531 printf (_("ELF Header:\n"));
3532 printf (_(" Magic: "));
3533 for (i = 0; i < EI_NIDENT; i++)
3534 printf ("%2.2x ", elf_header.e_ident[i]);
3536 printf (_(" Class: %s\n"),
3537 get_elf_class (elf_header.e_ident[EI_CLASS]));
3538 printf (_(" Data: %s\n"),
3539 get_data_encoding (elf_header.e_ident[EI_DATA]));
3540 printf (_(" Version: %d %s\n"),
3541 elf_header.e_ident[EI_VERSION],
3542 (elf_header.e_ident[EI_VERSION] == EV_CURRENT
3544 : (elf_header.e_ident[EI_VERSION] != EV_NONE
3545 ? _("<unknown: %lx>")
3547 printf (_(" OS/ABI: %s\n"),
3548 get_osabi_name (elf_header.e_ident[EI_OSABI]));
3549 printf (_(" ABI Version: %d\n"),
3550 elf_header.e_ident[EI_ABIVERSION]);
3551 printf (_(" Type: %s\n"),
3552 get_file_type (elf_header.e_type));
3553 printf (_(" Machine: %s\n"),
3554 get_machine_name (elf_header.e_machine));
3555 printf (_(" Version: 0x%lx\n"),
3556 (unsigned long) elf_header.e_version);
3558 printf (_(" Entry point address: "));
3559 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
3560 printf (_("\n Start of program headers: "));
3561 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
3562 printf (_(" (bytes into file)\n Start of section headers: "));
3563 print_vma ((bfd_vma) elf_header.e_shoff, DEC);
3564 printf (_(" (bytes into file)\n"));
3566 printf (_(" Flags: 0x%lx%s\n"),
3567 (unsigned long) elf_header.e_flags,
3568 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
3569 printf (_(" Size of this header: %ld (bytes)\n"),
3570 (long) elf_header.e_ehsize);
3571 printf (_(" Size of program headers: %ld (bytes)\n"),
3572 (long) elf_header.e_phentsize);
3573 printf (_(" Number of program headers: %ld"),
3574 (long) elf_header.e_phnum);
3575 if (section_headers != NULL
3576 && elf_header.e_phnum == PN_XNUM
3577 && section_headers[0].sh_info != 0)
3578 printf (" (%ld)", (long) section_headers[0].sh_info);
3579 putc ('\n', stdout);
3580 printf (_(" Size of section headers: %ld (bytes)\n"),
3581 (long) elf_header.e_shentsize);
3582 printf (_(" Number of section headers: %ld"),
3583 (long) elf_header.e_shnum);
3584 if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
3585 printf (" (%ld)", (long) section_headers[0].sh_size);
3586 putc ('\n', stdout);
3587 printf (_(" Section header string table index: %ld"),
3588 (long) elf_header.e_shstrndx);
3589 if (section_headers != NULL
3590 && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
3591 printf (" (%u)", section_headers[0].sh_link);
3592 else if (elf_header.e_shstrndx != SHN_UNDEF
3593 && elf_header.e_shstrndx >= elf_header.e_shnum)
3594 printf (_(" <corrupt: out of range>"));
3595 putc ('\n', stdout);
3598 if (section_headers != NULL)
3600 if (elf_header.e_phnum == PN_XNUM
3601 && section_headers[0].sh_info != 0)
3602 elf_header.e_phnum = section_headers[0].sh_info;
3603 if (elf_header.e_shnum == SHN_UNDEF)
3604 elf_header.e_shnum = section_headers[0].sh_size;
3605 if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
3606 elf_header.e_shstrndx = section_headers[0].sh_link;
3607 else if (elf_header.e_shstrndx >= elf_header.e_shnum)
3608 elf_header.e_shstrndx = SHN_UNDEF;
3609 free (section_headers);
3610 section_headers = NULL;
3618 get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
3620 Elf32_External_Phdr * phdrs;
3621 Elf32_External_Phdr * external;
3622 Elf_Internal_Phdr * internal;
3625 phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
3626 elf_header.e_phentsize,
3628 _("program headers"));
3632 for (i = 0, internal = pheaders, external = phdrs;
3633 i < elf_header.e_phnum;
3634 i++, internal++, external++)
3636 internal->p_type = BYTE_GET (external->p_type);
3637 internal->p_offset = BYTE_GET (external->p_offset);
3638 internal->p_vaddr = BYTE_GET (external->p_vaddr);
3639 internal->p_paddr = BYTE_GET (external->p_paddr);
3640 internal->p_filesz = BYTE_GET (external->p_filesz);
3641 internal->p_memsz = BYTE_GET (external->p_memsz);
3642 internal->p_flags = BYTE_GET (external->p_flags);
3643 internal->p_align = BYTE_GET (external->p_align);
3652 get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
3654 Elf64_External_Phdr * phdrs;
3655 Elf64_External_Phdr * external;
3656 Elf_Internal_Phdr * internal;
3659 phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
3660 elf_header.e_phentsize,
3662 _("program headers"));
3666 for (i = 0, internal = pheaders, external = phdrs;
3667 i < elf_header.e_phnum;
3668 i++, internal++, external++)
3670 internal->p_type = BYTE_GET (external->p_type);
3671 internal->p_flags = BYTE_GET (external->p_flags);
3672 internal->p_offset = BYTE_GET (external->p_offset);
3673 internal->p_vaddr = BYTE_GET (external->p_vaddr);
3674 internal->p_paddr = BYTE_GET (external->p_paddr);
3675 internal->p_filesz = BYTE_GET (external->p_filesz);
3676 internal->p_memsz = BYTE_GET (external->p_memsz);
3677 internal->p_align = BYTE_GET (external->p_align);
3685 /* Returns 1 if the program headers were read into `program_headers'. */
3688 get_program_headers (FILE * file)
3690 Elf_Internal_Phdr * phdrs;
3692 /* Check cache of prior read. */
3693 if (program_headers != NULL)
3696 phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
3697 sizeof (Elf_Internal_Phdr));
3701 error (_("Out of memory\n"));
3706 ? get_32bit_program_headers (file, phdrs)
3707 : get_64bit_program_headers (file, phdrs))
3709 program_headers = phdrs;
3717 /* Returns 1 if the program headers were loaded. */
3720 process_program_headers (FILE * file)
3722 Elf_Internal_Phdr * segment;
3725 if (elf_header.e_phnum == 0)
3727 /* PR binutils/12467. */
3728 if (elf_header.e_phoff != 0)
3729 warn (_("possibly corrupt ELF header - it has a non-zero program"
3730 " header offset, but no program headers"));
3731 else if (do_segments)
3732 printf (_("\nThere are no program headers in this file.\n"));
3736 if (do_segments && !do_header)
3738 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
3739 printf (_("Entry point "));
3740 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
3741 printf (_("\nThere are %d program headers, starting at offset "),
3742 elf_header.e_phnum);
3743 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
3747 if (! get_program_headers (file))
3752 if (elf_header.e_phnum > 1)
3753 printf (_("\nProgram Headers:\n"));
3755 printf (_("\nProgram Headers:\n"));
3759 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3762 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3766 (_(" Type Offset VirtAddr PhysAddr\n"));
3768 (_(" FileSiz MemSiz Flags Align\n"));
3775 for (i = 0, segment = program_headers;
3776 i < elf_header.e_phnum;
3781 printf (" %-14.14s ", get_segment_type (segment->p_type));
3785 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
3786 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
3787 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
3788 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
3789 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
3791 (segment->p_flags & PF_R ? 'R' : ' '),
3792 (segment->p_flags & PF_W ? 'W' : ' '),
3793 (segment->p_flags & PF_X ? 'E' : ' '));
3794 printf ("%#lx", (unsigned long) segment->p_align);
3798 if ((unsigned long) segment->p_offset == segment->p_offset)
3799 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
3802 print_vma (segment->p_offset, FULL_HEX);
3806 print_vma (segment->p_vaddr, FULL_HEX);
3808 print_vma (segment->p_paddr, FULL_HEX);
3811 if ((unsigned long) segment->p_filesz == segment->p_filesz)
3812 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
3815 print_vma (segment->p_filesz, FULL_HEX);
3819 if ((unsigned long) segment->p_memsz == segment->p_memsz)
3820 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
3823 print_vma (segment->p_memsz, FULL_HEX);
3827 (segment->p_flags & PF_R ? 'R' : ' '),
3828 (segment->p_flags & PF_W ? 'W' : ' '),
3829 (segment->p_flags & PF_X ? 'E' : ' '));
3831 if ((unsigned long) segment->p_align == segment->p_align)
3832 printf ("%#lx", (unsigned long) segment->p_align);
3835 print_vma (segment->p_align, PREFIX_HEX);
3840 print_vma (segment->p_offset, FULL_HEX);
3842 print_vma (segment->p_vaddr, FULL_HEX);
3844 print_vma (segment->p_paddr, FULL_HEX);
3846 print_vma (segment->p_filesz, FULL_HEX);
3848 print_vma (segment->p_memsz, FULL_HEX);
3850 (segment->p_flags & PF_R ? 'R' : ' '),
3851 (segment->p_flags & PF_W ? 'W' : ' '),
3852 (segment->p_flags & PF_X ? 'E' : ' '));
3853 print_vma (segment->p_align, HEX);
3857 switch (segment->p_type)
3861 error (_("more than one dynamic segment\n"));
3863 /* By default, assume that the .dynamic section is the first
3864 section in the DYNAMIC segment. */
3865 dynamic_addr = segment->p_offset;
3866 dynamic_size = segment->p_filesz;
3868 /* Try to locate the .dynamic section. If there is
3869 a section header table, we can easily locate it. */
3870 if (section_headers != NULL)
3872 Elf_Internal_Shdr * sec;
3874 sec = find_section (".dynamic");
3875 if (sec == NULL || sec->sh_size == 0)
3877 /* A corresponding .dynamic section is expected, but on
3878 IA-64/OpenVMS it is OK for it to be missing. */
3879 if (!is_ia64_vms ())
3880 error (_("no .dynamic section in the dynamic segment\n"));
3884 if (sec->sh_type == SHT_NOBITS)
3890 dynamic_addr = sec->sh_offset;
3891 dynamic_size = sec->sh_size;
3893 if (dynamic_addr < segment->p_offset
3894 || dynamic_addr > segment->p_offset + segment->p_filesz)
3895 warn (_("the .dynamic section is not contained"
3896 " within the dynamic segment\n"));
3897 else if (dynamic_addr > segment->p_offset)
3898 warn (_("the .dynamic section is not the first section"
3899 " in the dynamic segment.\n"));
3904 if (fseek (file, archive_file_offset + (long) segment->p_offset,
3906 error (_("Unable to find program interpreter name\n"));
3910 int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX);
3912 if (ret >= (int) sizeof (fmt) || ret < 0)
3913 error (_("Internal error: failed to create format string to display program interpreter\n"));
3915 program_interpreter[0] = 0;
3916 if (fscanf (file, fmt, program_interpreter) <= 0)
3917 error (_("Unable to read program interpreter name\n"));
3920 printf (_("\n [Requesting program interpreter: %s]"),
3921 program_interpreter);
3927 putc ('\n', stdout);
3930 if (do_segments && section_headers != NULL && string_table != NULL)
3932 printf (_("\n Section to Segment mapping:\n"));
3933 printf (_(" Segment Sections...\n"));
3935 for (i = 0; i < elf_header.e_phnum; i++)
3938 Elf_Internal_Shdr * section;
3940 segment = program_headers + i;
3941 section = section_headers + 1;
3943 printf (" %2.2d ", i);
3945 for (j = 1; j < elf_header.e_shnum; j++, section++)
3947 if (!ELF_TBSS_SPECIAL (section, segment)
3948 && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
3949 printf ("%s ", SECTION_NAME (section));
3960 /* Find the file offset corresponding to VMA by using the program headers. */
3963 offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
3965 Elf_Internal_Phdr * seg;
3967 if (! get_program_headers (file))
3969 warn (_("Cannot interpret virtual addresses without program headers.\n"));
3973 for (seg = program_headers;
3974 seg < program_headers + elf_header.e_phnum;
3977 if (seg->p_type != PT_LOAD)
3980 if (vma >= (seg->p_vaddr & -seg->p_align)
3981 && vma + size <= seg->p_vaddr + seg->p_filesz)
3982 return vma - seg->p_vaddr + seg->p_offset;
3985 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
3986 (unsigned long) vma);
3992 get_32bit_section_headers (FILE * file, unsigned int num)
3994 Elf32_External_Shdr * shdrs;
3995 Elf_Internal_Shdr * internal;
3998 shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
3999 elf_header.e_shentsize, num,
4000 _("section headers"));
4004 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4005 sizeof (Elf_Internal_Shdr));
4007 if (section_headers == NULL)
4009 error (_("Out of memory\n"));
4013 for (i = 0, internal = section_headers;
4017 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4018 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
4019 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4020 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4021 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
4022 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4023 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4024 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
4025 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4026 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
4035 get_64bit_section_headers (FILE * file, unsigned int num)
4037 Elf64_External_Shdr * shdrs;
4038 Elf_Internal_Shdr * internal;
4041 shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
4042 elf_header.e_shentsize, num,
4043 _("section headers"));
4047 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4048 sizeof (Elf_Internal_Shdr));
4050 if (section_headers == NULL)
4052 error (_("Out of memory\n"));
4056 for (i = 0, internal = section_headers;
4060 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4061 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
4062 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4063 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4064 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4065 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
4066 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4067 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
4068 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
4069 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4077 static Elf_Internal_Sym *
4078 get_32bit_elf_symbols (FILE * file,
4079 Elf_Internal_Shdr * section,
4080 unsigned long * num_syms_return)
4082 unsigned long number = 0;
4083 Elf32_External_Sym * esyms = NULL;
4084 Elf_External_Sym_Shndx * shndx = NULL;
4085 Elf_Internal_Sym * isyms = NULL;
4086 Elf_Internal_Sym * psym;
4089 /* Run some sanity checks first. */
4090 if (section->sh_entsize == 0)
4092 error (_("sh_entsize is zero\n"));
4096 number = section->sh_size / section->sh_entsize;
4098 if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
4100 error (_("Invalid sh_entsize\n"));
4104 esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4105 section->sh_size, _("symbols"));
4110 if (symtab_shndx_hdr != NULL
4111 && (symtab_shndx_hdr->sh_link
4112 == (unsigned long) (section - section_headers)))
4114 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4115 symtab_shndx_hdr->sh_offset,
4116 1, symtab_shndx_hdr->sh_size,
4117 _("symbol table section indicies"));
4122 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
4126 error (_("Out of memory\n"));
4130 for (j = 0, psym = isyms; j < number; j++, psym++)
4132 psym->st_name = BYTE_GET (esyms[j].st_name);
4133 psym->st_value = BYTE_GET (esyms[j].st_value);
4134 psym->st_size = BYTE_GET (esyms[j].st_size);
4135 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4136 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
4138 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4139 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4140 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
4141 psym->st_info = BYTE_GET (esyms[j].st_info);
4142 psym->st_other = BYTE_GET (esyms[j].st_other);
4151 if (num_syms_return != NULL)
4152 * num_syms_return = isyms == NULL ? 0 : number;
4157 static Elf_Internal_Sym *
4158 get_64bit_elf_symbols (FILE * file,
4159 Elf_Internal_Shdr * section,
4160 unsigned long * num_syms_return)
4162 unsigned long number = 0;
4163 Elf64_External_Sym * esyms = NULL;
4164 Elf_External_Sym_Shndx * shndx = NULL;
4165 Elf_Internal_Sym * isyms = NULL;
4166 Elf_Internal_Sym * psym;
4169 /* Run some sanity checks first. */
4170 if (section->sh_entsize == 0)
4172 error (_("sh_entsize is zero\n"));
4176 number = section->sh_size / section->sh_entsize;
4178 if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
4180 error (_("Invalid sh_entsize\n"));
4184 esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4185 section->sh_size, _("symbols"));
4189 if (symtab_shndx_hdr != NULL
4190 && (symtab_shndx_hdr->sh_link
4191 == (unsigned long) (section - section_headers)))
4193 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4194 symtab_shndx_hdr->sh_offset,
4195 1, symtab_shndx_hdr->sh_size,
4196 _("symbol table section indicies"));
4201 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
4205 error (_("Out of memory\n"));
4209 for (j = 0, psym = isyms; j < number; j++, psym++)
4211 psym->st_name = BYTE_GET (esyms[j].st_name);
4212 psym->st_info = BYTE_GET (esyms[j].st_info);
4213 psym->st_other = BYTE_GET (esyms[j].st_other);
4214 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4216 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
4218 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4219 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4220 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
4222 psym->st_value = BYTE_GET (esyms[j].st_value);
4223 psym->st_size = BYTE_GET (esyms[j].st_size);
4232 if (num_syms_return != NULL)
4233 * num_syms_return = isyms == NULL ? 0 : number;
4239 get_elf_section_flags (bfd_vma sh_flags)
4241 static char buff[1024];
4243 int field_size = is_32bit_elf ? 8 : 16;
4245 int size = sizeof (buff) - (field_size + 4 + 1);
4246 bfd_vma os_flags = 0;
4247 bfd_vma proc_flags = 0;
4248 bfd_vma unknown_flags = 0;
4256 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
4257 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
4258 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
4259 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
4260 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
4261 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
4262 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
4263 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
4264 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
4265 /* 9 */ { STRING_COMMA_LEN ("TLS") },
4266 /* IA-64 specific. */
4267 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
4268 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
4269 /* IA-64 OpenVMS specific. */
4270 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
4271 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
4272 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
4273 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
4274 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
4275 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
4277 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
4278 /* SPARC specific. */
4279 /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
4282 if (do_section_details)
4284 sprintf (buff, "[%*.*lx]: ",
4285 field_size, field_size, (unsigned long) sh_flags);
4286 p += field_size + 4;
4293 flag = sh_flags & - sh_flags;
4296 if (do_section_details)
4300 case SHF_WRITE: sindex = 0; break;
4301 case SHF_ALLOC: sindex = 1; break;
4302 case SHF_EXECINSTR: sindex = 2; break;
4303 case SHF_MERGE: sindex = 3; break;
4304 case SHF_STRINGS: sindex = 4; break;
4305 case SHF_INFO_LINK: sindex = 5; break;
4306 case SHF_LINK_ORDER: sindex = 6; break;
4307 case SHF_OS_NONCONFORMING: sindex = 7; break;
4308 case SHF_GROUP: sindex = 8; break;
4309 case SHF_TLS: sindex = 9; break;
4310 case SHF_EXCLUDE: sindex = 18; break;
4314 switch (elf_header.e_machine)
4317 if (flag == SHF_IA_64_SHORT)
4319 else if (flag == SHF_IA_64_NORECOV)
4322 else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
4325 case SHF_IA_64_VMS_GLOBAL: sindex = 12; break;
4326 case SHF_IA_64_VMS_OVERLAID: sindex = 13; break;
4327 case SHF_IA_64_VMS_SHARED: sindex = 14; break;
4328 case SHF_IA_64_VMS_VECTOR: sindex = 15; break;
4329 case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
4330 case SHF_IA_64_VMS_PROTECTED: sindex = 17; break;
4341 case EM_OLD_SPARCV9:
4342 case EM_SPARC32PLUS:
4345 if (flag == SHF_ORDERED)
4355 if (p != buff + field_size + 4)
4357 if (size < (10 + 2))
4364 size -= flags [sindex].len;
4365 p = stpcpy (p, flags [sindex].str);
4367 else if (flag & SHF_MASKOS)
4369 else if (flag & SHF_MASKPROC)
4372 unknown_flags |= flag;
4378 case SHF_WRITE: *p = 'W'; break;
4379 case SHF_ALLOC: *p = 'A'; break;
4380 case SHF_EXECINSTR: *p = 'X'; break;
4381 case SHF_MERGE: *p = 'M'; break;
4382 case SHF_STRINGS: *p = 'S'; break;
4383 case SHF_INFO_LINK: *p = 'I'; break;
4384 case SHF_LINK_ORDER: *p = 'L'; break;
4385 case SHF_OS_NONCONFORMING: *p = 'O'; break;
4386 case SHF_GROUP: *p = 'G'; break;
4387 case SHF_TLS: *p = 'T'; break;
4388 case SHF_EXCLUDE: *p = 'E'; break;
4391 if ((elf_header.e_machine == EM_X86_64
4392 || elf_header.e_machine == EM_L1OM
4393 || elf_header.e_machine == EM_K1OM)
4394 && flag == SHF_X86_64_LARGE)
4396 else if (flag & SHF_MASKOS)
4399 sh_flags &= ~ SHF_MASKOS;
4401 else if (flag & SHF_MASKPROC)
4404 sh_flags &= ~ SHF_MASKPROC;
4414 if (do_section_details)
4418 size -= 5 + field_size;
4419 if (p != buff + field_size + 4)
4427 sprintf (p, "OS (%*.*lx)", field_size, field_size,
4428 (unsigned long) os_flags);
4429 p += 5 + field_size;
4433 size -= 7 + field_size;
4434 if (p != buff + field_size + 4)
4442 sprintf (p, "PROC (%*.*lx)", field_size, field_size,
4443 (unsigned long) proc_flags);
4444 p += 7 + field_size;
4448 size -= 10 + field_size;
4449 if (p != buff + field_size + 4)
4457 sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
4458 (unsigned long) unknown_flags);
4459 p += 10 + field_size;
4468 process_section_headers (FILE * file)
4470 Elf_Internal_Shdr * section;
4473 section_headers = NULL;
4475 if (elf_header.e_shnum == 0)
4477 /* PR binutils/12467. */
4478 if (elf_header.e_shoff != 0)
4479 warn (_("possibly corrupt ELF file header - it has a non-zero"
4480 " section header offset, but no section headers\n"));
4481 else if (do_sections)
4482 printf (_("\nThere are no sections in this file.\n"));
4487 if (do_sections && !do_header)
4488 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
4489 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
4493 if (! get_32bit_section_headers (file, elf_header.e_shnum))
4496 else if (! get_64bit_section_headers (file, elf_header.e_shnum))
4499 /* Read in the string table, so that we have names to display. */
4500 if (elf_header.e_shstrndx != SHN_UNDEF
4501 && elf_header.e_shstrndx < elf_header.e_shnum)
4503 section = section_headers + elf_header.e_shstrndx;
4505 if (section->sh_size != 0)
4507 string_table = (char *) get_data (NULL, file, section->sh_offset,
4508 1, section->sh_size,
4511 string_table_length = string_table != NULL ? section->sh_size : 0;
4515 /* Scan the sections for the dynamic symbol table
4516 and dynamic string table and debug sections. */
4517 dynamic_symbols = NULL;
4518 dynamic_strings = NULL;
4519 dynamic_syminfo = NULL;
4520 symtab_shndx_hdr = NULL;
4522 eh_addr_size = is_32bit_elf ? 4 : 8;
4523 switch (elf_header.e_machine)
4526 case EM_MIPS_RS3_LE:
4527 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
4528 FDE addresses. However, the ABI also has a semi-official ILP32
4529 variant for which the normal FDE address size rules apply.
4531 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
4532 section, where XX is the size of longs in bits. Unfortunately,
4533 earlier compilers provided no way of distinguishing ILP32 objects
4534 from LP64 objects, so if there's any doubt, we should assume that
4535 the official LP64 form is being used. */
4536 if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
4537 && find_section (".gcc_compiled_long32") == NULL)
4543 switch (elf_header.e_flags & EF_H8_MACH)
4545 case E_H8_MACH_H8300:
4546 case E_H8_MACH_H8300HN:
4547 case E_H8_MACH_H8300SN:
4548 case E_H8_MACH_H8300SXN:
4551 case E_H8_MACH_H8300H:
4552 case E_H8_MACH_H8300S:
4553 case E_H8_MACH_H8300SX:
4561 switch (elf_header.e_flags & EF_M32C_CPU_MASK)
4563 case EF_M32C_CPU_M16C:
4570 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
4573 size_t expected_entsize \
4574 = is_32bit_elf ? size32 : size64; \
4575 if (section->sh_entsize != expected_entsize) \
4576 error (_("Section %d has invalid sh_entsize %lx (expected %lx)\n"), \
4577 i, (unsigned long int) section->sh_entsize, \
4578 (unsigned long int) expected_entsize); \
4579 section->sh_entsize = expected_entsize; \
4582 #define CHECK_ENTSIZE(section, i, type) \
4583 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
4584 sizeof (Elf64_External_##type))
4586 for (i = 0, section = section_headers;
4587 i < elf_header.e_shnum;
4590 char * name = SECTION_NAME (section);
4592 if (section->sh_type == SHT_DYNSYM)
4594 if (dynamic_symbols != NULL)
4596 error (_("File contains multiple dynamic symbol tables\n"));
4600 CHECK_ENTSIZE (section, i, Sym);
4601 dynamic_symbols = GET_ELF_SYMBOLS (file, section, & num_dynamic_syms);
4603 else if (section->sh_type == SHT_STRTAB
4604 && streq (name, ".dynstr"))
4606 if (dynamic_strings != NULL)
4608 error (_("File contains multiple dynamic string tables\n"));
4612 dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
4613 1, section->sh_size,
4614 _("dynamic strings"));
4615 dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
4617 else if (section->sh_type == SHT_SYMTAB_SHNDX)
4619 if (symtab_shndx_hdr != NULL)
4621 error (_("File contains multiple symtab shndx tables\n"));
4624 symtab_shndx_hdr = section;
4626 else if (section->sh_type == SHT_SYMTAB)
4627 CHECK_ENTSIZE (section, i, Sym);
4628 else if (section->sh_type == SHT_GROUP)
4629 CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
4630 else if (section->sh_type == SHT_REL)
4631 CHECK_ENTSIZE (section, i, Rel);
4632 else if (section->sh_type == SHT_RELA)
4633 CHECK_ENTSIZE (section, i, Rela);
4634 else if ((do_debugging || do_debug_info || do_debug_abbrevs
4635 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
4636 || do_debug_aranges || do_debug_frames || do_debug_macinfo
4637 || do_debug_str || do_debug_loc || do_debug_ranges)
4638 && (const_strneq (name, ".debug_")
4639 || const_strneq (name, ".zdebug_")))
4642 name += sizeof (".zdebug_") - 1;
4644 name += sizeof (".debug_") - 1;
4647 || (do_debug_info && const_strneq (name, "info"))
4648 || (do_debug_info && const_strneq (name, "types"))
4649 || (do_debug_abbrevs && const_strneq (name, "abbrev"))
4650 || (do_debug_lines && const_strneq (name, "line"))
4651 || (do_debug_pubnames && const_strneq (name, "pubnames"))
4652 || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
4653 || (do_debug_aranges && const_strneq (name, "aranges"))
4654 || (do_debug_ranges && const_strneq (name, "ranges"))
4655 || (do_debug_frames && const_strneq (name, "frame"))
4656 || (do_debug_macinfo && const_strneq (name, "macinfo"))
4657 || (do_debug_macinfo && const_strneq (name, "macro"))
4658 || (do_debug_str && const_strneq (name, "str"))
4659 || (do_debug_loc && const_strneq (name, "loc"))
4661 request_dump_bynumber (i, DEBUG_DUMP);
4663 /* Linkonce section to be combined with .debug_info at link time. */
4664 else if ((do_debugging || do_debug_info)
4665 && const_strneq (name, ".gnu.linkonce.wi."))
4666 request_dump_bynumber (i, DEBUG_DUMP);
4667 else if (do_debug_frames && streq (name, ".eh_frame"))
4668 request_dump_bynumber (i, DEBUG_DUMP);
4669 else if (do_gdb_index && streq (name, ".gdb_index"))
4670 request_dump_bynumber (i, DEBUG_DUMP);
4671 /* Trace sections for Itanium VMS. */
4672 else if ((do_debugging || do_trace_info || do_trace_abbrevs
4673 || do_trace_aranges)
4674 && const_strneq (name, ".trace_"))
4676 name += sizeof (".trace_") - 1;
4679 || (do_trace_info && streq (name, "info"))
4680 || (do_trace_abbrevs && streq (name, "abbrev"))
4681 || (do_trace_aranges && streq (name, "aranges"))
4683 request_dump_bynumber (i, DEBUG_DUMP);
4691 if (elf_header.e_shnum > 1)
4692 printf (_("\nSection Headers:\n"));
4694 printf (_("\nSection Header:\n"));
4698 if (do_section_details)
4700 printf (_(" [Nr] Name\n"));
4701 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
4705 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
4709 if (do_section_details)
4711 printf (_(" [Nr] Name\n"));
4712 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
4716 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
4720 if (do_section_details)
4722 printf (_(" [Nr] Name\n"));
4723 printf (_(" Type Address Offset Link\n"));
4724 printf (_(" Size EntSize Info Align\n"));
4728 printf (_(" [Nr] Name Type Address Offset\n"));
4729 printf (_(" Size EntSize Flags Link Info Align\n"));
4733 if (do_section_details)
4734 printf (_(" Flags\n"));
4736 for (i = 0, section = section_headers;
4737 i < elf_header.e_shnum;
4740 if (do_section_details)
4742 printf (" [%2u] %s\n",
4744 SECTION_NAME (section));
4745 if (is_32bit_elf || do_wide)
4746 printf (" %-15.15s ",
4747 get_section_type_name (section->sh_type));
4750 printf ((do_wide ? " [%2u] %-17s %-15s "
4751 : " [%2u] %-17.17s %-15.15s "),
4753 SECTION_NAME (section),
4754 get_section_type_name (section->sh_type));
4758 const char * link_too_big = NULL;
4760 print_vma (section->sh_addr, LONG_HEX);
4762 printf ( " %6.6lx %6.6lx %2.2lx",
4763 (unsigned long) section->sh_offset,
4764 (unsigned long) section->sh_size,
4765 (unsigned long) section->sh_entsize);
4767 if (do_section_details)
4768 fputs (" ", stdout);
4770 printf (" %3s ", get_elf_section_flags (section->sh_flags));
4772 if (section->sh_link >= elf_header.e_shnum)
4775 /* The sh_link value is out of range. Normally this indicates
4776 an error but it can have special values in Solaris binaries. */
4777 switch (elf_header.e_machine)
4784 case EM_OLD_SPARCV9:
4785 case EM_SPARC32PLUS:
4788 if (section->sh_link == (SHN_BEFORE & 0xffff))
4789 link_too_big = "BEFORE";
4790 else if (section->sh_link == (SHN_AFTER & 0xffff))
4791 link_too_big = "AFTER";
4798 if (do_section_details)
4800 if (link_too_big != NULL && * link_too_big)
4801 printf ("<%s> ", link_too_big);
4803 printf ("%2u ", section->sh_link);
4804 printf ("%3u %2lu\n", section->sh_info,
4805 (unsigned long) section->sh_addralign);
4808 printf ("%2u %3u %2lu\n",
4811 (unsigned long) section->sh_addralign);
4813 if (link_too_big && ! * link_too_big)
4814 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
4815 i, section->sh_link);
4819 print_vma (section->sh_addr, LONG_HEX);
4821 if ((long) section->sh_offset == section->sh_offset)
4822 printf (" %6.6lx", (unsigned long) section->sh_offset);
4826 print_vma (section->sh_offset, LONG_HEX);
4829 if ((unsigned long) section->sh_size == section->sh_size)
4830 printf (" %6.6lx", (unsigned long) section->sh_size);
4834 print_vma (section->sh_size, LONG_HEX);
4837 if ((unsigned long) section->sh_entsize == section->sh_entsize)
4838 printf (" %2.2lx", (unsigned long) section->sh_entsize);
4842 print_vma (section->sh_entsize, LONG_HEX);
4845 if (do_section_details)
4846 fputs (" ", stdout);
4848 printf (" %3s ", get_elf_section_flags (section->sh_flags));
4850 printf ("%2u %3u ", section->sh_link, section->sh_info);
4852 if ((unsigned long) section->sh_addralign == section->sh_addralign)
4853 printf ("%2lu\n", (unsigned long) section->sh_addralign);
4856 print_vma (section->sh_addralign, DEC);
4860 else if (do_section_details)
4862 printf (" %-15.15s ",
4863 get_section_type_name (section->sh_type));
4864 print_vma (section->sh_addr, LONG_HEX);
4865 if ((long) section->sh_offset == section->sh_offset)
4866 printf (" %16.16lx", (unsigned long) section->sh_offset);
4870 print_vma (section->sh_offset, LONG_HEX);
4872 printf (" %u\n ", section->sh_link);
4873 print_vma (section->sh_size, LONG_HEX);
4875 print_vma (section->sh_entsize, LONG_HEX);
4877 printf (" %-16u %lu\n",
4879 (unsigned long) section->sh_addralign);
4884 print_vma (section->sh_addr, LONG_HEX);
4885 if ((long) section->sh_offset == section->sh_offset)
4886 printf (" %8.8lx", (unsigned long) section->sh_offset);
4890 print_vma (section->sh_offset, LONG_HEX);
4893 print_vma (section->sh_size, LONG_HEX);
4895 print_vma (section->sh_entsize, LONG_HEX);
4897 printf (" %3s ", get_elf_section_flags (section->sh_flags));
4899 printf (" %2u %3u %lu\n",
4902 (unsigned long) section->sh_addralign);
4905 if (do_section_details)
4906 printf (" %s\n", get_elf_section_flags (section->sh_flags));
4909 if (!do_section_details)
4911 if (elf_header.e_machine == EM_X86_64
4912 || elf_header.e_machine == EM_L1OM
4913 || elf_header.e_machine == EM_K1OM)
4914 printf (_("Key to Flags:\n\
4915 W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
4916 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
4917 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
4919 printf (_("Key to Flags:\n\
4920 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
4921 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
4922 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
4929 get_group_flags (unsigned int flags)
4931 static char buff[32];
4941 snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x] "), flags);
4948 process_section_groups (FILE * file)
4950 Elf_Internal_Shdr * section;
4952 struct group * group;
4953 Elf_Internal_Shdr * symtab_sec;
4954 Elf_Internal_Shdr * strtab_sec;
4955 Elf_Internal_Sym * symtab;
4956 unsigned long num_syms;
4960 /* Don't process section groups unless needed. */
4961 if (!do_unwind && !do_section_groups)
4964 if (elf_header.e_shnum == 0)
4966 if (do_section_groups)
4967 printf (_("\nThere are no sections to group in this file.\n"));
4972 if (section_headers == NULL)
4974 error (_("Section headers are not available!\n"));
4975 /* PR 13622: This can happen with a corrupt ELF header. */
4979 section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
4980 sizeof (struct group *));
4982 if (section_headers_groups == NULL)
4984 error (_("Out of memory\n"));
4988 /* Scan the sections for the group section. */
4990 for (i = 0, section = section_headers;
4991 i < elf_header.e_shnum;
4993 if (section->sh_type == SHT_GROUP)
4996 if (group_count == 0)
4998 if (do_section_groups)
4999 printf (_("\nThere are no section groups in this file.\n"));
5004 section_groups = (struct group *) calloc (group_count, sizeof (struct group));
5006 if (section_groups == NULL)
5008 error (_("Out of memory\n"));
5018 for (i = 0, section = section_headers, group = section_groups;
5019 i < elf_header.e_shnum;
5022 if (section->sh_type == SHT_GROUP)
5024 char * name = SECTION_NAME (section);
5026 unsigned char * start;
5027 unsigned char * indices;
5028 unsigned int entry, j, size;
5029 Elf_Internal_Shdr * sec;
5030 Elf_Internal_Sym * sym;
5032 /* Get the symbol table. */
5033 if (section->sh_link >= elf_header.e_shnum
5034 || ((sec = section_headers + section->sh_link)->sh_type
5037 error (_("Bad sh_link in group section `%s'\n"), name);
5041 if (symtab_sec != sec)
5046 symtab = GET_ELF_SYMBOLS (file, symtab_sec, & num_syms);
5051 error (_("Corrupt header in group section `%s'\n"), name);
5055 if (section->sh_info >= num_syms)
5057 error (_("Bad sh_info in group section `%s'\n"), name);
5061 sym = symtab + section->sh_info;
5063 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
5065 if (sym->st_shndx == 0
5066 || sym->st_shndx >= elf_header.e_shnum)
5068 error (_("Bad sh_info in group section `%s'\n"), name);
5072 group_name = SECTION_NAME (section_headers + sym->st_shndx);
5081 /* Get the string table. */
5082 if (symtab_sec->sh_link >= elf_header.e_shnum)
5091 != (sec = section_headers + symtab_sec->sh_link))
5096 strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
5097 1, strtab_sec->sh_size,
5099 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
5101 group_name = sym->st_name < strtab_size
5102 ? strtab + sym->st_name : _("<corrupt>");
5105 start = (unsigned char *) get_data (NULL, file, section->sh_offset,
5106 1, section->sh_size,
5112 size = (section->sh_size / section->sh_entsize) - 1;
5113 entry = byte_get (indices, 4);
5116 if (do_section_groups)
5118 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
5119 get_group_flags (entry), i, name, group_name, size);
5121 printf (_(" [Index] Name\n"));
5124 group->group_index = i;
5126 for (j = 0; j < size; j++)
5128 struct group_list * g;
5130 entry = byte_get (indices, 4);
5133 if (entry >= elf_header.e_shnum)
5135 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
5136 entry, i, elf_header.e_shnum - 1);
5140 if (section_headers_groups [entry] != NULL)
5144 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
5146 section_headers_groups [entry]->group_index);
5151 /* Intel C/C++ compiler may put section 0 in a
5152 section group. We just warn it the first time
5153 and ignore it afterwards. */
5154 static int warned = 0;
5157 error (_("section 0 in group section [%5u]\n"),
5158 section_headers_groups [entry]->group_index);
5164 section_headers_groups [entry] = group;
5166 if (do_section_groups)
5168 sec = section_headers + entry;
5169 printf (" [%5u] %s\n", entry, SECTION_NAME (sec));
5172 g = (struct group_list *) xmalloc (sizeof (struct group_list));
5173 g->section_index = entry;
5174 g->next = group->root;
5192 /* Data used to display dynamic fixups. */
5194 struct ia64_vms_dynfixup
5196 bfd_vma needed_ident; /* Library ident number. */
5197 bfd_vma needed; /* Index in the dstrtab of the library name. */
5198 bfd_vma fixup_needed; /* Index of the library. */
5199 bfd_vma fixup_rela_cnt; /* Number of fixups. */
5200 bfd_vma fixup_rela_off; /* Fixups offset in the dynamic segment. */
5203 /* Data used to display dynamic relocations. */
5205 struct ia64_vms_dynimgrela
5207 bfd_vma img_rela_cnt; /* Number of relocations. */
5208 bfd_vma img_rela_off; /* Reloc offset in the dynamic segment. */
5211 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
5215 dump_ia64_vms_dynamic_fixups (FILE *file, struct ia64_vms_dynfixup *fixup,
5216 const char *strtab, unsigned int strtab_sz)
5218 Elf64_External_VMS_IMAGE_FIXUP *imfs;
5220 const char *lib_name;
5222 imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
5223 1, fixup->fixup_rela_cnt * sizeof (*imfs),
5224 _("dynamic section image fixups"));
5228 if (fixup->needed < strtab_sz)
5229 lib_name = strtab + fixup->needed;
5232 warn ("corrupt library name index of 0x%lx found in dynamic entry",
5233 (unsigned long) fixup->needed);
5236 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
5237 (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
5239 (_("Seg Offset Type SymVec DataType\n"));
5241 for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
5246 printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
5247 printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
5248 type = BYTE_GET (imfs [i].type);
5249 rtype = elf_ia64_reloc_type (type);
5251 printf (" 0x%08x ", type);
5253 printf (" %-32s ", rtype);
5254 printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
5255 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
5261 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
5264 dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
5266 Elf64_External_VMS_IMAGE_RELA *imrs;
5269 imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
5270 1, imgrela->img_rela_cnt * sizeof (*imrs),
5271 _("dynamic section image relocations"));
5275 printf (_("\nImage relocs\n"));
5277 (_("Seg Offset Type Addend Seg Sym Off\n"));
5279 for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
5284 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
5285 printf ("%08" BFD_VMA_FMT "x ",
5286 (bfd_vma) BYTE_GET (imrs [i].rela_offset));
5287 type = BYTE_GET (imrs [i].type);
5288 rtype = elf_ia64_reloc_type (type);
5290 printf ("0x%08x ", type);
5292 printf ("%-31s ", rtype);
5293 print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
5294 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
5295 printf ("%08" BFD_VMA_FMT "x\n",
5296 (bfd_vma) BYTE_GET (imrs [i].sym_offset));
5302 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
5305 process_ia64_vms_dynamic_relocs (FILE *file)
5307 struct ia64_vms_dynfixup fixup;
5308 struct ia64_vms_dynimgrela imgrela;
5309 Elf_Internal_Dyn *entry;
5311 bfd_vma strtab_off = 0;
5312 bfd_vma strtab_sz = 0;
5313 char *strtab = NULL;
5315 memset (&fixup, 0, sizeof (fixup));
5316 memset (&imgrela, 0, sizeof (imgrela));
5318 /* Note: the order of the entries is specified by the OpenVMS specs. */
5319 for (entry = dynamic_section;
5320 entry < dynamic_section + dynamic_nent;
5323 switch (entry->d_tag)
5325 case DT_IA_64_VMS_STRTAB_OFFSET:
5326 strtab_off = entry->d_un.d_val;
5329 strtab_sz = entry->d_un.d_val;
5331 strtab = get_data (NULL, file, dynamic_addr + strtab_off,
5332 1, strtab_sz, _("dynamic string section"));
5335 case DT_IA_64_VMS_NEEDED_IDENT:
5336 fixup.needed_ident = entry->d_un.d_val;
5339 fixup.needed = entry->d_un.d_val;
5341 case DT_IA_64_VMS_FIXUP_NEEDED:
5342 fixup.fixup_needed = entry->d_un.d_val;
5344 case DT_IA_64_VMS_FIXUP_RELA_CNT:
5345 fixup.fixup_rela_cnt = entry->d_un.d_val;
5347 case DT_IA_64_VMS_FIXUP_RELA_OFF:
5348 fixup.fixup_rela_off = entry->d_un.d_val;
5350 dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz);
5353 case DT_IA_64_VMS_IMG_RELA_CNT:
5354 imgrela.img_rela_cnt = entry->d_un.d_val;
5356 case DT_IA_64_VMS_IMG_RELA_OFF:
5357 imgrela.img_rela_off = entry->d_un.d_val;
5359 dump_ia64_vms_dynamic_relocs (file, &imgrela);
5379 } dynamic_relocations [] =
5381 { "REL", DT_REL, DT_RELSZ, FALSE },
5382 { "RELA", DT_RELA, DT_RELASZ, TRUE },
5383 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
5386 /* Process the reloc section. */
5389 process_relocs (FILE * file)
5391 unsigned long rel_size;
5392 unsigned long rel_offset;
5398 if (do_using_dynamic)
5402 int has_dynamic_reloc;
5405 has_dynamic_reloc = 0;
5407 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
5409 is_rela = dynamic_relocations [i].rela;
5410 name = dynamic_relocations [i].name;
5411 rel_size = dynamic_info [dynamic_relocations [i].size];
5412 rel_offset = dynamic_info [dynamic_relocations [i].reloc];
5414 has_dynamic_reloc |= rel_size;
5416 if (is_rela == UNKNOWN)
5418 if (dynamic_relocations [i].reloc == DT_JMPREL)
5419 switch (dynamic_info[DT_PLTREL])
5433 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
5434 name, rel_offset, rel_size);
5436 dump_relocations (file,
5437 offset_from_vma (file, rel_offset, rel_size),
5439 dynamic_symbols, num_dynamic_syms,
5440 dynamic_strings, dynamic_strings_length, is_rela);
5445 has_dynamic_reloc |= process_ia64_vms_dynamic_relocs (file);
5447 if (! has_dynamic_reloc)
5448 printf (_("\nThere are no dynamic relocations in this file.\n"));
5452 Elf_Internal_Shdr * section;
5456 for (i = 0, section = section_headers;
5457 i < elf_header.e_shnum;
5460 if ( section->sh_type != SHT_RELA
5461 && section->sh_type != SHT_REL)
5464 rel_offset = section->sh_offset;
5465 rel_size = section->sh_size;
5469 Elf_Internal_Shdr * strsec;
5472 printf (_("\nRelocation section "));
5474 if (string_table == NULL)
5475 printf ("%d", section->sh_name);
5477 printf ("'%s'", SECTION_NAME (section));
5479 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5480 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
5482 is_rela = section->sh_type == SHT_RELA;
5484 if (section->sh_link != 0
5485 && section->sh_link < elf_header.e_shnum)
5487 Elf_Internal_Shdr * symsec;
5488 Elf_Internal_Sym * symtab;
5489 unsigned long nsyms;
5490 unsigned long strtablen = 0;
5491 char * strtab = NULL;
5493 symsec = section_headers + section->sh_link;
5494 if (symsec->sh_type != SHT_SYMTAB
5495 && symsec->sh_type != SHT_DYNSYM)
5498 symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
5503 if (symsec->sh_link != 0
5504 && symsec->sh_link < elf_header.e_shnum)
5506 strsec = section_headers + symsec->sh_link;
5508 strtab = (char *) get_data (NULL, file, strsec->sh_offset,
5511 strtablen = strtab == NULL ? 0 : strsec->sh_size;
5514 dump_relocations (file, rel_offset, rel_size,
5515 symtab, nsyms, strtab, strtablen, is_rela);
5521 dump_relocations (file, rel_offset, rel_size,
5522 NULL, 0, NULL, 0, is_rela);
5529 printf (_("\nThere are no relocations in this file.\n"));
5535 /* Process the unwind section. */
5537 #include "unwind-ia64.h"
5539 /* An absolute address consists of a section and an offset. If the
5540 section is NULL, the offset itself is the address, otherwise, the
5541 address equals to LOAD_ADDRESS(section) + offset. */
5545 unsigned short section;
5549 #define ABSADDR(a) \
5551 ? section_headers [(a).section].sh_addr + (a).offset \
5554 struct ia64_unw_table_entry
5556 struct absaddr start;
5558 struct absaddr info;
5561 struct ia64_unw_aux_info
5564 struct ia64_unw_table_entry *table; /* Unwind table. */
5565 unsigned long table_len; /* Length of unwind table. */
5566 unsigned char * info; /* Unwind info. */
5567 unsigned long info_size; /* Size of unwind info. */
5568 bfd_vma info_addr; /* starting address of unwind info. */
5569 bfd_vma seg_base; /* Starting address of segment. */
5570 Elf_Internal_Sym * symtab; /* The symbol table. */
5571 unsigned long nsyms; /* Number of symbols. */
5572 char * strtab; /* The string table. */
5573 unsigned long strtab_size; /* Size of string table. */
5577 find_symbol_for_address (Elf_Internal_Sym * symtab,
5578 unsigned long nsyms,
5579 const char * strtab,
5580 unsigned long strtab_size,
5581 struct absaddr addr,
5582 const char ** symname,
5585 bfd_vma dist = 0x100000;
5586 Elf_Internal_Sym * sym;
5587 Elf_Internal_Sym * best = NULL;
5590 REMOVE_ARCH_BITS (addr.offset);
5592 for (i = 0, sym = symtab; i < nsyms; ++i, ++sym)
5594 bfd_vma value = sym->st_value;
5596 REMOVE_ARCH_BITS (value);
5598 if (ELF_ST_TYPE (sym->st_info) == STT_FUNC
5599 && sym->st_name != 0
5600 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
5601 && addr.offset >= value
5602 && addr.offset - value < dist)
5605 dist = addr.offset - value;
5613 *symname = (best->st_name >= strtab_size
5614 ? _("<corrupt>") : strtab + best->st_name);
5620 *offset = addr.offset;
5624 dump_ia64_unwind (struct ia64_unw_aux_info * aux)
5626 struct ia64_unw_table_entry * tp;
5629 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
5633 const unsigned char * dp;
5634 const unsigned char * head;
5635 const char * procname;
5637 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
5638 aux->strtab_size, tp->start, &procname, &offset);
5640 fputs ("\n<", stdout);
5644 fputs (procname, stdout);
5647 printf ("+%lx", (unsigned long) offset);
5650 fputs (">: [", stdout);
5651 print_vma (tp->start.offset, PREFIX_HEX);
5652 fputc ('-', stdout);
5653 print_vma (tp->end.offset, PREFIX_HEX);
5654 printf ("], info at +0x%lx\n",
5655 (unsigned long) (tp->info.offset - aux->seg_base));
5657 head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
5658 stamp = byte_get ((unsigned char *) head, sizeof (stamp));
5660 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
5661 (unsigned) UNW_VER (stamp),
5662 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
5663 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
5664 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
5665 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
5667 if (UNW_VER (stamp) != 1)
5669 printf (_("\tUnknown version.\n"));
5674 for (dp = head + 8; dp < head + 8 + eh_addr_size * UNW_LENGTH (stamp);)
5675 dp = unw_decode (dp, in_body, & in_body);
5680 slurp_ia64_unwind_table (FILE * file,
5681 struct ia64_unw_aux_info * aux,
5682 Elf_Internal_Shdr * sec)
5684 unsigned long size, nrelas, i;
5685 Elf_Internal_Phdr * seg;
5686 struct ia64_unw_table_entry * tep;
5687 Elf_Internal_Shdr * relsec;
5688 Elf_Internal_Rela * rela;
5689 Elf_Internal_Rela * rp;
5690 unsigned char * table;
5692 Elf_Internal_Sym * sym;
5693 const char * relname;
5695 /* First, find the starting address of the segment that includes
5698 if (elf_header.e_phnum)
5700 if (! get_program_headers (file))
5703 for (seg = program_headers;
5704 seg < program_headers + elf_header.e_phnum;
5707 if (seg->p_type != PT_LOAD)
5710 if (sec->sh_addr >= seg->p_vaddr
5711 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
5713 aux->seg_base = seg->p_vaddr;
5719 /* Second, build the unwind table from the contents of the unwind section: */
5720 size = sec->sh_size;
5721 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
5726 aux->table = (struct ia64_unw_table_entry *)
5727 xcmalloc (size / (3 * eh_addr_size), sizeof (aux->table[0]));
5729 for (tp = table; tp < table + size; ++tep)
5731 tep->start.section = SHN_UNDEF;
5732 tep->end.section = SHN_UNDEF;
5733 tep->info.section = SHN_UNDEF;
5734 tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
5735 tep->end.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
5736 tep->info.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
5737 tep->start.offset += aux->seg_base;
5738 tep->end.offset += aux->seg_base;
5739 tep->info.offset += aux->seg_base;
5743 /* Third, apply any relocations to the unwind table: */
5744 for (relsec = section_headers;
5745 relsec < section_headers + elf_header.e_shnum;
5748 if (relsec->sh_type != SHT_RELA
5749 || relsec->sh_info >= elf_header.e_shnum
5750 || section_headers + relsec->sh_info != sec)
5753 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
5757 for (rp = rela; rp < rela + nrelas; ++rp)
5759 relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
5760 sym = aux->symtab + get_reloc_symindex (rp->r_info);
5762 if (! const_strneq (relname, "R_IA64_SEGREL"))
5764 warn (_("Skipping unexpected relocation type %s\n"), relname);
5768 i = rp->r_offset / (3 * eh_addr_size);
5770 switch (rp->r_offset/eh_addr_size % 3)
5773 aux->table[i].start.section = sym->st_shndx;
5774 aux->table[i].start.offset = rp->r_addend + sym->st_value;
5777 aux->table[i].end.section = sym->st_shndx;
5778 aux->table[i].end.offset = rp->r_addend + sym->st_value;
5781 aux->table[i].info.section = sym->st_shndx;
5782 aux->table[i].info.offset = rp->r_addend + sym->st_value;
5792 aux->table_len = size / (3 * eh_addr_size);
5797 ia64_process_unwind (FILE * file)
5799 Elf_Internal_Shdr * sec;
5800 Elf_Internal_Shdr * unwsec = NULL;
5801 Elf_Internal_Shdr * strsec;
5802 unsigned long i, unwcount = 0, unwstart = 0;
5803 struct ia64_unw_aux_info aux;
5805 memset (& aux, 0, sizeof (aux));
5807 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
5809 if (sec->sh_type == SHT_SYMTAB
5810 && sec->sh_link < elf_header.e_shnum)
5812 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
5814 strsec = section_headers + sec->sh_link;
5815 assert (aux.strtab == NULL);
5816 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
5819 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
5821 else if (sec->sh_type == SHT_IA_64_UNWIND)
5826 printf (_("\nThere are no unwind sections in this file.\n"));
5828 while (unwcount-- > 0)
5833 for (i = unwstart, sec = section_headers + unwstart;
5834 i < elf_header.e_shnum; ++i, ++sec)
5835 if (sec->sh_type == SHT_IA_64_UNWIND)
5842 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
5844 if ((unwsec->sh_flags & SHF_GROUP) != 0)
5846 /* We need to find which section group it is in. */
5847 struct group_list * g = section_headers_groups [i]->root;
5849 for (; g != NULL; g = g->next)
5851 sec = section_headers + g->section_index;
5853 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
5858 i = elf_header.e_shnum;
5860 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
5862 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
5863 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
5864 suffix = SECTION_NAME (unwsec) + len;
5865 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
5867 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
5868 && streq (SECTION_NAME (sec) + len2, suffix))
5873 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
5874 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
5875 len = sizeof (ELF_STRING_ia64_unwind) - 1;
5876 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
5878 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
5879 suffix = SECTION_NAME (unwsec) + len;
5880 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
5882 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
5883 && streq (SECTION_NAME (sec) + len2, suffix))
5887 if (i == elf_header.e_shnum)
5889 printf (_("\nCould not find unwind info section for "));
5891 if (string_table == NULL)
5892 printf ("%d", unwsec->sh_name);
5894 printf (_("'%s'"), SECTION_NAME (unwsec));
5898 aux.info_addr = sec->sh_addr;
5899 aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
5902 aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
5904 printf (_("\nUnwind section "));
5906 if (string_table == NULL)
5907 printf ("%d", unwsec->sh_name);
5909 printf (_("'%s'"), SECTION_NAME (unwsec));
5911 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5912 (unsigned long) unwsec->sh_offset,
5913 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
5915 (void) slurp_ia64_unwind_table (file, & aux, unwsec);
5917 if (aux.table_len > 0)
5918 dump_ia64_unwind (& aux);
5921 free ((char *) aux.table);
5923 free ((char *) aux.info);
5932 free ((char *) aux.strtab);
5935 struct hppa_unw_table_entry
5937 struct absaddr start;
5939 unsigned int Cannot_unwind:1; /* 0 */
5940 unsigned int Millicode:1; /* 1 */
5941 unsigned int Millicode_save_sr0:1; /* 2 */
5942 unsigned int Region_description:2; /* 3..4 */
5943 unsigned int reserved1:1; /* 5 */
5944 unsigned int Entry_SR:1; /* 6 */
5945 unsigned int Entry_FR:4; /* number saved */ /* 7..10 */
5946 unsigned int Entry_GR:5; /* number saved */ /* 11..15 */
5947 unsigned int Args_stored:1; /* 16 */
5948 unsigned int Variable_Frame:1; /* 17 */
5949 unsigned int Separate_Package_Body:1; /* 18 */
5950 unsigned int Frame_Extension_Millicode:1; /* 19 */
5951 unsigned int Stack_Overflow_Check:1; /* 20 */
5952 unsigned int Two_Instruction_SP_Increment:1; /* 21 */
5953 unsigned int Ada_Region:1; /* 22 */
5954 unsigned int cxx_info:1; /* 23 */
5955 unsigned int cxx_try_catch:1; /* 24 */
5956 unsigned int sched_entry_seq:1; /* 25 */
5957 unsigned int reserved2:1; /* 26 */
5958 unsigned int Save_SP:1; /* 27 */
5959 unsigned int Save_RP:1; /* 28 */
5960 unsigned int Save_MRP_in_frame:1; /* 29 */
5961 unsigned int extn_ptr_defined:1; /* 30 */
5962 unsigned int Cleanup_defined:1; /* 31 */
5964 unsigned int MPE_XL_interrupt_marker:1; /* 0 */
5965 unsigned int HP_UX_interrupt_marker:1; /* 1 */
5966 unsigned int Large_frame:1; /* 2 */
5967 unsigned int Pseudo_SP_Set:1; /* 3 */
5968 unsigned int reserved4:1; /* 4 */
5969 unsigned int Total_frame_size:27; /* 5..31 */
5972 struct hppa_unw_aux_info
5974 struct hppa_unw_table_entry *table; /* Unwind table. */
5975 unsigned long table_len; /* Length of unwind table. */
5976 bfd_vma seg_base; /* Starting address of segment. */
5977 Elf_Internal_Sym * symtab; /* The symbol table. */
5978 unsigned long nsyms; /* Number of symbols. */
5979 char * strtab; /* The string table. */
5980 unsigned long strtab_size; /* Size of string table. */
5984 dump_hppa_unwind (struct hppa_unw_aux_info * aux)
5986 struct hppa_unw_table_entry * tp;
5988 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
5991 const char * procname;
5993 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
5994 aux->strtab_size, tp->start, &procname,
5997 fputs ("\n<", stdout);
6001 fputs (procname, stdout);
6004 printf ("+%lx", (unsigned long) offset);
6007 fputs (">: [", stdout);
6008 print_vma (tp->start.offset, PREFIX_HEX);
6009 fputc ('-', stdout);
6010 print_vma (tp->end.offset, PREFIX_HEX);
6013 #define PF(_m) if (tp->_m) printf (#_m " ");
6014 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
6017 PF(Millicode_save_sr0);
6018 /* PV(Region_description); */
6024 PF(Separate_Package_Body);
6025 PF(Frame_Extension_Millicode);
6026 PF(Stack_Overflow_Check);
6027 PF(Two_Instruction_SP_Increment);
6031 PF(sched_entry_seq);
6034 PF(Save_MRP_in_frame);
6035 PF(extn_ptr_defined);
6036 PF(Cleanup_defined);
6037 PF(MPE_XL_interrupt_marker);
6038 PF(HP_UX_interrupt_marker);
6041 PV(Total_frame_size);
6050 slurp_hppa_unwind_table (FILE * file,
6051 struct hppa_unw_aux_info * aux,
6052 Elf_Internal_Shdr * sec)
6054 unsigned long size, unw_ent_size, nentries, nrelas, i;
6055 Elf_Internal_Phdr * seg;
6056 struct hppa_unw_table_entry * tep;
6057 Elf_Internal_Shdr * relsec;
6058 Elf_Internal_Rela * rela;
6059 Elf_Internal_Rela * rp;
6060 unsigned char * table;
6062 Elf_Internal_Sym * sym;
6063 const char * relname;
6065 /* First, find the starting address of the segment that includes
6068 if (elf_header.e_phnum)
6070 if (! get_program_headers (file))
6073 for (seg = program_headers;
6074 seg < program_headers + elf_header.e_phnum;
6077 if (seg->p_type != PT_LOAD)
6080 if (sec->sh_addr >= seg->p_vaddr
6081 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
6083 aux->seg_base = seg->p_vaddr;
6089 /* Second, build the unwind table from the contents of the unwind
6091 size = sec->sh_size;
6092 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
6098 nentries = size / unw_ent_size;
6099 size = unw_ent_size * nentries;
6101 tep = aux->table = (struct hppa_unw_table_entry *)
6102 xcmalloc (nentries, sizeof (aux->table[0]));
6104 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
6106 unsigned int tmp1, tmp2;
6108 tep->start.section = SHN_UNDEF;
6109 tep->end.section = SHN_UNDEF;
6111 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
6112 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
6113 tmp1 = byte_get ((unsigned char *) tp + 8, 4);
6114 tmp2 = byte_get ((unsigned char *) tp + 12, 4);
6116 tep->start.offset += aux->seg_base;
6117 tep->end.offset += aux->seg_base;
6119 tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
6120 tep->Millicode = (tmp1 >> 30) & 0x1;
6121 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
6122 tep->Region_description = (tmp1 >> 27) & 0x3;
6123 tep->reserved1 = (tmp1 >> 26) & 0x1;
6124 tep->Entry_SR = (tmp1 >> 25) & 0x1;
6125 tep->Entry_FR = (tmp1 >> 21) & 0xf;
6126 tep->Entry_GR = (tmp1 >> 16) & 0x1f;
6127 tep->Args_stored = (tmp1 >> 15) & 0x1;
6128 tep->Variable_Frame = (tmp1 >> 14) & 0x1;
6129 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
6130 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
6131 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
6132 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
6133 tep->Ada_Region = (tmp1 >> 9) & 0x1;
6134 tep->cxx_info = (tmp1 >> 8) & 0x1;
6135 tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
6136 tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
6137 tep->reserved2 = (tmp1 >> 5) & 0x1;
6138 tep->Save_SP = (tmp1 >> 4) & 0x1;
6139 tep->Save_RP = (tmp1 >> 3) & 0x1;
6140 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
6141 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
6142 tep->Cleanup_defined = tmp1 & 0x1;
6144 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
6145 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
6146 tep->Large_frame = (tmp2 >> 29) & 0x1;
6147 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
6148 tep->reserved4 = (tmp2 >> 27) & 0x1;
6149 tep->Total_frame_size = tmp2 & 0x7ffffff;
6153 /* Third, apply any relocations to the unwind table. */
6154 for (relsec = section_headers;
6155 relsec < section_headers + elf_header.e_shnum;
6158 if (relsec->sh_type != SHT_RELA
6159 || relsec->sh_info >= elf_header.e_shnum
6160 || section_headers + relsec->sh_info != sec)
6163 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6167 for (rp = rela; rp < rela + nrelas; ++rp)
6169 relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
6170 sym = aux->symtab + get_reloc_symindex (rp->r_info);
6172 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
6173 if (! const_strneq (relname, "R_PARISC_SEGREL"))
6175 warn (_("Skipping unexpected relocation type %s\n"), relname);
6179 i = rp->r_offset / unw_ent_size;
6181 switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
6184 aux->table[i].start.section = sym->st_shndx;
6185 aux->table[i].start.offset = sym->st_value + rp->r_addend;
6188 aux->table[i].end.section = sym->st_shndx;
6189 aux->table[i].end.offset = sym->st_value + rp->r_addend;
6199 aux->table_len = nentries;
6205 hppa_process_unwind (FILE * file)
6207 struct hppa_unw_aux_info aux;
6208 Elf_Internal_Shdr * unwsec = NULL;
6209 Elf_Internal_Shdr * strsec;
6210 Elf_Internal_Shdr * sec;
6213 if (string_table == NULL)
6216 memset (& aux, 0, sizeof (aux));
6218 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6220 if (sec->sh_type == SHT_SYMTAB
6221 && sec->sh_link < elf_header.e_shnum)
6223 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
6225 strsec = section_headers + sec->sh_link;
6226 assert (aux.strtab == NULL);
6227 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6230 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
6232 else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
6237 printf (_("\nThere are no unwind sections in this file.\n"));
6239 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6241 if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
6243 printf (_("\nUnwind section "));
6244 printf (_("'%s'"), SECTION_NAME (sec));
6246 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6247 (unsigned long) sec->sh_offset,
6248 (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
6250 slurp_hppa_unwind_table (file, &aux, sec);
6251 if (aux.table_len > 0)
6252 dump_hppa_unwind (&aux);
6255 free ((char *) aux.table);
6263 free ((char *) aux.strtab);
6268 unsigned char * data; /* The unwind data. */
6269 Elf_Internal_Shdr * sec; /* The cached unwind section header. */
6270 Elf_Internal_Rela * rela; /* The cached relocations for this section. */
6271 unsigned long nrelas; /* The number of relocations. */
6272 unsigned int rel_type; /* REL or RELA ? */
6273 Elf_Internal_Rela * next_rela; /* Cyclic pointer to the next reloc to process. */
6276 struct arm_unw_aux_info
6278 FILE * file; /* The file containing the unwind sections. */
6279 Elf_Internal_Sym * symtab; /* The file's symbol table. */
6280 unsigned long nsyms; /* Number of symbols. */
6281 char * strtab; /* The file's string table. */
6282 unsigned long strtab_size; /* Size of string table. */
6286 arm_print_vma_and_name (struct arm_unw_aux_info *aux,
6287 bfd_vma fn, struct absaddr addr)
6289 const char *procname;
6292 if (addr.section == SHN_UNDEF)
6295 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6296 aux->strtab_size, addr, &procname,
6299 print_vma (fn, PREFIX_HEX);
6303 fputs (" <", stdout);
6304 fputs (procname, stdout);
6307 printf ("+0x%lx", (unsigned long) sym_offset);
6308 fputc ('>', stdout);
6315 arm_free_section (struct arm_section *arm_sec)
6317 if (arm_sec->data != NULL)
6318 free (arm_sec->data);
6320 if (arm_sec->rela != NULL)
6321 free (arm_sec->rela);
6324 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
6325 cached section and install SEC instead.
6326 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
6327 and return its valued in * WORDP, relocating if necessary.
6328 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
6329 relocation's offset in ADDR.
6330 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
6331 into the string table of the symbol associated with the reloc. If no
6332 reloc was applied store -1 there.
6333 5) Return TRUE upon success, FALSE otherwise. */
6336 get_unwind_section_word (struct arm_unw_aux_info * aux,
6337 struct arm_section * arm_sec,
6338 Elf_Internal_Shdr * sec,
6339 bfd_vma word_offset,
6340 unsigned int * wordp,
6341 struct absaddr * addr,
6344 Elf_Internal_Rela *rp;
6345 Elf_Internal_Sym *sym;
6346 const char * relname;
6348 bfd_boolean wrapped;
6350 addr->section = SHN_UNDEF;
6353 if (sym_name != NULL)
6354 *sym_name = (bfd_vma) -1;
6356 /* If necessary, update the section cache. */
6357 if (sec != arm_sec->sec)
6359 Elf_Internal_Shdr *relsec;
6361 arm_free_section (arm_sec);
6364 arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
6365 sec->sh_size, _("unwind data"));
6366 arm_sec->rela = NULL;
6367 arm_sec->nrelas = 0;
6369 for (relsec = section_headers;
6370 relsec < section_headers + elf_header.e_shnum;
6373 if (relsec->sh_info >= elf_header.e_shnum
6374 || section_headers + relsec->sh_info != sec)
6377 arm_sec->rel_type = relsec->sh_type;
6378 if (relsec->sh_type == SHT_REL)
6380 if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
6382 & arm_sec->rela, & arm_sec->nrelas))
6386 else if (relsec->sh_type == SHT_RELA)
6388 if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
6390 & arm_sec->rela, & arm_sec->nrelas))
6395 warn (_("unexpected relocation type (%d) for section %d"),
6396 relsec->sh_type, relsec->sh_info);
6399 arm_sec->next_rela = arm_sec->rela;
6402 /* If there is no unwind data we can do nothing. */
6403 if (arm_sec->data == NULL)
6406 /* Get the word at the required offset. */
6407 word = byte_get (arm_sec->data + word_offset, 4);
6409 /* Look through the relocs to find the one that applies to the provided offset. */
6411 for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
6413 bfd_vma prelval, offset;
6415 if (rp->r_offset > word_offset && !wrapped)
6420 if (rp->r_offset > word_offset)
6423 if (rp->r_offset & 3)
6425 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
6426 (unsigned long) rp->r_offset);
6430 if (rp->r_offset < word_offset)
6433 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
6435 if (arm_sec->rel_type == SHT_REL)
6437 offset = word & 0x7fffffff;
6438 if (offset & 0x40000000)
6439 offset |= ~ (bfd_vma) 0x7fffffff;
6441 else if (arm_sec->rel_type == SHT_RELA)
6442 offset = rp->r_addend;
6446 offset += sym->st_value;
6447 prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
6449 /* Check that we are processing the expected reloc type. */
6450 if (elf_header.e_machine == EM_ARM)
6452 relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
6454 if (streq (relname, "R_ARM_NONE"))
6457 if (! streq (relname, "R_ARM_PREL31"))
6459 warn (_("Skipping unexpected relocation type %s\n"), relname);
6463 else if (elf_header.e_machine == EM_TI_C6000)
6465 relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
6467 if (streq (relname, "R_C6000_NONE"))
6470 if (! streq (relname, "R_C6000_PREL31"))
6472 warn (_("Skipping unexpected relocation type %s\n"), relname);
6479 /* This function currently only supports ARM and TI unwinders. */
6482 word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
6483 addr->section = sym->st_shndx;
6484 addr->offset = offset;
6486 * sym_name = sym->st_name;
6491 arm_sec->next_rela = rp;
6496 static const char *tic6x_unwind_regnames[16] =
6498 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
6499 "A14", "A13", "A12", "A11", "A10",
6500 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
6504 decode_tic6x_unwind_regmask (unsigned int mask)
6508 for (i = 12; mask; mask >>= 1, i--)
6512 fputs (tic6x_unwind_regnames[i], stdout);
6514 fputs (", ", stdout);
6520 if (remaining == 0 && more_words) \
6523 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
6524 data_offset, & word, & addr, NULL)) \
6530 #define GET_OP(OP) \
6535 (OP) = word >> 24; \
6540 printf (_("[Truncated opcode]\n")); \
6543 printf ("0x%02x ", OP)
6546 decode_arm_unwind_bytecode (struct arm_unw_aux_info *aux,
6547 unsigned int word, unsigned int remaining,
6548 unsigned int more_words,
6549 bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
6550 struct arm_section *data_arm_sec)
6552 struct absaddr addr;
6554 /* Decode the unwinding instructions. */
6557 unsigned int op, op2;
6566 printf (" 0x%02x ", op);
6568 if ((op & 0xc0) == 0x00)
6570 int offset = ((op & 0x3f) << 2) + 4;
6572 printf (" vsp = vsp + %d", offset);
6574 else if ((op & 0xc0) == 0x40)
6576 int offset = ((op & 0x3f) << 2) + 4;
6578 printf (" vsp = vsp - %d", offset);
6580 else if ((op & 0xf0) == 0x80)
6583 if (op == 0x80 && op2 == 0)
6584 printf (_("Refuse to unwind"));
6587 unsigned int mask = ((op & 0x0f) << 8) | op2;
6592 for (i = 0; i < 12; i++)
6593 if (mask & (1 << i))
6599 printf ("r%d", 4 + i);
6604 else if ((op & 0xf0) == 0x90)
6606 if (op == 0x9d || op == 0x9f)
6607 printf (_(" [Reserved]"));
6609 printf (" vsp = r%d", op & 0x0f);
6611 else if ((op & 0xf0) == 0xa0)
6613 int end = 4 + (op & 0x07);
6618 for (i = 4; i <= end; i++)
6634 else if (op == 0xb0)
6635 printf (_(" finish"));
6636 else if (op == 0xb1)
6639 if (op2 == 0 || (op2 & 0xf0) != 0)
6640 printf (_("[Spare]"));
6643 unsigned int mask = op2 & 0x0f;
6648 for (i = 0; i < 12; i++)
6649 if (mask & (1 << i))
6660 else if (op == 0xb2)
6662 unsigned char buf[9];
6663 unsigned int i, len;
6664 unsigned long offset;
6666 for (i = 0; i < sizeof (buf); i++)
6669 if ((buf[i] & 0x80) == 0)
6672 assert (i < sizeof (buf));
6673 offset = read_uleb128 (buf, &len);
6674 assert (len == i + 1);
6675 offset = offset * 4 + 0x204;
6676 printf ("vsp = vsp + %ld", offset);
6678 else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
6680 unsigned int first, last;
6687 printf ("pop {D%d", first);
6689 printf ("-D%d", first + last);
6692 else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
6694 unsigned int count = op & 0x07;
6698 printf ("-D%d", 8 + count);
6701 else if (op >= 0xc0 && op <= 0xc5)
6703 unsigned int count = op & 0x07;
6705 printf (" pop {wR10");
6707 printf ("-wR%d", 10 + count);
6710 else if (op == 0xc6)
6712 unsigned int first, last;
6717 printf ("pop {wR%d", first);
6719 printf ("-wR%d", first + last);
6722 else if (op == 0xc7)
6725 if (op2 == 0 || (op2 & 0xf0) != 0)
6726 printf (_("[Spare]"));
6729 unsigned int mask = op2 & 0x0f;
6734 for (i = 0; i < 4; i++)
6735 if (mask & (1 << i))
6741 printf ("wCGR%d", i);
6747 printf (_(" [unsupported opcode]"));
6753 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info *aux,
6754 unsigned int word, unsigned int remaining,
6755 unsigned int more_words,
6756 bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
6757 struct arm_section *data_arm_sec)
6759 struct absaddr addr;
6761 /* Decode the unwinding instructions. */
6764 unsigned int op, op2;
6773 printf (" 0x%02x ", op);
6775 if ((op & 0xc0) == 0x00)
6777 int offset = ((op & 0x3f) << 3) + 8;
6778 printf (" sp = sp + %d", offset);
6780 else if ((op & 0xc0) == 0x80)
6783 if (op == 0x80 && op2 == 0)
6784 printf (_("Refuse to unwind"));
6787 unsigned int mask = ((op & 0x1f) << 8) | op2;
6789 printf ("pop compact {");
6793 decode_tic6x_unwind_regmask (mask);
6797 else if ((op & 0xf0) == 0xc0)
6805 unsigned int offset;
6809 /* Scan entire instruction first so that GET_OP output is not
6810 interleaved with disassembly. */
6812 for (i = 0; nregs < (op & 0xf); i++)
6818 regpos[nregs].offset = i * 2;
6819 regpos[nregs].reg = reg;
6826 regpos[nregs].offset = i * 2 + 1;
6827 regpos[nregs].reg = reg;
6832 printf (_("pop frame {"));
6834 for (i = i * 2; i > 0; i--)
6836 if (regpos[reg].offset == i - 1)
6838 name = tic6x_unwind_regnames[regpos[reg].reg];
6845 fputs (name, stdout);
6852 else if (op == 0xd0)
6853 printf (" MOV FP, SP");
6854 else if (op == 0xd1)
6855 printf (" __c6xabi_pop_rts");
6856 else if (op == 0xd2)
6858 unsigned char buf[9];
6859 unsigned int i, len;
6860 unsigned long offset;
6862 for (i = 0; i < sizeof (buf); i++)
6865 if ((buf[i] & 0x80) == 0)
6868 assert (i < sizeof (buf));
6869 offset = read_uleb128 (buf, &len);
6870 assert (len == i + 1);
6871 offset = offset * 8 + 0x408;
6872 printf (_("sp = sp + %ld"), offset);
6874 else if ((op & 0xf0) == 0xe0)
6876 if ((op & 0x0f) == 7)
6879 printf (" MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
6883 printf (_(" [unsupported opcode]"));
6890 arm_expand_prel31 (bfd_vma word, bfd_vma where)
6894 offset = word & 0x7fffffff;
6895 if (offset & 0x40000000)
6896 offset |= ~ (bfd_vma) 0x7fffffff;
6898 if (elf_header.e_machine == EM_TI_C6000)
6901 return offset + where;
6905 decode_arm_unwind (struct arm_unw_aux_info * aux,
6907 unsigned int remaining,
6908 bfd_vma data_offset,
6909 Elf_Internal_Shdr * data_sec,
6910 struct arm_section * data_arm_sec)
6913 unsigned int more_words = 0;
6914 struct absaddr addr;
6915 bfd_vma sym_name = (bfd_vma) -1;
6919 /* Fetch the first word.
6920 Note - when decoding an object file the address extracted
6921 here will always be 0. So we also pass in the sym_name
6922 parameter so that we can find the symbol associated with
6923 the personality routine. */
6924 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, data_offset,
6925 & word, & addr, & sym_name))
6931 if ((word & 0x80000000) == 0)
6933 /* Expand prel31 for personality routine. */
6935 const char *procname;
6937 fn = arm_expand_prel31 (word, data_sec->sh_addr + data_offset);
6938 printf (_(" Personality routine: "));
6940 && addr.section == SHN_UNDEF && addr.offset == 0
6941 && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
6943 procname = aux->strtab + sym_name;
6944 print_vma (fn, PREFIX_HEX);
6947 fputs (" <", stdout);
6948 fputs (procname, stdout);
6949 fputc ('>', stdout);
6953 procname = arm_print_vma_and_name (aux, fn, addr);
6954 fputc ('\n', stdout);
6956 /* The GCC personality routines use the standard compact
6957 encoding, starting with one byte giving the number of
6959 if (procname != NULL
6960 && (const_strneq (procname, "__gcc_personality_v0")
6961 || const_strneq (procname, "__gxx_personality_v0")
6962 || const_strneq (procname, "__gcj_personality_v0")
6963 || const_strneq (procname, "__gnu_objc_personality_v0")))
6970 printf (_(" [Truncated data]\n"));
6973 more_words = word >> 24;
6983 /* ARM EHABI Section 6.3:
6985 An exception-handling table entry for the compact model looks like:
6989 1 0 index Data for personalityRoutine[index] */
6991 if (elf_header.e_machine == EM_ARM
6992 && (word & 0x70000000))
6993 warn (_("Corrupt ARM compact model table entry: %x \n"), word);
6995 per_index = (word >> 24) & 0x7f;
6996 printf (_(" Compact model index: %d\n"), per_index);
7003 else if (per_index < 3)
7005 more_words = (word >> 16) & 0xff;
7011 switch (elf_header.e_machine)
7016 decode_arm_unwind_bytecode (aux, word, remaining, more_words,
7017 data_offset, data_sec, data_arm_sec);
7021 warn (_("Unknown ARM compact model index encountered\n"));
7022 printf (_(" [reserved]\n"));
7029 decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
7030 data_offset, data_sec, data_arm_sec);
7032 else if (per_index < 5)
7034 if (((word >> 17) & 0x7f) == 0x7f)
7035 printf (_(" Restore stack from frame pointer\n"));
7037 printf (_(" Stack increment %d\n"), (word >> 14) & 0x1fc);
7038 printf (_(" Registers restored: "));
7040 printf (" (compact) ");
7041 decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
7043 printf (_(" Return register: %s\n"),
7044 tic6x_unwind_regnames[word & 0xf]);
7047 printf (_(" [reserved (%d)]\n"), per_index);
7051 error (_("Unsupported architecture type %d encountered when decoding unwind table"),
7052 elf_header.e_machine);
7055 /* Decode the descriptors. Not implemented. */
7059 dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
7061 struct arm_section exidx_arm_sec, extab_arm_sec;
7062 unsigned int i, exidx_len;
7064 memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
7065 memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
7066 exidx_len = exidx_sec->sh_size / 8;
7068 for (i = 0; i < exidx_len; i++)
7070 unsigned int exidx_fn, exidx_entry;
7071 struct absaddr fn_addr, entry_addr;
7074 fputc ('\n', stdout);
7076 if (! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
7077 8 * i, & exidx_fn, & fn_addr, NULL)
7078 || ! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
7079 8 * i + 4, & exidx_entry, & entry_addr, NULL))
7081 arm_free_section (& exidx_arm_sec);
7082 arm_free_section (& extab_arm_sec);
7086 /* ARM EHABI, Section 5:
7087 An index table entry consists of 2 words.
7088 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
7089 if (exidx_fn & 0x80000000)
7090 warn (_("corrupt index table entry: %x\n"), exidx_fn);
7092 fn = arm_expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
7094 arm_print_vma_and_name (aux, fn, fn_addr);
7095 fputs (": ", stdout);
7097 if (exidx_entry == 1)
7099 print_vma (exidx_entry, PREFIX_HEX);
7100 fputs (" [cantunwind]\n", stdout);
7102 else if (exidx_entry & 0x80000000)
7104 print_vma (exidx_entry, PREFIX_HEX);
7105 fputc ('\n', stdout);
7106 decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
7110 bfd_vma table, table_offset = 0;
7111 Elf_Internal_Shdr *table_sec;
7113 fputs ("@", stdout);
7114 table = arm_expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
7115 print_vma (table, PREFIX_HEX);
7118 /* Locate the matching .ARM.extab. */
7119 if (entry_addr.section != SHN_UNDEF
7120 && entry_addr.section < elf_header.e_shnum)
7122 table_sec = section_headers + entry_addr.section;
7123 table_offset = entry_addr.offset;
7127 table_sec = find_section_by_address (table);
7128 if (table_sec != NULL)
7129 table_offset = table - table_sec->sh_addr;
7131 if (table_sec == NULL)
7133 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
7134 (unsigned long) table);
7137 decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
7144 arm_free_section (&exidx_arm_sec);
7145 arm_free_section (&extab_arm_sec);
7148 /* Used for both ARM and C6X unwinding tables. */
7151 arm_process_unwind (FILE *file)
7153 struct arm_unw_aux_info aux;
7154 Elf_Internal_Shdr *unwsec = NULL;
7155 Elf_Internal_Shdr *strsec;
7156 Elf_Internal_Shdr *sec;
7158 unsigned int sec_type;
7160 switch (elf_header.e_machine)
7163 sec_type = SHT_ARM_EXIDX;
7167 sec_type = SHT_C6000_UNWIND;
7171 error (_("Unsupported architecture type %d encountered when processing unwind table"),
7172 elf_header.e_machine);
7176 if (string_table == NULL)
7179 memset (& aux, 0, sizeof (aux));
7182 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7184 if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
7186 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
7188 strsec = section_headers + sec->sh_link;
7189 assert (aux.strtab == NULL);
7190 aux.strtab = get_data (NULL, file, strsec->sh_offset,
7191 1, strsec->sh_size, _("string table"));
7192 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7194 else if (sec->sh_type == sec_type)
7199 printf (_("\nThere are no unwind sections in this file.\n"));
7201 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7203 if (sec->sh_type == sec_type)
7205 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
7207 (unsigned long) sec->sh_offset,
7208 (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
7210 dump_arm_unwind (&aux, sec);
7217 free ((char *) aux.strtab);
7221 process_unwind (FILE * file)
7223 struct unwind_handler
7226 void (* handler)(FILE *);
7229 { EM_ARM, arm_process_unwind },
7230 { EM_IA_64, ia64_process_unwind },
7231 { EM_PARISC, hppa_process_unwind },
7232 { EM_TI_C6000, arm_process_unwind },
7240 for (i = 0; handlers[i].handler != NULL; i++)
7241 if (elf_header.e_machine == handlers[i].machtype)
7242 return handlers[i].handler (file);
7244 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
7245 get_machine_name (elf_header.e_machine));
7249 dynamic_section_mips_val (Elf_Internal_Dyn * entry)
7251 switch (entry->d_tag)
7254 if (entry->d_un.d_val == 0)
7258 static const char * opts[] =
7260 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
7261 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
7262 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
7263 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
7269 for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
7270 if (entry->d_un.d_val & (1 << cnt))
7272 printf ("%s%s", first ? "" : " ", opts[cnt]);
7278 case DT_MIPS_IVERSION:
7279 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
7280 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
7282 printf (_("<corrupt: %" BFD_VMA_FMT "d>"), entry->d_un.d_ptr);
7285 case DT_MIPS_TIME_STAMP:
7290 time_t atime = entry->d_un.d_val;
7291 tmp = gmtime (&atime);
7292 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
7293 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
7294 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
7295 printf (_("Time Stamp: %s"), timebuf);
7299 case DT_MIPS_RLD_VERSION:
7300 case DT_MIPS_LOCAL_GOTNO:
7301 case DT_MIPS_CONFLICTNO:
7302 case DT_MIPS_LIBLISTNO:
7303 case DT_MIPS_SYMTABNO:
7304 case DT_MIPS_UNREFEXTNO:
7305 case DT_MIPS_HIPAGENO:
7306 case DT_MIPS_DELTA_CLASS_NO:
7307 case DT_MIPS_DELTA_INSTANCE_NO:
7308 case DT_MIPS_DELTA_RELOC_NO:
7309 case DT_MIPS_DELTA_SYM_NO:
7310 case DT_MIPS_DELTA_CLASSSYM_NO:
7311 case DT_MIPS_COMPACT_SIZE:
7312 print_vma (entry->d_un.d_ptr, DEC);
7316 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7322 dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
7324 switch (entry->d_tag)
7326 case DT_HP_DLD_FLAGS:
7335 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
7336 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
7337 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
7338 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
7339 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
7340 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
7341 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
7342 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
7343 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
7344 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
7345 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
7346 { DT_HP_GST, "HP_GST" },
7347 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
7348 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
7349 { DT_HP_NODELETE, "HP_NODELETE" },
7350 { DT_HP_GROUP, "HP_GROUP" },
7351 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
7355 bfd_vma val = entry->d_un.d_val;
7357 for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
7358 if (val & flags[cnt].bit)
7362 fputs (flags[cnt].str, stdout);
7364 val ^= flags[cnt].bit;
7367 if (val != 0 || first)
7371 print_vma (val, HEX);
7377 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7385 /* VMS vs Unix time offset and factor. */
7387 #define VMS_EPOCH_OFFSET 35067168000000000LL
7388 #define VMS_GRANULARITY_FACTOR 10000000
7390 /* Display a VMS time in a human readable format. */
7393 print_vms_time (bfd_int64_t vmstime)
7398 unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
7399 tm = gmtime (&unxtime);
7400 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
7401 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
7402 tm->tm_hour, tm->tm_min, tm->tm_sec);
7407 dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
7409 switch (entry->d_tag)
7411 case DT_IA_64_PLT_RESERVE:
7412 /* First 3 slots reserved. */
7413 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7415 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
7418 case DT_IA_64_VMS_LINKTIME:
7420 print_vms_time (entry->d_un.d_val);
7424 case DT_IA_64_VMS_LNKFLAGS:
7425 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7426 if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
7427 printf (" CALL_DEBUG");
7428 if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
7429 printf (" NOP0BUFS");
7430 if (entry->d_un.d_val & VMS_LF_P0IMAGE)
7431 printf (" P0IMAGE");
7432 if (entry->d_un.d_val & VMS_LF_MKTHREADS)
7433 printf (" MKTHREADS");
7434 if (entry->d_un.d_val & VMS_LF_UPCALLS)
7435 printf (" UPCALLS");
7436 if (entry->d_un.d_val & VMS_LF_IMGSTA)
7438 if (entry->d_un.d_val & VMS_LF_INITIALIZE)
7439 printf (" INITIALIZE");
7440 if (entry->d_un.d_val & VMS_LF_MAIN)
7442 if (entry->d_un.d_val & VMS_LF_EXE_INIT)
7443 printf (" EXE_INIT");
7444 if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
7445 printf (" TBK_IN_IMG");
7446 if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
7447 printf (" DBG_IN_IMG");
7448 if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
7449 printf (" TBK_IN_DSF");
7450 if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
7451 printf (" DBG_IN_DSF");
7452 if (entry->d_un.d_val & VMS_LF_SIGNATURES)
7453 printf (" SIGNATURES");
7454 if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
7455 printf (" REL_SEG_OFF");
7459 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7466 get_32bit_dynamic_section (FILE * file)
7468 Elf32_External_Dyn * edyn;
7469 Elf32_External_Dyn * ext;
7470 Elf_Internal_Dyn * entry;
7472 edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
7473 dynamic_size, _("dynamic section"));
7477 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
7478 might not have the luxury of section headers. Look for the DT_NULL
7479 terminator to determine the number of entries. */
7480 for (ext = edyn, dynamic_nent = 0;
7481 (char *) ext < (char *) edyn + dynamic_size;
7485 if (BYTE_GET (ext->d_tag) == DT_NULL)
7489 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
7491 if (dynamic_section == NULL)
7493 error (_("Out of memory\n"));
7498 for (ext = edyn, entry = dynamic_section;
7499 entry < dynamic_section + dynamic_nent;
7502 entry->d_tag = BYTE_GET (ext->d_tag);
7503 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
7512 get_64bit_dynamic_section (FILE * file)
7514 Elf64_External_Dyn * edyn;
7515 Elf64_External_Dyn * ext;
7516 Elf_Internal_Dyn * entry;
7518 edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
7519 dynamic_size, _("dynamic section"));
7523 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
7524 might not have the luxury of section headers. Look for the DT_NULL
7525 terminator to determine the number of entries. */
7526 for (ext = edyn, dynamic_nent = 0;
7527 (char *) ext < (char *) edyn + dynamic_size;
7531 if (BYTE_GET (ext->d_tag) == DT_NULL)
7535 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
7537 if (dynamic_section == NULL)
7539 error (_("Out of memory\n"));
7544 for (ext = edyn, entry = dynamic_section;
7545 entry < dynamic_section + dynamic_nent;
7548 entry->d_tag = BYTE_GET (ext->d_tag);
7549 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
7558 print_dynamic_flags (bfd_vma flags)
7566 flag = flags & - flags;
7576 case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
7577 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
7578 case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
7579 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
7580 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
7581 default: fputs (_("unknown"), stdout); break;
7587 /* Parse and display the contents of the dynamic section. */
7590 process_dynamic_section (FILE * file)
7592 Elf_Internal_Dyn * entry;
7594 if (dynamic_size == 0)
7597 printf (_("\nThere is no dynamic section in this file.\n"));
7604 if (! get_32bit_dynamic_section (file))
7607 else if (! get_64bit_dynamic_section (file))
7610 /* Find the appropriate symbol table. */
7611 if (dynamic_symbols == NULL)
7613 for (entry = dynamic_section;
7614 entry < dynamic_section + dynamic_nent;
7617 Elf_Internal_Shdr section;
7619 if (entry->d_tag != DT_SYMTAB)
7622 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
7624 /* Since we do not know how big the symbol table is,
7625 we default to reading in the entire file (!) and
7626 processing that. This is overkill, I know, but it
7628 section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
7630 if (archive_file_offset != 0)
7631 section.sh_size = archive_file_size - section.sh_offset;
7634 if (fseek (file, 0, SEEK_END))
7635 error (_("Unable to seek to end of file!\n"));
7637 section.sh_size = ftell (file) - section.sh_offset;
7641 section.sh_entsize = sizeof (Elf32_External_Sym);
7643 section.sh_entsize = sizeof (Elf64_External_Sym);
7645 dynamic_symbols = GET_ELF_SYMBOLS (file, §ion, & num_dynamic_syms);
7646 if (num_dynamic_syms < 1)
7648 error (_("Unable to determine the number of symbols to load\n"));
7654 /* Similarly find a string table. */
7655 if (dynamic_strings == NULL)
7657 for (entry = dynamic_section;
7658 entry < dynamic_section + dynamic_nent;
7661 unsigned long offset;
7664 if (entry->d_tag != DT_STRTAB)
7667 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
7669 /* Since we do not know how big the string table is,
7670 we default to reading in the entire file (!) and
7671 processing that. This is overkill, I know, but it
7674 offset = offset_from_vma (file, entry->d_un.d_val, 0);
7676 if (archive_file_offset != 0)
7677 str_tab_len = archive_file_size - offset;
7680 if (fseek (file, 0, SEEK_END))
7681 error (_("Unable to seek to end of file\n"));
7682 str_tab_len = ftell (file) - offset;
7685 if (str_tab_len < 1)
7688 (_("Unable to determine the length of the dynamic string table\n"));
7692 dynamic_strings = (char *) get_data (NULL, file, offset, 1,
7694 _("dynamic string table"));
7695 dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
7700 /* And find the syminfo section if available. */
7701 if (dynamic_syminfo == NULL)
7703 unsigned long syminsz = 0;
7705 for (entry = dynamic_section;
7706 entry < dynamic_section + dynamic_nent;
7709 if (entry->d_tag == DT_SYMINENT)
7711 /* Note: these braces are necessary to avoid a syntax
7712 error from the SunOS4 C compiler. */
7713 assert (sizeof (Elf_External_Syminfo) == entry->d_un.d_val);
7715 else if (entry->d_tag == DT_SYMINSZ)
7716 syminsz = entry->d_un.d_val;
7717 else if (entry->d_tag == DT_SYMINFO)
7718 dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
7722 if (dynamic_syminfo_offset != 0 && syminsz != 0)
7724 Elf_External_Syminfo * extsyminfo;
7725 Elf_External_Syminfo * extsym;
7726 Elf_Internal_Syminfo * syminfo;
7728 /* There is a syminfo section. Read the data. */
7729 extsyminfo = (Elf_External_Syminfo *)
7730 get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
7731 _("symbol information"));
7735 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
7736 if (dynamic_syminfo == NULL)
7738 error (_("Out of memory\n"));
7742 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
7743 for (syminfo = dynamic_syminfo, extsym = extsyminfo;
7744 syminfo < dynamic_syminfo + dynamic_syminfo_nent;
7745 ++syminfo, ++extsym)
7747 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
7748 syminfo->si_flags = BYTE_GET (extsym->si_flags);
7755 if (do_dynamic && dynamic_addr)
7756 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
7757 dynamic_addr, dynamic_nent);
7759 printf (_(" Tag Type Name/Value\n"));
7761 for (entry = dynamic_section;
7762 entry < dynamic_section + dynamic_nent;
7770 print_vma (entry->d_tag, FULL_HEX);
7771 dtype = get_dynamic_type (entry->d_tag);
7772 printf (" (%s)%*s", dtype,
7773 ((is_32bit_elf ? 27 : 19)
7774 - (int) strlen (dtype)),
7778 switch (entry->d_tag)
7782 print_dynamic_flags (entry->d_un.d_val);
7792 switch (entry->d_tag)
7795 printf (_("Auxiliary library"));
7799 printf (_("Filter library"));
7803 printf (_("Configuration file"));
7807 printf (_("Dependency audit library"));
7811 printf (_("Audit library"));
7815 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
7816 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
7820 print_vma (entry->d_un.d_val, PREFIX_HEX);
7829 printf (_("Flags:"));
7831 if (entry->d_un.d_val == 0)
7832 printf (_(" None\n"));
7835 unsigned long int val = entry->d_un.d_val;
7837 if (val & DTF_1_PARINIT)
7839 printf (" PARINIT");
7840 val ^= DTF_1_PARINIT;
7842 if (val & DTF_1_CONFEXP)
7844 printf (" CONFEXP");
7845 val ^= DTF_1_CONFEXP;
7848 printf (" %lx", val);
7857 printf (_("Flags:"));
7859 if (entry->d_un.d_val == 0)
7860 printf (_(" None\n"));
7863 unsigned long int val = entry->d_un.d_val;
7865 if (val & DF_P1_LAZYLOAD)
7867 printf (" LAZYLOAD");
7868 val ^= DF_P1_LAZYLOAD;
7870 if (val & DF_P1_GROUPPERM)
7872 printf (" GROUPPERM");
7873 val ^= DF_P1_GROUPPERM;
7876 printf (" %lx", val);
7885 printf (_("Flags:"));
7886 if (entry->d_un.d_val == 0)
7887 printf (_(" None\n"));
7890 unsigned long int val = entry->d_un.d_val;
7897 if (val & DF_1_GLOBAL)
7902 if (val & DF_1_GROUP)
7907 if (val & DF_1_NODELETE)
7909 printf (" NODELETE");
7910 val ^= DF_1_NODELETE;
7912 if (val & DF_1_LOADFLTR)
7914 printf (" LOADFLTR");
7915 val ^= DF_1_LOADFLTR;
7917 if (val & DF_1_INITFIRST)
7919 printf (" INITFIRST");
7920 val ^= DF_1_INITFIRST;
7922 if (val & DF_1_NOOPEN)
7927 if (val & DF_1_ORIGIN)
7932 if (val & DF_1_DIRECT)
7937 if (val & DF_1_TRANS)
7942 if (val & DF_1_INTERPOSE)
7944 printf (" INTERPOSE");
7945 val ^= DF_1_INTERPOSE;
7947 if (val & DF_1_NODEFLIB)
7949 printf (" NODEFLIB");
7950 val ^= DF_1_NODEFLIB;
7952 if (val & DF_1_NODUMP)
7957 if (val & DF_1_CONLFAT)
7959 printf (" CONLFAT");
7960 val ^= DF_1_CONLFAT;
7963 printf (" %lx", val);
7970 dynamic_info[entry->d_tag] = entry->d_un.d_val;
7972 puts (get_dynamic_type (entry->d_un.d_val));
7992 dynamic_info[entry->d_tag] = entry->d_un.d_val;
7998 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
7999 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
8005 switch (entry->d_tag)
8008 printf (_("Shared library: [%s]"), name);
8010 if (streq (name, program_interpreter))
8011 printf (_(" program interpreter"));
8015 printf (_("Library soname: [%s]"), name);
8019 printf (_("Library rpath: [%s]"), name);
8023 printf (_("Library runpath: [%s]"), name);
8027 print_vma (entry->d_un.d_val, PREFIX_HEX);
8032 print_vma (entry->d_un.d_val, PREFIX_HEX);
8045 dynamic_info[entry->d_tag] = entry->d_un.d_val;
8049 case DT_INIT_ARRAYSZ:
8050 case DT_FINI_ARRAYSZ:
8051 case DT_GNU_CONFLICTSZ:
8052 case DT_GNU_LIBLISTSZ:
8055 print_vma (entry->d_un.d_val, UNSIGNED);
8056 printf (_(" (bytes)\n"));
8066 print_vma (entry->d_un.d_val, UNSIGNED);
8079 if (entry->d_tag == DT_USED
8080 && VALID_DYNAMIC_NAME (entry->d_un.d_val))
8082 char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
8086 printf (_("Not needed object: [%s]\n"), name);
8091 print_vma (entry->d_un.d_val, PREFIX_HEX);
8097 /* The value of this entry is ignored. */
8102 case DT_GNU_PRELINKED:
8106 time_t atime = entry->d_un.d_val;
8108 tmp = gmtime (&atime);
8109 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
8110 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
8111 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
8117 dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
8120 print_vma (entry->d_un.d_val, PREFIX_HEX);
8126 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
8127 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
8132 switch (elf_header.e_machine)
8135 case EM_MIPS_RS3_LE:
8136 dynamic_section_mips_val (entry);
8139 dynamic_section_parisc_val (entry);
8142 dynamic_section_ia64_val (entry);
8145 print_vma (entry->d_un.d_val, PREFIX_HEX);
8157 get_ver_flags (unsigned int flags)
8159 static char buff[32];
8166 if (flags & VER_FLG_BASE)
8167 strcat (buff, "BASE ");
8169 if (flags & VER_FLG_WEAK)
8171 if (flags & VER_FLG_BASE)
8172 strcat (buff, "| ");
8174 strcat (buff, "WEAK ");
8177 if (flags & VER_FLG_INFO)
8179 if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
8180 strcat (buff, "| ");
8182 strcat (buff, "INFO ");
8185 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
8186 strcat (buff, _("| <unknown>"));
8191 /* Display the contents of the version sections. */
8194 process_version_sections (FILE * file)
8196 Elf_Internal_Shdr * section;
8203 for (i = 0, section = section_headers;
8204 i < elf_header.e_shnum;
8207 switch (section->sh_type)
8209 case SHT_GNU_verdef:
8211 Elf_External_Verdef * edefs;
8219 (_("\nVersion definition section '%s' contains %u entries:\n"),
8220 SECTION_NAME (section), section->sh_info);
8222 printf (_(" Addr: 0x"));
8223 printf_vma (section->sh_addr);
8224 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
8225 (unsigned long) section->sh_offset, section->sh_link,
8226 section->sh_link < elf_header.e_shnum
8227 ? SECTION_NAME (section_headers + section->sh_link)
8230 edefs = (Elf_External_Verdef *)
8231 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
8232 _("version definition section"));
8235 endbuf = (char *) edefs + section->sh_size;
8237 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
8240 Elf_External_Verdef * edef;
8241 Elf_Internal_Verdef ent;
8242 Elf_External_Verdaux * eaux;
8243 Elf_Internal_Verdaux aux;
8247 /* Check for negative or very large indicies. */
8248 if ((unsigned char *) edefs + idx < (unsigned char *) edefs)
8251 vstart = ((char *) edefs) + idx;
8252 if (vstart + sizeof (*edef) > endbuf)
8255 edef = (Elf_External_Verdef *) vstart;
8257 ent.vd_version = BYTE_GET (edef->vd_version);
8258 ent.vd_flags = BYTE_GET (edef->vd_flags);
8259 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
8260 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
8261 ent.vd_hash = BYTE_GET (edef->vd_hash);
8262 ent.vd_aux = BYTE_GET (edef->vd_aux);
8263 ent.vd_next = BYTE_GET (edef->vd_next);
8265 printf (_(" %#06x: Rev: %d Flags: %s"),
8266 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
8268 printf (_(" Index: %d Cnt: %d "),
8269 ent.vd_ndx, ent.vd_cnt);
8271 /* Check for overflow. */
8272 if ((unsigned char *)(vstart + ent.vd_aux) < (unsigned char *) vstart
8273 || (unsigned char *)(vstart + ent.vd_aux) > (unsigned char *) endbuf)
8276 vstart += ent.vd_aux;
8278 eaux = (Elf_External_Verdaux *) vstart;
8280 aux.vda_name = BYTE_GET (eaux->vda_name);
8281 aux.vda_next = BYTE_GET (eaux->vda_next);
8283 if (VALID_DYNAMIC_NAME (aux.vda_name))
8284 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
8286 printf (_("Name index: %ld\n"), aux.vda_name);
8288 isum = idx + ent.vd_aux;
8290 for (j = 1; j < ent.vd_cnt; j++)
8292 /* Check for overflow. */
8293 if ((unsigned char *)(vstart + aux.vda_next) < (unsigned char *) vstart
8294 || (unsigned char *)(vstart + aux.vda_next) > (unsigned char *) endbuf)
8297 isum += aux.vda_next;
8298 vstart += aux.vda_next;
8300 eaux = (Elf_External_Verdaux *) vstart;
8301 if (vstart + sizeof (*eaux) > endbuf)
8304 aux.vda_name = BYTE_GET (eaux->vda_name);
8305 aux.vda_next = BYTE_GET (eaux->vda_next);
8307 if (VALID_DYNAMIC_NAME (aux.vda_name))
8308 printf (_(" %#06x: Parent %d: %s\n"),
8309 isum, j, GET_DYNAMIC_NAME (aux.vda_name));
8311 printf (_(" %#06x: Parent %d, name index: %ld\n"),
8312 isum, j, aux.vda_name);
8316 printf (_(" Version def aux past end of section\n"));
8321 if (cnt < section->sh_info)
8322 printf (_(" Version definition past end of section\n"));
8328 case SHT_GNU_verneed:
8330 Elf_External_Verneed * eneed;
8337 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
8338 SECTION_NAME (section), section->sh_info);
8340 printf (_(" Addr: 0x"));
8341 printf_vma (section->sh_addr);
8342 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
8343 (unsigned long) section->sh_offset, section->sh_link,
8344 section->sh_link < elf_header.e_shnum
8345 ? SECTION_NAME (section_headers + section->sh_link)
8348 eneed = (Elf_External_Verneed *) get_data (NULL, file,
8349 section->sh_offset, 1,
8351 _("Version Needs section"));
8354 endbuf = (char *) eneed + section->sh_size;
8356 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
8358 Elf_External_Verneed * entry;
8359 Elf_Internal_Verneed ent;
8364 if ((unsigned char *) eneed + idx < (unsigned char *) eneed)
8367 vstart = ((char *) eneed) + idx;
8368 if (vstart + sizeof (*entry) > endbuf)
8371 entry = (Elf_External_Verneed *) vstart;
8373 ent.vn_version = BYTE_GET (entry->vn_version);
8374 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
8375 ent.vn_file = BYTE_GET (entry->vn_file);
8376 ent.vn_aux = BYTE_GET (entry->vn_aux);
8377 ent.vn_next = BYTE_GET (entry->vn_next);
8379 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
8381 if (VALID_DYNAMIC_NAME (ent.vn_file))
8382 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
8384 printf (_(" File: %lx"), ent.vn_file);
8386 printf (_(" Cnt: %d\n"), ent.vn_cnt);
8388 /* Check for overflow. */
8389 if ((unsigned char *)(vstart + ent.vn_aux) < (unsigned char *) vstart
8390 || (unsigned char *)(vstart + ent.vn_aux) > (unsigned char *) endbuf)
8393 vstart += ent.vn_aux;
8395 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
8397 Elf_External_Vernaux * eaux;
8398 Elf_Internal_Vernaux aux;
8400 if (vstart + sizeof (*eaux) > endbuf)
8402 eaux = (Elf_External_Vernaux *) vstart;
8404 aux.vna_hash = BYTE_GET (eaux->vna_hash);
8405 aux.vna_flags = BYTE_GET (eaux->vna_flags);
8406 aux.vna_other = BYTE_GET (eaux->vna_other);
8407 aux.vna_name = BYTE_GET (eaux->vna_name);
8408 aux.vna_next = BYTE_GET (eaux->vna_next);
8410 if (VALID_DYNAMIC_NAME (aux.vna_name))
8411 printf (_(" %#06x: Name: %s"),
8412 isum, GET_DYNAMIC_NAME (aux.vna_name));
8414 printf (_(" %#06x: Name index: %lx"),
8415 isum, aux.vna_name);
8417 printf (_(" Flags: %s Version: %d\n"),
8418 get_ver_flags (aux.vna_flags), aux.vna_other);
8420 /* Check for overflow. */
8421 if ((unsigned char *)(vstart + aux.vna_next) < (unsigned char *) vstart
8422 || (unsigned char *)(vstart + aux.vna_next) > (unsigned char *) endbuf)
8425 isum += aux.vna_next;
8426 vstart += aux.vna_next;
8430 warn (_("Missing Version Needs auxillary information\n"));
8435 if (cnt < section->sh_info)
8436 warn (_("Missing Version Needs information\n"));
8442 case SHT_GNU_versym:
8444 Elf_Internal_Shdr * link_section;
8447 unsigned char * edata;
8448 unsigned short * data;
8450 Elf_Internal_Sym * symbols;
8451 Elf_Internal_Shdr * string_sec;
8452 unsigned long num_syms;
8455 if (section->sh_link >= elf_header.e_shnum)
8458 link_section = section_headers + section->sh_link;
8459 total = section->sh_size / sizeof (Elf_External_Versym);
8461 if (link_section->sh_link >= elf_header.e_shnum)
8466 symbols = GET_ELF_SYMBOLS (file, link_section, & num_syms);
8467 if (symbols == NULL)
8470 string_sec = section_headers + link_section->sh_link;
8472 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
8473 string_sec->sh_size,
8474 _("version string table"));
8481 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
8482 SECTION_NAME (section), total);
8484 printf (_(" Addr: "));
8485 printf_vma (section->sh_addr);
8486 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
8487 (unsigned long) section->sh_offset, section->sh_link,
8488 SECTION_NAME (link_section));
8490 off = offset_from_vma (file,
8491 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
8492 total * sizeof (short));
8493 edata = (unsigned char *) get_data (NULL, file, off, total,
8495 _("version symbol data"));
8503 data = (short unsigned int *) cmalloc (total, sizeof (short));
8505 for (cnt = total; cnt --;)
8506 data[cnt] = byte_get (edata + cnt * sizeof (short),
8511 for (cnt = 0; cnt < total; cnt += 4)
8514 int check_def, check_need;
8517 printf (" %03x:", cnt);
8519 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
8520 switch (data[cnt + j])
8523 fputs (_(" 0 (*local*) "), stdout);
8527 fputs (_(" 1 (*global*) "), stdout);
8531 nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
8532 data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
8534 /* If this index value is greater than the size of the symbols
8535 array, break to avoid an out-of-bounds read. */
8536 if ((unsigned long)(cnt + j) >= num_syms)
8538 warn (_("invalid index into symbol array\n"));
8544 if (symbols[cnt + j].st_shndx >= elf_header.e_shnum
8545 || section_headers[symbols[cnt + j].st_shndx].sh_type
8548 if (symbols[cnt + j].st_shndx == SHN_UNDEF)
8555 && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
8557 Elf_Internal_Verneed ivn;
8558 unsigned long offset;
8560 offset = offset_from_vma
8561 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
8562 sizeof (Elf_External_Verneed));
8566 Elf_Internal_Vernaux ivna;
8567 Elf_External_Verneed evn;
8568 Elf_External_Vernaux evna;
8569 unsigned long a_off;
8571 if (get_data (&evn, file, offset, sizeof (evn), 1,
8572 _("version need")) == NULL)
8575 ivn.vn_aux = BYTE_GET (evn.vn_aux);
8576 ivn.vn_next = BYTE_GET (evn.vn_next);
8578 a_off = offset + ivn.vn_aux;
8582 if (get_data (&evna, file, a_off, sizeof (evna),
8583 1, _("version need aux (2)")) == NULL)
8590 ivna.vna_next = BYTE_GET (evna.vna_next);
8591 ivna.vna_other = BYTE_GET (evna.vna_other);
8594 a_off += ivna.vna_next;
8596 while (ivna.vna_other != data[cnt + j]
8597 && ivna.vna_next != 0);
8599 if (ivna.vna_other == data[cnt + j])
8601 ivna.vna_name = BYTE_GET (evna.vna_name);
8603 if (ivna.vna_name >= string_sec->sh_size)
8604 name = _("*invalid*");
8606 name = strtab + ivna.vna_name;
8607 nn += printf ("(%s%-*s",
8609 12 - (int) strlen (name),
8615 offset += ivn.vn_next;
8617 while (ivn.vn_next);
8620 if (check_def && data[cnt + j] != 0x8001
8621 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
8623 Elf_Internal_Verdef ivd;
8624 Elf_External_Verdef evd;
8625 unsigned long offset;
8627 offset = offset_from_vma
8628 (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
8633 if (get_data (&evd, file, offset, sizeof (evd), 1,
8634 _("version def")) == NULL)
8641 ivd.vd_next = BYTE_GET (evd.vd_next);
8642 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
8645 offset += ivd.vd_next;
8647 while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
8648 && ivd.vd_next != 0);
8650 if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
8652 Elf_External_Verdaux evda;
8653 Elf_Internal_Verdaux ivda;
8655 ivd.vd_aux = BYTE_GET (evd.vd_aux);
8657 if (get_data (&evda, file,
8658 offset - ivd.vd_next + ivd.vd_aux,
8660 _("version def aux")) == NULL)
8663 ivda.vda_name = BYTE_GET (evda.vda_name);
8665 if (ivda.vda_name >= string_sec->sh_size)
8666 name = _("*invalid*");
8668 name = strtab + ivda.vda_name;
8669 nn += printf ("(%s%-*s",
8671 12 - (int) strlen (name),
8677 printf ("%*c", 18 - nn, ' ');
8695 printf (_("\nNo version information found in this file.\n"));
8701 get_symbol_binding (unsigned int binding)
8703 static char buff[32];
8707 case STB_LOCAL: return "LOCAL";
8708 case STB_GLOBAL: return "GLOBAL";
8709 case STB_WEAK: return "WEAK";
8711 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
8712 snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
8714 else if (binding >= STB_LOOS && binding <= STB_HIOS)
8716 if (binding == STB_GNU_UNIQUE
8717 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
8718 /* GNU is still using the default value 0. */
8719 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
8721 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
8724 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
8730 get_symbol_type (unsigned int type)
8732 static char buff[32];
8736 case STT_NOTYPE: return "NOTYPE";
8737 case STT_OBJECT: return "OBJECT";
8738 case STT_FUNC: return "FUNC";
8739 case STT_SECTION: return "SECTION";
8740 case STT_FILE: return "FILE";
8741 case STT_COMMON: return "COMMON";
8742 case STT_TLS: return "TLS";
8743 case STT_RELC: return "RELC";
8744 case STT_SRELC: return "SRELC";
8746 if (type >= STT_LOPROC && type <= STT_HIPROC)
8748 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
8749 return "THUMB_FUNC";
8751 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
8754 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
8755 return "PARISC_MILLI";
8757 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
8759 else if (type >= STT_LOOS && type <= STT_HIOS)
8761 if (elf_header.e_machine == EM_PARISC)
8763 if (type == STT_HP_OPAQUE)
8765 if (type == STT_HP_STUB)
8769 if (type == STT_GNU_IFUNC
8770 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
8771 || elf_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
8772 /* GNU is still using the default value 0. */
8773 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
8776 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
8779 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
8785 get_symbol_visibility (unsigned int visibility)
8789 case STV_DEFAULT: return "DEFAULT";
8790 case STV_INTERNAL: return "INTERNAL";
8791 case STV_HIDDEN: return "HIDDEN";
8792 case STV_PROTECTED: return "PROTECTED";
8798 get_mips_symbol_other (unsigned int other)
8810 case STO_MICROMIPS | STO_MIPS_PIC:
8811 return "MICROMIPS, MIPS PIC";
8820 get_ia64_symbol_other (unsigned int other)
8824 static char res[32];
8828 /* Function types is for images and .STB files only. */
8829 switch (elf_header.e_type)
8833 switch (VMS_ST_FUNC_TYPE (other))
8835 case VMS_SFT_CODE_ADDR:
8836 strcat (res, " CA");
8838 case VMS_SFT_SYMV_IDX:
8839 strcat (res, " VEC");
8842 strcat (res, " FD");
8844 case VMS_SFT_RESERVE:
8845 strcat (res, " RSV");
8854 switch (VMS_ST_LINKAGE (other))
8856 case VMS_STL_IGNORE:
8857 strcat (res, " IGN");
8859 case VMS_STL_RESERVE:
8860 strcat (res, " RSV");
8863 strcat (res, " STD");
8866 strcat (res, " LNK");
8881 get_symbol_other (unsigned int other)
8883 const char * result = NULL;
8884 static char buff [32];
8889 switch (elf_header.e_machine)
8892 result = get_mips_symbol_other (other);
8895 result = get_ia64_symbol_other (other);
8904 snprintf (buff, sizeof buff, _("<other>: %x"), other);
8909 get_symbol_index_type (unsigned int type)
8911 static char buff[32];
8915 case SHN_UNDEF: return "UND";
8916 case SHN_ABS: return "ABS";
8917 case SHN_COMMON: return "COM";
8919 if (type == SHN_IA_64_ANSI_COMMON
8920 && elf_header.e_machine == EM_IA_64
8921 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
8923 else if ((elf_header.e_machine == EM_X86_64
8924 || elf_header.e_machine == EM_L1OM
8925 || elf_header.e_machine == EM_K1OM)
8926 && type == SHN_X86_64_LCOMMON)
8928 else if ((type == SHN_MIPS_SCOMMON
8929 && elf_header.e_machine == EM_MIPS)
8930 || (type == SHN_TIC6X_SCOMMON
8931 && elf_header.e_machine == EM_TI_C6000))
8933 else if (type == SHN_MIPS_SUNDEFINED
8934 && elf_header.e_machine == EM_MIPS)
8936 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
8937 sprintf (buff, "PRC[0x%04x]", type & 0xffff);
8938 else if (type >= SHN_LOOS && type <= SHN_HIOS)
8939 sprintf (buff, "OS [0x%04x]", type & 0xffff);
8940 else if (type >= SHN_LORESERVE)
8941 sprintf (buff, "RSV[0x%04x]", type & 0xffff);
8943 sprintf (buff, "%3d", type);
8951 get_dynamic_data (FILE * file, unsigned int number, unsigned int ent_size)
8953 unsigned char * e_data;
8956 e_data = (unsigned char *) cmalloc (number, ent_size);
8960 error (_("Out of memory\n"));
8964 if (fread (e_data, ent_size, number, file) != number)
8966 error (_("Unable to read in dynamic data\n"));
8970 i_data = (bfd_vma *) cmalloc (number, sizeof (*i_data));
8974 error (_("Out of memory\n"));
8980 i_data[number] = byte_get (e_data + number * ent_size, ent_size);
8988 print_dynamic_symbol (bfd_vma si, unsigned long hn)
8990 Elf_Internal_Sym * psym;
8993 psym = dynamic_symbols + si;
8995 n = print_vma (si, DEC_5);
8997 fputs (" " + n, stdout);
8998 printf (" %3lu: ", hn);
8999 print_vma (psym->st_value, LONG_HEX);
9001 print_vma (psym->st_size, DEC_5);
9003 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
9004 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
9005 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
9006 /* Check to see if any other bits in the st_other field are set.
9007 Note - displaying this information disrupts the layout of the
9008 table being generated, but for the moment this case is very
9010 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
9011 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
9012 printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
9013 if (VALID_DYNAMIC_NAME (psym->st_name))
9014 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
9016 printf (_(" <corrupt: %14ld>"), psym->st_name);
9020 /* Dump the symbol table. */
9022 process_symbol_table (FILE * file)
9024 Elf_Internal_Shdr * section;
9025 bfd_vma nbuckets = 0;
9026 bfd_vma nchains = 0;
9027 bfd_vma * buckets = NULL;
9028 bfd_vma * chains = NULL;
9029 bfd_vma ngnubuckets = 0;
9030 bfd_vma * gnubuckets = NULL;
9031 bfd_vma * gnuchains = NULL;
9032 bfd_vma gnusymidx = 0;
9034 if (!do_syms && !do_dyn_syms && !do_histogram)
9037 if (dynamic_info[DT_HASH]
9039 || (do_using_dynamic
9041 && dynamic_strings != NULL)))
9043 unsigned char nb[8];
9044 unsigned char nc[8];
9045 int hash_ent_size = 4;
9047 if ((elf_header.e_machine == EM_ALPHA
9048 || elf_header.e_machine == EM_S390
9049 || elf_header.e_machine == EM_S390_OLD)
9050 && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
9054 (archive_file_offset
9055 + offset_from_vma (file, dynamic_info[DT_HASH],
9056 sizeof nb + sizeof nc)),
9059 error (_("Unable to seek to start of dynamic information\n"));
9063 if (fread (nb, hash_ent_size, 1, file) != 1)
9065 error (_("Failed to read in number of buckets\n"));
9069 if (fread (nc, hash_ent_size, 1, file) != 1)
9071 error (_("Failed to read in number of chains\n"));
9075 nbuckets = byte_get (nb, hash_ent_size);
9076 nchains = byte_get (nc, hash_ent_size);
9078 buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
9079 chains = get_dynamic_data (file, nchains, hash_ent_size);
9082 if (buckets == NULL || chains == NULL)
9084 if (do_using_dynamic)
9095 if (dynamic_info_DT_GNU_HASH
9097 || (do_using_dynamic
9099 && dynamic_strings != NULL)))
9101 unsigned char nb[16];
9102 bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
9103 bfd_vma buckets_vma;
9106 (archive_file_offset
9107 + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
9111 error (_("Unable to seek to start of dynamic information\n"));
9115 if (fread (nb, 16, 1, file) != 1)
9117 error (_("Failed to read in number of buckets\n"));
9121 ngnubuckets = byte_get (nb, 4);
9122 gnusymidx = byte_get (nb + 4, 4);
9123 bitmaskwords = byte_get (nb + 8, 4);
9124 buckets_vma = dynamic_info_DT_GNU_HASH + 16;
9126 buckets_vma += bitmaskwords * 4;
9128 buckets_vma += bitmaskwords * 8;
9131 (archive_file_offset
9132 + offset_from_vma (file, buckets_vma, 4)),
9135 error (_("Unable to seek to start of dynamic information\n"));
9139 gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
9141 if (gnubuckets == NULL)
9144 for (i = 0; i < ngnubuckets; i++)
9145 if (gnubuckets[i] != 0)
9147 if (gnubuckets[i] < gnusymidx)
9150 if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
9151 maxchain = gnubuckets[i];
9154 if (maxchain == 0xffffffff)
9157 maxchain -= gnusymidx;
9160 (archive_file_offset
9161 + offset_from_vma (file, buckets_vma
9162 + 4 * (ngnubuckets + maxchain), 4)),
9165 error (_("Unable to seek to start of dynamic information\n"));
9171 if (fread (nb, 4, 1, file) != 1)
9173 error (_("Failed to determine last chain length\n"));
9177 if (maxchain + 1 == 0)
9182 while ((byte_get (nb, 4) & 1) == 0);
9185 (archive_file_offset
9186 + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
9189 error (_("Unable to seek to start of dynamic information\n"));
9193 gnuchains = get_dynamic_data (file, maxchain, 4);
9196 if (gnuchains == NULL)
9201 if (do_using_dynamic)
9206 if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
9209 && dynamic_strings != NULL)
9213 if (dynamic_info[DT_HASH])
9217 printf (_("\nSymbol table for image:\n"));
9219 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9221 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9223 for (hn = 0; hn < nbuckets; hn++)
9228 for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
9229 print_dynamic_symbol (si, hn);
9233 if (dynamic_info_DT_GNU_HASH)
9235 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
9237 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9239 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9241 for (hn = 0; hn < ngnubuckets; ++hn)
9242 if (gnubuckets[hn] != 0)
9244 bfd_vma si = gnubuckets[hn];
9245 bfd_vma off = si - gnusymidx;
9249 print_dynamic_symbol (si, hn);
9252 while ((gnuchains[off++] & 1) == 0);
9256 else if (do_dyn_syms || (do_syms && !do_using_dynamic))
9260 for (i = 0, section = section_headers;
9261 i < elf_header.e_shnum;
9265 char * strtab = NULL;
9266 unsigned long int strtab_size = 0;
9267 Elf_Internal_Sym * symtab;
9268 Elf_Internal_Sym * psym;
9269 unsigned long num_syms;
9271 if ((section->sh_type != SHT_SYMTAB
9272 && section->sh_type != SHT_DYNSYM)
9274 && section->sh_type == SHT_SYMTAB))
9277 if (section->sh_entsize == 0)
9279 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
9280 SECTION_NAME (section));
9284 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
9285 SECTION_NAME (section),
9286 (unsigned long) (section->sh_size / section->sh_entsize));
9289 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
9291 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
9293 symtab = GET_ELF_SYMBOLS (file, section, & num_syms);
9297 if (section->sh_link == elf_header.e_shstrndx)
9299 strtab = string_table;
9300 strtab_size = string_table_length;
9302 else if (section->sh_link < elf_header.e_shnum)
9304 Elf_Internal_Shdr * string_sec;
9306 string_sec = section_headers + section->sh_link;
9308 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
9309 1, string_sec->sh_size,
9311 strtab_size = strtab != NULL ? string_sec->sh_size : 0;
9314 for (si = 0, psym = symtab; si < num_syms; si++, psym++)
9316 printf ("%6d: ", si);
9317 print_vma (psym->st_value, LONG_HEX);
9319 print_vma (psym->st_size, DEC_5);
9320 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
9321 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
9322 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
9323 /* Check to see if any other bits in the st_other field are set.
9324 Note - displaying this information disrupts the layout of the
9325 table being generated, but for the moment this case is very rare. */
9326 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
9327 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
9328 printf (" %4s ", get_symbol_index_type (psym->st_shndx));
9329 print_symbol (25, psym->st_name < strtab_size
9330 ? strtab + psym->st_name : _("<corrupt>"));
9332 if (section->sh_type == SHT_DYNSYM
9333 && version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
9335 unsigned char data[2];
9336 unsigned short vers_data;
9337 unsigned long offset;
9341 offset = offset_from_vma
9342 (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
9343 sizeof data + si * sizeof (vers_data));
9345 if (get_data (&data, file, offset + si * sizeof (vers_data),
9346 sizeof (data), 1, _("version data")) == NULL)
9349 vers_data = byte_get (data, 2);
9351 is_nobits = (psym->st_shndx < elf_header.e_shnum
9352 && section_headers[psym->st_shndx].sh_type
9355 check_def = (psym->st_shndx != SHN_UNDEF);
9357 if ((vers_data & VERSYM_HIDDEN) || vers_data > 1)
9359 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
9360 && (is_nobits || ! check_def))
9362 Elf_External_Verneed evn;
9363 Elf_Internal_Verneed ivn;
9364 Elf_Internal_Vernaux ivna;
9366 /* We must test both. */
9367 offset = offset_from_vma
9368 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
9373 unsigned long vna_off;
9375 if (get_data (&evn, file, offset, sizeof (evn), 1,
9376 _("version need")) == NULL)
9384 ivn.vn_aux = BYTE_GET (evn.vn_aux);
9385 ivn.vn_next = BYTE_GET (evn.vn_next);
9387 vna_off = offset + ivn.vn_aux;
9391 Elf_External_Vernaux evna;
9393 if (get_data (&evna, file, vna_off,
9395 _("version need aux (3)")) == NULL)
9403 ivna.vna_other = BYTE_GET (evna.vna_other);
9404 ivna.vna_next = BYTE_GET (evna.vna_next);
9405 ivna.vna_name = BYTE_GET (evna.vna_name);
9408 vna_off += ivna.vna_next;
9410 while (ivna.vna_other != vers_data
9411 && ivna.vna_next != 0);
9413 if (ivna.vna_other == vers_data)
9416 offset += ivn.vn_next;
9418 while (ivn.vn_next != 0);
9420 if (ivna.vna_other == vers_data)
9423 ivna.vna_name < strtab_size
9424 ? strtab + ivna.vna_name : _("<corrupt>"),
9428 else if (! is_nobits)
9429 error (_("bad dynamic symbol\n"));
9436 if (vers_data != 0x8001
9437 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
9439 Elf_Internal_Verdef ivd;
9440 Elf_Internal_Verdaux ivda;
9441 Elf_External_Verdaux evda;
9444 off = offset_from_vma
9446 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
9447 sizeof (Elf_External_Verdef));
9451 Elf_External_Verdef evd;
9453 if (get_data (&evd, file, off, sizeof (evd),
9454 1, _("version def")) == NULL)
9462 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
9463 ivd.vd_aux = BYTE_GET (evd.vd_aux);
9464 ivd.vd_next = BYTE_GET (evd.vd_next);
9469 while (ivd.vd_ndx != (vers_data & VERSYM_VERSION)
9470 && ivd.vd_next != 0);
9475 if (get_data (&evda, file, off, sizeof (evda),
9476 1, _("version def aux")) == NULL)
9479 ivda.vda_name = BYTE_GET (evda.vda_name);
9481 if (psym->st_name != ivda.vda_name)
9482 printf ((vers_data & VERSYM_HIDDEN)
9484 ivda.vda_name < strtab_size
9485 ? strtab + ivda.vda_name : _("<corrupt>"));
9495 if (strtab != string_table)
9501 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
9503 if (do_histogram && buckets != NULL)
9505 unsigned long * lengths;
9506 unsigned long * counts;
9509 unsigned long maxlength = 0;
9510 unsigned long nzero_counts = 0;
9511 unsigned long nsyms = 0;
9513 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
9514 (unsigned long) nbuckets);
9515 printf (_(" Length Number %% of total Coverage\n"));
9517 lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
9518 if (lengths == NULL)
9520 error (_("Out of memory\n"));
9523 for (hn = 0; hn < nbuckets; ++hn)
9525 for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
9528 if (maxlength < ++lengths[hn])
9533 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
9536 error (_("Out of memory\n"));
9540 for (hn = 0; hn < nbuckets; ++hn)
9541 ++counts[lengths[hn]];
9546 printf (" 0 %-10lu (%5.1f%%)\n",
9547 counts[0], (counts[0] * 100.0) / nbuckets);
9548 for (i = 1; i <= maxlength; ++i)
9550 nzero_counts += counts[i] * i;
9551 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
9552 i, counts[i], (counts[i] * 100.0) / nbuckets,
9553 (nzero_counts * 100.0) / nsyms);
9561 if (buckets != NULL)
9567 if (do_histogram && gnubuckets != NULL)
9569 unsigned long * lengths;
9570 unsigned long * counts;
9572 unsigned long maxlength = 0;
9573 unsigned long nzero_counts = 0;
9574 unsigned long nsyms = 0;
9576 lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
9577 if (lengths == NULL)
9579 error (_("Out of memory\n"));
9583 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
9584 (unsigned long) ngnubuckets);
9585 printf (_(" Length Number %% of total Coverage\n"));
9587 for (hn = 0; hn < ngnubuckets; ++hn)
9588 if (gnubuckets[hn] != 0)
9590 bfd_vma off, length = 1;
9592 for (off = gnubuckets[hn] - gnusymidx;
9593 (gnuchains[off] & 1) == 0; ++off)
9595 lengths[hn] = length;
9596 if (length > maxlength)
9601 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
9604 error (_("Out of memory\n"));
9608 for (hn = 0; hn < ngnubuckets; ++hn)
9609 ++counts[lengths[hn]];
9611 if (ngnubuckets > 0)
9614 printf (" 0 %-10lu (%5.1f%%)\n",
9615 counts[0], (counts[0] * 100.0) / ngnubuckets);
9616 for (j = 1; j <= maxlength; ++j)
9618 nzero_counts += counts[j] * j;
9619 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
9620 j, counts[j], (counts[j] * 100.0) / ngnubuckets,
9621 (nzero_counts * 100.0) / nsyms);
9635 process_syminfo (FILE * file ATTRIBUTE_UNUSED)
9639 if (dynamic_syminfo == NULL
9641 /* No syminfo, this is ok. */
9644 /* There better should be a dynamic symbol section. */
9645 if (dynamic_symbols == NULL || dynamic_strings == NULL)
9649 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
9650 dynamic_syminfo_offset, dynamic_syminfo_nent);
9652 printf (_(" Num: Name BoundTo Flags\n"));
9653 for (i = 0; i < dynamic_syminfo_nent; ++i)
9655 unsigned short int flags = dynamic_syminfo[i].si_flags;
9657 printf ("%4d: ", i);
9658 if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
9659 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
9661 printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
9664 switch (dynamic_syminfo[i].si_boundto)
9666 case SYMINFO_BT_SELF:
9667 fputs ("SELF ", stdout);
9669 case SYMINFO_BT_PARENT:
9670 fputs ("PARENT ", stdout);
9673 if (dynamic_syminfo[i].si_boundto > 0
9674 && dynamic_syminfo[i].si_boundto < dynamic_nent
9675 && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
9677 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
9681 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
9685 if (flags & SYMINFO_FLG_DIRECT)
9687 if (flags & SYMINFO_FLG_PASSTHRU)
9688 printf (" PASSTHRU");
9689 if (flags & SYMINFO_FLG_COPY)
9691 if (flags & SYMINFO_FLG_LAZYLOAD)
9692 printf (" LAZYLOAD");
9700 /* Check to see if the given reloc needs to be handled in a target specific
9701 manner. If so then process the reloc and return TRUE otherwise return
9705 target_specific_reloc_handling (Elf_Internal_Rela * reloc,
9706 unsigned char * start,
9707 Elf_Internal_Sym * symtab)
9709 unsigned int reloc_type = get_reloc_type (reloc->r_info);
9711 switch (elf_header.e_machine)
9714 case EM_CYGNUS_MN10300:
9716 static Elf_Internal_Sym * saved_sym = NULL;
9720 case 34: /* R_MN10300_ALIGN */
9722 case 33: /* R_MN10300_SYM_DIFF */
9723 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
9725 case 1: /* R_MN10300_32 */
9726 case 2: /* R_MN10300_16 */
9727 if (saved_sym != NULL)
9731 value = reloc->r_addend
9732 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
9733 - saved_sym->st_value);
9735 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
9742 if (saved_sym != NULL)
9743 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc"));
9753 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
9754 DWARF debug sections. This is a target specific test. Note - we do not
9755 go through the whole including-target-headers-multiple-times route, (as
9756 we have already done with <elf/h8.h>) because this would become very
9757 messy and even then this function would have to contain target specific
9758 information (the names of the relocs instead of their numeric values).
9759 FIXME: This is not the correct way to solve this problem. The proper way
9760 is to have target specific reloc sizing and typing functions created by
9761 the reloc-macros.h header, in the same way that it already creates the
9762 reloc naming functions. */
9765 is_32bit_abs_reloc (unsigned int reloc_type)
9767 switch (elf_header.e_machine)
9771 return reloc_type == 1; /* R_386_32. */
9773 return reloc_type == 1; /* R_68K_32. */
9775 return reloc_type == 1; /* R_860_32. */
9777 return reloc_type == 2; /* R_960_32. */
9779 return reloc_type == 1; /* R_ALPHA_REFLONG. */
9781 return reloc_type == 1; /* R_ARC_32. */
9783 return reloc_type == 2; /* R_ARM_ABS32 */
9786 return reloc_type == 1;
9787 case EM_ADAPTEVA_EPIPHANY:
9788 return reloc_type == 3;
9790 return reloc_type == 0x12; /* R_byte4_data. */
9792 return reloc_type == 3; /* R_CRIS_32. */
9794 return reloc_type == 3; /* R_CR16_NUM32. */
9796 return reloc_type == 15; /* R_CRX_NUM32. */
9798 return reloc_type == 1;
9799 case EM_CYGNUS_D10V:
9801 return reloc_type == 6; /* R_D10V_32. */
9802 case EM_CYGNUS_D30V:
9804 return reloc_type == 12; /* R_D30V_32_NORMAL. */
9806 return reloc_type == 3; /* R_DLX_RELOC_32. */
9807 case EM_CYGNUS_FR30:
9809 return reloc_type == 3; /* R_FR30_32. */
9813 return reloc_type == 1; /* R_H8_DIR32. */
9815 return reloc_type == 0x65; /* R_IA64_SECREL32LSB. */
9818 return reloc_type == 2; /* R_IP2K_32. */
9820 return reloc_type == 2; /* R_IQ2000_32. */
9821 case EM_LATTICEMICO32:
9822 return reloc_type == 3; /* R_LM32_32. */
9825 return reloc_type == 3; /* R_M32C_32. */
9827 return reloc_type == 34; /* R_M32R_32_RELA. */
9829 return reloc_type == 1; /* R_MCORE_ADDR32. */
9831 return reloc_type == 4; /* R_MEP_32. */
9833 return reloc_type == 1; /* R_MICROBLAZE_32. */
9835 return reloc_type == 2; /* R_MIPS_32. */
9837 return reloc_type == 4; /* R_MMIX_32. */
9838 case EM_CYGNUS_MN10200:
9840 return reloc_type == 1; /* R_MN10200_32. */
9841 case EM_CYGNUS_MN10300:
9843 return reloc_type == 1; /* R_MN10300_32. */
9845 return reloc_type == 1; /* R_MOXIE_32. */
9848 return reloc_type == 1; /* R_MSP43_32. */
9850 return reloc_type == 2; /* R_MT_32. */
9851 case EM_ALTERA_NIOS2:
9853 return reloc_type == 1; /* R_NIOS_32. */
9856 return reloc_type == 1; /* R_OR32_32. */
9858 return (reloc_type == 1 /* R_PARISC_DIR32. */
9859 || reloc_type == 41); /* R_PARISC_SECREL32. */
9862 return reloc_type == 1; /* R_PJ_DATA_DIR32. */
9864 return reloc_type == 1; /* R_PPC64_ADDR32. */
9866 return reloc_type == 1; /* R_PPC_ADDR32. */
9868 return reloc_type == 1; /* R_RL78_DIR32. */
9870 return reloc_type == 1; /* R_RX_DIR32. */
9872 return reloc_type == 1; /* R_I370_ADDR31. */
9875 return reloc_type == 4; /* R_S390_32. */
9877 return reloc_type == 8; /* R_SCORE_ABS32. */
9879 return reloc_type == 1; /* R_SH_DIR32. */
9880 case EM_SPARC32PLUS:
9883 return reloc_type == 3 /* R_SPARC_32. */
9884 || reloc_type == 23; /* R_SPARC_UA32. */
9886 return reloc_type == 6; /* R_SPU_ADDR32 */
9888 return reloc_type == 1; /* R_C6000_ABS32. */
9890 return reloc_type == 2; /* R_TILEGX_32. */
9892 return reloc_type == 1; /* R_TILEPRO_32. */
9893 case EM_CYGNUS_V850:
9895 return reloc_type == 6; /* R_V850_ABS32. */
9897 return reloc_type == 1; /* R_VAX_32. */
9901 return reloc_type == 10; /* R_X86_64_32. */
9904 return reloc_type == 3; /* R_XC16C_ABS_32. */
9906 return reloc_type == 4; /* R_XGATE_32. */
9908 return reloc_type == 1; /* R_XSTROMY16_32. */
9911 return reloc_type == 1; /* R_XTENSA_32. */
9913 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
9914 elf_header.e_machine);
9919 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9920 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
9923 is_32bit_pcrel_reloc (unsigned int reloc_type)
9925 switch (elf_header.e_machine)
9929 return reloc_type == 2; /* R_386_PC32. */
9931 return reloc_type == 4; /* R_68K_PC32. */
9932 case EM_ADAPTEVA_EPIPHANY:
9933 return reloc_type == 6;
9935 return reloc_type == 10; /* R_ALPHA_SREL32. */
9937 return reloc_type == 3; /* R_ARM_REL32 */
9939 return reloc_type == 2; /* R_MICROBLAZE_32_PCREL. */
9941 return reloc_type == 9; /* R_PARISC_PCREL32. */
9943 return reloc_type == 26; /* R_PPC_REL32. */
9945 return reloc_type == 26; /* R_PPC64_REL32. */
9948 return reloc_type == 5; /* R_390_PC32. */
9950 return reloc_type == 2; /* R_SH_REL32. */
9951 case EM_SPARC32PLUS:
9954 return reloc_type == 6; /* R_SPARC_DISP32. */
9956 return reloc_type == 13; /* R_SPU_REL32. */
9958 return reloc_type == 6; /* R_TILEGX_32_PCREL. */
9960 return reloc_type == 4; /* R_TILEPRO_32_PCREL. */
9964 return reloc_type == 2; /* R_X86_64_PC32. */
9967 return reloc_type == 14; /* R_XTENSA_32_PCREL. */
9969 /* Do not abort or issue an error message here. Not all targets use
9970 pc-relative 32-bit relocs in their DWARF debug information and we
9971 have already tested for target coverage in is_32bit_abs_reloc. A
9972 more helpful warning message will be generated by apply_relocations
9973 anyway, so just return. */
9978 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9979 a 64-bit absolute RELA relocation used in DWARF debug sections. */
9982 is_64bit_abs_reloc (unsigned int reloc_type)
9984 switch (elf_header.e_machine)
9987 return reloc_type == 2; /* R_ALPHA_REFQUAD. */
9989 return reloc_type == 0x27; /* R_IA64_DIR64LSB. */
9991 return reloc_type == 80; /* R_PARISC_DIR64. */
9993 return reloc_type == 38; /* R_PPC64_ADDR64. */
9994 case EM_SPARC32PLUS:
9997 return reloc_type == 54; /* R_SPARC_UA64. */
10001 return reloc_type == 1; /* R_X86_64_64. */
10004 return reloc_type == 22; /* R_S390_64. */
10006 return reloc_type == 1; /* R_TILEGX_64. */
10008 return reloc_type == 18; /* R_MIPS_64. */
10014 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
10015 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
10018 is_64bit_pcrel_reloc (unsigned int reloc_type)
10020 switch (elf_header.e_machine)
10023 return reloc_type == 11; /* R_ALPHA_SREL64. */
10025 return reloc_type == 0x4f; /* R_IA64_PCREL64LSB. */
10027 return reloc_type == 72; /* R_PARISC_PCREL64. */
10029 return reloc_type == 44; /* R_PPC64_REL64. */
10030 case EM_SPARC32PLUS:
10033 return reloc_type == 46; /* R_SPARC_DISP64. */
10037 return reloc_type == 24; /* R_X86_64_PC64. */
10040 return reloc_type == 23; /* R_S390_PC64. */
10042 return reloc_type == 5; /* R_TILEGX_64_PCREL. */
10048 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10049 a 24-bit absolute RELA relocation used in DWARF debug sections. */
10052 is_24bit_abs_reloc (unsigned int reloc_type)
10054 switch (elf_header.e_machine)
10056 case EM_CYGNUS_MN10200:
10058 return reloc_type == 4; /* R_MN10200_24. */
10064 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10065 a 16-bit absolute RELA relocation used in DWARF debug sections. */
10068 is_16bit_abs_reloc (unsigned int reloc_type)
10070 switch (elf_header.e_machine)
10074 return reloc_type == 4; /* R_AVR_16. */
10075 case EM_ADAPTEVA_EPIPHANY:
10076 return reloc_type == 5;
10077 case EM_CYGNUS_D10V:
10079 return reloc_type == 3; /* R_D10V_16. */
10083 return reloc_type == R_H8_DIR16;
10086 return reloc_type == 1; /* R_IP2K_16. */
10089 return reloc_type == 1; /* R_M32C_16 */
10090 case EM_MSP430_OLD:
10092 return reloc_type == 5; /* R_MSP430_16_BYTE. */
10093 case EM_ALTERA_NIOS2:
10095 return reloc_type == 9; /* R_NIOS_16. */
10097 return reloc_type == 2; /* R_C6000_ABS16. */
10100 return reloc_type == 2; /* R_XC16C_ABS_16. */
10101 case EM_CYGNUS_MN10300:
10103 return reloc_type == 2; /* R_MN10300_16. */
10105 return reloc_type == 3; /* R_XGATE_16. */
10111 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
10112 relocation entries (possibly formerly used for SHT_GROUP sections). */
10115 is_none_reloc (unsigned int reloc_type)
10117 switch (elf_header.e_machine)
10119 case EM_68K: /* R_68K_NONE. */
10120 case EM_386: /* R_386_NONE. */
10121 case EM_SPARC32PLUS:
10123 case EM_SPARC: /* R_SPARC_NONE. */
10124 case EM_MIPS: /* R_MIPS_NONE. */
10125 case EM_PARISC: /* R_PARISC_NONE. */
10126 case EM_ALPHA: /* R_ALPHA_NONE. */
10127 case EM_ADAPTEVA_EPIPHANY:
10128 case EM_PPC: /* R_PPC_NONE. */
10129 case EM_PPC64: /* R_PPC64_NONE. */
10130 case EM_ARM: /* R_ARM_NONE. */
10131 case EM_IA_64: /* R_IA64_NONE. */
10132 case EM_SH: /* R_SH_NONE. */
10134 case EM_S390: /* R_390_NONE. */
10135 case EM_CRIS: /* R_CRIS_NONE. */
10136 case EM_X86_64: /* R_X86_64_NONE. */
10137 case EM_L1OM: /* R_X86_64_NONE. */
10138 case EM_K1OM: /* R_X86_64_NONE. */
10139 case EM_MN10300: /* R_MN10300_NONE. */
10140 case EM_MOXIE: /* R_MOXIE_NONE. */
10141 case EM_M32R: /* R_M32R_NONE. */
10142 case EM_TI_C6000:/* R_C6000_NONE. */
10143 case EM_TILEGX: /* R_TILEGX_NONE. */
10144 case EM_TILEPRO: /* R_TILEPRO_NONE. */
10146 case EM_C166: /* R_XC16X_NONE. */
10147 return reloc_type == 0;
10148 case EM_XTENSA_OLD:
10150 return (reloc_type == 0 /* R_XTENSA_NONE. */
10151 || reloc_type == 17 /* R_XTENSA_DIFF8. */
10152 || reloc_type == 18 /* R_XTENSA_DIFF16. */
10153 || reloc_type == 19 /* R_XTENSA_DIFF32. */);
10158 /* Apply relocations to a section.
10159 Note: So far support has been added only for those relocations
10160 which can be found in debug sections.
10161 FIXME: Add support for more relocations ? */
10164 apply_relocations (void * file,
10165 Elf_Internal_Shdr * section,
10166 unsigned char * start)
10168 Elf_Internal_Shdr * relsec;
10169 unsigned char * end = start + section->sh_size;
10171 if (elf_header.e_type != ET_REL)
10174 /* Find the reloc section associated with the section. */
10175 for (relsec = section_headers;
10176 relsec < section_headers + elf_header.e_shnum;
10179 bfd_boolean is_rela;
10180 unsigned long num_relocs;
10181 Elf_Internal_Rela * relocs;
10182 Elf_Internal_Rela * rp;
10183 Elf_Internal_Shdr * symsec;
10184 Elf_Internal_Sym * symtab;
10185 unsigned long num_syms;
10186 Elf_Internal_Sym * sym;
10188 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
10189 || relsec->sh_info >= elf_header.e_shnum
10190 || section_headers + relsec->sh_info != section
10191 || relsec->sh_size == 0
10192 || relsec->sh_link >= elf_header.e_shnum)
10195 is_rela = relsec->sh_type == SHT_RELA;
10199 if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
10200 relsec->sh_size, & relocs, & num_relocs))
10205 if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
10206 relsec->sh_size, & relocs, & num_relocs))
10210 /* SH uses RELA but uses in place value instead of the addend field. */
10211 if (elf_header.e_machine == EM_SH)
10214 symsec = section_headers + relsec->sh_link;
10215 symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec, & num_syms);
10217 for (rp = relocs; rp < relocs + num_relocs; ++rp)
10220 unsigned int reloc_type;
10221 unsigned int reloc_size;
10222 unsigned char * rloc;
10223 unsigned long sym_index;
10225 reloc_type = get_reloc_type (rp->r_info);
10227 if (target_specific_reloc_handling (rp, start, symtab))
10229 else if (is_none_reloc (reloc_type))
10231 else if (is_32bit_abs_reloc (reloc_type)
10232 || is_32bit_pcrel_reloc (reloc_type))
10234 else if (is_64bit_abs_reloc (reloc_type)
10235 || is_64bit_pcrel_reloc (reloc_type))
10237 else if (is_24bit_abs_reloc (reloc_type))
10239 else if (is_16bit_abs_reloc (reloc_type))
10243 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
10244 reloc_type, SECTION_NAME (section));
10248 rloc = start + rp->r_offset;
10249 if ((rloc + reloc_size) > end)
10251 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
10252 (unsigned long) rp->r_offset,
10253 SECTION_NAME (section));
10257 sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
10258 if (sym_index >= num_syms)
10260 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
10261 sym_index, SECTION_NAME (section));
10264 sym = symtab + sym_index;
10266 /* If the reloc has a symbol associated with it,
10267 make sure that it is of an appropriate type.
10269 Relocations against symbols without type can happen.
10270 Gcc -feliminate-dwarf2-dups may generate symbols
10271 without type for debug info.
10273 Icc generates relocations against function symbols
10274 instead of local labels.
10276 Relocations against object symbols can happen, eg when
10277 referencing a global array. For an example of this see
10278 the _clz.o binary in libgcc.a. */
10280 && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
10282 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
10283 get_symbol_type (ELF_ST_TYPE (sym->st_info)),
10284 (long int)(rp - relocs),
10285 SECTION_NAME (relsec));
10291 addend += rp->r_addend;
10292 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
10293 partial_inplace. */
10295 || (elf_header.e_machine == EM_XTENSA
10296 && reloc_type == 1)
10297 || ((elf_header.e_machine == EM_PJ
10298 || elf_header.e_machine == EM_PJ_OLD)
10299 && reloc_type == 1)
10300 || ((elf_header.e_machine == EM_D30V
10301 || elf_header.e_machine == EM_CYGNUS_D30V)
10302 && reloc_type == 12))
10303 addend += byte_get (rloc, reloc_size);
10305 if (is_32bit_pcrel_reloc (reloc_type)
10306 || is_64bit_pcrel_reloc (reloc_type))
10308 /* On HPPA, all pc-relative relocations are biased by 8. */
10309 if (elf_header.e_machine == EM_PARISC)
10311 byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
10315 byte_put (rloc, addend + sym->st_value, reloc_size);
10324 #ifdef SUPPORT_DISASSEMBLY
10326 disassemble_section (Elf_Internal_Shdr * section, FILE * file)
10328 printf (_("\nAssembly dump of section %s\n"),
10329 SECTION_NAME (section));
10331 /* XXX -- to be done --- XXX */
10337 /* Reads in the contents of SECTION from FILE, returning a pointer
10338 to a malloc'ed buffer or NULL if something went wrong. */
10341 get_section_contents (Elf_Internal_Shdr * section, FILE * file)
10343 bfd_size_type num_bytes;
10345 num_bytes = section->sh_size;
10347 if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
10349 printf (_("\nSection '%s' has no data to dump.\n"),
10350 SECTION_NAME (section));
10354 return (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
10355 _("section contents"));
10360 dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
10362 Elf_Internal_Shdr * relsec;
10363 bfd_size_type num_bytes;
10367 char * name = SECTION_NAME (section);
10368 bfd_boolean some_strings_shown;
10370 start = get_section_contents (section, file);
10374 printf (_("\nString dump of section '%s':\n"), name);
10376 /* If the section being dumped has relocations against it the user might
10377 be expecting these relocations to have been applied. Check for this
10378 case and issue a warning message in order to avoid confusion.
10379 FIXME: Maybe we ought to have an option that dumps a section with
10380 relocs applied ? */
10381 for (relsec = section_headers;
10382 relsec < section_headers + elf_header.e_shnum;
10385 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
10386 || relsec->sh_info >= elf_header.e_shnum
10387 || section_headers + relsec->sh_info != section
10388 || relsec->sh_size == 0
10389 || relsec->sh_link >= elf_header.e_shnum)
10392 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
10396 num_bytes = section->sh_size;
10398 end = start + num_bytes;
10399 some_strings_shown = FALSE;
10403 while (!ISPRINT (* data))
10404 if (++ data >= end)
10410 /* PR 11128: Use two separate invocations in order to work
10411 around bugs in the Solaris 8 implementation of printf. */
10412 printf (" [%6tx] ", data - start);
10413 printf ("%s\n", data);
10415 printf (" [%6Ix] %s\n", (size_t) (data - start), data);
10417 data += strlen (data);
10418 some_strings_shown = TRUE;
10422 if (! some_strings_shown)
10423 printf (_(" No strings found in this section."));
10431 dump_section_as_bytes (Elf_Internal_Shdr * section,
10433 bfd_boolean relocate)
10435 Elf_Internal_Shdr * relsec;
10436 bfd_size_type bytes;
10438 unsigned char * data;
10439 unsigned char * start;
10441 start = (unsigned char *) get_section_contents (section, file);
10445 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
10449 apply_relocations (file, section, start);
10453 /* If the section being dumped has relocations against it the user might
10454 be expecting these relocations to have been applied. Check for this
10455 case and issue a warning message in order to avoid confusion.
10456 FIXME: Maybe we ought to have an option that dumps a section with
10457 relocs applied ? */
10458 for (relsec = section_headers;
10459 relsec < section_headers + elf_header.e_shnum;
10462 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
10463 || relsec->sh_info >= elf_header.e_shnum
10464 || section_headers + relsec->sh_info != section
10465 || relsec->sh_size == 0
10466 || relsec->sh_link >= elf_header.e_shnum)
10469 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
10474 addr = section->sh_addr;
10475 bytes = section->sh_size;
10484 lbytes = (bytes > 16 ? 16 : bytes);
10486 printf (" 0x%8.8lx ", (unsigned long) addr);
10488 for (j = 0; j < 16; j++)
10491 printf ("%2.2x", data[j]);
10499 for (j = 0; j < lbytes; j++)
10502 if (k >= ' ' && k < 0x7f)
10520 /* Uncompresses a section that was compressed using zlib, in place. */
10523 uncompress_section_contents (unsigned char **buffer ATTRIBUTE_UNUSED,
10524 dwarf_size_type *size ATTRIBUTE_UNUSED)
10526 #ifndef HAVE_ZLIB_H
10529 dwarf_size_type compressed_size = *size;
10530 unsigned char * compressed_buffer = *buffer;
10531 dwarf_size_type uncompressed_size;
10532 unsigned char * uncompressed_buffer;
10535 dwarf_size_type header_size = 12;
10537 /* Read the zlib header. In this case, it should be "ZLIB" followed
10538 by the uncompressed section size, 8 bytes in big-endian order. */
10539 if (compressed_size < header_size
10540 || ! streq ((char *) compressed_buffer, "ZLIB"))
10543 uncompressed_size = compressed_buffer[4]; uncompressed_size <<= 8;
10544 uncompressed_size += compressed_buffer[5]; uncompressed_size <<= 8;
10545 uncompressed_size += compressed_buffer[6]; uncompressed_size <<= 8;
10546 uncompressed_size += compressed_buffer[7]; uncompressed_size <<= 8;
10547 uncompressed_size += compressed_buffer[8]; uncompressed_size <<= 8;
10548 uncompressed_size += compressed_buffer[9]; uncompressed_size <<= 8;
10549 uncompressed_size += compressed_buffer[10]; uncompressed_size <<= 8;
10550 uncompressed_size += compressed_buffer[11];
10552 /* It is possible the section consists of several compressed
10553 buffers concatenated together, so we uncompress in a loop. */
10554 strm.zalloc = NULL;
10556 strm.opaque = NULL;
10557 strm.avail_in = compressed_size - header_size;
10558 strm.next_in = (Bytef *) compressed_buffer + header_size;
10559 strm.avail_out = uncompressed_size;
10560 uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
10562 rc = inflateInit (& strm);
10563 while (strm.avail_in > 0)
10567 strm.next_out = ((Bytef *) uncompressed_buffer
10568 + (uncompressed_size - strm.avail_out));
10569 rc = inflate (&strm, Z_FINISH);
10570 if (rc != Z_STREAM_END)
10572 rc = inflateReset (& strm);
10574 rc = inflateEnd (& strm);
10576 || strm.avail_out != 0)
10579 free (compressed_buffer);
10580 *buffer = uncompressed_buffer;
10581 *size = uncompressed_size;
10585 free (uncompressed_buffer);
10586 /* Indicate decompression failure. */
10589 #endif /* HAVE_ZLIB_H */
10593 load_specific_debug_section (enum dwarf_section_display_enum debug,
10594 Elf_Internal_Shdr * sec, void * file)
10596 struct dwarf_section * section = &debug_displays [debug].section;
10599 /* If it is already loaded, do nothing. */
10600 if (section->start != NULL)
10603 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
10604 section->address = sec->sh_addr;
10605 section->start = (unsigned char *) get_data (NULL, (FILE *) file,
10607 sec->sh_size, buf);
10608 if (section->start == NULL)
10612 section->size = sec->sh_size;
10613 if (uncompress_section_contents (§ion->start, §ion->size))
10614 sec->sh_size = section->size;
10617 if (section->start == NULL)
10620 if (debug_displays [debug].relocate)
10621 apply_relocations ((FILE *) file, sec, section->start);
10627 load_debug_section (enum dwarf_section_display_enum debug, void * file)
10629 struct dwarf_section * section = &debug_displays [debug].section;
10630 Elf_Internal_Shdr * sec;
10632 /* Locate the debug section. */
10633 sec = find_section (section->uncompressed_name);
10635 section->name = section->uncompressed_name;
10638 sec = find_section (section->compressed_name);
10640 section->name = section->compressed_name;
10645 return load_specific_debug_section (debug, sec, (FILE *) file);
10649 free_debug_section (enum dwarf_section_display_enum debug)
10651 struct dwarf_section * section = &debug_displays [debug].section;
10653 if (section->start == NULL)
10656 free ((char *) section->start);
10657 section->start = NULL;
10658 section->address = 0;
10663 display_debug_section (Elf_Internal_Shdr * section, FILE * file)
10665 char * name = SECTION_NAME (section);
10666 bfd_size_type length;
10670 length = section->sh_size;
10673 printf (_("\nSection '%s' has no debugging data.\n"), name);
10676 if (section->sh_type == SHT_NOBITS)
10678 /* There is no point in dumping the contents of a debugging section
10679 which has the NOBITS type - the bits in the file will be random.
10680 This can happen when a file containing a .eh_frame section is
10681 stripped with the --only-keep-debug command line option. */
10682 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"), name);
10686 if (const_strneq (name, ".gnu.linkonce.wi."))
10687 name = ".debug_info";
10689 /* See if we know how to display the contents of this section. */
10690 for (i = 0; i < max; i++)
10691 if (streq (debug_displays[i].section.uncompressed_name, name)
10692 || streq (debug_displays[i].section.compressed_name, name))
10694 struct dwarf_section * sec = &debug_displays [i].section;
10695 int secondary = (section != find_section (name));
10698 free_debug_section ((enum dwarf_section_display_enum) i);
10700 if (streq (sec->uncompressed_name, name))
10701 sec->name = sec->uncompressed_name;
10703 sec->name = sec->compressed_name;
10704 if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
10707 result &= debug_displays[i].display (sec, file);
10709 if (secondary || (i != info && i != abbrev))
10710 free_debug_section ((enum dwarf_section_display_enum) i);
10718 printf (_("Unrecognized debug section: %s\n"), name);
10725 /* Set DUMP_SECTS for all sections where dumps were requested
10726 based on section name. */
10729 initialise_dumps_byname (void)
10731 struct dump_list_entry * cur;
10733 for (cur = dump_sects_byname; cur; cur = cur->next)
10738 for (i = 0, any = 0; i < elf_header.e_shnum; i++)
10739 if (streq (SECTION_NAME (section_headers + i), cur->name))
10741 request_dump_bynumber (i, cur->type);
10746 warn (_("Section '%s' was not dumped because it does not exist!\n"),
10752 process_section_contents (FILE * file)
10754 Elf_Internal_Shdr * section;
10760 initialise_dumps_byname ();
10762 for (i = 0, section = section_headers;
10763 i < elf_header.e_shnum && i < num_dump_sects;
10766 #ifdef SUPPORT_DISASSEMBLY
10767 if (dump_sects[i] & DISASS_DUMP)
10768 disassemble_section (section, file);
10770 if (dump_sects[i] & HEX_DUMP)
10771 dump_section_as_bytes (section, file, FALSE);
10773 if (dump_sects[i] & RELOC_DUMP)
10774 dump_section_as_bytes (section, file, TRUE);
10776 if (dump_sects[i] & STRING_DUMP)
10777 dump_section_as_strings (section, file);
10779 if (dump_sects[i] & DEBUG_DUMP)
10780 display_debug_section (section, file);
10783 /* Check to see if the user requested a
10784 dump of a section that does not exist. */
10785 while (i++ < num_dump_sects)
10787 warn (_("Section %d was not dumped because it does not exist!\n"), i);
10791 process_mips_fpe_exception (int mask)
10796 if (mask & OEX_FPU_INEX)
10797 fputs ("INEX", stdout), first = 0;
10798 if (mask & OEX_FPU_UFLO)
10799 printf ("%sUFLO", first ? "" : "|"), first = 0;
10800 if (mask & OEX_FPU_OFLO)
10801 printf ("%sOFLO", first ? "" : "|"), first = 0;
10802 if (mask & OEX_FPU_DIV0)
10803 printf ("%sDIV0", first ? "" : "|"), first = 0;
10804 if (mask & OEX_FPU_INVAL)
10805 printf ("%sINVAL", first ? "" : "|");
10808 fputs ("0", stdout);
10811 /* ARM EABI attributes section. */
10816 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
10818 const char ** table;
10819 } arm_attr_public_tag;
10821 static const char * arm_attr_tag_CPU_arch[] =
10822 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
10823 "v6K", "v7", "v6-M", "v6S-M", "v7E-M"};
10824 static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
10825 static const char * arm_attr_tag_THUMB_ISA_use[] =
10826 {"No", "Thumb-1", "Thumb-2"};
10827 static const char * arm_attr_tag_FP_arch[] =
10828 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16"};
10829 static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
10830 static const char * arm_attr_tag_Advanced_SIMD_arch[] =
10831 {"No", "NEONv1", "NEONv1 with Fused-MAC"};
10832 static const char * arm_attr_tag_PCS_config[] =
10833 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
10834 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
10835 static const char * arm_attr_tag_ABI_PCS_R9_use[] =
10836 {"V6", "SB", "TLS", "Unused"};
10837 static const char * arm_attr_tag_ABI_PCS_RW_data[] =
10838 {"Absolute", "PC-relative", "SB-relative", "None"};
10839 static const char * arm_attr_tag_ABI_PCS_RO_data[] =
10840 {"Absolute", "PC-relative", "None"};
10841 static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
10842 {"None", "direct", "GOT-indirect"};
10843 static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
10844 {"None", "??? 1", "2", "??? 3", "4"};
10845 static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
10846 static const char * arm_attr_tag_ABI_FP_denormal[] =
10847 {"Unused", "Needed", "Sign only"};
10848 static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
10849 static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
10850 static const char * arm_attr_tag_ABI_FP_number_model[] =
10851 {"Unused", "Finite", "RTABI", "IEEE 754"};
10852 static const char * arm_attr_tag_ABI_enum_size[] =
10853 {"Unused", "small", "int", "forced to int"};
10854 static const char * arm_attr_tag_ABI_HardFP_use[] =
10855 {"As Tag_FP_arch", "SP only", "DP only", "SP and DP"};
10856 static const char * arm_attr_tag_ABI_VFP_args[] =
10857 {"AAPCS", "VFP registers", "custom"};
10858 static const char * arm_attr_tag_ABI_WMMX_args[] =
10859 {"AAPCS", "WMMX registers", "custom"};
10860 static const char * arm_attr_tag_ABI_optimization_goals[] =
10861 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
10862 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
10863 static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
10864 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
10865 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
10866 static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
10867 static const char * arm_attr_tag_FP_HP_extension[] =
10868 {"Not Allowed", "Allowed"};
10869 static const char * arm_attr_tag_ABI_FP_16bit_format[] =
10870 {"None", "IEEE 754", "Alternative Format"};
10871 static const char * arm_attr_tag_MPextension_use[] =
10872 {"Not Allowed", "Allowed"};
10873 static const char * arm_attr_tag_DIV_use[] =
10874 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
10875 "Allowed in v7-A with integer division extension"};
10876 static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
10877 static const char * arm_attr_tag_Virtualization_use[] =
10878 {"Not Allowed", "TrustZone", "Virtualization Extensions",
10879 "TrustZone and Virtualization Extensions"};
10880 static const char * arm_attr_tag_MPextension_use_legacy[] =
10881 {"Not Allowed", "Allowed"};
10883 #define LOOKUP(id, name) \
10884 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
10885 static arm_attr_public_tag arm_attr_public_tags[] =
10887 {4, "CPU_raw_name", 1, NULL},
10888 {5, "CPU_name", 1, NULL},
10889 LOOKUP(6, CPU_arch),
10890 {7, "CPU_arch_profile", 0, NULL},
10891 LOOKUP(8, ARM_ISA_use),
10892 LOOKUP(9, THUMB_ISA_use),
10893 LOOKUP(10, FP_arch),
10894 LOOKUP(11, WMMX_arch),
10895 LOOKUP(12, Advanced_SIMD_arch),
10896 LOOKUP(13, PCS_config),
10897 LOOKUP(14, ABI_PCS_R9_use),
10898 LOOKUP(15, ABI_PCS_RW_data),
10899 LOOKUP(16, ABI_PCS_RO_data),
10900 LOOKUP(17, ABI_PCS_GOT_use),
10901 LOOKUP(18, ABI_PCS_wchar_t),
10902 LOOKUP(19, ABI_FP_rounding),
10903 LOOKUP(20, ABI_FP_denormal),
10904 LOOKUP(21, ABI_FP_exceptions),
10905 LOOKUP(22, ABI_FP_user_exceptions),
10906 LOOKUP(23, ABI_FP_number_model),
10907 {24, "ABI_align_needed", 0, NULL},
10908 {25, "ABI_align_preserved", 0, NULL},
10909 LOOKUP(26, ABI_enum_size),
10910 LOOKUP(27, ABI_HardFP_use),
10911 LOOKUP(28, ABI_VFP_args),
10912 LOOKUP(29, ABI_WMMX_args),
10913 LOOKUP(30, ABI_optimization_goals),
10914 LOOKUP(31, ABI_FP_optimization_goals),
10915 {32, "compatibility", 0, NULL},
10916 LOOKUP(34, CPU_unaligned_access),
10917 LOOKUP(36, FP_HP_extension),
10918 LOOKUP(38, ABI_FP_16bit_format),
10919 LOOKUP(42, MPextension_use),
10920 LOOKUP(44, DIV_use),
10921 {64, "nodefaults", 0, NULL},
10922 {65, "also_compatible_with", 0, NULL},
10923 LOOKUP(66, T2EE_use),
10924 {67, "conformance", 1, NULL},
10925 LOOKUP(68, Virtualization_use),
10926 LOOKUP(70, MPextension_use_legacy)
10930 static unsigned char *
10931 display_arm_attribute (unsigned char * p)
10936 arm_attr_public_tag * attr;
10940 tag = read_uleb128 (p, &len);
10943 for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
10945 if (arm_attr_public_tags[i].tag == tag)
10947 attr = &arm_attr_public_tags[i];
10954 printf (" Tag_%s: ", attr->name);
10955 switch (attr->type)
10960 case 7: /* Tag_CPU_arch_profile. */
10961 val = read_uleb128 (p, &len);
10965 case 0: printf (_("None\n")); break;
10966 case 'A': printf (_("Application\n")); break;
10967 case 'R': printf (_("Realtime\n")); break;
10968 case 'M': printf (_("Microcontroller\n")); break;
10969 case 'S': printf (_("Application or Realtime\n")); break;
10970 default: printf ("??? (%d)\n", val); break;
10974 case 24: /* Tag_align_needed. */
10975 val = read_uleb128 (p, &len);
10979 case 0: printf (_("None\n")); break;
10980 case 1: printf (_("8-byte\n")); break;
10981 case 2: printf (_("4-byte\n")); break;
10982 case 3: printf ("??? 3\n"); break;
10985 printf (_("8-byte and up to %d-byte extended\n"),
10988 printf ("??? (%d)\n", val);
10993 case 25: /* Tag_align_preserved. */
10994 val = read_uleb128 (p, &len);
10998 case 0: printf (_("None\n")); break;
10999 case 1: printf (_("8-byte, except leaf SP\n")); break;
11000 case 2: printf (_("8-byte\n")); break;
11001 case 3: printf ("??? 3\n"); break;
11004 printf (_("8-byte and up to %d-byte extended\n"),
11007 printf ("??? (%d)\n", val);
11012 case 32: /* Tag_compatibility. */
11013 val = read_uleb128 (p, &len);
11015 printf (_("flag = %d, vendor = %s\n"), val, p);
11016 p += strlen ((char *) p) + 1;
11019 case 64: /* Tag_nodefaults. */
11021 printf (_("True\n"));
11024 case 65: /* Tag_also_compatible_with. */
11025 val = read_uleb128 (p, &len);
11027 if (val == 6 /* Tag_CPU_arch. */)
11029 val = read_uleb128 (p, &len);
11031 if ((unsigned int)val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
11032 printf ("??? (%d)\n", val);
11034 printf ("%s\n", arm_attr_tag_CPU_arch[val]);
11038 while (*(p++) != '\0' /* NUL terminator. */);
11052 assert (attr->type & 0x80);
11053 val = read_uleb128 (p, &len);
11055 type = attr->type & 0x7f;
11057 printf ("??? (%d)\n", val);
11059 printf ("%s\n", attr->table[val]);
11066 type = 1; /* String. */
11068 type = 2; /* uleb128. */
11069 printf (" Tag_unknown_%d: ", tag);
11074 printf ("\"%s\"\n", p);
11075 p += strlen ((char *) p) + 1;
11079 val = read_uleb128 (p, &len);
11081 printf ("%d (0x%x)\n", val, val);
11087 static unsigned char *
11088 display_gnu_attribute (unsigned char * p,
11089 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int))
11096 tag = read_uleb128 (p, &len);
11099 /* Tag_compatibility is the only generic GNU attribute defined at
11103 val = read_uleb128 (p, &len);
11105 printf (_("flag = %d, vendor = %s\n"), val, p);
11106 p += strlen ((char *) p) + 1;
11110 if ((tag & 2) == 0 && display_proc_gnu_attribute)
11111 return display_proc_gnu_attribute (p, tag);
11114 type = 1; /* String. */
11116 type = 2; /* uleb128. */
11117 printf (" Tag_unknown_%d: ", tag);
11121 printf ("\"%s\"\n", p);
11122 p += strlen ((char *) p) + 1;
11126 val = read_uleb128 (p, &len);
11128 printf ("%d (0x%x)\n", val, val);
11134 static unsigned char *
11135 display_power_gnu_attribute (unsigned char * p, int tag)
11141 if (tag == Tag_GNU_Power_ABI_FP)
11143 val = read_uleb128 (p, &len);
11145 printf (" Tag_GNU_Power_ABI_FP: ");
11150 printf (_("Hard or soft float\n"));
11153 printf (_("Hard float\n"));
11156 printf (_("Soft float\n"));
11159 printf (_("Single-precision hard float\n"));
11162 printf ("??? (%d)\n", val);
11168 if (tag == Tag_GNU_Power_ABI_Vector)
11170 val = read_uleb128 (p, &len);
11172 printf (" Tag_GNU_Power_ABI_Vector: ");
11176 printf (_("Any\n"));
11179 printf (_("Generic\n"));
11182 printf ("AltiVec\n");
11188 printf ("??? (%d)\n", val);
11194 if (tag == Tag_GNU_Power_ABI_Struct_Return)
11196 val = read_uleb128 (p, &len);
11198 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
11202 printf (_("Any\n"));
11205 printf ("r3/r4\n");
11208 printf (_("Memory\n"));
11211 printf ("??? (%d)\n", val);
11218 type = 1; /* String. */
11220 type = 2; /* uleb128. */
11221 printf (" Tag_unknown_%d: ", tag);
11225 printf ("\"%s\"\n", p);
11226 p += strlen ((char *) p) + 1;
11230 val = read_uleb128 (p, &len);
11232 printf ("%d (0x%x)\n", val, val);
11239 display_sparc_hwcaps (int mask)
11244 if (mask & ELF_SPARC_HWCAP_MUL32)
11245 fputs ("mul32", stdout), first = 0;
11246 if (mask & ELF_SPARC_HWCAP_DIV32)
11247 printf ("%sdiv32", first ? "" : "|"), first = 0;
11248 if (mask & ELF_SPARC_HWCAP_FSMULD)
11249 printf ("%sfsmuld", first ? "" : "|"), first = 0;
11250 if (mask & ELF_SPARC_HWCAP_V8PLUS)
11251 printf ("%sv8plus", first ? "" : "|"), first = 0;
11252 if (mask & ELF_SPARC_HWCAP_POPC)
11253 printf ("%spopc", first ? "" : "|"), first = 0;
11254 if (mask & ELF_SPARC_HWCAP_VIS)
11255 printf ("%svis", first ? "" : "|"), first = 0;
11256 if (mask & ELF_SPARC_HWCAP_VIS2)
11257 printf ("%svis2", first ? "" : "|"), first = 0;
11258 if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
11259 printf ("%sASIBlkInit", first ? "" : "|"), first = 0;
11260 if (mask & ELF_SPARC_HWCAP_FMAF)
11261 printf ("%sfmaf", first ? "" : "|"), first = 0;
11262 if (mask & ELF_SPARC_HWCAP_VIS3)
11263 printf ("%svis3", first ? "" : "|"), first = 0;
11264 if (mask & ELF_SPARC_HWCAP_HPC)
11265 printf ("%shpc", first ? "" : "|"), first = 0;
11266 if (mask & ELF_SPARC_HWCAP_RANDOM)
11267 printf ("%srandom", first ? "" : "|"), first = 0;
11268 if (mask & ELF_SPARC_HWCAP_TRANS)
11269 printf ("%strans", first ? "" : "|"), first = 0;
11270 if (mask & ELF_SPARC_HWCAP_FJFMAU)
11271 printf ("%sfjfmau", first ? "" : "|"), first = 0;
11272 if (mask & ELF_SPARC_HWCAP_IMA)
11273 printf ("%sima", first ? "" : "|"), first = 0;
11274 if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
11275 printf ("%scspare", first ? "" : "|"), first = 0;
11278 fputc('0', stdout);
11279 fputc('\n', stdout);
11282 static unsigned char *
11283 display_sparc_gnu_attribute (unsigned char * p, int tag)
11289 if (tag == Tag_GNU_Sparc_HWCAPS)
11291 val = read_uleb128 (p, &len);
11293 printf (" Tag_GNU_Sparc_HWCAPS: ");
11295 display_sparc_hwcaps (val);
11300 type = 1; /* String. */
11302 type = 2; /* uleb128. */
11303 printf (" Tag_unknown_%d: ", tag);
11307 printf ("\"%s\"\n", p);
11308 p += strlen ((char *) p) + 1;
11312 val = read_uleb128 (p, &len);
11314 printf ("%d (0x%x)\n", val, val);
11320 static unsigned char *
11321 display_mips_gnu_attribute (unsigned char * p, int tag)
11327 if (tag == Tag_GNU_MIPS_ABI_FP)
11329 val = read_uleb128 (p, &len);
11331 printf (" Tag_GNU_MIPS_ABI_FP: ");
11336 printf (_("Hard or soft float\n"));
11339 printf (_("Hard float (double precision)\n"));
11342 printf (_("Hard float (single precision)\n"));
11345 printf (_("Soft float\n"));
11348 printf (_("Hard float (MIPS32r2 64-bit FPU)\n"));
11351 printf ("??? (%d)\n", val);
11358 type = 1; /* String. */
11360 type = 2; /* uleb128. */
11361 printf (" Tag_unknown_%d: ", tag);
11365 printf ("\"%s\"\n", p);
11366 p += strlen ((char *) p) + 1;
11370 val = read_uleb128 (p, &len);
11372 printf ("%d (0x%x)\n", val, val);
11378 static unsigned char *
11379 display_tic6x_attribute (unsigned char * p)
11385 tag = read_uleb128 (p, &len);
11391 val = read_uleb128 (p, &len);
11393 printf (" Tag_ISA: ");
11397 case C6XABI_Tag_ISA_none:
11398 printf (_("None\n"));
11400 case C6XABI_Tag_ISA_C62X:
11403 case C6XABI_Tag_ISA_C67X:
11406 case C6XABI_Tag_ISA_C67XP:
11407 printf ("C67x+\n");
11409 case C6XABI_Tag_ISA_C64X:
11412 case C6XABI_Tag_ISA_C64XP:
11413 printf ("C64x+\n");
11415 case C6XABI_Tag_ISA_C674X:
11416 printf ("C674x\n");
11419 printf ("??? (%d)\n", val);
11424 case Tag_ABI_wchar_t:
11425 val = read_uleb128 (p, &len);
11427 printf (" Tag_ABI_wchar_t: ");
11431 printf (_("Not used\n"));
11434 printf (_("2 bytes\n"));
11437 printf (_("4 bytes\n"));
11440 printf ("??? (%d)\n", val);
11445 case Tag_ABI_stack_align_needed:
11446 val = read_uleb128 (p, &len);
11448 printf (" Tag_ABI_stack_align_needed: ");
11452 printf (_("8-byte\n"));
11455 printf (_("16-byte\n"));
11458 printf ("??? (%d)\n", val);
11463 case Tag_ABI_stack_align_preserved:
11464 val = read_uleb128 (p, &len);
11466 printf (" Tag_ABI_stack_align_preserved: ");
11470 printf (_("8-byte\n"));
11473 printf (_("16-byte\n"));
11476 printf ("??? (%d)\n", val);
11482 val = read_uleb128 (p, &len);
11484 printf (" Tag_ABI_DSBT: ");
11488 printf (_("DSBT addressing not used\n"));
11491 printf (_("DSBT addressing used\n"));
11494 printf ("??? (%d)\n", val);
11500 val = read_uleb128 (p, &len);
11502 printf (" Tag_ABI_PID: ");
11506 printf (_("Data addressing position-dependent\n"));
11509 printf (_("Data addressing position-independent, GOT near DP\n"));
11512 printf (_("Data addressing position-independent, GOT far from DP\n"));
11515 printf ("??? (%d)\n", val);
11521 val = read_uleb128 (p, &len);
11523 printf (" Tag_ABI_PIC: ");
11527 printf (_("Code addressing position-dependent\n"));
11530 printf (_("Code addressing position-independent\n"));
11533 printf ("??? (%d)\n", val);
11538 case Tag_ABI_array_object_alignment:
11539 val = read_uleb128 (p, &len);
11541 printf (" Tag_ABI_array_object_alignment: ");
11545 printf (_("8-byte\n"));
11548 printf (_("4-byte\n"));
11551 printf (_("16-byte\n"));
11554 printf ("??? (%d)\n", val);
11559 case Tag_ABI_array_object_align_expected:
11560 val = read_uleb128 (p, &len);
11562 printf (" Tag_ABI_array_object_align_expected: ");
11566 printf (_("8-byte\n"));
11569 printf (_("4-byte\n"));
11572 printf (_("16-byte\n"));
11575 printf ("??? (%d)\n", val);
11580 case Tag_ABI_compatibility:
11581 val = read_uleb128 (p, &len);
11583 printf (" Tag_ABI_compatibility: ");
11584 printf (_("flag = %d, vendor = %s\n"), val, p);
11585 p += strlen ((char *) p) + 1;
11588 case Tag_ABI_conformance:
11589 printf (" Tag_ABI_conformance: ");
11590 printf ("\"%s\"\n", p);
11591 p += strlen ((char *) p) + 1;
11595 printf (" Tag_unknown_%d: ", tag);
11599 printf ("\"%s\"\n", p);
11600 p += strlen ((char *) p) + 1;
11604 val = read_uleb128 (p, &len);
11606 printf ("%d (0x%x)\n", val, val);
11613 process_attributes (FILE * file,
11614 const char * public_name,
11615 unsigned int proc_type,
11616 unsigned char * (* display_pub_attribute) (unsigned char *),
11617 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int))
11619 Elf_Internal_Shdr * sect;
11620 unsigned char * contents;
11622 unsigned char * end;
11623 bfd_vma section_len;
11627 /* Find the section header so that we get the size. */
11628 for (i = 0, sect = section_headers;
11629 i < elf_header.e_shnum;
11632 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
11635 contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
11636 sect->sh_size, _("attributes"));
11637 if (contents == NULL)
11643 len = sect->sh_size - 1;
11649 bfd_boolean public_section;
11650 bfd_boolean gnu_section;
11652 section_len = byte_get (p, 4);
11655 if (section_len > len)
11657 printf (_("ERROR: Bad section length (%d > %d)\n"),
11658 (int) section_len, (int) len);
11662 len -= section_len;
11663 printf (_("Attribute Section: %s\n"), p);
11665 if (public_name && streq ((char *) p, public_name))
11666 public_section = TRUE;
11668 public_section = FALSE;
11670 if (streq ((char *) p, "gnu"))
11671 gnu_section = TRUE;
11673 gnu_section = FALSE;
11675 namelen = strlen ((char *) p) + 1;
11677 section_len -= namelen + 4;
11679 while (section_len > 0)
11685 size = byte_get (p, 4);
11686 if (size > section_len)
11688 printf (_("ERROR: Bad subsection length (%d > %d)\n"),
11689 (int) size, (int) section_len);
11690 size = section_len;
11693 section_len -= size;
11694 end = p + size - 1;
11700 printf (_("File Attributes\n"));
11703 printf (_("Section Attributes:"));
11706 printf (_("Symbol Attributes:"));
11712 val = read_uleb128 (p, &j);
11716 printf (" %d", val);
11721 printf (_("Unknown tag: %d\n"), tag);
11722 public_section = FALSE;
11726 if (public_section)
11729 p = display_pub_attribute (p);
11731 else if (gnu_section)
11734 p = display_gnu_attribute (p,
11735 display_proc_gnu_attribute);
11739 /* ??? Do something sensible, like dump hex. */
11740 printf (_(" Unknown section contexts\n"));
11747 printf (_("Unknown format '%c'\n"), *p);
11755 process_arm_specific (FILE * file)
11757 return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
11758 display_arm_attribute, NULL);
11762 process_power_specific (FILE * file)
11764 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
11765 display_power_gnu_attribute);
11769 process_sparc_specific (FILE * file)
11771 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
11772 display_sparc_gnu_attribute);
11776 process_tic6x_specific (FILE * file)
11778 return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
11779 display_tic6x_attribute, NULL);
11782 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
11783 Print the Address, Access and Initial fields of an entry at VMA ADDR
11784 and return the VMA of the next entry. */
11787 print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
11790 print_vma (addr, LONG_HEX);
11792 if (addr < pltgot + 0xfff0)
11793 printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
11795 printf ("%10s", "");
11798 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
11803 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
11804 print_vma (entry, LONG_HEX);
11806 return addr + (is_32bit_elf ? 4 : 8);
11809 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
11810 PLTGOT. Print the Address and Initial fields of an entry at VMA
11811 ADDR and return the VMA of the next entry. */
11814 print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
11817 print_vma (addr, LONG_HEX);
11820 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
11825 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
11826 print_vma (entry, LONG_HEX);
11828 return addr + (is_32bit_elf ? 4 : 8);
11832 process_mips_specific (FILE * file)
11834 Elf_Internal_Dyn * entry;
11835 size_t liblist_offset = 0;
11836 size_t liblistno = 0;
11837 size_t conflictsno = 0;
11838 size_t options_offset = 0;
11839 size_t conflicts_offset = 0;
11840 size_t pltrelsz = 0;
11842 bfd_vma pltgot = 0;
11843 bfd_vma mips_pltgot = 0;
11844 bfd_vma jmprel = 0;
11845 bfd_vma local_gotno = 0;
11846 bfd_vma gotsym = 0;
11847 bfd_vma symtabno = 0;
11849 process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
11850 display_mips_gnu_attribute);
11852 /* We have a lot of special sections. Thanks SGI! */
11853 if (dynamic_section == NULL)
11854 /* No information available. */
11857 for (entry = dynamic_section; entry->d_tag != DT_NULL; ++entry)
11858 switch (entry->d_tag)
11860 case DT_MIPS_LIBLIST:
11862 = offset_from_vma (file, entry->d_un.d_val,
11863 liblistno * sizeof (Elf32_External_Lib));
11865 case DT_MIPS_LIBLISTNO:
11866 liblistno = entry->d_un.d_val;
11868 case DT_MIPS_OPTIONS:
11869 options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
11871 case DT_MIPS_CONFLICT:
11873 = offset_from_vma (file, entry->d_un.d_val,
11874 conflictsno * sizeof (Elf32_External_Conflict));
11876 case DT_MIPS_CONFLICTNO:
11877 conflictsno = entry->d_un.d_val;
11880 pltgot = entry->d_un.d_ptr;
11882 case DT_MIPS_LOCAL_GOTNO:
11883 local_gotno = entry->d_un.d_val;
11885 case DT_MIPS_GOTSYM:
11886 gotsym = entry->d_un.d_val;
11888 case DT_MIPS_SYMTABNO:
11889 symtabno = entry->d_un.d_val;
11891 case DT_MIPS_PLTGOT:
11892 mips_pltgot = entry->d_un.d_ptr;
11895 pltrel = entry->d_un.d_val;
11898 pltrelsz = entry->d_un.d_val;
11901 jmprel = entry->d_un.d_ptr;
11907 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
11909 Elf32_External_Lib * elib;
11912 elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
11914 sizeof (Elf32_External_Lib),
11915 _("liblist section data"));
11918 printf (_("\nSection '.liblist' contains %lu entries:\n"),
11919 (unsigned long) liblistno);
11920 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
11923 for (cnt = 0; cnt < liblistno; ++cnt)
11930 liblist.l_name = BYTE_GET (elib[cnt].l_name);
11931 atime = BYTE_GET (elib[cnt].l_time_stamp);
11932 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
11933 liblist.l_version = BYTE_GET (elib[cnt].l_version);
11934 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
11936 tmp = gmtime (&atime);
11937 snprintf (timebuf, sizeof (timebuf),
11938 "%04u-%02u-%02uT%02u:%02u:%02u",
11939 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
11940 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
11942 printf ("%3lu: ", (unsigned long) cnt);
11943 if (VALID_DYNAMIC_NAME (liblist.l_name))
11944 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
11946 printf (_("<corrupt: %9ld>"), liblist.l_name);
11947 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
11948 liblist.l_version);
11950 if (liblist.l_flags == 0)
11954 static const struct
11961 { " EXACT_MATCH", LL_EXACT_MATCH },
11962 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
11963 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
11964 { " EXPORTS", LL_EXPORTS },
11965 { " DELAY_LOAD", LL_DELAY_LOAD },
11966 { " DELTA", LL_DELTA }
11968 int flags = liblist.l_flags;
11971 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
11972 if ((flags & l_flags_vals[fcnt].bit) != 0)
11974 fputs (l_flags_vals[fcnt].name, stdout);
11975 flags ^= l_flags_vals[fcnt].bit;
11978 printf (" %#x", (unsigned int) flags);
11988 if (options_offset != 0)
11990 Elf_External_Options * eopt;
11991 Elf_Internal_Shdr * sect = section_headers;
11992 Elf_Internal_Options * iopt;
11993 Elf_Internal_Options * option;
11997 /* Find the section header so that we get the size. */
11998 while (sect->sh_type != SHT_MIPS_OPTIONS)
12001 eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
12002 sect->sh_size, _("options"));
12005 iopt = (Elf_Internal_Options *)
12006 cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
12009 error (_("Out of memory\n"));
12016 while (offset < sect->sh_size)
12018 Elf_External_Options * eoption;
12020 eoption = (Elf_External_Options *) ((char *) eopt + offset);
12022 option->kind = BYTE_GET (eoption->kind);
12023 option->size = BYTE_GET (eoption->size);
12024 option->section = BYTE_GET (eoption->section);
12025 option->info = BYTE_GET (eoption->info);
12027 offset += option->size;
12033 printf (_("\nSection '%s' contains %d entries:\n"),
12034 SECTION_NAME (sect), cnt);
12042 switch (option->kind)
12045 /* This shouldn't happen. */
12046 printf (" NULL %d %lx", option->section, option->info);
12049 printf (" REGINFO ");
12050 if (elf_header.e_machine == EM_MIPS)
12053 Elf32_External_RegInfo * ereg;
12054 Elf32_RegInfo reginfo;
12056 ereg = (Elf32_External_RegInfo *) (option + 1);
12057 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
12058 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
12059 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
12060 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
12061 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
12062 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
12064 printf ("GPR %08lx GP 0x%lx\n",
12065 reginfo.ri_gprmask,
12066 (unsigned long) reginfo.ri_gp_value);
12067 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
12068 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
12069 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
12074 Elf64_External_RegInfo * ereg;
12075 Elf64_Internal_RegInfo reginfo;
12077 ereg = (Elf64_External_RegInfo *) (option + 1);
12078 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
12079 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
12080 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
12081 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
12082 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
12083 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
12085 printf ("GPR %08lx GP 0x",
12086 reginfo.ri_gprmask);
12087 printf_vma (reginfo.ri_gp_value);
12090 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
12091 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
12092 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
12096 case ODK_EXCEPTIONS:
12097 fputs (" EXCEPTIONS fpe_min(", stdout);
12098 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
12099 fputs (") fpe_max(", stdout);
12100 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
12101 fputs (")", stdout);
12103 if (option->info & OEX_PAGE0)
12104 fputs (" PAGE0", stdout);
12105 if (option->info & OEX_SMM)
12106 fputs (" SMM", stdout);
12107 if (option->info & OEX_FPDBUG)
12108 fputs (" FPDBUG", stdout);
12109 if (option->info & OEX_DISMISS)
12110 fputs (" DISMISS", stdout);
12113 fputs (" PAD ", stdout);
12114 if (option->info & OPAD_PREFIX)
12115 fputs (" PREFIX", stdout);
12116 if (option->info & OPAD_POSTFIX)
12117 fputs (" POSTFIX", stdout);
12118 if (option->info & OPAD_SYMBOL)
12119 fputs (" SYMBOL", stdout);
12122 fputs (" HWPATCH ", stdout);
12123 if (option->info & OHW_R4KEOP)
12124 fputs (" R4KEOP", stdout);
12125 if (option->info & OHW_R8KPFETCH)
12126 fputs (" R8KPFETCH", stdout);
12127 if (option->info & OHW_R5KEOP)
12128 fputs (" R5KEOP", stdout);
12129 if (option->info & OHW_R5KCVTL)
12130 fputs (" R5KCVTL", stdout);
12133 fputs (" FILL ", stdout);
12134 /* XXX Print content of info word? */
12137 fputs (" TAGS ", stdout);
12138 /* XXX Print content of info word? */
12141 fputs (" HWAND ", stdout);
12142 if (option->info & OHWA0_R4KEOP_CHECKED)
12143 fputs (" R4KEOP_CHECKED", stdout);
12144 if (option->info & OHWA0_R4KEOP_CLEAN)
12145 fputs (" R4KEOP_CLEAN", stdout);
12148 fputs (" HWOR ", stdout);
12149 if (option->info & OHWA0_R4KEOP_CHECKED)
12150 fputs (" R4KEOP_CHECKED", stdout);
12151 if (option->info & OHWA0_R4KEOP_CLEAN)
12152 fputs (" R4KEOP_CLEAN", stdout);
12155 printf (" GP_GROUP %#06lx self-contained %#06lx",
12156 option->info & OGP_GROUP,
12157 (option->info & OGP_SELF) >> 16);
12160 printf (" IDENT %#06lx self-contained %#06lx",
12161 option->info & OGP_GROUP,
12162 (option->info & OGP_SELF) >> 16);
12165 /* This shouldn't happen. */
12166 printf (" %3d ??? %d %lx",
12167 option->kind, option->section, option->info);
12171 len = sizeof (* eopt);
12172 while (len < option->size)
12173 if (((char *) option)[len] >= ' '
12174 && ((char *) option)[len] < 0x7f)
12175 printf ("%c", ((char *) option)[len++]);
12177 printf ("\\%03o", ((char *) option)[len++]);
12179 fputs ("\n", stdout);
12187 if (conflicts_offset != 0 && conflictsno != 0)
12189 Elf32_Conflict * iconf;
12192 if (dynamic_symbols == NULL)
12194 error (_("conflict list found without a dynamic symbol table\n"));
12198 iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
12201 error (_("Out of memory\n"));
12207 Elf32_External_Conflict * econf32;
12209 econf32 = (Elf32_External_Conflict *)
12210 get_data (NULL, file, conflicts_offset, conflictsno,
12211 sizeof (* econf32), _("conflict"));
12215 for (cnt = 0; cnt < conflictsno; ++cnt)
12216 iconf[cnt] = BYTE_GET (econf32[cnt]);
12222 Elf64_External_Conflict * econf64;
12224 econf64 = (Elf64_External_Conflict *)
12225 get_data (NULL, file, conflicts_offset, conflictsno,
12226 sizeof (* econf64), _("conflict"));
12230 for (cnt = 0; cnt < conflictsno; ++cnt)
12231 iconf[cnt] = BYTE_GET (econf64[cnt]);
12236 printf (_("\nSection '.conflict' contains %lu entries:\n"),
12237 (unsigned long) conflictsno);
12238 puts (_(" Num: Index Value Name"));
12240 for (cnt = 0; cnt < conflictsno; ++cnt)
12242 Elf_Internal_Sym * psym = & dynamic_symbols[iconf[cnt]];
12244 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
12245 print_vma (psym->st_value, FULL_HEX);
12247 if (VALID_DYNAMIC_NAME (psym->st_name))
12248 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
12250 printf (_("<corrupt: %14ld>"), psym->st_name);
12257 if (pltgot != 0 && local_gotno != 0)
12259 bfd_vma ent, local_end, global_end;
12261 unsigned char * data;
12265 addr_size = (is_32bit_elf ? 4 : 8);
12266 local_end = pltgot + local_gotno * addr_size;
12267 global_end = local_end + (symtabno - gotsym) * addr_size;
12269 offset = offset_from_vma (file, pltgot, global_end - pltgot);
12270 data = (unsigned char *) get_data (NULL, file, offset,
12271 global_end - pltgot, 1,
12272 _("Global Offset Table data"));
12276 printf (_("\nPrimary GOT:\n"));
12277 printf (_(" Canonical gp value: "));
12278 print_vma (pltgot + 0x7ff0, LONG_HEX);
12281 printf (_(" Reserved entries:\n"));
12282 printf (_(" %*s %10s %*s Purpose\n"),
12283 addr_size * 2, _("Address"), _("Access"),
12284 addr_size * 2, _("Initial"));
12285 ent = print_mips_got_entry (data, pltgot, ent);
12286 printf (_(" Lazy resolver\n"));
12288 && (byte_get (data + ent - pltgot, addr_size)
12289 >> (addr_size * 8 - 1)) != 0)
12291 ent = print_mips_got_entry (data, pltgot, ent);
12292 printf (_(" Module pointer (GNU extension)\n"));
12296 if (ent < local_end)
12298 printf (_(" Local entries:\n"));
12299 printf (" %*s %10s %*s\n",
12300 addr_size * 2, _("Address"), _("Access"),
12301 addr_size * 2, _("Initial"));
12302 while (ent < local_end)
12304 ent = print_mips_got_entry (data, pltgot, ent);
12310 if (gotsym < symtabno)
12314 printf (_(" Global entries:\n"));
12315 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
12316 addr_size * 2, _("Address"),
12318 addr_size * 2, _("Initial"),
12319 addr_size * 2, _("Sym.Val."),
12321 /* Note for translators: "Ndx" = abbreviated form of "Index". */
12322 _("Ndx"), _("Name"));
12324 sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
12325 for (i = gotsym; i < symtabno; i++)
12327 Elf_Internal_Sym * psym;
12329 psym = dynamic_symbols + i;
12330 ent = print_mips_got_entry (data, pltgot, ent);
12332 print_vma (psym->st_value, LONG_HEX);
12333 printf (" %-7s %3s ",
12334 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
12335 get_symbol_index_type (psym->st_shndx));
12336 if (VALID_DYNAMIC_NAME (psym->st_name))
12337 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
12339 printf (_("<corrupt: %14ld>"), psym->st_name);
12349 if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
12352 size_t offset, rel_offset;
12353 unsigned long count, i;
12354 unsigned char * data;
12355 int addr_size, sym_width;
12356 Elf_Internal_Rela * rels;
12358 rel_offset = offset_from_vma (file, jmprel, pltrelsz);
12359 if (pltrel == DT_RELA)
12361 if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
12366 if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
12371 addr_size = (is_32bit_elf ? 4 : 8);
12372 end = mips_pltgot + (2 + count) * addr_size;
12374 offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
12375 data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
12376 1, _("Procedure Linkage Table data"));
12380 printf ("\nPLT GOT:\n\n");
12381 printf (_(" Reserved entries:\n"));
12382 printf (_(" %*s %*s Purpose\n"),
12383 addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
12384 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
12385 printf (_(" PLT lazy resolver\n"));
12386 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
12387 printf (_(" Module pointer\n"));
12390 printf (_(" Entries:\n"));
12391 printf (" %*s %*s %*s %-7s %3s %s\n",
12392 addr_size * 2, _("Address"),
12393 addr_size * 2, _("Initial"),
12394 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
12395 sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
12396 for (i = 0; i < count; i++)
12398 Elf_Internal_Sym * psym;
12400 psym = dynamic_symbols + get_reloc_symindex (rels[i].r_info);
12401 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
12403 print_vma (psym->st_value, LONG_HEX);
12404 printf (" %-7s %3s ",
12405 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
12406 get_symbol_index_type (psym->st_shndx));
12407 if (VALID_DYNAMIC_NAME (psym->st_name))
12408 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
12410 printf (_("<corrupt: %14ld>"), psym->st_name);
12424 process_gnu_liblist (FILE * file)
12426 Elf_Internal_Shdr * section;
12427 Elf_Internal_Shdr * string_sec;
12428 Elf32_External_Lib * elib;
12430 size_t strtab_size;
12437 for (i = 0, section = section_headers;
12438 i < elf_header.e_shnum;
12441 switch (section->sh_type)
12443 case SHT_GNU_LIBLIST:
12444 if (section->sh_link >= elf_header.e_shnum)
12447 elib = (Elf32_External_Lib *)
12448 get_data (NULL, file, section->sh_offset, 1, section->sh_size,
12449 _("liblist section data"));
12453 string_sec = section_headers + section->sh_link;
12455 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
12456 string_sec->sh_size,
12457 _("liblist string table"));
12459 || section->sh_entsize != sizeof (Elf32_External_Lib))
12465 strtab_size = string_sec->sh_size;
12467 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
12468 SECTION_NAME (section),
12469 (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
12471 puts (_(" Library Time Stamp Checksum Version Flags"));
12473 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
12481 liblist.l_name = BYTE_GET (elib[cnt].l_name);
12482 atime = BYTE_GET (elib[cnt].l_time_stamp);
12483 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
12484 liblist.l_version = BYTE_GET (elib[cnt].l_version);
12485 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
12487 tmp = gmtime (&atime);
12488 snprintf (timebuf, sizeof (timebuf),
12489 "%04u-%02u-%02uT%02u:%02u:%02u",
12490 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
12491 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
12493 printf ("%3lu: ", (unsigned long) cnt);
12495 printf ("%-20s", liblist.l_name < strtab_size
12496 ? strtab + liblist.l_name : _("<corrupt>"));
12498 printf ("%-20.20s", liblist.l_name < strtab_size
12499 ? strtab + liblist.l_name : _("<corrupt>"));
12500 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
12501 liblist.l_version, liblist.l_flags);
12512 static const char *
12513 get_note_type (unsigned e_type)
12515 static char buff[64];
12517 if (elf_header.e_type == ET_CORE)
12521 return _("NT_AUXV (auxiliary vector)");
12523 return _("NT_PRSTATUS (prstatus structure)");
12525 return _("NT_FPREGSET (floating point registers)");
12527 return _("NT_PRPSINFO (prpsinfo structure)");
12528 case NT_TASKSTRUCT:
12529 return _("NT_TASKSTRUCT (task structure)");
12531 return _("NT_PRXFPREG (user_xfpregs structure)");
12533 return _("NT_PPC_VMX (ppc Altivec registers)");
12535 return _("NT_PPC_VSX (ppc VSX registers)");
12536 case NT_X86_XSTATE:
12537 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
12538 case NT_S390_HIGH_GPRS:
12539 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
12540 case NT_S390_TIMER:
12541 return _("NT_S390_TIMER (s390 timer register)");
12542 case NT_S390_TODCMP:
12543 return _("NT_S390_TODCMP (s390 TOD comparator register)");
12544 case NT_S390_TODPREG:
12545 return _("NT_S390_TODPREG (s390 TOD programmable register)");
12547 return _("NT_S390_CTRS (s390 control registers)");
12548 case NT_S390_PREFIX:
12549 return _("NT_S390_PREFIX (s390 prefix register)");
12551 return _("NT_ARM_VFP (arm VFP registers)");
12553 return _("NT_PSTATUS (pstatus structure)");
12555 return _("NT_FPREGS (floating point registers)");
12557 return _("NT_PSINFO (psinfo structure)");
12559 return _("NT_LWPSTATUS (lwpstatus_t structure)");
12561 return _("NT_LWPSINFO (lwpsinfo_t structure)");
12562 case NT_WIN32PSTATUS:
12563 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
12571 return _("NT_VERSION (version)");
12573 return _("NT_ARCH (architecture)");
12578 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
12582 static const char *
12583 get_gnu_elf_note_type (unsigned e_type)
12585 static char buff[64];
12589 case NT_GNU_ABI_TAG:
12590 return _("NT_GNU_ABI_TAG (ABI version tag)");
12592 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
12593 case NT_GNU_BUILD_ID:
12594 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
12595 case NT_GNU_GOLD_VERSION:
12596 return _("NT_GNU_GOLD_VERSION (gold version)");
12601 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
12606 print_gnu_note (Elf_Internal_Note *pnote)
12608 switch (pnote->type)
12610 case NT_GNU_BUILD_ID:
12614 printf (_(" Build ID: "));
12615 for (i = 0; i < pnote->descsz; ++i)
12616 printf ("%02x", pnote->descdata[i] & 0xff);
12621 case NT_GNU_ABI_TAG:
12623 unsigned long os, major, minor, subminor;
12624 const char *osname;
12626 os = byte_get ((unsigned char *) pnote->descdata, 4);
12627 major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
12628 minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
12629 subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
12633 case GNU_ABI_TAG_LINUX:
12636 case GNU_ABI_TAG_HURD:
12639 case GNU_ABI_TAG_SOLARIS:
12640 osname = "Solaris";
12642 case GNU_ABI_TAG_FREEBSD:
12643 osname = "FreeBSD";
12645 case GNU_ABI_TAG_NETBSD:
12649 osname = "Unknown";
12653 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname,
12654 major, minor, subminor);
12662 static const char *
12663 get_netbsd_elfcore_note_type (unsigned e_type)
12665 static char buff[64];
12667 if (e_type == NT_NETBSDCORE_PROCINFO)
12669 /* NetBSD core "procinfo" structure. */
12670 return _("NetBSD procinfo structure");
12673 /* As of Jan 2002 there are no other machine-independent notes
12674 defined for NetBSD core files. If the note type is less
12675 than the start of the machine-dependent note types, we don't
12678 if (e_type < NT_NETBSDCORE_FIRSTMACH)
12680 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
12684 switch (elf_header.e_machine)
12686 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
12687 and PT_GETFPREGS == mach+2. */
12692 case EM_SPARC32PLUS:
12696 case NT_NETBSDCORE_FIRSTMACH + 0:
12697 return _("PT_GETREGS (reg structure)");
12698 case NT_NETBSDCORE_FIRSTMACH + 2:
12699 return _("PT_GETFPREGS (fpreg structure)");
12705 /* On all other arch's, PT_GETREGS == mach+1 and
12706 PT_GETFPREGS == mach+3. */
12710 case NT_NETBSDCORE_FIRSTMACH + 1:
12711 return _("PT_GETREGS (reg structure)");
12712 case NT_NETBSDCORE_FIRSTMACH + 3:
12713 return _("PT_GETFPREGS (fpreg structure)");
12719 snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
12720 e_type - NT_NETBSDCORE_FIRSTMACH);
12724 static const char *
12725 get_stapsdt_note_type (unsigned e_type)
12727 static char buff[64];
12732 return _("NT_STAPSDT (SystemTap probe descriptors)");
12738 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
12743 print_stapsdt_note (Elf_Internal_Note *pnote)
12745 int addr_size = is_32bit_elf ? 4 : 8;
12746 char *data = pnote->descdata;
12747 char *data_end = pnote->descdata + pnote->descsz;
12748 bfd_vma pc, base_addr, semaphore;
12749 char *provider, *probe, *arg_fmt;
12751 pc = byte_get ((unsigned char *) data, addr_size);
12753 base_addr = byte_get ((unsigned char *) data, addr_size);
12755 semaphore = byte_get ((unsigned char *) data, addr_size);
12759 data += strlen (data) + 1;
12761 data += strlen (data) + 1;
12763 data += strlen (data) + 1;
12765 printf (_(" Provider: %s\n"), provider);
12766 printf (_(" Name: %s\n"), probe);
12767 printf (_(" Location: "));
12768 print_vma (pc, FULL_HEX);
12769 printf (_(", Base: "));
12770 print_vma (base_addr, FULL_HEX);
12771 printf (_(", Semaphore: "));
12772 print_vma (semaphore, FULL_HEX);
12774 printf (_(" Arguments: %s\n"), arg_fmt);
12776 return data == data_end;
12779 static const char *
12780 get_ia64_vms_note_type (unsigned e_type)
12782 static char buff[64];
12787 return _("NT_VMS_MHD (module header)");
12789 return _("NT_VMS_LNM (language name)");
12791 return _("NT_VMS_SRC (source files)");
12793 return "NT_VMS_TITLE";
12795 return _("NT_VMS_EIDC (consistency check)");
12796 case NT_VMS_FPMODE:
12797 return _("NT_VMS_FPMODE (FP mode)");
12798 case NT_VMS_LINKTIME:
12799 return "NT_VMS_LINKTIME";
12800 case NT_VMS_IMGNAM:
12801 return _("NT_VMS_IMGNAM (image name)");
12803 return _("NT_VMS_IMGID (image id)");
12804 case NT_VMS_LINKID:
12805 return _("NT_VMS_LINKID (link id)");
12806 case NT_VMS_IMGBID:
12807 return _("NT_VMS_IMGBID (build id)");
12808 case NT_VMS_GSTNAM:
12809 return _("NT_VMS_GSTNAM (sym table name)");
12810 case NT_VMS_ORIG_DYN:
12811 return "NT_VMS_ORIG_DYN";
12812 case NT_VMS_PATCHTIME:
12813 return "NT_VMS_PATCHTIME";
12815 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
12821 print_ia64_vms_note (Elf_Internal_Note * pnote)
12823 switch (pnote->type)
12826 if (pnote->descsz > 36)
12828 size_t l = strlen (pnote->descdata + 34);
12829 printf (_(" Creation date : %.17s\n"), pnote->descdata);
12830 printf (_(" Last patch date: %.17s\n"), pnote->descdata + 17);
12831 printf (_(" Module name : %s\n"), pnote->descdata + 34);
12832 printf (_(" Module version : %s\n"), pnote->descdata + 34 + l + 1);
12835 printf (_(" Invalid size\n"));
12838 printf (_(" Language: %s\n"), pnote->descdata);
12841 case NT_VMS_FPMODE:
12842 printf (_(" Floating Point mode: "));
12843 printf ("0x%016" BFD_VMA_FMT "x\n",
12844 (bfd_vma)byte_get ((unsigned char *)pnote->descdata, 8));
12846 case NT_VMS_LINKTIME:
12847 printf (_(" Link time: "));
12849 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
12852 case NT_VMS_PATCHTIME:
12853 printf (_(" Patch time: "));
12855 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
12858 case NT_VMS_ORIG_DYN:
12859 printf (_(" Major id: %u, minor id: %u\n"),
12860 (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
12861 (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
12862 printf (_(" Last modified : "));
12864 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
12865 printf (_("\n Link flags : "));
12866 printf ("0x%016" BFD_VMA_FMT "x\n",
12867 (bfd_vma)byte_get ((unsigned char *)pnote->descdata + 16, 8));
12868 printf (_(" Header flags: 0x%08x\n"),
12869 (unsigned)byte_get ((unsigned char *)pnote->descdata + 24, 4));
12870 printf (_(" Image id : %s\n"), pnote->descdata + 32);
12873 case NT_VMS_IMGNAM:
12874 printf (_(" Image name: %s\n"), pnote->descdata);
12876 case NT_VMS_GSTNAM:
12877 printf (_(" Global symbol table name: %s\n"), pnote->descdata);
12880 printf (_(" Image id: %s\n"), pnote->descdata);
12882 case NT_VMS_LINKID:
12883 printf (_(" Linker id: %s\n"), pnote->descdata);
12891 /* Note that by the ELF standard, the name field is already null byte
12892 terminated, and namesz includes the terminating null byte.
12893 I.E. the value of namesz for the name "FSF" is 4.
12895 If the value of namesz is zero, there is no name present. */
12897 process_note (Elf_Internal_Note * pnote)
12899 const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
12902 if (pnote->namesz == 0)
12903 /* If there is no note name, then use the default set of
12904 note type strings. */
12905 nt = get_note_type (pnote->type);
12907 else if (const_strneq (pnote->namedata, "GNU"))
12908 /* GNU-specific object file notes. */
12909 nt = get_gnu_elf_note_type (pnote->type);
12911 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
12912 /* NetBSD-specific core file notes. */
12913 nt = get_netbsd_elfcore_note_type (pnote->type);
12915 else if (strneq (pnote->namedata, "SPU/", 4))
12917 /* SPU-specific core file notes. */
12918 nt = pnote->namedata + 4;
12922 else if (const_strneq (pnote->namedata, "IPF/VMS"))
12923 /* VMS/ia64-specific file notes. */
12924 nt = get_ia64_vms_note_type (pnote->type);
12926 else if (const_strneq (pnote->namedata, "stapsdt"))
12927 nt = get_stapsdt_note_type (pnote->type);
12930 /* Don't recognize this note name; just use the default set of
12931 note type strings. */
12932 nt = get_note_type (pnote->type);
12934 printf (" %-20s 0x%08lx\t%s\n", name, pnote->descsz, nt);
12936 if (const_strneq (pnote->namedata, "IPF/VMS"))
12937 return print_ia64_vms_note (pnote);
12938 else if (const_strneq (pnote->namedata, "GNU"))
12939 return print_gnu_note (pnote);
12940 else if (const_strneq (pnote->namedata, "stapsdt"))
12941 return print_stapsdt_note (pnote);
12948 process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
12950 Elf_External_Note * pnotes;
12951 Elf_External_Note * external;
12957 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
12959 if (pnotes == NULL)
12964 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
12965 (unsigned long) offset, (unsigned long) length);
12966 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
12968 while (external < (Elf_External_Note *) ((char *) pnotes + length))
12970 Elf_External_Note * next;
12971 Elf_Internal_Note inote;
12972 char * temp = NULL;
12974 if (!is_ia64_vms ())
12976 inote.type = BYTE_GET (external->type);
12977 inote.namesz = BYTE_GET (external->namesz);
12978 inote.namedata = external->name;
12979 inote.descsz = BYTE_GET (external->descsz);
12980 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
12981 inote.descpos = offset + (inote.descdata - (char *) pnotes);
12983 next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
12987 Elf64_External_VMS_Note *vms_external;
12989 vms_external = (Elf64_External_VMS_Note *)external;
12990 inote.type = BYTE_GET (vms_external->type);
12991 inote.namesz = BYTE_GET (vms_external->namesz);
12992 inote.namedata = vms_external->name;
12993 inote.descsz = BYTE_GET (vms_external->descsz);
12994 inote.descdata = inote.namedata + align_power (inote.namesz, 3);
12995 inote.descpos = offset + (inote.descdata - (char *) pnotes);
12997 next = (Elf_External_Note *)
12998 (inote.descdata + align_power (inote.descsz, 3));
13001 if ( ((char *) next > ((char *) pnotes) + length)
13002 || ((char *) next < (char *) pnotes))
13004 warn (_("corrupt note found at offset %lx into core notes\n"),
13005 (unsigned long) ((char *) external - (char *) pnotes));
13006 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
13007 inote.type, inote.namesz, inote.descsz);
13013 /* Prevent out-of-bounds indexing. */
13014 if (inote.namedata + inote.namesz > (char *) pnotes + length
13015 || inote.namedata + inote.namesz < inote.namedata)
13017 warn (_("corrupt note found at offset %lx into core notes\n"),
13018 (unsigned long) ((char *) external - (char *) pnotes));
13019 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
13020 inote.type, inote.namesz, inote.descsz);
13024 /* Verify that name is null terminated. It appears that at least
13025 one version of Linux (RedHat 6.0) generates corefiles that don't
13026 comply with the ELF spec by failing to include the null byte in
13028 if (inote.namedata[inote.namesz - 1] != '\0')
13030 temp = (char *) malloc (inote.namesz + 1);
13034 error (_("Out of memory\n"));
13039 strncpy (temp, inote.namedata, inote.namesz);
13040 temp[inote.namesz] = 0;
13042 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
13043 inote.namedata = temp;
13046 res &= process_note (& inote);
13061 process_corefile_note_segments (FILE * file)
13063 Elf_Internal_Phdr * segment;
13067 if (! get_program_headers (file))
13070 for (i = 0, segment = program_headers;
13071 i < elf_header.e_phnum;
13074 if (segment->p_type == PT_NOTE)
13075 res &= process_corefile_note_segment (file,
13076 (bfd_vma) segment->p_offset,
13077 (bfd_vma) segment->p_filesz);
13084 process_note_sections (FILE * file)
13086 Elf_Internal_Shdr * section;
13090 for (i = 0, section = section_headers;
13091 i < elf_header.e_shnum && section != NULL;
13093 if (section->sh_type == SHT_NOTE)
13094 res &= process_corefile_note_segment (file,
13095 (bfd_vma) section->sh_offset,
13096 (bfd_vma) section->sh_size);
13102 process_notes (FILE * file)
13104 /* If we have not been asked to display the notes then do nothing. */
13108 if (elf_header.e_type != ET_CORE)
13109 return process_note_sections (file);
13111 /* No program headers means no NOTE segment. */
13112 if (elf_header.e_phnum > 0)
13113 return process_corefile_note_segments (file);
13115 printf (_("No note segments present in the core file.\n"));
13120 process_arch_specific (FILE * file)
13125 switch (elf_header.e_machine)
13128 return process_arm_specific (file);
13130 case EM_MIPS_RS3_LE:
13131 return process_mips_specific (file);
13134 return process_power_specific (file);
13137 case EM_SPARC32PLUS:
13139 return process_sparc_specific (file);
13142 return process_tic6x_specific (file);
13151 get_file_header (FILE * file)
13153 /* Read in the identity array. */
13154 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
13157 /* Determine how to read the rest of the header. */
13158 switch (elf_header.e_ident[EI_DATA])
13160 default: /* fall through */
13161 case ELFDATANONE: /* fall through */
13163 byte_get = byte_get_little_endian;
13164 byte_put = byte_put_little_endian;
13167 byte_get = byte_get_big_endian;
13168 byte_put = byte_put_big_endian;
13172 /* For now we only support 32 bit and 64 bit ELF files. */
13173 is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
13175 /* Read in the rest of the header. */
13178 Elf32_External_Ehdr ehdr32;
13180 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
13183 elf_header.e_type = BYTE_GET (ehdr32.e_type);
13184 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
13185 elf_header.e_version = BYTE_GET (ehdr32.e_version);
13186 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
13187 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
13188 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
13189 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
13190 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
13191 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
13192 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
13193 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
13194 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
13195 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
13199 Elf64_External_Ehdr ehdr64;
13201 /* If we have been compiled with sizeof (bfd_vma) == 4, then
13202 we will not be able to cope with the 64bit data found in
13203 64 ELF files. Detect this now and abort before we start
13204 overwriting things. */
13205 if (sizeof (bfd_vma) < 8)
13207 error (_("This instance of readelf has been built without support for a\n\
13208 64 bit data type and so it cannot read 64 bit ELF files.\n"));
13212 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
13215 elf_header.e_type = BYTE_GET (ehdr64.e_type);
13216 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
13217 elf_header.e_version = BYTE_GET (ehdr64.e_version);
13218 elf_header.e_entry = BYTE_GET (ehdr64.e_entry);
13219 elf_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
13220 elf_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
13221 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
13222 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
13223 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
13224 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
13225 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
13226 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
13227 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
13230 if (elf_header.e_shoff)
13232 /* There may be some extensions in the first section header. Don't
13233 bomb if we can't read it. */
13235 get_32bit_section_headers (file, 1);
13237 get_64bit_section_headers (file, 1);
13243 /* Process one ELF object file according to the command line options.
13244 This file may actually be stored in an archive. The file is
13245 positioned at the start of the ELF object. */
13248 process_object (char * file_name, FILE * file)
13252 if (! get_file_header (file))
13254 error (_("%s: Failed to read file header\n"), file_name);
13258 /* Initialise per file variables. */
13259 for (i = ARRAY_SIZE (version_info); i--;)
13260 version_info[i] = 0;
13262 for (i = ARRAY_SIZE (dynamic_info); i--;)
13263 dynamic_info[i] = 0;
13264 dynamic_info_DT_GNU_HASH = 0;
13266 /* Process the file. */
13268 printf (_("\nFile: %s\n"), file_name);
13270 /* Initialise the dump_sects array from the cmdline_dump_sects array.
13271 Note we do this even if cmdline_dump_sects is empty because we
13272 must make sure that the dump_sets array is zeroed out before each
13273 object file is processed. */
13274 if (num_dump_sects > num_cmdline_dump_sects)
13275 memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
13277 if (num_cmdline_dump_sects > 0)
13279 if (num_dump_sects == 0)
13280 /* A sneaky way of allocating the dump_sects array. */
13281 request_dump_bynumber (num_cmdline_dump_sects, 0);
13283 assert (num_dump_sects >= num_cmdline_dump_sects);
13284 memcpy (dump_sects, cmdline_dump_sects,
13285 num_cmdline_dump_sects * sizeof (* dump_sects));
13288 if (! process_file_header ())
13291 if (! process_section_headers (file))
13293 /* Without loaded section headers we cannot process lots of
13295 do_unwind = do_version = do_dump = do_arch = 0;
13297 if (! do_using_dynamic)
13298 do_syms = do_dyn_syms = do_reloc = 0;
13301 if (! process_section_groups (file))
13303 /* Without loaded section groups we cannot process unwind. */
13307 if (process_program_headers (file))
13308 process_dynamic_section (file);
13310 process_relocs (file);
13312 process_unwind (file);
13314 process_symbol_table (file);
13316 process_syminfo (file);
13318 process_version_sections (file);
13320 process_section_contents (file);
13322 process_notes (file);
13324 process_gnu_liblist (file);
13326 process_arch_specific (file);
13328 if (program_headers)
13330 free (program_headers);
13331 program_headers = NULL;
13334 if (section_headers)
13336 free (section_headers);
13337 section_headers = NULL;
13342 free (string_table);
13343 string_table = NULL;
13344 string_table_length = 0;
13347 if (dynamic_strings)
13349 free (dynamic_strings);
13350 dynamic_strings = NULL;
13351 dynamic_strings_length = 0;
13354 if (dynamic_symbols)
13356 free (dynamic_symbols);
13357 dynamic_symbols = NULL;
13358 num_dynamic_syms = 0;
13361 if (dynamic_syminfo)
13363 free (dynamic_syminfo);
13364 dynamic_syminfo = NULL;
13367 if (dynamic_section)
13369 free (dynamic_section);
13370 dynamic_section = NULL;
13373 if (section_headers_groups)
13375 free (section_headers_groups);
13376 section_headers_groups = NULL;
13379 if (section_groups)
13381 struct group_list * g;
13382 struct group_list * next;
13384 for (i = 0; i < group_count; i++)
13386 for (g = section_groups [i].root; g != NULL; g = next)
13393 free (section_groups);
13394 section_groups = NULL;
13397 free_debug_memory ();
13402 /* Process an ELF archive.
13403 On entry the file is positioned just after the ARMAG string. */
13406 process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
13408 struct archive_info arch;
13409 struct archive_info nested_arch;
13415 /* The ARCH structure is used to hold information about this archive. */
13416 arch.file_name = NULL;
13418 arch.index_array = NULL;
13419 arch.sym_table = NULL;
13420 arch.longnames = NULL;
13422 /* The NESTED_ARCH structure is used as a single-item cache of information
13423 about a nested archive (when members of a thin archive reside within
13424 another regular archive file). */
13425 nested_arch.file_name = NULL;
13426 nested_arch.file = NULL;
13427 nested_arch.index_array = NULL;
13428 nested_arch.sym_table = NULL;
13429 nested_arch.longnames = NULL;
13431 if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
13437 if (do_archive_index)
13439 if (arch.sym_table == NULL)
13440 error (_("%s: unable to dump the index as none was found\n"), file_name);
13444 unsigned long current_pos;
13446 printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
13447 file_name, arch.index_num, arch.sym_size);
13448 current_pos = ftell (file);
13450 for (i = l = 0; i < arch.index_num; i++)
13452 if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
13454 char * member_name;
13456 member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
13458 if (member_name != NULL)
13460 char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
13462 if (qualified_name != NULL)
13464 printf (_("Binary %s contains:\n"), qualified_name);
13465 free (qualified_name);
13470 if (l >= arch.sym_size)
13472 error (_("%s: end of the symbol table reached before the end of the index\n"),
13476 printf ("\t%s\n", arch.sym_table + l);
13477 l += strlen (arch.sym_table + l) + 1;
13482 if (l < arch.sym_size)
13483 error (_("%s: symbols remain in the index symbol table, but without corresponding entries in the index table\n"),
13486 if (fseek (file, current_pos, SEEK_SET) != 0)
13488 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
13494 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
13495 && !do_segments && !do_header && !do_dump && !do_version
13496 && !do_histogram && !do_debugging && !do_arch && !do_notes
13497 && !do_section_groups && !do_dyn_syms)
13499 ret = 0; /* Archive index only. */
13510 char * qualified_name;
13512 /* Read the next archive header. */
13513 if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
13515 error (_("%s: failed to seek to next archive header\n"), file_name);
13518 got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
13519 if (got != sizeof arch.arhdr)
13523 error (_("%s: failed to read archive header\n"), file_name);
13527 if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
13529 error (_("%s: did not find a valid archive header\n"), arch.file_name);
13534 arch.next_arhdr_offset += sizeof arch.arhdr;
13536 archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
13537 if (archive_file_size & 01)
13538 ++archive_file_size;
13540 name = get_archive_member_name (&arch, &nested_arch);
13543 error (_("%s: bad archive file name\n"), file_name);
13547 namelen = strlen (name);
13549 qualified_name = make_qualified_name (&arch, &nested_arch, name);
13550 if (qualified_name == NULL)
13552 error (_("%s: bad archive file name\n"), file_name);
13557 if (is_thin_archive && arch.nested_member_origin == 0)
13559 /* This is a proxy for an external member of a thin archive. */
13560 FILE * member_file;
13561 char * member_file_name = adjust_relative_path (file_name, name, namelen);
13562 if (member_file_name == NULL)
13568 member_file = fopen (member_file_name, "rb");
13569 if (member_file == NULL)
13571 error (_("Input file '%s' is not readable.\n"), member_file_name);
13572 free (member_file_name);
13577 archive_file_offset = arch.nested_member_origin;
13579 ret |= process_object (qualified_name, member_file);
13581 fclose (member_file);
13582 free (member_file_name);
13584 else if (is_thin_archive)
13586 /* This is a proxy for a member of a nested archive. */
13587 archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
13589 /* The nested archive file will have been opened and setup by
13590 get_archive_member_name. */
13591 if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
13593 error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
13598 ret |= process_object (qualified_name, nested_arch.file);
13602 archive_file_offset = arch.next_arhdr_offset;
13603 arch.next_arhdr_offset += archive_file_size;
13605 ret |= process_object (qualified_name, file);
13608 if (dump_sects != NULL)
13612 num_dump_sects = 0;
13615 free (qualified_name);
13619 if (nested_arch.file != NULL)
13620 fclose (nested_arch.file);
13621 release_archive (&nested_arch);
13622 release_archive (&arch);
13628 process_file (char * file_name)
13631 struct stat statbuf;
13632 char armag[SARMAG];
13635 if (stat (file_name, &statbuf) < 0)
13637 if (errno == ENOENT)
13638 error (_("'%s': No such file\n"), file_name);
13640 error (_("Could not locate '%s'. System error message: %s\n"),
13641 file_name, strerror (errno));
13645 if (! S_ISREG (statbuf.st_mode))
13647 error (_("'%s' is not an ordinary file\n"), file_name);
13651 file = fopen (file_name, "rb");
13654 error (_("Input file '%s' is not readable.\n"), file_name);
13658 if (fread (armag, SARMAG, 1, file) != 1)
13660 error (_("%s: Failed to read file's magic number\n"), file_name);
13665 if (memcmp (armag, ARMAG, SARMAG) == 0)
13666 ret = process_archive (file_name, file, FALSE);
13667 else if (memcmp (armag, ARMAGT, SARMAG) == 0)
13668 ret = process_archive (file_name, file, TRUE);
13671 if (do_archive_index)
13672 error (_("File %s is not an archive so its index cannot be displayed.\n"),
13676 archive_file_size = archive_file_offset = 0;
13677 ret = process_object (file_name, file);
13685 #ifdef SUPPORT_DISASSEMBLY
13686 /* Needed by the i386 disassembler. For extra credit, someone could
13687 fix this so that we insert symbolic addresses here, esp for GOT/PLT
13691 print_address (unsigned int addr, FILE * outfile)
13693 fprintf (outfile,"0x%8.8x", addr);
13696 /* Needed by the i386 disassembler. */
13698 db_task_printsym (unsigned int addr)
13700 print_address (addr, stderr);
13705 main (int argc, char ** argv)
13709 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
13710 setlocale (LC_MESSAGES, "");
13712 #if defined (HAVE_SETLOCALE)
13713 setlocale (LC_CTYPE, "");
13715 bindtextdomain (PACKAGE, LOCALEDIR);
13716 textdomain (PACKAGE);
13718 expandargv (&argc, &argv);
13720 parse_args (argc, argv);
13722 if (num_dump_sects > 0)
13724 /* Make a copy of the dump_sects array. */
13725 cmdline_dump_sects = (dump_type *)
13726 malloc (num_dump_sects * sizeof (* dump_sects));
13727 if (cmdline_dump_sects == NULL)
13728 error (_("Out of memory allocating dump request table.\n"));
13731 memcpy (cmdline_dump_sects, dump_sects,
13732 num_dump_sects * sizeof (* dump_sects));
13733 num_cmdline_dump_sects = num_dump_sects;
13737 if (optind < (argc - 1))
13741 while (optind < argc)
13742 err |= process_file (argv[optind++]);
13744 if (dump_sects != NULL)
13746 if (cmdline_dump_sects != NULL)
13747 free (cmdline_dump_sects);