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 2 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/cris.h"
115 #include "elf/d10v.h"
116 #include "elf/d30v.h"
118 #include "elf/fr30.h"
121 #include "elf/hppa.h"
122 #include "elf/i386.h"
123 #include "elf/i370.h"
124 #include "elf/i860.h"
125 #include "elf/i960.h"
126 #include "elf/ia64.h"
127 #include "elf/ip2k.h"
128 #include "elf/iq2000.h"
129 #include "elf/m32c.h"
130 #include "elf/m32r.h"
131 #include "elf/m68k.h"
132 #include "elf/m68hc11.h"
133 #include "elf/mcore.h"
135 #include "elf/mips.h"
136 #include "elf/mmix.h"
137 #include "elf/mn10200.h"
138 #include "elf/mn10300.h"
140 #include "elf/msp430.h"
141 #include "elf/or32.h"
144 #include "elf/ppc64.h"
145 #include "elf/s390.h"
146 #include "elf/score.h"
148 #include "elf/sparc.h"
150 #include "elf/v850.h"
152 #include "elf/x86-64.h"
153 #include "elf/xstormy16.h"
154 #include "elf/xtensa.h"
159 #include "libiberty.h"
161 char *program_name = "readelf";
162 static long archive_file_offset;
163 static unsigned long archive_file_size;
164 static unsigned long dynamic_addr;
165 static bfd_size_type dynamic_size;
166 static unsigned int dynamic_nent;
167 static char *dynamic_strings;
168 static unsigned long dynamic_strings_length;
169 static char *string_table;
170 static unsigned long string_table_length;
171 static unsigned long num_dynamic_syms;
172 static Elf_Internal_Sym *dynamic_symbols;
173 static Elf_Internal_Syminfo *dynamic_syminfo;
174 static unsigned long dynamic_syminfo_offset;
175 static unsigned int dynamic_syminfo_nent;
176 static char program_interpreter[PATH_MAX];
177 static bfd_vma dynamic_info[DT_JMPREL + 1];
178 static bfd_vma dynamic_info_DT_GNU_HASH;
179 static bfd_vma version_info[16];
180 static Elf_Internal_Ehdr elf_header;
181 static Elf_Internal_Shdr *section_headers;
182 static Elf_Internal_Phdr *program_headers;
183 static Elf_Internal_Dyn *dynamic_section;
184 static Elf_Internal_Shdr *symtab_shndx_hdr;
185 static int show_name;
186 static int do_dynamic;
189 static int do_sections;
190 static int do_section_groups;
191 static int do_section_details;
192 static int do_segments;
193 static int do_unwind;
194 static int do_using_dynamic;
195 static int do_header;
197 static int do_version;
199 static int do_histogram;
200 static int do_debugging;
203 static int is_32bit_elf;
207 struct group_list *next;
208 unsigned int section_index;
213 struct group_list *root;
214 unsigned int group_index;
217 static size_t group_count;
218 static struct group *section_groups;
219 static struct group **section_headers_groups;
221 /* A linked list of the section names for which dumps were requested
223 struct dump_list_entry
227 struct dump_list_entry *next;
229 static struct dump_list_entry *dump_sects_byname;
231 /* A dynamic array of flags indicating for which sections a hex dump
232 has been requested (via the -x switch) and/or a disassembly dump
233 (via the -i switch). */
234 char *cmdline_dump_sects = NULL;
235 unsigned num_cmdline_dump_sects = 0;
237 /* A dynamic array of flags indicating for which sections a dump of
238 some kind has been requested. It is reset on a per-object file
239 basis and then initialised from the cmdline_dump_sects array,
240 the results of interpreting the -w switch, and the
241 dump_sects_byname list. */
242 char *dump_sects = NULL;
243 unsigned int num_dump_sects = 0;
245 #define HEX_DUMP (1 << 0)
246 #define DISASS_DUMP (1 << 1)
247 #define DEBUG_DUMP (1 << 2)
249 /* How to print a vma value. */
250 typedef enum print_mode
262 static void (*byte_put) (unsigned char *, bfd_vma, int);
266 #define SECTION_NAME(X) \
267 ((X) == NULL ? "<none>" \
268 : string_table == NULL ? "<no-name>" \
269 : ((X)->sh_name >= string_table_length ? "<corrupt>" \
270 : string_table + (X)->sh_name))
272 /* Given st_shndx I, map to section_headers index. */
273 #define SECTION_HEADER_INDEX(I) \
274 ((I) < SHN_LORESERVE \
276 : ((I) <= SHN_HIRESERVE \
278 : (I) - (SHN_HIRESERVE + 1 - SHN_LORESERVE)))
280 /* Reverse of the above. */
281 #define SECTION_HEADER_NUM(N) \
282 ((N) < SHN_LORESERVE \
284 : (N) + (SHN_HIRESERVE + 1 - SHN_LORESERVE))
286 #define SECTION_HEADER(I) (section_headers + SECTION_HEADER_INDEX (I))
288 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
290 #define BYTE_GET(field) byte_get (field, sizeof (field))
292 #define NUM_ELEM(array) (sizeof (array) / sizeof ((array)[0]))
294 #define GET_ELF_SYMBOLS(file, section) \
295 (is_32bit_elf ? get_32bit_elf_symbols (file, section) \
296 : get_64bit_elf_symbols (file, section))
298 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
299 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
300 already been called and verified that the string exists. */
301 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
303 /* This is just a bit of syntatic sugar. */
304 #define streq(a,b) (strcmp ((a), (b)) == 0)
305 #define strneq(a,b,n) (strncmp ((a), (b), (n)) == 0)
306 #define const_strneq(a,b) (strncmp ((a), (b), sizeof (b) - 1) == 0)
309 get_data (void *var, FILE *file, long offset, size_t size, size_t nmemb,
314 if (size == 0 || nmemb == 0)
317 if (fseek (file, archive_file_offset + offset, SEEK_SET))
319 error (_("Unable to seek to 0x%lx for %s\n"),
320 archive_file_offset + offset, reason);
327 /* Check for overflow. */
328 if (nmemb < (~(size_t) 0 - 1) / size)
329 /* + 1 so that we can '\0' terminate invalid string table sections. */
330 mvar = malloc (size * nmemb + 1);
334 error (_("Out of memory allocating 0x%lx bytes for %s\n"),
335 (unsigned long)(size * nmemb), reason);
339 ((char *) mvar)[size * nmemb] = '\0';
342 if (fread (mvar, size, nmemb, file) != nmemb)
344 error (_("Unable to read in 0x%lx bytes of %s\n"),
345 (unsigned long)(size * nmemb), reason);
355 byte_put_little_endian (unsigned char *field, bfd_vma value, int size)
360 field[7] = (((value >> 24) >> 24) >> 8) & 0xff;
361 field[6] = ((value >> 24) >> 24) & 0xff;
362 field[5] = ((value >> 24) >> 16) & 0xff;
363 field[4] = ((value >> 24) >> 8) & 0xff;
366 field[3] = (value >> 24) & 0xff;
367 field[2] = (value >> 16) & 0xff;
370 field[1] = (value >> 8) & 0xff;
373 field[0] = value & 0xff;
377 error (_("Unhandled data length: %d\n"), size);
382 #if defined BFD64 && !BFD_HOST_64BIT_LONG
384 print_dec_vma (bfd_vma vma, int is_signed)
390 if (is_signed && (bfd_signed_vma) vma < 0)
399 *bufp++ = '0' + vma % 10;
411 print_hex_vma (bfd_vma vma)
419 char digit = '0' + (vma & 0x0f);
421 digit += 'a' - '0' - 10;
434 /* Print a VMA value. */
436 print_vma (bfd_vma vma, print_mode mode)
445 return printf ("0x%8.8lx", (unsigned long) vma);
448 return printf ("%8.8lx", (unsigned long) vma);
452 return printf ("%5ld", (long) vma);
456 return printf ("0x%lx", (unsigned long) vma);
459 return printf ("%lx", (unsigned long) vma);
462 return printf ("%ld", (unsigned long) vma);
465 return printf ("%lu", (unsigned long) vma);
488 #if BFD_HOST_64BIT_LONG
489 return nc + printf ("%lx", vma);
491 return nc + print_hex_vma (vma);
495 #if BFD_HOST_64BIT_LONG
496 return printf ("%ld", vma);
498 return print_dec_vma (vma, 1);
502 #if BFD_HOST_64BIT_LONG
504 return printf ("%5ld", vma);
506 return printf ("%#lx", vma);
509 return printf ("%5ld", _bfd_int64_low (vma));
511 return print_hex_vma (vma);
515 #if BFD_HOST_64BIT_LONG
516 return printf ("%lu", vma);
518 return print_dec_vma (vma, 0);
526 /* Display a symbol on stdout. If do_wide is not true then
527 format the symbol to be at most WIDTH characters,
528 truncating as necessary. If WIDTH is negative then
529 format the string to be exactly - WIDTH characters,
530 truncating or padding as necessary. */
533 print_symbol (int width, const char *symbol)
536 printf ("%s", symbol);
538 printf ("%-*.*s", width, width, symbol);
540 printf ("%-.*s", width, symbol);
544 byte_put_big_endian (unsigned char *field, bfd_vma value, int size)
549 field[7] = value & 0xff;
550 field[6] = (value >> 8) & 0xff;
551 field[5] = (value >> 16) & 0xff;
552 field[4] = (value >> 24) & 0xff;
557 field[3] = value & 0xff;
558 field[2] = (value >> 8) & 0xff;
562 field[1] = value & 0xff;
566 field[0] = value & 0xff;
570 error (_("Unhandled data length: %d\n"), size);
575 /* Return a pointer to section NAME, or NULL if no such section exists. */
577 static Elf_Internal_Shdr *
578 find_section (const char *name)
582 for (i = 0; i < elf_header.e_shnum; i++)
583 if (streq (SECTION_NAME (section_headers + i), name))
584 return section_headers + i;
589 /* Guess the relocation size commonly used by the specific machines. */
592 guess_is_rela (unsigned long e_machine)
596 /* Targets that use REL relocations. */
612 /* Targets that use RELA relocations. */
616 case EM_ALTERA_NIOS2:
640 case EM_CYGNUS_MN10200:
642 case EM_CYGNUS_MN10300:
683 warn (_("Don't know about relocations on this machine architecture\n"));
689 slurp_rela_relocs (FILE *file,
690 unsigned long rel_offset,
691 unsigned long rel_size,
692 Elf_Internal_Rela **relasp,
693 unsigned long *nrelasp)
695 Elf_Internal_Rela *relas;
696 unsigned long nrelas;
701 Elf32_External_Rela *erelas;
703 erelas = get_data (NULL, file, rel_offset, 1, rel_size, _("relocs"));
707 nrelas = rel_size / sizeof (Elf32_External_Rela);
709 relas = cmalloc (nrelas, sizeof (Elf_Internal_Rela));
714 error (_("out of memory parsing relocs\n"));
718 for (i = 0; i < nrelas; i++)
720 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
721 relas[i].r_info = BYTE_GET (erelas[i].r_info);
722 relas[i].r_addend = BYTE_GET (erelas[i].r_addend);
729 Elf64_External_Rela *erelas;
731 erelas = get_data (NULL, file, rel_offset, 1, rel_size, _("relocs"));
735 nrelas = rel_size / sizeof (Elf64_External_Rela);
737 relas = cmalloc (nrelas, sizeof (Elf_Internal_Rela));
742 error (_("out of memory parsing relocs\n"));
746 for (i = 0; i < nrelas; i++)
748 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
749 relas[i].r_info = BYTE_GET (erelas[i].r_info);
750 relas[i].r_addend = BYTE_GET (erelas[i].r_addend);
761 slurp_rel_relocs (FILE *file,
762 unsigned long rel_offset,
763 unsigned long rel_size,
764 Elf_Internal_Rela **relsp,
765 unsigned long *nrelsp)
767 Elf_Internal_Rela *rels;
773 Elf32_External_Rel *erels;
775 erels = get_data (NULL, file, rel_offset, 1, rel_size, _("relocs"));
779 nrels = rel_size / sizeof (Elf32_External_Rel);
781 rels = cmalloc (nrels, sizeof (Elf_Internal_Rela));
786 error (_("out of memory parsing relocs\n"));
790 for (i = 0; i < nrels; i++)
792 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
793 rels[i].r_info = BYTE_GET (erels[i].r_info);
794 rels[i].r_addend = 0;
801 Elf64_External_Rel *erels;
803 erels = get_data (NULL, file, rel_offset, 1, rel_size, _("relocs"));
807 nrels = rel_size / sizeof (Elf64_External_Rel);
809 rels = cmalloc (nrels, sizeof (Elf_Internal_Rela));
814 error (_("out of memory parsing relocs\n"));
818 for (i = 0; i < nrels; i++)
820 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
821 rels[i].r_info = BYTE_GET (erels[i].r_info);
822 rels[i].r_addend = 0;
832 /* Display the contents of the relocation data found at the specified
836 dump_relocations (FILE *file,
837 unsigned long rel_offset,
838 unsigned long rel_size,
839 Elf_Internal_Sym *symtab,
842 unsigned long strtablen,
846 Elf_Internal_Rela *rels;
849 if (is_rela == UNKNOWN)
850 is_rela = guess_is_rela (elf_header.e_machine);
854 if (!slurp_rela_relocs (file, rel_offset, rel_size, &rels, &rel_size))
859 if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
868 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
870 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
875 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
877 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
885 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
887 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
892 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
894 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
898 for (i = 0; i < rel_size; i++)
901 const char *rtype2 = NULL;
902 const char *rtype3 = NULL;
905 bfd_vma symtab_index;
910 offset = rels[i].r_offset;
911 info = rels[i].r_info;
915 type = ELF32_R_TYPE (info);
916 symtab_index = ELF32_R_SYM (info);
920 /* The #ifdef BFD64 below is to prevent a compile time warning.
921 We know that if we do not have a 64 bit data type that we
922 will never execute this code anyway. */
924 if (elf_header.e_machine == EM_MIPS)
926 /* In little-endian objects, r_info isn't really a 64-bit
927 little-endian value: it has a 32-bit little-endian
928 symbol index followed by four individual byte fields.
929 Reorder INFO accordingly. */
930 if (elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
931 info = (((info & 0xffffffff) << 32)
932 | ((info >> 56) & 0xff)
933 | ((info >> 40) & 0xff00)
934 | ((info >> 24) & 0xff0000)
935 | ((info >> 8) & 0xff000000));
936 type = ELF64_MIPS_R_TYPE (info);
937 type2 = ELF64_MIPS_R_TYPE2 (info);
938 type3 = ELF64_MIPS_R_TYPE3 (info);
940 else if (elf_header.e_machine == EM_SPARCV9)
941 type = ELF64_R_TYPE_ID (info);
943 type = ELF64_R_TYPE (info);
945 symtab_index = ELF64_R_SYM (info);
951 #ifdef _bfd_int64_low
952 printf ("%8.8lx %8.8lx ", _bfd_int64_low (offset), _bfd_int64_low (info));
954 printf ("%8.8lx %8.8lx ", offset, info);
959 #ifdef _bfd_int64_low
961 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
962 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
963 _bfd_int64_high (offset),
964 _bfd_int64_low (offset),
965 _bfd_int64_high (info),
966 _bfd_int64_low (info));
969 ? "%16.16lx %16.16lx "
970 : "%12.12lx %12.12lx ",
975 switch (elf_header.e_machine)
983 rtype = elf_m32r_reloc_type (type);
988 rtype = elf_i386_reloc_type (type);
993 rtype = elf_m68hc11_reloc_type (type);
997 rtype = elf_m68k_reloc_type (type);
1001 rtype = elf_i960_reloc_type (type);
1006 rtype = elf_avr_reloc_type (type);
1009 case EM_OLD_SPARCV9:
1010 case EM_SPARC32PLUS:
1013 rtype = elf_sparc_reloc_type (type);
1017 rtype = elf_spu_reloc_type (type);
1021 case EM_CYGNUS_V850:
1022 rtype = v850_reloc_type (type);
1026 case EM_CYGNUS_D10V:
1027 rtype = elf_d10v_reloc_type (type);
1031 case EM_CYGNUS_D30V:
1032 rtype = elf_d30v_reloc_type (type);
1036 rtype = elf_dlx_reloc_type (type);
1040 rtype = elf_sh_reloc_type (type);
1044 case EM_CYGNUS_MN10300:
1045 rtype = elf_mn10300_reloc_type (type);
1049 case EM_CYGNUS_MN10200:
1050 rtype = elf_mn10200_reloc_type (type);
1054 case EM_CYGNUS_FR30:
1055 rtype = elf_fr30_reloc_type (type);
1059 rtype = elf_frv_reloc_type (type);
1063 rtype = elf_mcore_reloc_type (type);
1067 rtype = elf_mmix_reloc_type (type);
1072 rtype = elf_msp430_reloc_type (type);
1076 rtype = elf_ppc_reloc_type (type);
1080 rtype = elf_ppc64_reloc_type (type);
1084 case EM_MIPS_RS3_LE:
1085 rtype = elf_mips_reloc_type (type);
1088 rtype2 = elf_mips_reloc_type (type2);
1089 rtype3 = elf_mips_reloc_type (type3);
1094 rtype = elf_alpha_reloc_type (type);
1098 rtype = elf_arm_reloc_type (type);
1102 rtype = elf_arc_reloc_type (type);
1106 rtype = elf_hppa_reloc_type (type);
1112 rtype = elf_h8_reloc_type (type);
1117 rtype = elf_or32_reloc_type (type);
1122 rtype = elf_pj_reloc_type (type);
1125 rtype = elf_ia64_reloc_type (type);
1129 rtype = elf_cris_reloc_type (type);
1133 rtype = elf_i860_reloc_type (type);
1137 rtype = elf_x86_64_reloc_type (type);
1141 rtype = i370_reloc_type (type);
1146 rtype = elf_s390_reloc_type (type);
1150 rtype = elf_score_reloc_type (type);
1154 rtype = elf_xstormy16_reloc_type (type);
1158 rtype = elf_crx_reloc_type (type);
1162 rtype = elf_vax_reloc_type (type);
1167 rtype = elf_ip2k_reloc_type (type);
1171 rtype = elf_iq2000_reloc_type (type);
1176 rtype = elf_xtensa_reloc_type (type);
1180 rtype = elf_m32c_reloc_type (type);
1184 rtype = elf_mt_reloc_type (type);
1188 rtype = elf_bfin_reloc_type (type);
1192 rtype = elf_mep_reloc_type (type);
1197 #ifdef _bfd_int64_low
1198 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type));
1200 printf (_("unrecognized: %-7lx"), type);
1203 printf (do_wide ? "%-22.22s" : "%-17.17s", rtype);
1205 if (elf_header.e_machine == EM_ALPHA
1207 && streq (rtype, "R_ALPHA_LITUSE")
1210 switch (rels[i].r_addend)
1212 case LITUSE_ALPHA_ADDR: rtype = "ADDR"; break;
1213 case LITUSE_ALPHA_BASE: rtype = "BASE"; break;
1214 case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1215 case LITUSE_ALPHA_JSR: rtype = "JSR"; break;
1216 case LITUSE_ALPHA_TLSGD: rtype = "TLSGD"; break;
1217 case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1218 case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1219 default: rtype = NULL;
1222 printf (" (%s)", rtype);
1226 printf (_("<unknown addend: %lx>"),
1227 (unsigned long) rels[i].r_addend);
1230 else if (symtab_index)
1232 if (symtab == NULL || symtab_index >= nsyms)
1233 printf (" bad symbol index: %08lx", (unsigned long) symtab_index);
1236 Elf_Internal_Sym *psym;
1238 psym = symtab + symtab_index;
1241 print_vma (psym->st_value, LONG_HEX);
1242 printf (is_32bit_elf ? " " : " ");
1244 if (psym->st_name == 0)
1246 const char *sec_name = "<null>";
1249 if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1251 bfd_vma sec_index = (bfd_vma) -1;
1253 if (psym->st_shndx < SHN_LORESERVE)
1254 sec_index = psym->st_shndx;
1255 else if (psym->st_shndx > SHN_HIRESERVE)
1256 sec_index = psym->st_shndx - (SHN_HIRESERVE + 1
1259 if (sec_index != (bfd_vma) -1)
1260 sec_name = SECTION_NAME (section_headers + sec_index);
1261 else if (psym->st_shndx == SHN_ABS)
1263 else if (psym->st_shndx == SHN_COMMON)
1264 sec_name = "COMMON";
1265 else if (elf_header.e_machine == EM_MIPS
1266 && psym->st_shndx == SHN_MIPS_SCOMMON)
1267 sec_name = "SCOMMON";
1268 else if (elf_header.e_machine == EM_MIPS
1269 && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1270 sec_name = "SUNDEF";
1271 else if (elf_header.e_machine == EM_X86_64
1272 && psym->st_shndx == SHN_X86_64_LCOMMON)
1273 sec_name = "LARGE_COMMON";
1274 else if (elf_header.e_machine == EM_IA_64
1275 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1276 && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1277 sec_name = "ANSI_COM";
1280 sprintf (name_buf, "<section 0x%x>",
1281 (unsigned int) psym->st_shndx);
1282 sec_name = name_buf;
1285 print_symbol (22, sec_name);
1287 else if (strtab == NULL)
1288 printf (_("<string table index: %3ld>"), psym->st_name);
1289 else if (psym->st_name >= strtablen)
1290 printf (_("<corrupt string table index: %3ld>"), psym->st_name);
1292 print_symbol (22, strtab + psym->st_name);
1295 printf (" + %lx", (unsigned long) rels[i].r_addend);
1300 printf ("%*c", is_32bit_elf ?
1301 (do_wide ? 34 : 28) : (do_wide ? 26 : 20), ' ');
1302 print_vma (rels[i].r_addend, LONG_HEX);
1305 if (elf_header.e_machine == EM_SPARCV9
1307 && streq (rtype, "R_SPARC_OLO10"))
1308 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (info));
1312 if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
1314 printf (" Type2: ");
1317 #ifdef _bfd_int64_low
1318 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type2));
1320 printf (_("unrecognized: %-7lx"), type2);
1323 printf ("%-17.17s", rtype2);
1325 printf ("\n Type3: ");
1328 #ifdef _bfd_int64_low
1329 printf (_("unrecognized: %-7lx"), _bfd_int64_low (type3));
1331 printf (_("unrecognized: %-7lx"), type3);
1334 printf ("%-17.17s", rtype3);
1346 get_mips_dynamic_type (unsigned long type)
1350 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1351 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1352 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1353 case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1354 case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1355 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1356 case DT_MIPS_MSYM: return "MIPS_MSYM";
1357 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1358 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1359 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1360 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1361 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1362 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1363 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1364 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1365 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1366 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1367 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1368 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1369 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1370 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1371 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1372 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1373 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1374 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1375 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1376 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1377 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1378 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1379 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1380 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1381 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1382 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1383 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1384 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1385 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1386 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1387 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1388 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1389 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1390 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1391 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1392 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
1399 get_sparc64_dynamic_type (unsigned long type)
1403 case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1410 get_ppc_dynamic_type (unsigned long type)
1414 case DT_PPC_GOT: return "PPC_GOT";
1421 get_ppc64_dynamic_type (unsigned long type)
1425 case DT_PPC64_GLINK: return "PPC64_GLINK";
1426 case DT_PPC64_OPD: return "PPC64_OPD";
1427 case DT_PPC64_OPDSZ: return "PPC64_OPDSZ";
1434 get_parisc_dynamic_type (unsigned long type)
1438 case DT_HP_LOAD_MAP: return "HP_LOAD_MAP";
1439 case DT_HP_DLD_FLAGS: return "HP_DLD_FLAGS";
1440 case DT_HP_DLD_HOOK: return "HP_DLD_HOOK";
1441 case DT_HP_UX10_INIT: return "HP_UX10_INIT";
1442 case DT_HP_UX10_INITSZ: return "HP_UX10_INITSZ";
1443 case DT_HP_PREINIT: return "HP_PREINIT";
1444 case DT_HP_PREINITSZ: return "HP_PREINITSZ";
1445 case DT_HP_NEEDED: return "HP_NEEDED";
1446 case DT_HP_TIME_STAMP: return "HP_TIME_STAMP";
1447 case DT_HP_CHECKSUM: return "HP_CHECKSUM";
1448 case DT_HP_GST_SIZE: return "HP_GST_SIZE";
1449 case DT_HP_GST_VERSION: return "HP_GST_VERSION";
1450 case DT_HP_GST_HASHVAL: return "HP_GST_HASHVAL";
1451 case DT_HP_EPLTREL: return "HP_GST_EPLTREL";
1452 case DT_HP_EPLTRELSZ: return "HP_GST_EPLTRELSZ";
1453 case DT_HP_FILTERED: return "HP_FILTERED";
1454 case DT_HP_FILTER_TLS: return "HP_FILTER_TLS";
1455 case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1456 case DT_HP_LAZYLOAD: return "HP_LAZYLOAD";
1457 case DT_HP_BIND_NOW_COUNT: return "HP_BIND_NOW_COUNT";
1458 case DT_PLT: return "PLT";
1459 case DT_PLT_SIZE: return "PLT_SIZE";
1460 case DT_DLT: return "DLT";
1461 case DT_DLT_SIZE: return "DLT_SIZE";
1468 get_ia64_dynamic_type (unsigned long type)
1472 case DT_IA_64_PLT_RESERVE: return "IA_64_PLT_RESERVE";
1479 get_alpha_dynamic_type (unsigned long type)
1483 case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
1490 get_score_dynamic_type (unsigned long type)
1494 case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
1495 case DT_SCORE_LOCAL_GOTNO: return "SCORE_LOCAL_GOTNO";
1496 case DT_SCORE_SYMTABNO: return "SCORE_SYMTABNO";
1497 case DT_SCORE_GOTSYM: return "SCORE_GOTSYM";
1498 case DT_SCORE_UNREFEXTNO: return "SCORE_UNREFEXTNO";
1499 case DT_SCORE_HIPAGENO: return "SCORE_HIPAGENO";
1507 get_dynamic_type (unsigned long type)
1509 static char buff[64];
1513 case DT_NULL: return "NULL";
1514 case DT_NEEDED: return "NEEDED";
1515 case DT_PLTRELSZ: return "PLTRELSZ";
1516 case DT_PLTGOT: return "PLTGOT";
1517 case DT_HASH: return "HASH";
1518 case DT_STRTAB: return "STRTAB";
1519 case DT_SYMTAB: return "SYMTAB";
1520 case DT_RELA: return "RELA";
1521 case DT_RELASZ: return "RELASZ";
1522 case DT_RELAENT: return "RELAENT";
1523 case DT_STRSZ: return "STRSZ";
1524 case DT_SYMENT: return "SYMENT";
1525 case DT_INIT: return "INIT";
1526 case DT_FINI: return "FINI";
1527 case DT_SONAME: return "SONAME";
1528 case DT_RPATH: return "RPATH";
1529 case DT_SYMBOLIC: return "SYMBOLIC";
1530 case DT_REL: return "REL";
1531 case DT_RELSZ: return "RELSZ";
1532 case DT_RELENT: return "RELENT";
1533 case DT_PLTREL: return "PLTREL";
1534 case DT_DEBUG: return "DEBUG";
1535 case DT_TEXTREL: return "TEXTREL";
1536 case DT_JMPREL: return "JMPREL";
1537 case DT_BIND_NOW: return "BIND_NOW";
1538 case DT_INIT_ARRAY: return "INIT_ARRAY";
1539 case DT_FINI_ARRAY: return "FINI_ARRAY";
1540 case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
1541 case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
1542 case DT_RUNPATH: return "RUNPATH";
1543 case DT_FLAGS: return "FLAGS";
1545 case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1546 case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
1548 case DT_CHECKSUM: return "CHECKSUM";
1549 case DT_PLTPADSZ: return "PLTPADSZ";
1550 case DT_MOVEENT: return "MOVEENT";
1551 case DT_MOVESZ: return "MOVESZ";
1552 case DT_FEATURE: return "FEATURE";
1553 case DT_POSFLAG_1: return "POSFLAG_1";
1554 case DT_SYMINSZ: return "SYMINSZ";
1555 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
1557 case DT_ADDRRNGLO: return "ADDRRNGLO";
1558 case DT_CONFIG: return "CONFIG";
1559 case DT_DEPAUDIT: return "DEPAUDIT";
1560 case DT_AUDIT: return "AUDIT";
1561 case DT_PLTPAD: return "PLTPAD";
1562 case DT_MOVETAB: return "MOVETAB";
1563 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
1565 case DT_VERSYM: return "VERSYM";
1567 case DT_TLSDESC_GOT: return "TLSDESC_GOT";
1568 case DT_TLSDESC_PLT: return "TLSDESC_PLT";
1569 case DT_RELACOUNT: return "RELACOUNT";
1570 case DT_RELCOUNT: return "RELCOUNT";
1571 case DT_FLAGS_1: return "FLAGS_1";
1572 case DT_VERDEF: return "VERDEF";
1573 case DT_VERDEFNUM: return "VERDEFNUM";
1574 case DT_VERNEED: return "VERNEED";
1575 case DT_VERNEEDNUM: return "VERNEEDNUM";
1577 case DT_AUXILIARY: return "AUXILIARY";
1578 case DT_USED: return "USED";
1579 case DT_FILTER: return "FILTER";
1581 case DT_GNU_PRELINKED: return "GNU_PRELINKED";
1582 case DT_GNU_CONFLICT: return "GNU_CONFLICT";
1583 case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
1584 case DT_GNU_LIBLIST: return "GNU_LIBLIST";
1585 case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
1586 case DT_GNU_HASH: return "GNU_HASH";
1589 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1593 switch (elf_header.e_machine)
1596 case EM_MIPS_RS3_LE:
1597 result = get_mips_dynamic_type (type);
1600 result = get_sparc64_dynamic_type (type);
1603 result = get_ppc_dynamic_type (type);
1606 result = get_ppc64_dynamic_type (type);
1609 result = get_ia64_dynamic_type (type);
1612 result = get_alpha_dynamic_type (type);
1615 result = get_score_dynamic_type (type);
1625 snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
1627 else if (((type >= DT_LOOS) && (type <= DT_HIOS))
1628 || (elf_header.e_machine == EM_PARISC
1629 && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
1633 switch (elf_header.e_machine)
1636 result = get_parisc_dynamic_type (type);
1646 snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
1650 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
1657 get_file_type (unsigned e_type)
1659 static char buff[32];
1663 case ET_NONE: return _("NONE (None)");
1664 case ET_REL: return _("REL (Relocatable file)");
1665 case ET_EXEC: return _("EXEC (Executable file)");
1666 case ET_DYN: return _("DYN (Shared object file)");
1667 case ET_CORE: return _("CORE (Core file)");
1670 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
1671 snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
1672 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
1673 snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
1675 snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
1681 get_machine_name (unsigned e_machine)
1683 static char buff[64]; /* XXX */
1687 case EM_NONE: return _("None");
1688 case EM_M32: return "WE32100";
1689 case EM_SPARC: return "Sparc";
1690 case EM_SPU: return "SPU";
1691 case EM_386: return "Intel 80386";
1692 case EM_68K: return "MC68000";
1693 case EM_88K: return "MC88000";
1694 case EM_486: return "Intel 80486";
1695 case EM_860: return "Intel 80860";
1696 case EM_MIPS: return "MIPS R3000";
1697 case EM_S370: return "IBM System/370";
1698 case EM_MIPS_RS3_LE: return "MIPS R4000 big-endian";
1699 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
1700 case EM_PARISC: return "HPPA";
1701 case EM_PPC_OLD: return "Power PC (old)";
1702 case EM_SPARC32PLUS: return "Sparc v8+" ;
1703 case EM_960: return "Intel 90860";
1704 case EM_PPC: return "PowerPC";
1705 case EM_PPC64: return "PowerPC64";
1706 case EM_V800: return "NEC V800";
1707 case EM_FR20: return "Fujitsu FR20";
1708 case EM_RH32: return "TRW RH32";
1709 case EM_MCORE: return "MCORE";
1710 case EM_ARM: return "ARM";
1711 case EM_OLD_ALPHA: return "Digital Alpha (old)";
1712 case EM_SH: return "Renesas / SuperH SH";
1713 case EM_SPARCV9: return "Sparc v9";
1714 case EM_TRICORE: return "Siemens Tricore";
1715 case EM_ARC: return "ARC";
1716 case EM_H8_300: return "Renesas H8/300";
1717 case EM_H8_300H: return "Renesas H8/300H";
1718 case EM_H8S: return "Renesas H8S";
1719 case EM_H8_500: return "Renesas H8/500";
1720 case EM_IA_64: return "Intel IA-64";
1721 case EM_MIPS_X: return "Stanford MIPS-X";
1722 case EM_COLDFIRE: return "Motorola Coldfire";
1723 case EM_68HC12: return "Motorola M68HC12";
1724 case EM_ALPHA: return "Alpha";
1725 case EM_CYGNUS_D10V:
1726 case EM_D10V: return "d10v";
1727 case EM_CYGNUS_D30V:
1728 case EM_D30V: return "d30v";
1729 case EM_CYGNUS_M32R:
1730 case EM_M32R: return "Renesas M32R (formerly Mitsubishi M32r)";
1731 case EM_CYGNUS_V850:
1732 case EM_V850: return "NEC v850";
1733 case EM_CYGNUS_MN10300:
1734 case EM_MN10300: return "mn10300";
1735 case EM_CYGNUS_MN10200:
1736 case EM_MN10200: return "mn10200";
1737 case EM_CYGNUS_FR30:
1738 case EM_FR30: return "Fujitsu FR30";
1739 case EM_CYGNUS_FRV: return "Fujitsu FR-V";
1741 case EM_PJ: return "picoJava";
1742 case EM_MMA: return "Fujitsu Multimedia Accelerator";
1743 case EM_PCP: return "Siemens PCP";
1744 case EM_NCPU: return "Sony nCPU embedded RISC processor";
1745 case EM_NDR1: return "Denso NDR1 microprocesspr";
1746 case EM_STARCORE: return "Motorola Star*Core processor";
1747 case EM_ME16: return "Toyota ME16 processor";
1748 case EM_ST100: return "STMicroelectronics ST100 processor";
1749 case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
1750 case EM_FX66: return "Siemens FX66 microcontroller";
1751 case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1752 case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
1753 case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
1754 case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
1755 case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
1756 case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
1757 case EM_SVX: return "Silicon Graphics SVx";
1758 case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
1759 case EM_VAX: return "Digital VAX";
1761 case EM_AVR: return "Atmel AVR 8-bit microcontroller";
1762 case EM_CRIS: return "Axis Communications 32-bit embedded processor";
1763 case EM_JAVELIN: return "Infineon Technologies 32-bit embedded cpu";
1764 case EM_FIREPATH: return "Element 14 64-bit DSP processor";
1765 case EM_ZSP: return "LSI Logic's 16-bit DSP processor";
1766 case EM_MMIX: return "Donald Knuth's educational 64-bit processor";
1767 case EM_HUANY: return "Harvard Universitys's machine-independent object format";
1768 case EM_PRISM: return "Vitesse Prism";
1769 case EM_X86_64: return "Advanced Micro Devices X86-64";
1771 case EM_S390: return "IBM S/390";
1772 case EM_SCORE: return "SUNPLUS S+Core";
1773 case EM_XSTORMY16: return "Sanyo Xstormy16 CPU core";
1775 case EM_OR32: return "OpenRISC";
1776 case EM_CRX: return "National Semiconductor CRX microprocessor";
1777 case EM_DLX: return "OpenDLX";
1779 case EM_IP2K: return "Ubicom IP2xxx 8-bit microcontrollers";
1780 case EM_IQ2000: return "Vitesse IQ2000";
1782 case EM_XTENSA: return "Tensilica Xtensa Processor";
1783 case EM_M32C: return "Renesas M32c";
1784 case EM_MT: return "Morpho Techologies MT processor";
1785 case EM_BLACKFIN: return "Analog Devices Blackfin";
1786 case EM_NIOS32: return "Altera Nios";
1787 case EM_ALTERA_NIOS2: return "Altera Nios II";
1788 case EM_XC16X: return "Infineon Technologies xc16x";
1789 case EM_CYGNUS_MEP: return "Toshiba MeP Media Engine";
1791 snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
1797 decode_ARM_machine_flags (unsigned e_flags, char buf[])
1802 eabi = EF_ARM_EABI_VERSION (e_flags);
1803 e_flags &= ~ EF_ARM_EABIMASK;
1805 /* Handle "generic" ARM flags. */
1806 if (e_flags & EF_ARM_RELEXEC)
1808 strcat (buf, ", relocatable executable");
1809 e_flags &= ~ EF_ARM_RELEXEC;
1812 if (e_flags & EF_ARM_HASENTRY)
1814 strcat (buf, ", has entry point");
1815 e_flags &= ~ EF_ARM_HASENTRY;
1818 /* Now handle EABI specific flags. */
1822 strcat (buf, ", <unrecognized EABI>");
1827 case EF_ARM_EABI_VER1:
1828 strcat (buf, ", Version1 EABI");
1833 /* Process flags one bit at a time. */
1834 flag = e_flags & - e_flags;
1839 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
1840 strcat (buf, ", sorted symbol tables");
1850 case EF_ARM_EABI_VER2:
1851 strcat (buf, ", Version2 EABI");
1856 /* Process flags one bit at a time. */
1857 flag = e_flags & - e_flags;
1862 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
1863 strcat (buf, ", sorted symbol tables");
1866 case EF_ARM_DYNSYMSUSESEGIDX:
1867 strcat (buf, ", dynamic symbols use segment index");
1870 case EF_ARM_MAPSYMSFIRST:
1871 strcat (buf, ", mapping symbols precede others");
1881 case EF_ARM_EABI_VER3:
1882 strcat (buf, ", Version3 EABI");
1885 case EF_ARM_EABI_VER4:
1886 strcat (buf, ", Version4 EABI");
1889 case EF_ARM_EABI_VER5:
1890 strcat (buf, ", Version5 EABI");
1896 /* Process flags one bit at a time. */
1897 flag = e_flags & - e_flags;
1903 strcat (buf, ", BE8");
1907 strcat (buf, ", LE8");
1917 case EF_ARM_EABI_UNKNOWN:
1918 strcat (buf, ", GNU EABI");
1923 /* Process flags one bit at a time. */
1924 flag = e_flags & - e_flags;
1929 case EF_ARM_INTERWORK:
1930 strcat (buf, ", interworking enabled");
1933 case EF_ARM_APCS_26:
1934 strcat (buf, ", uses APCS/26");
1937 case EF_ARM_APCS_FLOAT:
1938 strcat (buf, ", uses APCS/float");
1942 strcat (buf, ", position independent");
1946 strcat (buf, ", 8 bit structure alignment");
1949 case EF_ARM_NEW_ABI:
1950 strcat (buf, ", uses new ABI");
1953 case EF_ARM_OLD_ABI:
1954 strcat (buf, ", uses old ABI");
1957 case EF_ARM_SOFT_FLOAT:
1958 strcat (buf, ", software FP");
1961 case EF_ARM_VFP_FLOAT:
1962 strcat (buf, ", VFP");
1965 case EF_ARM_MAVERICK_FLOAT:
1966 strcat (buf, ", Maverick FP");
1977 strcat (buf,", <unknown>");
1981 get_machine_flags (unsigned e_flags, unsigned e_machine)
1983 static char buf[1024];
1995 decode_ARM_machine_flags (e_flags, buf);
1999 switch (e_flags & EF_FRV_CPU_MASK)
2001 case EF_FRV_CPU_GENERIC:
2005 strcat (buf, ", fr???");
2008 case EF_FRV_CPU_FR300:
2009 strcat (buf, ", fr300");
2012 case EF_FRV_CPU_FR400:
2013 strcat (buf, ", fr400");
2015 case EF_FRV_CPU_FR405:
2016 strcat (buf, ", fr405");
2019 case EF_FRV_CPU_FR450:
2020 strcat (buf, ", fr450");
2023 case EF_FRV_CPU_FR500:
2024 strcat (buf, ", fr500");
2026 case EF_FRV_CPU_FR550:
2027 strcat (buf, ", fr550");
2030 case EF_FRV_CPU_SIMPLE:
2031 strcat (buf, ", simple");
2033 case EF_FRV_CPU_TOMCAT:
2034 strcat (buf, ", tomcat");
2040 if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
2041 strcat (buf, ", m68000");
2042 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
2043 strcat (buf, ", cpu32");
2044 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
2045 strcat (buf, ", fido_a");
2048 char const *isa = _("unknown");
2049 char const *mac = _("unknown mac");
2050 char const *additional = NULL;
2052 switch (e_flags & EF_M68K_CF_ISA_MASK)
2054 case EF_M68K_CF_ISA_A_NODIV:
2056 additional = ", nodiv";
2058 case EF_M68K_CF_ISA_A:
2061 case EF_M68K_CF_ISA_A_PLUS:
2064 case EF_M68K_CF_ISA_B_NOUSP:
2066 additional = ", nousp";
2068 case EF_M68K_CF_ISA_B:
2072 strcat (buf, ", cf, isa ");
2075 strcat (buf, additional);
2076 if (e_flags & EF_M68K_CF_FLOAT)
2077 strcat (buf, ", float");
2078 switch (e_flags & EF_M68K_CF_MAC_MASK)
2083 case EF_M68K_CF_MAC:
2086 case EF_M68K_CF_EMAC:
2099 if (e_flags & EF_PPC_EMB)
2100 strcat (buf, ", emb");
2102 if (e_flags & EF_PPC_RELOCATABLE)
2103 strcat (buf, ", relocatable");
2105 if (e_flags & EF_PPC_RELOCATABLE_LIB)
2106 strcat (buf, ", relocatable-lib");
2110 case EM_CYGNUS_V850:
2111 switch (e_flags & EF_V850_ARCH)
2114 strcat (buf, ", v850e1");
2117 strcat (buf, ", v850e");
2120 strcat (buf, ", v850");
2123 strcat (buf, ", unknown v850 architecture variant");
2129 case EM_CYGNUS_M32R:
2130 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
2131 strcat (buf, ", m32r");
2135 case EM_MIPS_RS3_LE:
2136 if (e_flags & EF_MIPS_NOREORDER)
2137 strcat (buf, ", noreorder");
2139 if (e_flags & EF_MIPS_PIC)
2140 strcat (buf, ", pic");
2142 if (e_flags & EF_MIPS_CPIC)
2143 strcat (buf, ", cpic");
2145 if (e_flags & EF_MIPS_UCODE)
2146 strcat (buf, ", ugen_reserved");
2148 if (e_flags & EF_MIPS_ABI2)
2149 strcat (buf, ", abi2");
2151 if (e_flags & EF_MIPS_OPTIONS_FIRST)
2152 strcat (buf, ", odk first");
2154 if (e_flags & EF_MIPS_32BITMODE)
2155 strcat (buf, ", 32bitmode");
2157 switch ((e_flags & EF_MIPS_MACH))
2159 case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
2160 case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
2161 case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
2162 case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
2163 case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
2164 case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
2165 case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
2166 case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
2167 case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); break;
2168 case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
2170 /* We simply ignore the field in this case to avoid confusion:
2171 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2174 default: strcat (buf, ", unknown CPU"); break;
2177 switch ((e_flags & EF_MIPS_ABI))
2179 case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
2180 case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
2181 case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
2182 case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
2184 /* We simply ignore the field in this case to avoid confusion:
2185 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2186 This means it is likely to be an o32 file, but not for
2189 default: strcat (buf, ", unknown ABI"); break;
2192 if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
2193 strcat (buf, ", mdmx");
2195 if (e_flags & EF_MIPS_ARCH_ASE_M16)
2196 strcat (buf, ", mips16");
2198 switch ((e_flags & EF_MIPS_ARCH))
2200 case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
2201 case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
2202 case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
2203 case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
2204 case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
2205 case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
2206 case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
2207 case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
2208 case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
2209 default: strcat (buf, ", unknown ISA"); break;
2215 switch ((e_flags & EF_SH_MACH_MASK))
2217 case EF_SH1: strcat (buf, ", sh1"); break;
2218 case EF_SH2: strcat (buf, ", sh2"); break;
2219 case EF_SH3: strcat (buf, ", sh3"); break;
2220 case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
2221 case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
2222 case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
2223 case EF_SH3E: strcat (buf, ", sh3e"); break;
2224 case EF_SH4: strcat (buf, ", sh4"); break;
2225 case EF_SH5: strcat (buf, ", sh5"); break;
2226 case EF_SH2E: strcat (buf, ", sh2e"); break;
2227 case EF_SH4A: strcat (buf, ", sh4a"); break;
2228 case EF_SH2A: strcat (buf, ", sh2a"); break;
2229 case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
2230 case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
2231 case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
2232 case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
2233 case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
2234 case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
2235 case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
2236 case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
2237 case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
2238 default: strcat (buf, ", unknown ISA"); break;
2244 if (e_flags & EF_SPARC_32PLUS)
2245 strcat (buf, ", v8+");
2247 if (e_flags & EF_SPARC_SUN_US1)
2248 strcat (buf, ", ultrasparcI");
2250 if (e_flags & EF_SPARC_SUN_US3)
2251 strcat (buf, ", ultrasparcIII");
2253 if (e_flags & EF_SPARC_HAL_R1)
2254 strcat (buf, ", halr1");
2256 if (e_flags & EF_SPARC_LEDATA)
2257 strcat (buf, ", ledata");
2259 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
2260 strcat (buf, ", tso");
2262 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
2263 strcat (buf, ", pso");
2265 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
2266 strcat (buf, ", rmo");
2270 switch (e_flags & EF_PARISC_ARCH)
2272 case EFA_PARISC_1_0:
2273 strcpy (buf, ", PA-RISC 1.0");
2275 case EFA_PARISC_1_1:
2276 strcpy (buf, ", PA-RISC 1.1");
2278 case EFA_PARISC_2_0:
2279 strcpy (buf, ", PA-RISC 2.0");
2284 if (e_flags & EF_PARISC_TRAPNIL)
2285 strcat (buf, ", trapnil");
2286 if (e_flags & EF_PARISC_EXT)
2287 strcat (buf, ", ext");
2288 if (e_flags & EF_PARISC_LSB)
2289 strcat (buf, ", lsb");
2290 if (e_flags & EF_PARISC_WIDE)
2291 strcat (buf, ", wide");
2292 if (e_flags & EF_PARISC_NO_KABP)
2293 strcat (buf, ", no kabp");
2294 if (e_flags & EF_PARISC_LAZYSWAP)
2295 strcat (buf, ", lazyswap");
2300 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
2301 strcat (buf, ", new calling convention");
2303 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
2304 strcat (buf, ", gnu calling convention");
2308 if ((e_flags & EF_IA_64_ABI64))
2309 strcat (buf, ", 64-bit");
2311 strcat (buf, ", 32-bit");
2312 if ((e_flags & EF_IA_64_REDUCEDFP))
2313 strcat (buf, ", reduced fp model");
2314 if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
2315 strcat (buf, ", no function descriptors, constant gp");
2316 else if ((e_flags & EF_IA_64_CONS_GP))
2317 strcat (buf, ", constant gp");
2318 if ((e_flags & EF_IA_64_ABSOLUTE))
2319 strcat (buf, ", absolute");
2323 if ((e_flags & EF_VAX_NONPIC))
2324 strcat (buf, ", non-PIC");
2325 if ((e_flags & EF_VAX_DFLOAT))
2326 strcat (buf, ", D-Float");
2327 if ((e_flags & EF_VAX_GFLOAT))
2328 strcat (buf, ", G-Float");
2337 get_osabi_name (unsigned int osabi)
2339 static char buff[32];
2343 case ELFOSABI_NONE: return "UNIX - System V";
2344 case ELFOSABI_HPUX: return "UNIX - HP-UX";
2345 case ELFOSABI_NETBSD: return "UNIX - NetBSD";
2346 case ELFOSABI_LINUX: return "UNIX - Linux";
2347 case ELFOSABI_HURD: return "GNU/Hurd";
2348 case ELFOSABI_SOLARIS: return "UNIX - Solaris";
2349 case ELFOSABI_AIX: return "UNIX - AIX";
2350 case ELFOSABI_IRIX: return "UNIX - IRIX";
2351 case ELFOSABI_FREEBSD: return "UNIX - FreeBSD";
2352 case ELFOSABI_TRU64: return "UNIX - TRU64";
2353 case ELFOSABI_MODESTO: return "Novell - Modesto";
2354 case ELFOSABI_OPENBSD: return "UNIX - OpenBSD";
2355 case ELFOSABI_OPENVMS: return "VMS - OpenVMS";
2356 case ELFOSABI_NSK: return "HP - Non-Stop Kernel";
2357 case ELFOSABI_AROS: return "Amiga Research OS";
2358 case ELFOSABI_STANDALONE: return _("Standalone App");
2359 case ELFOSABI_ARM: return "ARM";
2361 snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
2367 get_arm_segment_type (unsigned long type)
2381 get_mips_segment_type (unsigned long type)
2385 case PT_MIPS_REGINFO:
2387 case PT_MIPS_RTPROC:
2389 case PT_MIPS_OPTIONS:
2399 get_parisc_segment_type (unsigned long type)
2403 case PT_HP_TLS: return "HP_TLS";
2404 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
2405 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
2406 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
2407 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
2408 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
2409 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
2410 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
2411 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
2412 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
2413 case PT_HP_PARALLEL: return "HP_PARALLEL";
2414 case PT_HP_FASTBIND: return "HP_FASTBIND";
2415 case PT_HP_OPT_ANNOT: return "HP_OPT_ANNOT";
2416 case PT_HP_HSL_ANNOT: return "HP_HSL_ANNOT";
2417 case PT_HP_STACK: return "HP_STACK";
2418 case PT_HP_CORE_UTSNAME: return "HP_CORE_UTSNAME";
2419 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
2420 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
2421 case PT_PARISC_WEAKORDER: return "PARISC_WEAKORDER";
2430 get_ia64_segment_type (unsigned long type)
2434 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
2435 case PT_IA_64_UNWIND: return "IA_64_UNWIND";
2436 case PT_HP_TLS: return "HP_TLS";
2437 case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
2438 case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
2439 case PT_IA_64_HP_STACK: return "HP_STACK";
2448 get_segment_type (unsigned long p_type)
2450 static char buff[32];
2454 case PT_NULL: return "NULL";
2455 case PT_LOAD: return "LOAD";
2456 case PT_DYNAMIC: return "DYNAMIC";
2457 case PT_INTERP: return "INTERP";
2458 case PT_NOTE: return "NOTE";
2459 case PT_SHLIB: return "SHLIB";
2460 case PT_PHDR: return "PHDR";
2461 case PT_TLS: return "TLS";
2463 case PT_GNU_EH_FRAME:
2464 return "GNU_EH_FRAME";
2465 case PT_GNU_STACK: return "GNU_STACK";
2466 case PT_GNU_RELRO: return "GNU_RELRO";
2469 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
2473 switch (elf_header.e_machine)
2476 result = get_arm_segment_type (p_type);
2479 case EM_MIPS_RS3_LE:
2480 result = get_mips_segment_type (p_type);
2483 result = get_parisc_segment_type (p_type);
2486 result = get_ia64_segment_type (p_type);
2496 sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
2498 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
2502 switch (elf_header.e_machine)
2505 result = get_parisc_segment_type (p_type);
2508 result = get_ia64_segment_type (p_type);
2518 sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
2521 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
2528 get_mips_section_type_name (unsigned int sh_type)
2532 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
2533 case SHT_MIPS_MSYM: return "MIPS_MSYM";
2534 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
2535 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
2536 case SHT_MIPS_UCODE: return "MIPS_UCODE";
2537 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
2538 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
2539 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
2540 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
2541 case SHT_MIPS_RELD: return "MIPS_RELD";
2542 case SHT_MIPS_IFACE: return "MIPS_IFACE";
2543 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
2544 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
2545 case SHT_MIPS_SHDR: return "MIPS_SHDR";
2546 case SHT_MIPS_FDESC: return "MIPS_FDESC";
2547 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
2548 case SHT_MIPS_DENSE: return "MIPS_DENSE";
2549 case SHT_MIPS_PDESC: return "MIPS_PDESC";
2550 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
2551 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
2552 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
2553 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
2554 case SHT_MIPS_LINE: return "MIPS_LINE";
2555 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
2556 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
2557 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
2558 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
2559 case SHT_MIPS_DWARF: return "MIPS_DWARF";
2560 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
2561 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
2562 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
2563 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
2564 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
2565 case SHT_MIPS_XLATE: return "MIPS_XLATE";
2566 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
2567 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
2568 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
2569 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
2570 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
2578 get_parisc_section_type_name (unsigned int sh_type)
2582 case SHT_PARISC_EXT: return "PARISC_EXT";
2583 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
2584 case SHT_PARISC_DOC: return "PARISC_DOC";
2585 case SHT_PARISC_ANNOT: return "PARISC_ANNOT";
2586 case SHT_PARISC_SYMEXTN: return "PARISC_SYMEXTN";
2587 case SHT_PARISC_STUBS: return "PARISC_STUBS";
2588 case SHT_PARISC_DLKM: return "PARISC_DLKM";
2596 get_ia64_section_type_name (unsigned int sh_type)
2598 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
2599 if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
2600 return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
2604 case SHT_IA_64_EXT: return "IA_64_EXT";
2605 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
2606 case SHT_IA_64_PRIORITY_INIT: return "IA_64_PRIORITY_INIT";
2614 get_x86_64_section_type_name (unsigned int sh_type)
2618 case SHT_X86_64_UNWIND: return "X86_64_UNWIND";
2626 get_arm_section_type_name (unsigned int sh_type)
2632 case SHT_ARM_PREEMPTMAP:
2633 return "ARM_PREEMPTMAP";
2634 case SHT_ARM_ATTRIBUTES:
2635 return "ARM_ATTRIBUTES";
2643 get_section_type_name (unsigned int sh_type)
2645 static char buff[32];
2649 case SHT_NULL: return "NULL";
2650 case SHT_PROGBITS: return "PROGBITS";
2651 case SHT_SYMTAB: return "SYMTAB";
2652 case SHT_STRTAB: return "STRTAB";
2653 case SHT_RELA: return "RELA";
2654 case SHT_HASH: return "HASH";
2655 case SHT_DYNAMIC: return "DYNAMIC";
2656 case SHT_NOTE: return "NOTE";
2657 case SHT_NOBITS: return "NOBITS";
2658 case SHT_REL: return "REL";
2659 case SHT_SHLIB: return "SHLIB";
2660 case SHT_DYNSYM: return "DYNSYM";
2661 case SHT_INIT_ARRAY: return "INIT_ARRAY";
2662 case SHT_FINI_ARRAY: return "FINI_ARRAY";
2663 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
2664 case SHT_GNU_HASH: return "GNU_HASH";
2665 case SHT_GROUP: return "GROUP";
2666 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICIES";
2667 case SHT_GNU_verdef: return "VERDEF";
2668 case SHT_GNU_verneed: return "VERNEED";
2669 case SHT_GNU_versym: return "VERSYM";
2670 case 0x6ffffff0: return "VERSYM";
2671 case 0x6ffffffc: return "VERDEF";
2672 case 0x7ffffffd: return "AUXILIARY";
2673 case 0x7fffffff: return "FILTER";
2674 case SHT_GNU_LIBLIST: return "GNU_LIBLIST";
2677 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
2681 switch (elf_header.e_machine)
2684 case EM_MIPS_RS3_LE:
2685 result = get_mips_section_type_name (sh_type);
2688 result = get_parisc_section_type_name (sh_type);
2691 result = get_ia64_section_type_name (sh_type);
2694 result = get_x86_64_section_type_name (sh_type);
2697 result = get_arm_section_type_name (sh_type);
2707 sprintf (buff, "LOPROC+%x", sh_type - SHT_LOPROC);
2709 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
2710 sprintf (buff, "LOOS+%x", sh_type - SHT_LOOS);
2711 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
2712 sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER);
2714 snprintf (buff, sizeof (buff), _("<unknown>: %x"), sh_type);
2720 #define OPTION_DEBUG_DUMP 512
2722 static struct option options[] =
2724 {"all", no_argument, 0, 'a'},
2725 {"file-header", no_argument, 0, 'h'},
2726 {"program-headers", no_argument, 0, 'l'},
2727 {"headers", no_argument, 0, 'e'},
2728 {"histogram", no_argument, 0, 'I'},
2729 {"segments", no_argument, 0, 'l'},
2730 {"sections", no_argument, 0, 'S'},
2731 {"section-headers", no_argument, 0, 'S'},
2732 {"section-groups", no_argument, 0, 'g'},
2733 {"section-details", no_argument, 0, 't'},
2734 {"full-section-name",no_argument, 0, 'N'},
2735 {"symbols", no_argument, 0, 's'},
2736 {"syms", no_argument, 0, 's'},
2737 {"relocs", no_argument, 0, 'r'},
2738 {"notes", no_argument, 0, 'n'},
2739 {"dynamic", no_argument, 0, 'd'},
2740 {"arch-specific", no_argument, 0, 'A'},
2741 {"version-info", no_argument, 0, 'V'},
2742 {"use-dynamic", no_argument, 0, 'D'},
2743 {"hex-dump", required_argument, 0, 'x'},
2744 {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
2745 {"unwind", no_argument, 0, 'u'},
2746 #ifdef SUPPORT_DISASSEMBLY
2747 {"instruction-dump", required_argument, 0, 'i'},
2750 {"version", no_argument, 0, 'v'},
2751 {"wide", no_argument, 0, 'W'},
2752 {"help", no_argument, 0, 'H'},
2753 {0, no_argument, 0, 0}
2757 usage (FILE *stream)
2759 fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
2760 fprintf (stream, _(" Display information about the contents of ELF format files\n"));
2761 fprintf (stream, _(" Options are:\n\
2762 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
2763 -h --file-header Display the ELF file header\n\
2764 -l --program-headers Display the program headers\n\
2765 --segments An alias for --program-headers\n\
2766 -S --section-headers Display the sections' header\n\
2767 --sections An alias for --section-headers\n\
2768 -g --section-groups Display the section groups\n\
2769 -t --section-details Display the section details\n\
2770 -e --headers Equivalent to: -h -l -S\n\
2771 -s --syms Display the symbol table\n\
2772 --symbols An alias for --syms\n\
2773 -n --notes Display the core notes (if present)\n\
2774 -r --relocs Display the relocations (if present)\n\
2775 -u --unwind Display the unwind info (if present)\n\
2776 -d --dynamic Display the dynamic section (if present)\n\
2777 -V --version-info Display the version sections (if present)\n\
2778 -A --arch-specific Display architecture specific information (if any).\n\
2779 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
2780 -x --hex-dump=<number> Dump the contents of section <number>\n\
2781 -w[liaprmfFsoR] or\n\
2782 --debug-dump[=line,=info,=abbrev,=pubnames,=aranges,=macro,=frames,=str,=loc,=Ranges]\n\
2783 Display the contents of DWARF2 debug sections\n"));
2784 #ifdef SUPPORT_DISASSEMBLY
2785 fprintf (stream, _("\
2786 -i --instruction-dump=<number>\n\
2787 Disassemble the contents of section <number>\n"));
2789 fprintf (stream, _("\
2790 -I --histogram Display histogram of bucket list lengths\n\
2791 -W --wide Allow output width to exceed 80 characters\n\
2792 @<file> Read options from <file>\n\
2793 -H --help Display this information\n\
2794 -v --version Display the version number of readelf\n"));
2796 if (REPORT_BUGS_TO[0] && stream == stdout)
2797 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
2799 exit (stream == stdout ? 0 : 1);
2802 /* Record the fact that the user wants the contents of section number
2803 SECTION to be displayed using the method(s) encoded as flags bits
2804 in TYPE. Note, TYPE can be zero if we are creating the array for
2808 request_dump (unsigned int section, int type)
2810 if (section >= num_dump_sects)
2812 char *new_dump_sects;
2814 new_dump_sects = calloc (section + 1, 1);
2816 if (new_dump_sects == NULL)
2817 error (_("Out of memory allocating dump request table.\n"));
2820 /* Copy current flag settings. */
2821 memcpy (new_dump_sects, dump_sects, num_dump_sects);
2825 dump_sects = new_dump_sects;
2826 num_dump_sects = section + 1;
2831 dump_sects[section] |= type;
2836 /* Request a dump by section name. */
2839 request_dump_byname (const char *section, int type)
2841 struct dump_list_entry *new_request;
2843 new_request = malloc (sizeof (struct dump_list_entry));
2845 error (_("Out of memory allocating dump request table.\n"));
2847 new_request->name = strdup (section);
2848 if (!new_request->name)
2849 error (_("Out of memory allocating dump request table.\n"));
2851 new_request->type = type;
2853 new_request->next = dump_sects_byname;
2854 dump_sects_byname = new_request;
2858 parse_args (int argc, char **argv)
2865 while ((c = getopt_long
2866 (argc, argv, "ersuahnldSDAINtgw::x:i:vVWH", options, NULL)) != EOF)
2887 do_section_groups++;
2895 do_section_groups++;
2900 do_section_details++;
2942 section = strtoul (optarg, & cp, 0);
2943 if (! *cp && section >= 0)
2944 request_dump (section, HEX_DUMP);
2946 request_dump_byname (optarg, HEX_DUMP);
2954 unsigned int index = 0;
2958 while (optarg[index])
2959 switch (optarg[index++])
2968 do_debug_abbrevs = 1;
2978 do_debug_pubnames = 1;
2982 do_debug_aranges = 1;
2986 do_debug_ranges = 1;
2990 do_debug_frames_interp = 1;
2992 do_debug_frames = 1;
2997 do_debug_macinfo = 1;
3011 warn (_("Unrecognized debug option '%s'\n"), optarg);
3016 case OPTION_DEBUG_DUMP:
3024 const char * option;
3027 debug_dump_long_opts;
3029 debug_dump_long_opts opts_table [] =
3031 /* Please keep this table alpha- sorted. */
3032 { "Ranges", & do_debug_ranges },
3033 { "abbrev", & do_debug_abbrevs },
3034 { "aranges", & do_debug_aranges },
3035 { "frames", & do_debug_frames },
3036 { "frames-interp", & do_debug_frames_interp },
3037 { "info", & do_debug_info },
3038 { "line", & do_debug_lines },
3039 { "loc", & do_debug_loc },
3040 { "macro", & do_debug_macinfo },
3041 { "pubnames", & do_debug_pubnames },
3042 /* This entry is for compatability
3043 with earlier versions of readelf. */
3044 { "ranges", & do_debug_aranges },
3045 { "str", & do_debug_str },
3056 debug_dump_long_opts * entry;
3058 for (entry = opts_table; entry->option; entry++)
3060 size_t len = strlen (entry->option);
3062 if (strneq (p, entry->option, len)
3063 && (p[len] == ',' || p[len] == '\0'))
3065 * entry->variable = 1;
3067 /* The --debug-dump=frames-interp option also
3068 enables the --debug-dump=frames option. */
3069 if (do_debug_frames_interp)
3070 do_debug_frames = 1;
3077 if (entry->option == NULL)
3079 warn (_("Unrecognized debug option '%s'\n"), p);
3080 p = strchr (p, ',');
3090 #ifdef SUPPORT_DISASSEMBLY
3093 section = strtoul (optarg, & cp, 0);
3094 if (! *cp && section >= 0)
3096 request_dump (section, DISASS_DUMP);
3102 print_version (program_name);
3111 #ifdef SUPPORT_DISASSEMBLY
3114 /* xgettext:c-format */
3115 error (_("Invalid option '-%c'\n"), c);
3122 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
3123 && !do_segments && !do_header && !do_dump && !do_version
3124 && !do_histogram && !do_debugging && !do_arch && !do_notes
3125 && !do_section_groups)
3129 warn (_("Nothing to do.\n"));
3135 get_elf_class (unsigned int elf_class)
3137 static char buff[32];
3141 case ELFCLASSNONE: return _("none");
3142 case ELFCLASS32: return "ELF32";
3143 case ELFCLASS64: return "ELF64";
3145 snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
3151 get_data_encoding (unsigned int encoding)
3153 static char buff[32];
3157 case ELFDATANONE: return _("none");
3158 case ELFDATA2LSB: return _("2's complement, little endian");
3159 case ELFDATA2MSB: return _("2's complement, big endian");
3161 snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
3166 /* Decode the data held in 'elf_header'. */
3169 process_file_header (void)
3171 if ( elf_header.e_ident[EI_MAG0] != ELFMAG0
3172 || elf_header.e_ident[EI_MAG1] != ELFMAG1
3173 || elf_header.e_ident[EI_MAG2] != ELFMAG2
3174 || elf_header.e_ident[EI_MAG3] != ELFMAG3)
3177 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3185 printf (_("ELF Header:\n"));
3186 printf (_(" Magic: "));
3187 for (i = 0; i < EI_NIDENT; i++)
3188 printf ("%2.2x ", elf_header.e_ident[i]);
3190 printf (_(" Class: %s\n"),
3191 get_elf_class (elf_header.e_ident[EI_CLASS]));
3192 printf (_(" Data: %s\n"),
3193 get_data_encoding (elf_header.e_ident[EI_DATA]));
3194 printf (_(" Version: %d %s\n"),
3195 elf_header.e_ident[EI_VERSION],
3196 (elf_header.e_ident[EI_VERSION] == EV_CURRENT
3198 : (elf_header.e_ident[EI_VERSION] != EV_NONE
3201 printf (_(" OS/ABI: %s\n"),
3202 get_osabi_name (elf_header.e_ident[EI_OSABI]));
3203 printf (_(" ABI Version: %d\n"),
3204 elf_header.e_ident[EI_ABIVERSION]);
3205 printf (_(" Type: %s\n"),
3206 get_file_type (elf_header.e_type));
3207 printf (_(" Machine: %s\n"),
3208 get_machine_name (elf_header.e_machine));
3209 printf (_(" Version: 0x%lx\n"),
3210 (unsigned long) elf_header.e_version);
3212 printf (_(" Entry point address: "));
3213 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
3214 printf (_("\n Start of program headers: "));
3215 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
3216 printf (_(" (bytes into file)\n Start of section headers: "));
3217 print_vma ((bfd_vma) elf_header.e_shoff, DEC);
3218 printf (_(" (bytes into file)\n"));
3220 printf (_(" Flags: 0x%lx%s\n"),
3221 (unsigned long) elf_header.e_flags,
3222 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
3223 printf (_(" Size of this header: %ld (bytes)\n"),
3224 (long) elf_header.e_ehsize);
3225 printf (_(" Size of program headers: %ld (bytes)\n"),
3226 (long) elf_header.e_phentsize);
3227 printf (_(" Number of program headers: %ld\n"),
3228 (long) elf_header.e_phnum);
3229 printf (_(" Size of section headers: %ld (bytes)\n"),
3230 (long) elf_header.e_shentsize);
3231 printf (_(" Number of section headers: %ld"),
3232 (long) elf_header.e_shnum);
3233 if (section_headers != NULL && elf_header.e_shnum == 0)
3234 printf (" (%ld)", (long) section_headers[0].sh_size);
3235 putc ('\n', stdout);
3236 printf (_(" Section header string table index: %ld"),
3237 (long) elf_header.e_shstrndx);
3238 if (section_headers != NULL && elf_header.e_shstrndx == SHN_XINDEX)
3239 printf (" (%ld)", (long) section_headers[0].sh_link);
3240 else if (elf_header.e_shstrndx != SHN_UNDEF
3241 && (elf_header.e_shstrndx >= elf_header.e_shnum
3242 || (elf_header.e_shstrndx >= SHN_LORESERVE
3243 && elf_header.e_shstrndx <= SHN_HIRESERVE)))
3244 printf (" <corrupt: out of range>");
3245 putc ('\n', stdout);
3248 if (section_headers != NULL)
3250 if (elf_header.e_shnum == 0)
3251 elf_header.e_shnum = section_headers[0].sh_size;
3252 if (elf_header.e_shstrndx == SHN_XINDEX)
3253 elf_header.e_shstrndx = section_headers[0].sh_link;
3254 else if (elf_header.e_shstrndx != SHN_UNDEF
3255 && (elf_header.e_shstrndx >= elf_header.e_shnum
3256 || (elf_header.e_shstrndx >= SHN_LORESERVE
3257 && elf_header.e_shstrndx <= SHN_HIRESERVE)))
3258 elf_header.e_shstrndx = SHN_UNDEF;
3259 free (section_headers);
3260 section_headers = NULL;
3268 get_32bit_program_headers (FILE *file, Elf_Internal_Phdr *program_headers)
3270 Elf32_External_Phdr *phdrs;
3271 Elf32_External_Phdr *external;
3272 Elf_Internal_Phdr *internal;
3275 phdrs = get_data (NULL, file, elf_header.e_phoff,
3276 elf_header.e_phentsize, elf_header.e_phnum,
3277 _("program headers"));
3281 for (i = 0, internal = program_headers, external = phdrs;
3282 i < elf_header.e_phnum;
3283 i++, internal++, external++)
3285 internal->p_type = BYTE_GET (external->p_type);
3286 internal->p_offset = BYTE_GET (external->p_offset);
3287 internal->p_vaddr = BYTE_GET (external->p_vaddr);
3288 internal->p_paddr = BYTE_GET (external->p_paddr);
3289 internal->p_filesz = BYTE_GET (external->p_filesz);
3290 internal->p_memsz = BYTE_GET (external->p_memsz);
3291 internal->p_flags = BYTE_GET (external->p_flags);
3292 internal->p_align = BYTE_GET (external->p_align);
3301 get_64bit_program_headers (FILE *file, Elf_Internal_Phdr *program_headers)
3303 Elf64_External_Phdr *phdrs;
3304 Elf64_External_Phdr *external;
3305 Elf_Internal_Phdr *internal;
3308 phdrs = get_data (NULL, file, elf_header.e_phoff,
3309 elf_header.e_phentsize, elf_header.e_phnum,
3310 _("program headers"));
3314 for (i = 0, internal = program_headers, external = phdrs;
3315 i < elf_header.e_phnum;
3316 i++, internal++, external++)
3318 internal->p_type = BYTE_GET (external->p_type);
3319 internal->p_flags = BYTE_GET (external->p_flags);
3320 internal->p_offset = BYTE_GET (external->p_offset);
3321 internal->p_vaddr = BYTE_GET (external->p_vaddr);
3322 internal->p_paddr = BYTE_GET (external->p_paddr);
3323 internal->p_filesz = BYTE_GET (external->p_filesz);
3324 internal->p_memsz = BYTE_GET (external->p_memsz);
3325 internal->p_align = BYTE_GET (external->p_align);
3333 /* Returns 1 if the program headers were read into `program_headers'. */
3336 get_program_headers (FILE *file)
3338 Elf_Internal_Phdr *phdrs;
3340 /* Check cache of prior read. */
3341 if (program_headers != NULL)
3344 phdrs = cmalloc (elf_header.e_phnum, sizeof (Elf_Internal_Phdr));
3348 error (_("Out of memory\n"));
3353 ? get_32bit_program_headers (file, phdrs)
3354 : get_64bit_program_headers (file, phdrs))
3356 program_headers = phdrs;
3364 /* Returns 1 if the program headers were loaded. */
3367 process_program_headers (FILE *file)
3369 Elf_Internal_Phdr *segment;
3372 if (elf_header.e_phnum == 0)
3375 printf (_("\nThere are no program headers in this file.\n"));
3379 if (do_segments && !do_header)
3381 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
3382 printf (_("Entry point "));
3383 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
3384 printf (_("\nThere are %d program headers, starting at offset "),
3385 elf_header.e_phnum);
3386 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
3390 if (! get_program_headers (file))
3395 if (elf_header.e_phnum > 1)
3396 printf (_("\nProgram Headers:\n"));
3398 printf (_("\nProgram Headers:\n"));
3402 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3405 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3409 (_(" Type Offset VirtAddr PhysAddr\n"));
3411 (_(" FileSiz MemSiz Flags Align\n"));
3418 for (i = 0, segment = program_headers;
3419 i < elf_header.e_phnum;
3424 printf (" %-14.14s ", get_segment_type (segment->p_type));
3428 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
3429 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
3430 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
3431 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
3432 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
3434 (segment->p_flags & PF_R ? 'R' : ' '),
3435 (segment->p_flags & PF_W ? 'W' : ' '),
3436 (segment->p_flags & PF_X ? 'E' : ' '));
3437 printf ("%#lx", (unsigned long) segment->p_align);
3441 if ((unsigned long) segment->p_offset == segment->p_offset)
3442 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
3445 print_vma (segment->p_offset, FULL_HEX);
3449 print_vma (segment->p_vaddr, FULL_HEX);
3451 print_vma (segment->p_paddr, FULL_HEX);
3454 if ((unsigned long) segment->p_filesz == segment->p_filesz)
3455 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
3458 print_vma (segment->p_filesz, FULL_HEX);
3462 if ((unsigned long) segment->p_memsz == segment->p_memsz)
3463 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
3466 print_vma (segment->p_offset, FULL_HEX);
3470 (segment->p_flags & PF_R ? 'R' : ' '),
3471 (segment->p_flags & PF_W ? 'W' : ' '),
3472 (segment->p_flags & PF_X ? 'E' : ' '));
3474 if ((unsigned long) segment->p_align == segment->p_align)
3475 printf ("%#lx", (unsigned long) segment->p_align);
3478 print_vma (segment->p_align, PREFIX_HEX);
3483 print_vma (segment->p_offset, FULL_HEX);
3485 print_vma (segment->p_vaddr, FULL_HEX);
3487 print_vma (segment->p_paddr, FULL_HEX);
3489 print_vma (segment->p_filesz, FULL_HEX);
3491 print_vma (segment->p_memsz, FULL_HEX);
3493 (segment->p_flags & PF_R ? 'R' : ' '),
3494 (segment->p_flags & PF_W ? 'W' : ' '),
3495 (segment->p_flags & PF_X ? 'E' : ' '));
3496 print_vma (segment->p_align, HEX);
3500 switch (segment->p_type)
3504 error (_("more than one dynamic segment\n"));
3506 /* Try to locate the .dynamic section. If there is
3507 a section header table, we can easily locate it. */
3508 if (section_headers != NULL)
3510 Elf_Internal_Shdr *sec;
3512 sec = find_section (".dynamic");
3513 if (sec == NULL || sec->sh_size == 0)
3515 error (_("no .dynamic section in the dynamic segment\n"));
3519 if (sec->sh_type == SHT_NOBITS)
3522 dynamic_addr = sec->sh_offset;
3523 dynamic_size = sec->sh_size;
3525 if (dynamic_addr < segment->p_offset
3526 || dynamic_addr > segment->p_offset + segment->p_filesz)
3527 warn (_("the .dynamic section is not contained within the dynamic segment\n"));
3528 else if (dynamic_addr > segment->p_offset)
3529 warn (_("the .dynamic section is not the first section in the dynamic segment.\n"));
3533 /* Otherwise, we can only assume that the .dynamic
3534 section is the first section in the DYNAMIC segment. */
3535 dynamic_addr = segment->p_offset;
3536 dynamic_size = segment->p_filesz;
3541 if (fseek (file, archive_file_offset + (long) segment->p_offset,
3543 error (_("Unable to find program interpreter name\n"));
3547 int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX);
3549 if (ret >= (int) sizeof (fmt) || ret < 0)
3550 error (_("Internal error: failed to create format string to display program interpreter\n"));
3552 program_interpreter[0] = 0;
3553 if (fscanf (file, fmt, program_interpreter) <= 0)
3554 error (_("Unable to read program interpreter name\n"));
3557 printf (_("\n [Requesting program interpreter: %s]"),
3558 program_interpreter);
3564 putc ('\n', stdout);
3567 if (do_segments && section_headers != NULL && string_table != NULL)
3569 printf (_("\n Section to Segment mapping:\n"));
3570 printf (_(" Segment Sections...\n"));
3572 for (i = 0; i < elf_header.e_phnum; i++)
3575 Elf_Internal_Shdr *section;
3577 segment = program_headers + i;
3578 section = section_headers;
3580 printf (" %2.2d ", i);
3582 for (j = 1; j < elf_header.e_shnum; j++, section++)
3584 if (ELF_IS_SECTION_IN_SEGMENT_MEMORY(section, segment))
3585 printf ("%s ", SECTION_NAME (section));
3596 /* Find the file offset corresponding to VMA by using the program headers. */
3599 offset_from_vma (FILE *file, bfd_vma vma, bfd_size_type size)
3601 Elf_Internal_Phdr *seg;
3603 if (! get_program_headers (file))
3605 warn (_("Cannot interpret virtual addresses without program headers.\n"));
3609 for (seg = program_headers;
3610 seg < program_headers + elf_header.e_phnum;
3613 if (seg->p_type != PT_LOAD)
3616 if (vma >= (seg->p_vaddr & -seg->p_align)
3617 && vma + size <= seg->p_vaddr + seg->p_filesz)
3618 return vma - seg->p_vaddr + seg->p_offset;
3621 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
3628 get_32bit_section_headers (FILE *file, unsigned int num)
3630 Elf32_External_Shdr *shdrs;
3631 Elf_Internal_Shdr *internal;
3634 shdrs = get_data (NULL, file, elf_header.e_shoff,
3635 elf_header.e_shentsize, num, _("section headers"));
3639 section_headers = cmalloc (num, sizeof (Elf_Internal_Shdr));
3641 if (section_headers == NULL)
3643 error (_("Out of memory\n"));
3647 for (i = 0, internal = section_headers;
3651 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
3652 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
3653 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
3654 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
3655 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
3656 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
3657 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
3658 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
3659 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
3660 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
3669 get_64bit_section_headers (FILE *file, unsigned int num)
3671 Elf64_External_Shdr *shdrs;
3672 Elf_Internal_Shdr *internal;
3675 shdrs = get_data (NULL, file, elf_header.e_shoff,
3676 elf_header.e_shentsize, num, _("section headers"));
3680 section_headers = cmalloc (num, sizeof (Elf_Internal_Shdr));
3682 if (section_headers == NULL)
3684 error (_("Out of memory\n"));
3688 for (i = 0, internal = section_headers;
3692 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
3693 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
3694 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
3695 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
3696 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
3697 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
3698 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
3699 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
3700 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
3701 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
3709 static Elf_Internal_Sym *
3710 get_32bit_elf_symbols (FILE *file, Elf_Internal_Shdr *section)
3712 unsigned long number;
3713 Elf32_External_Sym *esyms;
3714 Elf_External_Sym_Shndx *shndx;
3715 Elf_Internal_Sym *isyms;
3716 Elf_Internal_Sym *psym;
3719 esyms = get_data (NULL, file, section->sh_offset, 1, section->sh_size,
3725 if (symtab_shndx_hdr != NULL
3726 && (symtab_shndx_hdr->sh_link
3727 == (unsigned long) SECTION_HEADER_NUM (section - section_headers)))
3729 shndx = get_data (NULL, file, symtab_shndx_hdr->sh_offset,
3730 1, symtab_shndx_hdr->sh_size, _("symtab shndx"));
3738 number = section->sh_size / section->sh_entsize;
3739 isyms = cmalloc (number, sizeof (Elf_Internal_Sym));
3743 error (_("Out of memory\n"));
3750 for (j = 0, psym = isyms;
3754 psym->st_name = BYTE_GET (esyms[j].st_name);
3755 psym->st_value = BYTE_GET (esyms[j].st_value);
3756 psym->st_size = BYTE_GET (esyms[j].st_size);
3757 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
3758 if (psym->st_shndx == SHN_XINDEX && shndx != NULL)
3760 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
3761 psym->st_info = BYTE_GET (esyms[j].st_info);
3762 psym->st_other = BYTE_GET (esyms[j].st_other);
3772 static Elf_Internal_Sym *
3773 get_64bit_elf_symbols (FILE *file, Elf_Internal_Shdr *section)
3775 unsigned long number;
3776 Elf64_External_Sym *esyms;
3777 Elf_External_Sym_Shndx *shndx;
3778 Elf_Internal_Sym *isyms;
3779 Elf_Internal_Sym *psym;
3782 esyms = get_data (NULL, file, section->sh_offset, 1, section->sh_size,
3788 if (symtab_shndx_hdr != NULL
3789 && (symtab_shndx_hdr->sh_link
3790 == (unsigned long) SECTION_HEADER_NUM (section - section_headers)))
3792 shndx = get_data (NULL, file, symtab_shndx_hdr->sh_offset,
3793 1, symtab_shndx_hdr->sh_size, _("symtab shndx"));
3801 number = section->sh_size / section->sh_entsize;
3802 isyms = cmalloc (number, sizeof (Elf_Internal_Sym));
3806 error (_("Out of memory\n"));
3813 for (j = 0, psym = isyms;
3817 psym->st_name = BYTE_GET (esyms[j].st_name);
3818 psym->st_info = BYTE_GET (esyms[j].st_info);
3819 psym->st_other = BYTE_GET (esyms[j].st_other);
3820 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
3821 if (psym->st_shndx == SHN_XINDEX && shndx != NULL)
3823 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
3824 psym->st_value = BYTE_GET (esyms[j].st_value);
3825 psym->st_size = BYTE_GET (esyms[j].st_size);
3836 get_elf_section_flags (bfd_vma sh_flags)
3838 static char buff[1024];
3840 int field_size = is_32bit_elf ? 8 : 16;
3841 int index, size = sizeof (buff) - (field_size + 4 + 1);
3842 bfd_vma os_flags = 0;
3843 bfd_vma proc_flags = 0;
3844 bfd_vma unknown_flags = 0;
3858 { "LINK ORDER", 10 },
3859 { "OS NONCONF", 10 },
3864 if (do_section_details)
3866 sprintf (buff, "[%*.*lx]: ",
3867 field_size, field_size, (unsigned long) sh_flags);
3868 p += field_size + 4;
3875 flag = sh_flags & - sh_flags;
3878 if (do_section_details)
3882 case SHF_WRITE: index = 0; break;
3883 case SHF_ALLOC: index = 1; break;
3884 case SHF_EXECINSTR: index = 2; break;
3885 case SHF_MERGE: index = 3; break;
3886 case SHF_STRINGS: index = 4; break;
3887 case SHF_INFO_LINK: index = 5; break;
3888 case SHF_LINK_ORDER: index = 6; break;
3889 case SHF_OS_NONCONFORMING: index = 7; break;
3890 case SHF_GROUP: index = 8; break;
3891 case SHF_TLS: index = 9; break;
3900 if (p != buff + field_size + 4)
3902 if (size < (10 + 2))
3909 size -= flags [index].len;
3910 p = stpcpy (p, flags [index].str);
3912 else if (flag & SHF_MASKOS)
3914 else if (flag & SHF_MASKPROC)
3917 unknown_flags |= flag;
3923 case SHF_WRITE: *p = 'W'; break;
3924 case SHF_ALLOC: *p = 'A'; break;
3925 case SHF_EXECINSTR: *p = 'X'; break;
3926 case SHF_MERGE: *p = 'M'; break;
3927 case SHF_STRINGS: *p = 'S'; break;
3928 case SHF_INFO_LINK: *p = 'I'; break;
3929 case SHF_LINK_ORDER: *p = 'L'; break;
3930 case SHF_OS_NONCONFORMING: *p = 'O'; break;
3931 case SHF_GROUP: *p = 'G'; break;
3932 case SHF_TLS: *p = 'T'; break;
3935 if (elf_header.e_machine == EM_X86_64
3936 && flag == SHF_X86_64_LARGE)
3938 else if (flag & SHF_MASKOS)
3941 sh_flags &= ~ SHF_MASKOS;
3943 else if (flag & SHF_MASKPROC)
3946 sh_flags &= ~ SHF_MASKPROC;
3956 if (do_section_details)
3960 size -= 5 + field_size;
3961 if (p != buff + field_size + 4)
3969 sprintf (p, "OS (%*.*lx)", field_size, field_size,
3970 (unsigned long) os_flags);
3971 p += 5 + field_size;
3975 size -= 7 + field_size;
3976 if (p != buff + field_size + 4)
3984 sprintf (p, "PROC (%*.*lx)", field_size, field_size,
3985 (unsigned long) proc_flags);
3986 p += 7 + field_size;
3990 size -= 10 + field_size;
3991 if (p != buff + field_size + 4)
3999 sprintf (p, "UNKNOWN (%*.*lx)", field_size, field_size,
4000 (unsigned long) unknown_flags);
4001 p += 10 + field_size;
4010 process_section_headers (FILE *file)
4012 Elf_Internal_Shdr *section;
4015 section_headers = NULL;
4017 if (elf_header.e_shnum == 0)
4020 printf (_("\nThere are no sections in this file.\n"));
4025 if (do_sections && !do_header)
4026 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
4027 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
4031 if (! get_32bit_section_headers (file, elf_header.e_shnum))
4034 else if (! get_64bit_section_headers (file, elf_header.e_shnum))
4037 /* Read in the string table, so that we have names to display. */
4038 if (elf_header.e_shstrndx != SHN_UNDEF
4039 && SECTION_HEADER_INDEX (elf_header.e_shstrndx) < elf_header.e_shnum)
4041 section = SECTION_HEADER (elf_header.e_shstrndx);
4043 if (section->sh_size != 0)
4045 string_table = get_data (NULL, file, section->sh_offset,
4046 1, section->sh_size, _("string table"));
4048 string_table_length = string_table != NULL ? section->sh_size : 0;
4052 /* Scan the sections for the dynamic symbol table
4053 and dynamic string table and debug sections. */
4054 dynamic_symbols = NULL;
4055 dynamic_strings = NULL;
4056 dynamic_syminfo = NULL;
4057 symtab_shndx_hdr = NULL;
4059 eh_addr_size = is_32bit_elf ? 4 : 8;
4060 switch (elf_header.e_machine)
4063 case EM_MIPS_RS3_LE:
4064 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
4065 FDE addresses. However, the ABI also has a semi-official ILP32
4066 variant for which the normal FDE address size rules apply.
4068 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
4069 section, where XX is the size of longs in bits. Unfortunately,
4070 earlier compilers provided no way of distinguishing ILP32 objects
4071 from LP64 objects, so if there's any doubt, we should assume that
4072 the official LP64 form is being used. */
4073 if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
4074 && find_section (".gcc_compiled_long32") == NULL)
4080 switch (elf_header.e_flags & EF_H8_MACH)
4082 case E_H8_MACH_H8300:
4083 case E_H8_MACH_H8300HN:
4084 case E_H8_MACH_H8300SN:
4085 case E_H8_MACH_H8300SXN:
4088 case E_H8_MACH_H8300H:
4089 case E_H8_MACH_H8300S:
4090 case E_H8_MACH_H8300SX:
4096 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
4099 size_t expected_entsize \
4100 = is_32bit_elf ? size32 : size64; \
4101 if (section->sh_entsize != expected_entsize) \
4102 error (_("Section %d has invalid sh_entsize %lx (expected %lx)\n"), \
4103 i, (unsigned long int) section->sh_entsize, \
4104 (unsigned long int) expected_entsize); \
4105 section->sh_entsize = expected_entsize; \
4108 #define CHECK_ENTSIZE(section, i, type) \
4109 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
4110 sizeof (Elf64_External_##type))
4112 for (i = 0, section = section_headers;
4113 i < elf_header.e_shnum;
4116 char *name = SECTION_NAME (section);
4118 if (section->sh_type == SHT_DYNSYM)
4120 if (dynamic_symbols != NULL)
4122 error (_("File contains multiple dynamic symbol tables\n"));
4126 CHECK_ENTSIZE (section, i, Sym);
4127 num_dynamic_syms = section->sh_size / section->sh_entsize;
4128 dynamic_symbols = GET_ELF_SYMBOLS (file, section);
4130 else if (section->sh_type == SHT_STRTAB
4131 && streq (name, ".dynstr"))
4133 if (dynamic_strings != NULL)
4135 error (_("File contains multiple dynamic string tables\n"));
4139 dynamic_strings = get_data (NULL, file, section->sh_offset,
4140 1, section->sh_size, _("dynamic strings"));
4141 dynamic_strings_length = section->sh_size;
4143 else if (section->sh_type == SHT_SYMTAB_SHNDX)
4145 if (symtab_shndx_hdr != NULL)
4147 error (_("File contains multiple symtab shndx tables\n"));
4150 symtab_shndx_hdr = section;
4152 else if (section->sh_type == SHT_SYMTAB)
4153 CHECK_ENTSIZE (section, i, Sym);
4154 else if (section->sh_type == SHT_GROUP)
4155 CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
4156 else if (section->sh_type == SHT_REL)
4157 CHECK_ENTSIZE (section, i, Rel);
4158 else if (section->sh_type == SHT_RELA)
4159 CHECK_ENTSIZE (section, i, Rela);
4160 else if ((do_debugging || do_debug_info || do_debug_abbrevs
4161 || do_debug_lines || do_debug_pubnames || do_debug_aranges
4162 || do_debug_frames || do_debug_macinfo || do_debug_str
4163 || do_debug_loc || do_debug_ranges)
4164 && const_strneq (name, ".debug_"))
4169 || (do_debug_info && streq (name, "info"))
4170 || (do_debug_abbrevs && streq (name, "abbrev"))
4171 || (do_debug_lines && streq (name, "line"))
4172 || (do_debug_pubnames && streq (name, "pubnames"))
4173 || (do_debug_aranges && streq (name, "aranges"))
4174 || (do_debug_ranges && streq (name, "ranges"))
4175 || (do_debug_frames && streq (name, "frame"))
4176 || (do_debug_macinfo && streq (name, "macinfo"))
4177 || (do_debug_str && streq (name, "str"))
4178 || (do_debug_loc && streq (name, "loc"))
4180 request_dump (i, DEBUG_DUMP);
4182 /* linkonce section to be combined with .debug_info at link time. */
4183 else if ((do_debugging || do_debug_info)
4184 && const_strneq (name, ".gnu.linkonce.wi."))
4185 request_dump (i, DEBUG_DUMP);
4186 else if (do_debug_frames && streq (name, ".eh_frame"))
4187 request_dump (i, DEBUG_DUMP);
4193 if (elf_header.e_shnum > 1)
4194 printf (_("\nSection Headers:\n"));
4196 printf (_("\nSection Header:\n"));
4200 if (do_section_details)
4202 printf (_(" [Nr] Name\n"));
4203 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
4207 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
4211 if (do_section_details)
4213 printf (_(" [Nr] Name\n"));
4214 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
4218 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
4222 if (do_section_details)
4224 printf (_(" [Nr] Name\n"));
4225 printf (_(" Type Address Offset Link\n"));
4226 printf (_(" Size EntSize Info Align\n"));
4230 printf (_(" [Nr] Name Type Address Offset\n"));
4231 printf (_(" Size EntSize Flags Link Info Align\n"));
4235 if (do_section_details)
4236 printf (_(" Flags\n"));
4238 for (i = 0, section = section_headers;
4239 i < elf_header.e_shnum;
4242 if (do_section_details)
4244 printf (" [%2u] %s\n",
4245 SECTION_HEADER_NUM (i),
4246 SECTION_NAME (section));
4247 if (is_32bit_elf || do_wide)
4248 printf (" %-15.15s ",
4249 get_section_type_name (section->sh_type));
4252 printf (" [%2u] %-17.17s %-15.15s ",
4253 SECTION_HEADER_NUM (i),
4254 SECTION_NAME (section),
4255 get_section_type_name (section->sh_type));
4259 print_vma (section->sh_addr, LONG_HEX);
4261 printf ( " %6.6lx %6.6lx %2.2lx",
4262 (unsigned long) section->sh_offset,
4263 (unsigned long) section->sh_size,
4264 (unsigned long) section->sh_entsize);
4266 if (do_section_details)
4267 fputs (" ", stdout);
4269 printf (" %3s ", get_elf_section_flags (section->sh_flags));
4271 printf ("%2ld %3lu %2ld\n",
4272 (unsigned long) section->sh_link,
4273 (unsigned long) section->sh_info,
4274 (unsigned long) section->sh_addralign);
4278 print_vma (section->sh_addr, LONG_HEX);
4280 if ((long) section->sh_offset == section->sh_offset)
4281 printf (" %6.6lx", (unsigned long) section->sh_offset);
4285 print_vma (section->sh_offset, LONG_HEX);
4288 if ((unsigned long) section->sh_size == section->sh_size)
4289 printf (" %6.6lx", (unsigned long) section->sh_size);
4293 print_vma (section->sh_size, LONG_HEX);
4296 if ((unsigned long) section->sh_entsize == section->sh_entsize)
4297 printf (" %2.2lx", (unsigned long) section->sh_entsize);
4301 print_vma (section->sh_entsize, LONG_HEX);
4304 if (do_section_details)
4305 fputs (" ", stdout);
4307 printf (" %3s ", get_elf_section_flags (section->sh_flags));
4309 printf ("%2ld %3lu ",
4310 (unsigned long) section->sh_link,
4311 (unsigned long) section->sh_info);
4313 if ((unsigned long) section->sh_addralign == section->sh_addralign)
4314 printf ("%2ld\n", (unsigned long) section->sh_addralign);
4317 print_vma (section->sh_addralign, DEC);
4321 else if (do_section_details)
4323 printf (" %-15.15s ",
4324 get_section_type_name (section->sh_type));
4325 print_vma (section->sh_addr, LONG_HEX);
4326 if ((long) section->sh_offset == section->sh_offset)
4327 printf (" %16.16lx", (unsigned long) section->sh_offset);
4331 print_vma (section->sh_offset, LONG_HEX);
4333 printf (" %ld\n ", (unsigned long) section->sh_link);
4334 print_vma (section->sh_size, LONG_HEX);
4336 print_vma (section->sh_entsize, LONG_HEX);
4338 printf (" %-16lu %ld\n",
4339 (unsigned long) section->sh_info,
4340 (unsigned long) section->sh_addralign);
4345 print_vma (section->sh_addr, LONG_HEX);
4346 if ((long) section->sh_offset == section->sh_offset)
4347 printf (" %8.8lx", (unsigned long) section->sh_offset);
4351 print_vma (section->sh_offset, LONG_HEX);
4354 print_vma (section->sh_size, LONG_HEX);
4356 print_vma (section->sh_entsize, LONG_HEX);
4358 printf (" %3s ", get_elf_section_flags (section->sh_flags));
4360 printf (" %2ld %3lu %ld\n",
4361 (unsigned long) section->sh_link,
4362 (unsigned long) section->sh_info,
4363 (unsigned long) section->sh_addralign);
4366 if (do_section_details)
4367 printf (" %s\n", get_elf_section_flags (section->sh_flags));
4370 if (!do_section_details)
4371 printf (_("Key to Flags:\n\
4372 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
4373 I (info), L (link order), G (group), x (unknown)\n\
4374 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
4380 get_group_flags (unsigned int flags)
4382 static char buff[32];
4389 snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x]"), flags);
4396 process_section_groups (FILE *file)
4398 Elf_Internal_Shdr *section;
4400 struct group *group;
4401 Elf_Internal_Shdr *symtab_sec, *strtab_sec;
4402 Elf_Internal_Sym *symtab;
4406 /* Don't process section groups unless needed. */
4407 if (!do_unwind && !do_section_groups)
4410 if (elf_header.e_shnum == 0)
4412 if (do_section_groups)
4413 printf (_("\nThere are no sections in this file.\n"));
4418 if (section_headers == NULL)
4420 error (_("Section headers are not available!\n"));
4424 section_headers_groups = calloc (elf_header.e_shnum,
4425 sizeof (struct group *));
4427 if (section_headers_groups == NULL)
4429 error (_("Out of memory\n"));
4433 /* Scan the sections for the group section. */
4435 for (i = 0, section = section_headers;
4436 i < elf_header.e_shnum;
4438 if (section->sh_type == SHT_GROUP)
4441 if (group_count == 0)
4443 if (do_section_groups)
4444 printf (_("\nThere are no section groups in this file.\n"));
4449 section_groups = calloc (group_count, sizeof (struct group));
4451 if (section_groups == NULL)
4453 error (_("Out of memory\n"));
4462 for (i = 0, section = section_headers, group = section_groups;
4463 i < elf_header.e_shnum;
4466 if (section->sh_type == SHT_GROUP)
4468 char *name = SECTION_NAME (section);
4470 unsigned char *start, *indices;
4471 unsigned int entry, j, size;
4472 Elf_Internal_Shdr *sec;
4473 Elf_Internal_Sym *sym;
4475 /* Get the symbol table. */
4476 if (SECTION_HEADER_INDEX (section->sh_link) >= elf_header.e_shnum
4477 || ((sec = SECTION_HEADER (section->sh_link))->sh_type
4480 error (_("Bad sh_link in group section `%s'\n"), name);
4484 if (symtab_sec != sec)
4489 symtab = GET_ELF_SYMBOLS (file, symtab_sec);
4492 sym = symtab + section->sh_info;
4494 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
4496 bfd_vma sec_index = SECTION_HEADER_INDEX (sym->st_shndx);
4499 error (_("Bad sh_info in group section `%s'\n"), name);
4503 group_name = SECTION_NAME (section_headers + sec_index);
4512 /* Get the string table. */
4513 if (SECTION_HEADER_INDEX (symtab_sec->sh_link)
4514 >= elf_header.e_shnum)
4523 != (sec = SECTION_HEADER (symtab_sec->sh_link)))
4528 strtab = get_data (NULL, file, strtab_sec->sh_offset,
4529 1, strtab_sec->sh_size,
4531 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
4533 group_name = sym->st_name < strtab_size
4534 ? strtab + sym->st_name : "<corrupt>";
4537 start = get_data (NULL, file, section->sh_offset,
4538 1, section->sh_size, _("section data"));
4541 size = (section->sh_size / section->sh_entsize) - 1;
4542 entry = byte_get (indices, 4);
4545 if (do_section_groups)
4547 printf ("\n%s group section [%5u] `%s' [%s] contains %u sections:\n",
4548 get_group_flags (entry), i, name, group_name, size);
4550 printf (_(" [Index] Name\n"));
4553 group->group_index = i;
4555 for (j = 0; j < size; j++)
4557 struct group_list *g;
4559 entry = byte_get (indices, 4);
4562 if (SECTION_HEADER_INDEX (entry) >= elf_header.e_shnum)
4564 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
4565 entry, i, elf_header.e_shnum - 1);
4568 else if (entry >= SHN_LORESERVE && entry <= SHN_HIRESERVE)
4570 error (_("invalid section [%5u] in group section [%5u]\n"),
4575 if (section_headers_groups [SECTION_HEADER_INDEX (entry)]
4580 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
4582 section_headers_groups [SECTION_HEADER_INDEX (entry)]->group_index);
4587 /* Intel C/C++ compiler may put section 0 in a
4588 section group. We just warn it the first time
4589 and ignore it afterwards. */
4590 static int warned = 0;
4593 error (_("section 0 in group section [%5u]\n"),
4594 section_headers_groups [SECTION_HEADER_INDEX (entry)]->group_index);
4600 section_headers_groups [SECTION_HEADER_INDEX (entry)]
4603 if (do_section_groups)
4605 sec = SECTION_HEADER (entry);
4606 printf (" [%5u] %s\n", entry, SECTION_NAME (sec));
4609 g = xmalloc (sizeof (struct group_list));
4610 g->section_index = entry;
4611 g->next = group->root;
4635 } dynamic_relocations [] =
4637 { "REL", DT_REL, DT_RELSZ, FALSE },
4638 { "RELA", DT_RELA, DT_RELASZ, TRUE },
4639 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
4642 /* Process the reloc section. */
4645 process_relocs (FILE *file)
4647 unsigned long rel_size;
4648 unsigned long rel_offset;
4654 if (do_using_dynamic)
4658 int has_dynamic_reloc;
4661 has_dynamic_reloc = 0;
4663 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
4665 is_rela = dynamic_relocations [i].rela;
4666 name = dynamic_relocations [i].name;
4667 rel_size = dynamic_info [dynamic_relocations [i].size];
4668 rel_offset = dynamic_info [dynamic_relocations [i].reloc];
4670 has_dynamic_reloc |= rel_size;
4672 if (is_rela == UNKNOWN)
4674 if (dynamic_relocations [i].reloc == DT_JMPREL)
4675 switch (dynamic_info[DT_PLTREL])
4689 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
4690 name, rel_offset, rel_size);
4692 dump_relocations (file,
4693 offset_from_vma (file, rel_offset, rel_size),
4695 dynamic_symbols, num_dynamic_syms,
4696 dynamic_strings, dynamic_strings_length, is_rela);
4700 if (! has_dynamic_reloc)
4701 printf (_("\nThere are no dynamic relocations in this file.\n"));
4705 Elf_Internal_Shdr *section;
4709 for (i = 0, section = section_headers;
4710 i < elf_header.e_shnum;
4713 if ( section->sh_type != SHT_RELA
4714 && section->sh_type != SHT_REL)
4717 rel_offset = section->sh_offset;
4718 rel_size = section->sh_size;
4722 Elf_Internal_Shdr *strsec;
4725 printf (_("\nRelocation section "));
4727 if (string_table == NULL)
4728 printf ("%d", section->sh_name);
4730 printf (_("'%s'"), SECTION_NAME (section));
4732 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4733 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
4735 is_rela = section->sh_type == SHT_RELA;
4737 if (section->sh_link
4738 && SECTION_HEADER_INDEX (section->sh_link)
4739 < elf_header.e_shnum)
4741 Elf_Internal_Shdr *symsec;
4742 Elf_Internal_Sym *symtab;
4743 unsigned long nsyms;
4744 unsigned long strtablen = 0;
4745 char *strtab = NULL;
4747 symsec = SECTION_HEADER (section->sh_link);
4748 if (symsec->sh_type != SHT_SYMTAB
4749 && symsec->sh_type != SHT_DYNSYM)
4752 nsyms = symsec->sh_size / symsec->sh_entsize;
4753 symtab = GET_ELF_SYMBOLS (file, symsec);
4758 if (SECTION_HEADER_INDEX (symsec->sh_link)
4759 < elf_header.e_shnum)
4761 strsec = SECTION_HEADER (symsec->sh_link);
4763 strtab = get_data (NULL, file, strsec->sh_offset,
4766 strtablen = strtab == NULL ? 0 : strsec->sh_size;
4769 dump_relocations (file, rel_offset, rel_size,
4770 symtab, nsyms, strtab, strtablen, is_rela);
4776 dump_relocations (file, rel_offset, rel_size,
4777 NULL, 0, NULL, 0, is_rela);
4784 printf (_("\nThere are no relocations in this file.\n"));
4790 /* Process the unwind section. */
4792 #include "unwind-ia64.h"
4794 /* An absolute address consists of a section and an offset. If the
4795 section is NULL, the offset itself is the address, otherwise, the
4796 address equals to LOAD_ADDRESS(section) + offset. */
4800 unsigned short section;
4804 #define ABSADDR(a) \
4806 ? section_headers [(a).section].sh_addr + (a).offset \
4809 struct ia64_unw_aux_info
4811 struct ia64_unw_table_entry
4813 struct absaddr start;
4815 struct absaddr info;
4817 *table; /* Unwind table. */
4818 unsigned long table_len; /* Length of unwind table. */
4819 unsigned char *info; /* Unwind info. */
4820 unsigned long info_size; /* Size of unwind info. */
4821 bfd_vma info_addr; /* starting address of unwind info. */
4822 bfd_vma seg_base; /* Starting address of segment. */
4823 Elf_Internal_Sym *symtab; /* The symbol table. */
4824 unsigned long nsyms; /* Number of symbols. */
4825 char *strtab; /* The string table. */
4826 unsigned long strtab_size; /* Size of string table. */
4830 find_symbol_for_address (Elf_Internal_Sym *symtab,
4831 unsigned long nsyms,
4833 unsigned long strtab_size,
4834 struct absaddr addr,
4835 const char **symname,
4838 bfd_vma dist = 0x100000;
4839 Elf_Internal_Sym *sym, *best = NULL;
4842 for (i = 0, sym = symtab; i < nsyms; ++i, ++sym)
4844 if (ELF_ST_TYPE (sym->st_info) == STT_FUNC
4845 && sym->st_name != 0
4846 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
4847 && addr.offset >= sym->st_value
4848 && addr.offset - sym->st_value < dist)
4851 dist = addr.offset - sym->st_value;
4858 *symname = (best->st_name >= strtab_size
4859 ? "<corrupt>" : strtab + best->st_name);
4864 *offset = addr.offset;
4868 dump_ia64_unwind (struct ia64_unw_aux_info *aux)
4870 struct ia64_unw_table_entry *tp;
4873 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
4877 const unsigned char *dp;
4878 const unsigned char *head;
4879 const char *procname;
4881 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
4882 aux->strtab_size, tp->start, &procname, &offset);
4884 fputs ("\n<", stdout);
4888 fputs (procname, stdout);
4891 printf ("+%lx", (unsigned long) offset);
4894 fputs (">: [", stdout);
4895 print_vma (tp->start.offset, PREFIX_HEX);
4896 fputc ('-', stdout);
4897 print_vma (tp->end.offset, PREFIX_HEX);
4898 printf ("], info at +0x%lx\n",
4899 (unsigned long) (tp->info.offset - aux->seg_base));
4901 head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
4902 stamp = byte_get ((unsigned char *) head, sizeof (stamp));
4904 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
4905 (unsigned) UNW_VER (stamp),
4906 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
4907 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
4908 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
4909 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
4911 if (UNW_VER (stamp) != 1)
4913 printf ("\tUnknown version.\n");
4918 for (dp = head + 8; dp < head + 8 + eh_addr_size * UNW_LENGTH (stamp);)
4919 dp = unw_decode (dp, in_body, & in_body);
4924 slurp_ia64_unwind_table (FILE *file,
4925 struct ia64_unw_aux_info *aux,
4926 Elf_Internal_Shdr *sec)
4928 unsigned long size, nrelas, i;
4929 Elf_Internal_Phdr *seg;
4930 struct ia64_unw_table_entry *tep;
4931 Elf_Internal_Shdr *relsec;
4932 Elf_Internal_Rela *rela, *rp;
4933 unsigned char *table, *tp;
4934 Elf_Internal_Sym *sym;
4935 const char *relname;
4937 /* First, find the starting address of the segment that includes
4940 if (elf_header.e_phnum)
4942 if (! get_program_headers (file))
4945 for (seg = program_headers;
4946 seg < program_headers + elf_header.e_phnum;
4949 if (seg->p_type != PT_LOAD)
4952 if (sec->sh_addr >= seg->p_vaddr
4953 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
4955 aux->seg_base = seg->p_vaddr;
4961 /* Second, build the unwind table from the contents of the unwind section: */
4962 size = sec->sh_size;
4963 table = get_data (NULL, file, sec->sh_offset, 1, size, _("unwind table"));
4967 aux->table = xcmalloc (size / (3 * eh_addr_size), sizeof (aux->table[0]));
4969 for (tp = table; tp < table + size; tp += 3 * eh_addr_size, ++tep)
4971 tep->start.section = SHN_UNDEF;
4972 tep->end.section = SHN_UNDEF;
4973 tep->info.section = SHN_UNDEF;
4976 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
4977 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
4978 tep->info.offset = byte_get ((unsigned char *) tp + 8, 4);
4982 tep->start.offset = BYTE_GET ((unsigned char *) tp + 0);
4983 tep->end.offset = BYTE_GET ((unsigned char *) tp + 8);
4984 tep->info.offset = BYTE_GET ((unsigned char *) tp + 16);
4986 tep->start.offset += aux->seg_base;
4987 tep->end.offset += aux->seg_base;
4988 tep->info.offset += aux->seg_base;
4992 /* Third, apply any relocations to the unwind table: */
4994 for (relsec = section_headers;
4995 relsec < section_headers + elf_header.e_shnum;
4998 if (relsec->sh_type != SHT_RELA
4999 || SECTION_HEADER_INDEX (relsec->sh_info) >= elf_header.e_shnum
5000 || SECTION_HEADER (relsec->sh_info) != sec)
5003 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
5007 for (rp = rela; rp < rela + nrelas; ++rp)
5011 relname = elf_ia64_reloc_type (ELF32_R_TYPE (rp->r_info));
5012 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
5016 relname = elf_ia64_reloc_type (ELF64_R_TYPE (rp->r_info));
5017 sym = aux->symtab + ELF64_R_SYM (rp->r_info);
5020 if (! const_strneq (relname, "R_IA64_SEGREL"))
5022 warn (_("Skipping unexpected relocation type %s\n"), relname);
5026 i = rp->r_offset / (3 * eh_addr_size);
5028 switch (rp->r_offset/eh_addr_size % 3)
5031 aux->table[i].start.section = sym->st_shndx;
5032 aux->table[i].start.offset += rp->r_addend + sym->st_value;
5035 aux->table[i].end.section = sym->st_shndx;
5036 aux->table[i].end.offset += rp->r_addend + sym->st_value;
5039 aux->table[i].info.section = sym->st_shndx;
5040 aux->table[i].info.offset += rp->r_addend + sym->st_value;
5050 aux->table_len = size / (3 * eh_addr_size);
5055 ia64_process_unwind (FILE *file)
5057 Elf_Internal_Shdr *sec, *unwsec = NULL, *strsec;
5058 unsigned long i, unwcount = 0, unwstart = 0;
5059 struct ia64_unw_aux_info aux;
5061 memset (& aux, 0, sizeof (aux));
5063 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
5065 if (sec->sh_type == SHT_SYMTAB
5066 && SECTION_HEADER_INDEX (sec->sh_link) < elf_header.e_shnum)
5068 aux.nsyms = sec->sh_size / sec->sh_entsize;
5069 aux.symtab = GET_ELF_SYMBOLS (file, sec);
5071 strsec = SECTION_HEADER (sec->sh_link);
5072 aux.strtab = get_data (NULL, file, strsec->sh_offset,
5073 1, strsec->sh_size, _("string table"));
5074 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
5076 else if (sec->sh_type == SHT_IA_64_UNWIND)
5081 printf (_("\nThere are no unwind sections in this file.\n"));
5083 while (unwcount-- > 0)
5088 for (i = unwstart, sec = section_headers + unwstart;
5089 i < elf_header.e_shnum; ++i, ++sec)
5090 if (sec->sh_type == SHT_IA_64_UNWIND)
5097 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
5099 if ((unwsec->sh_flags & SHF_GROUP) != 0)
5101 /* We need to find which section group it is in. */
5102 struct group_list *g = section_headers_groups [i]->root;
5104 for (; g != NULL; g = g->next)
5106 sec = SECTION_HEADER (g->section_index);
5108 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
5113 i = elf_header.e_shnum;
5115 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
5117 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
5118 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
5119 suffix = SECTION_NAME (unwsec) + len;
5120 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
5122 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
5123 && streq (SECTION_NAME (sec) + len2, suffix))
5128 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
5129 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
5130 len = sizeof (ELF_STRING_ia64_unwind) - 1;
5131 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
5133 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
5134 suffix = SECTION_NAME (unwsec) + len;
5135 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
5137 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
5138 && streq (SECTION_NAME (sec) + len2, suffix))
5142 if (i == elf_header.e_shnum)
5144 printf (_("\nCould not find unwind info section for "));
5146 if (string_table == NULL)
5147 printf ("%d", unwsec->sh_name);
5149 printf (_("'%s'"), SECTION_NAME (unwsec));
5153 aux.info_size = sec->sh_size;
5154 aux.info_addr = sec->sh_addr;
5155 aux.info = get_data (NULL, file, sec->sh_offset, 1, aux.info_size,
5158 printf (_("\nUnwind section "));
5160 if (string_table == NULL)
5161 printf ("%d", unwsec->sh_name);
5163 printf (_("'%s'"), SECTION_NAME (unwsec));
5165 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5166 (unsigned long) unwsec->sh_offset,
5167 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
5169 (void) slurp_ia64_unwind_table (file, & aux, unwsec);
5171 if (aux.table_len > 0)
5172 dump_ia64_unwind (& aux);
5175 free ((char *) aux.table);
5177 free ((char *) aux.info);
5186 free ((char *) aux.strtab);
5191 struct hppa_unw_aux_info
5193 struct hppa_unw_table_entry
5195 struct absaddr start;
5197 unsigned int Cannot_unwind:1; /* 0 */
5198 unsigned int Millicode:1; /* 1 */
5199 unsigned int Millicode_save_sr0:1; /* 2 */
5200 unsigned int Region_description:2; /* 3..4 */
5201 unsigned int reserved1:1; /* 5 */
5202 unsigned int Entry_SR:1; /* 6 */
5203 unsigned int Entry_FR:4; /* number saved */ /* 7..10 */
5204 unsigned int Entry_GR:5; /* number saved */ /* 11..15 */
5205 unsigned int Args_stored:1; /* 16 */
5206 unsigned int Variable_Frame:1; /* 17 */
5207 unsigned int Separate_Package_Body:1; /* 18 */
5208 unsigned int Frame_Extension_Millicode:1; /* 19 */
5209 unsigned int Stack_Overflow_Check:1; /* 20 */
5210 unsigned int Two_Instruction_SP_Increment:1; /* 21 */
5211 unsigned int Ada_Region:1; /* 22 */
5212 unsigned int cxx_info:1; /* 23 */
5213 unsigned int cxx_try_catch:1; /* 24 */
5214 unsigned int sched_entry_seq:1; /* 25 */
5215 unsigned int reserved2:1; /* 26 */
5216 unsigned int Save_SP:1; /* 27 */
5217 unsigned int Save_RP:1; /* 28 */
5218 unsigned int Save_MRP_in_frame:1; /* 29 */
5219 unsigned int extn_ptr_defined:1; /* 30 */
5220 unsigned int Cleanup_defined:1; /* 31 */
5222 unsigned int MPE_XL_interrupt_marker:1; /* 0 */
5223 unsigned int HP_UX_interrupt_marker:1; /* 1 */
5224 unsigned int Large_frame:1; /* 2 */
5225 unsigned int Pseudo_SP_Set:1; /* 3 */
5226 unsigned int reserved4:1; /* 4 */
5227 unsigned int Total_frame_size:27; /* 5..31 */
5229 *table; /* Unwind table. */
5230 unsigned long table_len; /* Length of unwind table. */
5231 bfd_vma seg_base; /* Starting address of segment. */
5232 Elf_Internal_Sym *symtab; /* The symbol table. */
5233 unsigned long nsyms; /* Number of symbols. */
5234 char *strtab; /* The string table. */
5235 unsigned long strtab_size; /* Size of string table. */
5239 dump_hppa_unwind (struct hppa_unw_aux_info *aux)
5241 struct hppa_unw_table_entry *tp;
5243 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
5246 const char *procname;
5248 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
5249 aux->strtab_size, tp->start, &procname,
5252 fputs ("\n<", stdout);
5256 fputs (procname, stdout);
5259 printf ("+%lx", (unsigned long) offset);
5262 fputs (">: [", stdout);
5263 print_vma (tp->start.offset, PREFIX_HEX);
5264 fputc ('-', stdout);
5265 print_vma (tp->end.offset, PREFIX_HEX);
5268 #define PF(_m) if (tp->_m) printf (#_m " ");
5269 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
5272 PF(Millicode_save_sr0);
5273 /* PV(Region_description); */
5279 PF(Separate_Package_Body);
5280 PF(Frame_Extension_Millicode);
5281 PF(Stack_Overflow_Check);
5282 PF(Two_Instruction_SP_Increment);
5286 PF(sched_entry_seq);
5289 PF(Save_MRP_in_frame);
5290 PF(extn_ptr_defined);
5291 PF(Cleanup_defined);
5292 PF(MPE_XL_interrupt_marker);
5293 PF(HP_UX_interrupt_marker);
5296 PV(Total_frame_size);
5305 slurp_hppa_unwind_table (FILE *file,
5306 struct hppa_unw_aux_info *aux,
5307 Elf_Internal_Shdr *sec)
5309 unsigned long size, unw_ent_size, nentries, nrelas, i;
5310 Elf_Internal_Phdr *seg;
5311 struct hppa_unw_table_entry *tep;
5312 Elf_Internal_Shdr *relsec;
5313 Elf_Internal_Rela *rela, *rp;
5314 unsigned char *table, *tp;
5315 Elf_Internal_Sym *sym;
5316 const char *relname;
5318 /* First, find the starting address of the segment that includes
5321 if (elf_header.e_phnum)
5323 if (! get_program_headers (file))
5326 for (seg = program_headers;
5327 seg < program_headers + elf_header.e_phnum;
5330 if (seg->p_type != PT_LOAD)
5333 if (sec->sh_addr >= seg->p_vaddr
5334 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
5336 aux->seg_base = seg->p_vaddr;
5342 /* Second, build the unwind table from the contents of the unwind
5344 size = sec->sh_size;
5345 table = get_data (NULL, file, sec->sh_offset, 1, size, _("unwind table"));
5350 nentries = size / unw_ent_size;
5351 size = unw_ent_size * nentries;
5353 tep = aux->table = xcmalloc (nentries, sizeof (aux->table[0]));
5355 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
5357 unsigned int tmp1, tmp2;
5359 tep->start.section = SHN_UNDEF;
5360 tep->end.section = SHN_UNDEF;
5362 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
5363 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
5364 tmp1 = byte_get ((unsigned char *) tp + 8, 4);
5365 tmp2 = byte_get ((unsigned char *) tp + 12, 4);
5367 tep->start.offset += aux->seg_base;
5368 tep->end.offset += aux->seg_base;
5370 tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
5371 tep->Millicode = (tmp1 >> 30) & 0x1;
5372 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
5373 tep->Region_description = (tmp1 >> 27) & 0x3;
5374 tep->reserved1 = (tmp1 >> 26) & 0x1;
5375 tep->Entry_SR = (tmp1 >> 25) & 0x1;
5376 tep->Entry_FR = (tmp1 >> 21) & 0xf;
5377 tep->Entry_GR = (tmp1 >> 16) & 0x1f;
5378 tep->Args_stored = (tmp1 >> 15) & 0x1;
5379 tep->Variable_Frame = (tmp1 >> 14) & 0x1;
5380 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
5381 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
5382 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
5383 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
5384 tep->Ada_Region = (tmp1 >> 9) & 0x1;
5385 tep->cxx_info = (tmp1 >> 8) & 0x1;
5386 tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
5387 tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
5388 tep->reserved2 = (tmp1 >> 5) & 0x1;
5389 tep->Save_SP = (tmp1 >> 4) & 0x1;
5390 tep->Save_RP = (tmp1 >> 3) & 0x1;
5391 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
5392 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
5393 tep->Cleanup_defined = tmp1 & 0x1;
5395 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
5396 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
5397 tep->Large_frame = (tmp2 >> 29) & 0x1;
5398 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
5399 tep->reserved4 = (tmp2 >> 27) & 0x1;
5400 tep->Total_frame_size = tmp2 & 0x7ffffff;
5404 /* Third, apply any relocations to the unwind table. */
5406 for (relsec = section_headers;
5407 relsec < section_headers + elf_header.e_shnum;
5410 if (relsec->sh_type != SHT_RELA
5411 || SECTION_HEADER_INDEX (relsec->sh_info) >= elf_header.e_shnum
5412 || SECTION_HEADER (relsec->sh_info) != sec)
5415 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
5419 for (rp = rela; rp < rela + nrelas; ++rp)
5423 relname = elf_hppa_reloc_type (ELF32_R_TYPE (rp->r_info));
5424 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
5428 relname = elf_hppa_reloc_type (ELF64_R_TYPE (rp->r_info));
5429 sym = aux->symtab + ELF64_R_SYM (rp->r_info);
5432 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
5433 if (! const_strneq (relname, "R_PARISC_SEGREL"))
5435 warn (_("Skipping unexpected relocation type %s\n"), relname);
5439 i = rp->r_offset / unw_ent_size;
5441 switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
5444 aux->table[i].start.section = sym->st_shndx;
5445 aux->table[i].start.offset += sym->st_value + rp->r_addend;
5448 aux->table[i].end.section = sym->st_shndx;
5449 aux->table[i].end.offset += sym->st_value + rp->r_addend;
5459 aux->table_len = nentries;
5465 hppa_process_unwind (FILE *file)
5467 struct hppa_unw_aux_info aux;
5468 Elf_Internal_Shdr *unwsec = NULL;
5469 Elf_Internal_Shdr *strsec;
5470 Elf_Internal_Shdr *sec;
5473 memset (& aux, 0, sizeof (aux));
5475 if (string_table == NULL)
5478 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
5480 if (sec->sh_type == SHT_SYMTAB
5481 && SECTION_HEADER_INDEX (sec->sh_link) < elf_header.e_shnum)
5483 aux.nsyms = sec->sh_size / sec->sh_entsize;
5484 aux.symtab = GET_ELF_SYMBOLS (file, sec);
5486 strsec = SECTION_HEADER (sec->sh_link);
5487 aux.strtab = get_data (NULL, file, strsec->sh_offset,
5488 1, strsec->sh_size, _("string table"));
5489 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
5491 else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
5496 printf (_("\nThere are no unwind sections in this file.\n"));
5498 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
5500 if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
5502 printf (_("\nUnwind section "));
5503 printf (_("'%s'"), SECTION_NAME (sec));
5505 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5506 (unsigned long) sec->sh_offset,
5507 (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
5509 slurp_hppa_unwind_table (file, &aux, sec);
5510 if (aux.table_len > 0)
5511 dump_hppa_unwind (&aux);
5514 free ((char *) aux.table);
5522 free ((char *) aux.strtab);
5528 process_unwind (FILE *file)
5530 struct unwind_handler {
5532 int (*handler)(FILE *file);
5534 { EM_IA_64, ia64_process_unwind },
5535 { EM_PARISC, hppa_process_unwind },
5543 for (i = 0; handlers[i].handler != NULL; i++)
5544 if (elf_header.e_machine == handlers[i].machtype)
5545 return handlers[i].handler (file);
5547 printf (_("\nThere are no unwind sections in this file.\n"));
5552 dynamic_section_mips_val (Elf_Internal_Dyn *entry)
5554 switch (entry->d_tag)
5557 if (entry->d_un.d_val == 0)
5561 static const char * opts[] =
5563 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
5564 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
5565 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
5566 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
5571 for (cnt = 0; cnt < NUM_ELEM (opts); ++cnt)
5572 if (entry->d_un.d_val & (1 << cnt))
5574 printf ("%s%s", first ? "" : " ", opts[cnt]);
5581 case DT_MIPS_IVERSION:
5582 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
5583 printf ("Interface Version: %s\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
5585 printf ("<corrupt: %ld>\n", (long) entry->d_un.d_ptr);
5588 case DT_MIPS_TIME_STAMP:
5593 time_t time = entry->d_un.d_val;
5594 tmp = gmtime (&time);
5595 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
5596 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
5597 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
5598 printf ("Time Stamp: %s\n", timebuf);
5602 case DT_MIPS_RLD_VERSION:
5603 case DT_MIPS_LOCAL_GOTNO:
5604 case DT_MIPS_CONFLICTNO:
5605 case DT_MIPS_LIBLISTNO:
5606 case DT_MIPS_SYMTABNO:
5607 case DT_MIPS_UNREFEXTNO:
5608 case DT_MIPS_HIPAGENO:
5609 case DT_MIPS_DELTA_CLASS_NO:
5610 case DT_MIPS_DELTA_INSTANCE_NO:
5611 case DT_MIPS_DELTA_RELOC_NO:
5612 case DT_MIPS_DELTA_SYM_NO:
5613 case DT_MIPS_DELTA_CLASSSYM_NO:
5614 case DT_MIPS_COMPACT_SIZE:
5615 printf ("%ld\n", (long) entry->d_un.d_ptr);
5619 printf ("%#lx\n", (long) entry->d_un.d_ptr);
5625 dynamic_section_parisc_val (Elf_Internal_Dyn *entry)
5627 switch (entry->d_tag)
5629 case DT_HP_DLD_FLAGS:
5638 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
5639 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
5640 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
5641 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
5642 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
5643 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
5644 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
5645 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
5646 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
5647 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
5648 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
5649 { DT_HP_GST, "HP_GST" },
5650 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
5651 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
5652 { DT_HP_NODELETE, "HP_NODELETE" },
5653 { DT_HP_GROUP, "HP_GROUP" },
5654 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
5658 bfd_vma val = entry->d_un.d_val;
5660 for (cnt = 0; cnt < sizeof (flags) / sizeof (flags[0]); ++cnt)
5661 if (val & flags[cnt].bit)
5665 fputs (flags[cnt].str, stdout);
5667 val ^= flags[cnt].bit;
5670 if (val != 0 || first)
5674 print_vma (val, HEX);
5680 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
5687 dynamic_section_ia64_val (Elf_Internal_Dyn *entry)
5689 switch (entry->d_tag)
5691 case DT_IA_64_PLT_RESERVE:
5692 /* First 3 slots reserved. */
5693 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
5695 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
5699 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
5706 get_32bit_dynamic_section (FILE *file)
5708 Elf32_External_Dyn *edyn, *ext;
5709 Elf_Internal_Dyn *entry;
5711 edyn = get_data (NULL, file, dynamic_addr, 1, dynamic_size,
5712 _("dynamic section"));
5716 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5717 might not have the luxury of section headers. Look for the DT_NULL
5718 terminator to determine the number of entries. */
5719 for (ext = edyn, dynamic_nent = 0;
5720 (char *) ext < (char *) edyn + dynamic_size;
5724 if (BYTE_GET (ext->d_tag) == DT_NULL)
5728 dynamic_section = cmalloc (dynamic_nent, sizeof (*entry));
5729 if (dynamic_section == NULL)
5731 error (_("Out of memory\n"));
5736 for (ext = edyn, entry = dynamic_section;
5737 entry < dynamic_section + dynamic_nent;
5740 entry->d_tag = BYTE_GET (ext->d_tag);
5741 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
5750 get_64bit_dynamic_section (FILE *file)
5752 Elf64_External_Dyn *edyn, *ext;
5753 Elf_Internal_Dyn *entry;
5755 edyn = get_data (NULL, file, dynamic_addr, 1, dynamic_size,
5756 _("dynamic section"));
5760 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5761 might not have the luxury of section headers. Look for the DT_NULL
5762 terminator to determine the number of entries. */
5763 for (ext = edyn, dynamic_nent = 0;
5764 (char *) ext < (char *) edyn + dynamic_size;
5768 if (BYTE_GET (ext->d_tag) == DT_NULL)
5772 dynamic_section = cmalloc (dynamic_nent, sizeof (*entry));
5773 if (dynamic_section == NULL)
5775 error (_("Out of memory\n"));
5780 for (ext = edyn, entry = dynamic_section;
5781 entry < dynamic_section + dynamic_nent;
5784 entry->d_tag = BYTE_GET (ext->d_tag);
5785 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
5794 print_dynamic_flags (bfd_vma flags)
5802 flag = flags & - flags;
5812 case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
5813 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
5814 case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
5815 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
5816 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
5817 default: fputs ("unknown", stdout); break;
5823 /* Parse and display the contents of the dynamic section. */
5826 process_dynamic_section (FILE *file)
5828 Elf_Internal_Dyn *entry;
5830 if (dynamic_size == 0)
5833 printf (_("\nThere is no dynamic section in this file.\n"));
5840 if (! get_32bit_dynamic_section (file))
5843 else if (! get_64bit_dynamic_section (file))
5846 /* Find the appropriate symbol table. */
5847 if (dynamic_symbols == NULL)
5849 for (entry = dynamic_section;
5850 entry < dynamic_section + dynamic_nent;
5853 Elf_Internal_Shdr section;
5855 if (entry->d_tag != DT_SYMTAB)
5858 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
5860 /* Since we do not know how big the symbol table is,
5861 we default to reading in the entire file (!) and
5862 processing that. This is overkill, I know, but it
5864 section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
5866 if (archive_file_offset != 0)
5867 section.sh_size = archive_file_size - section.sh_offset;
5870 if (fseek (file, 0, SEEK_END))
5871 error (_("Unable to seek to end of file!\n"));
5873 section.sh_size = ftell (file) - section.sh_offset;
5877 section.sh_entsize = sizeof (Elf32_External_Sym);
5879 section.sh_entsize = sizeof (Elf64_External_Sym);
5881 num_dynamic_syms = section.sh_size / section.sh_entsize;
5882 if (num_dynamic_syms < 1)
5884 error (_("Unable to determine the number of symbols to load\n"));
5888 dynamic_symbols = GET_ELF_SYMBOLS (file, §ion);
5892 /* Similarly find a string table. */
5893 if (dynamic_strings == NULL)
5895 for (entry = dynamic_section;
5896 entry < dynamic_section + dynamic_nent;
5899 unsigned long offset;
5902 if (entry->d_tag != DT_STRTAB)
5905 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
5907 /* Since we do not know how big the string table is,
5908 we default to reading in the entire file (!) and
5909 processing that. This is overkill, I know, but it
5912 offset = offset_from_vma (file, entry->d_un.d_val, 0);
5914 if (archive_file_offset != 0)
5915 str_tab_len = archive_file_size - offset;
5918 if (fseek (file, 0, SEEK_END))
5919 error (_("Unable to seek to end of file\n"));
5920 str_tab_len = ftell (file) - offset;
5923 if (str_tab_len < 1)
5926 (_("Unable to determine the length of the dynamic string table\n"));
5930 dynamic_strings = get_data (NULL, file, offset, 1, str_tab_len,
5931 _("dynamic string table"));
5932 dynamic_strings_length = str_tab_len;
5937 /* And find the syminfo section if available. */
5938 if (dynamic_syminfo == NULL)
5940 unsigned long syminsz = 0;
5942 for (entry = dynamic_section;
5943 entry < dynamic_section + dynamic_nent;
5946 if (entry->d_tag == DT_SYMINENT)
5948 /* Note: these braces are necessary to avoid a syntax
5949 error from the SunOS4 C compiler. */
5950 assert (sizeof (Elf_External_Syminfo) == entry->d_un.d_val);
5952 else if (entry->d_tag == DT_SYMINSZ)
5953 syminsz = entry->d_un.d_val;
5954 else if (entry->d_tag == DT_SYMINFO)
5955 dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
5959 if (dynamic_syminfo_offset != 0 && syminsz != 0)
5961 Elf_External_Syminfo *extsyminfo, *extsym;
5962 Elf_Internal_Syminfo *syminfo;
5964 /* There is a syminfo section. Read the data. */
5965 extsyminfo = get_data (NULL, file, dynamic_syminfo_offset, 1,
5966 syminsz, _("symbol information"));
5970 dynamic_syminfo = malloc (syminsz);
5971 if (dynamic_syminfo == NULL)
5973 error (_("Out of memory\n"));
5977 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
5978 for (syminfo = dynamic_syminfo, extsym = extsyminfo;
5979 syminfo < dynamic_syminfo + dynamic_syminfo_nent;
5980 ++syminfo, ++extsym)
5982 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
5983 syminfo->si_flags = BYTE_GET (extsym->si_flags);
5990 if (do_dynamic && dynamic_addr)
5991 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
5992 dynamic_addr, dynamic_nent);
5994 printf (_(" Tag Type Name/Value\n"));
5996 for (entry = dynamic_section;
5997 entry < dynamic_section + dynamic_nent;
6005 print_vma (entry->d_tag, FULL_HEX);
6006 dtype = get_dynamic_type (entry->d_tag);
6007 printf (" (%s)%*s", dtype,
6008 ((is_32bit_elf ? 27 : 19)
6009 - (int) strlen (dtype)),
6013 switch (entry->d_tag)
6017 print_dynamic_flags (entry->d_un.d_val);
6027 switch (entry->d_tag)
6030 printf (_("Auxiliary library"));
6034 printf (_("Filter library"));
6038 printf (_("Configuration file"));
6042 printf (_("Dependency audit library"));
6046 printf (_("Audit library"));
6050 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
6051 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
6055 print_vma (entry->d_un.d_val, PREFIX_HEX);
6064 printf (_("Flags:"));
6066 if (entry->d_un.d_val == 0)
6067 printf (_(" None\n"));
6070 unsigned long int val = entry->d_un.d_val;
6072 if (val & DTF_1_PARINIT)
6074 printf (" PARINIT");
6075 val ^= DTF_1_PARINIT;
6077 if (val & DTF_1_CONFEXP)
6079 printf (" CONFEXP");
6080 val ^= DTF_1_CONFEXP;
6083 printf (" %lx", val);
6092 printf (_("Flags:"));
6094 if (entry->d_un.d_val == 0)
6095 printf (_(" None\n"));
6098 unsigned long int val = entry->d_un.d_val;
6100 if (val & DF_P1_LAZYLOAD)
6102 printf (" LAZYLOAD");
6103 val ^= DF_P1_LAZYLOAD;
6105 if (val & DF_P1_GROUPPERM)
6107 printf (" GROUPPERM");
6108 val ^= DF_P1_GROUPPERM;
6111 printf (" %lx", val);
6120 printf (_("Flags:"));
6121 if (entry->d_un.d_val == 0)
6122 printf (_(" None\n"));
6125 unsigned long int val = entry->d_un.d_val;
6132 if (val & DF_1_GLOBAL)
6137 if (val & DF_1_GROUP)
6142 if (val & DF_1_NODELETE)
6144 printf (" NODELETE");
6145 val ^= DF_1_NODELETE;
6147 if (val & DF_1_LOADFLTR)
6149 printf (" LOADFLTR");
6150 val ^= DF_1_LOADFLTR;
6152 if (val & DF_1_INITFIRST)
6154 printf (" INITFIRST");
6155 val ^= DF_1_INITFIRST;
6157 if (val & DF_1_NOOPEN)
6162 if (val & DF_1_ORIGIN)
6167 if (val & DF_1_DIRECT)
6172 if (val & DF_1_TRANS)
6177 if (val & DF_1_INTERPOSE)
6179 printf (" INTERPOSE");
6180 val ^= DF_1_INTERPOSE;
6182 if (val & DF_1_NODEFLIB)
6184 printf (" NODEFLIB");
6185 val ^= DF_1_NODEFLIB;
6187 if (val & DF_1_NODUMP)
6192 if (val & DF_1_CONLFAT)
6194 printf (" CONLFAT");
6195 val ^= DF_1_CONLFAT;
6198 printf (" %lx", val);
6205 dynamic_info[entry->d_tag] = entry->d_un.d_val;
6207 puts (get_dynamic_type (entry->d_un.d_val));
6227 dynamic_info[entry->d_tag] = entry->d_un.d_val;
6233 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
6234 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
6240 switch (entry->d_tag)
6243 printf (_("Shared library: [%s]"), name);
6245 if (streq (name, program_interpreter))
6246 printf (_(" program interpreter"));
6250 printf (_("Library soname: [%s]"), name);
6254 printf (_("Library rpath: [%s]"), name);
6258 printf (_("Library runpath: [%s]"), name);
6262 print_vma (entry->d_un.d_val, PREFIX_HEX);
6267 print_vma (entry->d_un.d_val, PREFIX_HEX);
6280 dynamic_info[entry->d_tag] = entry->d_un.d_val;
6284 case DT_INIT_ARRAYSZ:
6285 case DT_FINI_ARRAYSZ:
6286 case DT_GNU_CONFLICTSZ:
6287 case DT_GNU_LIBLISTSZ:
6290 print_vma (entry->d_un.d_val, UNSIGNED);
6291 printf (" (bytes)\n");
6301 print_vma (entry->d_un.d_val, UNSIGNED);
6314 if (entry->d_tag == DT_USED
6315 && VALID_DYNAMIC_NAME (entry->d_un.d_val))
6317 char *name = GET_DYNAMIC_NAME (entry->d_un.d_val);
6321 printf (_("Not needed object: [%s]\n"), name);
6326 print_vma (entry->d_un.d_val, PREFIX_HEX);
6332 /* The value of this entry is ignored. */
6337 case DT_GNU_PRELINKED:
6341 time_t time = entry->d_un.d_val;
6343 tmp = gmtime (&time);
6344 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
6345 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
6346 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
6352 dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
6355 print_vma (entry->d_un.d_val, PREFIX_HEX);
6361 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
6362 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
6367 switch (elf_header.e_machine)
6370 case EM_MIPS_RS3_LE:
6371 dynamic_section_mips_val (entry);
6374 dynamic_section_parisc_val (entry);
6377 dynamic_section_ia64_val (entry);
6380 print_vma (entry->d_un.d_val, PREFIX_HEX);
6392 get_ver_flags (unsigned int flags)
6394 static char buff[32];
6401 if (flags & VER_FLG_BASE)
6402 strcat (buff, "BASE ");
6404 if (flags & VER_FLG_WEAK)
6406 if (flags & VER_FLG_BASE)
6407 strcat (buff, "| ");
6409 strcat (buff, "WEAK ");
6412 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK))
6413 strcat (buff, "| <unknown>");
6418 /* Display the contents of the version sections. */
6420 process_version_sections (FILE *file)
6422 Elf_Internal_Shdr *section;
6429 for (i = 0, section = section_headers;
6430 i < elf_header.e_shnum;
6433 switch (section->sh_type)
6435 case SHT_GNU_verdef:
6437 Elf_External_Verdef *edefs;
6444 (_("\nVersion definition section '%s' contains %ld entries:\n"),
6445 SECTION_NAME (section), section->sh_info);
6447 printf (_(" Addr: 0x"));
6448 printf_vma (section->sh_addr);
6449 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
6450 (unsigned long) section->sh_offset, section->sh_link,
6451 SECTION_HEADER_INDEX (section->sh_link)
6452 < elf_header.e_shnum
6453 ? SECTION_NAME (SECTION_HEADER (section->sh_link))
6456 edefs = get_data (NULL, file, section->sh_offset, 1,
6458 _("version definition section"));
6462 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
6465 Elf_External_Verdef *edef;
6466 Elf_Internal_Verdef ent;
6467 Elf_External_Verdaux *eaux;
6468 Elf_Internal_Verdaux aux;
6472 vstart = ((char *) edefs) + idx;
6474 edef = (Elf_External_Verdef *) vstart;
6476 ent.vd_version = BYTE_GET (edef->vd_version);
6477 ent.vd_flags = BYTE_GET (edef->vd_flags);
6478 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
6479 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
6480 ent.vd_hash = BYTE_GET (edef->vd_hash);
6481 ent.vd_aux = BYTE_GET (edef->vd_aux);
6482 ent.vd_next = BYTE_GET (edef->vd_next);
6484 printf (_(" %#06x: Rev: %d Flags: %s"),
6485 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
6487 printf (_(" Index: %d Cnt: %d "),
6488 ent.vd_ndx, ent.vd_cnt);
6490 vstart += ent.vd_aux;
6492 eaux = (Elf_External_Verdaux *) vstart;
6494 aux.vda_name = BYTE_GET (eaux->vda_name);
6495 aux.vda_next = BYTE_GET (eaux->vda_next);
6497 if (VALID_DYNAMIC_NAME (aux.vda_name))
6498 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
6500 printf (_("Name index: %ld\n"), aux.vda_name);
6502 isum = idx + ent.vd_aux;
6504 for (j = 1; j < ent.vd_cnt; j++)
6506 isum += aux.vda_next;
6507 vstart += aux.vda_next;
6509 eaux = (Elf_External_Verdaux *) vstart;
6511 aux.vda_name = BYTE_GET (eaux->vda_name);
6512 aux.vda_next = BYTE_GET (eaux->vda_next);
6514 if (VALID_DYNAMIC_NAME (aux.vda_name))
6515 printf (_(" %#06x: Parent %d: %s\n"),
6516 isum, j, GET_DYNAMIC_NAME (aux.vda_name));
6518 printf (_(" %#06x: Parent %d, name index: %ld\n"),
6519 isum, j, aux.vda_name);
6529 case SHT_GNU_verneed:
6531 Elf_External_Verneed *eneed;
6537 printf (_("\nVersion needs section '%s' contains %ld entries:\n"),
6538 SECTION_NAME (section), section->sh_info);
6540 printf (_(" Addr: 0x"));
6541 printf_vma (section->sh_addr);
6542 printf (_(" Offset: %#08lx Link to section: %ld (%s)\n"),
6543 (unsigned long) section->sh_offset, section->sh_link,
6544 SECTION_HEADER_INDEX (section->sh_link)
6545 < elf_header.e_shnum
6546 ? SECTION_NAME (SECTION_HEADER (section->sh_link))
6549 eneed = get_data (NULL, file, section->sh_offset, 1,
6551 _("version need section"));
6555 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
6557 Elf_External_Verneed *entry;
6558 Elf_Internal_Verneed ent;
6563 vstart = ((char *) eneed) + idx;
6565 entry = (Elf_External_Verneed *) vstart;
6567 ent.vn_version = BYTE_GET (entry->vn_version);
6568 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
6569 ent.vn_file = BYTE_GET (entry->vn_file);
6570 ent.vn_aux = BYTE_GET (entry->vn_aux);
6571 ent.vn_next = BYTE_GET (entry->vn_next);
6573 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
6575 if (VALID_DYNAMIC_NAME (ent.vn_file))
6576 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
6578 printf (_(" File: %lx"), ent.vn_file);
6580 printf (_(" Cnt: %d\n"), ent.vn_cnt);
6582 vstart += ent.vn_aux;
6584 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
6586 Elf_External_Vernaux *eaux;
6587 Elf_Internal_Vernaux aux;
6589 eaux = (Elf_External_Vernaux *) vstart;
6591 aux.vna_hash = BYTE_GET (eaux->vna_hash);
6592 aux.vna_flags = BYTE_GET (eaux->vna_flags);
6593 aux.vna_other = BYTE_GET (eaux->vna_other);
6594 aux.vna_name = BYTE_GET (eaux->vna_name);
6595 aux.vna_next = BYTE_GET (eaux->vna_next);
6597 if (VALID_DYNAMIC_NAME (aux.vna_name))
6598 printf (_(" %#06x: Name: %s"),
6599 isum, GET_DYNAMIC_NAME (aux.vna_name));
6601 printf (_(" %#06x: Name index: %lx"),
6602 isum, aux.vna_name);
6604 printf (_(" Flags: %s Version: %d\n"),
6605 get_ver_flags (aux.vna_flags), aux.vna_other);
6607 isum += aux.vna_next;
6608 vstart += aux.vna_next;
6618 case SHT_GNU_versym:
6620 Elf_Internal_Shdr *link_section;
6623 unsigned char *edata;
6624 unsigned short *data;
6626 Elf_Internal_Sym *symbols;
6627 Elf_Internal_Shdr *string_sec;
6630 if (SECTION_HEADER_INDEX (section->sh_link) >= elf_header.e_shnum)
6633 link_section = SECTION_HEADER (section->sh_link);
6634 total = section->sh_size / sizeof (Elf_External_Versym);
6636 if (SECTION_HEADER_INDEX (link_section->sh_link)
6637 >= elf_header.e_shnum)
6642 symbols = GET_ELF_SYMBOLS (file, link_section);
6644 string_sec = SECTION_HEADER (link_section->sh_link);
6646 strtab = get_data (NULL, file, string_sec->sh_offset, 1,
6647 string_sec->sh_size, _("version string table"));
6651 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
6652 SECTION_NAME (section), total);
6654 printf (_(" Addr: "));
6655 printf_vma (section->sh_addr);
6656 printf (_(" Offset: %#08lx Link: %lx (%s)\n"),
6657 (unsigned long) section->sh_offset, section->sh_link,
6658 SECTION_NAME (link_section));
6660 off = offset_from_vma (file,
6661 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
6662 total * sizeof (short));
6663 edata = get_data (NULL, file, off, total, sizeof (short),
6664 _("version symbol data"));
6671 data = cmalloc (total, sizeof (short));
6673 for (cnt = total; cnt --;)
6674 data[cnt] = byte_get (edata + cnt * sizeof (short),
6679 for (cnt = 0; cnt < total; cnt += 4)
6682 int check_def, check_need;
6685 printf (" %03x:", cnt);
6687 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
6688 switch (data[cnt + j])
6691 fputs (_(" 0 (*local*) "), stdout);
6695 fputs (_(" 1 (*global*) "), stdout);
6699 nn = printf ("%4x%c", data[cnt + j] & 0x7fff,
6700 data[cnt + j] & 0x8000 ? 'h' : ' ');
6704 if (SECTION_HEADER_INDEX (symbols[cnt + j].st_shndx)
6705 >= elf_header.e_shnum
6706 || SECTION_HEADER (symbols[cnt + j].st_shndx)->sh_type
6709 if (symbols[cnt + j].st_shndx == SHN_UNDEF)
6716 && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
6718 Elf_Internal_Verneed ivn;
6719 unsigned long offset;
6721 offset = offset_from_vma
6722 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
6723 sizeof (Elf_External_Verneed));
6727 Elf_Internal_Vernaux ivna;
6728 Elf_External_Verneed evn;
6729 Elf_External_Vernaux evna;
6730 unsigned long a_off;
6732 get_data (&evn, file, offset, sizeof (evn), 1,
6735 ivn.vn_aux = BYTE_GET (evn.vn_aux);
6736 ivn.vn_next = BYTE_GET (evn.vn_next);
6738 a_off = offset + ivn.vn_aux;
6742 get_data (&evna, file, a_off, sizeof (evna),
6743 1, _("version need aux (2)"));
6745 ivna.vna_next = BYTE_GET (evna.vna_next);
6746 ivna.vna_other = BYTE_GET (evna.vna_other);
6748 a_off += ivna.vna_next;
6750 while (ivna.vna_other != data[cnt + j]
6751 && ivna.vna_next != 0);
6753 if (ivna.vna_other == data[cnt + j])
6755 ivna.vna_name = BYTE_GET (evna.vna_name);
6757 name = strtab + ivna.vna_name;
6758 nn += printf ("(%s%-*s",
6760 12 - (int) strlen (name),
6766 offset += ivn.vn_next;
6768 while (ivn.vn_next);
6771 if (check_def && data[cnt + j] != 0x8001
6772 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
6774 Elf_Internal_Verdef ivd;
6775 Elf_External_Verdef evd;
6776 unsigned long offset;
6778 offset = offset_from_vma
6779 (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
6784 get_data (&evd, file, offset, sizeof (evd), 1,
6787 ivd.vd_next = BYTE_GET (evd.vd_next);
6788 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
6790 offset += ivd.vd_next;
6792 while (ivd.vd_ndx != (data[cnt + j] & 0x7fff)
6793 && ivd.vd_next != 0);
6795 if (ivd.vd_ndx == (data[cnt + j] & 0x7fff))
6797 Elf_External_Verdaux evda;
6798 Elf_Internal_Verdaux ivda;
6800 ivd.vd_aux = BYTE_GET (evd.vd_aux);
6802 get_data (&evda, file,
6803 offset - ivd.vd_next + ivd.vd_aux,
6805 _("version def aux"));
6807 ivda.vda_name = BYTE_GET (evda.vda_name);
6809 name = strtab + ivda.vda_name;
6810 nn += printf ("(%s%-*s",
6812 12 - (int) strlen (name),
6818 printf ("%*c", 18 - nn, ' ');
6836 printf (_("\nNo version information found in this file.\n"));
6842 get_symbol_binding (unsigned int binding)
6844 static char buff[32];
6848 case STB_LOCAL: return "LOCAL";
6849 case STB_GLOBAL: return "GLOBAL";
6850 case STB_WEAK: return "WEAK";
6852 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
6853 snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
6855 else if (binding >= STB_LOOS && binding <= STB_HIOS)
6856 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
6858 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
6864 get_symbol_type (unsigned int type)
6866 static char buff[32];
6870 case STT_NOTYPE: return "NOTYPE";
6871 case STT_OBJECT: return "OBJECT";
6872 case STT_FUNC: return "FUNC";
6873 case STT_SECTION: return "SECTION";
6874 case STT_FILE: return "FILE";
6875 case STT_COMMON: return "COMMON";
6876 case STT_TLS: return "TLS";
6877 case STT_RELC: return "RELC";
6878 case STT_SRELC: return "SRELC";
6880 if (type >= STT_LOPROC && type <= STT_HIPROC)
6882 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
6883 return "THUMB_FUNC";
6885 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
6888 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
6889 return "PARISC_MILLI";
6891 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
6893 else if (type >= STT_LOOS && type <= STT_HIOS)
6895 if (elf_header.e_machine == EM_PARISC)
6897 if (type == STT_HP_OPAQUE)
6899 if (type == STT_HP_STUB)
6903 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
6906 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
6912 get_symbol_visibility (unsigned int visibility)
6916 case STV_DEFAULT: return "DEFAULT";
6917 case STV_INTERNAL: return "INTERNAL";
6918 case STV_HIDDEN: return "HIDDEN";
6919 case STV_PROTECTED: return "PROTECTED";
6925 get_mips_symbol_other (unsigned int other)
6929 case STO_OPTIONAL: return "OPTIONAL";
6930 case STO_MIPS16: return "MIPS16";
6931 default: return NULL;
6936 get_symbol_other (unsigned int other)
6938 const char * result = NULL;
6939 static char buff [32];
6944 switch (elf_header.e_machine)
6947 result = get_mips_symbol_other (other);
6955 snprintf (buff, sizeof buff, _("<other>: %x"), other);
6960 get_symbol_index_type (unsigned int type)
6962 static char buff[32];
6966 case SHN_UNDEF: return "UND";
6967 case SHN_ABS: return "ABS";
6968 case SHN_COMMON: return "COM";
6970 if (type == SHN_IA_64_ANSI_COMMON
6971 && elf_header.e_machine == EM_IA_64
6972 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
6974 else if (elf_header.e_machine == EM_X86_64
6975 && type == SHN_X86_64_LCOMMON)
6977 else if (type == SHN_MIPS_SCOMMON
6978 && elf_header.e_machine == EM_MIPS)
6980 else if (type == SHN_MIPS_SUNDEFINED
6981 && elf_header.e_machine == EM_MIPS)
6983 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
6984 sprintf (buff, "PRC[0x%04x]", type);
6985 else if (type >= SHN_LOOS && type <= SHN_HIOS)
6986 sprintf (buff, "OS [0x%04x]", type);
6987 else if (type >= SHN_LORESERVE && type <= SHN_HIRESERVE)
6988 sprintf (buff, "RSV[0x%04x]", type);
6990 sprintf (buff, "%3d", type);
6998 get_dynamic_data (FILE *file, unsigned int number, unsigned int ent_size)
7000 unsigned char *e_data;
7003 e_data = cmalloc (number, ent_size);
7007 error (_("Out of memory\n"));
7011 if (fread (e_data, ent_size, number, file) != number)
7013 error (_("Unable to read in dynamic data\n"));
7017 i_data = cmalloc (number, sizeof (*i_data));
7021 error (_("Out of memory\n"));
7027 i_data[number] = byte_get (e_data + number * ent_size, ent_size);
7034 /* Dump the symbol table. */
7036 process_symbol_table (FILE *file)
7038 Elf_Internal_Shdr *section;
7039 bfd_vma nbuckets = 0;
7040 bfd_vma nchains = 0;
7041 bfd_vma *buckets = NULL;
7042 bfd_vma *chains = NULL;
7043 bfd_vma ngnubuckets = 0;
7044 bfd_vma *gnubuckets = NULL;
7045 bfd_vma *gnuchains = NULL;
7047 if (! do_syms && !do_histogram)
7050 if (dynamic_info[DT_HASH] && ((do_using_dynamic && dynamic_strings != NULL)
7053 unsigned char nb[8];
7054 unsigned char nc[8];
7055 int hash_ent_size = 4;
7057 if ((elf_header.e_machine == EM_ALPHA
7058 || elf_header.e_machine == EM_S390
7059 || elf_header.e_machine == EM_S390_OLD)
7060 && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
7064 (archive_file_offset
7065 + offset_from_vma (file, dynamic_info[DT_HASH],
7066 sizeof nb + sizeof nc)),
7069 error (_("Unable to seek to start of dynamic information\n"));
7073 if (fread (nb, hash_ent_size, 1, file) != 1)
7075 error (_("Failed to read in number of buckets\n"));
7079 if (fread (nc, hash_ent_size, 1, file) != 1)
7081 error (_("Failed to read in number of chains\n"));
7085 nbuckets = byte_get (nb, hash_ent_size);
7086 nchains = byte_get (nc, hash_ent_size);
7088 buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
7089 chains = get_dynamic_data (file, nchains, hash_ent_size);
7091 if (buckets == NULL || chains == NULL)
7096 && dynamic_info[DT_HASH] && do_using_dynamic && dynamic_strings != NULL)
7101 printf (_("\nSymbol table for image:\n"));
7103 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7105 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7107 for (hn = 0; hn < nbuckets; hn++)
7112 for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
7114 Elf_Internal_Sym *psym;
7117 psym = dynamic_symbols + si;
7119 n = print_vma (si, DEC_5);
7121 fputs (" " + n, stdout);
7122 printf (" %3lu: ", hn);
7123 print_vma (psym->st_value, LONG_HEX);
7125 print_vma (psym->st_size, DEC_5);
7127 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
7128 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
7129 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
7130 /* Check to see if any other bits in the st_other field are set.
7131 Note - displaying this information disrupts the layout of the
7132 table being generated, but for the moment this case is very rare. */
7133 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
7134 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
7135 printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
7136 if (VALID_DYNAMIC_NAME (psym->st_name))
7137 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
7139 printf (" <corrupt: %14ld>", psym->st_name);
7144 else if (do_syms && !do_using_dynamic)
7148 for (i = 0, section = section_headers;
7149 i < elf_header.e_shnum;
7153 char *strtab = NULL;
7154 unsigned long int strtab_size = 0;
7155 Elf_Internal_Sym *symtab;
7156 Elf_Internal_Sym *psym;
7159 if ( section->sh_type != SHT_SYMTAB
7160 && section->sh_type != SHT_DYNSYM)
7163 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
7164 SECTION_NAME (section),
7165 (unsigned long) (section->sh_size / section->sh_entsize));
7167 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
7169 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
7171 symtab = GET_ELF_SYMBOLS (file, section);
7175 if (section->sh_link == elf_header.e_shstrndx)
7177 strtab = string_table;
7178 strtab_size = string_table_length;
7180 else if (SECTION_HEADER_INDEX (section->sh_link) < elf_header.e_shnum)
7182 Elf_Internal_Shdr *string_sec;
7184 string_sec = SECTION_HEADER (section->sh_link);
7186 strtab = get_data (NULL, file, string_sec->sh_offset,
7187 1, string_sec->sh_size, _("string table"));
7188 strtab_size = strtab != NULL ? string_sec->sh_size : 0;
7191 for (si = 0, psym = symtab;
7192 si < section->sh_size / section->sh_entsize;
7195 printf ("%6d: ", si);
7196 print_vma (psym->st_value, LONG_HEX);
7198 print_vma (psym->st_size, DEC_5);
7199 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
7200 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
7201 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
7202 /* Check to see if any other bits in the st_other field are set.
7203 Note - displaying this information disrupts the layout of the
7204 table being generated, but for the moment this case is very rare. */
7205 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
7206 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
7207 printf (" %4s ", get_symbol_index_type (psym->st_shndx));
7208 print_symbol (25, psym->st_name < strtab_size
7209 ? strtab + psym->st_name : "<corrupt>");
7211 if (section->sh_type == SHT_DYNSYM &&
7212 version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
7214 unsigned char data[2];
7215 unsigned short vers_data;
7216 unsigned long offset;
7220 offset = offset_from_vma
7221 (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
7222 sizeof data + si * sizeof (vers_data));
7224 get_data (&data, file, offset + si * sizeof (vers_data),
7225 sizeof (data), 1, _("version data"));
7227 vers_data = byte_get (data, 2);
7229 is_nobits = (SECTION_HEADER_INDEX (psym->st_shndx)
7230 < elf_header.e_shnum
7231 && SECTION_HEADER (psym->st_shndx)->sh_type
7234 check_def = (psym->st_shndx != SHN_UNDEF);
7236 if ((vers_data & 0x8000) || vers_data > 1)
7238 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
7239 && (is_nobits || ! check_def))
7241 Elf_External_Verneed evn;
7242 Elf_Internal_Verneed ivn;
7243 Elf_Internal_Vernaux ivna;
7245 /* We must test both. */
7246 offset = offset_from_vma
7247 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
7252 unsigned long vna_off;
7254 get_data (&evn, file, offset, sizeof (evn), 1,
7257 ivn.vn_aux = BYTE_GET (evn.vn_aux);
7258 ivn.vn_next = BYTE_GET (evn.vn_next);
7260 vna_off = offset + ivn.vn_aux;
7264 Elf_External_Vernaux evna;
7266 get_data (&evna, file, vna_off,
7268 _("version need aux (3)"));
7270 ivna.vna_other = BYTE_GET (evna.vna_other);
7271 ivna.vna_next = BYTE_GET (evna.vna_next);
7272 ivna.vna_name = BYTE_GET (evna.vna_name);
7274 vna_off += ivna.vna_next;
7276 while (ivna.vna_other != vers_data
7277 && ivna.vna_next != 0);
7279 if (ivna.vna_other == vers_data)
7282 offset += ivn.vn_next;
7284 while (ivn.vn_next != 0);
7286 if (ivna.vna_other == vers_data)
7289 ivna.vna_name < strtab_size
7290 ? strtab + ivna.vna_name : "<corrupt>",
7294 else if (! is_nobits)
7295 error (_("bad dynamic symbol\n"));
7302 if (vers_data != 0x8001
7303 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
7305 Elf_Internal_Verdef ivd;
7306 Elf_Internal_Verdaux ivda;
7307 Elf_External_Verdaux evda;
7308 unsigned long offset;
7310 offset = offset_from_vma
7312 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
7313 sizeof (Elf_External_Verdef));
7317 Elf_External_Verdef evd;
7319 get_data (&evd, file, offset, sizeof (evd),
7320 1, _("version def"));
7322 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
7323 ivd.vd_aux = BYTE_GET (evd.vd_aux);
7324 ivd.vd_next = BYTE_GET (evd.vd_next);
7326 offset += ivd.vd_next;
7328 while (ivd.vd_ndx != (vers_data & 0x7fff)
7329 && ivd.vd_next != 0);
7331 offset -= ivd.vd_next;
7332 offset += ivd.vd_aux;
7334 get_data (&evda, file, offset, sizeof (evda),
7335 1, _("version def aux"));
7337 ivda.vda_name = BYTE_GET (evda.vda_name);
7339 if (psym->st_name != ivda.vda_name)
7340 printf ((vers_data & 0x8000)
7342 ivda.vda_name < strtab_size
7343 ? strtab + ivda.vda_name : "<corrupt>");
7353 if (strtab != string_table)
7359 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
7361 if (do_histogram && buckets != NULL)
7363 unsigned long *lengths;
7364 unsigned long *counts;
7367 unsigned long maxlength = 0;
7368 unsigned long nzero_counts = 0;
7369 unsigned long nsyms = 0;
7371 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
7372 (unsigned long) nbuckets);
7373 printf (_(" Length Number %% of total Coverage\n"));
7375 lengths = calloc (nbuckets, sizeof (*lengths));
7376 if (lengths == NULL)
7378 error (_("Out of memory\n"));
7381 for (hn = 0; hn < nbuckets; ++hn)
7383 for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
7386 if (maxlength < ++lengths[hn])
7391 counts = calloc (maxlength + 1, sizeof (*counts));
7394 error (_("Out of memory\n"));
7398 for (hn = 0; hn < nbuckets; ++hn)
7399 ++counts[lengths[hn]];
7404 printf (" 0 %-10lu (%5.1f%%)\n",
7405 counts[0], (counts[0] * 100.0) / nbuckets);
7406 for (i = 1; i <= maxlength; ++i)
7408 nzero_counts += counts[i] * i;
7409 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
7410 i, counts[i], (counts[i] * 100.0) / nbuckets,
7411 (nzero_counts * 100.0) / nsyms);
7419 if (buckets != NULL)
7425 if (do_histogram && dynamic_info_DT_GNU_HASH)
7427 unsigned char nb[16];
7428 bfd_vma i, maxchain = 0xffffffff, symidx, bitmaskwords;
7429 unsigned long *lengths;
7430 unsigned long *counts;
7432 unsigned long maxlength = 0;
7433 unsigned long nzero_counts = 0;
7434 unsigned long nsyms = 0;
7435 bfd_vma buckets_vma;
7438 (archive_file_offset
7439 + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
7443 error (_("Unable to seek to start of dynamic information\n"));
7447 if (fread (nb, 16, 1, file) != 1)
7449 error (_("Failed to read in number of buckets\n"));
7453 ngnubuckets = byte_get (nb, 4);
7454 symidx = byte_get (nb + 4, 4);
7455 bitmaskwords = byte_get (nb + 8, 4);
7456 buckets_vma = dynamic_info_DT_GNU_HASH + 16;
7458 buckets_vma += bitmaskwords * 4;
7460 buckets_vma += bitmaskwords * 8;
7463 (archive_file_offset
7464 + offset_from_vma (file, buckets_vma, 4)),
7467 error (_("Unable to seek to start of dynamic information\n"));
7471 gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
7473 if (gnubuckets == NULL)
7476 for (i = 0; i < ngnubuckets; i++)
7477 if (gnubuckets[i] != 0)
7479 if (gnubuckets[i] < symidx)
7482 if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
7483 maxchain = gnubuckets[i];
7486 if (maxchain == 0xffffffff)
7492 (archive_file_offset
7493 + offset_from_vma (file, buckets_vma
7494 + 4 * (ngnubuckets + maxchain), 4)),
7497 error (_("Unable to seek to start of dynamic information\n"));
7503 if (fread (nb, 4, 1, file) != 1)
7505 error (_("Failed to determine last chain length\n"));
7509 if (maxchain + 1 == 0)
7514 while ((byte_get (nb, 4) & 1) == 0);
7517 (archive_file_offset
7518 + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
7521 error (_("Unable to seek to start of dynamic information\n"));
7525 gnuchains = get_dynamic_data (file, maxchain, 4);
7527 if (gnuchains == NULL)
7530 lengths = calloc (ngnubuckets, sizeof (*lengths));
7531 if (lengths == NULL)
7533 error (_("Out of memory\n"));
7537 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
7538 (unsigned long) ngnubuckets);
7539 printf (_(" Length Number %% of total Coverage\n"));
7541 for (hn = 0; hn < ngnubuckets; ++hn)
7542 if (gnubuckets[hn] != 0)
7544 bfd_vma off, length = 1;
7546 for (off = gnubuckets[hn] - symidx;
7547 (gnuchains[off] & 1) == 0; ++off)
7549 lengths[hn] = length;
7550 if (length > maxlength)
7555 counts = calloc (maxlength + 1, sizeof (*counts));
7558 error (_("Out of memory\n"));
7562 for (hn = 0; hn < ngnubuckets; ++hn)
7563 ++counts[lengths[hn]];
7565 if (ngnubuckets > 0)
7568 printf (" 0 %-10lu (%5.1f%%)\n",
7569 counts[0], (counts[0] * 100.0) / ngnubuckets);
7570 for (j = 1; j <= maxlength; ++j)
7572 nzero_counts += counts[j] * j;
7573 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
7574 j, counts[j], (counts[j] * 100.0) / ngnubuckets,
7575 (nzero_counts * 100.0) / nsyms);
7589 process_syminfo (FILE *file ATTRIBUTE_UNUSED)
7593 if (dynamic_syminfo == NULL
7595 /* No syminfo, this is ok. */
7598 /* There better should be a dynamic symbol section. */
7599 if (dynamic_symbols == NULL || dynamic_strings == NULL)
7603 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
7604 dynamic_syminfo_offset, dynamic_syminfo_nent);
7606 printf (_(" Num: Name BoundTo Flags\n"));
7607 for (i = 0; i < dynamic_syminfo_nent; ++i)
7609 unsigned short int flags = dynamic_syminfo[i].si_flags;
7611 printf ("%4d: ", i);
7612 if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
7613 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
7615 printf ("<corrupt: %19ld>", dynamic_symbols[i].st_name);
7618 switch (dynamic_syminfo[i].si_boundto)
7620 case SYMINFO_BT_SELF:
7621 fputs ("SELF ", stdout);
7623 case SYMINFO_BT_PARENT:
7624 fputs ("PARENT ", stdout);
7627 if (dynamic_syminfo[i].si_boundto > 0
7628 && dynamic_syminfo[i].si_boundto < dynamic_nent
7629 && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
7631 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
7635 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
7639 if (flags & SYMINFO_FLG_DIRECT)
7641 if (flags & SYMINFO_FLG_PASSTHRU)
7642 printf (" PASSTHRU");
7643 if (flags & SYMINFO_FLG_COPY)
7645 if (flags & SYMINFO_FLG_LAZYLOAD)
7646 printf (" LAZYLOAD");
7654 #ifdef SUPPORT_DISASSEMBLY
7656 disassemble_section (Elf_Internal_Shdr *section, FILE *file)
7658 printf (_("\nAssembly dump of section %s\n"),
7659 SECTION_NAME (section));
7661 /* XXX -- to be done --- XXX */
7668 dump_section (Elf_Internal_Shdr *section, FILE *file)
7670 Elf_Internal_Shdr *relsec;
7671 bfd_size_type bytes;
7673 unsigned char *data;
7674 unsigned char *start;
7676 bytes = section->sh_size;
7678 if (bytes == 0 || section->sh_type == SHT_NOBITS)
7680 printf (_("\nSection '%s' has no data to dump.\n"),
7681 SECTION_NAME (section));
7685 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
7687 addr = section->sh_addr;
7689 start = get_data (NULL, file, section->sh_offset, 1, bytes,
7694 /* If the section being dumped has relocations against it the user might
7695 be expecting these relocations to have been applied. Check for this
7696 case and issue a warning message in order to avoid confusion.
7697 FIXME: Maybe we ought to have an option that dumps a section with
7699 for (relsec = section_headers;
7700 relsec < section_headers + elf_header.e_shnum;
7703 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
7704 || SECTION_HEADER_INDEX (relsec->sh_info) >= elf_header.e_shnum
7705 || SECTION_HEADER (relsec->sh_info) != section
7706 || relsec->sh_size == 0
7707 || SECTION_HEADER_INDEX (relsec->sh_link) >= elf_header.e_shnum)
7710 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
7722 lbytes = (bytes > 16 ? 16 : bytes);
7724 printf (" 0x%8.8lx ", (unsigned long) addr);
7726 for (j = 0; j < 16; j++)
7729 printf ("%2.2x", data[j]);
7737 for (j = 0; j < lbytes; j++)
7740 if (k >= ' ' && k < 0x7f)
7759 /* Return the number of bytes affected by a given reloc.
7760 This information is architecture and reloc dependent.
7761 Returns 4 by default, although this is not always correct.
7762 It should return 0 if a decision cannot be made.
7763 FIXME: This is not the correct way to solve this problem.
7764 The proper way is to have target specific reloc sizing functions
7765 created by the reloc-macros.h header, in the same way that it
7766 already creates the reloc naming functions. */
7769 get_reloc_size (Elf_Internal_Rela * reloc)
7771 switch (elf_header.e_machine)
7777 switch (ELF32_R_TYPE (reloc->r_info))
7779 /* PR gas/3800 - without this information we do not correctly
7780 decode the debug information generated by the h8300 assembler. */
7787 /* FIXME: We need to extend this switch statement to cope with other
7788 architecture's relocs. (When those relocs are used against debug
7789 sections, and when their size is not 4). But see the multiple
7790 inclusions of <elf/h8.h> for an example of the hoops that we need
7791 to jump through in order to obtain the reloc numbers. */
7796 /* Apply addends of RELA relocations. */
7799 debug_apply_rela_addends (void *file,
7800 Elf_Internal_Shdr *section,
7801 unsigned char *start)
7803 Elf_Internal_Shdr *relsec;
7804 unsigned char *end = start + section->sh_size;
7806 if (!is_relocatable)
7809 /* SH uses RELA but uses in place value instead of the addend field. */
7810 if (elf_header.e_machine == EM_SH)
7813 for (relsec = section_headers;
7814 relsec < section_headers + elf_header.e_shnum;
7817 unsigned long nrelas;
7818 Elf_Internal_Rela *rela, *rp;
7819 Elf_Internal_Shdr *symsec;
7820 Elf_Internal_Sym *symtab;
7821 Elf_Internal_Sym *sym;
7823 if (relsec->sh_type != SHT_RELA
7824 || SECTION_HEADER_INDEX (relsec->sh_info) >= elf_header.e_shnum
7825 || SECTION_HEADER (relsec->sh_info) != section
7826 || relsec->sh_size == 0
7827 || SECTION_HEADER_INDEX (relsec->sh_link) >= elf_header.e_shnum)
7830 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
7834 symsec = SECTION_HEADER (relsec->sh_link);
7835 symtab = GET_ELF_SYMBOLS (file, symsec);
7837 for (rp = rela; rp < rela + nrelas; ++rp)
7840 unsigned int reloc_size;
7842 reloc_size = get_reloc_size (rp);
7843 if (reloc_size == 0)
7845 warn (_("skipping relocation of unknown size against offset 0x%lx in section %s\n"),
7846 (unsigned long) rp->r_offset,
7847 SECTION_NAME (section));
7851 loc = start + rp->r_offset;
7852 if ((loc + reloc_size) > end)
7854 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
7855 (unsigned long) rp->r_offset,
7856 SECTION_NAME (section));
7862 sym = symtab + ELF32_R_SYM (rp->r_info);
7864 if (ELF32_R_SYM (rp->r_info) != 0
7865 && ELF32_ST_TYPE (sym->st_info) != STT_SECTION
7866 /* Relocations against symbols without type can happen.
7867 Gcc -feliminate-dwarf2-dups may generate symbols
7868 without type for debug info. */
7869 && ELF32_ST_TYPE (sym->st_info) != STT_NOTYPE
7870 /* Relocations against object symbols can happen,
7871 eg when referencing a global array. For an
7872 example of this see the _clz.o binary in libgcc.a. */
7873 && ELF32_ST_TYPE (sym->st_info) != STT_OBJECT)
7875 warn (_("skipping unexpected symbol type %s in relocation in section .rela%s\n"),
7876 get_symbol_type (ELF32_ST_TYPE (sym->st_info)),
7877 SECTION_NAME (section));
7883 /* In MIPS little-endian objects, r_info isn't really a
7884 64-bit little-endian value: it has a 32-bit little-endian
7885 symbol index followed by four individual byte fields.
7886 Reorder INFO accordingly. */
7887 if (elf_header.e_machine == EM_MIPS
7888 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
7889 rp->r_info = (((rp->r_info & 0xffffffff) << 32)
7890 | ((rp->r_info >> 56) & 0xff)
7891 | ((rp->r_info >> 40) & 0xff00)
7892 | ((rp->r_info >> 24) & 0xff0000)
7893 | ((rp->r_info >> 8) & 0xff000000));
7895 sym = symtab + ELF64_R_SYM (rp->r_info);
7897 if (ELF64_R_SYM (rp->r_info) != 0
7898 && ELF64_ST_TYPE (sym->st_info) != STT_SECTION
7899 && ELF64_ST_TYPE (sym->st_info) != STT_NOTYPE
7900 && ELF64_ST_TYPE (sym->st_info) != STT_OBJECT)
7902 warn (_("skipping unexpected symbol type %s in relocation in section .rela.%s\n"),
7903 get_symbol_type (ELF64_ST_TYPE (sym->st_info)),
7904 SECTION_NAME (section));
7909 byte_put (loc, rp->r_addend, reloc_size);
7920 load_debug_section (enum dwarf_section_display_enum debug, void *file)
7922 struct dwarf_section *section = &debug_displays [debug].section;
7923 Elf_Internal_Shdr *sec;
7926 /* If it is already loaded, do nothing. */
7927 if (section->start != NULL)
7930 /* Locate the debug section. */
7931 sec = find_section (section->name);
7935 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
7936 section->address = sec->sh_addr;
7937 section->size = sec->sh_size;
7938 section->start = get_data (NULL, file, sec->sh_offset, 1,
7941 if (debug_displays [debug].relocate)
7942 debug_apply_rela_addends (file, sec, section->start);
7944 return section->start != NULL;
7948 free_debug_section (enum dwarf_section_display_enum debug)
7950 struct dwarf_section *section = &debug_displays [debug].section;
7952 if (section->start == NULL)
7955 free ((char *) section->start);
7956 section->start = NULL;
7957 section->address = 0;
7962 display_debug_section (Elf_Internal_Shdr *section, FILE *file)
7964 char *name = SECTION_NAME (section);
7965 bfd_size_type length;
7967 enum dwarf_section_display_enum i;
7969 length = section->sh_size;
7972 printf (_("\nSection '%s' has no debugging data.\n"), name);
7976 if (const_strneq (name, ".gnu.linkonce.wi."))
7977 name = ".debug_info";
7979 /* See if we know how to display the contents of this section. */
7980 for (i = 0; i < max; i++)
7981 if (streq (debug_displays[i].section.name, name))
7983 struct dwarf_section *sec = &debug_displays [i].section;
7985 if (load_debug_section (i, file))
7987 result &= debug_displays[i].display (sec, file);
7989 if (i != info && i != abbrev)
7990 free_debug_section (i);
7998 printf (_("Unrecognized debug section: %s\n"), name);
8005 /* Set DUMP_SECTS for all sections where dumps were requested
8006 based on section name. */
8009 initialise_dumps_byname (void)
8011 struct dump_list_entry *cur;
8013 for (cur = dump_sects_byname; cur; cur = cur->next)
8018 for (i = 0, any = 0; i < elf_header.e_shnum; i++)
8019 if (streq (SECTION_NAME (section_headers + i), cur->name))
8021 request_dump (i, cur->type);
8026 warn (_("Section '%s' was not dumped because it does not exist!\n"),
8032 process_section_contents (FILE *file)
8034 Elf_Internal_Shdr *section;
8040 initialise_dumps_byname ();
8042 for (i = 0, section = section_headers;
8043 i < elf_header.e_shnum && i < num_dump_sects;
8046 #ifdef SUPPORT_DISASSEMBLY
8047 if (dump_sects[i] & DISASS_DUMP)
8048 disassemble_section (section, file);
8050 if (dump_sects[i] & HEX_DUMP)
8051 dump_section (section, file);
8053 if (dump_sects[i] & DEBUG_DUMP)
8054 display_debug_section (section, file);
8057 /* Check to see if the user requested a
8058 dump of a section that does not exist. */
8059 while (i++ < num_dump_sects)
8061 warn (_("Section %d was not dumped because it does not exist!\n"), i);
8065 process_mips_fpe_exception (int mask)
8070 if (mask & OEX_FPU_INEX)
8071 fputs ("INEX", stdout), first = 0;
8072 if (mask & OEX_FPU_UFLO)
8073 printf ("%sUFLO", first ? "" : "|"), first = 0;
8074 if (mask & OEX_FPU_OFLO)
8075 printf ("%sOFLO", first ? "" : "|"), first = 0;
8076 if (mask & OEX_FPU_DIV0)
8077 printf ("%sDIV0", first ? "" : "|"), first = 0;
8078 if (mask & OEX_FPU_INVAL)
8079 printf ("%sINVAL", first ? "" : "|");
8082 fputs ("0", stdout);
8085 /* ARM EABI attributes section. */
8090 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
8093 } arm_attr_public_tag;
8095 static const char *arm_attr_tag_CPU_arch[] =
8096 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
8098 static const char *arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
8099 static const char *arm_attr_tag_THUMB_ISA_use[] =
8100 {"No", "Thumb-1", "Thumb-2"};
8101 /* FIXME: VFPv3 encoding was extrapolated! */
8102 static const char *arm_attr_tag_VFP_arch[] = {"No", "VFPv1", "VFPv2", "VFPv3"};
8103 static const char *arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1"};
8104 static const char *arm_attr_tag_NEON_arch[] = {"No", "NEONv1"};
8105 static const char *arm_attr_tag_ABI_PCS_config[] =
8106 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
8107 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
8108 static const char *arm_attr_tag_ABI_PCS_R9_use[] =
8109 {"V6", "SB", "TLS", "Unused"};
8110 static const char *arm_attr_tag_ABI_PCS_RW_data[] =
8111 {"Absolute", "PC-relative", "SB-relative", "None"};
8112 static const char *arm_attr_tag_ABI_PCS_RO_DATA[] =
8113 {"Absolute", "PC-relative", "None"};
8114 static const char *arm_attr_tag_ABI_PCS_GOT_use[] =
8115 {"None", "direct", "GOT-indirect"};
8116 static const char *arm_attr_tag_ABI_PCS_wchar_t[] =
8117 {"None", "??? 1", "2", "??? 3", "4"};
8118 static const char *arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
8119 static const char *arm_attr_tag_ABI_FP_denormal[] = {"Unused", "Needed"};
8120 static const char *arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
8121 static const char *arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
8122 static const char *arm_attr_tag_ABI_FP_number_model[] =
8123 {"Unused", "Finite", "RTABI", "IEEE 754"};
8124 static const char *arm_attr_tag_ABI_align8_needed[] = {"No", "Yes", "4-byte"};
8125 static const char *arm_attr_tag_ABI_align8_preserved[] =
8126 {"No", "Yes, except leaf SP", "Yes"};
8127 static const char *arm_attr_tag_ABI_enum_size[] =
8128 {"Unused", "small", "int", "forced to int"};
8129 static const char *arm_attr_tag_ABI_HardFP_use[] =
8130 {"As Tag_VFP_arch", "SP only", "DP only", "SP and DP"};
8131 static const char *arm_attr_tag_ABI_VFP_args[] =
8132 {"AAPCS", "VFP registers", "custom"};
8133 static const char *arm_attr_tag_ABI_WMMX_args[] =
8134 {"AAPCS", "WMMX registers", "custom"};
8135 static const char *arm_attr_tag_ABI_optimization_goals[] =
8136 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
8137 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
8138 static const char *arm_attr_tag_ABI_FP_optimization_goals[] =
8139 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
8140 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
8142 #define LOOKUP(id, name) \
8143 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
8144 static arm_attr_public_tag arm_attr_public_tags[] =
8146 {4, "CPU_raw_name", 1, NULL},
8147 {5, "CPU_name", 1, NULL},
8148 LOOKUP(6, CPU_arch),
8149 {7, "CPU_arch_profile", 0, NULL},
8150 LOOKUP(8, ARM_ISA_use),
8151 LOOKUP(9, THUMB_ISA_use),
8152 LOOKUP(10, VFP_arch),
8153 LOOKUP(11, WMMX_arch),
8154 LOOKUP(12, NEON_arch),
8155 LOOKUP(13, ABI_PCS_config),
8156 LOOKUP(14, ABI_PCS_R9_use),
8157 LOOKUP(15, ABI_PCS_RW_data),
8158 LOOKUP(16, ABI_PCS_RO_DATA),
8159 LOOKUP(17, ABI_PCS_GOT_use),
8160 LOOKUP(18, ABI_PCS_wchar_t),
8161 LOOKUP(19, ABI_FP_rounding),
8162 LOOKUP(20, ABI_FP_denormal),
8163 LOOKUP(21, ABI_FP_exceptions),
8164 LOOKUP(22, ABI_FP_user_exceptions),
8165 LOOKUP(23, ABI_FP_number_model),
8166 LOOKUP(24, ABI_align8_needed),
8167 LOOKUP(25, ABI_align8_preserved),
8168 LOOKUP(26, ABI_enum_size),
8169 LOOKUP(27, ABI_HardFP_use),
8170 LOOKUP(28, ABI_VFP_args),
8171 LOOKUP(29, ABI_WMMX_args),
8172 LOOKUP(30, ABI_optimization_goals),
8173 LOOKUP(31, ABI_FP_optimization_goals),
8174 {32, "compatibility", 0, NULL}
8178 /* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
8181 read_uleb128 (unsigned char *p, unsigned int *plen)
8195 val |= ((unsigned int)c & 0x7f) << shift;
8204 static unsigned char *
8205 display_arm_attribute (unsigned char *p)
8210 arm_attr_public_tag *attr;
8214 tag = read_uleb128 (p, &len);
8217 for (i = 0; i < ARRAY_SIZE(arm_attr_public_tags); i++)
8219 if (arm_attr_public_tags[i].tag == tag)
8221 attr = &arm_attr_public_tags[i];
8228 printf (" Tag_%s: ", attr->name);
8234 case 7: /* Tag_CPU_arch_profile. */
8235 val = read_uleb128 (p, &len);
8239 case 0: printf ("None\n"); break;
8240 case 'A': printf ("Application\n"); break;
8241 case 'R': printf ("Realtime\n"); break;
8242 case 'M': printf ("Microcontroller\n"); break;
8243 default: printf ("??? (%d)\n", val); break;
8247 case 32: /* Tag_compatibility. */
8248 val = read_uleb128 (p, &len);
8250 printf ("flag = %d, vendor = %s\n", val, p);
8251 p += strlen((char *)p) + 1;
8265 assert (attr->type & 0x80);
8266 val = read_uleb128 (p, &len);
8268 type = attr->type & 0x7f;
8270 printf ("??? (%d)\n", val);
8272 printf ("%s\n", attr->table[val]);
8279 type = 1; /* String. */
8281 type = 2; /* uleb128. */
8282 printf (" Tag_unknown_%d: ", tag);
8287 printf ("\"%s\"\n", p);
8288 p += strlen((char *)p) + 1;
8292 val = read_uleb128 (p, &len);
8294 printf ("%d (0x%x)\n", val, val);
8301 static unsigned char *
8302 display_gnu_attribute (unsigned char *p,
8303 unsigned char *(*display_proc_gnu_attribute)
8304 (unsigned char *, int))
8311 tag = read_uleb128 (p, &len);
8314 /* Tag_compatibility is the only generic GNU attribute defined at
8318 val = read_uleb128 (p, &len);
8320 printf ("flag = %d, vendor = %s\n", val, p);
8321 p += strlen((char *)p) + 1;
8325 if ((tag & 2) == 0 && display_proc_gnu_attribute)
8326 return display_proc_gnu_attribute (p, tag);
8329 type = 1; /* String. */
8331 type = 2; /* uleb128. */
8332 printf (" Tag_unknown_%d: ", tag);
8336 printf ("\"%s\"\n", p);
8337 p += strlen ((char *)p) + 1;
8341 val = read_uleb128 (p, &len);
8343 printf ("%d (0x%x)\n", val, val);
8349 static unsigned char *
8350 display_power_gnu_attribute (unsigned char *p, int tag)
8356 if (tag == Tag_GNU_Power_ABI_FP)
8358 val = read_uleb128 (p, &len);
8360 printf (" Tag_GNU_Power_ABI_FP: ");
8364 printf ("Hard or soft float\n");
8367 printf ("Hard float\n");
8370 printf ("Soft float\n");
8373 printf ("??? (%d)\n", val);
8380 type = 1; /* String. */
8382 type = 2; /* uleb128. */
8383 printf (" Tag_unknown_%d: ", tag);
8387 printf ("\"%s\"\n", p);
8388 p += strlen ((char *)p) + 1;
8392 val = read_uleb128 (p, &len);
8394 printf ("%d (0x%x)\n", val, val);
8400 static unsigned char *
8401 display_mips_gnu_attribute (unsigned char *p, int tag)
8407 if (tag == Tag_GNU_MIPS_ABI_FP)
8409 val = read_uleb128 (p, &len);
8411 printf (" Tag_GNU_MIPS_ABI_FP: ");
8415 printf ("Hard or soft float\n");
8418 printf ("Hard float (-mdouble-float)\n");
8421 printf ("Hard float (-msingle-float)\n");
8424 printf ("Soft float\n");
8427 printf ("??? (%d)\n", val);
8434 type = 1; /* String. */
8436 type = 2; /* uleb128. */
8437 printf (" Tag_unknown_%d: ", tag);
8441 printf ("\"%s\"\n", p);
8442 p += strlen ((char *)p) + 1;
8446 val = read_uleb128 (p, &len);
8448 printf ("%d (0x%x)\n", val, val);
8455 process_attributes (FILE *file, const char *public_name,
8456 unsigned int proc_type,
8457 unsigned char *(*display_pub_attribute) (unsigned char *),
8458 unsigned char *(*display_proc_gnu_attribute)
8459 (unsigned char *, int))
8461 Elf_Internal_Shdr *sect;
8462 unsigned char *contents;
8465 bfd_vma section_len;
8469 /* Find the section header so that we get the size. */
8470 for (i = 0, sect = section_headers;
8471 i < elf_header.e_shnum;
8474 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
8477 contents = get_data (NULL, file, sect->sh_offset, 1, sect->sh_size,
8485 len = sect->sh_size - 1;
8490 bfd_boolean public_section;
8491 bfd_boolean gnu_section;
8493 section_len = byte_get (p, 4);
8495 if (section_len > len)
8497 printf (_("ERROR: Bad section length (%d > %d)\n"),
8498 (int)section_len, (int)len);
8502 printf ("Attribute Section: %s\n", p);
8503 if (public_name && strcmp ((char *)p, public_name) == 0)
8504 public_section = TRUE;
8506 public_section = FALSE;
8507 if (strcmp ((char *)p, "gnu") == 0)
8510 gnu_section = FALSE;
8511 namelen = strlen ((char *)p) + 1;
8513 section_len -= namelen + 4;
8514 while (section_len > 0)
8519 size = byte_get (p, 4);
8520 if (size > section_len)
8522 printf (_("ERROR: Bad subsection length (%d > %d)\n"),
8523 (int)size, (int)section_len);
8526 section_len -= size;
8532 printf ("File Attributes\n");
8535 printf ("Section Attributes:");
8538 printf ("Symbol Attributes:");
8543 val = read_uleb128 (p, &i);
8547 printf (" %d", val);
8552 printf ("Unknown tag: %d\n", tag);
8553 public_section = FALSE;
8559 p = display_pub_attribute (p);
8561 else if (gnu_section)
8564 p = display_gnu_attribute (p,
8565 display_proc_gnu_attribute);
8569 /* ??? Do something sensible, like dump hex. */
8570 printf (" Unknown section contexts\n");
8578 printf (_("Unknown format '%c'\n"), *p);
8587 process_arm_specific (FILE *file)
8589 return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
8590 display_arm_attribute, NULL);
8594 process_power_specific (FILE *file)
8596 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
8597 display_power_gnu_attribute);
8601 process_mips_specific (FILE *file)
8603 Elf_Internal_Dyn *entry;
8604 size_t liblist_offset = 0;
8605 size_t liblistno = 0;
8606 size_t conflictsno = 0;
8607 size_t options_offset = 0;
8608 size_t conflicts_offset = 0;
8610 process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
8611 display_mips_gnu_attribute);
8613 /* We have a lot of special sections. Thanks SGI! */
8614 if (dynamic_section == NULL)
8615 /* No information available. */
8618 for (entry = dynamic_section; entry->d_tag != DT_NULL; ++entry)
8619 switch (entry->d_tag)
8621 case DT_MIPS_LIBLIST:
8623 = offset_from_vma (file, entry->d_un.d_val,
8624 liblistno * sizeof (Elf32_External_Lib));
8626 case DT_MIPS_LIBLISTNO:
8627 liblistno = entry->d_un.d_val;
8629 case DT_MIPS_OPTIONS:
8630 options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
8632 case DT_MIPS_CONFLICT:
8634 = offset_from_vma (file, entry->d_un.d_val,
8635 conflictsno * sizeof (Elf32_External_Conflict));
8637 case DT_MIPS_CONFLICTNO:
8638 conflictsno = entry->d_un.d_val;
8644 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
8646 Elf32_External_Lib *elib;
8649 elib = get_data (NULL, file, liblist_offset,
8650 liblistno, sizeof (Elf32_External_Lib),
8654 printf ("\nSection '.liblist' contains %lu entries:\n",
8655 (unsigned long) liblistno);
8656 fputs (" Library Time Stamp Checksum Version Flags\n",
8659 for (cnt = 0; cnt < liblistno; ++cnt)
8666 liblist.l_name = BYTE_GET (elib[cnt].l_name);
8667 time = BYTE_GET (elib[cnt].l_time_stamp);
8668 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
8669 liblist.l_version = BYTE_GET (elib[cnt].l_version);
8670 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
8672 tmp = gmtime (&time);
8673 snprintf (timebuf, sizeof (timebuf),
8674 "%04u-%02u-%02uT%02u:%02u:%02u",
8675 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
8676 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
8678 printf ("%3lu: ", (unsigned long) cnt);
8679 if (VALID_DYNAMIC_NAME (liblist.l_name))
8680 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
8682 printf ("<corrupt: %9ld>", liblist.l_name);
8683 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
8686 if (liblist.l_flags == 0)
8697 { " EXACT_MATCH", LL_EXACT_MATCH },
8698 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
8699 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
8700 { " EXPORTS", LL_EXPORTS },
8701 { " DELAY_LOAD", LL_DELAY_LOAD },
8702 { " DELTA", LL_DELTA }
8704 int flags = liblist.l_flags;
8708 fcnt < sizeof (l_flags_vals) / sizeof (l_flags_vals[0]);
8710 if ((flags & l_flags_vals[fcnt].bit) != 0)
8712 fputs (l_flags_vals[fcnt].name, stdout);
8713 flags ^= l_flags_vals[fcnt].bit;
8716 printf (" %#x", (unsigned int) flags);
8726 if (options_offset != 0)
8728 Elf_External_Options *eopt;
8729 Elf_Internal_Shdr *sect = section_headers;
8730 Elf_Internal_Options *iopt;
8731 Elf_Internal_Options *option;
8735 /* Find the section header so that we get the size. */
8736 while (sect->sh_type != SHT_MIPS_OPTIONS)
8739 eopt = get_data (NULL, file, options_offset, 1, sect->sh_size,
8743 iopt = cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (*iopt));
8746 error (_("Out of memory\n"));
8753 while (offset < sect->sh_size)
8755 Elf_External_Options *eoption;
8757 eoption = (Elf_External_Options *) ((char *) eopt + offset);
8759 option->kind = BYTE_GET (eoption->kind);
8760 option->size = BYTE_GET (eoption->size);
8761 option->section = BYTE_GET (eoption->section);
8762 option->info = BYTE_GET (eoption->info);
8764 offset += option->size;
8770 printf (_("\nSection '%s' contains %d entries:\n"),
8771 SECTION_NAME (sect), cnt);
8779 switch (option->kind)
8782 /* This shouldn't happen. */
8783 printf (" NULL %d %lx", option->section, option->info);
8786 printf (" REGINFO ");
8787 if (elf_header.e_machine == EM_MIPS)
8790 Elf32_External_RegInfo *ereg;
8791 Elf32_RegInfo reginfo;
8793 ereg = (Elf32_External_RegInfo *) (option + 1);
8794 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
8795 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
8796 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
8797 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
8798 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
8799 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
8801 printf ("GPR %08lx GP 0x%lx\n",
8803 (unsigned long) reginfo.ri_gp_value);
8804 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
8805 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
8806 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
8811 Elf64_External_RegInfo *ereg;
8812 Elf64_Internal_RegInfo reginfo;
8814 ereg = (Elf64_External_RegInfo *) (option + 1);
8815 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
8816 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
8817 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
8818 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
8819 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
8820 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
8822 printf ("GPR %08lx GP 0x",
8823 reginfo.ri_gprmask);
8824 printf_vma (reginfo.ri_gp_value);
8827 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
8828 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
8829 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
8833 case ODK_EXCEPTIONS:
8834 fputs (" EXCEPTIONS fpe_min(", stdout);
8835 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
8836 fputs (") fpe_max(", stdout);
8837 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
8838 fputs (")", stdout);
8840 if (option->info & OEX_PAGE0)
8841 fputs (" PAGE0", stdout);
8842 if (option->info & OEX_SMM)
8843 fputs (" SMM", stdout);
8844 if (option->info & OEX_FPDBUG)
8845 fputs (" FPDBUG", stdout);
8846 if (option->info & OEX_DISMISS)
8847 fputs (" DISMISS", stdout);
8850 fputs (" PAD ", stdout);
8851 if (option->info & OPAD_PREFIX)
8852 fputs (" PREFIX", stdout);
8853 if (option->info & OPAD_POSTFIX)
8854 fputs (" POSTFIX", stdout);
8855 if (option->info & OPAD_SYMBOL)
8856 fputs (" SYMBOL", stdout);
8859 fputs (" HWPATCH ", stdout);
8860 if (option->info & OHW_R4KEOP)
8861 fputs (" R4KEOP", stdout);
8862 if (option->info & OHW_R8KPFETCH)
8863 fputs (" R8KPFETCH", stdout);
8864 if (option->info & OHW_R5KEOP)
8865 fputs (" R5KEOP", stdout);
8866 if (option->info & OHW_R5KCVTL)
8867 fputs (" R5KCVTL", stdout);
8870 fputs (" FILL ", stdout);
8871 /* XXX Print content of info word? */
8874 fputs (" TAGS ", stdout);
8875 /* XXX Print content of info word? */
8878 fputs (" HWAND ", stdout);
8879 if (option->info & OHWA0_R4KEOP_CHECKED)
8880 fputs (" R4KEOP_CHECKED", stdout);
8881 if (option->info & OHWA0_R4KEOP_CLEAN)
8882 fputs (" R4KEOP_CLEAN", stdout);
8885 fputs (" HWOR ", stdout);
8886 if (option->info & OHWA0_R4KEOP_CHECKED)
8887 fputs (" R4KEOP_CHECKED", stdout);
8888 if (option->info & OHWA0_R4KEOP_CLEAN)
8889 fputs (" R4KEOP_CLEAN", stdout);
8892 printf (" GP_GROUP %#06lx self-contained %#06lx",
8893 option->info & OGP_GROUP,
8894 (option->info & OGP_SELF) >> 16);
8897 printf (" IDENT %#06lx self-contained %#06lx",
8898 option->info & OGP_GROUP,
8899 (option->info & OGP_SELF) >> 16);
8902 /* This shouldn't happen. */
8903 printf (" %3d ??? %d %lx",
8904 option->kind, option->section, option->info);
8908 len = sizeof (*eopt);
8909 while (len < option->size)
8910 if (((char *) option)[len] >= ' '
8911 && ((char *) option)[len] < 0x7f)
8912 printf ("%c", ((char *) option)[len++]);
8914 printf ("\\%03o", ((char *) option)[len++]);
8916 fputs ("\n", stdout);
8924 if (conflicts_offset != 0 && conflictsno != 0)
8926 Elf32_Conflict *iconf;
8929 if (dynamic_symbols == NULL)
8931 error (_("conflict list found without a dynamic symbol table\n"));
8935 iconf = cmalloc (conflictsno, sizeof (*iconf));
8938 error (_("Out of memory\n"));
8944 Elf32_External_Conflict *econf32;
8946 econf32 = get_data (NULL, file, conflicts_offset,
8947 conflictsno, sizeof (*econf32), _("conflict"));
8951 for (cnt = 0; cnt < conflictsno; ++cnt)
8952 iconf[cnt] = BYTE_GET (econf32[cnt]);
8958 Elf64_External_Conflict *econf64;
8960 econf64 = get_data (NULL, file, conflicts_offset,
8961 conflictsno, sizeof (*econf64), _("conflict"));
8965 for (cnt = 0; cnt < conflictsno; ++cnt)
8966 iconf[cnt] = BYTE_GET (econf64[cnt]);
8971 printf (_("\nSection '.conflict' contains %lu entries:\n"),
8972 (unsigned long) conflictsno);
8973 puts (_(" Num: Index Value Name"));
8975 for (cnt = 0; cnt < conflictsno; ++cnt)
8977 Elf_Internal_Sym *psym = & dynamic_symbols[iconf[cnt]];
8979 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
8980 print_vma (psym->st_value, FULL_HEX);
8982 if (VALID_DYNAMIC_NAME (psym->st_name))
8983 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
8985 printf ("<corrupt: %14ld>", psym->st_name);
8996 process_gnu_liblist (FILE *file)
8998 Elf_Internal_Shdr *section, *string_sec;
8999 Elf32_External_Lib *elib;
9008 for (i = 0, section = section_headers;
9009 i < elf_header.e_shnum;
9012 switch (section->sh_type)
9014 case SHT_GNU_LIBLIST:
9015 if (SECTION_HEADER_INDEX (section->sh_link) >= elf_header.e_shnum)
9018 elib = get_data (NULL, file, section->sh_offset, 1, section->sh_size,
9023 string_sec = SECTION_HEADER (section->sh_link);
9025 strtab = get_data (NULL, file, string_sec->sh_offset, 1,
9026 string_sec->sh_size, _("liblist string table"));
9027 strtab_size = string_sec->sh_size;
9030 || section->sh_entsize != sizeof (Elf32_External_Lib))
9036 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
9037 SECTION_NAME (section),
9038 (long) (section->sh_size / sizeof (Elf32_External_Lib)));
9040 puts (" Library Time Stamp Checksum Version Flags");
9042 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
9050 liblist.l_name = BYTE_GET (elib[cnt].l_name);
9051 time = BYTE_GET (elib[cnt].l_time_stamp);
9052 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
9053 liblist.l_version = BYTE_GET (elib[cnt].l_version);
9054 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
9056 tmp = gmtime (&time);
9057 snprintf (timebuf, sizeof (timebuf),
9058 "%04u-%02u-%02uT%02u:%02u:%02u",
9059 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9060 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
9062 printf ("%3lu: ", (unsigned long) cnt);
9064 printf ("%-20s", liblist.l_name < strtab_size
9065 ? strtab + liblist.l_name : "<corrupt>");
9067 printf ("%-20.20s", liblist.l_name < strtab_size
9068 ? strtab + liblist.l_name : "<corrupt>");
9069 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
9070 liblist.l_version, liblist.l_flags);
9081 get_note_type (unsigned e_type)
9083 static char buff[64];
9085 if (elf_header.e_type == ET_CORE)
9089 return _("NT_AUXV (auxiliary vector)");
9091 return _("NT_PRSTATUS (prstatus structure)");
9093 return _("NT_FPREGSET (floating point registers)");
9095 return _("NT_PRPSINFO (prpsinfo structure)");
9097 return _("NT_TASKSTRUCT (task structure)");
9099 return _("NT_PRXFPREG (user_xfpregs structure)");
9101 return _("NT_PSTATUS (pstatus structure)");
9103 return _("NT_FPREGS (floating point registers)");
9105 return _("NT_PSINFO (psinfo structure)");
9107 return _("NT_LWPSTATUS (lwpstatus_t structure)");
9109 return _("NT_LWPSINFO (lwpsinfo_t structure)");
9110 case NT_WIN32PSTATUS:
9111 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
9119 return _("NT_VERSION (version)");
9121 return _("NT_ARCH (architecture)");
9126 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
9131 get_netbsd_elfcore_note_type (unsigned e_type)
9133 static char buff[64];
9135 if (e_type == NT_NETBSDCORE_PROCINFO)
9137 /* NetBSD core "procinfo" structure. */
9138 return _("NetBSD procinfo structure");
9141 /* As of Jan 2002 there are no other machine-independent notes
9142 defined for NetBSD core files. If the note type is less
9143 than the start of the machine-dependent note types, we don't
9146 if (e_type < NT_NETBSDCORE_FIRSTMACH)
9148 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
9152 switch (elf_header.e_machine)
9154 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
9155 and PT_GETFPREGS == mach+2. */
9160 case EM_SPARC32PLUS:
9164 case NT_NETBSDCORE_FIRSTMACH+0:
9165 return _("PT_GETREGS (reg structure)");
9166 case NT_NETBSDCORE_FIRSTMACH+2:
9167 return _("PT_GETFPREGS (fpreg structure)");
9173 /* On all other arch's, PT_GETREGS == mach+1 and
9174 PT_GETFPREGS == mach+3. */
9178 case NT_NETBSDCORE_FIRSTMACH+1:
9179 return _("PT_GETREGS (reg structure)");
9180 case NT_NETBSDCORE_FIRSTMACH+3:
9181 return _("PT_GETFPREGS (fpreg structure)");
9187 snprintf (buff, sizeof (buff), _("PT_FIRSTMACH+%d"),
9188 e_type - NT_NETBSDCORE_FIRSTMACH);
9192 /* Note that by the ELF standard, the name field is already null byte
9193 terminated, and namesz includes the terminating null byte.
9194 I.E. the value of namesz for the name "FSF" is 4.
9196 If the value of namesz is zero, there is no name present. */
9198 process_note (Elf_Internal_Note *pnote)
9202 if (pnote->namesz == 0)
9203 /* If there is no note name, then use the default set of
9204 note type strings. */
9205 nt = get_note_type (pnote->type);
9207 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
9208 /* NetBSD-specific core file notes. */
9209 nt = get_netbsd_elfcore_note_type (pnote->type);
9212 /* Don't recognize this note name; just use the default set of
9213 note type strings. */
9214 nt = get_note_type (pnote->type);
9216 printf (" %s\t\t0x%08lx\t%s\n",
9217 pnote->namesz ? pnote->namedata : "(NONE)",
9224 process_corefile_note_segment (FILE *file, bfd_vma offset, bfd_vma length)
9226 Elf_External_Note *pnotes;
9227 Elf_External_Note *external;
9233 pnotes = get_data (NULL, file, offset, 1, length, _("notes"));
9239 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
9240 (unsigned long) offset, (unsigned long) length);
9241 printf (_(" Owner\t\tData size\tDescription\n"));
9243 while (external < (Elf_External_Note *)((char *) pnotes + length))
9245 Elf_External_Note *next;
9246 Elf_Internal_Note inote;
9249 inote.type = BYTE_GET (external->type);
9250 inote.namesz = BYTE_GET (external->namesz);
9251 inote.namedata = external->name;
9252 inote.descsz = BYTE_GET (external->descsz);
9253 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
9254 inote.descpos = offset + (inote.descdata - (char *) pnotes);
9256 next = (Elf_External_Note *)(inote.descdata + align_power (inote.descsz, 2));
9258 if (((char *) next) > (((char *) pnotes) + length))
9260 warn (_("corrupt note found at offset %lx into core notes\n"),
9261 (long)((char *)external - (char *)pnotes));
9262 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
9263 inote.type, inote.namesz, inote.descsz);
9269 /* Verify that name is null terminated. It appears that at least
9270 one version of Linux (RedHat 6.0) generates corefiles that don't
9271 comply with the ELF spec by failing to include the null byte in
9273 if (inote.namedata[inote.namesz] != '\0')
9275 temp = malloc (inote.namesz + 1);
9279 error (_("Out of memory\n"));
9284 strncpy (temp, inote.namedata, inote.namesz);
9285 temp[inote.namesz] = 0;
9287 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
9288 inote.namedata = temp;
9291 res &= process_note (& inote);
9306 process_corefile_note_segments (FILE *file)
9308 Elf_Internal_Phdr *segment;
9312 if (! get_program_headers (file))
9315 for (i = 0, segment = program_headers;
9316 i < elf_header.e_phnum;
9319 if (segment->p_type == PT_NOTE)
9320 res &= process_corefile_note_segment (file,
9321 (bfd_vma) segment->p_offset,
9322 (bfd_vma) segment->p_filesz);
9329 process_note_sections (FILE *file)
9331 Elf_Internal_Shdr *section;
9335 for (i = 0, section = section_headers;
9336 i < elf_header.e_shnum;
9338 if (section->sh_type == SHT_NOTE)
9339 res &= process_corefile_note_segment (file,
9340 (bfd_vma) section->sh_offset,
9341 (bfd_vma) section->sh_size);
9347 process_notes (FILE *file)
9349 /* If we have not been asked to display the notes then do nothing. */
9353 if (elf_header.e_type != ET_CORE)
9354 return process_note_sections (file);
9356 /* No program headers means no NOTE segment. */
9357 if (elf_header.e_phnum > 0)
9358 return process_corefile_note_segments (file);
9360 printf (_("No note segments present in the core file.\n"));
9365 process_arch_specific (FILE *file)
9370 switch (elf_header.e_machine)
9373 return process_arm_specific (file);
9375 case EM_MIPS_RS3_LE:
9376 return process_mips_specific (file);
9379 return process_power_specific (file);
9388 get_file_header (FILE *file)
9390 /* Read in the identity array. */
9391 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
9394 /* Determine how to read the rest of the header. */
9395 switch (elf_header.e_ident[EI_DATA])
9397 default: /* fall through */
9398 case ELFDATANONE: /* fall through */
9400 byte_get = byte_get_little_endian;
9401 byte_put = byte_put_little_endian;
9404 byte_get = byte_get_big_endian;
9405 byte_put = byte_put_big_endian;
9409 /* For now we only support 32 bit and 64 bit ELF files. */
9410 is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
9412 /* Read in the rest of the header. */
9415 Elf32_External_Ehdr ehdr32;
9417 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
9420 elf_header.e_type = BYTE_GET (ehdr32.e_type);
9421 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
9422 elf_header.e_version = BYTE_GET (ehdr32.e_version);
9423 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
9424 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
9425 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
9426 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
9427 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
9428 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
9429 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
9430 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
9431 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
9432 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
9436 Elf64_External_Ehdr ehdr64;
9438 /* If we have been compiled with sizeof (bfd_vma) == 4, then
9439 we will not be able to cope with the 64bit data found in
9440 64 ELF files. Detect this now and abort before we start
9441 overwriting things. */
9442 if (sizeof (bfd_vma) < 8)
9444 error (_("This instance of readelf has been built without support for a\n\
9445 64 bit data type and so it cannot read 64 bit ELF files.\n"));
9449 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
9452 elf_header.e_type = BYTE_GET (ehdr64.e_type);
9453 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
9454 elf_header.e_version = BYTE_GET (ehdr64.e_version);
9455 elf_header.e_entry = BYTE_GET (ehdr64.e_entry);
9456 elf_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
9457 elf_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
9458 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
9459 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
9460 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
9461 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
9462 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
9463 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
9464 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
9467 if (elf_header.e_shoff)
9469 /* There may be some extensions in the first section header. Don't
9470 bomb if we can't read it. */
9472 get_32bit_section_headers (file, 1);
9474 get_64bit_section_headers (file, 1);
9477 is_relocatable = elf_header.e_type == ET_REL;
9482 /* Process one ELF object file according to the command line options.
9483 This file may actually be stored in an archive. The file is
9484 positioned at the start of the ELF object. */
9487 process_object (char *file_name, FILE *file)
9491 if (! get_file_header (file))
9493 error (_("%s: Failed to read file header\n"), file_name);
9497 /* Initialise per file variables. */
9498 for (i = NUM_ELEM (version_info); i--;)
9499 version_info[i] = 0;
9501 for (i = NUM_ELEM (dynamic_info); i--;)
9502 dynamic_info[i] = 0;
9504 /* Process the file. */
9506 printf (_("\nFile: %s\n"), file_name);
9508 /* Initialise the dump_sects array from the cmdline_dump_sects array.
9509 Note we do this even if cmdline_dump_sects is empty because we
9510 must make sure that the dump_sets array is zeroed out before each
9511 object file is processed. */
9512 if (num_dump_sects > num_cmdline_dump_sects)
9513 memset (dump_sects, 0, num_dump_sects);
9515 if (num_cmdline_dump_sects > 0)
9517 if (num_dump_sects == 0)
9518 /* A sneaky way of allocating the dump_sects array. */
9519 request_dump (num_cmdline_dump_sects, 0);
9521 assert (num_dump_sects >= num_cmdline_dump_sects);
9522 memcpy (dump_sects, cmdline_dump_sects, num_cmdline_dump_sects);
9525 if (! process_file_header ())
9528 if (! process_section_headers (file))
9530 /* Without loaded section headers we cannot process lots of
9532 do_unwind = do_version = do_dump = do_arch = 0;
9534 if (! do_using_dynamic)
9535 do_syms = do_reloc = 0;
9538 if (! process_section_groups (file))
9540 /* Without loaded section groups we cannot process unwind. */
9544 if (process_program_headers (file))
9545 process_dynamic_section (file);
9547 process_relocs (file);
9549 process_unwind (file);
9551 process_symbol_table (file);
9553 process_syminfo (file);
9555 process_version_sections (file);
9557 process_section_contents (file);
9559 process_notes (file);
9561 process_gnu_liblist (file);
9563 process_arch_specific (file);
9565 if (program_headers)
9567 free (program_headers);
9568 program_headers = NULL;
9571 if (section_headers)
9573 free (section_headers);
9574 section_headers = NULL;
9579 free (string_table);
9580 string_table = NULL;
9581 string_table_length = 0;
9584 if (dynamic_strings)
9586 free (dynamic_strings);
9587 dynamic_strings = NULL;
9588 dynamic_strings_length = 0;
9591 if (dynamic_symbols)
9593 free (dynamic_symbols);
9594 dynamic_symbols = NULL;
9595 num_dynamic_syms = 0;
9598 if (dynamic_syminfo)
9600 free (dynamic_syminfo);
9601 dynamic_syminfo = NULL;
9604 if (section_headers_groups)
9606 free (section_headers_groups);
9607 section_headers_groups = NULL;
9612 struct group_list *g, *next;
9614 for (i = 0; i < group_count; i++)
9616 for (g = section_groups [i].root; g != NULL; g = next)
9623 free (section_groups);
9624 section_groups = NULL;
9627 free_debug_memory ();
9632 /* Process an ELF archive. The file is positioned just after the
9636 process_archive (char *file_name, FILE *file)
9638 struct ar_hdr arhdr;
9641 char *longnames = NULL;
9642 unsigned long longnames_size = 0;
9643 size_t file_name_size;
9648 got = fread (&arhdr, 1, sizeof arhdr, file);
9649 if (got != sizeof arhdr)
9654 error (_("%s: failed to read archive header\n"), file_name);
9658 if (const_strneq (arhdr.ar_name, "/ "))
9660 /* This is the archive symbol table. Skip it.
9661 FIXME: We should have an option to dump it. */
9662 size = strtoul (arhdr.ar_size, NULL, 10);
9663 if (fseek (file, size + (size & 1), SEEK_CUR) != 0)
9665 error (_("%s: failed to skip archive symbol table\n"), file_name);
9669 got = fread (&arhdr, 1, sizeof arhdr, file);
9670 if (got != sizeof arhdr)
9675 error (_("%s: failed to read archive header\n"), file_name);
9680 if (const_strneq (arhdr.ar_name, "// "))
9682 /* This is the archive string table holding long member
9685 longnames_size = strtoul (arhdr.ar_size, NULL, 10);
9687 longnames = malloc (longnames_size);
9688 if (longnames == NULL)
9690 error (_("Out of memory\n"));
9694 if (fread (longnames, longnames_size, 1, file) != 1)
9697 error (_("%s: failed to read string table\n"), file_name);
9701 if ((longnames_size & 1) != 0)
9704 got = fread (&arhdr, 1, sizeof arhdr, file);
9705 if (got != sizeof arhdr)
9712 error (_("%s: failed to read archive header\n"), file_name);
9717 file_name_size = strlen (file_name);
9726 if (arhdr.ar_name[0] == '/')
9730 off = strtoul (arhdr.ar_name + 1, NULL, 10);
9731 if (off >= longnames_size)
9733 error (_("%s: invalid archive string table offset %lu\n"), file_name, off);
9738 name = longnames + off;
9739 nameend = memchr (name, '/', longnames_size - off);
9743 name = arhdr.ar_name;
9744 nameend = memchr (name, '/', 16);
9747 if (nameend == NULL)
9749 error (_("%s: bad archive file name\n"), file_name);
9754 namealc = malloc (file_name_size + (nameend - name) + 3);
9755 if (namealc == NULL)
9757 error (_("Out of memory\n"));
9762 memcpy (namealc, file_name, file_name_size);
9763 namealc[file_name_size] = '(';
9764 memcpy (namealc + file_name_size + 1, name, nameend - name);
9765 namealc[file_name_size + 1 + (nameend - name)] = ')';
9766 namealc[file_name_size + 2 + (nameend - name)] = '\0';
9768 archive_file_offset = ftell (file);
9769 archive_file_size = strtoul (arhdr.ar_size, NULL, 10);
9771 ret |= process_object (namealc, file);
9776 (archive_file_offset
9778 + (archive_file_size & 1)),
9781 error (_("%s: failed to seek to next archive header\n"), file_name);
9786 got = fread (&arhdr, 1, sizeof arhdr, file);
9787 if (got != sizeof arhdr)
9792 error (_("%s: failed to read archive header\n"), file_name);
9805 process_file (char *file_name)
9808 struct stat statbuf;
9812 if (stat (file_name, &statbuf) < 0)
9814 if (errno == ENOENT)
9815 error (_("'%s': No such file\n"), file_name);
9817 error (_("Could not locate '%s'. System error message: %s\n"),
9818 file_name, strerror (errno));
9822 if (! S_ISREG (statbuf.st_mode))
9824 error (_("'%s' is not an ordinary file\n"), file_name);
9828 file = fopen (file_name, "rb");
9831 error (_("Input file '%s' is not readable.\n"), file_name);
9835 if (fread (armag, SARMAG, 1, file) != 1)
9837 error (_("%s: Failed to read file header\n"), file_name);
9842 if (memcmp (armag, ARMAG, SARMAG) == 0)
9843 ret = process_archive (file_name, file);
9847 archive_file_size = archive_file_offset = 0;
9848 ret = process_object (file_name, file);
9856 #ifdef SUPPORT_DISASSEMBLY
9857 /* Needed by the i386 disassembler. For extra credit, someone could
9858 fix this so that we insert symbolic addresses here, esp for GOT/PLT
9862 print_address (unsigned int addr, FILE *outfile)
9864 fprintf (outfile,"0x%8.8x", addr);
9867 /* Needed by the i386 disassembler. */
9869 db_task_printsym (unsigned int addr)
9871 print_address (addr, stderr);
9876 main (int argc, char **argv)
9880 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
9881 setlocale (LC_MESSAGES, "");
9883 #if defined (HAVE_SETLOCALE)
9884 setlocale (LC_CTYPE, "");
9886 bindtextdomain (PACKAGE, LOCALEDIR);
9887 textdomain (PACKAGE);
9889 expandargv (&argc, &argv);
9891 parse_args (argc, argv);
9893 if (num_dump_sects > 0)
9895 /* Make a copy of the dump_sects array. */
9896 cmdline_dump_sects = malloc (num_dump_sects);
9897 if (cmdline_dump_sects == NULL)
9898 error (_("Out of memory allocating dump request table.\n"));
9901 memcpy (cmdline_dump_sects, dump_sects, num_dump_sects);
9902 num_cmdline_dump_sects = num_dump_sects;
9906 if (optind < (argc - 1))
9910 while (optind < argc)
9911 err |= process_file (argv[optind++]);
9913 if (dump_sects != NULL)
9915 if (cmdline_dump_sects != NULL)
9916 free (cmdline_dump_sects);