1 /* readelf.c -- display contents of an ELF format file
2 Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
3 2008 Free Software Foundation, Inc.
5 Originally developed by Eric Youngdale <eric@andante.jic.com>
6 Modifications by Nick Clifton <nickc@redhat.com>
8 This file is part of GNU Binutils.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
25 /* The difference between readelf and objdump:
27 Both programs are capable of displaying the contents of ELF format files,
28 so why does the binutils project have two file dumpers ?
30 The reason is that objdump sees an ELF file through a BFD filter of the
31 world; if BFD has a bug where, say, it disagrees about a machine constant
32 in e_flags, then the odds are good that it will remain internally
33 consistent. The linker sees it the BFD way, objdump sees it the BFD way,
34 GAS sees it the BFD way. There was need for a tool to go find out what
35 the file actually says.
37 This is why the readelf program does not link against the BFD library - it
38 exists as an independent program to help verify the correct working of BFD.
40 There is also the case that readelf can provide more information about an
41 ELF file than is provided by objdump. In particular it can display DWARF
42 debugging information which (at the moment) objdump cannot. */
60 # ifdef HAVE_SYS_PARAM_H
61 # include <sys/param.h>
65 # define PATH_MAX MAXPATHLEN
67 # define PATH_MAX 1024
73 /* Define BFD64 here, even if our default architecture is 32 bit ELF
74 as this will allow us to read in and parse 64bit and 32bit ELF files.
75 Only do this if we believe that the compiler can support a 64 bit
76 data type. For now we only rely on GCC being able to do this. */
84 #include "elf/common.h"
85 #include "elf/external.h"
86 #include "elf/internal.h"
89 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
90 we can obtain the H8 reloc numbers. We need these for the
91 get_reloc_size() function. We include h8.h again after defining
92 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
97 /* Undo the effects of #including reloc-macros.h. */
99 #undef START_RELOC_NUMBERS
103 #undef END_RELOC_NUMBERS
104 #undef _RELOC_MACROS_H
106 /* The following headers use the elf/reloc-macros.h file to
107 automatically generate relocation recognition functions
108 such as elf_mips_reloc_type() */
110 #define RELOC_MACROS_GEN_FUNC
112 #include "elf/alpha.h"
116 #include "elf/bfin.h"
117 #include "elf/cr16.h"
118 #include "elf/cris.h"
120 #include "elf/d10v.h"
121 #include "elf/d30v.h"
123 #include "elf/fr30.h"
126 #include "elf/hppa.h"
127 #include "elf/i386.h"
128 #include "elf/i370.h"
129 #include "elf/i860.h"
130 #include "elf/i960.h"
131 #include "elf/ia64.h"
132 #include "elf/ip2k.h"
133 #include "elf/iq2000.h"
134 #include "elf/m32c.h"
135 #include "elf/m32r.h"
136 #include "elf/m68k.h"
137 #include "elf/m68hc11.h"
138 #include "elf/mcore.h"
140 #include "elf/mips.h"
141 #include "elf/mmix.h"
142 #include "elf/mn10200.h"
143 #include "elf/mn10300.h"
145 #include "elf/msp430.h"
146 #include "elf/or32.h"
149 #include "elf/ppc64.h"
150 #include "elf/s390.h"
151 #include "elf/score.h"
153 #include "elf/sparc.h"
155 #include "elf/v850.h"
157 #include "elf/x86-64.h"
158 #include "elf/xstormy16.h"
159 #include "elf/xtensa.h"
164 #include "libiberty.h"
165 #include "safe-ctype.h"
167 char *program_name = "readelf";
169 static long archive_file_offset;
170 static unsigned long archive_file_size;
171 static unsigned long dynamic_addr;
172 static bfd_size_type dynamic_size;
173 static unsigned int dynamic_nent;
174 static char *dynamic_strings;
175 static unsigned long dynamic_strings_length;
176 static char *string_table;
177 static unsigned long string_table_length;
178 static unsigned long num_dynamic_syms;
179 static Elf_Internal_Sym *dynamic_symbols;
180 static Elf_Internal_Syminfo *dynamic_syminfo;
181 static unsigned long dynamic_syminfo_offset;
182 static unsigned int dynamic_syminfo_nent;
183 static char program_interpreter[PATH_MAX];
184 static bfd_vma dynamic_info[DT_JMPREL + 1];
185 static bfd_vma dynamic_info_DT_GNU_HASH;
186 static bfd_vma version_info[16];
187 static Elf_Internal_Ehdr elf_header;
188 static Elf_Internal_Shdr *section_headers;
189 static Elf_Internal_Phdr *program_headers;
190 static Elf_Internal_Dyn *dynamic_section;
191 static Elf_Internal_Shdr *symtab_shndx_hdr;
192 static int show_name;
193 static int do_dynamic;
196 static int do_sections;
197 static int do_section_groups;
198 static int do_section_details;
199 static int do_segments;
200 static int do_unwind;
201 static int do_using_dynamic;
202 static int do_header;
204 static int do_version;
205 static int do_histogram;
206 static int do_debugging;
209 static int do_archive_index;
210 static int is_32bit_elf;
214 struct group_list *next;
215 unsigned int section_index;
220 struct group_list *root;
221 unsigned int group_index;
224 static size_t group_count;
225 static struct group *section_groups;
226 static struct group **section_headers_groups;
229 /* Flag bits indicating particular types of dump. */
230 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
231 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
232 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
233 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
235 typedef unsigned char dump_type;
237 /* A linked list of the section names for which dumps were requested. */
238 struct dump_list_entry
242 struct dump_list_entry *next;
244 static struct dump_list_entry *dump_sects_byname;
246 /* A dynamic array of flags indicating for which sections a dump
247 has been requested via command line switches. */
248 static dump_type * cmdline_dump_sects = NULL;
249 static unsigned int num_cmdline_dump_sects = 0;
251 /* A dynamic array of flags indicating for which sections a dump of
252 some kind has been requested. It is reset on a per-object file
253 basis and then initialised from the cmdline_dump_sects array,
254 the results of interpreting the -w switch, and the
255 dump_sects_byname list. */
256 static dump_type * dump_sects = NULL;
257 static unsigned int num_dump_sects = 0;
260 /* How to print a vma value. */
261 typedef enum print_mode
273 static void (*byte_put) (unsigned char *, bfd_vma, int);
277 #define SECTION_NAME(X) \
278 ((X) == NULL ? "<none>" \
279 : string_table == NULL ? "<no-name>" \
280 : ((X)->sh_name >= string_table_length ? "<corrupt>" \
281 : string_table + (X)->sh_name))
283 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
285 #define BYTE_GET(field) byte_get (field, sizeof (field))
287 #define GET_ELF_SYMBOLS(file, section) \
288 (is_32bit_elf ? get_32bit_elf_symbols (file, section) \
289 : get_64bit_elf_symbols (file, section))
291 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
292 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
293 already been called and verified that the string exists. */
294 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
296 /* This is just a bit of syntatic sugar. */
297 #define streq(a,b) (strcmp ((a), (b)) == 0)
298 #define strneq(a,b,n) (strncmp ((a), (b), (n)) == 0)
299 #define const_strneq(a,b) (strncmp ((a), (b), sizeof (b) - 1) == 0)
302 get_data (void *var, FILE *file, long offset, size_t size, size_t nmemb,
307 if (size == 0 || nmemb == 0)
310 if (fseek (file, archive_file_offset + offset, SEEK_SET))
312 error (_("Unable to seek to 0x%lx for %s\n"),
313 (unsigned long) archive_file_offset + offset, reason);
320 /* Check for overflow. */
321 if (nmemb < (~(size_t) 0 - 1) / size)
322 /* + 1 so that we can '\0' terminate invalid string table sections. */
323 mvar = malloc (size * nmemb + 1);
327 error (_("Out of memory allocating 0x%lx bytes for %s\n"),
328 (unsigned long)(size * nmemb), reason);
332 ((char *) mvar)[size * nmemb] = '\0';
335 if (fread (mvar, size, nmemb, file) != nmemb)
337 error (_("Unable to read in 0x%lx bytes of %s\n"),
338 (unsigned long)(size * nmemb), reason);
348 byte_put_little_endian (unsigned char *field, bfd_vma value, int size)
353 field[7] = (((value >> 24) >> 24) >> 8) & 0xff;
354 field[6] = ((value >> 24) >> 24) & 0xff;
355 field[5] = ((value >> 24) >> 16) & 0xff;
356 field[4] = ((value >> 24) >> 8) & 0xff;
359 field[3] = (value >> 24) & 0xff;
360 field[2] = (value >> 16) & 0xff;
363 field[1] = (value >> 8) & 0xff;
366 field[0] = value & 0xff;
370 error (_("Unhandled data length: %d\n"), size);
375 /* Print a VMA value. */
378 print_vma (bfd_vma vma, print_mode mode)
391 return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
398 return printf ("%5" BFD_VMA_FMT "d", vma);
406 return nc + printf ("%" BFD_VMA_FMT "x", vma);
409 return printf ("%" BFD_VMA_FMT "d", vma);
412 return printf ("%" BFD_VMA_FMT "u", vma);
417 /* Display a symbol on stdout. Handles the display of non-printing characters.
419 If DO_WIDE is not true then format the symbol to be at most WIDTH characters,
420 truncating as necessary. If WIDTH is negative then format the string to be
421 exactly - WIDTH characters, truncating or padding as necessary.
423 Returns the number of emitted characters. */
426 print_symbol (int width, const char *symbol)
429 bfd_boolean extra_padding = FALSE;
430 unsigned int num_printed = 0;
434 /* Set the width to a very large value. This simplifies the code below. */
439 /* Keep the width positive. This also helps. */
441 extra_padding = TRUE;
450 /* Look for non-printing symbols inside the symbol's name.
451 This test is triggered in particular by the names generated
452 by the assembler for local labels. */
453 while (ISPRINT (* c))
463 printf ("%.*s", len, symbol);
469 if (* c == 0 || width == 0)
472 /* Now display the non-printing character, if
473 there is room left in which to dipslay it. */
479 printf ("^%c", *c + 0x40);
489 printf ("<0x%.2x>", *c);
498 if (extra_padding && width > 0)
500 /* Fill in the remaining spaces. */
501 printf ("%-*s", width, " ");
509 byte_put_big_endian (unsigned char *field, bfd_vma value, int size)
514 field[7] = value & 0xff;
515 field[6] = (value >> 8) & 0xff;
516 field[5] = (value >> 16) & 0xff;
517 field[4] = (value >> 24) & 0xff;
522 field[3] = value & 0xff;
523 field[2] = (value >> 8) & 0xff;
527 field[1] = value & 0xff;
531 field[0] = value & 0xff;
535 error (_("Unhandled data length: %d\n"), size);
540 /* Return a pointer to section NAME, or NULL if no such section exists. */
542 static Elf_Internal_Shdr *
543 find_section (const char *name)
547 for (i = 0; i < elf_header.e_shnum; i++)
548 if (streq (SECTION_NAME (section_headers + i), name))
549 return section_headers + i;
554 /* Guess the relocation size commonly used by the specific machines. */
557 guess_is_rela (unsigned int e_machine)
561 /* Targets that use REL relocations. */
577 /* Targets that use RELA relocations. */
581 case EM_ALTERA_NIOS2:
608 case EM_CYGNUS_MN10200:
610 case EM_CYGNUS_MN10300:
651 warn (_("Don't know about relocations on this machine architecture\n"));
657 slurp_rela_relocs (FILE *file,
658 unsigned long rel_offset,
659 unsigned long rel_size,
660 Elf_Internal_Rela **relasp,
661 unsigned long *nrelasp)
663 Elf_Internal_Rela *relas;
664 unsigned long nrelas;
669 Elf32_External_Rela *erelas;
671 erelas = get_data (NULL, file, rel_offset, 1, rel_size, _("relocs"));
675 nrelas = rel_size / sizeof (Elf32_External_Rela);
677 relas = cmalloc (nrelas, sizeof (Elf_Internal_Rela));
682 error (_("out of memory parsing relocs\n"));
686 for (i = 0; i < nrelas; i++)
688 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
689 relas[i].r_info = BYTE_GET (erelas[i].r_info);
690 relas[i].r_addend = BYTE_GET (erelas[i].r_addend);
697 Elf64_External_Rela *erelas;
699 erelas = get_data (NULL, file, rel_offset, 1, rel_size, _("relocs"));
703 nrelas = rel_size / sizeof (Elf64_External_Rela);
705 relas = cmalloc (nrelas, sizeof (Elf_Internal_Rela));
710 error (_("out of memory parsing relocs\n"));
714 for (i = 0; i < nrelas; i++)
716 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
717 relas[i].r_info = BYTE_GET (erelas[i].r_info);
718 relas[i].r_addend = BYTE_GET (erelas[i].r_addend);
720 /* The #ifdef BFD64 below is to prevent a compile time
721 warning. We know that if we do not have a 64 bit data
722 type that we will never execute this code anyway. */
724 if (elf_header.e_machine == EM_MIPS
725 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
727 /* In little-endian objects, r_info isn't really a
728 64-bit little-endian value: it has a 32-bit
729 little-endian symbol index followed by four
730 individual byte fields. Reorder INFO
732 bfd_vma info = relas[i].r_info;
733 info = (((info & 0xffffffff) << 32)
734 | ((info >> 56) & 0xff)
735 | ((info >> 40) & 0xff00)
736 | ((info >> 24) & 0xff0000)
737 | ((info >> 8) & 0xff000000));
738 relas[i].r_info = info;
751 slurp_rel_relocs (FILE *file,
752 unsigned long rel_offset,
753 unsigned long rel_size,
754 Elf_Internal_Rela **relsp,
755 unsigned long *nrelsp)
757 Elf_Internal_Rela *rels;
763 Elf32_External_Rel *erels;
765 erels = get_data (NULL, file, rel_offset, 1, rel_size, _("relocs"));
769 nrels = rel_size / sizeof (Elf32_External_Rel);
771 rels = cmalloc (nrels, sizeof (Elf_Internal_Rela));
776 error (_("out of memory parsing relocs\n"));
780 for (i = 0; i < nrels; i++)
782 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
783 rels[i].r_info = BYTE_GET (erels[i].r_info);
784 rels[i].r_addend = 0;
791 Elf64_External_Rel *erels;
793 erels = get_data (NULL, file, rel_offset, 1, rel_size, _("relocs"));
797 nrels = rel_size / sizeof (Elf64_External_Rel);
799 rels = cmalloc (nrels, sizeof (Elf_Internal_Rela));
804 error (_("out of memory parsing relocs\n"));
808 for (i = 0; i < nrels; i++)
810 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
811 rels[i].r_info = BYTE_GET (erels[i].r_info);
812 rels[i].r_addend = 0;
814 /* The #ifdef BFD64 below is to prevent a compile time
815 warning. We know that if we do not have a 64 bit data
816 type that we will never execute this code anyway. */
818 if (elf_header.e_machine == EM_MIPS
819 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
821 /* In little-endian objects, r_info isn't really a
822 64-bit little-endian value: it has a 32-bit
823 little-endian symbol index followed by four
824 individual byte fields. Reorder INFO
826 bfd_vma info = rels[i].r_info;
827 info = (((info & 0xffffffff) << 32)
828 | ((info >> 56) & 0xff)
829 | ((info >> 40) & 0xff00)
830 | ((info >> 24) & 0xff0000)
831 | ((info >> 8) & 0xff000000));
832 rels[i].r_info = info;
844 /* Returns the reloc type extracted from the reloc info field. */
847 get_reloc_type (bfd_vma reloc_info)
850 return ELF32_R_TYPE (reloc_info);
852 switch (elf_header.e_machine)
855 /* Note: We assume that reloc_info has already been adjusted for us. */
856 return ELF64_MIPS_R_TYPE (reloc_info);
859 return ELF64_R_TYPE_ID (reloc_info);
862 return ELF64_R_TYPE (reloc_info);
866 /* Return the symbol index extracted from the reloc info field. */
869 get_reloc_symindex (bfd_vma reloc_info)
871 return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
874 /* Display the contents of the relocation data found at the specified
878 dump_relocations (FILE *file,
879 unsigned long rel_offset,
880 unsigned long rel_size,
881 Elf_Internal_Sym *symtab,
884 unsigned long strtablen,
888 Elf_Internal_Rela *rels;
891 if (is_rela == UNKNOWN)
892 is_rela = guess_is_rela (elf_header.e_machine);
896 if (!slurp_rela_relocs (file, rel_offset, rel_size, &rels, &rel_size))
901 if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
910 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
912 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
917 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
919 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
927 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
929 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
934 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
936 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
940 for (i = 0; i < rel_size; i++)
945 bfd_vma symtab_index;
948 offset = rels[i].r_offset;
949 info = rels[i].r_info;
951 type = get_reloc_type (info);
952 symtab_index = get_reloc_symindex (info);
956 printf ("%8.8lx %8.8lx ",
957 (unsigned long) offset & 0xffffffff,
958 (unsigned long) info & 0xffffffff);
962 #if BFD_HOST_64BIT_LONG
964 ? "%16.16lx %16.16lx "
965 : "%12.12lx %12.12lx ",
967 #elif BFD_HOST_64BIT_LONG_LONG
970 ? "%16.16llx %16.16llx "
971 : "%12.12llx %12.12llx ",
975 ? "%16.16I64x %16.16I64x "
976 : "%12.12I64x %12.12I64x ",
981 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
982 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
983 _bfd_int64_high (offset),
984 _bfd_int64_low (offset),
985 _bfd_int64_high (info),
986 _bfd_int64_low (info));
990 switch (elf_header.e_machine)
998 rtype = elf_m32r_reloc_type (type);
1003 rtype = elf_i386_reloc_type (type);
1008 rtype = elf_m68hc11_reloc_type (type);
1012 rtype = elf_m68k_reloc_type (type);
1016 rtype = elf_i960_reloc_type (type);
1021 rtype = elf_avr_reloc_type (type);
1024 case EM_OLD_SPARCV9:
1025 case EM_SPARC32PLUS:
1028 rtype = elf_sparc_reloc_type (type);
1032 rtype = elf_spu_reloc_type (type);
1036 case EM_CYGNUS_V850:
1037 rtype = v850_reloc_type (type);
1041 case EM_CYGNUS_D10V:
1042 rtype = elf_d10v_reloc_type (type);
1046 case EM_CYGNUS_D30V:
1047 rtype = elf_d30v_reloc_type (type);
1051 rtype = elf_dlx_reloc_type (type);
1055 rtype = elf_sh_reloc_type (type);
1059 case EM_CYGNUS_MN10300:
1060 rtype = elf_mn10300_reloc_type (type);
1064 case EM_CYGNUS_MN10200:
1065 rtype = elf_mn10200_reloc_type (type);
1069 case EM_CYGNUS_FR30:
1070 rtype = elf_fr30_reloc_type (type);
1074 rtype = elf_frv_reloc_type (type);
1078 rtype = elf_mcore_reloc_type (type);
1082 rtype = elf_mmix_reloc_type (type);
1087 rtype = elf_msp430_reloc_type (type);
1091 rtype = elf_ppc_reloc_type (type);
1095 rtype = elf_ppc64_reloc_type (type);
1099 case EM_MIPS_RS3_LE:
1100 rtype = elf_mips_reloc_type (type);
1104 rtype = elf_alpha_reloc_type (type);
1108 rtype = elf_arm_reloc_type (type);
1112 rtype = elf_arc_reloc_type (type);
1116 rtype = elf_hppa_reloc_type (type);
1122 rtype = elf_h8_reloc_type (type);
1127 rtype = elf_or32_reloc_type (type);
1132 rtype = elf_pj_reloc_type (type);
1135 rtype = elf_ia64_reloc_type (type);
1139 rtype = elf_cris_reloc_type (type);
1143 rtype = elf_i860_reloc_type (type);
1147 rtype = elf_x86_64_reloc_type (type);
1151 rtype = i370_reloc_type (type);
1156 rtype = elf_s390_reloc_type (type);
1160 rtype = elf_score_reloc_type (type);
1164 rtype = elf_xstormy16_reloc_type (type);
1168 rtype = elf_crx_reloc_type (type);
1172 rtype = elf_vax_reloc_type (type);
1177 rtype = elf_ip2k_reloc_type (type);
1181 rtype = elf_iq2000_reloc_type (type);
1186 rtype = elf_xtensa_reloc_type (type);
1191 rtype = elf_m32c_reloc_type (type);
1195 rtype = elf_mt_reloc_type (type);
1199 rtype = elf_bfin_reloc_type (type);
1203 rtype = elf_mep_reloc_type (type);
1208 rtype = elf_cr16_reloc_type (type);
1213 printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
1215 printf (do_wide ? "%-22.22s" : "%-17.17s", rtype);
1217 if (elf_header.e_machine == EM_ALPHA
1219 && streq (rtype, "R_ALPHA_LITUSE")
1222 switch (rels[i].r_addend)
1224 case LITUSE_ALPHA_ADDR: rtype = "ADDR"; break;
1225 case LITUSE_ALPHA_BASE: rtype = "BASE"; break;
1226 case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1227 case LITUSE_ALPHA_JSR: rtype = "JSR"; break;
1228 case LITUSE_ALPHA_TLSGD: rtype = "TLSGD"; break;
1229 case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1230 case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1231 default: rtype = NULL;
1234 printf (" (%s)", rtype);
1238 printf (_("<unknown addend: %lx>"),
1239 (unsigned long) rels[i].r_addend);
1242 else if (symtab_index)
1244 if (symtab == NULL || symtab_index >= nsyms)
1245 printf (" bad symbol index: %08lx", (unsigned long) symtab_index);
1248 Elf_Internal_Sym *psym;
1250 psym = symtab + symtab_index;
1254 print_vma (psym->st_value, LONG_HEX);
1256 printf (is_32bit_elf ? " " : " ");
1258 if (psym->st_name == 0)
1260 const char *sec_name = "<null>";
1263 if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1265 if (psym->st_shndx < elf_header.e_shnum)
1267 = SECTION_NAME (section_headers + psym->st_shndx);
1268 else if (psym->st_shndx == SHN_ABS)
1270 else if (psym->st_shndx == SHN_COMMON)
1271 sec_name = "COMMON";
1272 else if (elf_header.e_machine == EM_MIPS
1273 && psym->st_shndx == SHN_MIPS_SCOMMON)
1274 sec_name = "SCOMMON";
1275 else if (elf_header.e_machine == EM_MIPS
1276 && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1277 sec_name = "SUNDEF";
1278 else if (elf_header.e_machine == EM_X86_64
1279 && psym->st_shndx == SHN_X86_64_LCOMMON)
1280 sec_name = "LARGE_COMMON";
1281 else if (elf_header.e_machine == EM_IA_64
1282 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1283 && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1284 sec_name = "ANSI_COM";
1285 else if (elf_header.e_machine == EM_IA_64
1286 && (elf_header.e_ident[EI_OSABI]
1287 == ELFOSABI_OPENVMS)
1288 && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1289 sec_name = "VMS_SYMVEC";
1292 sprintf (name_buf, "<section 0x%x>",
1293 (unsigned int) psym->st_shndx);
1294 sec_name = name_buf;
1297 print_symbol (22, sec_name);
1299 else if (strtab == NULL)
1300 printf (_("<string table index: %3ld>"), psym->st_name);
1301 else if (psym->st_name >= strtablen)
1302 printf (_("<corrupt string table index: %3ld>"), psym->st_name);
1304 print_symbol (22, strtab + psym->st_name);
1308 long offset = (long) (bfd_signed_vma) rels[i].r_addend;
1311 printf (" - %lx", - offset);
1313 printf (" + %lx", offset);
1319 printf ("%*c", is_32bit_elf ?
1320 (do_wide ? 34 : 28) : (do_wide ? 26 : 20), ' ');
1321 print_vma (rels[i].r_addend, LONG_HEX);
1324 if (elf_header.e_machine == EM_SPARCV9
1326 && streq (rtype, "R_SPARC_OLO10"))
1327 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (info));
1332 if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
1334 bfd_vma type2 = ELF64_MIPS_R_TYPE2 (info);
1335 bfd_vma type3 = ELF64_MIPS_R_TYPE3 (info);
1336 const char *rtype2 = elf_mips_reloc_type (type2);
1337 const char *rtype3 = elf_mips_reloc_type (type3);
1339 printf (" Type2: ");
1342 printf (_("unrecognized: %-7lx"),
1343 (unsigned long) type2 & 0xffffffff);
1345 printf ("%-17.17s", rtype2);
1347 printf ("\n Type3: ");
1350 printf (_("unrecognized: %-7lx"),
1351 (unsigned long) type3 & 0xffffffff);
1353 printf ("%-17.17s", rtype3);
1364 get_mips_dynamic_type (unsigned long type)
1368 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1369 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1370 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1371 case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1372 case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1373 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1374 case DT_MIPS_MSYM: return "MIPS_MSYM";
1375 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1376 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1377 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1378 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1379 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1380 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1381 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1382 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1383 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1384 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1385 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1386 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1387 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1388 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1389 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1390 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1391 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1392 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1393 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1394 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1395 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1396 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1397 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1398 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1399 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1400 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1401 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1402 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1403 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1404 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1405 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1406 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1407 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1408 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1409 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1410 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
1411 case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1412 case DT_MIPS_RWPLT: return "MIPS_RWPLT";
1419 get_sparc64_dynamic_type (unsigned long type)
1423 case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1430 get_ppc_dynamic_type (unsigned long type)
1434 case DT_PPC_GOT: return "PPC_GOT";
1441 get_ppc64_dynamic_type (unsigned long type)
1445 case DT_PPC64_GLINK: return "PPC64_GLINK";
1446 case DT_PPC64_OPD: return "PPC64_OPD";
1447 case DT_PPC64_OPDSZ: return "PPC64_OPDSZ";
1454 get_parisc_dynamic_type (unsigned long type)
1458 case DT_HP_LOAD_MAP: return "HP_LOAD_MAP";
1459 case DT_HP_DLD_FLAGS: return "HP_DLD_FLAGS";
1460 case DT_HP_DLD_HOOK: return "HP_DLD_HOOK";
1461 case DT_HP_UX10_INIT: return "HP_UX10_INIT";
1462 case DT_HP_UX10_INITSZ: return "HP_UX10_INITSZ";
1463 case DT_HP_PREINIT: return "HP_PREINIT";
1464 case DT_HP_PREINITSZ: return "HP_PREINITSZ";
1465 case DT_HP_NEEDED: return "HP_NEEDED";
1466 case DT_HP_TIME_STAMP: return "HP_TIME_STAMP";
1467 case DT_HP_CHECKSUM: return "HP_CHECKSUM";
1468 case DT_HP_GST_SIZE: return "HP_GST_SIZE";
1469 case DT_HP_GST_VERSION: return "HP_GST_VERSION";
1470 case DT_HP_GST_HASHVAL: return "HP_GST_HASHVAL";
1471 case DT_HP_EPLTREL: return "HP_GST_EPLTREL";
1472 case DT_HP_EPLTRELSZ: return "HP_GST_EPLTRELSZ";
1473 case DT_HP_FILTERED: return "HP_FILTERED";
1474 case DT_HP_FILTER_TLS: return "HP_FILTER_TLS";
1475 case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1476 case DT_HP_LAZYLOAD: return "HP_LAZYLOAD";
1477 case DT_HP_BIND_NOW_COUNT: return "HP_BIND_NOW_COUNT";
1478 case DT_PLT: return "PLT";
1479 case DT_PLT_SIZE: return "PLT_SIZE";
1480 case DT_DLT: return "DLT";
1481 case DT_DLT_SIZE: return "DLT_SIZE";
1488 get_ia64_dynamic_type (unsigned long type)
1492 case DT_IA_64_PLT_RESERVE: return "IA_64_PLT_RESERVE";
1493 case DT_IA_64_VMS_SUBTYPE: return "VMS_SUBTYPE";
1494 case DT_IA_64_VMS_IMGIOCNT: return "VMS_IMGIOCNT";
1495 case DT_IA_64_VMS_LNKFLAGS: return "VMS_LNKFLAGS";
1496 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1497 case DT_IA_64_VMS_IDENT: return "VMS_IDENT";
1498 case DT_IA_64_VMS_NEEDED_IDENT: return "VMS_NEEDED_IDENT";
1499 case DT_IA_64_VMS_IMG_RELA_CNT: return "VMS_IMG_RELA_CNT";
1500 case DT_IA_64_VMS_SEG_RELA_CNT: return "VMS_SEG_RELA_CNT";
1501 case DT_IA_64_VMS_FIXUP_RELA_CNT: return "VMS_FIXUP_RELA_CNT";
1502 case DT_IA_64_VMS_FIXUP_NEEDED: return "VMS_FIXUP_NEEDED";
1503 case DT_IA_64_VMS_SYMVEC_CNT: return "VMS_SYMVEC_CNT";
1504 case DT_IA_64_VMS_XLATED: return "VMS_XLATED";
1505 case DT_IA_64_VMS_STACKSIZE: return "VMS_STACKSIZE";
1506 case DT_IA_64_VMS_UNWINDSZ: return "VMS_UNWINDSZ";
1507 case DT_IA_64_VMS_UNWIND_CODSEG: return "VMS_UNWIND_CODSEG";
1508 case DT_IA_64_VMS_UNWIND_INFOSEG: return "VMS_UNWIND_INFOSEG";
1509 case DT_IA_64_VMS_LINKTIME: return "VMS_LINKTIME";
1510 case DT_IA_64_VMS_SEG_NO: return "VMS_SEG_NO";
1511 case DT_IA_64_VMS_SYMVEC_OFFSET: return "VMS_SYMVEC_OFFSET";
1512 case DT_IA_64_VMS_SYMVEC_SEG: return "VMS_SYMVEC_SEG";
1513 case DT_IA_64_VMS_UNWIND_OFFSET: return "VMS_UNWIND_OFFSET";
1514 case DT_IA_64_VMS_UNWIND_SEG: return "VMS_UNWIND_SEG";
1515 case DT_IA_64_VMS_STRTAB_OFFSET: return "VMS_STRTAB_OFFSET";
1516 case DT_IA_64_VMS_SYSVER_OFFSET: return "VMS_SYSVER_OFFSET";
1517 case DT_IA_64_VMS_IMG_RELA_OFF: return "VMS_IMG_RELA_OFF";
1518 case DT_IA_64_VMS_SEG_RELA_OFF: return "VMS_SEG_RELA_OFF";
1519 case DT_IA_64_VMS_FIXUP_RELA_OFF: return "VMS_FIXUP_RELA_OFF";
1520 case DT_IA_64_VMS_PLTGOT_OFFSET: return "VMS_PLTGOT_OFFSET";
1521 case DT_IA_64_VMS_PLTGOT_SEG: return "VMS_PLTGOT_SEG";
1522 case DT_IA_64_VMS_FPMODE: return "VMS_FPMODE";
1529 get_alpha_dynamic_type (unsigned long type)
1533 case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
1540 get_score_dynamic_type (unsigned long type)
1544 case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
1545 case DT_SCORE_LOCAL_GOTNO: return "SCORE_LOCAL_GOTNO";
1546 case DT_SCORE_SYMTABNO: return "SCORE_SYMTABNO";
1547 case DT_SCORE_GOTSYM: return "SCORE_GOTSYM";
1548 case DT_SCORE_UNREFEXTNO: return "SCORE_UNREFEXTNO";
1549 case DT_SCORE_HIPAGENO: return "SCORE_HIPAGENO";
1557 get_dynamic_type (unsigned long type)
1559 static char buff[64];
1563 case DT_NULL: return "NULL";
1564 case DT_NEEDED: return "NEEDED";
1565 case DT_PLTRELSZ: return "PLTRELSZ";
1566 case DT_PLTGOT: return "PLTGOT";
1567 case DT_HASH: return "HASH";
1568 case DT_STRTAB: return "STRTAB";
1569 case DT_SYMTAB: return "SYMTAB";
1570 case DT_RELA: return "RELA";
1571 case DT_RELASZ: return "RELASZ";
1572 case DT_RELAENT: return "RELAENT";
1573 case DT_STRSZ: return "STRSZ";
1574 case DT_SYMENT: return "SYMENT";
1575 case DT_INIT: return "INIT";
1576 case DT_FINI: return "FINI";
1577 case DT_SONAME: return "SONAME";
1578 case DT_RPATH: return "RPATH";
1579 case DT_SYMBOLIC: return "SYMBOLIC";
1580 case DT_REL: return "REL";
1581 case DT_RELSZ: return "RELSZ";
1582 case DT_RELENT: return "RELENT";
1583 case DT_PLTREL: return "PLTREL";
1584 case DT_DEBUG: return "DEBUG";
1585 case DT_TEXTREL: return "TEXTREL";
1586 case DT_JMPREL: return "JMPREL";
1587 case DT_BIND_NOW: return "BIND_NOW";
1588 case DT_INIT_ARRAY: return "INIT_ARRAY";
1589 case DT_FINI_ARRAY: return "FINI_ARRAY";
1590 case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
1591 case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
1592 case DT_RUNPATH: return "RUNPATH";
1593 case DT_FLAGS: return "FLAGS";
1595 case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1596 case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
1598 case DT_CHECKSUM: return "CHECKSUM";
1599 case DT_PLTPADSZ: return "PLTPADSZ";
1600 case DT_MOVEENT: return "MOVEENT";
1601 case DT_MOVESZ: return "MOVESZ";
1602 case DT_FEATURE: return "FEATURE";
1603 case DT_POSFLAG_1: return "POSFLAG_1";
1604 case DT_SYMINSZ: return "SYMINSZ";
1605 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
1607 case DT_ADDRRNGLO: return "ADDRRNGLO";
1608 case DT_CONFIG: return "CONFIG";
1609 case DT_DEPAUDIT: return "DEPAUDIT";
1610 case DT_AUDIT: return "AUDIT";
1611 case DT_PLTPAD: return "PLTPAD";
1612 case DT_MOVETAB: return "MOVETAB";
1613 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
1615 case DT_VERSYM: return "VERSYM";
1617 case DT_TLSDESC_GOT: return "TLSDESC_GOT";
1618 case DT_TLSDESC_PLT: return "TLSDESC_PLT";
1619 case DT_RELACOUNT: return "RELACOUNT";
1620 case DT_RELCOUNT: return "RELCOUNT";
1621 case DT_FLAGS_1: return "FLAGS_1";
1622 case DT_VERDEF: return "VERDEF";
1623 case DT_VERDEFNUM: return "VERDEFNUM";
1624 case DT_VERNEED: return "VERNEED";
1625 case DT_VERNEEDNUM: return "VERNEEDNUM";
1627 case DT_AUXILIARY: return "AUXILIARY";
1628 case DT_USED: return "USED";
1629 case DT_FILTER: return "FILTER";
1631 case DT_GNU_PRELINKED: return "GNU_PRELINKED";
1632 case DT_GNU_CONFLICT: return "GNU_CONFLICT";
1633 case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
1634 case DT_GNU_LIBLIST: return "GNU_LIBLIST";
1635 case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
1636 case DT_GNU_HASH: return "GNU_HASH";
1639 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1643 switch (elf_header.e_machine)
1646 case EM_MIPS_RS3_LE:
1647 result = get_mips_dynamic_type (type);
1650 result = get_sparc64_dynamic_type (type);
1653 result = get_ppc_dynamic_type (type);
1656 result = get_ppc64_dynamic_type (type);
1659 result = get_ia64_dynamic_type (type);
1662 result = get_alpha_dynamic_type (type);
1665 result = get_score_dynamic_type (type);
1675 snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
1677 else if (((type >= DT_LOOS) && (type <= DT_HIOS))
1678 || (elf_header.e_machine == EM_PARISC
1679 && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
1683 switch (elf_header.e_machine)
1686 result = get_parisc_dynamic_type (type);
1689 result = get_ia64_dynamic_type (type);
1699 snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
1703 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
1710 get_file_type (unsigned e_type)
1712 static char buff[32];
1716 case ET_NONE: return _("NONE (None)");
1717 case ET_REL: return _("REL (Relocatable file)");
1718 case ET_EXEC: return _("EXEC (Executable file)");
1719 case ET_DYN: return _("DYN (Shared object file)");
1720 case ET_CORE: return _("CORE (Core file)");
1723 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
1724 snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
1725 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
1726 snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
1728 snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
1734 get_machine_name (unsigned e_machine)
1736 static char buff[64]; /* XXX */
1740 case EM_NONE: return _("None");
1741 case EM_M32: return "WE32100";
1742 case EM_SPARC: return "Sparc";
1743 case EM_SPU: return "SPU";
1744 case EM_386: return "Intel 80386";
1745 case EM_68K: return "MC68000";
1746 case EM_88K: return "MC88000";
1747 case EM_486: return "Intel 80486";
1748 case EM_860: return "Intel 80860";
1749 case EM_MIPS: return "MIPS R3000";
1750 case EM_S370: return "IBM System/370";
1751 case EM_MIPS_RS3_LE: return "MIPS R4000 big-endian";
1752 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
1753 case EM_PARISC: return "HPPA";
1754 case EM_PPC_OLD: return "Power PC (old)";
1755 case EM_SPARC32PLUS: return "Sparc v8+" ;
1756 case EM_960: return "Intel 90860";
1757 case EM_PPC: return "PowerPC";
1758 case EM_PPC64: return "PowerPC64";
1759 case EM_V800: return "NEC V800";
1760 case EM_FR20: return "Fujitsu FR20";
1761 case EM_RH32: return "TRW RH32";
1762 case EM_MCORE: return "MCORE";
1763 case EM_ARM: return "ARM";
1764 case EM_OLD_ALPHA: return "Digital Alpha (old)";
1765 case EM_SH: return "Renesas / SuperH SH";
1766 case EM_SPARCV9: return "Sparc v9";
1767 case EM_TRICORE: return "Siemens Tricore";
1768 case EM_ARC: return "ARC";
1769 case EM_H8_300: return "Renesas H8/300";
1770 case EM_H8_300H: return "Renesas H8/300H";
1771 case EM_H8S: return "Renesas H8S";
1772 case EM_H8_500: return "Renesas H8/500";
1773 case EM_IA_64: return "Intel IA-64";
1774 case EM_MIPS_X: return "Stanford MIPS-X";
1775 case EM_COLDFIRE: return "Motorola Coldfire";
1776 case EM_68HC12: return "Motorola M68HC12";
1777 case EM_ALPHA: return "Alpha";
1778 case EM_CYGNUS_D10V:
1779 case EM_D10V: return "d10v";
1780 case EM_CYGNUS_D30V:
1781 case EM_D30V: return "d30v";
1782 case EM_CYGNUS_M32R:
1783 case EM_M32R: return "Renesas M32R (formerly Mitsubishi M32r)";
1784 case EM_CYGNUS_V850:
1785 case EM_V850: return "NEC v850";
1786 case EM_CYGNUS_MN10300:
1787 case EM_MN10300: return "mn10300";
1788 case EM_CYGNUS_MN10200:
1789 case EM_MN10200: return "mn10200";
1790 case EM_CYGNUS_FR30:
1791 case EM_FR30: return "Fujitsu FR30";
1792 case EM_CYGNUS_FRV: return "Fujitsu FR-V";
1794 case EM_PJ: return "picoJava";
1795 case EM_MMA: return "Fujitsu Multimedia Accelerator";
1796 case EM_PCP: return "Siemens PCP";
1797 case EM_NCPU: return "Sony nCPU embedded RISC processor";
1798 case EM_NDR1: return "Denso NDR1 microprocesspr";
1799 case EM_STARCORE: return "Motorola Star*Core processor";
1800 case EM_ME16: return "Toyota ME16 processor";
1801 case EM_ST100: return "STMicroelectronics ST100 processor";
1802 case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
1803 case EM_FX66: return "Siemens FX66 microcontroller";
1804 case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1805 case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
1806 case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
1807 case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
1808 case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
1809 case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
1810 case EM_SVX: return "Silicon Graphics SVx";
1811 case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
1812 case EM_VAX: return "Digital VAX";
1814 case EM_AVR: return "Atmel AVR 8-bit microcontroller";
1815 case EM_CRIS: return "Axis Communications 32-bit embedded processor";
1816 case EM_JAVELIN: return "Infineon Technologies 32-bit embedded cpu";
1817 case EM_FIREPATH: return "Element 14 64-bit DSP processor";
1818 case EM_ZSP: return "LSI Logic's 16-bit DSP processor";
1819 case EM_MMIX: return "Donald Knuth's educational 64-bit processor";
1820 case EM_HUANY: return "Harvard Universitys's machine-independent object format";
1821 case EM_PRISM: return "Vitesse Prism";
1822 case EM_X86_64: return "Advanced Micro Devices X86-64";
1824 case EM_S390: return "IBM S/390";
1825 case EM_SCORE: return "SUNPLUS S+Core";
1826 case EM_XSTORMY16: return "Sanyo Xstormy16 CPU core";
1828 case EM_OR32: return "OpenRISC";
1829 case EM_CRX: return "National Semiconductor CRX microprocessor";
1830 case EM_DLX: return "OpenDLX";
1832 case EM_IP2K: return "Ubicom IP2xxx 8-bit microcontrollers";
1833 case EM_IQ2000: return "Vitesse IQ2000";
1835 case EM_XTENSA: return "Tensilica Xtensa Processor";
1837 case EM_M32C: return "Renesas M32c";
1838 case EM_MT: return "Morpho Techologies MT processor";
1839 case EM_BLACKFIN: return "Analog Devices Blackfin";
1840 case EM_NIOS32: return "Altera Nios";
1841 case EM_ALTERA_NIOS2: return "Altera Nios II";
1842 case EM_XC16X: return "Infineon Technologies xc16x";
1843 case EM_CYGNUS_MEP: return "Toshiba MeP Media Engine";
1845 case EM_CR16_OLD: return "National Semiconductor's CR16";
1847 snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
1853 decode_ARM_machine_flags (unsigned e_flags, char buf[])
1858 eabi = EF_ARM_EABI_VERSION (e_flags);
1859 e_flags &= ~ EF_ARM_EABIMASK;
1861 /* Handle "generic" ARM flags. */
1862 if (e_flags & EF_ARM_RELEXEC)
1864 strcat (buf, ", relocatable executable");
1865 e_flags &= ~ EF_ARM_RELEXEC;
1868 if (e_flags & EF_ARM_HASENTRY)
1870 strcat (buf, ", has entry point");
1871 e_flags &= ~ EF_ARM_HASENTRY;
1874 /* Now handle EABI specific flags. */
1878 strcat (buf, ", <unrecognized EABI>");
1883 case EF_ARM_EABI_VER1:
1884 strcat (buf, ", Version1 EABI");
1889 /* Process flags one bit at a time. */
1890 flag = e_flags & - e_flags;
1895 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
1896 strcat (buf, ", sorted symbol tables");
1906 case EF_ARM_EABI_VER2:
1907 strcat (buf, ", Version2 EABI");
1912 /* Process flags one bit at a time. */
1913 flag = e_flags & - e_flags;
1918 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
1919 strcat (buf, ", sorted symbol tables");
1922 case EF_ARM_DYNSYMSUSESEGIDX:
1923 strcat (buf, ", dynamic symbols use segment index");
1926 case EF_ARM_MAPSYMSFIRST:
1927 strcat (buf, ", mapping symbols precede others");
1937 case EF_ARM_EABI_VER3:
1938 strcat (buf, ", Version3 EABI");
1941 case EF_ARM_EABI_VER4:
1942 strcat (buf, ", Version4 EABI");
1945 case EF_ARM_EABI_VER5:
1946 strcat (buf, ", Version5 EABI");
1952 /* Process flags one bit at a time. */
1953 flag = e_flags & - e_flags;
1959 strcat (buf, ", BE8");
1963 strcat (buf, ", LE8");
1973 case EF_ARM_EABI_UNKNOWN:
1974 strcat (buf, ", GNU EABI");
1979 /* Process flags one bit at a time. */
1980 flag = e_flags & - e_flags;
1985 case EF_ARM_INTERWORK:
1986 strcat (buf, ", interworking enabled");
1989 case EF_ARM_APCS_26:
1990 strcat (buf, ", uses APCS/26");
1993 case EF_ARM_APCS_FLOAT:
1994 strcat (buf, ", uses APCS/float");
1998 strcat (buf, ", position independent");
2002 strcat (buf, ", 8 bit structure alignment");
2005 case EF_ARM_NEW_ABI:
2006 strcat (buf, ", uses new ABI");
2009 case EF_ARM_OLD_ABI:
2010 strcat (buf, ", uses old ABI");
2013 case EF_ARM_SOFT_FLOAT:
2014 strcat (buf, ", software FP");
2017 case EF_ARM_VFP_FLOAT:
2018 strcat (buf, ", VFP");
2021 case EF_ARM_MAVERICK_FLOAT:
2022 strcat (buf, ", Maverick FP");
2033 strcat (buf,", <unknown>");
2037 get_machine_flags (unsigned e_flags, unsigned e_machine)
2039 static char buf[1024];
2051 decode_ARM_machine_flags (e_flags, buf);
2055 switch (e_flags & EF_FRV_CPU_MASK)
2057 case EF_FRV_CPU_GENERIC:
2061 strcat (buf, ", fr???");
2064 case EF_FRV_CPU_FR300:
2065 strcat (buf, ", fr300");
2068 case EF_FRV_CPU_FR400:
2069 strcat (buf, ", fr400");
2071 case EF_FRV_CPU_FR405:
2072 strcat (buf, ", fr405");
2075 case EF_FRV_CPU_FR450:
2076 strcat (buf, ", fr450");
2079 case EF_FRV_CPU_FR500:
2080 strcat (buf, ", fr500");
2082 case EF_FRV_CPU_FR550:
2083 strcat (buf, ", fr550");
2086 case EF_FRV_CPU_SIMPLE:
2087 strcat (buf, ", simple");
2089 case EF_FRV_CPU_TOMCAT:
2090 strcat (buf, ", tomcat");
2096 if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
2097 strcat (buf, ", m68000");
2098 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
2099 strcat (buf, ", cpu32");
2100 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
2101 strcat (buf, ", fido_a");
2104 char const *isa = _("unknown");
2105 char const *mac = _("unknown mac");
2106 char const *additional = NULL;
2108 switch (e_flags & EF_M68K_CF_ISA_MASK)
2110 case EF_M68K_CF_ISA_A_NODIV:
2112 additional = ", nodiv";
2114 case EF_M68K_CF_ISA_A:
2117 case EF_M68K_CF_ISA_A_PLUS:
2120 case EF_M68K_CF_ISA_B_NOUSP:
2122 additional = ", nousp";
2124 case EF_M68K_CF_ISA_B:
2128 strcat (buf, ", cf, isa ");
2131 strcat (buf, additional);
2132 if (e_flags & EF_M68K_CF_FLOAT)
2133 strcat (buf, ", float");
2134 switch (e_flags & EF_M68K_CF_MAC_MASK)
2139 case EF_M68K_CF_MAC:
2142 case EF_M68K_CF_EMAC:
2155 if (e_flags & EF_PPC_EMB)
2156 strcat (buf, ", emb");
2158 if (e_flags & EF_PPC_RELOCATABLE)
2159 strcat (buf, ", relocatable");
2161 if (e_flags & EF_PPC_RELOCATABLE_LIB)
2162 strcat (buf, ", relocatable-lib");
2166 case EM_CYGNUS_V850:
2167 switch (e_flags & EF_V850_ARCH)
2170 strcat (buf, ", v850e1");
2173 strcat (buf, ", v850e");
2176 strcat (buf, ", v850");
2179 strcat (buf, ", unknown v850 architecture variant");
2185 case EM_CYGNUS_M32R:
2186 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
2187 strcat (buf, ", m32r");
2191 case EM_MIPS_RS3_LE:
2192 if (e_flags & EF_MIPS_NOREORDER)
2193 strcat (buf, ", noreorder");
2195 if (e_flags & EF_MIPS_PIC)
2196 strcat (buf, ", pic");
2198 if (e_flags & EF_MIPS_CPIC)
2199 strcat (buf, ", cpic");
2201 if (e_flags & EF_MIPS_UCODE)
2202 strcat (buf, ", ugen_reserved");
2204 if (e_flags & EF_MIPS_ABI2)
2205 strcat (buf, ", abi2");
2207 if (e_flags & EF_MIPS_OPTIONS_FIRST)
2208 strcat (buf, ", odk first");
2210 if (e_flags & EF_MIPS_32BITMODE)
2211 strcat (buf, ", 32bitmode");
2213 switch ((e_flags & EF_MIPS_MACH))
2215 case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
2216 case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
2217 case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
2218 case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
2219 case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
2220 case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
2221 case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
2222 case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
2223 case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); break;
2224 case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
2225 case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
2226 case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
2227 case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
2229 /* We simply ignore the field in this case to avoid confusion:
2230 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2233 default: strcat (buf, ", unknown CPU"); break;
2236 switch ((e_flags & EF_MIPS_ABI))
2238 case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
2239 case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
2240 case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
2241 case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
2243 /* We simply ignore the field in this case to avoid confusion:
2244 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2245 This means it is likely to be an o32 file, but not for
2248 default: strcat (buf, ", unknown ABI"); break;
2251 if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
2252 strcat (buf, ", mdmx");
2254 if (e_flags & EF_MIPS_ARCH_ASE_M16)
2255 strcat (buf, ", mips16");
2257 switch ((e_flags & EF_MIPS_ARCH))
2259 case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
2260 case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
2261 case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
2262 case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
2263 case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
2264 case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
2265 case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
2266 case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
2267 case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
2268 default: strcat (buf, ", unknown ISA"); break;
2274 switch ((e_flags & EF_SH_MACH_MASK))
2276 case EF_SH1: strcat (buf, ", sh1"); break;
2277 case EF_SH2: strcat (buf, ", sh2"); break;
2278 case EF_SH3: strcat (buf, ", sh3"); break;
2279 case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
2280 case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
2281 case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
2282 case EF_SH3E: strcat (buf, ", sh3e"); break;
2283 case EF_SH4: strcat (buf, ", sh4"); break;
2284 case EF_SH5: strcat (buf, ", sh5"); break;
2285 case EF_SH2E: strcat (buf, ", sh2e"); break;
2286 case EF_SH4A: strcat (buf, ", sh4a"); break;
2287 case EF_SH2A: strcat (buf, ", sh2a"); break;
2288 case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
2289 case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
2290 case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
2291 case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
2292 case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
2293 case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
2294 case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
2295 case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
2296 case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
2297 default: strcat (buf, ", unknown ISA"); break;
2303 if (e_flags & EF_SPARC_32PLUS)
2304 strcat (buf, ", v8+");
2306 if (e_flags & EF_SPARC_SUN_US1)
2307 strcat (buf, ", ultrasparcI");
2309 if (e_flags & EF_SPARC_SUN_US3)
2310 strcat (buf, ", ultrasparcIII");
2312 if (e_flags & EF_SPARC_HAL_R1)
2313 strcat (buf, ", halr1");
2315 if (e_flags & EF_SPARC_LEDATA)
2316 strcat (buf, ", ledata");
2318 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
2319 strcat (buf, ", tso");
2321 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
2322 strcat (buf, ", pso");
2324 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
2325 strcat (buf, ", rmo");
2329 switch (e_flags & EF_PARISC_ARCH)
2331 case EFA_PARISC_1_0:
2332 strcpy (buf, ", PA-RISC 1.0");
2334 case EFA_PARISC_1_1:
2335 strcpy (buf, ", PA-RISC 1.1");
2337 case EFA_PARISC_2_0:
2338 strcpy (buf, ", PA-RISC 2.0");
2343 if (e_flags & EF_PARISC_TRAPNIL)
2344 strcat (buf, ", trapnil");
2345 if (e_flags & EF_PARISC_EXT)
2346 strcat (buf, ", ext");
2347 if (e_flags & EF_PARISC_LSB)
2348 strcat (buf, ", lsb");
2349 if (e_flags & EF_PARISC_WIDE)
2350 strcat (buf, ", wide");
2351 if (e_flags & EF_PARISC_NO_KABP)
2352 strcat (buf, ", no kabp");
2353 if (e_flags & EF_PARISC_LAZYSWAP)
2354 strcat (buf, ", lazyswap");
2359 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
2360 strcat (buf, ", new calling convention");
2362 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
2363 strcat (buf, ", gnu calling convention");
2367 if ((e_flags & EF_IA_64_ABI64))
2368 strcat (buf, ", 64-bit");
2370 strcat (buf, ", 32-bit");
2371 if ((e_flags & EF_IA_64_REDUCEDFP))
2372 strcat (buf, ", reduced fp model");
2373 if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
2374 strcat (buf, ", no function descriptors, constant gp");
2375 else if ((e_flags & EF_IA_64_CONS_GP))
2376 strcat (buf, ", constant gp");
2377 if ((e_flags & EF_IA_64_ABSOLUTE))
2378 strcat (buf, ", absolute");
2382 if ((e_flags & EF_VAX_NONPIC))
2383 strcat (buf, ", non-PIC");
2384 if ((e_flags & EF_VAX_DFLOAT))
2385 strcat (buf, ", D-Float");
2386 if ((e_flags & EF_VAX_GFLOAT))
2387 strcat (buf, ", G-Float");
2396 get_osabi_name (unsigned int osabi)
2398 static char buff[32];
2402 case ELFOSABI_NONE: return "UNIX - System V";
2403 case ELFOSABI_HPUX: return "UNIX - HP-UX";
2404 case ELFOSABI_NETBSD: return "UNIX - NetBSD";
2405 case ELFOSABI_LINUX: return "UNIX - Linux";
2406 case ELFOSABI_HURD: return "GNU/Hurd";
2407 case ELFOSABI_SOLARIS: return "UNIX - Solaris";
2408 case ELFOSABI_AIX: return "UNIX - AIX";
2409 case ELFOSABI_IRIX: return "UNIX - IRIX";
2410 case ELFOSABI_FREEBSD: return "UNIX - FreeBSD";
2411 case ELFOSABI_TRU64: return "UNIX - TRU64";
2412 case ELFOSABI_MODESTO: return "Novell - Modesto";
2413 case ELFOSABI_OPENBSD: return "UNIX - OpenBSD";
2414 case ELFOSABI_OPENVMS: return "VMS - OpenVMS";
2415 case ELFOSABI_NSK: return "HP - Non-Stop Kernel";
2416 case ELFOSABI_AROS: return "AROS";
2417 case ELFOSABI_STANDALONE: return _("Standalone App");
2418 case ELFOSABI_ARM: return "ARM";
2420 snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
2426 get_arm_segment_type (unsigned long type)
2440 get_mips_segment_type (unsigned long type)
2444 case PT_MIPS_REGINFO:
2446 case PT_MIPS_RTPROC:
2448 case PT_MIPS_OPTIONS:
2458 get_parisc_segment_type (unsigned long type)
2462 case PT_HP_TLS: return "HP_TLS";
2463 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
2464 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
2465 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
2466 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
2467 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
2468 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
2469 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
2470 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
2471 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
2472 case PT_HP_PARALLEL: return "HP_PARALLEL";
2473 case PT_HP_FASTBIND: return "HP_FASTBIND";
2474 case PT_HP_OPT_ANNOT: return "HP_OPT_ANNOT";
2475 case PT_HP_HSL_ANNOT: return "HP_HSL_ANNOT";
2476 case PT_HP_STACK: return "HP_STACK";
2477 case PT_HP_CORE_UTSNAME: return "HP_CORE_UTSNAME";
2478 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
2479 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
2480 case PT_PARISC_WEAKORDER: return "PARISC_WEAKORDER";
2489 get_ia64_segment_type (unsigned long type)
2493 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
2494 case PT_IA_64_UNWIND: return "IA_64_UNWIND";
2495 case PT_HP_TLS: return "HP_TLS";
2496 case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
2497 case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
2498 case PT_IA_64_HP_STACK: return "HP_STACK";
2507 get_segment_type (unsigned long p_type)
2509 static char buff[32];
2513 case PT_NULL: return "NULL";
2514 case PT_LOAD: return "LOAD";
2515 case PT_DYNAMIC: return "DYNAMIC";
2516 case PT_INTERP: return "INTERP";
2517 case PT_NOTE: return "NOTE";
2518 case PT_SHLIB: return "SHLIB";
2519 case PT_PHDR: return "PHDR";
2520 case PT_TLS: return "TLS";
2522 case PT_GNU_EH_FRAME:
2523 return "GNU_EH_FRAME";
2524 case PT_GNU_STACK: return "GNU_STACK";
2525 case PT_GNU_RELRO: return "GNU_RELRO";
2528 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
2532 switch (elf_header.e_machine)
2535 result = get_arm_segment_type (p_type);
2538 case EM_MIPS_RS3_LE:
2539 result = get_mips_segment_type (p_type);
2542 result = get_parisc_segment_type (p_type);
2545 result = get_ia64_segment_type (p_type);
2555 sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
2557 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
2561 switch (elf_header.e_machine)
2564 result = get_parisc_segment_type (p_type);
2567 result = get_ia64_segment_type (p_type);
2577 sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
2580 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
2587 get_mips_section_type_name (unsigned int sh_type)
2591 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
2592 case SHT_MIPS_MSYM: return "MIPS_MSYM";
2593 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
2594 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
2595 case SHT_MIPS_UCODE: return "MIPS_UCODE";
2596 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
2597 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
2598 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
2599 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
2600 case SHT_MIPS_RELD: return "MIPS_RELD";
2601 case SHT_MIPS_IFACE: return "MIPS_IFACE";
2602 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
2603 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
2604 case SHT_MIPS_SHDR: return "MIPS_SHDR";
2605 case SHT_MIPS_FDESC: return "MIPS_FDESC";
2606 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
2607 case SHT_MIPS_DENSE: return "MIPS_DENSE";
2608 case SHT_MIPS_PDESC: return "MIPS_PDESC";
2609 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
2610 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
2611 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
2612 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
2613 case SHT_MIPS_LINE: return "MIPS_LINE";
2614 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
2615 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
2616 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
2617 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
2618 case SHT_MIPS_DWARF: return "MIPS_DWARF";
2619 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
2620 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
2621 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
2622 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
2623 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
2624 case SHT_MIPS_XLATE: return "MIPS_XLATE";
2625 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
2626 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
2627 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
2628 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
2629 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
2637 get_parisc_section_type_name (unsigned int sh_type)
2641 case SHT_PARISC_EXT: return "PARISC_EXT";
2642 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
2643 case SHT_PARISC_DOC: return "PARISC_DOC";
2644 case SHT_PARISC_ANNOT: return "PARISC_ANNOT";
2645 case SHT_PARISC_SYMEXTN: return "PARISC_SYMEXTN";
2646 case SHT_PARISC_STUBS: return "PARISC_STUBS";
2647 case SHT_PARISC_DLKM: return "PARISC_DLKM";
2655 get_ia64_section_type_name (unsigned int sh_type)
2657 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
2658 if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
2659 return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
2663 case SHT_IA_64_EXT: return "IA_64_EXT";
2664 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
2665 case SHT_IA_64_PRIORITY_INIT: return "IA_64_PRIORITY_INIT";
2666 case SHT_IA_64_VMS_TRACE: return "VMS_TRACE";
2667 case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
2668 case SHT_IA_64_VMS_DEBUG: return "VMS_DEBUG";
2669 case SHT_IA_64_VMS_DEBUG_STR: return "VMS_DEBUG_STR";
2670 case SHT_IA_64_VMS_LINKAGES: return "VMS_LINKAGES";
2671 case SHT_IA_64_VMS_SYMBOL_VECTOR: return "VMS_SYMBOL_VECTOR";
2672 case SHT_IA_64_VMS_FIXUP: return "VMS_FIXUP";
2680 get_x86_64_section_type_name (unsigned int sh_type)
2684 case SHT_X86_64_UNWIND: return "X86_64_UNWIND";
2692 get_arm_section_type_name (unsigned int sh_type)
2698 case SHT_ARM_PREEMPTMAP:
2699 return "ARM_PREEMPTMAP";
2700 case SHT_ARM_ATTRIBUTES:
2701 return "ARM_ATTRIBUTES";
2709 get_section_type_name (unsigned int sh_type)
2711 static char buff[32];
2715 case SHT_NULL: return "NULL";
2716 case SHT_PROGBITS: return "PROGBITS";
2717 case SHT_SYMTAB: return "SYMTAB";
2718 case SHT_STRTAB: return "STRTAB";
2719 case SHT_RELA: return "RELA";
2720 case SHT_HASH: return "HASH";
2721 case SHT_DYNAMIC: return "DYNAMIC";
2722 case SHT_NOTE: return "NOTE";
2723 case SHT_NOBITS: return "NOBITS";
2724 case SHT_REL: return "REL";
2725 case SHT_SHLIB: return "SHLIB";
2726 case SHT_DYNSYM: return "DYNSYM";
2727 case SHT_INIT_ARRAY: return "INIT_ARRAY";
2728 case SHT_FINI_ARRAY: return "FINI_ARRAY";
2729 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
2730 case SHT_GNU_HASH: return "GNU_HASH";
2731 case SHT_GROUP: return "GROUP";
2732 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICIES";
2733 case SHT_GNU_verdef: return "VERDEF";
2734 case SHT_GNU_verneed: return "VERNEED";
2735 case SHT_GNU_versym: return "VERSYM";
2736 case 0x6ffffff0: return "VERSYM";
2737 case 0x6ffffffc: return "VERDEF";
2738 case 0x7ffffffd: return "AUXILIARY";
2739 case 0x7fffffff: return "FILTER";
2740 case SHT_GNU_LIBLIST: return "GNU_LIBLIST";
2743 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
2747 switch (elf_header.e_machine)
2750 case EM_MIPS_RS3_LE:
2751 result = get_mips_section_type_name (sh_type);
2754 result = get_parisc_section_type_name (sh_type);
2757 result = get_ia64_section_type_name (sh_type);
2760 result = get_x86_64_section_type_name (sh_type);
2763 result = get_arm_section_type_name (sh_type);
2773 sprintf (buff, "LOPROC+%x", sh_type - SHT_LOPROC);
2775 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
2779 switch (elf_header.e_machine)
2782 result = get_ia64_section_type_name (sh_type);
2792 sprintf (buff, "LOOS+%x", sh_type - SHT_LOOS);
2794 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
2795 sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER);
2797 snprintf (buff, sizeof (buff), _("<unknown>: %x"), sh_type);
2803 #define OPTION_DEBUG_DUMP 512
2805 static struct option options[] =
2807 {"all", no_argument, 0, 'a'},
2808 {"file-header", no_argument, 0, 'h'},
2809 {"program-headers", no_argument, 0, 'l'},
2810 {"headers", no_argument, 0, 'e'},
2811 {"histogram", no_argument, 0, 'I'},
2812 {"segments", no_argument, 0, 'l'},
2813 {"sections", no_argument, 0, 'S'},
2814 {"section-headers", no_argument, 0, 'S'},
2815 {"section-groups", no_argument, 0, 'g'},
2816 {"section-details", no_argument, 0, 't'},
2817 {"full-section-name",no_argument, 0, 'N'},
2818 {"symbols", no_argument, 0, 's'},
2819 {"syms", no_argument, 0, 's'},
2820 {"relocs", no_argument, 0, 'r'},
2821 {"notes", no_argument, 0, 'n'},
2822 {"dynamic", no_argument, 0, 'd'},
2823 {"arch-specific", no_argument, 0, 'A'},
2824 {"version-info", no_argument, 0, 'V'},
2825 {"use-dynamic", no_argument, 0, 'D'},
2826 {"unwind", no_argument, 0, 'u'},
2827 {"archive-index", no_argument, 0, 'c'},
2828 {"hex-dump", required_argument, 0, 'x'},
2829 {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
2830 {"string-dump", required_argument, 0, 'p'},
2831 #ifdef SUPPORT_DISASSEMBLY
2832 {"instruction-dump", required_argument, 0, 'i'},
2835 {"version", no_argument, 0, 'v'},
2836 {"wide", no_argument, 0, 'W'},
2837 {"help", no_argument, 0, 'H'},
2838 {0, no_argument, 0, 0}
2842 usage (FILE *stream)
2844 fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
2845 fprintf (stream, _(" Display information about the contents of ELF format files\n"));
2846 fprintf (stream, _(" Options are:\n\
2847 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
2848 -h --file-header Display the ELF file header\n\
2849 -l --program-headers Display the program headers\n\
2850 --segments An alias for --program-headers\n\
2851 -S --section-headers Display the sections' header\n\
2852 --sections An alias for --section-headers\n\
2853 -g --section-groups Display the section groups\n\
2854 -t --section-details Display the section details\n\
2855 -e --headers Equivalent to: -h -l -S\n\
2856 -s --syms Display the symbol table\n\
2857 --symbols An alias for --syms\n\
2858 -n --notes Display the core notes (if present)\n\
2859 -r --relocs Display the relocations (if present)\n\
2860 -u --unwind Display the unwind info (if present)\n\
2861 -d --dynamic Display the dynamic section (if present)\n\
2862 -V --version-info Display the version sections (if present)\n\
2863 -A --arch-specific Display architecture specific information (if any).\n\
2864 -c --archive-index Display the symbol/file index in an archive\n\
2865 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
2866 -x --hex-dump=<number|name>\n\
2867 Dump the contents of section <number|name> as bytes\n\
2868 -p --string-dump=<number|name>\n\
2869 Dump the contents of section <number|name> as strings\n\
2870 -w[lLiaprmfFsoR] or\n\
2871 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,=str,=loc,=Ranges]\n\
2872 Display the contents of DWARF2 debug sections\n"));
2873 #ifdef SUPPORT_DISASSEMBLY
2874 fprintf (stream, _("\
2875 -i --instruction-dump=<number|name>\n\
2876 Disassemble the contents of section <number|name>\n"));
2878 fprintf (stream, _("\
2879 -I --histogram Display histogram of bucket list lengths\n\
2880 -W --wide Allow output width to exceed 80 characters\n\
2881 @<file> Read options from <file>\n\
2882 -H --help Display this information\n\
2883 -v --version Display the version number of readelf\n"));
2885 if (REPORT_BUGS_TO[0] && stream == stdout)
2886 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
2888 exit (stream == stdout ? 0 : 1);
2891 /* Record the fact that the user wants the contents of section number
2892 SECTION to be displayed using the method(s) encoded as flags bits
2893 in TYPE. Note, TYPE can be zero if we are creating the array for
2897 request_dump_bynumber (unsigned int section, dump_type type)
2899 if (section >= num_dump_sects)
2901 dump_type *new_dump_sects;
2903 new_dump_sects = calloc (section + 1, sizeof (* dump_sects));
2905 if (new_dump_sects == NULL)
2906 error (_("Out of memory allocating dump request table.\n"));
2909 /* Copy current flag settings. */
2910 memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
2914 dump_sects = new_dump_sects;
2915 num_dump_sects = section + 1;
2920 dump_sects[section] |= type;
2925 /* Request a dump by section name. */
2928 request_dump_byname (const char *section, dump_type type)
2930 struct dump_list_entry *new_request;
2932 new_request = malloc (sizeof (struct dump_list_entry));
2934 error (_("Out of memory allocating dump request table.\n"));
2936 new_request->name = strdup (section);
2937 if (!new_request->name)
2938 error (_("Out of memory allocating dump request table.\n"));
2940 new_request->type = type;
2942 new_request->next = dump_sects_byname;
2943 dump_sects_byname = new_request;
2947 parse_args (int argc, char **argv)
2954 while ((c = getopt_long
2955 (argc, argv, "ADHINSVWacdeghi:lnp:rstuvw::x:", options, NULL)) != EOF)
2976 do_section_groups++;
2984 do_section_groups++;
2989 do_section_details++;
3034 section = strtoul (optarg, & cp, 0);
3035 if (! *cp && section >= 0)
3036 request_dump_bynumber (section, HEX_DUMP);
3038 request_dump_byname (optarg, HEX_DUMP);
3042 section = strtoul (optarg, & cp, 0);
3043 if (! *cp && section >= 0)
3044 request_dump_bynumber (section, STRING_DUMP);
3046 request_dump_byname (optarg, STRING_DUMP);
3054 unsigned int index = 0;
3058 while (optarg[index])
3059 switch (optarg[index++])
3066 do_debug_abbrevs = 1;
3074 do_debug_lines_decoded = 1;
3078 do_debug_pubnames = 1;
3082 do_debug_aranges = 1;
3086 do_debug_ranges = 1;
3090 do_debug_frames_interp = 1;
3092 do_debug_frames = 1;
3096 do_debug_macinfo = 1;
3108 warn (_("Unrecognized debug option '%s'\n"), optarg);
3113 case OPTION_DEBUG_DUMP:
3121 const char * option;
3124 debug_dump_long_opts;
3126 debug_dump_long_opts opts_table [] =
3128 /* Please keep this table alpha- sorted. */
3129 { "Ranges", & do_debug_ranges },
3130 { "abbrev", & do_debug_abbrevs },
3131 { "aranges", & do_debug_aranges },
3132 { "frames", & do_debug_frames },
3133 { "frames-interp", & do_debug_frames_interp },
3134 { "info", & do_debug_info },
3135 { "line", & do_debug_lines }, /* For backwards compatibility. */
3136 { "rawline", & do_debug_lines },
3137 { "decodedline", & do_debug_lines_decoded },
3138 { "loc", & do_debug_loc },
3139 { "macro", & do_debug_macinfo },
3140 { "pubnames", & do_debug_pubnames },
3141 /* This entry is for compatability
3142 with earlier versions of readelf. */
3143 { "ranges", & do_debug_aranges },
3144 { "str", & do_debug_str },
3155 debug_dump_long_opts * entry;
3157 for (entry = opts_table; entry->option; entry++)
3159 size_t len = strlen (entry->option);
3161 if (strneq (p, entry->option, len)
3162 && (p[len] == ',' || p[len] == '\0'))
3164 * entry->variable = 1;
3166 /* The --debug-dump=frames-interp option also
3167 enables the --debug-dump=frames option. */
3168 if (do_debug_frames_interp)
3169 do_debug_frames = 1;
3176 if (entry->option == NULL)
3178 warn (_("Unrecognized debug option '%s'\n"), p);
3179 p = strchr (p, ',');
3189 #ifdef SUPPORT_DISASSEMBLY
3192 section = strtoul (optarg, & cp, 0);
3193 if (! *cp && section >= 0)
3194 request_dump_bynumber (section, DISASS_DUMP);
3196 request_dump_byname (optarg, DISASS_DUMP);
3199 print_version (program_name);
3208 /* xgettext:c-format */
3209 error (_("Invalid option '-%c'\n"), c);
3216 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
3217 && !do_segments && !do_header && !do_dump && !do_version
3218 && !do_histogram && !do_debugging && !do_arch && !do_notes
3219 && !do_section_groups && !do_archive_index)
3223 warn (_("Nothing to do.\n"));
3229 get_elf_class (unsigned int elf_class)
3231 static char buff[32];
3235 case ELFCLASSNONE: return _("none");
3236 case ELFCLASS32: return "ELF32";
3237 case ELFCLASS64: return "ELF64";
3239 snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
3245 get_data_encoding (unsigned int encoding)
3247 static char buff[32];
3251 case ELFDATANONE: return _("none");
3252 case ELFDATA2LSB: return _("2's complement, little endian");
3253 case ELFDATA2MSB: return _("2's complement, big endian");
3255 snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
3260 /* Decode the data held in 'elf_header'. */
3263 process_file_header (void)
3265 if ( elf_header.e_ident[EI_MAG0] != ELFMAG0
3266 || elf_header.e_ident[EI_MAG1] != ELFMAG1
3267 || elf_header.e_ident[EI_MAG2] != ELFMAG2
3268 || elf_header.e_ident[EI_MAG3] != ELFMAG3)
3271 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3275 init_dwarf_regnames (elf_header.e_machine);
3281 printf (_("ELF Header:\n"));
3282 printf (_(" Magic: "));
3283 for (i = 0; i < EI_NIDENT; i++)
3284 printf ("%2.2x ", elf_header.e_ident[i]);
3286 printf (_(" Class: %s\n"),
3287 get_elf_class (elf_header.e_ident[EI_CLASS]));
3288 printf (_(" Data: %s\n"),
3289 get_data_encoding (elf_header.e_ident[EI_DATA]));
3290 printf (_(" Version: %d %s\n"),
3291 elf_header.e_ident[EI_VERSION],
3292 (elf_header.e_ident[EI_VERSION] == EV_CURRENT
3294 : (elf_header.e_ident[EI_VERSION] != EV_NONE
3297 printf (_(" OS/ABI: %s\n"),
3298 get_osabi_name (elf_header.e_ident[EI_OSABI]));
3299 printf (_(" ABI Version: %d\n"),
3300 elf_header.e_ident[EI_ABIVERSION]);
3301 printf (_(" Type: %s\n"),
3302 get_file_type (elf_header.e_type));
3303 printf (_(" Machine: %s\n"),
3304 get_machine_name (elf_header.e_machine));
3305 printf (_(" Version: 0x%lx\n"),
3306 (unsigned long) elf_header.e_version);
3308 printf (_(" Entry point address: "));
3309 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
3310 printf (_("\n Start of program headers: "));
3311 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
3312 printf (_(" (bytes into file)\n Start of section headers: "));
3313 print_vma ((bfd_vma) elf_header.e_shoff, DEC);
3314 printf (_(" (bytes into file)\n"));
3316 printf (_(" Flags: 0x%lx%s\n"),
3317 (unsigned long) elf_header.e_flags,
3318 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
3319 printf (_(" Size of this header: %ld (bytes)\n"),
3320 (long) elf_header.e_ehsize);
3321 printf (_(" Size of program headers: %ld (bytes)\n"),
3322 (long) elf_header.e_phentsize);
3323 printf (_(" Number of program headers: %ld\n"),
3324 (long) elf_header.e_phnum);
3325 printf (_(" Size of section headers: %ld (bytes)\n"),
3326 (long) elf_header.e_shentsize);
3327 printf (_(" Number of section headers: %ld"),
3328 (long) elf_header.e_shnum);
3329 if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
3330 printf (" (%ld)", (long) section_headers[0].sh_size);
3331 putc ('\n', stdout);
3332 printf (_(" Section header string table index: %ld"),
3333 (long) elf_header.e_shstrndx);
3334 if (section_headers != NULL
3335 && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
3336 printf (" (%u)", section_headers[0].sh_link);
3337 else if (elf_header.e_shstrndx >= elf_header.e_shnum)
3338 printf (" <corrupt: out of range>");
3339 putc ('\n', stdout);
3342 if (section_headers != NULL)
3344 if (elf_header.e_shnum == SHN_UNDEF)
3345 elf_header.e_shnum = section_headers[0].sh_size;
3346 if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
3347 elf_header.e_shstrndx = section_headers[0].sh_link;
3348 else if (elf_header.e_shstrndx >= elf_header.e_shnum)
3349 elf_header.e_shstrndx = SHN_UNDEF;
3350 free (section_headers);
3351 section_headers = NULL;
3359 get_32bit_program_headers (FILE *file, Elf_Internal_Phdr *program_headers)
3361 Elf32_External_Phdr *phdrs;
3362 Elf32_External_Phdr *external;
3363 Elf_Internal_Phdr *internal;
3366 phdrs = get_data (NULL, file, elf_header.e_phoff,
3367 elf_header.e_phentsize, elf_header.e_phnum,
3368 _("program headers"));
3372 for (i = 0, internal = program_headers, external = phdrs;
3373 i < elf_header.e_phnum;
3374 i++, internal++, external++)
3376 internal->p_type = BYTE_GET (external->p_type);
3377 internal->p_offset = BYTE_GET (external->p_offset);
3378 internal->p_vaddr = BYTE_GET (external->p_vaddr);
3379 internal->p_paddr = BYTE_GET (external->p_paddr);
3380 internal->p_filesz = BYTE_GET (external->p_filesz);
3381 internal->p_memsz = BYTE_GET (external->p_memsz);
3382 internal->p_flags = BYTE_GET (external->p_flags);
3383 internal->p_align = BYTE_GET (external->p_align);
3392 get_64bit_program_headers (FILE *file, Elf_Internal_Phdr *program_headers)
3394 Elf64_External_Phdr *phdrs;
3395 Elf64_External_Phdr *external;
3396 Elf_Internal_Phdr *internal;
3399 phdrs = get_data (NULL, file, elf_header.e_phoff,
3400 elf_header.e_phentsize, elf_header.e_phnum,
3401 _("program headers"));
3405 for (i = 0, internal = program_headers, external = phdrs;
3406 i < elf_header.e_phnum;
3407 i++, internal++, external++)
3409 internal->p_type = BYTE_GET (external->p_type);
3410 internal->p_flags = BYTE_GET (external->p_flags);
3411 internal->p_offset = BYTE_GET (external->p_offset);
3412 internal->p_vaddr = BYTE_GET (external->p_vaddr);
3413 internal->p_paddr = BYTE_GET (external->p_paddr);
3414 internal->p_filesz = BYTE_GET (external->p_filesz);
3415 internal->p_memsz = BYTE_GET (external->p_memsz);
3416 internal->p_align = BYTE_GET (external->p_align);
3424 /* Returns 1 if the program headers were read into `program_headers'. */
3427 get_program_headers (FILE *file)
3429 Elf_Internal_Phdr *phdrs;
3431 /* Check cache of prior read. */
3432 if (program_headers != NULL)
3435 phdrs = cmalloc (elf_header.e_phnum, sizeof (Elf_Internal_Phdr));
3439 error (_("Out of memory\n"));
3444 ? get_32bit_program_headers (file, phdrs)
3445 : get_64bit_program_headers (file, phdrs))
3447 program_headers = phdrs;
3455 /* Returns 1 if the program headers were loaded. */
3458 process_program_headers (FILE *file)
3460 Elf_Internal_Phdr *segment;
3463 if (elf_header.e_phnum == 0)
3466 printf (_("\nThere are no program headers in this file.\n"));
3470 if (do_segments && !do_header)
3472 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
3473 printf (_("Entry point "));
3474 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
3475 printf (_("\nThere are %d program headers, starting at offset "),
3476 elf_header.e_phnum);
3477 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
3481 if (! get_program_headers (file))
3486 if (elf_header.e_phnum > 1)
3487 printf (_("\nProgram Headers:\n"));
3489 printf (_("\nProgram Headers:\n"));
3493 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3496 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3500 (_(" Type Offset VirtAddr PhysAddr\n"));
3502 (_(" FileSiz MemSiz Flags Align\n"));
3509 for (i = 0, segment = program_headers;
3510 i < elf_header.e_phnum;
3515 printf (" %-14.14s ", get_segment_type (segment->p_type));
3519 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
3520 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
3521 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
3522 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
3523 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
3525 (segment->p_flags & PF_R ? 'R' : ' '),
3526 (segment->p_flags & PF_W ? 'W' : ' '),
3527 (segment->p_flags & PF_X ? 'E' : ' '));
3528 printf ("%#lx", (unsigned long) segment->p_align);
3532 if ((unsigned long) segment->p_offset == segment->p_offset)
3533 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
3536 print_vma (segment->p_offset, FULL_HEX);
3540 print_vma (segment->p_vaddr, FULL_HEX);
3542 print_vma (segment->p_paddr, FULL_HEX);
3545 if ((unsigned long) segment->p_filesz == segment->p_filesz)
3546 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
3549 print_vma (segment->p_filesz, FULL_HEX);
3553 if ((unsigned long) segment->p_memsz == segment->p_memsz)
3554 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
3557 print_vma (segment->p_offset, FULL_HEX);
3561 (segment->p_flags & PF_R ? 'R' : ' '),
3562 (segment->p_flags & PF_W ? 'W' : ' '),
3563 (segment->p_flags & PF_X ? 'E' : ' '));
3565 if ((unsigned long) segment->p_align == segment->p_align)
3566 printf ("%#lx", (unsigned long) segment->p_align);
3569 print_vma (segment->p_align, PREFIX_HEX);
3574 print_vma (segment->p_offset, FULL_HEX);
3576 print_vma (segment->p_vaddr, FULL_HEX);
3578 print_vma (segment->p_paddr, FULL_HEX);
3580 print_vma (segment->p_filesz, FULL_HEX);
3582 print_vma (segment->p_memsz, FULL_HEX);
3584 (segment->p_flags & PF_R ? 'R' : ' '),
3585 (segment->p_flags & PF_W ? 'W' : ' '),
3586 (segment->p_flags & PF_X ? 'E' : ' '));
3587 print_vma (segment->p_align, HEX);
3591 switch (segment->p_type)
3595 error (_("more than one dynamic segment\n"));
3597 /* By default, assume that the .dynamic section is the first
3598 section in the DYNAMIC segment. */
3599 dynamic_addr = segment->p_offset;
3600 dynamic_size = segment->p_filesz;
3602 /* Try to locate the .dynamic section. If there is
3603 a section header table, we can easily locate it. */
3604 if (section_headers != NULL)
3606 Elf_Internal_Shdr *sec;
3608 sec = find_section (".dynamic");
3609 if (sec == NULL || sec->sh_size == 0)
3611 error (_("no .dynamic section in the dynamic segment\n"));
3615 if (sec->sh_type == SHT_NOBITS)
3621 dynamic_addr = sec->sh_offset;
3622 dynamic_size = sec->sh_size;
3624 if (dynamic_addr < segment->p_offset
3625 || dynamic_addr > segment->p_offset + segment->p_filesz)
3626 warn (_("the .dynamic section is not contained"
3627 " within the dynamic segment\n"));
3628 else if (dynamic_addr > segment->p_offset)
3629 warn (_("the .dynamic section is not the first section"
3630 " in the dynamic segment.\n"));
3635 if (fseek (file, archive_file_offset + (long) segment->p_offset,
3637 error (_("Unable to find program interpreter name\n"));
3641 int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX);
3643 if (ret >= (int) sizeof (fmt) || ret < 0)
3644 error (_("Internal error: failed to create format string to display program interpreter\n"));
3646 program_interpreter[0] = 0;
3647 if (fscanf (file, fmt, program_interpreter) <= 0)
3648 error (_("Unable to read program interpreter name\n"));
3651 printf (_("\n [Requesting program interpreter: %s]"),
3652 program_interpreter);
3658 putc ('\n', stdout);
3661 if (do_segments && section_headers != NULL && string_table != NULL)
3663 printf (_("\n Section to Segment mapping:\n"));
3664 printf (_(" Segment Sections...\n"));
3666 for (i = 0; i < elf_header.e_phnum; i++)
3669 Elf_Internal_Shdr *section;
3671 segment = program_headers + i;
3672 section = section_headers + 1;
3674 printf (" %2.2d ", i);
3676 for (j = 1; j < elf_header.e_shnum; j++, section++)
3678 if (ELF_IS_SECTION_IN_SEGMENT_MEMORY(section, segment))
3679 printf ("%s ", SECTION_NAME (section));
3690 /* Find the file offset corresponding to VMA by using the program headers. */
3693 offset_from_vma (FILE *file, bfd_vma vma, bfd_size_type size)
3695 Elf_Internal_Phdr *seg;
3697 if (! get_program_headers (file))
3699 warn (_("Cannot interpret virtual addresses without program headers.\n"));
3703 for (seg = program_headers;
3704 seg < program_headers + elf_header.e_phnum;
3707 if (seg->p_type != PT_LOAD)
3710 if (vma >= (seg->p_vaddr & -seg->p_align)
3711 && vma + size <= seg->p_vaddr + seg->p_filesz)
3712 return vma - seg->p_vaddr + seg->p_offset;
3715 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
3716 (unsigned long) vma);
3722 get_32bit_section_headers (FILE *file, unsigned int num)
3724 Elf32_External_Shdr *shdrs;
3725 Elf_Internal_Shdr *internal;
3728 shdrs = get_data (NULL, file, elf_header.e_shoff,
3729 elf_header.e_shentsize, num, _("section headers"));
3733 section_headers = cmalloc (num, sizeof (Elf_Internal_Shdr));
3735 if (section_headers == NULL)
3737 error (_("Out of memory\n"));
3741 for (i = 0, internal = section_headers;
3745 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
3746 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
3747 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
3748 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
3749 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
3750 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
3751 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
3752 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
3753 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
3754 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
3763 get_64bit_section_headers (FILE *file, unsigned int num)
3765 Elf64_External_Shdr *shdrs;
3766 Elf_Internal_Shdr *internal;
3769 shdrs = get_data (NULL, file, elf_header.e_shoff,
3770 elf_header.e_shentsize, num, _("section headers"));
3774 section_headers = cmalloc (num, sizeof (Elf_Internal_Shdr));
3776 if (section_headers == NULL)
3778 error (_("Out of memory\n"));
3782 for (i = 0, internal = section_headers;
3786 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
3787 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
3788 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
3789 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
3790 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
3791 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
3792 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
3793 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
3794 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
3795 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
3803 static Elf_Internal_Sym *
3804 get_32bit_elf_symbols (FILE *file, Elf_Internal_Shdr *section)
3806 unsigned long number;
3807 Elf32_External_Sym *esyms;
3808 Elf_External_Sym_Shndx *shndx;
3809 Elf_Internal_Sym *isyms;
3810 Elf_Internal_Sym *psym;
3813 esyms = get_data (NULL, file, section->sh_offset, 1, section->sh_size,
3819 if (symtab_shndx_hdr != NULL
3820 && (symtab_shndx_hdr->sh_link
3821 == (unsigned long) (section - section_headers)))
3823 shndx = get_data (NULL, file, symtab_shndx_hdr->sh_offset,
3824 1, symtab_shndx_hdr->sh_size, _("symtab shndx"));
3832 number = section->sh_size / section->sh_entsize;
3833 isyms = cmalloc (number, sizeof (Elf_Internal_Sym));
3837 error (_("Out of memory\n"));
3844 for (j = 0, psym = isyms;
3848 psym->st_name = BYTE_GET (esyms[j].st_name);
3849 psym->st_value = BYTE_GET (esyms[j].st_value);
3850 psym->st_size = BYTE_GET (esyms[j].st_size);
3851 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
3852 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
3854 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
3855 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
3856 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
3857 psym->st_info = BYTE_GET (esyms[j].st_info);
3858 psym->st_other = BYTE_GET (esyms[j].st_other);
3868 static Elf_Internal_Sym *
3869 get_64bit_elf_symbols (FILE *file, Elf_Internal_Shdr *section)
3871 unsigned long number;
3872 Elf64_External_Sym *esyms;
3873 Elf_External_Sym_Shndx *shndx;
3874 Elf_Internal_Sym *isyms;
3875 Elf_Internal_Sym *psym;
3878 esyms = get_data (NULL, file, section->sh_offset, 1, section->sh_size,
3884 if (symtab_shndx_hdr != NULL
3885 && (symtab_shndx_hdr->sh_link
3886 == (unsigned long) (section - section_headers)))
3888 shndx = get_data (NULL, file, symtab_shndx_hdr->sh_offset,
3889 1, symtab_shndx_hdr->sh_size, _("symtab shndx"));
3897 number = section->sh_size / section->sh_entsize;
3898 isyms = cmalloc (number, sizeof (Elf_Internal_Sym));
3902 error (_("Out of memory\n"));
3909 for (j = 0, psym = isyms;
3913 psym->st_name = BYTE_GET (esyms[j].st_name);
3914 psym->st_info = BYTE_GET (esyms[j].st_info);
3915 psym->st_other = BYTE_GET (esyms[j].st_other);
3916 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
3917 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
3919 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
3920 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
3921 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
3922 psym->st_value = BYTE_GET (esyms[j].st_value);
3923 psym->st_size = BYTE_GET (esyms[j].st_size);
3934 get_elf_section_flags (bfd_vma sh_flags)
3936 static char buff[1024];
3938 int field_size = is_32bit_elf ? 8 : 16;
3939 int index, size = sizeof (buff) - (field_size + 4 + 1);
3940 bfd_vma os_flags = 0;
3941 bfd_vma proc_flags = 0;
3942 bfd_vma unknown_flags = 0;
3956 { "LINK ORDER", 10 },
3957 { "OS NONCONF", 10 },
3960 /* IA-64 specific. */
3963 /* IA-64 OpenVMS specific. */
3964 { "VMS_GLOBAL", 10 },
3965 { "VMS_OVERLAID", 12 },
3966 { "VMS_SHARED", 10 },
3967 { "VMS_VECTOR", 10 },
3968 { "VMS_ALLOC_64BIT", 15 },
3969 { "VMS_PROTECTED", 13}
3972 if (do_section_details)
3974 sprintf (buff, "[%*.*lx]: ",
3975 field_size, field_size, (unsigned long) sh_flags);
3976 p += field_size + 4;
3983 flag = sh_flags & - sh_flags;
3986 if (do_section_details)
3990 case SHF_WRITE: index = 0; break;
3991 case SHF_ALLOC: index = 1; break;
3992 case SHF_EXECINSTR: index = 2; break;
3993 case SHF_MERGE: index = 3; break;
3994 case SHF_STRINGS: index = 4; break;
3995 case SHF_INFO_LINK: index = 5; break;
3996 case SHF_LINK_ORDER: index = 6; break;
3997 case SHF_OS_NONCONFORMING: index = 7; break;
3998 case SHF_GROUP: index = 8; break;
3999 case SHF_TLS: index = 9; break;
4003 if (elf_header.e_machine == EM_IA_64)
4005 if (flag == SHF_IA_64_SHORT)
4007 else if (flag == SHF_IA_64_NORECOV)
4010 else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
4013 case SHF_IA_64_VMS_GLOBAL: index = 12; break;
4014 case SHF_IA_64_VMS_OVERLAID: index = 13; break;
4015 case SHF_IA_64_VMS_SHARED: index = 14; break;
4016 case SHF_IA_64_VMS_VECTOR: index = 15; break;
4017 case SHF_IA_64_VMS_ALLOC_64BIT: index = 16; break;
4018 case SHF_IA_64_VMS_PROTECTED: index = 17; break;
4028 if (p != buff + field_size + 4)
4030 if (size < (10 + 2))
4037 size -= flags [index].len;
4038 p = stpcpy (p, flags [index].str);
4040 else if (flag & SHF_MASKOS)
4042 else if (flag & SHF_MASKPROC)
4045 unknown_flags |= flag;
4051 case SHF_WRITE: *p = 'W'; break;
4052 case SHF_ALLOC: *p = 'A'; break;
4053 case SHF_EXECINSTR: *p = 'X'; break;
4054 case SHF_MERGE: *p = 'M'; break;
4055 case SHF_STRINGS: *p = 'S'; break;
4056 case SHF_INFO_LINK: *p = 'I'; break;
4057 case SHF_LINK_ORDER: *p = 'L'; break;
4058 case SHF_OS_NONCONFORMING: *p = 'O'; break;
4059 case SHF_GROUP: *p = 'G'; break;
4060 case SHF_TLS: *p = 'T'; break;
4063 if (elf_header.e_machine == EM_X86_64
4064 && flag == SHF_X86_64_LARGE)
4066 else if (flag & SHF_MASKOS)
4069 sh_flags &= ~ SHF_MASKOS;
4071 else if (flag & SHF_MASKPROC)
4074 sh_flags &= ~ SHF_MASKPROC;
4084 if (do_section_details)
4088 size -= 5 + field_size;
4089 if (p != buff + field_size + 4)
4097 sprintf (p, "OS (%*.*lx)", field_size, field_size,
4098 (unsigned long) os_flags);
4099 p += 5 + field_size;
4103 size -= 7 + field_size;
4104 if (p != buff + field_size + 4)
4112 sprintf (p, "PROC (%*.*lx)", field_size, field_size,
4113 (unsigned long) proc_flags);
4114 p += 7 + field_size;
4118 size -= 10 + field_size;
4119 if (p != buff + field_size + 4)
4127 sprintf (p, "UNKNOWN (%*.*lx)", field_size, field_size,
4128 (unsigned long) unknown_flags);
4129 p += 10 + field_size;
4138 process_section_headers (FILE *file)
4140 Elf_Internal_Shdr *section;
4143 section_headers = NULL;
4145 if (elf_header.e_shnum == 0)
4148 printf (_("\nThere are no sections in this file.\n"));
4153 if (do_sections && !do_header)
4154 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
4155 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
4159 if (! get_32bit_section_headers (file, elf_header.e_shnum))
4162 else if (! get_64bit_section_headers (file, elf_header.e_shnum))
4165 /* Read in the string table, so that we have names to display. */
4166 if (elf_header.e_shstrndx != SHN_UNDEF
4167 && elf_header.e_shstrndx < elf_header.e_shnum)
4169 section = section_headers + elf_header.e_shstrndx;
4171 if (section->sh_size != 0)
4173 string_table = get_data (NULL, file, section->sh_offset,
4174 1, section->sh_size, _("string table"));
4176 string_table_length = string_table != NULL ? section->sh_size : 0;
4180 /* Scan the sections for the dynamic symbol table
4181 and dynamic string table and debug sections. */
4182 dynamic_symbols = NULL;
4183 dynamic_strings = NULL;
4184 dynamic_syminfo = NULL;
4185 symtab_shndx_hdr = NULL;
4187 eh_addr_size = is_32bit_elf ? 4 : 8;
4188 switch (elf_header.e_machine)
4191 case EM_MIPS_RS3_LE:
4192 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
4193 FDE addresses. However, the ABI also has a semi-official ILP32
4194 variant for which the normal FDE address size rules apply.
4196 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
4197 section, where XX is the size of longs in bits. Unfortunately,
4198 earlier compilers provided no way of distinguishing ILP32 objects
4199 from LP64 objects, so if there's any doubt, we should assume that
4200 the official LP64 form is being used. */
4201 if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
4202 && find_section (".gcc_compiled_long32") == NULL)
4208 switch (elf_header.e_flags & EF_H8_MACH)
4210 case E_H8_MACH_H8300:
4211 case E_H8_MACH_H8300HN:
4212 case E_H8_MACH_H8300SN:
4213 case E_H8_MACH_H8300SXN:
4216 case E_H8_MACH_H8300H:
4217 case E_H8_MACH_H8300S:
4218 case E_H8_MACH_H8300SX:
4226 switch (elf_header.e_flags & EF_M32C_CPU_MASK)
4228 case EF_M32C_CPU_M16C:
4235 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
4238 size_t expected_entsize \
4239 = is_32bit_elf ? size32 : size64; \
4240 if (section->sh_entsize != expected_entsize) \
4241 error (_("Section %d has invalid sh_entsize %lx (expected %lx)\n"), \
4242 i, (unsigned long int) section->sh_entsize, \
4243 (unsigned long int) expected_entsize); \
4244 section->sh_entsize = expected_entsize; \
4247 #define CHECK_ENTSIZE(section, i, type) \
4248 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
4249 sizeof (Elf64_External_##type))
4251 for (i = 0, section = section_headers;
4252 i < elf_header.e_shnum;
4255 char *name = SECTION_NAME (section);
4257 if (section->sh_type == SHT_DYNSYM)
4259 if (dynamic_symbols != NULL)
4261 error (_("File contains multiple dynamic symbol tables\n"));
4265 CHECK_ENTSIZE (section, i, Sym);
4266 num_dynamic_syms = section->sh_size / section->sh_entsize;
4267 dynamic_symbols = GET_ELF_SYMBOLS (file, section);
4269 else if (section->sh_type == SHT_STRTAB
4270 && streq (name, ".dynstr"))
4272 if (dynamic_strings != NULL)
4274 error (_("File contains multiple dynamic string tables\n"));
4278 dynamic_strings = get_data (NULL, file, section->sh_offset,
4279 1, section->sh_size, _("dynamic strings"));
4280 dynamic_strings_length = section->sh_size;
4282 else if (section->sh_type == SHT_SYMTAB_SHNDX)
4284 if (symtab_shndx_hdr != NULL)
4286 error (_("File contains multiple symtab shndx tables\n"));
4289 symtab_shndx_hdr = section;
4291 else if (section->sh_type == SHT_SYMTAB)
4292 CHECK_ENTSIZE (section, i, Sym);
4293 else if (section->sh_type == SHT_GROUP)
4294 CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
4295 else if (section->sh_type == SHT_REL)
4296 CHECK_ENTSIZE (section, i, Rel);
4297 else if (section->sh_type == SHT_RELA)
4298 CHECK_ENTSIZE (section, i, Rela);
4299 else if ((do_debugging || do_debug_info || do_debug_abbrevs
4300 || do_debug_lines || do_debug_lines_decoded || do_debug_pubnames
4301 || do_debug_aranges || do_debug_frames || do_debug_macinfo
4302 || do_debug_str || do_debug_loc || do_debug_ranges)
4303 && (const_strneq (name, ".debug_")
4304 || const_strneq (name, ".zdebug_")))
4307 name += sizeof (".zdebug_") - 1;
4309 name += sizeof (".debug_") - 1;
4312 || (do_debug_info && streq (name, "info"))
4313 || (do_debug_abbrevs && streq (name, "abbrev"))
4314 || ((do_debug_lines || do_debug_lines_decoded)
4315 && streq (name, "line"))
4316 || (do_debug_pubnames && streq (name, "pubnames"))
4317 || (do_debug_aranges && streq (name, "aranges"))
4318 || (do_debug_ranges && streq (name, "ranges"))
4319 || (do_debug_frames && streq (name, "frame"))
4320 || (do_debug_macinfo && streq (name, "macinfo"))
4321 || (do_debug_str && streq (name, "str"))
4322 || (do_debug_loc && streq (name, "loc"))
4324 request_dump_bynumber (i, DEBUG_DUMP);
4326 /* Linkonce section to be combined with .debug_info at link time. */
4327 else if ((do_debugging || do_debug_info)
4328 && const_strneq (name, ".gnu.linkonce.wi."))
4329 request_dump_bynumber (i, DEBUG_DUMP);
4330 else if (do_debug_frames && streq (name, ".eh_frame"))
4331 request_dump_bynumber (i, DEBUG_DUMP);
4337 if (elf_header.e_shnum > 1)
4338 printf (_("\nSection Headers:\n"));
4340 printf (_("\nSection Header:\n"));
4344 if (do_section_details)
4346 printf (_(" [Nr] Name\n"));
4347 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
4351 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
4355 if (do_section_details)
4357 printf (_(" [Nr] Name\n"));
4358 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
4362 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
4366 if (do_section_details)
4368 printf (_(" [Nr] Name\n"));
4369 printf (_(" Type Address Offset Link\n"));
4370 printf (_(" Size EntSize Info Align\n"));
4374 printf (_(" [Nr] Name Type Address Offset\n"));
4375 printf (_(" Size EntSize Flags Link Info Align\n"));
4379 if (do_section_details)
4380 printf (_(" Flags\n"));
4382 for (i = 0, section = section_headers;
4383 i < elf_header.e_shnum;
4386 if (do_section_details)
4388 printf (" [%2u] %s\n",
4390 SECTION_NAME (section));
4391 if (is_32bit_elf || do_wide)
4392 printf (" %-15.15s ",
4393 get_section_type_name (section->sh_type));
4396 printf ((do_wide ? " [%2u] %-17s %-15s "
4397 : " [%2u] %-17.17s %-15.15s "),
4399 SECTION_NAME (section),
4400 get_section_type_name (section->sh_type));
4404 print_vma (section->sh_addr, LONG_HEX);
4406 printf ( " %6.6lx %6.6lx %2.2lx",
4407 (unsigned long) section->sh_offset,
4408 (unsigned long) section->sh_size,
4409 (unsigned long) section->sh_entsize);
4411 if (do_section_details)
4412 fputs (" ", stdout);
4414 printf (" %3s ", get_elf_section_flags (section->sh_flags));
4416 printf ("%2u %3u %2lu\n",
4419 (unsigned long) section->sh_addralign);
4423 print_vma (section->sh_addr, LONG_HEX);
4425 if ((long) section->sh_offset == section->sh_offset)
4426 printf (" %6.6lx", (unsigned long) section->sh_offset);
4430 print_vma (section->sh_offset, LONG_HEX);
4433 if ((unsigned long) section->sh_size == section->sh_size)
4434 printf (" %6.6lx", (unsigned long) section->sh_size);
4438 print_vma (section->sh_size, LONG_HEX);
4441 if ((unsigned long) section->sh_entsize == section->sh_entsize)
4442 printf (" %2.2lx", (unsigned long) section->sh_entsize);
4446 print_vma (section->sh_entsize, LONG_HEX);
4449 if (do_section_details)
4450 fputs (" ", stdout);
4452 printf (" %3s ", get_elf_section_flags (section->sh_flags));
4454 printf ("%2u %3u ", section->sh_link, section->sh_info);
4456 if ((unsigned long) section->sh_addralign == section->sh_addralign)
4457 printf ("%2lu\n", (unsigned long) section->sh_addralign);
4460 print_vma (section->sh_addralign, DEC);
4464 else if (do_section_details)
4466 printf (" %-15.15s ",
4467 get_section_type_name (section->sh_type));
4468 print_vma (section->sh_addr, LONG_HEX);
4469 if ((long) section->sh_offset == section->sh_offset)
4470 printf (" %16.16lx", (unsigned long) section->sh_offset);
4474 print_vma (section->sh_offset, LONG_HEX);
4476 printf (" %u\n ", section->sh_link);
4477 print_vma (section->sh_size, LONG_HEX);
4479 print_vma (section->sh_entsize, LONG_HEX);
4481 printf (" %-16u %lu\n",
4483 (unsigned long) section->sh_addralign);
4488 print_vma (section->sh_addr, LONG_HEX);
4489 if ((long) section->sh_offset == section->sh_offset)
4490 printf (" %8.8lx", (unsigned long) section->sh_offset);
4494 print_vma (section->sh_offset, LONG_HEX);
4497 print_vma (section->sh_size, LONG_HEX);
4499 print_vma (section->sh_entsize, LONG_HEX);
4501 printf (" %3s ", get_elf_section_flags (section->sh_flags));
4503 printf (" %2u %3u %lu\n",
4506 (unsigned long) section->sh_addralign);
4509 if (do_section_details)
4510 printf (" %s\n", get_elf_section_flags (section->sh_flags));
4513 if (!do_section_details)
4514 printf (_("Key to Flags:\n\
4515 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
4516 I (info), L (link order), G (group), x (unknown)\n\
4517 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
4523 get_group_flags (unsigned int flags)
4525 static char buff[32];
4532 snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x]"), flags);
4539 process_section_groups (FILE *file)
4541 Elf_Internal_Shdr *section;
4543 struct group *group;
4544 Elf_Internal_Shdr *symtab_sec, *strtab_sec;
4545 Elf_Internal_Sym *symtab;
4549 /* Don't process section groups unless needed. */
4550 if (!do_unwind && !do_section_groups)
4553 if (elf_header.e_shnum == 0)
4555 if (do_section_groups)
4556 printf (_("\nThere are no sections in this file.\n"));
4561 if (section_headers == NULL)
4563 error (_("Section headers are not available!\n"));
4567 section_headers_groups = calloc (elf_header.e_shnum,
4568 sizeof (struct group *));
4570 if (section_headers_groups == NULL)
4572 error (_("Out of memory\n"));
4576 /* Scan the sections for the group section. */
4578 for (i = 0, section = section_headers;
4579 i < elf_header.e_shnum;
4581 if (section->sh_type == SHT_GROUP)
4584 if (group_count == 0)
4586 if (do_section_groups)
4587 printf (_("\nThere are no section groups in this file.\n"));
4592 section_groups = calloc (group_count, sizeof (struct group));
4594 if (section_groups == NULL)
4596 error (_("Out of memory\n"));
4605 for (i = 0, section = section_headers, group = section_groups;
4606 i < elf_header.e_shnum;
4609 if (section->sh_type == SHT_GROUP)
4611 char *name = SECTION_NAME (section);
4613 unsigned char *start, *indices;
4614 unsigned int entry, j, size;
4615 Elf_Internal_Shdr *sec;
4616 Elf_Internal_Sym *sym;
4618 /* Get the symbol table. */
4619 if (section->sh_link >= elf_header.e_shnum
4620 || ((sec = section_headers + section->sh_link)->sh_type
4623 error (_("Bad sh_link in group section `%s'\n"), name);
4627 if (symtab_sec != sec)
4632 symtab = GET_ELF_SYMBOLS (file, symtab_sec);
4635 sym = symtab + section->sh_info;
4637 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
4639 if (sym->st_shndx == 0
4640 || sym->st_shndx >= elf_header.e_shnum)
4642 error (_("Bad sh_info in group section `%s'\n"), name);
4646 group_name = SECTION_NAME (section_headers + sym->st_shndx);
4655 /* Get the string table. */
4656 if (symtab_sec->sh_link >= elf_header.e_shnum)
4665 != (sec = section_headers + symtab_sec->sh_link))
4670 strtab = get_data (NULL, file, strtab_sec->sh_offset,
4671 1, strtab_sec->sh_size,
4673 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
4675 group_name = sym->st_name < strtab_size
4676 ? strtab + sym->st_name : "<corrupt>";
4679 start = get_data (NULL, file, section->sh_offset,
4680 1, section->sh_size, _("section data"));
4683 size = (section->sh_size / section->sh_entsize) - 1;
4684 entry = byte_get (indices, 4);
4687 if (do_section_groups)
4689 printf ("\n%s group section [%5u] `%s' [%s] contains %u sections:\n",
4690 get_group_flags (entry), i, name, group_name, size);
4692 printf (_(" [Index] Name\n"));
4695 group->group_index = i;
4697 for (j = 0; j < size; j++)
4699 struct group_list *g;
4701 entry = byte_get (indices, 4);
4704 if (entry >= elf_header.e_shnum)
4706 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
4707 entry, i, elf_header.e_shnum - 1);
4711 if (section_headers_groups [entry] != NULL)
4715 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
4717 section_headers_groups [entry]->group_index);
4722 /* Intel C/C++ compiler may put section 0 in a
4723 section group. We just warn it the first time
4724 and ignore it afterwards. */
4725 static int warned = 0;
4728 error (_("section 0 in group section [%5u]\n"),
4729 section_headers_groups [entry]->group_index);
4735 section_headers_groups [entry] = group;
4737 if (do_section_groups)
4739 sec = section_headers + entry;
4740 printf (" [%5u] %s\n", entry, SECTION_NAME (sec));
4743 g = xmalloc (sizeof (struct group_list));
4744 g->section_index = entry;
4745 g->next = group->root;
4769 } dynamic_relocations [] =
4771 { "REL", DT_REL, DT_RELSZ, FALSE },
4772 { "RELA", DT_RELA, DT_RELASZ, TRUE },
4773 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
4776 /* Process the reloc section. */
4779 process_relocs (FILE *file)
4781 unsigned long rel_size;
4782 unsigned long rel_offset;
4788 if (do_using_dynamic)
4792 int has_dynamic_reloc;
4795 has_dynamic_reloc = 0;
4797 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
4799 is_rela = dynamic_relocations [i].rela;
4800 name = dynamic_relocations [i].name;
4801 rel_size = dynamic_info [dynamic_relocations [i].size];
4802 rel_offset = dynamic_info [dynamic_relocations [i].reloc];
4804 has_dynamic_reloc |= rel_size;
4806 if (is_rela == UNKNOWN)
4808 if (dynamic_relocations [i].reloc == DT_JMPREL)
4809 switch (dynamic_info[DT_PLTREL])
4823 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
4824 name, rel_offset, rel_size);
4826 dump_relocations (file,
4827 offset_from_vma (file, rel_offset, rel_size),
4829 dynamic_symbols, num_dynamic_syms,
4830 dynamic_strings, dynamic_strings_length, is_rela);
4834 if (! has_dynamic_reloc)
4835 printf (_("\nThere are no dynamic relocations in this file.\n"));
4839 Elf_Internal_Shdr *section;
4843 for (i = 0, section = section_headers;
4844 i < elf_header.e_shnum;
4847 if ( section->sh_type != SHT_RELA
4848 && section->sh_type != SHT_REL)
4851 rel_offset = section->sh_offset;
4852 rel_size = section->sh_size;
4856 Elf_Internal_Shdr *strsec;
4859 printf (_("\nRelocation section "));
4861 if (string_table == NULL)
4862 printf ("%d", section->sh_name);
4864 printf (_("'%s'"), SECTION_NAME (section));
4866 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4867 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
4869 is_rela = section->sh_type == SHT_RELA;
4871 if (section->sh_link != 0
4872 && section->sh_link < elf_header.e_shnum)
4874 Elf_Internal_Shdr *symsec;
4875 Elf_Internal_Sym *symtab;
4876 unsigned long nsyms;
4877 unsigned long strtablen = 0;
4878 char *strtab = NULL;
4880 symsec = section_headers + section->sh_link;
4881 if (symsec->sh_type != SHT_SYMTAB
4882 && symsec->sh_type != SHT_DYNSYM)
4885 nsyms = symsec->sh_size / symsec->sh_entsize;
4886 symtab = GET_ELF_SYMBOLS (file, symsec);
4891 if (symsec->sh_link != 0
4892 && symsec->sh_link < elf_header.e_shnum)
4894 strsec = section_headers + symsec->sh_link;
4896 strtab = get_data (NULL, file, strsec->sh_offset,
4899 strtablen = strtab == NULL ? 0 : strsec->sh_size;
4902 dump_relocations (file, rel_offset, rel_size,
4903 symtab, nsyms, strtab, strtablen, is_rela);
4909 dump_relocations (file, rel_offset, rel_size,
4910 NULL, 0, NULL, 0, is_rela);
4917 printf (_("\nThere are no relocations in this file.\n"));
4923 /* Process the unwind section. */
4925 #include "unwind-ia64.h"
4927 /* An absolute address consists of a section and an offset. If the
4928 section is NULL, the offset itself is the address, otherwise, the
4929 address equals to LOAD_ADDRESS(section) + offset. */
4933 unsigned short section;
4937 #define ABSADDR(a) \
4939 ? section_headers [(a).section].sh_addr + (a).offset \
4942 struct ia64_unw_aux_info
4944 struct ia64_unw_table_entry
4946 struct absaddr start;
4948 struct absaddr info;
4950 *table; /* Unwind table. */
4951 unsigned long table_len; /* Length of unwind table. */
4952 unsigned char *info; /* Unwind info. */
4953 unsigned long info_size; /* Size of unwind info. */
4954 bfd_vma info_addr; /* starting address of unwind info. */
4955 bfd_vma seg_base; /* Starting address of segment. */
4956 Elf_Internal_Sym *symtab; /* The symbol table. */
4957 unsigned long nsyms; /* Number of symbols. */
4958 char *strtab; /* The string table. */
4959 unsigned long strtab_size; /* Size of string table. */
4963 find_symbol_for_address (Elf_Internal_Sym *symtab,
4964 unsigned long nsyms,
4966 unsigned long strtab_size,
4967 struct absaddr addr,
4968 const char **symname,
4971 bfd_vma dist = 0x100000;
4972 Elf_Internal_Sym *sym, *best = NULL;
4975 for (i = 0, sym = symtab; i < nsyms; ++i, ++sym)
4977 if (ELF_ST_TYPE (sym->st_info) == STT_FUNC
4978 && sym->st_name != 0
4979 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
4980 && addr.offset >= sym->st_value
4981 && addr.offset - sym->st_value < dist)
4984 dist = addr.offset - sym->st_value;
4991 *symname = (best->st_name >= strtab_size
4992 ? "<corrupt>" : strtab + best->st_name);
4997 *offset = addr.offset;
5001 dump_ia64_unwind (struct ia64_unw_aux_info *aux)
5003 struct ia64_unw_table_entry *tp;
5006 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
5010 const unsigned char *dp;
5011 const unsigned char *head;
5012 const char *procname;
5014 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
5015 aux->strtab_size, tp->start, &procname, &offset);
5017 fputs ("\n<", stdout);
5021 fputs (procname, stdout);
5024 printf ("+%lx", (unsigned long) offset);
5027 fputs (">: [", stdout);
5028 print_vma (tp->start.offset, PREFIX_HEX);
5029 fputc ('-', stdout);
5030 print_vma (tp->end.offset, PREFIX_HEX);
5031 printf ("], info at +0x%lx\n",
5032 (unsigned long) (tp->info.offset - aux->seg_base));
5034 head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
5035 stamp = byte_get ((unsigned char *) head, sizeof (stamp));
5037 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
5038 (unsigned) UNW_VER (stamp),
5039 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
5040 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
5041 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
5042 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
5044 if (UNW_VER (stamp) != 1)
5046 printf ("\tUnknown version.\n");
5051 for (dp = head + 8; dp < head + 8 + eh_addr_size * UNW_LENGTH (stamp);)
5052 dp = unw_decode (dp, in_body, & in_body);
5057 slurp_ia64_unwind_table (FILE *file,
5058 struct ia64_unw_aux_info *aux,
5059 Elf_Internal_Shdr *sec)
5061 unsigned long size, nrelas, i;
5062 Elf_Internal_Phdr *seg;
5063 struct ia64_unw_table_entry *tep;
5064 Elf_Internal_Shdr *relsec;
5065 Elf_Internal_Rela *rela, *rp;
5066 unsigned char *table, *tp;
5067 Elf_Internal_Sym *sym;
5068 const char *relname;
5070 /* First, find the starting address of the segment that includes
5073 if (elf_header.e_phnum)
5075 if (! get_program_headers (file))
5078 for (seg = program_headers;
5079 seg < program_headers + elf_header.e_phnum;
5082 if (seg->p_type != PT_LOAD)
5085 if (sec->sh_addr >= seg->p_vaddr
5086 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
5088 aux->seg_base = seg->p_vaddr;
5094 /* Second, build the unwind table from the contents of the unwind section: */
5095 size = sec->sh_size;
5096 table = get_data (NULL, file, sec->sh_offset, 1, size, _("unwind table"));
5100 aux->table = xcmalloc (size / (3 * eh_addr_size), sizeof (aux->table[0]));
5102 for (tp = table; tp < table + size; tp += 3 * eh_addr_size, ++tep)
5104 tep->start.section = SHN_UNDEF;
5105 tep->end.section = SHN_UNDEF;
5106 tep->info.section = SHN_UNDEF;
5109 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
5110 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
5111 tep->info.offset = byte_get ((unsigned char *) tp + 8, 4);
5115 tep->start.offset = BYTE_GET ((unsigned char *) tp + 0);
5116 tep->end.offset = BYTE_GET ((unsigned char *) tp + 8);
5117 tep->info.offset = BYTE_GET ((unsigned char *) tp + 16);
5119 tep->start.offset += aux->seg_base;
5120 tep->end.offset += aux->seg_base;
5121 tep->info.offset += aux->seg_base;
5125 /* Third, apply any relocations to the unwind table: */
5126 for (relsec = section_headers;
5127 relsec < section_headers + elf_header.e_shnum;
5130 if (relsec->sh_type != SHT_RELA
5131 || relsec->sh_info >= elf_header.e_shnum
5132 || section_headers + relsec->sh_info != sec)
5135 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
5139 for (rp = rela; rp < rela + nrelas; ++rp)
5141 relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
5142 sym = aux->symtab + get_reloc_symindex (rp->r_info);
5144 if (! const_strneq (relname, "R_IA64_SEGREL"))
5146 warn (_("Skipping unexpected relocation type %s\n"), relname);
5150 i = rp->r_offset / (3 * eh_addr_size);
5152 switch (rp->r_offset/eh_addr_size % 3)
5155 aux->table[i].start.section = sym->st_shndx;
5156 aux->table[i].start.offset += rp->r_addend + sym->st_value;
5159 aux->table[i].end.section = sym->st_shndx;
5160 aux->table[i].end.offset += rp->r_addend + sym->st_value;
5163 aux->table[i].info.section = sym->st_shndx;
5164 aux->table[i].info.offset += rp->r_addend + sym->st_value;
5174 aux->table_len = size / (3 * eh_addr_size);
5179 ia64_process_unwind (FILE *file)
5181 Elf_Internal_Shdr *sec, *unwsec = NULL, *strsec;
5182 unsigned long i, unwcount = 0, unwstart = 0;
5183 struct ia64_unw_aux_info aux;
5185 memset (& aux, 0, sizeof (aux));
5187 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
5189 if (sec->sh_type == SHT_SYMTAB
5190 && sec->sh_link < elf_header.e_shnum)
5192 aux.nsyms = sec->sh_size / sec->sh_entsize;
5193 aux.symtab = GET_ELF_SYMBOLS (file, sec);
5195 strsec = section_headers + sec->sh_link;
5196 aux.strtab = get_data (NULL, file, strsec->sh_offset,
5197 1, strsec->sh_size, _("string table"));
5198 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
5200 else if (sec->sh_type == SHT_IA_64_UNWIND)
5205 printf (_("\nThere are no unwind sections in this file.\n"));
5207 while (unwcount-- > 0)
5212 for (i = unwstart, sec = section_headers + unwstart;
5213 i < elf_header.e_shnum; ++i, ++sec)
5214 if (sec->sh_type == SHT_IA_64_UNWIND)
5221 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
5223 if ((unwsec->sh_flags & SHF_GROUP) != 0)
5225 /* We need to find which section group it is in. */
5226 struct group_list *g = section_headers_groups [i]->root;
5228 for (; g != NULL; g = g->next)
5230 sec = section_headers + g->section_index;
5232 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
5237 i = elf_header.e_shnum;
5239 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
5241 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
5242 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
5243 suffix = SECTION_NAME (unwsec) + len;
5244 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
5246 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
5247 && streq (SECTION_NAME (sec) + len2, suffix))
5252 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
5253 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
5254 len = sizeof (ELF_STRING_ia64_unwind) - 1;
5255 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
5257 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
5258 suffix = SECTION_NAME (unwsec) + len;
5259 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
5261 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
5262 && streq (SECTION_NAME (sec) + len2, suffix))
5266 if (i == elf_header.e_shnum)
5268 printf (_("\nCould not find unwind info section for "));
5270 if (string_table == NULL)
5271 printf ("%d", unwsec->sh_name);
5273 printf (_("'%s'"), SECTION_NAME (unwsec));
5277 aux.info_size = sec->sh_size;
5278 aux.info_addr = sec->sh_addr;
5279 aux.info = get_data (NULL, file, sec->sh_offset, 1, aux.info_size,
5282 printf (_("\nUnwind section "));
5284 if (string_table == NULL)
5285 printf ("%d", unwsec->sh_name);
5287 printf (_("'%s'"), SECTION_NAME (unwsec));
5289 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5290 (unsigned long) unwsec->sh_offset,
5291 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
5293 (void) slurp_ia64_unwind_table (file, & aux, unwsec);
5295 if (aux.table_len > 0)
5296 dump_ia64_unwind (& aux);
5299 free ((char *) aux.table);
5301 free ((char *) aux.info);
5310 free ((char *) aux.strtab);
5315 struct hppa_unw_aux_info
5317 struct hppa_unw_table_entry
5319 struct absaddr start;
5321 unsigned int Cannot_unwind:1; /* 0 */
5322 unsigned int Millicode:1; /* 1 */
5323 unsigned int Millicode_save_sr0:1; /* 2 */
5324 unsigned int Region_description:2; /* 3..4 */
5325 unsigned int reserved1:1; /* 5 */
5326 unsigned int Entry_SR:1; /* 6 */
5327 unsigned int Entry_FR:4; /* number saved */ /* 7..10 */
5328 unsigned int Entry_GR:5; /* number saved */ /* 11..15 */
5329 unsigned int Args_stored:1; /* 16 */
5330 unsigned int Variable_Frame:1; /* 17 */
5331 unsigned int Separate_Package_Body:1; /* 18 */
5332 unsigned int Frame_Extension_Millicode:1; /* 19 */
5333 unsigned int Stack_Overflow_Check:1; /* 20 */
5334 unsigned int Two_Instruction_SP_Increment:1; /* 21 */
5335 unsigned int Ada_Region:1; /* 22 */
5336 unsigned int cxx_info:1; /* 23 */
5337 unsigned int cxx_try_catch:1; /* 24 */
5338 unsigned int sched_entry_seq:1; /* 25 */
5339 unsigned int reserved2:1; /* 26 */
5340 unsigned int Save_SP:1; /* 27 */
5341 unsigned int Save_RP:1; /* 28 */
5342 unsigned int Save_MRP_in_frame:1; /* 29 */
5343 unsigned int extn_ptr_defined:1; /* 30 */
5344 unsigned int Cleanup_defined:1; /* 31 */
5346 unsigned int MPE_XL_interrupt_marker:1; /* 0 */
5347 unsigned int HP_UX_interrupt_marker:1; /* 1 */
5348 unsigned int Large_frame:1; /* 2 */
5349 unsigned int Pseudo_SP_Set:1; /* 3 */
5350 unsigned int reserved4:1; /* 4 */
5351 unsigned int Total_frame_size:27; /* 5..31 */
5353 *table; /* Unwind table. */
5354 unsigned long table_len; /* Length of unwind table. */
5355 bfd_vma seg_base; /* Starting address of segment. */
5356 Elf_Internal_Sym *symtab; /* The symbol table. */
5357 unsigned long nsyms; /* Number of symbols. */
5358 char *strtab; /* The string table. */
5359 unsigned long strtab_size; /* Size of string table. */
5363 dump_hppa_unwind (struct hppa_unw_aux_info *aux)
5365 struct hppa_unw_table_entry *tp;
5367 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
5370 const char *procname;
5372 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
5373 aux->strtab_size, tp->start, &procname,
5376 fputs ("\n<", stdout);
5380 fputs (procname, stdout);
5383 printf ("+%lx", (unsigned long) offset);
5386 fputs (">: [", stdout);
5387 print_vma (tp->start.offset, PREFIX_HEX);
5388 fputc ('-', stdout);
5389 print_vma (tp->end.offset, PREFIX_HEX);
5392 #define PF(_m) if (tp->_m) printf (#_m " ");
5393 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
5396 PF(Millicode_save_sr0);
5397 /* PV(Region_description); */
5403 PF(Separate_Package_Body);
5404 PF(Frame_Extension_Millicode);
5405 PF(Stack_Overflow_Check);
5406 PF(Two_Instruction_SP_Increment);
5410 PF(sched_entry_seq);
5413 PF(Save_MRP_in_frame);
5414 PF(extn_ptr_defined);
5415 PF(Cleanup_defined);
5416 PF(MPE_XL_interrupt_marker);
5417 PF(HP_UX_interrupt_marker);
5420 PV(Total_frame_size);
5429 slurp_hppa_unwind_table (FILE *file,
5430 struct hppa_unw_aux_info *aux,
5431 Elf_Internal_Shdr *sec)
5433 unsigned long size, unw_ent_size, nentries, nrelas, i;
5434 Elf_Internal_Phdr *seg;
5435 struct hppa_unw_table_entry *tep;
5436 Elf_Internal_Shdr *relsec;
5437 Elf_Internal_Rela *rela, *rp;
5438 unsigned char *table, *tp;
5439 Elf_Internal_Sym *sym;
5440 const char *relname;
5442 /* First, find the starting address of the segment that includes
5445 if (elf_header.e_phnum)
5447 if (! get_program_headers (file))
5450 for (seg = program_headers;
5451 seg < program_headers + elf_header.e_phnum;
5454 if (seg->p_type != PT_LOAD)
5457 if (sec->sh_addr >= seg->p_vaddr
5458 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
5460 aux->seg_base = seg->p_vaddr;
5466 /* Second, build the unwind table from the contents of the unwind
5468 size = sec->sh_size;
5469 table = get_data (NULL, file, sec->sh_offset, 1, size, _("unwind table"));
5474 nentries = size / unw_ent_size;
5475 size = unw_ent_size * nentries;
5477 tep = aux->table = xcmalloc (nentries, sizeof (aux->table[0]));
5479 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
5481 unsigned int tmp1, tmp2;
5483 tep->start.section = SHN_UNDEF;
5484 tep->end.section = SHN_UNDEF;
5486 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
5487 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
5488 tmp1 = byte_get ((unsigned char *) tp + 8, 4);
5489 tmp2 = byte_get ((unsigned char *) tp + 12, 4);
5491 tep->start.offset += aux->seg_base;
5492 tep->end.offset += aux->seg_base;
5494 tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
5495 tep->Millicode = (tmp1 >> 30) & 0x1;
5496 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
5497 tep->Region_description = (tmp1 >> 27) & 0x3;
5498 tep->reserved1 = (tmp1 >> 26) & 0x1;
5499 tep->Entry_SR = (tmp1 >> 25) & 0x1;
5500 tep->Entry_FR = (tmp1 >> 21) & 0xf;
5501 tep->Entry_GR = (tmp1 >> 16) & 0x1f;
5502 tep->Args_stored = (tmp1 >> 15) & 0x1;
5503 tep->Variable_Frame = (tmp1 >> 14) & 0x1;
5504 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
5505 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
5506 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
5507 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
5508 tep->Ada_Region = (tmp1 >> 9) & 0x1;
5509 tep->cxx_info = (tmp1 >> 8) & 0x1;
5510 tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
5511 tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
5512 tep->reserved2 = (tmp1 >> 5) & 0x1;
5513 tep->Save_SP = (tmp1 >> 4) & 0x1;
5514 tep->Save_RP = (tmp1 >> 3) & 0x1;
5515 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
5516 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
5517 tep->Cleanup_defined = tmp1 & 0x1;
5519 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
5520 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
5521 tep->Large_frame = (tmp2 >> 29) & 0x1;
5522 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
5523 tep->reserved4 = (tmp2 >> 27) & 0x1;
5524 tep->Total_frame_size = tmp2 & 0x7ffffff;
5528 /* Third, apply any relocations to the unwind table. */
5529 for (relsec = section_headers;
5530 relsec < section_headers + elf_header.e_shnum;
5533 if (relsec->sh_type != SHT_RELA
5534 || relsec->sh_info >= elf_header.e_shnum
5535 || section_headers + relsec->sh_info != sec)
5538 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
5542 for (rp = rela; rp < rela + nrelas; ++rp)
5544 relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
5545 sym = aux->symtab + get_reloc_symindex (rp->r_info);
5547 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
5548 if (! const_strneq (relname, "R_PARISC_SEGREL"))
5550 warn (_("Skipping unexpected relocation type %s\n"), relname);
5554 i = rp->r_offset / unw_ent_size;
5556 switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
5559 aux->table[i].start.section = sym->st_shndx;
5560 aux->table[i].start.offset += sym->st_value + rp->r_addend;
5563 aux->table[i].end.section = sym->st_shndx;
5564 aux->table[i].end.offset += sym->st_value + rp->r_addend;
5574 aux->table_len = nentries;
5580 hppa_process_unwind (FILE *file)
5582 struct hppa_unw_aux_info aux;
5583 Elf_Internal_Shdr *unwsec = NULL;
5584 Elf_Internal_Shdr *strsec;
5585 Elf_Internal_Shdr *sec;
5588 memset (& aux, 0, sizeof (aux));
5590 if (string_table == NULL)
5593 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
5595 if (sec->sh_type == SHT_SYMTAB
5596 && sec->sh_link < elf_header.e_shnum)
5598 aux.nsyms = sec->sh_size / sec->sh_entsize;
5599 aux.symtab = GET_ELF_SYMBOLS (file, sec);
5601 strsec = section_headers + sec->sh_link;
5602 aux.strtab = get_data (NULL, file, strsec->sh_offset,
5603 1, strsec->sh_size, _("string table"));
5604 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
5606 else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
5611 printf (_("\nThere are no unwind sections in this file.\n"));
5613 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
5615 if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
5617 printf (_("\nUnwind section "));
5618 printf (_("'%s'"), SECTION_NAME (sec));
5620 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5621 (unsigned long) sec->sh_offset,
5622 (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
5624 slurp_hppa_unwind_table (file, &aux, sec);
5625 if (aux.table_len > 0)
5626 dump_hppa_unwind (&aux);
5629 free ((char *) aux.table);
5637 free ((char *) aux.strtab);
5643 process_unwind (FILE *file)
5645 struct unwind_handler {
5647 int (*handler)(FILE *file);
5649 { EM_IA_64, ia64_process_unwind },
5650 { EM_PARISC, hppa_process_unwind },
5658 for (i = 0; handlers[i].handler != NULL; i++)
5659 if (elf_header.e_machine == handlers[i].machtype)
5660 return handlers[i].handler (file);
5662 printf (_("\nThere are no unwind sections in this file.\n"));
5667 dynamic_section_mips_val (Elf_Internal_Dyn *entry)
5669 switch (entry->d_tag)
5672 if (entry->d_un.d_val == 0)
5676 static const char * opts[] =
5678 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
5679 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
5680 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
5681 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
5686 for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
5687 if (entry->d_un.d_val & (1 << cnt))
5689 printf ("%s%s", first ? "" : " ", opts[cnt]);
5696 case DT_MIPS_IVERSION:
5697 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
5698 printf ("Interface Version: %s\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
5700 printf ("<corrupt: %ld>\n", (long) entry->d_un.d_ptr);
5703 case DT_MIPS_TIME_STAMP:
5708 time_t time = entry->d_un.d_val;
5709 tmp = gmtime (&time);
5710 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
5711 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
5712 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
5713 printf ("Time Stamp: %s\n", timebuf);
5717 case DT_MIPS_RLD_VERSION:
5718 case DT_MIPS_LOCAL_GOTNO:
5719 case DT_MIPS_CONFLICTNO:
5720 case DT_MIPS_LIBLISTNO:
5721 case DT_MIPS_SYMTABNO:
5722 case DT_MIPS_UNREFEXTNO:
5723 case DT_MIPS_HIPAGENO:
5724 case DT_MIPS_DELTA_CLASS_NO:
5725 case DT_MIPS_DELTA_INSTANCE_NO:
5726 case DT_MIPS_DELTA_RELOC_NO:
5727 case DT_MIPS_DELTA_SYM_NO:
5728 case DT_MIPS_DELTA_CLASSSYM_NO:
5729 case DT_MIPS_COMPACT_SIZE:
5730 printf ("%ld\n", (long) entry->d_un.d_ptr);
5734 printf ("%#lx\n", (unsigned long) entry->d_un.d_ptr);
5740 dynamic_section_parisc_val (Elf_Internal_Dyn *entry)
5742 switch (entry->d_tag)
5744 case DT_HP_DLD_FLAGS:
5753 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
5754 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
5755 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
5756 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
5757 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
5758 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
5759 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
5760 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
5761 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
5762 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
5763 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
5764 { DT_HP_GST, "HP_GST" },
5765 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
5766 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
5767 { DT_HP_NODELETE, "HP_NODELETE" },
5768 { DT_HP_GROUP, "HP_GROUP" },
5769 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
5773 bfd_vma val = entry->d_un.d_val;
5775 for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
5776 if (val & flags[cnt].bit)
5780 fputs (flags[cnt].str, stdout);
5782 val ^= flags[cnt].bit;
5785 if (val != 0 || first)
5789 print_vma (val, HEX);
5795 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
5802 dynamic_section_ia64_val (Elf_Internal_Dyn *entry)
5804 switch (entry->d_tag)
5806 case DT_IA_64_PLT_RESERVE:
5807 /* First 3 slots reserved. */
5808 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
5810 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
5814 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
5821 get_32bit_dynamic_section (FILE *file)
5823 Elf32_External_Dyn *edyn, *ext;
5824 Elf_Internal_Dyn *entry;
5826 edyn = get_data (NULL, file, dynamic_addr, 1, dynamic_size,
5827 _("dynamic section"));
5831 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5832 might not have the luxury of section headers. Look for the DT_NULL
5833 terminator to determine the number of entries. */
5834 for (ext = edyn, dynamic_nent = 0;
5835 (char *) ext < (char *) edyn + dynamic_size;
5839 if (BYTE_GET (ext->d_tag) == DT_NULL)
5843 dynamic_section = cmalloc (dynamic_nent, sizeof (*entry));
5844 if (dynamic_section == NULL)
5846 error (_("Out of memory\n"));
5851 for (ext = edyn, entry = dynamic_section;
5852 entry < dynamic_section + dynamic_nent;
5855 entry->d_tag = BYTE_GET (ext->d_tag);
5856 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
5865 get_64bit_dynamic_section (FILE *file)
5867 Elf64_External_Dyn *edyn, *ext;
5868 Elf_Internal_Dyn *entry;
5870 edyn = get_data (NULL, file, dynamic_addr, 1, dynamic_size,
5871 _("dynamic section"));
5875 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5876 might not have the luxury of section headers. Look for the DT_NULL
5877 terminator to determine the number of entries. */
5878 for (ext = edyn, dynamic_nent = 0;
5879 (char *) ext < (char *) edyn + dynamic_size;
5883 if (BYTE_GET (ext->d_tag) == DT_NULL)
5887 dynamic_section = cmalloc (dynamic_nent, sizeof (*entry));
5888 if (dynamic_section == NULL)
5890 error (_("Out of memory\n"));
5895 for (ext = edyn, entry = dynamic_section;
5896 entry < dynamic_section + dynamic_nent;
5899 entry->d_tag = BYTE_GET (ext->d_tag);
5900 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
5909 print_dynamic_flags (bfd_vma flags)
5917 flag = flags & - flags;
5927 case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
5928 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
5929 case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
5930 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
5931 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
5932 default: fputs ("unknown", stdout); break;
5938 /* Parse and display the contents of the dynamic section. */
5941 process_dynamic_section (FILE *file)
5943 Elf_Internal_Dyn *entry;
5945 if (dynamic_size == 0)
5948 printf (_("\nThere is no dynamic section in this file.\n"));
5955 if (! get_32bit_dynamic_section (file))
5958 else if (! get_64bit_dynamic_section (file))
5961 /* Find the appropriate symbol table. */
5962 if (dynamic_symbols == NULL)
5964 for (entry = dynamic_section;
5965 entry < dynamic_section + dynamic_nent;
5968 Elf_Internal_Shdr section;
5970 if (entry->d_tag != DT_SYMTAB)
5973 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
5975 /* Since we do not know how big the symbol table is,
5976 we default to reading in the entire file (!) and
5977 processing that. This is overkill, I know, but it
5979 section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
5981 if (archive_file_offset != 0)
5982 section.sh_size = archive_file_size - section.sh_offset;
5985 if (fseek (file, 0, SEEK_END))
5986 error (_("Unable to seek to end of file!\n"));
5988 section.sh_size = ftell (file) - section.sh_offset;
5992 section.sh_entsize = sizeof (Elf32_External_Sym);
5994 section.sh_entsize = sizeof (Elf64_External_Sym);
5996 num_dynamic_syms = section.sh_size / section.sh_entsize;
5997 if (num_dynamic_syms < 1)
5999 error (_("Unable to determine the number of symbols to load\n"));
6003 dynamic_symbols = GET_ELF_SYMBOLS (file, §ion);
6007 /* Similarly find a string table. */
6008 if (dynamic_strings == NULL)
6010 for (entry = dynamic_section;
6011 entry < dynamic_section + dynamic_nent;
6014 unsigned long offset;
6017 if (entry->d_tag != DT_STRTAB)
6020 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
6022 /* Since we do not know how big the string table is,
6023 we default to reading in the entire file (!) and
6024 processing that. This is overkill, I know, but it
6027 offset = offset_from_vma (file, entry->d_un.d_val, 0);
6029 if (archive_file_offset != 0)
6030 str_tab_len = archive_file_size - offset;
6033 if (fseek (file, 0, SEEK_END))
6034 error (_("Unable to seek to end of file\n"));
6035 str_tab_len = ftell (file) - offset;
6038 if (str_tab_len < 1)
6041 (_("Unable to determine the length of the dynamic string table\n"));
6045 dynamic_strings = get_data (NULL, file, offset, 1, str_tab_len,
6046 _("dynamic string table"));
6047 dynamic_strings_length = str_tab_len;
6052 /* And find the syminfo section if available. */
6053 if (dynamic_syminfo == NULL)
6055 unsigned long syminsz = 0;
6057 for (entry = dynamic_section;
6058 entry < dynamic_section + dynamic_nent;
6061 if (entry->d_tag == DT_SYMINENT)
6063 /* Note: these braces are necessary to avoid a syntax
6064 error from the SunOS4 C compiler. */
6065 assert (sizeof (Elf_External_Syminfo) == entry->d_un.d_val);
6067 else if (entry->d_tag == DT_SYMINSZ)
6068 syminsz = entry->d_un.d_val;
6069 else if (entry->d_tag == DT_SYMINFO)
6070 dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
6074 if (dynamic_syminfo_offset != 0 && syminsz != 0)
6076 Elf_External_Syminfo *extsyminfo, *extsym;
6077 Elf_Internal_Syminfo *syminfo;
6079 /* There is a syminfo section. Read the data. */
6080 extsyminfo = get_data (NULL, file, dynamic_syminfo_offset, 1,
6081 syminsz, _("symbol information"));
6085 dynamic_syminfo = malloc (syminsz);
6086 if (dynamic_syminfo == NULL)
6088 error (_("Out of memory\n"));
6092 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
6093 for (syminfo = dynamic_syminfo, extsym = extsyminfo;
6094 syminfo < dynamic_syminfo + dynamic_syminfo_nent;
6095 ++syminfo, ++extsym)
6097 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
6098 syminfo->si_flags = BYTE_GET (extsym->si_flags);
6105 if (do_dynamic && dynamic_addr)
6106 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
6107 dynamic_addr, dynamic_nent);
6109 printf (_(" Tag Type Name/Value\n"));
6111 for (entry = dynamic_section;
6112 entry < dynamic_section + dynamic_nent;
6120 print_vma (entry->d_tag, FULL_HEX);
6121 dtype = get_dynamic_type (entry->d_tag);
6122 printf (" (%s)%*s", dtype,
6123 ((is_32bit_elf ? 27 : 19)
6124 - (int) strlen (dtype)),
6128 switch (entry->d_tag)
6132 print_dynamic_flags (entry->d_un.d_val);
6142 switch (entry->d_tag)
6145 printf (_("Auxiliary library"));
6149 printf (_("Filter library"));
6153 printf (_("Configuration file"));
6157 printf (_("Dependency audit library"));
6161 printf (_("Audit library"));
6165 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
6166 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
6170 print_vma (entry->d_un.d_val, PREFIX_HEX);
6179 printf (_("Flags:"));
6181 if (entry->d_un.d_val == 0)
6182 printf (_(" None\n"));
6185 unsigned long int val = entry->d_un.d_val;
6187 if (val & DTF_1_PARINIT)
6189 printf (" PARINIT");
6190 val ^= DTF_1_PARINIT;
6192 if (val & DTF_1_CONFEXP)
6194 printf (" CONFEXP");
6195 val ^= DTF_1_CONFEXP;
6198 printf (" %lx", val);
6207 printf (_("Flags:"));
6209 if (entry->d_un.d_val == 0)
6210 printf (_(" None\n"));
6213 unsigned long int val = entry->d_un.d_val;
6215 if (val & DF_P1_LAZYLOAD)
6217 printf (" LAZYLOAD");
6218 val ^= DF_P1_LAZYLOAD;
6220 if (val & DF_P1_GROUPPERM)
6222 printf (" GROUPPERM");
6223 val ^= DF_P1_GROUPPERM;
6226 printf (" %lx", val);
6235 printf (_("Flags:"));
6236 if (entry->d_un.d_val == 0)
6237 printf (_(" None\n"));
6240 unsigned long int val = entry->d_un.d_val;
6247 if (val & DF_1_GLOBAL)
6252 if (val & DF_1_GROUP)
6257 if (val & DF_1_NODELETE)
6259 printf (" NODELETE");
6260 val ^= DF_1_NODELETE;
6262 if (val & DF_1_LOADFLTR)
6264 printf (" LOADFLTR");
6265 val ^= DF_1_LOADFLTR;
6267 if (val & DF_1_INITFIRST)
6269 printf (" INITFIRST");
6270 val ^= DF_1_INITFIRST;
6272 if (val & DF_1_NOOPEN)
6277 if (val & DF_1_ORIGIN)
6282 if (val & DF_1_DIRECT)
6287 if (val & DF_1_TRANS)
6292 if (val & DF_1_INTERPOSE)
6294 printf (" INTERPOSE");
6295 val ^= DF_1_INTERPOSE;
6297 if (val & DF_1_NODEFLIB)
6299 printf (" NODEFLIB");
6300 val ^= DF_1_NODEFLIB;
6302 if (val & DF_1_NODUMP)
6307 if (val & DF_1_CONLFAT)
6309 printf (" CONLFAT");
6310 val ^= DF_1_CONLFAT;
6313 printf (" %lx", val);
6320 dynamic_info[entry->d_tag] = entry->d_un.d_val;
6322 puts (get_dynamic_type (entry->d_un.d_val));
6342 dynamic_info[entry->d_tag] = entry->d_un.d_val;
6348 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
6349 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
6355 switch (entry->d_tag)
6358 printf (_("Shared library: [%s]"), name);
6360 if (streq (name, program_interpreter))
6361 printf (_(" program interpreter"));
6365 printf (_("Library soname: [%s]"), name);
6369 printf (_("Library rpath: [%s]"), name);
6373 printf (_("Library runpath: [%s]"), name);
6377 print_vma (entry->d_un.d_val, PREFIX_HEX);
6382 print_vma (entry->d_un.d_val, PREFIX_HEX);
6395 dynamic_info[entry->d_tag] = entry->d_un.d_val;
6399 case DT_INIT_ARRAYSZ:
6400 case DT_FINI_ARRAYSZ:
6401 case DT_GNU_CONFLICTSZ:
6402 case DT_GNU_LIBLISTSZ:
6405 print_vma (entry->d_un.d_val, UNSIGNED);
6406 printf (" (bytes)\n");
6416 print_vma (entry->d_un.d_val, UNSIGNED);
6429 if (entry->d_tag == DT_USED
6430 && VALID_DYNAMIC_NAME (entry->d_un.d_val))
6432 char *name = GET_DYNAMIC_NAME (entry->d_un.d_val);
6436 printf (_("Not needed object: [%s]\n"), name);
6441 print_vma (entry->d_un.d_val, PREFIX_HEX);
6447 /* The value of this entry is ignored. */
6452 case DT_GNU_PRELINKED:
6456 time_t time = entry->d_un.d_val;
6458 tmp = gmtime (&time);
6459 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
6460 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
6461 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
6467 dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
6470 print_vma (entry->d_un.d_val, PREFIX_HEX);
6476 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
6477 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
6482 switch (elf_header.e_machine)
6485 case EM_MIPS_RS3_LE:
6486 dynamic_section_mips_val (entry);
6489 dynamic_section_parisc_val (entry);
6492 dynamic_section_ia64_val (entry);
6495 print_vma (entry->d_un.d_val, PREFIX_HEX);
6507 get_ver_flags (unsigned int flags)
6509 static char buff[32];
6516 if (flags & VER_FLG_BASE)
6517 strcat (buff, "BASE ");
6519 if (flags & VER_FLG_WEAK)
6521 if (flags & VER_FLG_BASE)
6522 strcat (buff, "| ");
6524 strcat (buff, "WEAK ");
6527 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK))
6528 strcat (buff, "| <unknown>");
6533 /* Display the contents of the version sections. */
6535 process_version_sections (FILE *file)
6537 Elf_Internal_Shdr *section;
6544 for (i = 0, section = section_headers;
6545 i < elf_header.e_shnum;
6548 switch (section->sh_type)
6550 case SHT_GNU_verdef:
6552 Elf_External_Verdef *edefs;
6560 (_("\nVersion definition section '%s' contains %u entries:\n"),
6561 SECTION_NAME (section), section->sh_info);
6563 printf (_(" Addr: 0x"));
6564 printf_vma (section->sh_addr);
6565 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
6566 (unsigned long) section->sh_offset, section->sh_link,
6567 section->sh_link < elf_header.e_shnum
6568 ? SECTION_NAME (section_headers + section->sh_link)
6571 edefs = get_data (NULL, file, section->sh_offset, 1,
6573 _("version definition section"));
6574 endbuf = (char *) edefs + section->sh_size;
6578 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
6581 Elf_External_Verdef *edef;
6582 Elf_Internal_Verdef ent;
6583 Elf_External_Verdaux *eaux;
6584 Elf_Internal_Verdaux aux;
6588 vstart = ((char *) edefs) + idx;
6589 if (vstart + sizeof (*edef) > endbuf)
6592 edef = (Elf_External_Verdef *) vstart;
6594 ent.vd_version = BYTE_GET (edef->vd_version);
6595 ent.vd_flags = BYTE_GET (edef->vd_flags);
6596 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
6597 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
6598 ent.vd_hash = BYTE_GET (edef->vd_hash);
6599 ent.vd_aux = BYTE_GET (edef->vd_aux);
6600 ent.vd_next = BYTE_GET (edef->vd_next);
6602 printf (_(" %#06x: Rev: %d Flags: %s"),
6603 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
6605 printf (_(" Index: %d Cnt: %d "),
6606 ent.vd_ndx, ent.vd_cnt);
6608 vstart += ent.vd_aux;
6610 eaux = (Elf_External_Verdaux *) vstart;
6612 aux.vda_name = BYTE_GET (eaux->vda_name);
6613 aux.vda_next = BYTE_GET (eaux->vda_next);
6615 if (VALID_DYNAMIC_NAME (aux.vda_name))
6616 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
6618 printf (_("Name index: %ld\n"), aux.vda_name);
6620 isum = idx + ent.vd_aux;
6622 for (j = 1; j < ent.vd_cnt; j++)
6624 isum += aux.vda_next;
6625 vstart += aux.vda_next;
6627 eaux = (Elf_External_Verdaux *) vstart;
6628 if (vstart + sizeof (*eaux) > endbuf)
6631 aux.vda_name = BYTE_GET (eaux->vda_name);
6632 aux.vda_next = BYTE_GET (eaux->vda_next);
6634 if (VALID_DYNAMIC_NAME (aux.vda_name))
6635 printf (_(" %#06x: Parent %d: %s\n"),
6636 isum, j, GET_DYNAMIC_NAME (aux.vda_name));
6638 printf (_(" %#06x: Parent %d, name index: %ld\n"),
6639 isum, j, aux.vda_name);
6642 printf (_(" Version def aux past end of section\n"));
6646 if (cnt < section->sh_info)
6647 printf (_(" Version definition past end of section\n"));
6653 case SHT_GNU_verneed:
6655 Elf_External_Verneed *eneed;
6662 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
6663 SECTION_NAME (section), section->sh_info);
6665 printf (_(" Addr: 0x"));
6666 printf_vma (section->sh_addr);
6667 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
6668 (unsigned long) section->sh_offset, section->sh_link,
6669 section->sh_link < elf_header.e_shnum
6670 ? SECTION_NAME (section_headers + section->sh_link)
6673 eneed = get_data (NULL, file, section->sh_offset, 1,
6675 _("version need section"));
6676 endbuf = (char *) eneed + section->sh_size;
6680 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
6682 Elf_External_Verneed *entry;
6683 Elf_Internal_Verneed ent;
6688 vstart = ((char *) eneed) + idx;
6689 if (vstart + sizeof (*entry) > endbuf)
6692 entry = (Elf_External_Verneed *) vstart;
6694 ent.vn_version = BYTE_GET (entry->vn_version);
6695 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
6696 ent.vn_file = BYTE_GET (entry->vn_file);
6697 ent.vn_aux = BYTE_GET (entry->vn_aux);
6698 ent.vn_next = BYTE_GET (entry->vn_next);
6700 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
6702 if (VALID_DYNAMIC_NAME (ent.vn_file))
6703 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
6705 printf (_(" File: %lx"), ent.vn_file);
6707 printf (_(" Cnt: %d\n"), ent.vn_cnt);
6709 vstart += ent.vn_aux;
6711 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
6713 Elf_External_Vernaux *eaux;
6714 Elf_Internal_Vernaux aux;
6716 if (vstart + sizeof (*eaux) > endbuf)
6718 eaux = (Elf_External_Vernaux *) vstart;
6720 aux.vna_hash = BYTE_GET (eaux->vna_hash);
6721 aux.vna_flags = BYTE_GET (eaux->vna_flags);
6722 aux.vna_other = BYTE_GET (eaux->vna_other);
6723 aux.vna_name = BYTE_GET (eaux->vna_name);
6724 aux.vna_next = BYTE_GET (eaux->vna_next);
6726 if (VALID_DYNAMIC_NAME (aux.vna_name))
6727 printf (_(" %#06x: Name: %s"),
6728 isum, GET_DYNAMIC_NAME (aux.vna_name));
6730 printf (_(" %#06x: Name index: %lx"),
6731 isum, aux.vna_name);
6733 printf (_(" Flags: %s Version: %d\n"),
6734 get_ver_flags (aux.vna_flags), aux.vna_other);
6736 isum += aux.vna_next;
6737 vstart += aux.vna_next;
6740 printf (_(" Version need aux past end of section\n"));
6744 if (cnt < section->sh_info)
6745 printf (_(" Version need past end of section\n"));
6751 case SHT_GNU_versym:
6753 Elf_Internal_Shdr *link_section;
6756 unsigned char *edata;
6757 unsigned short *data;
6759 Elf_Internal_Sym *symbols;
6760 Elf_Internal_Shdr *string_sec;
6763 if (section->sh_link >= elf_header.e_shnum)
6766 link_section = section_headers + section->sh_link;
6767 total = section->sh_size / sizeof (Elf_External_Versym);
6769 if (link_section->sh_link >= elf_header.e_shnum)
6774 symbols = GET_ELF_SYMBOLS (file, link_section);
6776 string_sec = section_headers + link_section->sh_link;
6778 strtab = get_data (NULL, file, string_sec->sh_offset, 1,
6779 string_sec->sh_size, _("version string table"));
6783 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
6784 SECTION_NAME (section), total);
6786 printf (_(" Addr: "));
6787 printf_vma (section->sh_addr);
6788 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
6789 (unsigned long) section->sh_offset, section->sh_link,
6790 SECTION_NAME (link_section));
6792 off = offset_from_vma (file,
6793 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
6794 total * sizeof (short));
6795 edata = get_data (NULL, file, off, total, sizeof (short),
6796 _("version symbol data"));
6803 data = cmalloc (total, sizeof (short));
6805 for (cnt = total; cnt --;)
6806 data[cnt] = byte_get (edata + cnt * sizeof (short),
6811 for (cnt = 0; cnt < total; cnt += 4)
6814 int check_def, check_need;
6817 printf (" %03x:", cnt);
6819 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
6820 switch (data[cnt + j])
6823 fputs (_(" 0 (*local*) "), stdout);
6827 fputs (_(" 1 (*global*) "), stdout);
6831 nn = printf ("%4x%c", data[cnt + j] & 0x7fff,
6832 data[cnt + j] & 0x8000 ? 'h' : ' ');
6836 if (symbols[cnt + j].st_shndx >= elf_header.e_shnum
6837 || section_headers[symbols[cnt + j].st_shndx].sh_type
6840 if (symbols[cnt + j].st_shndx == SHN_UNDEF)
6847 && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
6849 Elf_Internal_Verneed ivn;
6850 unsigned long offset;
6852 offset = offset_from_vma
6853 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
6854 sizeof (Elf_External_Verneed));
6858 Elf_Internal_Vernaux ivna;
6859 Elf_External_Verneed evn;
6860 Elf_External_Vernaux evna;
6861 unsigned long a_off;
6863 get_data (&evn, file, offset, sizeof (evn), 1,
6866 ivn.vn_aux = BYTE_GET (evn.vn_aux);
6867 ivn.vn_next = BYTE_GET (evn.vn_next);
6869 a_off = offset + ivn.vn_aux;
6873 get_data (&evna, file, a_off, sizeof (evna),
6874 1, _("version need aux (2)"));
6876 ivna.vna_next = BYTE_GET (evna.vna_next);
6877 ivna.vna_other = BYTE_GET (evna.vna_other);
6879 a_off += ivna.vna_next;
6881 while (ivna.vna_other != data[cnt + j]
6882 && ivna.vna_next != 0);
6884 if (ivna.vna_other == data[cnt + j])
6886 ivna.vna_name = BYTE_GET (evna.vna_name);
6888 if (ivna.vna_name >= string_sec->sh_size)
6889 name = _("*invalid*");
6891 name = strtab + ivna.vna_name;
6892 nn += printf ("(%s%-*s",
6894 12 - (int) strlen (name),
6900 offset += ivn.vn_next;
6902 while (ivn.vn_next);
6905 if (check_def && data[cnt + j] != 0x8001
6906 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
6908 Elf_Internal_Verdef ivd;
6909 Elf_External_Verdef evd;
6910 unsigned long offset;
6912 offset = offset_from_vma
6913 (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
6918 get_data (&evd, file, offset, sizeof (evd), 1,
6921 ivd.vd_next = BYTE_GET (evd.vd_next);
6922 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
6924 offset += ivd.vd_next;
6926 while (ivd.vd_ndx != (data[cnt + j] & 0x7fff)
6927 && ivd.vd_next != 0);
6929 if (ivd.vd_ndx == (data[cnt + j] & 0x7fff))
6931 Elf_External_Verdaux evda;
6932 Elf_Internal_Verdaux ivda;
6934 ivd.vd_aux = BYTE_GET (evd.vd_aux);
6936 get_data (&evda, file,
6937 offset - ivd.vd_next + ivd.vd_aux,
6939 _("version def aux"));
6941 ivda.vda_name = BYTE_GET (evda.vda_name);
6943 if (ivda.vda_name >= string_sec->sh_size)
6944 name = _("*invalid*");
6946 name = strtab + ivda.vda_name;
6947 nn += printf ("(%s%-*s",
6949 12 - (int) strlen (name),
6955 printf ("%*c", 18 - nn, ' ');
6973 printf (_("\nNo version information found in this file.\n"));
6979 get_symbol_binding (unsigned int binding)
6981 static char buff[32];
6985 case STB_LOCAL: return "LOCAL";
6986 case STB_GLOBAL: return "GLOBAL";
6987 case STB_WEAK: return "WEAK";
6989 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
6990 snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
6992 else if (binding >= STB_LOOS && binding <= STB_HIOS)
6993 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
6995 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
7001 get_symbol_type (unsigned int type)
7003 static char buff[32];
7007 case STT_NOTYPE: return "NOTYPE";
7008 case STT_OBJECT: return "OBJECT";
7009 case STT_FUNC: return "FUNC";
7010 case STT_SECTION: return "SECTION";
7011 case STT_FILE: return "FILE";
7012 case STT_COMMON: return "COMMON";
7013 case STT_TLS: return "TLS";
7014 case STT_RELC: return "RELC";
7015 case STT_SRELC: return "SRELC";
7017 if (type >= STT_LOPROC && type <= STT_HIPROC)
7019 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
7020 return "THUMB_FUNC";
7022 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
7025 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
7026 return "PARISC_MILLI";
7028 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
7030 else if (type >= STT_LOOS && type <= STT_HIOS)
7032 if (elf_header.e_machine == EM_PARISC)
7034 if (type == STT_HP_OPAQUE)
7036 if (type == STT_HP_STUB)
7040 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
7043 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
7049 get_symbol_visibility (unsigned int visibility)
7053 case STV_DEFAULT: return "DEFAULT";
7054 case STV_INTERNAL: return "INTERNAL";
7055 case STV_HIDDEN: return "HIDDEN";
7056 case STV_PROTECTED: return "PROTECTED";
7062 get_mips_symbol_other (unsigned int other)
7066 case STO_OPTIONAL: return "OPTIONAL";
7067 case STO_MIPS16: return "MIPS16";
7068 case STO_MIPS_PLT: return "MIPS PLT";
7069 case STO_MIPS_PIC: return "MIPS PIC";
7070 default: return NULL;
7075 get_symbol_other (unsigned int other)
7077 const char * result = NULL;
7078 static char buff [32];
7083 switch (elf_header.e_machine)
7086 result = get_mips_symbol_other (other);
7094 snprintf (buff, sizeof buff, _("<other>: %x"), other);
7099 get_symbol_index_type (unsigned int type)
7101 static char buff[32];
7105 case SHN_UNDEF: return "UND";
7106 case SHN_ABS: return "ABS";
7107 case SHN_COMMON: return "COM";
7109 if (type == SHN_IA_64_ANSI_COMMON
7110 && elf_header.e_machine == EM_IA_64
7111 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
7113 else if (elf_header.e_machine == EM_X86_64
7114 && type == SHN_X86_64_LCOMMON)
7116 else if (type == SHN_MIPS_SCOMMON
7117 && elf_header.e_machine == EM_MIPS)
7119 else if (type == SHN_MIPS_SUNDEFINED
7120 && elf_header.e_machine == EM_MIPS)
7122 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
7123 sprintf (buff, "PRC[0x%04x]", type & 0xffff);
7124 else if (type >= SHN_LOOS && type <= SHN_HIOS)
7125 sprintf (buff, "OS [0x%04x]", type & 0xffff);
7126 else if (type >= SHN_LORESERVE)
7127 sprintf (buff, "RSV[0x%04x]", type & 0xffff);
7129 sprintf (buff, "%3d", type);
7137 get_dynamic_data (FILE *file, unsigned int number, unsigned int ent_size)
7139 unsigned char *e_data;
7142 e_data = cmalloc (number, ent_size);
7146 error (_("Out of memory\n"));
7150 if (fread (e_data, ent_size, number, file) != number)
7152 error (_("Unable to read in dynamic data\n"));
7156 i_data = cmalloc (number, sizeof (*i_data));
7160 error (_("Out of memory\n"));
7166 i_data[number] = byte_get (e_data + number * ent_size, ent_size);
7174 print_dynamic_symbol (bfd_vma si, unsigned long hn)
7176 Elf_Internal_Sym *psym;
7179 psym = dynamic_symbols + si;
7181 n = print_vma (si, DEC_5);
7183 fputs (" " + n, stdout);
7184 printf (" %3lu: ", hn);
7185 print_vma (psym->st_value, LONG_HEX);
7187 print_vma (psym->st_size, DEC_5);
7189 printf (" %6s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
7190 printf (" %6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
7191 printf (" %3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
7192 /* Check to see if any other bits in the st_other field are set.
7193 Note - displaying this information disrupts the layout of the
7194 table being generated, but for the moment this case is very
7196 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
7197 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
7198 printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
7199 if (VALID_DYNAMIC_NAME (psym->st_name))
7200 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
7202 printf (" <corrupt: %14ld>", psym->st_name);
7206 /* Dump the symbol table. */
7208 process_symbol_table (FILE *file)
7210 Elf_Internal_Shdr *section;
7211 bfd_vma nbuckets = 0;
7212 bfd_vma nchains = 0;
7213 bfd_vma *buckets = NULL;
7214 bfd_vma *chains = NULL;
7215 bfd_vma ngnubuckets = 0;
7216 bfd_vma *gnubuckets = NULL;
7217 bfd_vma *gnuchains = NULL;
7218 bfd_vma gnusymidx = 0;
7220 if (! do_syms && !do_histogram)
7223 if (dynamic_info[DT_HASH]
7225 || (do_using_dynamic && dynamic_strings != NULL)))
7227 unsigned char nb[8];
7228 unsigned char nc[8];
7229 int hash_ent_size = 4;
7231 if ((elf_header.e_machine == EM_ALPHA
7232 || elf_header.e_machine == EM_S390
7233 || elf_header.e_machine == EM_S390_OLD)
7234 && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
7238 (archive_file_offset
7239 + offset_from_vma (file, dynamic_info[DT_HASH],
7240 sizeof nb + sizeof nc)),
7243 error (_("Unable to seek to start of dynamic information\n"));
7247 if (fread (nb, hash_ent_size, 1, file) != 1)
7249 error (_("Failed to read in number of buckets\n"));
7253 if (fread (nc, hash_ent_size, 1, file) != 1)
7255 error (_("Failed to read in number of chains\n"));
7259 nbuckets = byte_get (nb, hash_ent_size);
7260 nchains = byte_get (nc, hash_ent_size);
7262 buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
7263 chains = get_dynamic_data (file, nchains, hash_ent_size);
7265 if (buckets == NULL || chains == NULL)
7269 if (dynamic_info_DT_GNU_HASH
7271 || (do_using_dynamic && dynamic_strings != NULL)))
7273 unsigned char nb[16];
7274 bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
7275 bfd_vma buckets_vma;
7278 (archive_file_offset
7279 + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
7283 error (_("Unable to seek to start of dynamic information\n"));
7287 if (fread (nb, 16, 1, file) != 1)
7289 error (_("Failed to read in number of buckets\n"));
7293 ngnubuckets = byte_get (nb, 4);
7294 gnusymidx = byte_get (nb + 4, 4);
7295 bitmaskwords = byte_get (nb + 8, 4);
7296 buckets_vma = dynamic_info_DT_GNU_HASH + 16;
7298 buckets_vma += bitmaskwords * 4;
7300 buckets_vma += bitmaskwords * 8;
7303 (archive_file_offset
7304 + offset_from_vma (file, buckets_vma, 4)),
7307 error (_("Unable to seek to start of dynamic information\n"));
7311 gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
7313 if (gnubuckets == NULL)
7316 for (i = 0; i < ngnubuckets; i++)
7317 if (gnubuckets[i] != 0)
7319 if (gnubuckets[i] < gnusymidx)
7322 if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
7323 maxchain = gnubuckets[i];
7326 if (maxchain == 0xffffffff)
7329 maxchain -= gnusymidx;
7332 (archive_file_offset
7333 + offset_from_vma (file, buckets_vma
7334 + 4 * (ngnubuckets + maxchain), 4)),
7337 error (_("Unable to seek to start of dynamic information\n"));
7343 if (fread (nb, 4, 1, file) != 1)
7345 error (_("Failed to determine last chain length\n"));
7349 if (maxchain + 1 == 0)
7354 while ((byte_get (nb, 4) & 1) == 0);
7357 (archive_file_offset
7358 + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
7361 error (_("Unable to seek to start of dynamic information\n"));
7365 gnuchains = get_dynamic_data (file, maxchain, 4);
7367 if (gnuchains == NULL)
7371 if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
7374 && dynamic_strings != NULL)
7378 if (dynamic_info[DT_HASH])
7382 printf (_("\nSymbol table for image:\n"));
7384 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7386 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7388 for (hn = 0; hn < nbuckets; hn++)
7393 for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
7394 print_dynamic_symbol (si, hn);
7398 if (dynamic_info_DT_GNU_HASH)
7400 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
7402 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7404 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7406 for (hn = 0; hn < ngnubuckets; ++hn)
7407 if (gnubuckets[hn] != 0)
7409 bfd_vma si = gnubuckets[hn];
7410 bfd_vma off = si - gnusymidx;
7414 print_dynamic_symbol (si, hn);
7417 while ((gnuchains[off++] & 1) == 0);
7421 else if (do_syms && !do_using_dynamic)
7425 for (i = 0, section = section_headers;
7426 i < elf_header.e_shnum;
7430 char *strtab = NULL;
7431 unsigned long int strtab_size = 0;
7432 Elf_Internal_Sym *symtab;
7433 Elf_Internal_Sym *psym;
7436 if ( section->sh_type != SHT_SYMTAB
7437 && section->sh_type != SHT_DYNSYM)
7440 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
7441 SECTION_NAME (section),
7442 (unsigned long) (section->sh_size / section->sh_entsize));
7444 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
7446 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
7448 symtab = GET_ELF_SYMBOLS (file, section);
7452 if (section->sh_link == elf_header.e_shstrndx)
7454 strtab = string_table;
7455 strtab_size = string_table_length;
7457 else if (section->sh_link < elf_header.e_shnum)
7459 Elf_Internal_Shdr *string_sec;
7461 string_sec = section_headers + section->sh_link;
7463 strtab = get_data (NULL, file, string_sec->sh_offset,
7464 1, string_sec->sh_size, _("string table"));
7465 strtab_size = strtab != NULL ? string_sec->sh_size : 0;
7468 for (si = 0, psym = symtab;
7469 si < section->sh_size / section->sh_entsize;
7472 printf ("%6d: ", si);
7473 print_vma (psym->st_value, LONG_HEX);
7475 print_vma (psym->st_size, DEC_5);
7476 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
7477 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
7478 printf (" %-3s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
7479 /* Check to see if any other bits in the st_other field are set.
7480 Note - displaying this information disrupts the layout of the
7481 table being generated, but for the moment this case is very rare. */
7482 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
7483 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
7484 printf (" %4s ", get_symbol_index_type (psym->st_shndx));
7485 print_symbol (25, psym->st_name < strtab_size
7486 ? strtab + psym->st_name : "<corrupt>");
7488 if (section->sh_type == SHT_DYNSYM &&
7489 version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
7491 unsigned char data[2];
7492 unsigned short vers_data;
7493 unsigned long offset;
7497 offset = offset_from_vma
7498 (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
7499 sizeof data + si * sizeof (vers_data));
7501 get_data (&data, file, offset + si * sizeof (vers_data),
7502 sizeof (data), 1, _("version data"));
7504 vers_data = byte_get (data, 2);
7506 is_nobits = (psym->st_shndx < elf_header.e_shnum
7507 && section_headers[psym->st_shndx].sh_type
7510 check_def = (psym->st_shndx != SHN_UNDEF);
7512 if ((vers_data & 0x8000) || vers_data > 1)
7514 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
7515 && (is_nobits || ! check_def))
7517 Elf_External_Verneed evn;
7518 Elf_Internal_Verneed ivn;
7519 Elf_Internal_Vernaux ivna;
7521 /* We must test both. */
7522 offset = offset_from_vma
7523 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
7528 unsigned long vna_off;
7530 get_data (&evn, file, offset, sizeof (evn), 1,
7533 ivn.vn_aux = BYTE_GET (evn.vn_aux);
7534 ivn.vn_next = BYTE_GET (evn.vn_next);
7536 vna_off = offset + ivn.vn_aux;
7540 Elf_External_Vernaux evna;
7542 get_data (&evna, file, vna_off,
7544 _("version need aux (3)"));
7546 ivna.vna_other = BYTE_GET (evna.vna_other);
7547 ivna.vna_next = BYTE_GET (evna.vna_next);
7548 ivna.vna_name = BYTE_GET (evna.vna_name);
7550 vna_off += ivna.vna_next;
7552 while (ivna.vna_other != vers_data
7553 && ivna.vna_next != 0);
7555 if (ivna.vna_other == vers_data)
7558 offset += ivn.vn_next;
7560 while (ivn.vn_next != 0);
7562 if (ivna.vna_other == vers_data)
7565 ivna.vna_name < strtab_size
7566 ? strtab + ivna.vna_name : "<corrupt>",
7570 else if (! is_nobits)
7571 error (_("bad dynamic symbol\n"));
7578 if (vers_data != 0x8001
7579 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
7581 Elf_Internal_Verdef ivd;
7582 Elf_Internal_Verdaux ivda;
7583 Elf_External_Verdaux evda;
7584 unsigned long offset;
7586 offset = offset_from_vma
7588 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
7589 sizeof (Elf_External_Verdef));
7593 Elf_External_Verdef evd;
7595 get_data (&evd, file, offset, sizeof (evd),
7596 1, _("version def"));
7598 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
7599 ivd.vd_aux = BYTE_GET (evd.vd_aux);
7600 ivd.vd_next = BYTE_GET (evd.vd_next);
7602 offset += ivd.vd_next;
7604 while (ivd.vd_ndx != (vers_data & 0x7fff)
7605 && ivd.vd_next != 0);
7607 offset -= ivd.vd_next;
7608 offset += ivd.vd_aux;
7610 get_data (&evda, file, offset, sizeof (evda),
7611 1, _("version def aux"));
7613 ivda.vda_name = BYTE_GET (evda.vda_name);
7615 if (psym->st_name != ivda.vda_name)
7616 printf ((vers_data & 0x8000)
7618 ivda.vda_name < strtab_size
7619 ? strtab + ivda.vda_name : "<corrupt>");
7629 if (strtab != string_table)
7635 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
7637 if (do_histogram && buckets != NULL)
7639 unsigned long *lengths;
7640 unsigned long *counts;
7643 unsigned long maxlength = 0;
7644 unsigned long nzero_counts = 0;
7645 unsigned long nsyms = 0;
7647 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
7648 (unsigned long) nbuckets);
7649 printf (_(" Length Number %% of total Coverage\n"));
7651 lengths = calloc (nbuckets, sizeof (*lengths));
7652 if (lengths == NULL)
7654 error (_("Out of memory\n"));
7657 for (hn = 0; hn < nbuckets; ++hn)
7659 for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
7662 if (maxlength < ++lengths[hn])
7667 counts = calloc (maxlength + 1, sizeof (*counts));
7670 error (_("Out of memory\n"));
7674 for (hn = 0; hn < nbuckets; ++hn)
7675 ++counts[lengths[hn]];
7680 printf (" 0 %-10lu (%5.1f%%)\n",
7681 counts[0], (counts[0] * 100.0) / nbuckets);
7682 for (i = 1; i <= maxlength; ++i)
7684 nzero_counts += counts[i] * i;
7685 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
7686 i, counts[i], (counts[i] * 100.0) / nbuckets,
7687 (nzero_counts * 100.0) / nsyms);
7695 if (buckets != NULL)
7701 if (do_histogram && dynamic_info_DT_GNU_HASH)
7703 unsigned long *lengths;
7704 unsigned long *counts;
7706 unsigned long maxlength = 0;
7707 unsigned long nzero_counts = 0;
7708 unsigned long nsyms = 0;
7710 lengths = calloc (ngnubuckets, sizeof (*lengths));
7711 if (lengths == NULL)
7713 error (_("Out of memory\n"));
7717 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
7718 (unsigned long) ngnubuckets);
7719 printf (_(" Length Number %% of total Coverage\n"));
7721 for (hn = 0; hn < ngnubuckets; ++hn)
7722 if (gnubuckets[hn] != 0)
7724 bfd_vma off, length = 1;
7726 for (off = gnubuckets[hn] - gnusymidx;
7727 (gnuchains[off] & 1) == 0; ++off)
7729 lengths[hn] = length;
7730 if (length > maxlength)
7735 counts = calloc (maxlength + 1, sizeof (*counts));
7738 error (_("Out of memory\n"));
7742 for (hn = 0; hn < ngnubuckets; ++hn)
7743 ++counts[lengths[hn]];
7745 if (ngnubuckets > 0)
7748 printf (" 0 %-10lu (%5.1f%%)\n",
7749 counts[0], (counts[0] * 100.0) / ngnubuckets);
7750 for (j = 1; j <= maxlength; ++j)
7752 nzero_counts += counts[j] * j;
7753 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
7754 j, counts[j], (counts[j] * 100.0) / ngnubuckets,
7755 (nzero_counts * 100.0) / nsyms);
7769 process_syminfo (FILE *file ATTRIBUTE_UNUSED)
7773 if (dynamic_syminfo == NULL
7775 /* No syminfo, this is ok. */
7778 /* There better should be a dynamic symbol section. */
7779 if (dynamic_symbols == NULL || dynamic_strings == NULL)
7783 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
7784 dynamic_syminfo_offset, dynamic_syminfo_nent);
7786 printf (_(" Num: Name BoundTo Flags\n"));
7787 for (i = 0; i < dynamic_syminfo_nent; ++i)
7789 unsigned short int flags = dynamic_syminfo[i].si_flags;
7791 printf ("%4d: ", i);
7792 if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
7793 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
7795 printf ("<corrupt: %19ld>", dynamic_symbols[i].st_name);
7798 switch (dynamic_syminfo[i].si_boundto)
7800 case SYMINFO_BT_SELF:
7801 fputs ("SELF ", stdout);
7803 case SYMINFO_BT_PARENT:
7804 fputs ("PARENT ", stdout);
7807 if (dynamic_syminfo[i].si_boundto > 0
7808 && dynamic_syminfo[i].si_boundto < dynamic_nent
7809 && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
7811 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
7815 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
7819 if (flags & SYMINFO_FLG_DIRECT)
7821 if (flags & SYMINFO_FLG_PASSTHRU)
7822 printf (" PASSTHRU");
7823 if (flags & SYMINFO_FLG_COPY)
7825 if (flags & SYMINFO_FLG_LAZYLOAD)
7826 printf (" LAZYLOAD");
7834 #ifdef SUPPORT_DISASSEMBLY
7836 disassemble_section (Elf_Internal_Shdr *section, FILE *file)
7838 printf (_("\nAssembly dump of section %s\n"),
7839 SECTION_NAME (section));
7841 /* XXX -- to be done --- XXX */
7848 dump_section_as_strings (Elf_Internal_Shdr *section, FILE *file)
7850 Elf_Internal_Shdr *relsec;
7851 bfd_size_type num_bytes;
7856 char *name = SECTION_NAME (section);
7857 bfd_boolean some_strings_shown;
7859 num_bytes = section->sh_size;
7861 if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
7863 printf (_("\nSection '%s' has no data to dump.\n"), name);
7867 addr = section->sh_addr;
7869 start = get_data (NULL, file, section->sh_offset, 1, num_bytes,
7874 printf (_("\nString dump of section '%s':\n"), name);
7876 /* If the section being dumped has relocations against it the user might
7877 be expecting these relocations to have been applied. Check for this
7878 case and issue a warning message in order to avoid confusion.
7879 FIXME: Maybe we ought to have an option that dumps a section with
7881 for (relsec = section_headers;
7882 relsec < section_headers + elf_header.e_shnum;
7885 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
7886 || relsec->sh_info >= elf_header.e_shnum
7887 || section_headers + relsec->sh_info != section
7888 || relsec->sh_size == 0
7889 || relsec->sh_link >= elf_header.e_shnum)
7892 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
7897 end = start + num_bytes;
7898 some_strings_shown = FALSE;
7902 while (!ISPRINT (* data))
7909 printf (" [%6tx] %s\n", data - start, data);
7911 printf (" [%6Ix] %s\n", (size_t) (data - start), data);
7913 data += strlen (data);
7914 some_strings_shown = TRUE;
7918 if (! some_strings_shown)
7919 printf (_(" No strings found in this section."));
7929 dump_section_as_bytes (Elf_Internal_Shdr *section, FILE *file)
7931 Elf_Internal_Shdr *relsec;
7932 bfd_size_type bytes;
7934 unsigned char *data;
7935 unsigned char *start;
7937 bytes = section->sh_size;
7939 if (bytes == 0 || section->sh_type == SHT_NOBITS)
7941 printf (_("\nSection '%s' has no data to dump.\n"),
7942 SECTION_NAME (section));
7946 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
7948 addr = section->sh_addr;
7950 start = get_data (NULL, file, section->sh_offset, 1, bytes,
7955 /* If the section being dumped has relocations against it the user might
7956 be expecting these relocations to have been applied. Check for this
7957 case and issue a warning message in order to avoid confusion.
7958 FIXME: Maybe we ought to have an option that dumps a section with
7960 for (relsec = section_headers;
7961 relsec < section_headers + elf_header.e_shnum;
7964 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
7965 || relsec->sh_info >= elf_header.e_shnum
7966 || section_headers + relsec->sh_info != section
7967 || relsec->sh_size == 0
7968 || relsec->sh_link >= elf_header.e_shnum)
7971 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
7983 lbytes = (bytes > 16 ? 16 : bytes);
7985 printf (" 0x%8.8lx ", (unsigned long) addr);
7987 for (j = 0; j < 16; j++)
7990 printf ("%2.2x", data[j]);
7998 for (j = 0; j < lbytes; j++)
8001 if (k >= ' ' && k < 0x7f)
8020 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
8021 DWARF debug sections. This is a target specific test. Note - we do not
8022 go through the whole including-target-headers-multiple-times route, (as
8023 we have already done with <elf/h8.h>) because this would become very
8024 messy and even then this function would have to contain target specific
8025 information (the names of the relocs instead of their numeric values).
8026 FIXME: This is not the correct way to solve this problem. The proper way
8027 is to have target specific reloc sizing and typing functions created by
8028 the reloc-macros.h header, in the same way that it already creates the
8029 reloc naming functions. */
8032 is_32bit_abs_reloc (unsigned int reloc_type)
8034 switch (elf_header.e_machine)
8038 return reloc_type == 1; /* R_386_32. */
8040 return reloc_type == 1; /* R_68K_32. */
8042 return reloc_type == 1; /* R_860_32. */
8044 return reloc_type == 1; /* XXX Is this right ? */
8046 return reloc_type == 1; /* R_ARC_32. */
8048 return reloc_type == 2; /* R_ARM_ABS32 */
8051 return reloc_type == 1;
8053 return reloc_type == 0x12; /* R_byte4_data. */
8055 return reloc_type == 3; /* R_CRIS_32. */
8058 return reloc_type == 3; /* R_CR16_NUM32. */
8060 return reloc_type == 15; /* R_CRX_NUM32. */
8062 return reloc_type == 1;
8063 case EM_CYGNUS_D10V:
8065 return reloc_type == 6; /* R_D10V_32. */
8066 case EM_CYGNUS_D30V:
8068 return reloc_type == 12; /* R_D30V_32_NORMAL. */
8070 return reloc_type == 3; /* R_DLX_RELOC_32. */
8071 case EM_CYGNUS_FR30:
8073 return reloc_type == 3; /* R_FR30_32. */
8077 return reloc_type == 1; /* R_H8_DIR32. */
8079 return reloc_type == 0x65; /* R_IA64_SECREL32LSB. */
8082 return reloc_type == 2; /* R_IP2K_32. */
8084 return reloc_type == 2; /* R_IQ2000_32. */
8087 return reloc_type == 3; /* R_M32C_32. */
8089 return reloc_type == 34; /* R_M32R_32_RELA. */
8091 return reloc_type == 1; /* R_MCORE_ADDR32. */
8093 return reloc_type == 4; /* R_MEP_32. */
8095 return reloc_type == 2; /* R_MIPS_32. */
8097 return reloc_type == 4; /* R_MMIX_32. */
8098 case EM_CYGNUS_MN10200:
8100 return reloc_type == 1; /* R_MN10200_32. */
8101 case EM_CYGNUS_MN10300:
8103 return reloc_type == 1; /* R_MN10300_32. */
8106 return reloc_type == 1; /* R_MSP43_32. */
8108 return reloc_type == 2; /* R_MT_32. */
8109 case EM_ALTERA_NIOS2:
8111 return reloc_type == 1; /* R_NIOS_32. */
8114 return reloc_type == 1; /* R_OR32_32. */
8116 return reloc_type == 1; /* R_PARISC_DIR32. */
8119 return reloc_type == 1; /* R_PJ_DATA_DIR32. */
8121 return reloc_type == 1; /* R_PPC64_ADDR32. */
8123 return reloc_type == 1; /* R_PPC_ADDR32. */
8125 return reloc_type == 1; /* R_I370_ADDR31. */
8128 return reloc_type == 4; /* R_S390_32. */
8130 return reloc_type == 8; /* R_SCORE_ABS32. */
8132 return reloc_type == 1; /* R_SH_DIR32. */
8133 case EM_SPARC32PLUS:
8136 return reloc_type == 3 /* R_SPARC_32. */
8137 || reloc_type == 23; /* R_SPARC_UA32. */
8139 return reloc_type == 6; /* R_SPU_ADDR32 */
8140 case EM_CYGNUS_V850:
8142 return reloc_type == 6; /* R_V850_ABS32. */
8144 return reloc_type == 1; /* R_VAX_32. */
8146 return reloc_type == 10; /* R_X86_64_32. */
8148 return reloc_type == 1; /* R_XSTROMY16_32. */
8151 return reloc_type == 1; /* R_XTENSA_32. */
8154 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
8155 elf_header.e_machine);
8160 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8161 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
8164 is_32bit_pcrel_reloc (unsigned int reloc_type)
8166 switch (elf_header.e_machine)
8170 return reloc_type == 2; /* R_386_PC32. */
8172 return reloc_type == 4; /* R_68K_PC32. */
8174 return reloc_type == 10; /* R_ALPHA_SREL32. */
8176 return reloc_type == 3; /* R_ARM_REL32 */
8178 return reloc_type == 9; /* R_PARISC_PCREL32. */
8180 return reloc_type == 26; /* R_PPC_REL32. */
8182 return reloc_type == 26; /* R_PPC64_REL32. */
8185 return reloc_type == 5; /* R_390_PC32. */
8187 return reloc_type == 2; /* R_SH_REL32. */
8188 case EM_SPARC32PLUS:
8191 return reloc_type == 6; /* R_SPARC_DISP32. */
8193 return reloc_type == 13; /* R_SPU_REL32. */
8195 return reloc_type == 2; /* R_X86_64_PC32. */
8198 return reloc_type == 14; /* R_XTENSA_32_PCREL. */
8200 /* Do not abort or issue an error message here. Not all targets use
8201 pc-relative 32-bit relocs in their DWARF debug information and we
8202 have already tested for target coverage in is_32bit_abs_reloc. A
8203 more helpful warning message will be generated by
8204 debug_apply_relocations anyway, so just return. */
8209 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8210 a 64-bit absolute RELA relocation used in DWARF debug sections. */
8213 is_64bit_abs_reloc (unsigned int reloc_type)
8215 switch (elf_header.e_machine)
8218 return reloc_type == 2; /* R_ALPHA_REFQUAD. */
8220 return reloc_type == 0x27; /* R_IA64_DIR64LSB. */
8222 return reloc_type == 80; /* R_PARISC_DIR64. */
8224 return reloc_type == 38; /* R_PPC64_ADDR64. */
8225 case EM_SPARC32PLUS:
8228 return reloc_type == 54; /* R_SPARC_UA64. */
8230 return reloc_type == 1; /* R_X86_64_64. */
8233 return reloc_type == 22; /* R_S390_64 */
8235 return reloc_type == 18; /* R_MIPS_64 */
8241 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
8242 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
8245 is_64bit_pcrel_reloc (unsigned int reloc_type)
8247 switch (elf_header.e_machine)
8250 return reloc_type == 11; /* R_ALPHA_SREL64 */
8252 return reloc_type == 0x4f; /* R_IA64_PCREL64LSB */
8254 return reloc_type == 72; /* R_PARISC_PCREL64 */
8256 return reloc_type == 44; /* R_PPC64_REL64 */
8257 case EM_SPARC32PLUS:
8260 return reloc_type == 46; /* R_SPARC_DISP64 */
8262 return reloc_type == 24; /* R_X86_64_PC64 */
8265 return reloc_type == 23; /* R_S390_PC64 */
8271 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8272 a 16-bit absolute RELA relocation used in DWARF debug sections. */
8275 is_16bit_abs_reloc (unsigned int reloc_type)
8277 switch (elf_header.e_machine)
8281 return reloc_type == 4; /* R_AVR_16. */
8282 case EM_CYGNUS_D10V:
8284 return reloc_type == 3; /* R_D10V_16. */
8288 return reloc_type == R_H8_DIR16;
8291 return reloc_type == 1; /* R_IP2K_16. */
8294 return reloc_type == 1; /* R_M32C_16 */
8297 return reloc_type == 5; /* R_MSP430_16_BYTE. */
8298 case EM_ALTERA_NIOS2:
8300 return reloc_type == 9; /* R_NIOS_16. */
8306 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
8307 relocation entries (possibly formerly used for SHT_GROUP sections). */
8310 is_none_reloc (unsigned int reloc_type)
8312 switch (elf_header.e_machine)
8314 case EM_68K: /* R_68K_NONE. */
8315 case EM_386: /* R_386_NONE. */
8316 case EM_SPARC32PLUS:
8318 case EM_SPARC: /* R_SPARC_NONE. */
8319 case EM_MIPS: /* R_MIPS_NONE. */
8320 case EM_PARISC: /* R_PARISC_NONE. */
8321 case EM_ALPHA: /* R_ALPHA_NONE. */
8322 case EM_PPC: /* R_PPC_NONE. */
8323 case EM_PPC64: /* R_PPC64_NONE. */
8324 case EM_ARM: /* R_ARM_NONE. */
8325 case EM_IA_64: /* R_IA64_NONE. */
8326 case EM_SH: /* R_SH_NONE. */
8328 case EM_S390: /* R_390_NONE. */
8329 case EM_CRIS: /* R_CRIS_NONE. */
8330 case EM_X86_64: /* R_X86_64_NONE. */
8331 case EM_MN10300: /* R_MN10300_NONE. */
8332 case EM_M32R: /* R_M32R_NONE. */
8333 return reloc_type == 0;
8338 /* Uncompresses a section that was compressed using zlib, in place.
8339 This is a copy of bfd_uncompress_section_contents, in bfd/compress.c */
8342 uncompress_section_contents (unsigned char **buffer, dwarf_size_type *size)
8345 /* These are just to quiet gcc. */
8350 dwarf_size_type compressed_size = *size;
8351 unsigned char * compressed_buffer = *buffer;
8352 dwarf_size_type uncompressed_size;
8353 unsigned char * uncompressed_buffer;
8356 dwarf_size_type header_size = 12;
8358 /* Read the zlib header. In this case, it should be "ZLIB" followed
8359 by the uncompressed section size, 8 bytes in big-endian order. */
8360 if (compressed_size < header_size
8361 || ! streq ((char *) compressed_buffer, "ZLIB"))
8364 uncompressed_size = compressed_buffer[4]; uncompressed_size <<= 8;
8365 uncompressed_size += compressed_buffer[5]; uncompressed_size <<= 8;
8366 uncompressed_size += compressed_buffer[6]; uncompressed_size <<= 8;
8367 uncompressed_size += compressed_buffer[7]; uncompressed_size <<= 8;
8368 uncompressed_size += compressed_buffer[8]; uncompressed_size <<= 8;
8369 uncompressed_size += compressed_buffer[9]; uncompressed_size <<= 8;
8370 uncompressed_size += compressed_buffer[10]; uncompressed_size <<= 8;
8371 uncompressed_size += compressed_buffer[11];
8373 /* It is possible the section consists of several compressed
8374 buffers concatenated together, so we uncompress in a loop. */
8378 strm.avail_in = compressed_size - header_size;
8379 strm.next_in = (Bytef *) compressed_buffer + header_size;
8380 strm.avail_out = uncompressed_size;
8381 uncompressed_buffer = xmalloc (uncompressed_size);
8383 rc = inflateInit (& strm);
8384 while (strm.avail_in > 0)
8388 strm.next_out = ((Bytef *) uncompressed_buffer
8389 + (uncompressed_size - strm.avail_out));
8390 rc = inflate (&strm, Z_FINISH);
8391 if (rc != Z_STREAM_END)
8393 rc = inflateReset (& strm);
8395 rc = inflateEnd (& strm);
8397 || strm.avail_out != 0)
8400 free (compressed_buffer);
8401 *buffer = uncompressed_buffer;
8402 *size = uncompressed_size;
8406 free (uncompressed_buffer);
8408 #endif /* HAVE_ZLIB_H */
8411 /* Apply relocations to a debug section. */
8414 debug_apply_relocations (void *file,
8415 Elf_Internal_Shdr *section,
8416 unsigned char *start)
8418 Elf_Internal_Shdr *relsec;
8419 unsigned char *end = start + section->sh_size;
8421 if (elf_header.e_type != ET_REL)
8424 /* Find the reloc section associated with the debug section. */
8425 for (relsec = section_headers;
8426 relsec < section_headers + elf_header.e_shnum;
8429 bfd_boolean is_rela;
8430 unsigned long num_relocs;
8431 Elf_Internal_Rela *relocs, *rp;
8432 Elf_Internal_Shdr *symsec;
8433 Elf_Internal_Sym *symtab;
8434 Elf_Internal_Sym *sym;
8436 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
8437 || relsec->sh_info >= elf_header.e_shnum
8438 || section_headers + relsec->sh_info != section
8439 || relsec->sh_size == 0
8440 || relsec->sh_link >= elf_header.e_shnum)
8443 is_rela = relsec->sh_type == SHT_RELA;
8447 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
8448 & relocs, & num_relocs))
8453 if (!slurp_rel_relocs (file, relsec->sh_offset, relsec->sh_size,
8454 & relocs, & num_relocs))
8458 /* SH uses RELA but uses in place value instead of the addend field. */
8459 if (elf_header.e_machine == EM_SH)
8462 symsec = section_headers + relsec->sh_link;
8463 symtab = GET_ELF_SYMBOLS (file, symsec);
8465 for (rp = relocs; rp < relocs + num_relocs; ++rp)
8468 unsigned int reloc_type;
8469 unsigned int reloc_size;
8470 unsigned char * loc;
8472 reloc_type = get_reloc_type (rp->r_info);
8474 if (is_none_reloc (reloc_type))
8477 if (is_32bit_abs_reloc (reloc_type)
8478 || is_32bit_pcrel_reloc (reloc_type))
8480 else if (is_64bit_abs_reloc (reloc_type)
8481 || is_64bit_pcrel_reloc (reloc_type))
8483 else if (is_16bit_abs_reloc (reloc_type))
8487 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
8488 reloc_type, SECTION_NAME (section));
8492 loc = start + rp->r_offset;
8493 if ((loc + reloc_size) > end)
8495 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
8496 (unsigned long) rp->r_offset,
8497 SECTION_NAME (section));
8501 sym = symtab + get_reloc_symindex (rp->r_info);
8503 /* If the reloc has a symbol associated with it,
8504 make sure that it is of an appropriate type. */
8506 && ELF_ST_TYPE (sym->st_info) != STT_SECTION
8507 /* Relocations against symbols without type can happen.
8508 Gcc -feliminate-dwarf2-dups may generate symbols
8509 without type for debug info. */
8510 && ELF_ST_TYPE (sym->st_info) != STT_NOTYPE
8511 /* Relocations against object symbols can happen,
8512 eg when referencing a global array. For an
8513 example of this see the _clz.o binary in libgcc.a. */
8514 && ELF_ST_TYPE (sym->st_info) != STT_OBJECT)
8516 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
8517 get_symbol_type (ELF_ST_TYPE (sym->st_info)),
8518 (long int)(rp - relocs),
8519 SECTION_NAME (relsec));
8523 addend = is_rela ? rp->r_addend : byte_get (loc, reloc_size);
8525 if (is_32bit_pcrel_reloc (reloc_type)
8526 || is_64bit_pcrel_reloc (reloc_type))
8528 /* On HPPA, all pc-relative relocations are biased by 8. */
8529 if (elf_header.e_machine == EM_PARISC)
8531 byte_put (loc, (addend + sym->st_value) - rp->r_offset,
8535 byte_put (loc, addend + sym->st_value, reloc_size);
8545 load_specific_debug_section (enum dwarf_section_display_enum debug,
8546 Elf_Internal_Shdr *sec, void *file)
8548 struct dwarf_section *section = &debug_displays [debug].section;
8550 int section_is_compressed;
8552 /* If it is already loaded, do nothing. */
8553 if (section->start != NULL)
8556 section_is_compressed = section->name == section->compressed_name;
8558 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
8559 section->address = sec->sh_addr;
8560 section->size = sec->sh_size;
8561 section->start = get_data (NULL, file, sec->sh_offset, 1,
8563 if (section->start == NULL)
8566 if (section_is_compressed)
8567 if (! uncompress_section_contents (§ion->start, §ion->size))
8570 if (debug_displays [debug].relocate)
8571 debug_apply_relocations (file, sec, section->start);
8577 load_debug_section (enum dwarf_section_display_enum debug, void *file)
8579 struct dwarf_section *section = &debug_displays [debug].section;
8580 Elf_Internal_Shdr *sec;
8582 /* Locate the debug section. */
8583 sec = find_section (section->uncompressed_name);
8585 section->name = section->uncompressed_name;
8588 sec = find_section (section->compressed_name);
8590 section->name = section->compressed_name;
8595 return load_specific_debug_section (debug, sec, file);
8599 free_debug_section (enum dwarf_section_display_enum debug)
8601 struct dwarf_section *section = &debug_displays [debug].section;
8603 if (section->start == NULL)
8606 free ((char *) section->start);
8607 section->start = NULL;
8608 section->address = 0;
8613 display_debug_section (Elf_Internal_Shdr *section, FILE *file)
8615 char *name = SECTION_NAME (section);
8616 bfd_size_type length;
8618 enum dwarf_section_display_enum i;
8620 length = section->sh_size;
8623 printf (_("\nSection '%s' has no debugging data.\n"), name);
8627 if (const_strneq (name, ".gnu.linkonce.wi."))
8628 name = ".debug_info";
8630 /* See if we know how to display the contents of this section. */
8631 for (i = 0; i < max; i++)
8632 if (streq (debug_displays[i].section.uncompressed_name, name)
8633 || streq (debug_displays[i].section.compressed_name, name))
8635 struct dwarf_section *sec = &debug_displays [i].section;
8636 int secondary = (section != find_section (name));
8639 free_debug_section (i);
8641 if (streq (debug_displays[i].section.uncompressed_name, name))
8642 sec->name = sec->uncompressed_name;
8644 sec->name = sec->compressed_name;
8645 if (load_specific_debug_section (i, section, file))
8647 result &= debug_displays[i].display (sec, file);
8649 if (secondary || (i != info && i != abbrev))
8650 free_debug_section (i);
8658 printf (_("Unrecognized debug section: %s\n"), name);
8665 /* Set DUMP_SECTS for all sections where dumps were requested
8666 based on section name. */
8669 initialise_dumps_byname (void)
8671 struct dump_list_entry *cur;
8673 for (cur = dump_sects_byname; cur; cur = cur->next)
8678 for (i = 0, any = 0; i < elf_header.e_shnum; i++)
8679 if (streq (SECTION_NAME (section_headers + i), cur->name))
8681 request_dump_bynumber (i, cur->type);
8686 warn (_("Section '%s' was not dumped because it does not exist!\n"),
8692 process_section_contents (FILE *file)
8694 Elf_Internal_Shdr *section;
8700 initialise_dumps_byname ();
8702 for (i = 0, section = section_headers;
8703 i < elf_header.e_shnum && i < num_dump_sects;
8706 #ifdef SUPPORT_DISASSEMBLY
8707 if (dump_sects[i] & DISASS_DUMP)
8708 disassemble_section (section, file);
8710 if (dump_sects[i] & HEX_DUMP)
8711 dump_section_as_bytes (section, file);
8713 if (dump_sects[i] & DEBUG_DUMP)
8714 display_debug_section (section, file);
8716 if (dump_sects[i] & STRING_DUMP)
8717 dump_section_as_strings (section, file);
8720 /* Check to see if the user requested a
8721 dump of a section that does not exist. */
8722 while (i++ < num_dump_sects)
8724 warn (_("Section %d was not dumped because it does not exist!\n"), i);
8728 process_mips_fpe_exception (int mask)
8733 if (mask & OEX_FPU_INEX)
8734 fputs ("INEX", stdout), first = 0;
8735 if (mask & OEX_FPU_UFLO)
8736 printf ("%sUFLO", first ? "" : "|"), first = 0;
8737 if (mask & OEX_FPU_OFLO)
8738 printf ("%sOFLO", first ? "" : "|"), first = 0;
8739 if (mask & OEX_FPU_DIV0)
8740 printf ("%sDIV0", first ? "" : "|"), first = 0;
8741 if (mask & OEX_FPU_INVAL)
8742 printf ("%sINVAL", first ? "" : "|");
8745 fputs ("0", stdout);
8748 /* ARM EABI attributes section. */
8753 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
8756 } arm_attr_public_tag;
8758 static const char *arm_attr_tag_CPU_arch[] =
8759 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
8760 "v6K", "v7", "v6-M", "v6S-M"};
8761 static const char *arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
8762 static const char *arm_attr_tag_THUMB_ISA_use[] =
8763 {"No", "Thumb-1", "Thumb-2"};
8764 static const char *arm_attr_tag_VFP_arch[] =
8765 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16"};
8766 static const char *arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
8767 static const char *arm_attr_tag_Advanced_SIMD_arch[] = {"No", "NEONv1"};
8768 static const char *arm_attr_tag_PCS_config[] =
8769 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
8770 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
8771 static const char *arm_attr_tag_ABI_PCS_R9_use[] =
8772 {"V6", "SB", "TLS", "Unused"};
8773 static const char *arm_attr_tag_ABI_PCS_RW_data[] =
8774 {"Absolute", "PC-relative", "SB-relative", "None"};
8775 static const char *arm_attr_tag_ABI_PCS_RO_data[] =
8776 {"Absolute", "PC-relative", "None"};
8777 static const char *arm_attr_tag_ABI_PCS_GOT_use[] =
8778 {"None", "direct", "GOT-indirect"};
8779 static const char *arm_attr_tag_ABI_PCS_wchar_t[] =
8780 {"None", "??? 1", "2", "??? 3", "4"};
8781 static const char *arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
8782 static const char *arm_attr_tag_ABI_FP_denormal[] =
8783 {"Unused", "Needed", "Sign only"};
8784 static const char *arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
8785 static const char *arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
8786 static const char *arm_attr_tag_ABI_FP_number_model[] =
8787 {"Unused", "Finite", "RTABI", "IEEE 754"};
8788 static const char *arm_attr_tag_ABI_align8_needed[] = {"No", "Yes", "4-byte"};
8789 static const char *arm_attr_tag_ABI_align8_preserved[] =
8790 {"No", "Yes, except leaf SP", "Yes"};
8791 static const char *arm_attr_tag_ABI_enum_size[] =
8792 {"Unused", "small", "int", "forced to int"};
8793 static const char *arm_attr_tag_ABI_HardFP_use[] =
8794 {"As Tag_VFP_arch", "SP only", "DP only", "SP and DP"};
8795 static const char *arm_attr_tag_ABI_VFP_args[] =
8796 {"AAPCS", "VFP registers", "custom"};
8797 static const char *arm_attr_tag_ABI_WMMX_args[] =
8798 {"AAPCS", "WMMX registers", "custom"};
8799 static const char *arm_attr_tag_ABI_optimization_goals[] =
8800 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
8801 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
8802 static const char *arm_attr_tag_ABI_FP_optimization_goals[] =
8803 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
8804 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
8805 static const char *arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
8806 static const char *arm_attr_tag_VFP_HP_extension[] =
8807 {"Not Allowed", "Allowed"};
8808 static const char *arm_attr_tag_ABI_FP_16bit_format[] =
8809 {"None", "IEEE 754", "Alternative Format"};
8810 static const char *arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
8811 static const char *arm_attr_tag_Virtualization_use[] =
8812 {"Not Allowed", "Allowed"};
8813 static const char *arm_attr_tag_MPextension_use[] = {"Not Allowed", "Allowed"};
8815 #define LOOKUP(id, name) \
8816 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
8817 static arm_attr_public_tag arm_attr_public_tags[] =
8819 {4, "CPU_raw_name", 1, NULL},
8820 {5, "CPU_name", 1, NULL},
8821 LOOKUP(6, CPU_arch),
8822 {7, "CPU_arch_profile", 0, NULL},
8823 LOOKUP(8, ARM_ISA_use),
8824 LOOKUP(9, THUMB_ISA_use),
8825 LOOKUP(10, VFP_arch),
8826 LOOKUP(11, WMMX_arch),
8827 LOOKUP(12, Advanced_SIMD_arch),
8828 LOOKUP(13, PCS_config),
8829 LOOKUP(14, ABI_PCS_R9_use),
8830 LOOKUP(15, ABI_PCS_RW_data),
8831 LOOKUP(16, ABI_PCS_RO_data),
8832 LOOKUP(17, ABI_PCS_GOT_use),
8833 LOOKUP(18, ABI_PCS_wchar_t),
8834 LOOKUP(19, ABI_FP_rounding),
8835 LOOKUP(20, ABI_FP_denormal),
8836 LOOKUP(21, ABI_FP_exceptions),
8837 LOOKUP(22, ABI_FP_user_exceptions),
8838 LOOKUP(23, ABI_FP_number_model),
8839 LOOKUP(24, ABI_align8_needed),
8840 LOOKUP(25, ABI_align8_preserved),
8841 LOOKUP(26, ABI_enum_size),
8842 LOOKUP(27, ABI_HardFP_use),
8843 LOOKUP(28, ABI_VFP_args),
8844 LOOKUP(29, ABI_WMMX_args),
8845 LOOKUP(30, ABI_optimization_goals),
8846 LOOKUP(31, ABI_FP_optimization_goals),
8847 {32, "compatibility", 0, NULL},
8848 LOOKUP(34, CPU_unaligned_access),
8849 LOOKUP(36, VFP_HP_extension),
8850 LOOKUP(38, ABI_FP_16bit_format),
8851 {64, "nodefaults", 0, NULL},
8852 {65, "also_compatible_with", 0, NULL},
8853 LOOKUP(66, T2EE_use),
8854 {67, "conformance", 1, NULL},
8855 LOOKUP(68, Virtualization_use),
8856 LOOKUP(70, MPextension_use)
8860 /* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
8863 read_uleb128 (unsigned char *p, unsigned int *plen)
8877 val |= ((unsigned int)c & 0x7f) << shift;
8886 static unsigned char *
8887 display_arm_attribute (unsigned char *p)
8892 arm_attr_public_tag *attr;
8896 tag = read_uleb128 (p, &len);
8899 for (i = 0; i < ARRAY_SIZE(arm_attr_public_tags); i++)
8901 if (arm_attr_public_tags[i].tag == tag)
8903 attr = &arm_attr_public_tags[i];
8910 printf (" Tag_%s: ", attr->name);
8916 case 7: /* Tag_CPU_arch_profile. */
8917 val = read_uleb128 (p, &len);
8921 case 0: printf ("None\n"); break;
8922 case 'A': printf ("Application\n"); break;
8923 case 'R': printf ("Realtime\n"); break;
8924 case 'M': printf ("Microcontroller\n"); break;
8925 default: printf ("??? (%d)\n", val); break;
8929 case 32: /* Tag_compatibility. */
8930 val = read_uleb128 (p, &len);
8932 printf ("flag = %d, vendor = %s\n", val, p);
8933 p += strlen((char *)p) + 1;
8936 case 64: /* Tag_nodefaults. */
8941 case 65: /* Tag_also_compatible_with. */
8942 val = read_uleb128 (p, &len);
8944 if (val == 6 /* Tag_CPU_arch. */)
8946 val = read_uleb128 (p, &len);
8948 if ((unsigned int)val >= ARRAY_SIZE(arm_attr_tag_CPU_arch))
8949 printf ("??? (%d)\n", val);
8951 printf ("%s\n", arm_attr_tag_CPU_arch[val]);
8955 while (*(p++) != '\0' /* NUL terminator. */);
8969 assert (attr->type & 0x80);
8970 val = read_uleb128 (p, &len);
8972 type = attr->type & 0x7f;
8974 printf ("??? (%d)\n", val);
8976 printf ("%s\n", attr->table[val]);
8983 type = 1; /* String. */
8985 type = 2; /* uleb128. */
8986 printf (" Tag_unknown_%d: ", tag);
8991 printf ("\"%s\"\n", p);
8992 p += strlen((char *)p) + 1;
8996 val = read_uleb128 (p, &len);
8998 printf ("%d (0x%x)\n", val, val);
9004 static unsigned char *
9005 display_gnu_attribute (unsigned char * p,
9006 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int))
9013 tag = read_uleb128 (p, &len);
9016 /* Tag_compatibility is the only generic GNU attribute defined at
9020 val = read_uleb128 (p, &len);
9022 printf ("flag = %d, vendor = %s\n", val, p);
9023 p += strlen ((char *) p) + 1;
9027 if ((tag & 2) == 0 && display_proc_gnu_attribute)
9028 return display_proc_gnu_attribute (p, tag);
9031 type = 1; /* String. */
9033 type = 2; /* uleb128. */
9034 printf (" Tag_unknown_%d: ", tag);
9038 printf ("\"%s\"\n", p);
9039 p += strlen ((char *) p) + 1;
9043 val = read_uleb128 (p, &len);
9045 printf ("%d (0x%x)\n", val, val);
9051 static unsigned char *
9052 display_power_gnu_attribute (unsigned char *p, int tag)
9058 if (tag == Tag_GNU_Power_ABI_FP)
9060 val = read_uleb128 (p, &len);
9062 printf (" Tag_GNU_Power_ABI_FP: ");
9067 printf ("Hard or soft float\n");
9070 printf ("Hard float\n");
9073 printf ("Soft float\n");
9076 printf ("Single-precision hard float\n");
9079 printf ("??? (%d)\n", val);
9085 if (tag == Tag_GNU_Power_ABI_Vector)
9087 val = read_uleb128 (p, &len);
9089 printf (" Tag_GNU_Power_ABI_Vector: ");
9096 printf ("Generic\n");
9099 printf ("AltiVec\n");
9105 printf ("??? (%d)\n", val);
9111 if (tag == Tag_GNU_Power_ABI_Struct_Return)
9113 val = read_uleb128 (p, &len);
9115 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
9125 printf ("Memory\n");
9128 printf ("??? (%d)\n", val);
9135 type = 1; /* String. */
9137 type = 2; /* uleb128. */
9138 printf (" Tag_unknown_%d: ", tag);
9142 printf ("\"%s\"\n", p);
9143 p += strlen ((char *) p) + 1;
9147 val = read_uleb128 (p, &len);
9149 printf ("%d (0x%x)\n", val, val);
9155 static unsigned char *
9156 display_mips_gnu_attribute (unsigned char *p, int tag)
9162 if (tag == Tag_GNU_MIPS_ABI_FP)
9164 val = read_uleb128 (p, &len);
9166 printf (" Tag_GNU_MIPS_ABI_FP: ");
9171 printf ("Hard or soft float\n");
9174 printf ("Hard float (-mdouble-float)\n");
9177 printf ("Hard float (-msingle-float)\n");
9180 printf ("Soft float\n");
9183 printf ("64-bit float (-mips32r2 -mfp64)\n");
9186 printf ("??? (%d)\n", val);
9193 type = 1; /* String. */
9195 type = 2; /* uleb128. */
9196 printf (" Tag_unknown_%d: ", tag);
9200 printf ("\"%s\"\n", p);
9201 p += strlen ((char *) p) + 1;
9205 val = read_uleb128 (p, &len);
9207 printf ("%d (0x%x)\n", val, val);
9214 process_attributes (FILE * file,
9215 const char * public_name,
9216 unsigned int proc_type,
9217 unsigned char * (* display_pub_attribute) (unsigned char *),
9218 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int))
9220 Elf_Internal_Shdr *sect;
9221 unsigned char *contents;
9224 bfd_vma section_len;
9228 /* Find the section header so that we get the size. */
9229 for (i = 0, sect = section_headers;
9230 i < elf_header.e_shnum;
9233 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
9236 contents = get_data (NULL, file, sect->sh_offset, 1, sect->sh_size,
9238 if (contents == NULL)
9244 len = sect->sh_size - 1;
9250 bfd_boolean public_section;
9251 bfd_boolean gnu_section;
9253 section_len = byte_get (p, 4);
9256 if (section_len > len)
9258 printf (_("ERROR: Bad section length (%d > %d)\n"),
9259 (int) section_len, (int) len);
9264 printf ("Attribute Section: %s\n", p);
9266 if (public_name && streq ((char *) p, public_name))
9267 public_section = TRUE;
9269 public_section = FALSE;
9271 if (streq ((char *) p, "gnu"))
9274 gnu_section = FALSE;
9276 namelen = strlen ((char *) p) + 1;
9278 section_len -= namelen + 4;
9280 while (section_len > 0)
9286 size = byte_get (p, 4);
9287 if (size > section_len)
9289 printf (_("ERROR: Bad subsection length (%d > %d)\n"),
9290 (int) size, (int) section_len);
9294 section_len -= size;
9301 printf ("File Attributes\n");
9304 printf ("Section Attributes:");
9307 printf ("Symbol Attributes:");
9313 val = read_uleb128 (p, &i);
9317 printf (" %d", val);
9322 printf ("Unknown tag: %d\n", tag);
9323 public_section = FALSE;
9330 p = display_pub_attribute (p);
9332 else if (gnu_section)
9335 p = display_gnu_attribute (p,
9336 display_proc_gnu_attribute);
9340 /* ??? Do something sensible, like dump hex. */
9341 printf (" Unknown section contexts\n");
9348 printf (_("Unknown format '%c'\n"), *p);
9356 process_arm_specific (FILE *file)
9358 return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
9359 display_arm_attribute, NULL);
9363 process_power_specific (FILE *file)
9365 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
9366 display_power_gnu_attribute);
9369 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
9370 Print the Address, Access and Initial fields of an entry at VMA ADDR
9371 and return the VMA of the next entry. */
9374 print_mips_got_entry (unsigned char *data, bfd_vma pltgot, bfd_vma addr)
9377 print_vma (addr, LONG_HEX);
9379 if (addr < pltgot + 0xfff0)
9380 printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
9382 printf ("%10s", "");
9385 printf ("%*s", is_32bit_elf ? 8 : 16, "<unknown>");
9390 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
9391 print_vma (entry, LONG_HEX);
9393 return addr + (is_32bit_elf ? 4 : 8);
9396 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
9397 PLTGOT. Print the Address and Initial fields of an entry at VMA
9398 ADDR and return the VMA of the next entry. */
9401 print_mips_pltgot_entry (unsigned char *data, bfd_vma pltgot, bfd_vma addr)
9404 print_vma (addr, LONG_HEX);
9407 printf ("%*s", is_32bit_elf ? 8 : 16, "<unknown>");
9412 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
9413 print_vma (entry, LONG_HEX);
9415 return addr + (is_32bit_elf ? 4 : 8);
9419 process_mips_specific (FILE *file)
9421 Elf_Internal_Dyn *entry;
9422 size_t liblist_offset = 0;
9423 size_t liblistno = 0;
9424 size_t conflictsno = 0;
9425 size_t options_offset = 0;
9426 size_t conflicts_offset = 0;
9427 size_t pltrelsz = 0;
9430 bfd_vma mips_pltgot = 0;
9432 bfd_vma local_gotno = 0;
9434 bfd_vma symtabno = 0;
9436 process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
9437 display_mips_gnu_attribute);
9439 /* We have a lot of special sections. Thanks SGI! */
9440 if (dynamic_section == NULL)
9441 /* No information available. */
9444 for (entry = dynamic_section; entry->d_tag != DT_NULL; ++entry)
9445 switch (entry->d_tag)
9447 case DT_MIPS_LIBLIST:
9449 = offset_from_vma (file, entry->d_un.d_val,
9450 liblistno * sizeof (Elf32_External_Lib));
9452 case DT_MIPS_LIBLISTNO:
9453 liblistno = entry->d_un.d_val;
9455 case DT_MIPS_OPTIONS:
9456 options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
9458 case DT_MIPS_CONFLICT:
9460 = offset_from_vma (file, entry->d_un.d_val,
9461 conflictsno * sizeof (Elf32_External_Conflict));
9463 case DT_MIPS_CONFLICTNO:
9464 conflictsno = entry->d_un.d_val;
9467 pltgot = entry->d_un.d_ptr;
9469 case DT_MIPS_LOCAL_GOTNO:
9470 local_gotno = entry->d_un.d_val;
9472 case DT_MIPS_GOTSYM:
9473 gotsym = entry->d_un.d_val;
9475 case DT_MIPS_SYMTABNO:
9476 symtabno = entry->d_un.d_val;
9478 case DT_MIPS_PLTGOT:
9479 mips_pltgot = entry->d_un.d_ptr;
9482 pltrel = entry->d_un.d_val;
9485 pltrelsz = entry->d_un.d_val;
9488 jmprel = entry->d_un.d_ptr;
9494 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
9496 Elf32_External_Lib *elib;
9499 elib = get_data (NULL, file, liblist_offset,
9500 liblistno, sizeof (Elf32_External_Lib),
9504 printf ("\nSection '.liblist' contains %lu entries:\n",
9505 (unsigned long) liblistno);
9506 fputs (" Library Time Stamp Checksum Version Flags\n",
9509 for (cnt = 0; cnt < liblistno; ++cnt)
9516 liblist.l_name = BYTE_GET (elib[cnt].l_name);
9517 time = BYTE_GET (elib[cnt].l_time_stamp);
9518 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
9519 liblist.l_version = BYTE_GET (elib[cnt].l_version);
9520 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
9522 tmp = gmtime (&time);
9523 snprintf (timebuf, sizeof (timebuf),
9524 "%04u-%02u-%02uT%02u:%02u:%02u",
9525 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9526 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
9528 printf ("%3lu: ", (unsigned long) cnt);
9529 if (VALID_DYNAMIC_NAME (liblist.l_name))
9530 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
9532 printf ("<corrupt: %9ld>", liblist.l_name);
9533 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
9536 if (liblist.l_flags == 0)
9547 { " EXACT_MATCH", LL_EXACT_MATCH },
9548 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
9549 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
9550 { " EXPORTS", LL_EXPORTS },
9551 { " DELAY_LOAD", LL_DELAY_LOAD },
9552 { " DELTA", LL_DELTA }
9554 int flags = liblist.l_flags;
9557 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
9558 if ((flags & l_flags_vals[fcnt].bit) != 0)
9560 fputs (l_flags_vals[fcnt].name, stdout);
9561 flags ^= l_flags_vals[fcnt].bit;
9564 printf (" %#x", (unsigned int) flags);
9574 if (options_offset != 0)
9576 Elf_External_Options *eopt;
9577 Elf_Internal_Shdr *sect = section_headers;
9578 Elf_Internal_Options *iopt;
9579 Elf_Internal_Options *option;
9583 /* Find the section header so that we get the size. */
9584 while (sect->sh_type != SHT_MIPS_OPTIONS)
9587 eopt = get_data (NULL, file, options_offset, 1, sect->sh_size,
9591 iopt = cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (*iopt));
9594 error (_("Out of memory\n"));
9601 while (offset < sect->sh_size)
9603 Elf_External_Options *eoption;
9605 eoption = (Elf_External_Options *) ((char *) eopt + offset);
9607 option->kind = BYTE_GET (eoption->kind);
9608 option->size = BYTE_GET (eoption->size);
9609 option->section = BYTE_GET (eoption->section);
9610 option->info = BYTE_GET (eoption->info);
9612 offset += option->size;
9618 printf (_("\nSection '%s' contains %d entries:\n"),
9619 SECTION_NAME (sect), cnt);
9627 switch (option->kind)
9630 /* This shouldn't happen. */
9631 printf (" NULL %d %lx", option->section, option->info);
9634 printf (" REGINFO ");
9635 if (elf_header.e_machine == EM_MIPS)
9638 Elf32_External_RegInfo *ereg;
9639 Elf32_RegInfo reginfo;
9641 ereg = (Elf32_External_RegInfo *) (option + 1);
9642 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
9643 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
9644 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
9645 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
9646 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
9647 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
9649 printf ("GPR %08lx GP 0x%lx\n",
9651 (unsigned long) reginfo.ri_gp_value);
9652 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9653 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
9654 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
9659 Elf64_External_RegInfo *ereg;
9660 Elf64_Internal_RegInfo reginfo;
9662 ereg = (Elf64_External_RegInfo *) (option + 1);
9663 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
9664 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
9665 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
9666 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
9667 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
9668 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
9670 printf ("GPR %08lx GP 0x",
9671 reginfo.ri_gprmask);
9672 printf_vma (reginfo.ri_gp_value);
9675 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9676 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
9677 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
9681 case ODK_EXCEPTIONS:
9682 fputs (" EXCEPTIONS fpe_min(", stdout);
9683 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
9684 fputs (") fpe_max(", stdout);
9685 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
9686 fputs (")", stdout);
9688 if (option->info & OEX_PAGE0)
9689 fputs (" PAGE0", stdout);
9690 if (option->info & OEX_SMM)
9691 fputs (" SMM", stdout);
9692 if (option->info & OEX_FPDBUG)
9693 fputs (" FPDBUG", stdout);
9694 if (option->info & OEX_DISMISS)
9695 fputs (" DISMISS", stdout);
9698 fputs (" PAD ", stdout);
9699 if (option->info & OPAD_PREFIX)
9700 fputs (" PREFIX", stdout);
9701 if (option->info & OPAD_POSTFIX)
9702 fputs (" POSTFIX", stdout);
9703 if (option->info & OPAD_SYMBOL)
9704 fputs (" SYMBOL", stdout);
9707 fputs (" HWPATCH ", stdout);
9708 if (option->info & OHW_R4KEOP)
9709 fputs (" R4KEOP", stdout);
9710 if (option->info & OHW_R8KPFETCH)
9711 fputs (" R8KPFETCH", stdout);
9712 if (option->info & OHW_R5KEOP)
9713 fputs (" R5KEOP", stdout);
9714 if (option->info & OHW_R5KCVTL)
9715 fputs (" R5KCVTL", stdout);
9718 fputs (" FILL ", stdout);
9719 /* XXX Print content of info word? */
9722 fputs (" TAGS ", stdout);
9723 /* XXX Print content of info word? */
9726 fputs (" HWAND ", stdout);
9727 if (option->info & OHWA0_R4KEOP_CHECKED)
9728 fputs (" R4KEOP_CHECKED", stdout);
9729 if (option->info & OHWA0_R4KEOP_CLEAN)
9730 fputs (" R4KEOP_CLEAN", stdout);
9733 fputs (" HWOR ", stdout);
9734 if (option->info & OHWA0_R4KEOP_CHECKED)
9735 fputs (" R4KEOP_CHECKED", stdout);
9736 if (option->info & OHWA0_R4KEOP_CLEAN)
9737 fputs (" R4KEOP_CLEAN", stdout);
9740 printf (" GP_GROUP %#06lx self-contained %#06lx",
9741 option->info & OGP_GROUP,
9742 (option->info & OGP_SELF) >> 16);
9745 printf (" IDENT %#06lx self-contained %#06lx",
9746 option->info & OGP_GROUP,
9747 (option->info & OGP_SELF) >> 16);
9750 /* This shouldn't happen. */
9751 printf (" %3d ??? %d %lx",
9752 option->kind, option->section, option->info);
9756 len = sizeof (*eopt);
9757 while (len < option->size)
9758 if (((char *) option)[len] >= ' '
9759 && ((char *) option)[len] < 0x7f)
9760 printf ("%c", ((char *) option)[len++]);
9762 printf ("\\%03o", ((char *) option)[len++]);
9764 fputs ("\n", stdout);
9772 if (conflicts_offset != 0 && conflictsno != 0)
9774 Elf32_Conflict *iconf;
9777 if (dynamic_symbols == NULL)
9779 error (_("conflict list found without a dynamic symbol table\n"));
9783 iconf = cmalloc (conflictsno, sizeof (*iconf));
9786 error (_("Out of memory\n"));
9792 Elf32_External_Conflict *econf32;
9794 econf32 = get_data (NULL, file, conflicts_offset,
9795 conflictsno, sizeof (*econf32), _("conflict"));
9799 for (cnt = 0; cnt < conflictsno; ++cnt)
9800 iconf[cnt] = BYTE_GET (econf32[cnt]);
9806 Elf64_External_Conflict *econf64;
9808 econf64 = get_data (NULL, file, conflicts_offset,
9809 conflictsno, sizeof (*econf64), _("conflict"));
9813 for (cnt = 0; cnt < conflictsno; ++cnt)
9814 iconf[cnt] = BYTE_GET (econf64[cnt]);
9819 printf (_("\nSection '.conflict' contains %lu entries:\n"),
9820 (unsigned long) conflictsno);
9821 puts (_(" Num: Index Value Name"));
9823 for (cnt = 0; cnt < conflictsno; ++cnt)
9825 Elf_Internal_Sym *psym = & dynamic_symbols[iconf[cnt]];
9827 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
9828 print_vma (psym->st_value, FULL_HEX);
9830 if (VALID_DYNAMIC_NAME (psym->st_name))
9831 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
9833 printf ("<corrupt: %14ld>", psym->st_name);
9840 if (pltgot != 0 && local_gotno != 0)
9842 bfd_vma entry, local_end, global_end;
9844 unsigned char *data;
9848 addr_size = (is_32bit_elf ? 4 : 8);
9849 local_end = pltgot + local_gotno * addr_size;
9850 global_end = local_end + (symtabno - gotsym) * addr_size;
9852 offset = offset_from_vma (file, pltgot, global_end - pltgot);
9853 data = get_data (NULL, file, offset, global_end - pltgot, 1, _("GOT"));
9854 printf (_("\nPrimary GOT:\n"));
9855 printf (_(" Canonical gp value: "));
9856 print_vma (pltgot + 0x7ff0, LONG_HEX);
9859 printf (_(" Reserved entries:\n"));
9860 printf (_(" %*s %10s %*s Purpose\n"),
9861 addr_size * 2, "Address", "Access",
9862 addr_size * 2, "Initial");
9863 entry = print_mips_got_entry (data, pltgot, entry);
9864 printf (" Lazy resolver\n");
9866 && (byte_get (data + entry - pltgot, addr_size)
9867 >> (addr_size * 8 - 1)) != 0)
9869 entry = print_mips_got_entry (data, pltgot, entry);
9870 printf (" Module pointer (GNU extension)\n");
9874 if (entry < local_end)
9876 printf (_(" Local entries:\n"));
9877 printf (_(" %*s %10s %*s\n"),
9878 addr_size * 2, "Address", "Access",
9879 addr_size * 2, "Initial");
9880 while (entry < local_end)
9882 entry = print_mips_got_entry (data, pltgot, entry);
9888 if (gotsym < symtabno)
9892 printf (_(" Global entries:\n"));
9893 printf (_(" %*s %10s %*s %*s %-7s %3s %s\n"),
9894 addr_size * 2, "Address", "Access",
9895 addr_size * 2, "Initial",
9896 addr_size * 2, "Sym.Val.", "Type", "Ndx", "Name");
9897 sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
9898 for (i = gotsym; i < symtabno; i++)
9900 Elf_Internal_Sym *psym;
9902 psym = dynamic_symbols + i;
9903 entry = print_mips_got_entry (data, pltgot, entry);
9905 print_vma (psym->st_value, LONG_HEX);
9906 printf (" %-7s %3s ",
9907 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
9908 get_symbol_index_type (psym->st_shndx));
9909 if (VALID_DYNAMIC_NAME (psym->st_name))
9910 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
9912 printf ("<corrupt: %14ld>", psym->st_name);
9922 if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
9925 size_t offset, rel_offset;
9926 unsigned long count, i;
9927 unsigned char *data;
9928 int addr_size, sym_width;
9929 Elf_Internal_Rela *rels;
9931 rel_offset = offset_from_vma (file, jmprel, pltrelsz);
9932 if (pltrel == DT_RELA)
9934 if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
9939 if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
9943 entry = mips_pltgot;
9944 addr_size = (is_32bit_elf ? 4 : 8);
9945 end = mips_pltgot + (2 + count) * addr_size;
9947 offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
9948 data = get_data (NULL, file, offset, end - mips_pltgot, 1, _("PLT GOT"));
9949 printf (_("\nPLT GOT:\n\n"));
9950 printf (_(" Reserved entries:\n"));
9951 printf (_(" %*s %*s Purpose\n"),
9952 addr_size * 2, "Address", addr_size * 2, "Initial");
9953 entry = print_mips_pltgot_entry (data, mips_pltgot, entry);
9954 printf (" PLT lazy resolver\n");
9955 entry = print_mips_pltgot_entry (data, mips_pltgot, entry);
9956 printf (" Module pointer\n");
9959 printf (_(" Entries:\n"));
9960 printf (_(" %*s %*s %*s %-7s %3s %s\n"),
9961 addr_size * 2, "Address",
9962 addr_size * 2, "Initial",
9963 addr_size * 2, "Sym.Val.", "Type", "Ndx", "Name");
9964 sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
9965 for (i = 0; i < count; i++)
9967 Elf_Internal_Sym *psym;
9969 psym = dynamic_symbols + get_reloc_symindex (rels[i].r_info);
9970 entry = print_mips_pltgot_entry (data, mips_pltgot, entry);
9972 print_vma (psym->st_value, LONG_HEX);
9973 printf (" %-7s %3s ",
9974 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
9975 get_symbol_index_type (psym->st_shndx));
9976 if (VALID_DYNAMIC_NAME (psym->st_name))
9977 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
9979 printf ("<corrupt: %14ld>", psym->st_name);
9993 process_gnu_liblist (FILE *file)
9995 Elf_Internal_Shdr *section, *string_sec;
9996 Elf32_External_Lib *elib;
10005 for (i = 0, section = section_headers;
10006 i < elf_header.e_shnum;
10009 switch (section->sh_type)
10011 case SHT_GNU_LIBLIST:
10012 if (section->sh_link >= elf_header.e_shnum)
10015 elib = get_data (NULL, file, section->sh_offset, 1, section->sh_size,
10020 string_sec = section_headers + section->sh_link;
10022 strtab = get_data (NULL, file, string_sec->sh_offset, 1,
10023 string_sec->sh_size, _("liblist string table"));
10024 strtab_size = string_sec->sh_size;
10027 || section->sh_entsize != sizeof (Elf32_External_Lib))
10033 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
10034 SECTION_NAME (section),
10035 (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
10037 puts (" Library Time Stamp Checksum Version Flags");
10039 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
10047 liblist.l_name = BYTE_GET (elib[cnt].l_name);
10048 time = BYTE_GET (elib[cnt].l_time_stamp);
10049 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
10050 liblist.l_version = BYTE_GET (elib[cnt].l_version);
10051 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
10053 tmp = gmtime (&time);
10054 snprintf (timebuf, sizeof (timebuf),
10055 "%04u-%02u-%02uT%02u:%02u:%02u",
10056 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
10057 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
10059 printf ("%3lu: ", (unsigned long) cnt);
10061 printf ("%-20s", liblist.l_name < strtab_size
10062 ? strtab + liblist.l_name : "<corrupt>");
10064 printf ("%-20.20s", liblist.l_name < strtab_size
10065 ? strtab + liblist.l_name : "<corrupt>");
10066 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
10067 liblist.l_version, liblist.l_flags);
10077 static const char *
10078 get_note_type (unsigned e_type)
10080 static char buff[64];
10082 if (elf_header.e_type == ET_CORE)
10086 return _("NT_AUXV (auxiliary vector)");
10088 return _("NT_PRSTATUS (prstatus structure)");
10090 return _("NT_FPREGSET (floating point registers)");
10092 return _("NT_PRPSINFO (prpsinfo structure)");
10093 case NT_TASKSTRUCT:
10094 return _("NT_TASKSTRUCT (task structure)");
10096 return _("NT_PRXFPREG (user_xfpregs structure)");
10098 return _("NT_PPC_VMX (ppc Altivec registers)");
10100 return _("NT_PPC_VSX (ppc VSX registers)");
10102 return _("NT_PSTATUS (pstatus structure)");
10104 return _("NT_FPREGS (floating point registers)");
10106 return _("NT_PSINFO (psinfo structure)");
10108 return _("NT_LWPSTATUS (lwpstatus_t structure)");
10110 return _("NT_LWPSINFO (lwpsinfo_t structure)");
10111 case NT_WIN32PSTATUS:
10112 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
10120 return _("NT_VERSION (version)");
10122 return _("NT_ARCH (architecture)");
10127 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
10131 static const char *
10132 get_gnu_elf_note_type (unsigned e_type)
10134 static char buff[64];
10138 case NT_GNU_ABI_TAG:
10139 return _("NT_GNU_ABI_TAG (ABI version tag)");
10141 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
10142 case NT_GNU_BUILD_ID:
10143 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
10144 case NT_GNU_GOLD_VERSION:
10145 return _("NT_GNU_GOLD_VERSION (gold version)");
10150 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
10154 static const char *
10155 get_netbsd_elfcore_note_type (unsigned e_type)
10157 static char buff[64];
10159 if (e_type == NT_NETBSDCORE_PROCINFO)
10161 /* NetBSD core "procinfo" structure. */
10162 return _("NetBSD procinfo structure");
10165 /* As of Jan 2002 there are no other machine-independent notes
10166 defined for NetBSD core files. If the note type is less
10167 than the start of the machine-dependent note types, we don't
10170 if (e_type < NT_NETBSDCORE_FIRSTMACH)
10172 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
10176 switch (elf_header.e_machine)
10178 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
10179 and PT_GETFPREGS == mach+2. */
10184 case EM_SPARC32PLUS:
10188 case NT_NETBSDCORE_FIRSTMACH+0:
10189 return _("PT_GETREGS (reg structure)");
10190 case NT_NETBSDCORE_FIRSTMACH+2:
10191 return _("PT_GETFPREGS (fpreg structure)");
10197 /* On all other arch's, PT_GETREGS == mach+1 and
10198 PT_GETFPREGS == mach+3. */
10202 case NT_NETBSDCORE_FIRSTMACH+1:
10203 return _("PT_GETREGS (reg structure)");
10204 case NT_NETBSDCORE_FIRSTMACH+3:
10205 return _("PT_GETFPREGS (fpreg structure)");
10211 snprintf (buff, sizeof (buff), _("PT_FIRSTMACH+%d"),
10212 e_type - NT_NETBSDCORE_FIRSTMACH);
10216 /* Note that by the ELF standard, the name field is already null byte
10217 terminated, and namesz includes the terminating null byte.
10218 I.E. the value of namesz for the name "FSF" is 4.
10220 If the value of namesz is zero, there is no name present. */
10222 process_note (Elf_Internal_Note *pnote)
10224 const char *name = pnote->namesz ? pnote->namedata : "(NONE)";
10227 if (pnote->namesz == 0)
10228 /* If there is no note name, then use the default set of
10229 note type strings. */
10230 nt = get_note_type (pnote->type);
10232 else if (const_strneq (pnote->namedata, "GNU"))
10233 /* GNU-specific object file notes. */
10234 nt = get_gnu_elf_note_type (pnote->type);
10236 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
10237 /* NetBSD-specific core file notes. */
10238 nt = get_netbsd_elfcore_note_type (pnote->type);
10240 else if (strneq (pnote->namedata, "SPU/", 4))
10242 /* SPU-specific core file notes. */
10243 nt = pnote->namedata + 4;
10248 /* Don't recognize this note name; just use the default set of
10249 note type strings. */
10250 nt = get_note_type (pnote->type);
10252 printf (" %s\t\t0x%08lx\t%s\n", name, pnote->descsz, nt);
10258 process_corefile_note_segment (FILE *file, bfd_vma offset, bfd_vma length)
10260 Elf_External_Note *pnotes;
10261 Elf_External_Note *external;
10267 pnotes = get_data (NULL, file, offset, 1, length, _("notes"));
10273 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
10274 (unsigned long) offset, (unsigned long) length);
10275 printf (_(" Owner\t\tData size\tDescription\n"));
10277 while (external < (Elf_External_Note *)((char *) pnotes + length))
10279 Elf_External_Note *next;
10280 Elf_Internal_Note inote;
10283 inote.type = BYTE_GET (external->type);
10284 inote.namesz = BYTE_GET (external->namesz);
10285 inote.namedata = external->name;
10286 inote.descsz = BYTE_GET (external->descsz);
10287 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
10288 inote.descpos = offset + (inote.descdata - (char *) pnotes);
10290 next = (Elf_External_Note *)(inote.descdata + align_power (inote.descsz, 2));
10292 if (((char *) next) > (((char *) pnotes) + length))
10294 warn (_("corrupt note found at offset %lx into core notes\n"),
10295 (unsigned long) ((char *) external - (char *) pnotes));
10296 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
10297 inote.type, inote.namesz, inote.descsz);
10303 /* Verify that name is null terminated. It appears that at least
10304 one version of Linux (RedHat 6.0) generates corefiles that don't
10305 comply with the ELF spec by failing to include the null byte in
10307 if (inote.namedata[inote.namesz] != '\0')
10309 temp = malloc (inote.namesz + 1);
10313 error (_("Out of memory\n"));
10318 strncpy (temp, inote.namedata, inote.namesz);
10319 temp[inote.namesz] = 0;
10321 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
10322 inote.namedata = temp;
10325 res &= process_note (& inote);
10340 process_corefile_note_segments (FILE *file)
10342 Elf_Internal_Phdr *segment;
10346 if (! get_program_headers (file))
10349 for (i = 0, segment = program_headers;
10350 i < elf_header.e_phnum;
10353 if (segment->p_type == PT_NOTE)
10354 res &= process_corefile_note_segment (file,
10355 (bfd_vma) segment->p_offset,
10356 (bfd_vma) segment->p_filesz);
10363 process_note_sections (FILE *file)
10365 Elf_Internal_Shdr *section;
10369 for (i = 0, section = section_headers;
10370 i < elf_header.e_shnum;
10372 if (section->sh_type == SHT_NOTE)
10373 res &= process_corefile_note_segment (file,
10374 (bfd_vma) section->sh_offset,
10375 (bfd_vma) section->sh_size);
10381 process_notes (FILE *file)
10383 /* If we have not been asked to display the notes then do nothing. */
10387 if (elf_header.e_type != ET_CORE)
10388 return process_note_sections (file);
10390 /* No program headers means no NOTE segment. */
10391 if (elf_header.e_phnum > 0)
10392 return process_corefile_note_segments (file);
10394 printf (_("No note segments present in the core file.\n"));
10399 process_arch_specific (FILE *file)
10404 switch (elf_header.e_machine)
10407 return process_arm_specific (file);
10409 case EM_MIPS_RS3_LE:
10410 return process_mips_specific (file);
10413 return process_power_specific (file);
10422 get_file_header (FILE *file)
10424 /* Read in the identity array. */
10425 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
10428 /* Determine how to read the rest of the header. */
10429 switch (elf_header.e_ident[EI_DATA])
10431 default: /* fall through */
10432 case ELFDATANONE: /* fall through */
10434 byte_get = byte_get_little_endian;
10435 byte_put = byte_put_little_endian;
10438 byte_get = byte_get_big_endian;
10439 byte_put = byte_put_big_endian;
10443 /* For now we only support 32 bit and 64 bit ELF files. */
10444 is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
10446 /* Read in the rest of the header. */
10449 Elf32_External_Ehdr ehdr32;
10451 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
10454 elf_header.e_type = BYTE_GET (ehdr32.e_type);
10455 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
10456 elf_header.e_version = BYTE_GET (ehdr32.e_version);
10457 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
10458 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
10459 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
10460 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
10461 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
10462 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
10463 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
10464 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
10465 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
10466 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
10470 Elf64_External_Ehdr ehdr64;
10472 /* If we have been compiled with sizeof (bfd_vma) == 4, then
10473 we will not be able to cope with the 64bit data found in
10474 64 ELF files. Detect this now and abort before we start
10475 overwriting things. */
10476 if (sizeof (bfd_vma) < 8)
10478 error (_("This instance of readelf has been built without support for a\n\
10479 64 bit data type and so it cannot read 64 bit ELF files.\n"));
10483 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
10486 elf_header.e_type = BYTE_GET (ehdr64.e_type);
10487 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
10488 elf_header.e_version = BYTE_GET (ehdr64.e_version);
10489 elf_header.e_entry = BYTE_GET (ehdr64.e_entry);
10490 elf_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
10491 elf_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
10492 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
10493 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
10494 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
10495 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
10496 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
10497 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
10498 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
10501 if (elf_header.e_shoff)
10503 /* There may be some extensions in the first section header. Don't
10504 bomb if we can't read it. */
10506 get_32bit_section_headers (file, 1);
10508 get_64bit_section_headers (file, 1);
10514 /* Process one ELF object file according to the command line options.
10515 This file may actually be stored in an archive. The file is
10516 positioned at the start of the ELF object. */
10519 process_object (char *file_name, FILE *file)
10523 if (! get_file_header (file))
10525 error (_("%s: Failed to read file header\n"), file_name);
10529 /* Initialise per file variables. */
10530 for (i = ARRAY_SIZE (version_info); i--;)
10531 version_info[i] = 0;
10533 for (i = ARRAY_SIZE (dynamic_info); i--;)
10534 dynamic_info[i] = 0;
10536 /* Process the file. */
10538 printf (_("\nFile: %s\n"), file_name);
10540 /* Initialise the dump_sects array from the cmdline_dump_sects array.
10541 Note we do this even if cmdline_dump_sects is empty because we
10542 must make sure that the dump_sets array is zeroed out before each
10543 object file is processed. */
10544 if (num_dump_sects > num_cmdline_dump_sects)
10545 memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
10547 if (num_cmdline_dump_sects > 0)
10549 if (num_dump_sects == 0)
10550 /* A sneaky way of allocating the dump_sects array. */
10551 request_dump_bynumber (num_cmdline_dump_sects, 0);
10553 assert (num_dump_sects >= num_cmdline_dump_sects);
10554 memcpy (dump_sects, cmdline_dump_sects,
10555 num_cmdline_dump_sects * sizeof (* dump_sects));
10558 if (! process_file_header ())
10561 if (! process_section_headers (file))
10563 /* Without loaded section headers we cannot process lots of
10565 do_unwind = do_version = do_dump = do_arch = 0;
10567 if (! do_using_dynamic)
10568 do_syms = do_reloc = 0;
10571 if (! process_section_groups (file))
10573 /* Without loaded section groups we cannot process unwind. */
10577 if (process_program_headers (file))
10578 process_dynamic_section (file);
10580 process_relocs (file);
10582 process_unwind (file);
10584 process_symbol_table (file);
10586 process_syminfo (file);
10588 process_version_sections (file);
10590 process_section_contents (file);
10592 process_notes (file);
10594 process_gnu_liblist (file);
10596 process_arch_specific (file);
10598 if (program_headers)
10600 free (program_headers);
10601 program_headers = NULL;
10604 if (section_headers)
10606 free (section_headers);
10607 section_headers = NULL;
10612 free (string_table);
10613 string_table = NULL;
10614 string_table_length = 0;
10617 if (dynamic_strings)
10619 free (dynamic_strings);
10620 dynamic_strings = NULL;
10621 dynamic_strings_length = 0;
10624 if (dynamic_symbols)
10626 free (dynamic_symbols);
10627 dynamic_symbols = NULL;
10628 num_dynamic_syms = 0;
10631 if (dynamic_syminfo)
10633 free (dynamic_syminfo);
10634 dynamic_syminfo = NULL;
10637 if (section_headers_groups)
10639 free (section_headers_groups);
10640 section_headers_groups = NULL;
10643 if (section_groups)
10645 struct group_list *g, *next;
10647 for (i = 0; i < group_count; i++)
10649 for (g = section_groups [i].root; g != NULL; g = next)
10656 free (section_groups);
10657 section_groups = NULL;
10660 free_debug_memory ();
10665 /* Process an ELF archive.
10666 On entry the file is positioned just after the ARMAG string. */
10669 process_archive (char *file_name, FILE *file)
10671 struct ar_hdr arhdr;
10673 unsigned long size;
10674 unsigned long index_num = 0;
10675 unsigned long *index_array = NULL;
10676 char *sym_table = NULL;
10677 unsigned long sym_size = 0;
10678 char *longnames = NULL;
10679 unsigned long longnames_size = 0;
10680 size_t file_name_size;
10685 got = fread (&arhdr, 1, sizeof arhdr, file);
10686 if (got != sizeof arhdr)
10691 error (_("%s: failed to read archive header\n"), file_name);
10695 /* See if this is the archive symbol table. */
10696 if (const_strneq (arhdr.ar_name, "/ ")
10697 || const_strneq (arhdr.ar_name, "/SYM64/ "))
10699 size = strtoul (arhdr.ar_size, NULL, 10);
10700 size = size + (size & 1);
10702 if (do_archive_index)
10705 /* A buffer used to hold numbers read in from an archive index.
10706 These are always 4 bytes long and stored in big-endian format. */
10707 #define SIZEOF_AR_INDEX_NUMBERS 4
10708 unsigned char integer_buffer[SIZEOF_AR_INDEX_NUMBERS];
10709 unsigned char * index_buffer;
10711 /* Check the size of the archive index. */
10712 if (size < SIZEOF_AR_INDEX_NUMBERS)
10714 error (_("%s: the archive index is empty\n"), file_name);
10718 /* Read the numer of entries in the archive index. */
10719 got = fread (integer_buffer, 1, sizeof integer_buffer, file);
10720 if (got != sizeof (integer_buffer))
10722 error (_("%s: failed to read archive index\n"), file_name);
10725 index_num = byte_get_big_endian (integer_buffer, sizeof integer_buffer);
10726 size -= SIZEOF_AR_INDEX_NUMBERS;
10728 /* Read in the archive index. */
10729 if (size < index_num * SIZEOF_AR_INDEX_NUMBERS)
10731 error (_("%s: the archive index is supposed to have %ld entries, but the size in the header is too small\n"),
10732 file_name, index_num);
10735 index_buffer = malloc (index_num * SIZEOF_AR_INDEX_NUMBERS);
10736 if (index_buffer == NULL)
10738 error (_("Out of memory whilst trying to read archive symbol index\n"));
10741 got = fread (index_buffer, SIZEOF_AR_INDEX_NUMBERS, index_num, file);
10742 if (got != index_num)
10744 free (index_buffer);
10745 error (_("%s: failed to read archive index\n"), file_name);
10749 size -= index_num * SIZEOF_AR_INDEX_NUMBERS;
10751 /* Convert the index numbers into the host's numeric format. */
10752 index_array = malloc (index_num * sizeof (* index_array));
10753 if (index_array == NULL)
10755 free (index_buffer);
10756 error (_("Out of memory whilst trying to convert the archive symbol index\n"));
10760 for (i = 0; i < index_num; i++)
10761 index_array[i] = byte_get_big_endian ((unsigned char *)(index_buffer + (i * SIZEOF_AR_INDEX_NUMBERS)),
10762 SIZEOF_AR_INDEX_NUMBERS);
10763 free (index_buffer);
10765 /* The remaining space in the header is taken up by the symbol table. */
10768 error (_("%s: the archive has an index but no symbols\n"), file_name);
10772 sym_table = malloc (size);
10774 if (sym_table == NULL)
10776 error (_("Out of memory whilst trying to read archive index symbol table\n"));
10780 got = fread (sym_table, 1, size, file);
10783 error (_("%s: failed to read archive index symbol table\n"), file_name);
10790 if (fseek (file, size, SEEK_CUR) != 0)
10792 error (_("%s: failed to skip archive symbol table\n"), file_name);
10797 got = fread (& arhdr, 1, sizeof arhdr, file);
10798 if (got != sizeof arhdr)
10806 error (_("%s: failed to read archive header following archive index\n"), file_name);
10811 else if (do_archive_index)
10812 printf (_("%s has no archive index\n"), file_name);
10814 if (const_strneq (arhdr.ar_name, "// "))
10816 /* This is the archive string table holding long member
10819 longnames_size = strtoul (arhdr.ar_size, NULL, 10);
10820 longnames = malloc (longnames_size);
10821 if (longnames == NULL)
10823 error (_("Out of memory reading long symbol names in archive\n"));
10828 if (fread (longnames, longnames_size, 1, file) != 1)
10831 error (_("%s: failed to read long symbol name string table\n"), file_name);
10836 if ((longnames_size & 1) != 0)
10839 got = fread (& arhdr, 1, sizeof arhdr, file);
10840 if (got != sizeof arhdr)
10846 error (_("%s: failed to read archive header following long symbol names\n"), file_name);
10853 if (do_archive_index)
10855 if (sym_table == NULL)
10856 error (_("%s: unable to dump the index as none was found\n"), file_name);
10859 unsigned int i, j, k, l;
10861 unsigned long current_pos;
10863 printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
10864 file_name, index_num, sym_size);
10865 current_pos = ftell (file);
10867 for (i = l = 0; i < index_num; i++)
10869 if ((i == 0) || ((i > 0) && (index_array[i] != index_array[i - 1])))
10871 if (fseek (file, index_array[i], SEEK_SET) != 0)
10873 error (_("%s: failed to seek to next file name\n"), file_name);
10877 got = fread (elf_name, 1, 16, file);
10880 error (_("%s: failed to read file name\n"), file_name);
10885 if (elf_name[0] == '/')
10887 /* We have a long name. */
10888 k = j = strtoul (elf_name + 1, NULL, 10);
10889 while ((j < longnames_size) && (longnames[j] != '/'))
10891 longnames[j] = '\0';
10892 printf (_("Binary %s contains:\n"), longnames + k);
10893 longnames[j] = '/';
10898 while ((elf_name[j] != '/') && (j < 16))
10900 elf_name[j] = '\0';
10901 printf(_("Binary %s contains:\n"), elf_name);
10906 error (_("%s: end of the symbol table reached before the end of the index\n"),
10910 printf ("\t%s\n", sym_table + l);
10911 l += strlen (sym_table + l) + 1;
10915 error (_("%s: symbols remain in the index symbol table, but without corresponding entries in the index table\n"),
10918 free (index_array);
10919 index_array = NULL;
10922 if (fseek (file, current_pos, SEEK_SET) != 0)
10924 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
10929 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
10930 && !do_segments && !do_header && !do_dump && !do_version
10931 && !do_histogram && !do_debugging && !do_arch && !do_notes
10932 && !do_section_groups)
10933 return 0; /* Archive index only. */
10936 file_name_size = strlen (file_name);
10945 if (arhdr.ar_name[0] == '/')
10949 off = strtoul (arhdr.ar_name + 1, NULL, 10);
10950 if (off >= longnames_size)
10952 error (_("%s: invalid archive string table offset %lu\n"), file_name, off);
10957 name = longnames + off;
10958 nameend = memchr (name, '/', longnames_size - off);
10962 name = arhdr.ar_name;
10963 nameend = memchr (name, '/', 16);
10966 if (nameend == NULL)
10968 error (_("%s: bad archive file name\n"), file_name);
10973 namealc = malloc (file_name_size + (nameend - name) + 3);
10974 if (namealc == NULL)
10976 error (_("Out of memory\n"));
10981 memcpy (namealc, file_name, file_name_size);
10982 namealc[file_name_size] = '(';
10983 memcpy (namealc + file_name_size + 1, name, nameend - name);
10984 namealc[file_name_size + 1 + (nameend - name)] = ')';
10985 namealc[file_name_size + 2 + (nameend - name)] = '\0';
10987 archive_file_offset = ftell (file);
10988 archive_file_size = strtoul (arhdr.ar_size, NULL, 10);
10990 ret |= process_object (namealc, file);
10995 (archive_file_offset
10996 + archive_file_size
10997 + (archive_file_size & 1)),
11000 error (_("%s: failed to seek to next archive header\n"), file_name);
11005 got = fread (&arhdr, 1, sizeof arhdr, file);
11006 if (got != sizeof arhdr)
11011 error (_("%s: failed to read archive header\n"), file_name);
11018 if (index_array != NULL)
11019 free (index_array);
11020 if (sym_table != NULL)
11022 if (longnames != NULL)
11029 process_file (char *file_name)
11032 struct stat statbuf;
11033 char armag[SARMAG];
11036 if (stat (file_name, &statbuf) < 0)
11038 if (errno == ENOENT)
11039 error (_("'%s': No such file\n"), file_name);
11041 error (_("Could not locate '%s'. System error message: %s\n"),
11042 file_name, strerror (errno));
11046 if (! S_ISREG (statbuf.st_mode))
11048 error (_("'%s' is not an ordinary file\n"), file_name);
11052 file = fopen (file_name, "rb");
11055 error (_("Input file '%s' is not readable.\n"), file_name);
11059 if (fread (armag, SARMAG, 1, file) != 1)
11061 error (_("%s: Failed to read file's magic number\n"), file_name);
11066 if (memcmp (armag, ARMAG, SARMAG) == 0)
11067 ret = process_archive (file_name, file);
11070 if (do_archive_index)
11071 error (_("File %s is not an archive so its index cannot be displayed.\n"),
11075 archive_file_size = archive_file_offset = 0;
11076 ret = process_object (file_name, file);
11084 #ifdef SUPPORT_DISASSEMBLY
11085 /* Needed by the i386 disassembler. For extra credit, someone could
11086 fix this so that we insert symbolic addresses here, esp for GOT/PLT
11090 print_address (unsigned int addr, FILE *outfile)
11092 fprintf (outfile,"0x%8.8x", addr);
11095 /* Needed by the i386 disassembler. */
11097 db_task_printsym (unsigned int addr)
11099 print_address (addr, stderr);
11104 main (int argc, char **argv)
11108 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
11109 setlocale (LC_MESSAGES, "");
11111 #if defined (HAVE_SETLOCALE)
11112 setlocale (LC_CTYPE, "");
11114 bindtextdomain (PACKAGE, LOCALEDIR);
11115 textdomain (PACKAGE);
11117 expandargv (&argc, &argv);
11119 parse_args (argc, argv);
11121 if (num_dump_sects > 0)
11123 /* Make a copy of the dump_sects array. */
11124 cmdline_dump_sects = malloc (num_dump_sects * sizeof (* dump_sects));
11125 if (cmdline_dump_sects == NULL)
11126 error (_("Out of memory allocating dump request table.\n"));
11129 memcpy (cmdline_dump_sects, dump_sects,
11130 num_dump_sects * sizeof (* dump_sects));
11131 num_cmdline_dump_sects = num_dump_sects;
11135 if (optind < (argc - 1))
11139 while (optind < argc)
11140 err |= process_file (argv[optind++]);
11142 if (dump_sects != NULL)
11144 if (cmdline_dump_sects != NULL)
11145 free (cmdline_dump_sects);