1 /* readelf.c -- display contents of an ELF format file
2 Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
4 Free Software Foundation, Inc.
6 Originally developed by Eric Youngdale <eric@andante.jic.com>
7 Modifications by Nick Clifton <nickc@redhat.com>
9 This file is part of GNU Binutils.
11 This program is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 3 of the License, or
14 (at your option) any later version.
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
21 You should have received a copy of the GNU General Public License
22 along with this program; if not, write to the Free Software
23 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
26 /* The difference between readelf and objdump:
28 Both programs are capable of displaying the contents of ELF format files,
29 so why does the binutils project have two file dumpers ?
31 The reason is that objdump sees an ELF file through a BFD filter of the
32 world; if BFD has a bug where, say, it disagrees about a machine constant
33 in e_flags, then the odds are good that it will remain internally
34 consistent. The linker sees it the BFD way, objdump sees it the BFD way,
35 GAS sees it the BFD way. There was need for a tool to go find out what
36 the file actually says.
38 This is why the readelf program does not link against the BFD library - it
39 exists as an independent program to help verify the correct working of BFD.
41 There is also the case that readelf can provide more information about an
42 ELF file than is provided by objdump. In particular it can display DWARF
43 debugging information which (at the moment) objdump cannot. */
55 /* Define BFD64 here, even if our default architecture is 32 bit ELF
56 as this will allow us to read in and parse 64bit and 32bit ELF files.
57 Only do this if we believe that the compiler can support a 64 bit
58 data type. For now we only rely on GCC being able to do this. */
67 #include "elf/common.h"
68 #include "elf/external.h"
69 #include "elf/internal.h"
72 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
73 we can obtain the H8 reloc numbers. We need these for the
74 get_reloc_size() function. We include h8.h again after defining
75 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
80 /* Undo the effects of #including reloc-macros.h. */
82 #undef START_RELOC_NUMBERS
86 #undef END_RELOC_NUMBERS
87 #undef _RELOC_MACROS_H
89 /* The following headers use the elf/reloc-macros.h file to
90 automatically generate relocation recognition functions
91 such as elf_mips_reloc_type() */
93 #define RELOC_MACROS_GEN_FUNC
95 #include "elf/alpha.h"
100 #include "elf/cr16.h"
101 #include "elf/cris.h"
103 #include "elf/d10v.h"
104 #include "elf/d30v.h"
106 #include "elf/fr30.h"
109 #include "elf/hppa.h"
110 #include "elf/i386.h"
111 #include "elf/i370.h"
112 #include "elf/i860.h"
113 #include "elf/i960.h"
114 #include "elf/ia64.h"
115 #include "elf/ip2k.h"
116 #include "elf/lm32.h"
117 #include "elf/iq2000.h"
118 #include "elf/m32c.h"
119 #include "elf/m32r.h"
120 #include "elf/m68k.h"
121 #include "elf/m68hc11.h"
122 #include "elf/mcore.h"
124 #include "elf/microblaze.h"
125 #include "elf/mips.h"
126 #include "elf/mmix.h"
127 #include "elf/mn10200.h"
128 #include "elf/mn10300.h"
129 #include "elf/moxie.h"
131 #include "elf/msp430.h"
132 #include "elf/or32.h"
135 #include "elf/ppc64.h"
137 #include "elf/s390.h"
138 #include "elf/score.h"
140 #include "elf/sparc.h"
142 #include "elf/tic6x.h"
143 #include "elf/v850.h"
145 #include "elf/x86-64.h"
146 #include "elf/xc16x.h"
147 #include "elf/xstormy16.h"
148 #include "elf/xtensa.h"
151 #include "libiberty.h"
152 #include "safe-ctype.h"
153 #include "filenames.h"
155 char * program_name = "readelf";
156 static long archive_file_offset;
157 static unsigned long archive_file_size;
158 static unsigned long dynamic_addr;
159 static bfd_size_type dynamic_size;
160 static unsigned int dynamic_nent;
161 static char * dynamic_strings;
162 static unsigned long dynamic_strings_length;
163 static char * string_table;
164 static unsigned long string_table_length;
165 static unsigned long num_dynamic_syms;
166 static Elf_Internal_Sym * dynamic_symbols;
167 static Elf_Internal_Syminfo * dynamic_syminfo;
168 static unsigned long dynamic_syminfo_offset;
169 static unsigned int dynamic_syminfo_nent;
170 static char program_interpreter[PATH_MAX];
171 static bfd_vma dynamic_info[DT_ENCODING];
172 static bfd_vma dynamic_info_DT_GNU_HASH;
173 static bfd_vma version_info[16];
174 static Elf_Internal_Ehdr elf_header;
175 static Elf_Internal_Shdr * section_headers;
176 static Elf_Internal_Phdr * program_headers;
177 static Elf_Internal_Dyn * dynamic_section;
178 static Elf_Internal_Shdr * symtab_shndx_hdr;
179 static int show_name;
180 static int do_dynamic;
182 static int do_dyn_syms;
184 static int do_sections;
185 static int do_section_groups;
186 static int do_section_details;
187 static int do_segments;
188 static int do_unwind;
189 static int do_using_dynamic;
190 static int do_header;
192 static int do_version;
193 static int do_histogram;
194 static int do_debugging;
197 static int do_archive_index;
198 static int is_32bit_elf;
202 struct group_list * next;
203 unsigned int section_index;
208 struct group_list * root;
209 unsigned int group_index;
212 static size_t group_count;
213 static struct group * section_groups;
214 static struct group ** section_headers_groups;
217 /* Flag bits indicating particular types of dump. */
218 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
219 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
220 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
221 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
222 #define RELOC_DUMP (1 << 4) /* The -R command line switch. */
224 typedef unsigned char dump_type;
226 /* A linked list of the section names for which dumps were requested. */
227 struct dump_list_entry
231 struct dump_list_entry * next;
233 static struct dump_list_entry * dump_sects_byname;
235 /* A dynamic array of flags indicating for which sections a dump
236 has been requested via command line switches. */
237 static dump_type * cmdline_dump_sects = NULL;
238 static unsigned int num_cmdline_dump_sects = 0;
240 /* A dynamic array of flags indicating for which sections a dump of
241 some kind has been requested. It is reset on a per-object file
242 basis and then initialised from the cmdline_dump_sects array,
243 the results of interpreting the -w switch, and the
244 dump_sects_byname list. */
245 static dump_type * dump_sects = NULL;
246 static unsigned int num_dump_sects = 0;
249 /* How to print a vma value. */
250 typedef enum print_mode
264 #define SECTION_NAME(X) \
265 ((X) == NULL ? _("<none>") \
266 : string_table == NULL ? _("<no-name>") \
267 : ((X)->sh_name >= string_table_length ? _("<corrupt>") \
268 : string_table + (X)->sh_name))
270 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
272 #define GET_ELF_SYMBOLS(file, section) \
273 (is_32bit_elf ? get_32bit_elf_symbols (file, section) \
274 : get_64bit_elf_symbols (file, section))
276 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
277 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
278 already been called and verified that the string exists. */
279 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
281 #define REMOVE_ARCH_BITS(ADDR) do { \
282 if (elf_header.e_machine == EM_ARM) \
287 get_data (void * var, FILE * file, long offset, size_t size, size_t nmemb,
292 if (size == 0 || nmemb == 0)
295 if (fseek (file, archive_file_offset + offset, SEEK_SET))
297 error (_("Unable to seek to 0x%lx for %s\n"),
298 (unsigned long) archive_file_offset + offset, reason);
305 /* Check for overflow. */
306 if (nmemb < (~(size_t) 0 - 1) / size)
307 /* + 1 so that we can '\0' terminate invalid string table sections. */
308 mvar = malloc (size * nmemb + 1);
312 error (_("Out of memory allocating 0x%lx bytes for %s\n"),
313 (unsigned long)(size * nmemb), reason);
317 ((char *) mvar)[size * nmemb] = '\0';
320 if (fread (mvar, size, nmemb, file) != nmemb)
322 error (_("Unable to read in 0x%lx bytes of %s\n"),
323 (unsigned long)(size * nmemb), reason);
332 /* Print a VMA value. */
335 print_vma (bfd_vma vma, print_mode mode)
348 return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
355 return printf ("%5" BFD_VMA_FMT "d", vma);
363 return nc + printf ("%" BFD_VMA_FMT "x", vma);
366 return printf ("%" BFD_VMA_FMT "d", vma);
369 return printf ("%" BFD_VMA_FMT "u", vma);
374 /* Display a symbol on stdout. Handles the display of non-printing characters.
376 If DO_WIDE is not true then format the symbol to be at most WIDTH characters,
377 truncating as necessary. If WIDTH is negative then format the string to be
378 exactly - WIDTH characters, truncating or padding as necessary.
380 Returns the number of emitted characters. */
383 print_symbol (int width, const char *symbol)
386 bfd_boolean extra_padding = FALSE;
387 unsigned int num_printed = 0;
391 /* Set the width to a very large value. This simplifies the
397 /* Keep the width positive. This also helps. */
399 extra_padding = TRUE;
408 /* Look for non-printing symbols inside the symbol's name.
409 This test is triggered in particular by the names generated
410 by the assembler for local labels. */
421 printf ("%.*s", len, symbol);
427 if (*c == 0 || width == 0)
430 /* Now display the non-printing character, if
431 there is room left in which to dipslay it. */
432 if ((unsigned char) *c < 32)
437 printf ("^%c", *c + 0x40);
447 printf ("<0x%.2x>", (unsigned char) *c);
456 if (extra_padding && width > 0)
458 /* Fill in the remaining spaces. */
459 printf ("%-*s", width, " ");
466 /* Return a pointer to section NAME, or NULL if no such section exists. */
468 static Elf_Internal_Shdr *
469 find_section (const char * name)
473 for (i = 0; i < elf_header.e_shnum; i++)
474 if (streq (SECTION_NAME (section_headers + i), name))
475 return section_headers + i;
480 /* Return a pointer to a section containing ADDR, or NULL if no such
483 static Elf_Internal_Shdr *
484 find_section_by_address (bfd_vma addr)
488 for (i = 0; i < elf_header.e_shnum; i++)
490 Elf_Internal_Shdr *sec = section_headers + i;
491 if (addr >= sec->sh_addr && addr < sec->sh_addr + sec->sh_size)
498 /* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
502 read_uleb128 (unsigned char *data, unsigned int *length_return)
504 return read_leb128 (data, length_return, 0);
507 /* Return true if the current file is for IA-64 machine and OpenVMS ABI.
508 This OS has so many departures from the ELF standard that we test it at
514 return elf_header.e_machine == EM_IA_64
515 && elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS;
518 /* Guess the relocation size commonly used by the specific machines. */
521 guess_is_rela (unsigned int e_machine)
525 /* Targets that use REL relocations. */
541 /* Targets that use RELA relocations. */
545 case EM_ALTERA_NIOS2:
565 case EM_LATTICEMICO32:
573 case EM_CYGNUS_MN10200:
575 case EM_CYGNUS_MN10300:
601 case EM_MICROBLAZE_OLD:
622 warn (_("Don't know about relocations on this machine architecture\n"));
628 slurp_rela_relocs (FILE * file,
629 unsigned long rel_offset,
630 unsigned long rel_size,
631 Elf_Internal_Rela ** relasp,
632 unsigned long * nrelasp)
634 Elf_Internal_Rela * relas;
635 unsigned long nrelas;
640 Elf32_External_Rela * erelas;
642 erelas = (Elf32_External_Rela *) get_data (NULL, file, rel_offset, 1,
643 rel_size, _("relocs"));
647 nrelas = rel_size / sizeof (Elf32_External_Rela);
649 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
650 sizeof (Elf_Internal_Rela));
655 error (_("out of memory parsing relocs\n"));
659 for (i = 0; i < nrelas; i++)
661 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
662 relas[i].r_info = BYTE_GET (erelas[i].r_info);
663 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
670 Elf64_External_Rela * erelas;
672 erelas = (Elf64_External_Rela *) get_data (NULL, file, rel_offset, 1,
673 rel_size, _("relocs"));
677 nrelas = rel_size / sizeof (Elf64_External_Rela);
679 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
680 sizeof (Elf_Internal_Rela));
685 error (_("out of memory parsing relocs\n"));
689 for (i = 0; i < nrelas; i++)
691 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
692 relas[i].r_info = BYTE_GET (erelas[i].r_info);
693 relas[i].r_addend = BYTE_GET_SIGNED (erelas[i].r_addend);
695 /* The #ifdef BFD64 below is to prevent a compile time
696 warning. We know that if we do not have a 64 bit data
697 type that we will never execute this code anyway. */
699 if (elf_header.e_machine == EM_MIPS
700 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
702 /* In little-endian objects, r_info isn't really a
703 64-bit little-endian value: it has a 32-bit
704 little-endian symbol index followed by four
705 individual byte fields. Reorder INFO
707 bfd_vma inf = relas[i].r_info;
708 inf = (((inf & 0xffffffff) << 32)
709 | ((inf >> 56) & 0xff)
710 | ((inf >> 40) & 0xff00)
711 | ((inf >> 24) & 0xff0000)
712 | ((inf >> 8) & 0xff000000));
713 relas[i].r_info = inf;
726 slurp_rel_relocs (FILE * file,
727 unsigned long rel_offset,
728 unsigned long rel_size,
729 Elf_Internal_Rela ** relsp,
730 unsigned long * nrelsp)
732 Elf_Internal_Rela * rels;
738 Elf32_External_Rel * erels;
740 erels = (Elf32_External_Rel *) get_data (NULL, file, rel_offset, 1,
741 rel_size, _("relocs"));
745 nrels = rel_size / sizeof (Elf32_External_Rel);
747 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
752 error (_("out of memory parsing relocs\n"));
756 for (i = 0; i < nrels; i++)
758 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
759 rels[i].r_info = BYTE_GET (erels[i].r_info);
760 rels[i].r_addend = 0;
767 Elf64_External_Rel * erels;
769 erels = (Elf64_External_Rel *) get_data (NULL, file, rel_offset, 1,
770 rel_size, _("relocs"));
774 nrels = rel_size / sizeof (Elf64_External_Rel);
776 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
781 error (_("out of memory parsing relocs\n"));
785 for (i = 0; i < nrels; i++)
787 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
788 rels[i].r_info = BYTE_GET (erels[i].r_info);
789 rels[i].r_addend = 0;
791 /* The #ifdef BFD64 below is to prevent a compile time
792 warning. We know that if we do not have a 64 bit data
793 type that we will never execute this code anyway. */
795 if (elf_header.e_machine == EM_MIPS
796 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
798 /* In little-endian objects, r_info isn't really a
799 64-bit little-endian value: it has a 32-bit
800 little-endian symbol index followed by four
801 individual byte fields. Reorder INFO
803 bfd_vma inf = rels[i].r_info;
804 inf = (((inf & 0xffffffff) << 32)
805 | ((inf >> 56) & 0xff)
806 | ((inf >> 40) & 0xff00)
807 | ((inf >> 24) & 0xff0000)
808 | ((inf >> 8) & 0xff000000));
809 rels[i].r_info = inf;
821 /* Returns the reloc type extracted from the reloc info field. */
824 get_reloc_type (bfd_vma reloc_info)
827 return ELF32_R_TYPE (reloc_info);
829 switch (elf_header.e_machine)
832 /* Note: We assume that reloc_info has already been adjusted for us. */
833 return ELF64_MIPS_R_TYPE (reloc_info);
836 return ELF64_R_TYPE_ID (reloc_info);
839 return ELF64_R_TYPE (reloc_info);
843 /* Return the symbol index extracted from the reloc info field. */
846 get_reloc_symindex (bfd_vma reloc_info)
848 return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
851 /* Display the contents of the relocation data found at the specified
855 dump_relocations (FILE * file,
856 unsigned long rel_offset,
857 unsigned long rel_size,
858 Elf_Internal_Sym * symtab,
861 unsigned long strtablen,
865 Elf_Internal_Rela * rels;
867 if (is_rela == UNKNOWN)
868 is_rela = guess_is_rela (elf_header.e_machine);
872 if (!slurp_rela_relocs (file, rel_offset, rel_size, &rels, &rel_size))
877 if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
886 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
888 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
893 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
895 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
903 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
905 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
910 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
912 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
916 for (i = 0; i < rel_size; i++)
921 bfd_vma symtab_index;
924 offset = rels[i].r_offset;
925 inf = rels[i].r_info;
927 type = get_reloc_type (inf);
928 symtab_index = get_reloc_symindex (inf);
932 printf ("%8.8lx %8.8lx ",
933 (unsigned long) offset & 0xffffffff,
934 (unsigned long) inf & 0xffffffff);
938 #if BFD_HOST_64BIT_LONG
940 ? "%16.16lx %16.16lx "
941 : "%12.12lx %12.12lx ",
943 #elif BFD_HOST_64BIT_LONG_LONG
946 ? "%16.16llx %16.16llx "
947 : "%12.12llx %12.12llx ",
951 ? "%16.16I64x %16.16I64x "
952 : "%12.12I64x %12.12I64x ",
957 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
958 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
959 _bfd_int64_high (offset),
960 _bfd_int64_low (offset),
961 _bfd_int64_high (inf),
962 _bfd_int64_low (inf));
966 switch (elf_header.e_machine)
974 rtype = elf_m32r_reloc_type (type);
979 rtype = elf_i386_reloc_type (type);
984 rtype = elf_m68hc11_reloc_type (type);
988 rtype = elf_m68k_reloc_type (type);
992 rtype = elf_i960_reloc_type (type);
997 rtype = elf_avr_reloc_type (type);
1000 case EM_OLD_SPARCV9:
1001 case EM_SPARC32PLUS:
1004 rtype = elf_sparc_reloc_type (type);
1008 rtype = elf_spu_reloc_type (type);
1012 case EM_CYGNUS_V850:
1013 rtype = v850_reloc_type (type);
1017 case EM_CYGNUS_D10V:
1018 rtype = elf_d10v_reloc_type (type);
1022 case EM_CYGNUS_D30V:
1023 rtype = elf_d30v_reloc_type (type);
1027 rtype = elf_dlx_reloc_type (type);
1031 rtype = elf_sh_reloc_type (type);
1035 case EM_CYGNUS_MN10300:
1036 rtype = elf_mn10300_reloc_type (type);
1040 case EM_CYGNUS_MN10200:
1041 rtype = elf_mn10200_reloc_type (type);
1045 case EM_CYGNUS_FR30:
1046 rtype = elf_fr30_reloc_type (type);
1050 rtype = elf_frv_reloc_type (type);
1054 rtype = elf_mcore_reloc_type (type);
1058 rtype = elf_mmix_reloc_type (type);
1062 rtype = elf_moxie_reloc_type (type);
1067 rtype = elf_msp430_reloc_type (type);
1071 rtype = elf_ppc_reloc_type (type);
1075 rtype = elf_ppc64_reloc_type (type);
1079 case EM_MIPS_RS3_LE:
1080 rtype = elf_mips_reloc_type (type);
1084 rtype = elf_alpha_reloc_type (type);
1088 rtype = elf_arm_reloc_type (type);
1092 rtype = elf_arc_reloc_type (type);
1096 rtype = elf_hppa_reloc_type (type);
1102 rtype = elf_h8_reloc_type (type);
1107 rtype = elf_or32_reloc_type (type);
1112 rtype = elf_pj_reloc_type (type);
1115 rtype = elf_ia64_reloc_type (type);
1119 rtype = elf_cris_reloc_type (type);
1123 rtype = elf_i860_reloc_type (type);
1128 rtype = elf_x86_64_reloc_type (type);
1132 rtype = i370_reloc_type (type);
1137 rtype = elf_s390_reloc_type (type);
1141 rtype = elf_score_reloc_type (type);
1145 rtype = elf_xstormy16_reloc_type (type);
1149 rtype = elf_crx_reloc_type (type);
1153 rtype = elf_vax_reloc_type (type);
1158 rtype = elf_ip2k_reloc_type (type);
1162 rtype = elf_iq2000_reloc_type (type);
1167 rtype = elf_xtensa_reloc_type (type);
1170 case EM_LATTICEMICO32:
1171 rtype = elf_lm32_reloc_type (type);
1176 rtype = elf_m32c_reloc_type (type);
1180 rtype = elf_mt_reloc_type (type);
1184 rtype = elf_bfin_reloc_type (type);
1188 rtype = elf_mep_reloc_type (type);
1193 rtype = elf_cr16_reloc_type (type);
1197 case EM_MICROBLAZE_OLD:
1198 rtype = elf_microblaze_reloc_type (type);
1202 rtype = elf_rx_reloc_type (type);
1207 rtype = elf_xc16x_reloc_type (type);
1211 rtype = elf_tic6x_reloc_type (type);
1216 printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
1218 printf (do_wide ? "%-22.22s" : "%-17.17s", rtype);
1220 if (elf_header.e_machine == EM_ALPHA
1222 && streq (rtype, "R_ALPHA_LITUSE")
1225 switch (rels[i].r_addend)
1227 case LITUSE_ALPHA_ADDR: rtype = "ADDR"; break;
1228 case LITUSE_ALPHA_BASE: rtype = "BASE"; break;
1229 case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1230 case LITUSE_ALPHA_JSR: rtype = "JSR"; break;
1231 case LITUSE_ALPHA_TLSGD: rtype = "TLSGD"; break;
1232 case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1233 case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1234 default: rtype = NULL;
1237 printf (" (%s)", rtype);
1241 printf (_("<unknown addend: %lx>"),
1242 (unsigned long) rels[i].r_addend);
1245 else if (symtab_index)
1247 if (symtab == NULL || symtab_index >= nsyms)
1248 printf (_(" bad symbol index: %08lx"), (unsigned long) symtab_index);
1251 Elf_Internal_Sym * psym;
1253 psym = symtab + symtab_index;
1257 if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1261 unsigned int width = is_32bit_elf ? 8 : 14;
1263 /* Relocations against GNU_IFUNC symbols do not use the value
1264 of the symbol as the address to relocate against. Instead
1265 they invoke the function named by the symbol and use its
1266 result as the address for relocation.
1268 To indicate this to the user, do not display the value of
1269 the symbol in the "Symbols's Value" field. Instead show
1270 its name followed by () as a hint that the symbol is
1274 || psym->st_name == 0
1275 || psym->st_name >= strtablen)
1278 name = strtab + psym->st_name;
1280 len = print_symbol (width, name);
1281 printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1285 print_vma (psym->st_value, LONG_HEX);
1287 printf (is_32bit_elf ? " " : " ");
1290 if (psym->st_name == 0)
1292 const char * sec_name = "<null>";
1295 if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1297 if (psym->st_shndx < elf_header.e_shnum)
1299 = SECTION_NAME (section_headers + psym->st_shndx);
1300 else if (psym->st_shndx == SHN_ABS)
1302 else if (psym->st_shndx == SHN_COMMON)
1303 sec_name = "COMMON";
1304 else if (elf_header.e_machine == EM_MIPS
1305 && psym->st_shndx == SHN_MIPS_SCOMMON)
1306 sec_name = "SCOMMON";
1307 else if (elf_header.e_machine == EM_MIPS
1308 && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1309 sec_name = "SUNDEF";
1310 else if ((elf_header.e_machine == EM_X86_64
1311 || elf_header.e_machine == EM_L1OM)
1312 && psym->st_shndx == SHN_X86_64_LCOMMON)
1313 sec_name = "LARGE_COMMON";
1314 else if (elf_header.e_machine == EM_IA_64
1315 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1316 && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1317 sec_name = "ANSI_COM";
1318 else if (is_ia64_vms ()
1319 && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1320 sec_name = "VMS_SYMVEC";
1323 sprintf (name_buf, "<section 0x%x>",
1324 (unsigned int) psym->st_shndx);
1325 sec_name = name_buf;
1328 print_symbol (22, sec_name);
1330 else if (strtab == NULL)
1331 printf (_("<string table index: %3ld>"), psym->st_name);
1332 else if (psym->st_name >= strtablen)
1333 printf (_("<corrupt string table index: %3ld>"), psym->st_name);
1335 print_symbol (22, strtab + psym->st_name);
1339 bfd_signed_vma off = rels[i].r_addend;
1342 printf (" - %" BFD_VMA_FMT "x", - off);
1344 printf (" + %" BFD_VMA_FMT "x", off);
1350 printf ("%*c", is_32bit_elf ?
1351 (do_wide ? 34 : 28) : (do_wide ? 26 : 20), ' ');
1352 print_vma (rels[i].r_addend, LONG_HEX);
1355 if (elf_header.e_machine == EM_SPARCV9
1357 && streq (rtype, "R_SPARC_OLO10"))
1358 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
1363 if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
1365 bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1366 bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
1367 const char * rtype2 = elf_mips_reloc_type (type2);
1368 const char * rtype3 = elf_mips_reloc_type (type3);
1370 printf (" Type2: ");
1373 printf (_("unrecognized: %-7lx"),
1374 (unsigned long) type2 & 0xffffffff);
1376 printf ("%-17.17s", rtype2);
1378 printf ("\n Type3: ");
1381 printf (_("unrecognized: %-7lx"),
1382 (unsigned long) type3 & 0xffffffff);
1384 printf ("%-17.17s", rtype3);
1395 get_mips_dynamic_type (unsigned long type)
1399 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1400 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1401 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1402 case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1403 case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1404 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1405 case DT_MIPS_MSYM: return "MIPS_MSYM";
1406 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1407 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1408 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1409 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1410 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1411 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1412 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1413 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1414 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1415 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1416 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1417 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1418 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1419 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1420 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1421 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1422 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1423 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1424 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1425 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1426 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1427 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1428 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1429 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1430 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1431 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1432 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1433 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1434 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1435 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1436 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1437 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1438 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1439 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1440 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1441 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
1442 case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1443 case DT_MIPS_RWPLT: return "MIPS_RWPLT";
1450 get_sparc64_dynamic_type (unsigned long type)
1454 case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1461 get_ppc_dynamic_type (unsigned long type)
1465 case DT_PPC_GOT: return "PPC_GOT";
1466 case DT_PPC_TLSOPT: return "PPC_TLSOPT";
1473 get_ppc64_dynamic_type (unsigned long type)
1477 case DT_PPC64_GLINK: return "PPC64_GLINK";
1478 case DT_PPC64_OPD: return "PPC64_OPD";
1479 case DT_PPC64_OPDSZ: return "PPC64_OPDSZ";
1480 case DT_PPC64_TLSOPT: return "PPC64_TLSOPT";
1487 get_parisc_dynamic_type (unsigned long type)
1491 case DT_HP_LOAD_MAP: return "HP_LOAD_MAP";
1492 case DT_HP_DLD_FLAGS: return "HP_DLD_FLAGS";
1493 case DT_HP_DLD_HOOK: return "HP_DLD_HOOK";
1494 case DT_HP_UX10_INIT: return "HP_UX10_INIT";
1495 case DT_HP_UX10_INITSZ: return "HP_UX10_INITSZ";
1496 case DT_HP_PREINIT: return "HP_PREINIT";
1497 case DT_HP_PREINITSZ: return "HP_PREINITSZ";
1498 case DT_HP_NEEDED: return "HP_NEEDED";
1499 case DT_HP_TIME_STAMP: return "HP_TIME_STAMP";
1500 case DT_HP_CHECKSUM: return "HP_CHECKSUM";
1501 case DT_HP_GST_SIZE: return "HP_GST_SIZE";
1502 case DT_HP_GST_VERSION: return "HP_GST_VERSION";
1503 case DT_HP_GST_HASHVAL: return "HP_GST_HASHVAL";
1504 case DT_HP_EPLTREL: return "HP_GST_EPLTREL";
1505 case DT_HP_EPLTRELSZ: return "HP_GST_EPLTRELSZ";
1506 case DT_HP_FILTERED: return "HP_FILTERED";
1507 case DT_HP_FILTER_TLS: return "HP_FILTER_TLS";
1508 case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1509 case DT_HP_LAZYLOAD: return "HP_LAZYLOAD";
1510 case DT_HP_BIND_NOW_COUNT: return "HP_BIND_NOW_COUNT";
1511 case DT_PLT: return "PLT";
1512 case DT_PLT_SIZE: return "PLT_SIZE";
1513 case DT_DLT: return "DLT";
1514 case DT_DLT_SIZE: return "DLT_SIZE";
1521 get_ia64_dynamic_type (unsigned long type)
1525 case DT_IA_64_PLT_RESERVE: return "IA_64_PLT_RESERVE";
1526 case DT_IA_64_VMS_SUBTYPE: return "VMS_SUBTYPE";
1527 case DT_IA_64_VMS_IMGIOCNT: return "VMS_IMGIOCNT";
1528 case DT_IA_64_VMS_LNKFLAGS: return "VMS_LNKFLAGS";
1529 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1530 case DT_IA_64_VMS_IDENT: return "VMS_IDENT";
1531 case DT_IA_64_VMS_NEEDED_IDENT: return "VMS_NEEDED_IDENT";
1532 case DT_IA_64_VMS_IMG_RELA_CNT: return "VMS_IMG_RELA_CNT";
1533 case DT_IA_64_VMS_SEG_RELA_CNT: return "VMS_SEG_RELA_CNT";
1534 case DT_IA_64_VMS_FIXUP_RELA_CNT: return "VMS_FIXUP_RELA_CNT";
1535 case DT_IA_64_VMS_FIXUP_NEEDED: return "VMS_FIXUP_NEEDED";
1536 case DT_IA_64_VMS_SYMVEC_CNT: return "VMS_SYMVEC_CNT";
1537 case DT_IA_64_VMS_XLATED: return "VMS_XLATED";
1538 case DT_IA_64_VMS_STACKSIZE: return "VMS_STACKSIZE";
1539 case DT_IA_64_VMS_UNWINDSZ: return "VMS_UNWINDSZ";
1540 case DT_IA_64_VMS_UNWIND_CODSEG: return "VMS_UNWIND_CODSEG";
1541 case DT_IA_64_VMS_UNWIND_INFOSEG: return "VMS_UNWIND_INFOSEG";
1542 case DT_IA_64_VMS_LINKTIME: return "VMS_LINKTIME";
1543 case DT_IA_64_VMS_SEG_NO: return "VMS_SEG_NO";
1544 case DT_IA_64_VMS_SYMVEC_OFFSET: return "VMS_SYMVEC_OFFSET";
1545 case DT_IA_64_VMS_SYMVEC_SEG: return "VMS_SYMVEC_SEG";
1546 case DT_IA_64_VMS_UNWIND_OFFSET: return "VMS_UNWIND_OFFSET";
1547 case DT_IA_64_VMS_UNWIND_SEG: return "VMS_UNWIND_SEG";
1548 case DT_IA_64_VMS_STRTAB_OFFSET: return "VMS_STRTAB_OFFSET";
1549 case DT_IA_64_VMS_SYSVER_OFFSET: return "VMS_SYSVER_OFFSET";
1550 case DT_IA_64_VMS_IMG_RELA_OFF: return "VMS_IMG_RELA_OFF";
1551 case DT_IA_64_VMS_SEG_RELA_OFF: return "VMS_SEG_RELA_OFF";
1552 case DT_IA_64_VMS_FIXUP_RELA_OFF: return "VMS_FIXUP_RELA_OFF";
1553 case DT_IA_64_VMS_PLTGOT_OFFSET: return "VMS_PLTGOT_OFFSET";
1554 case DT_IA_64_VMS_PLTGOT_SEG: return "VMS_PLTGOT_SEG";
1555 case DT_IA_64_VMS_FPMODE: return "VMS_FPMODE";
1562 get_alpha_dynamic_type (unsigned long type)
1566 case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
1573 get_score_dynamic_type (unsigned long type)
1577 case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
1578 case DT_SCORE_LOCAL_GOTNO: return "SCORE_LOCAL_GOTNO";
1579 case DT_SCORE_SYMTABNO: return "SCORE_SYMTABNO";
1580 case DT_SCORE_GOTSYM: return "SCORE_GOTSYM";
1581 case DT_SCORE_UNREFEXTNO: return "SCORE_UNREFEXTNO";
1582 case DT_SCORE_HIPAGENO: return "SCORE_HIPAGENO";
1589 get_tic6x_dynamic_type (unsigned long type)
1593 case DT_C6000_GSYM_OFFSET: return "C6000_GSYM_OFFSET";
1594 case DT_C6000_GSTR_OFFSET: return "C6000_GSTR_OFFSET";
1595 case DT_C6000_DSBT_BASE: return "C6000_DSBT_BASE";
1596 case DT_C6000_DSBT_SIZE: return "C6000_DSBT_SIZE";
1597 case DT_C6000_PREEMPTMAP: return "C6000_PREEMPTMAP";
1598 case DT_C6000_DSBT_INDEX: return "C6000_DSBT_INDEX";
1605 get_dynamic_type (unsigned long type)
1607 static char buff[64];
1611 case DT_NULL: return "NULL";
1612 case DT_NEEDED: return "NEEDED";
1613 case DT_PLTRELSZ: return "PLTRELSZ";
1614 case DT_PLTGOT: return "PLTGOT";
1615 case DT_HASH: return "HASH";
1616 case DT_STRTAB: return "STRTAB";
1617 case DT_SYMTAB: return "SYMTAB";
1618 case DT_RELA: return "RELA";
1619 case DT_RELASZ: return "RELASZ";
1620 case DT_RELAENT: return "RELAENT";
1621 case DT_STRSZ: return "STRSZ";
1622 case DT_SYMENT: return "SYMENT";
1623 case DT_INIT: return "INIT";
1624 case DT_FINI: return "FINI";
1625 case DT_SONAME: return "SONAME";
1626 case DT_RPATH: return "RPATH";
1627 case DT_SYMBOLIC: return "SYMBOLIC";
1628 case DT_REL: return "REL";
1629 case DT_RELSZ: return "RELSZ";
1630 case DT_RELENT: return "RELENT";
1631 case DT_PLTREL: return "PLTREL";
1632 case DT_DEBUG: return "DEBUG";
1633 case DT_TEXTREL: return "TEXTREL";
1634 case DT_JMPREL: return "JMPREL";
1635 case DT_BIND_NOW: return "BIND_NOW";
1636 case DT_INIT_ARRAY: return "INIT_ARRAY";
1637 case DT_FINI_ARRAY: return "FINI_ARRAY";
1638 case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
1639 case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
1640 case DT_RUNPATH: return "RUNPATH";
1641 case DT_FLAGS: return "FLAGS";
1643 case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1644 case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
1646 case DT_CHECKSUM: return "CHECKSUM";
1647 case DT_PLTPADSZ: return "PLTPADSZ";
1648 case DT_MOVEENT: return "MOVEENT";
1649 case DT_MOVESZ: return "MOVESZ";
1650 case DT_FEATURE: return "FEATURE";
1651 case DT_POSFLAG_1: return "POSFLAG_1";
1652 case DT_SYMINSZ: return "SYMINSZ";
1653 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
1655 case DT_ADDRRNGLO: return "ADDRRNGLO";
1656 case DT_CONFIG: return "CONFIG";
1657 case DT_DEPAUDIT: return "DEPAUDIT";
1658 case DT_AUDIT: return "AUDIT";
1659 case DT_PLTPAD: return "PLTPAD";
1660 case DT_MOVETAB: return "MOVETAB";
1661 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
1663 case DT_VERSYM: return "VERSYM";
1665 case DT_TLSDESC_GOT: return "TLSDESC_GOT";
1666 case DT_TLSDESC_PLT: return "TLSDESC_PLT";
1667 case DT_RELACOUNT: return "RELACOUNT";
1668 case DT_RELCOUNT: return "RELCOUNT";
1669 case DT_FLAGS_1: return "FLAGS_1";
1670 case DT_VERDEF: return "VERDEF";
1671 case DT_VERDEFNUM: return "VERDEFNUM";
1672 case DT_VERNEED: return "VERNEED";
1673 case DT_VERNEEDNUM: return "VERNEEDNUM";
1675 case DT_AUXILIARY: return "AUXILIARY";
1676 case DT_USED: return "USED";
1677 case DT_FILTER: return "FILTER";
1679 case DT_GNU_PRELINKED: return "GNU_PRELINKED";
1680 case DT_GNU_CONFLICT: return "GNU_CONFLICT";
1681 case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
1682 case DT_GNU_LIBLIST: return "GNU_LIBLIST";
1683 case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
1684 case DT_GNU_HASH: return "GNU_HASH";
1687 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1689 const char * result;
1691 switch (elf_header.e_machine)
1694 case EM_MIPS_RS3_LE:
1695 result = get_mips_dynamic_type (type);
1698 result = get_sparc64_dynamic_type (type);
1701 result = get_ppc_dynamic_type (type);
1704 result = get_ppc64_dynamic_type (type);
1707 result = get_ia64_dynamic_type (type);
1710 result = get_alpha_dynamic_type (type);
1713 result = get_score_dynamic_type (type);
1716 result = get_tic6x_dynamic_type (type);
1726 snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
1728 else if (((type >= DT_LOOS) && (type <= DT_HIOS))
1729 || (elf_header.e_machine == EM_PARISC
1730 && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
1732 const char * result;
1734 switch (elf_header.e_machine)
1737 result = get_parisc_dynamic_type (type);
1740 result = get_ia64_dynamic_type (type);
1750 snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
1754 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
1761 get_file_type (unsigned e_type)
1763 static char buff[32];
1767 case ET_NONE: return _("NONE (None)");
1768 case ET_REL: return _("REL (Relocatable file)");
1769 case ET_EXEC: return _("EXEC (Executable file)");
1770 case ET_DYN: return _("DYN (Shared object file)");
1771 case ET_CORE: return _("CORE (Core file)");
1774 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
1775 snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
1776 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
1777 snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
1779 snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
1785 get_machine_name (unsigned e_machine)
1787 static char buff[64]; /* XXX */
1791 case EM_NONE: return _("None");
1792 case EM_M32: return "WE32100";
1793 case EM_SPARC: return "Sparc";
1794 case EM_SPU: return "SPU";
1795 case EM_386: return "Intel 80386";
1796 case EM_68K: return "MC68000";
1797 case EM_88K: return "MC88000";
1798 case EM_486: return "Intel 80486";
1799 case EM_860: return "Intel 80860";
1800 case EM_MIPS: return "MIPS R3000";
1801 case EM_S370: return "IBM System/370";
1802 case EM_MIPS_RS3_LE: return "MIPS R4000 big-endian";
1803 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
1804 case EM_PARISC: return "HPPA";
1805 case EM_PPC_OLD: return "Power PC (old)";
1806 case EM_SPARC32PLUS: return "Sparc v8+" ;
1807 case EM_960: return "Intel 90860";
1808 case EM_PPC: return "PowerPC";
1809 case EM_PPC64: return "PowerPC64";
1810 case EM_V800: return "NEC V800";
1811 case EM_FR20: return "Fujitsu FR20";
1812 case EM_RH32: return "TRW RH32";
1813 case EM_MCORE: return "MCORE";
1814 case EM_ARM: return "ARM";
1815 case EM_OLD_ALPHA: return "Digital Alpha (old)";
1816 case EM_SH: return "Renesas / SuperH SH";
1817 case EM_SPARCV9: return "Sparc v9";
1818 case EM_TRICORE: return "Siemens Tricore";
1819 case EM_ARC: return "ARC";
1820 case EM_H8_300: return "Renesas H8/300";
1821 case EM_H8_300H: return "Renesas H8/300H";
1822 case EM_H8S: return "Renesas H8S";
1823 case EM_H8_500: return "Renesas H8/500";
1824 case EM_IA_64: return "Intel IA-64";
1825 case EM_MIPS_X: return "Stanford MIPS-X";
1826 case EM_COLDFIRE: return "Motorola Coldfire";
1827 case EM_68HC12: return "Motorola M68HC12";
1828 case EM_ALPHA: return "Alpha";
1829 case EM_CYGNUS_D10V:
1830 case EM_D10V: return "d10v";
1831 case EM_CYGNUS_D30V:
1832 case EM_D30V: return "d30v";
1833 case EM_CYGNUS_M32R:
1834 case EM_M32R: return "Renesas M32R (formerly Mitsubishi M32r)";
1835 case EM_CYGNUS_V850:
1836 case EM_V850: return "NEC v850";
1837 case EM_CYGNUS_MN10300:
1838 case EM_MN10300: return "mn10300";
1839 case EM_CYGNUS_MN10200:
1840 case EM_MN10200: return "mn10200";
1841 case EM_MOXIE: return "Moxie";
1842 case EM_CYGNUS_FR30:
1843 case EM_FR30: return "Fujitsu FR30";
1844 case EM_CYGNUS_FRV: return "Fujitsu FR-V";
1846 case EM_PJ: return "picoJava";
1847 case EM_MMA: return "Fujitsu Multimedia Accelerator";
1848 case EM_PCP: return "Siemens PCP";
1849 case EM_NCPU: return "Sony nCPU embedded RISC processor";
1850 case EM_NDR1: return "Denso NDR1 microprocesspr";
1851 case EM_STARCORE: return "Motorola Star*Core processor";
1852 case EM_ME16: return "Toyota ME16 processor";
1853 case EM_ST100: return "STMicroelectronics ST100 processor";
1854 case EM_TINYJ: return "Advanced Logic Corp. TinyJ embedded processor";
1855 case EM_PDSP: return "Sony DSP processor";
1856 case EM_PDP10: return "Digital Equipment Corp. PDP-10";
1857 case EM_PDP11: return "Digital Equipment Corp. PDP-11";
1858 case EM_FX66: return "Siemens FX66 microcontroller";
1859 case EM_ST9PLUS: return "STMicroelectronics ST9+ 8/16 bit microcontroller";
1860 case EM_ST7: return "STMicroelectronics ST7 8-bit microcontroller";
1861 case EM_68HC16: return "Motorola MC68HC16 Microcontroller";
1862 case EM_68HC11: return "Motorola MC68HC11 Microcontroller";
1863 case EM_68HC08: return "Motorola MC68HC08 Microcontroller";
1864 case EM_68HC05: return "Motorola MC68HC05 Microcontroller";
1865 case EM_SVX: return "Silicon Graphics SVx";
1866 case EM_ST19: return "STMicroelectronics ST19 8-bit microcontroller";
1867 case EM_VAX: return "Digital VAX";
1869 case EM_AVR: return "Atmel AVR 8-bit microcontroller";
1870 case EM_CRIS: return "Axis Communications 32-bit embedded processor";
1871 case EM_JAVELIN: return "Infineon Technologies 32-bit embedded cpu";
1872 case EM_FIREPATH: return "Element 14 64-bit DSP processor";
1873 case EM_ZSP: return "LSI Logic's 16-bit DSP processor";
1874 case EM_MMIX: return "Donald Knuth's educational 64-bit processor";
1875 case EM_HUANY: return "Harvard Universitys's machine-independent object format";
1876 case EM_PRISM: return "Vitesse Prism";
1877 case EM_X86_64: return "Advanced Micro Devices X86-64";
1878 case EM_L1OM: return "Intel L1OM";
1880 case EM_S390: return "IBM S/390";
1881 case EM_SCORE: return "SUNPLUS S+Core";
1882 case EM_XSTORMY16: return "Sanyo Xstormy16 CPU core";
1884 case EM_OR32: return "OpenRISC";
1885 case EM_ARC_A5: return "ARC International ARCompact processor";
1886 case EM_CRX: return "National Semiconductor CRX microprocessor";
1887 case EM_DLX: return "OpenDLX";
1889 case EM_IP2K: return "Ubicom IP2xxx 8-bit microcontrollers";
1890 case EM_IQ2000: return "Vitesse IQ2000";
1892 case EM_XTENSA: return "Tensilica Xtensa Processor";
1893 case EM_VIDEOCORE: return "Alphamosaic VideoCore processor";
1894 case EM_TMM_GPP: return "Thompson Multimedia General Purpose Processor";
1895 case EM_NS32K: return "National Semiconductor 32000 series";
1896 case EM_TPC: return "Tenor Network TPC processor";
1897 case EM_ST200: return "STMicroelectronics ST200 microcontroller";
1898 case EM_MAX: return "MAX Processor";
1899 case EM_CR: return "National Semiconductor CompactRISC";
1900 case EM_F2MC16: return "Fujitsu F2MC16";
1901 case EM_MSP430: return "Texas Instruments msp430 microcontroller";
1902 case EM_LATTICEMICO32: return "Lattice Mico32";
1904 case EM_M32C: return "Renesas M32c";
1905 case EM_MT: return "Morpho Techologies MT processor";
1906 case EM_BLACKFIN: return "Analog Devices Blackfin";
1907 case EM_SE_C33: return "S1C33 Family of Seiko Epson processors";
1908 case EM_SEP: return "Sharp embedded microprocessor";
1909 case EM_ARCA: return "Arca RISC microprocessor";
1910 case EM_UNICORE: return "Unicore";
1911 case EM_EXCESS: return "eXcess 16/32/64-bit configurable embedded CPU";
1912 case EM_DXP: return "Icera Semiconductor Inc. Deep Execution Processor";
1913 case EM_NIOS32: return "Altera Nios";
1914 case EM_ALTERA_NIOS2: return "Altera Nios II";
1916 case EM_XC16X: return "Infineon Technologies xc16x";
1917 case EM_M16C: return "Renesas M16C series microprocessors";
1918 case EM_DSPIC30F: return "Microchip Technology dsPIC30F Digital Signal Controller";
1919 case EM_CE: return "Freescale Communication Engine RISC core";
1920 case EM_TSK3000: return "Altium TSK3000 core";
1921 case EM_RS08: return "Freescale RS08 embedded processor";
1922 case EM_ECOG2: return "Cyan Technology eCOG2 microprocessor";
1923 case EM_DSP24: return "New Japan Radio (NJR) 24-bit DSP Processor";
1924 case EM_VIDEOCORE3: return "Broadcom VideoCore III processor";
1925 case EM_SE_C17: return "Seiko Epson C17 family";
1926 case EM_TI_C6000: return "Texas Instruments TMS320C6000 DSP family";
1927 case EM_TI_C2000: return "Texas Instruments TMS320C2000 DSP family";
1928 case EM_TI_C5500: return "Texas Instruments TMS320C55x DSP family";
1929 case EM_MMDSP_PLUS: return "STMicroelectronics 64bit VLIW Data Signal Processor";
1930 case EM_CYPRESS_M8C: return "Cypress M8C microprocessor";
1931 case EM_R32C: return "Renesas R32C series microprocessors";
1932 case EM_TRIMEDIA: return "NXP Semiconductors TriMedia architecture family";
1933 case EM_QDSP6: return "QUALCOMM DSP6 Processor";
1934 case EM_8051: return "Intel 8051 and variants";
1935 case EM_STXP7X: return "STMicroelectronics STxP7x family";
1936 case EM_NDS32: return "Andes Technology compact code size embedded RISC processor family";
1937 case EM_ECOG1X: return "Cyan Technology eCOG1X family";
1938 case EM_MAXQ30: return "Dallas Semiconductor MAXQ30 Core microcontrollers";
1939 case EM_XIMO16: return "New Japan Radio (NJR) 16-bit DSP Processor";
1940 case EM_MANIK: return "M2000 Reconfigurable RISC Microprocessor";
1941 case EM_CRAYNV2: return "Cray Inc. NV2 vector architecture";
1942 case EM_CYGNUS_MEP: return "Toshiba MeP Media Engine";
1944 case EM_CR16_OLD: return "National Semiconductor's CR16";
1945 case EM_MICROBLAZE: return "Xilinx MicroBlaze";
1946 case EM_MICROBLAZE_OLD: return "Xilinx MicroBlaze";
1947 case EM_RX: return "Renesas RX";
1948 case EM_METAG: return "Imagination Technologies META processor architecture";
1949 case EM_MCST_ELBRUS: return "MCST Elbrus general purpose hardware architecture";
1950 case EM_ECOG16: return "Cyan Technology eCOG16 family";
1951 case EM_ETPU: return "Freescale Extended Time Processing Unit";
1952 case EM_SLE9X: return "Infineon Technologies SLE9X core";
1953 case EM_AVR32: return "Atmel Corporation 32-bit microprocessor family";
1954 case EM_STM8: return "STMicroeletronics STM8 8-bit microcontroller";
1955 case EM_TILE64: return "Tilera TILE64 multicore architecture family";
1956 case EM_TILEPRO: return "Tilera TILEPro multicore architecture family";
1957 case EM_CUDA: return "NVIDIA CUDA architecture";
1959 snprintf (buff, sizeof (buff), _("<unknown>: 0x%x"), e_machine);
1965 decode_ARM_machine_flags (unsigned e_flags, char buf[])
1970 eabi = EF_ARM_EABI_VERSION (e_flags);
1971 e_flags &= ~ EF_ARM_EABIMASK;
1973 /* Handle "generic" ARM flags. */
1974 if (e_flags & EF_ARM_RELEXEC)
1976 strcat (buf, ", relocatable executable");
1977 e_flags &= ~ EF_ARM_RELEXEC;
1980 if (e_flags & EF_ARM_HASENTRY)
1982 strcat (buf, ", has entry point");
1983 e_flags &= ~ EF_ARM_HASENTRY;
1986 /* Now handle EABI specific flags. */
1990 strcat (buf, ", <unrecognized EABI>");
1995 case EF_ARM_EABI_VER1:
1996 strcat (buf, ", Version1 EABI");
2001 /* Process flags one bit at a time. */
2002 flag = e_flags & - e_flags;
2007 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2008 strcat (buf, ", sorted symbol tables");
2018 case EF_ARM_EABI_VER2:
2019 strcat (buf, ", Version2 EABI");
2024 /* Process flags one bit at a time. */
2025 flag = e_flags & - e_flags;
2030 case EF_ARM_SYMSARESORTED: /* Conflicts with EF_ARM_INTERWORK. */
2031 strcat (buf, ", sorted symbol tables");
2034 case EF_ARM_DYNSYMSUSESEGIDX:
2035 strcat (buf, ", dynamic symbols use segment index");
2038 case EF_ARM_MAPSYMSFIRST:
2039 strcat (buf, ", mapping symbols precede others");
2049 case EF_ARM_EABI_VER3:
2050 strcat (buf, ", Version3 EABI");
2053 case EF_ARM_EABI_VER4:
2054 strcat (buf, ", Version4 EABI");
2057 case EF_ARM_EABI_VER5:
2058 strcat (buf, ", Version5 EABI");
2064 /* Process flags one bit at a time. */
2065 flag = e_flags & - e_flags;
2071 strcat (buf, ", BE8");
2075 strcat (buf, ", LE8");
2085 case EF_ARM_EABI_UNKNOWN:
2086 strcat (buf, ", GNU EABI");
2091 /* Process flags one bit at a time. */
2092 flag = e_flags & - e_flags;
2097 case EF_ARM_INTERWORK:
2098 strcat (buf, ", interworking enabled");
2101 case EF_ARM_APCS_26:
2102 strcat (buf, ", uses APCS/26");
2105 case EF_ARM_APCS_FLOAT:
2106 strcat (buf, ", uses APCS/float");
2110 strcat (buf, ", position independent");
2114 strcat (buf, ", 8 bit structure alignment");
2117 case EF_ARM_NEW_ABI:
2118 strcat (buf, ", uses new ABI");
2121 case EF_ARM_OLD_ABI:
2122 strcat (buf, ", uses old ABI");
2125 case EF_ARM_SOFT_FLOAT:
2126 strcat (buf, ", software FP");
2129 case EF_ARM_VFP_FLOAT:
2130 strcat (buf, ", VFP");
2133 case EF_ARM_MAVERICK_FLOAT:
2134 strcat (buf, ", Maverick FP");
2145 strcat (buf,_(", <unknown>"));
2149 get_machine_flags (unsigned e_flags, unsigned e_machine)
2151 static char buf[1024];
2163 decode_ARM_machine_flags (e_flags, buf);
2167 switch (e_flags & EF_FRV_CPU_MASK)
2169 case EF_FRV_CPU_GENERIC:
2173 strcat (buf, ", fr???");
2176 case EF_FRV_CPU_FR300:
2177 strcat (buf, ", fr300");
2180 case EF_FRV_CPU_FR400:
2181 strcat (buf, ", fr400");
2183 case EF_FRV_CPU_FR405:
2184 strcat (buf, ", fr405");
2187 case EF_FRV_CPU_FR450:
2188 strcat (buf, ", fr450");
2191 case EF_FRV_CPU_FR500:
2192 strcat (buf, ", fr500");
2194 case EF_FRV_CPU_FR550:
2195 strcat (buf, ", fr550");
2198 case EF_FRV_CPU_SIMPLE:
2199 strcat (buf, ", simple");
2201 case EF_FRV_CPU_TOMCAT:
2202 strcat (buf, ", tomcat");
2208 if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_M68000)
2209 strcat (buf, ", m68000");
2210 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_CPU32)
2211 strcat (buf, ", cpu32");
2212 else if ((e_flags & EF_M68K_ARCH_MASK) == EF_M68K_FIDO)
2213 strcat (buf, ", fido_a");
2216 char const * isa = _("unknown");
2217 char const * mac = _("unknown mac");
2218 char const * additional = NULL;
2220 switch (e_flags & EF_M68K_CF_ISA_MASK)
2222 case EF_M68K_CF_ISA_A_NODIV:
2224 additional = ", nodiv";
2226 case EF_M68K_CF_ISA_A:
2229 case EF_M68K_CF_ISA_A_PLUS:
2232 case EF_M68K_CF_ISA_B_NOUSP:
2234 additional = ", nousp";
2236 case EF_M68K_CF_ISA_B:
2239 case EF_M68K_CF_ISA_C:
2242 case EF_M68K_CF_ISA_C_NODIV:
2244 additional = ", nodiv";
2247 strcat (buf, ", cf, isa ");
2250 strcat (buf, additional);
2251 if (e_flags & EF_M68K_CF_FLOAT)
2252 strcat (buf, ", float");
2253 switch (e_flags & EF_M68K_CF_MAC_MASK)
2258 case EF_M68K_CF_MAC:
2261 case EF_M68K_CF_EMAC:
2264 case EF_M68K_CF_EMAC_B:
2277 if (e_flags & EF_PPC_EMB)
2278 strcat (buf, ", emb");
2280 if (e_flags & EF_PPC_RELOCATABLE)
2281 strcat (buf, _(", relocatable"));
2283 if (e_flags & EF_PPC_RELOCATABLE_LIB)
2284 strcat (buf, _(", relocatable-lib"));
2288 case EM_CYGNUS_V850:
2289 switch (e_flags & EF_V850_ARCH)
2291 case E_V850E2V3_ARCH:
2292 strcat (buf, ", v850e2v3");
2295 strcat (buf, ", v850e2");
2298 strcat (buf, ", v850e1");
2301 strcat (buf, ", v850e");
2304 strcat (buf, ", v850");
2307 strcat (buf, _(", unknown v850 architecture variant"));
2313 case EM_CYGNUS_M32R:
2314 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
2315 strcat (buf, ", m32r");
2319 case EM_MIPS_RS3_LE:
2320 if (e_flags & EF_MIPS_NOREORDER)
2321 strcat (buf, ", noreorder");
2323 if (e_flags & EF_MIPS_PIC)
2324 strcat (buf, ", pic");
2326 if (e_flags & EF_MIPS_CPIC)
2327 strcat (buf, ", cpic");
2329 if (e_flags & EF_MIPS_UCODE)
2330 strcat (buf, ", ugen_reserved");
2332 if (e_flags & EF_MIPS_ABI2)
2333 strcat (buf, ", abi2");
2335 if (e_flags & EF_MIPS_OPTIONS_FIRST)
2336 strcat (buf, ", odk first");
2338 if (e_flags & EF_MIPS_32BITMODE)
2339 strcat (buf, ", 32bitmode");
2341 switch ((e_flags & EF_MIPS_MACH))
2343 case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
2344 case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
2345 case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
2346 case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
2347 case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
2348 case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
2349 case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
2350 case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
2351 case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); break;
2352 case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
2353 case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
2354 case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
2355 case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
2356 case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
2357 case E_MIPS_MACH_XLR: strcat (buf, ", xlr"); break;
2359 /* We simply ignore the field in this case to avoid confusion:
2360 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2363 default: strcat (buf, _(", unknown CPU")); break;
2366 switch ((e_flags & EF_MIPS_ABI))
2368 case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
2369 case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
2370 case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
2371 case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
2373 /* We simply ignore the field in this case to avoid confusion:
2374 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2375 This means it is likely to be an o32 file, but not for
2378 default: strcat (buf, _(", unknown ABI")); break;
2381 if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
2382 strcat (buf, ", mdmx");
2384 if (e_flags & EF_MIPS_ARCH_ASE_M16)
2385 strcat (buf, ", mips16");
2387 switch ((e_flags & EF_MIPS_ARCH))
2389 case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
2390 case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
2391 case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
2392 case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
2393 case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
2394 case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
2395 case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
2396 case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
2397 case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
2398 default: strcat (buf, _(", unknown ISA")); break;
2401 if (e_flags & EF_SH_PIC)
2402 strcat (buf, ", pic");
2404 if (e_flags & EF_SH_FDPIC)
2405 strcat (buf, ", fdpic");
2409 switch ((e_flags & EF_SH_MACH_MASK))
2411 case EF_SH1: strcat (buf, ", sh1"); break;
2412 case EF_SH2: strcat (buf, ", sh2"); break;
2413 case EF_SH3: strcat (buf, ", sh3"); break;
2414 case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
2415 case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
2416 case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
2417 case EF_SH3E: strcat (buf, ", sh3e"); break;
2418 case EF_SH4: strcat (buf, ", sh4"); break;
2419 case EF_SH5: strcat (buf, ", sh5"); break;
2420 case EF_SH2E: strcat (buf, ", sh2e"); break;
2421 case EF_SH4A: strcat (buf, ", sh4a"); break;
2422 case EF_SH2A: strcat (buf, ", sh2a"); break;
2423 case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
2424 case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
2425 case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
2426 case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
2427 case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
2428 case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
2429 case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
2430 case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
2431 case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
2432 default: strcat (buf, _(", unknown ISA")); break;
2438 if (e_flags & EF_SPARC_32PLUS)
2439 strcat (buf, ", v8+");
2441 if (e_flags & EF_SPARC_SUN_US1)
2442 strcat (buf, ", ultrasparcI");
2444 if (e_flags & EF_SPARC_SUN_US3)
2445 strcat (buf, ", ultrasparcIII");
2447 if (e_flags & EF_SPARC_HAL_R1)
2448 strcat (buf, ", halr1");
2450 if (e_flags & EF_SPARC_LEDATA)
2451 strcat (buf, ", ledata");
2453 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
2454 strcat (buf, ", tso");
2456 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
2457 strcat (buf, ", pso");
2459 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
2460 strcat (buf, ", rmo");
2464 switch (e_flags & EF_PARISC_ARCH)
2466 case EFA_PARISC_1_0:
2467 strcpy (buf, ", PA-RISC 1.0");
2469 case EFA_PARISC_1_1:
2470 strcpy (buf, ", PA-RISC 1.1");
2472 case EFA_PARISC_2_0:
2473 strcpy (buf, ", PA-RISC 2.0");
2478 if (e_flags & EF_PARISC_TRAPNIL)
2479 strcat (buf, ", trapnil");
2480 if (e_flags & EF_PARISC_EXT)
2481 strcat (buf, ", ext");
2482 if (e_flags & EF_PARISC_LSB)
2483 strcat (buf, ", lsb");
2484 if (e_flags & EF_PARISC_WIDE)
2485 strcat (buf, ", wide");
2486 if (e_flags & EF_PARISC_NO_KABP)
2487 strcat (buf, ", no kabp");
2488 if (e_flags & EF_PARISC_LAZYSWAP)
2489 strcat (buf, ", lazyswap");
2494 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
2495 strcat (buf, ", new calling convention");
2497 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
2498 strcat (buf, ", gnu calling convention");
2502 if ((e_flags & EF_IA_64_ABI64))
2503 strcat (buf, ", 64-bit");
2505 strcat (buf, ", 32-bit");
2506 if ((e_flags & EF_IA_64_REDUCEDFP))
2507 strcat (buf, ", reduced fp model");
2508 if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
2509 strcat (buf, ", no function descriptors, constant gp");
2510 else if ((e_flags & EF_IA_64_CONS_GP))
2511 strcat (buf, ", constant gp");
2512 if ((e_flags & EF_IA_64_ABSOLUTE))
2513 strcat (buf, ", absolute");
2514 if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
2516 if ((e_flags & EF_IA_64_VMS_LINKAGES))
2517 strcat (buf, ", vms_linkages");
2518 switch ((e_flags & EF_IA_64_VMS_COMCOD))
2520 case EF_IA_64_VMS_COMCOD_SUCCESS:
2522 case EF_IA_64_VMS_COMCOD_WARNING:
2523 strcat (buf, ", warning");
2525 case EF_IA_64_VMS_COMCOD_ERROR:
2526 strcat (buf, ", error");
2528 case EF_IA_64_VMS_COMCOD_ABORT:
2529 strcat (buf, ", abort");
2538 if ((e_flags & EF_VAX_NONPIC))
2539 strcat (buf, ", non-PIC");
2540 if ((e_flags & EF_VAX_DFLOAT))
2541 strcat (buf, ", D-Float");
2542 if ((e_flags & EF_VAX_GFLOAT))
2543 strcat (buf, ", G-Float");
2547 if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
2548 strcat (buf, ", 64-bit doubles");
2549 if (e_flags & E_FLAG_RX_DSP)
2550 strcat (buf, ", dsp");
2553 if (e_flags & EF_S390_HIGH_GPRS)
2554 strcat (buf, ", highgprs");
2557 if ((e_flags & EF_C6000_REL))
2558 strcat (buf, ", relocatable module");
2566 get_osabi_name (unsigned int osabi)
2568 static char buff[32];
2572 case ELFOSABI_NONE: return "UNIX - System V";
2573 case ELFOSABI_HPUX: return "UNIX - HP-UX";
2574 case ELFOSABI_NETBSD: return "UNIX - NetBSD";
2575 case ELFOSABI_LINUX: return "UNIX - Linux";
2576 case ELFOSABI_HURD: return "GNU/Hurd";
2577 case ELFOSABI_SOLARIS: return "UNIX - Solaris";
2578 case ELFOSABI_AIX: return "UNIX - AIX";
2579 case ELFOSABI_IRIX: return "UNIX - IRIX";
2580 case ELFOSABI_FREEBSD: return "UNIX - FreeBSD";
2581 case ELFOSABI_TRU64: return "UNIX - TRU64";
2582 case ELFOSABI_MODESTO: return "Novell - Modesto";
2583 case ELFOSABI_OPENBSD: return "UNIX - OpenBSD";
2584 case ELFOSABI_OPENVMS: return "VMS - OpenVMS";
2585 case ELFOSABI_NSK: return "HP - Non-Stop Kernel";
2586 case ELFOSABI_AROS: return "AROS";
2587 case ELFOSABI_FENIXOS: return "FenixOS";
2590 switch (elf_header.e_machine)
2595 case ELFOSABI_ARM: return "ARM";
2605 case ELFOSABI_STANDALONE: return _("Standalone App");
2614 case ELFOSABI_C6000_ELFABI: return _("Bare-metal C6000");
2615 case ELFOSABI_C6000_LINUX: return "Linux C6000";
2624 snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
2630 get_arm_segment_type (unsigned long type)
2644 get_mips_segment_type (unsigned long type)
2648 case PT_MIPS_REGINFO:
2650 case PT_MIPS_RTPROC:
2652 case PT_MIPS_OPTIONS:
2662 get_parisc_segment_type (unsigned long type)
2666 case PT_HP_TLS: return "HP_TLS";
2667 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
2668 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
2669 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
2670 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
2671 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
2672 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
2673 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
2674 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
2675 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
2676 case PT_HP_PARALLEL: return "HP_PARALLEL";
2677 case PT_HP_FASTBIND: return "HP_FASTBIND";
2678 case PT_HP_OPT_ANNOT: return "HP_OPT_ANNOT";
2679 case PT_HP_HSL_ANNOT: return "HP_HSL_ANNOT";
2680 case PT_HP_STACK: return "HP_STACK";
2681 case PT_HP_CORE_UTSNAME: return "HP_CORE_UTSNAME";
2682 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
2683 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
2684 case PT_PARISC_WEAKORDER: return "PARISC_WEAKORDER";
2693 get_ia64_segment_type (unsigned long type)
2697 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
2698 case PT_IA_64_UNWIND: return "IA_64_UNWIND";
2699 case PT_HP_TLS: return "HP_TLS";
2700 case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
2701 case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
2702 case PT_IA_64_HP_STACK: return "HP_STACK";
2711 get_tic6x_segment_type (unsigned long type)
2715 case PT_C6000_PHATTR: return "C6000_PHATTR";
2724 get_segment_type (unsigned long p_type)
2726 static char buff[32];
2730 case PT_NULL: return "NULL";
2731 case PT_LOAD: return "LOAD";
2732 case PT_DYNAMIC: return "DYNAMIC";
2733 case PT_INTERP: return "INTERP";
2734 case PT_NOTE: return "NOTE";
2735 case PT_SHLIB: return "SHLIB";
2736 case PT_PHDR: return "PHDR";
2737 case PT_TLS: return "TLS";
2739 case PT_GNU_EH_FRAME:
2740 return "GNU_EH_FRAME";
2741 case PT_GNU_STACK: return "GNU_STACK";
2742 case PT_GNU_RELRO: return "GNU_RELRO";
2745 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
2747 const char * result;
2749 switch (elf_header.e_machine)
2752 result = get_arm_segment_type (p_type);
2755 case EM_MIPS_RS3_LE:
2756 result = get_mips_segment_type (p_type);
2759 result = get_parisc_segment_type (p_type);
2762 result = get_ia64_segment_type (p_type);
2765 result = get_tic6x_segment_type (p_type);
2775 sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
2777 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
2779 const char * result;
2781 switch (elf_header.e_machine)
2784 result = get_parisc_segment_type (p_type);
2787 result = get_ia64_segment_type (p_type);
2797 sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
2800 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
2807 get_mips_section_type_name (unsigned int sh_type)
2811 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
2812 case SHT_MIPS_MSYM: return "MIPS_MSYM";
2813 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
2814 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
2815 case SHT_MIPS_UCODE: return "MIPS_UCODE";
2816 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
2817 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
2818 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
2819 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
2820 case SHT_MIPS_RELD: return "MIPS_RELD";
2821 case SHT_MIPS_IFACE: return "MIPS_IFACE";
2822 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
2823 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
2824 case SHT_MIPS_SHDR: return "MIPS_SHDR";
2825 case SHT_MIPS_FDESC: return "MIPS_FDESC";
2826 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
2827 case SHT_MIPS_DENSE: return "MIPS_DENSE";
2828 case SHT_MIPS_PDESC: return "MIPS_PDESC";
2829 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
2830 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
2831 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
2832 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
2833 case SHT_MIPS_LINE: return "MIPS_LINE";
2834 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
2835 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
2836 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
2837 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
2838 case SHT_MIPS_DWARF: return "MIPS_DWARF";
2839 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
2840 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
2841 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
2842 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
2843 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
2844 case SHT_MIPS_XLATE: return "MIPS_XLATE";
2845 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
2846 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
2847 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
2848 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
2849 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
2857 get_parisc_section_type_name (unsigned int sh_type)
2861 case SHT_PARISC_EXT: return "PARISC_EXT";
2862 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
2863 case SHT_PARISC_DOC: return "PARISC_DOC";
2864 case SHT_PARISC_ANNOT: return "PARISC_ANNOT";
2865 case SHT_PARISC_SYMEXTN: return "PARISC_SYMEXTN";
2866 case SHT_PARISC_STUBS: return "PARISC_STUBS";
2867 case SHT_PARISC_DLKM: return "PARISC_DLKM";
2875 get_ia64_section_type_name (unsigned int sh_type)
2877 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
2878 if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
2879 return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
2883 case SHT_IA_64_EXT: return "IA_64_EXT";
2884 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
2885 case SHT_IA_64_PRIORITY_INIT: return "IA_64_PRIORITY_INIT";
2886 case SHT_IA_64_VMS_TRACE: return "VMS_TRACE";
2887 case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
2888 case SHT_IA_64_VMS_DEBUG: return "VMS_DEBUG";
2889 case SHT_IA_64_VMS_DEBUG_STR: return "VMS_DEBUG_STR";
2890 case SHT_IA_64_VMS_LINKAGES: return "VMS_LINKAGES";
2891 case SHT_IA_64_VMS_SYMBOL_VECTOR: return "VMS_SYMBOL_VECTOR";
2892 case SHT_IA_64_VMS_FIXUP: return "VMS_FIXUP";
2900 get_x86_64_section_type_name (unsigned int sh_type)
2904 case SHT_X86_64_UNWIND: return "X86_64_UNWIND";
2912 get_arm_section_type_name (unsigned int sh_type)
2916 case SHT_ARM_EXIDX: return "ARM_EXIDX";
2917 case SHT_ARM_PREEMPTMAP: return "ARM_PREEMPTMAP";
2918 case SHT_ARM_ATTRIBUTES: return "ARM_ATTRIBUTES";
2919 case SHT_ARM_DEBUGOVERLAY: return "ARM_DEBUGOVERLAY";
2920 case SHT_ARM_OVERLAYSECTION: return "ARM_OVERLAYSECTION";
2928 get_tic6x_section_type_name (unsigned int sh_type)
2932 case SHT_C6000_UNWIND:
2933 return "C6000_UNWIND";
2934 case SHT_C6000_PREEMPTMAP:
2935 return "C6000_PREEMPTMAP";
2936 case SHT_C6000_ATTRIBUTES:
2937 return "C6000_ATTRIBUTES";
2942 case SHT_TI_HANDLER:
2943 return "TI_HANDLER";
2944 case SHT_TI_INITINFO:
2945 return "TI_INITINFO";
2946 case SHT_TI_PHATTRS:
2947 return "TI_PHATTRS";
2955 get_section_type_name (unsigned int sh_type)
2957 static char buff[32];
2961 case SHT_NULL: return "NULL";
2962 case SHT_PROGBITS: return "PROGBITS";
2963 case SHT_SYMTAB: return "SYMTAB";
2964 case SHT_STRTAB: return "STRTAB";
2965 case SHT_RELA: return "RELA";
2966 case SHT_HASH: return "HASH";
2967 case SHT_DYNAMIC: return "DYNAMIC";
2968 case SHT_NOTE: return "NOTE";
2969 case SHT_NOBITS: return "NOBITS";
2970 case SHT_REL: return "REL";
2971 case SHT_SHLIB: return "SHLIB";
2972 case SHT_DYNSYM: return "DYNSYM";
2973 case SHT_INIT_ARRAY: return "INIT_ARRAY";
2974 case SHT_FINI_ARRAY: return "FINI_ARRAY";
2975 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
2976 case SHT_GNU_HASH: return "GNU_HASH";
2977 case SHT_GROUP: return "GROUP";
2978 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICIES";
2979 case SHT_GNU_verdef: return "VERDEF";
2980 case SHT_GNU_verneed: return "VERNEED";
2981 case SHT_GNU_versym: return "VERSYM";
2982 case 0x6ffffff0: return "VERSYM";
2983 case 0x6ffffffc: return "VERDEF";
2984 case 0x7ffffffd: return "AUXILIARY";
2985 case 0x7fffffff: return "FILTER";
2986 case SHT_GNU_LIBLIST: return "GNU_LIBLIST";
2989 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
2991 const char * result;
2993 switch (elf_header.e_machine)
2996 case EM_MIPS_RS3_LE:
2997 result = get_mips_section_type_name (sh_type);
3000 result = get_parisc_section_type_name (sh_type);
3003 result = get_ia64_section_type_name (sh_type);
3007 result = get_x86_64_section_type_name (sh_type);
3010 result = get_arm_section_type_name (sh_type);
3013 result = get_tic6x_section_type_name (sh_type);
3023 sprintf (buff, "LOPROC+%x", sh_type - SHT_LOPROC);
3025 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
3027 const char * result;
3029 switch (elf_header.e_machine)
3032 result = get_ia64_section_type_name (sh_type);
3042 sprintf (buff, "LOOS+%x", sh_type - SHT_LOOS);
3044 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
3045 sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER);
3047 snprintf (buff, sizeof (buff), _("<unknown>: %x"), sh_type);
3053 #define OPTION_DEBUG_DUMP 512
3054 #define OPTION_DYN_SYMS 513
3056 static struct option options[] =
3058 {"all", no_argument, 0, 'a'},
3059 {"file-header", no_argument, 0, 'h'},
3060 {"program-headers", no_argument, 0, 'l'},
3061 {"headers", no_argument, 0, 'e'},
3062 {"histogram", no_argument, 0, 'I'},
3063 {"segments", no_argument, 0, 'l'},
3064 {"sections", no_argument, 0, 'S'},
3065 {"section-headers", no_argument, 0, 'S'},
3066 {"section-groups", no_argument, 0, 'g'},
3067 {"section-details", no_argument, 0, 't'},
3068 {"full-section-name",no_argument, 0, 'N'},
3069 {"symbols", no_argument, 0, 's'},
3070 {"syms", no_argument, 0, 's'},
3071 {"dyn-syms", no_argument, 0, OPTION_DYN_SYMS},
3072 {"relocs", no_argument, 0, 'r'},
3073 {"notes", no_argument, 0, 'n'},
3074 {"dynamic", no_argument, 0, 'd'},
3075 {"arch-specific", no_argument, 0, 'A'},
3076 {"version-info", no_argument, 0, 'V'},
3077 {"use-dynamic", no_argument, 0, 'D'},
3078 {"unwind", no_argument, 0, 'u'},
3079 {"archive-index", no_argument, 0, 'c'},
3080 {"hex-dump", required_argument, 0, 'x'},
3081 {"relocated-dump", required_argument, 0, 'R'},
3082 {"string-dump", required_argument, 0, 'p'},
3083 #ifdef SUPPORT_DISASSEMBLY
3084 {"instruction-dump", required_argument, 0, 'i'},
3086 {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
3088 {"version", no_argument, 0, 'v'},
3089 {"wide", no_argument, 0, 'W'},
3090 {"help", no_argument, 0, 'H'},
3091 {0, no_argument, 0, 0}
3095 usage (FILE * stream)
3097 fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
3098 fprintf (stream, _(" Display information about the contents of ELF format files\n"));
3099 fprintf (stream, _(" Options are:\n\
3100 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
3101 -h --file-header Display the ELF file header\n\
3102 -l --program-headers Display the program headers\n\
3103 --segments An alias for --program-headers\n\
3104 -S --section-headers Display the sections' header\n\
3105 --sections An alias for --section-headers\n\
3106 -g --section-groups Display the section groups\n\
3107 -t --section-details Display the section details\n\
3108 -e --headers Equivalent to: -h -l -S\n\
3109 -s --syms Display the symbol table\n\
3110 --symbols An alias for --syms\n\
3111 --dyn-syms Display the dynamic symbol table\n\
3112 -n --notes Display the core notes (if present)\n\
3113 -r --relocs Display the relocations (if present)\n\
3114 -u --unwind Display the unwind info (if present)\n\
3115 -d --dynamic Display the dynamic section (if present)\n\
3116 -V --version-info Display the version sections (if present)\n\
3117 -A --arch-specific Display architecture specific information (if any).\n\
3118 -c --archive-index Display the symbol/file index in an archive\n\
3119 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
3120 -x --hex-dump=<number|name>\n\
3121 Dump the contents of section <number|name> as bytes\n\
3122 -p --string-dump=<number|name>\n\
3123 Dump the contents of section <number|name> as strings\n\
3124 -R --relocated-dump=<number|name>\n\
3125 Dump the contents of section <number|name> as relocated bytes\n\
3126 -w[lLiaprmfFsoRt] or\n\
3127 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
3128 =frames-interp,=str,=loc,=Ranges,=pubtypes,\n\
3129 =gdb_index,=trace_info,=trace_abbrev,=trace_aranges]\n\
3130 Display the contents of DWARF2 debug sections\n"));
3131 #ifdef SUPPORT_DISASSEMBLY
3132 fprintf (stream, _("\
3133 -i --instruction-dump=<number|name>\n\
3134 Disassemble the contents of section <number|name>\n"));
3136 fprintf (stream, _("\
3137 -I --histogram Display histogram of bucket list lengths\n\
3138 -W --wide Allow output width to exceed 80 characters\n\
3139 @<file> Read options from <file>\n\
3140 -H --help Display this information\n\
3141 -v --version Display the version number of readelf\n"));
3143 if (REPORT_BUGS_TO[0] && stream == stdout)
3144 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
3146 exit (stream == stdout ? 0 : 1);
3149 /* Record the fact that the user wants the contents of section number
3150 SECTION to be displayed using the method(s) encoded as flags bits
3151 in TYPE. Note, TYPE can be zero if we are creating the array for
3155 request_dump_bynumber (unsigned int section, dump_type type)
3157 if (section >= num_dump_sects)
3159 dump_type * new_dump_sects;
3161 new_dump_sects = (dump_type *) calloc (section + 1,
3162 sizeof (* dump_sects));
3164 if (new_dump_sects == NULL)
3165 error (_("Out of memory allocating dump request table.\n"));
3168 /* Copy current flag settings. */
3169 memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
3173 dump_sects = new_dump_sects;
3174 num_dump_sects = section + 1;
3179 dump_sects[section] |= type;
3184 /* Request a dump by section name. */
3187 request_dump_byname (const char * section, dump_type type)
3189 struct dump_list_entry * new_request;
3191 new_request = (struct dump_list_entry *)
3192 malloc (sizeof (struct dump_list_entry));
3194 error (_("Out of memory allocating dump request table.\n"));
3196 new_request->name = strdup (section);
3197 if (!new_request->name)
3198 error (_("Out of memory allocating dump request table.\n"));
3200 new_request->type = type;
3202 new_request->next = dump_sects_byname;
3203 dump_sects_byname = new_request;
3207 request_dump (dump_type type)
3213 section = strtoul (optarg, & cp, 0);
3215 if (! *cp && section >= 0)
3216 request_dump_bynumber (section, type);
3218 request_dump_byname (optarg, type);
3223 parse_args (int argc, char ** argv)
3230 while ((c = getopt_long
3231 (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options, NULL)) != EOF)
3249 do_section_groups++;
3257 do_section_groups++;
3262 do_section_details++;
3306 request_dump (HEX_DUMP);
3309 request_dump (STRING_DUMP);
3312 request_dump (RELOC_DUMP);
3319 dwarf_select_sections_all ();
3324 dwarf_select_sections_by_letters (optarg);
3327 case OPTION_DEBUG_DUMP:
3334 dwarf_select_sections_by_names (optarg);
3337 case OPTION_DYN_SYMS:
3340 #ifdef SUPPORT_DISASSEMBLY
3342 request_dump (DISASS_DUMP);
3346 print_version (program_name);
3355 /* xgettext:c-format */
3356 error (_("Invalid option '-%c'\n"), c);
3363 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
3364 && !do_segments && !do_header && !do_dump && !do_version
3365 && !do_histogram && !do_debugging && !do_arch && !do_notes
3366 && !do_section_groups && !do_archive_index
3371 warn (_("Nothing to do.\n"));
3377 get_elf_class (unsigned int elf_class)
3379 static char buff[32];
3383 case ELFCLASSNONE: return _("none");
3384 case ELFCLASS32: return "ELF32";
3385 case ELFCLASS64: return "ELF64";
3387 snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
3393 get_data_encoding (unsigned int encoding)
3395 static char buff[32];
3399 case ELFDATANONE: return _("none");
3400 case ELFDATA2LSB: return _("2's complement, little endian");
3401 case ELFDATA2MSB: return _("2's complement, big endian");
3403 snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
3408 /* Decode the data held in 'elf_header'. */
3411 process_file_header (void)
3413 if ( elf_header.e_ident[EI_MAG0] != ELFMAG0
3414 || elf_header.e_ident[EI_MAG1] != ELFMAG1
3415 || elf_header.e_ident[EI_MAG2] != ELFMAG2
3416 || elf_header.e_ident[EI_MAG3] != ELFMAG3)
3419 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3423 init_dwarf_regnames (elf_header.e_machine);
3429 printf (_("ELF Header:\n"));
3430 printf (_(" Magic: "));
3431 for (i = 0; i < EI_NIDENT; i++)
3432 printf ("%2.2x ", elf_header.e_ident[i]);
3434 printf (_(" Class: %s\n"),
3435 get_elf_class (elf_header.e_ident[EI_CLASS]));
3436 printf (_(" Data: %s\n"),
3437 get_data_encoding (elf_header.e_ident[EI_DATA]));
3438 printf (_(" Version: %d %s\n"),
3439 elf_header.e_ident[EI_VERSION],
3440 (elf_header.e_ident[EI_VERSION] == EV_CURRENT
3442 : (elf_header.e_ident[EI_VERSION] != EV_NONE
3443 ? _("<unknown: %lx>")
3445 printf (_(" OS/ABI: %s\n"),
3446 get_osabi_name (elf_header.e_ident[EI_OSABI]));
3447 printf (_(" ABI Version: %d\n"),
3448 elf_header.e_ident[EI_ABIVERSION]);
3449 printf (_(" Type: %s\n"),
3450 get_file_type (elf_header.e_type));
3451 printf (_(" Machine: %s\n"),
3452 get_machine_name (elf_header.e_machine));
3453 printf (_(" Version: 0x%lx\n"),
3454 (unsigned long) elf_header.e_version);
3456 printf (_(" Entry point address: "));
3457 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
3458 printf (_("\n Start of program headers: "));
3459 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
3460 printf (_(" (bytes into file)\n Start of section headers: "));
3461 print_vma ((bfd_vma) elf_header.e_shoff, DEC);
3462 printf (_(" (bytes into file)\n"));
3464 printf (_(" Flags: 0x%lx%s\n"),
3465 (unsigned long) elf_header.e_flags,
3466 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
3467 printf (_(" Size of this header: %ld (bytes)\n"),
3468 (long) elf_header.e_ehsize);
3469 printf (_(" Size of program headers: %ld (bytes)\n"),
3470 (long) elf_header.e_phentsize);
3471 printf (_(" Number of program headers: %ld"),
3472 (long) elf_header.e_phnum);
3473 if (section_headers != NULL
3474 && elf_header.e_phnum == PN_XNUM
3475 && section_headers[0].sh_info != 0)
3476 printf (" (%ld)", (long) section_headers[0].sh_info);
3477 putc ('\n', stdout);
3478 printf (_(" Size of section headers: %ld (bytes)\n"),
3479 (long) elf_header.e_shentsize);
3480 printf (_(" Number of section headers: %ld"),
3481 (long) elf_header.e_shnum);
3482 if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
3483 printf (" (%ld)", (long) section_headers[0].sh_size);
3484 putc ('\n', stdout);
3485 printf (_(" Section header string table index: %ld"),
3486 (long) elf_header.e_shstrndx);
3487 if (section_headers != NULL
3488 && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
3489 printf (" (%u)", section_headers[0].sh_link);
3490 else if (elf_header.e_shstrndx != SHN_UNDEF
3491 && elf_header.e_shstrndx >= elf_header.e_shnum)
3492 printf (_(" <corrupt: out of range>"));
3493 putc ('\n', stdout);
3496 if (section_headers != NULL)
3498 if (elf_header.e_phnum == PN_XNUM
3499 && section_headers[0].sh_info != 0)
3500 elf_header.e_phnum = section_headers[0].sh_info;
3501 if (elf_header.e_shnum == SHN_UNDEF)
3502 elf_header.e_shnum = section_headers[0].sh_size;
3503 if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
3504 elf_header.e_shstrndx = section_headers[0].sh_link;
3505 else if (elf_header.e_shstrndx >= elf_header.e_shnum)
3506 elf_header.e_shstrndx = SHN_UNDEF;
3507 free (section_headers);
3508 section_headers = NULL;
3516 get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
3518 Elf32_External_Phdr * phdrs;
3519 Elf32_External_Phdr * external;
3520 Elf_Internal_Phdr * internal;
3523 phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
3524 elf_header.e_phentsize,
3526 _("program headers"));
3530 for (i = 0, internal = pheaders, external = phdrs;
3531 i < elf_header.e_phnum;
3532 i++, internal++, external++)
3534 internal->p_type = BYTE_GET (external->p_type);
3535 internal->p_offset = BYTE_GET (external->p_offset);
3536 internal->p_vaddr = BYTE_GET (external->p_vaddr);
3537 internal->p_paddr = BYTE_GET (external->p_paddr);
3538 internal->p_filesz = BYTE_GET (external->p_filesz);
3539 internal->p_memsz = BYTE_GET (external->p_memsz);
3540 internal->p_flags = BYTE_GET (external->p_flags);
3541 internal->p_align = BYTE_GET (external->p_align);
3550 get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
3552 Elf64_External_Phdr * phdrs;
3553 Elf64_External_Phdr * external;
3554 Elf_Internal_Phdr * internal;
3557 phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
3558 elf_header.e_phentsize,
3560 _("program headers"));
3564 for (i = 0, internal = pheaders, external = phdrs;
3565 i < elf_header.e_phnum;
3566 i++, internal++, external++)
3568 internal->p_type = BYTE_GET (external->p_type);
3569 internal->p_flags = BYTE_GET (external->p_flags);
3570 internal->p_offset = BYTE_GET (external->p_offset);
3571 internal->p_vaddr = BYTE_GET (external->p_vaddr);
3572 internal->p_paddr = BYTE_GET (external->p_paddr);
3573 internal->p_filesz = BYTE_GET (external->p_filesz);
3574 internal->p_memsz = BYTE_GET (external->p_memsz);
3575 internal->p_align = BYTE_GET (external->p_align);
3583 /* Returns 1 if the program headers were read into `program_headers'. */
3586 get_program_headers (FILE * file)
3588 Elf_Internal_Phdr * phdrs;
3590 /* Check cache of prior read. */
3591 if (program_headers != NULL)
3594 phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
3595 sizeof (Elf_Internal_Phdr));
3599 error (_("Out of memory\n"));
3604 ? get_32bit_program_headers (file, phdrs)
3605 : get_64bit_program_headers (file, phdrs))
3607 program_headers = phdrs;
3615 /* Returns 1 if the program headers were loaded. */
3618 process_program_headers (FILE * file)
3620 Elf_Internal_Phdr * segment;
3623 if (elf_header.e_phnum == 0)
3626 printf (_("\nThere are no program headers in this file.\n"));
3630 if (do_segments && !do_header)
3632 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
3633 printf (_("Entry point "));
3634 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
3635 printf (_("\nThere are %d program headers, starting at offset "),
3636 elf_header.e_phnum);
3637 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
3641 if (! get_program_headers (file))
3646 if (elf_header.e_phnum > 1)
3647 printf (_("\nProgram Headers:\n"));
3649 printf (_("\nProgram Headers:\n"));
3653 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3656 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3660 (_(" Type Offset VirtAddr PhysAddr\n"));
3662 (_(" FileSiz MemSiz Flags Align\n"));
3669 for (i = 0, segment = program_headers;
3670 i < elf_header.e_phnum;
3675 printf (" %-14.14s ", get_segment_type (segment->p_type));
3679 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
3680 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
3681 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
3682 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
3683 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
3685 (segment->p_flags & PF_R ? 'R' : ' '),
3686 (segment->p_flags & PF_W ? 'W' : ' '),
3687 (segment->p_flags & PF_X ? 'E' : ' '));
3688 printf ("%#lx", (unsigned long) segment->p_align);
3692 if ((unsigned long) segment->p_offset == segment->p_offset)
3693 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
3696 print_vma (segment->p_offset, FULL_HEX);
3700 print_vma (segment->p_vaddr, FULL_HEX);
3702 print_vma (segment->p_paddr, FULL_HEX);
3705 if ((unsigned long) segment->p_filesz == segment->p_filesz)
3706 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
3709 print_vma (segment->p_filesz, FULL_HEX);
3713 if ((unsigned long) segment->p_memsz == segment->p_memsz)
3714 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
3717 print_vma (segment->p_offset, FULL_HEX);
3721 (segment->p_flags & PF_R ? 'R' : ' '),
3722 (segment->p_flags & PF_W ? 'W' : ' '),
3723 (segment->p_flags & PF_X ? 'E' : ' '));
3725 if ((unsigned long) segment->p_align == segment->p_align)
3726 printf ("%#lx", (unsigned long) segment->p_align);
3729 print_vma (segment->p_align, PREFIX_HEX);
3734 print_vma (segment->p_offset, FULL_HEX);
3736 print_vma (segment->p_vaddr, FULL_HEX);
3738 print_vma (segment->p_paddr, FULL_HEX);
3740 print_vma (segment->p_filesz, FULL_HEX);
3742 print_vma (segment->p_memsz, FULL_HEX);
3744 (segment->p_flags & PF_R ? 'R' : ' '),
3745 (segment->p_flags & PF_W ? 'W' : ' '),
3746 (segment->p_flags & PF_X ? 'E' : ' '));
3747 print_vma (segment->p_align, HEX);
3751 switch (segment->p_type)
3755 error (_("more than one dynamic segment\n"));
3757 /* By default, assume that the .dynamic section is the first
3758 section in the DYNAMIC segment. */
3759 dynamic_addr = segment->p_offset;
3760 dynamic_size = segment->p_filesz;
3762 /* Try to locate the .dynamic section. If there is
3763 a section header table, we can easily locate it. */
3764 if (section_headers != NULL)
3766 Elf_Internal_Shdr * sec;
3768 sec = find_section (".dynamic");
3769 if (sec == NULL || sec->sh_size == 0)
3771 /* A corresponding .dynamic section is expected, but on
3772 IA-64/OpenVMS it is OK for it to be missing. */
3773 if (!is_ia64_vms ())
3774 error (_("no .dynamic section in the dynamic segment\n"));
3778 if (sec->sh_type == SHT_NOBITS)
3784 dynamic_addr = sec->sh_offset;
3785 dynamic_size = sec->sh_size;
3787 if (dynamic_addr < segment->p_offset
3788 || dynamic_addr > segment->p_offset + segment->p_filesz)
3789 warn (_("the .dynamic section is not contained"
3790 " within the dynamic segment\n"));
3791 else if (dynamic_addr > segment->p_offset)
3792 warn (_("the .dynamic section is not the first section"
3793 " in the dynamic segment.\n"));
3798 if (fseek (file, archive_file_offset + (long) segment->p_offset,
3800 error (_("Unable to find program interpreter name\n"));
3804 int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX);
3806 if (ret >= (int) sizeof (fmt) || ret < 0)
3807 error (_("Internal error: failed to create format string to display program interpreter\n"));
3809 program_interpreter[0] = 0;
3810 if (fscanf (file, fmt, program_interpreter) <= 0)
3811 error (_("Unable to read program interpreter name\n"));
3814 printf (_("\n [Requesting program interpreter: %s]"),
3815 program_interpreter);
3821 putc ('\n', stdout);
3824 if (do_segments && section_headers != NULL && string_table != NULL)
3826 printf (_("\n Section to Segment mapping:\n"));
3827 printf (_(" Segment Sections...\n"));
3829 for (i = 0; i < elf_header.e_phnum; i++)
3832 Elf_Internal_Shdr * section;
3834 segment = program_headers + i;
3835 section = section_headers + 1;
3837 printf (" %2.2d ", i);
3839 for (j = 1; j < elf_header.e_shnum; j++, section++)
3841 if (!ELF_TBSS_SPECIAL (section, segment)
3842 && ELF_SECTION_IN_SEGMENT_STRICT (section, segment))
3843 printf ("%s ", SECTION_NAME (section));
3854 /* Find the file offset corresponding to VMA by using the program headers. */
3857 offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
3859 Elf_Internal_Phdr * seg;
3861 if (! get_program_headers (file))
3863 warn (_("Cannot interpret virtual addresses without program headers.\n"));
3867 for (seg = program_headers;
3868 seg < program_headers + elf_header.e_phnum;
3871 if (seg->p_type != PT_LOAD)
3874 if (vma >= (seg->p_vaddr & -seg->p_align)
3875 && vma + size <= seg->p_vaddr + seg->p_filesz)
3876 return vma - seg->p_vaddr + seg->p_offset;
3879 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
3880 (unsigned long) vma);
3886 get_32bit_section_headers (FILE * file, unsigned int num)
3888 Elf32_External_Shdr * shdrs;
3889 Elf_Internal_Shdr * internal;
3892 shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
3893 elf_header.e_shentsize, num,
3894 _("section headers"));
3898 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
3899 sizeof (Elf_Internal_Shdr));
3901 if (section_headers == NULL)
3903 error (_("Out of memory\n"));
3907 for (i = 0, internal = section_headers;
3911 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
3912 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
3913 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
3914 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
3915 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
3916 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
3917 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
3918 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
3919 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
3920 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
3929 get_64bit_section_headers (FILE * file, unsigned int num)
3931 Elf64_External_Shdr * shdrs;
3932 Elf_Internal_Shdr * internal;
3935 shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
3936 elf_header.e_shentsize, num,
3937 _("section headers"));
3941 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
3942 sizeof (Elf_Internal_Shdr));
3944 if (section_headers == NULL)
3946 error (_("Out of memory\n"));
3950 for (i = 0, internal = section_headers;
3954 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
3955 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
3956 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
3957 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
3958 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
3959 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
3960 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
3961 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
3962 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
3963 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
3971 static Elf_Internal_Sym *
3972 get_32bit_elf_symbols (FILE * file, Elf_Internal_Shdr * section)
3974 unsigned long number;
3975 Elf32_External_Sym * esyms = NULL;
3976 Elf_External_Sym_Shndx * shndx;
3977 Elf_Internal_Sym * isyms = NULL;
3978 Elf_Internal_Sym * psym;
3981 /* Run some sanity checks first. */
3982 if (section->sh_entsize == 0)
3984 error (_("sh_entsize is zero\n"));
3988 number = section->sh_size / section->sh_entsize;
3990 if (number * sizeof (Elf32_External_Sym) > section->sh_size + 1)
3992 error (_("Invalid sh_entsize\n"));
3996 esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
3997 section->sh_size, _("symbols"));
4002 if (symtab_shndx_hdr != NULL
4003 && (symtab_shndx_hdr->sh_link
4004 == (unsigned long) (section - section_headers)))
4006 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4007 symtab_shndx_hdr->sh_offset,
4008 1, symtab_shndx_hdr->sh_size,
4014 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
4018 error (_("Out of memory\n"));
4022 for (j = 0, psym = isyms; j < number; j++, psym++)
4024 psym->st_name = BYTE_GET (esyms[j].st_name);
4025 psym->st_value = BYTE_GET (esyms[j].st_value);
4026 psym->st_size = BYTE_GET (esyms[j].st_size);
4027 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4028 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
4030 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4031 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4032 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
4033 psym->st_info = BYTE_GET (esyms[j].st_info);
4034 psym->st_other = BYTE_GET (esyms[j].st_other);
4046 static Elf_Internal_Sym *
4047 get_64bit_elf_symbols (FILE * file, Elf_Internal_Shdr * section)
4049 unsigned long number;
4050 Elf64_External_Sym * esyms;
4051 Elf_External_Sym_Shndx * shndx;
4052 Elf_Internal_Sym * isyms;
4053 Elf_Internal_Sym * psym;
4056 /* Run some sanity checks first. */
4057 if (section->sh_entsize == 0)
4059 error (_("sh_entsize is zero\n"));
4063 number = section->sh_size / section->sh_entsize;
4065 if (number * sizeof (Elf64_External_Sym) > section->sh_size + 1)
4067 error (_("Invalid sh_entsize\n"));
4071 esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
4072 section->sh_size, _("symbols"));
4077 if (symtab_shndx_hdr != NULL
4078 && (symtab_shndx_hdr->sh_link
4079 == (unsigned long) (section - section_headers)))
4081 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
4082 symtab_shndx_hdr->sh_offset,
4083 1, symtab_shndx_hdr->sh_size,
4092 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
4096 error (_("Out of memory\n"));
4103 for (j = 0, psym = isyms;
4107 psym->st_name = BYTE_GET (esyms[j].st_name);
4108 psym->st_info = BYTE_GET (esyms[j].st_info);
4109 psym->st_other = BYTE_GET (esyms[j].st_other);
4110 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
4111 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
4113 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
4114 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
4115 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
4116 psym->st_value = BYTE_GET (esyms[j].st_value);
4117 psym->st_size = BYTE_GET (esyms[j].st_size);
4128 get_elf_section_flags (bfd_vma sh_flags)
4130 static char buff[1024];
4132 int field_size = is_32bit_elf ? 8 : 16;
4134 int size = sizeof (buff) - (field_size + 4 + 1);
4135 bfd_vma os_flags = 0;
4136 bfd_vma proc_flags = 0;
4137 bfd_vma unknown_flags = 0;
4145 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
4146 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
4147 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
4148 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
4149 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
4150 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
4151 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
4152 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
4153 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
4154 /* 9 */ { STRING_COMMA_LEN ("TLS") },
4155 /* IA-64 specific. */
4156 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
4157 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
4158 /* IA-64 OpenVMS specific. */
4159 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
4160 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
4161 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
4162 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
4163 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
4164 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
4166 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
4167 /* SPARC specific. */
4168 /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
4171 if (do_section_details)
4173 sprintf (buff, "[%*.*lx]: ",
4174 field_size, field_size, (unsigned long) sh_flags);
4175 p += field_size + 4;
4182 flag = sh_flags & - sh_flags;
4185 if (do_section_details)
4189 case SHF_WRITE: sindex = 0; break;
4190 case SHF_ALLOC: sindex = 1; break;
4191 case SHF_EXECINSTR: sindex = 2; break;
4192 case SHF_MERGE: sindex = 3; break;
4193 case SHF_STRINGS: sindex = 4; break;
4194 case SHF_INFO_LINK: sindex = 5; break;
4195 case SHF_LINK_ORDER: sindex = 6; break;
4196 case SHF_OS_NONCONFORMING: sindex = 7; break;
4197 case SHF_GROUP: sindex = 8; break;
4198 case SHF_TLS: sindex = 9; break;
4199 case SHF_EXCLUDE: sindex = 18; break;
4203 switch (elf_header.e_machine)
4206 if (flag == SHF_IA_64_SHORT)
4208 else if (flag == SHF_IA_64_NORECOV)
4211 else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
4214 case SHF_IA_64_VMS_GLOBAL: sindex = 12; break;
4215 case SHF_IA_64_VMS_OVERLAID: sindex = 13; break;
4216 case SHF_IA_64_VMS_SHARED: sindex = 14; break;
4217 case SHF_IA_64_VMS_VECTOR: sindex = 15; break;
4218 case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
4219 case SHF_IA_64_VMS_PROTECTED: sindex = 17; break;
4229 case EM_OLD_SPARCV9:
4230 case EM_SPARC32PLUS:
4233 if (flag == SHF_ORDERED)
4243 if (p != buff + field_size + 4)
4245 if (size < (10 + 2))
4252 size -= flags [sindex].len;
4253 p = stpcpy (p, flags [sindex].str);
4255 else if (flag & SHF_MASKOS)
4257 else if (flag & SHF_MASKPROC)
4260 unknown_flags |= flag;
4266 case SHF_WRITE: *p = 'W'; break;
4267 case SHF_ALLOC: *p = 'A'; break;
4268 case SHF_EXECINSTR: *p = 'X'; break;
4269 case SHF_MERGE: *p = 'M'; break;
4270 case SHF_STRINGS: *p = 'S'; break;
4271 case SHF_INFO_LINK: *p = 'I'; break;
4272 case SHF_LINK_ORDER: *p = 'L'; break;
4273 case SHF_OS_NONCONFORMING: *p = 'O'; break;
4274 case SHF_GROUP: *p = 'G'; break;
4275 case SHF_TLS: *p = 'T'; break;
4276 case SHF_EXCLUDE: *p = 'E'; break;
4279 if ((elf_header.e_machine == EM_X86_64
4280 || elf_header.e_machine == EM_L1OM)
4281 && flag == SHF_X86_64_LARGE)
4283 else if (flag & SHF_MASKOS)
4286 sh_flags &= ~ SHF_MASKOS;
4288 else if (flag & SHF_MASKPROC)
4291 sh_flags &= ~ SHF_MASKPROC;
4301 if (do_section_details)
4305 size -= 5 + field_size;
4306 if (p != buff + field_size + 4)
4314 sprintf (p, "OS (%*.*lx)", field_size, field_size,
4315 (unsigned long) os_flags);
4316 p += 5 + field_size;
4320 size -= 7 + field_size;
4321 if (p != buff + field_size + 4)
4329 sprintf (p, "PROC (%*.*lx)", field_size, field_size,
4330 (unsigned long) proc_flags);
4331 p += 7 + field_size;
4335 size -= 10 + field_size;
4336 if (p != buff + field_size + 4)
4344 sprintf (p, _("UNKNOWN (%*.*lx)"), field_size, field_size,
4345 (unsigned long) unknown_flags);
4346 p += 10 + field_size;
4355 process_section_headers (FILE * file)
4357 Elf_Internal_Shdr * section;
4360 section_headers = NULL;
4362 if (elf_header.e_shnum == 0)
4365 printf (_("\nThere are no sections in this file.\n"));
4370 if (do_sections && !do_header)
4371 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
4372 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
4376 if (! get_32bit_section_headers (file, elf_header.e_shnum))
4379 else if (! get_64bit_section_headers (file, elf_header.e_shnum))
4382 /* Read in the string table, so that we have names to display. */
4383 if (elf_header.e_shstrndx != SHN_UNDEF
4384 && elf_header.e_shstrndx < elf_header.e_shnum)
4386 section = section_headers + elf_header.e_shstrndx;
4388 if (section->sh_size != 0)
4390 string_table = (char *) get_data (NULL, file, section->sh_offset,
4391 1, section->sh_size,
4394 string_table_length = string_table != NULL ? section->sh_size : 0;
4398 /* Scan the sections for the dynamic symbol table
4399 and dynamic string table and debug sections. */
4400 dynamic_symbols = NULL;
4401 dynamic_strings = NULL;
4402 dynamic_syminfo = NULL;
4403 symtab_shndx_hdr = NULL;
4405 eh_addr_size = is_32bit_elf ? 4 : 8;
4406 switch (elf_header.e_machine)
4409 case EM_MIPS_RS3_LE:
4410 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
4411 FDE addresses. However, the ABI also has a semi-official ILP32
4412 variant for which the normal FDE address size rules apply.
4414 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
4415 section, where XX is the size of longs in bits. Unfortunately,
4416 earlier compilers provided no way of distinguishing ILP32 objects
4417 from LP64 objects, so if there's any doubt, we should assume that
4418 the official LP64 form is being used. */
4419 if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
4420 && find_section (".gcc_compiled_long32") == NULL)
4426 switch (elf_header.e_flags & EF_H8_MACH)
4428 case E_H8_MACH_H8300:
4429 case E_H8_MACH_H8300HN:
4430 case E_H8_MACH_H8300SN:
4431 case E_H8_MACH_H8300SXN:
4434 case E_H8_MACH_H8300H:
4435 case E_H8_MACH_H8300S:
4436 case E_H8_MACH_H8300SX:
4444 switch (elf_header.e_flags & EF_M32C_CPU_MASK)
4446 case EF_M32C_CPU_M16C:
4453 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
4456 size_t expected_entsize \
4457 = is_32bit_elf ? size32 : size64; \
4458 if (section->sh_entsize != expected_entsize) \
4459 error (_("Section %d has invalid sh_entsize %lx (expected %lx)\n"), \
4460 i, (unsigned long int) section->sh_entsize, \
4461 (unsigned long int) expected_entsize); \
4462 section->sh_entsize = expected_entsize; \
4465 #define CHECK_ENTSIZE(section, i, type) \
4466 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
4467 sizeof (Elf64_External_##type))
4469 for (i = 0, section = section_headers;
4470 i < elf_header.e_shnum;
4473 char * name = SECTION_NAME (section);
4475 if (section->sh_type == SHT_DYNSYM)
4477 if (dynamic_symbols != NULL)
4479 error (_("File contains multiple dynamic symbol tables\n"));
4483 CHECK_ENTSIZE (section, i, Sym);
4484 num_dynamic_syms = section->sh_size / section->sh_entsize;
4485 dynamic_symbols = GET_ELF_SYMBOLS (file, section);
4487 else if (section->sh_type == SHT_STRTAB
4488 && streq (name, ".dynstr"))
4490 if (dynamic_strings != NULL)
4492 error (_("File contains multiple dynamic string tables\n"));
4496 dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
4497 1, section->sh_size,
4498 _("dynamic strings"));
4499 dynamic_strings_length = section->sh_size;
4501 else if (section->sh_type == SHT_SYMTAB_SHNDX)
4503 if (symtab_shndx_hdr != NULL)
4505 error (_("File contains multiple symtab shndx tables\n"));
4508 symtab_shndx_hdr = section;
4510 else if (section->sh_type == SHT_SYMTAB)
4511 CHECK_ENTSIZE (section, i, Sym);
4512 else if (section->sh_type == SHT_GROUP)
4513 CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
4514 else if (section->sh_type == SHT_REL)
4515 CHECK_ENTSIZE (section, i, Rel);
4516 else if (section->sh_type == SHT_RELA)
4517 CHECK_ENTSIZE (section, i, Rela);
4518 else if ((do_debugging || do_debug_info || do_debug_abbrevs
4519 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
4520 || do_debug_aranges || do_debug_frames || do_debug_macinfo
4521 || do_debug_str || do_debug_loc || do_debug_ranges)
4522 && (const_strneq (name, ".debug_")
4523 || const_strneq (name, ".zdebug_")))
4526 name += sizeof (".zdebug_") - 1;
4528 name += sizeof (".debug_") - 1;
4531 || (do_debug_info && streq (name, "info"))
4532 || (do_debug_info && streq (name, "types"))
4533 || (do_debug_abbrevs && streq (name, "abbrev"))
4534 || (do_debug_lines && streq (name, "line"))
4535 || (do_debug_pubnames && streq (name, "pubnames"))
4536 || (do_debug_pubtypes && streq (name, "pubtypes"))
4537 || (do_debug_aranges && streq (name, "aranges"))
4538 || (do_debug_ranges && streq (name, "ranges"))
4539 || (do_debug_frames && streq (name, "frame"))
4540 || (do_debug_macinfo && streq (name, "macinfo"))
4541 || (do_debug_str && streq (name, "str"))
4542 || (do_debug_loc && streq (name, "loc"))
4544 request_dump_bynumber (i, DEBUG_DUMP);
4546 /* Linkonce section to be combined with .debug_info at link time. */
4547 else if ((do_debugging || do_debug_info)
4548 && const_strneq (name, ".gnu.linkonce.wi."))
4549 request_dump_bynumber (i, DEBUG_DUMP);
4550 else if (do_debug_frames && streq (name, ".eh_frame"))
4551 request_dump_bynumber (i, DEBUG_DUMP);
4552 else if (do_gdb_index && streq (name, ".gdb_index"))
4553 request_dump_bynumber (i, DEBUG_DUMP);
4554 /* Trace sections for Itanium VMS. */
4555 else if ((do_debugging || do_trace_info || do_trace_abbrevs
4556 || do_trace_aranges)
4557 && const_strneq (name, ".trace_"))
4559 name += sizeof (".trace_") - 1;
4562 || (do_trace_info && streq (name, "info"))
4563 || (do_trace_abbrevs && streq (name, "abbrev"))
4564 || (do_trace_aranges && streq (name, "aranges"))
4566 request_dump_bynumber (i, DEBUG_DUMP);
4574 if (elf_header.e_shnum > 1)
4575 printf (_("\nSection Headers:\n"));
4577 printf (_("\nSection Header:\n"));
4581 if (do_section_details)
4583 printf (_(" [Nr] Name\n"));
4584 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
4588 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
4592 if (do_section_details)
4594 printf (_(" [Nr] Name\n"));
4595 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
4599 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
4603 if (do_section_details)
4605 printf (_(" [Nr] Name\n"));
4606 printf (_(" Type Address Offset Link\n"));
4607 printf (_(" Size EntSize Info Align\n"));
4611 printf (_(" [Nr] Name Type Address Offset\n"));
4612 printf (_(" Size EntSize Flags Link Info Align\n"));
4616 if (do_section_details)
4617 printf (_(" Flags\n"));
4619 for (i = 0, section = section_headers;
4620 i < elf_header.e_shnum;
4623 if (do_section_details)
4625 printf (" [%2u] %s\n",
4627 SECTION_NAME (section));
4628 if (is_32bit_elf || do_wide)
4629 printf (" %-15.15s ",
4630 get_section_type_name (section->sh_type));
4633 printf ((do_wide ? " [%2u] %-17s %-15s "
4634 : " [%2u] %-17.17s %-15.15s "),
4636 SECTION_NAME (section),
4637 get_section_type_name (section->sh_type));
4641 const char * link_too_big = NULL;
4643 print_vma (section->sh_addr, LONG_HEX);
4645 printf ( " %6.6lx %6.6lx %2.2lx",
4646 (unsigned long) section->sh_offset,
4647 (unsigned long) section->sh_size,
4648 (unsigned long) section->sh_entsize);
4650 if (do_section_details)
4651 fputs (" ", stdout);
4653 printf (" %3s ", get_elf_section_flags (section->sh_flags));
4655 if (section->sh_link >= elf_header.e_shnum)
4658 /* The sh_link value is out of range. Normally this indicates
4659 an error but it can have special values in Solaris binaries. */
4660 switch (elf_header.e_machine)
4666 case EM_OLD_SPARCV9:
4667 case EM_SPARC32PLUS:
4670 if (section->sh_link == (SHN_BEFORE & 0xffff))
4671 link_too_big = "BEFORE";
4672 else if (section->sh_link == (SHN_AFTER & 0xffff))
4673 link_too_big = "AFTER";
4680 if (do_section_details)
4682 if (link_too_big != NULL && * link_too_big)
4683 printf ("<%s> ", link_too_big);
4685 printf ("%2u ", section->sh_link);
4686 printf ("%3u %2lu\n", section->sh_info,
4687 (unsigned long) section->sh_addralign);
4690 printf ("%2u %3u %2lu\n",
4693 (unsigned long) section->sh_addralign);
4695 if (link_too_big && ! * link_too_big)
4696 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
4697 i, section->sh_link);
4701 print_vma (section->sh_addr, LONG_HEX);
4703 if ((long) section->sh_offset == section->sh_offset)
4704 printf (" %6.6lx", (unsigned long) section->sh_offset);
4708 print_vma (section->sh_offset, LONG_HEX);
4711 if ((unsigned long) section->sh_size == section->sh_size)
4712 printf (" %6.6lx", (unsigned long) section->sh_size);
4716 print_vma (section->sh_size, LONG_HEX);
4719 if ((unsigned long) section->sh_entsize == section->sh_entsize)
4720 printf (" %2.2lx", (unsigned long) section->sh_entsize);
4724 print_vma (section->sh_entsize, LONG_HEX);
4727 if (do_section_details)
4728 fputs (" ", stdout);
4730 printf (" %3s ", get_elf_section_flags (section->sh_flags));
4732 printf ("%2u %3u ", section->sh_link, section->sh_info);
4734 if ((unsigned long) section->sh_addralign == section->sh_addralign)
4735 printf ("%2lu\n", (unsigned long) section->sh_addralign);
4738 print_vma (section->sh_addralign, DEC);
4742 else if (do_section_details)
4744 printf (" %-15.15s ",
4745 get_section_type_name (section->sh_type));
4746 print_vma (section->sh_addr, LONG_HEX);
4747 if ((long) section->sh_offset == section->sh_offset)
4748 printf (" %16.16lx", (unsigned long) section->sh_offset);
4752 print_vma (section->sh_offset, LONG_HEX);
4754 printf (" %u\n ", section->sh_link);
4755 print_vma (section->sh_size, LONG_HEX);
4757 print_vma (section->sh_entsize, LONG_HEX);
4759 printf (" %-16u %lu\n",
4761 (unsigned long) section->sh_addralign);
4766 print_vma (section->sh_addr, LONG_HEX);
4767 if ((long) section->sh_offset == section->sh_offset)
4768 printf (" %8.8lx", (unsigned long) section->sh_offset);
4772 print_vma (section->sh_offset, LONG_HEX);
4775 print_vma (section->sh_size, LONG_HEX);
4777 print_vma (section->sh_entsize, LONG_HEX);
4779 printf (" %3s ", get_elf_section_flags (section->sh_flags));
4781 printf (" %2u %3u %lu\n",
4784 (unsigned long) section->sh_addralign);
4787 if (do_section_details)
4788 printf (" %s\n", get_elf_section_flags (section->sh_flags));
4791 if (!do_section_details)
4793 if (elf_header.e_machine == EM_X86_64
4794 || elf_header.e_machine == EM_L1OM)
4795 printf (_("Key to Flags:\n\
4796 W (write), A (alloc), X (execute), M (merge), S (strings), l (large)\n\
4797 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
4798 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
4800 printf (_("Key to Flags:\n\
4801 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
4802 I (info), L (link order), G (group), T (TLS), E (exclude), x (unknown)\n\
4803 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
4810 get_group_flags (unsigned int flags)
4812 static char buff[32];
4822 snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x] "), flags);
4829 process_section_groups (FILE * file)
4831 Elf_Internal_Shdr * section;
4833 struct group * group;
4834 Elf_Internal_Shdr * symtab_sec;
4835 Elf_Internal_Shdr * strtab_sec;
4836 Elf_Internal_Sym * symtab;
4840 /* Don't process section groups unless needed. */
4841 if (!do_unwind && !do_section_groups)
4844 if (elf_header.e_shnum == 0)
4846 if (do_section_groups)
4847 printf (_("\nThere are no sections in this file.\n"));
4852 if (section_headers == NULL)
4854 error (_("Section headers are not available!\n"));
4858 section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
4859 sizeof (struct group *));
4861 if (section_headers_groups == NULL)
4863 error (_("Out of memory\n"));
4867 /* Scan the sections for the group section. */
4869 for (i = 0, section = section_headers;
4870 i < elf_header.e_shnum;
4872 if (section->sh_type == SHT_GROUP)
4875 if (group_count == 0)
4877 if (do_section_groups)
4878 printf (_("\nThere are no section groups in this file.\n"));
4883 section_groups = (struct group *) calloc (group_count, sizeof (struct group));
4885 if (section_groups == NULL)
4887 error (_("Out of memory\n"));
4896 for (i = 0, section = section_headers, group = section_groups;
4897 i < elf_header.e_shnum;
4900 if (section->sh_type == SHT_GROUP)
4902 char * name = SECTION_NAME (section);
4904 unsigned char * start;
4905 unsigned char * indices;
4906 unsigned int entry, j, size;
4907 Elf_Internal_Shdr * sec;
4908 Elf_Internal_Sym * sym;
4910 /* Get the symbol table. */
4911 if (section->sh_link >= elf_header.e_shnum
4912 || ((sec = section_headers + section->sh_link)->sh_type
4915 error (_("Bad sh_link in group section `%s'\n"), name);
4919 if (symtab_sec != sec)
4924 symtab = GET_ELF_SYMBOLS (file, symtab_sec);
4929 error (_("Corrupt header in group section `%s'\n"), name);
4933 sym = symtab + section->sh_info;
4935 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
4937 if (sym->st_shndx == 0
4938 || sym->st_shndx >= elf_header.e_shnum)
4940 error (_("Bad sh_info in group section `%s'\n"), name);
4944 group_name = SECTION_NAME (section_headers + sym->st_shndx);
4953 /* Get the string table. */
4954 if (symtab_sec->sh_link >= elf_header.e_shnum)
4963 != (sec = section_headers + symtab_sec->sh_link))
4968 strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
4969 1, strtab_sec->sh_size,
4971 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
4973 group_name = sym->st_name < strtab_size
4974 ? strtab + sym->st_name : _("<corrupt>");
4977 start = (unsigned char *) get_data (NULL, file, section->sh_offset,
4978 1, section->sh_size,
4982 size = (section->sh_size / section->sh_entsize) - 1;
4983 entry = byte_get (indices, 4);
4986 if (do_section_groups)
4988 printf (_("\n%sgroup section [%5u] `%s' [%s] contains %u sections:\n"),
4989 get_group_flags (entry), i, name, group_name, size);
4991 printf (_(" [Index] Name\n"));
4994 group->group_index = i;
4996 for (j = 0; j < size; j++)
4998 struct group_list * g;
5000 entry = byte_get (indices, 4);
5003 if (entry >= elf_header.e_shnum)
5005 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
5006 entry, i, elf_header.e_shnum - 1);
5010 if (section_headers_groups [entry] != NULL)
5014 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
5016 section_headers_groups [entry]->group_index);
5021 /* Intel C/C++ compiler may put section 0 in a
5022 section group. We just warn it the first time
5023 and ignore it afterwards. */
5024 static int warned = 0;
5027 error (_("section 0 in group section [%5u]\n"),
5028 section_headers_groups [entry]->group_index);
5034 section_headers_groups [entry] = group;
5036 if (do_section_groups)
5038 sec = section_headers + entry;
5039 printf (" [%5u] %s\n", entry, SECTION_NAME (sec));
5042 g = (struct group_list *) xmalloc (sizeof (struct group_list));
5043 g->section_index = entry;
5044 g->next = group->root;
5062 /* Data used to display dynamic fixups. */
5064 struct ia64_vms_dynfixup
5066 bfd_vma needed_ident; /* Library ident number. */
5067 bfd_vma needed; /* Index in the dstrtab of the library name. */
5068 bfd_vma fixup_needed; /* Index of the library. */
5069 bfd_vma fixup_rela_cnt; /* Number of fixups. */
5070 bfd_vma fixup_rela_off; /* Fixups offset in the dynamic segment. */
5073 /* Data used to display dynamic relocations. */
5075 struct ia64_vms_dynimgrela
5077 bfd_vma img_rela_cnt; /* Number of relocations. */
5078 bfd_vma img_rela_off; /* Reloc offset in the dynamic segment. */
5081 /* Display IA-64 OpenVMS dynamic fixups (used to dynamically link a shared
5085 dump_ia64_vms_dynamic_fixups (FILE *file, struct ia64_vms_dynfixup *fixup,
5086 const char *strtab, unsigned int strtab_sz)
5088 Elf64_External_VMS_IMAGE_FIXUP *imfs;
5090 const char *lib_name;
5092 imfs = get_data (NULL, file, dynamic_addr + fixup->fixup_rela_off,
5093 1, fixup->fixup_rela_cnt * sizeof (*imfs),
5094 _("dynamic section image fixups"));
5098 if (fixup->needed < strtab_sz)
5099 lib_name = strtab + fixup->needed;
5102 warn ("corrupt library name index of 0x%lx found in dynamic entry",
5103 (unsigned long) fixup->needed);
5106 printf (_("\nImage fixups for needed library #%d: %s - ident: %lx\n"),
5107 (int) fixup->fixup_needed, lib_name, (long) fixup->needed_ident);
5109 (_("Seg Offset Type SymVec DataType\n"));
5111 for (i = 0; i < (long) fixup->fixup_rela_cnt; i++)
5116 printf ("%3u ", (unsigned) BYTE_GET (imfs [i].fixup_seg));
5117 printf_vma ((bfd_vma) BYTE_GET (imfs [i].fixup_offset));
5118 type = BYTE_GET (imfs [i].type);
5119 rtype = elf_ia64_reloc_type (type);
5121 printf (" 0x%08x ", type);
5123 printf (" %-32s ", rtype);
5124 printf ("%6u ", (unsigned) BYTE_GET (imfs [i].symvec_index));
5125 printf ("0x%08x\n", (unsigned) BYTE_GET (imfs [i].data_type));
5131 /* Display IA-64 OpenVMS dynamic relocations (used to relocate an image). */
5134 dump_ia64_vms_dynamic_relocs (FILE *file, struct ia64_vms_dynimgrela *imgrela)
5136 Elf64_External_VMS_IMAGE_RELA *imrs;
5139 imrs = get_data (NULL, file, dynamic_addr + imgrela->img_rela_off,
5140 1, imgrela->img_rela_cnt * sizeof (*imrs),
5141 _("dynamic section image relas"));
5145 printf (_("\nImage relocs\n"));
5147 (_("Seg Offset Type Addend Seg Sym Off\n"));
5149 for (i = 0; i < (long) imgrela->img_rela_cnt; i++)
5154 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].rela_seg));
5155 printf ("%08" BFD_VMA_FMT "x ",
5156 (bfd_vma) BYTE_GET (imrs [i].rela_offset));
5157 type = BYTE_GET (imrs [i].type);
5158 rtype = elf_ia64_reloc_type (type);
5160 printf ("0x%08x ", type);
5162 printf ("%-31s ", rtype);
5163 print_vma (BYTE_GET (imrs [i].addend), FULL_HEX);
5164 printf ("%3u ", (unsigned) BYTE_GET (imrs [i].sym_seg));
5165 printf ("%08" BFD_VMA_FMT "x\n",
5166 (bfd_vma) BYTE_GET (imrs [i].sym_offset));
5172 /* Display IA-64 OpenVMS dynamic relocations and fixups. */
5175 process_ia64_vms_dynamic_relocs (FILE *file)
5177 struct ia64_vms_dynfixup fixup;
5178 struct ia64_vms_dynimgrela imgrela;
5179 Elf_Internal_Dyn *entry;
5181 bfd_vma strtab_off = 0;
5182 bfd_vma strtab_sz = 0;
5183 char *strtab = NULL;
5185 memset (&fixup, 0, sizeof (fixup));
5186 memset (&imgrela, 0, sizeof (imgrela));
5188 /* Note: the order of the entries is specified by the OpenVMS specs. */
5189 for (entry = dynamic_section;
5190 entry < dynamic_section + dynamic_nent;
5193 switch (entry->d_tag)
5195 case DT_IA_64_VMS_STRTAB_OFFSET:
5196 strtab_off = entry->d_un.d_val;
5199 strtab_sz = entry->d_un.d_val;
5201 strtab = get_data (NULL, file, dynamic_addr + strtab_off,
5202 1, strtab_sz, _("dynamic string section"));
5205 case DT_IA_64_VMS_NEEDED_IDENT:
5206 fixup.needed_ident = entry->d_un.d_val;
5209 fixup.needed = entry->d_un.d_val;
5211 case DT_IA_64_VMS_FIXUP_NEEDED:
5212 fixup.fixup_needed = entry->d_un.d_val;
5214 case DT_IA_64_VMS_FIXUP_RELA_CNT:
5215 fixup.fixup_rela_cnt = entry->d_un.d_val;
5217 case DT_IA_64_VMS_FIXUP_RELA_OFF:
5218 fixup.fixup_rela_off = entry->d_un.d_val;
5220 dump_ia64_vms_dynamic_fixups (file, &fixup, strtab, strtab_sz);
5223 case DT_IA_64_VMS_IMG_RELA_CNT:
5224 imgrela.img_rela_cnt = entry->d_un.d_val;
5226 case DT_IA_64_VMS_IMG_RELA_OFF:
5227 imgrela.img_rela_off = entry->d_un.d_val;
5229 dump_ia64_vms_dynamic_relocs (file, &imgrela);
5249 } dynamic_relocations [] =
5251 { "REL", DT_REL, DT_RELSZ, FALSE },
5252 { "RELA", DT_RELA, DT_RELASZ, TRUE },
5253 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
5256 /* Process the reloc section. */
5259 process_relocs (FILE * file)
5261 unsigned long rel_size;
5262 unsigned long rel_offset;
5268 if (do_using_dynamic)
5272 int has_dynamic_reloc;
5275 has_dynamic_reloc = 0;
5277 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
5279 is_rela = dynamic_relocations [i].rela;
5280 name = dynamic_relocations [i].name;
5281 rel_size = dynamic_info [dynamic_relocations [i].size];
5282 rel_offset = dynamic_info [dynamic_relocations [i].reloc];
5284 has_dynamic_reloc |= rel_size;
5286 if (is_rela == UNKNOWN)
5288 if (dynamic_relocations [i].reloc == DT_JMPREL)
5289 switch (dynamic_info[DT_PLTREL])
5303 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
5304 name, rel_offset, rel_size);
5306 dump_relocations (file,
5307 offset_from_vma (file, rel_offset, rel_size),
5309 dynamic_symbols, num_dynamic_syms,
5310 dynamic_strings, dynamic_strings_length, is_rela);
5315 has_dynamic_reloc |= process_ia64_vms_dynamic_relocs (file);
5317 if (! has_dynamic_reloc)
5318 printf (_("\nThere are no dynamic relocations in this file.\n"));
5322 Elf_Internal_Shdr * section;
5326 for (i = 0, section = section_headers;
5327 i < elf_header.e_shnum;
5330 if ( section->sh_type != SHT_RELA
5331 && section->sh_type != SHT_REL)
5334 rel_offset = section->sh_offset;
5335 rel_size = section->sh_size;
5339 Elf_Internal_Shdr * strsec;
5342 printf (_("\nRelocation section "));
5344 if (string_table == NULL)
5345 printf ("%d", section->sh_name);
5347 printf (_("'%s'"), SECTION_NAME (section));
5349 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5350 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
5352 is_rela = section->sh_type == SHT_RELA;
5354 if (section->sh_link != 0
5355 && section->sh_link < elf_header.e_shnum)
5357 Elf_Internal_Shdr * symsec;
5358 Elf_Internal_Sym * symtab;
5359 unsigned long nsyms;
5360 unsigned long strtablen = 0;
5361 char * strtab = NULL;
5363 symsec = section_headers + section->sh_link;
5364 if (symsec->sh_type != SHT_SYMTAB
5365 && symsec->sh_type != SHT_DYNSYM)
5368 nsyms = symsec->sh_size / symsec->sh_entsize;
5369 symtab = GET_ELF_SYMBOLS (file, symsec);
5374 if (symsec->sh_link != 0
5375 && symsec->sh_link < elf_header.e_shnum)
5377 strsec = section_headers + symsec->sh_link;
5379 strtab = (char *) get_data (NULL, file, strsec->sh_offset,
5382 strtablen = strtab == NULL ? 0 : strsec->sh_size;
5385 dump_relocations (file, rel_offset, rel_size,
5386 symtab, nsyms, strtab, strtablen, is_rela);
5392 dump_relocations (file, rel_offset, rel_size,
5393 NULL, 0, NULL, 0, is_rela);
5400 printf (_("\nThere are no relocations in this file.\n"));
5406 /* Process the unwind section. */
5408 #include "unwind-ia64.h"
5410 /* An absolute address consists of a section and an offset. If the
5411 section is NULL, the offset itself is the address, otherwise, the
5412 address equals to LOAD_ADDRESS(section) + offset. */
5416 unsigned short section;
5420 #define ABSADDR(a) \
5422 ? section_headers [(a).section].sh_addr + (a).offset \
5425 struct ia64_unw_table_entry
5427 struct absaddr start;
5429 struct absaddr info;
5432 struct ia64_unw_aux_info
5435 struct ia64_unw_table_entry *table; /* Unwind table. */
5436 unsigned long table_len; /* Length of unwind table. */
5437 unsigned char * info; /* Unwind info. */
5438 unsigned long info_size; /* Size of unwind info. */
5439 bfd_vma info_addr; /* starting address of unwind info. */
5440 bfd_vma seg_base; /* Starting address of segment. */
5441 Elf_Internal_Sym * symtab; /* The symbol table. */
5442 unsigned long nsyms; /* Number of symbols. */
5443 char * strtab; /* The string table. */
5444 unsigned long strtab_size; /* Size of string table. */
5448 find_symbol_for_address (Elf_Internal_Sym * symtab,
5449 unsigned long nsyms,
5450 const char * strtab,
5451 unsigned long strtab_size,
5452 struct absaddr addr,
5453 const char ** symname,
5456 bfd_vma dist = 0x100000;
5457 Elf_Internal_Sym * sym;
5458 Elf_Internal_Sym * best = NULL;
5461 REMOVE_ARCH_BITS (addr.offset);
5463 for (i = 0, sym = symtab; i < nsyms; ++i, ++sym)
5465 bfd_vma value = sym->st_value;
5467 REMOVE_ARCH_BITS (value);
5469 if (ELF_ST_TYPE (sym->st_info) == STT_FUNC
5470 && sym->st_name != 0
5471 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
5472 && addr.offset >= value
5473 && addr.offset - value < dist)
5476 dist = addr.offset - value;
5483 *symname = (best->st_name >= strtab_size
5484 ? _("<corrupt>") : strtab + best->st_name);
5489 *offset = addr.offset;
5493 dump_ia64_unwind (struct ia64_unw_aux_info * aux)
5495 struct ia64_unw_table_entry * tp;
5498 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
5502 const unsigned char * dp;
5503 const unsigned char * head;
5504 const char * procname;
5506 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
5507 aux->strtab_size, tp->start, &procname, &offset);
5509 fputs ("\n<", stdout);
5513 fputs (procname, stdout);
5516 printf ("+%lx", (unsigned long) offset);
5519 fputs (">: [", stdout);
5520 print_vma (tp->start.offset, PREFIX_HEX);
5521 fputc ('-', stdout);
5522 print_vma (tp->end.offset, PREFIX_HEX);
5523 printf ("], info at +0x%lx\n",
5524 (unsigned long) (tp->info.offset - aux->seg_base));
5526 head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
5527 stamp = byte_get ((unsigned char *) head, sizeof (stamp));
5529 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
5530 (unsigned) UNW_VER (stamp),
5531 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
5532 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
5533 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
5534 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
5536 if (UNW_VER (stamp) != 1)
5538 printf (_("\tUnknown version.\n"));
5543 for (dp = head + 8; dp < head + 8 + eh_addr_size * UNW_LENGTH (stamp);)
5544 dp = unw_decode (dp, in_body, & in_body);
5549 slurp_ia64_unwind_table (FILE * file,
5550 struct ia64_unw_aux_info * aux,
5551 Elf_Internal_Shdr * sec)
5553 unsigned long size, nrelas, i;
5554 Elf_Internal_Phdr * seg;
5555 struct ia64_unw_table_entry * tep;
5556 Elf_Internal_Shdr * relsec;
5557 Elf_Internal_Rela * rela;
5558 Elf_Internal_Rela * rp;
5559 unsigned char * table;
5561 Elf_Internal_Sym * sym;
5562 const char * relname;
5564 /* First, find the starting address of the segment that includes
5567 if (elf_header.e_phnum)
5569 if (! get_program_headers (file))
5572 for (seg = program_headers;
5573 seg < program_headers + elf_header.e_phnum;
5576 if (seg->p_type != PT_LOAD)
5579 if (sec->sh_addr >= seg->p_vaddr
5580 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
5582 aux->seg_base = seg->p_vaddr;
5588 /* Second, build the unwind table from the contents of the unwind section: */
5589 size = sec->sh_size;
5590 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
5595 aux->table = (struct ia64_unw_table_entry *)
5596 xcmalloc (size / (3 * eh_addr_size), sizeof (aux->table[0]));
5598 for (tp = table; tp < table + size; ++tep)
5600 tep->start.section = SHN_UNDEF;
5601 tep->end.section = SHN_UNDEF;
5602 tep->info.section = SHN_UNDEF;
5603 tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
5604 tep->end.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
5605 tep->info.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
5606 tep->start.offset += aux->seg_base;
5607 tep->end.offset += aux->seg_base;
5608 tep->info.offset += aux->seg_base;
5612 /* Third, apply any relocations to the unwind table: */
5613 for (relsec = section_headers;
5614 relsec < section_headers + elf_header.e_shnum;
5617 if (relsec->sh_type != SHT_RELA
5618 || relsec->sh_info >= elf_header.e_shnum
5619 || section_headers + relsec->sh_info != sec)
5622 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
5626 for (rp = rela; rp < rela + nrelas; ++rp)
5628 relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
5629 sym = aux->symtab + get_reloc_symindex (rp->r_info);
5631 if (! const_strneq (relname, "R_IA64_SEGREL"))
5633 warn (_("Skipping unexpected relocation type %s\n"), relname);
5637 i = rp->r_offset / (3 * eh_addr_size);
5639 switch (rp->r_offset/eh_addr_size % 3)
5642 aux->table[i].start.section = sym->st_shndx;
5643 aux->table[i].start.offset = rp->r_addend + sym->st_value;
5646 aux->table[i].end.section = sym->st_shndx;
5647 aux->table[i].end.offset = rp->r_addend + sym->st_value;
5650 aux->table[i].info.section = sym->st_shndx;
5651 aux->table[i].info.offset = rp->r_addend + sym->st_value;
5661 aux->table_len = size / (3 * eh_addr_size);
5666 ia64_process_unwind (FILE * file)
5668 Elf_Internal_Shdr * sec;
5669 Elf_Internal_Shdr * unwsec = NULL;
5670 Elf_Internal_Shdr * strsec;
5671 unsigned long i, unwcount = 0, unwstart = 0;
5672 struct ia64_unw_aux_info aux;
5674 memset (& aux, 0, sizeof (aux));
5676 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
5678 if (sec->sh_type == SHT_SYMTAB
5679 && sec->sh_link < elf_header.e_shnum)
5681 aux.nsyms = sec->sh_size / sec->sh_entsize;
5682 aux.symtab = GET_ELF_SYMBOLS (file, sec);
5684 strsec = section_headers + sec->sh_link;
5685 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
5688 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
5690 else if (sec->sh_type == SHT_IA_64_UNWIND)
5695 printf (_("\nThere are no unwind sections in this file.\n"));
5697 while (unwcount-- > 0)
5702 for (i = unwstart, sec = section_headers + unwstart;
5703 i < elf_header.e_shnum; ++i, ++sec)
5704 if (sec->sh_type == SHT_IA_64_UNWIND)
5711 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
5713 if ((unwsec->sh_flags & SHF_GROUP) != 0)
5715 /* We need to find which section group it is in. */
5716 struct group_list * g = section_headers_groups [i]->root;
5718 for (; g != NULL; g = g->next)
5720 sec = section_headers + g->section_index;
5722 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
5727 i = elf_header.e_shnum;
5729 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
5731 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
5732 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
5733 suffix = SECTION_NAME (unwsec) + len;
5734 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
5736 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
5737 && streq (SECTION_NAME (sec) + len2, suffix))
5742 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
5743 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
5744 len = sizeof (ELF_STRING_ia64_unwind) - 1;
5745 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
5747 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
5748 suffix = SECTION_NAME (unwsec) + len;
5749 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
5751 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
5752 && streq (SECTION_NAME (sec) + len2, suffix))
5756 if (i == elf_header.e_shnum)
5758 printf (_("\nCould not find unwind info section for "));
5760 if (string_table == NULL)
5761 printf ("%d", unwsec->sh_name);
5763 printf (_("'%s'"), SECTION_NAME (unwsec));
5767 aux.info_size = sec->sh_size;
5768 aux.info_addr = sec->sh_addr;
5769 aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
5773 printf (_("\nUnwind section "));
5775 if (string_table == NULL)
5776 printf ("%d", unwsec->sh_name);
5778 printf (_("'%s'"), SECTION_NAME (unwsec));
5780 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5781 (unsigned long) unwsec->sh_offset,
5782 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
5784 (void) slurp_ia64_unwind_table (file, & aux, unwsec);
5786 if (aux.table_len > 0)
5787 dump_ia64_unwind (& aux);
5790 free ((char *) aux.table);
5792 free ((char *) aux.info);
5801 free ((char *) aux.strtab);
5806 struct hppa_unw_table_entry
5808 struct absaddr start;
5810 unsigned int Cannot_unwind:1; /* 0 */
5811 unsigned int Millicode:1; /* 1 */
5812 unsigned int Millicode_save_sr0:1; /* 2 */
5813 unsigned int Region_description:2; /* 3..4 */
5814 unsigned int reserved1:1; /* 5 */
5815 unsigned int Entry_SR:1; /* 6 */
5816 unsigned int Entry_FR:4; /* number saved */ /* 7..10 */
5817 unsigned int Entry_GR:5; /* number saved */ /* 11..15 */
5818 unsigned int Args_stored:1; /* 16 */
5819 unsigned int Variable_Frame:1; /* 17 */
5820 unsigned int Separate_Package_Body:1; /* 18 */
5821 unsigned int Frame_Extension_Millicode:1; /* 19 */
5822 unsigned int Stack_Overflow_Check:1; /* 20 */
5823 unsigned int Two_Instruction_SP_Increment:1; /* 21 */
5824 unsigned int Ada_Region:1; /* 22 */
5825 unsigned int cxx_info:1; /* 23 */
5826 unsigned int cxx_try_catch:1; /* 24 */
5827 unsigned int sched_entry_seq:1; /* 25 */
5828 unsigned int reserved2:1; /* 26 */
5829 unsigned int Save_SP:1; /* 27 */
5830 unsigned int Save_RP:1; /* 28 */
5831 unsigned int Save_MRP_in_frame:1; /* 29 */
5832 unsigned int extn_ptr_defined:1; /* 30 */
5833 unsigned int Cleanup_defined:1; /* 31 */
5835 unsigned int MPE_XL_interrupt_marker:1; /* 0 */
5836 unsigned int HP_UX_interrupt_marker:1; /* 1 */
5837 unsigned int Large_frame:1; /* 2 */
5838 unsigned int Pseudo_SP_Set:1; /* 3 */
5839 unsigned int reserved4:1; /* 4 */
5840 unsigned int Total_frame_size:27; /* 5..31 */
5843 struct hppa_unw_aux_info
5845 struct hppa_unw_table_entry *table; /* Unwind table. */
5846 unsigned long table_len; /* Length of unwind table. */
5847 bfd_vma seg_base; /* Starting address of segment. */
5848 Elf_Internal_Sym * symtab; /* The symbol table. */
5849 unsigned long nsyms; /* Number of symbols. */
5850 char * strtab; /* The string table. */
5851 unsigned long strtab_size; /* Size of string table. */
5855 dump_hppa_unwind (struct hppa_unw_aux_info * aux)
5857 struct hppa_unw_table_entry * tp;
5859 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
5862 const char * procname;
5864 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
5865 aux->strtab_size, tp->start, &procname,
5868 fputs ("\n<", stdout);
5872 fputs (procname, stdout);
5875 printf ("+%lx", (unsigned long) offset);
5878 fputs (">: [", stdout);
5879 print_vma (tp->start.offset, PREFIX_HEX);
5880 fputc ('-', stdout);
5881 print_vma (tp->end.offset, PREFIX_HEX);
5884 #define PF(_m) if (tp->_m) printf (#_m " ");
5885 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
5888 PF(Millicode_save_sr0);
5889 /* PV(Region_description); */
5895 PF(Separate_Package_Body);
5896 PF(Frame_Extension_Millicode);
5897 PF(Stack_Overflow_Check);
5898 PF(Two_Instruction_SP_Increment);
5902 PF(sched_entry_seq);
5905 PF(Save_MRP_in_frame);
5906 PF(extn_ptr_defined);
5907 PF(Cleanup_defined);
5908 PF(MPE_XL_interrupt_marker);
5909 PF(HP_UX_interrupt_marker);
5912 PV(Total_frame_size);
5921 slurp_hppa_unwind_table (FILE * file,
5922 struct hppa_unw_aux_info * aux,
5923 Elf_Internal_Shdr * sec)
5925 unsigned long size, unw_ent_size, nentries, nrelas, i;
5926 Elf_Internal_Phdr * seg;
5927 struct hppa_unw_table_entry * tep;
5928 Elf_Internal_Shdr * relsec;
5929 Elf_Internal_Rela * rela;
5930 Elf_Internal_Rela * rp;
5931 unsigned char * table;
5933 Elf_Internal_Sym * sym;
5934 const char * relname;
5936 /* First, find the starting address of the segment that includes
5939 if (elf_header.e_phnum)
5941 if (! get_program_headers (file))
5944 for (seg = program_headers;
5945 seg < program_headers + elf_header.e_phnum;
5948 if (seg->p_type != PT_LOAD)
5951 if (sec->sh_addr >= seg->p_vaddr
5952 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
5954 aux->seg_base = seg->p_vaddr;
5960 /* Second, build the unwind table from the contents of the unwind
5962 size = sec->sh_size;
5963 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
5969 nentries = size / unw_ent_size;
5970 size = unw_ent_size * nentries;
5972 tep = aux->table = (struct hppa_unw_table_entry *)
5973 xcmalloc (nentries, sizeof (aux->table[0]));
5975 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
5977 unsigned int tmp1, tmp2;
5979 tep->start.section = SHN_UNDEF;
5980 tep->end.section = SHN_UNDEF;
5982 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
5983 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
5984 tmp1 = byte_get ((unsigned char *) tp + 8, 4);
5985 tmp2 = byte_get ((unsigned char *) tp + 12, 4);
5987 tep->start.offset += aux->seg_base;
5988 tep->end.offset += aux->seg_base;
5990 tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
5991 tep->Millicode = (tmp1 >> 30) & 0x1;
5992 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
5993 tep->Region_description = (tmp1 >> 27) & 0x3;
5994 tep->reserved1 = (tmp1 >> 26) & 0x1;
5995 tep->Entry_SR = (tmp1 >> 25) & 0x1;
5996 tep->Entry_FR = (tmp1 >> 21) & 0xf;
5997 tep->Entry_GR = (tmp1 >> 16) & 0x1f;
5998 tep->Args_stored = (tmp1 >> 15) & 0x1;
5999 tep->Variable_Frame = (tmp1 >> 14) & 0x1;
6000 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
6001 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
6002 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
6003 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
6004 tep->Ada_Region = (tmp1 >> 9) & 0x1;
6005 tep->cxx_info = (tmp1 >> 8) & 0x1;
6006 tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
6007 tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
6008 tep->reserved2 = (tmp1 >> 5) & 0x1;
6009 tep->Save_SP = (tmp1 >> 4) & 0x1;
6010 tep->Save_RP = (tmp1 >> 3) & 0x1;
6011 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
6012 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
6013 tep->Cleanup_defined = tmp1 & 0x1;
6015 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
6016 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
6017 tep->Large_frame = (tmp2 >> 29) & 0x1;
6018 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
6019 tep->reserved4 = (tmp2 >> 27) & 0x1;
6020 tep->Total_frame_size = tmp2 & 0x7ffffff;
6024 /* Third, apply any relocations to the unwind table. */
6025 for (relsec = section_headers;
6026 relsec < section_headers + elf_header.e_shnum;
6029 if (relsec->sh_type != SHT_RELA
6030 || relsec->sh_info >= elf_header.e_shnum
6031 || section_headers + relsec->sh_info != sec)
6034 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
6038 for (rp = rela; rp < rela + nrelas; ++rp)
6040 relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
6041 sym = aux->symtab + get_reloc_symindex (rp->r_info);
6043 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
6044 if (! const_strneq (relname, "R_PARISC_SEGREL"))
6046 warn (_("Skipping unexpected relocation type %s\n"), relname);
6050 i = rp->r_offset / unw_ent_size;
6052 switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
6055 aux->table[i].start.section = sym->st_shndx;
6056 aux->table[i].start.offset = sym->st_value + rp->r_addend;
6059 aux->table[i].end.section = sym->st_shndx;
6060 aux->table[i].end.offset = sym->st_value + rp->r_addend;
6070 aux->table_len = nentries;
6076 hppa_process_unwind (FILE * file)
6078 struct hppa_unw_aux_info aux;
6079 Elf_Internal_Shdr * unwsec = NULL;
6080 Elf_Internal_Shdr * strsec;
6081 Elf_Internal_Shdr * sec;
6084 memset (& aux, 0, sizeof (aux));
6086 if (string_table == NULL)
6089 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6091 if (sec->sh_type == SHT_SYMTAB
6092 && sec->sh_link < elf_header.e_shnum)
6094 aux.nsyms = sec->sh_size / sec->sh_entsize;
6095 aux.symtab = GET_ELF_SYMBOLS (file, sec);
6097 strsec = section_headers + sec->sh_link;
6098 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
6101 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
6103 else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
6108 printf (_("\nThere are no unwind sections in this file.\n"));
6110 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6112 if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
6114 printf (_("\nUnwind section "));
6115 printf (_("'%s'"), SECTION_NAME (sec));
6117 printf (_(" at offset 0x%lx contains %lu entries:\n"),
6118 (unsigned long) sec->sh_offset,
6119 (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
6121 slurp_hppa_unwind_table (file, &aux, sec);
6122 if (aux.table_len > 0)
6123 dump_hppa_unwind (&aux);
6126 free ((char *) aux.table);
6134 free ((char *) aux.strtab);
6141 unsigned char *data;
6143 Elf_Internal_Shdr *sec;
6144 Elf_Internal_Rela *rela;
6145 unsigned long nrelas;
6146 unsigned int rel_type;
6148 Elf_Internal_Rela *next_rela;
6151 struct arm_unw_aux_info
6155 Elf_Internal_Sym *symtab; /* The symbol table. */
6156 unsigned long nsyms; /* Number of symbols. */
6157 char *strtab; /* The string table. */
6158 unsigned long strtab_size; /* Size of string table. */
6162 arm_print_vma_and_name (struct arm_unw_aux_info *aux,
6163 bfd_vma fn, struct absaddr addr)
6165 const char *procname;
6168 if (addr.section == SHN_UNDEF)
6171 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
6172 aux->strtab_size, addr, &procname,
6175 print_vma (fn, PREFIX_HEX);
6179 fputs (" <", stdout);
6180 fputs (procname, stdout);
6183 printf ("+0x%lx", (unsigned long) sym_offset);
6184 fputc ('>', stdout);
6191 arm_free_section (struct arm_section *arm_sec)
6193 if (arm_sec->data != NULL)
6194 free (arm_sec->data);
6196 if (arm_sec->rela != NULL)
6197 free (arm_sec->rela);
6201 arm_section_get_word (struct arm_unw_aux_info *aux,
6202 struct arm_section *arm_sec,
6203 Elf_Internal_Shdr *sec, bfd_vma word_offset,
6204 unsigned int *wordp, struct absaddr *addr)
6206 Elf_Internal_Rela *rp;
6207 Elf_Internal_Sym *sym;
6208 const char * relname;
6210 bfd_boolean wrapped;
6212 addr->section = SHN_UNDEF;
6215 if (sec != arm_sec->sec)
6217 Elf_Internal_Shdr *relsec;
6219 arm_free_section (arm_sec);
6222 arm_sec->data = get_data (NULL, aux->file, sec->sh_offset, 1,
6223 sec->sh_size, _("unwind data"));
6225 arm_sec->rela = NULL;
6226 arm_sec->nrelas = 0;
6228 for (relsec = section_headers;
6229 relsec < section_headers + elf_header.e_shnum;
6232 if (relsec->sh_info >= elf_header.e_shnum
6233 || section_headers + relsec->sh_info != sec)
6236 if (relsec->sh_type == SHT_REL)
6238 if (!slurp_rel_relocs (aux->file, relsec->sh_offset,
6240 & arm_sec->rela, & arm_sec->nrelas))
6244 else if (relsec->sh_type == SHT_RELA)
6246 if (!slurp_rela_relocs (aux->file, relsec->sh_offset,
6248 & arm_sec->rela, & arm_sec->nrelas))
6254 arm_sec->next_rela = arm_sec->rela;
6257 if (arm_sec->data == NULL)
6260 word = byte_get (arm_sec->data + word_offset, 4);
6263 for (rp = arm_sec->next_rela; rp != arm_sec->rela + arm_sec->nrelas; rp++)
6265 bfd_vma prelval, offset;
6267 if (rp->r_offset > word_offset && !wrapped)
6272 if (rp->r_offset > word_offset)
6275 if (rp->r_offset & 3)
6277 warn (_("Skipping unexpected relocation at offset 0x%lx\n"),
6278 (unsigned long) rp->r_offset);
6282 if (rp->r_offset < word_offset)
6285 relname = elf_arm_reloc_type (ELF32_R_TYPE (rp->r_info));
6287 if (streq (relname, "R_ARM_NONE"))
6290 if (! streq (relname, "R_ARM_PREL31"))
6292 warn (_("Skipping unexpected relocation type %s\n"), relname);
6296 sym = aux->symtab + ELF32_R_SYM (rp->r_info);
6298 if (arm_sec->rel_type == SHT_REL)
6300 offset = word & 0x7fffffff;
6301 if (offset & 0x40000000)
6302 offset |= ~ (bfd_vma) 0x7fffffff;
6305 offset = rp->r_addend;
6307 offset += sym->st_value;
6308 prelval = offset - (arm_sec->sec->sh_addr + rp->r_offset);
6310 word = (word & ~ (bfd_vma) 0x7fffffff) | (prelval & 0x7fffffff);
6311 addr->section = sym->st_shndx;
6312 addr->offset = offset;
6317 arm_sec->next_rela = rp;
6323 decode_arm_unwind (struct arm_unw_aux_info *aux,
6324 unsigned int word, unsigned int remaining,
6325 bfd_vma data_offset, Elf_Internal_Shdr *data_sec,
6326 struct arm_section *data_arm_sec)
6329 unsigned int more_words;
6330 struct absaddr addr;
6333 if (remaining == 0 && more_words) \
6336 if (!arm_section_get_word (aux, data_arm_sec, data_sec, \
6337 data_offset, &word, &addr)) \
6343 #define GET_OP(OP) \
6348 (OP) = word >> 24; \
6353 printf (_("[Truncated opcode]\n")); \
6356 printf ("0x%02x ", OP)
6360 /* Fetch the first word. */
6361 if (!arm_section_get_word (aux, data_arm_sec, data_sec, data_offset,
6367 if ((word & 0x80000000) == 0)
6369 /* Expand prel31 for personality routine. */
6371 const char *procname;
6374 if (fn & 0x40000000)
6375 fn |= ~ (bfd_vma) 0x7fffffff;
6376 fn = fn + data_sec->sh_addr + data_offset;
6378 printf (_(" Personality routine: "));
6379 procname = arm_print_vma_and_name (aux, fn, addr);
6380 fputc ('\n', stdout);
6382 /* The GCC personality routines use the standard compact
6383 encoding, starting with one byte giving the number of
6385 if (procname != NULL
6386 && (const_strneq (procname, "__gcc_personality_v0")
6387 || const_strneq (procname, "__gxx_personality_v0")
6388 || const_strneq (procname, "__gcj_personality_v0")
6389 || const_strneq (procname, "__gnu_objc_personality_v0")))
6396 printf (_(" [Truncated data]\n"));
6399 more_words = word >> 24;
6408 per_index = (word >> 24) & 0x7f;
6409 if (per_index != 0 && per_index != 1 && per_index != 2)
6411 printf (_(" [reserved compact index %d]\n"), per_index);
6415 printf (_(" Compact model %d\n"), per_index);
6424 more_words = (word >> 16) & 0xff;
6430 /* Decode the unwinding instructions. */
6433 unsigned int op, op2;
6442 printf (" 0x%02x ", op);
6444 if ((op & 0xc0) == 0x00)
6446 int offset = ((op & 0x3f) << 2) + 4;
6447 printf (" vsp = vsp + %d", offset);
6449 else if ((op & 0xc0) == 0x40)
6451 int offset = ((op & 0x3f) << 2) + 4;
6452 printf (" vsp = vsp - %d", offset);
6454 else if ((op & 0xf0) == 0x80)
6457 if (op == 0x80 && op2 == 0)
6458 printf (_("Refuse to unwind"));
6461 unsigned int mask = ((op & 0x0f) << 8) | op2;
6466 for (i = 0; i < 12; i++)
6467 if (mask & (1 << i))
6473 printf ("r%d", 4 + i);
6478 else if ((op & 0xf0) == 0x90)
6480 if (op == 0x9d || op == 0x9f)
6481 printf (_(" [Reserved]"));
6483 printf (" vsp = r%d", op & 0x0f);
6485 else if ((op & 0xf0) == 0xa0)
6487 int end = 4 + (op & 0x07);
6491 for (i = 4; i <= end; i++)
6507 else if (op == 0xb0)
6508 printf (_(" finish"));
6509 else if (op == 0xb1)
6512 if (op2 == 0 || (op2 & 0xf0) != 0)
6513 printf (_("[Spare]"));
6516 unsigned int mask = op2 & 0x0f;
6520 for (i = 0; i < 12; i++)
6521 if (mask & (1 << i))
6532 else if (op == 0xb2)
6534 unsigned char buf[9];
6535 unsigned int i, len;
6536 unsigned long offset;
6537 for (i = 0; i < sizeof (buf); i++)
6540 if ((buf[i] & 0x80) == 0)
6543 assert (i < sizeof (buf));
6544 offset = read_uleb128 (buf, &len);
6545 assert (len == i + 1);
6546 offset = offset * 4 + 0x204;
6547 printf ("vsp = vsp + %ld", offset);
6551 if (op == 0xb3 || op == 0xc6 || op == 0xc7 || op == 0xc8 || op == 0xc9)
6554 printf (_("[unsupported two-byte opcode]"));
6558 printf (_(" [unsupported opcode]"));
6564 /* Decode the descriptors. Not implemented. */
6568 dump_arm_unwind (struct arm_unw_aux_info *aux, Elf_Internal_Shdr *exidx_sec)
6570 struct arm_section exidx_arm_sec, extab_arm_sec;
6571 unsigned int i, exidx_len;
6573 memset (&exidx_arm_sec, 0, sizeof (exidx_arm_sec));
6574 memset (&extab_arm_sec, 0, sizeof (extab_arm_sec));
6575 exidx_len = exidx_sec->sh_size / 8;
6577 for (i = 0; i < exidx_len; i++)
6579 unsigned int exidx_fn, exidx_entry;
6580 struct absaddr fn_addr, entry_addr;
6583 fputc ('\n', stdout);
6585 if (!arm_section_get_word (aux, &exidx_arm_sec, exidx_sec,
6586 8 * i, &exidx_fn, &fn_addr)
6587 || !arm_section_get_word (aux, &exidx_arm_sec, exidx_sec,
6588 8 * i + 4, &exidx_entry, &entry_addr))
6590 arm_free_section (&exidx_arm_sec);
6591 arm_free_section (&extab_arm_sec);
6595 fn = exidx_fn & 0x7fffffff;
6596 if (fn & 0x40000000)
6597 fn |= ~ (bfd_vma) 0x7fffffff;
6598 fn = fn + exidx_sec->sh_addr + 8 * i;
6600 arm_print_vma_and_name (aux, fn, entry_addr);
6601 fputs (": ", stdout);
6603 if (exidx_entry == 1)
6605 print_vma (exidx_entry, PREFIX_HEX);
6606 fputs (" [cantunwind]\n", stdout);
6608 else if (exidx_entry & 0x80000000)
6610 print_vma (exidx_entry, PREFIX_HEX);
6611 fputc ('\n', stdout);
6612 decode_arm_unwind (aux, exidx_entry, 4, 0, NULL, NULL);
6616 bfd_vma table, table_offset = 0;
6617 Elf_Internal_Shdr *table_sec;
6619 fputs ("@", stdout);
6620 table = exidx_entry;
6621 if (table & 0x40000000)
6622 table |= ~ (bfd_vma) 0x7fffffff;
6623 table = table + exidx_sec->sh_addr + 8 * i + 4;
6624 print_vma (table, PREFIX_HEX);
6627 /* Locate the matching .ARM.extab. */
6628 if (entry_addr.section != SHN_UNDEF
6629 && entry_addr.section < elf_header.e_shnum)
6631 table_sec = section_headers + entry_addr.section;
6632 table_offset = entry_addr.offset;
6636 table_sec = find_section_by_address (table);
6637 if (table_sec != NULL)
6638 table_offset = table - table_sec->sh_addr;
6640 if (table_sec == NULL)
6642 warn (_("Could not locate .ARM.extab section containing 0x%lx.\n"),
6643 (unsigned long) table);
6646 decode_arm_unwind (aux, 0, 0, table_offset, table_sec,
6653 arm_free_section (&exidx_arm_sec);
6654 arm_free_section (&extab_arm_sec);
6658 arm_process_unwind (FILE *file)
6660 struct arm_unw_aux_info aux;
6661 Elf_Internal_Shdr *unwsec = NULL;
6662 Elf_Internal_Shdr *strsec;
6663 Elf_Internal_Shdr *sec;
6666 memset (& aux, 0, sizeof (aux));
6669 if (string_table == NULL)
6672 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6674 if (sec->sh_type == SHT_SYMTAB && sec->sh_link < elf_header.e_shnum)
6676 aux.nsyms = sec->sh_size / sec->sh_entsize;
6677 aux.symtab = GET_ELF_SYMBOLS (file, sec);
6679 strsec = section_headers + sec->sh_link;
6680 aux.strtab = get_data (NULL, file, strsec->sh_offset,
6681 1, strsec->sh_size, _("string table"));
6682 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
6684 else if (sec->sh_type == SHT_ARM_EXIDX)
6689 printf (_("\nThere are no unwind sections in this file.\n"));
6691 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
6693 if (sec->sh_type == SHT_ARM_EXIDX)
6695 printf (_("\nUnwind table index '%s' at offset 0x%lx contains %lu entries:\n"),
6697 (unsigned long) sec->sh_offset,
6698 (unsigned long) (sec->sh_size / (2 * eh_addr_size)));
6700 dump_arm_unwind (&aux, sec);
6707 free ((char *) aux.strtab);
6713 process_unwind (FILE * file)
6715 struct unwind_handler
6718 int (* handler)(FILE *);
6721 { EM_ARM, arm_process_unwind },
6722 { EM_IA_64, ia64_process_unwind },
6723 { EM_PARISC, hppa_process_unwind },
6731 for (i = 0; handlers[i].handler != NULL; i++)
6732 if (elf_header.e_machine == handlers[i].machtype)
6733 return handlers[i].handler (file);
6735 printf (_("\nThere are no unwind sections in this file.\n"));
6740 dynamic_section_mips_val (Elf_Internal_Dyn * entry)
6742 switch (entry->d_tag)
6745 if (entry->d_un.d_val == 0)
6746 printf (_("NONE\n"));
6749 static const char * opts[] =
6751 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
6752 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
6753 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
6754 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
6760 for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
6761 if (entry->d_un.d_val & (1 << cnt))
6763 printf ("%s%s", first ? "" : " ", opts[cnt]);
6770 case DT_MIPS_IVERSION:
6771 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
6772 printf (_("Interface Version: %s\n"), GET_DYNAMIC_NAME (entry->d_un.d_val));
6774 printf (_("<corrupt: %ld>\n"), (long) entry->d_un.d_ptr);
6777 case DT_MIPS_TIME_STAMP:
6782 time_t atime = entry->d_un.d_val;
6783 tmp = gmtime (&atime);
6784 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
6785 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
6786 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
6787 printf (_("Time Stamp: %s\n"), timebuf);
6791 case DT_MIPS_RLD_VERSION:
6792 case DT_MIPS_LOCAL_GOTNO:
6793 case DT_MIPS_CONFLICTNO:
6794 case DT_MIPS_LIBLISTNO:
6795 case DT_MIPS_SYMTABNO:
6796 case DT_MIPS_UNREFEXTNO:
6797 case DT_MIPS_HIPAGENO:
6798 case DT_MIPS_DELTA_CLASS_NO:
6799 case DT_MIPS_DELTA_INSTANCE_NO:
6800 case DT_MIPS_DELTA_RELOC_NO:
6801 case DT_MIPS_DELTA_SYM_NO:
6802 case DT_MIPS_DELTA_CLASSSYM_NO:
6803 case DT_MIPS_COMPACT_SIZE:
6804 printf ("%ld\n", (long) entry->d_un.d_ptr);
6808 printf ("%#lx\n", (unsigned long) entry->d_un.d_ptr);
6813 dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
6815 switch (entry->d_tag)
6817 case DT_HP_DLD_FLAGS:
6826 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
6827 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
6828 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
6829 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
6830 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
6831 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
6832 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
6833 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
6834 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
6835 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
6836 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
6837 { DT_HP_GST, "HP_GST" },
6838 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
6839 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
6840 { DT_HP_NODELETE, "HP_NODELETE" },
6841 { DT_HP_GROUP, "HP_GROUP" },
6842 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
6846 bfd_vma val = entry->d_un.d_val;
6848 for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
6849 if (val & flags[cnt].bit)
6853 fputs (flags[cnt].str, stdout);
6855 val ^= flags[cnt].bit;
6858 if (val != 0 || first)
6862 print_vma (val, HEX);
6868 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
6876 /* VMS vs Unix time offset and factor. */
6878 #define VMS_EPOCH_OFFSET 35067168000000000LL
6879 #define VMS_GRANULARITY_FACTOR 10000000
6881 /* Display a VMS time in a human readable format. */
6884 print_vms_time (bfd_int64_t vmstime)
6889 unxtime = (vmstime - VMS_EPOCH_OFFSET) / VMS_GRANULARITY_FACTOR;
6890 tm = gmtime (&unxtime);
6891 printf ("%04u-%02u-%02uT%02u:%02u:%02u",
6892 tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday,
6893 tm->tm_hour, tm->tm_min, tm->tm_sec);
6898 dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
6900 switch (entry->d_tag)
6902 case DT_IA_64_PLT_RESERVE:
6903 /* First 3 slots reserved. */
6904 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
6906 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
6909 case DT_IA_64_VMS_LINKTIME:
6911 print_vms_time (entry->d_un.d_val);
6915 case DT_IA_64_VMS_LNKFLAGS:
6916 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
6917 if (entry->d_un.d_val & VMS_LF_CALL_DEBUG)
6918 printf (" CALL_DEBUG");
6919 if (entry->d_un.d_val & VMS_LF_NOP0BUFS)
6920 printf (" NOP0BUFS");
6921 if (entry->d_un.d_val & VMS_LF_P0IMAGE)
6922 printf (" P0IMAGE");
6923 if (entry->d_un.d_val & VMS_LF_MKTHREADS)
6924 printf (" MKTHREADS");
6925 if (entry->d_un.d_val & VMS_LF_UPCALLS)
6926 printf (" UPCALLS");
6927 if (entry->d_un.d_val & VMS_LF_IMGSTA)
6929 if (entry->d_un.d_val & VMS_LF_INITIALIZE)
6930 printf (" INITIALIZE");
6931 if (entry->d_un.d_val & VMS_LF_MAIN)
6933 if (entry->d_un.d_val & VMS_LF_EXE_INIT)
6934 printf (" EXE_INIT");
6935 if (entry->d_un.d_val & VMS_LF_TBK_IN_IMG)
6936 printf (" TBK_IN_IMG");
6937 if (entry->d_un.d_val & VMS_LF_DBG_IN_IMG)
6938 printf (" DBG_IN_IMG");
6939 if (entry->d_un.d_val & VMS_LF_TBK_IN_DSF)
6940 printf (" TBK_IN_DSF");
6941 if (entry->d_un.d_val & VMS_LF_DBG_IN_DSF)
6942 printf (" DBG_IN_DSF");
6943 if (entry->d_un.d_val & VMS_LF_SIGNATURES)
6944 printf (" SIGNATURES");
6945 if (entry->d_un.d_val & VMS_LF_REL_SEG_OFF)
6946 printf (" REL_SEG_OFF");
6950 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
6957 get_32bit_dynamic_section (FILE * file)
6959 Elf32_External_Dyn * edyn;
6960 Elf32_External_Dyn * ext;
6961 Elf_Internal_Dyn * entry;
6963 edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
6964 dynamic_size, _("dynamic section"));
6968 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
6969 might not have the luxury of section headers. Look for the DT_NULL
6970 terminator to determine the number of entries. */
6971 for (ext = edyn, dynamic_nent = 0;
6972 (char *) ext < (char *) edyn + dynamic_size;
6976 if (BYTE_GET (ext->d_tag) == DT_NULL)
6980 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
6982 if (dynamic_section == NULL)
6984 error (_("Out of memory\n"));
6989 for (ext = edyn, entry = dynamic_section;
6990 entry < dynamic_section + dynamic_nent;
6993 entry->d_tag = BYTE_GET (ext->d_tag);
6994 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
7003 get_64bit_dynamic_section (FILE * file)
7005 Elf64_External_Dyn * edyn;
7006 Elf64_External_Dyn * ext;
7007 Elf_Internal_Dyn * entry;
7009 edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
7010 dynamic_size, _("dynamic section"));
7014 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
7015 might not have the luxury of section headers. Look for the DT_NULL
7016 terminator to determine the number of entries. */
7017 for (ext = edyn, dynamic_nent = 0;
7018 (char *) ext < (char *) edyn + dynamic_size;
7022 if (BYTE_GET (ext->d_tag) == DT_NULL)
7026 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
7028 if (dynamic_section == NULL)
7030 error (_("Out of memory\n"));
7035 for (ext = edyn, entry = dynamic_section;
7036 entry < dynamic_section + dynamic_nent;
7039 entry->d_tag = BYTE_GET (ext->d_tag);
7040 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
7049 print_dynamic_flags (bfd_vma flags)
7057 flag = flags & - flags;
7067 case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
7068 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
7069 case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
7070 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
7071 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
7072 default: fputs (_("unknown"), stdout); break;
7078 /* Parse and display the contents of the dynamic section. */
7081 process_dynamic_section (FILE * file)
7083 Elf_Internal_Dyn * entry;
7085 if (dynamic_size == 0)
7088 printf (_("\nThere is no dynamic section in this file.\n"));
7095 if (! get_32bit_dynamic_section (file))
7098 else if (! get_64bit_dynamic_section (file))
7101 /* Find the appropriate symbol table. */
7102 if (dynamic_symbols == NULL)
7104 for (entry = dynamic_section;
7105 entry < dynamic_section + dynamic_nent;
7108 Elf_Internal_Shdr section;
7110 if (entry->d_tag != DT_SYMTAB)
7113 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
7115 /* Since we do not know how big the symbol table is,
7116 we default to reading in the entire file (!) and
7117 processing that. This is overkill, I know, but it
7119 section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
7121 if (archive_file_offset != 0)
7122 section.sh_size = archive_file_size - section.sh_offset;
7125 if (fseek (file, 0, SEEK_END))
7126 error (_("Unable to seek to end of file!\n"));
7128 section.sh_size = ftell (file) - section.sh_offset;
7132 section.sh_entsize = sizeof (Elf32_External_Sym);
7134 section.sh_entsize = sizeof (Elf64_External_Sym);
7136 num_dynamic_syms = section.sh_size / section.sh_entsize;
7137 if (num_dynamic_syms < 1)
7139 error (_("Unable to determine the number of symbols to load\n"));
7143 dynamic_symbols = GET_ELF_SYMBOLS (file, §ion);
7147 /* Similarly find a string table. */
7148 if (dynamic_strings == NULL)
7150 for (entry = dynamic_section;
7151 entry < dynamic_section + dynamic_nent;
7154 unsigned long offset;
7157 if (entry->d_tag != DT_STRTAB)
7160 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
7162 /* Since we do not know how big the string table is,
7163 we default to reading in the entire file (!) and
7164 processing that. This is overkill, I know, but it
7167 offset = offset_from_vma (file, entry->d_un.d_val, 0);
7169 if (archive_file_offset != 0)
7170 str_tab_len = archive_file_size - offset;
7173 if (fseek (file, 0, SEEK_END))
7174 error (_("Unable to seek to end of file\n"));
7175 str_tab_len = ftell (file) - offset;
7178 if (str_tab_len < 1)
7181 (_("Unable to determine the length of the dynamic string table\n"));
7185 dynamic_strings = (char *) get_data (NULL, file, offset, 1,
7187 _("dynamic string table"));
7188 dynamic_strings_length = str_tab_len;
7193 /* And find the syminfo section if available. */
7194 if (dynamic_syminfo == NULL)
7196 unsigned long syminsz = 0;
7198 for (entry = dynamic_section;
7199 entry < dynamic_section + dynamic_nent;
7202 if (entry->d_tag == DT_SYMINENT)
7204 /* Note: these braces are necessary to avoid a syntax
7205 error from the SunOS4 C compiler. */
7206 assert (sizeof (Elf_External_Syminfo) == entry->d_un.d_val);
7208 else if (entry->d_tag == DT_SYMINSZ)
7209 syminsz = entry->d_un.d_val;
7210 else if (entry->d_tag == DT_SYMINFO)
7211 dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
7215 if (dynamic_syminfo_offset != 0 && syminsz != 0)
7217 Elf_External_Syminfo * extsyminfo;
7218 Elf_External_Syminfo * extsym;
7219 Elf_Internal_Syminfo * syminfo;
7221 /* There is a syminfo section. Read the data. */
7222 extsyminfo = (Elf_External_Syminfo *)
7223 get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
7224 _("symbol information"));
7228 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
7229 if (dynamic_syminfo == NULL)
7231 error (_("Out of memory\n"));
7235 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
7236 for (syminfo = dynamic_syminfo, extsym = extsyminfo;
7237 syminfo < dynamic_syminfo + dynamic_syminfo_nent;
7238 ++syminfo, ++extsym)
7240 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
7241 syminfo->si_flags = BYTE_GET (extsym->si_flags);
7248 if (do_dynamic && dynamic_addr)
7249 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
7250 dynamic_addr, dynamic_nent);
7252 printf (_(" Tag Type Name/Value\n"));
7254 for (entry = dynamic_section;
7255 entry < dynamic_section + dynamic_nent;
7263 print_vma (entry->d_tag, FULL_HEX);
7264 dtype = get_dynamic_type (entry->d_tag);
7265 printf (" (%s)%*s", dtype,
7266 ((is_32bit_elf ? 27 : 19)
7267 - (int) strlen (dtype)),
7271 switch (entry->d_tag)
7275 print_dynamic_flags (entry->d_un.d_val);
7285 switch (entry->d_tag)
7288 printf (_("Auxiliary library"));
7292 printf (_("Filter library"));
7296 printf (_("Configuration file"));
7300 printf (_("Dependency audit library"));
7304 printf (_("Audit library"));
7308 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
7309 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
7313 print_vma (entry->d_un.d_val, PREFIX_HEX);
7322 printf (_("Flags:"));
7324 if (entry->d_un.d_val == 0)
7325 printf (_(" None\n"));
7328 unsigned long int val = entry->d_un.d_val;
7330 if (val & DTF_1_PARINIT)
7332 printf (" PARINIT");
7333 val ^= DTF_1_PARINIT;
7335 if (val & DTF_1_CONFEXP)
7337 printf (" CONFEXP");
7338 val ^= DTF_1_CONFEXP;
7341 printf (" %lx", val);
7350 printf (_("Flags:"));
7352 if (entry->d_un.d_val == 0)
7353 printf (_(" None\n"));
7356 unsigned long int val = entry->d_un.d_val;
7358 if (val & DF_P1_LAZYLOAD)
7360 printf (" LAZYLOAD");
7361 val ^= DF_P1_LAZYLOAD;
7363 if (val & DF_P1_GROUPPERM)
7365 printf (" GROUPPERM");
7366 val ^= DF_P1_GROUPPERM;
7369 printf (" %lx", val);
7378 printf (_("Flags:"));
7379 if (entry->d_un.d_val == 0)
7380 printf (_(" None\n"));
7383 unsigned long int val = entry->d_un.d_val;
7390 if (val & DF_1_GLOBAL)
7395 if (val & DF_1_GROUP)
7400 if (val & DF_1_NODELETE)
7402 printf (" NODELETE");
7403 val ^= DF_1_NODELETE;
7405 if (val & DF_1_LOADFLTR)
7407 printf (" LOADFLTR");
7408 val ^= DF_1_LOADFLTR;
7410 if (val & DF_1_INITFIRST)
7412 printf (" INITFIRST");
7413 val ^= DF_1_INITFIRST;
7415 if (val & DF_1_NOOPEN)
7420 if (val & DF_1_ORIGIN)
7425 if (val & DF_1_DIRECT)
7430 if (val & DF_1_TRANS)
7435 if (val & DF_1_INTERPOSE)
7437 printf (" INTERPOSE");
7438 val ^= DF_1_INTERPOSE;
7440 if (val & DF_1_NODEFLIB)
7442 printf (" NODEFLIB");
7443 val ^= DF_1_NODEFLIB;
7445 if (val & DF_1_NODUMP)
7450 if (val & DF_1_CONLFAT)
7452 printf (" CONLFAT");
7453 val ^= DF_1_CONLFAT;
7456 printf (" %lx", val);
7463 dynamic_info[entry->d_tag] = entry->d_un.d_val;
7465 puts (get_dynamic_type (entry->d_un.d_val));
7485 dynamic_info[entry->d_tag] = entry->d_un.d_val;
7491 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
7492 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
7498 switch (entry->d_tag)
7501 printf (_("Shared library: [%s]"), name);
7503 if (streq (name, program_interpreter))
7504 printf (_(" program interpreter"));
7508 printf (_("Library soname: [%s]"), name);
7512 printf (_("Library rpath: [%s]"), name);
7516 printf (_("Library runpath: [%s]"), name);
7520 print_vma (entry->d_un.d_val, PREFIX_HEX);
7525 print_vma (entry->d_un.d_val, PREFIX_HEX);
7538 dynamic_info[entry->d_tag] = entry->d_un.d_val;
7542 case DT_INIT_ARRAYSZ:
7543 case DT_FINI_ARRAYSZ:
7544 case DT_GNU_CONFLICTSZ:
7545 case DT_GNU_LIBLISTSZ:
7548 print_vma (entry->d_un.d_val, UNSIGNED);
7549 printf (_(" (bytes)\n"));
7559 print_vma (entry->d_un.d_val, UNSIGNED);
7572 if (entry->d_tag == DT_USED
7573 && VALID_DYNAMIC_NAME (entry->d_un.d_val))
7575 char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
7579 printf (_("Not needed object: [%s]\n"), name);
7584 print_vma (entry->d_un.d_val, PREFIX_HEX);
7590 /* The value of this entry is ignored. */
7595 case DT_GNU_PRELINKED:
7599 time_t atime = entry->d_un.d_val;
7601 tmp = gmtime (&atime);
7602 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
7603 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
7604 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
7610 dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
7613 print_vma (entry->d_un.d_val, PREFIX_HEX);
7619 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
7620 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
7625 switch (elf_header.e_machine)
7628 case EM_MIPS_RS3_LE:
7629 dynamic_section_mips_val (entry);
7632 dynamic_section_parisc_val (entry);
7635 dynamic_section_ia64_val (entry);
7638 print_vma (entry->d_un.d_val, PREFIX_HEX);
7650 get_ver_flags (unsigned int flags)
7652 static char buff[32];
7659 if (flags & VER_FLG_BASE)
7660 strcat (buff, "BASE ");
7662 if (flags & VER_FLG_WEAK)
7664 if (flags & VER_FLG_BASE)
7665 strcat (buff, "| ");
7667 strcat (buff, "WEAK ");
7670 if (flags & VER_FLG_INFO)
7672 if (flags & (VER_FLG_BASE|VER_FLG_WEAK))
7673 strcat (buff, "| ");
7675 strcat (buff, "INFO ");
7678 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK | VER_FLG_INFO))
7679 strcat (buff, _("| <unknown>"));
7684 /* Display the contents of the version sections. */
7687 process_version_sections (FILE * file)
7689 Elf_Internal_Shdr * section;
7696 for (i = 0, section = section_headers;
7697 i < elf_header.e_shnum;
7700 switch (section->sh_type)
7702 case SHT_GNU_verdef:
7704 Elf_External_Verdef * edefs;
7712 (_("\nVersion definition section '%s' contains %u entries:\n"),
7713 SECTION_NAME (section), section->sh_info);
7715 printf (_(" Addr: 0x"));
7716 printf_vma (section->sh_addr);
7717 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
7718 (unsigned long) section->sh_offset, section->sh_link,
7719 section->sh_link < elf_header.e_shnum
7720 ? SECTION_NAME (section_headers + section->sh_link)
7723 edefs = (Elf_External_Verdef *)
7724 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
7725 _("version definition section"));
7726 endbuf = (char *) edefs + section->sh_size;
7730 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
7733 Elf_External_Verdef * edef;
7734 Elf_Internal_Verdef ent;
7735 Elf_External_Verdaux * eaux;
7736 Elf_Internal_Verdaux aux;
7740 /* Check for negative or very large indicies. */
7741 if ((unsigned char *) edefs + idx < (unsigned char *) edefs)
7744 vstart = ((char *) edefs) + idx;
7745 if (vstart + sizeof (*edef) > endbuf)
7748 edef = (Elf_External_Verdef *) vstart;
7750 ent.vd_version = BYTE_GET (edef->vd_version);
7751 ent.vd_flags = BYTE_GET (edef->vd_flags);
7752 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
7753 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
7754 ent.vd_hash = BYTE_GET (edef->vd_hash);
7755 ent.vd_aux = BYTE_GET (edef->vd_aux);
7756 ent.vd_next = BYTE_GET (edef->vd_next);
7758 printf (_(" %#06x: Rev: %d Flags: %s"),
7759 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
7761 printf (_(" Index: %d Cnt: %d "),
7762 ent.vd_ndx, ent.vd_cnt);
7764 /* Check for overflow. */
7765 if ((unsigned char *)(vstart + ent.vd_aux) < (unsigned char *) vstart
7766 || (unsigned char *)(vstart + ent.vd_aux) > (unsigned char *) endbuf)
7769 vstart += ent.vd_aux;
7771 eaux = (Elf_External_Verdaux *) vstart;
7773 aux.vda_name = BYTE_GET (eaux->vda_name);
7774 aux.vda_next = BYTE_GET (eaux->vda_next);
7776 if (VALID_DYNAMIC_NAME (aux.vda_name))
7777 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
7779 printf (_("Name index: %ld\n"), aux.vda_name);
7781 isum = idx + ent.vd_aux;
7783 for (j = 1; j < ent.vd_cnt; j++)
7785 /* Check for overflow. */
7786 if ((unsigned char *)(vstart + aux.vda_next) < (unsigned char *) vstart
7787 || (unsigned char *)(vstart + aux.vda_next) > (unsigned char *) endbuf)
7790 isum += aux.vda_next;
7791 vstart += aux.vda_next;
7793 eaux = (Elf_External_Verdaux *) vstart;
7794 if (vstart + sizeof (*eaux) > endbuf)
7797 aux.vda_name = BYTE_GET (eaux->vda_name);
7798 aux.vda_next = BYTE_GET (eaux->vda_next);
7800 if (VALID_DYNAMIC_NAME (aux.vda_name))
7801 printf (_(" %#06x: Parent %d: %s\n"),
7802 isum, j, GET_DYNAMIC_NAME (aux.vda_name));
7804 printf (_(" %#06x: Parent %d, name index: %ld\n"),
7805 isum, j, aux.vda_name);
7809 printf (_(" Version def aux past end of section\n"));
7814 if (cnt < section->sh_info)
7815 printf (_(" Version definition past end of section\n"));
7821 case SHT_GNU_verneed:
7823 Elf_External_Verneed * eneed;
7830 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
7831 SECTION_NAME (section), section->sh_info);
7833 printf (_(" Addr: 0x"));
7834 printf_vma (section->sh_addr);
7835 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
7836 (unsigned long) section->sh_offset, section->sh_link,
7837 section->sh_link < elf_header.e_shnum
7838 ? SECTION_NAME (section_headers + section->sh_link)
7841 eneed = (Elf_External_Verneed *) get_data (NULL, file,
7842 section->sh_offset, 1,
7844 _("version need section"));
7845 endbuf = (char *) eneed + section->sh_size;
7849 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
7851 Elf_External_Verneed * entry;
7852 Elf_Internal_Verneed ent;
7857 if ((unsigned char *) eneed + idx < (unsigned char *) eneed)
7860 vstart = ((char *) eneed) + idx;
7861 if (vstart + sizeof (*entry) > endbuf)
7864 entry = (Elf_External_Verneed *) vstart;
7866 ent.vn_version = BYTE_GET (entry->vn_version);
7867 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
7868 ent.vn_file = BYTE_GET (entry->vn_file);
7869 ent.vn_aux = BYTE_GET (entry->vn_aux);
7870 ent.vn_next = BYTE_GET (entry->vn_next);
7872 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
7874 if (VALID_DYNAMIC_NAME (ent.vn_file))
7875 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
7877 printf (_(" File: %lx"), ent.vn_file);
7879 printf (_(" Cnt: %d\n"), ent.vn_cnt);
7881 /* Check for overflow. */
7882 if ((unsigned char *)(vstart + ent.vn_aux) < (unsigned char *) vstart
7883 || (unsigned char *)(vstart + ent.vn_aux) > (unsigned char *) endbuf)
7886 vstart += ent.vn_aux;
7888 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
7890 Elf_External_Vernaux * eaux;
7891 Elf_Internal_Vernaux aux;
7893 if (vstart + sizeof (*eaux) > endbuf)
7895 eaux = (Elf_External_Vernaux *) vstart;
7897 aux.vna_hash = BYTE_GET (eaux->vna_hash);
7898 aux.vna_flags = BYTE_GET (eaux->vna_flags);
7899 aux.vna_other = BYTE_GET (eaux->vna_other);
7900 aux.vna_name = BYTE_GET (eaux->vna_name);
7901 aux.vna_next = BYTE_GET (eaux->vna_next);
7903 if (VALID_DYNAMIC_NAME (aux.vna_name))
7904 printf (_(" %#06x: Name: %s"),
7905 isum, GET_DYNAMIC_NAME (aux.vna_name));
7907 printf (_(" %#06x: Name index: %lx"),
7908 isum, aux.vna_name);
7910 printf (_(" Flags: %s Version: %d\n"),
7911 get_ver_flags (aux.vna_flags), aux.vna_other);
7913 /* Check for overflow. */
7914 if ((unsigned char *)(vstart + aux.vna_next) < (unsigned char *) vstart
7915 || (unsigned char *)(vstart + aux.vna_next) > (unsigned char *) endbuf)
7918 isum += aux.vna_next;
7919 vstart += aux.vna_next;
7922 printf (_(" Version need aux past end of section\n"));
7926 if (cnt < section->sh_info)
7927 printf (_(" Version need past end of section\n"));
7933 case SHT_GNU_versym:
7935 Elf_Internal_Shdr * link_section;
7938 unsigned char * edata;
7939 unsigned short * data;
7941 Elf_Internal_Sym * symbols;
7942 Elf_Internal_Shdr * string_sec;
7945 if (section->sh_link >= elf_header.e_shnum)
7948 link_section = section_headers + section->sh_link;
7949 total = section->sh_size / sizeof (Elf_External_Versym);
7951 if (link_section->sh_link >= elf_header.e_shnum)
7956 symbols = GET_ELF_SYMBOLS (file, link_section);
7957 if (symbols == NULL)
7960 string_sec = section_headers + link_section->sh_link;
7962 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
7963 string_sec->sh_size,
7964 _("version string table"));
7968 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
7969 SECTION_NAME (section), total);
7971 printf (_(" Addr: "));
7972 printf_vma (section->sh_addr);
7973 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
7974 (unsigned long) section->sh_offset, section->sh_link,
7975 SECTION_NAME (link_section));
7977 off = offset_from_vma (file,
7978 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
7979 total * sizeof (short));
7980 edata = (unsigned char *) get_data (NULL, file, off, total,
7982 _("version symbol data"));
7989 data = (short unsigned int *) cmalloc (total, sizeof (short));
7991 for (cnt = total; cnt --;)
7992 data[cnt] = byte_get (edata + cnt * sizeof (short),
7997 for (cnt = 0; cnt < total; cnt += 4)
8000 int check_def, check_need;
8003 printf (" %03x:", cnt);
8005 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
8006 switch (data[cnt + j])
8009 fputs (_(" 0 (*local*) "), stdout);
8013 fputs (_(" 1 (*global*) "), stdout);
8017 nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
8018 data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
8020 /* If this index value is greater than the size of the symbols
8021 array, break to avoid an out-of-bounds read, */
8022 if ((unsigned long)(cnt + j) >=
8023 ((unsigned long)link_section->sh_size /
8024 (unsigned long)link_section->sh_entsize))
8026 warn (_("invalid index into symbol array\n"));
8032 if (symbols[cnt + j].st_shndx >= elf_header.e_shnum
8033 || section_headers[symbols[cnt + j].st_shndx].sh_type
8036 if (symbols[cnt + j].st_shndx == SHN_UNDEF)
8043 && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
8045 Elf_Internal_Verneed ivn;
8046 unsigned long offset;
8048 offset = offset_from_vma
8049 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
8050 sizeof (Elf_External_Verneed));
8054 Elf_Internal_Vernaux ivna;
8055 Elf_External_Verneed evn;
8056 Elf_External_Vernaux evna;
8057 unsigned long a_off;
8059 get_data (&evn, file, offset, sizeof (evn), 1,
8062 ivn.vn_aux = BYTE_GET (evn.vn_aux);
8063 ivn.vn_next = BYTE_GET (evn.vn_next);
8065 a_off = offset + ivn.vn_aux;
8069 get_data (&evna, file, a_off, sizeof (evna),
8070 1, _("version need aux (2)"));
8072 ivna.vna_next = BYTE_GET (evna.vna_next);
8073 ivna.vna_other = BYTE_GET (evna.vna_other);
8075 a_off += ivna.vna_next;
8077 while (ivna.vna_other != data[cnt + j]
8078 && ivna.vna_next != 0);
8080 if (ivna.vna_other == data[cnt + j])
8082 ivna.vna_name = BYTE_GET (evna.vna_name);
8084 if (ivna.vna_name >= string_sec->sh_size)
8085 name = _("*invalid*");
8087 name = strtab + ivna.vna_name;
8088 nn += printf ("(%s%-*s",
8090 12 - (int) strlen (name),
8096 offset += ivn.vn_next;
8098 while (ivn.vn_next);
8101 if (check_def && data[cnt + j] != 0x8001
8102 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
8104 Elf_Internal_Verdef ivd;
8105 Elf_External_Verdef evd;
8106 unsigned long offset;
8108 offset = offset_from_vma
8109 (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
8114 get_data (&evd, file, offset, sizeof (evd), 1,
8117 ivd.vd_next = BYTE_GET (evd.vd_next);
8118 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
8120 offset += ivd.vd_next;
8122 while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
8123 && ivd.vd_next != 0);
8125 if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
8127 Elf_External_Verdaux evda;
8128 Elf_Internal_Verdaux ivda;
8130 ivd.vd_aux = BYTE_GET (evd.vd_aux);
8132 get_data (&evda, file,
8133 offset - ivd.vd_next + ivd.vd_aux,
8135 _("version def aux"));
8137 ivda.vda_name = BYTE_GET (evda.vda_name);
8139 if (ivda.vda_name >= string_sec->sh_size)
8140 name = _("*invalid*");
8142 name = strtab + ivda.vda_name;
8143 nn += printf ("(%s%-*s",
8145 12 - (int) strlen (name),
8151 printf ("%*c", 18 - nn, ' ');
8169 printf (_("\nNo version information found in this file.\n"));
8175 get_symbol_binding (unsigned int binding)
8177 static char buff[32];
8181 case STB_LOCAL: return "LOCAL";
8182 case STB_GLOBAL: return "GLOBAL";
8183 case STB_WEAK: return "WEAK";
8185 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
8186 snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
8188 else if (binding >= STB_LOOS && binding <= STB_HIOS)
8190 if (binding == STB_GNU_UNIQUE
8191 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_LINUX
8192 /* GNU/Linux is still using the default value 0. */
8193 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
8195 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
8198 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
8204 get_symbol_type (unsigned int type)
8206 static char buff[32];
8210 case STT_NOTYPE: return "NOTYPE";
8211 case STT_OBJECT: return "OBJECT";
8212 case STT_FUNC: return "FUNC";
8213 case STT_SECTION: return "SECTION";
8214 case STT_FILE: return "FILE";
8215 case STT_COMMON: return "COMMON";
8216 case STT_TLS: return "TLS";
8217 case STT_RELC: return "RELC";
8218 case STT_SRELC: return "SRELC";
8220 if (type >= STT_LOPROC && type <= STT_HIPROC)
8222 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
8223 return "THUMB_FUNC";
8225 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
8228 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
8229 return "PARISC_MILLI";
8231 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
8233 else if (type >= STT_LOOS && type <= STT_HIOS)
8235 if (elf_header.e_machine == EM_PARISC)
8237 if (type == STT_HP_OPAQUE)
8239 if (type == STT_HP_STUB)
8243 if (type == STT_GNU_IFUNC
8244 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_LINUX
8245 /* GNU/Linux is still using the default value 0. */
8246 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
8249 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
8252 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
8258 get_symbol_visibility (unsigned int visibility)
8262 case STV_DEFAULT: return "DEFAULT";
8263 case STV_INTERNAL: return "INTERNAL";
8264 case STV_HIDDEN: return "HIDDEN";
8265 case STV_PROTECTED: return "PROTECTED";
8271 get_mips_symbol_other (unsigned int other)
8275 case STO_OPTIONAL: return "OPTIONAL";
8276 case STO_MIPS16: return "MIPS16";
8277 case STO_MIPS_PLT: return "MIPS PLT";
8278 case STO_MIPS_PIC: return "MIPS PIC";
8279 default: return NULL;
8284 get_ia64_symbol_other (unsigned int other)
8288 static char res[32];
8292 /* Function types is for images and .STB files only. */
8293 switch (elf_header.e_type)
8297 switch (VMS_ST_FUNC_TYPE (other))
8299 case VMS_SFT_CODE_ADDR:
8300 strcat (res, " CA");
8302 case VMS_SFT_SYMV_IDX:
8303 strcat (res, " VEC");
8306 strcat (res, " FD");
8308 case VMS_SFT_RESERVE:
8309 strcat (res, " RSV");
8318 switch (VMS_ST_LINKAGE (other))
8320 case VMS_STL_IGNORE:
8321 strcat (res, " IGN");
8323 case VMS_STL_RESERVE:
8324 strcat (res, " RSV");
8327 strcat (res, " STD");
8330 strcat (res, " LNK");
8345 get_symbol_other (unsigned int other)
8347 const char * result = NULL;
8348 static char buff [32];
8353 switch (elf_header.e_machine)
8356 result = get_mips_symbol_other (other);
8359 result = get_ia64_symbol_other (other);
8368 snprintf (buff, sizeof buff, _("<other>: %x"), other);
8373 get_symbol_index_type (unsigned int type)
8375 static char buff[32];
8379 case SHN_UNDEF: return "UND";
8380 case SHN_ABS: return "ABS";
8381 case SHN_COMMON: return "COM";
8383 if (type == SHN_IA_64_ANSI_COMMON
8384 && elf_header.e_machine == EM_IA_64
8385 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
8387 else if ((elf_header.e_machine == EM_X86_64
8388 || elf_header.e_machine == EM_L1OM)
8389 && type == SHN_X86_64_LCOMMON)
8391 else if (type == SHN_MIPS_SCOMMON
8392 && elf_header.e_machine == EM_MIPS)
8394 else if (type == SHN_MIPS_SUNDEFINED
8395 && elf_header.e_machine == EM_MIPS)
8397 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
8398 sprintf (buff, "PRC[0x%04x]", type & 0xffff);
8399 else if (type >= SHN_LOOS && type <= SHN_HIOS)
8400 sprintf (buff, "OS [0x%04x]", type & 0xffff);
8401 else if (type >= SHN_LORESERVE)
8402 sprintf (buff, "RSV[0x%04x]", type & 0xffff);
8404 sprintf (buff, "%3d", type);
8412 get_dynamic_data (FILE * file, unsigned int number, unsigned int ent_size)
8414 unsigned char * e_data;
8417 e_data = (unsigned char *) cmalloc (number, ent_size);
8421 error (_("Out of memory\n"));
8425 if (fread (e_data, ent_size, number, file) != number)
8427 error (_("Unable to read in dynamic data\n"));
8431 i_data = (bfd_vma *) cmalloc (number, sizeof (*i_data));
8435 error (_("Out of memory\n"));
8441 i_data[number] = byte_get (e_data + number * ent_size, ent_size);
8449 print_dynamic_symbol (bfd_vma si, unsigned long hn)
8451 Elf_Internal_Sym * psym;
8454 psym = dynamic_symbols + si;
8456 n = print_vma (si, DEC_5);
8458 fputs (" " + n, stdout);
8459 printf (" %3lu: ", hn);
8460 print_vma (psym->st_value, LONG_HEX);
8462 print_vma (psym->st_size, DEC_5);
8464 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
8465 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
8466 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
8467 /* Check to see if any other bits in the st_other field are set.
8468 Note - displaying this information disrupts the layout of the
8469 table being generated, but for the moment this case is very
8471 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
8472 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
8473 printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
8474 if (VALID_DYNAMIC_NAME (psym->st_name))
8475 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
8477 printf (_(" <corrupt: %14ld>"), psym->st_name);
8481 /* Dump the symbol table. */
8483 process_symbol_table (FILE * file)
8485 Elf_Internal_Shdr * section;
8486 bfd_vma nbuckets = 0;
8487 bfd_vma nchains = 0;
8488 bfd_vma * buckets = NULL;
8489 bfd_vma * chains = NULL;
8490 bfd_vma ngnubuckets = 0;
8491 bfd_vma * gnubuckets = NULL;
8492 bfd_vma * gnuchains = NULL;
8493 bfd_vma gnusymidx = 0;
8495 if (!do_syms && !do_dyn_syms && !do_histogram)
8498 if (dynamic_info[DT_HASH]
8500 || (do_using_dynamic
8502 && dynamic_strings != NULL)))
8504 unsigned char nb[8];
8505 unsigned char nc[8];
8506 int hash_ent_size = 4;
8508 if ((elf_header.e_machine == EM_ALPHA
8509 || elf_header.e_machine == EM_S390
8510 || elf_header.e_machine == EM_S390_OLD)
8511 && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
8515 (archive_file_offset
8516 + offset_from_vma (file, dynamic_info[DT_HASH],
8517 sizeof nb + sizeof nc)),
8520 error (_("Unable to seek to start of dynamic information\n"));
8524 if (fread (nb, hash_ent_size, 1, file) != 1)
8526 error (_("Failed to read in number of buckets\n"));
8530 if (fread (nc, hash_ent_size, 1, file) != 1)
8532 error (_("Failed to read in number of chains\n"));
8536 nbuckets = byte_get (nb, hash_ent_size);
8537 nchains = byte_get (nc, hash_ent_size);
8539 buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
8540 chains = get_dynamic_data (file, nchains, hash_ent_size);
8543 if (buckets == NULL || chains == NULL)
8545 if (do_using_dynamic)
8556 if (dynamic_info_DT_GNU_HASH
8558 || (do_using_dynamic
8560 && dynamic_strings != NULL)))
8562 unsigned char nb[16];
8563 bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
8564 bfd_vma buckets_vma;
8567 (archive_file_offset
8568 + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
8572 error (_("Unable to seek to start of dynamic information\n"));
8576 if (fread (nb, 16, 1, file) != 1)
8578 error (_("Failed to read in number of buckets\n"));
8582 ngnubuckets = byte_get (nb, 4);
8583 gnusymidx = byte_get (nb + 4, 4);
8584 bitmaskwords = byte_get (nb + 8, 4);
8585 buckets_vma = dynamic_info_DT_GNU_HASH + 16;
8587 buckets_vma += bitmaskwords * 4;
8589 buckets_vma += bitmaskwords * 8;
8592 (archive_file_offset
8593 + offset_from_vma (file, buckets_vma, 4)),
8596 error (_("Unable to seek to start of dynamic information\n"));
8600 gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
8602 if (gnubuckets == NULL)
8605 for (i = 0; i < ngnubuckets; i++)
8606 if (gnubuckets[i] != 0)
8608 if (gnubuckets[i] < gnusymidx)
8611 if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
8612 maxchain = gnubuckets[i];
8615 if (maxchain == 0xffffffff)
8618 maxchain -= gnusymidx;
8621 (archive_file_offset
8622 + offset_from_vma (file, buckets_vma
8623 + 4 * (ngnubuckets + maxchain), 4)),
8626 error (_("Unable to seek to start of dynamic information\n"));
8632 if (fread (nb, 4, 1, file) != 1)
8634 error (_("Failed to determine last chain length\n"));
8638 if (maxchain + 1 == 0)
8643 while ((byte_get (nb, 4) & 1) == 0);
8646 (archive_file_offset
8647 + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
8650 error (_("Unable to seek to start of dynamic information\n"));
8654 gnuchains = get_dynamic_data (file, maxchain, 4);
8657 if (gnuchains == NULL)
8662 if (do_using_dynamic)
8667 if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
8670 && dynamic_strings != NULL)
8674 if (dynamic_info[DT_HASH])
8678 printf (_("\nSymbol table for image:\n"));
8680 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
8682 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
8684 for (hn = 0; hn < nbuckets; hn++)
8689 for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
8690 print_dynamic_symbol (si, hn);
8694 if (dynamic_info_DT_GNU_HASH)
8696 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
8698 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
8700 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
8702 for (hn = 0; hn < ngnubuckets; ++hn)
8703 if (gnubuckets[hn] != 0)
8705 bfd_vma si = gnubuckets[hn];
8706 bfd_vma off = si - gnusymidx;
8710 print_dynamic_symbol (si, hn);
8713 while ((gnuchains[off++] & 1) == 0);
8717 else if (do_dyn_syms || (do_syms && !do_using_dynamic))
8721 for (i = 0, section = section_headers;
8722 i < elf_header.e_shnum;
8726 char * strtab = NULL;
8727 unsigned long int strtab_size = 0;
8728 Elf_Internal_Sym * symtab;
8729 Elf_Internal_Sym * psym;
8731 if ((section->sh_type != SHT_SYMTAB
8732 && section->sh_type != SHT_DYNSYM)
8734 && section->sh_type == SHT_SYMTAB))
8737 if (section->sh_entsize == 0)
8739 printf (_("\nSymbol table '%s' has a sh_entsize of zero!\n"),
8740 SECTION_NAME (section));
8744 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
8745 SECTION_NAME (section),
8746 (unsigned long) (section->sh_size / section->sh_entsize));
8749 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
8751 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
8753 symtab = GET_ELF_SYMBOLS (file, section);
8757 if (section->sh_link == elf_header.e_shstrndx)
8759 strtab = string_table;
8760 strtab_size = string_table_length;
8762 else if (section->sh_link < elf_header.e_shnum)
8764 Elf_Internal_Shdr * string_sec;
8766 string_sec = section_headers + section->sh_link;
8768 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
8769 1, string_sec->sh_size,
8771 strtab_size = strtab != NULL ? string_sec->sh_size : 0;
8774 for (si = 0, psym = symtab;
8775 si < section->sh_size / section->sh_entsize;
8778 printf ("%6d: ", si);
8779 print_vma (psym->st_value, LONG_HEX);
8781 print_vma (psym->st_size, DEC_5);
8782 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
8783 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
8784 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
8785 /* Check to see if any other bits in the st_other field are set.
8786 Note - displaying this information disrupts the layout of the
8787 table being generated, but for the moment this case is very rare. */
8788 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
8789 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
8790 printf (" %4s ", get_symbol_index_type (psym->st_shndx));
8791 print_symbol (25, psym->st_name < strtab_size
8792 ? strtab + psym->st_name : _("<corrupt>"));
8794 if (section->sh_type == SHT_DYNSYM &&
8795 version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
8797 unsigned char data[2];
8798 unsigned short vers_data;
8799 unsigned long offset;
8803 offset = offset_from_vma
8804 (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
8805 sizeof data + si * sizeof (vers_data));
8807 get_data (&data, file, offset + si * sizeof (vers_data),
8808 sizeof (data), 1, _("version data"));
8810 vers_data = byte_get (data, 2);
8812 is_nobits = (psym->st_shndx < elf_header.e_shnum
8813 && section_headers[psym->st_shndx].sh_type
8816 check_def = (psym->st_shndx != SHN_UNDEF);
8818 if ((vers_data & VERSYM_HIDDEN) || vers_data > 1)
8820 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
8821 && (is_nobits || ! check_def))
8823 Elf_External_Verneed evn;
8824 Elf_Internal_Verneed ivn;
8825 Elf_Internal_Vernaux ivna;
8827 /* We must test both. */
8828 offset = offset_from_vma
8829 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
8834 unsigned long vna_off;
8836 get_data (&evn, file, offset, sizeof (evn), 1,
8839 ivn.vn_aux = BYTE_GET (evn.vn_aux);
8840 ivn.vn_next = BYTE_GET (evn.vn_next);
8842 vna_off = offset + ivn.vn_aux;
8846 Elf_External_Vernaux evna;
8848 get_data (&evna, file, vna_off,
8850 _("version need aux (3)"));
8852 ivna.vna_other = BYTE_GET (evna.vna_other);
8853 ivna.vna_next = BYTE_GET (evna.vna_next);
8854 ivna.vna_name = BYTE_GET (evna.vna_name);
8856 vna_off += ivna.vna_next;
8858 while (ivna.vna_other != vers_data
8859 && ivna.vna_next != 0);
8861 if (ivna.vna_other == vers_data)
8864 offset += ivn.vn_next;
8866 while (ivn.vn_next != 0);
8868 if (ivna.vna_other == vers_data)
8871 ivna.vna_name < strtab_size
8872 ? strtab + ivna.vna_name : _("<corrupt>"),
8876 else if (! is_nobits)
8877 error (_("bad dynamic symbol\n"));
8884 if (vers_data != 0x8001
8885 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
8887 Elf_Internal_Verdef ivd;
8888 Elf_Internal_Verdaux ivda;
8889 Elf_External_Verdaux evda;
8892 off = offset_from_vma
8894 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
8895 sizeof (Elf_External_Verdef));
8899 Elf_External_Verdef evd;
8901 get_data (&evd, file, off, sizeof (evd),
8902 1, _("version def"));
8904 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
8905 ivd.vd_aux = BYTE_GET (evd.vd_aux);
8906 ivd.vd_next = BYTE_GET (evd.vd_next);
8910 while (ivd.vd_ndx != (vers_data & VERSYM_VERSION)
8911 && ivd.vd_next != 0);
8916 get_data (&evda, file, off, sizeof (evda),
8917 1, _("version def aux"));
8919 ivda.vda_name = BYTE_GET (evda.vda_name);
8921 if (psym->st_name != ivda.vda_name)
8922 printf ((vers_data & VERSYM_HIDDEN)
8924 ivda.vda_name < strtab_size
8925 ? strtab + ivda.vda_name : _("<corrupt>"));
8935 if (strtab != string_table)
8941 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
8943 if (do_histogram && buckets != NULL)
8945 unsigned long * lengths;
8946 unsigned long * counts;
8949 unsigned long maxlength = 0;
8950 unsigned long nzero_counts = 0;
8951 unsigned long nsyms = 0;
8953 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
8954 (unsigned long) nbuckets);
8955 printf (_(" Length Number %% of total Coverage\n"));
8957 lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
8958 if (lengths == NULL)
8960 error (_("Out of memory\n"));
8963 for (hn = 0; hn < nbuckets; ++hn)
8965 for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
8968 if (maxlength < ++lengths[hn])
8973 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
8976 error (_("Out of memory\n"));
8980 for (hn = 0; hn < nbuckets; ++hn)
8981 ++counts[lengths[hn]];
8986 printf (" 0 %-10lu (%5.1f%%)\n",
8987 counts[0], (counts[0] * 100.0) / nbuckets);
8988 for (i = 1; i <= maxlength; ++i)
8990 nzero_counts += counts[i] * i;
8991 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
8992 i, counts[i], (counts[i] * 100.0) / nbuckets,
8993 (nzero_counts * 100.0) / nsyms);
9001 if (buckets != NULL)
9007 if (do_histogram && gnubuckets != NULL)
9009 unsigned long * lengths;
9010 unsigned long * counts;
9012 unsigned long maxlength = 0;
9013 unsigned long nzero_counts = 0;
9014 unsigned long nsyms = 0;
9016 lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
9017 if (lengths == NULL)
9019 error (_("Out of memory\n"));
9023 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
9024 (unsigned long) ngnubuckets);
9025 printf (_(" Length Number %% of total Coverage\n"));
9027 for (hn = 0; hn < ngnubuckets; ++hn)
9028 if (gnubuckets[hn] != 0)
9030 bfd_vma off, length = 1;
9032 for (off = gnubuckets[hn] - gnusymidx;
9033 (gnuchains[off] & 1) == 0; ++off)
9035 lengths[hn] = length;
9036 if (length > maxlength)
9041 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
9044 error (_("Out of memory\n"));
9048 for (hn = 0; hn < ngnubuckets; ++hn)
9049 ++counts[lengths[hn]];
9051 if (ngnubuckets > 0)
9054 printf (" 0 %-10lu (%5.1f%%)\n",
9055 counts[0], (counts[0] * 100.0) / ngnubuckets);
9056 for (j = 1; j <= maxlength; ++j)
9058 nzero_counts += counts[j] * j;
9059 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
9060 j, counts[j], (counts[j] * 100.0) / ngnubuckets,
9061 (nzero_counts * 100.0) / nsyms);
9075 process_syminfo (FILE * file ATTRIBUTE_UNUSED)
9079 if (dynamic_syminfo == NULL
9081 /* No syminfo, this is ok. */
9084 /* There better should be a dynamic symbol section. */
9085 if (dynamic_symbols == NULL || dynamic_strings == NULL)
9089 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
9090 dynamic_syminfo_offset, dynamic_syminfo_nent);
9092 printf (_(" Num: Name BoundTo Flags\n"));
9093 for (i = 0; i < dynamic_syminfo_nent; ++i)
9095 unsigned short int flags = dynamic_syminfo[i].si_flags;
9097 printf ("%4d: ", i);
9098 if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
9099 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
9101 printf (_("<corrupt: %19ld>"), dynamic_symbols[i].st_name);
9104 switch (dynamic_syminfo[i].si_boundto)
9106 case SYMINFO_BT_SELF:
9107 fputs ("SELF ", stdout);
9109 case SYMINFO_BT_PARENT:
9110 fputs ("PARENT ", stdout);
9113 if (dynamic_syminfo[i].si_boundto > 0
9114 && dynamic_syminfo[i].si_boundto < dynamic_nent
9115 && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
9117 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
9121 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
9125 if (flags & SYMINFO_FLG_DIRECT)
9127 if (flags & SYMINFO_FLG_PASSTHRU)
9128 printf (" PASSTHRU");
9129 if (flags & SYMINFO_FLG_COPY)
9131 if (flags & SYMINFO_FLG_LAZYLOAD)
9132 printf (" LAZYLOAD");
9140 /* Check to see if the given reloc needs to be handled in a target specific
9141 manner. If so then process the reloc and return TRUE otherwise return
9145 target_specific_reloc_handling (Elf_Internal_Rela * reloc,
9146 unsigned char * start,
9147 Elf_Internal_Sym * symtab)
9149 unsigned int reloc_type = get_reloc_type (reloc->r_info);
9151 switch (elf_header.e_machine)
9154 case EM_CYGNUS_MN10300:
9156 static Elf_Internal_Sym * saved_sym = NULL;
9160 case 34: /* R_MN10300_ALIGN */
9162 case 33: /* R_MN10300_SYM_DIFF */
9163 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
9165 case 1: /* R_MN10300_32 */
9166 case 2: /* R_MN10300_16 */
9167 if (saved_sym != NULL)
9171 value = reloc->r_addend
9172 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
9173 - saved_sym->st_value);
9175 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
9182 if (saved_sym != NULL)
9183 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc"));
9193 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
9194 DWARF debug sections. This is a target specific test. Note - we do not
9195 go through the whole including-target-headers-multiple-times route, (as
9196 we have already done with <elf/h8.h>) because this would become very
9197 messy and even then this function would have to contain target specific
9198 information (the names of the relocs instead of their numeric values).
9199 FIXME: This is not the correct way to solve this problem. The proper way
9200 is to have target specific reloc sizing and typing functions created by
9201 the reloc-macros.h header, in the same way that it already creates the
9202 reloc naming functions. */
9205 is_32bit_abs_reloc (unsigned int reloc_type)
9207 switch (elf_header.e_machine)
9211 return reloc_type == 1; /* R_386_32. */
9213 return reloc_type == 1; /* R_68K_32. */
9215 return reloc_type == 1; /* R_860_32. */
9217 return reloc_type == 2; /* R_960_32. */
9219 return reloc_type == 1; /* R_ALPHA_REFLONG. */
9221 return reloc_type == 1; /* R_ARC_32. */
9223 return reloc_type == 2; /* R_ARM_ABS32 */
9226 return reloc_type == 1;
9228 return reloc_type == 0x12; /* R_byte4_data. */
9230 return reloc_type == 3; /* R_CRIS_32. */
9233 return reloc_type == 3; /* R_CR16_NUM32. */
9235 return reloc_type == 15; /* R_CRX_NUM32. */
9237 return reloc_type == 1;
9238 case EM_CYGNUS_D10V:
9240 return reloc_type == 6; /* R_D10V_32. */
9241 case EM_CYGNUS_D30V:
9243 return reloc_type == 12; /* R_D30V_32_NORMAL. */
9245 return reloc_type == 3; /* R_DLX_RELOC_32. */
9246 case EM_CYGNUS_FR30:
9248 return reloc_type == 3; /* R_FR30_32. */
9252 return reloc_type == 1; /* R_H8_DIR32. */
9254 return reloc_type == 0x65; /* R_IA64_SECREL32LSB. */
9257 return reloc_type == 2; /* R_IP2K_32. */
9259 return reloc_type == 2; /* R_IQ2000_32. */
9260 case EM_LATTICEMICO32:
9261 return reloc_type == 3; /* R_LM32_32. */
9264 return reloc_type == 3; /* R_M32C_32. */
9266 return reloc_type == 34; /* R_M32R_32_RELA. */
9268 return reloc_type == 1; /* R_MCORE_ADDR32. */
9270 return reloc_type == 4; /* R_MEP_32. */
9272 return reloc_type == 1; /* R_MICROBLAZE_32. */
9274 return reloc_type == 2; /* R_MIPS_32. */
9276 return reloc_type == 4; /* R_MMIX_32. */
9277 case EM_CYGNUS_MN10200:
9279 return reloc_type == 1; /* R_MN10200_32. */
9280 case EM_CYGNUS_MN10300:
9282 return reloc_type == 1; /* R_MN10300_32. */
9284 return reloc_type == 1; /* R_MOXIE_32. */
9287 return reloc_type == 1; /* R_MSP43_32. */
9289 return reloc_type == 2; /* R_MT_32. */
9290 case EM_ALTERA_NIOS2:
9292 return reloc_type == 1; /* R_NIOS_32. */
9295 return reloc_type == 1; /* R_OR32_32. */
9297 return (reloc_type == 1 /* R_PARISC_DIR32. */
9298 || reloc_type == 41); /* R_PARISC_SECREL32. */
9301 return reloc_type == 1; /* R_PJ_DATA_DIR32. */
9303 return reloc_type == 1; /* R_PPC64_ADDR32. */
9305 return reloc_type == 1; /* R_PPC_ADDR32. */
9307 return reloc_type == 1; /* R_RX_DIR32. */
9309 return reloc_type == 1; /* R_I370_ADDR31. */
9312 return reloc_type == 4; /* R_S390_32. */
9314 return reloc_type == 8; /* R_SCORE_ABS32. */
9316 return reloc_type == 1; /* R_SH_DIR32. */
9317 case EM_SPARC32PLUS:
9320 return reloc_type == 3 /* R_SPARC_32. */
9321 || reloc_type == 23; /* R_SPARC_UA32. */
9323 return reloc_type == 6; /* R_SPU_ADDR32 */
9325 return reloc_type == 1; /* R_C6000_ABS32. */
9326 case EM_CYGNUS_V850:
9328 return reloc_type == 6; /* R_V850_ABS32. */
9330 return reloc_type == 1; /* R_VAX_32. */
9333 return reloc_type == 10; /* R_X86_64_32. */
9336 return reloc_type == 3; /* R_XC16C_ABS_32. */
9338 return reloc_type == 1; /* R_XSTROMY16_32. */
9341 return reloc_type == 1; /* R_XTENSA_32. */
9343 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
9344 elf_header.e_machine);
9349 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9350 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
9353 is_32bit_pcrel_reloc (unsigned int reloc_type)
9355 switch (elf_header.e_machine)
9359 return reloc_type == 2; /* R_386_PC32. */
9361 return reloc_type == 4; /* R_68K_PC32. */
9363 return reloc_type == 10; /* R_ALPHA_SREL32. */
9365 return reloc_type == 3; /* R_ARM_REL32 */
9367 return reloc_type == 2; /* R_MICROBLAZE_32_PCREL. */
9369 return reloc_type == 9; /* R_PARISC_PCREL32. */
9371 return reloc_type == 26; /* R_PPC_REL32. */
9373 return reloc_type == 26; /* R_PPC64_REL32. */
9376 return reloc_type == 5; /* R_390_PC32. */
9378 return reloc_type == 2; /* R_SH_REL32. */
9379 case EM_SPARC32PLUS:
9382 return reloc_type == 6; /* R_SPARC_DISP32. */
9384 return reloc_type == 13; /* R_SPU_REL32. */
9387 return reloc_type == 2; /* R_X86_64_PC32. */
9390 return reloc_type == 14; /* R_XTENSA_32_PCREL. */
9392 /* Do not abort or issue an error message here. Not all targets use
9393 pc-relative 32-bit relocs in their DWARF debug information and we
9394 have already tested for target coverage in is_32bit_abs_reloc. A
9395 more helpful warning message will be generated by apply_relocations
9396 anyway, so just return. */
9401 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9402 a 64-bit absolute RELA relocation used in DWARF debug sections. */
9405 is_64bit_abs_reloc (unsigned int reloc_type)
9407 switch (elf_header.e_machine)
9410 return reloc_type == 2; /* R_ALPHA_REFQUAD. */
9412 return reloc_type == 0x27; /* R_IA64_DIR64LSB. */
9414 return reloc_type == 80; /* R_PARISC_DIR64. */
9416 return reloc_type == 38; /* R_PPC64_ADDR64. */
9417 case EM_SPARC32PLUS:
9420 return reloc_type == 54; /* R_SPARC_UA64. */
9423 return reloc_type == 1; /* R_X86_64_64. */
9426 return reloc_type == 22; /* R_S390_64 */
9428 return reloc_type == 18; /* R_MIPS_64 */
9434 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
9435 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
9438 is_64bit_pcrel_reloc (unsigned int reloc_type)
9440 switch (elf_header.e_machine)
9443 return reloc_type == 11; /* R_ALPHA_SREL64 */
9445 return reloc_type == 0x4f; /* R_IA64_PCREL64LSB */
9447 return reloc_type == 72; /* R_PARISC_PCREL64 */
9449 return reloc_type == 44; /* R_PPC64_REL64 */
9450 case EM_SPARC32PLUS:
9453 return reloc_type == 46; /* R_SPARC_DISP64 */
9456 return reloc_type == 24; /* R_X86_64_PC64 */
9459 return reloc_type == 23; /* R_S390_PC64 */
9465 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9466 a 24-bit absolute RELA relocation used in DWARF debug sections. */
9469 is_24bit_abs_reloc (unsigned int reloc_type)
9471 switch (elf_header.e_machine)
9473 case EM_CYGNUS_MN10200:
9475 return reloc_type == 4; /* R_MN10200_24. */
9481 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
9482 a 16-bit absolute RELA relocation used in DWARF debug sections. */
9485 is_16bit_abs_reloc (unsigned int reloc_type)
9487 switch (elf_header.e_machine)
9491 return reloc_type == 4; /* R_AVR_16. */
9492 case EM_CYGNUS_D10V:
9494 return reloc_type == 3; /* R_D10V_16. */
9498 return reloc_type == R_H8_DIR16;
9501 return reloc_type == 1; /* R_IP2K_16. */
9504 return reloc_type == 1; /* R_M32C_16 */
9507 return reloc_type == 5; /* R_MSP430_16_BYTE. */
9508 case EM_ALTERA_NIOS2:
9510 return reloc_type == 9; /* R_NIOS_16. */
9512 return reloc_type == 2; /* R_C6000_ABS16. */
9515 return reloc_type == 2; /* R_XC16C_ABS_16. */
9521 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
9522 relocation entries (possibly formerly used for SHT_GROUP sections). */
9525 is_none_reloc (unsigned int reloc_type)
9527 switch (elf_header.e_machine)
9529 case EM_68K: /* R_68K_NONE. */
9530 case EM_386: /* R_386_NONE. */
9531 case EM_SPARC32PLUS:
9533 case EM_SPARC: /* R_SPARC_NONE. */
9534 case EM_MIPS: /* R_MIPS_NONE. */
9535 case EM_PARISC: /* R_PARISC_NONE. */
9536 case EM_ALPHA: /* R_ALPHA_NONE. */
9537 case EM_PPC: /* R_PPC_NONE. */
9538 case EM_PPC64: /* R_PPC64_NONE. */
9539 case EM_ARM: /* R_ARM_NONE. */
9540 case EM_IA_64: /* R_IA64_NONE. */
9541 case EM_SH: /* R_SH_NONE. */
9543 case EM_S390: /* R_390_NONE. */
9544 case EM_CRIS: /* R_CRIS_NONE. */
9545 case EM_X86_64: /* R_X86_64_NONE. */
9546 case EM_L1OM: /* R_X86_64_NONE. */
9547 case EM_MN10300: /* R_MN10300_NONE. */
9548 case EM_MOXIE: /* R_MOXIE_NONE. */
9549 case EM_M32R: /* R_M32R_NONE. */
9550 case EM_TI_C6000:/* R_C6000_NONE. */
9552 case EM_C166: /* R_XC16X_NONE. */
9553 return reloc_type == 0;
9556 return (reloc_type == 0 /* R_XTENSA_NONE. */
9557 || reloc_type == 17 /* R_XTENSA_DIFF8. */
9558 || reloc_type == 18 /* R_XTENSA_DIFF16. */
9559 || reloc_type == 19 /* R_XTENSA_DIFF32. */);
9564 /* Apply relocations to a section.
9565 Note: So far support has been added only for those relocations
9566 which can be found in debug sections.
9567 FIXME: Add support for more relocations ? */
9570 apply_relocations (void * file,
9571 Elf_Internal_Shdr * section,
9572 unsigned char * start)
9574 Elf_Internal_Shdr * relsec;
9575 unsigned char * end = start + section->sh_size;
9577 if (elf_header.e_type != ET_REL)
9580 /* Find the reloc section associated with the section. */
9581 for (relsec = section_headers;
9582 relsec < section_headers + elf_header.e_shnum;
9585 bfd_boolean is_rela;
9586 unsigned long num_relocs;
9587 Elf_Internal_Rela * relocs;
9588 Elf_Internal_Rela * rp;
9589 Elf_Internal_Shdr * symsec;
9590 Elf_Internal_Sym * symtab;
9591 Elf_Internal_Sym * sym;
9593 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
9594 || relsec->sh_info >= elf_header.e_shnum
9595 || section_headers + relsec->sh_info != section
9596 || relsec->sh_size == 0
9597 || relsec->sh_link >= elf_header.e_shnum)
9600 is_rela = relsec->sh_type == SHT_RELA;
9604 if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
9605 relsec->sh_size, & relocs, & num_relocs))
9610 if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
9611 relsec->sh_size, & relocs, & num_relocs))
9615 /* SH uses RELA but uses in place value instead of the addend field. */
9616 if (elf_header.e_machine == EM_SH)
9619 symsec = section_headers + relsec->sh_link;
9620 symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec);
9622 for (rp = relocs; rp < relocs + num_relocs; ++rp)
9625 unsigned int reloc_type;
9626 unsigned int reloc_size;
9627 unsigned char * rloc;
9629 reloc_type = get_reloc_type (rp->r_info);
9631 if (target_specific_reloc_handling (rp, start, symtab))
9633 else if (is_none_reloc (reloc_type))
9635 else if (is_32bit_abs_reloc (reloc_type)
9636 || is_32bit_pcrel_reloc (reloc_type))
9638 else if (is_64bit_abs_reloc (reloc_type)
9639 || is_64bit_pcrel_reloc (reloc_type))
9641 else if (is_24bit_abs_reloc (reloc_type))
9643 else if (is_16bit_abs_reloc (reloc_type))
9647 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
9648 reloc_type, SECTION_NAME (section));
9652 rloc = start + rp->r_offset;
9653 if ((rloc + reloc_size) > end)
9655 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
9656 (unsigned long) rp->r_offset,
9657 SECTION_NAME (section));
9661 sym = symtab + get_reloc_symindex (rp->r_info);
9663 /* If the reloc has a symbol associated with it,
9664 make sure that it is of an appropriate type.
9666 Relocations against symbols without type can happen.
9667 Gcc -feliminate-dwarf2-dups may generate symbols
9668 without type for debug info.
9670 Icc generates relocations against function symbols
9671 instead of local labels.
9673 Relocations against object symbols can happen, eg when
9674 referencing a global array. For an example of this see
9675 the _clz.o binary in libgcc.a. */
9677 && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
9679 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
9680 get_symbol_type (ELF_ST_TYPE (sym->st_info)),
9681 (long int)(rp - relocs),
9682 SECTION_NAME (relsec));
9688 addend += rp->r_addend;
9689 /* R_XTENSA_32, R_PJ_DATA_DIR32 and R_D30V_32_NORMAL are
9692 || (elf_header.e_machine == EM_XTENSA
9694 || ((elf_header.e_machine == EM_PJ
9695 || elf_header.e_machine == EM_PJ_OLD)
9697 || ((elf_header.e_machine == EM_D30V
9698 || elf_header.e_machine == EM_CYGNUS_D30V)
9699 && reloc_type == 12))
9700 addend += byte_get (rloc, reloc_size);
9702 if (is_32bit_pcrel_reloc (reloc_type)
9703 || is_64bit_pcrel_reloc (reloc_type))
9705 /* On HPPA, all pc-relative relocations are biased by 8. */
9706 if (elf_header.e_machine == EM_PARISC)
9708 byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
9712 byte_put (rloc, addend + sym->st_value, reloc_size);
9721 #ifdef SUPPORT_DISASSEMBLY
9723 disassemble_section (Elf_Internal_Shdr * section, FILE * file)
9725 printf (_("\nAssembly dump of section %s\n"),
9726 SECTION_NAME (section));
9728 /* XXX -- to be done --- XXX */
9734 /* Reads in the contents of SECTION from FILE, returning a pointer
9735 to a malloc'ed buffer or NULL if something went wrong. */
9738 get_section_contents (Elf_Internal_Shdr * section, FILE * file)
9740 bfd_size_type num_bytes;
9742 num_bytes = section->sh_size;
9744 if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
9746 printf (_("\nSection '%s' has no data to dump.\n"),
9747 SECTION_NAME (section));
9751 return (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
9752 _("section contents"));
9757 dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
9759 Elf_Internal_Shdr * relsec;
9760 bfd_size_type num_bytes;
9764 char * name = SECTION_NAME (section);
9765 bfd_boolean some_strings_shown;
9767 start = get_section_contents (section, file);
9771 printf (_("\nString dump of section '%s':\n"), name);
9773 /* If the section being dumped has relocations against it the user might
9774 be expecting these relocations to have been applied. Check for this
9775 case and issue a warning message in order to avoid confusion.
9776 FIXME: Maybe we ought to have an option that dumps a section with
9778 for (relsec = section_headers;
9779 relsec < section_headers + elf_header.e_shnum;
9782 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
9783 || relsec->sh_info >= elf_header.e_shnum
9784 || section_headers + relsec->sh_info != section
9785 || relsec->sh_size == 0
9786 || relsec->sh_link >= elf_header.e_shnum)
9789 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
9793 num_bytes = section->sh_size;
9795 end = start + num_bytes;
9796 some_strings_shown = FALSE;
9800 while (!ISPRINT (* data))
9807 /* PR 11128: Use two separate invocations in order to work
9808 around bugs in the Solaris 8 implementation of printf. */
9809 printf (" [%6tx] ", data - start);
9810 printf ("%s\n", data);
9812 printf (" [%6Ix] %s\n", (size_t) (data - start), data);
9814 data += strlen (data);
9815 some_strings_shown = TRUE;
9819 if (! some_strings_shown)
9820 printf (_(" No strings found in this section."));
9828 dump_section_as_bytes (Elf_Internal_Shdr * section,
9830 bfd_boolean relocate)
9832 Elf_Internal_Shdr * relsec;
9833 bfd_size_type bytes;
9835 unsigned char * data;
9836 unsigned char * start;
9838 start = (unsigned char *) get_section_contents (section, file);
9842 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
9846 apply_relocations (file, section, start);
9850 /* If the section being dumped has relocations against it the user might
9851 be expecting these relocations to have been applied. Check for this
9852 case and issue a warning message in order to avoid confusion.
9853 FIXME: Maybe we ought to have an option that dumps a section with
9855 for (relsec = section_headers;
9856 relsec < section_headers + elf_header.e_shnum;
9859 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
9860 || relsec->sh_info >= elf_header.e_shnum
9861 || section_headers + relsec->sh_info != section
9862 || relsec->sh_size == 0
9863 || relsec->sh_link >= elf_header.e_shnum)
9866 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
9871 addr = section->sh_addr;
9872 bytes = section->sh_size;
9881 lbytes = (bytes > 16 ? 16 : bytes);
9883 printf (" 0x%8.8lx ", (unsigned long) addr);
9885 for (j = 0; j < 16; j++)
9888 printf ("%2.2x", data[j]);
9896 for (j = 0; j < lbytes; j++)
9899 if (k >= ' ' && k < 0x7f)
9917 /* Uncompresses a section that was compressed using zlib, in place. */
9920 uncompress_section_contents (unsigned char **buffer ATTRIBUTE_UNUSED,
9921 dwarf_size_type *size ATTRIBUTE_UNUSED)
9926 dwarf_size_type compressed_size = *size;
9927 unsigned char * compressed_buffer = *buffer;
9928 dwarf_size_type uncompressed_size;
9929 unsigned char * uncompressed_buffer;
9932 dwarf_size_type header_size = 12;
9934 /* Read the zlib header. In this case, it should be "ZLIB" followed
9935 by the uncompressed section size, 8 bytes in big-endian order. */
9936 if (compressed_size < header_size
9937 || ! streq ((char *) compressed_buffer, "ZLIB"))
9940 uncompressed_size = compressed_buffer[4]; uncompressed_size <<= 8;
9941 uncompressed_size += compressed_buffer[5]; uncompressed_size <<= 8;
9942 uncompressed_size += compressed_buffer[6]; uncompressed_size <<= 8;
9943 uncompressed_size += compressed_buffer[7]; uncompressed_size <<= 8;
9944 uncompressed_size += compressed_buffer[8]; uncompressed_size <<= 8;
9945 uncompressed_size += compressed_buffer[9]; uncompressed_size <<= 8;
9946 uncompressed_size += compressed_buffer[10]; uncompressed_size <<= 8;
9947 uncompressed_size += compressed_buffer[11];
9949 /* It is possible the section consists of several compressed
9950 buffers concatenated together, so we uncompress in a loop. */
9954 strm.avail_in = compressed_size - header_size;
9955 strm.next_in = (Bytef *) compressed_buffer + header_size;
9956 strm.avail_out = uncompressed_size;
9957 uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
9959 rc = inflateInit (& strm);
9960 while (strm.avail_in > 0)
9964 strm.next_out = ((Bytef *) uncompressed_buffer
9965 + (uncompressed_size - strm.avail_out));
9966 rc = inflate (&strm, Z_FINISH);
9967 if (rc != Z_STREAM_END)
9969 rc = inflateReset (& strm);
9971 rc = inflateEnd (& strm);
9973 || strm.avail_out != 0)
9976 free (compressed_buffer);
9977 *buffer = uncompressed_buffer;
9978 *size = uncompressed_size;
9982 free (uncompressed_buffer);
9983 /* Indicate decompression failure. */
9986 #endif /* HAVE_ZLIB_H */
9990 load_specific_debug_section (enum dwarf_section_display_enum debug,
9991 Elf_Internal_Shdr * sec, void * file)
9993 struct dwarf_section * section = &debug_displays [debug].section;
9996 /* If it is already loaded, do nothing. */
9997 if (section->start != NULL)
10000 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
10001 section->address = sec->sh_addr;
10002 section->size = sec->sh_size;
10003 section->start = (unsigned char *) get_data (NULL, (FILE *) file,
10005 sec->sh_size, buf);
10006 if (uncompress_section_contents (§ion->start, §ion->size))
10007 sec->sh_size = section->size;
10009 if (section->start == NULL)
10012 if (debug_displays [debug].relocate)
10013 apply_relocations ((FILE *) file, sec, section->start);
10019 load_debug_section (enum dwarf_section_display_enum debug, void * file)
10021 struct dwarf_section * section = &debug_displays [debug].section;
10022 Elf_Internal_Shdr * sec;
10024 /* Locate the debug section. */
10025 sec = find_section (section->uncompressed_name);
10027 section->name = section->uncompressed_name;
10030 sec = find_section (section->compressed_name);
10032 section->name = section->compressed_name;
10037 return load_specific_debug_section (debug, sec, (FILE *) file);
10041 free_debug_section (enum dwarf_section_display_enum debug)
10043 struct dwarf_section * section = &debug_displays [debug].section;
10045 if (section->start == NULL)
10048 free ((char *) section->start);
10049 section->start = NULL;
10050 section->address = 0;
10055 display_debug_section (Elf_Internal_Shdr * section, FILE * file)
10057 char * name = SECTION_NAME (section);
10058 bfd_size_type length;
10062 length = section->sh_size;
10065 printf (_("\nSection '%s' has no debugging data.\n"), name);
10068 if (section->sh_type == SHT_NOBITS)
10070 /* There is no point in dumping the contents of a debugging section
10071 which has the NOBITS type - the bits in the file will be random.
10072 This can happen when a file containing a .eh_frame section is
10073 stripped with the --only-keep-debug command line option. */
10074 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"), name);
10078 if (const_strneq (name, ".gnu.linkonce.wi."))
10079 name = ".debug_info";
10081 /* See if we know how to display the contents of this section. */
10082 for (i = 0; i < max; i++)
10083 if (streq (debug_displays[i].section.uncompressed_name, name)
10084 || streq (debug_displays[i].section.compressed_name, name))
10086 struct dwarf_section * sec = &debug_displays [i].section;
10087 int secondary = (section != find_section (name));
10090 free_debug_section ((enum dwarf_section_display_enum) i);
10092 if (streq (sec->uncompressed_name, name))
10093 sec->name = sec->uncompressed_name;
10095 sec->name = sec->compressed_name;
10096 if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
10099 result &= debug_displays[i].display (sec, file);
10101 if (secondary || (i != info && i != abbrev))
10102 free_debug_section ((enum dwarf_section_display_enum) i);
10110 printf (_("Unrecognized debug section: %s\n"), name);
10117 /* Set DUMP_SECTS for all sections where dumps were requested
10118 based on section name. */
10121 initialise_dumps_byname (void)
10123 struct dump_list_entry * cur;
10125 for (cur = dump_sects_byname; cur; cur = cur->next)
10130 for (i = 0, any = 0; i < elf_header.e_shnum; i++)
10131 if (streq (SECTION_NAME (section_headers + i), cur->name))
10133 request_dump_bynumber (i, cur->type);
10138 warn (_("Section '%s' was not dumped because it does not exist!\n"),
10144 process_section_contents (FILE * file)
10146 Elf_Internal_Shdr * section;
10152 initialise_dumps_byname ();
10154 for (i = 0, section = section_headers;
10155 i < elf_header.e_shnum && i < num_dump_sects;
10158 #ifdef SUPPORT_DISASSEMBLY
10159 if (dump_sects[i] & DISASS_DUMP)
10160 disassemble_section (section, file);
10162 if (dump_sects[i] & HEX_DUMP)
10163 dump_section_as_bytes (section, file, FALSE);
10165 if (dump_sects[i] & RELOC_DUMP)
10166 dump_section_as_bytes (section, file, TRUE);
10168 if (dump_sects[i] & STRING_DUMP)
10169 dump_section_as_strings (section, file);
10171 if (dump_sects[i] & DEBUG_DUMP)
10172 display_debug_section (section, file);
10175 /* Check to see if the user requested a
10176 dump of a section that does not exist. */
10177 while (i++ < num_dump_sects)
10179 warn (_("Section %d was not dumped because it does not exist!\n"), i);
10183 process_mips_fpe_exception (int mask)
10188 if (mask & OEX_FPU_INEX)
10189 fputs ("INEX", stdout), first = 0;
10190 if (mask & OEX_FPU_UFLO)
10191 printf ("%sUFLO", first ? "" : "|"), first = 0;
10192 if (mask & OEX_FPU_OFLO)
10193 printf ("%sOFLO", first ? "" : "|"), first = 0;
10194 if (mask & OEX_FPU_DIV0)
10195 printf ("%sDIV0", first ? "" : "|"), first = 0;
10196 if (mask & OEX_FPU_INVAL)
10197 printf ("%sINVAL", first ? "" : "|");
10200 fputs ("0", stdout);
10203 /* ARM EABI attributes section. */
10208 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
10210 const char ** table;
10211 } arm_attr_public_tag;
10213 static const char * arm_attr_tag_CPU_arch[] =
10214 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
10215 "v6K", "v7", "v6-M", "v6S-M", "v7E-M"};
10216 static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
10217 static const char * arm_attr_tag_THUMB_ISA_use[] =
10218 {"No", "Thumb-1", "Thumb-2"};
10219 static const char * arm_attr_tag_FP_arch[] =
10220 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16"};
10221 static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
10222 static const char * arm_attr_tag_Advanced_SIMD_arch[] =
10223 {"No", "NEONv1", "NEONv1 with Fused-MAC"};
10224 static const char * arm_attr_tag_PCS_config[] =
10225 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
10226 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
10227 static const char * arm_attr_tag_ABI_PCS_R9_use[] =
10228 {"V6", "SB", "TLS", "Unused"};
10229 static const char * arm_attr_tag_ABI_PCS_RW_data[] =
10230 {"Absolute", "PC-relative", "SB-relative", "None"};
10231 static const char * arm_attr_tag_ABI_PCS_RO_data[] =
10232 {"Absolute", "PC-relative", "None"};
10233 static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
10234 {"None", "direct", "GOT-indirect"};
10235 static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
10236 {"None", "??? 1", "2", "??? 3", "4"};
10237 static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
10238 static const char * arm_attr_tag_ABI_FP_denormal[] =
10239 {"Unused", "Needed", "Sign only"};
10240 static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
10241 static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
10242 static const char * arm_attr_tag_ABI_FP_number_model[] =
10243 {"Unused", "Finite", "RTABI", "IEEE 754"};
10244 static const char * arm_attr_tag_ABI_enum_size[] =
10245 {"Unused", "small", "int", "forced to int"};
10246 static const char * arm_attr_tag_ABI_HardFP_use[] =
10247 {"As Tag_FP_arch", "SP only", "DP only", "SP and DP"};
10248 static const char * arm_attr_tag_ABI_VFP_args[] =
10249 {"AAPCS", "VFP registers", "custom"};
10250 static const char * arm_attr_tag_ABI_WMMX_args[] =
10251 {"AAPCS", "WMMX registers", "custom"};
10252 static const char * arm_attr_tag_ABI_optimization_goals[] =
10253 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
10254 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
10255 static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
10256 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
10257 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
10258 static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
10259 static const char * arm_attr_tag_FP_HP_extension[] =
10260 {"Not Allowed", "Allowed"};
10261 static const char * arm_attr_tag_ABI_FP_16bit_format[] =
10262 {"None", "IEEE 754", "Alternative Format"};
10263 static const char * arm_attr_tag_MPextension_use[] =
10264 {"Not Allowed", "Allowed"};
10265 static const char * arm_attr_tag_DIV_use[] =
10266 {"Allowed in Thumb-ISA, v7-R or v7-M", "Not allowed",
10267 "Allowed in v7-A with integer division extension"};
10268 static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
10269 static const char * arm_attr_tag_Virtualization_use[] =
10270 {"Not Allowed", "TrustZone", "Virtualization Extensions",
10271 "TrustZone and Virtualization Extensions"};
10272 static const char * arm_attr_tag_MPextension_use_legacy[] =
10273 {"Not Allowed", "Allowed"};
10275 #define LOOKUP(id, name) \
10276 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
10277 static arm_attr_public_tag arm_attr_public_tags[] =
10279 {4, "CPU_raw_name", 1, NULL},
10280 {5, "CPU_name", 1, NULL},
10281 LOOKUP(6, CPU_arch),
10282 {7, "CPU_arch_profile", 0, NULL},
10283 LOOKUP(8, ARM_ISA_use),
10284 LOOKUP(9, THUMB_ISA_use),
10285 LOOKUP(10, FP_arch),
10286 LOOKUP(11, WMMX_arch),
10287 LOOKUP(12, Advanced_SIMD_arch),
10288 LOOKUP(13, PCS_config),
10289 LOOKUP(14, ABI_PCS_R9_use),
10290 LOOKUP(15, ABI_PCS_RW_data),
10291 LOOKUP(16, ABI_PCS_RO_data),
10292 LOOKUP(17, ABI_PCS_GOT_use),
10293 LOOKUP(18, ABI_PCS_wchar_t),
10294 LOOKUP(19, ABI_FP_rounding),
10295 LOOKUP(20, ABI_FP_denormal),
10296 LOOKUP(21, ABI_FP_exceptions),
10297 LOOKUP(22, ABI_FP_user_exceptions),
10298 LOOKUP(23, ABI_FP_number_model),
10299 {24, "ABI_align_needed", 0, NULL},
10300 {25, "ABI_align_preserved", 0, NULL},
10301 LOOKUP(26, ABI_enum_size),
10302 LOOKUP(27, ABI_HardFP_use),
10303 LOOKUP(28, ABI_VFP_args),
10304 LOOKUP(29, ABI_WMMX_args),
10305 LOOKUP(30, ABI_optimization_goals),
10306 LOOKUP(31, ABI_FP_optimization_goals),
10307 {32, "compatibility", 0, NULL},
10308 LOOKUP(34, CPU_unaligned_access),
10309 LOOKUP(36, FP_HP_extension),
10310 LOOKUP(38, ABI_FP_16bit_format),
10311 LOOKUP(42, MPextension_use),
10312 LOOKUP(44, DIV_use),
10313 {64, "nodefaults", 0, NULL},
10314 {65, "also_compatible_with", 0, NULL},
10315 LOOKUP(66, T2EE_use),
10316 {67, "conformance", 1, NULL},
10317 LOOKUP(68, Virtualization_use),
10318 LOOKUP(70, MPextension_use_legacy)
10322 static unsigned char *
10323 display_arm_attribute (unsigned char * p)
10328 arm_attr_public_tag * attr;
10332 tag = read_uleb128 (p, &len);
10335 for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
10337 if (arm_attr_public_tags[i].tag == tag)
10339 attr = &arm_attr_public_tags[i];
10346 printf (" Tag_%s: ", attr->name);
10347 switch (attr->type)
10352 case 7: /* Tag_CPU_arch_profile. */
10353 val = read_uleb128 (p, &len);
10357 case 0: printf (_("None\n")); break;
10358 case 'A': printf (_("Application\n")); break;
10359 case 'R': printf (_("Realtime\n")); break;
10360 case 'M': printf (_("Microcontroller\n")); break;
10361 case 'S': printf (_("Application or Realtime\n")); break;
10362 default: printf ("??? (%d)\n", val); break;
10366 case 24: /* Tag_align_needed. */
10367 val = read_uleb128 (p, &len);
10371 case 0: printf (_("None\n")); break;
10372 case 1: printf (_("8-byte\n")); break;
10373 case 2: printf (_("4-byte\n")); break;
10374 case 3: printf ("??? 3\n"); break;
10377 printf (_("8-byte and up to %d-byte extended\n"),
10380 printf ("??? (%d)\n", val);
10385 case 25: /* Tag_align_preserved. */
10386 val = read_uleb128 (p, &len);
10390 case 0: printf (_("None\n")); break;
10391 case 1: printf (_("8-byte, except leaf SP\n")); break;
10392 case 2: printf (_("8-byte\n")); break;
10393 case 3: printf ("??? 3\n"); break;
10396 printf (_("8-byte and up to %d-byte extended\n"),
10399 printf ("??? (%d)\n", val);
10404 case 32: /* Tag_compatibility. */
10405 val = read_uleb128 (p, &len);
10407 printf (_("flag = %d, vendor = %s\n"), val, p);
10408 p += strlen ((char *) p) + 1;
10411 case 64: /* Tag_nodefaults. */
10413 printf (_("True\n"));
10416 case 65: /* Tag_also_compatible_with. */
10417 val = read_uleb128 (p, &len);
10419 if (val == 6 /* Tag_CPU_arch. */)
10421 val = read_uleb128 (p, &len);
10423 if ((unsigned int)val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
10424 printf ("??? (%d)\n", val);
10426 printf ("%s\n", arm_attr_tag_CPU_arch[val]);
10430 while (*(p++) != '\0' /* NUL terminator. */);
10444 assert (attr->type & 0x80);
10445 val = read_uleb128 (p, &len);
10447 type = attr->type & 0x7f;
10449 printf ("??? (%d)\n", val);
10451 printf ("%s\n", attr->table[val]);
10458 type = 1; /* String. */
10460 type = 2; /* uleb128. */
10461 printf (" Tag_unknown_%d: ", tag);
10466 printf ("\"%s\"\n", p);
10467 p += strlen ((char *) p) + 1;
10471 val = read_uleb128 (p, &len);
10473 printf ("%d (0x%x)\n", val, val);
10479 static unsigned char *
10480 display_gnu_attribute (unsigned char * p,
10481 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int))
10488 tag = read_uleb128 (p, &len);
10491 /* Tag_compatibility is the only generic GNU attribute defined at
10495 val = read_uleb128 (p, &len);
10497 printf (_("flag = %d, vendor = %s\n"), val, p);
10498 p += strlen ((char *) p) + 1;
10502 if ((tag & 2) == 0 && display_proc_gnu_attribute)
10503 return display_proc_gnu_attribute (p, tag);
10506 type = 1; /* String. */
10508 type = 2; /* uleb128. */
10509 printf (" Tag_unknown_%d: ", tag);
10513 printf ("\"%s\"\n", p);
10514 p += strlen ((char *) p) + 1;
10518 val = read_uleb128 (p, &len);
10520 printf ("%d (0x%x)\n", val, val);
10526 static unsigned char *
10527 display_power_gnu_attribute (unsigned char * p, int tag)
10533 if (tag == Tag_GNU_Power_ABI_FP)
10535 val = read_uleb128 (p, &len);
10537 printf (" Tag_GNU_Power_ABI_FP: ");
10542 printf (_("Hard or soft float\n"));
10545 printf (_("Hard float\n"));
10548 printf (_("Soft float\n"));
10551 printf (_("Single-precision hard float\n"));
10554 printf ("??? (%d)\n", val);
10560 if (tag == Tag_GNU_Power_ABI_Vector)
10562 val = read_uleb128 (p, &len);
10564 printf (" Tag_GNU_Power_ABI_Vector: ");
10568 printf (_("Any\n"));
10571 printf (_("Generic\n"));
10574 printf ("AltiVec\n");
10580 printf ("??? (%d)\n", val);
10586 if (tag == Tag_GNU_Power_ABI_Struct_Return)
10588 val = read_uleb128 (p, &len);
10590 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
10594 printf (_("Any\n"));
10597 printf ("r3/r4\n");
10600 printf (_("Memory\n"));
10603 printf ("??? (%d)\n", val);
10610 type = 1; /* String. */
10612 type = 2; /* uleb128. */
10613 printf (" Tag_unknown_%d: ", tag);
10617 printf ("\"%s\"\n", p);
10618 p += strlen ((char *) p) + 1;
10622 val = read_uleb128 (p, &len);
10624 printf ("%d (0x%x)\n", val, val);
10630 static unsigned char *
10631 display_mips_gnu_attribute (unsigned char * p, int tag)
10637 if (tag == Tag_GNU_MIPS_ABI_FP)
10639 val = read_uleb128 (p, &len);
10641 printf (" Tag_GNU_MIPS_ABI_FP: ");
10646 printf (_("Hard or soft float\n"));
10649 printf (_("Hard float (double precision)\n"));
10652 printf (_("Hard float (single precision)\n"));
10655 printf (_("Soft float\n"));
10658 printf (_("Hard float (MIPS32r2 64-bit FPU)\n"));
10661 printf ("??? (%d)\n", val);
10668 type = 1; /* String. */
10670 type = 2; /* uleb128. */
10671 printf (" Tag_unknown_%d: ", tag);
10675 printf ("\"%s\"\n", p);
10676 p += strlen ((char *) p) + 1;
10680 val = read_uleb128 (p, &len);
10682 printf ("%d (0x%x)\n", val, val);
10688 static unsigned char *
10689 display_tic6x_attribute (unsigned char * p)
10695 tag = read_uleb128 (p, &len);
10701 val = read_uleb128 (p, &len);
10703 printf (" Tag_ISA: ");
10707 case C6XABI_Tag_ISA_none:
10708 printf (_("None\n"));
10710 case C6XABI_Tag_ISA_C62X:
10713 case C6XABI_Tag_ISA_C67X:
10716 case C6XABI_Tag_ISA_C67XP:
10717 printf ("C67x+\n");
10719 case C6XABI_Tag_ISA_C64X:
10722 case C6XABI_Tag_ISA_C64XP:
10723 printf ("C64x+\n");
10725 case C6XABI_Tag_ISA_C674X:
10726 printf ("C674x\n");
10729 printf ("??? (%d)\n", val);
10734 case Tag_ABI_wchar_t:
10735 val = read_uleb128 (p, &len);
10737 printf (" Tag_ABI_wchar_t: ");
10741 printf (_("Not used\n"));
10744 printf (_("2 bytes\n"));
10747 printf (_("4 bytes\n"));
10750 printf ("??? (%d)\n", val);
10755 case Tag_ABI_stack_align_needed:
10756 val = read_uleb128 (p, &len);
10758 printf (" Tag_ABI_stack_align_needed: ");
10762 printf (_("8-byte\n"));
10765 printf (_("16-byte\n"));
10768 printf ("??? (%d)\n", val);
10773 case Tag_ABI_stack_align_preserved:
10774 val = read_uleb128 (p, &len);
10776 printf (" Tag_ABI_stack_align_preserved: ");
10780 printf (_("8-byte\n"));
10783 printf (_("16-byte\n"));
10786 printf ("??? (%d)\n", val);
10792 val = read_uleb128 (p, &len);
10794 printf (" Tag_ABI_DSBT: ");
10798 printf (_("DSBT addressing not used\n"));
10801 printf (_("DSBT addressing used\n"));
10804 printf ("??? (%d)\n", val);
10810 val = read_uleb128 (p, &len);
10812 printf (" Tag_ABI_PID: ");
10816 printf (_("Data addressing position-dependent\n"));
10819 printf (_("Data addressing position-independent, GOT near DP\n"));
10822 printf (_("Data addressing position-independent, GOT far from DP\n"));
10825 printf ("??? (%d)\n", val);
10831 val = read_uleb128 (p, &len);
10833 printf (" Tag_ABI_PIC: ");
10837 printf (_("Code addressing position-dependent\n"));
10840 printf (_("Code addressing position-independent\n"));
10843 printf ("??? (%d)\n", val);
10848 case Tag_ABI_array_object_alignment:
10849 val = read_uleb128 (p, &len);
10851 printf (" Tag_ABI_array_object_alignment: ");
10855 printf (_("8-byte\n"));
10858 printf (_("4-byte\n"));
10861 printf (_("16-byte\n"));
10864 printf ("??? (%d)\n", val);
10869 case Tag_ABI_array_object_align_expected:
10870 val = read_uleb128 (p, &len);
10872 printf (" Tag_ABI_array_object_align_expected: ");
10876 printf (_("8-byte\n"));
10879 printf (_("4-byte\n"));
10882 printf (_("16-byte\n"));
10885 printf ("??? (%d)\n", val);
10890 case Tag_ABI_compatibility:
10891 val = read_uleb128 (p, &len);
10893 printf (" Tag_ABI_compatibility: ");
10894 printf (_("flag = %d, vendor = %s\n"), val, p);
10895 p += strlen ((char *) p) + 1;
10898 case Tag_ABI_conformance:
10899 printf (" Tag_ABI_conformance: ");
10900 printf ("\"%s\"\n", p);
10901 p += strlen ((char *) p) + 1;
10905 printf (" Tag_unknown_%d: ", tag);
10909 printf ("\"%s\"\n", p);
10910 p += strlen ((char *) p) + 1;
10914 val = read_uleb128 (p, &len);
10916 printf ("%d (0x%x)\n", val, val);
10923 process_attributes (FILE * file,
10924 const char * public_name,
10925 unsigned int proc_type,
10926 unsigned char * (* display_pub_attribute) (unsigned char *),
10927 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int))
10929 Elf_Internal_Shdr * sect;
10930 unsigned char * contents;
10932 unsigned char * end;
10933 bfd_vma section_len;
10937 /* Find the section header so that we get the size. */
10938 for (i = 0, sect = section_headers;
10939 i < elf_header.e_shnum;
10942 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
10945 contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
10946 sect->sh_size, _("attributes"));
10947 if (contents == NULL)
10953 len = sect->sh_size - 1;
10959 bfd_boolean public_section;
10960 bfd_boolean gnu_section;
10962 section_len = byte_get (p, 4);
10965 if (section_len > len)
10967 printf (_("ERROR: Bad section length (%d > %d)\n"),
10968 (int) section_len, (int) len);
10972 len -= section_len;
10973 printf (_("Attribute Section: %s\n"), p);
10975 if (public_name && streq ((char *) p, public_name))
10976 public_section = TRUE;
10978 public_section = FALSE;
10980 if (streq ((char *) p, "gnu"))
10981 gnu_section = TRUE;
10983 gnu_section = FALSE;
10985 namelen = strlen ((char *) p) + 1;
10987 section_len -= namelen + 4;
10989 while (section_len > 0)
10995 size = byte_get (p, 4);
10996 if (size > section_len)
10998 printf (_("ERROR: Bad subsection length (%d > %d)\n"),
10999 (int) size, (int) section_len);
11000 size = section_len;
11003 section_len -= size;
11004 end = p + size - 1;
11010 printf (_("File Attributes\n"));
11013 printf (_("Section Attributes:"));
11016 printf (_("Symbol Attributes:"));
11022 val = read_uleb128 (p, &j);
11026 printf (" %d", val);
11031 printf (_("Unknown tag: %d\n"), tag);
11032 public_section = FALSE;
11036 if (public_section)
11039 p = display_pub_attribute (p);
11041 else if (gnu_section)
11044 p = display_gnu_attribute (p,
11045 display_proc_gnu_attribute);
11049 /* ??? Do something sensible, like dump hex. */
11050 printf (_(" Unknown section contexts\n"));
11057 printf (_("Unknown format '%c'\n"), *p);
11065 process_arm_specific (FILE * file)
11067 return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
11068 display_arm_attribute, NULL);
11072 process_power_specific (FILE * file)
11074 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
11075 display_power_gnu_attribute);
11079 process_tic6x_specific (FILE * file)
11081 return process_attributes (file, "c6xabi", SHT_C6000_ATTRIBUTES,
11082 display_tic6x_attribute, NULL);
11085 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
11086 Print the Address, Access and Initial fields of an entry at VMA ADDR
11087 and return the VMA of the next entry. */
11090 print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
11093 print_vma (addr, LONG_HEX);
11095 if (addr < pltgot + 0xfff0)
11096 printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
11098 printf ("%10s", "");
11101 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
11106 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
11107 print_vma (entry, LONG_HEX);
11109 return addr + (is_32bit_elf ? 4 : 8);
11112 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
11113 PLTGOT. Print the Address and Initial fields of an entry at VMA
11114 ADDR and return the VMA of the next entry. */
11117 print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
11120 print_vma (addr, LONG_HEX);
11123 printf ("%*s", is_32bit_elf ? 8 : 16, _("<unknown>"));
11128 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
11129 print_vma (entry, LONG_HEX);
11131 return addr + (is_32bit_elf ? 4 : 8);
11135 process_mips_specific (FILE * file)
11137 Elf_Internal_Dyn * entry;
11138 size_t liblist_offset = 0;
11139 size_t liblistno = 0;
11140 size_t conflictsno = 0;
11141 size_t options_offset = 0;
11142 size_t conflicts_offset = 0;
11143 size_t pltrelsz = 0;
11145 bfd_vma pltgot = 0;
11146 bfd_vma mips_pltgot = 0;
11147 bfd_vma jmprel = 0;
11148 bfd_vma local_gotno = 0;
11149 bfd_vma gotsym = 0;
11150 bfd_vma symtabno = 0;
11152 process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
11153 display_mips_gnu_attribute);
11155 /* We have a lot of special sections. Thanks SGI! */
11156 if (dynamic_section == NULL)
11157 /* No information available. */
11160 for (entry = dynamic_section; entry->d_tag != DT_NULL; ++entry)
11161 switch (entry->d_tag)
11163 case DT_MIPS_LIBLIST:
11165 = offset_from_vma (file, entry->d_un.d_val,
11166 liblistno * sizeof (Elf32_External_Lib));
11168 case DT_MIPS_LIBLISTNO:
11169 liblistno = entry->d_un.d_val;
11171 case DT_MIPS_OPTIONS:
11172 options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
11174 case DT_MIPS_CONFLICT:
11176 = offset_from_vma (file, entry->d_un.d_val,
11177 conflictsno * sizeof (Elf32_External_Conflict));
11179 case DT_MIPS_CONFLICTNO:
11180 conflictsno = entry->d_un.d_val;
11183 pltgot = entry->d_un.d_ptr;
11185 case DT_MIPS_LOCAL_GOTNO:
11186 local_gotno = entry->d_un.d_val;
11188 case DT_MIPS_GOTSYM:
11189 gotsym = entry->d_un.d_val;
11191 case DT_MIPS_SYMTABNO:
11192 symtabno = entry->d_un.d_val;
11194 case DT_MIPS_PLTGOT:
11195 mips_pltgot = entry->d_un.d_ptr;
11198 pltrel = entry->d_un.d_val;
11201 pltrelsz = entry->d_un.d_val;
11204 jmprel = entry->d_un.d_ptr;
11210 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
11212 Elf32_External_Lib * elib;
11215 elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
11217 sizeof (Elf32_External_Lib),
11221 printf (_("\nSection '.liblist' contains %lu entries:\n"),
11222 (unsigned long) liblistno);
11223 fputs (_(" Library Time Stamp Checksum Version Flags\n"),
11226 for (cnt = 0; cnt < liblistno; ++cnt)
11233 liblist.l_name = BYTE_GET (elib[cnt].l_name);
11234 atime = BYTE_GET (elib[cnt].l_time_stamp);
11235 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
11236 liblist.l_version = BYTE_GET (elib[cnt].l_version);
11237 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
11239 tmp = gmtime (&atime);
11240 snprintf (timebuf, sizeof (timebuf),
11241 "%04u-%02u-%02uT%02u:%02u:%02u",
11242 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
11243 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
11245 printf ("%3lu: ", (unsigned long) cnt);
11246 if (VALID_DYNAMIC_NAME (liblist.l_name))
11247 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
11249 printf (_("<corrupt: %9ld>"), liblist.l_name);
11250 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
11251 liblist.l_version);
11253 if (liblist.l_flags == 0)
11257 static const struct
11264 { " EXACT_MATCH", LL_EXACT_MATCH },
11265 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
11266 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
11267 { " EXPORTS", LL_EXPORTS },
11268 { " DELAY_LOAD", LL_DELAY_LOAD },
11269 { " DELTA", LL_DELTA }
11271 int flags = liblist.l_flags;
11274 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
11275 if ((flags & l_flags_vals[fcnt].bit) != 0)
11277 fputs (l_flags_vals[fcnt].name, stdout);
11278 flags ^= l_flags_vals[fcnt].bit;
11281 printf (" %#x", (unsigned int) flags);
11291 if (options_offset != 0)
11293 Elf_External_Options * eopt;
11294 Elf_Internal_Shdr * sect = section_headers;
11295 Elf_Internal_Options * iopt;
11296 Elf_Internal_Options * option;
11300 /* Find the section header so that we get the size. */
11301 while (sect->sh_type != SHT_MIPS_OPTIONS)
11304 eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
11305 sect->sh_size, _("options"));
11308 iopt = (Elf_Internal_Options *)
11309 cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
11312 error (_("Out of memory\n"));
11319 while (offset < sect->sh_size)
11321 Elf_External_Options * eoption;
11323 eoption = (Elf_External_Options *) ((char *) eopt + offset);
11325 option->kind = BYTE_GET (eoption->kind);
11326 option->size = BYTE_GET (eoption->size);
11327 option->section = BYTE_GET (eoption->section);
11328 option->info = BYTE_GET (eoption->info);
11330 offset += option->size;
11336 printf (_("\nSection '%s' contains %d entries:\n"),
11337 SECTION_NAME (sect), cnt);
11345 switch (option->kind)
11348 /* This shouldn't happen. */
11349 printf (" NULL %d %lx", option->section, option->info);
11352 printf (" REGINFO ");
11353 if (elf_header.e_machine == EM_MIPS)
11356 Elf32_External_RegInfo * ereg;
11357 Elf32_RegInfo reginfo;
11359 ereg = (Elf32_External_RegInfo *) (option + 1);
11360 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
11361 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
11362 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
11363 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
11364 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
11365 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
11367 printf ("GPR %08lx GP 0x%lx\n",
11368 reginfo.ri_gprmask,
11369 (unsigned long) reginfo.ri_gp_value);
11370 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
11371 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
11372 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
11377 Elf64_External_RegInfo * ereg;
11378 Elf64_Internal_RegInfo reginfo;
11380 ereg = (Elf64_External_RegInfo *) (option + 1);
11381 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
11382 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
11383 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
11384 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
11385 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
11386 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
11388 printf ("GPR %08lx GP 0x",
11389 reginfo.ri_gprmask);
11390 printf_vma (reginfo.ri_gp_value);
11393 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
11394 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
11395 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
11399 case ODK_EXCEPTIONS:
11400 fputs (" EXCEPTIONS fpe_min(", stdout);
11401 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
11402 fputs (") fpe_max(", stdout);
11403 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
11404 fputs (")", stdout);
11406 if (option->info & OEX_PAGE0)
11407 fputs (" PAGE0", stdout);
11408 if (option->info & OEX_SMM)
11409 fputs (" SMM", stdout);
11410 if (option->info & OEX_FPDBUG)
11411 fputs (" FPDBUG", stdout);
11412 if (option->info & OEX_DISMISS)
11413 fputs (" DISMISS", stdout);
11416 fputs (" PAD ", stdout);
11417 if (option->info & OPAD_PREFIX)
11418 fputs (" PREFIX", stdout);
11419 if (option->info & OPAD_POSTFIX)
11420 fputs (" POSTFIX", stdout);
11421 if (option->info & OPAD_SYMBOL)
11422 fputs (" SYMBOL", stdout);
11425 fputs (" HWPATCH ", stdout);
11426 if (option->info & OHW_R4KEOP)
11427 fputs (" R4KEOP", stdout);
11428 if (option->info & OHW_R8KPFETCH)
11429 fputs (" R8KPFETCH", stdout);
11430 if (option->info & OHW_R5KEOP)
11431 fputs (" R5KEOP", stdout);
11432 if (option->info & OHW_R5KCVTL)
11433 fputs (" R5KCVTL", stdout);
11436 fputs (" FILL ", stdout);
11437 /* XXX Print content of info word? */
11440 fputs (" TAGS ", stdout);
11441 /* XXX Print content of info word? */
11444 fputs (" HWAND ", stdout);
11445 if (option->info & OHWA0_R4KEOP_CHECKED)
11446 fputs (" R4KEOP_CHECKED", stdout);
11447 if (option->info & OHWA0_R4KEOP_CLEAN)
11448 fputs (" R4KEOP_CLEAN", stdout);
11451 fputs (" HWOR ", stdout);
11452 if (option->info & OHWA0_R4KEOP_CHECKED)
11453 fputs (" R4KEOP_CHECKED", stdout);
11454 if (option->info & OHWA0_R4KEOP_CLEAN)
11455 fputs (" R4KEOP_CLEAN", stdout);
11458 printf (" GP_GROUP %#06lx self-contained %#06lx",
11459 option->info & OGP_GROUP,
11460 (option->info & OGP_SELF) >> 16);
11463 printf (" IDENT %#06lx self-contained %#06lx",
11464 option->info & OGP_GROUP,
11465 (option->info & OGP_SELF) >> 16);
11468 /* This shouldn't happen. */
11469 printf (" %3d ??? %d %lx",
11470 option->kind, option->section, option->info);
11474 len = sizeof (* eopt);
11475 while (len < option->size)
11476 if (((char *) option)[len] >= ' '
11477 && ((char *) option)[len] < 0x7f)
11478 printf ("%c", ((char *) option)[len++]);
11480 printf ("\\%03o", ((char *) option)[len++]);
11482 fputs ("\n", stdout);
11490 if (conflicts_offset != 0 && conflictsno != 0)
11492 Elf32_Conflict * iconf;
11495 if (dynamic_symbols == NULL)
11497 error (_("conflict list found without a dynamic symbol table\n"));
11501 iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
11504 error (_("Out of memory\n"));
11510 Elf32_External_Conflict * econf32;
11512 econf32 = (Elf32_External_Conflict *)
11513 get_data (NULL, file, conflicts_offset, conflictsno,
11514 sizeof (* econf32), _("conflict"));
11518 for (cnt = 0; cnt < conflictsno; ++cnt)
11519 iconf[cnt] = BYTE_GET (econf32[cnt]);
11525 Elf64_External_Conflict * econf64;
11527 econf64 = (Elf64_External_Conflict *)
11528 get_data (NULL, file, conflicts_offset, conflictsno,
11529 sizeof (* econf64), _("conflict"));
11533 for (cnt = 0; cnt < conflictsno; ++cnt)
11534 iconf[cnt] = BYTE_GET (econf64[cnt]);
11539 printf (_("\nSection '.conflict' contains %lu entries:\n"),
11540 (unsigned long) conflictsno);
11541 puts (_(" Num: Index Value Name"));
11543 for (cnt = 0; cnt < conflictsno; ++cnt)
11545 Elf_Internal_Sym * psym = & dynamic_symbols[iconf[cnt]];
11547 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
11548 print_vma (psym->st_value, FULL_HEX);
11550 if (VALID_DYNAMIC_NAME (psym->st_name))
11551 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
11553 printf (_("<corrupt: %14ld>"), psym->st_name);
11560 if (pltgot != 0 && local_gotno != 0)
11562 bfd_vma ent, local_end, global_end;
11564 unsigned char * data;
11568 addr_size = (is_32bit_elf ? 4 : 8);
11569 local_end = pltgot + local_gotno * addr_size;
11570 global_end = local_end + (symtabno - gotsym) * addr_size;
11572 offset = offset_from_vma (file, pltgot, global_end - pltgot);
11573 data = (unsigned char *) get_data (NULL, file, offset,
11574 global_end - pltgot, 1, _("GOT"));
11575 printf (_("\nPrimary GOT:\n"));
11576 printf (_(" Canonical gp value: "));
11577 print_vma (pltgot + 0x7ff0, LONG_HEX);
11580 printf (_(" Reserved entries:\n"));
11581 printf (_(" %*s %10s %*s Purpose\n"),
11582 addr_size * 2, _("Address"), _("Access"),
11583 addr_size * 2, _("Initial"));
11584 ent = print_mips_got_entry (data, pltgot, ent);
11585 printf (_(" Lazy resolver\n"));
11587 && (byte_get (data + ent - pltgot, addr_size)
11588 >> (addr_size * 8 - 1)) != 0)
11590 ent = print_mips_got_entry (data, pltgot, ent);
11591 printf (_(" Module pointer (GNU extension)\n"));
11595 if (ent < local_end)
11597 printf (_(" Local entries:\n"));
11598 printf (" %*s %10s %*s\n",
11599 addr_size * 2, _("Address"), _("Access"),
11600 addr_size * 2, _("Initial"));
11601 while (ent < local_end)
11603 ent = print_mips_got_entry (data, pltgot, ent);
11609 if (gotsym < symtabno)
11613 printf (_(" Global entries:\n"));
11614 printf (" %*s %10s %*s %*s %-7s %3s %s\n",
11615 addr_size * 2, _("Address"), _("Access"),
11616 addr_size * 2, _("Initial"),
11617 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
11618 sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
11619 for (i = gotsym; i < symtabno; i++)
11621 Elf_Internal_Sym * psym;
11623 psym = dynamic_symbols + i;
11624 ent = print_mips_got_entry (data, pltgot, ent);
11626 print_vma (psym->st_value, LONG_HEX);
11627 printf (" %-7s %3s ",
11628 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
11629 get_symbol_index_type (psym->st_shndx));
11630 if (VALID_DYNAMIC_NAME (psym->st_name))
11631 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
11633 printf (_("<corrupt: %14ld>"), psym->st_name);
11643 if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
11646 size_t offset, rel_offset;
11647 unsigned long count, i;
11648 unsigned char * data;
11649 int addr_size, sym_width;
11650 Elf_Internal_Rela * rels;
11652 rel_offset = offset_from_vma (file, jmprel, pltrelsz);
11653 if (pltrel == DT_RELA)
11655 if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
11660 if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
11665 addr_size = (is_32bit_elf ? 4 : 8);
11666 end = mips_pltgot + (2 + count) * addr_size;
11668 offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
11669 data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
11671 printf (_("\nPLT GOT:\n\n"));
11672 printf (_(" Reserved entries:\n"));
11673 printf (_(" %*s %*s Purpose\n"),
11674 addr_size * 2, _("Address"), addr_size * 2, _("Initial"));
11675 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
11676 printf (_(" PLT lazy resolver\n"));
11677 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
11678 printf (_(" Module pointer\n"));
11681 printf (_(" Entries:\n"));
11682 printf (" %*s %*s %*s %-7s %3s %s\n",
11683 addr_size * 2, _("Address"),
11684 addr_size * 2, _("Initial"),
11685 addr_size * 2, _("Sym.Val."), _("Type"), _("Ndx"), _("Name"));
11686 sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
11687 for (i = 0; i < count; i++)
11689 Elf_Internal_Sym * psym;
11691 psym = dynamic_symbols + get_reloc_symindex (rels[i].r_info);
11692 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
11694 print_vma (psym->st_value, LONG_HEX);
11695 printf (" %-7s %3s ",
11696 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
11697 get_symbol_index_type (psym->st_shndx));
11698 if (VALID_DYNAMIC_NAME (psym->st_name))
11699 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
11701 printf (_("<corrupt: %14ld>"), psym->st_name);
11715 process_gnu_liblist (FILE * file)
11717 Elf_Internal_Shdr * section;
11718 Elf_Internal_Shdr * string_sec;
11719 Elf32_External_Lib * elib;
11721 size_t strtab_size;
11728 for (i = 0, section = section_headers;
11729 i < elf_header.e_shnum;
11732 switch (section->sh_type)
11734 case SHT_GNU_LIBLIST:
11735 if (section->sh_link >= elf_header.e_shnum)
11738 elib = (Elf32_External_Lib *)
11739 get_data (NULL, file, section->sh_offset, 1, section->sh_size,
11744 string_sec = section_headers + section->sh_link;
11746 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
11747 string_sec->sh_size,
11748 _("liblist string table"));
11749 strtab_size = string_sec->sh_size;
11752 || section->sh_entsize != sizeof (Elf32_External_Lib))
11758 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
11759 SECTION_NAME (section),
11760 (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
11762 puts (_(" Library Time Stamp Checksum Version Flags"));
11764 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
11772 liblist.l_name = BYTE_GET (elib[cnt].l_name);
11773 atime = BYTE_GET (elib[cnt].l_time_stamp);
11774 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
11775 liblist.l_version = BYTE_GET (elib[cnt].l_version);
11776 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
11778 tmp = gmtime (&atime);
11779 snprintf (timebuf, sizeof (timebuf),
11780 "%04u-%02u-%02uT%02u:%02u:%02u",
11781 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
11782 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
11784 printf ("%3lu: ", (unsigned long) cnt);
11786 printf ("%-20s", liblist.l_name < strtab_size
11787 ? strtab + liblist.l_name : _("<corrupt>"));
11789 printf ("%-20.20s", liblist.l_name < strtab_size
11790 ? strtab + liblist.l_name : _("<corrupt>"));
11791 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
11792 liblist.l_version, liblist.l_flags);
11802 static const char *
11803 get_note_type (unsigned e_type)
11805 static char buff[64];
11807 if (elf_header.e_type == ET_CORE)
11811 return _("NT_AUXV (auxiliary vector)");
11813 return _("NT_PRSTATUS (prstatus structure)");
11815 return _("NT_FPREGSET (floating point registers)");
11817 return _("NT_PRPSINFO (prpsinfo structure)");
11818 case NT_TASKSTRUCT:
11819 return _("NT_TASKSTRUCT (task structure)");
11821 return _("NT_PRXFPREG (user_xfpregs structure)");
11823 return _("NT_PPC_VMX (ppc Altivec registers)");
11825 return _("NT_PPC_VSX (ppc VSX registers)");
11826 case NT_X86_XSTATE:
11827 return _("NT_X86_XSTATE (x86 XSAVE extended state)");
11828 case NT_S390_HIGH_GPRS:
11829 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
11830 case NT_S390_TIMER:
11831 return _("NT_S390_TIMER (s390 timer register)");
11832 case NT_S390_TODCMP:
11833 return _("NT_S390_TODCMP (s390 TOD comparator register)");
11834 case NT_S390_TODPREG:
11835 return _("NT_S390_TODPREG (s390 TOD programmable register)");
11837 return _("NT_S390_CTRS (s390 control registers)");
11838 case NT_S390_PREFIX:
11839 return _("NT_S390_PREFIX (s390 prefix register)");
11841 return _("NT_PSTATUS (pstatus structure)");
11843 return _("NT_FPREGS (floating point registers)");
11845 return _("NT_PSINFO (psinfo structure)");
11847 return _("NT_LWPSTATUS (lwpstatus_t structure)");
11849 return _("NT_LWPSINFO (lwpsinfo_t structure)");
11850 case NT_WIN32PSTATUS:
11851 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
11859 return _("NT_VERSION (version)");
11861 return _("NT_ARCH (architecture)");
11866 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
11870 static const char *
11871 get_gnu_elf_note_type (unsigned e_type)
11873 static char buff[64];
11877 case NT_GNU_ABI_TAG:
11878 return _("NT_GNU_ABI_TAG (ABI version tag)");
11880 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
11881 case NT_GNU_BUILD_ID:
11882 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
11883 case NT_GNU_GOLD_VERSION:
11884 return _("NT_GNU_GOLD_VERSION (gold version)");
11889 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
11893 static const char *
11894 get_netbsd_elfcore_note_type (unsigned e_type)
11896 static char buff[64];
11898 if (e_type == NT_NETBSDCORE_PROCINFO)
11900 /* NetBSD core "procinfo" structure. */
11901 return _("NetBSD procinfo structure");
11904 /* As of Jan 2002 there are no other machine-independent notes
11905 defined for NetBSD core files. If the note type is less
11906 than the start of the machine-dependent note types, we don't
11909 if (e_type < NT_NETBSDCORE_FIRSTMACH)
11911 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
11915 switch (elf_header.e_machine)
11917 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
11918 and PT_GETFPREGS == mach+2. */
11923 case EM_SPARC32PLUS:
11927 case NT_NETBSDCORE_FIRSTMACH + 0:
11928 return _("PT_GETREGS (reg structure)");
11929 case NT_NETBSDCORE_FIRSTMACH + 2:
11930 return _("PT_GETFPREGS (fpreg structure)");
11936 /* On all other arch's, PT_GETREGS == mach+1 and
11937 PT_GETFPREGS == mach+3. */
11941 case NT_NETBSDCORE_FIRSTMACH + 1:
11942 return _("PT_GETREGS (reg structure)");
11943 case NT_NETBSDCORE_FIRSTMACH + 3:
11944 return _("PT_GETFPREGS (fpreg structure)");
11950 snprintf (buff, sizeof (buff), _("PT_FIRSTMACH+%d"),
11951 e_type - NT_NETBSDCORE_FIRSTMACH);
11955 /* Note that by the ELF standard, the name field is already null byte
11956 terminated, and namesz includes the terminating null byte.
11957 I.E. the value of namesz for the name "FSF" is 4.
11959 If the value of namesz is zero, there is no name present. */
11961 process_note (Elf_Internal_Note * pnote)
11963 const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
11966 if (pnote->namesz == 0)
11967 /* If there is no note name, then use the default set of
11968 note type strings. */
11969 nt = get_note_type (pnote->type);
11971 else if (const_strneq (pnote->namedata, "GNU"))
11972 /* GNU-specific object file notes. */
11973 nt = get_gnu_elf_note_type (pnote->type);
11975 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
11976 /* NetBSD-specific core file notes. */
11977 nt = get_netbsd_elfcore_note_type (pnote->type);
11979 else if (strneq (pnote->namedata, "SPU/", 4))
11981 /* SPU-specific core file notes. */
11982 nt = pnote->namedata + 4;
11987 /* Don't recognize this note name; just use the default set of
11988 note type strings. */
11989 nt = get_note_type (pnote->type);
11991 printf (" %s\t\t0x%08lx\t%s\n", name, pnote->descsz, nt);
11997 process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
11999 Elf_External_Note * pnotes;
12000 Elf_External_Note * external;
12006 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
12008 if (pnotes == NULL)
12013 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
12014 (unsigned long) offset, (unsigned long) length);
12015 printf (_(" Owner\t\tData size\tDescription\n"));
12017 while (external < (Elf_External_Note *) ((char *) pnotes + length))
12019 Elf_External_Note * next;
12020 Elf_Internal_Note inote;
12021 char * temp = NULL;
12023 inote.type = BYTE_GET (external->type);
12024 inote.namesz = BYTE_GET (external->namesz);
12025 inote.namedata = external->name;
12026 inote.descsz = BYTE_GET (external->descsz);
12027 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
12028 inote.descpos = offset + (inote.descdata - (char *) pnotes);
12030 next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
12032 if ( ((char *) next > ((char *) pnotes) + length)
12033 || ((char *) next < (char *) pnotes))
12035 warn (_("corrupt note found at offset %lx into core notes\n"),
12036 (unsigned long) ((char *) external - (char *) pnotes));
12037 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
12038 inote.type, inote.namesz, inote.descsz);
12044 /* Prevent out-of-bounds indexing. */
12045 if (inote.namedata + inote.namesz >= (char *) pnotes + length
12046 || inote.namedata + inote.namesz < inote.namedata)
12048 warn (_("corrupt note found at offset %lx into core notes\n"),
12049 (unsigned long) ((char *) external - (char *) pnotes));
12050 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
12051 inote.type, inote.namesz, inote.descsz);
12055 /* Verify that name is null terminated. It appears that at least
12056 one version of Linux (RedHat 6.0) generates corefiles that don't
12057 comply with the ELF spec by failing to include the null byte in
12059 if (inote.namedata[inote.namesz] != '\0')
12061 temp = (char *) malloc (inote.namesz + 1);
12065 error (_("Out of memory\n"));
12070 strncpy (temp, inote.namedata, inote.namesz);
12071 temp[inote.namesz] = 0;
12073 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
12074 inote.namedata = temp;
12077 res &= process_note (& inote);
12092 process_corefile_note_segments (FILE * file)
12094 Elf_Internal_Phdr * segment;
12098 if (! get_program_headers (file))
12101 for (i = 0, segment = program_headers;
12102 i < elf_header.e_phnum;
12105 if (segment->p_type == PT_NOTE)
12106 res &= process_corefile_note_segment (file,
12107 (bfd_vma) segment->p_offset,
12108 (bfd_vma) segment->p_filesz);
12115 process_note_sections (FILE * file)
12117 Elf_Internal_Shdr * section;
12121 for (i = 0, section = section_headers;
12122 i < elf_header.e_shnum;
12124 if (section->sh_type == SHT_NOTE)
12125 res &= process_corefile_note_segment (file,
12126 (bfd_vma) section->sh_offset,
12127 (bfd_vma) section->sh_size);
12133 process_notes (FILE * file)
12135 /* If we have not been asked to display the notes then do nothing. */
12139 if (elf_header.e_type != ET_CORE)
12140 return process_note_sections (file);
12142 /* No program headers means no NOTE segment. */
12143 if (elf_header.e_phnum > 0)
12144 return process_corefile_note_segments (file);
12146 printf (_("No note segments present in the core file.\n"));
12151 process_arch_specific (FILE * file)
12156 switch (elf_header.e_machine)
12159 return process_arm_specific (file);
12161 case EM_MIPS_RS3_LE:
12162 return process_mips_specific (file);
12165 return process_power_specific (file);
12168 return process_tic6x_specific (file);
12177 get_file_header (FILE * file)
12179 /* Read in the identity array. */
12180 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
12183 /* Determine how to read the rest of the header. */
12184 switch (elf_header.e_ident[EI_DATA])
12186 default: /* fall through */
12187 case ELFDATANONE: /* fall through */
12189 byte_get = byte_get_little_endian;
12190 byte_put = byte_put_little_endian;
12193 byte_get = byte_get_big_endian;
12194 byte_put = byte_put_big_endian;
12198 /* For now we only support 32 bit and 64 bit ELF files. */
12199 is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
12201 /* Read in the rest of the header. */
12204 Elf32_External_Ehdr ehdr32;
12206 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
12209 elf_header.e_type = BYTE_GET (ehdr32.e_type);
12210 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
12211 elf_header.e_version = BYTE_GET (ehdr32.e_version);
12212 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
12213 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
12214 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
12215 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
12216 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
12217 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
12218 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
12219 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
12220 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
12221 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
12225 Elf64_External_Ehdr ehdr64;
12227 /* If we have been compiled with sizeof (bfd_vma) == 4, then
12228 we will not be able to cope with the 64bit data found in
12229 64 ELF files. Detect this now and abort before we start
12230 overwriting things. */
12231 if (sizeof (bfd_vma) < 8)
12233 error (_("This instance of readelf has been built without support for a\n\
12234 64 bit data type and so it cannot read 64 bit ELF files.\n"));
12238 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
12241 elf_header.e_type = BYTE_GET (ehdr64.e_type);
12242 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
12243 elf_header.e_version = BYTE_GET (ehdr64.e_version);
12244 elf_header.e_entry = BYTE_GET (ehdr64.e_entry);
12245 elf_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
12246 elf_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
12247 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
12248 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
12249 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
12250 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
12251 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
12252 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
12253 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
12256 if (elf_header.e_shoff)
12258 /* There may be some extensions in the first section header. Don't
12259 bomb if we can't read it. */
12261 get_32bit_section_headers (file, 1);
12263 get_64bit_section_headers (file, 1);
12269 /* Process one ELF object file according to the command line options.
12270 This file may actually be stored in an archive. The file is
12271 positioned at the start of the ELF object. */
12274 process_object (char * file_name, FILE * file)
12278 if (! get_file_header (file))
12280 error (_("%s: Failed to read file header\n"), file_name);
12284 /* Initialise per file variables. */
12285 for (i = ARRAY_SIZE (version_info); i--;)
12286 version_info[i] = 0;
12288 for (i = ARRAY_SIZE (dynamic_info); i--;)
12289 dynamic_info[i] = 0;
12290 dynamic_info_DT_GNU_HASH = 0;
12292 /* Process the file. */
12294 printf (_("\nFile: %s\n"), file_name);
12296 /* Initialise the dump_sects array from the cmdline_dump_sects array.
12297 Note we do this even if cmdline_dump_sects is empty because we
12298 must make sure that the dump_sets array is zeroed out before each
12299 object file is processed. */
12300 if (num_dump_sects > num_cmdline_dump_sects)
12301 memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
12303 if (num_cmdline_dump_sects > 0)
12305 if (num_dump_sects == 0)
12306 /* A sneaky way of allocating the dump_sects array. */
12307 request_dump_bynumber (num_cmdline_dump_sects, 0);
12309 assert (num_dump_sects >= num_cmdline_dump_sects);
12310 memcpy (dump_sects, cmdline_dump_sects,
12311 num_cmdline_dump_sects * sizeof (* dump_sects));
12314 if (! process_file_header ())
12317 if (! process_section_headers (file))
12319 /* Without loaded section headers we cannot process lots of
12321 do_unwind = do_version = do_dump = do_arch = 0;
12323 if (! do_using_dynamic)
12324 do_syms = do_dyn_syms = do_reloc = 0;
12327 if (! process_section_groups (file))
12329 /* Without loaded section groups we cannot process unwind. */
12333 if (process_program_headers (file))
12334 process_dynamic_section (file);
12336 process_relocs (file);
12338 process_unwind (file);
12340 process_symbol_table (file);
12342 process_syminfo (file);
12344 process_version_sections (file);
12346 process_section_contents (file);
12348 process_notes (file);
12350 process_gnu_liblist (file);
12352 process_arch_specific (file);
12354 if (program_headers)
12356 free (program_headers);
12357 program_headers = NULL;
12360 if (section_headers)
12362 free (section_headers);
12363 section_headers = NULL;
12368 free (string_table);
12369 string_table = NULL;
12370 string_table_length = 0;
12373 if (dynamic_strings)
12375 free (dynamic_strings);
12376 dynamic_strings = NULL;
12377 dynamic_strings_length = 0;
12380 if (dynamic_symbols)
12382 free (dynamic_symbols);
12383 dynamic_symbols = NULL;
12384 num_dynamic_syms = 0;
12387 if (dynamic_syminfo)
12389 free (dynamic_syminfo);
12390 dynamic_syminfo = NULL;
12393 if (dynamic_section)
12395 free (dynamic_section);
12396 dynamic_section = NULL;
12399 if (section_headers_groups)
12401 free (section_headers_groups);
12402 section_headers_groups = NULL;
12405 if (section_groups)
12407 struct group_list * g;
12408 struct group_list * next;
12410 for (i = 0; i < group_count; i++)
12412 for (g = section_groups [i].root; g != NULL; g = next)
12419 free (section_groups);
12420 section_groups = NULL;
12423 free_debug_memory ();
12428 /* Process an ELF archive.
12429 On entry the file is positioned just after the ARMAG string. */
12432 process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
12434 struct archive_info arch;
12435 struct archive_info nested_arch;
12441 /* The ARCH structure is used to hold information about this archive. */
12442 arch.file_name = NULL;
12444 arch.index_array = NULL;
12445 arch.sym_table = NULL;
12446 arch.longnames = NULL;
12448 /* The NESTED_ARCH structure is used as a single-item cache of information
12449 about a nested archive (when members of a thin archive reside within
12450 another regular archive file). */
12451 nested_arch.file_name = NULL;
12452 nested_arch.file = NULL;
12453 nested_arch.index_array = NULL;
12454 nested_arch.sym_table = NULL;
12455 nested_arch.longnames = NULL;
12457 if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
12463 if (do_archive_index)
12465 if (arch.sym_table == NULL)
12466 error (_("%s: unable to dump the index as none was found\n"), file_name);
12470 unsigned long current_pos;
12472 printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
12473 file_name, arch.index_num, arch.sym_size);
12474 current_pos = ftell (file);
12476 for (i = l = 0; i < arch.index_num; i++)
12478 if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
12480 char * member_name;
12482 member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
12484 if (member_name != NULL)
12486 char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
12488 if (qualified_name != NULL)
12490 printf (_("Binary %s contains:\n"), qualified_name);
12491 free (qualified_name);
12496 if (l >= arch.sym_size)
12498 error (_("%s: end of the symbol table reached before the end of the index\n"),
12502 printf ("\t%s\n", arch.sym_table + l);
12503 l += strlen (arch.sym_table + l) + 1;
12508 if (l < arch.sym_size)
12509 error (_("%s: symbols remain in the index symbol table, but without corresponding entries in the index table\n"),
12512 if (fseek (file, current_pos, SEEK_SET) != 0)
12514 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
12520 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
12521 && !do_segments && !do_header && !do_dump && !do_version
12522 && !do_histogram && !do_debugging && !do_arch && !do_notes
12523 && !do_section_groups && !do_dyn_syms)
12525 ret = 0; /* Archive index only. */
12536 char * qualified_name;
12538 /* Read the next archive header. */
12539 if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
12541 error (_("%s: failed to seek to next archive header\n"), file_name);
12544 got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
12545 if (got != sizeof arch.arhdr)
12549 error (_("%s: failed to read archive header\n"), file_name);
12553 if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
12555 error (_("%s: did not find a valid archive header\n"), arch.file_name);
12560 arch.next_arhdr_offset += sizeof arch.arhdr;
12562 archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
12563 if (archive_file_size & 01)
12564 ++archive_file_size;
12566 name = get_archive_member_name (&arch, &nested_arch);
12569 error (_("%s: bad archive file name\n"), file_name);
12573 namelen = strlen (name);
12575 qualified_name = make_qualified_name (&arch, &nested_arch, name);
12576 if (qualified_name == NULL)
12578 error (_("%s: bad archive file name\n"), file_name);
12583 if (is_thin_archive && arch.nested_member_origin == 0)
12585 /* This is a proxy for an external member of a thin archive. */
12586 FILE * member_file;
12587 char * member_file_name = adjust_relative_path (file_name, name, namelen);
12588 if (member_file_name == NULL)
12594 member_file = fopen (member_file_name, "rb");
12595 if (member_file == NULL)
12597 error (_("Input file '%s' is not readable.\n"), member_file_name);
12598 free (member_file_name);
12603 archive_file_offset = arch.nested_member_origin;
12605 ret |= process_object (qualified_name, member_file);
12607 fclose (member_file);
12608 free (member_file_name);
12610 else if (is_thin_archive)
12612 /* This is a proxy for a member of a nested archive. */
12613 archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
12615 /* The nested archive file will have been opened and setup by
12616 get_archive_member_name. */
12617 if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
12619 error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
12624 ret |= process_object (qualified_name, nested_arch.file);
12628 archive_file_offset = arch.next_arhdr_offset;
12629 arch.next_arhdr_offset += archive_file_size;
12631 ret |= process_object (qualified_name, file);
12634 if (dump_sects != NULL)
12638 num_dump_sects = 0;
12641 free (qualified_name);
12645 if (nested_arch.file != NULL)
12646 fclose (nested_arch.file);
12647 release_archive (&nested_arch);
12648 release_archive (&arch);
12654 process_file (char * file_name)
12657 struct stat statbuf;
12658 char armag[SARMAG];
12661 if (stat (file_name, &statbuf) < 0)
12663 if (errno == ENOENT)
12664 error (_("'%s': No such file\n"), file_name);
12666 error (_("Could not locate '%s'. System error message: %s\n"),
12667 file_name, strerror (errno));
12671 if (! S_ISREG (statbuf.st_mode))
12673 error (_("'%s' is not an ordinary file\n"), file_name);
12677 file = fopen (file_name, "rb");
12680 error (_("Input file '%s' is not readable.\n"), file_name);
12684 if (fread (armag, SARMAG, 1, file) != 1)
12686 error (_("%s: Failed to read file's magic number\n"), file_name);
12691 if (memcmp (armag, ARMAG, SARMAG) == 0)
12692 ret = process_archive (file_name, file, FALSE);
12693 else if (memcmp (armag, ARMAGT, SARMAG) == 0)
12694 ret = process_archive (file_name, file, TRUE);
12697 if (do_archive_index)
12698 error (_("File %s is not an archive so its index cannot be displayed.\n"),
12702 archive_file_size = archive_file_offset = 0;
12703 ret = process_object (file_name, file);
12711 #ifdef SUPPORT_DISASSEMBLY
12712 /* Needed by the i386 disassembler. For extra credit, someone could
12713 fix this so that we insert symbolic addresses here, esp for GOT/PLT
12717 print_address (unsigned int addr, FILE * outfile)
12719 fprintf (outfile,"0x%8.8x", addr);
12722 /* Needed by the i386 disassembler. */
12724 db_task_printsym (unsigned int addr)
12726 print_address (addr, stderr);
12731 main (int argc, char ** argv)
12735 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
12736 setlocale (LC_MESSAGES, "");
12738 #if defined (HAVE_SETLOCALE)
12739 setlocale (LC_CTYPE, "");
12741 bindtextdomain (PACKAGE, LOCALEDIR);
12742 textdomain (PACKAGE);
12744 expandargv (&argc, &argv);
12746 parse_args (argc, argv);
12748 if (num_dump_sects > 0)
12750 /* Make a copy of the dump_sects array. */
12751 cmdline_dump_sects = (dump_type *)
12752 malloc (num_dump_sects * sizeof (* dump_sects));
12753 if (cmdline_dump_sects == NULL)
12754 error (_("Out of memory allocating dump request table.\n"));
12757 memcpy (cmdline_dump_sects, dump_sects,
12758 num_dump_sects * sizeof (* dump_sects));
12759 num_cmdline_dump_sects = num_dump_sects;
12763 if (optind < (argc - 1))
12767 while (optind < argc)
12768 err |= process_file (argv[optind++]);
12770 if (dump_sects != NULL)
12772 if (cmdline_dump_sects != NULL)
12773 free (cmdline_dump_sects);