1 /* readelf.c -- display contents of an ELF format file
2 Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
3 Free Software Foundation, Inc.
5 Originally developed by Eric Youngdale <eric@andante.jic.com>
6 Modifications by Nick Clifton <nickc@redhat.com>
8 This file is part of GNU Binutils.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
25 /* The difference between readelf and objdump:
27 Both programs are capable of displaying the contents of ELF format files,
28 so why does the binutils project have two file dumpers ?
30 The reason is that objdump sees an ELF file through a BFD filter of the
31 world; if BFD has a bug where, say, it disagrees about a machine constant
32 in e_flags, then the odds are good that it will remain internally
33 consistent. The linker sees it the BFD way, objdump sees it the BFD way,
34 GAS sees it the BFD way. There was need for a tool to go find out what
35 the file actually says.
37 This is why the readelf program does not link against the BFD library - it
38 exists as an independent program to help verify the correct working of BFD.
40 There is also the case that readelf can provide more information about an
41 ELF file than is provided by objdump. In particular it can display DWARF
42 debugging information which (at the moment) objdump cannot. */
56 # ifdef HAVE_SYS_PARAM_H
57 # include <sys/param.h>
61 # define PATH_MAX MAXPATHLEN
63 # define PATH_MAX 1024
69 /* Define BFD64 here, even if our default architecture is 32 bit ELF
70 as this will allow us to read in and parse 64bit and 32bit ELF files.
71 Only do this if we believe that the compiler can support a 64 bit
72 data type. For now we only rely on GCC being able to do this. */
80 #include "elf/common.h"
81 #include "elf/external.h"
82 #include "elf/internal.h"
85 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
86 we can obtain the H8 reloc numbers. We need these for the
87 get_reloc_size() function. We include h8.h again after defining
88 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
93 /* Undo the effects of #including reloc-macros.h. */
95 #undef START_RELOC_NUMBERS
99 #undef END_RELOC_NUMBERS
100 #undef _RELOC_MACROS_H
102 /* The following headers use the elf/reloc-macros.h file to
103 automatically generate relocation recognition functions
104 such as elf_mips_reloc_type() */
106 #define RELOC_MACROS_GEN_FUNC
108 #include "elf/alpha.h"
112 #include "elf/bfin.h"
113 #include "elf/cr16.h"
114 #include "elf/cris.h"
116 #include "elf/d10v.h"
117 #include "elf/d30v.h"
119 #include "elf/fr30.h"
122 #include "elf/hppa.h"
123 #include "elf/i386.h"
124 #include "elf/i370.h"
125 #include "elf/i860.h"
126 #include "elf/i960.h"
127 #include "elf/ia64.h"
128 #include "elf/ip2k.h"
129 #include "elf/iq2000.h"
130 #include "elf/m32c.h"
131 #include "elf/m32r.h"
132 #include "elf/m68k.h"
133 #include "elf/m68hc11.h"
134 #include "elf/mcore.h"
136 #include "elf/mips.h"
137 #include "elf/mmix.h"
138 #include "elf/mn10200.h"
139 #include "elf/mn10300.h"
141 #include "elf/msp430.h"
142 #include "elf/or32.h"
145 #include "elf/ppc64.h"
146 #include "elf/s390.h"
147 #include "elf/score.h"
149 #include "elf/sparc.h"
151 #include "elf/v850.h"
153 #include "elf/x86-64.h"
154 #include "elf/xstormy16.h"
155 #include "elf/xtensa.h"
160 #include "libiberty.h"
161 #include "safe-ctype.h"
163 char *program_name = "readelf";
164 static long archive_file_offset;
165 static unsigned long archive_file_size;
166 static unsigned long dynamic_addr;
167 static bfd_size_type dynamic_size;
168 static unsigned int dynamic_nent;
169 static char *dynamic_strings;
170 static unsigned long dynamic_strings_length;
171 static char *string_table;
172 static unsigned long string_table_length;
173 static unsigned long num_dynamic_syms;
174 static Elf_Internal_Sym *dynamic_symbols;
175 static Elf_Internal_Syminfo *dynamic_syminfo;
176 static unsigned long dynamic_syminfo_offset;
177 static unsigned int dynamic_syminfo_nent;
178 static char program_interpreter[PATH_MAX];
179 static bfd_vma dynamic_info[DT_JMPREL + 1];
180 static bfd_vma dynamic_info_DT_GNU_HASH;
181 static bfd_vma version_info[16];
182 static Elf_Internal_Ehdr elf_header;
183 static Elf_Internal_Shdr *section_headers;
184 static Elf_Internal_Phdr *program_headers;
185 static Elf_Internal_Dyn *dynamic_section;
186 static Elf_Internal_Shdr *symtab_shndx_hdr;
187 static int show_name;
188 static int do_dynamic;
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;
201 static int do_histogram;
202 static int do_debugging;
205 static int do_archive_index;
206 static int is_32bit_elf;
210 struct group_list *next;
211 unsigned int section_index;
216 struct group_list *root;
217 unsigned int group_index;
220 static size_t group_count;
221 static struct group *section_groups;
222 static struct group **section_headers_groups;
225 /* Flag bits indicating particular types of dump. */
226 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
227 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
228 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
229 #define STRING_DUMP (1 << 3) /* The -p 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
269 static void (*byte_put) (unsigned char *, bfd_vma, int);
273 #define SECTION_NAME(X) \
274 ((X) == NULL ? "<none>" \
275 : string_table == NULL ? "<no-name>" \
276 : ((X)->sh_name >= string_table_length ? "<corrupt>" \
277 : string_table + (X)->sh_name))
279 /* Given st_shndx I, map to section_headers index. */
280 #define SECTION_HEADER_INDEX(I) \
281 ((I) < SHN_LORESERVE \
283 : ((I) <= SHN_HIRESERVE \
285 : (I) - (SHN_HIRESERVE + 1 - SHN_LORESERVE)))
287 /* Reverse of the above. */
288 #define SECTION_HEADER_NUM(N) \
289 ((N) < SHN_LORESERVE \
291 : (N) + (SHN_HIRESERVE + 1 - SHN_LORESERVE))
293 #define SECTION_HEADER(I) (section_headers + SECTION_HEADER_INDEX (I))
295 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
297 #define BYTE_GET(field) byte_get (field, sizeof (field))
299 #define GET_ELF_SYMBOLS(file, section) \
300 (is_32bit_elf ? get_32bit_elf_symbols (file, section) \
301 : get_64bit_elf_symbols (file, section))
303 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
304 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
305 already been called and verified that the string exists. */
306 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
308 /* This is just a bit of syntatic sugar. */
309 #define streq(a,b) (strcmp ((a), (b)) == 0)
310 #define strneq(a,b,n) (strncmp ((a), (b), (n)) == 0)
311 #define const_strneq(a,b) (strncmp ((a), (b), sizeof (b) - 1) == 0)
314 get_data (void *var, FILE *file, long offset, size_t size, size_t nmemb,
319 if (size == 0 || nmemb == 0)
322 if (fseek (file, archive_file_offset + offset, SEEK_SET))
324 error (_("Unable to seek to 0x%lx for %s\n"),
325 archive_file_offset + offset, reason);
332 /* Check for overflow. */
333 if (nmemb < (~(size_t) 0 - 1) / size)
334 /* + 1 so that we can '\0' terminate invalid string table sections. */
335 mvar = malloc (size * nmemb + 1);
339 error (_("Out of memory allocating 0x%lx bytes for %s\n"),
340 (unsigned long)(size * nmemb), reason);
344 ((char *) mvar)[size * nmemb] = '\0';
347 if (fread (mvar, size, nmemb, file) != nmemb)
349 error (_("Unable to read in 0x%lx bytes of %s\n"),
350 (unsigned long)(size * nmemb), reason);
360 byte_put_little_endian (unsigned char *field, bfd_vma value, int size)
365 field[7] = (((value >> 24) >> 24) >> 8) & 0xff;
366 field[6] = ((value >> 24) >> 24) & 0xff;
367 field[5] = ((value >> 24) >> 16) & 0xff;
368 field[4] = ((value >> 24) >> 8) & 0xff;
371 field[3] = (value >> 24) & 0xff;
372 field[2] = (value >> 16) & 0xff;
375 field[1] = (value >> 8) & 0xff;
378 field[0] = value & 0xff;
382 error (_("Unhandled data length: %d\n"), size);
387 #if defined BFD64 && !BFD_HOST_64BIT_LONG && !BFD_HOST_64BIT_LONG_LONG
389 print_dec_vma (bfd_vma vma, int is_signed)
395 if (is_signed && (bfd_signed_vma) vma < 0)
404 *bufp++ = '0' + vma % 10;
416 print_hex_vma (bfd_vma vma)
424 char digit = '0' + (vma & 0x0f);
426 digit += 'a' - '0' - 10;
439 /* Print a VMA value. */
441 print_vma (bfd_vma vma, print_mode mode)
450 return printf ("0x%8.8lx", (unsigned long) vma);
453 return printf ("%8.8lx", (unsigned long) vma);
457 return printf ("%5ld", (long) vma);
461 return printf ("0x%lx", (unsigned long) vma);
464 return printf ("%lx", (unsigned long) vma);
467 return printf ("%ld", (unsigned long) vma);
470 return printf ("%lu", (unsigned long) vma);
493 #if BFD_HOST_64BIT_LONG
494 return nc + printf ("%lx", vma);
495 #elif BFD_HOST_64BIT_LONG_LONG
496 return nc + printf ("%llx", vma);
498 return nc + print_hex_vma (vma);
502 #if BFD_HOST_64BIT_LONG
503 return printf ("%ld", vma);
504 #elif BFD_HOST_64BIT_LONG_LONG
505 return printf ("%lld", vma);
507 return print_dec_vma (vma, 1);
511 #if BFD_HOST_64BIT_LONG
513 return printf ("%5ld", vma);
515 return printf ("%#lx", vma);
516 #elif BFD_HOST_64BIT_LONG_LONG
518 return printf ("%5lld", vma);
520 return printf ("%#llx", vma);
523 return printf ("%5ld", _bfd_int64_low (vma));
525 return print_hex_vma (vma);
529 #if BFD_HOST_64BIT_LONG
530 return printf ("%lu", vma);
531 #elif BFD_HOST_64BIT_LONG_LONG
532 return printf ("%llu", vma);
534 return print_dec_vma (vma, 0);
542 /* Display a symbol on stdout. If do_wide is not true then
543 format the symbol to be at most WIDTH characters,
544 truncating as necessary. If WIDTH is negative then
545 format the string to be exactly - WIDTH characters,
546 truncating or padding as necessary. */
549 print_symbol (int width, const char *symbol)
552 printf ("%s", symbol);
554 printf ("%-*.*s", width, width, symbol);
556 printf ("%-.*s", width, symbol);
560 byte_put_big_endian (unsigned char *field, bfd_vma value, int size)
565 field[7] = value & 0xff;
566 field[6] = (value >> 8) & 0xff;
567 field[5] = (value >> 16) & 0xff;
568 field[4] = (value >> 24) & 0xff;
573 field[3] = value & 0xff;
574 field[2] = (value >> 8) & 0xff;
578 field[1] = value & 0xff;
582 field[0] = value & 0xff;
586 error (_("Unhandled data length: %d\n"), size);
591 /* Return a pointer to section NAME, or NULL if no such section exists. */
593 static Elf_Internal_Shdr *
594 find_section (const char *name)
598 for (i = 0; i < elf_header.e_shnum; i++)
599 if (streq (SECTION_NAME (section_headers + i), name))
600 return section_headers + i;
605 /* Guess the relocation size commonly used by the specific machines. */
608 guess_is_rela (unsigned long e_machine)
612 /* Targets that use REL relocations. */
628 /* Targets that use RELA relocations. */
632 case EM_ALTERA_NIOS2:
657 case EM_CYGNUS_MN10200:
659 case EM_CYGNUS_MN10300:
700 warn (_("Don't know about relocations on this machine architecture\n"));
706 slurp_rela_relocs (FILE *file,
707 unsigned long rel_offset,
708 unsigned long rel_size,
709 Elf_Internal_Rela **relasp,
710 unsigned long *nrelasp)
712 Elf_Internal_Rela *relas;
713 unsigned long nrelas;
718 Elf32_External_Rela *erelas;
720 erelas = get_data (NULL, file, rel_offset, 1, rel_size, _("relocs"));
724 nrelas = rel_size / sizeof (Elf32_External_Rela);
726 relas = cmalloc (nrelas, sizeof (Elf_Internal_Rela));
731 error (_("out of memory parsing relocs\n"));
735 for (i = 0; i < nrelas; i++)
737 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
738 relas[i].r_info = BYTE_GET (erelas[i].r_info);
739 relas[i].r_addend = BYTE_GET (erelas[i].r_addend);
746 Elf64_External_Rela *erelas;
748 erelas = get_data (NULL, file, rel_offset, 1, rel_size, _("relocs"));
752 nrelas = rel_size / sizeof (Elf64_External_Rela);
754 relas = cmalloc (nrelas, sizeof (Elf_Internal_Rela));
759 error (_("out of memory parsing relocs\n"));
763 for (i = 0; i < nrelas; i++)
765 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
766 relas[i].r_info = BYTE_GET (erelas[i].r_info);
767 relas[i].r_addend = BYTE_GET (erelas[i].r_addend);
778 slurp_rel_relocs (FILE *file,
779 unsigned long rel_offset,
780 unsigned long rel_size,
781 Elf_Internal_Rela **relsp,
782 unsigned long *nrelsp)
784 Elf_Internal_Rela *rels;
790 Elf32_External_Rel *erels;
792 erels = get_data (NULL, file, rel_offset, 1, rel_size, _("relocs"));
796 nrels = rel_size / sizeof (Elf32_External_Rel);
798 rels = cmalloc (nrels, sizeof (Elf_Internal_Rela));
803 error (_("out of memory parsing relocs\n"));
807 for (i = 0; i < nrels; i++)
809 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
810 rels[i].r_info = BYTE_GET (erels[i].r_info);
811 rels[i].r_addend = 0;
818 Elf64_External_Rel *erels;
820 erels = get_data (NULL, file, rel_offset, 1, rel_size, _("relocs"));
824 nrels = rel_size / sizeof (Elf64_External_Rel);
826 rels = cmalloc (nrels, sizeof (Elf_Internal_Rela));
831 error (_("out of memory parsing relocs\n"));
835 for (i = 0; i < nrels; i++)
837 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
838 rels[i].r_info = BYTE_GET (erels[i].r_info);
839 rels[i].r_addend = 0;
849 /* Returns the reloc type extracted from the reloc info field. */
852 get_reloc_type (bfd_vma reloc_info)
855 return ELF32_R_TYPE (reloc_info);
857 switch (elf_header.e_machine)
860 /* Note: We assume that reloc_info has already been adjusted for us. */
861 return ELF64_MIPS_R_TYPE (reloc_info);
864 return ELF64_R_TYPE_ID (reloc_info);
867 return ELF64_R_TYPE (reloc_info);
871 /* Return the symbol index extracted from the reloc info field. */
874 get_reloc_symindex (bfd_vma reloc_info)
876 return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
879 /* Display the contents of the relocation data found at the specified
883 dump_relocations (FILE *file,
884 unsigned long rel_offset,
885 unsigned long rel_size,
886 Elf_Internal_Sym *symtab,
889 unsigned long strtablen,
893 Elf_Internal_Rela *rels;
896 if (is_rela == UNKNOWN)
897 is_rela = guess_is_rela (elf_header.e_machine);
901 if (!slurp_rela_relocs (file, rel_offset, rel_size, &rels, &rel_size))
906 if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
915 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
917 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
922 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
924 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
932 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
934 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
939 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
941 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
945 for (i = 0; i < rel_size; i++)
950 bfd_vma symtab_index;
953 offset = rels[i].r_offset;
954 info = rels[i].r_info;
956 /* The #ifdef BFD64 below is to prevent a compile time warning.
957 We know that if we do not have a 64 bit data type that we
958 will never execute this code anyway. */
961 && elf_header.e_machine == EM_MIPS
962 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
964 /* In little-endian objects, r_info isn't really a 64-bit
965 little-endian value: it has a 32-bit little-endian
966 symbol index followed by four individual byte fields.
967 Reorder INFO accordingly. */
968 info = (((info & 0xffffffff) << 32)
969 | ((info >> 56) & 0xff)
970 | ((info >> 40) & 0xff00)
971 | ((info >> 24) & 0xff0000)
972 | ((info >> 8) & 0xff000000));
976 type = get_reloc_type (info);
977 symtab_index = get_reloc_symindex (info);
981 printf ("%8.8lx %8.8lx ",
982 (unsigned long) offset & 0xffffffff,
983 (unsigned long) info & 0xffffffff);
987 #if BFD_HOST_64BIT_LONG
989 ? "%16.16lx %16.16lx "
990 : "%12.12lx %12.12lx ",
992 #elif BFD_HOST_64BIT_LONG_LONG
994 ? "%16.16llx %16.16llx "
995 : "%12.12llx %12.12llx ",
999 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
1000 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
1001 _bfd_int64_high (offset),
1002 _bfd_int64_low (offset),
1003 _bfd_int64_high (info),
1004 _bfd_int64_low (info));
1008 switch (elf_header.e_machine)
1015 case EM_CYGNUS_M32R:
1016 rtype = elf_m32r_reloc_type (type);
1021 rtype = elf_i386_reloc_type (type);
1026 rtype = elf_m68hc11_reloc_type (type);
1030 rtype = elf_m68k_reloc_type (type);
1034 rtype = elf_i960_reloc_type (type);
1039 rtype = elf_avr_reloc_type (type);
1042 case EM_OLD_SPARCV9:
1043 case EM_SPARC32PLUS:
1046 rtype = elf_sparc_reloc_type (type);
1050 rtype = elf_spu_reloc_type (type);
1054 case EM_CYGNUS_V850:
1055 rtype = v850_reloc_type (type);
1059 case EM_CYGNUS_D10V:
1060 rtype = elf_d10v_reloc_type (type);
1064 case EM_CYGNUS_D30V:
1065 rtype = elf_d30v_reloc_type (type);
1069 rtype = elf_dlx_reloc_type (type);
1073 rtype = elf_sh_reloc_type (type);
1077 case EM_CYGNUS_MN10300:
1078 rtype = elf_mn10300_reloc_type (type);
1082 case EM_CYGNUS_MN10200:
1083 rtype = elf_mn10200_reloc_type (type);
1087 case EM_CYGNUS_FR30:
1088 rtype = elf_fr30_reloc_type (type);
1092 rtype = elf_frv_reloc_type (type);
1096 rtype = elf_mcore_reloc_type (type);
1100 rtype = elf_mmix_reloc_type (type);
1105 rtype = elf_msp430_reloc_type (type);
1109 rtype = elf_ppc_reloc_type (type);
1113 rtype = elf_ppc64_reloc_type (type);
1117 case EM_MIPS_RS3_LE:
1118 rtype = elf_mips_reloc_type (type);
1122 rtype = elf_alpha_reloc_type (type);
1126 rtype = elf_arm_reloc_type (type);
1130 rtype = elf_arc_reloc_type (type);
1134 rtype = elf_hppa_reloc_type (type);
1140 rtype = elf_h8_reloc_type (type);
1145 rtype = elf_or32_reloc_type (type);
1150 rtype = elf_pj_reloc_type (type);
1153 rtype = elf_ia64_reloc_type (type);
1157 rtype = elf_cris_reloc_type (type);
1161 rtype = elf_i860_reloc_type (type);
1165 rtype = elf_x86_64_reloc_type (type);
1169 rtype = i370_reloc_type (type);
1174 rtype = elf_s390_reloc_type (type);
1178 rtype = elf_score_reloc_type (type);
1182 rtype = elf_xstormy16_reloc_type (type);
1186 rtype = elf_crx_reloc_type (type);
1190 rtype = elf_vax_reloc_type (type);
1195 rtype = elf_ip2k_reloc_type (type);
1199 rtype = elf_iq2000_reloc_type (type);
1204 rtype = elf_xtensa_reloc_type (type);
1208 rtype = elf_m32c_reloc_type (type);
1212 rtype = elf_mt_reloc_type (type);
1216 rtype = elf_bfin_reloc_type (type);
1220 rtype = elf_mep_reloc_type (type);
1224 rtype = elf_cr16_reloc_type (type);
1229 printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
1231 printf (do_wide ? "%-22.22s" : "%-17.17s", rtype);
1233 if (elf_header.e_machine == EM_ALPHA
1235 && streq (rtype, "R_ALPHA_LITUSE")
1238 switch (rels[i].r_addend)
1240 case LITUSE_ALPHA_ADDR: rtype = "ADDR"; break;
1241 case LITUSE_ALPHA_BASE: rtype = "BASE"; break;
1242 case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1243 case LITUSE_ALPHA_JSR: rtype = "JSR"; break;
1244 case LITUSE_ALPHA_TLSGD: rtype = "TLSGD"; break;
1245 case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1246 case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1247 default: rtype = NULL;
1250 printf (" (%s)", rtype);
1254 printf (_("<unknown addend: %lx>"),
1255 (unsigned long) rels[i].r_addend);
1258 else if (symtab_index)
1260 if (symtab == NULL || symtab_index >= nsyms)
1261 printf (" bad symbol index: %08lx", (unsigned long) symtab_index);
1264 Elf_Internal_Sym *psym;
1266 psym = symtab + symtab_index;
1269 print_vma (psym->st_value, LONG_HEX);
1270 printf (is_32bit_elf ? " " : " ");
1272 if (psym->st_name == 0)
1274 const char *sec_name = "<null>";
1277 if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1279 bfd_vma sec_index = (bfd_vma) -1;
1281 if (psym->st_shndx < SHN_LORESERVE)
1282 sec_index = psym->st_shndx;
1283 else if (psym->st_shndx > SHN_HIRESERVE)
1284 sec_index = psym->st_shndx - (SHN_HIRESERVE + 1
1287 if (sec_index != (bfd_vma) -1)
1288 sec_name = SECTION_NAME (section_headers + sec_index);
1289 else if (psym->st_shndx == SHN_ABS)
1291 else if (psym->st_shndx == SHN_COMMON)
1292 sec_name = "COMMON";
1293 else if (elf_header.e_machine == EM_MIPS
1294 && psym->st_shndx == SHN_MIPS_SCOMMON)
1295 sec_name = "SCOMMON";
1296 else if (elf_header.e_machine == EM_MIPS
1297 && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1298 sec_name = "SUNDEF";
1299 else if (elf_header.e_machine == EM_X86_64
1300 && psym->st_shndx == SHN_X86_64_LCOMMON)
1301 sec_name = "LARGE_COMMON";
1302 else if (elf_header.e_machine == EM_IA_64
1303 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1304 && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1305 sec_name = "ANSI_COM";
1308 sprintf (name_buf, "<section 0x%x>",
1309 (unsigned int) psym->st_shndx);
1310 sec_name = name_buf;
1313 print_symbol (22, sec_name);
1315 else if (strtab == NULL)
1316 printf (_("<string table index: %3ld>"), psym->st_name);
1317 else if (psym->st_name >= strtablen)
1318 printf (_("<corrupt string table index: %3ld>"), psym->st_name);
1320 print_symbol (22, strtab + psym->st_name);
1323 printf (" + %lx", (unsigned long) rels[i].r_addend);
1328 printf ("%*c", is_32bit_elf ?
1329 (do_wide ? 34 : 28) : (do_wide ? 26 : 20), ' ');
1330 print_vma (rels[i].r_addend, LONG_HEX);
1333 if (elf_header.e_machine == EM_SPARCV9
1335 && streq (rtype, "R_SPARC_OLO10"))
1336 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (info));
1341 if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
1343 bfd_vma type2 = ELF64_MIPS_R_TYPE2 (info);
1344 bfd_vma type3 = ELF64_MIPS_R_TYPE3 (info);
1345 const char *rtype2 = elf_mips_reloc_type (type2);
1346 const char *rtype3 = elf_mips_reloc_type (type3);
1348 printf (" Type2: ");
1351 printf (_("unrecognized: %-7lx"),
1352 (unsigned long) type2 & 0xffffffff);
1354 printf ("%-17.17s", rtype2);
1356 printf ("\n Type3: ");
1359 printf (_("unrecognized: %-7lx"),
1360 (unsigned long) type3 & 0xffffffff);
1362 printf ("%-17.17s", rtype3);
1375 get_mips_dynamic_type (unsigned long type)
1379 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1380 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1381 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1382 case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1383 case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1384 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1385 case DT_MIPS_MSYM: return "MIPS_MSYM";
1386 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1387 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1388 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1389 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1390 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1391 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1392 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1393 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1394 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1395 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1396 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1397 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1398 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1399 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1400 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1401 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1402 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1403 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1404 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1405 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1406 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1407 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1408 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1409 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1410 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1411 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1412 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1413 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1414 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1415 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1416 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1417 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1418 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1419 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1420 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1421 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
1428 get_sparc64_dynamic_type (unsigned long type)
1432 case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1439 get_ppc_dynamic_type (unsigned long type)
1443 case DT_PPC_GOT: return "PPC_GOT";
1450 get_ppc64_dynamic_type (unsigned long type)
1454 case DT_PPC64_GLINK: return "PPC64_GLINK";
1455 case DT_PPC64_OPD: return "PPC64_OPD";
1456 case DT_PPC64_OPDSZ: return "PPC64_OPDSZ";
1463 get_parisc_dynamic_type (unsigned long type)
1467 case DT_HP_LOAD_MAP: return "HP_LOAD_MAP";
1468 case DT_HP_DLD_FLAGS: return "HP_DLD_FLAGS";
1469 case DT_HP_DLD_HOOK: return "HP_DLD_HOOK";
1470 case DT_HP_UX10_INIT: return "HP_UX10_INIT";
1471 case DT_HP_UX10_INITSZ: return "HP_UX10_INITSZ";
1472 case DT_HP_PREINIT: return "HP_PREINIT";
1473 case DT_HP_PREINITSZ: return "HP_PREINITSZ";
1474 case DT_HP_NEEDED: return "HP_NEEDED";
1475 case DT_HP_TIME_STAMP: return "HP_TIME_STAMP";
1476 case DT_HP_CHECKSUM: return "HP_CHECKSUM";
1477 case DT_HP_GST_SIZE: return "HP_GST_SIZE";
1478 case DT_HP_GST_VERSION: return "HP_GST_VERSION";
1479 case DT_HP_GST_HASHVAL: return "HP_GST_HASHVAL";
1480 case DT_HP_EPLTREL: return "HP_GST_EPLTREL";
1481 case DT_HP_EPLTRELSZ: return "HP_GST_EPLTRELSZ";
1482 case DT_HP_FILTERED: return "HP_FILTERED";
1483 case DT_HP_FILTER_TLS: return "HP_FILTER_TLS";
1484 case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1485 case DT_HP_LAZYLOAD: return "HP_LAZYLOAD";
1486 case DT_HP_BIND_NOW_COUNT: return "HP_BIND_NOW_COUNT";
1487 case DT_PLT: return "PLT";
1488 case DT_PLT_SIZE: return "PLT_SIZE";
1489 case DT_DLT: return "DLT";
1490 case DT_DLT_SIZE: return "DLT_SIZE";
1497 get_ia64_dynamic_type (unsigned long type)
1501 case DT_IA_64_PLT_RESERVE: return "IA_64_PLT_RESERVE";
1508 get_alpha_dynamic_type (unsigned long type)
1512 case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
1519 get_score_dynamic_type (unsigned long type)
1523 case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
1524 case DT_SCORE_LOCAL_GOTNO: return "SCORE_LOCAL_GOTNO";
1525 case DT_SCORE_SYMTABNO: return "SCORE_SYMTABNO";
1526 case DT_SCORE_GOTSYM: return "SCORE_GOTSYM";
1527 case DT_SCORE_UNREFEXTNO: return "SCORE_UNREFEXTNO";
1528 case DT_SCORE_HIPAGENO: return "SCORE_HIPAGENO";
1536 get_dynamic_type (unsigned long type)
1538 static char buff[64];
1542 case DT_NULL: return "NULL";
1543 case DT_NEEDED: return "NEEDED";
1544 case DT_PLTRELSZ: return "PLTRELSZ";
1545 case DT_PLTGOT: return "PLTGOT";
1546 case DT_HASH: return "HASH";
1547 case DT_STRTAB: return "STRTAB";
1548 case DT_SYMTAB: return "SYMTAB";
1549 case DT_RELA: return "RELA";
1550 case DT_RELASZ: return "RELASZ";
1551 case DT_RELAENT: return "RELAENT";
1552 case DT_STRSZ: return "STRSZ";
1553 case DT_SYMENT: return "SYMENT";
1554 case DT_INIT: return "INIT";
1555 case DT_FINI: return "FINI";
1556 case DT_SONAME: return "SONAME";
1557 case DT_RPATH: return "RPATH";
1558 case DT_SYMBOLIC: return "SYMBOLIC";
1559 case DT_REL: return "REL";
1560 case DT_RELSZ: return "RELSZ";
1561 case DT_RELENT: return "RELENT";
1562 case DT_PLTREL: return "PLTREL";
1563 case DT_DEBUG: return "DEBUG";
1564 case DT_TEXTREL: return "TEXTREL";
1565 case DT_JMPREL: return "JMPREL";
1566 case DT_BIND_NOW: return "BIND_NOW";
1567 case DT_INIT_ARRAY: return "INIT_ARRAY";
1568 case DT_FINI_ARRAY: return "FINI_ARRAY";
1569 case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
1570 case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
1571 case DT_RUNPATH: return "RUNPATH";
1572 case DT_FLAGS: return "FLAGS";
1574 case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1575 case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
1577 case DT_CHECKSUM: return "CHECKSUM";
1578 case DT_PLTPADSZ: return "PLTPADSZ";
1579 case DT_MOVEENT: return "MOVEENT";
1580 case DT_MOVESZ: return "MOVESZ";
1581 case DT_FEATURE: return "FEATURE";
1582 case DT_POSFLAG_1: return "POSFLAG_1";
1583 case DT_SYMINSZ: return "SYMINSZ";
1584 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
1586 case DT_ADDRRNGLO: return "ADDRRNGLO";
1587 case DT_CONFIG: return "CONFIG";
1588 case DT_DEPAUDIT: return "DEPAUDIT";
1589 case DT_AUDIT: return "AUDIT";
1590 case DT_PLTPAD: return "PLTPAD";
1591 case DT_MOVETAB: return "MOVETAB";
1592 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
1594 case DT_VERSYM: return "VERSYM";
1596 case DT_TLSDESC_GOT: return "TLSDESC_GOT";
1597 case DT_TLSDESC_PLT: return "TLSDESC_PLT";
1598 case DT_RELACOUNT: return "RELACOUNT";
1599 case DT_RELCOUNT: return "RELCOUNT";
1600 case DT_FLAGS_1: return "FLAGS_1";
1601 case DT_VERDEF: return "VERDEF";
1602 case DT_VERDEFNUM: return "VERDEFNUM";
1603 case DT_VERNEED: return "VERNEED";
1604 case DT_VERNEEDNUM: return "VERNEEDNUM";
1606 case DT_AUXILIARY: return "AUXILIARY";
1607 case DT_USED: return "USED";
1608 case DT_FILTER: return "FILTER";
1610 case DT_GNU_PRELINKED: return "GNU_PRELINKED";
1611 case DT_GNU_CONFLICT: return "GNU_CONFLICT";
1612 case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
1613 case DT_GNU_LIBLIST: return "GNU_LIBLIST";
1614 case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
1615 case DT_GNU_HASH: return "GNU_HASH";
1618 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1622 switch (elf_header.e_machine)
1625 case EM_MIPS_RS3_LE:
1626 result = get_mips_dynamic_type (type);
1629 result = get_sparc64_dynamic_type (type);
1632 result = get_ppc_dynamic_type (type);
1635 result = get_ppc64_dynamic_type (type);
1638 result = get_ia64_dynamic_type (type);
1641 result = get_alpha_dynamic_type (type);
1644 result = get_score_dynamic_type (type);
1654 snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
1656 else if (((type >= DT_LOOS) && (type <= DT_HIOS))
1657 || (elf_header.e_machine == EM_PARISC
1658 && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
1662 switch (elf_header.e_machine)
1665 result = get_parisc_dynamic_type (type);
1675 snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
1679 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
1686 get_file_type (unsigned e_type)
1688 static char buff[32];
1692 case ET_NONE: return _("NONE (None)");
1693 case ET_REL: return _("REL (Relocatable file)");
1694 case ET_EXEC: return _("EXEC (Executable file)");
1695 case ET_DYN: return _("DYN (Shared object file)");
1696 case ET_CORE: return _("CORE (Core file)");
1699 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
1700 snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
1701 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
1702 snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
1704 snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
1710 get_machine_name (unsigned e_machine)
1712 static char buff[64]; /* XXX */
1716 case EM_NONE: return _("None");
1717 case EM_M32: return "WE32100";
1718 case EM_SPARC: return "Sparc";
1719 case EM_SPU: return "SPU";
1720 case EM_386: return "Intel 80386";
1721 case EM_68K: return "MC68000";
1722 case EM_88K: return "MC88000";
1723 case EM_486: return "Intel 80486";
1724 case EM_860: return "Intel 80860";
1725 case EM_MIPS: return "MIPS R3000";
1726 case EM_S370: return "IBM System/370";
1727 case EM_MIPS_RS3_LE: return "MIPS R4000 big-endian";
1728 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
1729 case EM_PARISC: return "HPPA";
1730 case EM_PPC_OLD: return "Power PC (old)";
1731 case EM_SPARC32PLUS: return "Sparc v8+" ;
1732 case EM_960: return "Intel 90860";
1733 case EM_PPC: return "PowerPC";
1734 case EM_PPC64: return "PowerPC64";
1735 case EM_V800: return "NEC V800";
1736 case EM_FR20: return "Fujitsu FR20";
1737 case EM_RH32: return "TRW RH32";
1738 case EM_MCORE: return "MCORE";
1739 case EM_ARM: return "ARM";
1740 case EM_OLD_ALPHA: return "Digital Alpha (old)";
1741 case EM_SH: return "Renesas / SuperH SH";
1742 case EM_SPARCV9: return "Sparc v9";
1743 case EM_TRICORE: return "Siemens Tricore";
1744 case EM_ARC: return "ARC";
1745 case EM_H8_300: return "Renesas H8/300";
1746 case EM_H8_300H: return "Renesas H8/300H";
1747 case EM_H8S: return "Renesas H8S";
1748 case EM_H8_500: return "Renesas H8/500";
1749 case EM_IA_64: return "Intel IA-64";
1750 case EM_MIPS_X: return "Stanford MIPS-X";
1751 case EM_COLDFIRE: return "Motorola Coldfire";
1752 case EM_68HC12: return "Motorola M68HC12";
1753 case EM_ALPHA: return "Alpha";
1754 case EM_CYGNUS_D10V:
1755 case EM_D10V: return "d10v";
1756 case EM_CYGNUS_D30V:
1757 case EM_D30V: return "d30v";
1758 case EM_CYGNUS_M32R:
1759 case EM_M32R: return "Renesas M32R (formerly Mitsubishi M32r)";
1760 case EM_CYGNUS_V850:
1761 case EM_V850: return "NEC v850";
1762 case EM_CYGNUS_MN10300:
1763 case EM_MN10300: return "mn10300";
1764 case EM_CYGNUS_MN10200:
1765 case EM_MN10200: return "mn10200";
1766 case EM_CYGNUS_FR30:
1767 case EM_FR30: return "Fujitsu FR30";
1768 case EM_CYGNUS_FRV: return "Fujitsu FR-V";
1770 case EM_PJ: return "picoJava";
1771 case EM_MMA: return "Fujitsu Multimedia Accelerator";
1772 case EM_PCP: return "Siemens PCP";
1773 case EM_NCPU: return "Sony nCPU embedded RISC processor";
1774 case EM_NDR1: return "Denso NDR1 microprocesspr";
1775 case EM_STARCORE: return "Motorola Star*Core processor";
1776 case EM_ME16: return "Toyota ME16 processor";
1777 case EM_ST100: return "STMicroelectronics ST100 processor";
1778 case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
1779 case EM_FX66: return "Siemens FX66 microcontroller";
1780 case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1781 case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
1782 case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
1783 case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
1784 case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
1785 case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
1786 case EM_SVX: return "Silicon Graphics SVx";
1787 case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
1788 case EM_VAX: return "Digital VAX";
1790 case EM_AVR: return "Atmel AVR 8-bit microcontroller";
1791 case EM_CRIS: return "Axis Communications 32-bit embedded processor";
1792 case EM_JAVELIN: return "Infineon Technologies 32-bit embedded cpu";
1793 case EM_FIREPATH: return "Element 14 64-bit DSP processor";
1794 case EM_ZSP: return "LSI Logic's 16-bit DSP processor";
1795 case EM_MMIX: return "Donald Knuth's educational 64-bit processor";
1796 case EM_HUANY: return "Harvard Universitys's machine-independent object format";
1797 case EM_PRISM: return "Vitesse Prism";
1798 case EM_X86_64: return "Advanced Micro Devices X86-64";
1800 case EM_S390: return "IBM S/390";
1801 case EM_SCORE: return "SUNPLUS S+Core";
1802 case EM_XSTORMY16: return "Sanyo Xstormy16 CPU core";
1804 case EM_OR32: return "OpenRISC";
1805 case EM_CRX: return "National Semiconductor CRX microprocessor";
1806 case EM_DLX: return "OpenDLX";
1808 case EM_IP2K: return "Ubicom IP2xxx 8-bit microcontrollers";
1809 case EM_IQ2000: return "Vitesse IQ2000";
1811 case EM_XTENSA: return "Tensilica Xtensa Processor";
1812 case EM_M32C: return "Renesas M32c";
1813 case EM_MT: return "Morpho Techologies MT processor";
1814 case EM_BLACKFIN: return "Analog Devices Blackfin";
1815 case EM_NIOS32: return "Altera Nios";
1816 case EM_ALTERA_NIOS2: return "Altera Nios II";
1817 case EM_XC16X: return "Infineon Technologies xc16x";
1818 case EM_CYGNUS_MEP: return "Toshiba MeP Media Engine";
1819 case EM_CR16: return "National Semiconductor's CR16";
1821 snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
1827 decode_ARM_machine_flags (unsigned e_flags, char buf[])
1832 eabi = EF_ARM_EABI_VERSION (e_flags);
1833 e_flags &= ~ EF_ARM_EABIMASK;
1835 /* Handle "generic" ARM flags. */
1836 if (e_flags & EF_ARM_RELEXEC)
1838 strcat (buf, ", relocatable executable");
1839 e_flags &= ~ EF_ARM_RELEXEC;
1842 if (e_flags & EF_ARM_HASENTRY)
1844 strcat (buf, ", has entry point");
1845 e_flags &= ~ EF_ARM_HASENTRY;
1848 /* Now handle EABI specific flags. */
1852 strcat (buf, ", <unrecognized EABI>");
1857 case EF_ARM_EABI_VER1:
1858 strcat (buf, ", Version1 EABI");
1863 /* Process flags one bit at a time. */
1864 flag = e_flags & - e_flags;
1869 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
1870 strcat (buf, ", sorted symbol tables");
1880 case EF_ARM_EABI_VER2:
1881 strcat (buf, ", Version2 EABI");
1886 /* Process flags one bit at a time. */
1887 flag = e_flags & - e_flags;
1892 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
1893 strcat (buf, ", sorted symbol tables");
1896 case EF_ARM_DYNSYMSUSESEGIDX:
1897 strcat (buf, ", dynamic symbols use segment index");
1900 case EF_ARM_MAPSYMSFIRST:
1901 strcat (buf, ", mapping symbols precede others");
1911 case EF_ARM_EABI_VER3:
1912 strcat (buf, ", Version3 EABI");
1915 case EF_ARM_EABI_VER4:
1916 strcat (buf, ", Version4 EABI");
1919 case EF_ARM_EABI_VER5:
1920 strcat (buf, ", Version5 EABI");
1926 /* Process flags one bit at a time. */
1927 flag = e_flags & - e_flags;
1933 strcat (buf, ", BE8");
1937 strcat (buf, ", LE8");
1947 case EF_ARM_EABI_UNKNOWN:
1948 strcat (buf, ", GNU EABI");
1953 /* Process flags one bit at a time. */
1954 flag = e_flags & - e_flags;
1959 case EF_ARM_INTERWORK:
1960 strcat (buf, ", interworking enabled");
1963 case EF_ARM_APCS_26:
1964 strcat (buf, ", uses APCS/26");
1967 case EF_ARM_APCS_FLOAT:
1968 strcat (buf, ", uses APCS/float");
1972 strcat (buf, ", position independent");
1976 strcat (buf, ", 8 bit structure alignment");
1979 case EF_ARM_NEW_ABI:
1980 strcat (buf, ", uses new ABI");
1983 case EF_ARM_OLD_ABI:
1984 strcat (buf, ", uses old ABI");
1987 case EF_ARM_SOFT_FLOAT:
1988 strcat (buf, ", software FP");
1991 case EF_ARM_VFP_FLOAT:
1992 strcat (buf, ", VFP");
1995 case EF_ARM_MAVERICK_FLOAT:
1996 strcat (buf, ", Maverick FP");
2007 strcat (buf,", <unknown>");
2011 get_machine_flags (unsigned e_flags, unsigned e_machine)
2013 static char buf[1024];
2025 decode_ARM_machine_flags (e_flags, buf);
2029 switch (e_flags & EF_FRV_CPU_MASK)
2031 case EF_FRV_CPU_GENERIC:
2035 strcat (buf, ", fr???");
2038 case EF_FRV_CPU_FR300:
2039 strcat (buf, ", fr300");
2042 case EF_FRV_CPU_FR400:
2043 strcat (buf, ", fr400");
2045 case EF_FRV_CPU_FR405:
2046 strcat (buf, ", fr405");
2049 case EF_FRV_CPU_FR450:
2050 strcat (buf, ", fr450");
2053 case EF_FRV_CPU_FR500:
2054 strcat (buf, ", fr500");
2056 case EF_FRV_CPU_FR550:
2057 strcat (buf, ", fr550");
2060 case EF_FRV_CPU_SIMPLE:
2061 strcat (buf, ", simple");
2063 case EF_FRV_CPU_TOMCAT:
2064 strcat (buf, ", tomcat");
2070 if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
2071 strcat (buf, ", m68000");
2072 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
2073 strcat (buf, ", cpu32");
2074 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
2075 strcat (buf, ", fido_a");
2078 char const *isa = _("unknown");
2079 char const *mac = _("unknown mac");
2080 char const *additional = NULL;
2082 switch (e_flags & EF_M68K_CF_ISA_MASK)
2084 case EF_M68K_CF_ISA_A_NODIV:
2086 additional = ", nodiv";
2088 case EF_M68K_CF_ISA_A:
2091 case EF_M68K_CF_ISA_A_PLUS:
2094 case EF_M68K_CF_ISA_B_NOUSP:
2096 additional = ", nousp";
2098 case EF_M68K_CF_ISA_B:
2102 strcat (buf, ", cf, isa ");
2105 strcat (buf, additional);
2106 if (e_flags & EF_M68K_CF_FLOAT)
2107 strcat (buf, ", float");
2108 switch (e_flags & EF_M68K_CF_MAC_MASK)
2113 case EF_M68K_CF_MAC:
2116 case EF_M68K_CF_EMAC:
2129 if (e_flags & EF_PPC_EMB)
2130 strcat (buf, ", emb");
2132 if (e_flags & EF_PPC_RELOCATABLE)
2133 strcat (buf, ", relocatable");
2135 if (e_flags & EF_PPC_RELOCATABLE_LIB)
2136 strcat (buf, ", relocatable-lib");
2140 case EM_CYGNUS_V850:
2141 switch (e_flags & EF_V850_ARCH)
2144 strcat (buf, ", v850e1");
2147 strcat (buf, ", v850e");
2150 strcat (buf, ", v850");
2153 strcat (buf, ", unknown v850 architecture variant");
2159 case EM_CYGNUS_M32R:
2160 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
2161 strcat (buf, ", m32r");
2165 case EM_MIPS_RS3_LE:
2166 if (e_flags & EF_MIPS_NOREORDER)
2167 strcat (buf, ", noreorder");
2169 if (e_flags & EF_MIPS_PIC)
2170 strcat (buf, ", pic");
2172 if (e_flags & EF_MIPS_CPIC)
2173 strcat (buf, ", cpic");
2175 if (e_flags & EF_MIPS_UCODE)
2176 strcat (buf, ", ugen_reserved");
2178 if (e_flags & EF_MIPS_ABI2)
2179 strcat (buf, ", abi2");
2181 if (e_flags & EF_MIPS_OPTIONS_FIRST)
2182 strcat (buf, ", odk first");
2184 if (e_flags & EF_MIPS_32BITMODE)
2185 strcat (buf, ", 32bitmode");
2187 switch ((e_flags & EF_MIPS_MACH))
2189 case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
2190 case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
2191 case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
2192 case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
2193 case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
2194 case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
2195 case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
2196 case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
2197 case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); break;
2198 case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
2200 /* We simply ignore the field in this case to avoid confusion:
2201 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2204 default: strcat (buf, ", unknown CPU"); break;
2207 switch ((e_flags & EF_MIPS_ABI))
2209 case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
2210 case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
2211 case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
2212 case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
2214 /* We simply ignore the field in this case to avoid confusion:
2215 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2216 This means it is likely to be an o32 file, but not for
2219 default: strcat (buf, ", unknown ABI"); break;
2222 if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
2223 strcat (buf, ", mdmx");
2225 if (e_flags & EF_MIPS_ARCH_ASE_M16)
2226 strcat (buf, ", mips16");
2228 switch ((e_flags & EF_MIPS_ARCH))
2230 case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
2231 case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
2232 case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
2233 case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
2234 case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
2235 case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
2236 case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
2237 case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
2238 case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
2239 default: strcat (buf, ", unknown ISA"); break;
2245 switch ((e_flags & EF_SH_MACH_MASK))
2247 case EF_SH1: strcat (buf, ", sh1"); break;
2248 case EF_SH2: strcat (buf, ", sh2"); break;
2249 case EF_SH3: strcat (buf, ", sh3"); break;
2250 case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
2251 case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
2252 case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
2253 case EF_SH3E: strcat (buf, ", sh3e"); break;
2254 case EF_SH4: strcat (buf, ", sh4"); break;
2255 case EF_SH5: strcat (buf, ", sh5"); break;
2256 case EF_SH2E: strcat (buf, ", sh2e"); break;
2257 case EF_SH4A: strcat (buf, ", sh4a"); break;
2258 case EF_SH2A: strcat (buf, ", sh2a"); break;
2259 case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
2260 case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
2261 case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
2262 case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
2263 case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
2264 case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
2265 case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
2266 case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
2267 case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
2268 default: strcat (buf, ", unknown ISA"); break;
2274 if (e_flags & EF_SPARC_32PLUS)
2275 strcat (buf, ", v8+");
2277 if (e_flags & EF_SPARC_SUN_US1)
2278 strcat (buf, ", ultrasparcI");
2280 if (e_flags & EF_SPARC_SUN_US3)
2281 strcat (buf, ", ultrasparcIII");
2283 if (e_flags & EF_SPARC_HAL_R1)
2284 strcat (buf, ", halr1");
2286 if (e_flags & EF_SPARC_LEDATA)
2287 strcat (buf, ", ledata");
2289 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
2290 strcat (buf, ", tso");
2292 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
2293 strcat (buf, ", pso");
2295 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
2296 strcat (buf, ", rmo");
2300 switch (e_flags & EF_PARISC_ARCH)
2302 case EFA_PARISC_1_0:
2303 strcpy (buf, ", PA-RISC 1.0");
2305 case EFA_PARISC_1_1:
2306 strcpy (buf, ", PA-RISC 1.1");
2308 case EFA_PARISC_2_0:
2309 strcpy (buf, ", PA-RISC 2.0");
2314 if (e_flags & EF_PARISC_TRAPNIL)
2315 strcat (buf, ", trapnil");
2316 if (e_flags & EF_PARISC_EXT)
2317 strcat (buf, ", ext");
2318 if (e_flags & EF_PARISC_LSB)
2319 strcat (buf, ", lsb");
2320 if (e_flags & EF_PARISC_WIDE)
2321 strcat (buf, ", wide");
2322 if (e_flags & EF_PARISC_NO_KABP)
2323 strcat (buf, ", no kabp");
2324 if (e_flags & EF_PARISC_LAZYSWAP)
2325 strcat (buf, ", lazyswap");
2330 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
2331 strcat (buf, ", new calling convention");
2333 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
2334 strcat (buf, ", gnu calling convention");
2338 if ((e_flags & EF_IA_64_ABI64))
2339 strcat (buf, ", 64-bit");
2341 strcat (buf, ", 32-bit");
2342 if ((e_flags & EF_IA_64_REDUCEDFP))
2343 strcat (buf, ", reduced fp model");
2344 if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
2345 strcat (buf, ", no function descriptors, constant gp");
2346 else if ((e_flags & EF_IA_64_CONS_GP))
2347 strcat (buf, ", constant gp");
2348 if ((e_flags & EF_IA_64_ABSOLUTE))
2349 strcat (buf, ", absolute");
2353 if ((e_flags & EF_VAX_NONPIC))
2354 strcat (buf, ", non-PIC");
2355 if ((e_flags & EF_VAX_DFLOAT))
2356 strcat (buf, ", D-Float");
2357 if ((e_flags & EF_VAX_GFLOAT))
2358 strcat (buf, ", G-Float");
2367 get_osabi_name (unsigned int osabi)
2369 static char buff[32];
2373 case ELFOSABI_NONE: return "UNIX - System V";
2374 case ELFOSABI_HPUX: return "UNIX - HP-UX";
2375 case ELFOSABI_NETBSD: return "UNIX - NetBSD";
2376 case ELFOSABI_LINUX: return "UNIX - Linux";
2377 case ELFOSABI_HURD: return "GNU/Hurd";
2378 case ELFOSABI_SOLARIS: return "UNIX - Solaris";
2379 case ELFOSABI_AIX: return "UNIX - AIX";
2380 case ELFOSABI_IRIX: return "UNIX - IRIX";
2381 case ELFOSABI_FREEBSD: return "UNIX - FreeBSD";
2382 case ELFOSABI_TRU64: return "UNIX - TRU64";
2383 case ELFOSABI_MODESTO: return "Novell - Modesto";
2384 case ELFOSABI_OPENBSD: return "UNIX - OpenBSD";
2385 case ELFOSABI_OPENVMS: return "VMS - OpenVMS";
2386 case ELFOSABI_NSK: return "HP - Non-Stop Kernel";
2387 case ELFOSABI_AROS: return "Amiga Research OS";
2388 case ELFOSABI_STANDALONE: return _("Standalone App");
2389 case ELFOSABI_ARM: return "ARM";
2391 snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
2397 get_arm_segment_type (unsigned long type)
2411 get_mips_segment_type (unsigned long type)
2415 case PT_MIPS_REGINFO:
2417 case PT_MIPS_RTPROC:
2419 case PT_MIPS_OPTIONS:
2429 get_parisc_segment_type (unsigned long type)
2433 case PT_HP_TLS: return "HP_TLS";
2434 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
2435 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
2436 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
2437 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
2438 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
2439 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
2440 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
2441 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
2442 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
2443 case PT_HP_PARALLEL: return "HP_PARALLEL";
2444 case PT_HP_FASTBIND: return "HP_FASTBIND";
2445 case PT_HP_OPT_ANNOT: return "HP_OPT_ANNOT";
2446 case PT_HP_HSL_ANNOT: return "HP_HSL_ANNOT";
2447 case PT_HP_STACK: return "HP_STACK";
2448 case PT_HP_CORE_UTSNAME: return "HP_CORE_UTSNAME";
2449 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
2450 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
2451 case PT_PARISC_WEAKORDER: return "PARISC_WEAKORDER";
2460 get_ia64_segment_type (unsigned long type)
2464 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
2465 case PT_IA_64_UNWIND: return "IA_64_UNWIND";
2466 case PT_HP_TLS: return "HP_TLS";
2467 case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
2468 case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
2469 case PT_IA_64_HP_STACK: return "HP_STACK";
2478 get_segment_type (unsigned long p_type)
2480 static char buff[32];
2484 case PT_NULL: return "NULL";
2485 case PT_LOAD: return "LOAD";
2486 case PT_DYNAMIC: return "DYNAMIC";
2487 case PT_INTERP: return "INTERP";
2488 case PT_NOTE: return "NOTE";
2489 case PT_SHLIB: return "SHLIB";
2490 case PT_PHDR: return "PHDR";
2491 case PT_TLS: return "TLS";
2493 case PT_GNU_EH_FRAME:
2494 return "GNU_EH_FRAME";
2495 case PT_GNU_STACK: return "GNU_STACK";
2496 case PT_GNU_RELRO: return "GNU_RELRO";
2499 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
2503 switch (elf_header.e_machine)
2506 result = get_arm_segment_type (p_type);
2509 case EM_MIPS_RS3_LE:
2510 result = get_mips_segment_type (p_type);
2513 result = get_parisc_segment_type (p_type);
2516 result = get_ia64_segment_type (p_type);
2526 sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
2528 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
2532 switch (elf_header.e_machine)
2535 result = get_parisc_segment_type (p_type);
2538 result = get_ia64_segment_type (p_type);
2548 sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
2551 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
2558 get_mips_section_type_name (unsigned int sh_type)
2562 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
2563 case SHT_MIPS_MSYM: return "MIPS_MSYM";
2564 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
2565 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
2566 case SHT_MIPS_UCODE: return "MIPS_UCODE";
2567 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
2568 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
2569 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
2570 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
2571 case SHT_MIPS_RELD: return "MIPS_RELD";
2572 case SHT_MIPS_IFACE: return "MIPS_IFACE";
2573 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
2574 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
2575 case SHT_MIPS_SHDR: return "MIPS_SHDR";
2576 case SHT_MIPS_FDESC: return "MIPS_FDESC";
2577 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
2578 case SHT_MIPS_DENSE: return "MIPS_DENSE";
2579 case SHT_MIPS_PDESC: return "MIPS_PDESC";
2580 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
2581 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
2582 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
2583 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
2584 case SHT_MIPS_LINE: return "MIPS_LINE";
2585 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
2586 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
2587 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
2588 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
2589 case SHT_MIPS_DWARF: return "MIPS_DWARF";
2590 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
2591 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
2592 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
2593 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
2594 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
2595 case SHT_MIPS_XLATE: return "MIPS_XLATE";
2596 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
2597 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
2598 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
2599 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
2600 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
2608 get_parisc_section_type_name (unsigned int sh_type)
2612 case SHT_PARISC_EXT: return "PARISC_EXT";
2613 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
2614 case SHT_PARISC_DOC: return "PARISC_DOC";
2615 case SHT_PARISC_ANNOT: return "PARISC_ANNOT";
2616 case SHT_PARISC_SYMEXTN: return "PARISC_SYMEXTN";
2617 case SHT_PARISC_STUBS: return "PARISC_STUBS";
2618 case SHT_PARISC_DLKM: return "PARISC_DLKM";
2626 get_ia64_section_type_name (unsigned int sh_type)
2628 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
2629 if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
2630 return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
2634 case SHT_IA_64_EXT: return "IA_64_EXT";
2635 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
2636 case SHT_IA_64_PRIORITY_INIT: return "IA_64_PRIORITY_INIT";
2644 get_x86_64_section_type_name (unsigned int sh_type)
2648 case SHT_X86_64_UNWIND: return "X86_64_UNWIND";
2656 get_arm_section_type_name (unsigned int sh_type)
2662 case SHT_ARM_PREEMPTMAP:
2663 return "ARM_PREEMPTMAP";
2664 case SHT_ARM_ATTRIBUTES:
2665 return "ARM_ATTRIBUTES";
2673 get_section_type_name (unsigned int sh_type)
2675 static char buff[32];
2679 case SHT_NULL: return "NULL";
2680 case SHT_PROGBITS: return "PROGBITS";
2681 case SHT_SYMTAB: return "SYMTAB";
2682 case SHT_STRTAB: return "STRTAB";
2683 case SHT_RELA: return "RELA";
2684 case SHT_HASH: return "HASH";
2685 case SHT_DYNAMIC: return "DYNAMIC";
2686 case SHT_NOTE: return "NOTE";
2687 case SHT_NOBITS: return "NOBITS";
2688 case SHT_REL: return "REL";
2689 case SHT_SHLIB: return "SHLIB";
2690 case SHT_DYNSYM: return "DYNSYM";
2691 case SHT_INIT_ARRAY: return "INIT_ARRAY";
2692 case SHT_FINI_ARRAY: return "FINI_ARRAY";
2693 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
2694 case SHT_GNU_HASH: return "GNU_HASH";
2695 case SHT_GROUP: return "GROUP";
2696 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICIES";
2697 case SHT_GNU_verdef: return "VERDEF";
2698 case SHT_GNU_verneed: return "VERNEED";
2699 case SHT_GNU_versym: return "VERSYM";
2700 case 0x6ffffff0: return "VERSYM";
2701 case 0x6ffffffc: return "VERDEF";
2702 case 0x7ffffffd: return "AUXILIARY";
2703 case 0x7fffffff: return "FILTER";
2704 case SHT_GNU_LIBLIST: return "GNU_LIBLIST";
2707 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
2711 switch (elf_header.e_machine)
2714 case EM_MIPS_RS3_LE:
2715 result = get_mips_section_type_name (sh_type);
2718 result = get_parisc_section_type_name (sh_type);
2721 result = get_ia64_section_type_name (sh_type);
2724 result = get_x86_64_section_type_name (sh_type);
2727 result = get_arm_section_type_name (sh_type);
2737 sprintf (buff, "LOPROC+%x", sh_type - SHT_LOPROC);
2739 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
2740 sprintf (buff, "LOOS+%x", sh_type - SHT_LOOS);
2741 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
2742 sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER);
2744 snprintf (buff, sizeof (buff), _("<unknown>: %x"), sh_type);
2750 #define OPTION_DEBUG_DUMP 512
2752 static struct option options[] =
2754 {"all", no_argument, 0, 'a'},
2755 {"file-header", no_argument, 0, 'h'},
2756 {"program-headers", no_argument, 0, 'l'},
2757 {"headers", no_argument, 0, 'e'},
2758 {"histogram", no_argument, 0, 'I'},
2759 {"segments", no_argument, 0, 'l'},
2760 {"sections", no_argument, 0, 'S'},
2761 {"section-headers", no_argument, 0, 'S'},
2762 {"section-groups", no_argument, 0, 'g'},
2763 {"section-details", no_argument, 0, 't'},
2764 {"full-section-name",no_argument, 0, 'N'},
2765 {"symbols", no_argument, 0, 's'},
2766 {"syms", no_argument, 0, 's'},
2767 {"relocs", no_argument, 0, 'r'},
2768 {"notes", no_argument, 0, 'n'},
2769 {"dynamic", no_argument, 0, 'd'},
2770 {"arch-specific", no_argument, 0, 'A'},
2771 {"version-info", no_argument, 0, 'V'},
2772 {"use-dynamic", no_argument, 0, 'D'},
2773 {"unwind", no_argument, 0, 'u'},
2774 {"archive-index", no_argument, 0, 'c'},
2775 {"hex-dump", required_argument, 0, 'x'},
2776 {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
2777 {"string-dump", required_argument, 0, 'p'},
2778 #ifdef SUPPORT_DISASSEMBLY
2779 {"instruction-dump", required_argument, 0, 'i'},
2782 {"version", no_argument, 0, 'v'},
2783 {"wide", no_argument, 0, 'W'},
2784 {"help", no_argument, 0, 'H'},
2785 {0, no_argument, 0, 0}
2789 usage (FILE *stream)
2791 fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
2792 fprintf (stream, _(" Display information about the contents of ELF format files\n"));
2793 fprintf (stream, _(" Options are:\n\
2794 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
2795 -h --file-header Display the ELF file header\n\
2796 -l --program-headers Display the program headers\n\
2797 --segments An alias for --program-headers\n\
2798 -S --section-headers Display the sections' header\n\
2799 --sections An alias for --section-headers\n\
2800 -g --section-groups Display the section groups\n\
2801 -t --section-details Display the section details\n\
2802 -e --headers Equivalent to: -h -l -S\n\
2803 -s --syms Display the symbol table\n\
2804 --symbols An alias for --syms\n\
2805 -n --notes Display the core notes (if present)\n\
2806 -r --relocs Display the relocations (if present)\n\
2807 -u --unwind Display the unwind info (if present)\n\
2808 -d --dynamic Display the dynamic section (if present)\n\
2809 -V --version-info Display the version sections (if present)\n\
2810 -A --arch-specific Display architecture specific information (if any).\n\
2811 -c --archive-index Display the symbol/file index in an archive\n\
2812 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
2813 -x --hex-dump=<number|name>\n\
2814 Dump the contents of section <number|name> as bytes\n\
2815 -p --string-dump=<number|name>\n\
2816 Dump the contents of section <number|name> as strings\n\
2817 -w[liaprmfFsoR] or\n\
2818 --debug-dump[=line,=info,=abbrev,=pubnames,=aranges,=macro,=frames,=str,=loc,=Ranges]\n\
2819 Display the contents of DWARF2 debug sections\n"));
2820 #ifdef SUPPORT_DISASSEMBLY
2821 fprintf (stream, _("\
2822 -i --instruction-dump=<number|name>\n\
2823 Disassemble the contents of section <number|name>\n"));
2825 fprintf (stream, _("\
2826 -I --histogram Display histogram of bucket list lengths\n\
2827 -W --wide Allow output width to exceed 80 characters\n\
2828 @<file> Read options from <file>\n\
2829 -H --help Display this information\n\
2830 -v --version Display the version number of readelf\n"));
2832 if (REPORT_BUGS_TO[0] && stream == stdout)
2833 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
2835 exit (stream == stdout ? 0 : 1);
2838 /* Record the fact that the user wants the contents of section number
2839 SECTION to be displayed using the method(s) encoded as flags bits
2840 in TYPE. Note, TYPE can be zero if we are creating the array for
2844 request_dump_bynumber (unsigned int section, dump_type type)
2846 if (section >= num_dump_sects)
2848 dump_type *new_dump_sects;
2850 new_dump_sects = calloc (section + 1, sizeof (* dump_sects));
2852 if (new_dump_sects == NULL)
2853 error (_("Out of memory allocating dump request table.\n"));
2856 /* Copy current flag settings. */
2857 memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
2861 dump_sects = new_dump_sects;
2862 num_dump_sects = section + 1;
2867 dump_sects[section] |= type;
2872 /* Request a dump by section name. */
2875 request_dump_byname (const char *section, dump_type type)
2877 struct dump_list_entry *new_request;
2879 new_request = malloc (sizeof (struct dump_list_entry));
2881 error (_("Out of memory allocating dump request table.\n"));
2883 new_request->name = strdup (section);
2884 if (!new_request->name)
2885 error (_("Out of memory allocating dump request table.\n"));
2887 new_request->type = type;
2889 new_request->next = dump_sects_byname;
2890 dump_sects_byname = new_request;
2894 parse_args (int argc, char **argv)
2901 while ((c = getopt_long
2902 (argc, argv, "ADHINSVWacdeghi:lnp:rstuvw::x:", options, NULL)) != EOF)
2923 do_section_groups++;
2931 do_section_groups++;
2936 do_section_details++;
2981 section = strtoul (optarg, & cp, 0);
2982 if (! *cp && section >= 0)
2983 request_dump_bynumber (section, HEX_DUMP);
2985 request_dump_byname (optarg, HEX_DUMP);
2989 section = strtoul (optarg, & cp, 0);
2990 if (! *cp && section >= 0)
2991 request_dump_bynumber (section, STRING_DUMP);
2993 request_dump_byname (optarg, STRING_DUMP);
3001 unsigned int index = 0;
3005 while (optarg[index])
3006 switch (optarg[index++])
3015 do_debug_abbrevs = 1;
3025 do_debug_pubnames = 1;
3029 do_debug_aranges = 1;
3033 do_debug_ranges = 1;
3037 do_debug_frames_interp = 1;
3039 do_debug_frames = 1;
3044 do_debug_macinfo = 1;
3058 warn (_("Unrecognized debug option '%s'\n"), optarg);
3063 case OPTION_DEBUG_DUMP:
3071 const char * option;
3074 debug_dump_long_opts;
3076 debug_dump_long_opts opts_table [] =
3078 /* Please keep this table alpha- sorted. */
3079 { "Ranges", & do_debug_ranges },
3080 { "abbrev", & do_debug_abbrevs },
3081 { "aranges", & do_debug_aranges },
3082 { "frames", & do_debug_frames },
3083 { "frames-interp", & do_debug_frames_interp },
3084 { "info", & do_debug_info },
3085 { "line", & do_debug_lines },
3086 { "loc", & do_debug_loc },
3087 { "macro", & do_debug_macinfo },
3088 { "pubnames", & do_debug_pubnames },
3089 /* This entry is for compatability
3090 with earlier versions of readelf. */
3091 { "ranges", & do_debug_aranges },
3092 { "str", & do_debug_str },
3103 debug_dump_long_opts * entry;
3105 for (entry = opts_table; entry->option; entry++)
3107 size_t len = strlen (entry->option);
3109 if (strneq (p, entry->option, len)
3110 && (p[len] == ',' || p[len] == '\0'))
3112 * entry->variable = 1;
3114 /* The --debug-dump=frames-interp option also
3115 enables the --debug-dump=frames option. */
3116 if (do_debug_frames_interp)
3117 do_debug_frames = 1;
3124 if (entry->option == NULL)
3126 warn (_("Unrecognized debug option '%s'\n"), p);
3127 p = strchr (p, ',');
3137 #ifdef SUPPORT_DISASSEMBLY
3140 section = strtoul (optarg, & cp, 0);
3141 if (! *cp && section >= 0)
3142 request_dump_bynumber (section, DISASS_DUMP);
3144 request_dump_byname (optarg, DISASS_DUMP);
3147 print_version (program_name);
3156 /* xgettext:c-format */
3157 error (_("Invalid option '-%c'\n"), c);
3164 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
3165 && !do_segments && !do_header && !do_dump && !do_version
3166 && !do_histogram && !do_debugging && !do_arch && !do_notes
3167 && !do_section_groups && !do_archive_index)
3171 warn (_("Nothing to do.\n"));
3177 get_elf_class (unsigned int elf_class)
3179 static char buff[32];
3183 case ELFCLASSNONE: return _("none");
3184 case ELFCLASS32: return "ELF32";
3185 case ELFCLASS64: return "ELF64";
3187 snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
3193 get_data_encoding (unsigned int encoding)
3195 static char buff[32];
3199 case ELFDATANONE: return _("none");
3200 case ELFDATA2LSB: return _("2's complement, little endian");
3201 case ELFDATA2MSB: return _("2's complement, big endian");
3203 snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
3208 /* Decode the data held in 'elf_header'. */
3211 process_file_header (void)
3213 if ( elf_header.e_ident[EI_MAG0] != ELFMAG0
3214 || elf_header.e_ident[EI_MAG1] != ELFMAG1
3215 || elf_header.e_ident[EI_MAG2] != ELFMAG2
3216 || elf_header.e_ident[EI_MAG3] != ELFMAG3)
3219 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3227 printf (_("ELF Header:\n"));
3228 printf (_(" Magic: "));
3229 for (i = 0; i < EI_NIDENT; i++)
3230 printf ("%2.2x ", elf_header.e_ident[i]);
3232 printf (_(" Class: %s\n"),
3233 get_elf_class (elf_header.e_ident[EI_CLASS]));
3234 printf (_(" Data: %s\n"),
3235 get_data_encoding (elf_header.e_ident[EI_DATA]));
3236 printf (_(" Version: %d %s\n"),
3237 elf_header.e_ident[EI_VERSION],
3238 (elf_header.e_ident[EI_VERSION] == EV_CURRENT
3240 : (elf_header.e_ident[EI_VERSION] != EV_NONE
3243 printf (_(" OS/ABI: %s\n"),
3244 get_osabi_name (elf_header.e_ident[EI_OSABI]));
3245 printf (_(" ABI Version: %d\n"),
3246 elf_header.e_ident[EI_ABIVERSION]);
3247 printf (_(" Type: %s\n"),
3248 get_file_type (elf_header.e_type));
3249 printf (_(" Machine: %s\n"),
3250 get_machine_name (elf_header.e_machine));
3251 printf (_(" Version: 0x%lx\n"),
3252 (unsigned long) elf_header.e_version);
3254 printf (_(" Entry point address: "));
3255 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
3256 printf (_("\n Start of program headers: "));
3257 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
3258 printf (_(" (bytes into file)\n Start of section headers: "));
3259 print_vma ((bfd_vma) elf_header.e_shoff, DEC);
3260 printf (_(" (bytes into file)\n"));
3262 printf (_(" Flags: 0x%lx%s\n"),
3263 (unsigned long) elf_header.e_flags,
3264 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
3265 printf (_(" Size of this header: %ld (bytes)\n"),
3266 (long) elf_header.e_ehsize);
3267 printf (_(" Size of program headers: %ld (bytes)\n"),
3268 (long) elf_header.e_phentsize);
3269 printf (_(" Number of program headers: %ld\n"),
3270 (long) elf_header.e_phnum);
3271 printf (_(" Size of section headers: %ld (bytes)\n"),
3272 (long) elf_header.e_shentsize);
3273 printf (_(" Number of section headers: %ld"),
3274 (long) elf_header.e_shnum);
3275 if (section_headers != NULL && elf_header.e_shnum == 0)
3276 printf (" (%ld)", (long) section_headers[0].sh_size);
3277 putc ('\n', stdout);
3278 printf (_(" Section header string table index: %ld"),
3279 (long) elf_header.e_shstrndx);
3280 if (section_headers != NULL && elf_header.e_shstrndx == SHN_XINDEX)
3281 printf (" (%ld)", (long) section_headers[0].sh_link);
3282 else if (elf_header.e_shstrndx != SHN_UNDEF
3283 && (elf_header.e_shstrndx >= elf_header.e_shnum
3284 || (elf_header.e_shstrndx >= SHN_LORESERVE
3285 && elf_header.e_shstrndx <= SHN_HIRESERVE)))
3286 printf (" <corrupt: out of range>");
3287 putc ('\n', stdout);
3290 if (section_headers != NULL)
3292 if (elf_header.e_shnum == 0)
3293 elf_header.e_shnum = section_headers[0].sh_size;
3294 if (elf_header.e_shstrndx == SHN_XINDEX)
3295 elf_header.e_shstrndx = section_headers[0].sh_link;
3296 else if (elf_header.e_shstrndx != SHN_UNDEF
3297 && (elf_header.e_shstrndx >= elf_header.e_shnum
3298 || (elf_header.e_shstrndx >= SHN_LORESERVE
3299 && elf_header.e_shstrndx <= SHN_HIRESERVE)))
3300 elf_header.e_shstrndx = SHN_UNDEF;
3301 free (section_headers);
3302 section_headers = NULL;
3310 get_32bit_program_headers (FILE *file, Elf_Internal_Phdr *program_headers)
3312 Elf32_External_Phdr *phdrs;
3313 Elf32_External_Phdr *external;
3314 Elf_Internal_Phdr *internal;
3317 phdrs = get_data (NULL, file, elf_header.e_phoff,
3318 elf_header.e_phentsize, elf_header.e_phnum,
3319 _("program headers"));
3323 for (i = 0, internal = program_headers, external = phdrs;
3324 i < elf_header.e_phnum;
3325 i++, internal++, external++)
3327 internal->p_type = BYTE_GET (external->p_type);
3328 internal->p_offset = BYTE_GET (external->p_offset);
3329 internal->p_vaddr = BYTE_GET (external->p_vaddr);
3330 internal->p_paddr = BYTE_GET (external->p_paddr);
3331 internal->p_filesz = BYTE_GET (external->p_filesz);
3332 internal->p_memsz = BYTE_GET (external->p_memsz);
3333 internal->p_flags = BYTE_GET (external->p_flags);
3334 internal->p_align = BYTE_GET (external->p_align);
3343 get_64bit_program_headers (FILE *file, Elf_Internal_Phdr *program_headers)
3345 Elf64_External_Phdr *phdrs;
3346 Elf64_External_Phdr *external;
3347 Elf_Internal_Phdr *internal;
3350 phdrs = get_data (NULL, file, elf_header.e_phoff,
3351 elf_header.e_phentsize, elf_header.e_phnum,
3352 _("program headers"));
3356 for (i = 0, internal = program_headers, external = phdrs;
3357 i < elf_header.e_phnum;
3358 i++, internal++, external++)
3360 internal->p_type = BYTE_GET (external->p_type);
3361 internal->p_flags = BYTE_GET (external->p_flags);
3362 internal->p_offset = BYTE_GET (external->p_offset);
3363 internal->p_vaddr = BYTE_GET (external->p_vaddr);
3364 internal->p_paddr = BYTE_GET (external->p_paddr);
3365 internal->p_filesz = BYTE_GET (external->p_filesz);
3366 internal->p_memsz = BYTE_GET (external->p_memsz);
3367 internal->p_align = BYTE_GET (external->p_align);
3375 /* Returns 1 if the program headers were read into `program_headers'. */
3378 get_program_headers (FILE *file)
3380 Elf_Internal_Phdr *phdrs;
3382 /* Check cache of prior read. */
3383 if (program_headers != NULL)
3386 phdrs = cmalloc (elf_header.e_phnum, sizeof (Elf_Internal_Phdr));
3390 error (_("Out of memory\n"));
3395 ? get_32bit_program_headers (file, phdrs)
3396 : get_64bit_program_headers (file, phdrs))
3398 program_headers = phdrs;
3406 /* Returns 1 if the program headers were loaded. */
3409 process_program_headers (FILE *file)
3411 Elf_Internal_Phdr *segment;
3414 if (elf_header.e_phnum == 0)
3417 printf (_("\nThere are no program headers in this file.\n"));
3421 if (do_segments && !do_header)
3423 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
3424 printf (_("Entry point "));
3425 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
3426 printf (_("\nThere are %d program headers, starting at offset "),
3427 elf_header.e_phnum);
3428 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
3432 if (! get_program_headers (file))
3437 if (elf_header.e_phnum > 1)
3438 printf (_("\nProgram Headers:\n"));
3440 printf (_("\nProgram Headers:\n"));
3444 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3447 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3451 (_(" Type Offset VirtAddr PhysAddr\n"));
3453 (_(" FileSiz MemSiz Flags Align\n"));
3460 for (i = 0, segment = program_headers;
3461 i < elf_header.e_phnum;
3466 printf (" %-14.14s ", get_segment_type (segment->p_type));
3470 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
3471 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
3472 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
3473 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
3474 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
3476 (segment->p_flags & PF_R ? 'R' : ' '),
3477 (segment->p_flags & PF_W ? 'W' : ' '),
3478 (segment->p_flags & PF_X ? 'E' : ' '));
3479 printf ("%#lx", (unsigned long) segment->p_align);
3483 if ((unsigned long) segment->p_offset == segment->p_offset)
3484 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
3487 print_vma (segment->p_offset, FULL_HEX);
3491 print_vma (segment->p_vaddr, FULL_HEX);
3493 print_vma (segment->p_paddr, FULL_HEX);
3496 if ((unsigned long) segment->p_filesz == segment->p_filesz)
3497 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
3500 print_vma (segment->p_filesz, FULL_HEX);
3504 if ((unsigned long) segment->p_memsz == segment->p_memsz)
3505 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
3508 print_vma (segment->p_offset, FULL_HEX);
3512 (segment->p_flags & PF_R ? 'R' : ' '),
3513 (segment->p_flags & PF_W ? 'W' : ' '),
3514 (segment->p_flags & PF_X ? 'E' : ' '));
3516 if ((unsigned long) segment->p_align == segment->p_align)
3517 printf ("%#lx", (unsigned long) segment->p_align);
3520 print_vma (segment->p_align, PREFIX_HEX);
3525 print_vma (segment->p_offset, FULL_HEX);
3527 print_vma (segment->p_vaddr, FULL_HEX);
3529 print_vma (segment->p_paddr, FULL_HEX);
3531 print_vma (segment->p_filesz, FULL_HEX);
3533 print_vma (segment->p_memsz, FULL_HEX);
3535 (segment->p_flags & PF_R ? 'R' : ' '),
3536 (segment->p_flags & PF_W ? 'W' : ' '),
3537 (segment->p_flags & PF_X ? 'E' : ' '));
3538 print_vma (segment->p_align, HEX);
3542 switch (segment->p_type)
3546 error (_("more than one dynamic segment\n"));
3548 /* By default, assume that the .dynamic section is the first
3549 section in the DYNAMIC segment. */
3550 dynamic_addr = segment->p_offset;
3551 dynamic_size = segment->p_filesz;
3553 /* Try to locate the .dynamic section. If there is
3554 a section header table, we can easily locate it. */
3555 if (section_headers != NULL)
3557 Elf_Internal_Shdr *sec;
3559 sec = find_section (".dynamic");
3560 if (sec == NULL || sec->sh_size == 0)
3562 error (_("no .dynamic section in the dynamic segment\n"));
3566 if (sec->sh_type == SHT_NOBITS)
3572 dynamic_addr = sec->sh_offset;
3573 dynamic_size = sec->sh_size;
3575 if (dynamic_addr < segment->p_offset
3576 || dynamic_addr > segment->p_offset + segment->p_filesz)
3577 warn (_("the .dynamic section is not contained"
3578 " within the dynamic segment\n"));
3579 else if (dynamic_addr > segment->p_offset)
3580 warn (_("the .dynamic section is not the first section"
3581 " in the dynamic segment.\n"));
3586 if (fseek (file, archive_file_offset + (long) segment->p_offset,
3588 error (_("Unable to find program interpreter name\n"));
3592 int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX);
3594 if (ret >= (int) sizeof (fmt) || ret < 0)
3595 error (_("Internal error: failed to create format string to display program interpreter\n"));
3597 program_interpreter[0] = 0;
3598 if (fscanf (file, fmt, program_interpreter) <= 0)
3599 error (_("Unable to read program interpreter name\n"));
3602 printf (_("\n [Requesting program interpreter: %s]"),
3603 program_interpreter);
3609 putc ('\n', stdout);
3612 if (do_segments && section_headers != NULL && string_table != NULL)
3614 printf (_("\n Section to Segment mapping:\n"));
3615 printf (_(" Segment Sections...\n"));
3617 for (i = 0; i < elf_header.e_phnum; i++)
3620 Elf_Internal_Shdr *section;
3622 segment = program_headers + i;
3623 section = section_headers;
3625 printf (" %2.2d ", i);
3627 for (j = 1; j < elf_header.e_shnum; j++, section++)
3629 if (ELF_IS_SECTION_IN_SEGMENT_MEMORY(section, segment))
3630 printf ("%s ", SECTION_NAME (section));
3641 /* Find the file offset corresponding to VMA by using the program headers. */
3644 offset_from_vma (FILE *file, bfd_vma vma, bfd_size_type size)
3646 Elf_Internal_Phdr *seg;
3648 if (! get_program_headers (file))
3650 warn (_("Cannot interpret virtual addresses without program headers.\n"));
3654 for (seg = program_headers;
3655 seg < program_headers + elf_header.e_phnum;
3658 if (seg->p_type != PT_LOAD)
3661 if (vma >= (seg->p_vaddr & -seg->p_align)
3662 && vma + size <= seg->p_vaddr + seg->p_filesz)
3663 return vma - seg->p_vaddr + seg->p_offset;
3666 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
3673 get_32bit_section_headers (FILE *file, unsigned int num)
3675 Elf32_External_Shdr *shdrs;
3676 Elf_Internal_Shdr *internal;
3679 shdrs = get_data (NULL, file, elf_header.e_shoff,
3680 elf_header.e_shentsize, num, _("section headers"));
3684 section_headers = cmalloc (num, sizeof (Elf_Internal_Shdr));
3686 if (section_headers == NULL)
3688 error (_("Out of memory\n"));
3692 for (i = 0, internal = section_headers;
3696 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
3697 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
3698 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
3699 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
3700 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
3701 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
3702 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
3703 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
3704 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
3705 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
3714 get_64bit_section_headers (FILE *file, unsigned int num)
3716 Elf64_External_Shdr *shdrs;
3717 Elf_Internal_Shdr *internal;
3720 shdrs = get_data (NULL, file, elf_header.e_shoff,
3721 elf_header.e_shentsize, num, _("section headers"));
3725 section_headers = cmalloc (num, sizeof (Elf_Internal_Shdr));
3727 if (section_headers == NULL)
3729 error (_("Out of memory\n"));
3733 for (i = 0, internal = section_headers;
3737 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
3738 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
3739 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
3740 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
3741 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
3742 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
3743 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
3744 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
3745 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
3746 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
3754 static Elf_Internal_Sym *
3755 get_32bit_elf_symbols (FILE *file, Elf_Internal_Shdr *section)
3757 unsigned long number;
3758 Elf32_External_Sym *esyms;
3759 Elf_External_Sym_Shndx *shndx;
3760 Elf_Internal_Sym *isyms;
3761 Elf_Internal_Sym *psym;
3764 esyms = get_data (NULL, file, section->sh_offset, 1, section->sh_size,
3770 if (symtab_shndx_hdr != NULL
3771 && (symtab_shndx_hdr->sh_link
3772 == (unsigned long) SECTION_HEADER_NUM (section - section_headers)))
3774 shndx = get_data (NULL, file, symtab_shndx_hdr->sh_offset,
3775 1, symtab_shndx_hdr->sh_size, _("symtab shndx"));
3783 number = section->sh_size / section->sh_entsize;
3784 isyms = cmalloc (number, sizeof (Elf_Internal_Sym));
3788 error (_("Out of memory\n"));
3795 for (j = 0, psym = isyms;
3799 psym->st_name = BYTE_GET (esyms[j].st_name);
3800 psym->st_value = BYTE_GET (esyms[j].st_value);
3801 psym->st_size = BYTE_GET (esyms[j].st_size);
3802 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
3803 if (psym->st_shndx == SHN_XINDEX && shndx != NULL)
3805 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
3806 psym->st_info = BYTE_GET (esyms[j].st_info);
3807 psym->st_other = BYTE_GET (esyms[j].st_other);
3817 static Elf_Internal_Sym *
3818 get_64bit_elf_symbols (FILE *file, Elf_Internal_Shdr *section)
3820 unsigned long number;
3821 Elf64_External_Sym *esyms;
3822 Elf_External_Sym_Shndx *shndx;
3823 Elf_Internal_Sym *isyms;
3824 Elf_Internal_Sym *psym;
3827 esyms = get_data (NULL, file, section->sh_offset, 1, section->sh_size,
3833 if (symtab_shndx_hdr != NULL
3834 && (symtab_shndx_hdr->sh_link
3835 == (unsigned long) SECTION_HEADER_NUM (section - section_headers)))
3837 shndx = get_data (NULL, file, symtab_shndx_hdr->sh_offset,
3838 1, symtab_shndx_hdr->sh_size, _("symtab shndx"));
3846 number = section->sh_size / section->sh_entsize;
3847 isyms = cmalloc (number, sizeof (Elf_Internal_Sym));
3851 error (_("Out of memory\n"));
3858 for (j = 0, psym = isyms;
3862 psym->st_name = BYTE_GET (esyms[j].st_name);
3863 psym->st_info = BYTE_GET (esyms[j].st_info);
3864 psym->st_other = BYTE_GET (esyms[j].st_other);
3865 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
3866 if (psym->st_shndx == SHN_XINDEX && shndx != NULL)
3868 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
3869 psym->st_value = BYTE_GET (esyms[j].st_value);
3870 psym->st_size = BYTE_GET (esyms[j].st_size);
3881 get_elf_section_flags (bfd_vma sh_flags)
3883 static char buff[1024];
3885 int field_size = is_32bit_elf ? 8 : 16;
3886 int index, size = sizeof (buff) - (field_size + 4 + 1);
3887 bfd_vma os_flags = 0;
3888 bfd_vma proc_flags = 0;
3889 bfd_vma unknown_flags = 0;
3903 { "LINK ORDER", 10 },
3904 { "OS NONCONF", 10 },
3909 if (do_section_details)
3911 sprintf (buff, "[%*.*lx]: ",
3912 field_size, field_size, (unsigned long) sh_flags);
3913 p += field_size + 4;
3920 flag = sh_flags & - sh_flags;
3923 if (do_section_details)
3927 case SHF_WRITE: index = 0; break;
3928 case SHF_ALLOC: index = 1; break;
3929 case SHF_EXECINSTR: index = 2; break;
3930 case SHF_MERGE: index = 3; break;
3931 case SHF_STRINGS: index = 4; break;
3932 case SHF_INFO_LINK: index = 5; break;
3933 case SHF_LINK_ORDER: index = 6; break;
3934 case SHF_OS_NONCONFORMING: index = 7; break;
3935 case SHF_GROUP: index = 8; break;
3936 case SHF_TLS: index = 9; break;
3945 if (p != buff + field_size + 4)
3947 if (size < (10 + 2))
3954 size -= flags [index].len;
3955 p = stpcpy (p, flags [index].str);
3957 else if (flag & SHF_MASKOS)
3959 else if (flag & SHF_MASKPROC)
3962 unknown_flags |= flag;
3968 case SHF_WRITE: *p = 'W'; break;
3969 case SHF_ALLOC: *p = 'A'; break;
3970 case SHF_EXECINSTR: *p = 'X'; break;
3971 case SHF_MERGE: *p = 'M'; break;
3972 case SHF_STRINGS: *p = 'S'; break;
3973 case SHF_INFO_LINK: *p = 'I'; break;
3974 case SHF_LINK_ORDER: *p = 'L'; break;
3975 case SHF_OS_NONCONFORMING: *p = 'O'; break;
3976 case SHF_GROUP: *p = 'G'; break;
3977 case SHF_TLS: *p = 'T'; break;
3980 if (elf_header.e_machine == EM_X86_64
3981 && flag == SHF_X86_64_LARGE)
3983 else if (flag & SHF_MASKOS)
3986 sh_flags &= ~ SHF_MASKOS;
3988 else if (flag & SHF_MASKPROC)
3991 sh_flags &= ~ SHF_MASKPROC;
4001 if (do_section_details)
4005 size -= 5 + field_size;
4006 if (p != buff + field_size + 4)
4014 sprintf (p, "OS (%*.*lx)", field_size, field_size,
4015 (unsigned long) os_flags);
4016 p += 5 + field_size;
4020 size -= 7 + field_size;
4021 if (p != buff + field_size + 4)
4029 sprintf (p, "PROC (%*.*lx)", field_size, field_size,
4030 (unsigned long) proc_flags);
4031 p += 7 + field_size;
4035 size -= 10 + field_size;
4036 if (p != buff + field_size + 4)
4044 sprintf (p, "UNKNOWN (%*.*lx)", field_size, field_size,
4045 (unsigned long) unknown_flags);
4046 p += 10 + field_size;
4055 process_section_headers (FILE *file)
4057 Elf_Internal_Shdr *section;
4060 section_headers = NULL;
4062 if (elf_header.e_shnum == 0)
4065 printf (_("\nThere are no sections in this file.\n"));
4070 if (do_sections && !do_header)
4071 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
4072 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
4076 if (! get_32bit_section_headers (file, elf_header.e_shnum))
4079 else if (! get_64bit_section_headers (file, elf_header.e_shnum))
4082 /* Read in the string table, so that we have names to display. */
4083 if (elf_header.e_shstrndx != SHN_UNDEF
4084 && SECTION_HEADER_INDEX (elf_header.e_shstrndx) < elf_header.e_shnum)
4086 section = SECTION_HEADER (elf_header.e_shstrndx);
4088 if (section->sh_size != 0)
4090 string_table = get_data (NULL, file, section->sh_offset,
4091 1, section->sh_size, _("string table"));
4093 string_table_length = string_table != NULL ? section->sh_size : 0;
4097 /* Scan the sections for the dynamic symbol table
4098 and dynamic string table and debug sections. */
4099 dynamic_symbols = NULL;
4100 dynamic_strings = NULL;
4101 dynamic_syminfo = NULL;
4102 symtab_shndx_hdr = NULL;
4104 eh_addr_size = is_32bit_elf ? 4 : 8;
4105 switch (elf_header.e_machine)
4108 case EM_MIPS_RS3_LE:
4109 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
4110 FDE addresses. However, the ABI also has a semi-official ILP32
4111 variant for which the normal FDE address size rules apply.
4113 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
4114 section, where XX is the size of longs in bits. Unfortunately,
4115 earlier compilers provided no way of distinguishing ILP32 objects
4116 from LP64 objects, so if there's any doubt, we should assume that
4117 the official LP64 form is being used. */
4118 if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
4119 && find_section (".gcc_compiled_long32") == NULL)
4125 switch (elf_header.e_flags & EF_H8_MACH)
4127 case E_H8_MACH_H8300:
4128 case E_H8_MACH_H8300HN:
4129 case E_H8_MACH_H8300SN:
4130 case E_H8_MACH_H8300SXN:
4133 case E_H8_MACH_H8300H:
4134 case E_H8_MACH_H8300S:
4135 case E_H8_MACH_H8300SX:
4141 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
4144 size_t expected_entsize \
4145 = is_32bit_elf ? size32 : size64; \
4146 if (section->sh_entsize != expected_entsize) \
4147 error (_("Section %d has invalid sh_entsize %lx (expected %lx)\n"), \
4148 i, (unsigned long int) section->sh_entsize, \
4149 (unsigned long int) expected_entsize); \
4150 section->sh_entsize = expected_entsize; \
4153 #define CHECK_ENTSIZE(section, i, type) \
4154 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
4155 sizeof (Elf64_External_##type))
4157 for (i = 0, section = section_headers;
4158 i < elf_header.e_shnum;
4161 char *name = SECTION_NAME (section);
4163 if (section->sh_type == SHT_DYNSYM)
4165 if (dynamic_symbols != NULL)
4167 error (_("File contains multiple dynamic symbol tables\n"));
4171 CHECK_ENTSIZE (section, i, Sym);
4172 num_dynamic_syms = section->sh_size / section->sh_entsize;
4173 dynamic_symbols = GET_ELF_SYMBOLS (file, section);
4175 else if (section->sh_type == SHT_STRTAB
4176 && streq (name, ".dynstr"))
4178 if (dynamic_strings != NULL)
4180 error (_("File contains multiple dynamic string tables\n"));
4184 dynamic_strings = get_data (NULL, file, section->sh_offset,
4185 1, section->sh_size, _("dynamic strings"));
4186 dynamic_strings_length = section->sh_size;
4188 else if (section->sh_type == SHT_SYMTAB_SHNDX)
4190 if (symtab_shndx_hdr != NULL)
4192 error (_("File contains multiple symtab shndx tables\n"));
4195 symtab_shndx_hdr = section;
4197 else if (section->sh_type == SHT_SYMTAB)
4198 CHECK_ENTSIZE (section, i, Sym);
4199 else if (section->sh_type == SHT_GROUP)
4200 CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
4201 else if (section->sh_type == SHT_REL)
4202 CHECK_ENTSIZE (section, i, Rel);
4203 else if (section->sh_type == SHT_RELA)
4204 CHECK_ENTSIZE (section, i, Rela);
4205 else if ((do_debugging || do_debug_info || do_debug_abbrevs
4206 || do_debug_lines || do_debug_pubnames || do_debug_aranges
4207 || do_debug_frames || do_debug_macinfo || do_debug_str
4208 || do_debug_loc || do_debug_ranges)
4209 && const_strneq (name, ".debug_"))
4214 || (do_debug_info && streq (name, "info"))
4215 || (do_debug_abbrevs && streq (name, "abbrev"))
4216 || (do_debug_lines && streq (name, "line"))
4217 || (do_debug_pubnames && streq (name, "pubnames"))
4218 || (do_debug_aranges && streq (name, "aranges"))
4219 || (do_debug_ranges && streq (name, "ranges"))
4220 || (do_debug_frames && streq (name, "frame"))
4221 || (do_debug_macinfo && streq (name, "macinfo"))
4222 || (do_debug_str && streq (name, "str"))
4223 || (do_debug_loc && streq (name, "loc"))
4225 request_dump_bynumber (i, DEBUG_DUMP);
4227 /* linkonce section to be combined with .debug_info at link time. */
4228 else if ((do_debugging || do_debug_info)
4229 && const_strneq (name, ".gnu.linkonce.wi."))
4230 request_dump_bynumber (i, DEBUG_DUMP);
4231 else if (do_debug_frames && streq (name, ".eh_frame"))
4232 request_dump_bynumber (i, DEBUG_DUMP);
4238 if (elf_header.e_shnum > 1)
4239 printf (_("\nSection Headers:\n"));
4241 printf (_("\nSection Header:\n"));
4245 if (do_section_details)
4247 printf (_(" [Nr] Name\n"));
4248 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
4252 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
4256 if (do_section_details)
4258 printf (_(" [Nr] Name\n"));
4259 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
4263 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
4267 if (do_section_details)
4269 printf (_(" [Nr] Name\n"));
4270 printf (_(" Type Address Offset Link\n"));
4271 printf (_(" Size EntSize Info Align\n"));
4275 printf (_(" [Nr] Name Type Address Offset\n"));
4276 printf (_(" Size EntSize Flags Link Info Align\n"));
4280 if (do_section_details)
4281 printf (_(" Flags\n"));
4283 for (i = 0, section = section_headers;
4284 i < elf_header.e_shnum;
4287 if (do_section_details)
4289 printf (" [%2u] %s\n",
4290 SECTION_HEADER_NUM (i),
4291 SECTION_NAME (section));
4292 if (is_32bit_elf || do_wide)
4293 printf (" %-15.15s ",
4294 get_section_type_name (section->sh_type));
4297 printf (" [%2u] %-17.17s %-15.15s ",
4298 SECTION_HEADER_NUM (i),
4299 SECTION_NAME (section),
4300 get_section_type_name (section->sh_type));
4304 print_vma (section->sh_addr, LONG_HEX);
4306 printf ( " %6.6lx %6.6lx %2.2lx",
4307 (unsigned long) section->sh_offset,
4308 (unsigned long) section->sh_size,
4309 (unsigned long) section->sh_entsize);
4311 if (do_section_details)
4312 fputs (" ", stdout);
4314 printf (" %3s ", get_elf_section_flags (section->sh_flags));
4316 printf ("%2ld %3lu %2ld\n",
4317 (unsigned long) section->sh_link,
4318 (unsigned long) section->sh_info,
4319 (unsigned long) section->sh_addralign);
4323 print_vma (section->sh_addr, LONG_HEX);
4325 if ((long) section->sh_offset == section->sh_offset)
4326 printf (" %6.6lx", (unsigned long) section->sh_offset);
4330 print_vma (section->sh_offset, LONG_HEX);
4333 if ((unsigned long) section->sh_size == section->sh_size)
4334 printf (" %6.6lx", (unsigned long) section->sh_size);
4338 print_vma (section->sh_size, LONG_HEX);
4341 if ((unsigned long) section->sh_entsize == section->sh_entsize)
4342 printf (" %2.2lx", (unsigned long) section->sh_entsize);
4346 print_vma (section->sh_entsize, LONG_HEX);
4349 if (do_section_details)
4350 fputs (" ", stdout);
4352 printf (" %3s ", get_elf_section_flags (section->sh_flags));
4354 printf ("%2ld %3lu ",
4355 (unsigned long) section->sh_link,
4356 (unsigned long) section->sh_info);
4358 if ((unsigned long) section->sh_addralign == section->sh_addralign)
4359 printf ("%2ld\n", (unsigned long) section->sh_addralign);
4362 print_vma (section->sh_addralign, DEC);
4366 else if (do_section_details)
4368 printf (" %-15.15s ",
4369 get_section_type_name (section->sh_type));
4370 print_vma (section->sh_addr, LONG_HEX);
4371 if ((long) section->sh_offset == section->sh_offset)
4372 printf (" %16.16lx", (unsigned long) section->sh_offset);
4376 print_vma (section->sh_offset, LONG_HEX);
4378 printf (" %ld\n ", (unsigned long) section->sh_link);
4379 print_vma (section->sh_size, LONG_HEX);
4381 print_vma (section->sh_entsize, LONG_HEX);
4383 printf (" %-16lu %ld\n",
4384 (unsigned long) section->sh_info,
4385 (unsigned long) section->sh_addralign);
4390 print_vma (section->sh_addr, LONG_HEX);
4391 if ((long) section->sh_offset == section->sh_offset)
4392 printf (" %8.8lx", (unsigned long) section->sh_offset);
4396 print_vma (section->sh_offset, LONG_HEX);
4399 print_vma (section->sh_size, LONG_HEX);
4401 print_vma (section->sh_entsize, LONG_HEX);
4403 printf (" %3s ", get_elf_section_flags (section->sh_flags));
4405 printf (" %2ld %3lu %ld\n",
4406 (unsigned long) section->sh_link,
4407 (unsigned long) section->sh_info,
4408 (unsigned long) section->sh_addralign);
4411 if (do_section_details)
4412 printf (" %s\n", get_elf_section_flags (section->sh_flags));
4415 if (!do_section_details)
4416 printf (_("Key to Flags:\n\
4417 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
4418 I (info), L (link order), G (group), x (unknown)\n\
4419 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
4425 get_group_flags (unsigned int flags)
4427 static char buff[32];
4434 snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x]"), flags);
4441 process_section_groups (FILE *file)
4443 Elf_Internal_Shdr *section;
4445 struct group *group;
4446 Elf_Internal_Shdr *symtab_sec, *strtab_sec;
4447 Elf_Internal_Sym *symtab;
4451 /* Don't process section groups unless needed. */
4452 if (!do_unwind && !do_section_groups)
4455 if (elf_header.e_shnum == 0)
4457 if (do_section_groups)
4458 printf (_("\nThere are no sections in this file.\n"));
4463 if (section_headers == NULL)
4465 error (_("Section headers are not available!\n"));
4469 section_headers_groups = calloc (elf_header.e_shnum,
4470 sizeof (struct group *));
4472 if (section_headers_groups == NULL)
4474 error (_("Out of memory\n"));
4478 /* Scan the sections for the group section. */
4480 for (i = 0, section = section_headers;
4481 i < elf_header.e_shnum;
4483 if (section->sh_type == SHT_GROUP)
4486 if (group_count == 0)
4488 if (do_section_groups)
4489 printf (_("\nThere are no section groups in this file.\n"));
4494 section_groups = calloc (group_count, sizeof (struct group));
4496 if (section_groups == NULL)
4498 error (_("Out of memory\n"));
4507 for (i = 0, section = section_headers, group = section_groups;
4508 i < elf_header.e_shnum;
4511 if (section->sh_type == SHT_GROUP)
4513 char *name = SECTION_NAME (section);
4515 unsigned char *start, *indices;
4516 unsigned int entry, j, size;
4517 Elf_Internal_Shdr *sec;
4518 Elf_Internal_Sym *sym;
4520 /* Get the symbol table. */
4521 if (SECTION_HEADER_INDEX (section->sh_link) >= elf_header.e_shnum
4522 || ((sec = SECTION_HEADER (section->sh_link))->sh_type
4525 error (_("Bad sh_link in group section `%s'\n"), name);
4529 if (symtab_sec != sec)
4534 symtab = GET_ELF_SYMBOLS (file, symtab_sec);
4537 sym = symtab + section->sh_info;
4539 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
4541 bfd_vma sec_index = SECTION_HEADER_INDEX (sym->st_shndx);
4544 error (_("Bad sh_info in group section `%s'\n"), name);
4548 group_name = SECTION_NAME (section_headers + sec_index);
4557 /* Get the string table. */
4558 if (SECTION_HEADER_INDEX (symtab_sec->sh_link)
4559 >= elf_header.e_shnum)
4568 != (sec = SECTION_HEADER (symtab_sec->sh_link)))
4573 strtab = get_data (NULL, file, strtab_sec->sh_offset,
4574 1, strtab_sec->sh_size,
4576 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
4578 group_name = sym->st_name < strtab_size
4579 ? strtab + sym->st_name : "<corrupt>";
4582 start = get_data (NULL, file, section->sh_offset,
4583 1, section->sh_size, _("section data"));
4586 size = (section->sh_size / section->sh_entsize) - 1;
4587 entry = byte_get (indices, 4);
4590 if (do_section_groups)
4592 printf ("\n%s group section [%5u] `%s' [%s] contains %u sections:\n",
4593 get_group_flags (entry), i, name, group_name, size);
4595 printf (_(" [Index] Name\n"));
4598 group->group_index = i;
4600 for (j = 0; j < size; j++)
4602 struct group_list *g;
4604 entry = byte_get (indices, 4);
4607 if (SECTION_HEADER_INDEX (entry) >= elf_header.e_shnum)
4609 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
4610 entry, i, elf_header.e_shnum - 1);
4613 else if (entry >= SHN_LORESERVE && entry <= SHN_HIRESERVE)
4615 error (_("invalid section [%5u] in group section [%5u]\n"),
4620 if (section_headers_groups [SECTION_HEADER_INDEX (entry)]
4625 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
4627 section_headers_groups [SECTION_HEADER_INDEX (entry)]->group_index);
4632 /* Intel C/C++ compiler may put section 0 in a
4633 section group. We just warn it the first time
4634 and ignore it afterwards. */
4635 static int warned = 0;
4638 error (_("section 0 in group section [%5u]\n"),
4639 section_headers_groups [SECTION_HEADER_INDEX (entry)]->group_index);
4645 section_headers_groups [SECTION_HEADER_INDEX (entry)]
4648 if (do_section_groups)
4650 sec = SECTION_HEADER (entry);
4651 printf (" [%5u] %s\n", entry, SECTION_NAME (sec));
4654 g = xmalloc (sizeof (struct group_list));
4655 g->section_index = entry;
4656 g->next = group->root;
4680 } dynamic_relocations [] =
4682 { "REL", DT_REL, DT_RELSZ, FALSE },
4683 { "RELA", DT_RELA, DT_RELASZ, TRUE },
4684 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
4687 /* Process the reloc section. */
4690 process_relocs (FILE *file)
4692 unsigned long rel_size;
4693 unsigned long rel_offset;
4699 if (do_using_dynamic)
4703 int has_dynamic_reloc;
4706 has_dynamic_reloc = 0;
4708 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
4710 is_rela = dynamic_relocations [i].rela;
4711 name = dynamic_relocations [i].name;
4712 rel_size = dynamic_info [dynamic_relocations [i].size];
4713 rel_offset = dynamic_info [dynamic_relocations [i].reloc];
4715 has_dynamic_reloc |= rel_size;
4717 if (is_rela == UNKNOWN)
4719 if (dynamic_relocations [i].reloc == DT_JMPREL)
4720 switch (dynamic_info[DT_PLTREL])
4734 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
4735 name, rel_offset, rel_size);
4737 dump_relocations (file,
4738 offset_from_vma (file, rel_offset, rel_size),
4740 dynamic_symbols, num_dynamic_syms,
4741 dynamic_strings, dynamic_strings_length, is_rela);
4745 if (! has_dynamic_reloc)
4746 printf (_("\nThere are no dynamic relocations in this file.\n"));
4750 Elf_Internal_Shdr *section;
4754 for (i = 0, section = section_headers;
4755 i < elf_header.e_shnum;
4758 if ( section->sh_type != SHT_RELA
4759 && section->sh_type != SHT_REL)
4762 rel_offset = section->sh_offset;
4763 rel_size = section->sh_size;
4767 Elf_Internal_Shdr *strsec;
4770 printf (_("\nRelocation section "));
4772 if (string_table == NULL)
4773 printf ("%d", section->sh_name);
4775 printf (_("'%s'"), SECTION_NAME (section));
4777 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4778 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
4780 is_rela = section->sh_type == SHT_RELA;
4782 if (section->sh_link
4783 && SECTION_HEADER_INDEX (section->sh_link)
4784 < elf_header.e_shnum)
4786 Elf_Internal_Shdr *symsec;
4787 Elf_Internal_Sym *symtab;
4788 unsigned long nsyms;
4789 unsigned long strtablen = 0;
4790 char *strtab = NULL;
4792 symsec = SECTION_HEADER (section->sh_link);
4793 if (symsec->sh_type != SHT_SYMTAB
4794 && symsec->sh_type != SHT_DYNSYM)
4797 nsyms = symsec->sh_size / symsec->sh_entsize;
4798 symtab = GET_ELF_SYMBOLS (file, symsec);
4803 if (SECTION_HEADER_INDEX (symsec->sh_link)
4804 < elf_header.e_shnum)
4806 strsec = SECTION_HEADER (symsec->sh_link);
4808 strtab = get_data (NULL, file, strsec->sh_offset,
4811 strtablen = strtab == NULL ? 0 : strsec->sh_size;
4814 dump_relocations (file, rel_offset, rel_size,
4815 symtab, nsyms, strtab, strtablen, is_rela);
4821 dump_relocations (file, rel_offset, rel_size,
4822 NULL, 0, NULL, 0, is_rela);
4829 printf (_("\nThere are no relocations in this file.\n"));
4835 /* Process the unwind section. */
4837 #include "unwind-ia64.h"
4839 /* An absolute address consists of a section and an offset. If the
4840 section is NULL, the offset itself is the address, otherwise, the
4841 address equals to LOAD_ADDRESS(section) + offset. */
4845 unsigned short section;
4849 #define ABSADDR(a) \
4851 ? section_headers [(a).section].sh_addr + (a).offset \
4854 struct ia64_unw_aux_info
4856 struct ia64_unw_table_entry
4858 struct absaddr start;
4860 struct absaddr info;
4862 *table; /* Unwind table. */
4863 unsigned long table_len; /* Length of unwind table. */
4864 unsigned char *info; /* Unwind info. */
4865 unsigned long info_size; /* Size of unwind info. */
4866 bfd_vma info_addr; /* starting address of unwind info. */
4867 bfd_vma seg_base; /* Starting address of segment. */
4868 Elf_Internal_Sym *symtab; /* The symbol table. */
4869 unsigned long nsyms; /* Number of symbols. */
4870 char *strtab; /* The string table. */
4871 unsigned long strtab_size; /* Size of string table. */
4875 find_symbol_for_address (Elf_Internal_Sym *symtab,
4876 unsigned long nsyms,
4878 unsigned long strtab_size,
4879 struct absaddr addr,
4880 const char **symname,
4883 bfd_vma dist = 0x100000;
4884 Elf_Internal_Sym *sym, *best = NULL;
4887 for (i = 0, sym = symtab; i < nsyms; ++i, ++sym)
4889 if (ELF_ST_TYPE (sym->st_info) == STT_FUNC
4890 && sym->st_name != 0
4891 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
4892 && addr.offset >= sym->st_value
4893 && addr.offset - sym->st_value < dist)
4896 dist = addr.offset - sym->st_value;
4903 *symname = (best->st_name >= strtab_size
4904 ? "<corrupt>" : strtab + best->st_name);
4909 *offset = addr.offset;
4913 dump_ia64_unwind (struct ia64_unw_aux_info *aux)
4915 struct ia64_unw_table_entry *tp;
4918 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
4922 const unsigned char *dp;
4923 const unsigned char *head;
4924 const char *procname;
4926 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
4927 aux->strtab_size, tp->start, &procname, &offset);
4929 fputs ("\n<", stdout);
4933 fputs (procname, stdout);
4936 printf ("+%lx", (unsigned long) offset);
4939 fputs (">: [", stdout);
4940 print_vma (tp->start.offset, PREFIX_HEX);
4941 fputc ('-', stdout);
4942 print_vma (tp->end.offset, PREFIX_HEX);
4943 printf ("], info at +0x%lx\n",
4944 (unsigned long) (tp->info.offset - aux->seg_base));
4946 head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
4947 stamp = byte_get ((unsigned char *) head, sizeof (stamp));
4949 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4950 (unsigned) UNW_VER (stamp),
4951 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
4952 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
4953 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
4954 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
4956 if (UNW_VER (stamp) != 1)
4958 printf ("\tUnknown version.\n");
4963 for (dp = head + 8; dp < head + 8 + eh_addr_size * UNW_LENGTH (stamp);)
4964 dp = unw_decode (dp, in_body, & in_body);
4969 slurp_ia64_unwind_table (FILE *file,
4970 struct ia64_unw_aux_info *aux,
4971 Elf_Internal_Shdr *sec)
4973 unsigned long size, nrelas, i;
4974 Elf_Internal_Phdr *seg;
4975 struct ia64_unw_table_entry *tep;
4976 Elf_Internal_Shdr *relsec;
4977 Elf_Internal_Rela *rela, *rp;
4978 unsigned char *table, *tp;
4979 Elf_Internal_Sym *sym;
4980 const char *relname;
4982 /* First, find the starting address of the segment that includes
4985 if (elf_header.e_phnum)
4987 if (! get_program_headers (file))
4990 for (seg = program_headers;
4991 seg < program_headers + elf_header.e_phnum;
4994 if (seg->p_type != PT_LOAD)
4997 if (sec->sh_addr >= seg->p_vaddr
4998 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
5000 aux->seg_base = seg->p_vaddr;
5006 /* Second, build the unwind table from the contents of the unwind section: */
5007 size = sec->sh_size;
5008 table = get_data (NULL, file, sec->sh_offset, 1, size, _("unwind table"));
5012 aux->table = xcmalloc (size / (3 * eh_addr_size), sizeof (aux->table[0]));
5014 for (tp = table; tp < table + size; tp += 3 * eh_addr_size, ++tep)
5016 tep->start.section = SHN_UNDEF;
5017 tep->end.section = SHN_UNDEF;
5018 tep->info.section = SHN_UNDEF;
5021 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
5022 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
5023 tep->info.offset = byte_get ((unsigned char *) tp + 8, 4);
5027 tep->start.offset = BYTE_GET ((unsigned char *) tp + 0);
5028 tep->end.offset = BYTE_GET ((unsigned char *) tp + 8);
5029 tep->info.offset = BYTE_GET ((unsigned char *) tp + 16);
5031 tep->start.offset += aux->seg_base;
5032 tep->end.offset += aux->seg_base;
5033 tep->info.offset += aux->seg_base;
5037 /* Third, apply any relocations to the unwind table: */
5039 for (relsec = section_headers;
5040 relsec < section_headers + elf_header.e_shnum;
5043 if (relsec->sh_type != SHT_RELA
5044 || SECTION_HEADER_INDEX (relsec->sh_info) >= elf_header.e_shnum
5045 || SECTION_HEADER (relsec->sh_info) != sec)
5048 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
5052 for (rp = rela; rp < rela + nrelas; ++rp)
5054 relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
5055 sym = aux->symtab + get_reloc_symindex (rp->r_info);
5057 if (! const_strneq (relname, "R_IA64_SEGREL"))
5059 warn (_("Skipping unexpected relocation type %s\n"), relname);
5063 i = rp->r_offset / (3 * eh_addr_size);
5065 switch (rp->r_offset/eh_addr_size % 3)
5068 aux->table[i].start.section = sym->st_shndx;
5069 aux->table[i].start.offset += rp->r_addend + sym->st_value;
5072 aux->table[i].end.section = sym->st_shndx;
5073 aux->table[i].end.offset += rp->r_addend + sym->st_value;
5076 aux->table[i].info.section = sym->st_shndx;
5077 aux->table[i].info.offset += rp->r_addend + sym->st_value;
5087 aux->table_len = size / (3 * eh_addr_size);
5092 ia64_process_unwind (FILE *file)
5094 Elf_Internal_Shdr *sec, *unwsec = NULL, *strsec;
5095 unsigned long i, unwcount = 0, unwstart = 0;
5096 struct ia64_unw_aux_info aux;
5098 memset (& aux, 0, sizeof (aux));
5100 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
5102 if (sec->sh_type == SHT_SYMTAB
5103 && SECTION_HEADER_INDEX (sec->sh_link) < elf_header.e_shnum)
5105 aux.nsyms = sec->sh_size / sec->sh_entsize;
5106 aux.symtab = GET_ELF_SYMBOLS (file, sec);
5108 strsec = SECTION_HEADER (sec->sh_link);
5109 aux.strtab = get_data (NULL, file, strsec->sh_offset,
5110 1, strsec->sh_size, _("string table"));
5111 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
5113 else if (sec->sh_type == SHT_IA_64_UNWIND)
5118 printf (_("\nThere are no unwind sections in this file.\n"));
5120 while (unwcount-- > 0)
5125 for (i = unwstart, sec = section_headers + unwstart;
5126 i < elf_header.e_shnum; ++i, ++sec)
5127 if (sec->sh_type == SHT_IA_64_UNWIND)
5134 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
5136 if ((unwsec->sh_flags & SHF_GROUP) != 0)
5138 /* We need to find which section group it is in. */
5139 struct group_list *g = section_headers_groups [i]->root;
5141 for (; g != NULL; g = g->next)
5143 sec = SECTION_HEADER (g->section_index);
5145 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
5150 i = elf_header.e_shnum;
5152 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
5154 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
5155 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
5156 suffix = SECTION_NAME (unwsec) + len;
5157 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
5159 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
5160 && streq (SECTION_NAME (sec) + len2, suffix))
5165 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
5166 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
5167 len = sizeof (ELF_STRING_ia64_unwind) - 1;
5168 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
5170 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
5171 suffix = SECTION_NAME (unwsec) + len;
5172 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
5174 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
5175 && streq (SECTION_NAME (sec) + len2, suffix))
5179 if (i == elf_header.e_shnum)
5181 printf (_("\nCould not find unwind info section for "));
5183 if (string_table == NULL)
5184 printf ("%d", unwsec->sh_name);
5186 printf (_("'%s'"), SECTION_NAME (unwsec));
5190 aux.info_size = sec->sh_size;
5191 aux.info_addr = sec->sh_addr;
5192 aux.info = get_data (NULL, file, sec->sh_offset, 1, aux.info_size,
5195 printf (_("\nUnwind section "));
5197 if (string_table == NULL)
5198 printf ("%d", unwsec->sh_name);
5200 printf (_("'%s'"), SECTION_NAME (unwsec));
5202 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5203 (unsigned long) unwsec->sh_offset,
5204 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
5206 (void) slurp_ia64_unwind_table (file, & aux, unwsec);
5208 if (aux.table_len > 0)
5209 dump_ia64_unwind (& aux);
5212 free ((char *) aux.table);
5214 free ((char *) aux.info);
5223 free ((char *) aux.strtab);
5228 struct hppa_unw_aux_info
5230 struct hppa_unw_table_entry
5232 struct absaddr start;
5234 unsigned int Cannot_unwind:1; /* 0 */
5235 unsigned int Millicode:1; /* 1 */
5236 unsigned int Millicode_save_sr0:1; /* 2 */
5237 unsigned int Region_description:2; /* 3..4 */
5238 unsigned int reserved1:1; /* 5 */
5239 unsigned int Entry_SR:1; /* 6 */
5240 unsigned int Entry_FR:4; /* number saved */ /* 7..10 */
5241 unsigned int Entry_GR:5; /* number saved */ /* 11..15 */
5242 unsigned int Args_stored:1; /* 16 */
5243 unsigned int Variable_Frame:1; /* 17 */
5244 unsigned int Separate_Package_Body:1; /* 18 */
5245 unsigned int Frame_Extension_Millicode:1; /* 19 */
5246 unsigned int Stack_Overflow_Check:1; /* 20 */
5247 unsigned int Two_Instruction_SP_Increment:1; /* 21 */
5248 unsigned int Ada_Region:1; /* 22 */
5249 unsigned int cxx_info:1; /* 23 */
5250 unsigned int cxx_try_catch:1; /* 24 */
5251 unsigned int sched_entry_seq:1; /* 25 */
5252 unsigned int reserved2:1; /* 26 */
5253 unsigned int Save_SP:1; /* 27 */
5254 unsigned int Save_RP:1; /* 28 */
5255 unsigned int Save_MRP_in_frame:1; /* 29 */
5256 unsigned int extn_ptr_defined:1; /* 30 */
5257 unsigned int Cleanup_defined:1; /* 31 */
5259 unsigned int MPE_XL_interrupt_marker:1; /* 0 */
5260 unsigned int HP_UX_interrupt_marker:1; /* 1 */
5261 unsigned int Large_frame:1; /* 2 */
5262 unsigned int Pseudo_SP_Set:1; /* 3 */
5263 unsigned int reserved4:1; /* 4 */
5264 unsigned int Total_frame_size:27; /* 5..31 */
5266 *table; /* Unwind table. */
5267 unsigned long table_len; /* Length of unwind table. */
5268 bfd_vma seg_base; /* Starting address of segment. */
5269 Elf_Internal_Sym *symtab; /* The symbol table. */
5270 unsigned long nsyms; /* Number of symbols. */
5271 char *strtab; /* The string table. */
5272 unsigned long strtab_size; /* Size of string table. */
5276 dump_hppa_unwind (struct hppa_unw_aux_info *aux)
5278 struct hppa_unw_table_entry *tp;
5280 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
5283 const char *procname;
5285 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
5286 aux->strtab_size, tp->start, &procname,
5289 fputs ("\n<", stdout);
5293 fputs (procname, stdout);
5296 printf ("+%lx", (unsigned long) offset);
5299 fputs (">: [", stdout);
5300 print_vma (tp->start.offset, PREFIX_HEX);
5301 fputc ('-', stdout);
5302 print_vma (tp->end.offset, PREFIX_HEX);
5305 #define PF(_m) if (tp->_m) printf (#_m " ");
5306 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
5309 PF(Millicode_save_sr0);
5310 /* PV(Region_description); */
5316 PF(Separate_Package_Body);
5317 PF(Frame_Extension_Millicode);
5318 PF(Stack_Overflow_Check);
5319 PF(Two_Instruction_SP_Increment);
5323 PF(sched_entry_seq);
5326 PF(Save_MRP_in_frame);
5327 PF(extn_ptr_defined);
5328 PF(Cleanup_defined);
5329 PF(MPE_XL_interrupt_marker);
5330 PF(HP_UX_interrupt_marker);
5333 PV(Total_frame_size);
5342 slurp_hppa_unwind_table (FILE *file,
5343 struct hppa_unw_aux_info *aux,
5344 Elf_Internal_Shdr *sec)
5346 unsigned long size, unw_ent_size, nentries, nrelas, i;
5347 Elf_Internal_Phdr *seg;
5348 struct hppa_unw_table_entry *tep;
5349 Elf_Internal_Shdr *relsec;
5350 Elf_Internal_Rela *rela, *rp;
5351 unsigned char *table, *tp;
5352 Elf_Internal_Sym *sym;
5353 const char *relname;
5355 /* First, find the starting address of the segment that includes
5358 if (elf_header.e_phnum)
5360 if (! get_program_headers (file))
5363 for (seg = program_headers;
5364 seg < program_headers + elf_header.e_phnum;
5367 if (seg->p_type != PT_LOAD)
5370 if (sec->sh_addr >= seg->p_vaddr
5371 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
5373 aux->seg_base = seg->p_vaddr;
5379 /* Second, build the unwind table from the contents of the unwind
5381 size = sec->sh_size;
5382 table = get_data (NULL, file, sec->sh_offset, 1, size, _("unwind table"));
5387 nentries = size / unw_ent_size;
5388 size = unw_ent_size * nentries;
5390 tep = aux->table = xcmalloc (nentries, sizeof (aux->table[0]));
5392 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
5394 unsigned int tmp1, tmp2;
5396 tep->start.section = SHN_UNDEF;
5397 tep->end.section = SHN_UNDEF;
5399 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
5400 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
5401 tmp1 = byte_get ((unsigned char *) tp + 8, 4);
5402 tmp2 = byte_get ((unsigned char *) tp + 12, 4);
5404 tep->start.offset += aux->seg_base;
5405 tep->end.offset += aux->seg_base;
5407 tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
5408 tep->Millicode = (tmp1 >> 30) & 0x1;
5409 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
5410 tep->Region_description = (tmp1 >> 27) & 0x3;
5411 tep->reserved1 = (tmp1 >> 26) & 0x1;
5412 tep->Entry_SR = (tmp1 >> 25) & 0x1;
5413 tep->Entry_FR = (tmp1 >> 21) & 0xf;
5414 tep->Entry_GR = (tmp1 >> 16) & 0x1f;
5415 tep->Args_stored = (tmp1 >> 15) & 0x1;
5416 tep->Variable_Frame = (tmp1 >> 14) & 0x1;
5417 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
5418 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
5419 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
5420 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
5421 tep->Ada_Region = (tmp1 >> 9) & 0x1;
5422 tep->cxx_info = (tmp1 >> 8) & 0x1;
5423 tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
5424 tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
5425 tep->reserved2 = (tmp1 >> 5) & 0x1;
5426 tep->Save_SP = (tmp1 >> 4) & 0x1;
5427 tep->Save_RP = (tmp1 >> 3) & 0x1;
5428 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
5429 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
5430 tep->Cleanup_defined = tmp1 & 0x1;
5432 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
5433 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
5434 tep->Large_frame = (tmp2 >> 29) & 0x1;
5435 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
5436 tep->reserved4 = (tmp2 >> 27) & 0x1;
5437 tep->Total_frame_size = tmp2 & 0x7ffffff;
5441 /* Third, apply any relocations to the unwind table. */
5443 for (relsec = section_headers;
5444 relsec < section_headers + elf_header.e_shnum;
5447 if (relsec->sh_type != SHT_RELA
5448 || SECTION_HEADER_INDEX (relsec->sh_info) >= elf_header.e_shnum
5449 || SECTION_HEADER (relsec->sh_info) != sec)
5452 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
5456 for (rp = rela; rp < rela + nrelas; ++rp)
5458 relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
5459 sym = aux->symtab + get_reloc_symindex (rp->r_info);
5461 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
5462 if (! const_strneq (relname, "R_PARISC_SEGREL"))
5464 warn (_("Skipping unexpected relocation type %s\n"), relname);
5468 i = rp->r_offset / unw_ent_size;
5470 switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
5473 aux->table[i].start.section = sym->st_shndx;
5474 aux->table[i].start.offset += sym->st_value + rp->r_addend;
5477 aux->table[i].end.section = sym->st_shndx;
5478 aux->table[i].end.offset += sym->st_value + rp->r_addend;
5488 aux->table_len = nentries;
5494 hppa_process_unwind (FILE *file)
5496 struct hppa_unw_aux_info aux;
5497 Elf_Internal_Shdr *unwsec = NULL;
5498 Elf_Internal_Shdr *strsec;
5499 Elf_Internal_Shdr *sec;
5502 memset (& aux, 0, sizeof (aux));
5504 if (string_table == NULL)
5507 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
5509 if (sec->sh_type == SHT_SYMTAB
5510 && SECTION_HEADER_INDEX (sec->sh_link) < elf_header.e_shnum)
5512 aux.nsyms = sec->sh_size / sec->sh_entsize;
5513 aux.symtab = GET_ELF_SYMBOLS (file, sec);
5515 strsec = SECTION_HEADER (sec->sh_link);
5516 aux.strtab = get_data (NULL, file, strsec->sh_offset,
5517 1, strsec->sh_size, _("string table"));
5518 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
5520 else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
5525 printf (_("\nThere are no unwind sections in this file.\n"));
5527 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
5529 if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
5531 printf (_("\nUnwind section "));
5532 printf (_("'%s'"), SECTION_NAME (sec));
5534 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5535 (unsigned long) sec->sh_offset,
5536 (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
5538 slurp_hppa_unwind_table (file, &aux, sec);
5539 if (aux.table_len > 0)
5540 dump_hppa_unwind (&aux);
5543 free ((char *) aux.table);
5551 free ((char *) aux.strtab);
5557 process_unwind (FILE *file)
5559 struct unwind_handler {
5561 int (*handler)(FILE *file);
5563 { EM_IA_64, ia64_process_unwind },
5564 { EM_PARISC, hppa_process_unwind },
5572 for (i = 0; handlers[i].handler != NULL; i++)
5573 if (elf_header.e_machine == handlers[i].machtype)
5574 return handlers[i].handler (file);
5576 printf (_("\nThere are no unwind sections in this file.\n"));
5581 dynamic_section_mips_val (Elf_Internal_Dyn *entry)
5583 switch (entry->d_tag)
5586 if (entry->d_un.d_val == 0)
5590 static const char * opts[] =
5592 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
5593 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
5594 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
5595 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
5600 for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
5601 if (entry->d_un.d_val & (1 << cnt))
5603 printf ("%s%s", first ? "" : " ", opts[cnt]);
5610 case DT_MIPS_IVERSION:
5611 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
5612 printf ("Interface Version: %s\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
5614 printf ("<corrupt: %ld>\n", (long) entry->d_un.d_ptr);
5617 case DT_MIPS_TIME_STAMP:
5622 time_t time = entry->d_un.d_val;
5623 tmp = gmtime (&time);
5624 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
5625 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
5626 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
5627 printf ("Time Stamp: %s\n", timebuf);
5631 case DT_MIPS_RLD_VERSION:
5632 case DT_MIPS_LOCAL_GOTNO:
5633 case DT_MIPS_CONFLICTNO:
5634 case DT_MIPS_LIBLISTNO:
5635 case DT_MIPS_SYMTABNO:
5636 case DT_MIPS_UNREFEXTNO:
5637 case DT_MIPS_HIPAGENO:
5638 case DT_MIPS_DELTA_CLASS_NO:
5639 case DT_MIPS_DELTA_INSTANCE_NO:
5640 case DT_MIPS_DELTA_RELOC_NO:
5641 case DT_MIPS_DELTA_SYM_NO:
5642 case DT_MIPS_DELTA_CLASSSYM_NO:
5643 case DT_MIPS_COMPACT_SIZE:
5644 printf ("%ld\n", (long) entry->d_un.d_ptr);
5648 printf ("%#lx\n", (long) entry->d_un.d_ptr);
5654 dynamic_section_parisc_val (Elf_Internal_Dyn *entry)
5656 switch (entry->d_tag)
5658 case DT_HP_DLD_FLAGS:
5667 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
5668 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
5669 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
5670 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
5671 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
5672 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
5673 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
5674 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
5675 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
5676 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
5677 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
5678 { DT_HP_GST, "HP_GST" },
5679 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
5680 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
5681 { DT_HP_NODELETE, "HP_NODELETE" },
5682 { DT_HP_GROUP, "HP_GROUP" },
5683 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
5687 bfd_vma val = entry->d_un.d_val;
5689 for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
5690 if (val & flags[cnt].bit)
5694 fputs (flags[cnt].str, stdout);
5696 val ^= flags[cnt].bit;
5699 if (val != 0 || first)
5703 print_vma (val, HEX);
5709 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
5716 dynamic_section_ia64_val (Elf_Internal_Dyn *entry)
5718 switch (entry->d_tag)
5720 case DT_IA_64_PLT_RESERVE:
5721 /* First 3 slots reserved. */
5722 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
5724 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
5728 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
5735 get_32bit_dynamic_section (FILE *file)
5737 Elf32_External_Dyn *edyn, *ext;
5738 Elf_Internal_Dyn *entry;
5740 edyn = get_data (NULL, file, dynamic_addr, 1, dynamic_size,
5741 _("dynamic section"));
5745 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5746 might not have the luxury of section headers. Look for the DT_NULL
5747 terminator to determine the number of entries. */
5748 for (ext = edyn, dynamic_nent = 0;
5749 (char *) ext < (char *) edyn + dynamic_size;
5753 if (BYTE_GET (ext->d_tag) == DT_NULL)
5757 dynamic_section = cmalloc (dynamic_nent, sizeof (*entry));
5758 if (dynamic_section == NULL)
5760 error (_("Out of memory\n"));
5765 for (ext = edyn, entry = dynamic_section;
5766 entry < dynamic_section + dynamic_nent;
5769 entry->d_tag = BYTE_GET (ext->d_tag);
5770 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
5779 get_64bit_dynamic_section (FILE *file)
5781 Elf64_External_Dyn *edyn, *ext;
5782 Elf_Internal_Dyn *entry;
5784 edyn = get_data (NULL, file, dynamic_addr, 1, dynamic_size,
5785 _("dynamic section"));
5789 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5790 might not have the luxury of section headers. Look for the DT_NULL
5791 terminator to determine the number of entries. */
5792 for (ext = edyn, dynamic_nent = 0;
5793 (char *) ext < (char *) edyn + dynamic_size;
5797 if (BYTE_GET (ext->d_tag) == DT_NULL)
5801 dynamic_section = cmalloc (dynamic_nent, sizeof (*entry));
5802 if (dynamic_section == NULL)
5804 error (_("Out of memory\n"));
5809 for (ext = edyn, entry = dynamic_section;
5810 entry < dynamic_section + dynamic_nent;
5813 entry->d_tag = BYTE_GET (ext->d_tag);
5814 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
5823 print_dynamic_flags (bfd_vma flags)
5831 flag = flags & - flags;
5841 case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
5842 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
5843 case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
5844 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
5845 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
5846 default: fputs ("unknown", stdout); break;
5852 /* Parse and display the contents of the dynamic section. */
5855 process_dynamic_section (FILE *file)
5857 Elf_Internal_Dyn *entry;
5859 if (dynamic_size == 0)
5862 printf (_("\nThere is no dynamic section in this file.\n"));
5869 if (! get_32bit_dynamic_section (file))
5872 else if (! get_64bit_dynamic_section (file))
5875 /* Find the appropriate symbol table. */
5876 if (dynamic_symbols == NULL)
5878 for (entry = dynamic_section;
5879 entry < dynamic_section + dynamic_nent;
5882 Elf_Internal_Shdr section;
5884 if (entry->d_tag != DT_SYMTAB)
5887 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
5889 /* Since we do not know how big the symbol table is,
5890 we default to reading in the entire file (!) and
5891 processing that. This is overkill, I know, but it
5893 section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
5895 if (archive_file_offset != 0)
5896 section.sh_size = archive_file_size - section.sh_offset;
5899 if (fseek (file, 0, SEEK_END))
5900 error (_("Unable to seek to end of file!\n"));
5902 section.sh_size = ftell (file) - section.sh_offset;
5906 section.sh_entsize = sizeof (Elf32_External_Sym);
5908 section.sh_entsize = sizeof (Elf64_External_Sym);
5910 num_dynamic_syms = section.sh_size / section.sh_entsize;
5911 if (num_dynamic_syms < 1)
5913 error (_("Unable to determine the number of symbols to load\n"));
5917 dynamic_symbols = GET_ELF_SYMBOLS (file, §ion);
5921 /* Similarly find a string table. */
5922 if (dynamic_strings == NULL)
5924 for (entry = dynamic_section;
5925 entry < dynamic_section + dynamic_nent;
5928 unsigned long offset;
5931 if (entry->d_tag != DT_STRTAB)
5934 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
5936 /* Since we do not know how big the string table is,
5937 we default to reading in the entire file (!) and
5938 processing that. This is overkill, I know, but it
5941 offset = offset_from_vma (file, entry->d_un.d_val, 0);
5943 if (archive_file_offset != 0)
5944 str_tab_len = archive_file_size - offset;
5947 if (fseek (file, 0, SEEK_END))
5948 error (_("Unable to seek to end of file\n"));
5949 str_tab_len = ftell (file) - offset;
5952 if (str_tab_len < 1)
5955 (_("Unable to determine the length of the dynamic string table\n"));
5959 dynamic_strings = get_data (NULL, file, offset, 1, str_tab_len,
5960 _("dynamic string table"));
5961 dynamic_strings_length = str_tab_len;
5966 /* And find the syminfo section if available. */
5967 if (dynamic_syminfo == NULL)
5969 unsigned long syminsz = 0;
5971 for (entry = dynamic_section;
5972 entry < dynamic_section + dynamic_nent;
5975 if (entry->d_tag == DT_SYMINENT)
5977 /* Note: these braces are necessary to avoid a syntax
5978 error from the SunOS4 C compiler. */
5979 assert (sizeof (Elf_External_Syminfo) == entry->d_un.d_val);
5981 else if (entry->d_tag == DT_SYMINSZ)
5982 syminsz = entry->d_un.d_val;
5983 else if (entry->d_tag == DT_SYMINFO)
5984 dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
5988 if (dynamic_syminfo_offset != 0 && syminsz != 0)
5990 Elf_External_Syminfo *extsyminfo, *extsym;
5991 Elf_Internal_Syminfo *syminfo;
5993 /* There is a syminfo section. Read the data. */
5994 extsyminfo = get_data (NULL, file, dynamic_syminfo_offset, 1,
5995 syminsz, _("symbol information"));
5999 dynamic_syminfo = malloc (syminsz);
6000 if (dynamic_syminfo == NULL)
6002 error (_("Out of memory\n"));
6006 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
6007 for (syminfo = dynamic_syminfo, extsym = extsyminfo;
6008 syminfo < dynamic_syminfo + dynamic_syminfo_nent;
6009 ++syminfo, ++extsym)
6011 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
6012 syminfo->si_flags = BYTE_GET (extsym->si_flags);
6019 if (do_dynamic && dynamic_addr)
6020 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
6021 dynamic_addr, dynamic_nent);
6023 printf (_(" Tag Type Name/Value\n"));
6025 for (entry = dynamic_section;
6026 entry < dynamic_section + dynamic_nent;
6034 print_vma (entry->d_tag, FULL_HEX);
6035 dtype = get_dynamic_type (entry->d_tag);
6036 printf (" (%s)%*s", dtype,
6037 ((is_32bit_elf ? 27 : 19)
6038 - (int) strlen (dtype)),
6042 switch (entry->d_tag)
6046 print_dynamic_flags (entry->d_un.d_val);
6056 switch (entry->d_tag)
6059 printf (_("Auxiliary library"));
6063 printf (_("Filter library"));
6067 printf (_("Configuration file"));
6071 printf (_("Dependency audit library"));
6075 printf (_("Audit library"));
6079 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
6080 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
6084 print_vma (entry->d_un.d_val, PREFIX_HEX);
6093 printf (_("Flags:"));
6095 if (entry->d_un.d_val == 0)
6096 printf (_(" None\n"));
6099 unsigned long int val = entry->d_un.d_val;
6101 if (val & DTF_1_PARINIT)
6103 printf (" PARINIT");
6104 val ^= DTF_1_PARINIT;
6106 if (val & DTF_1_CONFEXP)
6108 printf (" CONFEXP");
6109 val ^= DTF_1_CONFEXP;
6112 printf (" %lx", val);
6121 printf (_("Flags:"));
6123 if (entry->d_un.d_val == 0)
6124 printf (_(" None\n"));
6127 unsigned long int val = entry->d_un.d_val;
6129 if (val & DF_P1_LAZYLOAD)
6131 printf (" LAZYLOAD");
6132 val ^= DF_P1_LAZYLOAD;
6134 if (val & DF_P1_GROUPPERM)
6136 printf (" GROUPPERM");
6137 val ^= DF_P1_GROUPPERM;
6140 printf (" %lx", val);
6149 printf (_("Flags:"));
6150 if (entry->d_un.d_val == 0)
6151 printf (_(" None\n"));
6154 unsigned long int val = entry->d_un.d_val;
6161 if (val & DF_1_GLOBAL)
6166 if (val & DF_1_GROUP)
6171 if (val & DF_1_NODELETE)
6173 printf (" NODELETE");
6174 val ^= DF_1_NODELETE;
6176 if (val & DF_1_LOADFLTR)
6178 printf (" LOADFLTR");
6179 val ^= DF_1_LOADFLTR;
6181 if (val & DF_1_INITFIRST)
6183 printf (" INITFIRST");
6184 val ^= DF_1_INITFIRST;
6186 if (val & DF_1_NOOPEN)
6191 if (val & DF_1_ORIGIN)
6196 if (val & DF_1_DIRECT)
6201 if (val & DF_1_TRANS)
6206 if (val & DF_1_INTERPOSE)
6208 printf (" INTERPOSE");
6209 val ^= DF_1_INTERPOSE;
6211 if (val & DF_1_NODEFLIB)
6213 printf (" NODEFLIB");
6214 val ^= DF_1_NODEFLIB;
6216 if (val & DF_1_NODUMP)
6221 if (val & DF_1_CONLFAT)
6223 printf (" CONLFAT");
6224 val ^= DF_1_CONLFAT;
6227 printf (" %lx", val);
6234 dynamic_info[entry->d_tag] = entry->d_un.d_val;
6236 puts (get_dynamic_type (entry->d_un.d_val));
6256 dynamic_info[entry->d_tag] = entry->d_un.d_val;
6262 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
6263 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
6269 switch (entry->d_tag)
6272 printf (_("Shared library: [%s]"), name);
6274 if (streq (name, program_interpreter))
6275 printf (_(" program interpreter"));
6279 printf (_("Library soname: [%s]"), name);
6283 printf (_("Library rpath: [%s]"), name);
6287 printf (_("Library runpath: [%s]"), name);
6291 print_vma (entry->d_un.d_val, PREFIX_HEX);
6296 print_vma (entry->d_un.d_val, PREFIX_HEX);
6309 dynamic_info[entry->d_tag] = entry->d_un.d_val;
6313 case DT_INIT_ARRAYSZ:
6314 case DT_FINI_ARRAYSZ:
6315 case DT_GNU_CONFLICTSZ:
6316 case DT_GNU_LIBLISTSZ:
6319 print_vma (entry->d_un.d_val, UNSIGNED);
6320 printf (" (bytes)\n");
6330 print_vma (entry->d_un.d_val, UNSIGNED);
6343 if (entry->d_tag == DT_USED
6344 && VALID_DYNAMIC_NAME (entry->d_un.d_val))
6346 char *name = GET_DYNAMIC_NAME (entry->d_un.d_val);
6350 printf (_("Not needed object: [%s]\n"), name);
6355 print_vma (entry->d_un.d_val, PREFIX_HEX);
6361 /* The value of this entry is ignored. */
6366 case DT_GNU_PRELINKED:
6370 time_t time = entry->d_un.d_val;
6372 tmp = gmtime (&time);
6373 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
6374 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
6375 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
6381 dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
6384 print_vma (entry->d_un.d_val, PREFIX_HEX);
6390 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
6391 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
6396 switch (elf_header.e_machine)
6399 case EM_MIPS_RS3_LE:
6400 dynamic_section_mips_val (entry);
6403 dynamic_section_parisc_val (entry);
6406 dynamic_section_ia64_val (entry);
6409 print_vma (entry->d_un.d_val, PREFIX_HEX);
6421 get_ver_flags (unsigned int flags)
6423 static char buff[32];
6430 if (flags & VER_FLG_BASE)
6431 strcat (buff, "BASE ");
6433 if (flags & VER_FLG_WEAK)
6435 if (flags & VER_FLG_BASE)
6436 strcat (buff, "| ");
6438 strcat (buff, "WEAK ");
6441 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK))
6442 strcat (buff, "| <unknown>");
6447 /* Display the contents of the version sections. */
6449 process_version_sections (FILE *file)
6451 Elf_Internal_Shdr *section;
6458 for (i = 0, section = section_headers;
6459 i < elf_header.e_shnum;
6462 switch (section->sh_type)
6464 case SHT_GNU_verdef:
6466 Elf_External_Verdef *edefs;
6474 (_("\nVersion definition section '%s' contains %ld entries:\n"),
6475 SECTION_NAME (section), section->sh_info);
6477 printf (_(" Addr: 0x"));
6478 printf_vma (section->sh_addr);
6479 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
6480 (unsigned long) section->sh_offset, section->sh_link,
6481 SECTION_HEADER_INDEX (section->sh_link)
6482 < elf_header.e_shnum
6483 ? SECTION_NAME (SECTION_HEADER (section->sh_link))
6486 edefs = get_data (NULL, file, section->sh_offset, 1,
6488 _("version definition section"));
6489 endbuf = (char *) edefs + section->sh_size;
6493 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
6496 Elf_External_Verdef *edef;
6497 Elf_Internal_Verdef ent;
6498 Elf_External_Verdaux *eaux;
6499 Elf_Internal_Verdaux aux;
6503 vstart = ((char *) edefs) + idx;
6504 if (vstart + sizeof (*edef) > endbuf)
6507 edef = (Elf_External_Verdef *) vstart;
6509 ent.vd_version = BYTE_GET (edef->vd_version);
6510 ent.vd_flags = BYTE_GET (edef->vd_flags);
6511 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
6512 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
6513 ent.vd_hash = BYTE_GET (edef->vd_hash);
6514 ent.vd_aux = BYTE_GET (edef->vd_aux);
6515 ent.vd_next = BYTE_GET (edef->vd_next);
6517 printf (_(" %#06x: Rev: %d Flags: %s"),
6518 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
6520 printf (_(" Index: %d Cnt: %d "),
6521 ent.vd_ndx, ent.vd_cnt);
6523 vstart += ent.vd_aux;
6525 eaux = (Elf_External_Verdaux *) vstart;
6527 aux.vda_name = BYTE_GET (eaux->vda_name);
6528 aux.vda_next = BYTE_GET (eaux->vda_next);
6530 if (VALID_DYNAMIC_NAME (aux.vda_name))
6531 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
6533 printf (_("Name index: %ld\n"), aux.vda_name);
6535 isum = idx + ent.vd_aux;
6537 for (j = 1; j < ent.vd_cnt; j++)
6539 isum += aux.vda_next;
6540 vstart += aux.vda_next;
6542 eaux = (Elf_External_Verdaux *) vstart;
6543 if (vstart + sizeof (*eaux) > endbuf)
6546 aux.vda_name = BYTE_GET (eaux->vda_name);
6547 aux.vda_next = BYTE_GET (eaux->vda_next);
6549 if (VALID_DYNAMIC_NAME (aux.vda_name))
6550 printf (_(" %#06x: Parent %d: %s\n"),
6551 isum, j, GET_DYNAMIC_NAME (aux.vda_name));
6553 printf (_(" %#06x: Parent %d, name index: %ld\n"),
6554 isum, j, aux.vda_name);
6557 printf (_(" Version def aux past end of section\n"));
6561 if (cnt < section->sh_info)
6562 printf (_(" Version definition past end of section\n"));
6568 case SHT_GNU_verneed:
6570 Elf_External_Verneed *eneed;
6577 printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
6578 SECTION_NAME (section), section->sh_info);
6580 printf (_(" Addr: 0x"));
6581 printf_vma (section->sh_addr);
6582 printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"),
6583 (unsigned long) section->sh_offset, section->sh_link,
6584 SECTION_HEADER_INDEX (section->sh_link)
6585 < elf_header.e_shnum
6586 ? SECTION_NAME (SECTION_HEADER (section->sh_link))
6589 eneed = get_data (NULL, file, section->sh_offset, 1,
6591 _("version need section"));
6592 endbuf = (char *) eneed + section->sh_size;
6596 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
6598 Elf_External_Verneed *entry;
6599 Elf_Internal_Verneed ent;
6604 vstart = ((char *) eneed) + idx;
6605 if (vstart + sizeof (*entry) > endbuf)
6608 entry = (Elf_External_Verneed *) vstart;
6610 ent.vn_version = BYTE_GET (entry->vn_version);
6611 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
6612 ent.vn_file = BYTE_GET (entry->vn_file);
6613 ent.vn_aux = BYTE_GET (entry->vn_aux);
6614 ent.vn_next = BYTE_GET (entry->vn_next);
6616 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
6618 if (VALID_DYNAMIC_NAME (ent.vn_file))
6619 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
6621 printf (_(" File: %lx"), ent.vn_file);
6623 printf (_(" Cnt: %d\n"), ent.vn_cnt);
6625 vstart += ent.vn_aux;
6627 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
6629 Elf_External_Vernaux *eaux;
6630 Elf_Internal_Vernaux aux;
6632 if (vstart + sizeof (*eaux) > endbuf)
6634 eaux = (Elf_External_Vernaux *) vstart;
6636 aux.vna_hash = BYTE_GET (eaux->vna_hash);
6637 aux.vna_flags = BYTE_GET (eaux->vna_flags);
6638 aux.vna_other = BYTE_GET (eaux->vna_other);
6639 aux.vna_name = BYTE_GET (eaux->vna_name);
6640 aux.vna_next = BYTE_GET (eaux->vna_next);
6642 if (VALID_DYNAMIC_NAME (aux.vna_name))
6643 printf (_(" %#06x: Name: %s"),
6644 isum, GET_DYNAMIC_NAME (aux.vna_name));
6646 printf (_(" %#06x: Name index: %lx"),
6647 isum, aux.vna_name);
6649 printf (_(" Flags: %s Version: %d\n"),
6650 get_ver_flags (aux.vna_flags), aux.vna_other);
6652 isum += aux.vna_next;
6653 vstart += aux.vna_next;
6656 printf (_(" Version need aux past end of section\n"));
6660 if (cnt < section->sh_info)
6661 printf (_(" Version need past end of section\n"));
6667 case SHT_GNU_versym:
6669 Elf_Internal_Shdr *link_section;
6672 unsigned char *edata;
6673 unsigned short *data;
6675 Elf_Internal_Sym *symbols;
6676 Elf_Internal_Shdr *string_sec;
6679 if (SECTION_HEADER_INDEX (section->sh_link) >= elf_header.e_shnum)
6682 link_section = SECTION_HEADER (section->sh_link);
6683 total = section->sh_size / sizeof (Elf_External_Versym);
6685 if (SECTION_HEADER_INDEX (link_section->sh_link)
6686 >= elf_header.e_shnum)
6691 symbols = GET_ELF_SYMBOLS (file, link_section);
6693 string_sec = SECTION_HEADER (link_section->sh_link);
6695 strtab = get_data (NULL, file, string_sec->sh_offset, 1,
6696 string_sec->sh_size, _("version string table"));
6700 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
6701 SECTION_NAME (section), total);
6703 printf (_(" Addr: "));
6704 printf_vma (section->sh_addr);
6705 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
6706 (unsigned long) section->sh_offset, section->sh_link,
6707 SECTION_NAME (link_section));
6709 off = offset_from_vma (file,
6710 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
6711 total * sizeof (short));
6712 edata = get_data (NULL, file, off, total, sizeof (short),
6713 _("version symbol data"));
6720 data = cmalloc (total, sizeof (short));
6722 for (cnt = total; cnt --;)
6723 data[cnt] = byte_get (edata + cnt * sizeof (short),
6728 for (cnt = 0; cnt < total; cnt += 4)
6731 int check_def, check_need;
6734 printf (" %03x:", cnt);
6736 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
6737 switch (data[cnt + j])
6740 fputs (_(" 0 (*local*) "), stdout);
6744 fputs (_(" 1 (*global*) "), stdout);
6748 nn = printf ("%4x%c", data[cnt + j] & 0x7fff,
6749 data[cnt + j] & 0x8000 ? 'h' : ' ');
6753 if (SECTION_HEADER_INDEX (symbols[cnt + j].st_shndx)
6754 >= elf_header.e_shnum
6755 || SECTION_HEADER (symbols[cnt + j].st_shndx)->sh_type
6758 if (symbols[cnt + j].st_shndx == SHN_UNDEF)
6765 && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
6767 Elf_Internal_Verneed ivn;
6768 unsigned long offset;
6770 offset = offset_from_vma
6771 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
6772 sizeof (Elf_External_Verneed));
6776 Elf_Internal_Vernaux ivna;
6777 Elf_External_Verneed evn;
6778 Elf_External_Vernaux evna;
6779 unsigned long a_off;
6781 get_data (&evn, file, offset, sizeof (evn), 1,
6784 ivn.vn_aux = BYTE_GET (evn.vn_aux);
6785 ivn.vn_next = BYTE_GET (evn.vn_next);
6787 a_off = offset + ivn.vn_aux;
6791 get_data (&evna, file, a_off, sizeof (evna),
6792 1, _("version need aux (2)"));
6794 ivna.vna_next = BYTE_GET (evna.vna_next);
6795 ivna.vna_other = BYTE_GET (evna.vna_other);
6797 a_off += ivna.vna_next;
6799 while (ivna.vna_other != data[cnt + j]
6800 && ivna.vna_next != 0);
6802 if (ivna.vna_other == data[cnt + j])
6804 ivna.vna_name = BYTE_GET (evna.vna_name);
6806 if (ivna.vna_name >= string_sec->sh_size)
6807 name = _("*invalid*");
6809 name = strtab + ivna.vna_name;
6810 nn += printf ("(%s%-*s",
6812 12 - (int) strlen (name),
6818 offset += ivn.vn_next;
6820 while (ivn.vn_next);
6823 if (check_def && data[cnt + j] != 0x8001
6824 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
6826 Elf_Internal_Verdef ivd;
6827 Elf_External_Verdef evd;
6828 unsigned long offset;
6830 offset = offset_from_vma
6831 (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
6836 get_data (&evd, file, offset, sizeof (evd), 1,
6839 ivd.vd_next = BYTE_GET (evd.vd_next);
6840 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
6842 offset += ivd.vd_next;
6844 while (ivd.vd_ndx != (data[cnt + j] & 0x7fff)
6845 && ivd.vd_next != 0);
6847 if (ivd.vd_ndx == (data[cnt + j] & 0x7fff))
6849 Elf_External_Verdaux evda;
6850 Elf_Internal_Verdaux ivda;
6852 ivd.vd_aux = BYTE_GET (evd.vd_aux);
6854 get_data (&evda, file,
6855 offset - ivd.vd_next + ivd.vd_aux,
6857 _("version def aux"));
6859 ivda.vda_name = BYTE_GET (evda.vda_name);
6861 if (ivda.vda_name >= string_sec->sh_size)
6862 name = _("*invalid*");
6864 name = strtab + ivda.vda_name;
6865 nn += printf ("(%s%-*s",
6867 12 - (int) strlen (name),
6873 printf ("%*c", 18 - nn, ' ');
6891 printf (_("\nNo version information found in this file.\n"));
6897 get_symbol_binding (unsigned int binding)
6899 static char buff[32];
6903 case STB_LOCAL: return "LOCAL";
6904 case STB_GLOBAL: return "GLOBAL";
6905 case STB_WEAK: return "WEAK";
6907 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
6908 snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
6910 else if (binding >= STB_LOOS && binding <= STB_HIOS)
6911 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
6913 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
6919 get_symbol_type (unsigned int type)
6921 static char buff[32];
6925 case STT_NOTYPE: return "NOTYPE";
6926 case STT_OBJECT: return "OBJECT";
6927 case STT_FUNC: return "FUNC";
6928 case STT_SECTION: return "SECTION";
6929 case STT_FILE: return "FILE";
6930 case STT_COMMON: return "COMMON";
6931 case STT_TLS: return "TLS";
6932 case STT_RELC: return "RELC";
6933 case STT_SRELC: return "SRELC";
6935 if (type >= STT_LOPROC && type <= STT_HIPROC)
6937 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
6938 return "THUMB_FUNC";
6940 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
6943 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
6944 return "PARISC_MILLI";
6946 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
6948 else if (type >= STT_LOOS && type <= STT_HIOS)
6950 if (elf_header.e_machine == EM_PARISC)
6952 if (type == STT_HP_OPAQUE)
6954 if (type == STT_HP_STUB)
6958 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
6961 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
6967 get_symbol_visibility (unsigned int visibility)
6971 case STV_DEFAULT: return "DEFAULT";
6972 case STV_INTERNAL: return "INTERNAL";
6973 case STV_HIDDEN: return "HIDDEN";
6974 case STV_PROTECTED: return "PROTECTED";
6980 get_mips_symbol_other (unsigned int other)
6984 case STO_OPTIONAL: return "OPTIONAL";
6985 case STO_MIPS16: return "MIPS16";
6986 default: return NULL;
6991 get_symbol_other (unsigned int other)
6993 const char * result = NULL;
6994 static char buff [32];
6999 switch (elf_header.e_machine)
7002 result = get_mips_symbol_other (other);
7010 snprintf (buff, sizeof buff, _("<other>: %x"), other);
7015 get_symbol_index_type (unsigned int type)
7017 static char buff[32];
7021 case SHN_UNDEF: return "UND";
7022 case SHN_ABS: return "ABS";
7023 case SHN_COMMON: return "COM";
7025 if (type == SHN_IA_64_ANSI_COMMON
7026 && elf_header.e_machine == EM_IA_64
7027 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
7029 else if (elf_header.e_machine == EM_X86_64
7030 && type == SHN_X86_64_LCOMMON)
7032 else if (type == SHN_MIPS_SCOMMON
7033 && elf_header.e_machine == EM_MIPS)
7035 else if (type == SHN_MIPS_SUNDEFINED
7036 && elf_header.e_machine == EM_MIPS)
7038 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
7039 sprintf (buff, "PRC[0x%04x]", type);
7040 else if (type >= SHN_LOOS && type <= SHN_HIOS)
7041 sprintf (buff, "OS [0x%04x]", type);
7042 else if (type >= SHN_LORESERVE && type <= SHN_HIRESERVE)
7043 sprintf (buff, "RSV[0x%04x]", type);
7045 sprintf (buff, "%3d", type);
7053 get_dynamic_data (FILE *file, unsigned int number, unsigned int ent_size)
7055 unsigned char *e_data;
7058 e_data = cmalloc (number, ent_size);
7062 error (_("Out of memory\n"));
7066 if (fread (e_data, ent_size, number, file) != number)
7068 error (_("Unable to read in dynamic data\n"));
7072 i_data = cmalloc (number, sizeof (*i_data));
7076 error (_("Out of memory\n"));
7082 i_data[number] = byte_get (e_data + number * ent_size, ent_size);
7090 print_dynamic_symbol (bfd_vma si, unsigned long hn)
7092 Elf_Internal_Sym *psym;
7095 psym = dynamic_symbols + si;
7097 n = print_vma (si, DEC_5);
7099 fputs (" " + n, stdout);
7100 printf (" %3lu: ", hn);
7101 print_vma (psym->st_value, LONG_HEX);
7103 print_vma (psym->st_size, DEC_5);
7105 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
7106 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
7107 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
7108 /* Check to see if any other bits in the st_other field are set.
7109 Note - displaying this information disrupts the layout of the
7110 table being generated, but for the moment this case is very
7112 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
7113 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
7114 printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
7115 if (VALID_DYNAMIC_NAME (psym->st_name))
7116 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
7118 printf (" <corrupt: %14ld>", psym->st_name);
7122 /* Dump the symbol table. */
7124 process_symbol_table (FILE *file)
7126 Elf_Internal_Shdr *section;
7127 bfd_vma nbuckets = 0;
7128 bfd_vma nchains = 0;
7129 bfd_vma *buckets = NULL;
7130 bfd_vma *chains = NULL;
7131 bfd_vma ngnubuckets = 0;
7132 bfd_vma *gnubuckets = NULL;
7133 bfd_vma *gnuchains = NULL;
7134 bfd_vma gnusymidx = 0;
7136 if (! do_syms && !do_histogram)
7139 if (dynamic_info[DT_HASH]
7141 || (do_using_dynamic && dynamic_strings != NULL)))
7143 unsigned char nb[8];
7144 unsigned char nc[8];
7145 int hash_ent_size = 4;
7147 if ((elf_header.e_machine == EM_ALPHA
7148 || elf_header.e_machine == EM_S390
7149 || elf_header.e_machine == EM_S390_OLD)
7150 && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
7154 (archive_file_offset
7155 + offset_from_vma (file, dynamic_info[DT_HASH],
7156 sizeof nb + sizeof nc)),
7159 error (_("Unable to seek to start of dynamic information\n"));
7163 if (fread (nb, hash_ent_size, 1, file) != 1)
7165 error (_("Failed to read in number of buckets\n"));
7169 if (fread (nc, hash_ent_size, 1, file) != 1)
7171 error (_("Failed to read in number of chains\n"));
7175 nbuckets = byte_get (nb, hash_ent_size);
7176 nchains = byte_get (nc, hash_ent_size);
7178 buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
7179 chains = get_dynamic_data (file, nchains, hash_ent_size);
7181 if (buckets == NULL || chains == NULL)
7185 if (dynamic_info_DT_GNU_HASH
7187 || (do_using_dynamic && dynamic_strings != NULL)))
7189 unsigned char nb[16];
7190 bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
7191 bfd_vma buckets_vma;
7194 (archive_file_offset
7195 + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
7199 error (_("Unable to seek to start of dynamic information\n"));
7203 if (fread (nb, 16, 1, file) != 1)
7205 error (_("Failed to read in number of buckets\n"));
7209 ngnubuckets = byte_get (nb, 4);
7210 gnusymidx = byte_get (nb + 4, 4);
7211 bitmaskwords = byte_get (nb + 8, 4);
7212 buckets_vma = dynamic_info_DT_GNU_HASH + 16;
7214 buckets_vma += bitmaskwords * 4;
7216 buckets_vma += bitmaskwords * 8;
7219 (archive_file_offset
7220 + offset_from_vma (file, buckets_vma, 4)),
7223 error (_("Unable to seek to start of dynamic information\n"));
7227 gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
7229 if (gnubuckets == NULL)
7232 for (i = 0; i < ngnubuckets; i++)
7233 if (gnubuckets[i] != 0)
7235 if (gnubuckets[i] < gnusymidx)
7238 if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
7239 maxchain = gnubuckets[i];
7242 if (maxchain == 0xffffffff)
7245 maxchain -= gnusymidx;
7248 (archive_file_offset
7249 + offset_from_vma (file, buckets_vma
7250 + 4 * (ngnubuckets + maxchain), 4)),
7253 error (_("Unable to seek to start of dynamic information\n"));
7259 if (fread (nb, 4, 1, file) != 1)
7261 error (_("Failed to determine last chain length\n"));
7265 if (maxchain + 1 == 0)
7270 while ((byte_get (nb, 4) & 1) == 0);
7273 (archive_file_offset
7274 + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
7277 error (_("Unable to seek to start of dynamic information\n"));
7281 gnuchains = get_dynamic_data (file, maxchain, 4);
7283 if (gnuchains == NULL)
7287 if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
7290 && dynamic_strings != NULL)
7294 if (dynamic_info[DT_HASH])
7298 printf (_("\nSymbol table for image:\n"));
7300 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7302 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7304 for (hn = 0; hn < nbuckets; hn++)
7309 for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
7310 print_dynamic_symbol (si, hn);
7314 if (dynamic_info_DT_GNU_HASH)
7316 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
7318 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7320 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7322 for (hn = 0; hn < ngnubuckets; ++hn)
7323 if (gnubuckets[hn] != 0)
7325 bfd_vma si = gnubuckets[hn];
7326 bfd_vma off = si - gnusymidx;
7330 print_dynamic_symbol (si, hn);
7333 while ((gnuchains[off++] & 1) == 0);
7337 else if (do_syms && !do_using_dynamic)
7341 for (i = 0, section = section_headers;
7342 i < elf_header.e_shnum;
7346 char *strtab = NULL;
7347 unsigned long int strtab_size = 0;
7348 Elf_Internal_Sym *symtab;
7349 Elf_Internal_Sym *psym;
7352 if ( section->sh_type != SHT_SYMTAB
7353 && section->sh_type != SHT_DYNSYM)
7356 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
7357 SECTION_NAME (section),
7358 (unsigned long) (section->sh_size / section->sh_entsize));
7360 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
7362 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
7364 symtab = GET_ELF_SYMBOLS (file, section);
7368 if (section->sh_link == elf_header.e_shstrndx)
7370 strtab = string_table;
7371 strtab_size = string_table_length;
7373 else if (SECTION_HEADER_INDEX (section->sh_link) < elf_header.e_shnum)
7375 Elf_Internal_Shdr *string_sec;
7377 string_sec = SECTION_HEADER (section->sh_link);
7379 strtab = get_data (NULL, file, string_sec->sh_offset,
7380 1, string_sec->sh_size, _("string table"));
7381 strtab_size = strtab != NULL ? string_sec->sh_size : 0;
7384 for (si = 0, psym = symtab;
7385 si < section->sh_size / section->sh_entsize;
7388 printf ("%6d: ", si);
7389 print_vma (psym->st_value, LONG_HEX);
7391 print_vma (psym->st_size, DEC_5);
7392 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
7393 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
7394 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
7395 /* Check to see if any other bits in the st_other field are set.
7396 Note - displaying this information disrupts the layout of the
7397 table being generated, but for the moment this case is very rare. */
7398 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
7399 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
7400 printf (" %4s ", get_symbol_index_type (psym->st_shndx));
7401 print_symbol (25, psym->st_name < strtab_size
7402 ? strtab + psym->st_name : "<corrupt>");
7404 if (section->sh_type == SHT_DYNSYM &&
7405 version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
7407 unsigned char data[2];
7408 unsigned short vers_data;
7409 unsigned long offset;
7413 offset = offset_from_vma
7414 (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
7415 sizeof data + si * sizeof (vers_data));
7417 get_data (&data, file, offset + si * sizeof (vers_data),
7418 sizeof (data), 1, _("version data"));
7420 vers_data = byte_get (data, 2);
7422 is_nobits = (SECTION_HEADER_INDEX (psym->st_shndx)
7423 < elf_header.e_shnum
7424 && SECTION_HEADER (psym->st_shndx)->sh_type
7427 check_def = (psym->st_shndx != SHN_UNDEF);
7429 if ((vers_data & 0x8000) || vers_data > 1)
7431 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
7432 && (is_nobits || ! check_def))
7434 Elf_External_Verneed evn;
7435 Elf_Internal_Verneed ivn;
7436 Elf_Internal_Vernaux ivna;
7438 /* We must test both. */
7439 offset = offset_from_vma
7440 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
7445 unsigned long vna_off;
7447 get_data (&evn, file, offset, sizeof (evn), 1,
7450 ivn.vn_aux = BYTE_GET (evn.vn_aux);
7451 ivn.vn_next = BYTE_GET (evn.vn_next);
7453 vna_off = offset + ivn.vn_aux;
7457 Elf_External_Vernaux evna;
7459 get_data (&evna, file, vna_off,
7461 _("version need aux (3)"));
7463 ivna.vna_other = BYTE_GET (evna.vna_other);
7464 ivna.vna_next = BYTE_GET (evna.vna_next);
7465 ivna.vna_name = BYTE_GET (evna.vna_name);
7467 vna_off += ivna.vna_next;
7469 while (ivna.vna_other != vers_data
7470 && ivna.vna_next != 0);
7472 if (ivna.vna_other == vers_data)
7475 offset += ivn.vn_next;
7477 while (ivn.vn_next != 0);
7479 if (ivna.vna_other == vers_data)
7482 ivna.vna_name < strtab_size
7483 ? strtab + ivna.vna_name : "<corrupt>",
7487 else if (! is_nobits)
7488 error (_("bad dynamic symbol\n"));
7495 if (vers_data != 0x8001
7496 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
7498 Elf_Internal_Verdef ivd;
7499 Elf_Internal_Verdaux ivda;
7500 Elf_External_Verdaux evda;
7501 unsigned long offset;
7503 offset = offset_from_vma
7505 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
7506 sizeof (Elf_External_Verdef));
7510 Elf_External_Verdef evd;
7512 get_data (&evd, file, offset, sizeof (evd),
7513 1, _("version def"));
7515 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
7516 ivd.vd_aux = BYTE_GET (evd.vd_aux);
7517 ivd.vd_next = BYTE_GET (evd.vd_next);
7519 offset += ivd.vd_next;
7521 while (ivd.vd_ndx != (vers_data & 0x7fff)
7522 && ivd.vd_next != 0);
7524 offset -= ivd.vd_next;
7525 offset += ivd.vd_aux;
7527 get_data (&evda, file, offset, sizeof (evda),
7528 1, _("version def aux"));
7530 ivda.vda_name = BYTE_GET (evda.vda_name);
7532 if (psym->st_name != ivda.vda_name)
7533 printf ((vers_data & 0x8000)
7535 ivda.vda_name < strtab_size
7536 ? strtab + ivda.vda_name : "<corrupt>");
7546 if (strtab != string_table)
7552 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
7554 if (do_histogram && buckets != NULL)
7556 unsigned long *lengths;
7557 unsigned long *counts;
7560 unsigned long maxlength = 0;
7561 unsigned long nzero_counts = 0;
7562 unsigned long nsyms = 0;
7564 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
7565 (unsigned long) nbuckets);
7566 printf (_(" Length Number %% of total Coverage\n"));
7568 lengths = calloc (nbuckets, sizeof (*lengths));
7569 if (lengths == NULL)
7571 error (_("Out of memory\n"));
7574 for (hn = 0; hn < nbuckets; ++hn)
7576 for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
7579 if (maxlength < ++lengths[hn])
7584 counts = calloc (maxlength + 1, sizeof (*counts));
7587 error (_("Out of memory\n"));
7591 for (hn = 0; hn < nbuckets; ++hn)
7592 ++counts[lengths[hn]];
7597 printf (" 0 %-10lu (%5.1f%%)\n",
7598 counts[0], (counts[0] * 100.0) / nbuckets);
7599 for (i = 1; i <= maxlength; ++i)
7601 nzero_counts += counts[i] * i;
7602 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
7603 i, counts[i], (counts[i] * 100.0) / nbuckets,
7604 (nzero_counts * 100.0) / nsyms);
7612 if (buckets != NULL)
7618 if (do_histogram && dynamic_info_DT_GNU_HASH)
7620 unsigned long *lengths;
7621 unsigned long *counts;
7623 unsigned long maxlength = 0;
7624 unsigned long nzero_counts = 0;
7625 unsigned long nsyms = 0;
7627 lengths = calloc (ngnubuckets, sizeof (*lengths));
7628 if (lengths == NULL)
7630 error (_("Out of memory\n"));
7634 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
7635 (unsigned long) ngnubuckets);
7636 printf (_(" Length Number %% of total Coverage\n"));
7638 for (hn = 0; hn < ngnubuckets; ++hn)
7639 if (gnubuckets[hn] != 0)
7641 bfd_vma off, length = 1;
7643 for (off = gnubuckets[hn] - gnusymidx;
7644 (gnuchains[off] & 1) == 0; ++off)
7646 lengths[hn] = length;
7647 if (length > maxlength)
7652 counts = calloc (maxlength + 1, sizeof (*counts));
7655 error (_("Out of memory\n"));
7659 for (hn = 0; hn < ngnubuckets; ++hn)
7660 ++counts[lengths[hn]];
7662 if (ngnubuckets > 0)
7665 printf (" 0 %-10lu (%5.1f%%)\n",
7666 counts[0], (counts[0] * 100.0) / ngnubuckets);
7667 for (j = 1; j <= maxlength; ++j)
7669 nzero_counts += counts[j] * j;
7670 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
7671 j, counts[j], (counts[j] * 100.0) / ngnubuckets,
7672 (nzero_counts * 100.0) / nsyms);
7686 process_syminfo (FILE *file ATTRIBUTE_UNUSED)
7690 if (dynamic_syminfo == NULL
7692 /* No syminfo, this is ok. */
7695 /* There better should be a dynamic symbol section. */
7696 if (dynamic_symbols == NULL || dynamic_strings == NULL)
7700 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
7701 dynamic_syminfo_offset, dynamic_syminfo_nent);
7703 printf (_(" Num: Name BoundTo Flags\n"));
7704 for (i = 0; i < dynamic_syminfo_nent; ++i)
7706 unsigned short int flags = dynamic_syminfo[i].si_flags;
7708 printf ("%4d: ", i);
7709 if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
7710 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
7712 printf ("<corrupt: %19ld>", dynamic_symbols[i].st_name);
7715 switch (dynamic_syminfo[i].si_boundto)
7717 case SYMINFO_BT_SELF:
7718 fputs ("SELF ", stdout);
7720 case SYMINFO_BT_PARENT:
7721 fputs ("PARENT ", stdout);
7724 if (dynamic_syminfo[i].si_boundto > 0
7725 && dynamic_syminfo[i].si_boundto < dynamic_nent
7726 && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
7728 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
7732 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
7736 if (flags & SYMINFO_FLG_DIRECT)
7738 if (flags & SYMINFO_FLG_PASSTHRU)
7739 printf (" PASSTHRU");
7740 if (flags & SYMINFO_FLG_COPY)
7742 if (flags & SYMINFO_FLG_LAZYLOAD)
7743 printf (" LAZYLOAD");
7751 #ifdef SUPPORT_DISASSEMBLY
7753 disassemble_section (Elf_Internal_Shdr *section, FILE *file)
7755 printf (_("\nAssembly dump of section %s\n"),
7756 SECTION_NAME (section));
7758 /* XXX -- to be done --- XXX */
7765 dump_section_as_strings (Elf_Internal_Shdr *section, FILE *file)
7767 Elf_Internal_Shdr *relsec;
7768 bfd_size_type num_bytes;
7773 char *name = SECTION_NAME (section);
7774 bfd_boolean some_strings_shown;
7776 num_bytes = section->sh_size;
7778 if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
7780 printf (_("\nSection '%s' has no data to dump.\n"), name);
7784 addr = section->sh_addr;
7786 start = get_data (NULL, file, section->sh_offset, 1, num_bytes,
7791 printf (_("\nString dump of section '%s':\n"), name);
7793 /* If the section being dumped has relocations against it the user might
7794 be expecting these relocations to have been applied. Check for this
7795 case and issue a warning message in order to avoid confusion.
7796 FIXME: Maybe we ought to have an option that dumps a section with
7798 for (relsec = section_headers;
7799 relsec < section_headers + elf_header.e_shnum;
7802 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
7803 || SECTION_HEADER_INDEX (relsec->sh_info) >= elf_header.e_shnum
7804 || SECTION_HEADER (relsec->sh_info) != section
7805 || relsec->sh_size == 0
7806 || SECTION_HEADER_INDEX (relsec->sh_link) >= elf_header.e_shnum)
7809 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
7814 end = start + num_bytes;
7815 some_strings_shown = FALSE;
7819 while (!ISPRINT (* data))
7825 printf (" [%6tx] %s\n", data - start, data);
7826 data += strlen (data);
7827 some_strings_shown = TRUE;
7831 if (! some_strings_shown)
7832 printf (_(" No strings found in this section."));
7842 dump_section_as_bytes (Elf_Internal_Shdr *section, FILE *file)
7844 Elf_Internal_Shdr *relsec;
7845 bfd_size_type bytes;
7847 unsigned char *data;
7848 unsigned char *start;
7850 bytes = section->sh_size;
7852 if (bytes == 0 || section->sh_type == SHT_NOBITS)
7854 printf (_("\nSection '%s' has no data to dump.\n"),
7855 SECTION_NAME (section));
7859 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
7861 addr = section->sh_addr;
7863 start = get_data (NULL, file, section->sh_offset, 1, bytes,
7868 /* If the section being dumped has relocations against it the user might
7869 be expecting these relocations to have been applied. Check for this
7870 case and issue a warning message in order to avoid confusion.
7871 FIXME: Maybe we ought to have an option that dumps a section with
7873 for (relsec = section_headers;
7874 relsec < section_headers + elf_header.e_shnum;
7877 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
7878 || SECTION_HEADER_INDEX (relsec->sh_info) >= elf_header.e_shnum
7879 || SECTION_HEADER (relsec->sh_info) != section
7880 || relsec->sh_size == 0
7881 || SECTION_HEADER_INDEX (relsec->sh_link) >= elf_header.e_shnum)
7884 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
7896 lbytes = (bytes > 16 ? 16 : bytes);
7898 printf (" 0x%8.8lx ", (unsigned long) addr);
7900 for (j = 0; j < 16; j++)
7903 printf ("%2.2x", data[j]);
7911 for (j = 0; j < lbytes; j++)
7914 if (k >= ' ' && k < 0x7f)
7933 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
7934 DWARF debug sections. This is a target specific test. Note - we do not
7935 go through the whole including-target-headers-multiple-times route, (as
7936 we have already done with <elf/h8.h>) because this would become very
7937 messy and even then this function would have to contain target specific
7938 information (the names of the relocs instead of their numeric values).
7939 FIXME: This is not the correct way to solve this problem. The proper way
7940 is to have target specific reloc sizing and typing functions created by
7941 the reloc-macros.h header, in the same way that it already creates the
7942 reloc naming functions. */
7945 is_32bit_abs_reloc (unsigned int reloc_type)
7947 switch (elf_header.e_machine)
7950 return reloc_type == 1; /* R_68K_32. */
7952 return reloc_type == 1; /* R_860_32. */
7954 return reloc_type == 1; /* XXX Is this right ? */
7957 return reloc_type == 1;
7959 return reloc_type == 0x12; /* R_byte4_data. */
7961 return reloc_type == 3; /* R_CRIS_32. */
7963 return reloc_type == 3; /* R_CR16_NUM32. */
7965 return reloc_type == 15; /* R_CRX_NUM32. */
7967 return reloc_type == 1;
7968 case EM_CYGNUS_D30V:
7970 return reloc_type == 12; /* R_D30V_32_NORMAL. */
7971 case EM_CYGNUS_FR30:
7973 return reloc_type == 3; /* R_FR30_32. */
7977 return reloc_type == 1; /* R_H8_DIR32. */
7979 return reloc_type == 0x65; /* R_IA64_SECREL32LSB. */
7982 return reloc_type == 2; /* R_IP2K_32. */
7984 return reloc_type == 2; /* R_IQ2000_32. */
7986 return reloc_type == 3; /* R_M32C_32. */
7988 return reloc_type == 34; /* R_M32R_32_RELA. */
7990 return reloc_type == 1; /* R_MCORE_ADDR32. */
7992 return reloc_type == 4; /* R_MEP_32. */
7994 return reloc_type == 2; /* R_MIPS_32. */
7996 return reloc_type == 4; /* R_MMIX_32. */
7997 case EM_CYGNUS_MN10200:
7999 return reloc_type == 1; /* R_MN10200_32. */
8000 case EM_CYGNUS_MN10300:
8002 return reloc_type == 1; /* R_MN10300_32. */
8005 return reloc_type == 1; /* R_MSP43_32. */
8007 return reloc_type == 2; /* R_MT_32. */
8009 return reloc_type == 1; /* R_PARISC_DIR32. */
8012 return reloc_type == 1; /* R_PJ_DATA_DIR32. */
8014 return reloc_type == 1; /* R_PPC64_ADDR32. */
8016 return reloc_type == 1; /* R_PPC_ADDR32. */
8018 return reloc_type == 1; /* R_I370_ADDR31. */
8021 return reloc_type == 4; /* R_S390_32. */
8023 return reloc_type == 1; /* R_SH_DIR32. */
8024 case EM_SPARC32PLUS:
8027 return reloc_type == 3 /* R_SPARC_32. */
8028 || reloc_type == 23; /* R_SPARC_UA32. */
8029 case EM_CYGNUS_V850:
8031 return reloc_type == 6; /* R_V850_ABS32. */
8033 return reloc_type == 1; /* R_VAX_32. */
8035 return reloc_type == 10; /* R_X86_64_32. */
8037 return reloc_type == 1; /* R_XSTROMY16_32. */
8040 return reloc_type == 1; /* R_XTENSA_32. */
8042 case EM_ALTERA_NIOS2:
8043 /* Fall through (what reloc type is used ?). */
8045 /* Fall through (what reloc type is used ?). */
8047 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
8048 elf_header.e_machine);
8053 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8054 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
8057 is_32bit_pcrel_reloc (unsigned int reloc_type)
8059 switch (elf_header.e_machine)
8062 return reloc_type == 4; /* R_68K_PC32. */
8064 return reloc_type == 10; /* R_ALPHA_SREL32. */
8066 return reloc_type == 0; /* R_PARISC_NONE. *//* FIXME: This reloc is generated, but it may be a bug. */
8068 return reloc_type == 26; /* R_PPC_REL32. */
8070 return reloc_type == 26; /* R_PPC64_REL32. */
8073 return reloc_type == 5; /* R_390_PC32. */
8075 return reloc_type == 2; /* R_SH_REL32. */
8076 case EM_SPARC32PLUS:
8079 return reloc_type == 6; /* R_SPARC_DISP32. */
8081 return reloc_type == 2; /* R_X86_64_PC32. */
8083 /* Do not abort or issue an error message here. Not all targets use
8084 pc-relative 32-bit relocs in their DWARF debug information and we
8085 have already tested for target coverage in is_32bit_abs_reloc. A
8086 more helpful warning message will be generated by debug_apply_rela_addends
8087 anyway, so just return. */
8092 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8093 a 64-bit absolute RELA relocation used in DWARF debug sections. */
8096 is_64bit_abs_reloc (unsigned int reloc_type)
8098 switch (elf_header.e_machine)
8101 return reloc_type == 2; /* R_ALPHA_REFQUAD. */
8103 return reloc_type == 0x27; /* R_IA64_DIR64LSB. */
8105 return reloc_type == 38; /* R_PPC64_ADDR64. */
8106 case EM_SPARC32PLUS:
8109 return reloc_type == 54; /* R_SPARC_UA64. */
8111 return reloc_type == 1; /* R_X86_64_64. */
8117 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8118 a 16-bit absolute RELA relocation used in DWARF debug sections. */
8121 is_16bit_abs_reloc (unsigned int reloc_type)
8123 switch (elf_header.e_machine)
8127 return reloc_type == 4; /* R_AVR_16. */
8131 return reloc_type == R_H8_DIR16;
8134 return reloc_type == 1; /* R_IP2K_16. */
8137 return reloc_type == 5; /* R_MSP430_16_BYTE. */
8143 /* Apply addends of RELA relocations. */
8146 debug_apply_rela_addends (void *file,
8147 Elf_Internal_Shdr *section,
8148 unsigned char *start)
8150 Elf_Internal_Shdr *relsec;
8151 unsigned char *end = start + section->sh_size;
8153 if (!is_relocatable)
8156 /* SH uses RELA but uses in place value instead of the addend field. */
8157 if (elf_header.e_machine == EM_SH)
8160 for (relsec = section_headers;
8161 relsec < section_headers + elf_header.e_shnum;
8164 unsigned long nrelas;
8165 Elf_Internal_Rela *rela, *rp;
8166 Elf_Internal_Shdr *symsec;
8167 Elf_Internal_Sym *symtab;
8168 Elf_Internal_Sym *sym;
8170 if (relsec->sh_type != SHT_RELA
8171 || SECTION_HEADER_INDEX (relsec->sh_info) >= elf_header.e_shnum
8172 || SECTION_HEADER (relsec->sh_info) != section
8173 || relsec->sh_size == 0
8174 || SECTION_HEADER_INDEX (relsec->sh_link) >= elf_header.e_shnum)
8177 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
8181 symsec = SECTION_HEADER (relsec->sh_link);
8182 symtab = GET_ELF_SYMBOLS (file, symsec);
8184 for (rp = rela; rp < rela + nrelas; ++rp)
8186 unsigned int reloc_type;
8187 unsigned int reloc_size;
8190 /* In MIPS little-endian objects, r_info isn't really a
8191 64-bit little-endian value: it has a 32-bit little-endian
8192 symbol index followed by four individual byte fields.
8193 Reorder INFO accordingly. */
8195 && elf_header.e_machine == EM_MIPS
8196 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
8197 rp->r_info = (((rp->r_info & 0xffffffff) << 32)
8198 | ((rp->r_info >> 56) & 0xff)
8199 | ((rp->r_info >> 40) & 0xff00)
8200 | ((rp->r_info >> 24) & 0xff0000)
8201 | ((rp->r_info >> 8) & 0xff000000));
8203 sym = symtab + get_reloc_symindex (rp->r_info);
8204 reloc_type = get_reloc_type (rp->r_info);
8205 if (is_32bit_abs_reloc (reloc_type)
8206 || is_32bit_pcrel_reloc (reloc_type))
8208 else if (is_64bit_abs_reloc (reloc_type))
8210 else if (is_16bit_abs_reloc (reloc_type))
8214 warn (_("skipping unsupported reloc type %d in section .rela%s\n"),
8215 reloc_type, SECTION_NAME (section));
8219 loc = start + rp->r_offset;
8220 if ((loc + reloc_size) > end)
8222 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
8223 (unsigned long) rp->r_offset,
8224 SECTION_NAME (section));
8229 && ELF_ST_TYPE (sym->st_info) != STT_SECTION
8230 /* Relocations against symbols without type can happen.
8231 Gcc -feliminate-dwarf2-dups may generate symbols
8232 without type for debug info. */
8233 && ELF_ST_TYPE (sym->st_info) != STT_NOTYPE
8234 /* Relocations against object symbols can happen,
8235 eg when referencing a global array. For an
8236 example of this see the _clz.o binary in libgcc.a. */
8237 && ELF_ST_TYPE (sym->st_info) != STT_OBJECT)
8239 warn (_("skipping unexpected symbol type %s in relocation in section .rela%s\n"),
8240 get_symbol_type (ELF_ST_TYPE (sym->st_info)),
8241 SECTION_NAME (section));
8245 /* FIXME. We apply pcrel relocs as if they were absolute,
8246 ie. without subtracting the pc. This is to suit
8247 display_debug_frames which does not add the pc even
8248 though it ought to for DW_EH_PE_pcrel FDEs. Removing
8249 the hack in display_debug_frames will require that we
8250 apply rel relocs too. */
8251 byte_put (loc, rp->r_addend + sym->st_value, reloc_size);
8262 load_debug_section (enum dwarf_section_display_enum debug, void *file)
8264 struct dwarf_section *section = &debug_displays [debug].section;
8265 Elf_Internal_Shdr *sec;
8268 /* If it is already loaded, do nothing. */
8269 if (section->start != NULL)
8272 /* Locate the debug section. */
8273 sec = find_section (section->name);
8277 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
8278 section->address = sec->sh_addr;
8279 section->size = sec->sh_size;
8280 section->start = get_data (NULL, file, sec->sh_offset, 1,
8283 if (debug_displays [debug].relocate)
8284 debug_apply_rela_addends (file, sec, section->start);
8286 return section->start != NULL;
8290 free_debug_section (enum dwarf_section_display_enum debug)
8292 struct dwarf_section *section = &debug_displays [debug].section;
8294 if (section->start == NULL)
8297 free ((char *) section->start);
8298 section->start = NULL;
8299 section->address = 0;
8304 display_debug_section (Elf_Internal_Shdr *section, FILE *file)
8306 char *name = SECTION_NAME (section);
8307 bfd_size_type length;
8309 enum dwarf_section_display_enum i;
8311 length = section->sh_size;
8314 printf (_("\nSection '%s' has no debugging data.\n"), name);
8318 if (const_strneq (name, ".gnu.linkonce.wi."))
8319 name = ".debug_info";
8321 /* See if we know how to display the contents of this section. */
8322 for (i = 0; i < max; i++)
8323 if (streq (debug_displays[i].section.name, name))
8325 struct dwarf_section *sec = &debug_displays [i].section;
8327 if (load_debug_section (i, file))
8329 result &= debug_displays[i].display (sec, file);
8331 if (i != info && i != abbrev)
8332 free_debug_section (i);
8340 printf (_("Unrecognized debug section: %s\n"), name);
8347 /* Set DUMP_SECTS for all sections where dumps were requested
8348 based on section name. */
8351 initialise_dumps_byname (void)
8353 struct dump_list_entry *cur;
8355 for (cur = dump_sects_byname; cur; cur = cur->next)
8360 for (i = 0, any = 0; i < elf_header.e_shnum; i++)
8361 if (streq (SECTION_NAME (section_headers + i), cur->name))
8363 request_dump_bynumber (i, cur->type);
8368 warn (_("Section '%s' was not dumped because it does not exist!\n"),
8374 process_section_contents (FILE *file)
8376 Elf_Internal_Shdr *section;
8382 initialise_dumps_byname ();
8384 for (i = 0, section = section_headers;
8385 i < elf_header.e_shnum && i < num_dump_sects;
8388 #ifdef SUPPORT_DISASSEMBLY
8389 if (dump_sects[i] & DISASS_DUMP)
8390 disassemble_section (section, file);
8392 if (dump_sects[i] & HEX_DUMP)
8393 dump_section_as_bytes (section, file);
8395 if (dump_sects[i] & DEBUG_DUMP)
8396 display_debug_section (section, file);
8398 if (dump_sects[i] & STRING_DUMP)
8399 dump_section_as_strings (section, file);
8402 /* Check to see if the user requested a
8403 dump of a section that does not exist. */
8404 while (i++ < num_dump_sects)
8406 warn (_("Section %d was not dumped because it does not exist!\n"), i);
8410 process_mips_fpe_exception (int mask)
8415 if (mask & OEX_FPU_INEX)
8416 fputs ("INEX", stdout), first = 0;
8417 if (mask & OEX_FPU_UFLO)
8418 printf ("%sUFLO", first ? "" : "|"), first = 0;
8419 if (mask & OEX_FPU_OFLO)
8420 printf ("%sOFLO", first ? "" : "|"), first = 0;
8421 if (mask & OEX_FPU_DIV0)
8422 printf ("%sDIV0", first ? "" : "|"), first = 0;
8423 if (mask & OEX_FPU_INVAL)
8424 printf ("%sINVAL", first ? "" : "|");
8427 fputs ("0", stdout);
8430 /* ARM EABI attributes section. */
8435 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
8438 } arm_attr_public_tag;
8440 static const char *arm_attr_tag_CPU_arch[] =
8441 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
8443 static const char *arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
8444 static const char *arm_attr_tag_THUMB_ISA_use[] =
8445 {"No", "Thumb-1", "Thumb-2"};
8446 /* FIXME: VFPv3 encoding was extrapolated! */
8447 static const char *arm_attr_tag_VFP_arch[] = {"No", "VFPv1", "VFPv2", "VFPv3"};
8448 static const char *arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1"};
8449 static const char *arm_attr_tag_NEON_arch[] = {"No", "NEONv1"};
8450 static const char *arm_attr_tag_ABI_PCS_config[] =
8451 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
8452 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
8453 static const char *arm_attr_tag_ABI_PCS_R9_use[] =
8454 {"V6", "SB", "TLS", "Unused"};
8455 static const char *arm_attr_tag_ABI_PCS_RW_data[] =
8456 {"Absolute", "PC-relative", "SB-relative", "None"};
8457 static const char *arm_attr_tag_ABI_PCS_RO_DATA[] =
8458 {"Absolute", "PC-relative", "None"};
8459 static const char *arm_attr_tag_ABI_PCS_GOT_use[] =
8460 {"None", "direct", "GOT-indirect"};
8461 static const char *arm_attr_tag_ABI_PCS_wchar_t[] =
8462 {"None", "??? 1", "2", "??? 3", "4"};
8463 static const char *arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
8464 static const char *arm_attr_tag_ABI_FP_denormal[] = {"Unused", "Needed"};
8465 static const char *arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
8466 static const char *arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
8467 static const char *arm_attr_tag_ABI_FP_number_model[] =
8468 {"Unused", "Finite", "RTABI", "IEEE 754"};
8469 static const char *arm_attr_tag_ABI_align8_needed[] = {"No", "Yes", "4-byte"};
8470 static const char *arm_attr_tag_ABI_align8_preserved[] =
8471 {"No", "Yes, except leaf SP", "Yes"};
8472 static const char *arm_attr_tag_ABI_enum_size[] =
8473 {"Unused", "small", "int", "forced to int"};
8474 static const char *arm_attr_tag_ABI_HardFP_use[] =
8475 {"As Tag_VFP_arch", "SP only", "DP only", "SP and DP"};
8476 static const char *arm_attr_tag_ABI_VFP_args[] =
8477 {"AAPCS", "VFP registers", "custom"};
8478 static const char *arm_attr_tag_ABI_WMMX_args[] =
8479 {"AAPCS", "WMMX registers", "custom"};
8480 static const char *arm_attr_tag_ABI_optimization_goals[] =
8481 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
8482 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
8483 static const char *arm_attr_tag_ABI_FP_optimization_goals[] =
8484 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
8485 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
8487 #define LOOKUP(id, name) \
8488 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
8489 static arm_attr_public_tag arm_attr_public_tags[] =
8491 {4, "CPU_raw_name", 1, NULL},
8492 {5, "CPU_name", 1, NULL},
8493 LOOKUP(6, CPU_arch),
8494 {7, "CPU_arch_profile", 0, NULL},
8495 LOOKUP(8, ARM_ISA_use),
8496 LOOKUP(9, THUMB_ISA_use),
8497 LOOKUP(10, VFP_arch),
8498 LOOKUP(11, WMMX_arch),
8499 LOOKUP(12, NEON_arch),
8500 LOOKUP(13, ABI_PCS_config),
8501 LOOKUP(14, ABI_PCS_R9_use),
8502 LOOKUP(15, ABI_PCS_RW_data),
8503 LOOKUP(16, ABI_PCS_RO_DATA),
8504 LOOKUP(17, ABI_PCS_GOT_use),
8505 LOOKUP(18, ABI_PCS_wchar_t),
8506 LOOKUP(19, ABI_FP_rounding),
8507 LOOKUP(20, ABI_FP_denormal),
8508 LOOKUP(21, ABI_FP_exceptions),
8509 LOOKUP(22, ABI_FP_user_exceptions),
8510 LOOKUP(23, ABI_FP_number_model),
8511 LOOKUP(24, ABI_align8_needed),
8512 LOOKUP(25, ABI_align8_preserved),
8513 LOOKUP(26, ABI_enum_size),
8514 LOOKUP(27, ABI_HardFP_use),
8515 LOOKUP(28, ABI_VFP_args),
8516 LOOKUP(29, ABI_WMMX_args),
8517 LOOKUP(30, ABI_optimization_goals),
8518 LOOKUP(31, ABI_FP_optimization_goals),
8519 {32, "compatibility", 0, NULL}
8523 /* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
8526 read_uleb128 (unsigned char *p, unsigned int *plen)
8540 val |= ((unsigned int)c & 0x7f) << shift;
8549 static unsigned char *
8550 display_arm_attribute (unsigned char *p)
8555 arm_attr_public_tag *attr;
8559 tag = read_uleb128 (p, &len);
8562 for (i = 0; i < ARRAY_SIZE(arm_attr_public_tags); i++)
8564 if (arm_attr_public_tags[i].tag == tag)
8566 attr = &arm_attr_public_tags[i];
8573 printf (" Tag_%s: ", attr->name);
8579 case 7: /* Tag_CPU_arch_profile. */
8580 val = read_uleb128 (p, &len);
8584 case 0: printf ("None\n"); break;
8585 case 'A': printf ("Application\n"); break;
8586 case 'R': printf ("Realtime\n"); break;
8587 case 'M': printf ("Microcontroller\n"); break;
8588 default: printf ("??? (%d)\n", val); break;
8592 case 32: /* Tag_compatibility. */
8593 val = read_uleb128 (p, &len);
8595 printf ("flag = %d, vendor = %s\n", val, p);
8596 p += strlen((char *)p) + 1;
8610 assert (attr->type & 0x80);
8611 val = read_uleb128 (p, &len);
8613 type = attr->type & 0x7f;
8615 printf ("??? (%d)\n", val);
8617 printf ("%s\n", attr->table[val]);
8624 type = 1; /* String. */
8626 type = 2; /* uleb128. */
8627 printf (" Tag_unknown_%d: ", tag);
8632 printf ("\"%s\"\n", p);
8633 p += strlen((char *)p) + 1;
8637 val = read_uleb128 (p, &len);
8639 printf ("%d (0x%x)\n", val, val);
8645 static unsigned char *
8646 display_gnu_attribute (unsigned char * p,
8647 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int))
8654 tag = read_uleb128 (p, &len);
8657 /* Tag_compatibility is the only generic GNU attribute defined at
8661 val = read_uleb128 (p, &len);
8663 printf ("flag = %d, vendor = %s\n", val, p);
8664 p += strlen ((char *) p) + 1;
8668 if ((tag & 2) == 0 && display_proc_gnu_attribute)
8669 return display_proc_gnu_attribute (p, tag);
8672 type = 1; /* String. */
8674 type = 2; /* uleb128. */
8675 printf (" Tag_unknown_%d: ", tag);
8679 printf ("\"%s\"\n", p);
8680 p += strlen ((char *) p) + 1;
8684 val = read_uleb128 (p, &len);
8686 printf ("%d (0x%x)\n", val, val);
8692 static unsigned char *
8693 display_power_gnu_attribute (unsigned char *p, int tag)
8699 if (tag == Tag_GNU_Power_ABI_FP)
8701 val = read_uleb128 (p, &len);
8703 printf (" Tag_GNU_Power_ABI_FP: ");
8708 printf ("Hard or soft float\n");
8711 printf ("Hard float\n");
8714 printf ("Soft float\n");
8717 printf ("??? (%d)\n", val);
8723 if (tag == Tag_GNU_Power_ABI_Vector)
8725 val = read_uleb128 (p, &len);
8727 printf (" Tag_GNU_Power_ABI_Vector: ");
8734 printf ("Generic\n");
8737 printf ("AltiVec\n");
8743 printf ("??? (%d)\n", val);
8750 type = 1; /* String. */
8752 type = 2; /* uleb128. */
8753 printf (" Tag_unknown_%d: ", tag);
8757 printf ("\"%s\"\n", p);
8758 p += strlen ((char *) p) + 1;
8762 val = read_uleb128 (p, &len);
8764 printf ("%d (0x%x)\n", val, val);
8770 static unsigned char *
8771 display_mips_gnu_attribute (unsigned char *p, int tag)
8777 if (tag == Tag_GNU_MIPS_ABI_FP)
8779 val = read_uleb128 (p, &len);
8781 printf (" Tag_GNU_MIPS_ABI_FP: ");
8786 printf ("Hard or soft float\n");
8789 printf ("Hard float (-mdouble-float)\n");
8792 printf ("Hard float (-msingle-float)\n");
8795 printf ("Soft float\n");
8798 printf ("??? (%d)\n", val);
8805 type = 1; /* String. */
8807 type = 2; /* uleb128. */
8808 printf (" Tag_unknown_%d: ", tag);
8812 printf ("\"%s\"\n", p);
8813 p += strlen ((char *) p) + 1;
8817 val = read_uleb128 (p, &len);
8819 printf ("%d (0x%x)\n", val, val);
8826 process_attributes (FILE * file,
8827 const char * public_name,
8828 unsigned int proc_type,
8829 unsigned char * (* display_pub_attribute) (unsigned char *),
8830 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int))
8832 Elf_Internal_Shdr *sect;
8833 unsigned char *contents;
8836 bfd_vma section_len;
8840 /* Find the section header so that we get the size. */
8841 for (i = 0, sect = section_headers;
8842 i < elf_header.e_shnum;
8845 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
8848 contents = get_data (NULL, file, sect->sh_offset, 1, sect->sh_size,
8850 if (contents == NULL)
8856 len = sect->sh_size - 1;
8862 bfd_boolean public_section;
8863 bfd_boolean gnu_section;
8865 section_len = byte_get (p, 4);
8868 if (section_len > len)
8870 printf (_("ERROR: Bad section length (%d > %d)\n"),
8871 (int) section_len, (int) len);
8876 printf ("Attribute Section: %s\n", p);
8878 if (public_name && streq ((char *) p, public_name))
8879 public_section = TRUE;
8881 public_section = FALSE;
8883 if (streq ((char *) p, "gnu"))
8886 gnu_section = FALSE;
8888 namelen = strlen ((char *) p) + 1;
8890 section_len -= namelen + 4;
8892 while (section_len > 0)
8898 size = byte_get (p, 4);
8899 if (size > section_len)
8901 printf (_("ERROR: Bad subsection length (%d > %d)\n"),
8902 (int) size, (int) section_len);
8906 section_len -= size;
8913 printf ("File Attributes\n");
8916 printf ("Section Attributes:");
8919 printf ("Symbol Attributes:");
8925 val = read_uleb128 (p, &i);
8929 printf (" %d", val);
8934 printf ("Unknown tag: %d\n", tag);
8935 public_section = FALSE;
8942 p = display_pub_attribute (p);
8944 else if (gnu_section)
8947 p = display_gnu_attribute (p,
8948 display_proc_gnu_attribute);
8952 /* ??? Do something sensible, like dump hex. */
8953 printf (" Unknown section contexts\n");
8960 printf (_("Unknown format '%c'\n"), *p);
8968 process_arm_specific (FILE *file)
8970 return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
8971 display_arm_attribute, NULL);
8975 process_power_specific (FILE *file)
8977 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
8978 display_power_gnu_attribute);
8982 process_mips_specific (FILE *file)
8984 Elf_Internal_Dyn *entry;
8985 size_t liblist_offset = 0;
8986 size_t liblistno = 0;
8987 size_t conflictsno = 0;
8988 size_t options_offset = 0;
8989 size_t conflicts_offset = 0;
8991 process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
8992 display_mips_gnu_attribute);
8994 /* We have a lot of special sections. Thanks SGI! */
8995 if (dynamic_section == NULL)
8996 /* No information available. */
8999 for (entry = dynamic_section; entry->d_tag != DT_NULL; ++entry)
9000 switch (entry->d_tag)
9002 case DT_MIPS_LIBLIST:
9004 = offset_from_vma (file, entry->d_un.d_val,
9005 liblistno * sizeof (Elf32_External_Lib));
9007 case DT_MIPS_LIBLISTNO:
9008 liblistno = entry->d_un.d_val;
9010 case DT_MIPS_OPTIONS:
9011 options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
9013 case DT_MIPS_CONFLICT:
9015 = offset_from_vma (file, entry->d_un.d_val,
9016 conflictsno * sizeof (Elf32_External_Conflict));
9018 case DT_MIPS_CONFLICTNO:
9019 conflictsno = entry->d_un.d_val;
9025 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
9027 Elf32_External_Lib *elib;
9030 elib = get_data (NULL, file, liblist_offset,
9031 liblistno, sizeof (Elf32_External_Lib),
9035 printf ("\nSection '.liblist' contains %lu entries:\n",
9036 (unsigned long) liblistno);
9037 fputs (" Library Time Stamp Checksum Version Flags\n",
9040 for (cnt = 0; cnt < liblistno; ++cnt)
9047 liblist.l_name = BYTE_GET (elib[cnt].l_name);
9048 time = BYTE_GET (elib[cnt].l_time_stamp);
9049 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
9050 liblist.l_version = BYTE_GET (elib[cnt].l_version);
9051 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
9053 tmp = gmtime (&time);
9054 snprintf (timebuf, sizeof (timebuf),
9055 "%04u-%02u-%02uT%02u:%02u:%02u",
9056 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9057 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
9059 printf ("%3lu: ", (unsigned long) cnt);
9060 if (VALID_DYNAMIC_NAME (liblist.l_name))
9061 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
9063 printf ("<corrupt: %9ld>", liblist.l_name);
9064 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
9067 if (liblist.l_flags == 0)
9078 { " EXACT_MATCH", LL_EXACT_MATCH },
9079 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
9080 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
9081 { " EXPORTS", LL_EXPORTS },
9082 { " DELAY_LOAD", LL_DELAY_LOAD },
9083 { " DELTA", LL_DELTA }
9085 int flags = liblist.l_flags;
9088 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
9089 if ((flags & l_flags_vals[fcnt].bit) != 0)
9091 fputs (l_flags_vals[fcnt].name, stdout);
9092 flags ^= l_flags_vals[fcnt].bit;
9095 printf (" %#x", (unsigned int) flags);
9105 if (options_offset != 0)
9107 Elf_External_Options *eopt;
9108 Elf_Internal_Shdr *sect = section_headers;
9109 Elf_Internal_Options *iopt;
9110 Elf_Internal_Options *option;
9114 /* Find the section header so that we get the size. */
9115 while (sect->sh_type != SHT_MIPS_OPTIONS)
9118 eopt = get_data (NULL, file, options_offset, 1, sect->sh_size,
9122 iopt = cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (*iopt));
9125 error (_("Out of memory\n"));
9132 while (offset < sect->sh_size)
9134 Elf_External_Options *eoption;
9136 eoption = (Elf_External_Options *) ((char *) eopt + offset);
9138 option->kind = BYTE_GET (eoption->kind);
9139 option->size = BYTE_GET (eoption->size);
9140 option->section = BYTE_GET (eoption->section);
9141 option->info = BYTE_GET (eoption->info);
9143 offset += option->size;
9149 printf (_("\nSection '%s' contains %d entries:\n"),
9150 SECTION_NAME (sect), cnt);
9158 switch (option->kind)
9161 /* This shouldn't happen. */
9162 printf (" NULL %d %lx", option->section, option->info);
9165 printf (" REGINFO ");
9166 if (elf_header.e_machine == EM_MIPS)
9169 Elf32_External_RegInfo *ereg;
9170 Elf32_RegInfo reginfo;
9172 ereg = (Elf32_External_RegInfo *) (option + 1);
9173 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
9174 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
9175 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
9176 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
9177 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
9178 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
9180 printf ("GPR %08lx GP 0x%lx\n",
9182 (unsigned long) reginfo.ri_gp_value);
9183 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9184 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
9185 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
9190 Elf64_External_RegInfo *ereg;
9191 Elf64_Internal_RegInfo reginfo;
9193 ereg = (Elf64_External_RegInfo *) (option + 1);
9194 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
9195 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
9196 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
9197 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
9198 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
9199 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
9201 printf ("GPR %08lx GP 0x",
9202 reginfo.ri_gprmask);
9203 printf_vma (reginfo.ri_gp_value);
9206 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9207 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
9208 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
9212 case ODK_EXCEPTIONS:
9213 fputs (" EXCEPTIONS fpe_min(", stdout);
9214 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
9215 fputs (") fpe_max(", stdout);
9216 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
9217 fputs (")", stdout);
9219 if (option->info & OEX_PAGE0)
9220 fputs (" PAGE0", stdout);
9221 if (option->info & OEX_SMM)
9222 fputs (" SMM", stdout);
9223 if (option->info & OEX_FPDBUG)
9224 fputs (" FPDBUG", stdout);
9225 if (option->info & OEX_DISMISS)
9226 fputs (" DISMISS", stdout);
9229 fputs (" PAD ", stdout);
9230 if (option->info & OPAD_PREFIX)
9231 fputs (" PREFIX", stdout);
9232 if (option->info & OPAD_POSTFIX)
9233 fputs (" POSTFIX", stdout);
9234 if (option->info & OPAD_SYMBOL)
9235 fputs (" SYMBOL", stdout);
9238 fputs (" HWPATCH ", stdout);
9239 if (option->info & OHW_R4KEOP)
9240 fputs (" R4KEOP", stdout);
9241 if (option->info & OHW_R8KPFETCH)
9242 fputs (" R8KPFETCH", stdout);
9243 if (option->info & OHW_R5KEOP)
9244 fputs (" R5KEOP", stdout);
9245 if (option->info & OHW_R5KCVTL)
9246 fputs (" R5KCVTL", stdout);
9249 fputs (" FILL ", stdout);
9250 /* XXX Print content of info word? */
9253 fputs (" TAGS ", stdout);
9254 /* XXX Print content of info word? */
9257 fputs (" HWAND ", stdout);
9258 if (option->info & OHWA0_R4KEOP_CHECKED)
9259 fputs (" R4KEOP_CHECKED", stdout);
9260 if (option->info & OHWA0_R4KEOP_CLEAN)
9261 fputs (" R4KEOP_CLEAN", stdout);
9264 fputs (" HWOR ", stdout);
9265 if (option->info & OHWA0_R4KEOP_CHECKED)
9266 fputs (" R4KEOP_CHECKED", stdout);
9267 if (option->info & OHWA0_R4KEOP_CLEAN)
9268 fputs (" R4KEOP_CLEAN", stdout);
9271 printf (" GP_GROUP %#06lx self-contained %#06lx",
9272 option->info & OGP_GROUP,
9273 (option->info & OGP_SELF) >> 16);
9276 printf (" IDENT %#06lx self-contained %#06lx",
9277 option->info & OGP_GROUP,
9278 (option->info & OGP_SELF) >> 16);
9281 /* This shouldn't happen. */
9282 printf (" %3d ??? %d %lx",
9283 option->kind, option->section, option->info);
9287 len = sizeof (*eopt);
9288 while (len < option->size)
9289 if (((char *) option)[len] >= ' '
9290 && ((char *) option)[len] < 0x7f)
9291 printf ("%c", ((char *) option)[len++]);
9293 printf ("\\%03o", ((char *) option)[len++]);
9295 fputs ("\n", stdout);
9303 if (conflicts_offset != 0 && conflictsno != 0)
9305 Elf32_Conflict *iconf;
9308 if (dynamic_symbols == NULL)
9310 error (_("conflict list found without a dynamic symbol table\n"));
9314 iconf = cmalloc (conflictsno, sizeof (*iconf));
9317 error (_("Out of memory\n"));
9323 Elf32_External_Conflict *econf32;
9325 econf32 = get_data (NULL, file, conflicts_offset,
9326 conflictsno, sizeof (*econf32), _("conflict"));
9330 for (cnt = 0; cnt < conflictsno; ++cnt)
9331 iconf[cnt] = BYTE_GET (econf32[cnt]);
9337 Elf64_External_Conflict *econf64;
9339 econf64 = get_data (NULL, file, conflicts_offset,
9340 conflictsno, sizeof (*econf64), _("conflict"));
9344 for (cnt = 0; cnt < conflictsno; ++cnt)
9345 iconf[cnt] = BYTE_GET (econf64[cnt]);
9350 printf (_("\nSection '.conflict' contains %lu entries:\n"),
9351 (unsigned long) conflictsno);
9352 puts (_(" Num: Index Value Name"));
9354 for (cnt = 0; cnt < conflictsno; ++cnt)
9356 Elf_Internal_Sym *psym = & dynamic_symbols[iconf[cnt]];
9358 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
9359 print_vma (psym->st_value, FULL_HEX);
9361 if (VALID_DYNAMIC_NAME (psym->st_name))
9362 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
9364 printf ("<corrupt: %14ld>", psym->st_name);
9375 process_gnu_liblist (FILE *file)
9377 Elf_Internal_Shdr *section, *string_sec;
9378 Elf32_External_Lib *elib;
9387 for (i = 0, section = section_headers;
9388 i < elf_header.e_shnum;
9391 switch (section->sh_type)
9393 case SHT_GNU_LIBLIST:
9394 if (SECTION_HEADER_INDEX (section->sh_link) >= elf_header.e_shnum)
9397 elib = get_data (NULL, file, section->sh_offset, 1, section->sh_size,
9402 string_sec = SECTION_HEADER (section->sh_link);
9404 strtab = get_data (NULL, file, string_sec->sh_offset, 1,
9405 string_sec->sh_size, _("liblist string table"));
9406 strtab_size = string_sec->sh_size;
9409 || section->sh_entsize != sizeof (Elf32_External_Lib))
9415 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
9416 SECTION_NAME (section),
9417 (long) (section->sh_size / sizeof (Elf32_External_Lib)));
9419 puts (" Library Time Stamp Checksum Version Flags");
9421 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
9429 liblist.l_name = BYTE_GET (elib[cnt].l_name);
9430 time = BYTE_GET (elib[cnt].l_time_stamp);
9431 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
9432 liblist.l_version = BYTE_GET (elib[cnt].l_version);
9433 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
9435 tmp = gmtime (&time);
9436 snprintf (timebuf, sizeof (timebuf),
9437 "%04u-%02u-%02uT%02u:%02u:%02u",
9438 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9439 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
9441 printf ("%3lu: ", (unsigned long) cnt);
9443 printf ("%-20s", liblist.l_name < strtab_size
9444 ? strtab + liblist.l_name : "<corrupt>");
9446 printf ("%-20.20s", liblist.l_name < strtab_size
9447 ? strtab + liblist.l_name : "<corrupt>");
9448 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
9449 liblist.l_version, liblist.l_flags);
9460 get_note_type (unsigned e_type)
9462 static char buff[64];
9464 if (elf_header.e_type == ET_CORE)
9468 return _("NT_AUXV (auxiliary vector)");
9470 return _("NT_PRSTATUS (prstatus structure)");
9472 return _("NT_FPREGSET (floating point registers)");
9474 return _("NT_PRPSINFO (prpsinfo structure)");
9476 return _("NT_TASKSTRUCT (task structure)");
9478 return _("NT_PRXFPREG (user_xfpregs structure)");
9480 return _("NT_PPC_VMX (ppc Altivec registers)");
9482 return _("NT_PSTATUS (pstatus structure)");
9484 return _("NT_FPREGS (floating point registers)");
9486 return _("NT_PSINFO (psinfo structure)");
9488 return _("NT_LWPSTATUS (lwpstatus_t structure)");
9490 return _("NT_LWPSINFO (lwpsinfo_t structure)");
9491 case NT_WIN32PSTATUS:
9492 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
9500 return _("NT_VERSION (version)");
9502 return _("NT_ARCH (architecture)");
9507 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
9512 get_gnu_elf_note_type (unsigned e_type)
9514 static char buff[64];
9518 case NT_GNU_ABI_TAG:
9519 return _("NT_GNU_ABI_TAG (ABI version tag)");
9521 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
9522 case NT_GNU_BUILD_ID:
9523 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
9528 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
9533 get_netbsd_elfcore_note_type (unsigned e_type)
9535 static char buff[64];
9537 if (e_type == NT_NETBSDCORE_PROCINFO)
9539 /* NetBSD core "procinfo" structure. */
9540 return _("NetBSD procinfo structure");
9543 /* As of Jan 2002 there are no other machine-independent notes
9544 defined for NetBSD core files. If the note type is less
9545 than the start of the machine-dependent note types, we don't
9548 if (e_type < NT_NETBSDCORE_FIRSTMACH)
9550 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
9554 switch (elf_header.e_machine)
9556 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
9557 and PT_GETFPREGS == mach+2. */
9562 case EM_SPARC32PLUS:
9566 case NT_NETBSDCORE_FIRSTMACH+0:
9567 return _("PT_GETREGS (reg structure)");
9568 case NT_NETBSDCORE_FIRSTMACH+2:
9569 return _("PT_GETFPREGS (fpreg structure)");
9575 /* On all other arch's, PT_GETREGS == mach+1 and
9576 PT_GETFPREGS == mach+3. */
9580 case NT_NETBSDCORE_FIRSTMACH+1:
9581 return _("PT_GETREGS (reg structure)");
9582 case NT_NETBSDCORE_FIRSTMACH+3:
9583 return _("PT_GETFPREGS (fpreg structure)");
9589 snprintf (buff, sizeof (buff), _("PT_FIRSTMACH+%d"),
9590 e_type - NT_NETBSDCORE_FIRSTMACH);
9594 /* Note that by the ELF standard, the name field is already null byte
9595 terminated, and namesz includes the terminating null byte.
9596 I.E. the value of namesz for the name "FSF" is 4.
9598 If the value of namesz is zero, there is no name present. */
9600 process_note (Elf_Internal_Note *pnote)
9602 const char *name = pnote->namesz ? pnote->namedata : "(NONE)";
9605 if (pnote->namesz == 0)
9606 /* If there is no note name, then use the default set of
9607 note type strings. */
9608 nt = get_note_type (pnote->type);
9610 else if (const_strneq (pnote->namedata, "GNU"))
9611 /* GNU-specific object file notes. */
9612 nt = get_gnu_elf_note_type (pnote->type);
9614 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
9615 /* NetBSD-specific core file notes. */
9616 nt = get_netbsd_elfcore_note_type (pnote->type);
9618 else if (strneq (pnote->namedata, "SPU/", 4))
9620 /* SPU-specific core file notes. */
9621 nt = pnote->namedata + 4;
9626 /* Don't recognize this note name; just use the default set of
9627 note type strings. */
9628 nt = get_note_type (pnote->type);
9630 printf (" %s\t\t0x%08lx\t%s\n", name, pnote->descsz, nt);
9636 process_corefile_note_segment (FILE *file, bfd_vma offset, bfd_vma length)
9638 Elf_External_Note *pnotes;
9639 Elf_External_Note *external;
9645 pnotes = get_data (NULL, file, offset, 1, length, _("notes"));
9651 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
9652 (unsigned long) offset, (unsigned long) length);
9653 printf (_(" Owner\t\tData size\tDescription\n"));
9655 while (external < (Elf_External_Note *)((char *) pnotes + length))
9657 Elf_External_Note *next;
9658 Elf_Internal_Note inote;
9661 inote.type = BYTE_GET (external->type);
9662 inote.namesz = BYTE_GET (external->namesz);
9663 inote.namedata = external->name;
9664 inote.descsz = BYTE_GET (external->descsz);
9665 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
9666 inote.descpos = offset + (inote.descdata - (char *) pnotes);
9668 next = (Elf_External_Note *)(inote.descdata + align_power (inote.descsz, 2));
9670 if (((char *) next) > (((char *) pnotes) + length))
9672 warn (_("corrupt note found at offset %lx into core notes\n"),
9673 (long)((char *)external - (char *)pnotes));
9674 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
9675 inote.type, inote.namesz, inote.descsz);
9681 /* Verify that name is null terminated. It appears that at least
9682 one version of Linux (RedHat 6.0) generates corefiles that don't
9683 comply with the ELF spec by failing to include the null byte in
9685 if (inote.namedata[inote.namesz] != '\0')
9687 temp = malloc (inote.namesz + 1);
9691 error (_("Out of memory\n"));
9696 strncpy (temp, inote.namedata, inote.namesz);
9697 temp[inote.namesz] = 0;
9699 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
9700 inote.namedata = temp;
9703 res &= process_note (& inote);
9718 process_corefile_note_segments (FILE *file)
9720 Elf_Internal_Phdr *segment;
9724 if (! get_program_headers (file))
9727 for (i = 0, segment = program_headers;
9728 i < elf_header.e_phnum;
9731 if (segment->p_type == PT_NOTE)
9732 res &= process_corefile_note_segment (file,
9733 (bfd_vma) segment->p_offset,
9734 (bfd_vma) segment->p_filesz);
9741 process_note_sections (FILE *file)
9743 Elf_Internal_Shdr *section;
9747 for (i = 0, section = section_headers;
9748 i < elf_header.e_shnum;
9750 if (section->sh_type == SHT_NOTE)
9751 res &= process_corefile_note_segment (file,
9752 (bfd_vma) section->sh_offset,
9753 (bfd_vma) section->sh_size);
9759 process_notes (FILE *file)
9761 /* If we have not been asked to display the notes then do nothing. */
9765 if (elf_header.e_type != ET_CORE)
9766 return process_note_sections (file);
9768 /* No program headers means no NOTE segment. */
9769 if (elf_header.e_phnum > 0)
9770 return process_corefile_note_segments (file);
9772 printf (_("No note segments present in the core file.\n"));
9777 process_arch_specific (FILE *file)
9782 switch (elf_header.e_machine)
9785 return process_arm_specific (file);
9787 case EM_MIPS_RS3_LE:
9788 return process_mips_specific (file);
9791 return process_power_specific (file);
9800 get_file_header (FILE *file)
9802 /* Read in the identity array. */
9803 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
9806 /* Determine how to read the rest of the header. */
9807 switch (elf_header.e_ident[EI_DATA])
9809 default: /* fall through */
9810 case ELFDATANONE: /* fall through */
9812 byte_get = byte_get_little_endian;
9813 byte_put = byte_put_little_endian;
9816 byte_get = byte_get_big_endian;
9817 byte_put = byte_put_big_endian;
9821 /* For now we only support 32 bit and 64 bit ELF files. */
9822 is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
9824 /* Read in the rest of the header. */
9827 Elf32_External_Ehdr ehdr32;
9829 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
9832 elf_header.e_type = BYTE_GET (ehdr32.e_type);
9833 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
9834 elf_header.e_version = BYTE_GET (ehdr32.e_version);
9835 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
9836 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
9837 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
9838 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
9839 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
9840 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
9841 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
9842 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
9843 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
9844 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
9848 Elf64_External_Ehdr ehdr64;
9850 /* If we have been compiled with sizeof (bfd_vma) == 4, then
9851 we will not be able to cope with the 64bit data found in
9852 64 ELF files. Detect this now and abort before we start
9853 overwriting things. */
9854 if (sizeof (bfd_vma) < 8)
9856 error (_("This instance of readelf has been built without support for a\n\
9857 64 bit data type and so it cannot read 64 bit ELF files.\n"));
9861 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
9864 elf_header.e_type = BYTE_GET (ehdr64.e_type);
9865 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
9866 elf_header.e_version = BYTE_GET (ehdr64.e_version);
9867 elf_header.e_entry = BYTE_GET (ehdr64.e_entry);
9868 elf_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
9869 elf_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
9870 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
9871 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
9872 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
9873 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
9874 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
9875 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
9876 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
9879 if (elf_header.e_shoff)
9881 /* There may be some extensions in the first section header. Don't
9882 bomb if we can't read it. */
9884 get_32bit_section_headers (file, 1);
9886 get_64bit_section_headers (file, 1);
9889 is_relocatable = elf_header.e_type == ET_REL;
9894 /* Process one ELF object file according to the command line options.
9895 This file may actually be stored in an archive. The file is
9896 positioned at the start of the ELF object. */
9899 process_object (char *file_name, FILE *file)
9903 if (! get_file_header (file))
9905 error (_("%s: Failed to read file header\n"), file_name);
9909 /* Initialise per file variables. */
9910 for (i = ARRAY_SIZE (version_info); i--;)
9911 version_info[i] = 0;
9913 for (i = ARRAY_SIZE (dynamic_info); i--;)
9914 dynamic_info[i] = 0;
9916 /* Process the file. */
9918 printf (_("\nFile: %s\n"), file_name);
9920 /* Initialise the dump_sects array from the cmdline_dump_sects array.
9921 Note we do this even if cmdline_dump_sects is empty because we
9922 must make sure that the dump_sets array is zeroed out before each
9923 object file is processed. */
9924 if (num_dump_sects > num_cmdline_dump_sects)
9925 memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
9927 if (num_cmdline_dump_sects > 0)
9929 if (num_dump_sects == 0)
9930 /* A sneaky way of allocating the dump_sects array. */
9931 request_dump_bynumber (num_cmdline_dump_sects, 0);
9933 assert (num_dump_sects >= num_cmdline_dump_sects);
9934 memcpy (dump_sects, cmdline_dump_sects,
9935 num_cmdline_dump_sects * sizeof (* dump_sects));
9938 if (! process_file_header ())
9941 if (! process_section_headers (file))
9943 /* Without loaded section headers we cannot process lots of
9945 do_unwind = do_version = do_dump = do_arch = 0;
9947 if (! do_using_dynamic)
9948 do_syms = do_reloc = 0;
9951 if (! process_section_groups (file))
9953 /* Without loaded section groups we cannot process unwind. */
9957 if (process_program_headers (file))
9958 process_dynamic_section (file);
9960 process_relocs (file);
9962 process_unwind (file);
9964 process_symbol_table (file);
9966 process_syminfo (file);
9968 process_version_sections (file);
9970 process_section_contents (file);
9972 process_notes (file);
9974 process_gnu_liblist (file);
9976 process_arch_specific (file);
9978 if (program_headers)
9980 free (program_headers);
9981 program_headers = NULL;
9984 if (section_headers)
9986 free (section_headers);
9987 section_headers = NULL;
9992 free (string_table);
9993 string_table = NULL;
9994 string_table_length = 0;
9997 if (dynamic_strings)
9999 free (dynamic_strings);
10000 dynamic_strings = NULL;
10001 dynamic_strings_length = 0;
10004 if (dynamic_symbols)
10006 free (dynamic_symbols);
10007 dynamic_symbols = NULL;
10008 num_dynamic_syms = 0;
10011 if (dynamic_syminfo)
10013 free (dynamic_syminfo);
10014 dynamic_syminfo = NULL;
10017 if (section_headers_groups)
10019 free (section_headers_groups);
10020 section_headers_groups = NULL;
10023 if (section_groups)
10025 struct group_list *g, *next;
10027 for (i = 0; i < group_count; i++)
10029 for (g = section_groups [i].root; g != NULL; g = next)
10036 free (section_groups);
10037 section_groups = NULL;
10040 free_debug_memory ();
10045 /* Process an ELF archive.
10046 On entry the file is positioned just after the ARMAG string. */
10049 process_archive (char *file_name, FILE *file)
10051 struct ar_hdr arhdr;
10053 unsigned long size;
10054 unsigned long index_num = 0;
10055 unsigned long *index_array = NULL;
10056 char *sym_table = NULL;
10057 unsigned long sym_size = 0;
10058 char *longnames = NULL;
10059 unsigned long longnames_size = 0;
10060 size_t file_name_size;
10065 got = fread (&arhdr, 1, sizeof arhdr, file);
10066 if (got != sizeof arhdr)
10071 error (_("%s: failed to read archive header\n"), file_name);
10075 /* See if this is the archive symbol table. */
10076 if (const_strneq (arhdr.ar_name, "/ ")
10077 || const_strneq (arhdr.ar_name, "/SYM64/ "))
10079 size = strtoul (arhdr.ar_size, NULL, 10);
10080 size = size + (size & 1);
10082 if (do_archive_index)
10085 /* A buffer used to hold numbers read in from an archive index.
10086 These are always 4 bytes long and stored in big-endian format. */
10087 #define SIZEOF_AR_INDEX_NUMBERS 4
10088 unsigned char integer_buffer[SIZEOF_AR_INDEX_NUMBERS];
10089 unsigned char * index_buffer;
10091 /* Check the size of the archive index. */
10092 if (size < SIZEOF_AR_INDEX_NUMBERS)
10094 error (_("%s: the archive index is empty\n"), file_name);
10098 /* Read the numer of entries in the archive index. */
10099 got = fread (integer_buffer, 1, sizeof integer_buffer, file);
10100 if (got != sizeof (integer_buffer))
10102 error (_("%s: failed to read archive index\n"), file_name);
10105 index_num = byte_get_big_endian (integer_buffer, sizeof integer_buffer);
10106 size -= SIZEOF_AR_INDEX_NUMBERS;
10108 /* Read in the archive index. */
10109 if (size < index_num * SIZEOF_AR_INDEX_NUMBERS)
10111 error (_("%s: the archive index is supposed to have %ld entries, but the size in the header is too small\n"),
10112 file_name, index_num);
10115 index_buffer = malloc (index_num * SIZEOF_AR_INDEX_NUMBERS);
10116 if (index_buffer == NULL)
10118 error (_("Out of memory whilst trying to read archive symbol index\n"));
10121 got = fread (index_buffer, SIZEOF_AR_INDEX_NUMBERS, index_num, file);
10122 if (got != index_num)
10124 free (index_buffer);
10125 error (_("%s: failed to read archive index\n"), file_name);
10129 size -= index_num * SIZEOF_AR_INDEX_NUMBERS;
10131 /* Convert the index numbers into the host's numeric format. */
10132 index_array = malloc (index_num * sizeof (* index_array));
10133 if (index_array == NULL)
10135 free (index_buffer);
10136 error (_("Out of memory whilst trying to convert the archive symbol index\n"));
10140 for (i = 0; i < index_num; i++)
10141 index_array[i] = byte_get_big_endian ((unsigned char *)(index_buffer + (i * SIZEOF_AR_INDEX_NUMBERS)),
10142 SIZEOF_AR_INDEX_NUMBERS);
10143 free (index_buffer);
10145 /* The remaining space in the header is taken up by the symbol table. */
10148 error (_("%s: the archive has an index but no symbols\n"), file_name);
10152 sym_table = malloc (size);
10154 if (sym_table == NULL)
10156 error (_("Out of memory whilst trying to read archive index symbol table\n"));
10160 got = fread (sym_table, 1, size, file);
10163 error (_("%s: failed to read archive index symbol table\n"), file_name);
10170 if (fseek (file, size, SEEK_CUR) != 0)
10172 error (_("%s: failed to skip archive symbol table\n"), file_name);
10177 got = fread (& arhdr, 1, sizeof arhdr, file);
10178 if (got != sizeof arhdr)
10186 error (_("%s: failed to read archive header following archive index\n"), file_name);
10191 else if (do_archive_index)
10192 printf (_("%s has no archive index\n"), file_name);
10194 if (const_strneq (arhdr.ar_name, "// "))
10196 /* This is the archive string table holding long member
10199 longnames_size = strtoul (arhdr.ar_size, NULL, 10);
10200 longnames = malloc (longnames_size);
10201 if (longnames == NULL)
10203 error (_("Out of memory reading long symbol names in archive\n"));
10208 if (fread (longnames, longnames_size, 1, file) != 1)
10211 error (_("%s: failed to read long symbol name string table\n"), file_name);
10216 if ((longnames_size & 1) != 0)
10219 got = fread (& arhdr, 1, sizeof arhdr, file);
10220 if (got != sizeof arhdr)
10226 error (_("%s: failed to read archive header following long symbol names\n"), file_name);
10233 if (do_archive_index)
10235 if (sym_table == NULL)
10236 error (_("%s: unable to dump the index as none was found\n"), file_name);
10239 unsigned int i, j, k, l;
10241 unsigned long current_pos;
10243 printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
10244 file_name, index_num, sym_size);
10245 current_pos = ftell (file);
10247 for (i = l = 0; i < index_num; i++)
10249 if ((i == 0) || ((i > 0) && (index_array[i] != index_array[i - 1])))
10251 if (fseek (file, index_array[i], SEEK_SET) != 0)
10253 error (_("%s: failed to seek to next file name\n"), file_name);
10257 got = fread (elf_name, 1, 16, file);
10260 error (_("%s: failed to read file name\n"), file_name);
10265 if (elf_name[0] == '/')
10267 /* We have a long name. */
10268 k = j = strtoul (elf_name + 1, NULL, 10);
10269 while ((j < longnames_size) && (longnames[j] != '/'))
10271 longnames[j] = '\0';
10272 printf (_("Binary %s contains:\n"), longnames + k);
10273 longnames[j] = '/';
10278 while ((elf_name[j] != '/') && (j < 16))
10280 elf_name[j] = '\0';
10281 printf(_("Binary %s contains:\n"), elf_name);
10286 error (_("%s: end of the symbol table reached before the end of the index\n"),
10290 printf ("\t%s\n", sym_table + l);
10291 l += strlen (sym_table + l) + 1;
10295 error (_("%s: symbols remain in the index symbol table, but without corresponding entries in the index table\n"),
10298 free (index_array);
10299 index_array = NULL;
10302 if (fseek (file, current_pos, SEEK_SET) != 0)
10304 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
10309 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
10310 && !do_segments && !do_header && !do_dump && !do_version
10311 && !do_histogram && !do_debugging && !do_arch && !do_notes
10312 && !do_section_groups)
10313 return 0; /* Archive index only. */
10316 file_name_size = strlen (file_name);
10325 if (arhdr.ar_name[0] == '/')
10329 off = strtoul (arhdr.ar_name + 1, NULL, 10);
10330 if (off >= longnames_size)
10332 error (_("%s: invalid archive string table offset %lu\n"), file_name, off);
10337 name = longnames + off;
10338 nameend = memchr (name, '/', longnames_size - off);
10342 name = arhdr.ar_name;
10343 nameend = memchr (name, '/', 16);
10346 if (nameend == NULL)
10348 error (_("%s: bad archive file name\n"), file_name);
10353 namealc = malloc (file_name_size + (nameend - name) + 3);
10354 if (namealc == NULL)
10356 error (_("Out of memory\n"));
10361 memcpy (namealc, file_name, file_name_size);
10362 namealc[file_name_size] = '(';
10363 memcpy (namealc + file_name_size + 1, name, nameend - name);
10364 namealc[file_name_size + 1 + (nameend - name)] = ')';
10365 namealc[file_name_size + 2 + (nameend - name)] = '\0';
10367 archive_file_offset = ftell (file);
10368 archive_file_size = strtoul (arhdr.ar_size, NULL, 10);
10370 ret |= process_object (namealc, file);
10375 (archive_file_offset
10376 + archive_file_size
10377 + (archive_file_size & 1)),
10380 error (_("%s: failed to seek to next archive header\n"), file_name);
10385 got = fread (&arhdr, 1, sizeof arhdr, file);
10386 if (got != sizeof arhdr)
10391 error (_("%s: failed to read archive header\n"), file_name);
10398 if (index_array != NULL)
10399 free (index_array);
10400 if (sym_table != NULL)
10402 if (longnames != NULL)
10409 process_file (char *file_name)
10412 struct stat statbuf;
10413 char armag[SARMAG];
10416 if (stat (file_name, &statbuf) < 0)
10418 if (errno == ENOENT)
10419 error (_("'%s': No such file\n"), file_name);
10421 error (_("Could not locate '%s'. System error message: %s\n"),
10422 file_name, strerror (errno));
10426 if (! S_ISREG (statbuf.st_mode))
10428 error (_("'%s' is not an ordinary file\n"), file_name);
10432 file = fopen (file_name, "rb");
10435 error (_("Input file '%s' is not readable.\n"), file_name);
10439 if (fread (armag, SARMAG, 1, file) != 1)
10441 error (_("%s: Failed to read file's magic number\n"), file_name);
10446 if (memcmp (armag, ARMAG, SARMAG) == 0)
10447 ret = process_archive (file_name, file);
10450 if (do_archive_index)
10451 error (_("File %s is not an archive so its index cannot be displayed.\n"),
10455 archive_file_size = archive_file_offset = 0;
10456 ret = process_object (file_name, file);
10464 #ifdef SUPPORT_DISASSEMBLY
10465 /* Needed by the i386 disassembler. For extra credit, someone could
10466 fix this so that we insert symbolic addresses here, esp for GOT/PLT
10470 print_address (unsigned int addr, FILE *outfile)
10472 fprintf (outfile,"0x%8.8x", addr);
10475 /* Needed by the i386 disassembler. */
10477 db_task_printsym (unsigned int addr)
10479 print_address (addr, stderr);
10484 main (int argc, char **argv)
10488 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
10489 setlocale (LC_MESSAGES, "");
10491 #if defined (HAVE_SETLOCALE)
10492 setlocale (LC_CTYPE, "");
10494 bindtextdomain (PACKAGE, LOCALEDIR);
10495 textdomain (PACKAGE);
10497 expandargv (&argc, &argv);
10499 parse_args (argc, argv);
10501 if (num_dump_sects > 0)
10503 /* Make a copy of the dump_sects array. */
10504 cmdline_dump_sects = malloc (num_dump_sects * sizeof (* dump_sects));
10505 if (cmdline_dump_sects == NULL)
10506 error (_("Out of memory allocating dump request table.\n"));
10509 memcpy (cmdline_dump_sects, dump_sects,
10510 num_dump_sects * sizeof (* dump_sects));
10511 num_cmdline_dump_sects = num_dump_sects;
10515 if (optind < (argc - 1))
10519 while (optind < argc)
10520 err |= process_file (argv[optind++]);
10522 if (dump_sects != NULL)
10524 if (cmdline_dump_sects != NULL)
10525 free (cmdline_dump_sects);