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, 2013
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. */
56 /* Define BFD64 here, even if our default architecture is 32 bit ELF
57 as this will allow us to read in and parse 64bit and 32bit ELF files.
58 Only do this if we believe that the compiler can support a 64 bit
59 data type. For now we only rely on GCC being able to do this. */
68 #include "elf/common.h"
69 #include "elf/external.h"
70 #include "elf/internal.h"
73 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
74 we can obtain the H8 reloc numbers. We need these for the
75 get_reloc_size() function. We include h8.h again after defining
76 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
81 /* Undo the effects of #including reloc-macros.h. */
83 #undef START_RELOC_NUMBERS
87 #undef END_RELOC_NUMBERS
88 #undef _RELOC_MACROS_H
90 /* The following headers use the elf/reloc-macros.h file to
91 automatically generate relocation recognition functions
92 such as elf_mips_reloc_type() */
94 #define RELOC_MACROS_GEN_FUNC
96 #include "elf/aarch64.h"
97 #include "elf/alpha.h"
101 #include "elf/bfin.h"
102 #include "elf/cr16.h"
103 #include "elf/cris.h"
105 #include "elf/d10v.h"
106 #include "elf/d30v.h"
108 #include "elf/epiphany.h"
109 #include "elf/fr30.h"
112 #include "elf/hppa.h"
113 #include "elf/i386.h"
114 #include "elf/i370.h"
115 #include "elf/i860.h"
116 #include "elf/i960.h"
117 #include "elf/ia64.h"
118 #include "elf/ip2k.h"
119 #include "elf/lm32.h"
120 #include "elf/iq2000.h"
121 #include "elf/m32c.h"
122 #include "elf/m32r.h"
123 #include "elf/m68k.h"
124 #include "elf/m68hc11.h"
125 #include "elf/mcore.h"
127 #include "elf/microblaze.h"
128 #include "elf/mips.h"
129 #include "elf/mmix.h"
130 #include "elf/mn10200.h"
131 #include "elf/mn10300.h"
132 #include "elf/moxie.h"
134 #include "elf/msp430.h"
135 #include "elf/or32.h"
138 #include "elf/ppc64.h"
139 #include "elf/rl78.h"
141 #include "elf/s390.h"
142 #include "elf/score.h"
144 #include "elf/sparc.h"
146 #include "elf/tic6x.h"
147 #include "elf/tilegx.h"
148 #include "elf/tilepro.h"
149 #include "elf/v850.h"
151 #include "elf/x86-64.h"
152 #include "elf/xc16x.h"
153 #include "elf/xgate.h"
154 #include "elf/xstormy16.h"
155 #include "elf/xtensa.h"
158 #include "libiberty.h"
159 #include "safe-ctype.h"
160 #include "filenames.h"
162 char * program_name = "readelf";
163 static long archive_file_offset;
164 static unsigned long archive_file_size;
165 static unsigned long dynamic_addr;
166 static bfd_size_type dynamic_size;
167 static unsigned int dynamic_nent;
168 static char * dynamic_strings;
169 static unsigned long dynamic_strings_length;
170 static char * string_table;
171 static unsigned long string_table_length;
172 static unsigned long num_dynamic_syms;
173 static Elf_Internal_Sym * dynamic_symbols;
174 static Elf_Internal_Syminfo * dynamic_syminfo;
175 static unsigned long dynamic_syminfo_offset;
176 static unsigned int dynamic_syminfo_nent;
177 static char program_interpreter[PATH_MAX];
178 static bfd_vma dynamic_info[DT_ENCODING];
179 static bfd_vma dynamic_info_DT_GNU_HASH;
180 static bfd_vma version_info[16];
181 static Elf_Internal_Ehdr elf_header;
182 static Elf_Internal_Shdr * section_headers;
183 static Elf_Internal_Phdr * program_headers;
184 static Elf_Internal_Dyn * dynamic_section;
185 static Elf_Internal_Shdr * symtab_shndx_hdr;
186 static int show_name;
187 static int do_dynamic;
189 static int do_dyn_syms;
191 static int do_sections;
192 static int do_section_groups;
193 static int do_section_details;
194 static int do_segments;
195 static int do_unwind;
196 static int do_using_dynamic;
197 static int do_header;
199 static int do_version;
200 static int do_histogram;
201 static int do_debugging;
204 static int do_archive_index;
205 static int is_32bit_elf;
209 struct group_list * next;
210 unsigned int section_index;
215 struct group_list * root;
216 unsigned int group_index;
219 static size_t group_count;
220 static struct group * section_groups;
221 static struct group ** section_headers_groups;
224 /* Flag bits indicating particular types of dump. */
225 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
226 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
227 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
228 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
229 #define RELOC_DUMP (1 << 4) /* The -R command line switch. */
231 typedef unsigned char dump_type;
233 /* A linked list of the section names for which dumps were requested. */
234 struct dump_list_entry
238 struct dump_list_entry * next;
240 static struct dump_list_entry * dump_sects_byname;
242 /* A dynamic array of flags indicating for which sections a dump
243 has been requested via command line switches. */
244 static dump_type * cmdline_dump_sects = NULL;
245 static unsigned int num_cmdline_dump_sects = 0;
247 /* A dynamic array of flags indicating for which sections a dump of
248 some kind has been requested. It is reset on a per-object file
249 basis and then initialised from the cmdline_dump_sects array,
250 the results of interpreting the -w switch, and the
251 dump_sects_byname list. */
252 static dump_type * dump_sects = NULL;
253 static unsigned int num_dump_sects = 0;
256 /* How to print a vma value. */
257 typedef enum print_mode
271 #define SECTION_NAME(X) \
272 ((X) == NULL ? _("<none>") \
273 : string_table == NULL ? _("<no-name>") \
274 : ((X)->sh_name >= string_table_length ? _("<corrupt>") \
275 : string_table + (X)->sh_name))
277 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
279 #define GET_ELF_SYMBOLS(file, section, sym_count) \
280 (is_32bit_elf ? get_32bit_elf_symbols (file, section, sym_count) \
281 : get_64bit_elf_symbols (file, section, sym_count))
283 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
284 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
285 already been called and verified that the string exists. */
286 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
288 #define REMOVE_ARCH_BITS(ADDR) \
291 if (elf_header.e_machine == EM_ARM) \
296 /* Retrieve NMEMB structures, each SIZE bytes long from FILE starting at OFFSET.
297 Put the retrieved data into VAR, if it is not NULL. Otherwise allocate a buffer
298 using malloc and fill that. In either case return the pointer to the start of
299 the retrieved data or NULL if something went wrong. If something does go wrong
300 emit an error message using REASON as part of the context. */
303 get_data (void * var, FILE * file, long offset, size_t size, size_t nmemb,
308 if (size == 0 || nmemb == 0)
311 if (fseek (file, archive_file_offset + offset, SEEK_SET))
313 error (_("Unable to seek to 0x%lx for %s\n"),
314 (unsigned long) archive_file_offset + offset, reason);
321 /* Check for overflow. */
322 if (nmemb < (~(size_t) 0 - 1) / size)
323 /* + 1 so that we can '\0' terminate invalid string table sections. */
324 mvar = malloc (size * nmemb + 1);
328 error (_("Out of memory allocating 0x%lx bytes for %s\n"),
329 (unsigned long)(size * nmemb), reason);
333 ((char *) mvar)[size * nmemb] = '\0';
336 if (fread (mvar, size, nmemb, file) != nmemb)
338 error (_("Unable to read in 0x%lx bytes of %s\n"),
339 (unsigned long)(size * nmemb), reason);
348 /* Print a VMA value. */
351 print_vma (bfd_vma vma, print_mode mode)
364 return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
371 return printf ("%5" BFD_VMA_FMT "d", vma);
379 return nc + printf ("%" BFD_VMA_FMT "x", vma);
382 return printf ("%" BFD_VMA_FMT "d", vma);
385 return printf ("%" BFD_VMA_FMT "u", vma);
390 /* Display a symbol on stdout. Handles the display of control characters and
391 multibye characters (assuming the host environment supports them).
393 Display at most abs(WIDTH) characters, truncating as necessary, unless do_wide is true.
395 If WIDTH is negative then ensure that the output is at least (- WIDTH) characters,
396 padding as necessary.
398 Returns the number of emitted characters. */
401 print_symbol (int width, const char *symbol)
403 bfd_boolean extra_padding = FALSE;
405 #ifdef HAVE_MBSTATE_T
412 /* Keep the width positive. This also helps. */
414 extra_padding = TRUE;
418 /* Set the remaining width to a very large value.
419 This simplifies the code below. */
420 width_remaining = INT_MAX;
422 width_remaining = width;
424 #ifdef HAVE_MBSTATE_T
425 /* Initialise the multibyte conversion state. */
426 memset (& state, 0, sizeof (state));
429 while (width_remaining)
432 const char c = *symbol++;
437 /* Do not print control characters directly as they can affect terminal
438 settings. Such characters usually appear in the names generated
439 by the assembler for local labels. */
442 if (width_remaining < 2)
445 printf ("^%c", c + 0x40);
446 width_remaining -= 2;
449 else if (ISPRINT (c))
457 #ifdef HAVE_MBSTATE_T
460 /* Let printf do the hard work of displaying multibyte characters. */
461 printf ("%.1s", symbol - 1);
465 #ifdef HAVE_MBSTATE_T
466 /* Try to find out how many bytes made up the character that was
467 just printed. Advance the symbol pointer past the bytes that
469 n = mbrtowc (& w, symbol - 1, MB_CUR_MAX, & state);
473 if (n != (size_t) -1 && n != (size_t) -2 && n > 0)
478 if (extra_padding && num_printed < width)
480 /* Fill in the remaining spaces. */
481 printf ("%-*s", width - num_printed, " ");
488 /* Return a pointer to section NAME, or NULL if no such section exists. */
490 static Elf_Internal_Shdr *
491 find_section (const char * name)
495 for (i = 0; i < elf_header.e_shnum; i++)
496 if (streq (SECTION_NAME (section_headers + i), name))
497 return section_headers + i;
502 /* Return a pointer to a section containing ADDR, or NULL if no such
505 static Elf_Internal_Shdr *
506 find_section_by_address (bfd_vma addr)
510 for (i = 0; i < elf_header.e_shnum; i++)
512 Elf_Internal_Shdr *sec = section_headers + i;
513 if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
520 /* Return a pointer to section NAME, or NULL if no such section exists,
521 restricted to the list of sections given in SET. */
523 static Elf_Internal_Shdr *
524 find_section_in_set (const char * name, unsigned int * set)
530 while ((i = *set++) > 0)
531 if (streq (SECTION_NAME (section_headers + i), name))
532 return section_headers + i;
535 return find_section (name);
538 /* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
542 read_uleb128 (unsigned char *data, unsigned int *length_return)
544 return read_leb128 (data, length_return, 0);
547 /* Return true if the current file is for IA-64 machine and OpenVMS ABI.
548 This OS has so many departures from the ELF standard that we test it at
554 return elf_header.e_machine == EM_IA_64
555 && elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
558 /* Guess the relocation size commonly used by the specific machines. */
561 guess_is_rela (unsigned int e_machine)
565 /* Targets that use REL relocations. */
582 /* Targets that use RELA relocations. */
586 case EM_ADAPTEVA_EPIPHANY:
588 case EM_ALTERA_NIOS2:
607 case EM_LATTICEMICO32:
615 case EM_CYGNUS_MN10200:
617 case EM_CYGNUS_MN10300:
648 case EM_MICROBLAZE_OLD:
669 warn (_("Don't know about relocations on this machine architecture\n"));
675 slurp_rela_relocs (FILE * file,
676 unsigned long rel_offset,
677 unsigned long rel_size,
678 Elf_Internal_Rela ** relasp,
679 unsigned long * nrelasp)
681 Elf_Internal_Rela * relas;
682 unsigned long nrelas;
687 Elf32_External_Rela * erelas;
689 erelas = (Elf32_External_Rela *) get_data (NULL, file, rel_offset, 1,
690 rel_size, _("32-bit relocation data"));
694 nrelas = rel_size / sizeof (Elf32_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);
717 Elf64_External_Rela * erelas;
719 erelas = (Elf64_External_Rela *) get_data (NULL, file, rel_offset, 1,
720 rel_size, _("64-bit relocation data"));
724 nrelas = rel_size / sizeof (Elf64_External_Rela);
726 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
727 sizeof (Elf_Internal_Rela));
732 error (_("out of memory parsing relocs\n"));
736 for (i = 0; i < nrelas; i++)
738 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
739 relas[i].r_info = BYTE_GET (erelas[i].r_info);
740 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
742 /* The #ifdef BFD64 below is to prevent a compile time
743 warning. We know that if we do not have a 64 bit data
744 type that we will never execute this code anyway. */
746 if (elf_header.e_machine == EM_MIPS
747 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
749 /* In little-endian objects, r_info isn't really a
750 64-bit little-endian value: it has a 32-bit
751 little-endian symbol index followed by four
752 individual byte fields. Reorder INFO
754 bfd_vma inf = relas[i].r_info;
755 inf = (((inf & 0xffffffff) << 32)
756 | ((inf >> 56) & 0xff)
757 | ((inf >> 40) & 0xff00)
758 | ((inf >> 24) & 0xff0000)
759 | ((inf >> 8) & 0xff000000));
760 relas[i].r_info = inf;
773 slurp_rel_relocs (FILE * file,
774 unsigned long rel_offset,
775 unsigned long rel_size,
776 Elf_Internal_Rela ** relsp,
777 unsigned long * nrelsp)
779 Elf_Internal_Rela * rels;
785 Elf32_External_Rel * erels;
787 erels = (Elf32_External_Rel *) get_data (NULL, file, rel_offset, 1,
788 rel_size, _("32-bit relocation data"));
792 nrels = rel_size / sizeof (Elf32_External_Rel);
794 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
799 error (_("out of memory parsing relocs\n"));
803 for (i = 0; i < nrels; i++)
805 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
806 rels[i].r_info = BYTE_GET (erels[i].r_info);
807 rels[i].r_addend = 0;
814 Elf64_External_Rel * erels;
816 erels = (Elf64_External_Rel *) get_data (NULL, file, rel_offset, 1,
817 rel_size, _("64-bit relocation data"));
821 nrels = rel_size / sizeof (Elf64_External_Rel);
823 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
828 error (_("out of memory parsing relocs\n"));
832 for (i = 0; i < nrels; i++)
834 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
835 rels[i].r_info = BYTE_GET (erels[i].r_info);
836 rels[i].r_addend = 0;
838 /* The #ifdef BFD64 below is to prevent a compile time
839 warning. We know that if we do not have a 64 bit data
840 type that we will never execute this code anyway. */
842 if (elf_header.e_machine == EM_MIPS
843 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
845 /* In little-endian objects, r_info isn't really a
846 64-bit little-endian value: it has a 32-bit
847 little-endian symbol index followed by four
848 individual byte fields. Reorder INFO
850 bfd_vma inf = rels[i].r_info;
851 inf = (((inf & 0xffffffff) << 32)
852 | ((inf >> 56) & 0xff)
853 | ((inf >> 40) & 0xff00)
854 | ((inf >> 24) & 0xff0000)
855 | ((inf >> 8) & 0xff000000));
856 rels[i].r_info = inf;
868 /* Returns the reloc type extracted from the reloc info field. */
871 get_reloc_type (bfd_vma reloc_info)
874 return ELF32_R_TYPE (reloc_info);
876 switch (elf_header.e_machine)
879 /* Note: We assume that reloc_info has already been adjusted for us. */
880 return ELF64_MIPS_R_TYPE (reloc_info);
883 return ELF64_R_TYPE_ID (reloc_info);
886 return ELF64_R_TYPE (reloc_info);
890 /* Return the symbol index extracted from the reloc info field. */
893 get_reloc_symindex (bfd_vma reloc_info)
895 return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
898 /* Display the contents of the relocation data found at the specified
902 dump_relocations (FILE * file,
903 unsigned long rel_offset,
904 unsigned long rel_size,
905 Elf_Internal_Sym * symtab,
908 unsigned long strtablen,
912 Elf_Internal_Rela * rels;
914 if (is_rela == UNKNOWN)
915 is_rela = guess_is_rela (elf_header.e_machine);
919 if (!slurp_rela_relocs (file, rel_offset, rel_size, &rels, &rel_size))
924 if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
933 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
935 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
940 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
942 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
950 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
952 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
957 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
959 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
963 for (i = 0; i < rel_size; i++)
968 bfd_vma symtab_index;
971 offset = rels[i].r_offset;
972 inf = rels[i].r_info;
974 type = get_reloc_type (inf);
975 symtab_index = get_reloc_symindex (inf);
979 printf ("%8.8lx %8.8lx ",
980 (unsigned long) offset & 0xffffffff,
981 (unsigned long) inf & 0xffffffff);
985 #if BFD_HOST_64BIT_LONG
987 ? "%16.16lx %16.16lx "
988 : "%12.12lx %12.12lx ",
990 #elif BFD_HOST_64BIT_LONG_LONG
993 ? "%16.16llx %16.16llx "
994 : "%12.12llx %12.12llx ",
998 ? "%16.16I64x %16.16I64x "
999 : "%12.12I64x %12.12I64x ",
1004 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1005 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1006 _bfd_int64_high (offset),
1007 _bfd_int64_low (offset),
1008 _bfd_int64_high (inf),
1009 _bfd_int64_low (inf));
1013 switch (elf_header.e_machine)
1020 rtype = elf_aarch64_reloc_type (type);
1024 case EM_CYGNUS_M32R:
1025 rtype = elf_m32r_reloc_type (type);
1030 rtype = elf_i386_reloc_type (type);
1035 rtype = elf_m68hc11_reloc_type (type);
1039 rtype = elf_m68k_reloc_type (type);
1043 rtype = elf_i960_reloc_type (type);
1048 rtype = elf_avr_reloc_type (type);
1051 case EM_OLD_SPARCV9:
1052 case EM_SPARC32PLUS:
1055 rtype = elf_sparc_reloc_type (type);
1059 rtype = elf_spu_reloc_type (type);
1063 rtype = v800_reloc_type (type);
1066 case EM_CYGNUS_V850:
1067 rtype = v850_reloc_type (type);
1071 case EM_CYGNUS_D10V:
1072 rtype = elf_d10v_reloc_type (type);
1076 case EM_CYGNUS_D30V:
1077 rtype = elf_d30v_reloc_type (type);
1081 rtype = elf_dlx_reloc_type (type);
1085 rtype = elf_sh_reloc_type (type);
1089 case EM_CYGNUS_MN10300:
1090 rtype = elf_mn10300_reloc_type (type);
1094 case EM_CYGNUS_MN10200:
1095 rtype = elf_mn10200_reloc_type (type);
1099 case EM_CYGNUS_FR30:
1100 rtype = elf_fr30_reloc_type (type);
1104 rtype = elf_frv_reloc_type (type);
1108 rtype = elf_mcore_reloc_type (type);
1112 rtype = elf_mmix_reloc_type (type);
1116 rtype = elf_moxie_reloc_type (type);
1121 rtype = elf_msp430_reloc_type (type);
1125 rtype = elf_ppc_reloc_type (type);
1129 rtype = elf_ppc64_reloc_type (type);
1133 case EM_MIPS_RS3_LE:
1134 rtype = elf_mips_reloc_type (type);
1138 rtype = elf_alpha_reloc_type (type);
1142 rtype = elf_arm_reloc_type (type);
1146 rtype = elf_arc_reloc_type (type);
1150 rtype = elf_hppa_reloc_type (type);
1156 rtype = elf_h8_reloc_type (type);
1161 rtype = elf_or32_reloc_type (type);
1166 rtype = elf_pj_reloc_type (type);
1169 rtype = elf_ia64_reloc_type (type);
1173 rtype = elf_cris_reloc_type (type);
1177 rtype = elf_i860_reloc_type (type);
1183 rtype = elf_x86_64_reloc_type (type);
1187 rtype = i370_reloc_type (type);
1192 rtype = elf_s390_reloc_type (type);
1196 rtype = elf_score_reloc_type (type);
1200 rtype = elf_xstormy16_reloc_type (type);
1204 rtype = elf_crx_reloc_type (type);
1208 rtype = elf_vax_reloc_type (type);
1211 case EM_ADAPTEVA_EPIPHANY:
1212 rtype = elf_epiphany_reloc_type (type);
1217 rtype = elf_ip2k_reloc_type (type);
1221 rtype = elf_iq2000_reloc_type (type);
1226 rtype = elf_xtensa_reloc_type (type);
1229 case EM_LATTICEMICO32:
1230 rtype = elf_lm32_reloc_type (type);
1235 rtype = elf_m32c_reloc_type (type);
1239 rtype = elf_mt_reloc_type (type);
1243 rtype = elf_bfin_reloc_type (type);
1247 rtype = elf_mep_reloc_type (type);
1251 rtype = elf_cr16_reloc_type (type);
1255 case EM_MICROBLAZE_OLD:
1256 rtype = elf_microblaze_reloc_type (type);
1260 rtype = elf_rl78_reloc_type (type);
1264 rtype = elf_rx_reloc_type (type);
1269 rtype = elf_xc16x_reloc_type (type);
1273 rtype = elf_tic6x_reloc_type (type);
1277 rtype = elf_tilegx_reloc_type (type);
1281 rtype = elf_tilepro_reloc_type (type);
1285 rtype = elf_xgate_reloc_type (type);
1290 printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
1292 printf (do_wide ? "%-22.22s" : "%-17.17s", rtype);
1294 if (elf_header.e_machine == EM_ALPHA
1296 && streq (rtype, "R_ALPHA_LITUSE")
1299 switch (rels[i].r_addend)
1301 case LITUSE_ALPHA_ADDR: rtype = "ADDR"; break;
1302 case LITUSE_ALPHA_BASE: rtype = "BASE"; break;
1303 case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1304 case LITUSE_ALPHA_JSR: rtype = "JSR"; break;
1305 case LITUSE_ALPHA_TLSGD: rtype = "TLSGD"; break;
1306 case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1307 case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1308 default: rtype = NULL;
1311 printf (" (%s)", rtype);
1315 printf (_("<unknown addend: %lx>"),
1316 (unsigned long) rels[i].r_addend);
1319 else if (symtab_index)
1321 if (symtab == NULL || symtab_index >= nsyms)
1322 printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index);
1325 Elf_Internal_Sym * psym;
1327 psym = symtab + symtab_index;
1331 if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1335 unsigned int width = is_32bit_elf ? 8 : 14;
1337 /* Relocations against GNU_IFUNC symbols do not use the value
1338 of the symbol as the address to relocate against. Instead
1339 they invoke the function named by the symbol and use its
1340 result as the address for relocation.
1342 To indicate this to the user, do not display the value of
1343 the symbol in the "Symbols's Value" field. Instead show
1344 its name followed by () as a hint that the symbol is
1348 || psym->st_name == 0
1349 || psym->st_name >= strtablen)
1352 name = strtab + psym->st_name;
1354 len = print_symbol (width, name);
1355 printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1359 print_vma (psym->st_value, LONG_HEX);
1361 printf (is_32bit_elf ? " " : " ");
1364 if (psym->st_name == 0)
1366 const char * sec_name = "<null>";
1369 if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1371 if (psym->st_shndx < elf_header.e_shnum)
1373 = SECTION_NAME (section_headers + psym->st_shndx);
1374 else if (psym->st_shndx == SHN_ABS)
1376 else if (psym->st_shndx == SHN_COMMON)
1377 sec_name = "COMMON";
1378 else if ((elf_header.e_machine == EM_MIPS
1379 && psym->st_shndx == SHN_MIPS_SCOMMON)
1380 || (elf_header.e_machine == EM_TI_C6000
1381 && psym->st_shndx == SHN_TIC6X_SCOMMON))
1382 sec_name = "SCOMMON";
1383 else if (elf_header.e_machine == EM_MIPS
1384 && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1385 sec_name = "SUNDEF";
1386 else if ((elf_header.e_machine == EM_X86_64
1387 || elf_header.e_machine == EM_L1OM
1388 || elf_header.e_machine == EM_K1OM)
1389 && psym->st_shndx == SHN_X86_64_LCOMMON)
1390 sec_name = "LARGE_COMMON";
1391 else if (elf_header.e_machine == EM_IA_64
1392 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1393 && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1394 sec_name = "ANSI_COM";
1395 else if (is_ia64_vms ()
1396 && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1397 sec_name = "VMS_SYMVEC";
1400 sprintf (name_buf, "<section 0x%x>",
1401 (unsigned int) psym->st_shndx);
1402 sec_name = name_buf;
1405 print_symbol (22, sec_name);
1407 else if (strtab == NULL)
1408 printf (_("<string table index: %3ld>"), psym->st_name);
1409 else if (psym->st_name >= strtablen)
1410 printf (_("<corrupt string table index: %3ld>"), psym->st_name);
1412 print_symbol (22, strtab + psym->st_name);
1416 bfd_signed_vma off = rels[i].r_addend;
1419 printf (" - %" BFD_VMA_FMT "x", - off);
1421 printf (" + %" BFD_VMA_FMT "x", off);
1427 bfd_signed_vma off = rels[i].r_addend;
1429 printf ("%*c", is_32bit_elf ? 12 : 20, ' ');
1431 printf ("-%" BFD_VMA_FMT "x", - off);
1433 printf ("%" BFD_VMA_FMT "x", off);
1436 if (elf_header.e_machine == EM_SPARCV9
1438 && streq (rtype, "R_SPARC_OLO10"))
1439 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
1444 if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
1446 bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1447 bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
1448 const char * rtype2 = elf_mips_reloc_type (type2);
1449 const char * rtype3 = elf_mips_reloc_type (type3);
1451 printf (" Type2: ");
1454 printf (_("unrecognized: %-7lx"),
1455 (unsigned long) type2 & 0xffffffff);
1457 printf ("%-17.17s", rtype2);
1459 printf ("\n Type3: ");
1462 printf (_("unrecognized: %-7lx"),
1463 (unsigned long) type3 & 0xffffffff);
1465 printf ("%-17.17s", rtype3);
1476 get_mips_dynamic_type (unsigned long type)
1480 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1481 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1482 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1483 case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1484 case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1485 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1486 case DT_MIPS_MSYM: return "MIPS_MSYM";
1487 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1488 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1489 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1490 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1491 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1492 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1493 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1494 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1495 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1496 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1497 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1498 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1499 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1500 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1501 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1502 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1503 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1504 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1505 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1506 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1507 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1508 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1509 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1510 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1511 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1512 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1513 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1514 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1515 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1516 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1517 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1518 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1519 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1520 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1521 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1522 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
1523 case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1524 case DT_MIPS_RWPLT: return "MIPS_RWPLT";
1531 get_sparc64_dynamic_type (unsigned long type)
1535 case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1542 get_ppc_dynamic_type (unsigned long type)
1546 case DT_PPC_GOT: return "PPC_GOT";
1547 case DT_PPC_TLSOPT: return "PPC_TLSOPT";
1554 get_ppc64_dynamic_type (unsigned long type)
1558 case DT_PPC64_GLINK: return "PPC64_GLINK";
1559 case DT_PPC64_OPD: return "PPC64_OPD";
1560 case DT_PPC64_OPDSZ: return "PPC64_OPDSZ";
1561 case DT_PPC64_TLSOPT: return "PPC64_TLSOPT";
1568 get_parisc_dynamic_type (unsigned long type)
1572 case DT_HP_LOAD_MAP: return "HP_LOAD_MAP";
1573 case DT_HP_DLD_FLAGS: return "HP_DLD_FLAGS";
1574 case DT_HP_DLD_HOOK: return "HP_DLD_HOOK";
1575 case DT_HP_UX10_INIT: return "HP_UX10_INIT";
1576 case DT_HP_UX10_INITSZ: return "HP_UX10_INITSZ";
1577 case DT_HP_PREINIT: return "HP_PREINIT";
1578 case DT_HP_PREINITSZ: return "HP_PREINITSZ";
1579 case DT_HP_NEEDED: return "HP_NEEDED";
1580 case DT_HP_TIME_STAMP: return "HP_TIME_STAMP";
1581 case DT_HP_CHECKSUM: return "HP_CHECKSUM";
1582 case DT_HP_GST_SIZE: return "HP_GST_SIZE";
1583 case DT_HP_GST_VERSION: return "HP_GST_VERSION";
1584 case DT_HP_GST_HASHVAL: return "HP_GST_HASHVAL";
1585 case DT_HP_EPLTREL: return "HP_GST_EPLTREL";
1586 case DT_HP_EPLTRELSZ: return "HP_GST_EPLTRELSZ";
1587 case DT_HP_FILTERED: return "HP_FILTERED";
1588 case DT_HP_FILTER_TLS: return "HP_FILTER_TLS";
1589 case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1590 case DT_HP_LAZYLOAD: return "HP_LAZYLOAD";
1591 case DT_HP_BIND_NOW_COUNT: return "HP_BIND_NOW_COUNT";
1592 case DT_PLT: return "PLT";
1593 case DT_PLT_SIZE: return "PLT_SIZE";
1594 case DT_DLT: return "DLT";
1595 case DT_DLT_SIZE: return "DLT_SIZE";
1602 get_ia64_dynamic_type (unsigned long type)
1606 case DT_IA_64_PLT_RESERVE: return "IA_64_PLT_RESERVE";
1607 case DT_IA_64_VMS_SUBTYPE: return "VMS_SUBTYPE";
1608 case DT_IA_64_VMS_IMGIOCNT: return "VMS_IMGIOCNT";
1609 case DT_IA_64_VMS_LNKFLAGS: return "VMS_LNKFLAGS";
1610 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1611 case DT_IA_64_VMS_IDENT: return "VMS_IDENT";
1612 case DT_IA_64_VMS_NEEDED_IDENT: return "VMS_NEEDED_IDENT";
1613 case DT_IA_64_VMS_IMG_RELA_CNT: return "VMS_IMG_RELA_CNT";
1614 case DT_IA_64_VMS_SEG_RELA_CNT: return "VMS_SEG_RELA_CNT";
1615 case DT_IA_64_VMS_FIXUP_RELA_CNT: return "VMS_FIXUP_RELA_CNT";
1616 case DT_IA_64_VMS_FIXUP_NEEDED: return "VMS_FIXUP_NEEDED";
1617 case DT_IA_64_VMS_SYMVEC_CNT: return "VMS_SYMVEC_CNT";
1618 case DT_IA_64_VMS_XLATED: return "VMS_XLATED";
1619 case DT_IA_64_VMS_STACKSIZE: return "VMS_STACKSIZE";
1620 case DT_IA_64_VMS_UNWINDSZ: return "VMS_UNWINDSZ";
1621 case DT_IA_64_VMS_UNWIND_CODSEG: return "VMS_UNWIND_CODSEG";
1622 case DT_IA_64_VMS_UNWIND_INFOSEG: return "VMS_UNWIND_INFOSEG";
1623 case DT_IA_64_VMS_LINKTIME: return "VMS_LINKTIME";
1624 case DT_IA_64_VMS_SEG_NO: return "VMS_SEG_NO";
1625 case DT_IA_64_VMS_SYMVEC_OFFSET: return "VMS_SYMVEC_OFFSET";
1626 case DT_IA_64_VMS_SYMVEC_SEG: return "VMS_SYMVEC_SEG";
1627 case DT_IA_64_VMS_UNWIND_OFFSET: return "VMS_UNWIND_OFFSET";
1628 case DT_IA_64_VMS_UNWIND_SEG: return "VMS_UNWIND_SEG";
1629 case DT_IA_64_VMS_STRTAB_OFFSET: return "VMS_STRTAB_OFFSET";
1630 case DT_IA_64_VMS_SYSVER_OFFSET: return "VMS_SYSVER_OFFSET";
1631 case DT_IA_64_VMS_IMG_RELA_OFF: return "VMS_IMG_RELA_OFF";
1632 case DT_IA_64_VMS_SEG_RELA_OFF: return "VMS_SEG_RELA_OFF";
1633 case DT_IA_64_VMS_FIXUP_RELA_OFF: return "VMS_FIXUP_RELA_OFF";
1634 case DT_IA_64_VMS_PLTGOT_OFFSET: return "VMS_PLTGOT_OFFSET";
1635 case DT_IA_64_VMS_PLTGOT_SEG: return "VMS_PLTGOT_SEG";
1636 case DT_IA_64_VMS_FPMODE: return "VMS_FPMODE";
1643 get_alpha_dynamic_type (unsigned long type)
1647 case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
1654 get_score_dynamic_type (unsigned long type)
1658 case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
1659 case DT_SCORE_LOCAL_GOTNO: return "SCORE_LOCAL_GOTNO";
1660 case DT_SCORE_SYMTABNO: return "SCORE_SYMTABNO";
1661 case DT_SCORE_GOTSYM: return "SCORE_GOTSYM";
1662 case DT_SCORE_UNREFEXTNO: return "SCORE_UNREFEXTNO";
1663 case DT_SCORE_HIPAGENO: return "SCORE_HIPAGENO";
1670 get_tic6x_dynamic_type (unsigned long type)
1674 case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
1675 case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
1676 case DT_C6000_DSBT_BASE: return "C6000_DSBT_BASE";
1677 case DT_C6000_DSBT_SIZE: return "C6000_DSBT_SIZE";
1678 case DT_C6000_PREEMPTMAP: return "C6000_PREEMPTMAP";
1679 case DT_C6000_DSBT_INDEX: return "C6000_DSBT_INDEX";
1686 get_dynamic_type (unsigned long type)
1688 static char buff[64];
1692 case DT_NULL: return "NULL";
1693 case DT_NEEDED: return "NEEDED";
1694 case DT_PLTRELSZ: return "PLTRELSZ";
1695 case DT_PLTGOT: return "PLTGOT";
1696 case DT_HASH: return "HASH";
1697 case DT_STRTAB: return "STRTAB";
1698 case DT_SYMTAB: return "SYMTAB";
1699 case DT_RELA: return "RELA";
1700 case DT_RELASZ: return "RELASZ";
1701 case DT_RELAENT: return "RELAENT";
1702 case DT_STRSZ: return "STRSZ";
1703 case DT_SYMENT: return "SYMENT";
1704 case DT_INIT: return "INIT";
1705 case DT_FINI: return "FINI";
1706 case DT_SONAME: return "SONAME";
1707 case DT_RPATH: return "RPATH";
1708 case DT_SYMBOLIC: return "SYMBOLIC";
1709 case DT_REL: return "REL";
1710 case DT_RELSZ: return "RELSZ";
1711 case DT_RELENT: return "RELENT";
1712 case DT_PLTREL: return "PLTREL";
1713 case DT_DEBUG: return "DEBUG";
1714 case DT_TEXTREL: return "TEXTREL";
1715 case DT_JMPREL: return "JMPREL";
1716 case DT_BIND_NOW: return "BIND_NOW";
1717 case DT_INIT_ARRAY: return "INIT_ARRAY";
1718 case DT_FINI_ARRAY: return "FINI_ARRAY";
1719 case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
1720 case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
1721 case DT_RUNPATH: return "RUNPATH";
1722 case DT_FLAGS: return "FLAGS";
1724 case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1725 case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
1727 case DT_CHECKSUM: return "CHECKSUM";
1728 case DT_PLTPADSZ: return "PLTPADSZ";
1729 case DT_MOVEENT: return "MOVEENT";
1730 case DT_MOVESZ: return "MOVESZ";
1731 case DT_FEATURE: return "FEATURE";
1732 case DT_POSFLAG_1: return "POSFLAG_1";
1733 case DT_SYMINSZ: return "SYMINSZ";
1734 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
1736 case DT_ADDRRNGLO: return "ADDRRNGLO";
1737 case DT_CONFIG: return "CONFIG";
1738 case DT_DEPAUDIT: return "DEPAUDIT";
1739 case DT_AUDIT: return "AUDIT";
1740 case DT_PLTPAD: return "PLTPAD";
1741 case DT_MOVETAB: return "MOVETAB";
1742 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
1744 case DT_VERSYM: return "VERSYM";
1746 case DT_TLSDESC_GOT: return "TLSDESC_GOT";
1747 case DT_TLSDESC_PLT: return "TLSDESC_PLT";
1748 case DT_RELACOUNT: return "RELACOUNT";
1749 case DT_RELCOUNT: return "RELCOUNT";
1750 case DT_FLAGS_1: return "FLAGS_1";
1751 case DT_VERDEF: return "VERDEF";
1752 case DT_VERDEFNUM: return "VERDEFNUM";
1753 case DT_VERNEED: return "VERNEED";
1754 case DT_VERNEEDNUM: return "VERNEEDNUM";
1756 case DT_AUXILIARY: return "AUXILIARY";
1757 case DT_USED: return "USED";
1758 case DT_FILTER: return "FILTER";
1760 case DT_GNU_PRELINKED: return "GNU_PRELINKED";
1761 case DT_GNU_CONFLICT: return "GNU_CONFLICT";
1762 case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
1763 case DT_GNU_LIBLIST: return "GNU_LIBLIST";
1764 case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
1765 case DT_GNU_HASH: return "GNU_HASH";
1768 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1770 const char * result;
1772 switch (elf_header.e_machine)
1775 case EM_MIPS_RS3_LE:
1776 result = get_mips_dynamic_type (type);
1779 result = get_sparc64_dynamic_type (type);
1782 result = get_ppc_dynamic_type (type);
1785 result = get_ppc64_dynamic_type (type);
1788 result = get_ia64_dynamic_type (type);
1791 result = get_alpha_dynamic_type (type);
1794 result = get_score_dynamic_type (type);
1797 result = get_tic6x_dynamic_type (type);
1807 snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
1809 else if (((type >= DT_LOOS) && (type <= DT_HIOS))
1810 || (elf_header.e_machine == EM_PARISC
1811 && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
1813 const char * result;
1815 switch (elf_header.e_machine)
1818 result = get_parisc_dynamic_type (type);
1821 result = get_ia64_dynamic_type (type);
1831 snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
1835 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
1842 get_file_type (unsigned e_type)
1844 static char buff[32];
1848 case ET_NONE: return _("NONE (None)");
1849 case ET_REL: return _("REL (Relocatable file)");
1850 case ET_EXEC: return _("EXEC (Executable file)");
1851 case ET_DYN: return _("DYN (Shared object file)");
1852 case ET_CORE: return _("CORE (Core file)");
1855 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
1856 snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
1857 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
1858 snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
1860 snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
1866 get_machine_name (unsigned e_machine)
1868 static char buff[64]; /* XXX */
1872 case EM_NONE: return _("None");
1873 case EM_AARCH64: return "AArch64";
1874 case EM_M32: return "WE32100";
1875 case EM_SPARC: return "Sparc";
1876 case EM_SPU: return "SPU";
1877 case EM_386: return "Intel 80386";
1878 case EM_68K: return "MC68000";
1879 case EM_88K: return "MC88000";
1880 case EM_486: return "Intel 80486";
1881 case EM_860: return "Intel 80860";
1882 case EM_MIPS: return "MIPS R3000";
1883 case EM_S370: return "IBM System/370";
1884 case EM_MIPS_RS3_LE: return "MIPS R4000 big-endian";
1885 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
1886 case EM_PARISC: return "HPPA";
1887 case EM_PPC_OLD: return "Power PC (old)";
1888 case EM_SPARC32PLUS: return "Sparc v8+" ;
1889 case EM_960: return "Intel 90860";
1890 case EM_PPC: return "PowerPC";
1891 case EM_PPC64: return "PowerPC64";
1892 case EM_FR20: return "Fujitsu FR20";
1893 case EM_RH32: return "TRW RH32";
1894 case EM_MCORE: return "MCORE";
1895 case EM_ARM: return "ARM";
1896 case EM_OLD_ALPHA: return "Digital Alpha (old)";
1897 case EM_SH: return "Renesas / SuperH SH";
1898 case EM_SPARCV9: return "Sparc v9";
1899 case EM_TRICORE: return "Siemens Tricore";
1900 case EM_ARC: return "ARC";
1901 case EM_H8_300: return "Renesas H8/300";
1902 case EM_H8_300H: return "Renesas H8/300H";
1903 case EM_H8S: return "Renesas H8S";
1904 case EM_H8_500: return "Renesas H8/500";
1905 case EM_IA_64: return "Intel IA-64";
1906 case EM_MIPS_X: return "Stanford MIPS-X";
1907 case EM_COLDFIRE: return "Motorola Coldfire";
1908 case EM_ALPHA: return "Alpha";
1909 case EM_CYGNUS_D10V:
1910 case EM_D10V: return "d10v";
1911 case EM_CYGNUS_D30V:
1912 case EM_D30V: return "d30v";
1913 case EM_CYGNUS_M32R:
1914 case EM_M32R: return "Renesas M32R (formerly Mitsubishi M32r)";
1915 case EM_CYGNUS_V850:
1916 case EM_V800: return "Renesas V850 (using RH850 ABI)";
1917 case EM_V850: return "Renesas V850";
1918 case EM_CYGNUS_MN10300:
1919 case EM_MN10300: return "mn10300";
1920 case EM_CYGNUS_MN10200:
1921 case EM_MN10200: return "mn10200";
1922 case EM_MOXIE: return "Moxie";
1923 case EM_CYGNUS_FR30:
1924 case EM_FR30: return "Fujitsu FR30";
1925 case EM_CYGNUS_FRV: return "Fujitsu FR-V";
1927 case EM_PJ: return "picoJava";
1928 case EM_MMA: return "Fujitsu Multimedia Accelerator";
1929 case EM_PCP: return "Siemens PCP";
1930 case EM_NCPU: return "Sony nCPU embedded RISC processor";
1931 case EM_NDR1: return "Denso NDR1 microprocesspr";
1932 case EM_STARCORE: return "Motorola Star*Core processor";
1933 case EM_ME16: return "Toyota ME16 processor";
1934 case EM_ST100: return "STMicroelectronics ST100 processor";
1935 case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
1936 case EM_PDSP: return "Sony DSP processor";
1937 case EM_PDP10: return "Digital Equipment Corp. PDP-10";
1938 case EM_PDP11: return "Digital Equipment Corp. PDP-11";
1939 case EM_FX66: return "Siemens FX66 microcontroller";
1940 case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1941 case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
1942 case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
1943 case EM_68HC12: return "Motorola MC68HC12 Microcontroller";
1944 case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
1945 case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
1946 case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
1947 case EM_SVX: return "Silicon Graphics SVx";
1948 case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
1949 case EM_VAX: return "Digital VAX";
1951 case EM_AVR: return "Atmel AVR 8-bit microcontroller";
1952 case EM_CRIS: return "Axis Communications 32-bit embedded processor";
1953 case EM_JAVELIN: return "Infineon Technologies 32-bit embedded cpu";
1954 case EM_FIREPATH: return "Element 14 64-bit DSP processor";
1955 case EM_ZSP: return "LSI Logic's 16-bit DSP processor";
1956 case EM_MMIX: return "Donald Knuth's educational 64-bit processor";
1957 case EM_HUANY: return "Harvard Universitys's machine-independent object format";
1958 case EM_PRISM: return "Vitesse Prism";
1959 case EM_X86_64: return "Advanced Micro Devices X86-64";
1960 case EM_L1OM: return "Intel L1OM";
1961 case EM_K1OM: return "Intel K1OM";
1963 case EM_S390: return "IBM S/390";
1964 case EM_SCORE: return "SUNPLUS S+Core";
1965 case EM_XSTORMY16: return "Sanyo XStormy16 CPU core";
1967 case EM_OR32: return "OpenRISC";
1968 case EM_ARC_A5: return "ARC International ARCompact processor";
1969 case EM_CRX: return "National Semiconductor CRX microprocessor";
1970 case EM_ADAPTEVA_EPIPHANY: return "Adapteva EPIPHANY";
1971 case EM_DLX: return "OpenDLX";
1973 case EM_IP2K: return "Ubicom IP2xxx 8-bit microcontrollers";
1974 case EM_IQ2000: return "Vitesse IQ2000";
1976 case EM_XTENSA: return "Tensilica Xtensa Processor";
1977 case EM_VIDEOCORE: return "Alphamosaic VideoCore processor";
1978 case EM_TMM_GPP: return "Thompson Multimedia General Purpose Processor";
1979 case EM_NS32K: return "National Semiconductor 32000 series";
1980 case EM_TPC: return "Tenor Network TPC processor";
1981 case EM_ST200: return "STMicroelectronics ST200 microcontroller";
1982 case EM_MAX: return "MAX Processor";
1983 case EM_CR: return "National Semiconductor CompactRISC";
1984 case EM_F2MC16: return "Fujitsu F2MC16";
1985 case EM_MSP430: return "Texas Instruments msp430 microcontroller";
1986 case EM_LATTICEMICO32: return "Lattice Mico32";
1988 case EM_M32C: return "Renesas M32c";
1989 case EM_MT: return "Morpho Techologies MT processor";
1990 case EM_BLACKFIN: return "Analog Devices Blackfin";
1991 case EM_SE_C33: return "S1C33 Family of Seiko Epson processors";
1992 case EM_SEP: return "Sharp embedded microprocessor";
1993 case EM_ARCA: return "Arca RISC microprocessor";
1994 case EM_UNICORE: return "Unicore";
1995 case EM_EXCESS: return "eXcess 16/32/64-bit configurable embedded CPU";
1996 case EM_DXP: return "Icera Semiconductor Inc. Deep Execution Processor";
1997 case EM_NIOS32: return "Altera Nios";
1998 case EM_ALTERA_NIOS2: return "Altera Nios II";
2000 case EM_XC16X: return "Infineon Technologies xc16x";
2001 case EM_M16C: return "Renesas M16C series microprocessors";
2002 case EM_DSPIC30F: return "Microchip Technology dsPIC30F Digital Signal Controller";
2003 case EM_CE: return "Freescale Communication Engine RISC core";
2004 case EM_TSK3000: return "Altium TSK3000 core";
2005 case EM_RS08: return "Freescale RS08 embedded processor";
2006 case EM_ECOG2: return "Cyan Technology eCOG2 microprocessor";
2007 case EM_DSP24: return "New Japan Radio (NJR) 24-bit DSP Processor";
2008 case EM_VIDEOCORE3: return "Broadcom VideoCore III processor";
2009 case EM_SE_C17: return "Seiko Epson C17 family";
2010 case EM_TI_C6000: return "Texas Instruments TMS320C6000 DSP family";
2011 case EM_TI_C2000: return "Texas Instruments TMS320C2000 DSP family";
2012 case EM_TI_C5500: return "Texas Instruments TMS320C55x DSP family";
2013 case EM_MMDSP_PLUS: return "STMicroelectronics 64bit VLIW Data Signal Processor";
2014 case EM_CYPRESS_M8C: return "Cypress M8C microprocessor";
2015 case EM_R32C: return "Renesas R32C series microprocessors";
2016 case EM_TRIMEDIA: return "NXP Semiconductors TriMedia architecture family";
2017 case EM_QDSP6: return "QUALCOMM DSP6 Processor";
2018 case EM_8051: return "Intel 8051 and variants";
2019 case EM_STXP7X: return "STMicroelectronics STxP7x family";
2020 case EM_NDS32: return "Andes Technology compact code size embedded RISC processor family";
2021 case EM_ECOG1X: return "Cyan Technology eCOG1X family";
2022 case EM_MAXQ30: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
2023 case EM_XIMO16: return "New Japan Radio (NJR) 16-bit DSP Processor";
2024 case EM_MANIK: return "M2000 Reconfigurable RISC Microprocessor";
2025 case EM_CRAYNV2: return "Cray Inc. NV2 vector architecture";
2026 case EM_CYGNUS_MEP: return "Toshiba MeP Media Engine";
2029 case EM_MICROBLAZE_OLD: return "Xilinx MicroBlaze";
2030 case EM_RL78: return "Renesas RL78";
2031 case EM_RX: return "Renesas RX";
2032 case EM_METAG: return "Imagination Technologies META processor architecture";
2033 case EM_MCST_ELBRUS: return "MCST Elbrus general purpose hardware architecture";
2034 case EM_ECOG16: return "Cyan Technology eCOG16 family";
2035 case EM_ETPU: return "Freescale Extended Time Processing Unit";
2036 case EM_SLE9X: return "Infineon Technologies SLE9X core";
2037 case EM_AVR32: return "Atmel Corporation 32-bit microprocessor family";
2038 case EM_STM8: return "STMicroeletronics STM8 8-bit microcontroller";
2039 case EM_TILE64: return "Tilera TILE64 multicore architecture family";
2040 case EM_TILEPRO: return "Tilera TILEPro multicore architecture family";
2041 case EM_TILEGX: return "Tilera TILE-Gx multicore architecture family";
2042 case EM_CUDA: return "NVIDIA CUDA architecture";
2043 case EM_XGATE: return "Motorola XGATE embedded processor";
2045 snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
2051 decode_ARM_machine_flags (unsigned e_flags, char buf[])
2056 eabi = EF_ARM_EABI_VERSION (e_flags);
2057 e_flags &= ~ EF_ARM_EABIMASK;
2059 /* Handle "generic" ARM flags. */
2060 if (e_flags & EF_ARM_RELEXEC)
2062 strcat (buf, ", relocatable executable");
2063 e_flags &= ~ EF_ARM_RELEXEC;
2066 if (e_flags & EF_ARM_HASENTRY)
2068 strcat (buf, ", has entry point");
2069 e_flags &= ~ EF_ARM_HASENTRY;
2072 /* Now handle EABI specific flags. */
2076 strcat (buf, ", <unrecognized EABI>");
2081 case EF_ARM_EABI_VER1:
2082 strcat (buf, ", Version1 EABI");
2087 /* Process flags one bit at a time. */
2088 flag = e_flags & - e_flags;
2093 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2094 strcat (buf, ", sorted symbol tables");
2104 case EF_ARM_EABI_VER2:
2105 strcat (buf, ", Version2 EABI");
2110 /* Process flags one bit at a time. */
2111 flag = e_flags & - e_flags;
2116 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2117 strcat (buf, ", sorted symbol tables");
2120 case EF_ARM_DYNSYMSUSESEGIDX:
2121 strcat (buf, ", dynamic symbols use segment index");
2124 case EF_ARM_MAPSYMSFIRST:
2125 strcat (buf, ", mapping symbols precede others");
2135 case EF_ARM_EABI_VER3:
2136 strcat (buf, ", Version3 EABI");
2139 case EF_ARM_EABI_VER4:
2140 strcat (buf, ", Version4 EABI");
2145 /* Process flags one bit at a time. */
2146 flag = e_flags & - e_flags;
2152 strcat (buf, ", BE8");
2156 strcat (buf, ", LE8");
2167 case EF_ARM_EABI_VER5:
2168 strcat (buf, ", Version5 EABI");
2173 /* Process flags one bit at a time. */
2174 flag = e_flags & - e_flags;
2180 strcat (buf, ", BE8");
2184 strcat (buf, ", LE8");
2187 case EF_ARM_ABI_FLOAT_SOFT: /* Conflicts with EF_ARM_SOFT_FLOAT. */
2188 strcat (buf, ", soft-float ABI");
2191 case EF_ARM_ABI_FLOAT_HARD: /* Conflicts with EF_ARM_VFP_FLOAT. */
2192 strcat (buf, ", hard-float ABI");
2202 case EF_ARM_EABI_UNKNOWN:
2203 strcat (buf, ", GNU EABI");
2208 /* Process flags one bit at a time. */
2209 flag = e_flags & - e_flags;
2214 case EF_ARM_INTERWORK:
2215 strcat (buf, ", interworking enabled");
2218 case EF_ARM_APCS_26:
2219 strcat (buf, ", uses APCS/26");
2222 case EF_ARM_APCS_FLOAT:
2223 strcat (buf, ", uses APCS/float");
2227 strcat (buf, ", position independent");
2231 strcat (buf, ", 8 bit structure alignment");
2234 case EF_ARM_NEW_ABI:
2235 strcat (buf, ", uses new ABI");
2238 case EF_ARM_OLD_ABI:
2239 strcat (buf, ", uses old ABI");
2242 case EF_ARM_SOFT_FLOAT:
2243 strcat (buf, ", software FP");
2246 case EF_ARM_VFP_FLOAT:
2247 strcat (buf, ", VFP");
2250 case EF_ARM_MAVERICK_FLOAT:
2251 strcat (buf, ", Maverick FP");
2262 strcat (buf,_(", <unknown>"));
2266 get_machine_flags (unsigned e_flags, unsigned e_machine)
2268 static char buf[1024];
2280 decode_ARM_machine_flags (e_flags, buf);
2284 if (e_flags & EF_BFIN_PIC)
2285 strcat (buf, ", PIC");
2287 if (e_flags & EF_BFIN_FDPIC)
2288 strcat (buf, ", FDPIC");
2290 if (e_flags & EF_BFIN_CODE_IN_L1)
2291 strcat (buf, ", code in L1");
2293 if (e_flags & EF_BFIN_DATA_IN_L1)
2294 strcat (buf, ", data in L1");
2299 switch (e_flags & EF_FRV_CPU_MASK)
2301 case EF_FRV_CPU_GENERIC:
2305 strcat (buf, ", fr???");
2308 case EF_FRV_CPU_FR300:
2309 strcat (buf, ", fr300");
2312 case EF_FRV_CPU_FR400:
2313 strcat (buf, ", fr400");
2315 case EF_FRV_CPU_FR405:
2316 strcat (buf, ", fr405");
2319 case EF_FRV_CPU_FR450:
2320 strcat (buf, ", fr450");
2323 case EF_FRV_CPU_FR500:
2324 strcat (buf, ", fr500");
2326 case EF_FRV_CPU_FR550:
2327 strcat (buf, ", fr550");
2330 case EF_FRV_CPU_SIMPLE:
2331 strcat (buf, ", simple");
2333 case EF_FRV_CPU_TOMCAT:
2334 strcat (buf, ", tomcat");
2340 if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
2341 strcat (buf, ", m68000");
2342 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
2343 strcat (buf, ", cpu32");
2344 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
2345 strcat (buf, ", fido_a");
2348 char const * isa = _("unknown");
2349 char const * mac = _("unknown mac");
2350 char const * additional = NULL;
2352 switch (e_flags & EF_M68K_CF_ISA_MASK)
2354 case EF_M68K_CF_ISA_A_NODIV:
2356 additional = ", nodiv";
2358 case EF_M68K_CF_ISA_A:
2361 case EF_M68K_CF_ISA_A_PLUS:
2364 case EF_M68K_CF_ISA_B_NOUSP:
2366 additional = ", nousp";
2368 case EF_M68K_CF_ISA_B:
2371 case EF_M68K_CF_ISA_C:
2374 case EF_M68K_CF_ISA_C_NODIV:
2376 additional = ", nodiv";
2379 strcat (buf, ", cf, isa ");
2382 strcat (buf, additional);
2383 if (e_flags & EF_M68K_CF_FLOAT)
2384 strcat (buf, ", float");
2385 switch (e_flags & EF_M68K_CF_MAC_MASK)
2390 case EF_M68K_CF_MAC:
2393 case EF_M68K_CF_EMAC:
2396 case EF_M68K_CF_EMAC_B:
2409 if (e_flags & EF_PPC_EMB)
2410 strcat (buf, ", emb");
2412 if (e_flags & EF_PPC_RELOCATABLE)
2413 strcat (buf, _(", relocatable"));
2415 if (e_flags & EF_PPC_RELOCATABLE_LIB)
2416 strcat (buf, _(", relocatable-lib"));
2420 if ((e_flags & EF_RH850_ABI) == EF_RH850_ABI)
2421 strcat (buf, ", RH850 ABI");
2423 if (e_flags & EF_V800_850E3)
2424 strcat (buf, ", V3 architecture");
2426 if ((e_flags & (EF_RH850_FPU_DOUBLE | EF_RH850_FPU_SINGLE)) == 0)
2427 strcat (buf, ", FPU not used");
2429 if ((e_flags & (EF_RH850_REGMODE22 | EF_RH850_REGMODE32)) == 0)
2430 strcat (buf, ", regmode: COMMON");
2432 if ((e_flags & (EF_RH850_GP_FIX | EF_RH850_GP_NOFIX)) == 0)
2433 strcat (buf, ", r4 not used");
2435 if ((e_flags & (EF_RH850_EP_FIX | EF_RH850_EP_NOFIX)) == 0)
2436 strcat (buf, ", r30 not used");
2438 if ((e_flags & (EF_RH850_TP_FIX | EF_RH850_TP_NOFIX)) == 0)
2439 strcat (buf, ", r5 not used");
2441 if ((e_flags & (EF_RH850_REG2_RESERVE | EF_RH850_REG2_NORESERVE)) == 0)
2442 strcat (buf, ", r2 not used");
2444 for (e_flags &= 0xFFFF; e_flags; e_flags &= ~ (e_flags & - e_flags))
2446 switch (e_flags & - e_flags)
2448 case EF_RH850_FPU_DOUBLE: strcat (buf, ", double precision FPU"); break;
2449 case EF_RH850_FPU_SINGLE: strcat (buf, ", single precision FPU"); break;
2450 case EF_RH850_SIMD: strcat (buf, ", SIMD"); break;
2451 case EF_RH850_CACHE: strcat (buf, ", CACHE"); break;
2452 case EF_RH850_MMU: strcat (buf, ", MMU"); break;
2453 case EF_RH850_REGMODE22: strcat (buf, ", regmode:22"); break;
2454 case EF_RH850_REGMODE32: strcat (buf, ", regmode:23"); break;
2455 case EF_RH850_DATA_ALIGN8: strcat (buf, ", 8-byte alignment"); break;
2456 case EF_RH850_GP_FIX: strcat (buf, ", r4 fixed"); break;
2457 case EF_RH850_GP_NOFIX: strcat (buf, ", r4 free"); break;
2458 case EF_RH850_EP_FIX: strcat (buf, ", r30 fixed"); break;
2459 case EF_RH850_EP_NOFIX: strcat (buf, ", r30 free"); break;
2460 case EF_RH850_TP_FIX: strcat (buf, ", r5 fixed"); break;
2461 case EF_RH850_TP_NOFIX: strcat (buf, ", r5 free"); break;
2462 case EF_RH850_REG2_RESERVE: strcat (buf, ", r2 fixed"); break;
2463 case EF_RH850_REG2_NORESERVE: strcat (buf, ", r2 free"); break;
2470 case EM_CYGNUS_V850:
2471 switch (e_flags & EF_V850_ARCH)
2473 case E_V850E2V3_ARCH:
2474 strcat (buf, ", v850e2v3");
2477 strcat (buf, ", v850e2");
2480 strcat (buf, ", v850e1");
2483 strcat (buf, ", v850e");
2486 strcat (buf, ", v850");
2489 strcat (buf, _(", unknown v850 architecture variant"));
2495 case EM_CYGNUS_M32R:
2496 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
2497 strcat (buf, ", m32r");
2501 case EM_MIPS_RS3_LE:
2502 if (e_flags & EF_MIPS_NOREORDER)
2503 strcat (buf, ", noreorder");
2505 if (e_flags & EF_MIPS_PIC)
2506 strcat (buf, ", pic");
2508 if (e_flags & EF_MIPS_CPIC)
2509 strcat (buf, ", cpic");
2511 if (e_flags & EF_MIPS_UCODE)
2512 strcat (buf, ", ugen_reserved");
2514 if (e_flags & EF_MIPS_ABI2)
2515 strcat (buf, ", abi2");
2517 if (e_flags & EF_MIPS_OPTIONS_FIRST)
2518 strcat (buf, ", odk first");
2520 if (e_flags & EF_MIPS_32BITMODE)
2521 strcat (buf, ", 32bitmode");
2523 switch ((e_flags & EF_MIPS_MACH))
2525 case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
2526 case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
2527 case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
2528 case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
2529 case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
2530 case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
2531 case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
2532 case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
2533 case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); break;
2534 case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
2535 case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
2536 case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
2537 case E_MIPS_MACH_LS3A: strcat (buf, ", loongson-3a"); break;
2538 case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
2539 case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
2540 case E_MIPS_MACH_XLR: strcat (buf, ", xlr"); break;
2542 /* We simply ignore the field in this case to avoid confusion:
2543 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2546 default: strcat (buf, _(", unknown CPU")); break;
2549 switch ((e_flags & EF_MIPS_ABI))
2551 case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
2552 case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
2553 case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
2554 case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
2556 /* We simply ignore the field in this case to avoid confusion:
2557 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2558 This means it is likely to be an o32 file, but not for
2561 default: strcat (buf, _(", unknown ABI")); break;
2564 if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
2565 strcat (buf, ", mdmx");
2567 if (e_flags & EF_MIPS_ARCH_ASE_M16)
2568 strcat (buf, ", mips16");
2570 if (e_flags & EF_MIPS_ARCH_ASE_MICROMIPS)
2571 strcat (buf, ", micromips");
2573 switch ((e_flags & EF_MIPS_ARCH))
2575 case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
2576 case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
2577 case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
2578 case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
2579 case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
2580 case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
2581 case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
2582 case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
2583 case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
2584 default: strcat (buf, _(", unknown ISA")); break;
2589 switch ((e_flags & EF_SH_MACH_MASK))
2591 case EF_SH1: strcat (buf, ", sh1"); break;
2592 case EF_SH2: strcat (buf, ", sh2"); break;
2593 case EF_SH3: strcat (buf, ", sh3"); break;
2594 case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
2595 case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
2596 case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
2597 case EF_SH3E: strcat (buf, ", sh3e"); break;
2598 case EF_SH4: strcat (buf, ", sh4"); break;
2599 case EF_SH5: strcat (buf, ", sh5"); break;
2600 case EF_SH2E: strcat (buf, ", sh2e"); break;
2601 case EF_SH4A: strcat (buf, ", sh4a"); break;
2602 case EF_SH2A: strcat (buf, ", sh2a"); break;
2603 case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
2604 case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
2605 case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
2606 case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
2607 case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
2608 case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
2609 case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
2610 case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
2611 case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
2612 default: strcat (buf, _(", unknown ISA")); break;
2615 if (e_flags & EF_SH_PIC)
2616 strcat (buf, ", pic");
2618 if (e_flags & EF_SH_FDPIC)
2619 strcat (buf, ", fdpic");
2623 if (e_flags & EF_SPARC_32PLUS)
2624 strcat (buf, ", v8+");
2626 if (e_flags & EF_SPARC_SUN_US1)
2627 strcat (buf, ", ultrasparcI");
2629 if (e_flags & EF_SPARC_SUN_US3)
2630 strcat (buf, ", ultrasparcIII");
2632 if (e_flags & EF_SPARC_HAL_R1)
2633 strcat (buf, ", halr1");
2635 if (e_flags & EF_SPARC_LEDATA)
2636 strcat (buf, ", ledata");
2638 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
2639 strcat (buf, ", tso");
2641 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
2642 strcat (buf, ", pso");
2644 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
2645 strcat (buf, ", rmo");
2649 switch (e_flags & EF_PARISC_ARCH)
2651 case EFA_PARISC_1_0:
2652 strcpy (buf, ", PA-RISC 1.0");
2654 case EFA_PARISC_1_1:
2655 strcpy (buf, ", PA-RISC 1.1");
2657 case EFA_PARISC_2_0:
2658 strcpy (buf, ", PA-RISC 2.0");
2663 if (e_flags & EF_PARISC_TRAPNIL)
2664 strcat (buf, ", trapnil");
2665 if (e_flags & EF_PARISC_EXT)
2666 strcat (buf, ", ext");
2667 if (e_flags & EF_PARISC_LSB)
2668 strcat (buf, ", lsb");
2669 if (e_flags & EF_PARISC_WIDE)
2670 strcat (buf, ", wide");
2671 if (e_flags & EF_PARISC_NO_KABP)
2672 strcat (buf, ", no kabp");
2673 if (e_flags & EF_PARISC_LAZYSWAP)
2674 strcat (buf, ", lazyswap");
2679 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
2680 strcat (buf, ", new calling convention");
2682 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
2683 strcat (buf, ", gnu calling convention");
2687 if ((e_flags & EF_IA_64_ABI64))
2688 strcat (buf, ", 64-bit");
2690 strcat (buf, ", 32-bit");
2691 if ((e_flags & EF_IA_64_REDUCEDFP))
2692 strcat (buf, ", reduced fp model");
2693 if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
2694 strcat (buf, ", no function descriptors, constant gp");
2695 else if ((e_flags & EF_IA_64_CONS_GP))
2696 strcat (buf, ", constant gp");
2697 if ((e_flags & EF_IA_64_ABSOLUTE))
2698 strcat (buf, ", absolute");
2699 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
2701 if ((e_flags & EF_IA_64_VMS_LINKAGES))
2702 strcat (buf, ", vms_linkages");
2703 switch ((e_flags & EF_IA_64_VMS_COMCOD))
2705 case EF_IA_64_VMS_COMCOD_SUCCESS:
2707 case EF_IA_64_VMS_COMCOD_WARNING:
2708 strcat (buf, ", warning");
2710 case EF_IA_64_VMS_COMCOD_ERROR:
2711 strcat (buf, ", error");
2713 case EF_IA_64_VMS_COMCOD_ABORT:
2714 strcat (buf, ", abort");
2723 if ((e_flags & EF_VAX_NONPIC))
2724 strcat (buf, ", non-PIC");
2725 if ((e_flags & EF_VAX_DFLOAT))
2726 strcat (buf, ", D-Float");
2727 if ((e_flags & EF_VAX_GFLOAT))
2728 strcat (buf, ", G-Float");
2732 if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
2733 strcat (buf, ", 64-bit doubles");
2734 if (e_flags & E_FLAG_RX_DSP)
2735 strcat (buf, ", dsp");
2736 if (e_flags & E_FLAG_RX_PID)
2737 strcat (buf, ", pid");
2738 if (e_flags & E_FLAG_RX_ABI)
2739 strcat (buf, ", RX ABI");
2743 if (e_flags & EF_S390_HIGH_GPRS)
2744 strcat (buf, ", highgprs");
2748 if ((e_flags & EF_C6000_REL))
2749 strcat (buf, ", relocatable module");
2758 get_osabi_name (unsigned int osabi)
2760 static char buff[32];
2764 case ELFOSABI_NONE: return "UNIX - System V";
2765 case ELFOSABI_HPUX: return "UNIX - HP-UX";
2766 case ELFOSABI_NETBSD: return "UNIX - NetBSD";
2767 case ELFOSABI_GNU: return "UNIX - GNU";
2768 case ELFOSABI_SOLARIS: return "UNIX - Solaris";
2769 case ELFOSABI_AIX: return "UNIX - AIX";
2770 case ELFOSABI_IRIX: return "UNIX - IRIX";
2771 case ELFOSABI_FREEBSD: return "UNIX - FreeBSD";
2772 case ELFOSABI_TRU64: return "UNIX - TRU64";
2773 case ELFOSABI_MODESTO: return "Novell - Modesto";
2774 case ELFOSABI_OPENBSD: return "UNIX - OpenBSD";
2775 case ELFOSABI_OPENVMS: return "VMS - OpenVMS";
2776 case ELFOSABI_NSK: return "HP - Non-Stop Kernel";
2777 case ELFOSABI_AROS: return "AROS";
2778 case ELFOSABI_FENIXOS: return "FenixOS";
2781 switch (elf_header.e_machine)
2786 case ELFOSABI_ARM: return "ARM";
2796 case ELFOSABI_STANDALONE: return _("Standalone App");
2805 case ELFOSABI_C6000_ELFABI: return _("Bare-metal C6000");
2806 case ELFOSABI_C6000_LINUX: return "Linux C6000";
2815 snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
2821 get_aarch64_segment_type (unsigned long type)
2825 case PT_AARCH64_ARCHEXT:
2826 return "AARCH64_ARCHEXT";
2835 get_arm_segment_type (unsigned long type)
2849 get_mips_segment_type (unsigned long type)
2853 case PT_MIPS_REGINFO:
2855 case PT_MIPS_RTPROC:
2857 case PT_MIPS_OPTIONS:
2867 get_parisc_segment_type (unsigned long type)
2871 case PT_HP_TLS: return "HP_TLS";
2872 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
2873 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
2874 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
2875 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
2876 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
2877 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
2878 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
2879 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
2880 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
2881 case PT_HP_PARALLEL: return "HP_PARALLEL";
2882 case PT_HP_FASTBIND: return "HP_FASTBIND";
2883 case PT_HP_OPT_ANNOT: return "HP_OPT_ANNOT";
2884 case PT_HP_HSL_ANNOT: return "HP_HSL_ANNOT";
2885 case PT_HP_STACK: return "HP_STACK";
2886 case PT_HP_CORE_UTSNAME: return "HP_CORE_UTSNAME";
2887 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
2888 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
2889 case PT_PARISC_WEAKORDER: return "PARISC_WEAKORDER";
2898 get_ia64_segment_type (unsigned long type)
2902 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
2903 case PT_IA_64_UNWIND: return "IA_64_UNWIND";
2904 case PT_HP_TLS: return "HP_TLS";
2905 case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
2906 case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
2907 case PT_IA_64_HP_STACK: return "HP_STACK";
2916 get_tic6x_segment_type (unsigned long type)
2920 case PT_C6000_PHATTR: return "C6000_PHATTR";
2929 get_segment_type (unsigned long p_type)
2931 static char buff[32];
2935 case PT_NULL: return "NULL";
2936 case PT_LOAD: return "LOAD";
2937 case PT_DYNAMIC: return "DYNAMIC";
2938 case PT_INTERP: return "INTERP";
2939 case PT_NOTE: return "NOTE";
2940 case PT_SHLIB: return "SHLIB";
2941 case PT_PHDR: return "PHDR";
2942 case PT_TLS: return "TLS";
2944 case PT_GNU_EH_FRAME:
2945 return "GNU_EH_FRAME";
2946 case PT_GNU_STACK: return "GNU_STACK";
2947 case PT_GNU_RELRO: return "GNU_RELRO";
2950 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
2952 const char * result;
2954 switch (elf_header.e_machine)
2957 result = get_aarch64_segment_type (p_type);
2960 result = get_arm_segment_type (p_type);
2963 case EM_MIPS_RS3_LE:
2964 result = get_mips_segment_type (p_type);
2967 result = get_parisc_segment_type (p_type);
2970 result = get_ia64_segment_type (p_type);
2973 result = get_tic6x_segment_type (p_type);
2983 sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
2985 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
2987 const char * result;
2989 switch (elf_header.e_machine)
2992 result = get_parisc_segment_type (p_type);
2995 result = get_ia64_segment_type (p_type);
3005 sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
3008 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
3015 get_mips_section_type_name (unsigned int sh_type)
3019 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
3020 case SHT_MIPS_MSYM: return "MIPS_MSYM";
3021 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
3022 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
3023 case SHT_MIPS_UCODE: return "MIPS_UCODE";
3024 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
3025 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
3026 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
3027 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
3028 case SHT_MIPS_RELD: return "MIPS_RELD";
3029 case SHT_MIPS_IFACE: return "MIPS_IFACE";
3030 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
3031 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
3032 case SHT_MIPS_SHDR: return "MIPS_SHDR";
3033 case SHT_MIPS_FDESC: return "MIPS_FDESC";
3034 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
3035 case SHT_MIPS_DENSE: return "MIPS_DENSE";
3036 case SHT_MIPS_PDESC: return "MIPS_PDESC";
3037 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
3038 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
3039 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
3040 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
3041 case SHT_MIPS_LINE: return "MIPS_LINE";
3042 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
3043 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
3044 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
3045 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
3046 case SHT_MIPS_DWARF: return "MIPS_DWARF";
3047 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
3048 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
3049 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
3050 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
3051 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
3052 case SHT_MIPS_XLATE: return "MIPS_XLATE";
3053 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
3054 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
3055 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
3056 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
3057 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
3065 get_parisc_section_type_name (unsigned int sh_type)
3069 case SHT_PARISC_EXT: return "PARISC_EXT";
3070 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
3071 case SHT_PARISC_DOC: return "PARISC_DOC";
3072 case SHT_PARISC_ANNOT: return "PARISC_ANNOT";
3073 case SHT_PARISC_SYMEXTN: return "PARISC_SYMEXTN";
3074 case SHT_PARISC_STUBS: return "PARISC_STUBS";
3075 case SHT_PARISC_DLKM: return "PARISC_DLKM";
3083 get_ia64_section_type_name (unsigned int sh_type)
3085 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
3086 if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
3087 return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
3091 case SHT_IA_64_EXT: return "IA_64_EXT";
3092 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
3093 case SHT_IA_64_PRIORITY_INIT: return "IA_64_PRIORITY_INIT";
3094 case SHT_IA_64_VMS_TRACE: return "VMS_TRACE";
3095 case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
3096 case SHT_IA_64_VMS_DEBUG: return "VMS_DEBUG";
3097 case SHT_IA_64_VMS_DEBUG_STR: return "VMS_DEBUG_STR";
3098 case SHT_IA_64_VMS_LINKAGES: return "VMS_LINKAGES";
3099 case SHT_IA_64_VMS_SYMBOL_VECTOR: return "VMS_SYMBOL_VECTOR";
3100 case SHT_IA_64_VMS_FIXUP: return "VMS_FIXUP";
3108 get_x86_64_section_type_name (unsigned int sh_type)
3112 case SHT_X86_64_UNWIND: return "X86_64_UNWIND";
3120 get_aarch64_section_type_name (unsigned int sh_type)
3124 case SHT_AARCH64_ATTRIBUTES:
3125 return "AARCH64_ATTRIBUTES";
3133 get_arm_section_type_name (unsigned int sh_type)
3137 case SHT_ARM_EXIDX: return "ARM_EXIDX";
3138 case SHT_ARM_PREEMPTMAP: return "ARM_PREEMPTMAP";
3139 case SHT_ARM_ATTRIBUTES: return "ARM_ATTRIBUTES";
3140 case SHT_ARM_DEBUGOVERLAY: return "ARM_DEBUGOVERLAY";
3141 case SHT_ARM_OVERLAYSECTION: return "ARM_OVERLAYSECTION";
3149 get_tic6x_section_type_name (unsigned int sh_type)
3153 case SHT_C6000_UNWIND:
3154 return "C6000_UNWIND";
3155 case SHT_C6000_PREEMPTMAP:
3156 return "C6000_PREEMPTMAP";
3157 case SHT_C6000_ATTRIBUTES:
3158 return "C6000_ATTRIBUTES";
3163 case SHT_TI_HANDLER:
3164 return "TI_HANDLER";
3165 case SHT_TI_INITINFO:
3166 return "TI_INITINFO";
3167 case SHT_TI_PHATTRS:
3168 return "TI_PHATTRS";
3176 get_section_type_name (unsigned int sh_type)
3178 static char buff[32];
3182 case SHT_NULL: return "NULL";
3183 case SHT_PROGBITS: return "PROGBITS";
3184 case SHT_SYMTAB: return "SYMTAB";
3185 case SHT_STRTAB: return "STRTAB";
3186 case SHT_RELA: return "RELA";
3187 case SHT_HASH: return "HASH";
3188 case SHT_DYNAMIC: return "DYNAMIC";
3189 case SHT_NOTE: return "NOTE";
3190 case SHT_NOBITS: return "NOBITS";
3191 case SHT_REL: return "REL";
3192 case SHT_SHLIB: return "SHLIB";
3193 case SHT_DYNSYM: return "DYNSYM";
3194 case SHT_INIT_ARRAY: return "INIT_ARRAY";
3195 case SHT_FINI_ARRAY: return "FINI_ARRAY";
3196 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
3197 case SHT_GNU_HASH: return "GNU_HASH";
3198 case SHT_GROUP: return "GROUP";
3199 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICIES";
3200 case SHT_GNU_verdef: return "VERDEF";
3201 case SHT_GNU_verneed: return "VERNEED";
3202 case SHT_GNU_versym: return "VERSYM";
3203 case 0x6ffffff0: return "VERSYM";
3204 case 0x6ffffffc: return "VERDEF";
3205 case 0x7ffffffd: return "AUXILIARY";
3206 case 0x7fffffff: return "FILTER";
3207 case SHT_GNU_LIBLIST: return "GNU_LIBLIST";
3210 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
3212 const char * result;
3214 switch (elf_header.e_machine)
3217 case EM_MIPS_RS3_LE:
3218 result = get_mips_section_type_name (sh_type);
3221 result = get_parisc_section_type_name (sh_type);
3224 result = get_ia64_section_type_name (sh_type);
3229 result = get_x86_64_section_type_name (sh_type);
3232 result = get_aarch64_section_type_name (sh_type);
3235 result = get_arm_section_type_name (sh_type);
3238 result = get_tic6x_section_type_name (sh_type);
3248 sprintf (buff, "LOPROC+%x", sh_type - SHT_LOPROC);
3250 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
3252 const char * result;
3254 switch (elf_header.e_machine)
3257 result = get_ia64_section_type_name (sh_type);
3267 sprintf (buff, "LOOS+%x", sh_type - SHT_LOOS);
3269 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
3270 sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER);
3272 /* This message is probably going to be displayed in a 15
3273 character wide field, so put the hex value first. */
3274 snprintf (buff, sizeof (buff), _("%08x: <unknown>"), sh_type);
3280 #define OPTION_DEBUG_DUMP 512
3281 #define OPTION_DYN_SYMS 513
3282 #define OPTION_DWARF_DEPTH 514
3283 #define OPTION_DWARF_START 515
3284 #define OPTION_DWARF_CHECK 516
3286 static struct option options[] =
3288 {"all", no_argument, 0, 'a'},
3289 {"file-header", no_argument, 0, 'h'},
3290 {"program-headers", no_argument, 0, 'l'},
3291 {"headers", no_argument, 0, 'e'},
3292 {"histogram", no_argument, 0, 'I'},
3293 {"segments", no_argument, 0, 'l'},
3294 {"sections", no_argument, 0, 'S'},
3295 {"section-headers", no_argument, 0, 'S'},
3296 {"section-groups", no_argument, 0, 'g'},
3297 {"section-details", no_argument, 0, 't'},
3298 {"full-section-name",no_argument, 0, 'N'},
3299 {"symbols", no_argument, 0, 's'},
3300 {"syms", no_argument, 0, 's'},
3301 {"dyn-syms", no_argument, 0, OPTION_DYN_SYMS},
3302 {"relocs", no_argument, 0, 'r'},
3303 {"notes", no_argument, 0, 'n'},
3304 {"dynamic", no_argument, 0, 'd'},
3305 {"arch-specific", no_argument, 0, 'A'},
3306 {"version-info", no_argument, 0, 'V'},
3307 {"use-dynamic", no_argument, 0, 'D'},
3308 {"unwind", no_argument, 0, 'u'},
3309 {"archive-index", no_argument, 0, 'c'},
3310 {"hex-dump", required_argument, 0, 'x'},
3311 {"relocated-dump", required_argument, 0, 'R'},
3312 {"string-dump", required_argument, 0, 'p'},
3313 #ifdef SUPPORT_DISASSEMBLY
3314 {"instruction-dump", required_argument, 0, 'i'},
3316 {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
3318 {"dwarf-depth", required_argument, 0, OPTION_DWARF_DEPTH},
3319 {"dwarf-start", required_argument, 0, OPTION_DWARF_START},
3320 {"dwarf-check", no_argument, 0, OPTION_DWARF_CHECK},
3322 {"version", no_argument, 0, 'v'},
3323 {"wide", no_argument, 0, 'W'},
3324 {"help", no_argument, 0, 'H'},
3325 {0, no_argument, 0, 0}
3329 usage (FILE * stream)
3331 fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
3332 fprintf (stream, _(" Display information about the contents of ELF format files\n"));
3333 fprintf (stream, _(" Options are:\n\
3334 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3335 -h --file-header Display the ELF file header\n\
3336 -l --program-headers Display the program headers\n\
3337 --segments An alias for --program-headers\n\
3338 -S --section-headers Display the sections' header\n\
3339 --sections An alias for --section-headers\n\
3340 -g --section-groups Display the section groups\n\
3341 -t --section-details Display the section details\n\
3342 -e --headers Equivalent to: -h -l -S\n\
3343 -s --syms Display the symbol table\n\
3344 --symbols An alias for --syms\n\
3345 --dyn-syms Display the dynamic symbol table\n\
3346 -n --notes Display the core notes (if present)\n\
3347 -r --relocs Display the relocations (if present)\n\
3348 -u --unwind Display the unwind info (if present)\n\
3349 -d --dynamic Display the dynamic section (if present)\n\
3350 -V --version-info Display the version sections (if present)\n\
3351 -A --arch-specific Display architecture specific information (if any)\n\
3352 -c --archive-index Display the symbol/file index in an archive\n\
3353 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
3354 -x --hex-dump=<number|name>\n\
3355 Dump the contents of section <number|name> as bytes\n\
3356 -p --string-dump=<number|name>\n\
3357 Dump the contents of section <number|name> as strings\n\
3358 -R --relocated-dump=<number|name>\n\
3359 Dump the contents of section <number|name> as relocated bytes\n\
3360 -w[lLiaprmfFsoRt] or\n\
3361 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
3362 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
3363 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges,\n\
3365 Display the contents of DWARF2 debug sections\n"));
3366 fprintf (stream, _("\
3367 --dwarf-depth=N Do not display DIEs at depth N or greater\n\
3368 --dwarf-start=N Display DIEs starting with N, at the same depth\n\
3370 #ifdef SUPPORT_DISASSEMBLY
3371 fprintf (stream, _("\
3372 -i --instruction-dump=<number|name>\n\
3373 Disassemble the contents of section <number|name>\n"));
3375 fprintf (stream, _("\
3376 -I --histogram Display histogram of bucket list lengths\n\
3377 -W --wide Allow output width to exceed 80 characters\n\
3378 @<file> Read options from <file>\n\
3379 -H --help Display this information\n\
3380 -v --version Display the version number of readelf\n"));
3382 if (REPORT_BUGS_TO[0] && stream == stdout)
3383 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
3385 exit (stream == stdout ? 0 : 1);
3388 /* Record the fact that the user wants the contents of section number
3389 SECTION to be displayed using the method(s) encoded as flags bits
3390 in TYPE. Note, TYPE can be zero if we are creating the array for
3394 request_dump_bynumber (unsigned int section, dump_type type)
3396 if (section >= num_dump_sects)
3398 dump_type * new_dump_sects;
3400 new_dump_sects = (dump_type *) calloc (section + 1,
3401 sizeof (* dump_sects));
3403 if (new_dump_sects == NULL)
3404 error (_("Out of memory allocating dump request table.\n"));
3407 /* Copy current flag settings. */
3408 memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
3412 dump_sects = new_dump_sects;
3413 num_dump_sects = section + 1;
3418 dump_sects[section] |= type;
3423 /* Request a dump by section name. */
3426 request_dump_byname (const char * section, dump_type type)
3428 struct dump_list_entry * new_request;
3430 new_request = (struct dump_list_entry *)
3431 malloc (sizeof (struct dump_list_entry));
3433 error (_("Out of memory allocating dump request table.\n"));
3435 new_request->name = strdup (section);
3436 if (!new_request->name)
3437 error (_("Out of memory allocating dump request table.\n"));
3439 new_request->type = type;
3441 new_request->next = dump_sects_byname;
3442 dump_sects_byname = new_request;
3446 request_dump (dump_type type)
3452 section = strtoul (optarg, & cp, 0);
3454 if (! *cp && section >= 0)
3455 request_dump_bynumber (section, type);
3457 request_dump_byname (optarg, type);
3462 parse_args (int argc, char ** argv)
3469 while ((c = getopt_long
3470 (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options, NULL)) != EOF)
3488 do_section_groups++;
3496 do_section_groups++;
3501 do_section_details++;
3545 request_dump (HEX_DUMP);
3548 request_dump (STRING_DUMP);
3551 request_dump (RELOC_DUMP);
3558 dwarf_select_sections_all ();
3563 dwarf_select_sections_by_letters (optarg);
3566 case OPTION_DEBUG_DUMP:
3573 dwarf_select_sections_by_names (optarg);
3576 case OPTION_DWARF_DEPTH:
3580 dwarf_cutoff_level = strtoul (optarg, & cp, 0);
3583 case OPTION_DWARF_START:
3587 dwarf_start_die = strtoul (optarg, & cp, 0);
3590 case OPTION_DWARF_CHECK:
3593 case OPTION_DYN_SYMS:
3596 #ifdef SUPPORT_DISASSEMBLY
3598 request_dump (DISASS_DUMP);
3602 print_version (program_name);
3611 /* xgettext:c-format */
3612 error (_("Invalid option '-%c'\n"), c);
3619 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
3620 && !do_segments && !do_header && !do_dump && !do_version
3621 && !do_histogram && !do_debugging && !do_arch && !do_notes
3622 && !do_section_groups && !do_archive_index
3627 warn (_("Nothing to do.\n"));
3633 get_elf_class (unsigned int elf_class)
3635 static char buff[32];
3639 case ELFCLASSNONE: return _("none");
3640 case ELFCLASS32: return "ELF32";
3641 case ELFCLASS64: return "ELF64";
3643 snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
3649 get_data_encoding (unsigned int encoding)
3651 static char buff[32];
3655 case ELFDATANONE: return _("none");
3656 case ELFDATA2LSB: return _("2's complement, little endian");
3657 case ELFDATA2MSB: return _("2's complement, big endian");
3659 snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
3664 /* Decode the data held in 'elf_header'. */
3667 process_file_header (void)
3669 if ( elf_header.e_ident[EI_MAG0] != ELFMAG0
3670 || elf_header.e_ident[EI_MAG1] != ELFMAG1
3671 || elf_header.e_ident[EI_MAG2] != ELFMAG2
3672 || elf_header.e_ident[EI_MAG3] != ELFMAG3)
3675 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3679 init_dwarf_regnames (elf_header.e_machine);
3685 printf (_("ELF Header:\n"));
3686 printf (_(" Magic: "));
3687 for (i = 0; i < EI_NIDENT; i++)
3688 printf ("%2.2x ", elf_header.e_ident[i]);
3690 printf (_(" Class: %s\n"),
3691 get_elf_class (elf_header.e_ident[EI_CLASS]));
3692 printf (_(" Data: %s\n"),
3693 get_data_encoding (elf_header.e_ident[EI_DATA]));
3694 printf (_(" Version: %d %s\n"),
3695 elf_header.e_ident[EI_VERSION],
3696 (elf_header.e_ident[EI_VERSION] == EV_CURRENT
3698 : (elf_header.e_ident[EI_VERSION] != EV_NONE
3699 ? _("<unknown: %lx>")
3701 printf (_(" OS/ABI: %s\n"),
3702 get_osabi_name (elf_header.e_ident[EI_OSABI]));
3703 printf (_(" ABI Version: %d\n"),
3704 elf_header.e_ident[EI_ABIVERSION]);
3705 printf (_(" Type: %s\n"),
3706 get_file_type (elf_header.e_type));
3707 printf (_(" Machine: %s\n"),
3708 get_machine_name (elf_header.e_machine));
3709 printf (_(" Version: 0x%lx\n"),
3710 (unsigned long) elf_header.e_version);
3712 printf (_(" Entry point address: "));
3713 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
3714 printf (_("\n Start of program headers: "));
3715 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
3716 printf (_(" (bytes into file)\n Start of section headers: "));
3717 print_vma ((bfd_vma) elf_header.e_shoff, DEC);
3718 printf (_(" (bytes into file)\n"));
3720 printf (_(" Flags: 0x%lx%s\n"),
3721 (unsigned long) elf_header.e_flags,
3722 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
3723 printf (_(" Size of this header: %ld (bytes)\n"),
3724 (long) elf_header.e_ehsize);
3725 printf (_(" Size of program headers: %ld (bytes)\n"),
3726 (long) elf_header.e_phentsize);
3727 printf (_(" Number of program headers: %ld"),
3728 (long) elf_header.e_phnum);
3729 if (section_headers != NULL
3730 && elf_header.e_phnum == PN_XNUM
3731 && section_headers[0].sh_info != 0)
3732 printf (" (%ld)", (long) section_headers[0].sh_info);
3733 putc ('\n', stdout);
3734 printf (_(" Size of section headers: %ld (bytes)\n"),
3735 (long) elf_header.e_shentsize);
3736 printf (_(" Number of section headers: %ld"),
3737 (long) elf_header.e_shnum);
3738 if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
3739 printf (" (%ld)", (long) section_headers[0].sh_size);
3740 putc ('\n', stdout);
3741 printf (_(" Section header string table index: %ld"),
3742 (long) elf_header.e_shstrndx);
3743 if (section_headers != NULL
3744 && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
3745 printf (" (%u)", section_headers[0].sh_link);
3746 else if (elf_header.e_shstrndx != SHN_UNDEF
3747 && elf_header.e_shstrndx >= elf_header.e_shnum)
3748 printf (_(" <corrupt: out of range>"));
3749 putc ('\n', stdout);
3752 if (section_headers != NULL)
3754 if (elf_header.e_phnum == PN_XNUM
3755 && section_headers[0].sh_info != 0)
3756 elf_header.e_phnum = section_headers[0].sh_info;
3757 if (elf_header.e_shnum == SHN_UNDEF)
3758 elf_header.e_shnum = section_headers[0].sh_size;
3759 if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
3760 elf_header.e_shstrndx = section_headers[0].sh_link;
3761 else if (elf_header.e_shstrndx >= elf_header.e_shnum)
3762 elf_header.e_shstrndx = SHN_UNDEF;
3763 free (section_headers);
3764 section_headers = NULL;
3772 get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
3774 Elf32_External_Phdr * phdrs;
3775 Elf32_External_Phdr * external;
3776 Elf_Internal_Phdr * internal;
3779 phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
3780 elf_header.e_phentsize,
3782 _("program headers"));
3786 for (i = 0, internal = pheaders, external = phdrs;
3787 i < elf_header.e_phnum;
3788 i++, internal++, external++)
3790 internal->p_type = BYTE_GET (external->p_type);
3791 internal->p_offset = BYTE_GET (external->p_offset);
3792 internal->p_vaddr = BYTE_GET (external->p_vaddr);
3793 internal->p_paddr = BYTE_GET (external->p_paddr);
3794 internal->p_filesz = BYTE_GET (external->p_filesz);
3795 internal->p_memsz = BYTE_GET (external->p_memsz);
3796 internal->p_flags = BYTE_GET (external->p_flags);
3797 internal->p_align = BYTE_GET (external->p_align);
3806 get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
3808 Elf64_External_Phdr * phdrs;
3809 Elf64_External_Phdr * external;
3810 Elf_Internal_Phdr * internal;
3813 phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
3814 elf_header.e_phentsize,
3816 _("program headers"));
3820 for (i = 0, internal = pheaders, external = phdrs;
3821 i < elf_header.e_phnum;
3822 i++, internal++, external++)
3824 internal->p_type = BYTE_GET (external->p_type);
3825 internal->p_flags = BYTE_GET (external->p_flags);
3826 internal->p_offset = BYTE_GET (external->p_offset);
3827 internal->p_vaddr = BYTE_GET (external->p_vaddr);
3828 internal->p_paddr = BYTE_GET (external->p_paddr);
3829 internal->p_filesz = BYTE_GET (external->p_filesz);
3830 internal->p_memsz = BYTE_GET (external->p_memsz);
3831 internal->p_align = BYTE_GET (external->p_align);
3839 /* Returns 1 if the program headers were read into `program_headers'. */
3842 get_program_headers (FILE * file)
3844 Elf_Internal_Phdr * phdrs;
3846 /* Check cache of prior read. */
3847 if (program_headers != NULL)
3850 phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
3851 sizeof (Elf_Internal_Phdr));
3855 error (_("Out of memory\n"));
3860 ? get_32bit_program_headers (file, phdrs)
3861 : get_64bit_program_headers (file, phdrs))
3863 program_headers = phdrs;
3871 /* Returns 1 if the program headers were loaded. */
3874 process_program_headers (FILE * file)
3876 Elf_Internal_Phdr * segment;
3879 if (elf_header.e_phnum == 0)
3881 /* PR binutils/12467. */
3882 if (elf_header.e_phoff != 0)
3883 warn (_("possibly corrupt ELF header - it has a non-zero program"
3884 " header offset, but no program headers"));
3885 else if (do_segments)
3886 printf (_("\nThere are no program headers in this file.\n"));
3890 if (do_segments && !do_header)
3892 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
3893 printf (_("Entry point "));
3894 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
3895 printf (_("\nThere are %d program headers, starting at offset "),
3896 elf_header.e_phnum);
3897 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
3901 if (! get_program_headers (file))
3906 if (elf_header.e_phnum > 1)
3907 printf (_("\nProgram Headers:\n"));
3909 printf (_("\nProgram Headers:\n"));
3913 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3916 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3920 (_(" Type Offset VirtAddr PhysAddr\n"));
3922 (_(" FileSiz MemSiz Flags Align\n"));
3929 for (i = 0, segment = program_headers;
3930 i < elf_header.e_phnum;
3935 printf (" %-14.14s ", get_segment_type (segment->p_type));
3939 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
3940 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
3941 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
3942 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
3943 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
3945 (segment->p_flags & PF_R ? 'R' : ' '),
3946 (segment->p_flags & PF_W ? 'W' : ' '),
3947 (segment->p_flags & PF_X ? 'E' : ' '));
3948 printf ("%#lx", (unsigned long) segment->p_align);
3952 if ((unsigned long) segment->p_offset == segment->p_offset)
3953 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
3956 print_vma (segment->p_offset, FULL_HEX);
3960 print_vma (segment->p_vaddr, FULL_HEX);
3962 print_vma (segment->p_paddr, FULL_HEX);
3965 if ((unsigned long) segment->p_filesz == segment->p_filesz)
3966 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
3969 print_vma (segment->p_filesz, FULL_HEX);
3973 if ((unsigned long) segment->p_memsz == segment->p_memsz)
3974 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
3977 print_vma (segment->p_memsz, FULL_HEX);
3981 (segment->p_flags & PF_R ? 'R' : ' '),
3982 (segment->p_flags & PF_W ? 'W' : ' '),
3983 (segment->p_flags & PF_X ? 'E' : ' '));
3985 if ((unsigned long) segment->p_align == segment->p_align)
3986 printf ("%#lx", (unsigned long) segment->p_align);
3989 print_vma (segment->p_align, PREFIX_HEX);
3994 print_vma (segment->p_offset, FULL_HEX);
3996 print_vma (segment->p_vaddr, FULL_HEX);
3998 print_vma (segment->p_paddr, FULL_HEX);
4000 print_vma (segment->p_filesz, FULL_HEX);
4002 print_vma (segment->p_memsz, FULL_HEX);
4004 (segment->p_flags & PF_R ? 'R' : ' '),
4005 (segment->p_flags & PF_W ? 'W' : ' '),
4006 (segment->p_flags & PF_X ? 'E' : ' '));
4007 print_vma (segment->p_align, HEX);
4011 switch (segment->p_type)
4015 error (_("more than one dynamic segment\n"));
4017 /* By default, assume that the .dynamic section is the first
4018 section in the DYNAMIC segment. */
4019 dynamic_addr = segment->p_offset;
4020 dynamic_size = segment->p_filesz;
4022 /* Try to locate the .dynamic section. If there is
4023 a section header table, we can easily locate it. */
4024 if (section_headers != NULL)
4026 Elf_Internal_Shdr * sec;
4028 sec = find_section (".dynamic");
4029 if (sec == NULL || sec->sh_size == 0)
4031 /* A corresponding .dynamic section is expected, but on
4032 IA-64/OpenVMS it is OK for it to be missing. */
4033 if (!is_ia64_vms ())
4034 error (_("no .dynamic section in the dynamic segment\n"));
4038 if (sec->sh_type == SHT_NOBITS)
4044 dynamic_addr = sec->sh_offset;
4045 dynamic_size = sec->sh_size;
4047 if (dynamic_addr < segment->p_offset
4048 || dynamic_addr > segment->p_offset + segment->p_filesz)
4049 warn (_("the .dynamic section is not contained"
4050 " within the dynamic segment\n"));
4051 else if (dynamic_addr > segment->p_offset)
4052 warn (_("the .dynamic section is not the first section"
4053 " in the dynamic segment.\n"));
4058 if (fseek (file, archive_file_offset + (long) segment->p_offset,
4060 error (_("Unable to find program interpreter name\n"));
4064 int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX);
4066 if (ret >= (int) sizeof (fmt) || ret < 0)
4067 error (_("Internal error: failed to create format string to display program interpreter\n"));
4069 program_interpreter[0] = 0;
4070 if (fscanf (file, fmt, program_interpreter) <= 0)
4071 error (_("Unable to read program interpreter name\n"));
4074 printf (_("\n [Requesting program interpreter: %s]"),
4075 program_interpreter);
4081 putc ('\n', stdout);
4084 if (do_segments && section_headers != NULL && string_table != NULL)
4086 printf (_("\n Section to Segment mapping:\n"));
4087 printf (_(" Segment Sections...\n"));
4089 for (i = 0; i < elf_header.e_phnum; i++)
4092 Elf_Internal_Shdr * section;
4094 segment = program_headers + i;
4095 section = section_headers + 1;
4097 printf (" %2.2d ", i);
4099 for (j = 1; j < elf_header.e_shnum; j++, section++)
4101 if (!ELF_TBSS_SPECIAL (section, segment)
4102 && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
4103 printf ("%s ", SECTION_NAME (section));
4114 /* Find the file offset corresponding to VMA by using the program headers. */
4117 offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
4119 Elf_Internal_Phdr * seg;
4121 if (! get_program_headers (file))
4123 warn (_("Cannot interpret virtual addresses without program headers.\n"));
4127 for (seg = program_headers;
4128 seg < program_headers + elf_header.e_phnum;
4131 if (seg->p_type != PT_LOAD)
4134 if (vma >= (seg->p_vaddr & -seg->p_align)
4135 && vma + size <= seg->p_vaddr + seg->p_filesz)
4136 return vma - seg->p_vaddr + seg->p_offset;
4139 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
4140 (unsigned long) vma);
4146 get_32bit_section_headers (FILE * file, unsigned int num)
4148 Elf32_External_Shdr * shdrs;
4149 Elf_Internal_Shdr * internal;
4152 shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
4153 elf_header.e_shentsize, num,
4154 _("section headers"));
4158 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4159 sizeof (Elf_Internal_Shdr));
4161 if (section_headers == NULL)
4163 error (_("Out of memory\n"));
4167 for (i = 0, internal = section_headers;
4171 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4172 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
4173 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4174 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4175 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
4176 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4177 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4178 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
4179 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4180 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
4189 get_64bit_section_headers (FILE * file, unsigned int num)
4191 Elf64_External_Shdr * shdrs;
4192 Elf_Internal_Shdr * internal;
4195 shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
4196 elf_header.e_shentsize, num,
4197 _("section headers"));
4201 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
4202 sizeof (Elf_Internal_Shdr));
4204 if (section_headers == NULL)
4206 error (_("Out of memory\n"));
4210 for (i = 0, internal = section_headers;
4214 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
4215 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
4216 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
4217 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
4218 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
4219 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
4220 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
4221 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
4222 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
4223 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
4231 static Elf_Internal_Sym *
4232 get_32bit_elf_symbols (FILE * file,
4233 Elf_Internal_Shdr * section,
4234 unsigned long * num_syms_return)
4236 unsigned long number = 0;
4237 Elf32_External_Sym * esyms = NULL;
4238 Elf_External_Sym_Shndx * shndx = NULL;
4239 Elf_Internal_Sym * isyms = NULL;
4240 Elf_Internal_Sym * psym;
4243 /* Run some sanity checks first. */
4244 if (section->sh_entsize == 0)
4246 error (_("sh_entsize is zero\n"));
4250 number = section->sh_size / section->sh_entsize;
4252 if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
4254 error (_("Invalid sh_entsize\n"));
4258 esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4259 section->sh_size, _("symbols"));
4264 if (symtab_shndx_hdr != NULL
4265 && (symtab_shndx_hdr->sh_link
4266 == (unsigned long) (section - section_headers)))
4268 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4269 symtab_shndx_hdr->sh_offset,
4270 1, symtab_shndx_hdr->sh_size,
4271 _("symbol table section indicies"));
4276 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
4280 error (_("Out of memory\n"));
4284 for (j = 0, psym = isyms; j < number; j++, psym++)
4286 psym->st_name = BYTE_GET (esyms[j].st_name);
4287 psym->st_value = BYTE_GET (esyms[j].st_value);
4288 psym->st_size = BYTE_GET (esyms[j].st_size);
4289 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4290 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
4292 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4293 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4294 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
4295 psym->st_info = BYTE_GET (esyms[j].st_info);
4296 psym->st_other = BYTE_GET (esyms[j].st_other);
4305 if (num_syms_return != NULL)
4306 * num_syms_return = isyms == NULL ? 0 : number;
4311 static Elf_Internal_Sym *
4312 get_64bit_elf_symbols (FILE * file,
4313 Elf_Internal_Shdr * section,
4314 unsigned long * num_syms_return)
4316 unsigned long number = 0;
4317 Elf64_External_Sym * esyms = NULL;
4318 Elf_External_Sym_Shndx * shndx = NULL;
4319 Elf_Internal_Sym * isyms = NULL;
4320 Elf_Internal_Sym * psym;
4323 /* Run some sanity checks first. */
4324 if (section->sh_entsize == 0)
4326 error (_("sh_entsize is zero\n"));
4330 number = section->sh_size / section->sh_entsize;
4332 if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
4334 error (_("Invalid sh_entsize\n"));
4338 esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4339 section->sh_size, _("symbols"));
4343 if (symtab_shndx_hdr != NULL
4344 && (symtab_shndx_hdr->sh_link
4345 == (unsigned long) (section - section_headers)))
4347 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4348 symtab_shndx_hdr->sh_offset,
4349 1, symtab_shndx_hdr->sh_size,
4350 _("symbol table section indicies"));
4355 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
4359 error (_("Out of memory\n"));
4363 for (j = 0, psym = isyms; j < number; j++, psym++)
4365 psym->st_name = BYTE_GET (esyms[j].st_name);
4366 psym->st_info = BYTE_GET (esyms[j].st_info);
4367 psym->st_other = BYTE_GET (esyms[j].st_other);
4368 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4370 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
4372 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4373 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4374 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
4376 psym->st_value = BYTE_GET (esyms[j].st_value);
4377 psym->st_size = BYTE_GET (esyms[j].st_size);
4386 if (num_syms_return != NULL)
4387 * num_syms_return = isyms == NULL ? 0 : number;
4393 get_elf_section_flags (bfd_vma sh_flags)
4395 static char buff[1024];
4397 int field_size = is_32bit_elf ? 8 : 16;
4399 int size = sizeof (buff) - (field_size + 4 + 1);
4400 bfd_vma os_flags = 0;
4401 bfd_vma proc_flags = 0;
4402 bfd_vma unknown_flags = 0;
4410 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
4411 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
4412 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
4413 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
4414 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
4415 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
4416 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
4417 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
4418 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
4419 /* 9 */ { STRING_COMMA_LEN ("TLS") },
4420 /* IA-64 specific. */
4421 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
4422 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
4423 /* IA-64 OpenVMS specific. */
4424 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
4425 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
4426 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
4427 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
4428 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
4429 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
4431 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
4432 /* SPARC specific. */
4433 /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
4436 if (do_section_details)
4438 sprintf (buff, "[%*.*lx]: ",
4439 field_size, field_size, (unsigned long) sh_flags);
4440 p += field_size + 4;
4447 flag = sh_flags & - sh_flags;
4450 if (do_section_details)
4454 case SHF_WRITE: sindex = 0; break;
4455 case SHF_ALLOC: sindex = 1; break;
4456 case SHF_EXECINSTR: sindex = 2; break;
4457 case SHF_MERGE: sindex = 3; break;
4458 case SHF_STRINGS: sindex = 4; break;
4459 case SHF_INFO_LINK: sindex = 5; break;
4460 case SHF_LINK_ORDER: sindex = 6; break;
4461 case SHF_OS_NONCONFORMING: sindex = 7; break;
4462 case SHF_GROUP: sindex = 8; break;
4463 case SHF_TLS: sindex = 9; break;
4464 case SHF_EXCLUDE: sindex = 18; break;
4468 switch (elf_header.e_machine)
4471 if (flag == SHF_IA_64_SHORT)
4473 else if (flag == SHF_IA_64_NORECOV)
4476 else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
4479 case SHF_IA_64_VMS_GLOBAL: sindex = 12; break;
4480 case SHF_IA_64_VMS_OVERLAID: sindex = 13; break;
4481 case SHF_IA_64_VMS_SHARED: sindex = 14; break;
4482 case SHF_IA_64_VMS_VECTOR: sindex = 15; break;
4483 case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
4484 case SHF_IA_64_VMS_PROTECTED: sindex = 17; break;
4495 case EM_OLD_SPARCV9:
4496 case EM_SPARC32PLUS:
4499 if (flag == SHF_ORDERED)
4509 if (p != buff + field_size + 4)
4511 if (size < (10 + 2))
4518 size -= flags [sindex].len;
4519 p = stpcpy (p, flags [sindex].str);
4521 else if (flag & SHF_MASKOS)
4523 else if (flag & SHF_MASKPROC)
4526 unknown_flags |= flag;
4532 case SHF_WRITE: *p = 'W'; break;
4533 case SHF_ALLOC: *p = 'A'; break;
4534 case SHF_EXECINSTR: *p = 'X'; break;
4535 case SHF_MERGE: *p = 'M'; break;
4536 case SHF_STRINGS: *p = 'S'; break;
4537 case SHF_INFO_LINK: *p = 'I'; break;
4538 case SHF_LINK_ORDER: *p = 'L'; break;
4539 case SHF_OS_NONCONFORMING: *p = 'O'; break;
4540 case SHF_GROUP: *p = 'G'; break;
4541 case SHF_TLS: *p = 'T'; break;
4542 case SHF_EXCLUDE: *p = 'E'; break;
4545 if ((elf_header.e_machine == EM_X86_64
4546 || elf_header.e_machine == EM_L1OM
4547 || elf_header.e_machine == EM_K1OM)
4548 && flag == SHF_X86_64_LARGE)
4550 else if (flag & SHF_MASKOS)
4553 sh_flags &= ~ SHF_MASKOS;
4555 else if (flag & SHF_MASKPROC)
4558 sh_flags &= ~ SHF_MASKPROC;
4568 if (do_section_details)
4572 size -= 5 + field_size;
4573 if (p != buff + field_size + 4)
4581 sprintf (p, "OS (%*.*lx)", field_size, field_size,
4582 (unsigned long) os_flags);
4583 p += 5 + field_size;
4587 size -= 7 + field_size;
4588 if (p != buff + field_size + 4)
4596 sprintf (p, "PROC (%*.*lx)", field_size, field_size,
4597 (unsigned long) proc_flags);
4598 p += 7 + field_size;
4602 size -= 10 + field_size;
4603 if (p != buff + field_size + 4)
4611 sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
4612 (unsigned long) unknown_flags);
4613 p += 10 + field_size;
4622 process_section_headers (FILE * file)
4624 Elf_Internal_Shdr * section;
4627 section_headers = NULL;
4629 if (elf_header.e_shnum == 0)
4631 /* PR binutils/12467. */
4632 if (elf_header.e_shoff != 0)
4633 warn (_("possibly corrupt ELF file header - it has a non-zero"
4634 " section header offset, but no section headers\n"));
4635 else if (do_sections)
4636 printf (_("\nThere are no sections in this file.\n"));
4641 if (do_sections && !do_header)
4642 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
4643 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
4647 if (! get_32bit_section_headers (file, elf_header.e_shnum))
4650 else if (! get_64bit_section_headers (file, elf_header.e_shnum))
4653 /* Read in the string table, so that we have names to display. */
4654 if (elf_header.e_shstrndx != SHN_UNDEF
4655 && elf_header.e_shstrndx < elf_header.e_shnum)
4657 section = section_headers + elf_header.e_shstrndx;
4659 if (section->sh_size != 0)
4661 string_table = (char *) get_data (NULL, file, section->sh_offset,
4662 1, section->sh_size,
4665 string_table_length = string_table != NULL ? section->sh_size : 0;
4669 /* Scan the sections for the dynamic symbol table
4670 and dynamic string table and debug sections. */
4671 dynamic_symbols = NULL;
4672 dynamic_strings = NULL;
4673 dynamic_syminfo = NULL;
4674 symtab_shndx_hdr = NULL;
4676 eh_addr_size = is_32bit_elf ? 4 : 8;
4677 switch (elf_header.e_machine)
4680 case EM_MIPS_RS3_LE:
4681 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
4682 FDE addresses. However, the ABI also has a semi-official ILP32
4683 variant for which the normal FDE address size rules apply.
4685 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
4686 section, where XX is the size of longs in bits. Unfortunately,
4687 earlier compilers provided no way of distinguishing ILP32 objects
4688 from LP64 objects, so if there's any doubt, we should assume that
4689 the official LP64 form is being used. */
4690 if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
4691 && find_section (".gcc_compiled_long32") == NULL)
4697 switch (elf_header.e_flags & EF_H8_MACH)
4699 case E_H8_MACH_H8300:
4700 case E_H8_MACH_H8300HN:
4701 case E_H8_MACH_H8300SN:
4702 case E_H8_MACH_H8300SXN:
4705 case E_H8_MACH_H8300H:
4706 case E_H8_MACH_H8300S:
4707 case E_H8_MACH_H8300SX:
4715 switch (elf_header.e_flags & EF_M32C_CPU_MASK)
4717 case EF_M32C_CPU_M16C:
4724 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
4727 size_t expected_entsize \
4728 = is_32bit_elf ? size32 : size64; \
4729 if (section->sh_entsize != expected_entsize) \
4730 error (_("Section %d has invalid sh_entsize %lx (expected %lx)\n"), \
4731 i, (unsigned long int) section->sh_entsize, \
4732 (unsigned long int) expected_entsize); \
4733 section->sh_entsize = expected_entsize; \
4736 #define CHECK_ENTSIZE(section, i, type) \
4737 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
4738 sizeof (Elf64_External_##type))
4740 for (i = 0, section = section_headers;
4741 i < elf_header.e_shnum;
4744 char * name = SECTION_NAME (section);
4746 if (section->sh_type == SHT_DYNSYM)
4748 if (dynamic_symbols != NULL)
4750 error (_("File contains multiple dynamic symbol tables\n"));
4754 CHECK_ENTSIZE (section, i, Sym);
4755 dynamic_symbols = GET_ELF_SYMBOLS (file, section, & num_dynamic_syms);
4757 else if (section->sh_type == SHT_STRTAB
4758 && streq (name, ".dynstr"))
4760 if (dynamic_strings != NULL)
4762 error (_("File contains multiple dynamic string tables\n"));
4766 dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
4767 1, section->sh_size,
4768 _("dynamic strings"));
4769 dynamic_strings_length = dynamic_strings == NULL ? 0 : section->sh_size;
4771 else if (section->sh_type == SHT_SYMTAB_SHNDX)
4773 if (symtab_shndx_hdr != NULL)
4775 error (_("File contains multiple symtab shndx tables\n"));
4778 symtab_shndx_hdr = section;
4780 else if (section->sh_type == SHT_SYMTAB)
4781 CHECK_ENTSIZE (section, i, Sym);
4782 else if (section->sh_type == SHT_GROUP)
4783 CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
4784 else if (section->sh_type == SHT_REL)
4785 CHECK_ENTSIZE (section, i, Rel);
4786 else if (section->sh_type == SHT_RELA)
4787 CHECK_ENTSIZE (section, i, Rela);
4788 else if ((do_debugging || do_debug_info || do_debug_abbrevs
4789 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
4790 || do_debug_aranges || do_debug_frames || do_debug_macinfo
4791 || do_debug_str || do_debug_loc || do_debug_ranges
4792 || do_debug_addr || do_debug_cu_index)
4793 && (const_strneq (name, ".debug_")
4794 || const_strneq (name, ".zdebug_")))
4797 name += sizeof (".zdebug_") - 1;
4799 name += sizeof (".debug_") - 1;
4802 || (do_debug_info && const_strneq (name, "info"))
4803 || (do_debug_info && const_strneq (name, "types"))
4804 || (do_debug_abbrevs && const_strneq (name, "abbrev"))
4805 || (do_debug_lines && const_strneq (name, "line"))
4806 || (do_debug_pubnames && const_strneq (name, "pubnames"))
4807 || (do_debug_pubtypes && const_strneq (name, "pubtypes"))
4808 || (do_debug_aranges && const_strneq (name, "aranges"))
4809 || (do_debug_ranges && const_strneq (name, "ranges"))
4810 || (do_debug_frames && const_strneq (name, "frame"))
4811 || (do_debug_macinfo && const_strneq (name, "macinfo"))
4812 || (do_debug_macinfo && const_strneq (name, "macro"))
4813 || (do_debug_str && const_strneq (name, "str"))
4814 || (do_debug_loc && const_strneq (name, "loc"))
4815 || (do_debug_addr && const_strneq (name, "addr"))
4816 || (do_debug_cu_index && const_strneq (name, "cu_index"))
4817 || (do_debug_cu_index && const_strneq (name, "tu_index"))
4819 request_dump_bynumber (i, DEBUG_DUMP);
4821 /* Linkonce section to be combined with .debug_info at link time. */
4822 else if ((do_debugging || do_debug_info)
4823 && const_strneq (name, ".gnu.linkonce.wi."))
4824 request_dump_bynumber (i, DEBUG_DUMP);
4825 else if (do_debug_frames && streq (name, ".eh_frame"))
4826 request_dump_bynumber (i, DEBUG_DUMP);
4827 else if (do_gdb_index && streq (name, ".gdb_index"))
4828 request_dump_bynumber (i, DEBUG_DUMP);
4829 /* Trace sections for Itanium VMS. */
4830 else if ((do_debugging || do_trace_info || do_trace_abbrevs
4831 || do_trace_aranges)
4832 && const_strneq (name, ".trace_"))
4834 name += sizeof (".trace_") - 1;
4837 || (do_trace_info && streq (name, "info"))
4838 || (do_trace_abbrevs && streq (name, "abbrev"))
4839 || (do_trace_aranges && streq (name, "aranges"))
4841 request_dump_bynumber (i, DEBUG_DUMP);
4849 if (elf_header.e_shnum > 1)
4850 printf (_("\nSection Headers:\n"));
4852 printf (_("\nSection Header:\n"));
4856 if (do_section_details)
4858 printf (_(" [Nr] Name\n"));
4859 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
4863 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
4867 if (do_section_details)
4869 printf (_(" [Nr] Name\n"));
4870 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
4874 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
4878 if (do_section_details)
4880 printf (_(" [Nr] Name\n"));
4881 printf (_(" Type Address Offset Link\n"));
4882 printf (_(" Size EntSize Info Align\n"));
4886 printf (_(" [Nr] Name Type Address Offset\n"));
4887 printf (_(" Size EntSize Flags Link Info Align\n"));
4891 if (do_section_details)
4892 printf (_(" Flags\n"));
4894 for (i = 0, section = section_headers;
4895 i < elf_header.e_shnum;
4898 printf (" [%2u] ", i);
4899 if (do_section_details)
4901 print_symbol (INT_MAX, SECTION_NAME (section));
4906 print_symbol (-17, SECTION_NAME (section));
4909 printf (do_wide ? " %-15s " : " %-15.15s ",
4910 get_section_type_name (section->sh_type));
4914 const char * link_too_big = NULL;
4916 print_vma (section->sh_addr, LONG_HEX);
4918 printf ( " %6.6lx %6.6lx %2.2lx",
4919 (unsigned long) section->sh_offset,
4920 (unsigned long) section->sh_size,
4921 (unsigned long) section->sh_entsize);
4923 if (do_section_details)
4924 fputs (" ", stdout);
4926 printf (" %3s ", get_elf_section_flags (section->sh_flags));
4928 if (section->sh_link >= elf_header.e_shnum)
4931 /* The sh_link value is out of range. Normally this indicates
4932 an error but it can have special values in Solaris binaries. */
4933 switch (elf_header.e_machine)
4940 case EM_OLD_SPARCV9:
4941 case EM_SPARC32PLUS:
4944 if (section->sh_link == (SHN_BEFORE & 0xffff))
4945 link_too_big = "BEFORE";
4946 else if (section->sh_link == (SHN_AFTER & 0xffff))
4947 link_too_big = "AFTER";
4954 if (do_section_details)
4956 if (link_too_big != NULL && * link_too_big)
4957 printf ("<%s> ", link_too_big);
4959 printf ("%2u ", section->sh_link);
4960 printf ("%3u %2lu\n", section->sh_info,
4961 (unsigned long) section->sh_addralign);
4964 printf ("%2u %3u %2lu\n",
4967 (unsigned long) section->sh_addralign);
4969 if (link_too_big && ! * link_too_big)
4970 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
4971 i, section->sh_link);
4975 print_vma (section->sh_addr, LONG_HEX);
4977 if ((long) section->sh_offset == section->sh_offset)
4978 printf (" %6.6lx", (unsigned long) section->sh_offset);
4982 print_vma (section->sh_offset, LONG_HEX);
4985 if ((unsigned long) section->sh_size == section->sh_size)
4986 printf (" %6.6lx", (unsigned long) section->sh_size);
4990 print_vma (section->sh_size, LONG_HEX);
4993 if ((unsigned long) section->sh_entsize == section->sh_entsize)
4994 printf (" %2.2lx", (unsigned long) section->sh_entsize);
4998 print_vma (section->sh_entsize, LONG_HEX);
5001 if (do_section_details)
5002 fputs (" ", stdout);
5004 printf (" %3s ", get_elf_section_flags (section->sh_flags));
5006 printf ("%2u %3u ", section->sh_link, section->sh_info);
5008 if ((unsigned long) section->sh_addralign == section->sh_addralign)
5009 printf ("%2lu\n", (unsigned long) section->sh_addralign);
5012 print_vma (section->sh_addralign, DEC);
5016 else if (do_section_details)
5018 printf (" %-15.15s ",
5019 get_section_type_name (section->sh_type));
5020 print_vma (section->sh_addr, LONG_HEX);
5021 if ((long) section->sh_offset == section->sh_offset)
5022 printf (" %16.16lx", (unsigned long) section->sh_offset);
5026 print_vma (section->sh_offset, LONG_HEX);
5028 printf (" %u\n ", section->sh_link);
5029 print_vma (section->sh_size, LONG_HEX);
5031 print_vma (section->sh_entsize, LONG_HEX);
5033 printf (" %-16u %lu\n",
5035 (unsigned long) section->sh_addralign);
5040 print_vma (section->sh_addr, LONG_HEX);
5041 if ((long) section->sh_offset == section->sh_offset)
5042 printf (" %8.8lx", (unsigned long) section->sh_offset);
5046 print_vma (section->sh_offset, LONG_HEX);
5049 print_vma (section->sh_size, LONG_HEX);
5051 print_vma (section->sh_entsize, LONG_HEX);
5053 printf (" %3s ", get_elf_section_flags (section->sh_flags));
5055 printf (" %2u %3u %lu\n",
5058 (unsigned long) section->sh_addralign);
5061 if (do_section_details)
5062 printf (" %s\n", get_elf_section_flags (section->sh_flags));
5065 if (!do_section_details)
5067 if (elf_header.e_machine == EM_X86_64
5068 || elf_header.e_machine == EM_L1OM
5069 || elf_header.e_machine == EM_K1OM)
5070 printf (_("Key to Flags:\n\
5071 W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
5072 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5073 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5075 printf (_("Key to Flags:\n\
5076 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
5077 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
5078 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
5085 get_group_flags (unsigned int flags)
5087 static char buff[32];
5097 snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x] "), flags);
5104 process_section_groups (FILE * file)
5106 Elf_Internal_Shdr * section;
5108 struct group * group;
5109 Elf_Internal_Shdr * symtab_sec;
5110 Elf_Internal_Shdr * strtab_sec;
5111 Elf_Internal_Sym * symtab;
5112 unsigned long num_syms;
5116 /* Don't process section groups unless needed. */
5117 if (!do_unwind && !do_section_groups)
5120 if (elf_header.e_shnum == 0)
5122 if (do_section_groups)
5123 printf (_("\nThere are no sections to group in this file.\n"));
5128 if (section_headers == NULL)
5130 error (_("Section headers are not available!\n"));
5131 /* PR 13622: This can happen with a corrupt ELF header. */
5135 section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
5136 sizeof (struct group *));
5138 if (section_headers_groups == NULL)
5140 error (_("Out of memory\n"));
5144 /* Scan the sections for the group section. */
5146 for (i = 0, section = section_headers;
5147 i < elf_header.e_shnum;
5149 if (section->sh_type == SHT_GROUP)
5152 if (group_count == 0)
5154 if (do_section_groups)
5155 printf (_("\nThere are no section groups in this file.\n"));
5160 section_groups = (struct group *) calloc (group_count, sizeof (struct group));
5162 if (section_groups == NULL)
5164 error (_("Out of memory\n"));
5174 for (i = 0, section = section_headers, group = section_groups;
5175 i < elf_header.e_shnum;
5178 if (section->sh_type == SHT_GROUP)
5180 char * name = SECTION_NAME (section);
5182 unsigned char * start;
5183 unsigned char * indices;
5184 unsigned int entry, j, size;
5185 Elf_Internal_Shdr * sec;
5186 Elf_Internal_Sym * sym;
5188 /* Get the symbol table. */
5189 if (section->sh_link >= elf_header.e_shnum
5190 || ((sec = section_headers + section->sh_link)->sh_type
5193 error (_("Bad sh_link in group section `%s'\n"), name);
5197 if (symtab_sec != sec)
5202 symtab = GET_ELF_SYMBOLS (file, symtab_sec, & num_syms);
5207 error (_("Corrupt header in group section `%s'\n"), name);
5211 if (section->sh_info >= num_syms)
5213 error (_("Bad sh_info in group section `%s'\n"), name);
5217 sym = symtab + section->sh_info;
5219 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
5221 if (sym->st_shndx == 0
5222 || sym->st_shndx >= elf_header.e_shnum)
5224 error (_("Bad sh_info in group section `%s'\n"), name);
5228 group_name = SECTION_NAME (section_headers + sym->st_shndx);
5237 /* Get the string table. */
5238 if (symtab_sec->sh_link >= elf_header.e_shnum)
5247 != (sec = section_headers + symtab_sec->sh_link))
5252 strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
5253 1, strtab_sec->sh_size,
5255 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
5257 group_name = sym->st_name < strtab_size
5258 ? strtab + sym->st_name : _("<corrupt>");
5261 start = (unsigned char *) get_data (NULL, file, section->sh_offset,
5262 1, section->sh_size,
5268 size = (section->sh_size / section->sh_entsize) - 1;
5269 entry = byte_get (indices, 4);
5272 if (do_section_groups)
5274 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
5275 get_group_flags (entry), i, name, group_name, size);
5277 printf (_(" [Index] Name\n"));
5280 group->group_index = i;
5282 for (j = 0; j < size; j++)
5284 struct group_list * g;
5286 entry = byte_get (indices, 4);
5289 if (entry >= elf_header.e_shnum)
5291 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
5292 entry, i, elf_header.e_shnum - 1);
5296 if (section_headers_groups [entry] != NULL)
5300 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
5302 section_headers_groups [entry]->group_index);
5307 /* Intel C/C++ compiler may put section 0 in a
5308 section group. We just warn it the first time
5309 and ignore it afterwards. */
5310 static int warned = 0;
5313 error (_("section 0 in group section [%5u]\n"),
5314 section_headers_groups [entry]->group_index);
5320 section_headers_groups [entry] = group;
5322 if (do_section_groups)
5324 sec = section_headers + entry;
5325 printf (" [%5u] %s\n", entry, SECTION_NAME (sec));
5328 g = (struct group_list *) xmalloc (sizeof (struct group_list));
5329 g->section_index = entry;
5330 g->next = group->root;
5348 /* Data used to display dynamic fixups. */
5350 struct ia64_vms_dynfixup
5352 bfd_vma needed_ident; /* Library ident number. */
5353 bfd_vma needed; /* Index in the dstrtab of the library name. */
5354 bfd_vma fixup_needed; /* Index of the library. */
5355 bfd_vma fixup_rela_cnt; /* Number of fixups. */
5356 bfd_vma fixup_rela_off; /* Fixups offset in the dynamic segment. */
5359 /* Data used to display dynamic relocations. */
5361 struct ia64_vms_dynimgrela
5363 bfd_vma img_rela_cnt; /* Number of relocations. */
5364 bfd_vma img_rela_off; /* Reloc offset in the dynamic segment. */
5367 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
5371 dump_ia64_vms_dynamic_fixups (FILE *file, struct ia64_vms_dynfixup *fixup,
5372 const char *strtab, unsigned int strtab_sz)
5374 Elf64_External_VMS_IMAGE_FIXUP *imfs;
5376 const char *lib_name;
5378 imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
5379 1, fixup->fixup_rela_cnt * sizeof (*imfs),
5380 _("dynamic section image fixups"));
5384 if (fixup->needed < strtab_sz)
5385 lib_name = strtab + fixup->needed;
5388 warn ("corrupt library name index of 0x%lx found in dynamic entry",
5389 (unsigned long) fixup->needed);
5392 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
5393 (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
5395 (_("Seg Offset Type SymVec DataType\n"));
5397 for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
5402 printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
5403 printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
5404 type = BYTE_GET (imfs [i].type);
5405 rtype = elf_ia64_reloc_type (type);
5407 printf (" 0x%08x ", type);
5409 printf (" %-32s ", rtype);
5410 printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
5411 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
5417 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
5420 dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
5422 Elf64_External_VMS_IMAGE_RELA *imrs;
5425 imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
5426 1, imgrela->img_rela_cnt * sizeof (*imrs),
5427 _("dynamic section image relocations"));
5431 printf (_("\nImage relocs\n"));
5433 (_("Seg Offset Type Addend Seg Sym Off\n"));
5435 for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
5440 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
5441 printf ("%08" BFD_VMA_FMT "x ",
5442 (bfd_vma) BYTE_GET (imrs [i].rela_offset));
5443 type = BYTE_GET (imrs [i].type);
5444 rtype = elf_ia64_reloc_type (type);
5446 printf ("0x%08x ", type);
5448 printf ("%-31s ", rtype);
5449 print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
5450 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
5451 printf ("%08" BFD_VMA_FMT "x\n",
5452 (bfd_vma) BYTE_GET (imrs [i].sym_offset));
5458 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
5461 process_ia64_vms_dynamic_relocs (FILE *file)
5463 struct ia64_vms_dynfixup fixup;
5464 struct ia64_vms_dynimgrela imgrela;
5465 Elf_Internal_Dyn *entry;
5467 bfd_vma strtab_off = 0;
5468 bfd_vma strtab_sz = 0;
5469 char *strtab = NULL;
5471 memset (&fixup, 0, sizeof (fixup));
5472 memset (&imgrela, 0, sizeof (imgrela));
5474 /* Note: the order of the entries is specified by the OpenVMS specs. */
5475 for (entry = dynamic_section;
5476 entry < dynamic_section + dynamic_nent;
5479 switch (entry->d_tag)
5481 case DT_IA_64_VMS_STRTAB_OFFSET:
5482 strtab_off = entry->d_un.d_val;
5485 strtab_sz = entry->d_un.d_val;
5487 strtab = get_data (NULL, file, dynamic_addr + strtab_off,
5488 1, strtab_sz, _("dynamic string section"));
5491 case DT_IA_64_VMS_NEEDED_IDENT:
5492 fixup.needed_ident = entry->d_un.d_val;
5495 fixup.needed = entry->d_un.d_val;
5497 case DT_IA_64_VMS_FIXUP_NEEDED:
5498 fixup.fixup_needed = entry->d_un.d_val;
5500 case DT_IA_64_VMS_FIXUP_RELA_CNT:
5501 fixup.fixup_rela_cnt = entry->d_un.d_val;
5503 case DT_IA_64_VMS_FIXUP_RELA_OFF:
5504 fixup.fixup_rela_off = entry->d_un.d_val;
5506 dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz);
5509 case DT_IA_64_VMS_IMG_RELA_CNT:
5510 imgrela.img_rela_cnt = entry->d_un.d_val;
5512 case DT_IA_64_VMS_IMG_RELA_OFF:
5513 imgrela.img_rela_off = entry->d_un.d_val;
5515 dump_ia64_vms_dynamic_relocs (file, &imgrela);
5535 } dynamic_relocations [] =
5537 { "REL", DT_REL, DT_RELSZ, FALSE },
5538 { "RELA", DT_RELA, DT_RELASZ, TRUE },
5539 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
5542 /* Process the reloc section. */
5545 process_relocs (FILE * file)
5547 unsigned long rel_size;
5548 unsigned long rel_offset;
5554 if (do_using_dynamic)
5558 int has_dynamic_reloc;
5561 has_dynamic_reloc = 0;
5563 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
5565 is_rela = dynamic_relocations [i].rela;
5566 name = dynamic_relocations [i].name;
5567 rel_size = dynamic_info [dynamic_relocations [i].size];
5568 rel_offset = dynamic_info [dynamic_relocations [i].reloc];
5570 has_dynamic_reloc |= rel_size;
5572 if (is_rela == UNKNOWN)
5574 if (dynamic_relocations [i].reloc == DT_JMPREL)
5575 switch (dynamic_info[DT_PLTREL])
5589 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
5590 name, rel_offset, rel_size);
5592 dump_relocations (file,
5593 offset_from_vma (file, rel_offset, rel_size),
5595 dynamic_symbols, num_dynamic_syms,
5596 dynamic_strings, dynamic_strings_length, is_rela);
5601 has_dynamic_reloc |= process_ia64_vms_dynamic_relocs (file);
5603 if (! has_dynamic_reloc)
5604 printf (_("\nThere are no dynamic relocations in this file.\n"));
5608 Elf_Internal_Shdr * section;
5612 for (i = 0, section = section_headers;
5613 i < elf_header.e_shnum;
5616 if ( section->sh_type != SHT_RELA
5617 && section->sh_type != SHT_REL)
5620 rel_offset = section->sh_offset;
5621 rel_size = section->sh_size;
5625 Elf_Internal_Shdr * strsec;
5628 printf (_("\nRelocation section "));
5630 if (string_table == NULL)
5631 printf ("%d", section->sh_name);
5633 printf ("'%s'", SECTION_NAME (section));
5635 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5636 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
5638 is_rela = section->sh_type == SHT_RELA;
5640 if (section->sh_link != 0
5641 && section->sh_link < elf_header.e_shnum)
5643 Elf_Internal_Shdr * symsec;
5644 Elf_Internal_Sym * symtab;
5645 unsigned long nsyms;
5646 unsigned long strtablen = 0;
5647 char * strtab = NULL;
5649 symsec = section_headers + section->sh_link;
5650 if (symsec->sh_type != SHT_SYMTAB
5651 && symsec->sh_type != SHT_DYNSYM)
5654 symtab = GET_ELF_SYMBOLS (file, symsec, & nsyms);
5659 if (symsec->sh_link != 0
5660 && symsec->sh_link < elf_header.e_shnum)
5662 strsec = section_headers + symsec->sh_link;
5664 strtab = (char *) get_data (NULL, file, strsec->sh_offset,
5667 strtablen = strtab == NULL ? 0 : strsec->sh_size;
5670 dump_relocations (file, rel_offset, rel_size,
5671 symtab, nsyms, strtab, strtablen, is_rela);
5677 dump_relocations (file, rel_offset, rel_size,
5678 NULL, 0, NULL, 0, is_rela);
5685 printf (_("\nThere are no relocations in this file.\n"));
5691 /* Process the unwind section. */
5693 #include "unwind-ia64.h"
5695 /* An absolute address consists of a section and an offset. If the
5696 section is NULL, the offset itself is the address, otherwise, the
5697 address equals to LOAD_ADDRESS(section) + offset. */
5701 unsigned short section;
5705 #define ABSADDR(a) \
5707 ? section_headers [(a).section].sh_addr + (a).offset \
5710 struct ia64_unw_table_entry
5712 struct absaddr start;
5714 struct absaddr info;
5717 struct ia64_unw_aux_info
5720 struct ia64_unw_table_entry *table; /* Unwind table. */
5721 unsigned long table_len; /* Length of unwind table. */
5722 unsigned char * info; /* Unwind info. */
5723 unsigned long info_size; /* Size of unwind info. */
5724 bfd_vma info_addr; /* starting address of unwind info. */
5725 bfd_vma seg_base; /* Starting address of segment. */
5726 Elf_Internal_Sym * symtab; /* The symbol table. */
5727 unsigned long nsyms; /* Number of symbols. */
5728 char * strtab; /* The string table. */
5729 unsigned long strtab_size; /* Size of string table. */
5733 find_symbol_for_address (Elf_Internal_Sym * symtab,
5734 unsigned long nsyms,
5735 const char * strtab,
5736 unsigned long strtab_size,
5737 struct absaddr addr,
5738 const char ** symname,
5741 bfd_vma dist = 0x100000;
5742 Elf_Internal_Sym * sym;
5743 Elf_Internal_Sym * best = NULL;
5746 REMOVE_ARCH_BITS (addr.offset);
5748 for (i = 0, sym = symtab; i < nsyms; ++i, ++sym)
5750 bfd_vma value = sym->st_value;
5752 REMOVE_ARCH_BITS (value);
5754 if (ELF_ST_TYPE (sym->st_info) == STT_FUNC
5755 && sym->st_name != 0
5756 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
5757 && addr.offset >= value
5758 && addr.offset - value < dist)
5761 dist = addr.offset - value;
5769 *symname = (best->st_name >= strtab_size
5770 ? _("<corrupt>") : strtab + best->st_name);
5776 *offset = addr.offset;
5780 dump_ia64_unwind (struct ia64_unw_aux_info * aux)
5782 struct ia64_unw_table_entry * tp;
5785 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
5789 const unsigned char * dp;
5790 const unsigned char * head;
5791 const char * procname;
5793 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
5794 aux->strtab_size, tp->start, &procname, &offset);
5796 fputs ("\n<", stdout);
5800 fputs (procname, stdout);
5803 printf ("+%lx", (unsigned long) offset);
5806 fputs (">: [", stdout);
5807 print_vma (tp->start.offset, PREFIX_HEX);
5808 fputc ('-', stdout);
5809 print_vma (tp->end.offset, PREFIX_HEX);
5810 printf ("], info at +0x%lx\n",
5811 (unsigned long) (tp->info.offset - aux->seg_base));
5813 head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
5814 stamp = byte_get ((unsigned char *) head, sizeof (stamp));
5816 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
5817 (unsigned) UNW_VER (stamp),
5818 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
5819 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
5820 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
5821 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
5823 if (UNW_VER (stamp) != 1)
5825 printf (_("\tUnknown version.\n"));
5830 for (dp = head + 8; dp < head + 8 + eh_addr_size * UNW_LENGTH (stamp);)
5831 dp = unw_decode (dp, in_body, & in_body);
5836 slurp_ia64_unwind_table (FILE * file,
5837 struct ia64_unw_aux_info * aux,
5838 Elf_Internal_Shdr * sec)
5840 unsigned long size, nrelas, i;
5841 Elf_Internal_Phdr * seg;
5842 struct ia64_unw_table_entry * tep;
5843 Elf_Internal_Shdr * relsec;
5844 Elf_Internal_Rela * rela;
5845 Elf_Internal_Rela * rp;
5846 unsigned char * table;
5848 Elf_Internal_Sym * sym;
5849 const char * relname;
5851 /* First, find the starting address of the segment that includes
5854 if (elf_header.e_phnum)
5856 if (! get_program_headers (file))
5859 for (seg = program_headers;
5860 seg < program_headers + elf_header.e_phnum;
5863 if (seg->p_type != PT_LOAD)
5866 if (sec->sh_addr >= seg->p_vaddr
5867 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
5869 aux->seg_base = seg->p_vaddr;
5875 /* Second, build the unwind table from the contents of the unwind section: */
5876 size = sec->sh_size;
5877 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
5882 aux->table = (struct ia64_unw_table_entry *)
5883 xcmalloc (size / (3 * eh_addr_size), sizeof (aux->table[0]));
5885 for (tp = table; tp < table + size; ++tep)
5887 tep->start.section = SHN_UNDEF;
5888 tep->end.section = SHN_UNDEF;
5889 tep->info.section = SHN_UNDEF;
5890 tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
5891 tep->end.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
5892 tep->info.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
5893 tep->start.offset += aux->seg_base;
5894 tep->end.offset += aux->seg_base;
5895 tep->info.offset += aux->seg_base;
5899 /* Third, apply any relocations to the unwind table: */
5900 for (relsec = section_headers;
5901 relsec < section_headers + elf_header.e_shnum;
5904 if (relsec->sh_type != SHT_RELA
5905 || relsec->sh_info >= elf_header.e_shnum
5906 || section_headers + relsec->sh_info != sec)
5909 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
5913 for (rp = rela; rp < rela + nrelas; ++rp)
5915 relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
5916 sym = aux->symtab + get_reloc_symindex (rp->r_info);
5918 if (! const_strneq (relname, "R_IA64_SEGREL"))
5920 warn (_("Skipping unexpected relocation type %s\n"), relname);
5924 i = rp->r_offset / (3 * eh_addr_size);
5926 switch (rp->r_offset/eh_addr_size % 3)
5929 aux->table[i].start.section = sym->st_shndx;
5930 aux->table[i].start.offset = rp->r_addend + sym->st_value;
5933 aux->table[i].end.section = sym->st_shndx;
5934 aux->table[i].end.offset = rp->r_addend + sym->st_value;
5937 aux->table[i].info.section = sym->st_shndx;
5938 aux->table[i].info.offset = rp->r_addend + sym->st_value;
5948 aux->table_len = size / (3 * eh_addr_size);
5953 ia64_process_unwind (FILE * file)
5955 Elf_Internal_Shdr * sec;
5956 Elf_Internal_Shdr * unwsec = NULL;
5957 Elf_Internal_Shdr * strsec;
5958 unsigned long i, unwcount = 0, unwstart = 0;
5959 struct ia64_unw_aux_info aux;
5961 memset (& aux, 0, sizeof (aux));
5963 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
5965 if (sec->sh_type == SHT_SYMTAB
5966 && sec->sh_link < elf_header.e_shnum)
5968 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
5970 strsec = section_headers + sec->sh_link;
5971 assert (aux.strtab == NULL);
5972 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
5975 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
5977 else if (sec->sh_type == SHT_IA_64_UNWIND)
5982 printf (_("\nThere are no unwind sections in this file.\n"));
5984 while (unwcount-- > 0)
5989 for (i = unwstart, sec = section_headers + unwstart;
5990 i < elf_header.e_shnum; ++i, ++sec)
5991 if (sec->sh_type == SHT_IA_64_UNWIND)
5998 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
6000 if ((unwsec->sh_flags & SHF_GROUP) != 0)
6002 /* We need to find which section group it is in. */
6003 struct group_list * g = section_headers_groups [i]->root;
6005 for (; g != NULL; g = g->next)
6007 sec = section_headers + g->section_index;
6009 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
6014 i = elf_header.e_shnum;
6016 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
6018 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
6019 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
6020 suffix = SECTION_NAME (unwsec) + len;
6021 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6023 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
6024 && streq (SECTION_NAME (sec) + len2, suffix))
6029 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
6030 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
6031 len = sizeof (ELF_STRING_ia64_unwind) - 1;
6032 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
6034 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
6035 suffix = SECTION_NAME (unwsec) + len;
6036 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
6038 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
6039 && streq (SECTION_NAME (sec) + len2, suffix))
6043 if (i == elf_header.e_shnum)
6045 printf (_("\nCould not find unwind info section for "));
6047 if (string_table == NULL)
6048 printf ("%d", unwsec->sh_name);
6050 printf (_("'%s'"), SECTION_NAME (unwsec));
6054 aux.info_addr = sec->sh_addr;
6055 aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
6058 aux.info_size = aux.info == NULL ? 0 : sec->sh_size;
6060 printf (_("\nUnwind section "));
6062 if (string_table == NULL)
6063 printf ("%d", unwsec->sh_name);
6065 printf (_("'%s'"), SECTION_NAME (unwsec));
6067 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6068 (unsigned long) unwsec->sh_offset,
6069 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
6071 (void) slurp_ia64_unwind_table (file, & aux, unwsec);
6073 if (aux.table_len > 0)
6074 dump_ia64_unwind (& aux);
6077 free ((char *) aux.table);
6079 free ((char *) aux.info);
6088 free ((char *) aux.strtab);
6091 struct hppa_unw_table_entry
6093 struct absaddr start;
6095 unsigned int Cannot_unwind:1; /* 0 */
6096 unsigned int Millicode:1; /* 1 */
6097 unsigned int Millicode_save_sr0:1; /* 2 */
6098 unsigned int Region_description:2; /* 3..4 */
6099 unsigned int reserved1:1; /* 5 */
6100 unsigned int Entry_SR:1; /* 6 */
6101 unsigned int Entry_FR:4; /* number saved */ /* 7..10 */
6102 unsigned int Entry_GR:5; /* number saved */ /* 11..15 */
6103 unsigned int Args_stored:1; /* 16 */
6104 unsigned int Variable_Frame:1; /* 17 */
6105 unsigned int Separate_Package_Body:1; /* 18 */
6106 unsigned int Frame_Extension_Millicode:1; /* 19 */
6107 unsigned int Stack_Overflow_Check:1; /* 20 */
6108 unsigned int Two_Instruction_SP_Increment:1; /* 21 */
6109 unsigned int Ada_Region:1; /* 22 */
6110 unsigned int cxx_info:1; /* 23 */
6111 unsigned int cxx_try_catch:1; /* 24 */
6112 unsigned int sched_entry_seq:1; /* 25 */
6113 unsigned int reserved2:1; /* 26 */
6114 unsigned int Save_SP:1; /* 27 */
6115 unsigned int Save_RP:1; /* 28 */
6116 unsigned int Save_MRP_in_frame:1; /* 29 */
6117 unsigned int extn_ptr_defined:1; /* 30 */
6118 unsigned int Cleanup_defined:1; /* 31 */
6120 unsigned int MPE_XL_interrupt_marker:1; /* 0 */
6121 unsigned int HP_UX_interrupt_marker:1; /* 1 */
6122 unsigned int Large_frame:1; /* 2 */
6123 unsigned int Pseudo_SP_Set:1; /* 3 */
6124 unsigned int reserved4:1; /* 4 */
6125 unsigned int Total_frame_size:27; /* 5..31 */
6128 struct hppa_unw_aux_info
6130 struct hppa_unw_table_entry *table; /* Unwind table. */
6131 unsigned long table_len; /* Length of unwind table. */
6132 bfd_vma seg_base; /* Starting address of segment. */
6133 Elf_Internal_Sym * symtab; /* The symbol table. */
6134 unsigned long nsyms; /* Number of symbols. */
6135 char * strtab; /* The string table. */
6136 unsigned long strtab_size; /* Size of string table. */
6140 dump_hppa_unwind (struct hppa_unw_aux_info * aux)
6142 struct hppa_unw_table_entry * tp;
6144 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
6147 const char * procname;
6149 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6150 aux->strtab_size, tp->start, &procname,
6153 fputs ("\n<", stdout);
6157 fputs (procname, stdout);
6160 printf ("+%lx", (unsigned long) offset);
6163 fputs (">: [", stdout);
6164 print_vma (tp->start.offset, PREFIX_HEX);
6165 fputc ('-', stdout);
6166 print_vma (tp->end.offset, PREFIX_HEX);
6169 #define PF(_m) if (tp->_m) printf (#_m " ");
6170 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
6173 PF(Millicode_save_sr0);
6174 /* PV(Region_description); */
6180 PF(Separate_Package_Body);
6181 PF(Frame_Extension_Millicode);
6182 PF(Stack_Overflow_Check);
6183 PF(Two_Instruction_SP_Increment);
6187 PF(sched_entry_seq);
6190 PF(Save_MRP_in_frame);
6191 PF(extn_ptr_defined);
6192 PF(Cleanup_defined);
6193 PF(MPE_XL_interrupt_marker);
6194 PF(HP_UX_interrupt_marker);
6197 PV(Total_frame_size);
6206 slurp_hppa_unwind_table (FILE * file,
6207 struct hppa_unw_aux_info * aux,
6208 Elf_Internal_Shdr * sec)
6210 unsigned long size, unw_ent_size, nentries, nrelas, i;
6211 Elf_Internal_Phdr * seg;
6212 struct hppa_unw_table_entry * tep;
6213 Elf_Internal_Shdr * relsec;
6214 Elf_Internal_Rela * rela;
6215 Elf_Internal_Rela * rp;
6216 unsigned char * table;
6218 Elf_Internal_Sym * sym;
6219 const char * relname;
6221 /* First, find the starting address of the segment that includes
6224 if (elf_header.e_phnum)
6226 if (! get_program_headers (file))
6229 for (seg = program_headers;
6230 seg < program_headers + elf_header.e_phnum;
6233 if (seg->p_type != PT_LOAD)
6236 if (sec->sh_addr >= seg->p_vaddr
6237 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
6239 aux->seg_base = seg->p_vaddr;
6245 /* Second, build the unwind table from the contents of the unwind
6247 size = sec->sh_size;
6248 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
6254 nentries = size / unw_ent_size;
6255 size = unw_ent_size * nentries;
6257 tep = aux->table = (struct hppa_unw_table_entry *)
6258 xcmalloc (nentries, sizeof (aux->table[0]));
6260 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
6262 unsigned int tmp1, tmp2;
6264 tep->start.section = SHN_UNDEF;
6265 tep->end.section = SHN_UNDEF;
6267 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
6268 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
6269 tmp1 = byte_get ((unsigned char *) tp + 8, 4);
6270 tmp2 = byte_get ((unsigned char *) tp + 12, 4);
6272 tep->start.offset += aux->seg_base;
6273 tep->end.offset += aux->seg_base;
6275 tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
6276 tep->Millicode = (tmp1 >> 30) & 0x1;
6277 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
6278 tep->Region_description = (tmp1 >> 27) & 0x3;
6279 tep->reserved1 = (tmp1 >> 26) & 0x1;
6280 tep->Entry_SR = (tmp1 >> 25) & 0x1;
6281 tep->Entry_FR = (tmp1 >> 21) & 0xf;
6282 tep->Entry_GR = (tmp1 >> 16) & 0x1f;
6283 tep->Args_stored = (tmp1 >> 15) & 0x1;
6284 tep->Variable_Frame = (tmp1 >> 14) & 0x1;
6285 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
6286 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
6287 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
6288 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
6289 tep->Ada_Region = (tmp1 >> 9) & 0x1;
6290 tep->cxx_info = (tmp1 >> 8) & 0x1;
6291 tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
6292 tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
6293 tep->reserved2 = (tmp1 >> 5) & 0x1;
6294 tep->Save_SP = (tmp1 >> 4) & 0x1;
6295 tep->Save_RP = (tmp1 >> 3) & 0x1;
6296 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
6297 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
6298 tep->Cleanup_defined = tmp1 & 0x1;
6300 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
6301 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
6302 tep->Large_frame = (tmp2 >> 29) & 0x1;
6303 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
6304 tep->reserved4 = (tmp2 >> 27) & 0x1;
6305 tep->Total_frame_size = tmp2 & 0x7ffffff;
6309 /* Third, apply any relocations to the unwind table. */
6310 for (relsec = section_headers;
6311 relsec < section_headers + elf_header.e_shnum;
6314 if (relsec->sh_type != SHT_RELA
6315 || relsec->sh_info >= elf_header.e_shnum
6316 || section_headers + relsec->sh_info != sec)
6319 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6323 for (rp = rela; rp < rela + nrelas; ++rp)
6325 relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
6326 sym = aux->symtab + get_reloc_symindex (rp->r_info);
6328 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
6329 if (! const_strneq (relname, "R_PARISC_SEGREL"))
6331 warn (_("Skipping unexpected relocation type %s\n"), relname);
6335 i = rp->r_offset / unw_ent_size;
6337 switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
6340 aux->table[i].start.section = sym->st_shndx;
6341 aux->table[i].start.offset = sym->st_value + rp->r_addend;
6344 aux->table[i].end.section = sym->st_shndx;
6345 aux->table[i].end.offset = sym->st_value + rp->r_addend;
6355 aux->table_len = nentries;
6361 hppa_process_unwind (FILE * file)
6363 struct hppa_unw_aux_info aux;
6364 Elf_Internal_Shdr * unwsec = NULL;
6365 Elf_Internal_Shdr * strsec;
6366 Elf_Internal_Shdr * sec;
6369 if (string_table == NULL)
6372 memset (& aux, 0, sizeof (aux));
6374 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6376 if (sec->sh_type == SHT_SYMTAB
6377 && sec->sh_link < elf_header.e_shnum)
6379 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
6381 strsec = section_headers + sec->sh_link;
6382 assert (aux.strtab == NULL);
6383 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6386 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
6388 else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
6393 printf (_("\nThere are no unwind sections in this file.\n"));
6395 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6397 if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
6399 printf (_("\nUnwind section "));
6400 printf (_("'%s'"), SECTION_NAME (sec));
6402 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6403 (unsigned long) sec->sh_offset,
6404 (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
6406 slurp_hppa_unwind_table (file, &aux, sec);
6407 if (aux.table_len > 0)
6408 dump_hppa_unwind (&aux);
6411 free ((char *) aux.table);
6419 free ((char *) aux.strtab);
6424 unsigned char * data; /* The unwind data. */
6425 Elf_Internal_Shdr * sec; /* The cached unwind section header. */
6426 Elf_Internal_Rela * rela; /* The cached relocations for this section. */
6427 unsigned long nrelas; /* The number of relocations. */
6428 unsigned int rel_type; /* REL or RELA ? */
6429 Elf_Internal_Rela * next_rela; /* Cyclic pointer to the next reloc to process. */
6432 struct arm_unw_aux_info
6434 FILE * file; /* The file containing the unwind sections. */
6435 Elf_Internal_Sym * symtab; /* The file's symbol table. */
6436 unsigned long nsyms; /* Number of symbols. */
6437 char * strtab; /* The file's string table. */
6438 unsigned long strtab_size; /* Size of string table. */
6442 arm_print_vma_and_name (struct arm_unw_aux_info *aux,
6443 bfd_vma fn, struct absaddr addr)
6445 const char *procname;
6448 if (addr.section == SHN_UNDEF)
6451 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6452 aux->strtab_size, addr, &procname,
6455 print_vma (fn, PREFIX_HEX);
6459 fputs (" <", stdout);
6460 fputs (procname, stdout);
6463 printf ("+0x%lx", (unsigned long) sym_offset);
6464 fputc ('>', stdout);
6471 arm_free_section (struct arm_section *arm_sec)
6473 if (arm_sec->data != NULL)
6474 free (arm_sec->data);
6476 if (arm_sec->rela != NULL)
6477 free (arm_sec->rela);
6480 /* 1) If SEC does not match the one cached in ARM_SEC, then free the current
6481 cached section and install SEC instead.
6482 2) Locate the 32-bit word at WORD_OFFSET in unwind section SEC
6483 and return its valued in * WORDP, relocating if necessary.
6484 3) Update the NEXT_RELA field in ARM_SEC and store the section index and
6485 relocation's offset in ADDR.
6486 4) If SYM_NAME is non-NULL and a relocation was applied, record the offset
6487 into the string table of the symbol associated with the reloc. If no
6488 reloc was applied store -1 there.
6489 5) Return TRUE upon success, FALSE otherwise. */
6492 get_unwind_section_word (struct arm_unw_aux_info * aux,
6493 struct arm_section * arm_sec,
6494 Elf_Internal_Shdr * sec,
6495 bfd_vma word_offset,
6496 unsigned int * wordp,
6497 struct absaddr * addr,
6500 Elf_Internal_Rela *rp;
6501 Elf_Internal_Sym *sym;
6502 const char * relname;
6504 bfd_boolean wrapped;
6506 addr->section = SHN_UNDEF;
6509 if (sym_name != NULL)
6510 *sym_name = (bfd_vma) -1;
6512 /* If necessary, update the section cache. */
6513 if (sec != arm_sec->sec)
6515 Elf_Internal_Shdr *relsec;
6517 arm_free_section (arm_sec);
6520 arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
6521 sec->sh_size, _("unwind data"));
6522 arm_sec->rela = NULL;
6523 arm_sec->nrelas = 0;
6525 for (relsec = section_headers;
6526 relsec < section_headers + elf_header.e_shnum;
6529 if (relsec->sh_info >= elf_header.e_shnum
6530 || section_headers + relsec->sh_info != sec)
6533 arm_sec->rel_type = relsec->sh_type;
6534 if (relsec->sh_type == SHT_REL)
6536 if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
6538 & arm_sec->rela, & arm_sec->nrelas))
6542 else if (relsec->sh_type == SHT_RELA)
6544 if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
6546 & arm_sec->rela, & arm_sec->nrelas))
6551 warn (_("unexpected relocation type (%d) for section %d"),
6552 relsec->sh_type, relsec->sh_info);
6555 arm_sec->next_rela = arm_sec->rela;
6558 /* If there is no unwind data we can do nothing. */
6559 if (arm_sec->data == NULL)
6562 /* Get the word at the required offset. */
6563 word = byte_get (arm_sec->data + word_offset, 4);
6565 /* Look through the relocs to find the one that applies to the provided offset. */
6567 for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
6569 bfd_vma prelval, offset;
6571 if (rp->r_offset > word_offset && !wrapped)
6576 if (rp->r_offset > word_offset)
6579 if (rp->r_offset & 3)
6581 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
6582 (unsigned long) rp->r_offset);
6586 if (rp->r_offset < word_offset)
6589 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
6591 if (arm_sec->rel_type == SHT_REL)
6593 offset = word & 0x7fffffff;
6594 if (offset & 0x40000000)
6595 offset |= ~ (bfd_vma) 0x7fffffff;
6597 else if (arm_sec->rel_type == SHT_RELA)
6598 offset = rp->r_addend;
6602 offset += sym->st_value;
6603 prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
6605 /* Check that we are processing the expected reloc type. */
6606 if (elf_header.e_machine == EM_ARM)
6608 relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
6610 if (streq (relname, "R_ARM_NONE"))
6613 if (! streq (relname, "R_ARM_PREL31"))
6615 warn (_("Skipping unexpected relocation type %s\n"), relname);
6619 else if (elf_header.e_machine == EM_TI_C6000)
6621 relname = elf_tic6x_reloc_type (ELF32_R_TYPE (rp->r_info));
6623 if (streq (relname, "R_C6000_NONE"))
6626 if (! streq (relname, "R_C6000_PREL31"))
6628 warn (_("Skipping unexpected relocation type %s\n"), relname);
6635 /* This function currently only supports ARM and TI unwinders. */
6638 word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
6639 addr->section = sym->st_shndx;
6640 addr->offset = offset;
6642 * sym_name = sym->st_name;
6647 arm_sec->next_rela = rp;
6652 static const char *tic6x_unwind_regnames[16] =
6654 "A15", "B15", "B14", "B13", "B12", "B11", "B10", "B3",
6655 "A14", "A13", "A12", "A11", "A10",
6656 "[invalid reg 13]", "[invalid reg 14]", "[invalid reg 15]"
6660 decode_tic6x_unwind_regmask (unsigned int mask)
6664 for (i = 12; mask; mask >>= 1, i--)
6668 fputs (tic6x_unwind_regnames[i], stdout);
6670 fputs (", ", stdout);
6676 if (remaining == 0 && more_words) \
6679 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, \
6680 data_offset, & word, & addr, NULL)) \
6686 #define GET_OP(OP) \
6691 (OP) = word >> 24; \
6696 printf (_("[Truncated opcode]\n")); \
6699 printf ("0x%02x ", OP)
6702 decode_arm_unwind_bytecode (struct arm_unw_aux_info *aux,
6703 unsigned int word, unsigned int remaining,
6704 unsigned int more_words,
6705 bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
6706 struct arm_section *data_arm_sec)
6708 struct absaddr addr;
6710 /* Decode the unwinding instructions. */
6713 unsigned int op, op2;
6722 printf (" 0x%02x ", op);
6724 if ((op & 0xc0) == 0x00)
6726 int offset = ((op & 0x3f) << 2) + 4;
6728 printf (" vsp = vsp + %d", offset);
6730 else if ((op & 0xc0) == 0x40)
6732 int offset = ((op & 0x3f) << 2) + 4;
6734 printf (" vsp = vsp - %d", offset);
6736 else if ((op & 0xf0) == 0x80)
6739 if (op == 0x80 && op2 == 0)
6740 printf (_("Refuse to unwind"));
6743 unsigned int mask = ((op & 0x0f) << 8) | op2;
6748 for (i = 0; i < 12; i++)
6749 if (mask & (1 << i))
6755 printf ("r%d", 4 + i);
6760 else if ((op & 0xf0) == 0x90)
6762 if (op == 0x9d || op == 0x9f)
6763 printf (_(" [Reserved]"));
6765 printf (" vsp = r%d", op & 0x0f);
6767 else if ((op & 0xf0) == 0xa0)
6769 int end = 4 + (op & 0x07);
6774 for (i = 4; i <= end; i++)
6790 else if (op == 0xb0)
6791 printf (_(" finish"));
6792 else if (op == 0xb1)
6795 if (op2 == 0 || (op2 & 0xf0) != 0)
6796 printf (_("[Spare]"));
6799 unsigned int mask = op2 & 0x0f;
6804 for (i = 0; i < 12; i++)
6805 if (mask & (1 << i))
6816 else if (op == 0xb2)
6818 unsigned char buf[9];
6819 unsigned int i, len;
6820 unsigned long offset;
6822 for (i = 0; i < sizeof (buf); i++)
6825 if ((buf[i] & 0x80) == 0)
6828 assert (i < sizeof (buf));
6829 offset = read_uleb128 (buf, &len);
6830 assert (len == i + 1);
6831 offset = offset * 4 + 0x204;
6832 printf ("vsp = vsp + %ld", offset);
6834 else if (op == 0xb3 || op == 0xc8 || op == 0xc9)
6836 unsigned int first, last;
6843 printf ("pop {D%d", first);
6845 printf ("-D%d", first + last);
6848 else if ((op & 0xf8) == 0xb8 || (op & 0xf8) == 0xd0)
6850 unsigned int count = op & 0x07;
6854 printf ("-D%d", 8 + count);
6857 else if (op >= 0xc0 && op <= 0xc5)
6859 unsigned int count = op & 0x07;
6861 printf (" pop {wR10");
6863 printf ("-wR%d", 10 + count);
6866 else if (op == 0xc6)
6868 unsigned int first, last;
6873 printf ("pop {wR%d", first);
6875 printf ("-wR%d", first + last);
6878 else if (op == 0xc7)
6881 if (op2 == 0 || (op2 & 0xf0) != 0)
6882 printf (_("[Spare]"));
6885 unsigned int mask = op2 & 0x0f;
6890 for (i = 0; i < 4; i++)
6891 if (mask & (1 << i))
6897 printf ("wCGR%d", i);
6903 printf (_(" [unsupported opcode]"));
6909 decode_tic6x_unwind_bytecode (struct arm_unw_aux_info *aux,
6910 unsigned int word, unsigned int remaining,
6911 unsigned int more_words,
6912 bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
6913 struct arm_section *data_arm_sec)
6915 struct absaddr addr;
6917 /* Decode the unwinding instructions. */
6920 unsigned int op, op2;
6929 printf (" 0x%02x ", op);
6931 if ((op & 0xc0) == 0x00)
6933 int offset = ((op & 0x3f) << 3) + 8;
6934 printf (" sp = sp + %d", offset);
6936 else if ((op & 0xc0) == 0x80)
6939 if (op == 0x80 && op2 == 0)
6940 printf (_("Refuse to unwind"));
6943 unsigned int mask = ((op & 0x1f) << 8) | op2;
6945 printf ("pop compact {");
6949 decode_tic6x_unwind_regmask (mask);
6953 else if ((op & 0xf0) == 0xc0)
6961 unsigned int offset;
6965 /* Scan entire instruction first so that GET_OP output is not
6966 interleaved with disassembly. */
6968 for (i = 0; nregs < (op & 0xf); i++)
6974 regpos[nregs].offset = i * 2;
6975 regpos[nregs].reg = reg;
6982 regpos[nregs].offset = i * 2 + 1;
6983 regpos[nregs].reg = reg;
6988 printf (_("pop frame {"));
6990 for (i = i * 2; i > 0; i--)
6992 if (regpos[reg].offset == i - 1)
6994 name = tic6x_unwind_regnames[regpos[reg].reg];
7001 fputs (name, stdout);
7008 else if (op == 0xd0)
7009 printf (" MOV FP, SP");
7010 else if (op == 0xd1)
7011 printf (" __c6xabi_pop_rts");
7012 else if (op == 0xd2)
7014 unsigned char buf[9];
7015 unsigned int i, len;
7016 unsigned long offset;
7018 for (i = 0; i < sizeof (buf); i++)
7021 if ((buf[i] & 0x80) == 0)
7024 assert (i < sizeof (buf));
7025 offset = read_uleb128 (buf, &len);
7026 assert (len == i + 1);
7027 offset = offset * 8 + 0x408;
7028 printf (_("sp = sp + %ld"), offset);
7030 else if ((op & 0xf0) == 0xe0)
7032 if ((op & 0x0f) == 7)
7035 printf (" MV %s, B3", tic6x_unwind_regnames[op & 0x0f]);
7039 printf (_(" [unsupported opcode]"));
7046 arm_expand_prel31 (bfd_vma word, bfd_vma where)
7050 offset = word & 0x7fffffff;
7051 if (offset & 0x40000000)
7052 offset |= ~ (bfd_vma) 0x7fffffff;
7054 if (elf_header.e_machine == EM_TI_C6000)
7057 return offset + where;
7061 decode_arm_unwind (struct arm_unw_aux_info * aux,
7063 unsigned int remaining,
7064 bfd_vma data_offset,
7065 Elf_Internal_Shdr * data_sec,
7066 struct arm_section * data_arm_sec)
7069 unsigned int more_words = 0;
7070 struct absaddr addr;
7071 bfd_vma sym_name = (bfd_vma) -1;
7075 /* Fetch the first word.
7076 Note - when decoding an object file the address extracted
7077 here will always be 0. So we also pass in the sym_name
7078 parameter so that we can find the symbol associated with
7079 the personality routine. */
7080 if (! get_unwind_section_word (aux, data_arm_sec, data_sec, data_offset,
7081 & word, & addr, & sym_name))
7087 if ((word & 0x80000000) == 0)
7089 /* Expand prel31 for personality routine. */
7091 const char *procname;
7093 fn = arm_expand_prel31 (word, data_sec->sh_addr + data_offset);
7094 printf (_(" Personality routine: "));
7096 && addr.section == SHN_UNDEF && addr.offset == 0
7097 && sym_name != (bfd_vma) -1 && sym_name < aux->strtab_size)
7099 procname = aux->strtab + sym_name;
7100 print_vma (fn, PREFIX_HEX);
7103 fputs (" <", stdout);
7104 fputs (procname, stdout);
7105 fputc ('>', stdout);
7109 procname = arm_print_vma_and_name (aux, fn, addr);
7110 fputc ('\n', stdout);
7112 /* The GCC personality routines use the standard compact
7113 encoding, starting with one byte giving the number of
7115 if (procname != NULL
7116 && (const_strneq (procname, "__gcc_personality_v0")
7117 || const_strneq (procname, "__gxx_personality_v0")
7118 || const_strneq (procname, "__gcj_personality_v0")
7119 || const_strneq (procname, "__gnu_objc_personality_v0")))
7126 printf (_(" [Truncated data]\n"));
7129 more_words = word >> 24;
7139 /* ARM EHABI Section 6.3:
7141 An exception-handling table entry for the compact model looks like:
7145 1 0 index Data for personalityRoutine[index] */
7147 if (elf_header.e_machine == EM_ARM
7148 && (word & 0x70000000))
7149 warn (_("Corrupt ARM compact model table entry: %x \n"), word);
7151 per_index = (word >> 24) & 0x7f;
7152 printf (_(" Compact model index: %d\n"), per_index);
7159 else if (per_index < 3)
7161 more_words = (word >> 16) & 0xff;
7167 switch (elf_header.e_machine)
7172 decode_arm_unwind_bytecode (aux, word, remaining, more_words,
7173 data_offset, data_sec, data_arm_sec);
7177 warn (_("Unknown ARM compact model index encountered\n"));
7178 printf (_(" [reserved]\n"));
7185 decode_tic6x_unwind_bytecode (aux, word, remaining, more_words,
7186 data_offset, data_sec, data_arm_sec);
7188 else if (per_index < 5)
7190 if (((word >> 17) & 0x7f) == 0x7f)
7191 printf (_(" Restore stack from frame pointer\n"));
7193 printf (_(" Stack increment %d\n"), (word >> 14) & 0x1fc);
7194 printf (_(" Registers restored: "));
7196 printf (" (compact) ");
7197 decode_tic6x_unwind_regmask ((word >> 4) & 0x1fff);
7199 printf (_(" Return register: %s\n"),
7200 tic6x_unwind_regnames[word & 0xf]);
7203 printf (_(" [reserved (%d)]\n"), per_index);
7207 error (_("Unsupported architecture type %d encountered when decoding unwind table"),
7208 elf_header.e_machine);
7211 /* Decode the descriptors. Not implemented. */
7215 dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
7217 struct arm_section exidx_arm_sec, extab_arm_sec;
7218 unsigned int i, exidx_len;
7220 memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
7221 memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
7222 exidx_len = exidx_sec->sh_size / 8;
7224 for (i = 0; i < exidx_len; i++)
7226 unsigned int exidx_fn, exidx_entry;
7227 struct absaddr fn_addr, entry_addr;
7230 fputc ('\n', stdout);
7232 if (! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
7233 8 * i, & exidx_fn, & fn_addr, NULL)
7234 || ! get_unwind_section_word (aux, & exidx_arm_sec, exidx_sec,
7235 8 * i + 4, & exidx_entry, & entry_addr, NULL))
7237 arm_free_section (& exidx_arm_sec);
7238 arm_free_section (& extab_arm_sec);
7242 /* ARM EHABI, Section 5:
7243 An index table entry consists of 2 words.
7244 The first word contains a prel31 offset to the start of a function, with bit 31 clear. */
7245 if (exidx_fn & 0x80000000)
7246 warn (_("corrupt index table entry: %x\n"), exidx_fn);
7248 fn = arm_expand_prel31 (exidx_fn, exidx_sec->sh_addr + 8 * i);
7250 arm_print_vma_and_name (aux, fn, fn_addr);
7251 fputs (": ", stdout);
7253 if (exidx_entry == 1)
7255 print_vma (exidx_entry, PREFIX_HEX);
7256 fputs (" [cantunwind]\n", stdout);
7258 else if (exidx_entry & 0x80000000)
7260 print_vma (exidx_entry, PREFIX_HEX);
7261 fputc ('\n', stdout);
7262 decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
7266 bfd_vma table, table_offset = 0;
7267 Elf_Internal_Shdr *table_sec;
7269 fputs ("@", stdout);
7270 table = arm_expand_prel31 (exidx_entry, exidx_sec->sh_addr + 8 * i + 4);
7271 print_vma (table, PREFIX_HEX);
7274 /* Locate the matching .ARM.extab. */
7275 if (entry_addr.section != SHN_UNDEF
7276 && entry_addr.section < elf_header.e_shnum)
7278 table_sec = section_headers + entry_addr.section;
7279 table_offset = entry_addr.offset;
7283 table_sec = find_section_by_address (table);
7284 if (table_sec != NULL)
7285 table_offset = table - table_sec->sh_addr;
7287 if (table_sec == NULL)
7289 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
7290 (unsigned long) table);
7293 decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
7300 arm_free_section (&exidx_arm_sec);
7301 arm_free_section (&extab_arm_sec);
7304 /* Used for both ARM and C6X unwinding tables. */
7307 arm_process_unwind (FILE *file)
7309 struct arm_unw_aux_info aux;
7310 Elf_Internal_Shdr *unwsec = NULL;
7311 Elf_Internal_Shdr *strsec;
7312 Elf_Internal_Shdr *sec;
7314 unsigned int sec_type;
7316 switch (elf_header.e_machine)
7319 sec_type = SHT_ARM_EXIDX;
7323 sec_type = SHT_C6000_UNWIND;
7327 error (_("Unsupported architecture type %d encountered when processing unwind table"),
7328 elf_header.e_machine);
7332 if (string_table == NULL)
7335 memset (& aux, 0, sizeof (aux));
7338 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7340 if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
7342 aux.symtab = GET_ELF_SYMBOLS (file, sec, & aux.nsyms);
7344 strsec = section_headers + sec->sh_link;
7345 assert (aux.strtab == NULL);
7346 aux.strtab = get_data (NULL, file, strsec->sh_offset,
7347 1, strsec->sh_size, _("string table"));
7348 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
7350 else if (sec->sh_type == sec_type)
7355 printf (_("\nThere are no unwind sections in this file.\n"));
7357 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
7359 if (sec->sh_type == sec_type)
7361 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
7363 (unsigned long) sec->sh_offset,
7364 (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
7366 dump_arm_unwind (&aux, sec);
7373 free ((char *) aux.strtab);
7377 process_unwind (FILE * file)
7379 struct unwind_handler
7382 void (* handler)(FILE *);
7385 { EM_ARM, arm_process_unwind },
7386 { EM_IA_64, ia64_process_unwind },
7387 { EM_PARISC, hppa_process_unwind },
7388 { EM_TI_C6000, arm_process_unwind },
7396 for (i = 0; handlers[i].handler != NULL; i++)
7397 if (elf_header.e_machine == handlers[i].machtype)
7398 return handlers[i].handler (file);
7400 printf (_("\nThe decoding of unwind sections for machine type %s is not currently supported.\n"),
7401 get_machine_name (elf_header.e_machine));
7405 dynamic_section_mips_val (Elf_Internal_Dyn * entry)
7407 switch (entry->d_tag)
7410 if (entry->d_un.d_val == 0)
7414 static const char * opts[] =
7416 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
7417 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
7418 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
7419 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
7425 for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
7426 if (entry->d_un.d_val & (1 << cnt))
7428 printf ("%s%s", first ? "" : " ", opts[cnt]);
7434 case DT_MIPS_IVERSION:
7435 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
7436 printf (_("Interface Version: %s"), GET_DYNAMIC_NAME (entry->d_un.d_val));
7438 printf (_("<corrupt: %" BFD_VMA_FMT "d>"), entry->d_un.d_ptr);
7441 case DT_MIPS_TIME_STAMP:
7446 time_t atime = entry->d_un.d_val;
7447 tmp = gmtime (&atime);
7448 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
7449 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
7450 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
7451 printf (_("Time Stamp: %s"), timebuf);
7455 case DT_MIPS_RLD_VERSION:
7456 case DT_MIPS_LOCAL_GOTNO:
7457 case DT_MIPS_CONFLICTNO:
7458 case DT_MIPS_LIBLISTNO:
7459 case DT_MIPS_SYMTABNO:
7460 case DT_MIPS_UNREFEXTNO:
7461 case DT_MIPS_HIPAGENO:
7462 case DT_MIPS_DELTA_CLASS_NO:
7463 case DT_MIPS_DELTA_INSTANCE_NO:
7464 case DT_MIPS_DELTA_RELOC_NO:
7465 case DT_MIPS_DELTA_SYM_NO:
7466 case DT_MIPS_DELTA_CLASSSYM_NO:
7467 case DT_MIPS_COMPACT_SIZE:
7468 print_vma (entry->d_un.d_ptr, DEC);
7472 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7478 dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
7480 switch (entry->d_tag)
7482 case DT_HP_DLD_FLAGS:
7491 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
7492 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
7493 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
7494 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
7495 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
7496 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
7497 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
7498 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
7499 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
7500 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
7501 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
7502 { DT_HP_GST, "HP_GST" },
7503 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
7504 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
7505 { DT_HP_NODELETE, "HP_NODELETE" },
7506 { DT_HP_GROUP, "HP_GROUP" },
7507 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
7511 bfd_vma val = entry->d_un.d_val;
7513 for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
7514 if (val & flags[cnt].bit)
7518 fputs (flags[cnt].str, stdout);
7520 val ^= flags[cnt].bit;
7523 if (val != 0 || first)
7527 print_vma (val, HEX);
7533 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7541 /* VMS vs Unix time offset and factor. */
7543 #define VMS_EPOCH_OFFSET 35067168000000000LL
7544 #define VMS_GRANULARITY_FACTOR 10000000
7546 /* Display a VMS time in a human readable format. */
7549 print_vms_time (bfd_int64_t vmstime)
7554 unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
7555 tm = gmtime (&unxtime);
7556 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
7557 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
7558 tm->tm_hour, tm->tm_min, tm->tm_sec);
7563 dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
7565 switch (entry->d_tag)
7567 case DT_IA_64_PLT_RESERVE:
7568 /* First 3 slots reserved. */
7569 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7571 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
7574 case DT_IA_64_VMS_LINKTIME:
7576 print_vms_time (entry->d_un.d_val);
7580 case DT_IA_64_VMS_LNKFLAGS:
7581 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7582 if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
7583 printf (" CALL_DEBUG");
7584 if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
7585 printf (" NOP0BUFS");
7586 if (entry->d_un.d_val & VMS_LF_P0IMAGE)
7587 printf (" P0IMAGE");
7588 if (entry->d_un.d_val & VMS_LF_MKTHREADS)
7589 printf (" MKTHREADS");
7590 if (entry->d_un.d_val & VMS_LF_UPCALLS)
7591 printf (" UPCALLS");
7592 if (entry->d_un.d_val & VMS_LF_IMGSTA)
7594 if (entry->d_un.d_val & VMS_LF_INITIALIZE)
7595 printf (" INITIALIZE");
7596 if (entry->d_un.d_val & VMS_LF_MAIN)
7598 if (entry->d_un.d_val & VMS_LF_EXE_INIT)
7599 printf (" EXE_INIT");
7600 if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
7601 printf (" TBK_IN_IMG");
7602 if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
7603 printf (" DBG_IN_IMG");
7604 if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
7605 printf (" TBK_IN_DSF");
7606 if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
7607 printf (" DBG_IN_DSF");
7608 if (entry->d_un.d_val & VMS_LF_SIGNATURES)
7609 printf (" SIGNATURES");
7610 if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
7611 printf (" REL_SEG_OFF");
7615 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
7622 get_32bit_dynamic_section (FILE * file)
7624 Elf32_External_Dyn * edyn;
7625 Elf32_External_Dyn * ext;
7626 Elf_Internal_Dyn * entry;
7628 edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
7629 dynamic_size, _("dynamic section"));
7633 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
7634 might not have the luxury of section headers. Look for the DT_NULL
7635 terminator to determine the number of entries. */
7636 for (ext = edyn, dynamic_nent = 0;
7637 (char *) ext < (char *) edyn + dynamic_size;
7641 if (BYTE_GET (ext->d_tag) == DT_NULL)
7645 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
7647 if (dynamic_section == NULL)
7649 error (_("Out of memory\n"));
7654 for (ext = edyn, entry = dynamic_section;
7655 entry < dynamic_section + dynamic_nent;
7658 entry->d_tag = BYTE_GET (ext->d_tag);
7659 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
7668 get_64bit_dynamic_section (FILE * file)
7670 Elf64_External_Dyn * edyn;
7671 Elf64_External_Dyn * ext;
7672 Elf_Internal_Dyn * entry;
7674 edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
7675 dynamic_size, _("dynamic section"));
7679 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
7680 might not have the luxury of section headers. Look for the DT_NULL
7681 terminator to determine the number of entries. */
7682 for (ext = edyn, dynamic_nent = 0;
7683 (char *) ext < (char *) edyn + dynamic_size;
7687 if (BYTE_GET (ext->d_tag) == DT_NULL)
7691 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
7693 if (dynamic_section == NULL)
7695 error (_("Out of memory\n"));
7700 for (ext = edyn, entry = dynamic_section;
7701 entry < dynamic_section + dynamic_nent;
7704 entry->d_tag = BYTE_GET (ext->d_tag);
7705 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
7714 print_dynamic_flags (bfd_vma flags)
7722 flag = flags & - flags;
7732 case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
7733 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
7734 case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
7735 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
7736 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
7737 default: fputs (_("unknown"), stdout); break;
7743 /* Parse and display the contents of the dynamic section. */
7746 process_dynamic_section (FILE * file)
7748 Elf_Internal_Dyn * entry;
7750 if (dynamic_size == 0)
7753 printf (_("\nThere is no dynamic section in this file.\n"));
7760 if (! get_32bit_dynamic_section (file))
7763 else if (! get_64bit_dynamic_section (file))
7766 /* Find the appropriate symbol table. */
7767 if (dynamic_symbols == NULL)
7769 for (entry = dynamic_section;
7770 entry < dynamic_section + dynamic_nent;
7773 Elf_Internal_Shdr section;
7775 if (entry->d_tag != DT_SYMTAB)
7778 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
7780 /* Since we do not know how big the symbol table is,
7781 we default to reading in the entire file (!) and
7782 processing that. This is overkill, I know, but it
7784 section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
7786 if (archive_file_offset != 0)
7787 section.sh_size = archive_file_size - section.sh_offset;
7790 if (fseek (file, 0, SEEK_END))
7791 error (_("Unable to seek to end of file!\n"));
7793 section.sh_size = ftell (file) - section.sh_offset;
7797 section.sh_entsize = sizeof (Elf32_External_Sym);
7799 section.sh_entsize = sizeof (Elf64_External_Sym);
7801 dynamic_symbols = GET_ELF_SYMBOLS (file, §ion, & num_dynamic_syms);
7802 if (num_dynamic_syms < 1)
7804 error (_("Unable to determine the number of symbols to load\n"));
7810 /* Similarly find a string table. */
7811 if (dynamic_strings == NULL)
7813 for (entry = dynamic_section;
7814 entry < dynamic_section + dynamic_nent;
7817 unsigned long offset;
7820 if (entry->d_tag != DT_STRTAB)
7823 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
7825 /* Since we do not know how big the string table is,
7826 we default to reading in the entire file (!) and
7827 processing that. This is overkill, I know, but it
7830 offset = offset_from_vma (file, entry->d_un.d_val, 0);
7832 if (archive_file_offset != 0)
7833 str_tab_len = archive_file_size - offset;
7836 if (fseek (file, 0, SEEK_END))
7837 error (_("Unable to seek to end of file\n"));
7838 str_tab_len = ftell (file) - offset;
7841 if (str_tab_len < 1)
7844 (_("Unable to determine the length of the dynamic string table\n"));
7848 dynamic_strings = (char *) get_data (NULL, file, offset, 1,
7850 _("dynamic string table"));
7851 dynamic_strings_length = dynamic_strings == NULL ? 0 : str_tab_len;
7856 /* And find the syminfo section if available. */
7857 if (dynamic_syminfo == NULL)
7859 unsigned long syminsz = 0;
7861 for (entry = dynamic_section;
7862 entry < dynamic_section + dynamic_nent;
7865 if (entry->d_tag == DT_SYMINENT)
7867 /* Note: these braces are necessary to avoid a syntax
7868 error from the SunOS4 C compiler. */
7869 assert (sizeof (Elf_External_Syminfo) == entry->d_un.d_val);
7871 else if (entry->d_tag == DT_SYMINSZ)
7872 syminsz = entry->d_un.d_val;
7873 else if (entry->d_tag == DT_SYMINFO)
7874 dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
7878 if (dynamic_syminfo_offset != 0 && syminsz != 0)
7880 Elf_External_Syminfo * extsyminfo;
7881 Elf_External_Syminfo * extsym;
7882 Elf_Internal_Syminfo * syminfo;
7884 /* There is a syminfo section. Read the data. */
7885 extsyminfo = (Elf_External_Syminfo *)
7886 get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
7887 _("symbol information"));
7891 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
7892 if (dynamic_syminfo == NULL)
7894 error (_("Out of memory\n"));
7898 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
7899 for (syminfo = dynamic_syminfo, extsym = extsyminfo;
7900 syminfo < dynamic_syminfo + dynamic_syminfo_nent;
7901 ++syminfo, ++extsym)
7903 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
7904 syminfo->si_flags = BYTE_GET (extsym->si_flags);
7911 if (do_dynamic && dynamic_addr)
7912 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
7913 dynamic_addr, dynamic_nent);
7915 printf (_(" Tag Type Name/Value\n"));
7917 for (entry = dynamic_section;
7918 entry < dynamic_section + dynamic_nent;
7926 print_vma (entry->d_tag, FULL_HEX);
7927 dtype = get_dynamic_type (entry->d_tag);
7928 printf (" (%s)%*s", dtype,
7929 ((is_32bit_elf ? 27 : 19)
7930 - (int) strlen (dtype)),
7934 switch (entry->d_tag)
7938 print_dynamic_flags (entry->d_un.d_val);
7948 switch (entry->d_tag)
7951 printf (_("Auxiliary library"));
7955 printf (_("Filter library"));
7959 printf (_("Configuration file"));
7963 printf (_("Dependency audit library"));
7967 printf (_("Audit library"));
7971 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
7972 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
7976 print_vma (entry->d_un.d_val, PREFIX_HEX);
7985 printf (_("Flags:"));
7987 if (entry->d_un.d_val == 0)
7988 printf (_(" None\n"));
7991 unsigned long int val = entry->d_un.d_val;
7993 if (val & DTF_1_PARINIT)
7995 printf (" PARINIT");
7996 val ^= DTF_1_PARINIT;
7998 if (val & DTF_1_CONFEXP)
8000 printf (" CONFEXP");
8001 val ^= DTF_1_CONFEXP;
8004 printf (" %lx", val);
8013 printf (_("Flags:"));
8015 if (entry->d_un.d_val == 0)
8016 printf (_(" None\n"));
8019 unsigned long int val = entry->d_un.d_val;
8021 if (val & DF_P1_LAZYLOAD)
8023 printf (" LAZYLOAD");
8024 val ^= DF_P1_LAZYLOAD;
8026 if (val & DF_P1_GROUPPERM)
8028 printf (" GROUPPERM");
8029 val ^= DF_P1_GROUPPERM;
8032 printf (" %lx", val);
8041 printf (_("Flags:"));
8042 if (entry->d_un.d_val == 0)
8043 printf (_(" None\n"));
8046 unsigned long int val = entry->d_un.d_val;
8053 if (val & DF_1_GLOBAL)
8058 if (val & DF_1_GROUP)
8063 if (val & DF_1_NODELETE)
8065 printf (" NODELETE");
8066 val ^= DF_1_NODELETE;
8068 if (val & DF_1_LOADFLTR)
8070 printf (" LOADFLTR");
8071 val ^= DF_1_LOADFLTR;
8073 if (val & DF_1_INITFIRST)
8075 printf (" INITFIRST");
8076 val ^= DF_1_INITFIRST;
8078 if (val & DF_1_NOOPEN)
8083 if (val & DF_1_ORIGIN)
8088 if (val & DF_1_DIRECT)
8093 if (val & DF_1_TRANS)
8098 if (val & DF_1_INTERPOSE)
8100 printf (" INTERPOSE");
8101 val ^= DF_1_INTERPOSE;
8103 if (val & DF_1_NODEFLIB)
8105 printf (" NODEFLIB");
8106 val ^= DF_1_NODEFLIB;
8108 if (val & DF_1_NODUMP)
8113 if (val & DF_1_CONFALT)
8115 printf (" CONFALT");
8116 val ^= DF_1_CONFALT;
8118 if (val & DF_1_ENDFILTEE)
8120 printf (" ENDFILTEE");
8121 val ^= DF_1_ENDFILTEE;
8123 if (val & DF_1_DISPRELDNE)
8125 printf (" DISPRELDNE");
8126 val ^= DF_1_DISPRELDNE;
8128 if (val & DF_1_DISPRELPND)
8130 printf (" DISPRELPND");
8131 val ^= DF_1_DISPRELPND;
8133 if (val & DF_1_NODIRECT)
8135 printf (" NODIRECT");
8136 val ^= DF_1_NODIRECT;
8138 if (val & DF_1_IGNMULDEF)
8140 printf (" IGNMULDEF");
8141 val ^= DF_1_IGNMULDEF;
8143 if (val & DF_1_NOKSYMS)
8145 printf (" NOKSYMS");
8146 val ^= DF_1_NOKSYMS;
8148 if (val & DF_1_NOHDR)
8153 if (val & DF_1_EDITED)
8158 if (val & DF_1_NORELOC)
8160 printf (" NORELOC");
8161 val ^= DF_1_NORELOC;
8163 if (val & DF_1_SYMINTPOSE)
8165 printf (" SYMINTPOSE");
8166 val ^= DF_1_SYMINTPOSE;
8168 if (val & DF_1_GLOBAUDIT)
8170 printf (" GLOBAUDIT");
8171 val ^= DF_1_GLOBAUDIT;
8173 if (val & DF_1_SINGLETON)
8175 printf (" SINGLETON");
8176 val ^= DF_1_SINGLETON;
8179 printf (" %lx", val);
8186 dynamic_info[entry->d_tag] = entry->d_un.d_val;
8188 puts (get_dynamic_type (entry->d_un.d_val));
8208 dynamic_info[entry->d_tag] = entry->d_un.d_val;
8214 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
8215 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
8221 switch (entry->d_tag)
8224 printf (_("Shared library: [%s]"), name);
8226 if (streq (name, program_interpreter))
8227 printf (_(" program interpreter"));
8231 printf (_("Library soname: [%s]"), name);
8235 printf (_("Library rpath: [%s]"), name);
8239 printf (_("Library runpath: [%s]"), name);
8243 print_vma (entry->d_un.d_val, PREFIX_HEX);
8248 print_vma (entry->d_un.d_val, PREFIX_HEX);
8261 dynamic_info[entry->d_tag] = entry->d_un.d_val;
8265 case DT_INIT_ARRAYSZ:
8266 case DT_FINI_ARRAYSZ:
8267 case DT_GNU_CONFLICTSZ:
8268 case DT_GNU_LIBLISTSZ:
8271 print_vma (entry->d_un.d_val, UNSIGNED);
8272 printf (_(" (bytes)\n"));
8282 print_vma (entry->d_un.d_val, UNSIGNED);
8295 if (entry->d_tag == DT_USED
8296 && VALID_DYNAMIC_NAME (entry->d_un.d_val))
8298 char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
8302 printf (_("Not needed object: [%s]\n"), name);
8307 print_vma (entry->d_un.d_val, PREFIX_HEX);
8313 /* The value of this entry is ignored. */
8318 case DT_GNU_PRELINKED:
8322 time_t atime = entry->d_un.d_val;
8324 tmp = gmtime (&atime);
8325 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
8326 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
8327 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
8333 dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
8336 print_vma (entry->d_un.d_val, PREFIX_HEX);
8342 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
8343 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
8348 switch (elf_header.e_machine)
8351 case EM_MIPS_RS3_LE:
8352 dynamic_section_mips_val (entry);
8355 dynamic_section_parisc_val (entry);
8358 dynamic_section_ia64_val (entry);
8361 print_vma (entry->d_un.d_val, PREFIX_HEX);
8373 get_ver_flags (unsigned int flags)
8375 static char buff[32];
8382 if (flags & VER_FLG_BASE)
8383 strcat (buff, "BASE ");
8385 if (flags & VER_FLG_WEAK)
8387 if (flags & VER_FLG_BASE)
8388 strcat (buff, "| ");
8390 strcat (buff, "WEAK ");
8393 if (flags & VER_FLG_INFO)
8395 if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
8396 strcat (buff, "| ");
8398 strcat (buff, "INFO ");
8401 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
8402 strcat (buff, _("| <unknown>"));
8407 /* Display the contents of the version sections. */
8410 process_version_sections (FILE * file)
8412 Elf_Internal_Shdr * section;
8419 for (i = 0, section = section_headers;
8420 i < elf_header.e_shnum;
8423 switch (section->sh_type)
8425 case SHT_GNU_verdef:
8427 Elf_External_Verdef * edefs;
8435 (_("\nVersion definition section '%s' contains %u entries:\n"),
8436 SECTION_NAME (section), section->sh_info);
8438 printf (_(" Addr: 0x"));
8439 printf_vma (section->sh_addr);
8440 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
8441 (unsigned long) section->sh_offset, section->sh_link,
8442 section->sh_link < elf_header.e_shnum
8443 ? SECTION_NAME (section_headers + section->sh_link)
8446 edefs = (Elf_External_Verdef *)
8447 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
8448 _("version definition section"));
8451 endbuf = (char *) edefs + section->sh_size;
8453 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
8456 Elf_External_Verdef * edef;
8457 Elf_Internal_Verdef ent;
8458 Elf_External_Verdaux * eaux;
8459 Elf_Internal_Verdaux aux;
8463 /* Check for negative or very large indicies. */
8464 if ((unsigned char *) edefs + idx < (unsigned char *) edefs)
8467 vstart = ((char *) edefs) + idx;
8468 if (vstart + sizeof (*edef) > endbuf)
8471 edef = (Elf_External_Verdef *) vstart;
8473 ent.vd_version = BYTE_GET (edef->vd_version);
8474 ent.vd_flags = BYTE_GET (edef->vd_flags);
8475 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
8476 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
8477 ent.vd_hash = BYTE_GET (edef->vd_hash);
8478 ent.vd_aux = BYTE_GET (edef->vd_aux);
8479 ent.vd_next = BYTE_GET (edef->vd_next);
8481 printf (_(" %#06x: Rev: %d Flags: %s"),
8482 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
8484 printf (_(" Index: %d Cnt: %d "),
8485 ent.vd_ndx, ent.vd_cnt);
8487 /* Check for overflow. */
8488 if ((unsigned char *)(vstart + ent.vd_aux) < (unsigned char *) vstart
8489 || (unsigned char *)(vstart + ent.vd_aux) > (unsigned char *) endbuf)
8492 vstart += ent.vd_aux;
8494 eaux = (Elf_External_Verdaux *) vstart;
8496 aux.vda_name = BYTE_GET (eaux->vda_name);
8497 aux.vda_next = BYTE_GET (eaux->vda_next);
8499 if (VALID_DYNAMIC_NAME (aux.vda_name))
8500 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
8502 printf (_("Name index: %ld\n"), aux.vda_name);
8504 isum = idx + ent.vd_aux;
8506 for (j = 1; j < ent.vd_cnt; j++)
8508 /* Check for overflow. */
8509 if ((unsigned char *)(vstart + aux.vda_next) < (unsigned char *) vstart
8510 || (unsigned char *)(vstart + aux.vda_next) > (unsigned char *) endbuf)
8513 isum += aux.vda_next;
8514 vstart += aux.vda_next;
8516 eaux = (Elf_External_Verdaux *) vstart;
8517 if (vstart + sizeof (*eaux) > endbuf)
8520 aux.vda_name = BYTE_GET (eaux->vda_name);
8521 aux.vda_next = BYTE_GET (eaux->vda_next);
8523 if (VALID_DYNAMIC_NAME (aux.vda_name))
8524 printf (_(" %#06x: Parent %d: %s\n"),
8525 isum, j, GET_DYNAMIC_NAME (aux.vda_name));
8527 printf (_(" %#06x: Parent %d, name index: %ld\n"),
8528 isum, j, aux.vda_name);
8532 printf (_(" Version def aux past end of section\n"));
8537 if (cnt < section->sh_info)
8538 printf (_(" Version definition past end of section\n"));
8544 case SHT_GNU_verneed:
8546 Elf_External_Verneed * eneed;
8553 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
8554 SECTION_NAME (section), section->sh_info);
8556 printf (_(" Addr: 0x"));
8557 printf_vma (section->sh_addr);
8558 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
8559 (unsigned long) section->sh_offset, section->sh_link,
8560 section->sh_link < elf_header.e_shnum
8561 ? SECTION_NAME (section_headers + section->sh_link)
8564 eneed = (Elf_External_Verneed *) get_data (NULL, file,
8565 section->sh_offset, 1,
8567 _("Version Needs section"));
8570 endbuf = (char *) eneed + section->sh_size;
8572 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
8574 Elf_External_Verneed * entry;
8575 Elf_Internal_Verneed ent;
8580 if ((unsigned char *) eneed + idx < (unsigned char *) eneed)
8583 vstart = ((char *) eneed) + idx;
8584 if (vstart + sizeof (*entry) > endbuf)
8587 entry = (Elf_External_Verneed *) vstart;
8589 ent.vn_version = BYTE_GET (entry->vn_version);
8590 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
8591 ent.vn_file = BYTE_GET (entry->vn_file);
8592 ent.vn_aux = BYTE_GET (entry->vn_aux);
8593 ent.vn_next = BYTE_GET (entry->vn_next);
8595 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
8597 if (VALID_DYNAMIC_NAME (ent.vn_file))
8598 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
8600 printf (_(" File: %lx"), ent.vn_file);
8602 printf (_(" Cnt: %d\n"), ent.vn_cnt);
8604 /* Check for overflow. */
8605 if ((unsigned char *)(vstart + ent.vn_aux) < (unsigned char *) vstart
8606 || (unsigned char *)(vstart + ent.vn_aux) > (unsigned char *) endbuf)
8609 vstart += ent.vn_aux;
8611 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
8613 Elf_External_Vernaux * eaux;
8614 Elf_Internal_Vernaux aux;
8616 if (vstart + sizeof (*eaux) > endbuf)
8618 eaux = (Elf_External_Vernaux *) vstart;
8620 aux.vna_hash = BYTE_GET (eaux->vna_hash);
8621 aux.vna_flags = BYTE_GET (eaux->vna_flags);
8622 aux.vna_other = BYTE_GET (eaux->vna_other);
8623 aux.vna_name = BYTE_GET (eaux->vna_name);
8624 aux.vna_next = BYTE_GET (eaux->vna_next);
8626 if (VALID_DYNAMIC_NAME (aux.vna_name))
8627 printf (_(" %#06x: Name: %s"),
8628 isum, GET_DYNAMIC_NAME (aux.vna_name));
8630 printf (_(" %#06x: Name index: %lx"),
8631 isum, aux.vna_name);
8633 printf (_(" Flags: %s Version: %d\n"),
8634 get_ver_flags (aux.vna_flags), aux.vna_other);
8636 /* Check for overflow. */
8637 if ((unsigned char *)(vstart + aux.vna_next) < (unsigned char *) vstart
8638 || (unsigned char *)(vstart + aux.vna_next) > (unsigned char *) endbuf)
8641 isum += aux.vna_next;
8642 vstart += aux.vna_next;
8646 warn (_("Missing Version Needs auxillary information\n"));
8651 if (cnt < section->sh_info)
8652 warn (_("Missing Version Needs information\n"));
8658 case SHT_GNU_versym:
8660 Elf_Internal_Shdr * link_section;
8663 unsigned char * edata;
8664 unsigned short * data;
8666 Elf_Internal_Sym * symbols;
8667 Elf_Internal_Shdr * string_sec;
8668 unsigned long num_syms;
8671 if (section->sh_link >= elf_header.e_shnum)
8674 link_section = section_headers + section->sh_link;
8675 total = section->sh_size / sizeof (Elf_External_Versym);
8677 if (link_section->sh_link >= elf_header.e_shnum)
8682 symbols = GET_ELF_SYMBOLS (file, link_section, & num_syms);
8683 if (symbols == NULL)
8686 string_sec = section_headers + link_section->sh_link;
8688 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
8689 string_sec->sh_size,
8690 _("version string table"));
8697 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
8698 SECTION_NAME (section), total);
8700 printf (_(" Addr: "));
8701 printf_vma (section->sh_addr);
8702 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
8703 (unsigned long) section->sh_offset, section->sh_link,
8704 SECTION_NAME (link_section));
8706 off = offset_from_vma (file,
8707 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
8708 total * sizeof (short));
8709 edata = (unsigned char *) get_data (NULL, file, off, total,
8711 _("version symbol data"));
8719 data = (short unsigned int *) cmalloc (total, sizeof (short));
8721 for (cnt = total; cnt --;)
8722 data[cnt] = byte_get (edata + cnt * sizeof (short),
8727 for (cnt = 0; cnt < total; cnt += 4)
8730 int check_def, check_need;
8733 printf (" %03x:", cnt);
8735 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
8736 switch (data[cnt + j])
8739 fputs (_(" 0 (*local*) "), stdout);
8743 fputs (_(" 1 (*global*) "), stdout);
8747 nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
8748 data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
8750 /* If this index value is greater than the size of the symbols
8751 array, break to avoid an out-of-bounds read. */
8752 if ((unsigned long)(cnt + j) >= num_syms)
8754 warn (_("invalid index into symbol array\n"));
8760 if (symbols[cnt + j].st_shndx >= elf_header.e_shnum
8761 || section_headers[symbols[cnt + j].st_shndx].sh_type
8764 if (symbols[cnt + j].st_shndx == SHN_UNDEF)
8771 && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
8773 Elf_Internal_Verneed ivn;
8774 unsigned long offset;
8776 offset = offset_from_vma
8777 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
8778 sizeof (Elf_External_Verneed));
8782 Elf_Internal_Vernaux ivna;
8783 Elf_External_Verneed evn;
8784 Elf_External_Vernaux evna;
8785 unsigned long a_off;
8787 if (get_data (&evn, file, offset, sizeof (evn), 1,
8788 _("version need")) == NULL)
8791 ivn.vn_aux = BYTE_GET (evn.vn_aux);
8792 ivn.vn_next = BYTE_GET (evn.vn_next);
8794 a_off = offset + ivn.vn_aux;
8798 if (get_data (&evna, file, a_off, sizeof (evna),
8799 1, _("version need aux (2)")) == NULL)
8806 ivna.vna_next = BYTE_GET (evna.vna_next);
8807 ivna.vna_other = BYTE_GET (evna.vna_other);
8810 a_off += ivna.vna_next;
8812 while (ivna.vna_other != data[cnt + j]
8813 && ivna.vna_next != 0);
8815 if (ivna.vna_other == data[cnt + j])
8817 ivna.vna_name = BYTE_GET (evna.vna_name);
8819 if (ivna.vna_name >= string_sec->sh_size)
8820 name = _("*invalid*");
8822 name = strtab + ivna.vna_name;
8823 nn += printf ("(%s%-*s",
8825 12 - (int) strlen (name),
8831 offset += ivn.vn_next;
8833 while (ivn.vn_next);
8836 if (check_def && data[cnt + j] != 0x8001
8837 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
8839 Elf_Internal_Verdef ivd;
8840 Elf_External_Verdef evd;
8841 unsigned long offset;
8843 offset = offset_from_vma
8844 (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
8849 if (get_data (&evd, file, offset, sizeof (evd), 1,
8850 _("version def")) == NULL)
8857 ivd.vd_next = BYTE_GET (evd.vd_next);
8858 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
8861 offset += ivd.vd_next;
8863 while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
8864 && ivd.vd_next != 0);
8866 if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
8868 Elf_External_Verdaux evda;
8869 Elf_Internal_Verdaux ivda;
8871 ivd.vd_aux = BYTE_GET (evd.vd_aux);
8873 if (get_data (&evda, file,
8874 offset - ivd.vd_next + ivd.vd_aux,
8876 _("version def aux")) == NULL)
8879 ivda.vda_name = BYTE_GET (evda.vda_name);
8881 if (ivda.vda_name >= string_sec->sh_size)
8882 name = _("*invalid*");
8884 name = strtab + ivda.vda_name;
8885 nn += printf ("(%s%-*s",
8887 12 - (int) strlen (name),
8893 printf ("%*c", 18 - nn, ' ');
8911 printf (_("\nNo version information found in this file.\n"));
8917 get_symbol_binding (unsigned int binding)
8919 static char buff[32];
8923 case STB_LOCAL: return "LOCAL";
8924 case STB_GLOBAL: return "GLOBAL";
8925 case STB_WEAK: return "WEAK";
8927 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
8928 snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
8930 else if (binding >= STB_LOOS && binding <= STB_HIOS)
8932 if (binding == STB_GNU_UNIQUE
8933 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
8934 /* GNU is still using the default value 0. */
8935 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
8937 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
8940 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
8946 get_symbol_type (unsigned int type)
8948 static char buff[32];
8952 case STT_NOTYPE: return "NOTYPE";
8953 case STT_OBJECT: return "OBJECT";
8954 case STT_FUNC: return "FUNC";
8955 case STT_SECTION: return "SECTION";
8956 case STT_FILE: return "FILE";
8957 case STT_COMMON: return "COMMON";
8958 case STT_TLS: return "TLS";
8959 case STT_RELC: return "RELC";
8960 case STT_SRELC: return "SRELC";
8962 if (type >= STT_LOPROC && type <= STT_HIPROC)
8964 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
8965 return "THUMB_FUNC";
8967 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
8970 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
8971 return "PARISC_MILLI";
8973 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
8975 else if (type >= STT_LOOS && type <= STT_HIOS)
8977 if (elf_header.e_machine == EM_PARISC)
8979 if (type == STT_HP_OPAQUE)
8981 if (type == STT_HP_STUB)
8985 if (type == STT_GNU_IFUNC
8986 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_GNU
8987 || elf_header.e_ident[EI_OSABI] == ELFOSABI_FREEBSD
8988 /* GNU is still using the default value 0. */
8989 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
8992 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
8995 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
9001 get_symbol_visibility (unsigned int visibility)
9005 case STV_DEFAULT: return "DEFAULT";
9006 case STV_INTERNAL: return "INTERNAL";
9007 case STV_HIDDEN: return "HIDDEN";
9008 case STV_PROTECTED: return "PROTECTED";
9014 get_mips_symbol_other (unsigned int other)
9026 case STO_MICROMIPS | STO_MIPS_PIC:
9027 return "MICROMIPS, MIPS PIC";
9036 get_ia64_symbol_other (unsigned int other)
9040 static char res[32];
9044 /* Function types is for images and .STB files only. */
9045 switch (elf_header.e_type)
9049 switch (VMS_ST_FUNC_TYPE (other))
9051 case VMS_SFT_CODE_ADDR:
9052 strcat (res, " CA");
9054 case VMS_SFT_SYMV_IDX:
9055 strcat (res, " VEC");
9058 strcat (res, " FD");
9060 case VMS_SFT_RESERVE:
9061 strcat (res, " RSV");
9070 switch (VMS_ST_LINKAGE (other))
9072 case VMS_STL_IGNORE:
9073 strcat (res, " IGN");
9075 case VMS_STL_RESERVE:
9076 strcat (res, " RSV");
9079 strcat (res, " STD");
9082 strcat (res, " LNK");
9097 get_symbol_other (unsigned int other)
9099 const char * result = NULL;
9100 static char buff [32];
9105 switch (elf_header.e_machine)
9108 result = get_mips_symbol_other (other);
9111 result = get_ia64_symbol_other (other);
9120 snprintf (buff, sizeof buff, _("<other>: %x"), other);
9125 get_symbol_index_type (unsigned int type)
9127 static char buff[32];
9131 case SHN_UNDEF: return "UND";
9132 case SHN_ABS: return "ABS";
9133 case SHN_COMMON: return "COM";
9135 if (type == SHN_IA_64_ANSI_COMMON
9136 && elf_header.e_machine == EM_IA_64
9137 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
9139 else if ((elf_header.e_machine == EM_X86_64
9140 || elf_header.e_machine == EM_L1OM
9141 || elf_header.e_machine == EM_K1OM)
9142 && type == SHN_X86_64_LCOMMON)
9144 else if ((type == SHN_MIPS_SCOMMON
9145 && elf_header.e_machine == EM_MIPS)
9146 || (type == SHN_TIC6X_SCOMMON
9147 && elf_header.e_machine == EM_TI_C6000))
9149 else if (type == SHN_MIPS_SUNDEFINED
9150 && elf_header.e_machine == EM_MIPS)
9152 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
9153 sprintf (buff, "PRC[0x%04x]", type & 0xffff);
9154 else if (type >= SHN_LOOS && type <= SHN_HIOS)
9155 sprintf (buff, "OS [0x%04x]", type & 0xffff);
9156 else if (type >= SHN_LORESERVE)
9157 sprintf (buff, "RSV[0x%04x]", type & 0xffff);
9158 else if (type >= elf_header.e_shnum)
9159 sprintf (buff, "bad section index[%3d]", type);
9161 sprintf (buff, "%3d", type);
9169 get_dynamic_data (FILE * file, unsigned int number, unsigned int ent_size)
9171 unsigned char * e_data;
9174 e_data = (unsigned char *) cmalloc (number, ent_size);
9178 error (_("Out of memory\n"));
9182 if (fread (e_data, ent_size, number, file) != number)
9184 error (_("Unable to read in dynamic data\n"));
9188 i_data = (bfd_vma *) cmalloc (number, sizeof (*i_data));
9192 error (_("Out of memory\n"));
9198 i_data[number] = byte_get (e_data + number * ent_size, ent_size);
9206 print_dynamic_symbol (bfd_vma si, unsigned long hn)
9208 Elf_Internal_Sym * psym;
9211 psym = dynamic_symbols + si;
9213 n = print_vma (si, DEC_5);
9215 fputs (" " + n, stdout);
9216 printf (" %3lu: ", hn);
9217 print_vma (psym->st_value, LONG_HEX);
9219 print_vma (psym->st_size, DEC_5);
9221 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
9222 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
9223 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
9224 /* Check to see if any other bits in the st_other field are set.
9225 Note - displaying this information disrupts the layout of the
9226 table being generated, but for the moment this case is very
9228 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
9229 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
9230 printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
9231 if (VALID_DYNAMIC_NAME (psym->st_name))
9232 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
9234 printf (_(" <corrupt: %14ld>"), psym->st_name);
9238 /* Dump the symbol table. */
9240 process_symbol_table (FILE * file)
9242 Elf_Internal_Shdr * section;
9243 bfd_vma nbuckets = 0;
9244 bfd_vma nchains = 0;
9245 bfd_vma * buckets = NULL;
9246 bfd_vma * chains = NULL;
9247 bfd_vma ngnubuckets = 0;
9248 bfd_vma * gnubuckets = NULL;
9249 bfd_vma * gnuchains = NULL;
9250 bfd_vma gnusymidx = 0;
9252 if (!do_syms && !do_dyn_syms && !do_histogram)
9255 if (dynamic_info[DT_HASH]
9257 || (do_using_dynamic
9259 && dynamic_strings != NULL)))
9261 unsigned char nb[8];
9262 unsigned char nc[8];
9263 int hash_ent_size = 4;
9265 if ((elf_header.e_machine == EM_ALPHA
9266 || elf_header.e_machine == EM_S390
9267 || elf_header.e_machine == EM_S390_OLD)
9268 && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
9272 (archive_file_offset
9273 + offset_from_vma (file, dynamic_info[DT_HASH],
9274 sizeof nb + sizeof nc)),
9277 error (_("Unable to seek to start of dynamic information\n"));
9281 if (fread (nb, hash_ent_size, 1, file) != 1)
9283 error (_("Failed to read in number of buckets\n"));
9287 if (fread (nc, hash_ent_size, 1, file) != 1)
9289 error (_("Failed to read in number of chains\n"));
9293 nbuckets = byte_get (nb, hash_ent_size);
9294 nchains = byte_get (nc, hash_ent_size);
9296 buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
9297 chains = get_dynamic_data (file, nchains, hash_ent_size);
9300 if (buckets == NULL || chains == NULL)
9302 if (do_using_dynamic)
9313 if (dynamic_info_DT_GNU_HASH
9315 || (do_using_dynamic
9317 && dynamic_strings != NULL)))
9319 unsigned char nb[16];
9320 bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
9321 bfd_vma buckets_vma;
9324 (archive_file_offset
9325 + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
9329 error (_("Unable to seek to start of dynamic information\n"));
9333 if (fread (nb, 16, 1, file) != 1)
9335 error (_("Failed to read in number of buckets\n"));
9339 ngnubuckets = byte_get (nb, 4);
9340 gnusymidx = byte_get (nb + 4, 4);
9341 bitmaskwords = byte_get (nb + 8, 4);
9342 buckets_vma = dynamic_info_DT_GNU_HASH + 16;
9344 buckets_vma += bitmaskwords * 4;
9346 buckets_vma += bitmaskwords * 8;
9349 (archive_file_offset
9350 + offset_from_vma (file, buckets_vma, 4)),
9353 error (_("Unable to seek to start of dynamic information\n"));
9357 gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
9359 if (gnubuckets == NULL)
9362 for (i = 0; i < ngnubuckets; i++)
9363 if (gnubuckets[i] != 0)
9365 if (gnubuckets[i] < gnusymidx)
9368 if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
9369 maxchain = gnubuckets[i];
9372 if (maxchain == 0xffffffff)
9375 maxchain -= gnusymidx;
9378 (archive_file_offset
9379 + offset_from_vma (file, buckets_vma
9380 + 4 * (ngnubuckets + maxchain), 4)),
9383 error (_("Unable to seek to start of dynamic information\n"));
9389 if (fread (nb, 4, 1, file) != 1)
9391 error (_("Failed to determine last chain length\n"));
9395 if (maxchain + 1 == 0)
9400 while ((byte_get (nb, 4) & 1) == 0);
9403 (archive_file_offset
9404 + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
9407 error (_("Unable to seek to start of dynamic information\n"));
9411 gnuchains = get_dynamic_data (file, maxchain, 4);
9414 if (gnuchains == NULL)
9419 if (do_using_dynamic)
9424 if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
9427 && dynamic_strings != NULL)
9431 if (dynamic_info[DT_HASH])
9435 printf (_("\nSymbol table for image:\n"));
9437 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9439 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9441 for (hn = 0; hn < nbuckets; hn++)
9446 for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
9447 print_dynamic_symbol (si, hn);
9451 if (dynamic_info_DT_GNU_HASH)
9453 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
9455 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9457 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
9459 for (hn = 0; hn < ngnubuckets; ++hn)
9460 if (gnubuckets[hn] != 0)
9462 bfd_vma si = gnubuckets[hn];
9463 bfd_vma off = si - gnusymidx;
9467 print_dynamic_symbol (si, hn);
9470 while ((gnuchains[off++] & 1) == 0);
9474 else if (do_dyn_syms || (do_syms && !do_using_dynamic))
9478 for (i = 0, section = section_headers;
9479 i < elf_header.e_shnum;
9483 char * strtab = NULL;
9484 unsigned long int strtab_size = 0;
9485 Elf_Internal_Sym * symtab;
9486 Elf_Internal_Sym * psym;
9487 unsigned long num_syms;
9489 if ((section->sh_type != SHT_SYMTAB
9490 && section->sh_type != SHT_DYNSYM)
9492 && section->sh_type == SHT_SYMTAB))
9495 if (section->sh_entsize == 0)
9497 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
9498 SECTION_NAME (section));
9502 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
9503 SECTION_NAME (section),
9504 (unsigned long) (section->sh_size / section->sh_entsize));
9507 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
9509 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
9511 symtab = GET_ELF_SYMBOLS (file, section, & num_syms);
9515 if (section->sh_link == elf_header.e_shstrndx)
9517 strtab = string_table;
9518 strtab_size = string_table_length;
9520 else if (section->sh_link < elf_header.e_shnum)
9522 Elf_Internal_Shdr * string_sec;
9524 string_sec = section_headers + section->sh_link;
9526 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
9527 1, string_sec->sh_size,
9529 strtab_size = strtab != NULL ? string_sec->sh_size : 0;
9532 for (si = 0, psym = symtab; si < num_syms; si++, psym++)
9534 printf ("%6d: ", si);
9535 print_vma (psym->st_value, LONG_HEX);
9537 print_vma (psym->st_size, DEC_5);
9538 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
9539 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
9540 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
9541 /* Check to see if any other bits in the st_other field are set.
9542 Note - displaying this information disrupts the layout of the
9543 table being generated, but for the moment this case is very rare. */
9544 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
9545 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
9546 printf (" %4s ", get_symbol_index_type (psym->st_shndx));
9547 print_symbol (25, psym->st_name < strtab_size
9548 ? strtab + psym->st_name : _("<corrupt>"));
9550 if (section->sh_type == SHT_DYNSYM
9551 && version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
9553 unsigned char data[2];
9554 unsigned short vers_data;
9555 unsigned long offset;
9559 offset = offset_from_vma
9560 (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
9561 sizeof data + si * sizeof (vers_data));
9563 if (get_data (&data, file, offset + si * sizeof (vers_data),
9564 sizeof (data), 1, _("version data")) == NULL)
9567 vers_data = byte_get (data, 2);
9569 is_nobits = (psym->st_shndx < elf_header.e_shnum
9570 && section_headers[psym->st_shndx].sh_type
9573 check_def = (psym->st_shndx != SHN_UNDEF);
9575 if ((vers_data & VERSYM_HIDDEN) || vers_data > 1)
9577 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
9578 && (is_nobits || ! check_def))
9580 Elf_External_Verneed evn;
9581 Elf_Internal_Verneed ivn;
9582 Elf_Internal_Vernaux ivna;
9584 /* We must test both. */
9585 offset = offset_from_vma
9586 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
9591 unsigned long vna_off;
9593 if (get_data (&evn, file, offset, sizeof (evn), 1,
9594 _("version need")) == NULL)
9602 ivn.vn_aux = BYTE_GET (evn.vn_aux);
9603 ivn.vn_next = BYTE_GET (evn.vn_next);
9605 vna_off = offset + ivn.vn_aux;
9609 Elf_External_Vernaux evna;
9611 if (get_data (&evna, file, vna_off,
9613 _("version need aux (3)")) == NULL)
9621 ivna.vna_other = BYTE_GET (evna.vna_other);
9622 ivna.vna_next = BYTE_GET (evna.vna_next);
9623 ivna.vna_name = BYTE_GET (evna.vna_name);
9626 vna_off += ivna.vna_next;
9628 while (ivna.vna_other != vers_data
9629 && ivna.vna_next != 0);
9631 if (ivna.vna_other == vers_data)
9634 offset += ivn.vn_next;
9636 while (ivn.vn_next != 0);
9638 if (ivna.vna_other == vers_data)
9641 ivna.vna_name < strtab_size
9642 ? strtab + ivna.vna_name : _("<corrupt>"),
9646 else if (! is_nobits)
9647 error (_("bad dynamic symbol\n"));
9654 if (vers_data != 0x8001
9655 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
9657 Elf_Internal_Verdef ivd;
9658 Elf_Internal_Verdaux ivda;
9659 Elf_External_Verdaux evda;
9662 off = offset_from_vma
9664 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
9665 sizeof (Elf_External_Verdef));
9669 Elf_External_Verdef evd;
9671 if (get_data (&evd, file, off, sizeof (evd),
9672 1, _("version def")) == NULL)
9680 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
9681 ivd.vd_aux = BYTE_GET (evd.vd_aux);
9682 ivd.vd_next = BYTE_GET (evd.vd_next);
9687 while (ivd.vd_ndx != (vers_data & VERSYM_VERSION)
9688 && ivd.vd_next != 0);
9693 if (get_data (&evda, file, off, sizeof (evda),
9694 1, _("version def aux")) == NULL)
9697 ivda.vda_name = BYTE_GET (evda.vda_name);
9699 if (psym->st_name != ivda.vda_name)
9700 printf ((vers_data & VERSYM_HIDDEN)
9702 ivda.vda_name < strtab_size
9703 ? strtab + ivda.vda_name : _("<corrupt>"));
9713 if (strtab != string_table)
9719 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
9721 if (do_histogram && buckets != NULL)
9723 unsigned long * lengths;
9724 unsigned long * counts;
9727 unsigned long maxlength = 0;
9728 unsigned long nzero_counts = 0;
9729 unsigned long nsyms = 0;
9731 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
9732 (unsigned long) nbuckets);
9733 printf (_(" Length Number %% of total Coverage\n"));
9735 lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
9736 if (lengths == NULL)
9738 error (_("Out of memory\n"));
9741 for (hn = 0; hn < nbuckets; ++hn)
9743 for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
9746 if (maxlength < ++lengths[hn])
9751 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
9754 error (_("Out of memory\n"));
9758 for (hn = 0; hn < nbuckets; ++hn)
9759 ++counts[lengths[hn]];
9764 printf (" 0 %-10lu (%5.1f%%)\n",
9765 counts[0], (counts[0] * 100.0) / nbuckets);
9766 for (i = 1; i <= maxlength; ++i)
9768 nzero_counts += counts[i] * i;
9769 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
9770 i, counts[i], (counts[i] * 100.0) / nbuckets,
9771 (nzero_counts * 100.0) / nsyms);
9779 if (buckets != NULL)
9785 if (do_histogram && gnubuckets != NULL)
9787 unsigned long * lengths;
9788 unsigned long * counts;
9790 unsigned long maxlength = 0;
9791 unsigned long nzero_counts = 0;
9792 unsigned long nsyms = 0;
9794 lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
9795 if (lengths == NULL)
9797 error (_("Out of memory\n"));
9801 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
9802 (unsigned long) ngnubuckets);
9803 printf (_(" Length Number %% of total Coverage\n"));
9805 for (hn = 0; hn < ngnubuckets; ++hn)
9806 if (gnubuckets[hn] != 0)
9808 bfd_vma off, length = 1;
9810 for (off = gnubuckets[hn] - gnusymidx;
9811 (gnuchains[off] & 1) == 0; ++off)
9813 lengths[hn] = length;
9814 if (length > maxlength)
9819 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
9822 error (_("Out of memory\n"));
9826 for (hn = 0; hn < ngnubuckets; ++hn)
9827 ++counts[lengths[hn]];
9829 if (ngnubuckets > 0)
9832 printf (" 0 %-10lu (%5.1f%%)\n",
9833 counts[0], (counts[0] * 100.0) / ngnubuckets);
9834 for (j = 1; j <= maxlength; ++j)
9836 nzero_counts += counts[j] * j;
9837 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
9838 j, counts[j], (counts[j] * 100.0) / ngnubuckets,
9839 (nzero_counts * 100.0) / nsyms);
9853 process_syminfo (FILE * file ATTRIBUTE_UNUSED)
9857 if (dynamic_syminfo == NULL
9859 /* No syminfo, this is ok. */
9862 /* There better should be a dynamic symbol section. */
9863 if (dynamic_symbols == NULL || dynamic_strings == NULL)
9867 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
9868 dynamic_syminfo_offset, dynamic_syminfo_nent);
9870 printf (_(" Num: Name BoundTo Flags\n"));
9871 for (i = 0; i < dynamic_syminfo_nent; ++i)
9873 unsigned short int flags = dynamic_syminfo[i].si_flags;
9875 printf ("%4d: ", i);
9876 if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
9877 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
9879 printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
9882 switch (dynamic_syminfo[i].si_boundto)
9884 case SYMINFO_BT_SELF:
9885 fputs ("SELF ", stdout);
9887 case SYMINFO_BT_PARENT:
9888 fputs ("PARENT ", stdout);
9891 if (dynamic_syminfo[i].si_boundto > 0
9892 && dynamic_syminfo[i].si_boundto < dynamic_nent
9893 && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
9895 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
9899 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
9903 if (flags & SYMINFO_FLG_DIRECT)
9905 if (flags & SYMINFO_FLG_PASSTHRU)
9906 printf (" PASSTHRU");
9907 if (flags & SYMINFO_FLG_COPY)
9909 if (flags & SYMINFO_FLG_LAZYLOAD)
9910 printf (" LAZYLOAD");
9918 /* Check to see if the given reloc needs to be handled in a target specific
9919 manner. If so then process the reloc and return TRUE otherwise return
9923 target_specific_reloc_handling (Elf_Internal_Rela * reloc,
9924 unsigned char * start,
9925 Elf_Internal_Sym * symtab)
9927 unsigned int reloc_type = get_reloc_type (reloc->r_info);
9929 switch (elf_header.e_machine)
9932 case EM_CYGNUS_MN10300:
9934 static Elf_Internal_Sym * saved_sym = NULL;
9938 case 34: /* R_MN10300_ALIGN */
9940 case 33: /* R_MN10300_SYM_DIFF */
9941 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
9943 case 1: /* R_MN10300_32 */
9944 case 2: /* R_MN10300_16 */
9945 if (saved_sym != NULL)
9949 value = reloc->r_addend
9950 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
9951 - saved_sym->st_value);
9953 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
9960 if (saved_sym != NULL)
9961 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc"));
9971 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
9972 DWARF debug sections. This is a target specific test. Note - we do not
9973 go through the whole including-target-headers-multiple-times route, (as
9974 we have already done with <elf/h8.h>) because this would become very
9975 messy and even then this function would have to contain target specific
9976 information (the names of the relocs instead of their numeric values).
9977 FIXME: This is not the correct way to solve this problem. The proper way
9978 is to have target specific reloc sizing and typing functions created by
9979 the reloc-macros.h header, in the same way that it already creates the
9980 reloc naming functions. */
9983 is_32bit_abs_reloc (unsigned int reloc_type)
9985 switch (elf_header.e_machine)
9989 return reloc_type == 1; /* R_386_32. */
9991 return reloc_type == 1; /* R_68K_32. */
9993 return reloc_type == 1; /* R_860_32. */
9995 return reloc_type == 2; /* R_960_32. */
9997 return reloc_type == 258; /* R_AARCH64_ABS32 */
9999 return reloc_type == 1; /* R_ALPHA_REFLONG. */
10001 return reloc_type == 1; /* R_ARC_32. */
10003 return reloc_type == 2; /* R_ARM_ABS32 */
10006 return reloc_type == 1;
10007 case EM_ADAPTEVA_EPIPHANY:
10008 return reloc_type == 3;
10010 return reloc_type == 0x12; /* R_byte4_data. */
10012 return reloc_type == 3; /* R_CRIS_32. */
10014 return reloc_type == 3; /* R_CR16_NUM32. */
10016 return reloc_type == 15; /* R_CRX_NUM32. */
10017 case EM_CYGNUS_FRV:
10018 return reloc_type == 1;
10019 case EM_CYGNUS_D10V:
10021 return reloc_type == 6; /* R_D10V_32. */
10022 case EM_CYGNUS_D30V:
10024 return reloc_type == 12; /* R_D30V_32_NORMAL. */
10026 return reloc_type == 3; /* R_DLX_RELOC_32. */
10027 case EM_CYGNUS_FR30:
10029 return reloc_type == 3; /* R_FR30_32. */
10033 return reloc_type == 1; /* R_H8_DIR32. */
10035 return reloc_type == 0x65; /* R_IA64_SECREL32LSB. */
10038 return reloc_type == 2; /* R_IP2K_32. */
10040 return reloc_type == 2; /* R_IQ2000_32. */
10041 case EM_LATTICEMICO32:
10042 return reloc_type == 3; /* R_LM32_32. */
10045 return reloc_type == 3; /* R_M32C_32. */
10047 return reloc_type == 34; /* R_M32R_32_RELA. */
10049 return reloc_type == 1; /* R_MCORE_ADDR32. */
10050 case EM_CYGNUS_MEP:
10051 return reloc_type == 4; /* R_MEP_32. */
10052 case EM_MICROBLAZE:
10053 return reloc_type == 1; /* R_MICROBLAZE_32. */
10055 return reloc_type == 2; /* R_MIPS_32. */
10057 return reloc_type == 4; /* R_MMIX_32. */
10058 case EM_CYGNUS_MN10200:
10060 return reloc_type == 1; /* R_MN10200_32. */
10061 case EM_CYGNUS_MN10300:
10063 return reloc_type == 1; /* R_MN10300_32. */
10065 return reloc_type == 1; /* R_MOXIE_32. */
10066 case EM_MSP430_OLD:
10068 return reloc_type == 1; /* R_MSP43_32. */
10070 return reloc_type == 2; /* R_MT_32. */
10071 case EM_ALTERA_NIOS2:
10073 return reloc_type == 1; /* R_NIOS_32. */
10076 return reloc_type == 1; /* R_OR32_32. */
10078 return (reloc_type == 1 /* R_PARISC_DIR32. */
10079 || reloc_type == 41); /* R_PARISC_SECREL32. */
10082 return reloc_type == 1; /* R_PJ_DATA_DIR32. */
10084 return reloc_type == 1; /* R_PPC64_ADDR32. */
10086 return reloc_type == 1; /* R_PPC_ADDR32. */
10088 return reloc_type == 1; /* R_RL78_DIR32. */
10090 return reloc_type == 1; /* R_RX_DIR32. */
10092 return reloc_type == 1; /* R_I370_ADDR31. */
10095 return reloc_type == 4; /* R_S390_32. */
10097 return reloc_type == 8; /* R_SCORE_ABS32. */
10099 return reloc_type == 1; /* R_SH_DIR32. */
10100 case EM_SPARC32PLUS:
10103 return reloc_type == 3 /* R_SPARC_32. */
10104 || reloc_type == 23; /* R_SPARC_UA32. */
10106 return reloc_type == 6; /* R_SPU_ADDR32 */
10108 return reloc_type == 1; /* R_C6000_ABS32. */
10110 return reloc_type == 2; /* R_TILEGX_32. */
10112 return reloc_type == 1; /* R_TILEPRO_32. */
10113 case EM_CYGNUS_V850:
10115 return reloc_type == 6; /* R_V850_ABS32. */
10117 return reloc_type == 0x33; /* R_V810_WORD. */
10119 return reloc_type == 1; /* R_VAX_32. */
10123 return reloc_type == 10; /* R_X86_64_32. */
10126 return reloc_type == 3; /* R_XC16C_ABS_32. */
10128 return reloc_type == 4; /* R_XGATE_32. */
10130 return reloc_type == 1; /* R_XSTROMY16_32. */
10131 case EM_XTENSA_OLD:
10133 return reloc_type == 1; /* R_XTENSA_32. */
10135 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
10136 elf_header.e_machine);
10141 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10142 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
10145 is_32bit_pcrel_reloc (unsigned int reloc_type)
10147 switch (elf_header.e_machine)
10151 return reloc_type == 2; /* R_386_PC32. */
10153 return reloc_type == 4; /* R_68K_PC32. */
10155 return reloc_type == 261; /* R_AARCH64_PREL32 */
10156 case EM_ADAPTEVA_EPIPHANY:
10157 return reloc_type == 6;
10159 return reloc_type == 10; /* R_ALPHA_SREL32. */
10161 return reloc_type == 3; /* R_ARM_REL32 */
10162 case EM_MICROBLAZE:
10163 return reloc_type == 2; /* R_MICROBLAZE_32_PCREL. */
10165 return reloc_type == 9; /* R_PARISC_PCREL32. */
10167 return reloc_type == 26; /* R_PPC_REL32. */
10169 return reloc_type == 26; /* R_PPC64_REL32. */
10172 return reloc_type == 5; /* R_390_PC32. */
10174 return reloc_type == 2; /* R_SH_REL32. */
10175 case EM_SPARC32PLUS:
10178 return reloc_type == 6; /* R_SPARC_DISP32. */
10180 return reloc_type == 13; /* R_SPU_REL32. */
10182 return reloc_type == 6; /* R_TILEGX_32_PCREL. */
10184 return reloc_type == 4; /* R_TILEPRO_32_PCREL. */
10188 return reloc_type == 2; /* R_X86_64_PC32. */
10189 case EM_XTENSA_OLD:
10191 return reloc_type == 14; /* R_XTENSA_32_PCREL. */
10193 /* Do not abort or issue an error message here. Not all targets use
10194 pc-relative 32-bit relocs in their DWARF debug information and we
10195 have already tested for target coverage in is_32bit_abs_reloc. A
10196 more helpful warning message will be generated by apply_relocations
10197 anyway, so just return. */
10202 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10203 a 64-bit absolute RELA relocation used in DWARF debug sections. */
10206 is_64bit_abs_reloc (unsigned int reloc_type)
10208 switch (elf_header.e_machine)
10211 return reloc_type == 257; /* R_AARCH64_ABS64. */
10213 return reloc_type == 2; /* R_ALPHA_REFQUAD. */
10215 return reloc_type == 0x27; /* R_IA64_DIR64LSB. */
10217 return reloc_type == 80; /* R_PARISC_DIR64. */
10219 return reloc_type == 38; /* R_PPC64_ADDR64. */
10220 case EM_SPARC32PLUS:
10223 return reloc_type == 54; /* R_SPARC_UA64. */
10227 return reloc_type == 1; /* R_X86_64_64. */
10230 return reloc_type == 22; /* R_S390_64. */
10232 return reloc_type == 1; /* R_TILEGX_64. */
10234 return reloc_type == 18; /* R_MIPS_64. */
10240 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
10241 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
10244 is_64bit_pcrel_reloc (unsigned int reloc_type)
10246 switch (elf_header.e_machine)
10249 return reloc_type == 260; /* R_AARCH64_PREL64. */
10251 return reloc_type == 11; /* R_ALPHA_SREL64. */
10253 return reloc_type == 0x4f; /* R_IA64_PCREL64LSB. */
10255 return reloc_type == 72; /* R_PARISC_PCREL64. */
10257 return reloc_type == 44; /* R_PPC64_REL64. */
10258 case EM_SPARC32PLUS:
10261 return reloc_type == 46; /* R_SPARC_DISP64. */
10265 return reloc_type == 24; /* R_X86_64_PC64. */
10268 return reloc_type == 23; /* R_S390_PC64. */
10270 return reloc_type == 5; /* R_TILEGX_64_PCREL. */
10276 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10277 a 24-bit absolute RELA relocation used in DWARF debug sections. */
10280 is_24bit_abs_reloc (unsigned int reloc_type)
10282 switch (elf_header.e_machine)
10284 case EM_CYGNUS_MN10200:
10286 return reloc_type == 4; /* R_MN10200_24. */
10292 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
10293 a 16-bit absolute RELA relocation used in DWARF debug sections. */
10296 is_16bit_abs_reloc (unsigned int reloc_type)
10298 switch (elf_header.e_machine)
10302 return reloc_type == 4; /* R_AVR_16. */
10303 case EM_ADAPTEVA_EPIPHANY:
10304 return reloc_type == 5;
10305 case EM_CYGNUS_D10V:
10307 return reloc_type == 3; /* R_D10V_16. */
10311 return reloc_type == R_H8_DIR16;
10314 return reloc_type == 1; /* R_IP2K_16. */
10317 return reloc_type == 1; /* R_M32C_16 */
10318 case EM_MSP430_OLD:
10320 return reloc_type == 5; /* R_MSP430_16_BYTE. */
10321 case EM_ALTERA_NIOS2:
10323 return reloc_type == 9; /* R_NIOS_16. */
10325 return reloc_type == 2; /* R_C6000_ABS16. */
10328 return reloc_type == 2; /* R_XC16C_ABS_16. */
10329 case EM_CYGNUS_MN10200:
10331 return reloc_type == 2; /* R_MN10200_16. */
10332 case EM_CYGNUS_MN10300:
10334 return reloc_type == 2; /* R_MN10300_16. */
10336 return reloc_type == 3; /* R_XGATE_16. */
10342 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
10343 relocation entries (possibly formerly used for SHT_GROUP sections). */
10346 is_none_reloc (unsigned int reloc_type)
10348 switch (elf_header.e_machine)
10350 case EM_68K: /* R_68K_NONE. */
10351 case EM_386: /* R_386_NONE. */
10352 case EM_SPARC32PLUS:
10354 case EM_SPARC: /* R_SPARC_NONE. */
10355 case EM_MIPS: /* R_MIPS_NONE. */
10356 case EM_PARISC: /* R_PARISC_NONE. */
10357 case EM_ALPHA: /* R_ALPHA_NONE. */
10358 case EM_ADAPTEVA_EPIPHANY:
10359 case EM_PPC: /* R_PPC_NONE. */
10360 case EM_PPC64: /* R_PPC64_NONE. */
10361 case EM_ARM: /* R_ARM_NONE. */
10362 case EM_IA_64: /* R_IA64_NONE. */
10363 case EM_SH: /* R_SH_NONE. */
10365 case EM_S390: /* R_390_NONE. */
10366 case EM_CRIS: /* R_CRIS_NONE. */
10367 case EM_X86_64: /* R_X86_64_NONE. */
10368 case EM_L1OM: /* R_X86_64_NONE. */
10369 case EM_K1OM: /* R_X86_64_NONE. */
10370 case EM_MN10300: /* R_MN10300_NONE. */
10371 case EM_MOXIE: /* R_MOXIE_NONE. */
10372 case EM_M32R: /* R_M32R_NONE. */
10373 case EM_TI_C6000:/* R_C6000_NONE. */
10374 case EM_TILEGX: /* R_TILEGX_NONE. */
10375 case EM_TILEPRO: /* R_TILEPRO_NONE. */
10377 case EM_C166: /* R_XC16X_NONE. */
10378 return reloc_type == 0;
10380 return reloc_type == 0 || reloc_type == 256;
10381 case EM_XTENSA_OLD:
10383 return (reloc_type == 0 /* R_XTENSA_NONE. */
10384 || reloc_type == 17 /* R_XTENSA_DIFF8. */
10385 || reloc_type == 18 /* R_XTENSA_DIFF16. */
10386 || reloc_type == 19 /* R_XTENSA_DIFF32. */);
10391 /* Apply relocations to a section.
10392 Note: So far support has been added only for those relocations
10393 which can be found in debug sections.
10394 FIXME: Add support for more relocations ? */
10397 apply_relocations (void * file,
10398 Elf_Internal_Shdr * section,
10399 unsigned char * start)
10401 Elf_Internal_Shdr * relsec;
10402 unsigned char * end = start + section->sh_size;
10404 if (elf_header.e_type != ET_REL)
10407 /* Find the reloc section associated with the section. */
10408 for (relsec = section_headers;
10409 relsec < section_headers + elf_header.e_shnum;
10412 bfd_boolean is_rela;
10413 unsigned long num_relocs;
10414 Elf_Internal_Rela * relocs;
10415 Elf_Internal_Rela * rp;
10416 Elf_Internal_Shdr * symsec;
10417 Elf_Internal_Sym * symtab;
10418 unsigned long num_syms;
10419 Elf_Internal_Sym * sym;
10421 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
10422 || relsec->sh_info >= elf_header.e_shnum
10423 || section_headers + relsec->sh_info != section
10424 || relsec->sh_size == 0
10425 || relsec->sh_link >= elf_header.e_shnum)
10428 is_rela = relsec->sh_type == SHT_RELA;
10432 if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
10433 relsec->sh_size, & relocs, & num_relocs))
10438 if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
10439 relsec->sh_size, & relocs, & num_relocs))
10443 /* SH uses RELA but uses in place value instead of the addend field. */
10444 if (elf_header.e_machine == EM_SH)
10447 symsec = section_headers + relsec->sh_link;
10448 symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec, & num_syms);
10450 for (rp = relocs; rp < relocs + num_relocs; ++rp)
10453 unsigned int reloc_type;
10454 unsigned int reloc_size;
10455 unsigned char * rloc;
10456 unsigned long sym_index;
10458 reloc_type = get_reloc_type (rp->r_info);
10460 if (target_specific_reloc_handling (rp, start, symtab))
10462 else if (is_none_reloc (reloc_type))
10464 else if (is_32bit_abs_reloc (reloc_type)
10465 || is_32bit_pcrel_reloc (reloc_type))
10467 else if (is_64bit_abs_reloc (reloc_type)
10468 || is_64bit_pcrel_reloc (reloc_type))
10470 else if (is_24bit_abs_reloc (reloc_type))
10472 else if (is_16bit_abs_reloc (reloc_type))
10476 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
10477 reloc_type, SECTION_NAME (section));
10481 rloc = start + rp->r_offset;
10482 if ((rloc + reloc_size) > end)
10484 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
10485 (unsigned long) rp->r_offset,
10486 SECTION_NAME (section));
10490 sym_index = (unsigned long) get_reloc_symindex (rp->r_info);
10491 if (sym_index >= num_syms)
10493 warn (_("skipping invalid relocation symbol index 0x%lx in section %s\n"),
10494 sym_index, SECTION_NAME (section));
10497 sym = symtab + sym_index;
10499 /* If the reloc has a symbol associated with it,
10500 make sure that it is of an appropriate type.
10502 Relocations against symbols without type can happen.
10503 Gcc -feliminate-dwarf2-dups may generate symbols
10504 without type for debug info.
10506 Icc generates relocations against function symbols
10507 instead of local labels.
10509 Relocations against object symbols can happen, eg when
10510 referencing a global array. For an example of this see
10511 the _clz.o binary in libgcc.a. */
10513 && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
10515 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
10516 get_symbol_type (ELF_ST_TYPE (sym->st_info)),
10517 (long int)(rp - relocs),
10518 SECTION_NAME (relsec));
10524 addend += rp->r_addend;
10525 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
10526 partial_inplace. */
10528 || (elf_header.e_machine == EM_XTENSA
10529 && reloc_type == 1)
10530 || ((elf_header.e_machine == EM_PJ
10531 || elf_header.e_machine == EM_PJ_OLD)
10532 && reloc_type == 1)
10533 || ((elf_header.e_machine == EM_D30V
10534 || elf_header.e_machine == EM_CYGNUS_D30V)
10535 && reloc_type == 12))
10536 addend += byte_get (rloc, reloc_size);
10538 if (is_32bit_pcrel_reloc (reloc_type)
10539 || is_64bit_pcrel_reloc (reloc_type))
10541 /* On HPPA, all pc-relative relocations are biased by 8. */
10542 if (elf_header.e_machine == EM_PARISC)
10544 byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
10548 byte_put (rloc, addend + sym->st_value, reloc_size);
10557 #ifdef SUPPORT_DISASSEMBLY
10559 disassemble_section (Elf_Internal_Shdr * section, FILE * file)
10561 printf (_("\nAssembly dump of section %s\n"),
10562 SECTION_NAME (section));
10564 /* XXX -- to be done --- XXX */
10570 /* Reads in the contents of SECTION from FILE, returning a pointer
10571 to a malloc'ed buffer or NULL if something went wrong. */
10574 get_section_contents (Elf_Internal_Shdr * section, FILE * file)
10576 bfd_size_type num_bytes;
10578 num_bytes = section->sh_size;
10580 if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
10582 printf (_("\nSection '%s' has no data to dump.\n"),
10583 SECTION_NAME (section));
10587 return (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
10588 _("section contents"));
10593 dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
10595 Elf_Internal_Shdr * relsec;
10596 bfd_size_type num_bytes;
10600 char * name = SECTION_NAME (section);
10601 bfd_boolean some_strings_shown;
10603 start = get_section_contents (section, file);
10607 printf (_("\nString dump of section '%s':\n"), name);
10609 /* If the section being dumped has relocations against it the user might
10610 be expecting these relocations to have been applied. Check for this
10611 case and issue a warning message in order to avoid confusion.
10612 FIXME: Maybe we ought to have an option that dumps a section with
10613 relocs applied ? */
10614 for (relsec = section_headers;
10615 relsec < section_headers + elf_header.e_shnum;
10618 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
10619 || relsec->sh_info >= elf_header.e_shnum
10620 || section_headers + relsec->sh_info != section
10621 || relsec->sh_size == 0
10622 || relsec->sh_link >= elf_header.e_shnum)
10625 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
10629 num_bytes = section->sh_size;
10631 end = start + num_bytes;
10632 some_strings_shown = FALSE;
10636 while (!ISPRINT (* data))
10637 if (++ data >= end)
10643 /* PR 11128: Use two separate invocations in order to work
10644 around bugs in the Solaris 8 implementation of printf. */
10645 printf (" [%6tx] ", data - start);
10646 printf ("%s\n", data);
10648 printf (" [%6Ix] %s\n", (size_t) (data - start), data);
10650 data += strlen (data);
10651 some_strings_shown = TRUE;
10655 if (! some_strings_shown)
10656 printf (_(" No strings found in this section."));
10664 dump_section_as_bytes (Elf_Internal_Shdr * section,
10666 bfd_boolean relocate)
10668 Elf_Internal_Shdr * relsec;
10669 bfd_size_type bytes;
10671 unsigned char * data;
10672 unsigned char * start;
10674 start = (unsigned char *) get_section_contents (section, file);
10678 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
10682 apply_relocations (file, section, start);
10686 /* If the section being dumped has relocations against it the user might
10687 be expecting these relocations to have been applied. Check for this
10688 case and issue a warning message in order to avoid confusion.
10689 FIXME: Maybe we ought to have an option that dumps a section with
10690 relocs applied ? */
10691 for (relsec = section_headers;
10692 relsec < section_headers + elf_header.e_shnum;
10695 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
10696 || relsec->sh_info >= elf_header.e_shnum
10697 || section_headers + relsec->sh_info != section
10698 || relsec->sh_size == 0
10699 || relsec->sh_link >= elf_header.e_shnum)
10702 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
10707 addr = section->sh_addr;
10708 bytes = section->sh_size;
10717 lbytes = (bytes > 16 ? 16 : bytes);
10719 printf (" 0x%8.8lx ", (unsigned long) addr);
10721 for (j = 0; j < 16; j++)
10724 printf ("%2.2x", data[j]);
10732 for (j = 0; j < lbytes; j++)
10735 if (k >= ' ' && k < 0x7f)
10753 /* Uncompresses a section that was compressed using zlib, in place. */
10756 uncompress_section_contents (unsigned char **buffer ATTRIBUTE_UNUSED,
10757 dwarf_size_type *size ATTRIBUTE_UNUSED)
10759 #ifndef HAVE_ZLIB_H
10762 dwarf_size_type compressed_size = *size;
10763 unsigned char * compressed_buffer = *buffer;
10764 dwarf_size_type uncompressed_size;
10765 unsigned char * uncompressed_buffer;
10768 dwarf_size_type header_size = 12;
10770 /* Read the zlib header. In this case, it should be "ZLIB" followed
10771 by the uncompressed section size, 8 bytes in big-endian order. */
10772 if (compressed_size < header_size
10773 || ! streq ((char *) compressed_buffer, "ZLIB"))
10776 uncompressed_size = compressed_buffer[4]; uncompressed_size <<= 8;
10777 uncompressed_size += compressed_buffer[5]; uncompressed_size <<= 8;
10778 uncompressed_size += compressed_buffer[6]; uncompressed_size <<= 8;
10779 uncompressed_size += compressed_buffer[7]; uncompressed_size <<= 8;
10780 uncompressed_size += compressed_buffer[8]; uncompressed_size <<= 8;
10781 uncompressed_size += compressed_buffer[9]; uncompressed_size <<= 8;
10782 uncompressed_size += compressed_buffer[10]; uncompressed_size <<= 8;
10783 uncompressed_size += compressed_buffer[11];
10785 /* It is possible the section consists of several compressed
10786 buffers concatenated together, so we uncompress in a loop. */
10787 strm.zalloc = NULL;
10789 strm.opaque = NULL;
10790 strm.avail_in = compressed_size - header_size;
10791 strm.next_in = (Bytef *) compressed_buffer + header_size;
10792 strm.avail_out = uncompressed_size;
10793 uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
10795 rc = inflateInit (& strm);
10796 while (strm.avail_in > 0)
10800 strm.next_out = ((Bytef *) uncompressed_buffer
10801 + (uncompressed_size - strm.avail_out));
10802 rc = inflate (&strm, Z_FINISH);
10803 if (rc != Z_STREAM_END)
10805 rc = inflateReset (& strm);
10807 rc = inflateEnd (& strm);
10809 || strm.avail_out != 0)
10812 free (compressed_buffer);
10813 *buffer = uncompressed_buffer;
10814 *size = uncompressed_size;
10818 free (uncompressed_buffer);
10819 /* Indicate decompression failure. */
10822 #endif /* HAVE_ZLIB_H */
10826 load_specific_debug_section (enum dwarf_section_display_enum debug,
10827 Elf_Internal_Shdr * sec, void * file)
10829 struct dwarf_section * section = &debug_displays [debug].section;
10832 /* If it is already loaded, do nothing. */
10833 if (section->start != NULL)
10836 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
10837 section->address = sec->sh_addr;
10838 section->start = (unsigned char *) get_data (NULL, (FILE *) file,
10840 sec->sh_size, buf);
10841 if (section->start == NULL)
10845 section->size = sec->sh_size;
10846 if (uncompress_section_contents (§ion->start, §ion->size))
10847 sec->sh_size = section->size;
10850 if (section->start == NULL)
10853 if (debug_displays [debug].relocate)
10854 apply_relocations ((FILE *) file, sec, section->start);
10859 /* If this is not NULL, load_debug_section will only look for sections
10860 within the list of sections given here. */
10861 unsigned int *section_subset = NULL;
10864 load_debug_section (enum dwarf_section_display_enum debug, void * file)
10866 struct dwarf_section * section = &debug_displays [debug].section;
10867 Elf_Internal_Shdr * sec;
10869 /* Locate the debug section. */
10870 sec = find_section_in_set (section->uncompressed_name, section_subset);
10872 section->name = section->uncompressed_name;
10875 sec = find_section_in_set (section->compressed_name, section_subset);
10877 section->name = section->compressed_name;
10882 /* If we're loading from a subset of sections, and we've loaded
10883 a section matching this name before, it's likely that it's a
10885 if (section_subset != NULL)
10886 free_debug_section (debug);
10888 return load_specific_debug_section (debug, sec, (FILE *) file);
10892 free_debug_section (enum dwarf_section_display_enum debug)
10894 struct dwarf_section * section = &debug_displays [debug].section;
10896 if (section->start == NULL)
10899 free ((char *) section->start);
10900 section->start = NULL;
10901 section->address = 0;
10906 display_debug_section (int shndx, Elf_Internal_Shdr * section, FILE * file)
10908 char * name = SECTION_NAME (section);
10909 bfd_size_type length;
10913 length = section->sh_size;
10916 printf (_("\nSection '%s' has no debugging data.\n"), name);
10919 if (section->sh_type == SHT_NOBITS)
10921 /* There is no point in dumping the contents of a debugging section
10922 which has the NOBITS type - the bits in the file will be random.
10923 This can happen when a file containing a .eh_frame section is
10924 stripped with the --only-keep-debug command line option. */
10925 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"), name);
10929 if (const_strneq (name, ".gnu.linkonce.wi."))
10930 name = ".debug_info";
10932 /* See if we know how to display the contents of this section. */
10933 for (i = 0; i < max; i++)
10934 if (streq (debug_displays[i].section.uncompressed_name, name)
10935 || streq (debug_displays[i].section.compressed_name, name))
10937 struct dwarf_section * sec = &debug_displays [i].section;
10938 int secondary = (section != find_section (name));
10941 free_debug_section ((enum dwarf_section_display_enum) i);
10943 if (streq (sec->uncompressed_name, name))
10944 sec->name = sec->uncompressed_name;
10946 sec->name = sec->compressed_name;
10947 if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
10950 /* If this debug section is part of a CU/TU set in a .dwp file,
10951 restrict load_debug_section to the sections in that set. */
10952 section_subset = find_cu_tu_set (file, shndx);
10954 result &= debug_displays[i].display (sec, file);
10956 section_subset = NULL;
10958 if (secondary || (i != info && i != abbrev))
10959 free_debug_section ((enum dwarf_section_display_enum) i);
10967 printf (_("Unrecognized debug section: %s\n"), name);
10974 /* Set DUMP_SECTS for all sections where dumps were requested
10975 based on section name. */
10978 initialise_dumps_byname (void)
10980 struct dump_list_entry * cur;
10982 for (cur = dump_sects_byname; cur; cur = cur->next)
10987 for (i = 0, any = 0; i < elf_header.e_shnum; i++)
10988 if (streq (SECTION_NAME (section_headers + i), cur->name))
10990 request_dump_bynumber (i, cur->type);
10995 warn (_("Section '%s' was not dumped because it does not exist!\n"),
11001 process_section_contents (FILE * file)
11003 Elf_Internal_Shdr * section;
11009 initialise_dumps_byname ();
11011 for (i = 0, section = section_headers;
11012 i < elf_header.e_shnum && i < num_dump_sects;
11015 #ifdef SUPPORT_DISASSEMBLY
11016 if (dump_sects[i] & DISASS_DUMP)
11017 disassemble_section (section, file);
11019 if (dump_sects[i] & HEX_DUMP)
11020 dump_section_as_bytes (section, file, FALSE);
11022 if (dump_sects[i] & RELOC_DUMP)
11023 dump_section_as_bytes (section, file, TRUE);
11025 if (dump_sects[i] & STRING_DUMP)
11026 dump_section_as_strings (section, file);
11028 if (dump_sects[i] & DEBUG_DUMP)
11029 display_debug_section (i, section, file);
11032 /* Check to see if the user requested a
11033 dump of a section that does not exist. */
11034 while (i++ < num_dump_sects)
11036 warn (_("Section %d was not dumped because it does not exist!\n"), i);
11040 process_mips_fpe_exception (int mask)
11045 if (mask & OEX_FPU_INEX)
11046 fputs ("INEX", stdout), first = 0;
11047 if (mask & OEX_FPU_UFLO)
11048 printf ("%sUFLO", first ? "" : "|"), first = 0;
11049 if (mask & OEX_FPU_OFLO)
11050 printf ("%sOFLO", first ? "" : "|"), first = 0;
11051 if (mask & OEX_FPU_DIV0)
11052 printf ("%sDIV0", first ? "" : "|"), first = 0;
11053 if (mask & OEX_FPU_INVAL)
11054 printf ("%sINVAL", first ? "" : "|");
11057 fputs ("0", stdout);
11060 /* ARM EABI attributes section. */
11065 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
11067 const char ** table;
11068 } arm_attr_public_tag;
11070 static const char * arm_attr_tag_CPU_arch[] =
11071 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
11072 "v6K", "v7", "v6-M", "v6S-M", "v7E-M", "v8"};
11073 static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
11074 static const char * arm_attr_tag_THUMB_ISA_use[] =
11075 {"No", "Thumb-1", "Thumb-2"};
11076 static const char * arm_attr_tag_FP_arch[] =
11077 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16",
11079 static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
11080 static const char * arm_attr_tag_Advanced_SIMD_arch[] =
11081 {"No", "NEONv1", "NEONv1 with Fused-MAC", "NEON for ARMv8"};
11082 static const char * arm_attr_tag_PCS_config[] =
11083 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
11084 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
11085 static const char * arm_attr_tag_ABI_PCS_R9_use[] =
11086 {"V6", "SB", "TLS", "Unused"};
11087 static const char * arm_attr_tag_ABI_PCS_RW_data[] =
11088 {"Absolute", "PC-relative", "SB-relative", "None"};
11089 static const char * arm_attr_tag_ABI_PCS_RO_data[] =
11090 {"Absolute", "PC-relative", "None"};
11091 static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
11092 {"None", "direct", "GOT-indirect"};
11093 static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
11094 {"None", "??? 1", "2", "??? 3", "4"};
11095 static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
11096 static const char * arm_attr_tag_ABI_FP_denormal[] =
11097 {"Unused", "Needed", "Sign only"};
11098 static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
11099 static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
11100 static const char * arm_attr_tag_ABI_FP_number_model[] =
11101 {"Unused", "Finite", "RTABI", "IEEE 754"};
11102 static const char * arm_attr_tag_ABI_enum_size[] =
11103 {"Unused", "small", "int", "forced to int"};
11104 static const char * arm_attr_tag_ABI_HardFP_use[] =
11105 {"As Tag_FP_arch", "SP only", "DP only", "SP and DP"};
11106 static const char * arm_attr_tag_ABI_VFP_args[] =
11107 {"AAPCS", "VFP registers", "custom"};
11108 static const char * arm_attr_tag_ABI_WMMX_args[] =
11109 {"AAPCS", "WMMX registers", "custom"};
11110 static const char * arm_attr_tag_ABI_optimization_goals[] =
11111 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
11112 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
11113 static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
11114 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
11115 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
11116 static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
11117 static const char * arm_attr_tag_FP_HP_extension[] =
11118 {"Not Allowed", "Allowed"};
11119 static const char * arm_attr_tag_ABI_FP_16bit_format[] =
11120 {"None", "IEEE 754", "Alternative Format"};
11121 static const char * arm_attr_tag_MPextension_use[] =
11122 {"Not Allowed", "Allowed"};
11123 static const char * arm_attr_tag_DIV_use[] =
11124 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
11125 "Allowed in v7-A with integer division extension"};
11126 static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
11127 static const char * arm_attr_tag_Virtualization_use[] =
11128 {"Not Allowed", "TrustZone", "Virtualization Extensions",
11129 "TrustZone and Virtualization Extensions"};
11130 static const char * arm_attr_tag_MPextension_use_legacy[] =
11131 {"Not Allowed", "Allowed"};
11133 #define LOOKUP(id, name) \
11134 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
11135 static arm_attr_public_tag arm_attr_public_tags[] =
11137 {4, "CPU_raw_name", 1, NULL},
11138 {5, "CPU_name", 1, NULL},
11139 LOOKUP(6, CPU_arch),
11140 {7, "CPU_arch_profile", 0, NULL},
11141 LOOKUP(8, ARM_ISA_use),
11142 LOOKUP(9, THUMB_ISA_use),
11143 LOOKUP(10, FP_arch),
11144 LOOKUP(11, WMMX_arch),
11145 LOOKUP(12, Advanced_SIMD_arch),
11146 LOOKUP(13, PCS_config),
11147 LOOKUP(14, ABI_PCS_R9_use),
11148 LOOKUP(15, ABI_PCS_RW_data),
11149 LOOKUP(16, ABI_PCS_RO_data),
11150 LOOKUP(17, ABI_PCS_GOT_use),
11151 LOOKUP(18, ABI_PCS_wchar_t),
11152 LOOKUP(19, ABI_FP_rounding),
11153 LOOKUP(20, ABI_FP_denormal),
11154 LOOKUP(21, ABI_FP_exceptions),
11155 LOOKUP(22, ABI_FP_user_exceptions),
11156 LOOKUP(23, ABI_FP_number_model),
11157 {24, "ABI_align_needed", 0, NULL},
11158 {25, "ABI_align_preserved", 0, NULL},
11159 LOOKUP(26, ABI_enum_size),
11160 LOOKUP(27, ABI_HardFP_use),
11161 LOOKUP(28, ABI_VFP_args),
11162 LOOKUP(29, ABI_WMMX_args),
11163 LOOKUP(30, ABI_optimization_goals),
11164 LOOKUP(31, ABI_FP_optimization_goals),
11165 {32, "compatibility", 0, NULL},
11166 LOOKUP(34, CPU_unaligned_access),
11167 LOOKUP(36, FP_HP_extension),
11168 LOOKUP(38, ABI_FP_16bit_format),
11169 LOOKUP(42, MPextension_use),
11170 LOOKUP(44, DIV_use),
11171 {64, "nodefaults", 0, NULL},
11172 {65, "also_compatible_with", 0, NULL},
11173 LOOKUP(66, T2EE_use),
11174 {67, "conformance", 1, NULL},
11175 LOOKUP(68, Virtualization_use),
11176 LOOKUP(70, MPextension_use_legacy)
11180 static unsigned char *
11181 display_arm_attribute (unsigned char * p)
11186 arm_attr_public_tag * attr;
11190 tag = read_uleb128 (p, &len);
11193 for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
11195 if (arm_attr_public_tags[i].tag == tag)
11197 attr = &arm_attr_public_tags[i];
11204 printf (" Tag_%s: ", attr->name);
11205 switch (attr->type)
11210 case 7: /* Tag_CPU_arch_profile. */
11211 val = read_uleb128 (p, &len);
11215 case 0: printf (_("None\n")); break;
11216 case 'A': printf (_("Application\n")); break;
11217 case 'R': printf (_("Realtime\n")); break;
11218 case 'M': printf (_("Microcontroller\n")); break;
11219 case 'S': printf (_("Application or Realtime\n")); break;
11220 default: printf ("??? (%d)\n", val); break;
11224 case 24: /* Tag_align_needed. */
11225 val = read_uleb128 (p, &len);
11229 case 0: printf (_("None\n")); break;
11230 case 1: printf (_("8-byte\n")); break;
11231 case 2: printf (_("4-byte\n")); break;
11232 case 3: printf ("??? 3\n"); break;
11235 printf (_("8-byte and up to %d-byte extended\n"),
11238 printf ("??? (%d)\n", val);
11243 case 25: /* Tag_align_preserved. */
11244 val = read_uleb128 (p, &len);
11248 case 0: printf (_("None\n")); break;
11249 case 1: printf (_("8-byte, except leaf SP\n")); break;
11250 case 2: printf (_("8-byte\n")); break;
11251 case 3: printf ("??? 3\n"); break;
11254 printf (_("8-byte and up to %d-byte extended\n"),
11257 printf ("??? (%d)\n", val);
11262 case 32: /* Tag_compatibility. */
11263 val = read_uleb128 (p, &len);
11265 printf (_("flag = %d, vendor = %s\n"), val, p);
11266 p += strlen ((char *) p) + 1;
11269 case 64: /* Tag_nodefaults. */
11271 printf (_("True\n"));
11274 case 65: /* Tag_also_compatible_with. */
11275 val = read_uleb128 (p, &len);
11277 if (val == 6 /* Tag_CPU_arch. */)
11279 val = read_uleb128 (p, &len);
11281 if ((unsigned int)val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
11282 printf ("??? (%d)\n", val);
11284 printf ("%s\n", arm_attr_tag_CPU_arch[val]);
11288 while (*(p++) != '\0' /* NUL terminator. */);
11302 assert (attr->type & 0x80);
11303 val = read_uleb128 (p, &len);
11305 type = attr->type & 0x7f;
11307 printf ("??? (%d)\n", val);
11309 printf ("%s\n", attr->table[val]);
11316 type = 1; /* String. */
11318 type = 2; /* uleb128. */
11319 printf (" Tag_unknown_%d: ", tag);
11324 printf ("\"%s\"\n", p);
11325 p += strlen ((char *) p) + 1;
11329 val = read_uleb128 (p, &len);
11331 printf ("%d (0x%x)\n", val, val);
11337 static unsigned char *
11338 display_gnu_attribute (unsigned char * p,
11339 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int))
11346 tag = read_uleb128 (p, &len);
11349 /* Tag_compatibility is the only generic GNU attribute defined at
11353 val = read_uleb128 (p, &len);
11355 printf (_("flag = %d, vendor = %s\n"), val, p);
11356 p += strlen ((char *) p) + 1;
11360 if ((tag & 2) == 0 && display_proc_gnu_attribute)
11361 return display_proc_gnu_attribute (p, tag);
11364 type = 1; /* String. */
11366 type = 2; /* uleb128. */
11367 printf (" Tag_unknown_%d: ", tag);
11371 printf ("\"%s\"\n", p);
11372 p += strlen ((char *) p) + 1;
11376 val = read_uleb128 (p, &len);
11378 printf ("%d (0x%x)\n", val, val);
11384 static unsigned char *
11385 display_power_gnu_attribute (unsigned char * p, int tag)
11391 if (tag == Tag_GNU_Power_ABI_FP)
11393 val = read_uleb128 (p, &len);
11395 printf (" Tag_GNU_Power_ABI_FP: ");
11400 printf (_("Hard or soft float\n"));
11403 printf (_("Hard float\n"));
11406 printf (_("Soft float\n"));
11409 printf (_("Single-precision hard float\n"));
11412 printf ("??? (%d)\n", val);
11418 if (tag == Tag_GNU_Power_ABI_Vector)
11420 val = read_uleb128 (p, &len);
11422 printf (" Tag_GNU_Power_ABI_Vector: ");
11426 printf (_("Any\n"));
11429 printf (_("Generic\n"));
11432 printf ("AltiVec\n");
11438 printf ("??? (%d)\n", val);
11444 if (tag == Tag_GNU_Power_ABI_Struct_Return)
11446 val = read_uleb128 (p, &len);
11448 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
11452 printf (_("Any\n"));
11455 printf ("r3/r4\n");
11458 printf (_("Memory\n"));
11461 printf ("??? (%d)\n", val);
11468 type = 1; /* String. */
11470 type = 2; /* uleb128. */
11471 printf (" Tag_unknown_%d: ", tag);
11475 printf ("\"%s\"\n", p);
11476 p += strlen ((char *) p) + 1;
11480 val = read_uleb128 (p, &len);
11482 printf ("%d (0x%x)\n", val, val);
11489 display_sparc_hwcaps (int mask)
11494 if (mask & ELF_SPARC_HWCAP_MUL32)
11495 fputs ("mul32", stdout), first = 0;
11496 if (mask & ELF_SPARC_HWCAP_DIV32)
11497 printf ("%sdiv32", first ? "" : "|"), first = 0;
11498 if (mask & ELF_SPARC_HWCAP_FSMULD)
11499 printf ("%sfsmuld", first ? "" : "|"), first = 0;
11500 if (mask & ELF_SPARC_HWCAP_V8PLUS)
11501 printf ("%sv8plus", first ? "" : "|"), first = 0;
11502 if (mask & ELF_SPARC_HWCAP_POPC)
11503 printf ("%spopc", first ? "" : "|"), first = 0;
11504 if (mask & ELF_SPARC_HWCAP_VIS)
11505 printf ("%svis", first ? "" : "|"), first = 0;
11506 if (mask & ELF_SPARC_HWCAP_VIS2)
11507 printf ("%svis2", first ? "" : "|"), first = 0;
11508 if (mask & ELF_SPARC_HWCAP_ASI_BLK_INIT)
11509 printf ("%sASIBlkInit", first ? "" : "|"), first = 0;
11510 if (mask & ELF_SPARC_HWCAP_FMAF)
11511 printf ("%sfmaf", first ? "" : "|"), first = 0;
11512 if (mask & ELF_SPARC_HWCAP_VIS3)
11513 printf ("%svis3", first ? "" : "|"), first = 0;
11514 if (mask & ELF_SPARC_HWCAP_HPC)
11515 printf ("%shpc", first ? "" : "|"), first = 0;
11516 if (mask & ELF_SPARC_HWCAP_RANDOM)
11517 printf ("%srandom", first ? "" : "|"), first = 0;
11518 if (mask & ELF_SPARC_HWCAP_TRANS)
11519 printf ("%strans", first ? "" : "|"), first = 0;
11520 if (mask & ELF_SPARC_HWCAP_FJFMAU)
11521 printf ("%sfjfmau", first ? "" : "|"), first = 0;
11522 if (mask & ELF_SPARC_HWCAP_IMA)
11523 printf ("%sima", first ? "" : "|"), first = 0;
11524 if (mask & ELF_SPARC_HWCAP_ASI_CACHE_SPARING)
11525 printf ("%scspare", first ? "" : "|"), first = 0;
11528 fputc('0', stdout);
11529 fputc('\n', stdout);
11532 static unsigned char *
11533 display_sparc_gnu_attribute (unsigned char * p, int tag)
11539 if (tag == Tag_GNU_Sparc_HWCAPS)
11541 val = read_uleb128 (p, &len);
11543 printf (" Tag_GNU_Sparc_HWCAPS: ");
11545 display_sparc_hwcaps (val);
11550 type = 1; /* String. */
11552 type = 2; /* uleb128. */
11553 printf (" Tag_unknown_%d: ", tag);
11557 printf ("\"%s\"\n", p);
11558 p += strlen ((char *) p) + 1;
11562 val = read_uleb128 (p, &len);
11564 printf ("%d (0x%x)\n", val, val);
11570 static unsigned char *
11571 display_mips_gnu_attribute (unsigned char * p, int tag)
11577 if (tag == Tag_GNU_MIPS_ABI_FP)
11579 val = read_uleb128 (p, &len);
11581 printf (" Tag_GNU_MIPS_ABI_FP: ");
11586 printf (_("Hard or soft float\n"));
11589 printf (_("Hard float (double precision)\n"));
11592 printf (_("Hard float (single precision)\n"));
11595 printf (_("Soft float\n"));
11598 printf (_("Hard float (MIPS32r2 64-bit FPU)\n"));
11601 printf ("??? (%d)\n", val);
11608 type = 1; /* String. */
11610 type = 2; /* uleb128. */
11611 printf (" Tag_unknown_%d: ", tag);
11615 printf ("\"%s\"\n", p);
11616 p += strlen ((char *) p) + 1;
11620 val = read_uleb128 (p, &len);
11622 printf ("%d (0x%x)\n", val, val);
11628 static unsigned char *
11629 display_tic6x_attribute (unsigned char * p)
11635 tag = read_uleb128 (p, &len);
11641 val = read_uleb128 (p, &len);
11643 printf (" Tag_ISA: ");
11647 case C6XABI_Tag_ISA_none:
11648 printf (_("None\n"));
11650 case C6XABI_Tag_ISA_C62X:
11653 case C6XABI_Tag_ISA_C67X:
11656 case C6XABI_Tag_ISA_C67XP:
11657 printf ("C67x+\n");
11659 case C6XABI_Tag_ISA_C64X:
11662 case C6XABI_Tag_ISA_C64XP:
11663 printf ("C64x+\n");
11665 case C6XABI_Tag_ISA_C674X:
11666 printf ("C674x\n");
11669 printf ("??? (%d)\n", val);
11674 case Tag_ABI_wchar_t:
11675 val = read_uleb128 (p, &len);
11677 printf (" Tag_ABI_wchar_t: ");
11681 printf (_("Not used\n"));
11684 printf (_("2 bytes\n"));
11687 printf (_("4 bytes\n"));
11690 printf ("??? (%d)\n", val);
11695 case Tag_ABI_stack_align_needed:
11696 val = read_uleb128 (p, &len);
11698 printf (" Tag_ABI_stack_align_needed: ");
11702 printf (_("8-byte\n"));
11705 printf (_("16-byte\n"));
11708 printf ("??? (%d)\n", val);
11713 case Tag_ABI_stack_align_preserved:
11714 val = read_uleb128 (p, &len);
11716 printf (" Tag_ABI_stack_align_preserved: ");
11720 printf (_("8-byte\n"));
11723 printf (_("16-byte\n"));
11726 printf ("??? (%d)\n", val);
11732 val = read_uleb128 (p, &len);
11734 printf (" Tag_ABI_DSBT: ");
11738 printf (_("DSBT addressing not used\n"));
11741 printf (_("DSBT addressing used\n"));
11744 printf ("??? (%d)\n", val);
11750 val = read_uleb128 (p, &len);
11752 printf (" Tag_ABI_PID: ");
11756 printf (_("Data addressing position-dependent\n"));
11759 printf (_("Data addressing position-independent, GOT near DP\n"));
11762 printf (_("Data addressing position-independent, GOT far from DP\n"));
11765 printf ("??? (%d)\n", val);
11771 val = read_uleb128 (p, &len);
11773 printf (" Tag_ABI_PIC: ");
11777 printf (_("Code addressing position-dependent\n"));
11780 printf (_("Code addressing position-independent\n"));
11783 printf ("??? (%d)\n", val);
11788 case Tag_ABI_array_object_alignment:
11789 val = read_uleb128 (p, &len);
11791 printf (" Tag_ABI_array_object_alignment: ");
11795 printf (_("8-byte\n"));
11798 printf (_("4-byte\n"));
11801 printf (_("16-byte\n"));
11804 printf ("??? (%d)\n", val);
11809 case Tag_ABI_array_object_align_expected:
11810 val = read_uleb128 (p, &len);
11812 printf (" Tag_ABI_array_object_align_expected: ");
11816 printf (_("8-byte\n"));
11819 printf (_("4-byte\n"));
11822 printf (_("16-byte\n"));
11825 printf ("??? (%d)\n", val);
11830 case Tag_ABI_compatibility:
11831 val = read_uleb128 (p, &len);
11833 printf (" Tag_ABI_compatibility: ");
11834 printf (_("flag = %d, vendor = %s\n"), val, p);
11835 p += strlen ((char *) p) + 1;
11838 case Tag_ABI_conformance:
11839 printf (" Tag_ABI_conformance: ");
11840 printf ("\"%s\"\n", p);
11841 p += strlen ((char *) p) + 1;
11845 printf (" Tag_unknown_%d: ", tag);
11849 printf ("\"%s\"\n", p);
11850 p += strlen ((char *) p) + 1;
11854 val = read_uleb128 (p, &len);
11856 printf ("%d (0x%x)\n", val, val);
11863 process_attributes (FILE * file,
11864 const char * public_name,
11865 unsigned int proc_type,
11866 unsigned char * (* display_pub_attribute) (unsigned char *),
11867 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int))
11869 Elf_Internal_Shdr * sect;
11870 unsigned char * contents;
11872 unsigned char * end;
11873 bfd_vma section_len;
11877 /* Find the section header so that we get the size. */
11878 for (i = 0, sect = section_headers;
11879 i < elf_header.e_shnum;
11882 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
11885 contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
11886 sect->sh_size, _("attributes"));
11887 if (contents == NULL)
11893 len = sect->sh_size - 1;
11899 bfd_boolean public_section;
11900 bfd_boolean gnu_section;
11902 section_len = byte_get (p, 4);
11905 if (section_len > len)
11907 printf (_("ERROR: Bad section length (%d > %d)\n"),
11908 (int) section_len, (int) len);
11912 len -= section_len;
11913 printf (_("Attribute Section: %s\n"), p);
11915 if (public_name && streq ((char *) p, public_name))
11916 public_section = TRUE;
11918 public_section = FALSE;
11920 if (streq ((char *) p, "gnu"))
11921 gnu_section = TRUE;
11923 gnu_section = FALSE;
11925 namelen = strlen ((char *) p) + 1;
11927 section_len -= namelen + 4;
11929 while (section_len > 0)
11935 size = byte_get (p, 4);
11936 if (size > section_len)
11938 printf (_("ERROR: Bad subsection length (%d > %d)\n"),
11939 (int) size, (int) section_len);
11940 size = section_len;
11943 section_len -= size;
11944 end = p + size - 1;
11950 printf (_("File Attributes\n"));
11953 printf (_("Section Attributes:"));
11956 printf (_("Symbol Attributes:"));
11962 val = read_uleb128 (p, &j);
11966 printf (" %d", val);
11971 printf (_("Unknown tag: %d\n"), tag);
11972 public_section = FALSE;
11976 if (public_section)
11979 p = display_pub_attribute (p);
11981 else if (gnu_section)
11984 p = display_gnu_attribute (p,
11985 display_proc_gnu_attribute);
11989 /* ??? Do something sensible, like dump hex. */
11990 printf (_(" Unknown section contexts\n"));
11997 printf (_("Unknown format '%c'\n"), *p);
12005 process_arm_specific (FILE * file)
12007 return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
12008 display_arm_attribute, NULL);
12012 process_power_specific (FILE * file)
12014 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
12015 display_power_gnu_attribute);
12019 process_sparc_specific (FILE * file)
12021 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
12022 display_sparc_gnu_attribute);
12026 process_tic6x_specific (FILE * file)
12028 return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
12029 display_tic6x_attribute, NULL);
12032 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
12033 Print the Address, Access and Initial fields of an entry at VMA ADDR
12034 and return the VMA of the next entry. */
12037 print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
12040 print_vma (addr, LONG_HEX);
12042 if (addr < pltgot + 0xfff0)
12043 printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
12045 printf ("%10s", "");
12048 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
12053 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
12054 print_vma (entry, LONG_HEX);
12056 return addr + (is_32bit_elf ? 4 : 8);
12059 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
12060 PLTGOT. Print the Address and Initial fields of an entry at VMA
12061 ADDR and return the VMA of the next entry. */
12064 print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
12067 print_vma (addr, LONG_HEX);
12070 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
12075 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
12076 print_vma (entry, LONG_HEX);
12078 return addr + (is_32bit_elf ? 4 : 8);
12082 process_mips_specific (FILE * file)
12084 Elf_Internal_Dyn * entry;
12085 size_t liblist_offset = 0;
12086 size_t liblistno = 0;
12087 size_t conflictsno = 0;
12088 size_t options_offset = 0;
12089 size_t conflicts_offset = 0;
12090 size_t pltrelsz = 0;
12092 bfd_vma pltgot = 0;
12093 bfd_vma mips_pltgot = 0;
12094 bfd_vma jmprel = 0;
12095 bfd_vma local_gotno = 0;
12096 bfd_vma gotsym = 0;
12097 bfd_vma symtabno = 0;
12099 process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
12100 display_mips_gnu_attribute);
12102 /* We have a lot of special sections. Thanks SGI! */
12103 if (dynamic_section == NULL)
12104 /* No information available. */
12107 for (entry = dynamic_section; entry->d_tag != DT_NULL; ++entry)
12108 switch (entry->d_tag)
12110 case DT_MIPS_LIBLIST:
12112 = offset_from_vma (file, entry->d_un.d_val,
12113 liblistno * sizeof (Elf32_External_Lib));
12115 case DT_MIPS_LIBLISTNO:
12116 liblistno = entry->d_un.d_val;
12118 case DT_MIPS_OPTIONS:
12119 options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
12121 case DT_MIPS_CONFLICT:
12123 = offset_from_vma (file, entry->d_un.d_val,
12124 conflictsno * sizeof (Elf32_External_Conflict));
12126 case DT_MIPS_CONFLICTNO:
12127 conflictsno = entry->d_un.d_val;
12130 pltgot = entry->d_un.d_ptr;
12132 case DT_MIPS_LOCAL_GOTNO:
12133 local_gotno = entry->d_un.d_val;
12135 case DT_MIPS_GOTSYM:
12136 gotsym = entry->d_un.d_val;
12138 case DT_MIPS_SYMTABNO:
12139 symtabno = entry->d_un.d_val;
12141 case DT_MIPS_PLTGOT:
12142 mips_pltgot = entry->d_un.d_ptr;
12145 pltrel = entry->d_un.d_val;
12148 pltrelsz = entry->d_un.d_val;
12151 jmprel = entry->d_un.d_ptr;
12157 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
12159 Elf32_External_Lib * elib;
12162 elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
12164 sizeof (Elf32_External_Lib),
12165 _("liblist section data"));
12168 printf (_("\nSection '.liblist' contains %lu entries:\n"),
12169 (unsigned long) liblistno);
12170 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
12173 for (cnt = 0; cnt < liblistno; ++cnt)
12180 liblist.l_name = BYTE_GET (elib[cnt].l_name);
12181 atime = BYTE_GET (elib[cnt].l_time_stamp);
12182 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
12183 liblist.l_version = BYTE_GET (elib[cnt].l_version);
12184 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
12186 tmp = gmtime (&atime);
12187 snprintf (timebuf, sizeof (timebuf),
12188 "%04u-%02u-%02uT%02u:%02u:%02u",
12189 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
12190 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
12192 printf ("%3lu: ", (unsigned long) cnt);
12193 if (VALID_DYNAMIC_NAME (liblist.l_name))
12194 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
12196 printf (_("<corrupt: %9ld>"), liblist.l_name);
12197 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
12198 liblist.l_version);
12200 if (liblist.l_flags == 0)
12204 static const struct
12211 { " EXACT_MATCH", LL_EXACT_MATCH },
12212 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
12213 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
12214 { " EXPORTS", LL_EXPORTS },
12215 { " DELAY_LOAD", LL_DELAY_LOAD },
12216 { " DELTA", LL_DELTA }
12218 int flags = liblist.l_flags;
12221 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
12222 if ((flags & l_flags_vals[fcnt].bit) != 0)
12224 fputs (l_flags_vals[fcnt].name, stdout);
12225 flags ^= l_flags_vals[fcnt].bit;
12228 printf (" %#x", (unsigned int) flags);
12238 if (options_offset != 0)
12240 Elf_External_Options * eopt;
12241 Elf_Internal_Shdr * sect = section_headers;
12242 Elf_Internal_Options * iopt;
12243 Elf_Internal_Options * option;
12247 /* Find the section header so that we get the size. */
12248 while (sect->sh_type != SHT_MIPS_OPTIONS)
12251 eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
12252 sect->sh_size, _("options"));
12255 iopt = (Elf_Internal_Options *)
12256 cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
12259 error (_("Out of memory\n"));
12266 while (offset < sect->sh_size)
12268 Elf_External_Options * eoption;
12270 eoption = (Elf_External_Options *) ((char *) eopt + offset);
12272 option->kind = BYTE_GET (eoption->kind);
12273 option->size = BYTE_GET (eoption->size);
12274 option->section = BYTE_GET (eoption->section);
12275 option->info = BYTE_GET (eoption->info);
12277 offset += option->size;
12283 printf (_("\nSection '%s' contains %d entries:\n"),
12284 SECTION_NAME (sect), cnt);
12292 switch (option->kind)
12295 /* This shouldn't happen. */
12296 printf (" NULL %d %lx", option->section, option->info);
12299 printf (" REGINFO ");
12300 if (elf_header.e_machine == EM_MIPS)
12303 Elf32_External_RegInfo * ereg;
12304 Elf32_RegInfo reginfo;
12306 ereg = (Elf32_External_RegInfo *) (option + 1);
12307 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
12308 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
12309 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
12310 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
12311 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
12312 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
12314 printf ("GPR %08lx GP 0x%lx\n",
12315 reginfo.ri_gprmask,
12316 (unsigned long) reginfo.ri_gp_value);
12317 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
12318 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
12319 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
12324 Elf64_External_RegInfo * ereg;
12325 Elf64_Internal_RegInfo reginfo;
12327 ereg = (Elf64_External_RegInfo *) (option + 1);
12328 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
12329 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
12330 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
12331 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
12332 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
12333 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
12335 printf ("GPR %08lx GP 0x",
12336 reginfo.ri_gprmask);
12337 printf_vma (reginfo.ri_gp_value);
12340 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
12341 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
12342 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
12346 case ODK_EXCEPTIONS:
12347 fputs (" EXCEPTIONS fpe_min(", stdout);
12348 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
12349 fputs (") fpe_max(", stdout);
12350 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
12351 fputs (")", stdout);
12353 if (option->info & OEX_PAGE0)
12354 fputs (" PAGE0", stdout);
12355 if (option->info & OEX_SMM)
12356 fputs (" SMM", stdout);
12357 if (option->info & OEX_FPDBUG)
12358 fputs (" FPDBUG", stdout);
12359 if (option->info & OEX_DISMISS)
12360 fputs (" DISMISS", stdout);
12363 fputs (" PAD ", stdout);
12364 if (option->info & OPAD_PREFIX)
12365 fputs (" PREFIX", stdout);
12366 if (option->info & OPAD_POSTFIX)
12367 fputs (" POSTFIX", stdout);
12368 if (option->info & OPAD_SYMBOL)
12369 fputs (" SYMBOL", stdout);
12372 fputs (" HWPATCH ", stdout);
12373 if (option->info & OHW_R4KEOP)
12374 fputs (" R4KEOP", stdout);
12375 if (option->info & OHW_R8KPFETCH)
12376 fputs (" R8KPFETCH", stdout);
12377 if (option->info & OHW_R5KEOP)
12378 fputs (" R5KEOP", stdout);
12379 if (option->info & OHW_R5KCVTL)
12380 fputs (" R5KCVTL", stdout);
12383 fputs (" FILL ", stdout);
12384 /* XXX Print content of info word? */
12387 fputs (" TAGS ", stdout);
12388 /* XXX Print content of info word? */
12391 fputs (" HWAND ", stdout);
12392 if (option->info & OHWA0_R4KEOP_CHECKED)
12393 fputs (" R4KEOP_CHECKED", stdout);
12394 if (option->info & OHWA0_R4KEOP_CLEAN)
12395 fputs (" R4KEOP_CLEAN", stdout);
12398 fputs (" HWOR ", stdout);
12399 if (option->info & OHWA0_R4KEOP_CHECKED)
12400 fputs (" R4KEOP_CHECKED", stdout);
12401 if (option->info & OHWA0_R4KEOP_CLEAN)
12402 fputs (" R4KEOP_CLEAN", stdout);
12405 printf (" GP_GROUP %#06lx self-contained %#06lx",
12406 option->info & OGP_GROUP,
12407 (option->info & OGP_SELF) >> 16);
12410 printf (" IDENT %#06lx self-contained %#06lx",
12411 option->info & OGP_GROUP,
12412 (option->info & OGP_SELF) >> 16);
12415 /* This shouldn't happen. */
12416 printf (" %3d ??? %d %lx",
12417 option->kind, option->section, option->info);
12421 len = sizeof (* eopt);
12422 while (len < option->size)
12423 if (((char *) option)[len] >= ' '
12424 && ((char *) option)[len] < 0x7f)
12425 printf ("%c", ((char *) option)[len++]);
12427 printf ("\\%03o", ((char *) option)[len++]);
12429 fputs ("\n", stdout);
12437 if (conflicts_offset != 0 && conflictsno != 0)
12439 Elf32_Conflict * iconf;
12442 if (dynamic_symbols == NULL)
12444 error (_("conflict list found without a dynamic symbol table\n"));
12448 iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
12451 error (_("Out of memory\n"));
12457 Elf32_External_Conflict * econf32;
12459 econf32 = (Elf32_External_Conflict *)
12460 get_data (NULL, file, conflicts_offset, conflictsno,
12461 sizeof (* econf32), _("conflict"));
12465 for (cnt = 0; cnt < conflictsno; ++cnt)
12466 iconf[cnt] = BYTE_GET (econf32[cnt]);
12472 Elf64_External_Conflict * econf64;
12474 econf64 = (Elf64_External_Conflict *)
12475 get_data (NULL, file, conflicts_offset, conflictsno,
12476 sizeof (* econf64), _("conflict"));
12480 for (cnt = 0; cnt < conflictsno; ++cnt)
12481 iconf[cnt] = BYTE_GET (econf64[cnt]);
12486 printf (_("\nSection '.conflict' contains %lu entries:\n"),
12487 (unsigned long) conflictsno);
12488 puts (_(" Num: Index Value Name"));
12490 for (cnt = 0; cnt < conflictsno; ++cnt)
12492 Elf_Internal_Sym * psym = & dynamic_symbols[iconf[cnt]];
12494 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
12495 print_vma (psym->st_value, FULL_HEX);
12497 if (VALID_DYNAMIC_NAME (psym->st_name))
12498 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
12500 printf (_("<corrupt: %14ld>"), psym->st_name);
12507 if (pltgot != 0 && local_gotno != 0)
12509 bfd_vma ent, local_end, global_end;
12511 unsigned char * data;
12515 addr_size = (is_32bit_elf ? 4 : 8);
12516 local_end = pltgot + local_gotno * addr_size;
12517 global_end = local_end + (symtabno - gotsym) * addr_size;
12519 offset = offset_from_vma (file, pltgot, global_end - pltgot);
12520 data = (unsigned char *) get_data (NULL, file, offset,
12521 global_end - pltgot, 1,
12522 _("Global Offset Table data"));
12526 printf (_("\nPrimary GOT:\n"));
12527 printf (_(" Canonical gp value: "));
12528 print_vma (pltgot + 0x7ff0, LONG_HEX);
12531 printf (_(" Reserved entries:\n"));
12532 printf (_(" %*s %10s %*s Purpose\n"),
12533 addr_size * 2, _("Address"), _("Access"),
12534 addr_size * 2, _("Initial"));
12535 ent = print_mips_got_entry (data, pltgot, ent);
12536 printf (_(" Lazy resolver\n"));
12538 && (byte_get (data + ent - pltgot, addr_size)
12539 >> (addr_size * 8 - 1)) != 0)
12541 ent = print_mips_got_entry (data, pltgot, ent);
12542 printf (_(" Module pointer (GNU extension)\n"));
12546 if (ent < local_end)
12548 printf (_(" Local entries:\n"));
12549 printf (" %*s %10s %*s\n",
12550 addr_size * 2, _("Address"), _("Access"),
12551 addr_size * 2, _("Initial"));
12552 while (ent < local_end)
12554 ent = print_mips_got_entry (data, pltgot, ent);
12560 if (gotsym < symtabno)
12564 printf (_(" Global entries:\n"));
12565 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
12566 addr_size * 2, _("Address"),
12568 addr_size * 2, _("Initial"),
12569 addr_size * 2, _("Sym.Val."),
12571 /* Note for translators: "Ndx" = abbreviated form of "Index". */
12572 _("Ndx"), _("Name"));
12574 sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
12575 for (i = gotsym; i < symtabno; i++)
12577 Elf_Internal_Sym * psym;
12579 psym = dynamic_symbols + i;
12580 ent = print_mips_got_entry (data, pltgot, ent);
12582 print_vma (psym->st_value, LONG_HEX);
12583 printf (" %-7s %3s ",
12584 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
12585 get_symbol_index_type (psym->st_shndx));
12586 if (VALID_DYNAMIC_NAME (psym->st_name))
12587 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
12589 printf (_("<corrupt: %14ld>"), psym->st_name);
12599 if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
12602 size_t offset, rel_offset;
12603 unsigned long count, i;
12604 unsigned char * data;
12605 int addr_size, sym_width;
12606 Elf_Internal_Rela * rels;
12608 rel_offset = offset_from_vma (file, jmprel, pltrelsz);
12609 if (pltrel == DT_RELA)
12611 if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
12616 if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
12621 addr_size = (is_32bit_elf ? 4 : 8);
12622 end = mips_pltgot + (2 + count) * addr_size;
12624 offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
12625 data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
12626 1, _("Procedure Linkage Table data"));
12630 printf ("\nPLT GOT:\n\n");
12631 printf (_(" Reserved entries:\n"));
12632 printf (_(" %*s %*s Purpose\n"),
12633 addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
12634 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
12635 printf (_(" PLT lazy resolver\n"));
12636 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
12637 printf (_(" Module pointer\n"));
12640 printf (_(" Entries:\n"));
12641 printf (" %*s %*s %*s %-7s %3s %s\n",
12642 addr_size * 2, _("Address"),
12643 addr_size * 2, _("Initial"),
12644 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
12645 sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
12646 for (i = 0; i < count; i++)
12648 Elf_Internal_Sym * psym;
12650 psym = dynamic_symbols + get_reloc_symindex (rels[i].r_info);
12651 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
12653 print_vma (psym->st_value, LONG_HEX);
12654 printf (" %-7s %3s ",
12655 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
12656 get_symbol_index_type (psym->st_shndx));
12657 if (VALID_DYNAMIC_NAME (psym->st_name))
12658 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
12660 printf (_("<corrupt: %14ld>"), psym->st_name);
12674 process_gnu_liblist (FILE * file)
12676 Elf_Internal_Shdr * section;
12677 Elf_Internal_Shdr * string_sec;
12678 Elf32_External_Lib * elib;
12680 size_t strtab_size;
12687 for (i = 0, section = section_headers;
12688 i < elf_header.e_shnum;
12691 switch (section->sh_type)
12693 case SHT_GNU_LIBLIST:
12694 if (section->sh_link >= elf_header.e_shnum)
12697 elib = (Elf32_External_Lib *)
12698 get_data (NULL, file, section->sh_offset, 1, section->sh_size,
12699 _("liblist section data"));
12703 string_sec = section_headers + section->sh_link;
12705 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
12706 string_sec->sh_size,
12707 _("liblist string table"));
12709 || section->sh_entsize != sizeof (Elf32_External_Lib))
12715 strtab_size = string_sec->sh_size;
12717 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
12718 SECTION_NAME (section),
12719 (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
12721 puts (_(" Library Time Stamp Checksum Version Flags"));
12723 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
12731 liblist.l_name = BYTE_GET (elib[cnt].l_name);
12732 atime = BYTE_GET (elib[cnt].l_time_stamp);
12733 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
12734 liblist.l_version = BYTE_GET (elib[cnt].l_version);
12735 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
12737 tmp = gmtime (&atime);
12738 snprintf (timebuf, sizeof (timebuf),
12739 "%04u-%02u-%02uT%02u:%02u:%02u",
12740 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
12741 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
12743 printf ("%3lu: ", (unsigned long) cnt);
12745 printf ("%-20s", liblist.l_name < strtab_size
12746 ? strtab + liblist.l_name : _("<corrupt>"));
12748 printf ("%-20.20s", liblist.l_name < strtab_size
12749 ? strtab + liblist.l_name : _("<corrupt>"));
12750 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
12751 liblist.l_version, liblist.l_flags);
12762 static const char *
12763 get_note_type (unsigned e_type)
12765 static char buff[64];
12767 if (elf_header.e_type == ET_CORE)
12771 return _("NT_AUXV (auxiliary vector)");
12773 return _("NT_PRSTATUS (prstatus structure)");
12775 return _("NT_FPREGSET (floating point registers)");
12777 return _("NT_PRPSINFO (prpsinfo structure)");
12778 case NT_TASKSTRUCT:
12779 return _("NT_TASKSTRUCT (task structure)");
12781 return _("NT_PRXFPREG (user_xfpregs structure)");
12783 return _("NT_PPC_VMX (ppc Altivec registers)");
12785 return _("NT_PPC_VSX (ppc VSX registers)");
12787 return _("NT_386_TLS (x86 TLS information)");
12788 case NT_386_IOPERM:
12789 return _("NT_386_IOPERM (x86 I/O permissions)");
12790 case NT_X86_XSTATE:
12791 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
12792 case NT_S390_HIGH_GPRS:
12793 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
12794 case NT_S390_TIMER:
12795 return _("NT_S390_TIMER (s390 timer register)");
12796 case NT_S390_TODCMP:
12797 return _("NT_S390_TODCMP (s390 TOD comparator register)");
12798 case NT_S390_TODPREG:
12799 return _("NT_S390_TODPREG (s390 TOD programmable register)");
12801 return _("NT_S390_CTRS (s390 control registers)");
12802 case NT_S390_PREFIX:
12803 return _("NT_S390_PREFIX (s390 prefix register)");
12805 return _("NT_ARM_VFP (arm VFP registers)");
12807 return _("NT_ARM_TLS (AArch TLS registers)");
12808 case NT_ARM_HW_BREAK:
12809 return _("NT_ARM_HW_BREAK (AArch hardware breakpoint registers)");
12810 case NT_ARM_HW_WATCH:
12811 return _("NT_ARM_HW_WATCH (AArch hardware watchpoint registers)");
12813 return _("NT_PSTATUS (pstatus structure)");
12815 return _("NT_FPREGS (floating point registers)");
12817 return _("NT_PSINFO (psinfo structure)");
12819 return _("NT_LWPSTATUS (lwpstatus_t structure)");
12821 return _("NT_LWPSINFO (lwpsinfo_t structure)");
12822 case NT_WIN32PSTATUS:
12823 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
12825 return _("NT_SIGINFO (siginfo_t data)");
12827 return _("NT_FILE (mapped files)");
12835 return _("NT_VERSION (version)");
12837 return _("NT_ARCH (architecture)");
12842 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
12847 print_core_note (Elf_Internal_Note *pnote)
12849 unsigned int addr_size = is_32bit_elf ? 4 : 8;
12850 bfd_vma count, page_size;
12851 unsigned char *descdata, *filenames, *descend;
12853 if (pnote->type != NT_FILE)
12859 printf (_(" Cannot decode 64-bit note in 32-bit build\n"));
12860 /* Still "successful". */
12865 if (pnote->descsz < 2 * addr_size)
12867 printf (_(" Malformed note - too short for header\n"));
12871 descdata = (unsigned char *) pnote->descdata;
12872 descend = descdata + pnote->descsz;
12874 if (descdata[pnote->descsz - 1] != '\0')
12876 printf (_(" Malformed note - does not end with \\0\n"));
12880 count = byte_get (descdata, addr_size);
12881 descdata += addr_size;
12883 page_size = byte_get (descdata, addr_size);
12884 descdata += addr_size;
12886 if (pnote->descsz < 2 * addr_size + count * 3 * addr_size)
12888 printf (_(" Malformed note - too short for supplied file count\n"));
12892 printf (_(" Page size: "));
12893 print_vma (page_size, DEC);
12896 printf (_(" %*s%*s%*s\n"),
12897 (int) (2 + 2 * addr_size), _("Start"),
12898 (int) (4 + 2 * addr_size), _("End"),
12899 (int) (4 + 2 * addr_size), _("Page Offset"));
12900 filenames = descdata + count * 3 * addr_size;
12901 while (--count > 0)
12903 bfd_vma start, end, file_ofs;
12905 if (filenames == descend)
12907 printf (_(" Malformed note - filenames end too early\n"));
12911 start = byte_get (descdata, addr_size);
12912 descdata += addr_size;
12913 end = byte_get (descdata, addr_size);
12914 descdata += addr_size;
12915 file_ofs = byte_get (descdata, addr_size);
12916 descdata += addr_size;
12919 print_vma (start, FULL_HEX);
12921 print_vma (end, FULL_HEX);
12923 print_vma (file_ofs, FULL_HEX);
12924 printf ("\n %s\n", filenames);
12926 filenames += 1 + strlen ((char *) filenames);
12932 static const char *
12933 get_gnu_elf_note_type (unsigned e_type)
12935 static char buff[64];
12939 case NT_GNU_ABI_TAG:
12940 return _("NT_GNU_ABI_TAG (ABI version tag)");
12942 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
12943 case NT_GNU_BUILD_ID:
12944 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
12945 case NT_GNU_GOLD_VERSION:
12946 return _("NT_GNU_GOLD_VERSION (gold version)");
12951 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
12956 print_gnu_note (Elf_Internal_Note *pnote)
12958 switch (pnote->type)
12960 case NT_GNU_BUILD_ID:
12964 printf (_(" Build ID: "));
12965 for (i = 0; i < pnote->descsz; ++i)
12966 printf ("%02x", pnote->descdata[i] & 0xff);
12971 case NT_GNU_ABI_TAG:
12973 unsigned long os, major, minor, subminor;
12974 const char *osname;
12976 os = byte_get ((unsigned char *) pnote->descdata, 4);
12977 major = byte_get ((unsigned char *) pnote->descdata + 4, 4);
12978 minor = byte_get ((unsigned char *) pnote->descdata + 8, 4);
12979 subminor = byte_get ((unsigned char *) pnote->descdata + 12, 4);
12983 case GNU_ABI_TAG_LINUX:
12986 case GNU_ABI_TAG_HURD:
12989 case GNU_ABI_TAG_SOLARIS:
12990 osname = "Solaris";
12992 case GNU_ABI_TAG_FREEBSD:
12993 osname = "FreeBSD";
12995 case GNU_ABI_TAG_NETBSD:
12999 osname = "Unknown";
13003 printf (_(" OS: %s, ABI: %ld.%ld.%ld\n"), osname,
13004 major, minor, subminor);
13012 static const char *
13013 get_netbsd_elfcore_note_type (unsigned e_type)
13015 static char buff[64];
13017 if (e_type == NT_NETBSDCORE_PROCINFO)
13019 /* NetBSD core "procinfo" structure. */
13020 return _("NetBSD procinfo structure");
13023 /* As of Jan 2002 there are no other machine-independent notes
13024 defined for NetBSD core files. If the note type is less
13025 than the start of the machine-dependent note types, we don't
13028 if (e_type < NT_NETBSDCORE_FIRSTMACH)
13030 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
13034 switch (elf_header.e_machine)
13036 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
13037 and PT_GETFPREGS == mach+2. */
13042 case EM_SPARC32PLUS:
13046 case NT_NETBSDCORE_FIRSTMACH + 0:
13047 return _("PT_GETREGS (reg structure)");
13048 case NT_NETBSDCORE_FIRSTMACH + 2:
13049 return _("PT_GETFPREGS (fpreg structure)");
13055 /* On all other arch's, PT_GETREGS == mach+1 and
13056 PT_GETFPREGS == mach+3. */
13060 case NT_NETBSDCORE_FIRSTMACH + 1:
13061 return _("PT_GETREGS (reg structure)");
13062 case NT_NETBSDCORE_FIRSTMACH + 3:
13063 return _("PT_GETFPREGS (fpreg structure)");
13069 snprintf (buff, sizeof (buff), "PT_FIRSTMACH+%d",
13070 e_type - NT_NETBSDCORE_FIRSTMACH);
13074 static const char *
13075 get_stapsdt_note_type (unsigned e_type)
13077 static char buff[64];
13082 return _("NT_STAPSDT (SystemTap probe descriptors)");
13088 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
13093 print_stapsdt_note (Elf_Internal_Note *pnote)
13095 int addr_size = is_32bit_elf ? 4 : 8;
13096 char *data = pnote->descdata;
13097 char *data_end = pnote->descdata + pnote->descsz;
13098 bfd_vma pc, base_addr, semaphore;
13099 char *provider, *probe, *arg_fmt;
13101 pc = byte_get ((unsigned char *) data, addr_size);
13103 base_addr = byte_get ((unsigned char *) data, addr_size);
13105 semaphore = byte_get ((unsigned char *) data, addr_size);
13109 data += strlen (data) + 1;
13111 data += strlen (data) + 1;
13113 data += strlen (data) + 1;
13115 printf (_(" Provider: %s\n"), provider);
13116 printf (_(" Name: %s\n"), probe);
13117 printf (_(" Location: "));
13118 print_vma (pc, FULL_HEX);
13119 printf (_(", Base: "));
13120 print_vma (base_addr, FULL_HEX);
13121 printf (_(", Semaphore: "));
13122 print_vma (semaphore, FULL_HEX);
13124 printf (_(" Arguments: %s\n"), arg_fmt);
13126 return data == data_end;
13129 static const char *
13130 get_ia64_vms_note_type (unsigned e_type)
13132 static char buff[64];
13137 return _("NT_VMS_MHD (module header)");
13139 return _("NT_VMS_LNM (language name)");
13141 return _("NT_VMS_SRC (source files)");
13143 return "NT_VMS_TITLE";
13145 return _("NT_VMS_EIDC (consistency check)");
13146 case NT_VMS_FPMODE:
13147 return _("NT_VMS_FPMODE (FP mode)");
13148 case NT_VMS_LINKTIME:
13149 return "NT_VMS_LINKTIME";
13150 case NT_VMS_IMGNAM:
13151 return _("NT_VMS_IMGNAM (image name)");
13153 return _("NT_VMS_IMGID (image id)");
13154 case NT_VMS_LINKID:
13155 return _("NT_VMS_LINKID (link id)");
13156 case NT_VMS_IMGBID:
13157 return _("NT_VMS_IMGBID (build id)");
13158 case NT_VMS_GSTNAM:
13159 return _("NT_VMS_GSTNAM (sym table name)");
13160 case NT_VMS_ORIG_DYN:
13161 return "NT_VMS_ORIG_DYN";
13162 case NT_VMS_PATCHTIME:
13163 return "NT_VMS_PATCHTIME";
13165 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
13171 print_ia64_vms_note (Elf_Internal_Note * pnote)
13173 switch (pnote->type)
13176 if (pnote->descsz > 36)
13178 size_t l = strlen (pnote->descdata + 34);
13179 printf (_(" Creation date : %.17s\n"), pnote->descdata);
13180 printf (_(" Last patch date: %.17s\n"), pnote->descdata + 17);
13181 printf (_(" Module name : %s\n"), pnote->descdata + 34);
13182 printf (_(" Module version : %s\n"), pnote->descdata + 34 + l + 1);
13185 printf (_(" Invalid size\n"));
13188 printf (_(" Language: %s\n"), pnote->descdata);
13191 case NT_VMS_FPMODE:
13192 printf (_(" Floating Point mode: "));
13193 printf ("0x%016" BFD_VMA_FMT "x\n",
13194 (bfd_vma)byte_get ((unsigned char *)pnote->descdata, 8));
13196 case NT_VMS_LINKTIME:
13197 printf (_(" Link time: "));
13199 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
13202 case NT_VMS_PATCHTIME:
13203 printf (_(" Patch time: "));
13205 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata, 8));
13208 case NT_VMS_ORIG_DYN:
13209 printf (_(" Major id: %u, minor id: %u\n"),
13210 (unsigned) byte_get ((unsigned char *)pnote->descdata, 4),
13211 (unsigned) byte_get ((unsigned char *)pnote->descdata + 4, 4));
13212 printf (_(" Last modified : "));
13214 ((bfd_int64_t) byte_get ((unsigned char *)pnote->descdata + 8, 8));
13215 printf (_("\n Link flags : "));
13216 printf ("0x%016" BFD_VMA_FMT "x\n",
13217 (bfd_vma)byte_get ((unsigned char *)pnote->descdata + 16, 8));
13218 printf (_(" Header flags: 0x%08x\n"),
13219 (unsigned)byte_get ((unsigned char *)pnote->descdata + 24, 4));
13220 printf (_(" Image id : %s\n"), pnote->descdata + 32);
13223 case NT_VMS_IMGNAM:
13224 printf (_(" Image name: %s\n"), pnote->descdata);
13226 case NT_VMS_GSTNAM:
13227 printf (_(" Global symbol table name: %s\n"), pnote->descdata);
13230 printf (_(" Image id: %s\n"), pnote->descdata);
13232 case NT_VMS_LINKID:
13233 printf (_(" Linker id: %s\n"), pnote->descdata);
13241 /* Note that by the ELF standard, the name field is already null byte
13242 terminated, and namesz includes the terminating null byte.
13243 I.E. the value of namesz for the name "FSF" is 4.
13245 If the value of namesz is zero, there is no name present. */
13247 process_note (Elf_Internal_Note * pnote)
13249 const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
13252 if (pnote->namesz == 0)
13253 /* If there is no note name, then use the default set of
13254 note type strings. */
13255 nt = get_note_type (pnote->type);
13257 else if (const_strneq (pnote->namedata, "GNU"))
13258 /* GNU-specific object file notes. */
13259 nt = get_gnu_elf_note_type (pnote->type);
13261 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
13262 /* NetBSD-specific core file notes. */
13263 nt = get_netbsd_elfcore_note_type (pnote->type);
13265 else if (strneq (pnote->namedata, "SPU/", 4))
13267 /* SPU-specific core file notes. */
13268 nt = pnote->namedata + 4;
13272 else if (const_strneq (pnote->namedata, "IPF/VMS"))
13273 /* VMS/ia64-specific file notes. */
13274 nt = get_ia64_vms_note_type (pnote->type);
13276 else if (const_strneq (pnote->namedata, "stapsdt"))
13277 nt = get_stapsdt_note_type (pnote->type);
13280 /* Don't recognize this note name; just use the default set of
13281 note type strings. */
13282 nt = get_note_type (pnote->type);
13284 printf (" %-20s 0x%08lx\t%s\n", name, pnote->descsz, nt);
13286 if (const_strneq (pnote->namedata, "IPF/VMS"))
13287 return print_ia64_vms_note (pnote);
13288 else if (const_strneq (pnote->namedata, "GNU"))
13289 return print_gnu_note (pnote);
13290 else if (const_strneq (pnote->namedata, "stapsdt"))
13291 return print_stapsdt_note (pnote);
13292 else if (const_strneq (pnote->namedata, "CORE"))
13293 return print_core_note (pnote);
13300 process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
13302 Elf_External_Note * pnotes;
13303 Elf_External_Note * external;
13309 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
13311 if (pnotes == NULL)
13316 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
13317 (unsigned long) offset, (unsigned long) length);
13318 printf (_(" %-20s %10s\tDescription\n"), _("Owner"), _("Data size"));
13320 while (external < (Elf_External_Note *) ((char *) pnotes + length))
13322 Elf_External_Note * next;
13323 Elf_Internal_Note inote;
13324 char * temp = NULL;
13326 if (!is_ia64_vms ())
13328 inote.type = BYTE_GET (external->type);
13329 inote.namesz = BYTE_GET (external->namesz);
13330 inote.namedata = external->name;
13331 inote.descsz = BYTE_GET (external->descsz);
13332 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
13333 inote.descpos = offset + (inote.descdata - (char *) pnotes);
13335 next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
13339 Elf64_External_VMS_Note *vms_external;
13341 vms_external = (Elf64_External_VMS_Note *)external;
13342 inote.type = BYTE_GET (vms_external->type);
13343 inote.namesz = BYTE_GET (vms_external->namesz);
13344 inote.namedata = vms_external->name;
13345 inote.descsz = BYTE_GET (vms_external->descsz);
13346 inote.descdata = inote.namedata + align_power (inote.namesz, 3);
13347 inote.descpos = offset + (inote.descdata - (char *) pnotes);
13349 next = (Elf_External_Note *)
13350 (inote.descdata + align_power (inote.descsz, 3));
13353 if ( ((char *) next > ((char *) pnotes) + length)
13354 || ((char *) next < (char *) pnotes))
13356 warn (_("corrupt note found at offset %lx into core notes\n"),
13357 (unsigned long) ((char *) external - (char *) pnotes));
13358 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
13359 inote.type, inote.namesz, inote.descsz);
13365 /* Prevent out-of-bounds indexing. */
13366 if (inote.namedata + inote.namesz > (char *) pnotes + length
13367 || inote.namedata + inote.namesz < inote.namedata)
13369 warn (_("corrupt note found at offset %lx into core notes\n"),
13370 (unsigned long) ((char *) external - (char *) pnotes));
13371 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
13372 inote.type, inote.namesz, inote.descsz);
13376 /* Verify that name is null terminated. It appears that at least
13377 one version of Linux (RedHat 6.0) generates corefiles that don't
13378 comply with the ELF spec by failing to include the null byte in
13380 if (inote.namedata[inote.namesz - 1] != '\0')
13382 temp = (char *) malloc (inote.namesz + 1);
13386 error (_("Out of memory\n"));
13391 strncpy (temp, inote.namedata, inote.namesz);
13392 temp[inote.namesz] = 0;
13394 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
13395 inote.namedata = temp;
13398 res &= process_note (& inote);
13413 process_corefile_note_segments (FILE * file)
13415 Elf_Internal_Phdr * segment;
13419 if (! get_program_headers (file))
13422 for (i = 0, segment = program_headers;
13423 i < elf_header.e_phnum;
13426 if (segment->p_type == PT_NOTE)
13427 res &= process_corefile_note_segment (file,
13428 (bfd_vma) segment->p_offset,
13429 (bfd_vma) segment->p_filesz);
13436 process_note_sections (FILE * file)
13438 Elf_Internal_Shdr * section;
13442 for (i = 0, section = section_headers;
13443 i < elf_header.e_shnum && section != NULL;
13445 if (section->sh_type == SHT_NOTE)
13446 res &= process_corefile_note_segment (file,
13447 (bfd_vma) section->sh_offset,
13448 (bfd_vma) section->sh_size);
13454 process_notes (FILE * file)
13456 /* If we have not been asked to display the notes then do nothing. */
13460 if (elf_header.e_type != ET_CORE)
13461 return process_note_sections (file);
13463 /* No program headers means no NOTE segment. */
13464 if (elf_header.e_phnum > 0)
13465 return process_corefile_note_segments (file);
13467 printf (_("No note segments present in the core file.\n"));
13472 process_arch_specific (FILE * file)
13477 switch (elf_header.e_machine)
13480 return process_arm_specific (file);
13482 case EM_MIPS_RS3_LE:
13483 return process_mips_specific (file);
13486 return process_power_specific (file);
13489 case EM_SPARC32PLUS:
13491 return process_sparc_specific (file);
13494 return process_tic6x_specific (file);
13503 get_file_header (FILE * file)
13505 /* Read in the identity array. */
13506 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
13509 /* Determine how to read the rest of the header. */
13510 switch (elf_header.e_ident[EI_DATA])
13512 default: /* fall through */
13513 case ELFDATANONE: /* fall through */
13515 byte_get = byte_get_little_endian;
13516 byte_put = byte_put_little_endian;
13519 byte_get = byte_get_big_endian;
13520 byte_put = byte_put_big_endian;
13524 /* For now we only support 32 bit and 64 bit ELF files. */
13525 is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
13527 /* Read in the rest of the header. */
13530 Elf32_External_Ehdr ehdr32;
13532 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
13535 elf_header.e_type = BYTE_GET (ehdr32.e_type);
13536 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
13537 elf_header.e_version = BYTE_GET (ehdr32.e_version);
13538 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
13539 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
13540 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
13541 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
13542 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
13543 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
13544 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
13545 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
13546 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
13547 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
13551 Elf64_External_Ehdr ehdr64;
13553 /* If we have been compiled with sizeof (bfd_vma) == 4, then
13554 we will not be able to cope with the 64bit data found in
13555 64 ELF files. Detect this now and abort before we start
13556 overwriting things. */
13557 if (sizeof (bfd_vma) < 8)
13559 error (_("This instance of readelf has been built without support for a\n\
13560 64 bit data type and so it cannot read 64 bit ELF files.\n"));
13564 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
13567 elf_header.e_type = BYTE_GET (ehdr64.e_type);
13568 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
13569 elf_header.e_version = BYTE_GET (ehdr64.e_version);
13570 elf_header.e_entry = BYTE_GET (ehdr64.e_entry);
13571 elf_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
13572 elf_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
13573 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
13574 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
13575 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
13576 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
13577 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
13578 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
13579 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
13582 if (elf_header.e_shoff)
13584 /* There may be some extensions in the first section header. Don't
13585 bomb if we can't read it. */
13587 get_32bit_section_headers (file, 1);
13589 get_64bit_section_headers (file, 1);
13595 /* Process one ELF object file according to the command line options.
13596 This file may actually be stored in an archive. The file is
13597 positioned at the start of the ELF object. */
13600 process_object (char * file_name, FILE * file)
13604 if (! get_file_header (file))
13606 error (_("%s: Failed to read file header\n"), file_name);
13610 /* Initialise per file variables. */
13611 for (i = ARRAY_SIZE (version_info); i--;)
13612 version_info[i] = 0;
13614 for (i = ARRAY_SIZE (dynamic_info); i--;)
13615 dynamic_info[i] = 0;
13616 dynamic_info_DT_GNU_HASH = 0;
13618 /* Process the file. */
13620 printf (_("\nFile: %s\n"), file_name);
13622 /* Initialise the dump_sects array from the cmdline_dump_sects array.
13623 Note we do this even if cmdline_dump_sects is empty because we
13624 must make sure that the dump_sets array is zeroed out before each
13625 object file is processed. */
13626 if (num_dump_sects > num_cmdline_dump_sects)
13627 memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
13629 if (num_cmdline_dump_sects > 0)
13631 if (num_dump_sects == 0)
13632 /* A sneaky way of allocating the dump_sects array. */
13633 request_dump_bynumber (num_cmdline_dump_sects, 0);
13635 assert (num_dump_sects >= num_cmdline_dump_sects);
13636 memcpy (dump_sects, cmdline_dump_sects,
13637 num_cmdline_dump_sects * sizeof (* dump_sects));
13640 if (! process_file_header ())
13643 if (! process_section_headers (file))
13645 /* Without loaded section headers we cannot process lots of
13647 do_unwind = do_version = do_dump = do_arch = 0;
13649 if (! do_using_dynamic)
13650 do_syms = do_dyn_syms = do_reloc = 0;
13653 if (! process_section_groups (file))
13655 /* Without loaded section groups we cannot process unwind. */
13659 if (process_program_headers (file))
13660 process_dynamic_section (file);
13662 process_relocs (file);
13664 process_unwind (file);
13666 process_symbol_table (file);
13668 process_syminfo (file);
13670 process_version_sections (file);
13672 process_section_contents (file);
13674 process_notes (file);
13676 process_gnu_liblist (file);
13678 process_arch_specific (file);
13680 if (program_headers)
13682 free (program_headers);
13683 program_headers = NULL;
13686 if (section_headers)
13688 free (section_headers);
13689 section_headers = NULL;
13694 free (string_table);
13695 string_table = NULL;
13696 string_table_length = 0;
13699 if (dynamic_strings)
13701 free (dynamic_strings);
13702 dynamic_strings = NULL;
13703 dynamic_strings_length = 0;
13706 if (dynamic_symbols)
13708 free (dynamic_symbols);
13709 dynamic_symbols = NULL;
13710 num_dynamic_syms = 0;
13713 if (dynamic_syminfo)
13715 free (dynamic_syminfo);
13716 dynamic_syminfo = NULL;
13719 if (dynamic_section)
13721 free (dynamic_section);
13722 dynamic_section = NULL;
13725 if (section_headers_groups)
13727 free (section_headers_groups);
13728 section_headers_groups = NULL;
13731 if (section_groups)
13733 struct group_list * g;
13734 struct group_list * next;
13736 for (i = 0; i < group_count; i++)
13738 for (g = section_groups [i].root; g != NULL; g = next)
13745 free (section_groups);
13746 section_groups = NULL;
13749 free_debug_memory ();
13754 /* Process an ELF archive.
13755 On entry the file is positioned just after the ARMAG string. */
13758 process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
13760 struct archive_info arch;
13761 struct archive_info nested_arch;
13767 /* The ARCH structure is used to hold information about this archive. */
13768 arch.file_name = NULL;
13770 arch.index_array = NULL;
13771 arch.sym_table = NULL;
13772 arch.longnames = NULL;
13774 /* The NESTED_ARCH structure is used as a single-item cache of information
13775 about a nested archive (when members of a thin archive reside within
13776 another regular archive file). */
13777 nested_arch.file_name = NULL;
13778 nested_arch.file = NULL;
13779 nested_arch.index_array = NULL;
13780 nested_arch.sym_table = NULL;
13781 nested_arch.longnames = NULL;
13783 if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
13789 if (do_archive_index)
13791 if (arch.sym_table == NULL)
13792 error (_("%s: unable to dump the index as none was found\n"), file_name);
13796 unsigned long current_pos;
13798 printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
13799 file_name, (long) arch.index_num, arch.sym_size);
13800 current_pos = ftell (file);
13802 for (i = l = 0; i < arch.index_num; i++)
13804 if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
13806 char * member_name;
13808 member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
13810 if (member_name != NULL)
13812 char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
13814 if (qualified_name != NULL)
13816 printf (_("Contents of binary %s at offset "), qualified_name);
13817 (void) print_vma (arch.index_array[i], PREFIX_HEX);
13819 free (qualified_name);
13824 if (l >= arch.sym_size)
13826 error (_("%s: end of the symbol table reached before the end of the index\n"),
13830 printf ("\t%s\n", arch.sym_table + l);
13831 l += strlen (arch.sym_table + l) + 1;
13834 if (arch.uses_64bit_indicies)
13839 if (l < arch.sym_size)
13840 error (_("%s: %ld bytes remain in the symbol table, but without corresponding entries in the index table\n"),
13841 file_name, arch.sym_size - l);
13843 if (fseek (file, current_pos, SEEK_SET) != 0)
13845 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
13851 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
13852 && !do_segments && !do_header && !do_dump && !do_version
13853 && !do_histogram && !do_debugging && !do_arch && !do_notes
13854 && !do_section_groups && !do_dyn_syms)
13856 ret = 0; /* Archive index only. */
13867 char * qualified_name;
13869 /* Read the next archive header. */
13870 if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
13872 error (_("%s: failed to seek to next archive header\n"), file_name);
13875 got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
13876 if (got != sizeof arch.arhdr)
13880 error (_("%s: failed to read archive header\n"), file_name);
13884 if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
13886 error (_("%s: did not find a valid archive header\n"), arch.file_name);
13891 arch.next_arhdr_offset += sizeof arch.arhdr;
13893 archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
13894 if (archive_file_size & 01)
13895 ++archive_file_size;
13897 name = get_archive_member_name (&arch, &nested_arch);
13900 error (_("%s: bad archive file name\n"), file_name);
13904 namelen = strlen (name);
13906 qualified_name = make_qualified_name (&arch, &nested_arch, name);
13907 if (qualified_name == NULL)
13909 error (_("%s: bad archive file name\n"), file_name);
13914 if (is_thin_archive && arch.nested_member_origin == 0)
13916 /* This is a proxy for an external member of a thin archive. */
13917 FILE * member_file;
13918 char * member_file_name = adjust_relative_path (file_name, name, namelen);
13919 if (member_file_name == NULL)
13925 member_file = fopen (member_file_name, "rb");
13926 if (member_file == NULL)
13928 error (_("Input file '%s' is not readable.\n"), member_file_name);
13929 free (member_file_name);
13934 archive_file_offset = arch.nested_member_origin;
13936 ret |= process_object (qualified_name, member_file);
13938 fclose (member_file);
13939 free (member_file_name);
13941 else if (is_thin_archive)
13943 /* This is a proxy for a member of a nested archive. */
13944 archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
13946 /* The nested archive file will have been opened and setup by
13947 get_archive_member_name. */
13948 if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
13950 error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
13955 ret |= process_object (qualified_name, nested_arch.file);
13959 archive_file_offset = arch.next_arhdr_offset;
13960 arch.next_arhdr_offset += archive_file_size;
13962 ret |= process_object (qualified_name, file);
13965 if (dump_sects != NULL)
13969 num_dump_sects = 0;
13972 free (qualified_name);
13976 if (nested_arch.file != NULL)
13977 fclose (nested_arch.file);
13978 release_archive (&nested_arch);
13979 release_archive (&arch);
13985 process_file (char * file_name)
13988 struct stat statbuf;
13989 char armag[SARMAG];
13992 if (stat (file_name, &statbuf) < 0)
13994 if (errno == ENOENT)
13995 error (_("'%s': No such file\n"), file_name);
13997 error (_("Could not locate '%s'. System error message: %s\n"),
13998 file_name, strerror (errno));
14002 if (! S_ISREG (statbuf.st_mode))
14004 error (_("'%s' is not an ordinary file\n"), file_name);
14008 file = fopen (file_name, "rb");
14011 error (_("Input file '%s' is not readable.\n"), file_name);
14015 if (fread (armag, SARMAG, 1, file) != 1)
14017 error (_("%s: Failed to read file's magic number\n"), file_name);
14022 if (memcmp (armag, ARMAG, SARMAG) == 0)
14023 ret = process_archive (file_name, file, FALSE);
14024 else if (memcmp (armag, ARMAGT, SARMAG) == 0)
14025 ret = process_archive (file_name, file, TRUE);
14028 if (do_archive_index)
14029 error (_("File %s is not an archive so its index cannot be displayed.\n"),
14033 archive_file_size = archive_file_offset = 0;
14034 ret = process_object (file_name, file);
14042 #ifdef SUPPORT_DISASSEMBLY
14043 /* Needed by the i386 disassembler. For extra credit, someone could
14044 fix this so that we insert symbolic addresses here, esp for GOT/PLT
14048 print_address (unsigned int addr, FILE * outfile)
14050 fprintf (outfile,"0x%8.8x", addr);
14053 /* Needed by the i386 disassembler. */
14055 db_task_printsym (unsigned int addr)
14057 print_address (addr, stderr);
14062 main (int argc, char ** argv)
14066 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
14067 setlocale (LC_MESSAGES, "");
14069 #if defined (HAVE_SETLOCALE)
14070 setlocale (LC_CTYPE, "");
14072 bindtextdomain (PACKAGE, LOCALEDIR);
14073 textdomain (PACKAGE);
14075 expandargv (&argc, &argv);
14077 parse_args (argc, argv);
14079 if (num_dump_sects > 0)
14081 /* Make a copy of the dump_sects array. */
14082 cmdline_dump_sects = (dump_type *)
14083 malloc (num_dump_sects * sizeof (* dump_sects));
14084 if (cmdline_dump_sects == NULL)
14085 error (_("Out of memory allocating dump request table.\n"));
14088 memcpy (cmdline_dump_sects, dump_sects,
14089 num_dump_sects * sizeof (* dump_sects));
14090 num_cmdline_dump_sects = num_dump_sects;
14094 if (optind < (argc - 1))
14098 while (optind < argc)
14099 err |= process_file (argv[optind++]);
14101 if (dump_sects != NULL)
14103 if (cmdline_dump_sects != NULL)
14104 free (cmdline_dump_sects);