1 /* readelf.c -- display contents of an ELF format file
2 Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
3 2008, 2009 Free Software Foundation, Inc.
5 Originally developed by Eric Youngdale <eric@andante.jic.com>
6 Modifications by Nick Clifton <nickc@redhat.com>
8 This file is part of GNU Binutils.
10 This program is free software; you can redistribute it and/or modify
11 it under the terms of the GNU General Public License as published by
12 the Free Software Foundation; either version 3 of the License, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA
25 /* The difference between readelf and objdump:
27 Both programs are capable of displaying the contents of ELF format files,
28 so why does the binutils project have two file dumpers ?
30 The reason is that objdump sees an ELF file through a BFD filter of the
31 world; if BFD has a bug where, say, it disagrees about a machine constant
32 in e_flags, then the odds are good that it will remain internally
33 consistent. The linker sees it the BFD way, objdump sees it the BFD way,
34 GAS sees it the BFD way. There was need for a tool to go find out what
35 the file actually says.
37 This is why the readelf program does not link against the BFD library - it
38 exists as an independent program to help verify the correct working of BFD.
40 There is also the case that readelf can provide more information about an
41 ELF file than is provided by objdump. In particular it can display DWARF
42 debugging information which (at the moment) objdump cannot. */
54 /* Define BFD64 here, even if our default architecture is 32 bit ELF
55 as this will allow us to read in and parse 64bit and 32bit ELF files.
56 Only do this if we believe that the compiler can support a 64 bit
57 data type. For now we only rely on GCC being able to do this. */
65 #include "elf/common.h"
66 #include "elf/external.h"
67 #include "elf/internal.h"
70 /* Included here, before RELOC_MACROS_GEN_FUNC is defined, so that
71 we can obtain the H8 reloc numbers. We need these for the
72 get_reloc_size() function. We include h8.h again after defining
73 RELOC_MACROS_GEN_FUNC so that we get the naming function as well. */
78 /* Undo the effects of #including reloc-macros.h. */
80 #undef START_RELOC_NUMBERS
84 #undef END_RELOC_NUMBERS
85 #undef _RELOC_MACROS_H
87 /* The following headers use the elf/reloc-macros.h file to
88 automatically generate relocation recognition functions
89 such as elf_mips_reloc_type() */
91 #define RELOC_MACROS_GEN_FUNC
93 #include "elf/alpha.h"
101 #include "elf/d10v.h"
102 #include "elf/d30v.h"
104 #include "elf/fr30.h"
107 #include "elf/hppa.h"
108 #include "elf/i386.h"
109 #include "elf/i370.h"
110 #include "elf/i860.h"
111 #include "elf/i960.h"
112 #include "elf/ia64.h"
113 #include "elf/ip2k.h"
114 #include "elf/lm32.h"
115 #include "elf/iq2000.h"
116 #include "elf/m32c.h"
117 #include "elf/m32r.h"
118 #include "elf/m68k.h"
119 #include "elf/m68hc11.h"
120 #include "elf/mcore.h"
122 #include "elf/microblaze.h"
123 #include "elf/mips.h"
124 #include "elf/mmix.h"
125 #include "elf/mn10200.h"
126 #include "elf/mn10300.h"
128 #include "elf/msp430.h"
129 #include "elf/or32.h"
132 #include "elf/ppc64.h"
134 #include "elf/s390.h"
135 #include "elf/score.h"
137 #include "elf/sparc.h"
139 #include "elf/v850.h"
141 #include "elf/x86-64.h"
142 #include "elf/xc16x.h"
143 #include "elf/xstormy16.h"
144 #include "elf/xtensa.h"
149 #include "libiberty.h"
150 #include "safe-ctype.h"
151 #include "filenames.h"
153 char * program_name = "readelf";
154 static long archive_file_offset;
155 static unsigned long archive_file_size;
156 static unsigned long dynamic_addr;
157 static bfd_size_type dynamic_size;
158 static unsigned int dynamic_nent;
159 static char * dynamic_strings;
160 static unsigned long dynamic_strings_length;
161 static char * string_table;
162 static unsigned long string_table_length;
163 static unsigned long num_dynamic_syms;
164 static Elf_Internal_Sym * dynamic_symbols;
165 static Elf_Internal_Syminfo * dynamic_syminfo;
166 static unsigned long dynamic_syminfo_offset;
167 static unsigned int dynamic_syminfo_nent;
168 static char program_interpreter[PATH_MAX];
169 static bfd_vma dynamic_info[DT_ENCODING];
170 static bfd_vma dynamic_info_DT_GNU_HASH;
171 static bfd_vma version_info[16];
172 static Elf_Internal_Ehdr elf_header;
173 static Elf_Internal_Shdr * section_headers;
174 static Elf_Internal_Phdr * program_headers;
175 static Elf_Internal_Dyn * dynamic_section;
176 static Elf_Internal_Shdr * symtab_shndx_hdr;
177 static int show_name;
178 static int do_dynamic;
181 static int do_sections;
182 static int do_section_groups;
183 static int do_section_details;
184 static int do_segments;
185 static int do_unwind;
186 static int do_using_dynamic;
187 static int do_header;
189 static int do_version;
190 static int do_histogram;
191 static int do_debugging;
194 static int do_archive_index;
195 static int is_32bit_elf;
199 struct group_list * next;
200 unsigned int section_index;
205 struct group_list * root;
206 unsigned int group_index;
209 static size_t group_count;
210 static struct group * section_groups;
211 static struct group ** section_headers_groups;
214 /* Flag bits indicating particular types of dump. */
215 #define HEX_DUMP (1 << 0) /* The -x command line switch. */
216 #define DISASS_DUMP (1 << 1) /* The -i command line switch. */
217 #define DEBUG_DUMP (1 << 2) /* The -w command line switch. */
218 #define STRING_DUMP (1 << 3) /* The -p command line switch. */
219 #define RELOC_DUMP (1 << 4) /* The -R command line switch. */
221 typedef unsigned char dump_type;
223 /* A linked list of the section names for which dumps were requested. */
224 struct dump_list_entry
228 struct dump_list_entry * next;
230 static struct dump_list_entry * dump_sects_byname;
232 /* A dynamic array of flags indicating for which sections a dump
233 has been requested via command line switches. */
234 static dump_type * cmdline_dump_sects = NULL;
235 static unsigned int num_cmdline_dump_sects = 0;
237 /* A dynamic array of flags indicating for which sections a dump of
238 some kind has been requested. It is reset on a per-object file
239 basis and then initialised from the cmdline_dump_sects array,
240 the results of interpreting the -w switch, and the
241 dump_sects_byname list. */
242 static dump_type * dump_sects = NULL;
243 static unsigned int num_dump_sects = 0;
246 /* How to print a vma value. */
247 typedef enum print_mode
259 static void (* byte_put) (unsigned char *, bfd_vma, int);
263 #define SECTION_NAME(X) \
264 ((X) == NULL ? "<none>" \
265 : string_table == NULL ? "<no-name>" \
266 : ((X)->sh_name >= string_table_length ? "<corrupt>" \
267 : string_table + (X)->sh_name))
269 #define DT_VERSIONTAGIDX(tag) (DT_VERNEEDNUM - (tag)) /* Reverse order! */
271 #define BYTE_GET(field) byte_get (field, sizeof (field))
273 #define GET_ELF_SYMBOLS(file, section) \
274 (is_32bit_elf ? get_32bit_elf_symbols (file, section) \
275 : get_64bit_elf_symbols (file, section))
277 #define VALID_DYNAMIC_NAME(offset) ((dynamic_strings != NULL) && (offset < dynamic_strings_length))
278 /* GET_DYNAMIC_NAME asssumes that VALID_DYNAMIC_NAME has
279 already been called and verified that the string exists. */
280 #define GET_DYNAMIC_NAME(offset) (dynamic_strings + offset)
282 /* This is just a bit of syntatic sugar. */
283 #define streq(a,b) (strcmp ((a), (b)) == 0)
284 #define strneq(a,b,n) (strncmp ((a), (b), (n)) == 0)
285 #define const_strneq(a,b) (strncmp ((a), (b), sizeof (b) - 1) == 0)
288 get_data (void * var, FILE * file, long offset, size_t size, size_t nmemb,
293 if (size == 0 || nmemb == 0)
296 if (fseek (file, archive_file_offset + offset, SEEK_SET))
298 error (_("Unable to seek to 0x%lx for %s\n"),
299 (unsigned long) archive_file_offset + offset, reason);
306 /* Check for overflow. */
307 if (nmemb < (~(size_t) 0 - 1) / size)
308 /* + 1 so that we can '\0' terminate invalid string table sections. */
309 mvar = malloc (size * nmemb + 1);
313 error (_("Out of memory allocating 0x%lx bytes for %s\n"),
314 (unsigned long)(size * nmemb), reason);
318 ((char *) mvar)[size * nmemb] = '\0';
321 if (fread (mvar, size, nmemb, file) != nmemb)
323 error (_("Unable to read in 0x%lx bytes of %s\n"),
324 (unsigned long)(size * nmemb), reason);
334 byte_put_little_endian (unsigned char * field, bfd_vma value, int size)
339 field[7] = (((value >> 24) >> 24) >> 8) & 0xff;
340 field[6] = ((value >> 24) >> 24) & 0xff;
341 field[5] = ((value >> 24) >> 16) & 0xff;
342 field[4] = ((value >> 24) >> 8) & 0xff;
345 field[3] = (value >> 24) & 0xff;
348 field[2] = (value >> 16) & 0xff;
351 field[1] = (value >> 8) & 0xff;
354 field[0] = value & 0xff;
358 error (_("Unhandled data length: %d\n"), size);
363 /* Print a VMA value. */
366 print_vma (bfd_vma vma, print_mode mode)
379 return nc + printf ("%8.8" BFD_VMA_FMT "x", vma);
386 return printf ("%5" BFD_VMA_FMT "d", vma);
394 return nc + printf ("%" BFD_VMA_FMT "x", vma);
397 return printf ("%" BFD_VMA_FMT "d", vma);
400 return printf ("%" BFD_VMA_FMT "u", vma);
405 /* Display a symbol on stdout. Handles the display of non-printing characters.
407 If DO_WIDE is not true then format the symbol to be at most WIDTH characters,
408 truncating as necessary. If WIDTH is negative then format the string to be
409 exactly - WIDTH characters, truncating or padding as necessary.
411 Returns the number of emitted characters. */
414 print_symbol (int width, const char * symbol)
417 bfd_boolean extra_padding = FALSE;
418 unsigned int num_printed = 0;
422 /* Set the width to a very large value. This simplifies the code below. */
427 /* Keep the width positive. This also helps. */
429 extra_padding = TRUE;
438 /* Look for non-printing symbols inside the symbol's name.
439 This test is triggered in particular by the names generated
440 by the assembler for local labels. */
441 while (ISPRINT (* c))
451 printf ("%.*s", len, symbol);
457 if (* c == 0 || width == 0)
460 /* Now display the non-printing character, if
461 there is room left in which to dipslay it. */
467 printf ("^%c", *c + 0x40);
477 printf ("<0x%.2x>", *c);
486 if (extra_padding && width > 0)
488 /* Fill in the remaining spaces. */
489 printf ("%-*s", width, " ");
497 byte_put_big_endian (unsigned char * field, bfd_vma value, int size)
502 field[7] = value & 0xff;
503 field[6] = (value >> 8) & 0xff;
504 field[5] = (value >> 16) & 0xff;
505 field[4] = (value >> 24) & 0xff;
510 field[3] = value & 0xff;
514 field[2] = value & 0xff;
518 field[1] = value & 0xff;
522 field[0] = value & 0xff;
526 error (_("Unhandled data length: %d\n"), size);
531 /* Return a pointer to section NAME, or NULL if no such section exists. */
533 static Elf_Internal_Shdr *
534 find_section (const char * name)
538 for (i = 0; i < elf_header.e_shnum; i++)
539 if (streq (SECTION_NAME (section_headers + i), name))
540 return section_headers + i;
545 /* Guess the relocation size commonly used by the specific machines. */
548 guess_is_rela (unsigned int e_machine)
552 /* Targets that use REL relocations. */
568 /* Targets that use RELA relocations. */
572 case EM_ALTERA_NIOS2:
592 case EM_LATTICEMICO32:
600 case EM_CYGNUS_MN10200:
602 case EM_CYGNUS_MN10300:
626 case EM_MICROBLAZE_OLD:
647 warn (_("Don't know about relocations on this machine architecture\n"));
653 slurp_rela_relocs (FILE * file,
654 unsigned long rel_offset,
655 unsigned long rel_size,
656 Elf_Internal_Rela ** relasp,
657 unsigned long * nrelasp)
659 Elf_Internal_Rela * relas;
660 unsigned long nrelas;
665 Elf32_External_Rela * erelas;
667 erelas = (Elf32_External_Rela *) get_data (NULL, file, rel_offset, 1,
668 rel_size, _("relocs"));
672 nrelas = rel_size / sizeof (Elf32_External_Rela);
674 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
675 sizeof (Elf_Internal_Rela));
680 error (_("out of memory parsing relocs\n"));
684 for (i = 0; i < nrelas; i++)
686 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
687 relas[i].r_info = BYTE_GET (erelas[i].r_info);
688 relas[i].r_addend = BYTE_GET (erelas[i].r_addend);
695 Elf64_External_Rela * erelas;
697 erelas = (Elf64_External_Rela *) get_data (NULL, file, rel_offset, 1,
698 rel_size, _("relocs"));
702 nrelas = rel_size / sizeof (Elf64_External_Rela);
704 relas = (Elf_Internal_Rela *) cmalloc (nrelas,
705 sizeof (Elf_Internal_Rela));
710 error (_("out of memory parsing relocs\n"));
714 for (i = 0; i < nrelas; i++)
716 relas[i].r_offset = BYTE_GET (erelas[i].r_offset);
717 relas[i].r_info = BYTE_GET (erelas[i].r_info);
718 relas[i].r_addend = BYTE_GET (erelas[i].r_addend);
720 /* The #ifdef BFD64 below is to prevent a compile time
721 warning. We know that if we do not have a 64 bit data
722 type that we will never execute this code anyway. */
724 if (elf_header.e_machine == EM_MIPS
725 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
727 /* In little-endian objects, r_info isn't really a
728 64-bit little-endian value: it has a 32-bit
729 little-endian symbol index followed by four
730 individual byte fields. Reorder INFO
732 bfd_vma inf = relas[i].r_info;
733 inf = (((inf & 0xffffffff) << 32)
734 | ((inf >> 56) & 0xff)
735 | ((inf >> 40) & 0xff00)
736 | ((inf >> 24) & 0xff0000)
737 | ((inf >> 8) & 0xff000000));
738 relas[i].r_info = inf;
751 slurp_rel_relocs (FILE * file,
752 unsigned long rel_offset,
753 unsigned long rel_size,
754 Elf_Internal_Rela ** relsp,
755 unsigned long * nrelsp)
757 Elf_Internal_Rela * rels;
763 Elf32_External_Rel * erels;
765 erels = (Elf32_External_Rel *) get_data (NULL, file, rel_offset, 1,
766 rel_size, _("relocs"));
770 nrels = rel_size / sizeof (Elf32_External_Rel);
772 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
777 error (_("out of memory parsing relocs\n"));
781 for (i = 0; i < nrels; i++)
783 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
784 rels[i].r_info = BYTE_GET (erels[i].r_info);
785 rels[i].r_addend = 0;
792 Elf64_External_Rel * erels;
794 erels = (Elf64_External_Rel *) get_data (NULL, file, rel_offset, 1,
795 rel_size, _("relocs"));
799 nrels = rel_size / sizeof (Elf64_External_Rel);
801 rels = (Elf_Internal_Rela *) cmalloc (nrels, sizeof (Elf_Internal_Rela));
806 error (_("out of memory parsing relocs\n"));
810 for (i = 0; i < nrels; i++)
812 rels[i].r_offset = BYTE_GET (erels[i].r_offset);
813 rels[i].r_info = BYTE_GET (erels[i].r_info);
814 rels[i].r_addend = 0;
816 /* The #ifdef BFD64 below is to prevent a compile time
817 warning. We know that if we do not have a 64 bit data
818 type that we will never execute this code anyway. */
820 if (elf_header.e_machine == EM_MIPS
821 && elf_header.e_ident[EI_DATA] != ELFDATA2MSB)
823 /* In little-endian objects, r_info isn't really a
824 64-bit little-endian value: it has a 32-bit
825 little-endian symbol index followed by four
826 individual byte fields. Reorder INFO
828 bfd_vma inf = rels[i].r_info;
829 inf = (((inf & 0xffffffff) << 32)
830 | ((inf >> 56) & 0xff)
831 | ((inf >> 40) & 0xff00)
832 | ((inf >> 24) & 0xff0000)
833 | ((inf >> 8) & 0xff000000));
834 rels[i].r_info = inf;
846 /* Returns the reloc type extracted from the reloc info field. */
849 get_reloc_type (bfd_vma reloc_info)
852 return ELF32_R_TYPE (reloc_info);
854 switch (elf_header.e_machine)
857 /* Note: We assume that reloc_info has already been adjusted for us. */
858 return ELF64_MIPS_R_TYPE (reloc_info);
861 return ELF64_R_TYPE_ID (reloc_info);
864 return ELF64_R_TYPE (reloc_info);
868 /* Return the symbol index extracted from the reloc info field. */
871 get_reloc_symindex (bfd_vma reloc_info)
873 return is_32bit_elf ? ELF32_R_SYM (reloc_info) : ELF64_R_SYM (reloc_info);
876 /* Display the contents of the relocation data found at the specified
880 dump_relocations (FILE * file,
881 unsigned long rel_offset,
882 unsigned long rel_size,
883 Elf_Internal_Sym * symtab,
886 unsigned long strtablen,
890 Elf_Internal_Rela * rels;
892 if (is_rela == UNKNOWN)
893 is_rela = guess_is_rela (elf_header.e_machine);
897 if (!slurp_rela_relocs (file, rel_offset, rel_size, &rels, &rel_size))
902 if (!slurp_rel_relocs (file, rel_offset, rel_size, &rels, &rel_size))
911 printf (_(" Offset Info Type Sym. Value Symbol's Name + Addend\n"));
913 printf (_(" Offset Info Type Sym.Value Sym. Name + Addend\n"));
918 printf (_(" Offset Info Type Sym. Value Symbol's Name\n"));
920 printf (_(" Offset Info Type Sym.Value Sym. Name\n"));
928 printf (_(" Offset Info Type Symbol's Value Symbol's Name + Addend\n"));
930 printf (_(" Offset Info Type Sym. Value Sym. Name + Addend\n"));
935 printf (_(" Offset Info Type Symbol's Value Symbol's Name\n"));
937 printf (_(" Offset Info Type Sym. Value Sym. Name\n"));
941 for (i = 0; i < rel_size; i++)
946 bfd_vma symtab_index;
949 offset = rels[i].r_offset;
950 inf = rels[i].r_info;
952 type = get_reloc_type (inf);
953 symtab_index = get_reloc_symindex (inf);
957 printf ("%8.8lx %8.8lx ",
958 (unsigned long) offset & 0xffffffff,
959 (unsigned long) inf & 0xffffffff);
963 #if BFD_HOST_64BIT_LONG
965 ? "%16.16lx %16.16lx "
966 : "%12.12lx %12.12lx ",
968 #elif BFD_HOST_64BIT_LONG_LONG
971 ? "%16.16llx %16.16llx "
972 : "%12.12llx %12.12llx ",
976 ? "%16.16I64x %16.16I64x "
977 : "%12.12I64x %12.12I64x ",
982 ? "%8.8lx%8.8lx %8.8lx%8.8lx "
983 : "%4.4lx%8.8lx %4.4lx%8.8lx ",
984 _bfd_int64_high (offset),
985 _bfd_int64_low (offset),
986 _bfd_int64_high (inf),
987 _bfd_int64_low (inf));
991 switch (elf_header.e_machine)
999 rtype = elf_m32r_reloc_type (type);
1004 rtype = elf_i386_reloc_type (type);
1009 rtype = elf_m68hc11_reloc_type (type);
1013 rtype = elf_m68k_reloc_type (type);
1017 rtype = elf_i960_reloc_type (type);
1022 rtype = elf_avr_reloc_type (type);
1025 case EM_OLD_SPARCV9:
1026 case EM_SPARC32PLUS:
1029 rtype = elf_sparc_reloc_type (type);
1033 rtype = elf_spu_reloc_type (type);
1037 case EM_CYGNUS_V850:
1038 rtype = v850_reloc_type (type);
1042 case EM_CYGNUS_D10V:
1043 rtype = elf_d10v_reloc_type (type);
1047 case EM_CYGNUS_D30V:
1048 rtype = elf_d30v_reloc_type (type);
1052 rtype = elf_dlx_reloc_type (type);
1056 rtype = elf_sh_reloc_type (type);
1060 case EM_CYGNUS_MN10300:
1061 rtype = elf_mn10300_reloc_type (type);
1065 case EM_CYGNUS_MN10200:
1066 rtype = elf_mn10200_reloc_type (type);
1070 case EM_CYGNUS_FR30:
1071 rtype = elf_fr30_reloc_type (type);
1075 rtype = elf_frv_reloc_type (type);
1079 rtype = elf_mcore_reloc_type (type);
1083 rtype = elf_mmix_reloc_type (type);
1088 rtype = elf_msp430_reloc_type (type);
1092 rtype = elf_ppc_reloc_type (type);
1096 rtype = elf_ppc64_reloc_type (type);
1100 case EM_MIPS_RS3_LE:
1101 rtype = elf_mips_reloc_type (type);
1105 rtype = elf_alpha_reloc_type (type);
1109 rtype = elf_arm_reloc_type (type);
1113 rtype = elf_arc_reloc_type (type);
1117 rtype = elf_hppa_reloc_type (type);
1123 rtype = elf_h8_reloc_type (type);
1128 rtype = elf_or32_reloc_type (type);
1133 rtype = elf_pj_reloc_type (type);
1136 rtype = elf_ia64_reloc_type (type);
1140 rtype = elf_cris_reloc_type (type);
1144 rtype = elf_i860_reloc_type (type);
1149 rtype = elf_x86_64_reloc_type (type);
1153 rtype = i370_reloc_type (type);
1158 rtype = elf_s390_reloc_type (type);
1162 rtype = elf_score_reloc_type (type);
1166 rtype = elf_xstormy16_reloc_type (type);
1170 rtype = elf_crx_reloc_type (type);
1174 rtype = elf_vax_reloc_type (type);
1179 rtype = elf_ip2k_reloc_type (type);
1183 rtype = elf_iq2000_reloc_type (type);
1188 rtype = elf_xtensa_reloc_type (type);
1191 case EM_LATTICEMICO32:
1192 rtype = elf_lm32_reloc_type (type);
1197 rtype = elf_m32c_reloc_type (type);
1201 rtype = elf_mt_reloc_type (type);
1205 rtype = elf_bfin_reloc_type (type);
1209 rtype = elf_mep_reloc_type (type);
1214 rtype = elf_cr16_reloc_type (type);
1218 case EM_MICROBLAZE_OLD:
1219 rtype = elf_microblaze_reloc_type (type);
1223 rtype = elf_rx_reloc_type (type);
1228 rtype = elf_xc16x_reloc_type (type);
1233 printf (_("unrecognized: %-7lx"), (unsigned long) type & 0xffffffff);
1235 printf (do_wide ? "%-22.22s" : "%-17.17s", rtype);
1237 if (elf_header.e_machine == EM_ALPHA
1239 && streq (rtype, "R_ALPHA_LITUSE")
1242 switch (rels[i].r_addend)
1244 case LITUSE_ALPHA_ADDR: rtype = "ADDR"; break;
1245 case LITUSE_ALPHA_BASE: rtype = "BASE"; break;
1246 case LITUSE_ALPHA_BYTOFF: rtype = "BYTOFF"; break;
1247 case LITUSE_ALPHA_JSR: rtype = "JSR"; break;
1248 case LITUSE_ALPHA_TLSGD: rtype = "TLSGD"; break;
1249 case LITUSE_ALPHA_TLSLDM: rtype = "TLSLDM"; break;
1250 case LITUSE_ALPHA_JSRDIRECT: rtype = "JSRDIRECT"; break;
1251 default: rtype = NULL;
1254 printf (" (%s)", rtype);
1258 printf (_("<unknown addend: %lx>"),
1259 (unsigned long) rels[i].r_addend);
1262 else if (symtab_index)
1264 if (symtab == NULL || symtab_index >= nsyms)
1265 printf (" bad symbol index: %08lx", (unsigned long) symtab_index);
1268 Elf_Internal_Sym * psym;
1270 psym = symtab + symtab_index;
1274 if (ELF_ST_TYPE (psym->st_info) == STT_GNU_IFUNC)
1278 unsigned int width = is_32bit_elf ? 8 : 14;
1280 /* Relocations against GNU_IFUNC symbols do not use the value
1281 of the symbol as the address to relocate against. Instead
1282 they invoke the function named by the symbol and use its
1283 result as the address for relocation.
1285 To indicate this to the user, do not display the value of
1286 the symbol in the "Symbols's Value" field. Instead show
1287 its name followed by () as a hint that the symbol is
1291 || psym->st_name == 0
1292 || psym->st_name >= strtablen)
1295 name = strtab + psym->st_name;
1297 len = print_symbol (width, name);
1298 printf ("()%-*s", len <= width ? (width + 1) - len : 1, " ");
1302 print_vma (psym->st_value, LONG_HEX);
1304 printf (is_32bit_elf ? " " : " ");
1307 if (psym->st_name == 0)
1309 const char * sec_name = "<null>";
1312 if (ELF_ST_TYPE (psym->st_info) == STT_SECTION)
1314 if (psym->st_shndx < elf_header.e_shnum)
1316 = SECTION_NAME (section_headers + psym->st_shndx);
1317 else if (psym->st_shndx == SHN_ABS)
1319 else if (psym->st_shndx == SHN_COMMON)
1320 sec_name = "COMMON";
1321 else if (elf_header.e_machine == EM_MIPS
1322 && psym->st_shndx == SHN_MIPS_SCOMMON)
1323 sec_name = "SCOMMON";
1324 else if (elf_header.e_machine == EM_MIPS
1325 && psym->st_shndx == SHN_MIPS_SUNDEFINED)
1326 sec_name = "SUNDEF";
1327 else if ((elf_header.e_machine == EM_X86_64
1328 || elf_header.e_machine == EM_L1OM)
1329 && psym->st_shndx == SHN_X86_64_LCOMMON)
1330 sec_name = "LARGE_COMMON";
1331 else if (elf_header.e_machine == EM_IA_64
1332 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX
1333 && psym->st_shndx == SHN_IA_64_ANSI_COMMON)
1334 sec_name = "ANSI_COM";
1335 else if (elf_header.e_machine == EM_IA_64
1336 && (elf_header.e_ident[EI_OSABI]
1337 == ELFOSABI_OPENVMS)
1338 && psym->st_shndx == SHN_IA_64_VMS_SYMVEC)
1339 sec_name = "VMS_SYMVEC";
1342 sprintf (name_buf, "<section 0x%x>",
1343 (unsigned int) psym->st_shndx);
1344 sec_name = name_buf;
1347 print_symbol (22, sec_name);
1349 else if (strtab == NULL)
1350 printf (_("<string table index: %3ld>"), psym->st_name);
1351 else if (psym->st_name >= strtablen)
1352 printf (_("<corrupt string table index: %3ld>"), psym->st_name);
1354 print_symbol (22, strtab + psym->st_name);
1358 long off = (long) (bfd_signed_vma) rels[i].r_addend;
1361 printf (" - %lx", - off);
1363 printf (" + %lx", off);
1369 printf ("%*c", is_32bit_elf ?
1370 (do_wide ? 34 : 28) : (do_wide ? 26 : 20), ' ');
1371 print_vma (rels[i].r_addend, LONG_HEX);
1374 if (elf_header.e_machine == EM_SPARCV9
1376 && streq (rtype, "R_SPARC_OLO10"))
1377 printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (inf));
1382 if (! is_32bit_elf && elf_header.e_machine == EM_MIPS)
1384 bfd_vma type2 = ELF64_MIPS_R_TYPE2 (inf);
1385 bfd_vma type3 = ELF64_MIPS_R_TYPE3 (inf);
1386 const char * rtype2 = elf_mips_reloc_type (type2);
1387 const char * rtype3 = elf_mips_reloc_type (type3);
1389 printf (" Type2: ");
1392 printf (_("unrecognized: %-7lx"),
1393 (unsigned long) type2 & 0xffffffff);
1395 printf ("%-17.17s", rtype2);
1397 printf ("\n Type3: ");
1400 printf (_("unrecognized: %-7lx"),
1401 (unsigned long) type3 & 0xffffffff);
1403 printf ("%-17.17s", rtype3);
1414 get_mips_dynamic_type (unsigned long type)
1418 case DT_MIPS_RLD_VERSION: return "MIPS_RLD_VERSION";
1419 case DT_MIPS_TIME_STAMP: return "MIPS_TIME_STAMP";
1420 case DT_MIPS_ICHECKSUM: return "MIPS_ICHECKSUM";
1421 case DT_MIPS_IVERSION: return "MIPS_IVERSION";
1422 case DT_MIPS_FLAGS: return "MIPS_FLAGS";
1423 case DT_MIPS_BASE_ADDRESS: return "MIPS_BASE_ADDRESS";
1424 case DT_MIPS_MSYM: return "MIPS_MSYM";
1425 case DT_MIPS_CONFLICT: return "MIPS_CONFLICT";
1426 case DT_MIPS_LIBLIST: return "MIPS_LIBLIST";
1427 case DT_MIPS_LOCAL_GOTNO: return "MIPS_LOCAL_GOTNO";
1428 case DT_MIPS_CONFLICTNO: return "MIPS_CONFLICTNO";
1429 case DT_MIPS_LIBLISTNO: return "MIPS_LIBLISTNO";
1430 case DT_MIPS_SYMTABNO: return "MIPS_SYMTABNO";
1431 case DT_MIPS_UNREFEXTNO: return "MIPS_UNREFEXTNO";
1432 case DT_MIPS_GOTSYM: return "MIPS_GOTSYM";
1433 case DT_MIPS_HIPAGENO: return "MIPS_HIPAGENO";
1434 case DT_MIPS_RLD_MAP: return "MIPS_RLD_MAP";
1435 case DT_MIPS_DELTA_CLASS: return "MIPS_DELTA_CLASS";
1436 case DT_MIPS_DELTA_CLASS_NO: return "MIPS_DELTA_CLASS_NO";
1437 case DT_MIPS_DELTA_INSTANCE: return "MIPS_DELTA_INSTANCE";
1438 case DT_MIPS_DELTA_INSTANCE_NO: return "MIPS_DELTA_INSTANCE_NO";
1439 case DT_MIPS_DELTA_RELOC: return "MIPS_DELTA_RELOC";
1440 case DT_MIPS_DELTA_RELOC_NO: return "MIPS_DELTA_RELOC_NO";
1441 case DT_MIPS_DELTA_SYM: return "MIPS_DELTA_SYM";
1442 case DT_MIPS_DELTA_SYM_NO: return "MIPS_DELTA_SYM_NO";
1443 case DT_MIPS_DELTA_CLASSSYM: return "MIPS_DELTA_CLASSSYM";
1444 case DT_MIPS_DELTA_CLASSSYM_NO: return "MIPS_DELTA_CLASSSYM_NO";
1445 case DT_MIPS_CXX_FLAGS: return "MIPS_CXX_FLAGS";
1446 case DT_MIPS_PIXIE_INIT: return "MIPS_PIXIE_INIT";
1447 case DT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
1448 case DT_MIPS_LOCALPAGE_GOTIDX: return "MIPS_LOCALPAGE_GOTIDX";
1449 case DT_MIPS_LOCAL_GOTIDX: return "MIPS_LOCAL_GOTIDX";
1450 case DT_MIPS_HIDDEN_GOTIDX: return "MIPS_HIDDEN_GOTIDX";
1451 case DT_MIPS_PROTECTED_GOTIDX: return "MIPS_PROTECTED_GOTIDX";
1452 case DT_MIPS_OPTIONS: return "MIPS_OPTIONS";
1453 case DT_MIPS_INTERFACE: return "MIPS_INTERFACE";
1454 case DT_MIPS_DYNSTR_ALIGN: return "MIPS_DYNSTR_ALIGN";
1455 case DT_MIPS_INTERFACE_SIZE: return "MIPS_INTERFACE_SIZE";
1456 case DT_MIPS_RLD_TEXT_RESOLVE_ADDR: return "MIPS_RLD_TEXT_RESOLVE_ADDR";
1457 case DT_MIPS_PERF_SUFFIX: return "MIPS_PERF_SUFFIX";
1458 case DT_MIPS_COMPACT_SIZE: return "MIPS_COMPACT_SIZE";
1459 case DT_MIPS_GP_VALUE: return "MIPS_GP_VALUE";
1460 case DT_MIPS_AUX_DYNAMIC: return "MIPS_AUX_DYNAMIC";
1461 case DT_MIPS_PLTGOT: return "MIPS_PLTGOT";
1462 case DT_MIPS_RWPLT: return "MIPS_RWPLT";
1469 get_sparc64_dynamic_type (unsigned long type)
1473 case DT_SPARC_REGISTER: return "SPARC_REGISTER";
1480 get_ppc_dynamic_type (unsigned long type)
1484 case DT_PPC_GOT: return "PPC_GOT";
1485 case DT_PPC_TLSOPT: return "PPC_TLSOPT";
1492 get_ppc64_dynamic_type (unsigned long type)
1496 case DT_PPC64_GLINK: return "PPC64_GLINK";
1497 case DT_PPC64_OPD: return "PPC64_OPD";
1498 case DT_PPC64_OPDSZ: return "PPC64_OPDSZ";
1499 case DT_PPC64_TLSOPT: return "PPC64_TLSOPT";
1506 get_parisc_dynamic_type (unsigned long type)
1510 case DT_HP_LOAD_MAP: return "HP_LOAD_MAP";
1511 case DT_HP_DLD_FLAGS: return "HP_DLD_FLAGS";
1512 case DT_HP_DLD_HOOK: return "HP_DLD_HOOK";
1513 case DT_HP_UX10_INIT: return "HP_UX10_INIT";
1514 case DT_HP_UX10_INITSZ: return "HP_UX10_INITSZ";
1515 case DT_HP_PREINIT: return "HP_PREINIT";
1516 case DT_HP_PREINITSZ: return "HP_PREINITSZ";
1517 case DT_HP_NEEDED: return "HP_NEEDED";
1518 case DT_HP_TIME_STAMP: return "HP_TIME_STAMP";
1519 case DT_HP_CHECKSUM: return "HP_CHECKSUM";
1520 case DT_HP_GST_SIZE: return "HP_GST_SIZE";
1521 case DT_HP_GST_VERSION: return "HP_GST_VERSION";
1522 case DT_HP_GST_HASHVAL: return "HP_GST_HASHVAL";
1523 case DT_HP_EPLTREL: return "HP_GST_EPLTREL";
1524 case DT_HP_EPLTRELSZ: return "HP_GST_EPLTRELSZ";
1525 case DT_HP_FILTERED: return "HP_FILTERED";
1526 case DT_HP_FILTER_TLS: return "HP_FILTER_TLS";
1527 case DT_HP_COMPAT_FILTERED: return "HP_COMPAT_FILTERED";
1528 case DT_HP_LAZYLOAD: return "HP_LAZYLOAD";
1529 case DT_HP_BIND_NOW_COUNT: return "HP_BIND_NOW_COUNT";
1530 case DT_PLT: return "PLT";
1531 case DT_PLT_SIZE: return "PLT_SIZE";
1532 case DT_DLT: return "DLT";
1533 case DT_DLT_SIZE: return "DLT_SIZE";
1540 get_ia64_dynamic_type (unsigned long type)
1544 case DT_IA_64_PLT_RESERVE: return "IA_64_PLT_RESERVE";
1545 case DT_IA_64_VMS_SUBTYPE: return "VMS_SUBTYPE";
1546 case DT_IA_64_VMS_IMGIOCNT: return "VMS_IMGIOCNT";
1547 case DT_IA_64_VMS_LNKFLAGS: return "VMS_LNKFLAGS";
1548 case DT_IA_64_VMS_VIR_MEM_BLK_SIZ: return "VMS_VIR_MEM_BLK_SIZ";
1549 case DT_IA_64_VMS_IDENT: return "VMS_IDENT";
1550 case DT_IA_64_VMS_NEEDED_IDENT: return "VMS_NEEDED_IDENT";
1551 case DT_IA_64_VMS_IMG_RELA_CNT: return "VMS_IMG_RELA_CNT";
1552 case DT_IA_64_VMS_SEG_RELA_CNT: return "VMS_SEG_RELA_CNT";
1553 case DT_IA_64_VMS_FIXUP_RELA_CNT: return "VMS_FIXUP_RELA_CNT";
1554 case DT_IA_64_VMS_FIXUP_NEEDED: return "VMS_FIXUP_NEEDED";
1555 case DT_IA_64_VMS_SYMVEC_CNT: return "VMS_SYMVEC_CNT";
1556 case DT_IA_64_VMS_XLATED: return "VMS_XLATED";
1557 case DT_IA_64_VMS_STACKSIZE: return "VMS_STACKSIZE";
1558 case DT_IA_64_VMS_UNWINDSZ: return "VMS_UNWINDSZ";
1559 case DT_IA_64_VMS_UNWIND_CODSEG: return "VMS_UNWIND_CODSEG";
1560 case DT_IA_64_VMS_UNWIND_INFOSEG: return "VMS_UNWIND_INFOSEG";
1561 case DT_IA_64_VMS_LINKTIME: return "VMS_LINKTIME";
1562 case DT_IA_64_VMS_SEG_NO: return "VMS_SEG_NO";
1563 case DT_IA_64_VMS_SYMVEC_OFFSET: return "VMS_SYMVEC_OFFSET";
1564 case DT_IA_64_VMS_SYMVEC_SEG: return "VMS_SYMVEC_SEG";
1565 case DT_IA_64_VMS_UNWIND_OFFSET: return "VMS_UNWIND_OFFSET";
1566 case DT_IA_64_VMS_UNWIND_SEG: return "VMS_UNWIND_SEG";
1567 case DT_IA_64_VMS_STRTAB_OFFSET: return "VMS_STRTAB_OFFSET";
1568 case DT_IA_64_VMS_SYSVER_OFFSET: return "VMS_SYSVER_OFFSET";
1569 case DT_IA_64_VMS_IMG_RELA_OFF: return "VMS_IMG_RELA_OFF";
1570 case DT_IA_64_VMS_SEG_RELA_OFF: return "VMS_SEG_RELA_OFF";
1571 case DT_IA_64_VMS_FIXUP_RELA_OFF: return "VMS_FIXUP_RELA_OFF";
1572 case DT_IA_64_VMS_PLTGOT_OFFSET: return "VMS_PLTGOT_OFFSET";
1573 case DT_IA_64_VMS_PLTGOT_SEG: return "VMS_PLTGOT_SEG";
1574 case DT_IA_64_VMS_FPMODE: return "VMS_FPMODE";
1581 get_alpha_dynamic_type (unsigned long type)
1585 case DT_ALPHA_PLTRO: return "ALPHA_PLTRO";
1592 get_score_dynamic_type (unsigned long type)
1596 case DT_SCORE_BASE_ADDRESS: return "SCORE_BASE_ADDRESS";
1597 case DT_SCORE_LOCAL_GOTNO: return "SCORE_LOCAL_GOTNO";
1598 case DT_SCORE_SYMTABNO: return "SCORE_SYMTABNO";
1599 case DT_SCORE_GOTSYM: return "SCORE_GOTSYM";
1600 case DT_SCORE_UNREFEXTNO: return "SCORE_UNREFEXTNO";
1601 case DT_SCORE_HIPAGENO: return "SCORE_HIPAGENO";
1609 get_dynamic_type (unsigned long type)
1611 static char buff[64];
1615 case DT_NULL: return "NULL";
1616 case DT_NEEDED: return "NEEDED";
1617 case DT_PLTRELSZ: return "PLTRELSZ";
1618 case DT_PLTGOT: return "PLTGOT";
1619 case DT_HASH: return "HASH";
1620 case DT_STRTAB: return "STRTAB";
1621 case DT_SYMTAB: return "SYMTAB";
1622 case DT_RELA: return "RELA";
1623 case DT_RELASZ: return "RELASZ";
1624 case DT_RELAENT: return "RELAENT";
1625 case DT_STRSZ: return "STRSZ";
1626 case DT_SYMENT: return "SYMENT";
1627 case DT_INIT: return "INIT";
1628 case DT_FINI: return "FINI";
1629 case DT_SONAME: return "SONAME";
1630 case DT_RPATH: return "RPATH";
1631 case DT_SYMBOLIC: return "SYMBOLIC";
1632 case DT_REL: return "REL";
1633 case DT_RELSZ: return "RELSZ";
1634 case DT_RELENT: return "RELENT";
1635 case DT_PLTREL: return "PLTREL";
1636 case DT_DEBUG: return "DEBUG";
1637 case DT_TEXTREL: return "TEXTREL";
1638 case DT_JMPREL: return "JMPREL";
1639 case DT_BIND_NOW: return "BIND_NOW";
1640 case DT_INIT_ARRAY: return "INIT_ARRAY";
1641 case DT_FINI_ARRAY: return "FINI_ARRAY";
1642 case DT_INIT_ARRAYSZ: return "INIT_ARRAYSZ";
1643 case DT_FINI_ARRAYSZ: return "FINI_ARRAYSZ";
1644 case DT_RUNPATH: return "RUNPATH";
1645 case DT_FLAGS: return "FLAGS";
1647 case DT_PREINIT_ARRAY: return "PREINIT_ARRAY";
1648 case DT_PREINIT_ARRAYSZ: return "PREINIT_ARRAYSZ";
1650 case DT_CHECKSUM: return "CHECKSUM";
1651 case DT_PLTPADSZ: return "PLTPADSZ";
1652 case DT_MOVEENT: return "MOVEENT";
1653 case DT_MOVESZ: return "MOVESZ";
1654 case DT_FEATURE: return "FEATURE";
1655 case DT_POSFLAG_1: return "POSFLAG_1";
1656 case DT_SYMINSZ: return "SYMINSZ";
1657 case DT_SYMINENT: return "SYMINENT"; /* aka VALRNGHI */
1659 case DT_ADDRRNGLO: return "ADDRRNGLO";
1660 case DT_CONFIG: return "CONFIG";
1661 case DT_DEPAUDIT: return "DEPAUDIT";
1662 case DT_AUDIT: return "AUDIT";
1663 case DT_PLTPAD: return "PLTPAD";
1664 case DT_MOVETAB: return "MOVETAB";
1665 case DT_SYMINFO: return "SYMINFO"; /* aka ADDRRNGHI */
1667 case DT_VERSYM: return "VERSYM";
1669 case DT_TLSDESC_GOT: return "TLSDESC_GOT";
1670 case DT_TLSDESC_PLT: return "TLSDESC_PLT";
1671 case DT_RELACOUNT: return "RELACOUNT";
1672 case DT_RELCOUNT: return "RELCOUNT";
1673 case DT_FLAGS_1: return "FLAGS_1";
1674 case DT_VERDEF: return "VERDEF";
1675 case DT_VERDEFNUM: return "VERDEFNUM";
1676 case DT_VERNEED: return "VERNEED";
1677 case DT_VERNEEDNUM: return "VERNEEDNUM";
1679 case DT_AUXILIARY: return "AUXILIARY";
1680 case DT_USED: return "USED";
1681 case DT_FILTER: return "FILTER";
1683 case DT_GNU_PRELINKED: return "GNU_PRELINKED";
1684 case DT_GNU_CONFLICT: return "GNU_CONFLICT";
1685 case DT_GNU_CONFLICTSZ: return "GNU_CONFLICTSZ";
1686 case DT_GNU_LIBLIST: return "GNU_LIBLIST";
1687 case DT_GNU_LIBLISTSZ: return "GNU_LIBLISTSZ";
1688 case DT_GNU_HASH: return "GNU_HASH";
1691 if ((type >= DT_LOPROC) && (type <= DT_HIPROC))
1693 const char * result;
1695 switch (elf_header.e_machine)
1698 case EM_MIPS_RS3_LE:
1699 result = get_mips_dynamic_type (type);
1702 result = get_sparc64_dynamic_type (type);
1705 result = get_ppc_dynamic_type (type);
1708 result = get_ppc64_dynamic_type (type);
1711 result = get_ia64_dynamic_type (type);
1714 result = get_alpha_dynamic_type (type);
1717 result = get_score_dynamic_type (type);
1727 snprintf (buff, sizeof (buff), _("Processor Specific: %lx"), type);
1729 else if (((type >= DT_LOOS) && (type <= DT_HIOS))
1730 || (elf_header.e_machine == EM_PARISC
1731 && (type >= OLD_DT_LOOS) && (type <= OLD_DT_HIOS)))
1733 const char * result;
1735 switch (elf_header.e_machine)
1738 result = get_parisc_dynamic_type (type);
1741 result = get_ia64_dynamic_type (type);
1751 snprintf (buff, sizeof (buff), _("Operating System specific: %lx"),
1755 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), type);
1762 get_file_type (unsigned e_type)
1764 static char buff[32];
1768 case ET_NONE: return _("NONE (None)");
1769 case ET_REL: return _("REL (Relocatable file)");
1770 case ET_EXEC: return _("EXEC (Executable file)");
1771 case ET_DYN: return _("DYN (Shared object file)");
1772 case ET_CORE: return _("CORE (Core file)");
1775 if ((e_type >= ET_LOPROC) && (e_type <= ET_HIPROC))
1776 snprintf (buff, sizeof (buff), _("Processor Specific: (%x)"), e_type);
1777 else if ((e_type >= ET_LOOS) && (e_type <= ET_HIOS))
1778 snprintf (buff, sizeof (buff), _("OS Specific: (%x)"), e_type);
1780 snprintf (buff, sizeof (buff), _("<unknown>: %x"), e_type);
1786 get_machine_name (unsigned e_machine)
1788 static char buff[64]; /* XXX */
1792 case EM_NONE: return _("None");
1793 case EM_M32: return "WE32100";
1794 case EM_SPARC: return "Sparc";
1795 case EM_SPU: return "SPU";
1796 case EM_386: return "Intel 80386";
1797 case EM_68K: return "MC68000";
1798 case EM_88K: return "MC88000";
1799 case EM_486: return "Intel 80486";
1800 case EM_860: return "Intel 80860";
1801 case EM_MIPS: return "MIPS R3000";
1802 case EM_S370: return "IBM System/370";
1803 case EM_MIPS_RS3_LE: return "MIPS R4000 big-endian";
1804 case EM_OLD_SPARCV9: return "Sparc v9 (old)";
1805 case EM_PARISC: return "HPPA";
1806 case EM_PPC_OLD: return "Power PC (old)";
1807 case EM_SPARC32PLUS: return "Sparc v8+" ;
1808 case EM_960: return "Intel 90860";
1809 case EM_PPC: return "PowerPC";
1810 case EM_PPC64: return "PowerPC64";
1811 case EM_V800: return "NEC V800";
1812 case EM_FR20: return "Fujitsu FR20";
1813 case EM_RH32: return "TRW RH32";
1814 case EM_MCORE: return "MCORE";
1815 case EM_ARM: return "ARM";
1816 case EM_OLD_ALPHA: return "Digital Alpha (old)";
1817 case EM_SH: return "Renesas / SuperH SH";
1818 case EM_SPARCV9: return "Sparc v9";
1819 case EM_TRICORE: return "Siemens Tricore";
1820 case EM_ARC: return "ARC";
1821 case EM_H8_300: return "Renesas H8/300";
1822 case EM_H8_300H: return "Renesas H8/300H";
1823 case EM_H8S: return "Renesas H8S";
1824 case EM_H8_500: return "Renesas H8/500";
1825 case EM_IA_64: return "Intel IA-64";
1826 case EM_MIPS_X: return "Stanford MIPS-X";
1827 case EM_COLDFIRE: return "Motorola Coldfire";
1828 case EM_68HC12: return "Motorola M68HC12";
1829 case EM_ALPHA: return "Alpha";
1830 case EM_CYGNUS_D10V:
1831 case EM_D10V: return "d10v";
1832 case EM_CYGNUS_D30V:
1833 case EM_D30V: return "d30v";
1834 case EM_CYGNUS_M32R:
1835 case EM_M32R: return "Renesas M32R (formerly Mitsubishi M32r)";
1836 case EM_CYGNUS_V850:
1837 case EM_V850: return "NEC v850";
1838 case EM_CYGNUS_MN10300:
1839 case EM_MN10300: return "mn10300";
1840 case EM_CYGNUS_MN10200:
1841 case EM_MN10200: return "mn10200";
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:
2240 strcat (buf, ", cf, isa ");
2243 strcat (buf, additional);
2244 if (e_flags & EF_M68K_CF_FLOAT)
2245 strcat (buf, ", float");
2246 switch (e_flags & EF_M68K_CF_MAC_MASK)
2251 case EF_M68K_CF_MAC:
2254 case EF_M68K_CF_EMAC:
2267 if (e_flags & EF_PPC_EMB)
2268 strcat (buf, ", emb");
2270 if (e_flags & EF_PPC_RELOCATABLE)
2271 strcat (buf, ", relocatable");
2273 if (e_flags & EF_PPC_RELOCATABLE_LIB)
2274 strcat (buf, ", relocatable-lib");
2278 case EM_CYGNUS_V850:
2279 switch (e_flags & EF_V850_ARCH)
2282 strcat (buf, ", v850e1");
2285 strcat (buf, ", v850e");
2288 strcat (buf, ", v850");
2291 strcat (buf, ", unknown v850 architecture variant");
2297 case EM_CYGNUS_M32R:
2298 if ((e_flags & EF_M32R_ARCH) == E_M32R_ARCH)
2299 strcat (buf, ", m32r");
2303 case EM_MIPS_RS3_LE:
2304 if (e_flags & EF_MIPS_NOREORDER)
2305 strcat (buf, ", noreorder");
2307 if (e_flags & EF_MIPS_PIC)
2308 strcat (buf, ", pic");
2310 if (e_flags & EF_MIPS_CPIC)
2311 strcat (buf, ", cpic");
2313 if (e_flags & EF_MIPS_UCODE)
2314 strcat (buf, ", ugen_reserved");
2316 if (e_flags & EF_MIPS_ABI2)
2317 strcat (buf, ", abi2");
2319 if (e_flags & EF_MIPS_OPTIONS_FIRST)
2320 strcat (buf, ", odk first");
2322 if (e_flags & EF_MIPS_32BITMODE)
2323 strcat (buf, ", 32bitmode");
2325 switch ((e_flags & EF_MIPS_MACH))
2327 case E_MIPS_MACH_3900: strcat (buf, ", 3900"); break;
2328 case E_MIPS_MACH_4010: strcat (buf, ", 4010"); break;
2329 case E_MIPS_MACH_4100: strcat (buf, ", 4100"); break;
2330 case E_MIPS_MACH_4111: strcat (buf, ", 4111"); break;
2331 case E_MIPS_MACH_4120: strcat (buf, ", 4120"); break;
2332 case E_MIPS_MACH_4650: strcat (buf, ", 4650"); break;
2333 case E_MIPS_MACH_5400: strcat (buf, ", 5400"); break;
2334 case E_MIPS_MACH_5500: strcat (buf, ", 5500"); break;
2335 case E_MIPS_MACH_SB1: strcat (buf, ", sb1"); break;
2336 case E_MIPS_MACH_9000: strcat (buf, ", 9000"); break;
2337 case E_MIPS_MACH_LS2E: strcat (buf, ", loongson-2e"); break;
2338 case E_MIPS_MACH_LS2F: strcat (buf, ", loongson-2f"); break;
2339 case E_MIPS_MACH_OCTEON: strcat (buf, ", octeon"); break;
2340 case E_MIPS_MACH_OCTEON2: strcat (buf, ", octeon2"); break;
2341 case E_MIPS_MACH_XLR: strcat (buf, ", xlr"); break;
2343 /* We simply ignore the field in this case to avoid confusion:
2344 MIPS ELF does not specify EF_MIPS_MACH, it is a GNU
2347 default: strcat (buf, ", unknown CPU"); break;
2350 switch ((e_flags & EF_MIPS_ABI))
2352 case E_MIPS_ABI_O32: strcat (buf, ", o32"); break;
2353 case E_MIPS_ABI_O64: strcat (buf, ", o64"); break;
2354 case E_MIPS_ABI_EABI32: strcat (buf, ", eabi32"); break;
2355 case E_MIPS_ABI_EABI64: strcat (buf, ", eabi64"); break;
2357 /* We simply ignore the field in this case to avoid confusion:
2358 MIPS ELF does not specify EF_MIPS_ABI, it is a GNU extension.
2359 This means it is likely to be an o32 file, but not for
2362 default: strcat (buf, ", unknown ABI"); break;
2365 if (e_flags & EF_MIPS_ARCH_ASE_MDMX)
2366 strcat (buf, ", mdmx");
2368 if (e_flags & EF_MIPS_ARCH_ASE_M16)
2369 strcat (buf, ", mips16");
2371 switch ((e_flags & EF_MIPS_ARCH))
2373 case E_MIPS_ARCH_1: strcat (buf, ", mips1"); break;
2374 case E_MIPS_ARCH_2: strcat (buf, ", mips2"); break;
2375 case E_MIPS_ARCH_3: strcat (buf, ", mips3"); break;
2376 case E_MIPS_ARCH_4: strcat (buf, ", mips4"); break;
2377 case E_MIPS_ARCH_5: strcat (buf, ", mips5"); break;
2378 case E_MIPS_ARCH_32: strcat (buf, ", mips32"); break;
2379 case E_MIPS_ARCH_32R2: strcat (buf, ", mips32r2"); break;
2380 case E_MIPS_ARCH_64: strcat (buf, ", mips64"); break;
2381 case E_MIPS_ARCH_64R2: strcat (buf, ", mips64r2"); break;
2382 default: strcat (buf, ", unknown ISA"); break;
2388 switch ((e_flags & EF_SH_MACH_MASK))
2390 case EF_SH1: strcat (buf, ", sh1"); break;
2391 case EF_SH2: strcat (buf, ", sh2"); break;
2392 case EF_SH3: strcat (buf, ", sh3"); break;
2393 case EF_SH_DSP: strcat (buf, ", sh-dsp"); break;
2394 case EF_SH3_DSP: strcat (buf, ", sh3-dsp"); break;
2395 case EF_SH4AL_DSP: strcat (buf, ", sh4al-dsp"); break;
2396 case EF_SH3E: strcat (buf, ", sh3e"); break;
2397 case EF_SH4: strcat (buf, ", sh4"); break;
2398 case EF_SH5: strcat (buf, ", sh5"); break;
2399 case EF_SH2E: strcat (buf, ", sh2e"); break;
2400 case EF_SH4A: strcat (buf, ", sh4a"); break;
2401 case EF_SH2A: strcat (buf, ", sh2a"); break;
2402 case EF_SH4_NOFPU: strcat (buf, ", sh4-nofpu"); break;
2403 case EF_SH4A_NOFPU: strcat (buf, ", sh4a-nofpu"); break;
2404 case EF_SH2A_NOFPU: strcat (buf, ", sh2a-nofpu"); break;
2405 case EF_SH3_NOMMU: strcat (buf, ", sh3-nommu"); break;
2406 case EF_SH4_NOMMU_NOFPU: strcat (buf, ", sh4-nommu-nofpu"); break;
2407 case EF_SH2A_SH4_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh4-nommu-nofpu"); break;
2408 case EF_SH2A_SH3_NOFPU: strcat (buf, ", sh2a-nofpu-or-sh3-nommu"); break;
2409 case EF_SH2A_SH4: strcat (buf, ", sh2a-or-sh4"); break;
2410 case EF_SH2A_SH3E: strcat (buf, ", sh2a-or-sh3e"); break;
2411 default: strcat (buf, ", unknown ISA"); break;
2417 if (e_flags & EF_SPARC_32PLUS)
2418 strcat (buf, ", v8+");
2420 if (e_flags & EF_SPARC_SUN_US1)
2421 strcat (buf, ", ultrasparcI");
2423 if (e_flags & EF_SPARC_SUN_US3)
2424 strcat (buf, ", ultrasparcIII");
2426 if (e_flags & EF_SPARC_HAL_R1)
2427 strcat (buf, ", halr1");
2429 if (e_flags & EF_SPARC_LEDATA)
2430 strcat (buf, ", ledata");
2432 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO)
2433 strcat (buf, ", tso");
2435 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO)
2436 strcat (buf, ", pso");
2438 if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO)
2439 strcat (buf, ", rmo");
2443 switch (e_flags & EF_PARISC_ARCH)
2445 case EFA_PARISC_1_0:
2446 strcpy (buf, ", PA-RISC 1.0");
2448 case EFA_PARISC_1_1:
2449 strcpy (buf, ", PA-RISC 1.1");
2451 case EFA_PARISC_2_0:
2452 strcpy (buf, ", PA-RISC 2.0");
2457 if (e_flags & EF_PARISC_TRAPNIL)
2458 strcat (buf, ", trapnil");
2459 if (e_flags & EF_PARISC_EXT)
2460 strcat (buf, ", ext");
2461 if (e_flags & EF_PARISC_LSB)
2462 strcat (buf, ", lsb");
2463 if (e_flags & EF_PARISC_WIDE)
2464 strcat (buf, ", wide");
2465 if (e_flags & EF_PARISC_NO_KABP)
2466 strcat (buf, ", no kabp");
2467 if (e_flags & EF_PARISC_LAZYSWAP)
2468 strcat (buf, ", lazyswap");
2473 if ((e_flags & EF_PICOJAVA_NEWCALLS) == EF_PICOJAVA_NEWCALLS)
2474 strcat (buf, ", new calling convention");
2476 if ((e_flags & EF_PICOJAVA_GNUCALLS) == EF_PICOJAVA_GNUCALLS)
2477 strcat (buf, ", gnu calling convention");
2481 if ((e_flags & EF_IA_64_ABI64))
2482 strcat (buf, ", 64-bit");
2484 strcat (buf, ", 32-bit");
2485 if ((e_flags & EF_IA_64_REDUCEDFP))
2486 strcat (buf, ", reduced fp model");
2487 if ((e_flags & EF_IA_64_NOFUNCDESC_CONS_GP))
2488 strcat (buf, ", no function descriptors, constant gp");
2489 else if ((e_flags & EF_IA_64_CONS_GP))
2490 strcat (buf, ", constant gp");
2491 if ((e_flags & EF_IA_64_ABSOLUTE))
2492 strcat (buf, ", absolute");
2496 if ((e_flags & EF_VAX_NONPIC))
2497 strcat (buf, ", non-PIC");
2498 if ((e_flags & EF_VAX_DFLOAT))
2499 strcat (buf, ", D-Float");
2500 if ((e_flags & EF_VAX_GFLOAT))
2501 strcat (buf, ", G-Float");
2505 if (e_flags & E_FLAG_RX_64BIT_DOUBLES)
2506 strcat (buf, ", 64-bit doubles");
2507 if (e_flags & E_FLAG_RX_DSP)
2508 strcat (buf, ", dsp");
2516 get_osabi_name (unsigned int osabi)
2518 static char buff[32];
2522 case ELFOSABI_NONE: return "UNIX - System V";
2523 case ELFOSABI_HPUX: return "UNIX - HP-UX";
2524 case ELFOSABI_NETBSD: return "UNIX - NetBSD";
2525 case ELFOSABI_LINUX: return "UNIX - Linux";
2526 case ELFOSABI_HURD: return "GNU/Hurd";
2527 case ELFOSABI_SOLARIS: return "UNIX - Solaris";
2528 case ELFOSABI_AIX: return "UNIX - AIX";
2529 case ELFOSABI_IRIX: return "UNIX - IRIX";
2530 case ELFOSABI_FREEBSD: return "UNIX - FreeBSD";
2531 case ELFOSABI_TRU64: return "UNIX - TRU64";
2532 case ELFOSABI_MODESTO: return "Novell - Modesto";
2533 case ELFOSABI_OPENBSD: return "UNIX - OpenBSD";
2534 case ELFOSABI_OPENVMS: return "VMS - OpenVMS";
2535 case ELFOSABI_NSK: return "HP - Non-Stop Kernel";
2536 case ELFOSABI_AROS: return "AROS";
2537 case ELFOSABI_FENIXOS: return "FenixOS";
2538 case ELFOSABI_STANDALONE: return _("Standalone App");
2539 case ELFOSABI_ARM: return "ARM";
2541 snprintf (buff, sizeof (buff), _("<unknown: %x>"), osabi);
2547 get_arm_segment_type (unsigned long type)
2561 get_mips_segment_type (unsigned long type)
2565 case PT_MIPS_REGINFO:
2567 case PT_MIPS_RTPROC:
2569 case PT_MIPS_OPTIONS:
2579 get_parisc_segment_type (unsigned long type)
2583 case PT_HP_TLS: return "HP_TLS";
2584 case PT_HP_CORE_NONE: return "HP_CORE_NONE";
2585 case PT_HP_CORE_VERSION: return "HP_CORE_VERSION";
2586 case PT_HP_CORE_KERNEL: return "HP_CORE_KERNEL";
2587 case PT_HP_CORE_COMM: return "HP_CORE_COMM";
2588 case PT_HP_CORE_PROC: return "HP_CORE_PROC";
2589 case PT_HP_CORE_LOADABLE: return "HP_CORE_LOADABLE";
2590 case PT_HP_CORE_STACK: return "HP_CORE_STACK";
2591 case PT_HP_CORE_SHM: return "HP_CORE_SHM";
2592 case PT_HP_CORE_MMF: return "HP_CORE_MMF";
2593 case PT_HP_PARALLEL: return "HP_PARALLEL";
2594 case PT_HP_FASTBIND: return "HP_FASTBIND";
2595 case PT_HP_OPT_ANNOT: return "HP_OPT_ANNOT";
2596 case PT_HP_HSL_ANNOT: return "HP_HSL_ANNOT";
2597 case PT_HP_STACK: return "HP_STACK";
2598 case PT_HP_CORE_UTSNAME: return "HP_CORE_UTSNAME";
2599 case PT_PARISC_ARCHEXT: return "PARISC_ARCHEXT";
2600 case PT_PARISC_UNWIND: return "PARISC_UNWIND";
2601 case PT_PARISC_WEAKORDER: return "PARISC_WEAKORDER";
2610 get_ia64_segment_type (unsigned long type)
2614 case PT_IA_64_ARCHEXT: return "IA_64_ARCHEXT";
2615 case PT_IA_64_UNWIND: return "IA_64_UNWIND";
2616 case PT_HP_TLS: return "HP_TLS";
2617 case PT_IA_64_HP_OPT_ANOT: return "HP_OPT_ANNOT";
2618 case PT_IA_64_HP_HSL_ANOT: return "HP_HSL_ANNOT";
2619 case PT_IA_64_HP_STACK: return "HP_STACK";
2628 get_segment_type (unsigned long p_type)
2630 static char buff[32];
2634 case PT_NULL: return "NULL";
2635 case PT_LOAD: return "LOAD";
2636 case PT_DYNAMIC: return "DYNAMIC";
2637 case PT_INTERP: return "INTERP";
2638 case PT_NOTE: return "NOTE";
2639 case PT_SHLIB: return "SHLIB";
2640 case PT_PHDR: return "PHDR";
2641 case PT_TLS: return "TLS";
2643 case PT_GNU_EH_FRAME:
2644 return "GNU_EH_FRAME";
2645 case PT_GNU_STACK: return "GNU_STACK";
2646 case PT_GNU_RELRO: return "GNU_RELRO";
2649 if ((p_type >= PT_LOPROC) && (p_type <= PT_HIPROC))
2651 const char * result;
2653 switch (elf_header.e_machine)
2656 result = get_arm_segment_type (p_type);
2659 case EM_MIPS_RS3_LE:
2660 result = get_mips_segment_type (p_type);
2663 result = get_parisc_segment_type (p_type);
2666 result = get_ia64_segment_type (p_type);
2676 sprintf (buff, "LOPROC+%lx", p_type - PT_LOPROC);
2678 else if ((p_type >= PT_LOOS) && (p_type <= PT_HIOS))
2680 const char * result;
2682 switch (elf_header.e_machine)
2685 result = get_parisc_segment_type (p_type);
2688 result = get_ia64_segment_type (p_type);
2698 sprintf (buff, "LOOS+%lx", p_type - PT_LOOS);
2701 snprintf (buff, sizeof (buff), _("<unknown>: %lx"), p_type);
2708 get_mips_section_type_name (unsigned int sh_type)
2712 case SHT_MIPS_LIBLIST: return "MIPS_LIBLIST";
2713 case SHT_MIPS_MSYM: return "MIPS_MSYM";
2714 case SHT_MIPS_CONFLICT: return "MIPS_CONFLICT";
2715 case SHT_MIPS_GPTAB: return "MIPS_GPTAB";
2716 case SHT_MIPS_UCODE: return "MIPS_UCODE";
2717 case SHT_MIPS_DEBUG: return "MIPS_DEBUG";
2718 case SHT_MIPS_REGINFO: return "MIPS_REGINFO";
2719 case SHT_MIPS_PACKAGE: return "MIPS_PACKAGE";
2720 case SHT_MIPS_PACKSYM: return "MIPS_PACKSYM";
2721 case SHT_MIPS_RELD: return "MIPS_RELD";
2722 case SHT_MIPS_IFACE: return "MIPS_IFACE";
2723 case SHT_MIPS_CONTENT: return "MIPS_CONTENT";
2724 case SHT_MIPS_OPTIONS: return "MIPS_OPTIONS";
2725 case SHT_MIPS_SHDR: return "MIPS_SHDR";
2726 case SHT_MIPS_FDESC: return "MIPS_FDESC";
2727 case SHT_MIPS_EXTSYM: return "MIPS_EXTSYM";
2728 case SHT_MIPS_DENSE: return "MIPS_DENSE";
2729 case SHT_MIPS_PDESC: return "MIPS_PDESC";
2730 case SHT_MIPS_LOCSYM: return "MIPS_LOCSYM";
2731 case SHT_MIPS_AUXSYM: return "MIPS_AUXSYM";
2732 case SHT_MIPS_OPTSYM: return "MIPS_OPTSYM";
2733 case SHT_MIPS_LOCSTR: return "MIPS_LOCSTR";
2734 case SHT_MIPS_LINE: return "MIPS_LINE";
2735 case SHT_MIPS_RFDESC: return "MIPS_RFDESC";
2736 case SHT_MIPS_DELTASYM: return "MIPS_DELTASYM";
2737 case SHT_MIPS_DELTAINST: return "MIPS_DELTAINST";
2738 case SHT_MIPS_DELTACLASS: return "MIPS_DELTACLASS";
2739 case SHT_MIPS_DWARF: return "MIPS_DWARF";
2740 case SHT_MIPS_DELTADECL: return "MIPS_DELTADECL";
2741 case SHT_MIPS_SYMBOL_LIB: return "MIPS_SYMBOL_LIB";
2742 case SHT_MIPS_EVENTS: return "MIPS_EVENTS";
2743 case SHT_MIPS_TRANSLATE: return "MIPS_TRANSLATE";
2744 case SHT_MIPS_PIXIE: return "MIPS_PIXIE";
2745 case SHT_MIPS_XLATE: return "MIPS_XLATE";
2746 case SHT_MIPS_XLATE_DEBUG: return "MIPS_XLATE_DEBUG";
2747 case SHT_MIPS_WHIRL: return "MIPS_WHIRL";
2748 case SHT_MIPS_EH_REGION: return "MIPS_EH_REGION";
2749 case SHT_MIPS_XLATE_OLD: return "MIPS_XLATE_OLD";
2750 case SHT_MIPS_PDR_EXCEPTION: return "MIPS_PDR_EXCEPTION";
2758 get_parisc_section_type_name (unsigned int sh_type)
2762 case SHT_PARISC_EXT: return "PARISC_EXT";
2763 case SHT_PARISC_UNWIND: return "PARISC_UNWIND";
2764 case SHT_PARISC_DOC: return "PARISC_DOC";
2765 case SHT_PARISC_ANNOT: return "PARISC_ANNOT";
2766 case SHT_PARISC_SYMEXTN: return "PARISC_SYMEXTN";
2767 case SHT_PARISC_STUBS: return "PARISC_STUBS";
2768 case SHT_PARISC_DLKM: return "PARISC_DLKM";
2776 get_ia64_section_type_name (unsigned int sh_type)
2778 /* If the top 8 bits are 0x78 the next 8 are the os/abi ID. */
2779 if ((sh_type & 0xFF000000) == SHT_IA_64_LOPSREG)
2780 return get_osabi_name ((sh_type & 0x00FF0000) >> 16);
2784 case SHT_IA_64_EXT: return "IA_64_EXT";
2785 case SHT_IA_64_UNWIND: return "IA_64_UNWIND";
2786 case SHT_IA_64_PRIORITY_INIT: return "IA_64_PRIORITY_INIT";
2787 case SHT_IA_64_VMS_TRACE: return "VMS_TRACE";
2788 case SHT_IA_64_VMS_TIE_SIGNATURES: return "VMS_TIE_SIGNATURES";
2789 case SHT_IA_64_VMS_DEBUG: return "VMS_DEBUG";
2790 case SHT_IA_64_VMS_DEBUG_STR: return "VMS_DEBUG_STR";
2791 case SHT_IA_64_VMS_LINKAGES: return "VMS_LINKAGES";
2792 case SHT_IA_64_VMS_SYMBOL_VECTOR: return "VMS_SYMBOL_VECTOR";
2793 case SHT_IA_64_VMS_FIXUP: return "VMS_FIXUP";
2801 get_x86_64_section_type_name (unsigned int sh_type)
2805 case SHT_X86_64_UNWIND: return "X86_64_UNWIND";
2813 get_arm_section_type_name (unsigned int sh_type)
2817 case SHT_ARM_EXIDX: return "ARM_EXIDX";
2818 case SHT_ARM_PREEMPTMAP: return "ARM_PREEMPTMAP";
2819 case SHT_ARM_ATTRIBUTES: return "ARM_ATTRIBUTES";
2820 case SHT_ARM_DEBUGOVERLAY: return "ARM_DEBUGOVERLAY";
2821 case SHT_ARM_OVERLAYSECTION: return "ARM_OVERLAYSECTION";
2829 get_section_type_name (unsigned int sh_type)
2831 static char buff[32];
2835 case SHT_NULL: return "NULL";
2836 case SHT_PROGBITS: return "PROGBITS";
2837 case SHT_SYMTAB: return "SYMTAB";
2838 case SHT_STRTAB: return "STRTAB";
2839 case SHT_RELA: return "RELA";
2840 case SHT_HASH: return "HASH";
2841 case SHT_DYNAMIC: return "DYNAMIC";
2842 case SHT_NOTE: return "NOTE";
2843 case SHT_NOBITS: return "NOBITS";
2844 case SHT_REL: return "REL";
2845 case SHT_SHLIB: return "SHLIB";
2846 case SHT_DYNSYM: return "DYNSYM";
2847 case SHT_INIT_ARRAY: return "INIT_ARRAY";
2848 case SHT_FINI_ARRAY: return "FINI_ARRAY";
2849 case SHT_PREINIT_ARRAY: return "PREINIT_ARRAY";
2850 case SHT_GNU_HASH: return "GNU_HASH";
2851 case SHT_GROUP: return "GROUP";
2852 case SHT_SYMTAB_SHNDX: return "SYMTAB SECTION INDICIES";
2853 case SHT_GNU_verdef: return "VERDEF";
2854 case SHT_GNU_verneed: return "VERNEED";
2855 case SHT_GNU_versym: return "VERSYM";
2856 case 0x6ffffff0: return "VERSYM";
2857 case 0x6ffffffc: return "VERDEF";
2858 case 0x7ffffffd: return "AUXILIARY";
2859 case 0x7fffffff: return "FILTER";
2860 case SHT_GNU_LIBLIST: return "GNU_LIBLIST";
2863 if ((sh_type >= SHT_LOPROC) && (sh_type <= SHT_HIPROC))
2865 const char * result;
2867 switch (elf_header.e_machine)
2870 case EM_MIPS_RS3_LE:
2871 result = get_mips_section_type_name (sh_type);
2874 result = get_parisc_section_type_name (sh_type);
2877 result = get_ia64_section_type_name (sh_type);
2881 result = get_x86_64_section_type_name (sh_type);
2884 result = get_arm_section_type_name (sh_type);
2894 sprintf (buff, "LOPROC+%x", sh_type - SHT_LOPROC);
2896 else if ((sh_type >= SHT_LOOS) && (sh_type <= SHT_HIOS))
2898 const char * result;
2900 switch (elf_header.e_machine)
2903 result = get_ia64_section_type_name (sh_type);
2913 sprintf (buff, "LOOS+%x", sh_type - SHT_LOOS);
2915 else if ((sh_type >= SHT_LOUSER) && (sh_type <= SHT_HIUSER))
2916 sprintf (buff, "LOUSER+%x", sh_type - SHT_LOUSER);
2918 snprintf (buff, sizeof (buff), _("<unknown>: %x"), sh_type);
2924 #define OPTION_DEBUG_DUMP 512
2926 static struct option options[] =
2928 {"all", no_argument, 0, 'a'},
2929 {"file-header", no_argument, 0, 'h'},
2930 {"program-headers", no_argument, 0, 'l'},
2931 {"headers", no_argument, 0, 'e'},
2932 {"histogram", no_argument, 0, 'I'},
2933 {"segments", no_argument, 0, 'l'},
2934 {"sections", no_argument, 0, 'S'},
2935 {"section-headers", no_argument, 0, 'S'},
2936 {"section-groups", no_argument, 0, 'g'},
2937 {"section-details", no_argument, 0, 't'},
2938 {"full-section-name",no_argument, 0, 'N'},
2939 {"symbols", no_argument, 0, 's'},
2940 {"syms", no_argument, 0, 's'},
2941 {"relocs", no_argument, 0, 'r'},
2942 {"notes", no_argument, 0, 'n'},
2943 {"dynamic", no_argument, 0, 'd'},
2944 {"arch-specific", no_argument, 0, 'A'},
2945 {"version-info", no_argument, 0, 'V'},
2946 {"use-dynamic", no_argument, 0, 'D'},
2947 {"unwind", no_argument, 0, 'u'},
2948 {"archive-index", no_argument, 0, 'c'},
2949 {"hex-dump", required_argument, 0, 'x'},
2950 {"relocated-dump", required_argument, 0, 'R'},
2951 {"string-dump", required_argument, 0, 'p'},
2952 #ifdef SUPPORT_DISASSEMBLY
2953 {"instruction-dump", required_argument, 0, 'i'},
2955 {"debug-dump", optional_argument, 0, OPTION_DEBUG_DUMP},
2957 {"version", no_argument, 0, 'v'},
2958 {"wide", no_argument, 0, 'W'},
2959 {"help", no_argument, 0, 'H'},
2960 {0, no_argument, 0, 0}
2964 usage (FILE * stream)
2966 fprintf (stream, _("Usage: readelf <option(s)> elf-file(s)\n"));
2967 fprintf (stream, _(" Display information about the contents of ELF format files\n"));
2968 fprintf (stream, _(" Options are:\n\
2969 -a --all Equivalent to: -h -l -S -s -r -d -V -A -I\n\
2970 -h --file-header Display the ELF file header\n\
2971 -l --program-headers Display the program headers\n\
2972 --segments An alias for --program-headers\n\
2973 -S --section-headers Display the sections' header\n\
2974 --sections An alias for --section-headers\n\
2975 -g --section-groups Display the section groups\n\
2976 -t --section-details Display the section details\n\
2977 -e --headers Equivalent to: -h -l -S\n\
2978 -s --syms Display the symbol table\n\
2979 --symbols An alias for --syms\n\
2980 -n --notes Display the core notes (if present)\n\
2981 -r --relocs Display the relocations (if present)\n\
2982 -u --unwind Display the unwind info (if present)\n\
2983 -d --dynamic Display the dynamic section (if present)\n\
2984 -V --version-info Display the version sections (if present)\n\
2985 -A --arch-specific Display architecture specific information (if any).\n\
2986 -c --archive-index Display the symbol/file index in an archive\n\
2987 -D --use-dynamic Use the dynamic section info when displaying symbols\n\
2988 -x --hex-dump=<number|name>\n\
2989 Dump the contents of section <number|name> as bytes\n\
2990 -p --string-dump=<number|name>\n\
2991 Dump the contents of section <number|name> as strings\n\
2992 -R --relocated-dump=<number|name>\n\
2993 Dump the contents of section <number|name> as relocated bytes\n\
2994 -w[lLiaprmfFsoRt] or\n\
2995 --debug-dump[=rawline,=decodedline,=info,=abbrev,=pubnames,=aranges,=macro,=frames,\n\
2996 =frames-interp,=str,=loc,=Ranges,=pubtypes]\n\
2997 Display the contents of DWARF2 debug sections\n"));
2998 #ifdef SUPPORT_DISASSEMBLY
2999 fprintf (stream, _("\
3000 -i --instruction-dump=<number|name>\n\
3001 Disassemble the contents of section <number|name>\n"));
3003 fprintf (stream, _("\
3004 -I --histogram Display histogram of bucket list lengths\n\
3005 -W --wide Allow output width to exceed 80 characters\n\
3006 @<file> Read options from <file>\n\
3007 -H --help Display this information\n\
3008 -v --version Display the version number of readelf\n"));
3010 if (REPORT_BUGS_TO[0] && stream == stdout)
3011 fprintf (stdout, _("Report bugs to %s\n"), REPORT_BUGS_TO);
3013 exit (stream == stdout ? 0 : 1);
3016 /* Record the fact that the user wants the contents of section number
3017 SECTION to be displayed using the method(s) encoded as flags bits
3018 in TYPE. Note, TYPE can be zero if we are creating the array for
3022 request_dump_bynumber (unsigned int section, dump_type type)
3024 if (section >= num_dump_sects)
3026 dump_type * new_dump_sects;
3028 new_dump_sects = (dump_type *) calloc (section + 1,
3029 sizeof (* dump_sects));
3031 if (new_dump_sects == NULL)
3032 error (_("Out of memory allocating dump request table.\n"));
3035 /* Copy current flag settings. */
3036 memcpy (new_dump_sects, dump_sects, num_dump_sects * sizeof (* dump_sects));
3040 dump_sects = new_dump_sects;
3041 num_dump_sects = section + 1;
3046 dump_sects[section] |= type;
3051 /* Request a dump by section name. */
3054 request_dump_byname (const char * section, dump_type type)
3056 struct dump_list_entry * new_request;
3058 new_request = (struct dump_list_entry *)
3059 malloc (sizeof (struct dump_list_entry));
3061 error (_("Out of memory allocating dump request table.\n"));
3063 new_request->name = strdup (section);
3064 if (!new_request->name)
3065 error (_("Out of memory allocating dump request table.\n"));
3067 new_request->type = type;
3069 new_request->next = dump_sects_byname;
3070 dump_sects_byname = new_request;
3074 request_dump (dump_type type)
3080 section = strtoul (optarg, & cp, 0);
3082 if (! *cp && section >= 0)
3083 request_dump_bynumber (section, type);
3085 request_dump_byname (optarg, type);
3090 parse_args (int argc, char ** argv)
3097 while ((c = getopt_long
3098 (argc, argv, "ADHINR:SVWacdeghi:lnp:rstuvw::x:", options, NULL)) != EOF)
3116 do_section_groups++;
3124 do_section_groups++;
3129 do_section_details++;
3173 request_dump (HEX_DUMP);
3176 request_dump (STRING_DUMP);
3179 request_dump (RELOC_DUMP);
3186 dwarf_select_sections_all ();
3191 dwarf_select_sections_by_letters (optarg);
3194 case OPTION_DEBUG_DUMP:
3201 dwarf_select_sections_by_names (optarg);
3204 #ifdef SUPPORT_DISASSEMBLY
3206 request_dump (DISASS_DUMP);
3210 print_version (program_name);
3219 /* xgettext:c-format */
3220 error (_("Invalid option '-%c'\n"), c);
3227 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
3228 && !do_segments && !do_header && !do_dump && !do_version
3229 && !do_histogram && !do_debugging && !do_arch && !do_notes
3230 && !do_section_groups && !do_archive_index)
3234 warn (_("Nothing to do.\n"));
3240 get_elf_class (unsigned int elf_class)
3242 static char buff[32];
3246 case ELFCLASSNONE: return _("none");
3247 case ELFCLASS32: return "ELF32";
3248 case ELFCLASS64: return "ELF64";
3250 snprintf (buff, sizeof (buff), _("<unknown: %x>"), elf_class);
3256 get_data_encoding (unsigned int encoding)
3258 static char buff[32];
3262 case ELFDATANONE: return _("none");
3263 case ELFDATA2LSB: return _("2's complement, little endian");
3264 case ELFDATA2MSB: return _("2's complement, big endian");
3266 snprintf (buff, sizeof (buff), _("<unknown: %x>"), encoding);
3271 /* Decode the data held in 'elf_header'. */
3274 process_file_header (void)
3276 if ( elf_header.e_ident[EI_MAG0] != ELFMAG0
3277 || elf_header.e_ident[EI_MAG1] != ELFMAG1
3278 || elf_header.e_ident[EI_MAG2] != ELFMAG2
3279 || elf_header.e_ident[EI_MAG3] != ELFMAG3)
3282 (_("Not an ELF file - it has the wrong magic bytes at the start\n"));
3286 init_dwarf_regnames (elf_header.e_machine);
3292 printf (_("ELF Header:\n"));
3293 printf (_(" Magic: "));
3294 for (i = 0; i < EI_NIDENT; i++)
3295 printf ("%2.2x ", elf_header.e_ident[i]);
3297 printf (_(" Class: %s\n"),
3298 get_elf_class (elf_header.e_ident[EI_CLASS]));
3299 printf (_(" Data: %s\n"),
3300 get_data_encoding (elf_header.e_ident[EI_DATA]));
3301 printf (_(" Version: %d %s\n"),
3302 elf_header.e_ident[EI_VERSION],
3303 (elf_header.e_ident[EI_VERSION] == EV_CURRENT
3305 : (elf_header.e_ident[EI_VERSION] != EV_NONE
3308 printf (_(" OS/ABI: %s\n"),
3309 get_osabi_name (elf_header.e_ident[EI_OSABI]));
3310 printf (_(" ABI Version: %d\n"),
3311 elf_header.e_ident[EI_ABIVERSION]);
3312 printf (_(" Type: %s\n"),
3313 get_file_type (elf_header.e_type));
3314 printf (_(" Machine: %s\n"),
3315 get_machine_name (elf_header.e_machine));
3316 printf (_(" Version: 0x%lx\n"),
3317 (unsigned long) elf_header.e_version);
3319 printf (_(" Entry point address: "));
3320 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
3321 printf (_("\n Start of program headers: "));
3322 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
3323 printf (_(" (bytes into file)\n Start of section headers: "));
3324 print_vma ((bfd_vma) elf_header.e_shoff, DEC);
3325 printf (_(" (bytes into file)\n"));
3327 printf (_(" Flags: 0x%lx%s\n"),
3328 (unsigned long) elf_header.e_flags,
3329 get_machine_flags (elf_header.e_flags, elf_header.e_machine));
3330 printf (_(" Size of this header: %ld (bytes)\n"),
3331 (long) elf_header.e_ehsize);
3332 printf (_(" Size of program headers: %ld (bytes)\n"),
3333 (long) elf_header.e_phentsize);
3334 printf (_(" Number of program headers: %ld\n"),
3335 (long) elf_header.e_phnum);
3336 printf (_(" Size of section headers: %ld (bytes)\n"),
3337 (long) elf_header.e_shentsize);
3338 printf (_(" Number of section headers: %ld"),
3339 (long) elf_header.e_shnum);
3340 if (section_headers != NULL && elf_header.e_shnum == SHN_UNDEF)
3341 printf (" (%ld)", (long) section_headers[0].sh_size);
3342 putc ('\n', stdout);
3343 printf (_(" Section header string table index: %ld"),
3344 (long) elf_header.e_shstrndx);
3345 if (section_headers != NULL
3346 && elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
3347 printf (" (%u)", section_headers[0].sh_link);
3348 else if (elf_header.e_shstrndx != SHN_UNDEF
3349 && elf_header.e_shstrndx >= elf_header.e_shnum)
3350 printf (" <corrupt: out of range>");
3351 putc ('\n', stdout);
3354 if (section_headers != NULL)
3356 if (elf_header.e_shnum == SHN_UNDEF)
3357 elf_header.e_shnum = section_headers[0].sh_size;
3358 if (elf_header.e_shstrndx == (SHN_XINDEX & 0xffff))
3359 elf_header.e_shstrndx = section_headers[0].sh_link;
3360 else if (elf_header.e_shstrndx >= elf_header.e_shnum)
3361 elf_header.e_shstrndx = SHN_UNDEF;
3362 free (section_headers);
3363 section_headers = NULL;
3371 get_32bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
3373 Elf32_External_Phdr * phdrs;
3374 Elf32_External_Phdr * external;
3375 Elf_Internal_Phdr * internal;
3378 phdrs = (Elf32_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
3379 elf_header.e_phentsize,
3381 _("program headers"));
3385 for (i = 0, internal = pheaders, external = phdrs;
3386 i < elf_header.e_phnum;
3387 i++, internal++, external++)
3389 internal->p_type = BYTE_GET (external->p_type);
3390 internal->p_offset = BYTE_GET (external->p_offset);
3391 internal->p_vaddr = BYTE_GET (external->p_vaddr);
3392 internal->p_paddr = BYTE_GET (external->p_paddr);
3393 internal->p_filesz = BYTE_GET (external->p_filesz);
3394 internal->p_memsz = BYTE_GET (external->p_memsz);
3395 internal->p_flags = BYTE_GET (external->p_flags);
3396 internal->p_align = BYTE_GET (external->p_align);
3405 get_64bit_program_headers (FILE * file, Elf_Internal_Phdr * pheaders)
3407 Elf64_External_Phdr * phdrs;
3408 Elf64_External_Phdr * external;
3409 Elf_Internal_Phdr * internal;
3412 phdrs = (Elf64_External_Phdr *) get_data (NULL, file, elf_header.e_phoff,
3413 elf_header.e_phentsize,
3415 _("program headers"));
3419 for (i = 0, internal = pheaders, external = phdrs;
3420 i < elf_header.e_phnum;
3421 i++, internal++, external++)
3423 internal->p_type = BYTE_GET (external->p_type);
3424 internal->p_flags = BYTE_GET (external->p_flags);
3425 internal->p_offset = BYTE_GET (external->p_offset);
3426 internal->p_vaddr = BYTE_GET (external->p_vaddr);
3427 internal->p_paddr = BYTE_GET (external->p_paddr);
3428 internal->p_filesz = BYTE_GET (external->p_filesz);
3429 internal->p_memsz = BYTE_GET (external->p_memsz);
3430 internal->p_align = BYTE_GET (external->p_align);
3438 /* Returns 1 if the program headers were read into `program_headers'. */
3441 get_program_headers (FILE * file)
3443 Elf_Internal_Phdr * phdrs;
3445 /* Check cache of prior read. */
3446 if (program_headers != NULL)
3449 phdrs = (Elf_Internal_Phdr *) cmalloc (elf_header.e_phnum,
3450 sizeof (Elf_Internal_Phdr));
3454 error (_("Out of memory\n"));
3459 ? get_32bit_program_headers (file, phdrs)
3460 : get_64bit_program_headers (file, phdrs))
3462 program_headers = phdrs;
3470 /* Returns 1 if the program headers were loaded. */
3473 process_program_headers (FILE * file)
3475 Elf_Internal_Phdr * segment;
3478 if (elf_header.e_phnum == 0)
3481 printf (_("\nThere are no program headers in this file.\n"));
3485 if (do_segments && !do_header)
3487 printf (_("\nElf file type is %s\n"), get_file_type (elf_header.e_type));
3488 printf (_("Entry point "));
3489 print_vma ((bfd_vma) elf_header.e_entry, PREFIX_HEX);
3490 printf (_("\nThere are %d program headers, starting at offset "),
3491 elf_header.e_phnum);
3492 print_vma ((bfd_vma) elf_header.e_phoff, DEC);
3496 if (! get_program_headers (file))
3501 if (elf_header.e_phnum > 1)
3502 printf (_("\nProgram Headers:\n"));
3504 printf (_("\nProgram Headers:\n"));
3508 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3511 (_(" Type Offset VirtAddr PhysAddr FileSiz MemSiz Flg Align\n"));
3515 (_(" Type Offset VirtAddr PhysAddr\n"));
3517 (_(" FileSiz MemSiz Flags Align\n"));
3524 for (i = 0, segment = program_headers;
3525 i < elf_header.e_phnum;
3530 printf (" %-14.14s ", get_segment_type (segment->p_type));
3534 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
3535 printf ("0x%8.8lx ", (unsigned long) segment->p_vaddr);
3536 printf ("0x%8.8lx ", (unsigned long) segment->p_paddr);
3537 printf ("0x%5.5lx ", (unsigned long) segment->p_filesz);
3538 printf ("0x%5.5lx ", (unsigned long) segment->p_memsz);
3540 (segment->p_flags & PF_R ? 'R' : ' '),
3541 (segment->p_flags & PF_W ? 'W' : ' '),
3542 (segment->p_flags & PF_X ? 'E' : ' '));
3543 printf ("%#lx", (unsigned long) segment->p_align);
3547 if ((unsigned long) segment->p_offset == segment->p_offset)
3548 printf ("0x%6.6lx ", (unsigned long) segment->p_offset);
3551 print_vma (segment->p_offset, FULL_HEX);
3555 print_vma (segment->p_vaddr, FULL_HEX);
3557 print_vma (segment->p_paddr, FULL_HEX);
3560 if ((unsigned long) segment->p_filesz == segment->p_filesz)
3561 printf ("0x%6.6lx ", (unsigned long) segment->p_filesz);
3564 print_vma (segment->p_filesz, FULL_HEX);
3568 if ((unsigned long) segment->p_memsz == segment->p_memsz)
3569 printf ("0x%6.6lx", (unsigned long) segment->p_memsz);
3572 print_vma (segment->p_offset, FULL_HEX);
3576 (segment->p_flags & PF_R ? 'R' : ' '),
3577 (segment->p_flags & PF_W ? 'W' : ' '),
3578 (segment->p_flags & PF_X ? 'E' : ' '));
3580 if ((unsigned long) segment->p_align == segment->p_align)
3581 printf ("%#lx", (unsigned long) segment->p_align);
3584 print_vma (segment->p_align, PREFIX_HEX);
3589 print_vma (segment->p_offset, FULL_HEX);
3591 print_vma (segment->p_vaddr, FULL_HEX);
3593 print_vma (segment->p_paddr, FULL_HEX);
3595 print_vma (segment->p_filesz, FULL_HEX);
3597 print_vma (segment->p_memsz, FULL_HEX);
3599 (segment->p_flags & PF_R ? 'R' : ' '),
3600 (segment->p_flags & PF_W ? 'W' : ' '),
3601 (segment->p_flags & PF_X ? 'E' : ' '));
3602 print_vma (segment->p_align, HEX);
3606 switch (segment->p_type)
3610 error (_("more than one dynamic segment\n"));
3612 /* By default, assume that the .dynamic section is the first
3613 section in the DYNAMIC segment. */
3614 dynamic_addr = segment->p_offset;
3615 dynamic_size = segment->p_filesz;
3617 /* Try to locate the .dynamic section. If there is
3618 a section header table, we can easily locate it. */
3619 if (section_headers != NULL)
3621 Elf_Internal_Shdr * sec;
3623 sec = find_section (".dynamic");
3624 if (sec == NULL || sec->sh_size == 0)
3626 error (_("no .dynamic section in the dynamic segment\n"));
3630 if (sec->sh_type == SHT_NOBITS)
3636 dynamic_addr = sec->sh_offset;
3637 dynamic_size = sec->sh_size;
3639 if (dynamic_addr < segment->p_offset
3640 || dynamic_addr > segment->p_offset + segment->p_filesz)
3641 warn (_("the .dynamic section is not contained"
3642 " within the dynamic segment\n"));
3643 else if (dynamic_addr > segment->p_offset)
3644 warn (_("the .dynamic section is not the first section"
3645 " in the dynamic segment.\n"));
3650 if (fseek (file, archive_file_offset + (long) segment->p_offset,
3652 error (_("Unable to find program interpreter name\n"));
3656 int ret = snprintf (fmt, sizeof (fmt), "%%%ds", PATH_MAX);
3658 if (ret >= (int) sizeof (fmt) || ret < 0)
3659 error (_("Internal error: failed to create format string to display program interpreter\n"));
3661 program_interpreter[0] = 0;
3662 if (fscanf (file, fmt, program_interpreter) <= 0)
3663 error (_("Unable to read program interpreter name\n"));
3666 printf (_("\n [Requesting program interpreter: %s]"),
3667 program_interpreter);
3673 putc ('\n', stdout);
3676 if (do_segments && section_headers != NULL && string_table != NULL)
3678 printf (_("\n Section to Segment mapping:\n"));
3679 printf (_(" Segment Sections...\n"));
3681 for (i = 0; i < elf_header.e_phnum; i++)
3684 Elf_Internal_Shdr * section;
3686 segment = program_headers + i;
3687 section = section_headers + 1;
3689 printf (" %2.2d ", i);
3691 for (j = 1; j < elf_header.e_shnum; j++, section++)
3693 if (ELF_IS_SECTION_IN_SEGMENT_MEMORY (section, segment))
3694 printf ("%s ", SECTION_NAME (section));
3705 /* Find the file offset corresponding to VMA by using the program headers. */
3708 offset_from_vma (FILE * file, bfd_vma vma, bfd_size_type size)
3710 Elf_Internal_Phdr * seg;
3712 if (! get_program_headers (file))
3714 warn (_("Cannot interpret virtual addresses without program headers.\n"));
3718 for (seg = program_headers;
3719 seg < program_headers + elf_header.e_phnum;
3722 if (seg->p_type != PT_LOAD)
3725 if (vma >= (seg->p_vaddr & -seg->p_align)
3726 && vma + size <= seg->p_vaddr + seg->p_filesz)
3727 return vma - seg->p_vaddr + seg->p_offset;
3730 warn (_("Virtual address 0x%lx not located in any PT_LOAD segment.\n"),
3731 (unsigned long) vma);
3737 get_32bit_section_headers (FILE * file, unsigned int num)
3739 Elf32_External_Shdr * shdrs;
3740 Elf_Internal_Shdr * internal;
3743 shdrs = (Elf32_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
3744 elf_header.e_shentsize, num,
3745 _("section headers"));
3749 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
3750 sizeof (Elf_Internal_Shdr));
3752 if (section_headers == NULL)
3754 error (_("Out of memory\n"));
3758 for (i = 0, internal = section_headers;
3762 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
3763 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
3764 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
3765 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
3766 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
3767 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
3768 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
3769 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
3770 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
3771 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
3780 get_64bit_section_headers (FILE * file, unsigned int num)
3782 Elf64_External_Shdr * shdrs;
3783 Elf_Internal_Shdr * internal;
3786 shdrs = (Elf64_External_Shdr *) get_data (NULL, file, elf_header.e_shoff,
3787 elf_header.e_shentsize, num,
3788 _("section headers"));
3792 section_headers = (Elf_Internal_Shdr *) cmalloc (num,
3793 sizeof (Elf_Internal_Shdr));
3795 if (section_headers == NULL)
3797 error (_("Out of memory\n"));
3801 for (i = 0, internal = section_headers;
3805 internal->sh_name = BYTE_GET (shdrs[i].sh_name);
3806 internal->sh_type = BYTE_GET (shdrs[i].sh_type);
3807 internal->sh_flags = BYTE_GET (shdrs[i].sh_flags);
3808 internal->sh_addr = BYTE_GET (shdrs[i].sh_addr);
3809 internal->sh_size = BYTE_GET (shdrs[i].sh_size);
3810 internal->sh_entsize = BYTE_GET (shdrs[i].sh_entsize);
3811 internal->sh_link = BYTE_GET (shdrs[i].sh_link);
3812 internal->sh_info = BYTE_GET (shdrs[i].sh_info);
3813 internal->sh_offset = BYTE_GET (shdrs[i].sh_offset);
3814 internal->sh_addralign = BYTE_GET (shdrs[i].sh_addralign);
3822 static Elf_Internal_Sym *
3823 get_32bit_elf_symbols (FILE * file, Elf_Internal_Shdr * section)
3825 unsigned long number;
3826 Elf32_External_Sym * esyms;
3827 Elf_External_Sym_Shndx * shndx;
3828 Elf_Internal_Sym * isyms;
3829 Elf_Internal_Sym * psym;
3832 esyms = (Elf32_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
3833 section->sh_size, _("symbols"));
3838 if (symtab_shndx_hdr != NULL
3839 && (symtab_shndx_hdr->sh_link
3840 == (unsigned long) (section - section_headers)))
3842 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
3843 symtab_shndx_hdr->sh_offset,
3844 1, symtab_shndx_hdr->sh_size,
3853 number = section->sh_size / section->sh_entsize;
3854 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
3858 error (_("Out of memory\n"));
3865 for (j = 0, psym = isyms;
3869 psym->st_name = BYTE_GET (esyms[j].st_name);
3870 psym->st_value = BYTE_GET (esyms[j].st_value);
3871 psym->st_size = BYTE_GET (esyms[j].st_size);
3872 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
3873 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
3875 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
3876 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
3877 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
3878 psym->st_info = BYTE_GET (esyms[j].st_info);
3879 psym->st_other = BYTE_GET (esyms[j].st_other);
3889 static Elf_Internal_Sym *
3890 get_64bit_elf_symbols (FILE * file, Elf_Internal_Shdr * section)
3892 unsigned long number;
3893 Elf64_External_Sym * esyms;
3894 Elf_External_Sym_Shndx * shndx;
3895 Elf_Internal_Sym * isyms;
3896 Elf_Internal_Sym * psym;
3899 esyms = (Elf64_External_Sym *) get_data (NULL, file, section->sh_offset, 1,
3900 section->sh_size, _("symbols"));
3905 if (symtab_shndx_hdr != NULL
3906 && (symtab_shndx_hdr->sh_link
3907 == (unsigned long) (section - section_headers)))
3909 shndx = (Elf_External_Sym_Shndx *) get_data (NULL, file,
3910 symtab_shndx_hdr->sh_offset,
3911 1, symtab_shndx_hdr->sh_size,
3920 number = section->sh_size / section->sh_entsize;
3921 isyms = (Elf_Internal_Sym *) cmalloc (number, sizeof (Elf_Internal_Sym));
3925 error (_("Out of memory\n"));
3932 for (j = 0, psym = isyms;
3936 psym->st_name = BYTE_GET (esyms[j].st_name);
3937 psym->st_info = BYTE_GET (esyms[j].st_info);
3938 psym->st_other = BYTE_GET (esyms[j].st_other);
3939 psym->st_shndx = BYTE_GET (esyms[j].st_shndx);
3940 if (psym->st_shndx == (SHN_XINDEX & 0xffff) && shndx != NULL)
3942 = byte_get ((unsigned char *) &shndx[j], sizeof (shndx[j]));
3943 else if (psym->st_shndx >= (SHN_LORESERVE & 0xffff))
3944 psym->st_shndx += SHN_LORESERVE - (SHN_LORESERVE & 0xffff);
3945 psym->st_value = BYTE_GET (esyms[j].st_value);
3946 psym->st_size = BYTE_GET (esyms[j].st_size);
3957 get_elf_section_flags (bfd_vma sh_flags)
3959 static char buff[1024];
3961 int field_size = is_32bit_elf ? 8 : 16;
3963 int size = sizeof (buff) - (field_size + 4 + 1);
3964 bfd_vma os_flags = 0;
3965 bfd_vma proc_flags = 0;
3966 bfd_vma unknown_flags = 0;
3974 /* 0 */ { STRING_COMMA_LEN ("WRITE") },
3975 /* 1 */ { STRING_COMMA_LEN ("ALLOC") },
3976 /* 2 */ { STRING_COMMA_LEN ("EXEC") },
3977 /* 3 */ { STRING_COMMA_LEN ("MERGE") },
3978 /* 4 */ { STRING_COMMA_LEN ("STRINGS") },
3979 /* 5 */ { STRING_COMMA_LEN ("INFO LINK") },
3980 /* 6 */ { STRING_COMMA_LEN ("LINK ORDER") },
3981 /* 7 */ { STRING_COMMA_LEN ("OS NONCONF") },
3982 /* 8 */ { STRING_COMMA_LEN ("GROUP") },
3983 /* 9 */ { STRING_COMMA_LEN ("TLS") },
3984 /* IA-64 specific. */
3985 /* 10 */ { STRING_COMMA_LEN ("SHORT") },
3986 /* 11 */ { STRING_COMMA_LEN ("NORECOV") },
3987 /* IA-64 OpenVMS specific. */
3988 /* 12 */ { STRING_COMMA_LEN ("VMS_GLOBAL") },
3989 /* 13 */ { STRING_COMMA_LEN ("VMS_OVERLAID") },
3990 /* 14 */ { STRING_COMMA_LEN ("VMS_SHARED") },
3991 /* 15 */ { STRING_COMMA_LEN ("VMS_VECTOR") },
3992 /* 16 */ { STRING_COMMA_LEN ("VMS_ALLOC_64BIT") },
3993 /* 17 */ { STRING_COMMA_LEN ("VMS_PROTECTED") },
3994 /* SPARC specific. */
3995 /* 18 */ { STRING_COMMA_LEN ("EXCLUDE") },
3996 /* 19 */ { STRING_COMMA_LEN ("ORDERED") }
3999 if (do_section_details)
4001 sprintf (buff, "[%*.*lx]: ",
4002 field_size, field_size, (unsigned long) sh_flags);
4003 p += field_size + 4;
4010 flag = sh_flags & - sh_flags;
4013 if (do_section_details)
4017 case SHF_WRITE: sindex = 0; break;
4018 case SHF_ALLOC: sindex = 1; break;
4019 case SHF_EXECINSTR: sindex = 2; break;
4020 case SHF_MERGE: sindex = 3; break;
4021 case SHF_STRINGS: sindex = 4; break;
4022 case SHF_INFO_LINK: sindex = 5; break;
4023 case SHF_LINK_ORDER: sindex = 6; break;
4024 case SHF_OS_NONCONFORMING: sindex = 7; break;
4025 case SHF_GROUP: sindex = 8; break;
4026 case SHF_TLS: sindex = 9; break;
4030 switch (elf_header.e_machine)
4033 if (flag == SHF_IA_64_SHORT)
4035 else if (flag == SHF_IA_64_NORECOV)
4038 else if (elf_header.e_ident[EI_OSABI] == ELFOSABI_OPENVMS)
4041 case SHF_IA_64_VMS_GLOBAL: sindex = 12; break;
4042 case SHF_IA_64_VMS_OVERLAID: sindex = 13; break;
4043 case SHF_IA_64_VMS_SHARED: sindex = 14; break;
4044 case SHF_IA_64_VMS_VECTOR: sindex = 15; break;
4045 case SHF_IA_64_VMS_ALLOC_64BIT: sindex = 16; break;
4046 case SHF_IA_64_VMS_PROTECTED: sindex = 17; break;
4055 case EM_OLD_SPARCV9:
4056 case EM_SPARC32PLUS:
4059 if (flag == SHF_EXCLUDE)
4061 else if (flag == SHF_ORDERED)
4071 if (p != buff + field_size + 4)
4073 if (size < (10 + 2))
4080 size -= flags [sindex].len;
4081 p = stpcpy (p, flags [sindex].str);
4083 else if (flag & SHF_MASKOS)
4085 else if (flag & SHF_MASKPROC)
4088 unknown_flags |= flag;
4094 case SHF_WRITE: *p = 'W'; break;
4095 case SHF_ALLOC: *p = 'A'; break;
4096 case SHF_EXECINSTR: *p = 'X'; break;
4097 case SHF_MERGE: *p = 'M'; break;
4098 case SHF_STRINGS: *p = 'S'; break;
4099 case SHF_INFO_LINK: *p = 'I'; break;
4100 case SHF_LINK_ORDER: *p = 'L'; break;
4101 case SHF_OS_NONCONFORMING: *p = 'O'; break;
4102 case SHF_GROUP: *p = 'G'; break;
4103 case SHF_TLS: *p = 'T'; break;
4106 if ((elf_header.e_machine == EM_X86_64
4107 || elf_header.e_machine == EM_L1OM)
4108 && flag == SHF_X86_64_LARGE)
4110 else if (flag & SHF_MASKOS)
4113 sh_flags &= ~ SHF_MASKOS;
4115 else if (flag & SHF_MASKPROC)
4118 sh_flags &= ~ SHF_MASKPROC;
4128 if (do_section_details)
4132 size -= 5 + field_size;
4133 if (p != buff + field_size + 4)
4141 sprintf (p, "OS (%*.*lx)", field_size, field_size,
4142 (unsigned long) os_flags);
4143 p += 5 + field_size;
4147 size -= 7 + field_size;
4148 if (p != buff + field_size + 4)
4156 sprintf (p, "PROC (%*.*lx)", field_size, field_size,
4157 (unsigned long) proc_flags);
4158 p += 7 + field_size;
4162 size -= 10 + field_size;
4163 if (p != buff + field_size + 4)
4171 sprintf (p, "UNKNOWN (%*.*lx)", field_size, field_size,
4172 (unsigned long) unknown_flags);
4173 p += 10 + field_size;
4182 process_section_headers (FILE * file)
4184 Elf_Internal_Shdr * section;
4187 section_headers = NULL;
4189 if (elf_header.e_shnum == 0)
4192 printf (_("\nThere are no sections in this file.\n"));
4197 if (do_sections && !do_header)
4198 printf (_("There are %d section headers, starting at offset 0x%lx:\n"),
4199 elf_header.e_shnum, (unsigned long) elf_header.e_shoff);
4203 if (! get_32bit_section_headers (file, elf_header.e_shnum))
4206 else if (! get_64bit_section_headers (file, elf_header.e_shnum))
4209 /* Read in the string table, so that we have names to display. */
4210 if (elf_header.e_shstrndx != SHN_UNDEF
4211 && elf_header.e_shstrndx < elf_header.e_shnum)
4213 section = section_headers + elf_header.e_shstrndx;
4215 if (section->sh_size != 0)
4217 string_table = (char *) get_data (NULL, file, section->sh_offset,
4218 1, section->sh_size,
4221 string_table_length = string_table != NULL ? section->sh_size : 0;
4225 /* Scan the sections for the dynamic symbol table
4226 and dynamic string table and debug sections. */
4227 dynamic_symbols = NULL;
4228 dynamic_strings = NULL;
4229 dynamic_syminfo = NULL;
4230 symtab_shndx_hdr = NULL;
4232 eh_addr_size = is_32bit_elf ? 4 : 8;
4233 switch (elf_header.e_machine)
4236 case EM_MIPS_RS3_LE:
4237 /* The 64-bit MIPS EABI uses a combination of 32-bit ELF and 64-bit
4238 FDE addresses. However, the ABI also has a semi-official ILP32
4239 variant for which the normal FDE address size rules apply.
4241 GCC 4.0 marks EABI64 objects with a dummy .gcc_compiled_longXX
4242 section, where XX is the size of longs in bits. Unfortunately,
4243 earlier compilers provided no way of distinguishing ILP32 objects
4244 from LP64 objects, so if there's any doubt, we should assume that
4245 the official LP64 form is being used. */
4246 if ((elf_header.e_flags & EF_MIPS_ABI) == E_MIPS_ABI_EABI64
4247 && find_section (".gcc_compiled_long32") == NULL)
4253 switch (elf_header.e_flags & EF_H8_MACH)
4255 case E_H8_MACH_H8300:
4256 case E_H8_MACH_H8300HN:
4257 case E_H8_MACH_H8300SN:
4258 case E_H8_MACH_H8300SXN:
4261 case E_H8_MACH_H8300H:
4262 case E_H8_MACH_H8300S:
4263 case E_H8_MACH_H8300SX:
4271 switch (elf_header.e_flags & EF_M32C_CPU_MASK)
4273 case EF_M32C_CPU_M16C:
4280 #define CHECK_ENTSIZE_VALUES(section, i, size32, size64) \
4283 size_t expected_entsize \
4284 = is_32bit_elf ? size32 : size64; \
4285 if (section->sh_entsize != expected_entsize) \
4286 error (_("Section %d has invalid sh_entsize %lx (expected %lx)\n"), \
4287 i, (unsigned long int) section->sh_entsize, \
4288 (unsigned long int) expected_entsize); \
4289 section->sh_entsize = expected_entsize; \
4292 #define CHECK_ENTSIZE(section, i, type) \
4293 CHECK_ENTSIZE_VALUES (section, i, sizeof (Elf32_External_##type), \
4294 sizeof (Elf64_External_##type))
4296 for (i = 0, section = section_headers;
4297 i < elf_header.e_shnum;
4300 char * name = SECTION_NAME (section);
4302 if (section->sh_type == SHT_DYNSYM)
4304 if (dynamic_symbols != NULL)
4306 error (_("File contains multiple dynamic symbol tables\n"));
4310 CHECK_ENTSIZE (section, i, Sym);
4311 num_dynamic_syms = section->sh_size / section->sh_entsize;
4312 dynamic_symbols = GET_ELF_SYMBOLS (file, section);
4314 else if (section->sh_type == SHT_STRTAB
4315 && streq (name, ".dynstr"))
4317 if (dynamic_strings != NULL)
4319 error (_("File contains multiple dynamic string tables\n"));
4323 dynamic_strings = (char *) get_data (NULL, file, section->sh_offset,
4324 1, section->sh_size,
4325 _("dynamic strings"));
4326 dynamic_strings_length = section->sh_size;
4328 else if (section->sh_type == SHT_SYMTAB_SHNDX)
4330 if (symtab_shndx_hdr != NULL)
4332 error (_("File contains multiple symtab shndx tables\n"));
4335 symtab_shndx_hdr = section;
4337 else if (section->sh_type == SHT_SYMTAB)
4338 CHECK_ENTSIZE (section, i, Sym);
4339 else if (section->sh_type == SHT_GROUP)
4340 CHECK_ENTSIZE_VALUES (section, i, GRP_ENTRY_SIZE, GRP_ENTRY_SIZE);
4341 else if (section->sh_type == SHT_REL)
4342 CHECK_ENTSIZE (section, i, Rel);
4343 else if (section->sh_type == SHT_RELA)
4344 CHECK_ENTSIZE (section, i, Rela);
4345 else if ((do_debugging || do_debug_info || do_debug_abbrevs
4346 || do_debug_lines || do_debug_pubnames || do_debug_pubtypes
4347 || do_debug_aranges || do_debug_frames || do_debug_macinfo
4348 || do_debug_str || do_debug_loc || do_debug_ranges)
4349 && (const_strneq (name, ".debug_")
4350 || const_strneq (name, ".zdebug_")))
4353 name += sizeof (".zdebug_") - 1;
4355 name += sizeof (".debug_") - 1;
4358 || (do_debug_info && streq (name, "info"))
4359 || (do_debug_info && streq (name, "types"))
4360 || (do_debug_abbrevs && streq (name, "abbrev"))
4361 || (do_debug_lines && streq (name, "line"))
4362 || (do_debug_pubnames && streq (name, "pubnames"))
4363 || (do_debug_pubtypes && streq (name, "pubtypes"))
4364 || (do_debug_aranges && streq (name, "aranges"))
4365 || (do_debug_ranges && streq (name, "ranges"))
4366 || (do_debug_frames && streq (name, "frame"))
4367 || (do_debug_macinfo && streq (name, "macinfo"))
4368 || (do_debug_str && streq (name, "str"))
4369 || (do_debug_loc && streq (name, "loc"))
4371 request_dump_bynumber (i, DEBUG_DUMP);
4373 /* Linkonce section to be combined with .debug_info at link time. */
4374 else if ((do_debugging || do_debug_info)
4375 && const_strneq (name, ".gnu.linkonce.wi."))
4376 request_dump_bynumber (i, DEBUG_DUMP);
4377 else if (do_debug_frames && streq (name, ".eh_frame"))
4378 request_dump_bynumber (i, DEBUG_DUMP);
4384 if (elf_header.e_shnum > 1)
4385 printf (_("\nSection Headers:\n"));
4387 printf (_("\nSection Header:\n"));
4391 if (do_section_details)
4393 printf (_(" [Nr] Name\n"));
4394 printf (_(" Type Addr Off Size ES Lk Inf Al\n"));
4398 (_(" [Nr] Name Type Addr Off Size ES Flg Lk Inf Al\n"));
4402 if (do_section_details)
4404 printf (_(" [Nr] Name\n"));
4405 printf (_(" Type Address Off Size ES Lk Inf Al\n"));
4409 (_(" [Nr] Name Type Address Off Size ES Flg Lk Inf Al\n"));
4413 if (do_section_details)
4415 printf (_(" [Nr] Name\n"));
4416 printf (_(" Type Address Offset Link\n"));
4417 printf (_(" Size EntSize Info Align\n"));
4421 printf (_(" [Nr] Name Type Address Offset\n"));
4422 printf (_(" Size EntSize Flags Link Info Align\n"));
4426 if (do_section_details)
4427 printf (_(" Flags\n"));
4429 for (i = 0, section = section_headers;
4430 i < elf_header.e_shnum;
4433 if (do_section_details)
4435 printf (" [%2u] %s\n",
4437 SECTION_NAME (section));
4438 if (is_32bit_elf || do_wide)
4439 printf (" %-15.15s ",
4440 get_section_type_name (section->sh_type));
4443 printf ((do_wide ? " [%2u] %-17s %-15s "
4444 : " [%2u] %-17.17s %-15.15s "),
4446 SECTION_NAME (section),
4447 get_section_type_name (section->sh_type));
4451 const char * link_too_big = NULL;
4453 print_vma (section->sh_addr, LONG_HEX);
4455 printf ( " %6.6lx %6.6lx %2.2lx",
4456 (unsigned long) section->sh_offset,
4457 (unsigned long) section->sh_size,
4458 (unsigned long) section->sh_entsize);
4460 if (do_section_details)
4461 fputs (" ", stdout);
4463 printf (" %3s ", get_elf_section_flags (section->sh_flags));
4465 if (section->sh_link >= elf_header.e_shnum)
4468 /* The sh_link value is out of range. Normally this indicates
4469 an error but it can have special values in Solaris binaries. */
4470 switch (elf_header.e_machine)
4475 case EM_OLD_SPARCV9:
4476 case EM_SPARC32PLUS:
4479 if (section->sh_link == (SHN_BEFORE & 0xffff))
4480 link_too_big = "BEFORE";
4481 else if (section->sh_link == (SHN_AFTER & 0xffff))
4482 link_too_big = "AFTER";
4489 if (do_section_details)
4491 if (link_too_big != NULL && * link_too_big)
4492 printf ("<%s> ", link_too_big);
4494 printf ("%2u ", section->sh_link);
4495 printf ("%3u %2lu\n", section->sh_info,
4496 (unsigned long) section->sh_addralign);
4499 printf ("%2u %3u %2lu\n",
4502 (unsigned long) section->sh_addralign);
4504 if (link_too_big && ! * link_too_big)
4505 warn (_("section %u: sh_link value of %u is larger than the number of sections\n"),
4506 i, section->sh_link);
4510 print_vma (section->sh_addr, LONG_HEX);
4512 if ((long) section->sh_offset == section->sh_offset)
4513 printf (" %6.6lx", (unsigned long) section->sh_offset);
4517 print_vma (section->sh_offset, LONG_HEX);
4520 if ((unsigned long) section->sh_size == section->sh_size)
4521 printf (" %6.6lx", (unsigned long) section->sh_size);
4525 print_vma (section->sh_size, LONG_HEX);
4528 if ((unsigned long) section->sh_entsize == section->sh_entsize)
4529 printf (" %2.2lx", (unsigned long) section->sh_entsize);
4533 print_vma (section->sh_entsize, LONG_HEX);
4536 if (do_section_details)
4537 fputs (" ", stdout);
4539 printf (" %3s ", get_elf_section_flags (section->sh_flags));
4541 printf ("%2u %3u ", section->sh_link, section->sh_info);
4543 if ((unsigned long) section->sh_addralign == section->sh_addralign)
4544 printf ("%2lu\n", (unsigned long) section->sh_addralign);
4547 print_vma (section->sh_addralign, DEC);
4551 else if (do_section_details)
4553 printf (" %-15.15s ",
4554 get_section_type_name (section->sh_type));
4555 print_vma (section->sh_addr, LONG_HEX);
4556 if ((long) section->sh_offset == section->sh_offset)
4557 printf (" %16.16lx", (unsigned long) section->sh_offset);
4561 print_vma (section->sh_offset, LONG_HEX);
4563 printf (" %u\n ", section->sh_link);
4564 print_vma (section->sh_size, LONG_HEX);
4566 print_vma (section->sh_entsize, LONG_HEX);
4568 printf (" %-16u %lu\n",
4570 (unsigned long) section->sh_addralign);
4575 print_vma (section->sh_addr, LONG_HEX);
4576 if ((long) section->sh_offset == section->sh_offset)
4577 printf (" %8.8lx", (unsigned long) section->sh_offset);
4581 print_vma (section->sh_offset, LONG_HEX);
4584 print_vma (section->sh_size, LONG_HEX);
4586 print_vma (section->sh_entsize, LONG_HEX);
4588 printf (" %3s ", get_elf_section_flags (section->sh_flags));
4590 printf (" %2u %3u %lu\n",
4593 (unsigned long) section->sh_addralign);
4596 if (do_section_details)
4597 printf (" %s\n", get_elf_section_flags (section->sh_flags));
4600 if (!do_section_details)
4601 printf (_("Key to Flags:\n\
4602 W (write), A (alloc), X (execute), M (merge), S (strings)\n\
4603 I (info), L (link order), G (group), x (unknown)\n\
4604 O (extra OS processing required) o (OS specific), p (processor specific)\n"));
4610 get_group_flags (unsigned int flags)
4612 static char buff[32];
4619 snprintf (buff, sizeof (buff), _("[<unknown>: 0x%x]"), flags);
4626 process_section_groups (FILE * file)
4628 Elf_Internal_Shdr * section;
4630 struct group * group;
4631 Elf_Internal_Shdr * symtab_sec;
4632 Elf_Internal_Shdr * strtab_sec;
4633 Elf_Internal_Sym * symtab;
4637 /* Don't process section groups unless needed. */
4638 if (!do_unwind && !do_section_groups)
4641 if (elf_header.e_shnum == 0)
4643 if (do_section_groups)
4644 printf (_("\nThere are no sections in this file.\n"));
4649 if (section_headers == NULL)
4651 error (_("Section headers are not available!\n"));
4655 section_headers_groups = (struct group **) calloc (elf_header.e_shnum,
4656 sizeof (struct group *));
4658 if (section_headers_groups == NULL)
4660 error (_("Out of memory\n"));
4664 /* Scan the sections for the group section. */
4666 for (i = 0, section = section_headers;
4667 i < elf_header.e_shnum;
4669 if (section->sh_type == SHT_GROUP)
4672 if (group_count == 0)
4674 if (do_section_groups)
4675 printf (_("\nThere are no section groups in this file.\n"));
4680 section_groups = (struct group *) calloc (group_count, sizeof (struct group));
4682 if (section_groups == NULL)
4684 error (_("Out of memory\n"));
4693 for (i = 0, section = section_headers, group = section_groups;
4694 i < elf_header.e_shnum;
4697 if (section->sh_type == SHT_GROUP)
4699 char * name = SECTION_NAME (section);
4701 unsigned char * start;
4702 unsigned char * indices;
4703 unsigned int entry, j, size;
4704 Elf_Internal_Shdr * sec;
4705 Elf_Internal_Sym * sym;
4707 /* Get the symbol table. */
4708 if (section->sh_link >= elf_header.e_shnum
4709 || ((sec = section_headers + section->sh_link)->sh_type
4712 error (_("Bad sh_link in group section `%s'\n"), name);
4716 if (symtab_sec != sec)
4721 symtab = GET_ELF_SYMBOLS (file, symtab_sec);
4724 sym = symtab + section->sh_info;
4726 if (ELF_ST_TYPE (sym->st_info) == STT_SECTION)
4728 if (sym->st_shndx == 0
4729 || sym->st_shndx >= elf_header.e_shnum)
4731 error (_("Bad sh_info in group section `%s'\n"), name);
4735 group_name = SECTION_NAME (section_headers + sym->st_shndx);
4744 /* Get the string table. */
4745 if (symtab_sec->sh_link >= elf_header.e_shnum)
4754 != (sec = section_headers + symtab_sec->sh_link))
4759 strtab = (char *) get_data (NULL, file, strtab_sec->sh_offset,
4760 1, strtab_sec->sh_size,
4762 strtab_size = strtab != NULL ? strtab_sec->sh_size : 0;
4764 group_name = sym->st_name < strtab_size
4765 ? strtab + sym->st_name : "<corrupt>";
4768 start = (unsigned char *) get_data (NULL, file, section->sh_offset,
4769 1, section->sh_size,
4773 size = (section->sh_size / section->sh_entsize) - 1;
4774 entry = byte_get (indices, 4);
4777 if (do_section_groups)
4779 printf ("\n%s group section [%5u] `%s' [%s] contains %u sections:\n",
4780 get_group_flags (entry), i, name, group_name, size);
4782 printf (_(" [Index] Name\n"));
4785 group->group_index = i;
4787 for (j = 0; j < size; j++)
4789 struct group_list * g;
4791 entry = byte_get (indices, 4);
4794 if (entry >= elf_header.e_shnum)
4796 error (_("section [%5u] in group section [%5u] > maximum section [%5u]\n"),
4797 entry, i, elf_header.e_shnum - 1);
4801 if (section_headers_groups [entry] != NULL)
4805 error (_("section [%5u] in group section [%5u] already in group section [%5u]\n"),
4807 section_headers_groups [entry]->group_index);
4812 /* Intel C/C++ compiler may put section 0 in a
4813 section group. We just warn it the first time
4814 and ignore it afterwards. */
4815 static int warned = 0;
4818 error (_("section 0 in group section [%5u]\n"),
4819 section_headers_groups [entry]->group_index);
4825 section_headers_groups [entry] = group;
4827 if (do_section_groups)
4829 sec = section_headers + entry;
4830 printf (" [%5u] %s\n", entry, SECTION_NAME (sec));
4833 g = (struct group_list *) xmalloc (sizeof (struct group_list));
4834 g->section_index = entry;
4835 g->next = group->root;
4859 } dynamic_relocations [] =
4861 { "REL", DT_REL, DT_RELSZ, FALSE },
4862 { "RELA", DT_RELA, DT_RELASZ, TRUE },
4863 { "PLT", DT_JMPREL, DT_PLTRELSZ, UNKNOWN }
4866 /* Process the reloc section. */
4869 process_relocs (FILE * file)
4871 unsigned long rel_size;
4872 unsigned long rel_offset;
4878 if (do_using_dynamic)
4882 int has_dynamic_reloc;
4885 has_dynamic_reloc = 0;
4887 for (i = 0; i < ARRAY_SIZE (dynamic_relocations); i++)
4889 is_rela = dynamic_relocations [i].rela;
4890 name = dynamic_relocations [i].name;
4891 rel_size = dynamic_info [dynamic_relocations [i].size];
4892 rel_offset = dynamic_info [dynamic_relocations [i].reloc];
4894 has_dynamic_reloc |= rel_size;
4896 if (is_rela == UNKNOWN)
4898 if (dynamic_relocations [i].reloc == DT_JMPREL)
4899 switch (dynamic_info[DT_PLTREL])
4913 (_("\n'%s' relocation section at offset 0x%lx contains %ld bytes:\n"),
4914 name, rel_offset, rel_size);
4916 dump_relocations (file,
4917 offset_from_vma (file, rel_offset, rel_size),
4919 dynamic_symbols, num_dynamic_syms,
4920 dynamic_strings, dynamic_strings_length, is_rela);
4924 if (! has_dynamic_reloc)
4925 printf (_("\nThere are no dynamic relocations in this file.\n"));
4929 Elf_Internal_Shdr * section;
4933 for (i = 0, section = section_headers;
4934 i < elf_header.e_shnum;
4937 if ( section->sh_type != SHT_RELA
4938 && section->sh_type != SHT_REL)
4941 rel_offset = section->sh_offset;
4942 rel_size = section->sh_size;
4946 Elf_Internal_Shdr * strsec;
4949 printf (_("\nRelocation section "));
4951 if (string_table == NULL)
4952 printf ("%d", section->sh_name);
4954 printf (_("'%s'"), SECTION_NAME (section));
4956 printf (_(" at offset 0x%lx contains %lu entries:\n"),
4957 rel_offset, (unsigned long) (rel_size / section->sh_entsize));
4959 is_rela = section->sh_type == SHT_RELA;
4961 if (section->sh_link != 0
4962 && section->sh_link < elf_header.e_shnum)
4964 Elf_Internal_Shdr * symsec;
4965 Elf_Internal_Sym * symtab;
4966 unsigned long nsyms;
4967 unsigned long strtablen = 0;
4968 char * strtab = NULL;
4970 symsec = section_headers + section->sh_link;
4971 if (symsec->sh_type != SHT_SYMTAB
4972 && symsec->sh_type != SHT_DYNSYM)
4975 nsyms = symsec->sh_size / symsec->sh_entsize;
4976 symtab = GET_ELF_SYMBOLS (file, symsec);
4981 if (symsec->sh_link != 0
4982 && symsec->sh_link < elf_header.e_shnum)
4984 strsec = section_headers + symsec->sh_link;
4986 strtab = (char *) get_data (NULL, file, strsec->sh_offset,
4989 strtablen = strtab == NULL ? 0 : strsec->sh_size;
4992 dump_relocations (file, rel_offset, rel_size,
4993 symtab, nsyms, strtab, strtablen, is_rela);
4999 dump_relocations (file, rel_offset, rel_size,
5000 NULL, 0, NULL, 0, is_rela);
5007 printf (_("\nThere are no relocations in this file.\n"));
5013 /* Process the unwind section. */
5015 #include "unwind-ia64.h"
5017 /* An absolute address consists of a section and an offset. If the
5018 section is NULL, the offset itself is the address, otherwise, the
5019 address equals to LOAD_ADDRESS(section) + offset. */
5023 unsigned short section;
5027 #define ABSADDR(a) \
5029 ? section_headers [(a).section].sh_addr + (a).offset \
5032 struct ia64_unw_table_entry
5034 struct absaddr start;
5036 struct absaddr info;
5039 struct ia64_unw_aux_info
5042 struct ia64_unw_table_entry *table; /* Unwind table. */
5043 unsigned long table_len; /* Length of unwind table. */
5044 unsigned char * info; /* Unwind info. */
5045 unsigned long info_size; /* Size of unwind info. */
5046 bfd_vma info_addr; /* starting address of unwind info. */
5047 bfd_vma seg_base; /* Starting address of segment. */
5048 Elf_Internal_Sym * symtab; /* The symbol table. */
5049 unsigned long nsyms; /* Number of symbols. */
5050 char * strtab; /* The string table. */
5051 unsigned long strtab_size; /* Size of string table. */
5055 find_symbol_for_address (Elf_Internal_Sym * symtab,
5056 unsigned long nsyms,
5057 const char * strtab,
5058 unsigned long strtab_size,
5059 struct absaddr addr,
5060 const char ** symname,
5063 bfd_vma dist = 0x100000;
5064 Elf_Internal_Sym * sym;
5065 Elf_Internal_Sym * best = NULL;
5068 for (i = 0, sym = symtab; i < nsyms; ++i, ++sym)
5070 if (ELF_ST_TYPE (sym->st_info) == STT_FUNC
5071 && sym->st_name != 0
5072 && (addr.section == SHN_UNDEF || addr.section == sym->st_shndx)
5073 && addr.offset >= sym->st_value
5074 && addr.offset - sym->st_value < dist)
5077 dist = addr.offset - sym->st_value;
5084 *symname = (best->st_name >= strtab_size
5085 ? "<corrupt>" : strtab + best->st_name);
5090 *offset = addr.offset;
5094 dump_ia64_unwind (struct ia64_unw_aux_info * aux)
5096 struct ia64_unw_table_entry * tp;
5099 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
5103 const unsigned char * dp;
5104 const unsigned char * head;
5105 const char * procname;
5107 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
5108 aux->strtab_size, tp->start, &procname, &offset);
5110 fputs ("\n<", stdout);
5114 fputs (procname, stdout);
5117 printf ("+%lx", (unsigned long) offset);
5120 fputs (">: [", stdout);
5121 print_vma (tp->start.offset, PREFIX_HEX);
5122 fputc ('-', stdout);
5123 print_vma (tp->end.offset, PREFIX_HEX);
5124 printf ("], info at +0x%lx\n",
5125 (unsigned long) (tp->info.offset - aux->seg_base));
5127 head = aux->info + (ABSADDR (tp->info) - aux->info_addr);
5128 stamp = byte_get ((unsigned char *) head, sizeof (stamp));
5130 printf (" v%u, flags=0x%lx (%s%s), len=%lu bytes\n",
5131 (unsigned) UNW_VER (stamp),
5132 (unsigned long) ((stamp & UNW_FLAG_MASK) >> 32),
5133 UNW_FLAG_EHANDLER (stamp) ? " ehandler" : "",
5134 UNW_FLAG_UHANDLER (stamp) ? " uhandler" : "",
5135 (unsigned long) (eh_addr_size * UNW_LENGTH (stamp)));
5137 if (UNW_VER (stamp) != 1)
5139 printf ("\tUnknown version.\n");
5144 for (dp = head + 8; dp < head + 8 + eh_addr_size * UNW_LENGTH (stamp);)
5145 dp = unw_decode (dp, in_body, & in_body);
5150 slurp_ia64_unwind_table (FILE * file,
5151 struct ia64_unw_aux_info * aux,
5152 Elf_Internal_Shdr * sec)
5154 unsigned long size, nrelas, i;
5155 Elf_Internal_Phdr * seg;
5156 struct ia64_unw_table_entry * tep;
5157 Elf_Internal_Shdr * relsec;
5158 Elf_Internal_Rela * rela;
5159 Elf_Internal_Rela * rp;
5160 unsigned char * table;
5162 Elf_Internal_Sym * sym;
5163 const char * relname;
5165 /* First, find the starting address of the segment that includes
5168 if (elf_header.e_phnum)
5170 if (! get_program_headers (file))
5173 for (seg = program_headers;
5174 seg < program_headers + elf_header.e_phnum;
5177 if (seg->p_type != PT_LOAD)
5180 if (sec->sh_addr >= seg->p_vaddr
5181 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
5183 aux->seg_base = seg->p_vaddr;
5189 /* Second, build the unwind table from the contents of the unwind section: */
5190 size = sec->sh_size;
5191 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
5196 aux->table = (struct ia64_unw_table_entry *)
5197 xcmalloc (size / (3 * eh_addr_size), sizeof (aux->table[0]));
5199 for (tp = table; tp < table + size; ++tep)
5201 tep->start.section = SHN_UNDEF;
5202 tep->end.section = SHN_UNDEF;
5203 tep->info.section = SHN_UNDEF;
5204 tep->start.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
5205 tep->end.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
5206 tep->info.offset = byte_get (tp, eh_addr_size); tp += eh_addr_size;
5207 tep->start.offset += aux->seg_base;
5208 tep->end.offset += aux->seg_base;
5209 tep->info.offset += aux->seg_base;
5213 /* Third, apply any relocations to the unwind table: */
5214 for (relsec = section_headers;
5215 relsec < section_headers + elf_header.e_shnum;
5218 if (relsec->sh_type != SHT_RELA
5219 || relsec->sh_info >= elf_header.e_shnum
5220 || section_headers + relsec->sh_info != sec)
5223 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
5227 for (rp = rela; rp < rela + nrelas; ++rp)
5229 relname = elf_ia64_reloc_type (get_reloc_type (rp->r_info));
5230 sym = aux->symtab + get_reloc_symindex (rp->r_info);
5232 if (! const_strneq (relname, "R_IA64_SEGREL"))
5234 warn (_("Skipping unexpected relocation type %s\n"), relname);
5238 i = rp->r_offset / (3 * eh_addr_size);
5240 switch (rp->r_offset/eh_addr_size % 3)
5243 aux->table[i].start.section = sym->st_shndx;
5244 aux->table[i].start.offset += rp->r_addend + sym->st_value;
5247 aux->table[i].end.section = sym->st_shndx;
5248 aux->table[i].end.offset += rp->r_addend + sym->st_value;
5251 aux->table[i].info.section = sym->st_shndx;
5252 aux->table[i].info.offset += rp->r_addend + sym->st_value;
5262 aux->table_len = size / (3 * eh_addr_size);
5267 ia64_process_unwind (FILE * file)
5269 Elf_Internal_Shdr * sec;
5270 Elf_Internal_Shdr * unwsec = NULL;
5271 Elf_Internal_Shdr * strsec;
5272 unsigned long i, unwcount = 0, unwstart = 0;
5273 struct ia64_unw_aux_info aux;
5275 memset (& aux, 0, sizeof (aux));
5277 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
5279 if (sec->sh_type == SHT_SYMTAB
5280 && sec->sh_link < elf_header.e_shnum)
5282 aux.nsyms = sec->sh_size / sec->sh_entsize;
5283 aux.symtab = GET_ELF_SYMBOLS (file, sec);
5285 strsec = section_headers + sec->sh_link;
5286 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
5289 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
5291 else if (sec->sh_type == SHT_IA_64_UNWIND)
5296 printf (_("\nThere are no unwind sections in this file.\n"));
5298 while (unwcount-- > 0)
5303 for (i = unwstart, sec = section_headers + unwstart;
5304 i < elf_header.e_shnum; ++i, ++sec)
5305 if (sec->sh_type == SHT_IA_64_UNWIND)
5312 len = sizeof (ELF_STRING_ia64_unwind_once) - 1;
5314 if ((unwsec->sh_flags & SHF_GROUP) != 0)
5316 /* We need to find which section group it is in. */
5317 struct group_list * g = section_headers_groups [i]->root;
5319 for (; g != NULL; g = g->next)
5321 sec = section_headers + g->section_index;
5323 if (streq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info))
5328 i = elf_header.e_shnum;
5330 else if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind_once, len))
5332 /* .gnu.linkonce.ia64unw.FOO -> .gnu.linkonce.ia64unwi.FOO. */
5333 len2 = sizeof (ELF_STRING_ia64_unwind_info_once) - 1;
5334 suffix = SECTION_NAME (unwsec) + len;
5335 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
5337 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info_once, len2)
5338 && streq (SECTION_NAME (sec) + len2, suffix))
5343 /* .IA_64.unwindFOO -> .IA_64.unwind_infoFOO
5344 .IA_64.unwind or BAR -> .IA_64.unwind_info. */
5345 len = sizeof (ELF_STRING_ia64_unwind) - 1;
5346 len2 = sizeof (ELF_STRING_ia64_unwind_info) - 1;
5348 if (strneq (SECTION_NAME (unwsec), ELF_STRING_ia64_unwind, len))
5349 suffix = SECTION_NAME (unwsec) + len;
5350 for (i = 0, sec = section_headers; i < elf_header.e_shnum;
5352 if (strneq (SECTION_NAME (sec), ELF_STRING_ia64_unwind_info, len2)
5353 && streq (SECTION_NAME (sec) + len2, suffix))
5357 if (i == elf_header.e_shnum)
5359 printf (_("\nCould not find unwind info section for "));
5361 if (string_table == NULL)
5362 printf ("%d", unwsec->sh_name);
5364 printf (_("'%s'"), SECTION_NAME (unwsec));
5368 aux.info_size = sec->sh_size;
5369 aux.info_addr = sec->sh_addr;
5370 aux.info = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1,
5374 printf (_("\nUnwind section "));
5376 if (string_table == NULL)
5377 printf ("%d", unwsec->sh_name);
5379 printf (_("'%s'"), SECTION_NAME (unwsec));
5381 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5382 (unsigned long) unwsec->sh_offset,
5383 (unsigned long) (unwsec->sh_size / (3 * eh_addr_size)));
5385 (void) slurp_ia64_unwind_table (file, & aux, unwsec);
5387 if (aux.table_len > 0)
5388 dump_ia64_unwind (& aux);
5391 free ((char *) aux.table);
5393 free ((char *) aux.info);
5402 free ((char *) aux.strtab);
5407 struct hppa_unw_table_entry
5409 struct absaddr start;
5411 unsigned int Cannot_unwind:1; /* 0 */
5412 unsigned int Millicode:1; /* 1 */
5413 unsigned int Millicode_save_sr0:1; /* 2 */
5414 unsigned int Region_description:2; /* 3..4 */
5415 unsigned int reserved1:1; /* 5 */
5416 unsigned int Entry_SR:1; /* 6 */
5417 unsigned int Entry_FR:4; /* number saved */ /* 7..10 */
5418 unsigned int Entry_GR:5; /* number saved */ /* 11..15 */
5419 unsigned int Args_stored:1; /* 16 */
5420 unsigned int Variable_Frame:1; /* 17 */
5421 unsigned int Separate_Package_Body:1; /* 18 */
5422 unsigned int Frame_Extension_Millicode:1; /* 19 */
5423 unsigned int Stack_Overflow_Check:1; /* 20 */
5424 unsigned int Two_Instruction_SP_Increment:1; /* 21 */
5425 unsigned int Ada_Region:1; /* 22 */
5426 unsigned int cxx_info:1; /* 23 */
5427 unsigned int cxx_try_catch:1; /* 24 */
5428 unsigned int sched_entry_seq:1; /* 25 */
5429 unsigned int reserved2:1; /* 26 */
5430 unsigned int Save_SP:1; /* 27 */
5431 unsigned int Save_RP:1; /* 28 */
5432 unsigned int Save_MRP_in_frame:1; /* 29 */
5433 unsigned int extn_ptr_defined:1; /* 30 */
5434 unsigned int Cleanup_defined:1; /* 31 */
5436 unsigned int MPE_XL_interrupt_marker:1; /* 0 */
5437 unsigned int HP_UX_interrupt_marker:1; /* 1 */
5438 unsigned int Large_frame:1; /* 2 */
5439 unsigned int Pseudo_SP_Set:1; /* 3 */
5440 unsigned int reserved4:1; /* 4 */
5441 unsigned int Total_frame_size:27; /* 5..31 */
5444 struct hppa_unw_aux_info
5446 struct hppa_unw_table_entry *table; /* Unwind table. */
5447 unsigned long table_len; /* Length of unwind table. */
5448 bfd_vma seg_base; /* Starting address of segment. */
5449 Elf_Internal_Sym * symtab; /* The symbol table. */
5450 unsigned long nsyms; /* Number of symbols. */
5451 char * strtab; /* The string table. */
5452 unsigned long strtab_size; /* Size of string table. */
5456 dump_hppa_unwind (struct hppa_unw_aux_info * aux)
5458 struct hppa_unw_table_entry * tp;
5460 for (tp = aux->table; tp < aux->table + aux->table_len; ++tp)
5463 const char * procname;
5465 find_symbol_for_address (aux->symtab, aux->nsyms, aux->strtab,
5466 aux->strtab_size, tp->start, &procname,
5469 fputs ("\n<", stdout);
5473 fputs (procname, stdout);
5476 printf ("+%lx", (unsigned long) offset);
5479 fputs (">: [", stdout);
5480 print_vma (tp->start.offset, PREFIX_HEX);
5481 fputc ('-', stdout);
5482 print_vma (tp->end.offset, PREFIX_HEX);
5485 #define PF(_m) if (tp->_m) printf (#_m " ");
5486 #define PV(_m) if (tp->_m) printf (#_m "=%d ", tp->_m);
5489 PF(Millicode_save_sr0);
5490 /* PV(Region_description); */
5496 PF(Separate_Package_Body);
5497 PF(Frame_Extension_Millicode);
5498 PF(Stack_Overflow_Check);
5499 PF(Two_Instruction_SP_Increment);
5503 PF(sched_entry_seq);
5506 PF(Save_MRP_in_frame);
5507 PF(extn_ptr_defined);
5508 PF(Cleanup_defined);
5509 PF(MPE_XL_interrupt_marker);
5510 PF(HP_UX_interrupt_marker);
5513 PV(Total_frame_size);
5522 slurp_hppa_unwind_table (FILE * file,
5523 struct hppa_unw_aux_info * aux,
5524 Elf_Internal_Shdr * sec)
5526 unsigned long size, unw_ent_size, nentries, nrelas, i;
5527 Elf_Internal_Phdr * seg;
5528 struct hppa_unw_table_entry * tep;
5529 Elf_Internal_Shdr * relsec;
5530 Elf_Internal_Rela * rela;
5531 Elf_Internal_Rela * rp;
5532 unsigned char * table;
5534 Elf_Internal_Sym * sym;
5535 const char * relname;
5537 /* First, find the starting address of the segment that includes
5540 if (elf_header.e_phnum)
5542 if (! get_program_headers (file))
5545 for (seg = program_headers;
5546 seg < program_headers + elf_header.e_phnum;
5549 if (seg->p_type != PT_LOAD)
5552 if (sec->sh_addr >= seg->p_vaddr
5553 && (sec->sh_addr + sec->sh_size <= seg->p_vaddr + seg->p_memsz))
5555 aux->seg_base = seg->p_vaddr;
5561 /* Second, build the unwind table from the contents of the unwind
5563 size = sec->sh_size;
5564 table = (unsigned char *) get_data (NULL, file, sec->sh_offset, 1, size,
5570 nentries = size / unw_ent_size;
5571 size = unw_ent_size * nentries;
5573 tep = aux->table = (struct hppa_unw_table_entry *)
5574 xcmalloc (nentries, sizeof (aux->table[0]));
5576 for (tp = table; tp < table + size; tp += unw_ent_size, ++tep)
5578 unsigned int tmp1, tmp2;
5580 tep->start.section = SHN_UNDEF;
5581 tep->end.section = SHN_UNDEF;
5583 tep->start.offset = byte_get ((unsigned char *) tp + 0, 4);
5584 tep->end.offset = byte_get ((unsigned char *) tp + 4, 4);
5585 tmp1 = byte_get ((unsigned char *) tp + 8, 4);
5586 tmp2 = byte_get ((unsigned char *) tp + 12, 4);
5588 tep->start.offset += aux->seg_base;
5589 tep->end.offset += aux->seg_base;
5591 tep->Cannot_unwind = (tmp1 >> 31) & 0x1;
5592 tep->Millicode = (tmp1 >> 30) & 0x1;
5593 tep->Millicode_save_sr0 = (tmp1 >> 29) & 0x1;
5594 tep->Region_description = (tmp1 >> 27) & 0x3;
5595 tep->reserved1 = (tmp1 >> 26) & 0x1;
5596 tep->Entry_SR = (tmp1 >> 25) & 0x1;
5597 tep->Entry_FR = (tmp1 >> 21) & 0xf;
5598 tep->Entry_GR = (tmp1 >> 16) & 0x1f;
5599 tep->Args_stored = (tmp1 >> 15) & 0x1;
5600 tep->Variable_Frame = (tmp1 >> 14) & 0x1;
5601 tep->Separate_Package_Body = (tmp1 >> 13) & 0x1;
5602 tep->Frame_Extension_Millicode = (tmp1 >> 12) & 0x1;
5603 tep->Stack_Overflow_Check = (tmp1 >> 11) & 0x1;
5604 tep->Two_Instruction_SP_Increment = (tmp1 >> 10) & 0x1;
5605 tep->Ada_Region = (tmp1 >> 9) & 0x1;
5606 tep->cxx_info = (tmp1 >> 8) & 0x1;
5607 tep->cxx_try_catch = (tmp1 >> 7) & 0x1;
5608 tep->sched_entry_seq = (tmp1 >> 6) & 0x1;
5609 tep->reserved2 = (tmp1 >> 5) & 0x1;
5610 tep->Save_SP = (tmp1 >> 4) & 0x1;
5611 tep->Save_RP = (tmp1 >> 3) & 0x1;
5612 tep->Save_MRP_in_frame = (tmp1 >> 2) & 0x1;
5613 tep->extn_ptr_defined = (tmp1 >> 1) & 0x1;
5614 tep->Cleanup_defined = tmp1 & 0x1;
5616 tep->MPE_XL_interrupt_marker = (tmp2 >> 31) & 0x1;
5617 tep->HP_UX_interrupt_marker = (tmp2 >> 30) & 0x1;
5618 tep->Large_frame = (tmp2 >> 29) & 0x1;
5619 tep->Pseudo_SP_Set = (tmp2 >> 28) & 0x1;
5620 tep->reserved4 = (tmp2 >> 27) & 0x1;
5621 tep->Total_frame_size = tmp2 & 0x7ffffff;
5625 /* Third, apply any relocations to the unwind table. */
5626 for (relsec = section_headers;
5627 relsec < section_headers + elf_header.e_shnum;
5630 if (relsec->sh_type != SHT_RELA
5631 || relsec->sh_info >= elf_header.e_shnum
5632 || section_headers + relsec->sh_info != sec)
5635 if (!slurp_rela_relocs (file, relsec->sh_offset, relsec->sh_size,
5639 for (rp = rela; rp < rela + nrelas; ++rp)
5641 relname = elf_hppa_reloc_type (get_reloc_type (rp->r_info));
5642 sym = aux->symtab + get_reloc_symindex (rp->r_info);
5644 /* R_PARISC_SEGREL32 or R_PARISC_SEGREL64. */
5645 if (! const_strneq (relname, "R_PARISC_SEGREL"))
5647 warn (_("Skipping unexpected relocation type %s\n"), relname);
5651 i = rp->r_offset / unw_ent_size;
5653 switch ((rp->r_offset % unw_ent_size) / eh_addr_size)
5656 aux->table[i].start.section = sym->st_shndx;
5657 aux->table[i].start.offset = sym->st_value + rp->r_addend;
5660 aux->table[i].end.section = sym->st_shndx;
5661 aux->table[i].end.offset = sym->st_value + rp->r_addend;
5671 aux->table_len = nentries;
5677 hppa_process_unwind (FILE * file)
5679 struct hppa_unw_aux_info aux;
5680 Elf_Internal_Shdr * unwsec = NULL;
5681 Elf_Internal_Shdr * strsec;
5682 Elf_Internal_Shdr * sec;
5685 memset (& aux, 0, sizeof (aux));
5687 if (string_table == NULL)
5690 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
5692 if (sec->sh_type == SHT_SYMTAB
5693 && sec->sh_link < elf_header.e_shnum)
5695 aux.nsyms = sec->sh_size / sec->sh_entsize;
5696 aux.symtab = GET_ELF_SYMBOLS (file, sec);
5698 strsec = section_headers + sec->sh_link;
5699 aux.strtab = (char *) get_data (NULL, file, strsec->sh_offset,
5702 aux.strtab_size = aux.strtab != NULL ? strsec->sh_size : 0;
5704 else if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
5709 printf (_("\nThere are no unwind sections in this file.\n"));
5711 for (i = 0, sec = section_headers; i < elf_header.e_shnum; ++i, ++sec)
5713 if (streq (SECTION_NAME (sec), ".PARISC.unwind"))
5715 printf (_("\nUnwind section "));
5716 printf (_("'%s'"), SECTION_NAME (sec));
5718 printf (_(" at offset 0x%lx contains %lu entries:\n"),
5719 (unsigned long) sec->sh_offset,
5720 (unsigned long) (sec->sh_size / (2 * eh_addr_size + 8)));
5722 slurp_hppa_unwind_table (file, &aux, sec);
5723 if (aux.table_len > 0)
5724 dump_hppa_unwind (&aux);
5727 free ((char *) aux.table);
5735 free ((char *) aux.strtab);
5741 process_unwind (FILE * file)
5743 struct unwind_handler
5746 int (* handler)(FILE *);
5749 { EM_IA_64, ia64_process_unwind },
5750 { EM_PARISC, hppa_process_unwind },
5758 for (i = 0; handlers[i].handler != NULL; i++)
5759 if (elf_header.e_machine == handlers[i].machtype)
5760 return handlers[i].handler (file);
5762 printf (_("\nThere are no unwind sections in this file.\n"));
5767 dynamic_section_mips_val (Elf_Internal_Dyn * entry)
5769 switch (entry->d_tag)
5772 if (entry->d_un.d_val == 0)
5776 static const char * opts[] =
5778 "QUICKSTART", "NOTPOT", "NO_LIBRARY_REPLACEMENT",
5779 "NO_MOVE", "SGI_ONLY", "GUARANTEE_INIT", "DELTA_C_PLUS_PLUS",
5780 "GUARANTEE_START_INIT", "PIXIE", "DEFAULT_DELAY_LOAD",
5781 "REQUICKSTART", "REQUICKSTARTED", "CORD", "NO_UNRES_UNDEF",
5786 for (cnt = 0; cnt < ARRAY_SIZE (opts); ++cnt)
5787 if (entry->d_un.d_val & (1 << cnt))
5789 printf ("%s%s", first ? "" : " ", opts[cnt]);
5796 case DT_MIPS_IVERSION:
5797 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
5798 printf ("Interface Version: %s\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
5800 printf ("<corrupt: %ld>\n", (long) entry->d_un.d_ptr);
5803 case DT_MIPS_TIME_STAMP:
5808 time_t atime = entry->d_un.d_val;
5809 tmp = gmtime (&atime);
5810 snprintf (timebuf, sizeof (timebuf), "%04u-%02u-%02uT%02u:%02u:%02u",
5811 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
5812 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
5813 printf ("Time Stamp: %s\n", timebuf);
5817 case DT_MIPS_RLD_VERSION:
5818 case DT_MIPS_LOCAL_GOTNO:
5819 case DT_MIPS_CONFLICTNO:
5820 case DT_MIPS_LIBLISTNO:
5821 case DT_MIPS_SYMTABNO:
5822 case DT_MIPS_UNREFEXTNO:
5823 case DT_MIPS_HIPAGENO:
5824 case DT_MIPS_DELTA_CLASS_NO:
5825 case DT_MIPS_DELTA_INSTANCE_NO:
5826 case DT_MIPS_DELTA_RELOC_NO:
5827 case DT_MIPS_DELTA_SYM_NO:
5828 case DT_MIPS_DELTA_CLASSSYM_NO:
5829 case DT_MIPS_COMPACT_SIZE:
5830 printf ("%ld\n", (long) entry->d_un.d_ptr);
5834 printf ("%#lx\n", (unsigned long) entry->d_un.d_ptr);
5840 dynamic_section_parisc_val (Elf_Internal_Dyn * entry)
5842 switch (entry->d_tag)
5844 case DT_HP_DLD_FLAGS:
5853 { DT_HP_DEBUG_PRIVATE, "HP_DEBUG_PRIVATE" },
5854 { DT_HP_DEBUG_CALLBACK, "HP_DEBUG_CALLBACK" },
5855 { DT_HP_DEBUG_CALLBACK_BOR, "HP_DEBUG_CALLBACK_BOR" },
5856 { DT_HP_NO_ENVVAR, "HP_NO_ENVVAR" },
5857 { DT_HP_BIND_NOW, "HP_BIND_NOW" },
5858 { DT_HP_BIND_NONFATAL, "HP_BIND_NONFATAL" },
5859 { DT_HP_BIND_VERBOSE, "HP_BIND_VERBOSE" },
5860 { DT_HP_BIND_RESTRICTED, "HP_BIND_RESTRICTED" },
5861 { DT_HP_BIND_SYMBOLIC, "HP_BIND_SYMBOLIC" },
5862 { DT_HP_RPATH_FIRST, "HP_RPATH_FIRST" },
5863 { DT_HP_BIND_DEPTH_FIRST, "HP_BIND_DEPTH_FIRST" },
5864 { DT_HP_GST, "HP_GST" },
5865 { DT_HP_SHLIB_FIXED, "HP_SHLIB_FIXED" },
5866 { DT_HP_MERGE_SHLIB_SEG, "HP_MERGE_SHLIB_SEG" },
5867 { DT_HP_NODELETE, "HP_NODELETE" },
5868 { DT_HP_GROUP, "HP_GROUP" },
5869 { DT_HP_PROTECT_LINKAGE_TABLE, "HP_PROTECT_LINKAGE_TABLE" }
5873 bfd_vma val = entry->d_un.d_val;
5875 for (cnt = 0; cnt < ARRAY_SIZE (flags); ++cnt)
5876 if (val & flags[cnt].bit)
5880 fputs (flags[cnt].str, stdout);
5882 val ^= flags[cnt].bit;
5885 if (val != 0 || first)
5889 print_vma (val, HEX);
5895 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
5902 dynamic_section_ia64_val (Elf_Internal_Dyn * entry)
5904 switch (entry->d_tag)
5906 case DT_IA_64_PLT_RESERVE:
5907 /* First 3 slots reserved. */
5908 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
5910 print_vma (entry->d_un.d_ptr + (3 * 8), PREFIX_HEX);
5914 print_vma (entry->d_un.d_ptr, PREFIX_HEX);
5921 get_32bit_dynamic_section (FILE * file)
5923 Elf32_External_Dyn * edyn;
5924 Elf32_External_Dyn * ext;
5925 Elf_Internal_Dyn * entry;
5927 edyn = (Elf32_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
5928 dynamic_size, _("dynamic section"));
5932 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5933 might not have the luxury of section headers. Look for the DT_NULL
5934 terminator to determine the number of entries. */
5935 for (ext = edyn, dynamic_nent = 0;
5936 (char *) ext < (char *) edyn + dynamic_size;
5940 if (BYTE_GET (ext->d_tag) == DT_NULL)
5944 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
5946 if (dynamic_section == NULL)
5948 error (_("Out of memory\n"));
5953 for (ext = edyn, entry = dynamic_section;
5954 entry < dynamic_section + dynamic_nent;
5957 entry->d_tag = BYTE_GET (ext->d_tag);
5958 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
5967 get_64bit_dynamic_section (FILE * file)
5969 Elf64_External_Dyn * edyn;
5970 Elf64_External_Dyn * ext;
5971 Elf_Internal_Dyn * entry;
5973 edyn = (Elf64_External_Dyn *) get_data (NULL, file, dynamic_addr, 1,
5974 dynamic_size, _("dynamic section"));
5978 /* SGI's ELF has more than one section in the DYNAMIC segment, and we
5979 might not have the luxury of section headers. Look for the DT_NULL
5980 terminator to determine the number of entries. */
5981 for (ext = edyn, dynamic_nent = 0;
5982 (char *) ext < (char *) edyn + dynamic_size;
5986 if (BYTE_GET (ext->d_tag) == DT_NULL)
5990 dynamic_section = (Elf_Internal_Dyn *) cmalloc (dynamic_nent,
5992 if (dynamic_section == NULL)
5994 error (_("Out of memory\n"));
5999 for (ext = edyn, entry = dynamic_section;
6000 entry < dynamic_section + dynamic_nent;
6003 entry->d_tag = BYTE_GET (ext->d_tag);
6004 entry->d_un.d_val = BYTE_GET (ext->d_un.d_val);
6013 print_dynamic_flags (bfd_vma flags)
6021 flag = flags & - flags;
6031 case DF_ORIGIN: fputs ("ORIGIN", stdout); break;
6032 case DF_SYMBOLIC: fputs ("SYMBOLIC", stdout); break;
6033 case DF_TEXTREL: fputs ("TEXTREL", stdout); break;
6034 case DF_BIND_NOW: fputs ("BIND_NOW", stdout); break;
6035 case DF_STATIC_TLS: fputs ("STATIC_TLS", stdout); break;
6036 default: fputs ("unknown", stdout); break;
6042 /* Parse and display the contents of the dynamic section. */
6045 process_dynamic_section (FILE * file)
6047 Elf_Internal_Dyn * entry;
6049 if (dynamic_size == 0)
6052 printf (_("\nThere is no dynamic section in this file.\n"));
6059 if (! get_32bit_dynamic_section (file))
6062 else if (! get_64bit_dynamic_section (file))
6065 /* Find the appropriate symbol table. */
6066 if (dynamic_symbols == NULL)
6068 for (entry = dynamic_section;
6069 entry < dynamic_section + dynamic_nent;
6072 Elf_Internal_Shdr section;
6074 if (entry->d_tag != DT_SYMTAB)
6077 dynamic_info[DT_SYMTAB] = entry->d_un.d_val;
6079 /* Since we do not know how big the symbol table is,
6080 we default to reading in the entire file (!) and
6081 processing that. This is overkill, I know, but it
6083 section.sh_offset = offset_from_vma (file, entry->d_un.d_val, 0);
6085 if (archive_file_offset != 0)
6086 section.sh_size = archive_file_size - section.sh_offset;
6089 if (fseek (file, 0, SEEK_END))
6090 error (_("Unable to seek to end of file!\n"));
6092 section.sh_size = ftell (file) - section.sh_offset;
6096 section.sh_entsize = sizeof (Elf32_External_Sym);
6098 section.sh_entsize = sizeof (Elf64_External_Sym);
6100 num_dynamic_syms = section.sh_size / section.sh_entsize;
6101 if (num_dynamic_syms < 1)
6103 error (_("Unable to determine the number of symbols to load\n"));
6107 dynamic_symbols = GET_ELF_SYMBOLS (file, §ion);
6111 /* Similarly find a string table. */
6112 if (dynamic_strings == NULL)
6114 for (entry = dynamic_section;
6115 entry < dynamic_section + dynamic_nent;
6118 unsigned long offset;
6121 if (entry->d_tag != DT_STRTAB)
6124 dynamic_info[DT_STRTAB] = entry->d_un.d_val;
6126 /* Since we do not know how big the string table is,
6127 we default to reading in the entire file (!) and
6128 processing that. This is overkill, I know, but it
6131 offset = offset_from_vma (file, entry->d_un.d_val, 0);
6133 if (archive_file_offset != 0)
6134 str_tab_len = archive_file_size - offset;
6137 if (fseek (file, 0, SEEK_END))
6138 error (_("Unable to seek to end of file\n"));
6139 str_tab_len = ftell (file) - offset;
6142 if (str_tab_len < 1)
6145 (_("Unable to determine the length of the dynamic string table\n"));
6149 dynamic_strings = (char *) get_data (NULL, file, offset, 1,
6151 _("dynamic string table"));
6152 dynamic_strings_length = str_tab_len;
6157 /* And find the syminfo section if available. */
6158 if (dynamic_syminfo == NULL)
6160 unsigned long syminsz = 0;
6162 for (entry = dynamic_section;
6163 entry < dynamic_section + dynamic_nent;
6166 if (entry->d_tag == DT_SYMINENT)
6168 /* Note: these braces are necessary to avoid a syntax
6169 error from the SunOS4 C compiler. */
6170 assert (sizeof (Elf_External_Syminfo) == entry->d_un.d_val);
6172 else if (entry->d_tag == DT_SYMINSZ)
6173 syminsz = entry->d_un.d_val;
6174 else if (entry->d_tag == DT_SYMINFO)
6175 dynamic_syminfo_offset = offset_from_vma (file, entry->d_un.d_val,
6179 if (dynamic_syminfo_offset != 0 && syminsz != 0)
6181 Elf_External_Syminfo * extsyminfo;
6182 Elf_External_Syminfo * extsym;
6183 Elf_Internal_Syminfo * syminfo;
6185 /* There is a syminfo section. Read the data. */
6186 extsyminfo = (Elf_External_Syminfo *)
6187 get_data (NULL, file, dynamic_syminfo_offset, 1, syminsz,
6188 _("symbol information"));
6192 dynamic_syminfo = (Elf_Internal_Syminfo *) malloc (syminsz);
6193 if (dynamic_syminfo == NULL)
6195 error (_("Out of memory\n"));
6199 dynamic_syminfo_nent = syminsz / sizeof (Elf_External_Syminfo);
6200 for (syminfo = dynamic_syminfo, extsym = extsyminfo;
6201 syminfo < dynamic_syminfo + dynamic_syminfo_nent;
6202 ++syminfo, ++extsym)
6204 syminfo->si_boundto = BYTE_GET (extsym->si_boundto);
6205 syminfo->si_flags = BYTE_GET (extsym->si_flags);
6212 if (do_dynamic && dynamic_addr)
6213 printf (_("\nDynamic section at offset 0x%lx contains %u entries:\n"),
6214 dynamic_addr, dynamic_nent);
6216 printf (_(" Tag Type Name/Value\n"));
6218 for (entry = dynamic_section;
6219 entry < dynamic_section + dynamic_nent;
6227 print_vma (entry->d_tag, FULL_HEX);
6228 dtype = get_dynamic_type (entry->d_tag);
6229 printf (" (%s)%*s", dtype,
6230 ((is_32bit_elf ? 27 : 19)
6231 - (int) strlen (dtype)),
6235 switch (entry->d_tag)
6239 print_dynamic_flags (entry->d_un.d_val);
6249 switch (entry->d_tag)
6252 printf (_("Auxiliary library"));
6256 printf (_("Filter library"));
6260 printf (_("Configuration file"));
6264 printf (_("Dependency audit library"));
6268 printf (_("Audit library"));
6272 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
6273 printf (": [%s]\n", GET_DYNAMIC_NAME (entry->d_un.d_val));
6277 print_vma (entry->d_un.d_val, PREFIX_HEX);
6286 printf (_("Flags:"));
6288 if (entry->d_un.d_val == 0)
6289 printf (_(" None\n"));
6292 unsigned long int val = entry->d_un.d_val;
6294 if (val & DTF_1_PARINIT)
6296 printf (" PARINIT");
6297 val ^= DTF_1_PARINIT;
6299 if (val & DTF_1_CONFEXP)
6301 printf (" CONFEXP");
6302 val ^= DTF_1_CONFEXP;
6305 printf (" %lx", val);
6314 printf (_("Flags:"));
6316 if (entry->d_un.d_val == 0)
6317 printf (_(" None\n"));
6320 unsigned long int val = entry->d_un.d_val;
6322 if (val & DF_P1_LAZYLOAD)
6324 printf (" LAZYLOAD");
6325 val ^= DF_P1_LAZYLOAD;
6327 if (val & DF_P1_GROUPPERM)
6329 printf (" GROUPPERM");
6330 val ^= DF_P1_GROUPPERM;
6333 printf (" %lx", val);
6342 printf (_("Flags:"));
6343 if (entry->d_un.d_val == 0)
6344 printf (_(" None\n"));
6347 unsigned long int val = entry->d_un.d_val;
6354 if (val & DF_1_GLOBAL)
6359 if (val & DF_1_GROUP)
6364 if (val & DF_1_NODELETE)
6366 printf (" NODELETE");
6367 val ^= DF_1_NODELETE;
6369 if (val & DF_1_LOADFLTR)
6371 printf (" LOADFLTR");
6372 val ^= DF_1_LOADFLTR;
6374 if (val & DF_1_INITFIRST)
6376 printf (" INITFIRST");
6377 val ^= DF_1_INITFIRST;
6379 if (val & DF_1_NOOPEN)
6384 if (val & DF_1_ORIGIN)
6389 if (val & DF_1_DIRECT)
6394 if (val & DF_1_TRANS)
6399 if (val & DF_1_INTERPOSE)
6401 printf (" INTERPOSE");
6402 val ^= DF_1_INTERPOSE;
6404 if (val & DF_1_NODEFLIB)
6406 printf (" NODEFLIB");
6407 val ^= DF_1_NODEFLIB;
6409 if (val & DF_1_NODUMP)
6414 if (val & DF_1_CONLFAT)
6416 printf (" CONLFAT");
6417 val ^= DF_1_CONLFAT;
6420 printf (" %lx", val);
6427 dynamic_info[entry->d_tag] = entry->d_un.d_val;
6429 puts (get_dynamic_type (entry->d_un.d_val));
6449 dynamic_info[entry->d_tag] = entry->d_un.d_val;
6455 if (VALID_DYNAMIC_NAME (entry->d_un.d_val))
6456 name = GET_DYNAMIC_NAME (entry->d_un.d_val);
6462 switch (entry->d_tag)
6465 printf (_("Shared library: [%s]"), name);
6467 if (streq (name, program_interpreter))
6468 printf (_(" program interpreter"));
6472 printf (_("Library soname: [%s]"), name);
6476 printf (_("Library rpath: [%s]"), name);
6480 printf (_("Library runpath: [%s]"), name);
6484 print_vma (entry->d_un.d_val, PREFIX_HEX);
6489 print_vma (entry->d_un.d_val, PREFIX_HEX);
6502 dynamic_info[entry->d_tag] = entry->d_un.d_val;
6506 case DT_INIT_ARRAYSZ:
6507 case DT_FINI_ARRAYSZ:
6508 case DT_GNU_CONFLICTSZ:
6509 case DT_GNU_LIBLISTSZ:
6512 print_vma (entry->d_un.d_val, UNSIGNED);
6513 printf (" (bytes)\n");
6523 print_vma (entry->d_un.d_val, UNSIGNED);
6536 if (entry->d_tag == DT_USED
6537 && VALID_DYNAMIC_NAME (entry->d_un.d_val))
6539 char * name = GET_DYNAMIC_NAME (entry->d_un.d_val);
6543 printf (_("Not needed object: [%s]\n"), name);
6548 print_vma (entry->d_un.d_val, PREFIX_HEX);
6554 /* The value of this entry is ignored. */
6559 case DT_GNU_PRELINKED:
6563 time_t atime = entry->d_un.d_val;
6565 tmp = gmtime (&atime);
6566 printf ("%04u-%02u-%02uT%02u:%02u:%02u\n",
6567 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
6568 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
6574 dynamic_info_DT_GNU_HASH = entry->d_un.d_val;
6577 print_vma (entry->d_un.d_val, PREFIX_HEX);
6583 if ((entry->d_tag >= DT_VERSYM) && (entry->d_tag <= DT_VERNEEDNUM))
6584 version_info[DT_VERSIONTAGIDX (entry->d_tag)] =
6589 switch (elf_header.e_machine)
6592 case EM_MIPS_RS3_LE:
6593 dynamic_section_mips_val (entry);
6596 dynamic_section_parisc_val (entry);
6599 dynamic_section_ia64_val (entry);
6602 print_vma (entry->d_un.d_val, PREFIX_HEX);
6614 get_ver_flags (unsigned int flags)
6616 static char buff[32];
6623 if (flags & VER_FLG_BASE)
6624 strcat (buff, "BASE ");
6626 if (flags & VER_FLG_WEAK)
6628 if (flags & VER_FLG_BASE)
6629 strcat (buff, "| ");
6631 strcat (buff, "WEAK ");
6634 if (flags & ~(VER_FLG_BASE | VER_FLG_WEAK))
6635 strcat (buff, "| <unknown>");
6640 /* Display the contents of the version sections. */
6643 process_version_sections (FILE * file)
6645 Elf_Internal_Shdr * section;
6652 for (i = 0, section = section_headers;
6653 i < elf_header.e_shnum;
6656 switch (section->sh_type)
6658 case SHT_GNU_verdef:
6660 Elf_External_Verdef * edefs;
6668 (_("\nVersion definition section '%s' contains %u entries:\n"),
6669 SECTION_NAME (section), section->sh_info);
6671 printf (_(" Addr: 0x"));
6672 printf_vma (section->sh_addr);
6673 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
6674 (unsigned long) section->sh_offset, section->sh_link,
6675 section->sh_link < elf_header.e_shnum
6676 ? SECTION_NAME (section_headers + section->sh_link)
6679 edefs = (Elf_External_Verdef *)
6680 get_data (NULL, file, section->sh_offset, 1,section->sh_size,
6681 _("version definition section"));
6682 endbuf = (char *) edefs + section->sh_size;
6686 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
6689 Elf_External_Verdef * edef;
6690 Elf_Internal_Verdef ent;
6691 Elf_External_Verdaux * eaux;
6692 Elf_Internal_Verdaux aux;
6696 vstart = ((char *) edefs) + idx;
6697 if (vstart + sizeof (*edef) > endbuf)
6700 edef = (Elf_External_Verdef *) vstart;
6702 ent.vd_version = BYTE_GET (edef->vd_version);
6703 ent.vd_flags = BYTE_GET (edef->vd_flags);
6704 ent.vd_ndx = BYTE_GET (edef->vd_ndx);
6705 ent.vd_cnt = BYTE_GET (edef->vd_cnt);
6706 ent.vd_hash = BYTE_GET (edef->vd_hash);
6707 ent.vd_aux = BYTE_GET (edef->vd_aux);
6708 ent.vd_next = BYTE_GET (edef->vd_next);
6710 printf (_(" %#06x: Rev: %d Flags: %s"),
6711 idx, ent.vd_version, get_ver_flags (ent.vd_flags));
6713 printf (_(" Index: %d Cnt: %d "),
6714 ent.vd_ndx, ent.vd_cnt);
6716 vstart += ent.vd_aux;
6718 eaux = (Elf_External_Verdaux *) vstart;
6720 aux.vda_name = BYTE_GET (eaux->vda_name);
6721 aux.vda_next = BYTE_GET (eaux->vda_next);
6723 if (VALID_DYNAMIC_NAME (aux.vda_name))
6724 printf (_("Name: %s\n"), GET_DYNAMIC_NAME (aux.vda_name));
6726 printf (_("Name index: %ld\n"), aux.vda_name);
6728 isum = idx + ent.vd_aux;
6730 for (j = 1; j < ent.vd_cnt; j++)
6732 isum += aux.vda_next;
6733 vstart += aux.vda_next;
6735 eaux = (Elf_External_Verdaux *) vstart;
6736 if (vstart + sizeof (*eaux) > endbuf)
6739 aux.vda_name = BYTE_GET (eaux->vda_name);
6740 aux.vda_next = BYTE_GET (eaux->vda_next);
6742 if (VALID_DYNAMIC_NAME (aux.vda_name))
6743 printf (_(" %#06x: Parent %d: %s\n"),
6744 isum, j, GET_DYNAMIC_NAME (aux.vda_name));
6746 printf (_(" %#06x: Parent %d, name index: %ld\n"),
6747 isum, j, aux.vda_name);
6750 printf (_(" Version def aux past end of section\n"));
6754 if (cnt < section->sh_info)
6755 printf (_(" Version definition past end of section\n"));
6761 case SHT_GNU_verneed:
6763 Elf_External_Verneed * eneed;
6770 printf (_("\nVersion needs section '%s' contains %u entries:\n"),
6771 SECTION_NAME (section), section->sh_info);
6773 printf (_(" Addr: 0x"));
6774 printf_vma (section->sh_addr);
6775 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
6776 (unsigned long) section->sh_offset, section->sh_link,
6777 section->sh_link < elf_header.e_shnum
6778 ? SECTION_NAME (section_headers + section->sh_link)
6781 eneed = (Elf_External_Verneed *) get_data (NULL, file,
6782 section->sh_offset, 1,
6784 _("version need section"));
6785 endbuf = (char *) eneed + section->sh_size;
6789 for (idx = cnt = 0; cnt < section->sh_info; ++cnt)
6791 Elf_External_Verneed * entry;
6792 Elf_Internal_Verneed ent;
6797 vstart = ((char *) eneed) + idx;
6798 if (vstart + sizeof (*entry) > endbuf)
6801 entry = (Elf_External_Verneed *) vstart;
6803 ent.vn_version = BYTE_GET (entry->vn_version);
6804 ent.vn_cnt = BYTE_GET (entry->vn_cnt);
6805 ent.vn_file = BYTE_GET (entry->vn_file);
6806 ent.vn_aux = BYTE_GET (entry->vn_aux);
6807 ent.vn_next = BYTE_GET (entry->vn_next);
6809 printf (_(" %#06x: Version: %d"), idx, ent.vn_version);
6811 if (VALID_DYNAMIC_NAME (ent.vn_file))
6812 printf (_(" File: %s"), GET_DYNAMIC_NAME (ent.vn_file));
6814 printf (_(" File: %lx"), ent.vn_file);
6816 printf (_(" Cnt: %d\n"), ent.vn_cnt);
6818 vstart += ent.vn_aux;
6820 for (j = 0, isum = idx + ent.vn_aux; j < ent.vn_cnt; ++j)
6822 Elf_External_Vernaux * eaux;
6823 Elf_Internal_Vernaux aux;
6825 if (vstart + sizeof (*eaux) > endbuf)
6827 eaux = (Elf_External_Vernaux *) vstart;
6829 aux.vna_hash = BYTE_GET (eaux->vna_hash);
6830 aux.vna_flags = BYTE_GET (eaux->vna_flags);
6831 aux.vna_other = BYTE_GET (eaux->vna_other);
6832 aux.vna_name = BYTE_GET (eaux->vna_name);
6833 aux.vna_next = BYTE_GET (eaux->vna_next);
6835 if (VALID_DYNAMIC_NAME (aux.vna_name))
6836 printf (_(" %#06x: Name: %s"),
6837 isum, GET_DYNAMIC_NAME (aux.vna_name));
6839 printf (_(" %#06x: Name index: %lx"),
6840 isum, aux.vna_name);
6842 printf (_(" Flags: %s Version: %d\n"),
6843 get_ver_flags (aux.vna_flags), aux.vna_other);
6845 isum += aux.vna_next;
6846 vstart += aux.vna_next;
6849 printf (_(" Version need aux past end of section\n"));
6853 if (cnt < section->sh_info)
6854 printf (_(" Version need past end of section\n"));
6860 case SHT_GNU_versym:
6862 Elf_Internal_Shdr * link_section;
6865 unsigned char * edata;
6866 unsigned short * data;
6868 Elf_Internal_Sym * symbols;
6869 Elf_Internal_Shdr * string_sec;
6872 if (section->sh_link >= elf_header.e_shnum)
6875 link_section = section_headers + section->sh_link;
6876 total = section->sh_size / sizeof (Elf_External_Versym);
6878 if (link_section->sh_link >= elf_header.e_shnum)
6883 symbols = GET_ELF_SYMBOLS (file, link_section);
6885 string_sec = section_headers + link_section->sh_link;
6887 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
6888 string_sec->sh_size,
6889 _("version string table"));
6893 printf (_("\nVersion symbols section '%s' contains %d entries:\n"),
6894 SECTION_NAME (section), total);
6896 printf (_(" Addr: "));
6897 printf_vma (section->sh_addr);
6898 printf (_(" Offset: %#08lx Link: %u (%s)\n"),
6899 (unsigned long) section->sh_offset, section->sh_link,
6900 SECTION_NAME (link_section));
6902 off = offset_from_vma (file,
6903 version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
6904 total * sizeof (short));
6905 edata = (unsigned char *) get_data (NULL, file, off, total,
6907 _("version symbol data"));
6914 data = (short unsigned int *) cmalloc (total, sizeof (short));
6916 for (cnt = total; cnt --;)
6917 data[cnt] = byte_get (edata + cnt * sizeof (short),
6922 for (cnt = 0; cnt < total; cnt += 4)
6925 int check_def, check_need;
6928 printf (" %03x:", cnt);
6930 for (j = 0; (j < 4) && (cnt + j) < total; ++j)
6931 switch (data[cnt + j])
6934 fputs (_(" 0 (*local*) "), stdout);
6938 fputs (_(" 1 (*global*) "), stdout);
6942 nn = printf ("%4x%c", data[cnt + j] & VERSYM_VERSION,
6943 data[cnt + j] & VERSYM_HIDDEN ? 'h' : ' ');
6947 if (symbols[cnt + j].st_shndx >= elf_header.e_shnum
6948 || section_headers[symbols[cnt + j].st_shndx].sh_type
6951 if (symbols[cnt + j].st_shndx == SHN_UNDEF)
6958 && version_info[DT_VERSIONTAGIDX (DT_VERNEED)])
6960 Elf_Internal_Verneed ivn;
6961 unsigned long offset;
6963 offset = offset_from_vma
6964 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
6965 sizeof (Elf_External_Verneed));
6969 Elf_Internal_Vernaux ivna;
6970 Elf_External_Verneed evn;
6971 Elf_External_Vernaux evna;
6972 unsigned long a_off;
6974 get_data (&evn, file, offset, sizeof (evn), 1,
6977 ivn.vn_aux = BYTE_GET (evn.vn_aux);
6978 ivn.vn_next = BYTE_GET (evn.vn_next);
6980 a_off = offset + ivn.vn_aux;
6984 get_data (&evna, file, a_off, sizeof (evna),
6985 1, _("version need aux (2)"));
6987 ivna.vna_next = BYTE_GET (evna.vna_next);
6988 ivna.vna_other = BYTE_GET (evna.vna_other);
6990 a_off += ivna.vna_next;
6992 while (ivna.vna_other != data[cnt + j]
6993 && ivna.vna_next != 0);
6995 if (ivna.vna_other == data[cnt + j])
6997 ivna.vna_name = BYTE_GET (evna.vna_name);
6999 if (ivna.vna_name >= string_sec->sh_size)
7000 name = _("*invalid*");
7002 name = strtab + ivna.vna_name;
7003 nn += printf ("(%s%-*s",
7005 12 - (int) strlen (name),
7011 offset += ivn.vn_next;
7013 while (ivn.vn_next);
7016 if (check_def && data[cnt + j] != 0x8001
7017 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
7019 Elf_Internal_Verdef ivd;
7020 Elf_External_Verdef evd;
7021 unsigned long offset;
7023 offset = offset_from_vma
7024 (file, version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
7029 get_data (&evd, file, offset, sizeof (evd), 1,
7032 ivd.vd_next = BYTE_GET (evd.vd_next);
7033 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
7035 offset += ivd.vd_next;
7037 while (ivd.vd_ndx != (data[cnt + j] & VERSYM_VERSION)
7038 && ivd.vd_next != 0);
7040 if (ivd.vd_ndx == (data[cnt + j] & VERSYM_VERSION))
7042 Elf_External_Verdaux evda;
7043 Elf_Internal_Verdaux ivda;
7045 ivd.vd_aux = BYTE_GET (evd.vd_aux);
7047 get_data (&evda, file,
7048 offset - ivd.vd_next + ivd.vd_aux,
7050 _("version def aux"));
7052 ivda.vda_name = BYTE_GET (evda.vda_name);
7054 if (ivda.vda_name >= string_sec->sh_size)
7055 name = _("*invalid*");
7057 name = strtab + ivda.vda_name;
7058 nn += printf ("(%s%-*s",
7060 12 - (int) strlen (name),
7066 printf ("%*c", 18 - nn, ' ');
7084 printf (_("\nNo version information found in this file.\n"));
7090 get_symbol_binding (unsigned int binding)
7092 static char buff[32];
7096 case STB_LOCAL: return "LOCAL";
7097 case STB_GLOBAL: return "GLOBAL";
7098 case STB_WEAK: return "WEAK";
7100 if (binding >= STB_LOPROC && binding <= STB_HIPROC)
7101 snprintf (buff, sizeof (buff), _("<processor specific>: %d"),
7103 else if (binding >= STB_LOOS && binding <= STB_HIOS)
7105 if (binding == STB_GNU_UNIQUE
7106 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_LINUX
7107 /* GNU/Linux is still using the default value 0. */
7108 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
7110 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), binding);
7113 snprintf (buff, sizeof (buff), _("<unknown>: %d"), binding);
7119 get_symbol_type (unsigned int type)
7121 static char buff[32];
7125 case STT_NOTYPE: return "NOTYPE";
7126 case STT_OBJECT: return "OBJECT";
7127 case STT_FUNC: return "FUNC";
7128 case STT_SECTION: return "SECTION";
7129 case STT_FILE: return "FILE";
7130 case STT_COMMON: return "COMMON";
7131 case STT_TLS: return "TLS";
7132 case STT_RELC: return "RELC";
7133 case STT_SRELC: return "SRELC";
7135 if (type >= STT_LOPROC && type <= STT_HIPROC)
7137 if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC)
7138 return "THUMB_FUNC";
7140 if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER)
7143 if (elf_header.e_machine == EM_PARISC && type == STT_PARISC_MILLI)
7144 return "PARISC_MILLI";
7146 snprintf (buff, sizeof (buff), _("<processor specific>: %d"), type);
7148 else if (type >= STT_LOOS && type <= STT_HIOS)
7150 if (elf_header.e_machine == EM_PARISC)
7152 if (type == STT_HP_OPAQUE)
7154 if (type == STT_HP_STUB)
7158 if (type == STT_GNU_IFUNC
7159 && (elf_header.e_ident[EI_OSABI] == ELFOSABI_LINUX
7160 /* GNU/Linux is still using the default value 0. */
7161 || elf_header.e_ident[EI_OSABI] == ELFOSABI_NONE))
7164 snprintf (buff, sizeof (buff), _("<OS specific>: %d"), type);
7167 snprintf (buff, sizeof (buff), _("<unknown>: %d"), type);
7173 get_symbol_visibility (unsigned int visibility)
7177 case STV_DEFAULT: return "DEFAULT";
7178 case STV_INTERNAL: return "INTERNAL";
7179 case STV_HIDDEN: return "HIDDEN";
7180 case STV_PROTECTED: return "PROTECTED";
7186 get_mips_symbol_other (unsigned int other)
7190 case STO_OPTIONAL: return "OPTIONAL";
7191 case STO_MIPS16: return "MIPS16";
7192 case STO_MIPS_PLT: return "MIPS PLT";
7193 case STO_MIPS_PIC: return "MIPS PIC";
7194 default: return NULL;
7199 get_symbol_other (unsigned int other)
7201 const char * result = NULL;
7202 static char buff [32];
7207 switch (elf_header.e_machine)
7210 result = get_mips_symbol_other (other);
7218 snprintf (buff, sizeof buff, _("<other>: %x"), other);
7223 get_symbol_index_type (unsigned int type)
7225 static char buff[32];
7229 case SHN_UNDEF: return "UND";
7230 case SHN_ABS: return "ABS";
7231 case SHN_COMMON: return "COM";
7233 if (type == SHN_IA_64_ANSI_COMMON
7234 && elf_header.e_machine == EM_IA_64
7235 && elf_header.e_ident[EI_OSABI] == ELFOSABI_HPUX)
7237 else if ((elf_header.e_machine == EM_X86_64
7238 || elf_header.e_machine == EM_L1OM)
7239 && type == SHN_X86_64_LCOMMON)
7241 else if (type == SHN_MIPS_SCOMMON
7242 && elf_header.e_machine == EM_MIPS)
7244 else if (type == SHN_MIPS_SUNDEFINED
7245 && elf_header.e_machine == EM_MIPS)
7247 else if (type >= SHN_LOPROC && type <= SHN_HIPROC)
7248 sprintf (buff, "PRC[0x%04x]", type & 0xffff);
7249 else if (type >= SHN_LOOS && type <= SHN_HIOS)
7250 sprintf (buff, "OS [0x%04x]", type & 0xffff);
7251 else if (type >= SHN_LORESERVE)
7252 sprintf (buff, "RSV[0x%04x]", type & 0xffff);
7254 sprintf (buff, "%3d", type);
7262 get_dynamic_data (FILE * file, unsigned int number, unsigned int ent_size)
7264 unsigned char * e_data;
7267 e_data = (unsigned char *) cmalloc (number, ent_size);
7271 error (_("Out of memory\n"));
7275 if (fread (e_data, ent_size, number, file) != number)
7277 error (_("Unable to read in dynamic data\n"));
7281 i_data = (bfd_vma *) cmalloc (number, sizeof (*i_data));
7285 error (_("Out of memory\n"));
7291 i_data[number] = byte_get (e_data + number * ent_size, ent_size);
7299 print_dynamic_symbol (bfd_vma si, unsigned long hn)
7301 Elf_Internal_Sym * psym;
7304 psym = dynamic_symbols + si;
7306 n = print_vma (si, DEC_5);
7308 fputs (" " + n, stdout);
7309 printf (" %3lu: ", hn);
7310 print_vma (psym->st_value, LONG_HEX);
7312 print_vma (psym->st_size, DEC_5);
7314 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
7315 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
7316 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
7317 /* Check to see if any other bits in the st_other field are set.
7318 Note - displaying this information disrupts the layout of the
7319 table being generated, but for the moment this case is very
7321 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
7322 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
7323 printf (" %3.3s ", get_symbol_index_type (psym->st_shndx));
7324 if (VALID_DYNAMIC_NAME (psym->st_name))
7325 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
7327 printf (" <corrupt: %14ld>", psym->st_name);
7331 /* Dump the symbol table. */
7333 process_symbol_table (FILE * file)
7335 Elf_Internal_Shdr * section;
7336 bfd_vma nbuckets = 0;
7337 bfd_vma nchains = 0;
7338 bfd_vma * buckets = NULL;
7339 bfd_vma * chains = NULL;
7340 bfd_vma ngnubuckets = 0;
7341 bfd_vma * gnubuckets = NULL;
7342 bfd_vma * gnuchains = NULL;
7343 bfd_vma gnusymidx = 0;
7345 if (! do_syms && !do_histogram)
7348 if (dynamic_info[DT_HASH]
7350 || (do_using_dynamic && dynamic_strings != NULL)))
7352 unsigned char nb[8];
7353 unsigned char nc[8];
7354 int hash_ent_size = 4;
7356 if ((elf_header.e_machine == EM_ALPHA
7357 || elf_header.e_machine == EM_S390
7358 || elf_header.e_machine == EM_S390_OLD)
7359 && elf_header.e_ident[EI_CLASS] == ELFCLASS64)
7363 (archive_file_offset
7364 + offset_from_vma (file, dynamic_info[DT_HASH],
7365 sizeof nb + sizeof nc)),
7368 error (_("Unable to seek to start of dynamic information\n"));
7372 if (fread (nb, hash_ent_size, 1, file) != 1)
7374 error (_("Failed to read in number of buckets\n"));
7378 if (fread (nc, hash_ent_size, 1, file) != 1)
7380 error (_("Failed to read in number of chains\n"));
7384 nbuckets = byte_get (nb, hash_ent_size);
7385 nchains = byte_get (nc, hash_ent_size);
7387 buckets = get_dynamic_data (file, nbuckets, hash_ent_size);
7388 chains = get_dynamic_data (file, nchains, hash_ent_size);
7391 if (buckets == NULL || chains == NULL)
7393 if (do_using_dynamic)
7404 if (dynamic_info_DT_GNU_HASH
7406 || (do_using_dynamic && dynamic_strings != NULL)))
7408 unsigned char nb[16];
7409 bfd_vma i, maxchain = 0xffffffff, bitmaskwords;
7410 bfd_vma buckets_vma;
7413 (archive_file_offset
7414 + offset_from_vma (file, dynamic_info_DT_GNU_HASH,
7418 error (_("Unable to seek to start of dynamic information\n"));
7422 if (fread (nb, 16, 1, file) != 1)
7424 error (_("Failed to read in number of buckets\n"));
7428 ngnubuckets = byte_get (nb, 4);
7429 gnusymidx = byte_get (nb + 4, 4);
7430 bitmaskwords = byte_get (nb + 8, 4);
7431 buckets_vma = dynamic_info_DT_GNU_HASH + 16;
7433 buckets_vma += bitmaskwords * 4;
7435 buckets_vma += bitmaskwords * 8;
7438 (archive_file_offset
7439 + offset_from_vma (file, buckets_vma, 4)),
7442 error (_("Unable to seek to start of dynamic information\n"));
7446 gnubuckets = get_dynamic_data (file, ngnubuckets, 4);
7448 if (gnubuckets == NULL)
7451 for (i = 0; i < ngnubuckets; i++)
7452 if (gnubuckets[i] != 0)
7454 if (gnubuckets[i] < gnusymidx)
7457 if (maxchain == 0xffffffff || gnubuckets[i] > maxchain)
7458 maxchain = gnubuckets[i];
7461 if (maxchain == 0xffffffff)
7464 maxchain -= gnusymidx;
7467 (archive_file_offset
7468 + offset_from_vma (file, buckets_vma
7469 + 4 * (ngnubuckets + maxchain), 4)),
7472 error (_("Unable to seek to start of dynamic information\n"));
7478 if (fread (nb, 4, 1, file) != 1)
7480 error (_("Failed to determine last chain length\n"));
7484 if (maxchain + 1 == 0)
7489 while ((byte_get (nb, 4) & 1) == 0);
7492 (archive_file_offset
7493 + offset_from_vma (file, buckets_vma + 4 * ngnubuckets, 4)),
7496 error (_("Unable to seek to start of dynamic information\n"));
7500 gnuchains = get_dynamic_data (file, maxchain, 4);
7503 if (gnuchains == NULL)
7508 if (do_using_dynamic)
7513 if ((dynamic_info[DT_HASH] || dynamic_info_DT_GNU_HASH)
7516 && dynamic_strings != NULL)
7520 if (dynamic_info[DT_HASH])
7524 printf (_("\nSymbol table for image:\n"));
7526 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7528 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7530 for (hn = 0; hn < nbuckets; hn++)
7535 for (si = buckets[hn]; si < nchains && si > 0; si = chains[si])
7536 print_dynamic_symbol (si, hn);
7540 if (dynamic_info_DT_GNU_HASH)
7542 printf (_("\nSymbol table of `.gnu.hash' for image:\n"));
7544 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7546 printf (_(" Num Buc: Value Size Type Bind Vis Ndx Name\n"));
7548 for (hn = 0; hn < ngnubuckets; ++hn)
7549 if (gnubuckets[hn] != 0)
7551 bfd_vma si = gnubuckets[hn];
7552 bfd_vma off = si - gnusymidx;
7556 print_dynamic_symbol (si, hn);
7559 while ((gnuchains[off++] & 1) == 0);
7563 else if (do_syms && !do_using_dynamic)
7567 for (i = 0, section = section_headers;
7568 i < elf_header.e_shnum;
7572 char * strtab = NULL;
7573 unsigned long int strtab_size = 0;
7574 Elf_Internal_Sym * symtab;
7575 Elf_Internal_Sym * psym;
7577 if ( section->sh_type != SHT_SYMTAB
7578 && section->sh_type != SHT_DYNSYM)
7581 printf (_("\nSymbol table '%s' contains %lu entries:\n"),
7582 SECTION_NAME (section),
7583 (unsigned long) (section->sh_size / section->sh_entsize));
7585 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
7587 printf (_(" Num: Value Size Type Bind Vis Ndx Name\n"));
7589 symtab = GET_ELF_SYMBOLS (file, section);
7593 if (section->sh_link == elf_header.e_shstrndx)
7595 strtab = string_table;
7596 strtab_size = string_table_length;
7598 else if (section->sh_link < elf_header.e_shnum)
7600 Elf_Internal_Shdr * string_sec;
7602 string_sec = section_headers + section->sh_link;
7604 strtab = (char *) get_data (NULL, file, string_sec->sh_offset,
7605 1, string_sec->sh_size,
7607 strtab_size = strtab != NULL ? string_sec->sh_size : 0;
7610 for (si = 0, psym = symtab;
7611 si < section->sh_size / section->sh_entsize;
7614 printf ("%6d: ", si);
7615 print_vma (psym->st_value, LONG_HEX);
7617 print_vma (psym->st_size, DEC_5);
7618 printf (" %-7s", get_symbol_type (ELF_ST_TYPE (psym->st_info)));
7619 printf (" %-6s", get_symbol_binding (ELF_ST_BIND (psym->st_info)));
7620 printf (" %-7s", get_symbol_visibility (ELF_ST_VISIBILITY (psym->st_other)));
7621 /* Check to see if any other bits in the st_other field are set.
7622 Note - displaying this information disrupts the layout of the
7623 table being generated, but for the moment this case is very rare. */
7624 if (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other))
7625 printf (" [%s] ", get_symbol_other (psym->st_other ^ ELF_ST_VISIBILITY (psym->st_other)));
7626 printf (" %4s ", get_symbol_index_type (psym->st_shndx));
7627 print_symbol (25, psym->st_name < strtab_size
7628 ? strtab + psym->st_name : "<corrupt>");
7630 if (section->sh_type == SHT_DYNSYM &&
7631 version_info[DT_VERSIONTAGIDX (DT_VERSYM)] != 0)
7633 unsigned char data[2];
7634 unsigned short vers_data;
7635 unsigned long offset;
7639 offset = offset_from_vma
7640 (file, version_info[DT_VERSIONTAGIDX (DT_VERSYM)],
7641 sizeof data + si * sizeof (vers_data));
7643 get_data (&data, file, offset + si * sizeof (vers_data),
7644 sizeof (data), 1, _("version data"));
7646 vers_data = byte_get (data, 2);
7648 is_nobits = (psym->st_shndx < elf_header.e_shnum
7649 && section_headers[psym->st_shndx].sh_type
7652 check_def = (psym->st_shndx != SHN_UNDEF);
7654 if ((vers_data & VERSYM_HIDDEN) || vers_data > 1)
7656 if (version_info[DT_VERSIONTAGIDX (DT_VERNEED)]
7657 && (is_nobits || ! check_def))
7659 Elf_External_Verneed evn;
7660 Elf_Internal_Verneed ivn;
7661 Elf_Internal_Vernaux ivna;
7663 /* We must test both. */
7664 offset = offset_from_vma
7665 (file, version_info[DT_VERSIONTAGIDX (DT_VERNEED)],
7670 unsigned long vna_off;
7672 get_data (&evn, file, offset, sizeof (evn), 1,
7675 ivn.vn_aux = BYTE_GET (evn.vn_aux);
7676 ivn.vn_next = BYTE_GET (evn.vn_next);
7678 vna_off = offset + ivn.vn_aux;
7682 Elf_External_Vernaux evna;
7684 get_data (&evna, file, vna_off,
7686 _("version need aux (3)"));
7688 ivna.vna_other = BYTE_GET (evna.vna_other);
7689 ivna.vna_next = BYTE_GET (evna.vna_next);
7690 ivna.vna_name = BYTE_GET (evna.vna_name);
7692 vna_off += ivna.vna_next;
7694 while (ivna.vna_other != vers_data
7695 && ivna.vna_next != 0);
7697 if (ivna.vna_other == vers_data)
7700 offset += ivn.vn_next;
7702 while (ivn.vn_next != 0);
7704 if (ivna.vna_other == vers_data)
7707 ivna.vna_name < strtab_size
7708 ? strtab + ivna.vna_name : "<corrupt>",
7712 else if (! is_nobits)
7713 error (_("bad dynamic symbol\n"));
7720 if (vers_data != 0x8001
7721 && version_info[DT_VERSIONTAGIDX (DT_VERDEF)])
7723 Elf_Internal_Verdef ivd;
7724 Elf_Internal_Verdaux ivda;
7725 Elf_External_Verdaux evda;
7728 off = offset_from_vma
7730 version_info[DT_VERSIONTAGIDX (DT_VERDEF)],
7731 sizeof (Elf_External_Verdef));
7735 Elf_External_Verdef evd;
7737 get_data (&evd, file, off, sizeof (evd),
7738 1, _("version def"));
7740 ivd.vd_ndx = BYTE_GET (evd.vd_ndx);
7741 ivd.vd_aux = BYTE_GET (evd.vd_aux);
7742 ivd.vd_next = BYTE_GET (evd.vd_next);
7746 while (ivd.vd_ndx != (vers_data & VERSYM_VERSION)
7747 && ivd.vd_next != 0);
7752 get_data (&evda, file, off, sizeof (evda),
7753 1, _("version def aux"));
7755 ivda.vda_name = BYTE_GET (evda.vda_name);
7757 if (psym->st_name != ivda.vda_name)
7758 printf ((vers_data & VERSYM_HIDDEN)
7760 ivda.vda_name < strtab_size
7761 ? strtab + ivda.vda_name : "<corrupt>");
7771 if (strtab != string_table)
7777 (_("\nDynamic symbol information is not available for displaying symbols.\n"));
7779 if (do_histogram && buckets != NULL)
7781 unsigned long * lengths;
7782 unsigned long * counts;
7785 unsigned long maxlength = 0;
7786 unsigned long nzero_counts = 0;
7787 unsigned long nsyms = 0;
7789 printf (_("\nHistogram for bucket list length (total of %lu buckets):\n"),
7790 (unsigned long) nbuckets);
7791 printf (_(" Length Number %% of total Coverage\n"));
7793 lengths = (unsigned long *) calloc (nbuckets, sizeof (*lengths));
7794 if (lengths == NULL)
7796 error (_("Out of memory\n"));
7799 for (hn = 0; hn < nbuckets; ++hn)
7801 for (si = buckets[hn]; si > 0 && si < nchains; si = chains[si])
7804 if (maxlength < ++lengths[hn])
7809 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
7812 error (_("Out of memory\n"));
7816 for (hn = 0; hn < nbuckets; ++hn)
7817 ++counts[lengths[hn]];
7822 printf (" 0 %-10lu (%5.1f%%)\n",
7823 counts[0], (counts[0] * 100.0) / nbuckets);
7824 for (i = 1; i <= maxlength; ++i)
7826 nzero_counts += counts[i] * i;
7827 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
7828 i, counts[i], (counts[i] * 100.0) / nbuckets,
7829 (nzero_counts * 100.0) / nsyms);
7837 if (buckets != NULL)
7843 if (do_histogram && gnubuckets != NULL)
7845 unsigned long * lengths;
7846 unsigned long * counts;
7848 unsigned long maxlength = 0;
7849 unsigned long nzero_counts = 0;
7850 unsigned long nsyms = 0;
7852 lengths = (unsigned long *) calloc (ngnubuckets, sizeof (*lengths));
7853 if (lengths == NULL)
7855 error (_("Out of memory\n"));
7859 printf (_("\nHistogram for `.gnu.hash' bucket list length (total of %lu buckets):\n"),
7860 (unsigned long) ngnubuckets);
7861 printf (_(" Length Number %% of total Coverage\n"));
7863 for (hn = 0; hn < ngnubuckets; ++hn)
7864 if (gnubuckets[hn] != 0)
7866 bfd_vma off, length = 1;
7868 for (off = gnubuckets[hn] - gnusymidx;
7869 (gnuchains[off] & 1) == 0; ++off)
7871 lengths[hn] = length;
7872 if (length > maxlength)
7877 counts = (unsigned long *) calloc (maxlength + 1, sizeof (*counts));
7880 error (_("Out of memory\n"));
7884 for (hn = 0; hn < ngnubuckets; ++hn)
7885 ++counts[lengths[hn]];
7887 if (ngnubuckets > 0)
7890 printf (" 0 %-10lu (%5.1f%%)\n",
7891 counts[0], (counts[0] * 100.0) / ngnubuckets);
7892 for (j = 1; j <= maxlength; ++j)
7894 nzero_counts += counts[j] * j;
7895 printf ("%7lu %-10lu (%5.1f%%) %5.1f%%\n",
7896 j, counts[j], (counts[j] * 100.0) / ngnubuckets,
7897 (nzero_counts * 100.0) / nsyms);
7911 process_syminfo (FILE * file ATTRIBUTE_UNUSED)
7915 if (dynamic_syminfo == NULL
7917 /* No syminfo, this is ok. */
7920 /* There better should be a dynamic symbol section. */
7921 if (dynamic_symbols == NULL || dynamic_strings == NULL)
7925 printf (_("\nDynamic info segment at offset 0x%lx contains %d entries:\n"),
7926 dynamic_syminfo_offset, dynamic_syminfo_nent);
7928 printf (_(" Num: Name BoundTo Flags\n"));
7929 for (i = 0; i < dynamic_syminfo_nent; ++i)
7931 unsigned short int flags = dynamic_syminfo[i].si_flags;
7933 printf ("%4d: ", i);
7934 if (VALID_DYNAMIC_NAME (dynamic_symbols[i].st_name))
7935 print_symbol (30, GET_DYNAMIC_NAME (dynamic_symbols[i].st_name));
7937 printf ("<corrupt: %19ld>", dynamic_symbols[i].st_name);
7940 switch (dynamic_syminfo[i].si_boundto)
7942 case SYMINFO_BT_SELF:
7943 fputs ("SELF ", stdout);
7945 case SYMINFO_BT_PARENT:
7946 fputs ("PARENT ", stdout);
7949 if (dynamic_syminfo[i].si_boundto > 0
7950 && dynamic_syminfo[i].si_boundto < dynamic_nent
7951 && VALID_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val))
7953 print_symbol (10, GET_DYNAMIC_NAME (dynamic_section[dynamic_syminfo[i].si_boundto].d_un.d_val));
7957 printf ("%-10d ", dynamic_syminfo[i].si_boundto);
7961 if (flags & SYMINFO_FLG_DIRECT)
7963 if (flags & SYMINFO_FLG_PASSTHRU)
7964 printf (" PASSTHRU");
7965 if (flags & SYMINFO_FLG_COPY)
7967 if (flags & SYMINFO_FLG_LAZYLOAD)
7968 printf (" LAZYLOAD");
7976 /* Check to see if the given reloc needs to be handled in a target specific
7977 manner. If so then process the reloc and return TRUE otherwise return
7981 target_specific_reloc_handling (Elf_Internal_Rela * reloc,
7982 unsigned char * start,
7983 Elf_Internal_Sym * symtab)
7985 unsigned int reloc_type = get_reloc_type (reloc->r_info);
7987 switch (elf_header.e_machine)
7990 case EM_CYGNUS_MN10300:
7992 static Elf_Internal_Sym * saved_sym = NULL;
7996 case 34: /* R_MN10300_ALIGN */
7998 case 33: /* R_MN10300_SYM_DIFF */
7999 saved_sym = symtab + get_reloc_symindex (reloc->r_info);
8001 case 1: /* R_MN10300_32 */
8002 case 2: /* R_MN10300_16 */
8003 if (saved_sym != NULL)
8007 value = reloc->r_addend
8008 + (symtab[get_reloc_symindex (reloc->r_info)].st_value
8009 - saved_sym->st_value);
8011 byte_put (start + reloc->r_offset, value, reloc_type == 1 ? 4 : 2);
8018 if (saved_sym != NULL)
8019 error (_("Unhandled MN10300 reloc type found after SYM_DIFF reloc"));
8029 /* Returns TRUE iff RELOC_TYPE is a 32-bit absolute RELA relocation used in
8030 DWARF debug sections. This is a target specific test. Note - we do not
8031 go through the whole including-target-headers-multiple-times route, (as
8032 we have already done with <elf/h8.h>) because this would become very
8033 messy and even then this function would have to contain target specific
8034 information (the names of the relocs instead of their numeric values).
8035 FIXME: This is not the correct way to solve this problem. The proper way
8036 is to have target specific reloc sizing and typing functions created by
8037 the reloc-macros.h header, in the same way that it already creates the
8038 reloc naming functions. */
8041 is_32bit_abs_reloc (unsigned int reloc_type)
8043 switch (elf_header.e_machine)
8047 return reloc_type == 1; /* R_386_32. */
8049 return reloc_type == 1; /* R_68K_32. */
8051 return reloc_type == 1; /* R_860_32. */
8053 return reloc_type == 1; /* XXX Is this right ? */
8055 return reloc_type == 1; /* R_ARC_32. */
8057 return reloc_type == 2; /* R_ARM_ABS32 */
8060 return reloc_type == 1;
8062 return reloc_type == 0x12; /* R_byte4_data. */
8064 return reloc_type == 3; /* R_CRIS_32. */
8067 return reloc_type == 3; /* R_CR16_NUM32. */
8069 return reloc_type == 15; /* R_CRX_NUM32. */
8071 return reloc_type == 1;
8072 case EM_CYGNUS_D10V:
8074 return reloc_type == 6; /* R_D10V_32. */
8075 case EM_CYGNUS_D30V:
8077 return reloc_type == 12; /* R_D30V_32_NORMAL. */
8079 return reloc_type == 3; /* R_DLX_RELOC_32. */
8080 case EM_CYGNUS_FR30:
8082 return reloc_type == 3; /* R_FR30_32. */
8086 return reloc_type == 1; /* R_H8_DIR32. */
8088 return reloc_type == 0x65; /* R_IA64_SECREL32LSB. */
8091 return reloc_type == 2; /* R_IP2K_32. */
8093 return reloc_type == 2; /* R_IQ2000_32. */
8094 case EM_LATTICEMICO32:
8095 return reloc_type == 3; /* R_LM32_32. */
8098 return reloc_type == 3; /* R_M32C_32. */
8100 return reloc_type == 34; /* R_M32R_32_RELA. */
8102 return reloc_type == 1; /* R_MCORE_ADDR32. */
8104 return reloc_type == 4; /* R_MEP_32. */
8106 return reloc_type == 2; /* R_MIPS_32. */
8108 return reloc_type == 4; /* R_MMIX_32. */
8109 case EM_CYGNUS_MN10200:
8111 return reloc_type == 1; /* R_MN10200_32. */
8112 case EM_CYGNUS_MN10300:
8114 return reloc_type == 1; /* R_MN10300_32. */
8117 return reloc_type == 1; /* R_MSP43_32. */
8119 return reloc_type == 2; /* R_MT_32. */
8120 case EM_ALTERA_NIOS2:
8122 return reloc_type == 1; /* R_NIOS_32. */
8125 return reloc_type == 1; /* R_OR32_32. */
8127 return (reloc_type == 1 /* R_PARISC_DIR32. */
8128 || reloc_type == 41); /* R_PARISC_SECREL32. */
8131 return reloc_type == 1; /* R_PJ_DATA_DIR32. */
8133 return reloc_type == 1; /* R_PPC64_ADDR32. */
8135 return reloc_type == 1; /* R_PPC_ADDR32. */
8137 return reloc_type == 1; /* R_RX_DIR32. */
8139 return reloc_type == 1; /* R_I370_ADDR31. */
8142 return reloc_type == 4; /* R_S390_32. */
8144 return reloc_type == 8; /* R_SCORE_ABS32. */
8146 return reloc_type == 1; /* R_SH_DIR32. */
8147 case EM_SPARC32PLUS:
8150 return reloc_type == 3 /* R_SPARC_32. */
8151 || reloc_type == 23; /* R_SPARC_UA32. */
8153 return reloc_type == 6; /* R_SPU_ADDR32 */
8154 case EM_CYGNUS_V850:
8156 return reloc_type == 6; /* R_V850_ABS32. */
8158 return reloc_type == 1; /* R_VAX_32. */
8161 return reloc_type == 10; /* R_X86_64_32. */
8164 return reloc_type == 3; /* R_XC16C_ABS_32. */
8166 return reloc_type == 1; /* R_XSTROMY16_32. */
8169 return reloc_type == 1; /* R_XTENSA_32. */
8171 error (_("Missing knowledge of 32-bit reloc types used in DWARF sections of machine number %d\n"),
8172 elf_header.e_machine);
8177 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8178 a 32-bit pc-relative RELA relocation used in DWARF debug sections. */
8181 is_32bit_pcrel_reloc (unsigned int reloc_type)
8183 switch (elf_header.e_machine)
8187 return reloc_type == 2; /* R_386_PC32. */
8189 return reloc_type == 4; /* R_68K_PC32. */
8191 return reloc_type == 10; /* R_ALPHA_SREL32. */
8193 return reloc_type == 3; /* R_ARM_REL32 */
8195 return reloc_type == 9; /* R_PARISC_PCREL32. */
8197 return reloc_type == 26; /* R_PPC_REL32. */
8199 return reloc_type == 26; /* R_PPC64_REL32. */
8202 return reloc_type == 5; /* R_390_PC32. */
8204 return reloc_type == 2; /* R_SH_REL32. */
8205 case EM_SPARC32PLUS:
8208 return reloc_type == 6; /* R_SPARC_DISP32. */
8210 return reloc_type == 13; /* R_SPU_REL32. */
8213 return reloc_type == 2; /* R_X86_64_PC32. */
8216 return reloc_type == 14; /* R_XTENSA_32_PCREL. */
8218 /* Do not abort or issue an error message here. Not all targets use
8219 pc-relative 32-bit relocs in their DWARF debug information and we
8220 have already tested for target coverage in is_32bit_abs_reloc. A
8221 more helpful warning message will be generated by apply_relocations
8222 anyway, so just return. */
8227 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8228 a 64-bit absolute RELA relocation used in DWARF debug sections. */
8231 is_64bit_abs_reloc (unsigned int reloc_type)
8233 switch (elf_header.e_machine)
8236 return reloc_type == 2; /* R_ALPHA_REFQUAD. */
8238 return reloc_type == 0x27; /* R_IA64_DIR64LSB. */
8240 return reloc_type == 80; /* R_PARISC_DIR64. */
8242 return reloc_type == 38; /* R_PPC64_ADDR64. */
8243 case EM_SPARC32PLUS:
8246 return reloc_type == 54; /* R_SPARC_UA64. */
8249 return reloc_type == 1; /* R_X86_64_64. */
8252 return reloc_type == 22; /* R_S390_64 */
8254 return reloc_type == 18; /* R_MIPS_64 */
8260 /* Like is_32bit_pcrel_reloc except that it returns TRUE iff RELOC_TYPE is
8261 a 64-bit pc-relative RELA relocation used in DWARF debug sections. */
8264 is_64bit_pcrel_reloc (unsigned int reloc_type)
8266 switch (elf_header.e_machine)
8269 return reloc_type == 11; /* R_ALPHA_SREL64 */
8271 return reloc_type == 0x4f; /* R_IA64_PCREL64LSB */
8273 return reloc_type == 72; /* R_PARISC_PCREL64 */
8275 return reloc_type == 44; /* R_PPC64_REL64 */
8276 case EM_SPARC32PLUS:
8279 return reloc_type == 46; /* R_SPARC_DISP64 */
8282 return reloc_type == 24; /* R_X86_64_PC64 */
8285 return reloc_type == 23; /* R_S390_PC64 */
8291 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8292 a 24-bit absolute RELA relocation used in DWARF debug sections. */
8295 is_24bit_abs_reloc (unsigned int reloc_type)
8297 switch (elf_header.e_machine)
8299 case EM_CYGNUS_MN10200:
8301 return reloc_type == 4; /* R_MN10200_24. */
8307 /* Like is_32bit_abs_reloc except that it returns TRUE iff RELOC_TYPE is
8308 a 16-bit absolute RELA relocation used in DWARF debug sections. */
8311 is_16bit_abs_reloc (unsigned int reloc_type)
8313 switch (elf_header.e_machine)
8317 return reloc_type == 4; /* R_AVR_16. */
8318 case EM_CYGNUS_D10V:
8320 return reloc_type == 3; /* R_D10V_16. */
8324 return reloc_type == R_H8_DIR16;
8327 return reloc_type == 1; /* R_IP2K_16. */
8330 return reloc_type == 1; /* R_M32C_16 */
8333 return reloc_type == 5; /* R_MSP430_16_BYTE. */
8334 case EM_ALTERA_NIOS2:
8336 return reloc_type == 9; /* R_NIOS_16. */
8339 return reloc_type == 2; /* R_XC16C_ABS_16. */
8345 /* Returns TRUE iff RELOC_TYPE is a NONE relocation used for discarded
8346 relocation entries (possibly formerly used for SHT_GROUP sections). */
8349 is_none_reloc (unsigned int reloc_type)
8351 switch (elf_header.e_machine)
8353 case EM_68K: /* R_68K_NONE. */
8354 case EM_386: /* R_386_NONE. */
8355 case EM_SPARC32PLUS:
8357 case EM_SPARC: /* R_SPARC_NONE. */
8358 case EM_MIPS: /* R_MIPS_NONE. */
8359 case EM_PARISC: /* R_PARISC_NONE. */
8360 case EM_ALPHA: /* R_ALPHA_NONE. */
8361 case EM_PPC: /* R_PPC_NONE. */
8362 case EM_PPC64: /* R_PPC64_NONE. */
8363 case EM_ARM: /* R_ARM_NONE. */
8364 case EM_IA_64: /* R_IA64_NONE. */
8365 case EM_SH: /* R_SH_NONE. */
8367 case EM_S390: /* R_390_NONE. */
8368 case EM_CRIS: /* R_CRIS_NONE. */
8369 case EM_X86_64: /* R_X86_64_NONE. */
8370 case EM_L1OM: /* R_X86_64_NONE. */
8371 case EM_MN10300: /* R_MN10300_NONE. */
8372 case EM_M32R: /* R_M32R_NONE. */
8374 case EM_C166: /* R_XC16X_NONE. */
8375 return reloc_type == 0;
8378 return (reloc_type == 0 /* R_XTENSA_NONE. */
8379 || reloc_type == 17 /* R_XTENSA_DIFF8. */
8380 || reloc_type == 18 /* R_XTENSA_DIFF16. */
8381 || reloc_type == 19 /* R_XTENSA_DIFF32. */);
8386 /* Apply relocations to a section.
8387 Note: So far support has been added only for those relocations
8388 which can be found in debug sections.
8389 FIXME: Add support for more relocations ? */
8392 apply_relocations (void * file,
8393 Elf_Internal_Shdr * section,
8394 unsigned char * start)
8396 Elf_Internal_Shdr * relsec;
8397 unsigned char * end = start + section->sh_size;
8399 if (elf_header.e_type != ET_REL)
8402 /* Find the reloc section associated with the section. */
8403 for (relsec = section_headers;
8404 relsec < section_headers + elf_header.e_shnum;
8407 bfd_boolean is_rela;
8408 unsigned long num_relocs;
8409 Elf_Internal_Rela * relocs;
8410 Elf_Internal_Rela * rp;
8411 Elf_Internal_Shdr * symsec;
8412 Elf_Internal_Sym * symtab;
8413 Elf_Internal_Sym * sym;
8415 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
8416 || relsec->sh_info >= elf_header.e_shnum
8417 || section_headers + relsec->sh_info != section
8418 || relsec->sh_size == 0
8419 || relsec->sh_link >= elf_header.e_shnum)
8422 is_rela = relsec->sh_type == SHT_RELA;
8426 if (!slurp_rela_relocs ((FILE *) file, relsec->sh_offset,
8427 relsec->sh_size, & relocs, & num_relocs))
8432 if (!slurp_rel_relocs ((FILE *) file, relsec->sh_offset,
8433 relsec->sh_size, & relocs, & num_relocs))
8437 /* SH uses RELA but uses in place value instead of the addend field. */
8438 if (elf_header.e_machine == EM_SH)
8441 symsec = section_headers + relsec->sh_link;
8442 symtab = GET_ELF_SYMBOLS ((FILE *) file, symsec);
8444 for (rp = relocs; rp < relocs + num_relocs; ++rp)
8447 unsigned int reloc_type;
8448 unsigned int reloc_size;
8449 unsigned char * rloc;
8451 reloc_type = get_reloc_type (rp->r_info);
8453 if (target_specific_reloc_handling (rp, start, symtab))
8455 else if (is_none_reloc (reloc_type))
8457 else if (is_32bit_abs_reloc (reloc_type)
8458 || is_32bit_pcrel_reloc (reloc_type))
8460 else if (is_64bit_abs_reloc (reloc_type)
8461 || is_64bit_pcrel_reloc (reloc_type))
8463 else if (is_24bit_abs_reloc (reloc_type))
8465 else if (is_16bit_abs_reloc (reloc_type))
8469 warn (_("unable to apply unsupported reloc type %d to section %s\n"),
8470 reloc_type, SECTION_NAME (section));
8474 rloc = start + rp->r_offset;
8475 if ((rloc + reloc_size) > end)
8477 warn (_("skipping invalid relocation offset 0x%lx in section %s\n"),
8478 (unsigned long) rp->r_offset,
8479 SECTION_NAME (section));
8483 sym = symtab + get_reloc_symindex (rp->r_info);
8485 /* If the reloc has a symbol associated with it,
8486 make sure that it is of an appropriate type.
8488 Relocations against symbols without type can happen.
8489 Gcc -feliminate-dwarf2-dups may generate symbols
8490 without type for debug info.
8492 Icc generates relocations against function symbols
8493 instead of local labels.
8495 Relocations against object symbols can happen, eg when
8496 referencing a global array. For an example of this see
8497 the _clz.o binary in libgcc.a. */
8499 && ELF_ST_TYPE (sym->st_info) > STT_SECTION)
8501 warn (_("skipping unexpected symbol type %s in %ld'th relocation in section %s\n"),
8502 get_symbol_type (ELF_ST_TYPE (sym->st_info)),
8503 (long int)(rp - relocs),
8504 SECTION_NAME (relsec));
8510 addend += rp->r_addend;
8511 /* R_XTENSA_32 and R_PJ_DATA_DIR32 are partial_inplace. */
8513 || (elf_header.e_machine == EM_XTENSA
8515 || ((elf_header.e_machine == EM_PJ
8516 || elf_header.e_machine == EM_PJ_OLD)
8517 && reloc_type == 1))
8518 addend += byte_get (rloc, reloc_size);
8520 if (is_32bit_pcrel_reloc (reloc_type)
8521 || is_64bit_pcrel_reloc (reloc_type))
8523 /* On HPPA, all pc-relative relocations are biased by 8. */
8524 if (elf_header.e_machine == EM_PARISC)
8526 byte_put (rloc, (addend + sym->st_value) - rp->r_offset,
8530 byte_put (rloc, addend + sym->st_value, reloc_size);
8539 #ifdef SUPPORT_DISASSEMBLY
8541 disassemble_section (Elf_Internal_Shdr * section, FILE * file)
8543 printf (_("\nAssembly dump of section %s\n"),
8544 SECTION_NAME (section));
8546 /* XXX -- to be done --- XXX */
8552 /* Reads in the contents of SECTION from FILE, returning a pointer
8553 to a malloc'ed buffer or NULL if something went wrong. */
8556 get_section_contents (Elf_Internal_Shdr * section, FILE * file)
8558 bfd_size_type num_bytes;
8560 num_bytes = section->sh_size;
8562 if (num_bytes == 0 || section->sh_type == SHT_NOBITS)
8564 printf (_("\nSection '%s' has no data to dump.\n"),
8565 SECTION_NAME (section));
8569 return (char *) get_data (NULL, file, section->sh_offset, 1, num_bytes,
8570 _("section contents"));
8575 dump_section_as_strings (Elf_Internal_Shdr * section, FILE * file)
8577 Elf_Internal_Shdr * relsec;
8578 bfd_size_type num_bytes;
8583 char * name = SECTION_NAME (section);
8584 bfd_boolean some_strings_shown;
8586 start = get_section_contents (section, file);
8590 printf (_("\nString dump of section '%s':\n"), name);
8592 /* If the section being dumped has relocations against it the user might
8593 be expecting these relocations to have been applied. Check for this
8594 case and issue a warning message in order to avoid confusion.
8595 FIXME: Maybe we ought to have an option that dumps a section with
8597 for (relsec = section_headers;
8598 relsec < section_headers + elf_header.e_shnum;
8601 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
8602 || relsec->sh_info >= elf_header.e_shnum
8603 || section_headers + relsec->sh_info != section
8604 || relsec->sh_size == 0
8605 || relsec->sh_link >= elf_header.e_shnum)
8608 printf (_(" Note: This section has relocations against it, but these have NOT been applied to this dump.\n"));
8612 num_bytes = section->sh_size;
8613 addr = section->sh_addr;
8615 end = start + num_bytes;
8616 some_strings_shown = FALSE;
8620 while (!ISPRINT (* data))
8627 printf (" [%6tx] %s\n", data - start, data);
8629 printf (" [%6Ix] %s\n", (size_t) (data - start), data);
8631 data += strlen (data);
8632 some_strings_shown = TRUE;
8636 if (! some_strings_shown)
8637 printf (_(" No strings found in this section."));
8645 dump_section_as_bytes (Elf_Internal_Shdr * section,
8647 bfd_boolean relocate)
8649 Elf_Internal_Shdr * relsec;
8650 bfd_size_type bytes;
8652 unsigned char * data;
8653 unsigned char * start;
8655 start = (unsigned char *) get_section_contents (section, file);
8659 printf (_("\nHex dump of section '%s':\n"), SECTION_NAME (section));
8663 apply_relocations (file, section, start);
8667 /* If the section being dumped has relocations against it the user might
8668 be expecting these relocations to have been applied. Check for this
8669 case and issue a warning message in order to avoid confusion.
8670 FIXME: Maybe we ought to have an option that dumps a section with
8672 for (relsec = section_headers;
8673 relsec < section_headers + elf_header.e_shnum;
8676 if ((relsec->sh_type != SHT_RELA && relsec->sh_type != SHT_REL)
8677 || relsec->sh_info >= elf_header.e_shnum
8678 || section_headers + relsec->sh_info != section
8679 || relsec->sh_size == 0
8680 || relsec->sh_link >= elf_header.e_shnum)
8683 printf (_(" NOTE: This section has relocations against it, but these have NOT been applied to this dump.\n"));
8688 addr = section->sh_addr;
8689 bytes = section->sh_size;
8698 lbytes = (bytes > 16 ? 16 : bytes);
8700 printf (" 0x%8.8lx ", (unsigned long) addr);
8702 for (j = 0; j < 16; j++)
8705 printf ("%2.2x", data[j]);
8713 for (j = 0; j < lbytes; j++)
8716 if (k >= ' ' && k < 0x7f)
8734 /* Uncompresses a section that was compressed using zlib, in place.
8735 This is a copy of bfd_uncompress_section_contents, in bfd/compress.c */
8738 uncompress_section_contents (unsigned char ** buffer, dwarf_size_type * size)
8741 /* These are just to quiet gcc. */
8746 dwarf_size_type compressed_size = *size;
8747 unsigned char * compressed_buffer = *buffer;
8748 dwarf_size_type uncompressed_size;
8749 unsigned char * uncompressed_buffer;
8752 dwarf_size_type header_size = 12;
8754 /* Read the zlib header. In this case, it should be "ZLIB" followed
8755 by the uncompressed section size, 8 bytes in big-endian order. */
8756 if (compressed_size < header_size
8757 || ! streq ((char *) compressed_buffer, "ZLIB"))
8760 uncompressed_size = compressed_buffer[4]; uncompressed_size <<= 8;
8761 uncompressed_size += compressed_buffer[5]; uncompressed_size <<= 8;
8762 uncompressed_size += compressed_buffer[6]; uncompressed_size <<= 8;
8763 uncompressed_size += compressed_buffer[7]; uncompressed_size <<= 8;
8764 uncompressed_size += compressed_buffer[8]; uncompressed_size <<= 8;
8765 uncompressed_size += compressed_buffer[9]; uncompressed_size <<= 8;
8766 uncompressed_size += compressed_buffer[10]; uncompressed_size <<= 8;
8767 uncompressed_size += compressed_buffer[11];
8769 /* It is possible the section consists of several compressed
8770 buffers concatenated together, so we uncompress in a loop. */
8774 strm.avail_in = compressed_size - header_size;
8775 strm.next_in = (Bytef *) compressed_buffer + header_size;
8776 strm.avail_out = uncompressed_size;
8777 uncompressed_buffer = (unsigned char *) xmalloc (uncompressed_size);
8779 rc = inflateInit (& strm);
8780 while (strm.avail_in > 0)
8784 strm.next_out = ((Bytef *) uncompressed_buffer
8785 + (uncompressed_size - strm.avail_out));
8786 rc = inflate (&strm, Z_FINISH);
8787 if (rc != Z_STREAM_END)
8789 rc = inflateReset (& strm);
8791 rc = inflateEnd (& strm);
8793 || strm.avail_out != 0)
8796 free (compressed_buffer);
8797 *buffer = uncompressed_buffer;
8798 *size = uncompressed_size;
8802 free (uncompressed_buffer);
8804 #endif /* HAVE_ZLIB_H */
8808 load_specific_debug_section (enum dwarf_section_display_enum debug,
8809 Elf_Internal_Shdr * sec, void * file)
8811 struct dwarf_section * section = &debug_displays [debug].section;
8813 int section_is_compressed;
8815 /* If it is already loaded, do nothing. */
8816 if (section->start != NULL)
8819 section_is_compressed = section->name == section->compressed_name;
8821 snprintf (buf, sizeof (buf), _("%s section data"), section->name);
8822 section->address = sec->sh_addr;
8823 section->size = sec->sh_size;
8824 section->start = (unsigned char *) get_data (NULL, (FILE *) file,
8827 if (section->start == NULL)
8830 if (section_is_compressed)
8831 if (! uncompress_section_contents (§ion->start, §ion->size))
8834 if (debug_displays [debug].relocate)
8835 apply_relocations ((FILE *) file, sec, section->start);
8841 load_debug_section (enum dwarf_section_display_enum debug, void * file)
8843 struct dwarf_section * section = &debug_displays [debug].section;
8844 Elf_Internal_Shdr * sec;
8846 /* Locate the debug section. */
8847 sec = find_section (section->uncompressed_name);
8849 section->name = section->uncompressed_name;
8852 sec = find_section (section->compressed_name);
8854 section->name = section->compressed_name;
8859 return load_specific_debug_section (debug, sec, (FILE *) file);
8863 free_debug_section (enum dwarf_section_display_enum debug)
8865 struct dwarf_section * section = &debug_displays [debug].section;
8867 if (section->start == NULL)
8870 free ((char *) section->start);
8871 section->start = NULL;
8872 section->address = 0;
8877 display_debug_section (Elf_Internal_Shdr * section, FILE * file)
8879 char * name = SECTION_NAME (section);
8880 bfd_size_type length;
8884 length = section->sh_size;
8887 printf (_("\nSection '%s' has no debugging data.\n"), name);
8890 if (section->sh_type == SHT_NOBITS)
8892 /* There is no point in dumping the contents of a debugging section
8893 which has the NOBITS type - the bits in the file will be random.
8894 This can happen when a file containing a .eh_frame section is
8895 stripped with the --only-keep-debug command line option. */
8896 printf (_("section '%s' has the NOBITS type - its contents are unreliable.\n"), name);
8900 if (const_strneq (name, ".gnu.linkonce.wi."))
8901 name = ".debug_info";
8903 /* See if we know how to display the contents of this section. */
8904 for (i = 0; i < max; i++)
8905 if (streq (debug_displays[i].section.uncompressed_name, name)
8906 || streq (debug_displays[i].section.compressed_name, name))
8908 struct dwarf_section * sec = &debug_displays [i].section;
8909 int secondary = (section != find_section (name));
8912 free_debug_section ((enum dwarf_section_display_enum) i);
8914 if (streq (sec->uncompressed_name, name))
8915 sec->name = sec->uncompressed_name;
8917 sec->name = sec->compressed_name;
8918 if (load_specific_debug_section ((enum dwarf_section_display_enum) i,
8921 result &= debug_displays[i].display (sec, file);
8923 if (secondary || (i != info && i != abbrev))
8924 free_debug_section ((enum dwarf_section_display_enum) i);
8932 printf (_("Unrecognized debug section: %s\n"), name);
8939 /* Set DUMP_SECTS for all sections where dumps were requested
8940 based on section name. */
8943 initialise_dumps_byname (void)
8945 struct dump_list_entry * cur;
8947 for (cur = dump_sects_byname; cur; cur = cur->next)
8952 for (i = 0, any = 0; i < elf_header.e_shnum; i++)
8953 if (streq (SECTION_NAME (section_headers + i), cur->name))
8955 request_dump_bynumber (i, cur->type);
8960 warn (_("Section '%s' was not dumped because it does not exist!\n"),
8966 process_section_contents (FILE * file)
8968 Elf_Internal_Shdr * section;
8974 initialise_dumps_byname ();
8976 for (i = 0, section = section_headers;
8977 i < elf_header.e_shnum && i < num_dump_sects;
8980 #ifdef SUPPORT_DISASSEMBLY
8981 if (dump_sects[i] & DISASS_DUMP)
8982 disassemble_section (section, file);
8984 if (dump_sects[i] & HEX_DUMP)
8985 dump_section_as_bytes (section, file, FALSE);
8987 if (dump_sects[i] & RELOC_DUMP)
8988 dump_section_as_bytes (section, file, TRUE);
8990 if (dump_sects[i] & STRING_DUMP)
8991 dump_section_as_strings (section, file);
8993 if (dump_sects[i] & DEBUG_DUMP)
8994 display_debug_section (section, file);
8997 /* Check to see if the user requested a
8998 dump of a section that does not exist. */
8999 while (i++ < num_dump_sects)
9001 warn (_("Section %d was not dumped because it does not exist!\n"), i);
9005 process_mips_fpe_exception (int mask)
9010 if (mask & OEX_FPU_INEX)
9011 fputs ("INEX", stdout), first = 0;
9012 if (mask & OEX_FPU_UFLO)
9013 printf ("%sUFLO", first ? "" : "|"), first = 0;
9014 if (mask & OEX_FPU_OFLO)
9015 printf ("%sOFLO", first ? "" : "|"), first = 0;
9016 if (mask & OEX_FPU_DIV0)
9017 printf ("%sDIV0", first ? "" : "|"), first = 0;
9018 if (mask & OEX_FPU_INVAL)
9019 printf ("%sINVAL", first ? "" : "|");
9022 fputs ("0", stdout);
9025 /* ARM EABI attributes section. */
9030 /* 0 = special, 1 = string, 2 = uleb123, > 0x80 == table lookup. */
9032 const char ** table;
9033 } arm_attr_public_tag;
9035 static const char * arm_attr_tag_CPU_arch[] =
9036 {"Pre-v4", "v4", "v4T", "v5T", "v5TE", "v5TEJ", "v6", "v6KZ", "v6T2",
9037 "v6K", "v7", "v6-M", "v6S-M", "v7E-M"};
9038 static const char * arm_attr_tag_ARM_ISA_use[] = {"No", "Yes"};
9039 static const char * arm_attr_tag_THUMB_ISA_use[] =
9040 {"No", "Thumb-1", "Thumb-2"};
9041 static const char * arm_attr_tag_VFP_arch[] =
9042 {"No", "VFPv1", "VFPv2", "VFPv3", "VFPv3-D16", "VFPv4", "VFPv4-D16"};
9043 static const char * arm_attr_tag_WMMX_arch[] = {"No", "WMMXv1", "WMMXv2"};
9044 static const char * arm_attr_tag_Advanced_SIMD_arch[] = {"No", "NEONv1"};
9045 static const char * arm_attr_tag_PCS_config[] =
9046 {"None", "Bare platform", "Linux application", "Linux DSO", "PalmOS 2004",
9047 "PalmOS (reserved)", "SymbianOS 2004", "SymbianOS (reserved)"};
9048 static const char * arm_attr_tag_ABI_PCS_R9_use[] =
9049 {"V6", "SB", "TLS", "Unused"};
9050 static const char * arm_attr_tag_ABI_PCS_RW_data[] =
9051 {"Absolute", "PC-relative", "SB-relative", "None"};
9052 static const char * arm_attr_tag_ABI_PCS_RO_data[] =
9053 {"Absolute", "PC-relative", "None"};
9054 static const char * arm_attr_tag_ABI_PCS_GOT_use[] =
9055 {"None", "direct", "GOT-indirect"};
9056 static const char * arm_attr_tag_ABI_PCS_wchar_t[] =
9057 {"None", "??? 1", "2", "??? 3", "4"};
9058 static const char * arm_attr_tag_ABI_FP_rounding[] = {"Unused", "Needed"};
9059 static const char * arm_attr_tag_ABI_FP_denormal[] =
9060 {"Unused", "Needed", "Sign only"};
9061 static const char * arm_attr_tag_ABI_FP_exceptions[] = {"Unused", "Needed"};
9062 static const char * arm_attr_tag_ABI_FP_user_exceptions[] = {"Unused", "Needed"};
9063 static const char * arm_attr_tag_ABI_FP_number_model[] =
9064 {"Unused", "Finite", "RTABI", "IEEE 754"};
9065 static const char * arm_attr_tag_ABI_align8_needed[] = {"No", "Yes", "4-byte"};
9066 static const char * arm_attr_tag_ABI_align8_preserved[] =
9067 {"No", "Yes, except leaf SP", "Yes"};
9068 static const char * arm_attr_tag_ABI_enum_size[] =
9069 {"Unused", "small", "int", "forced to int"};
9070 static const char * arm_attr_tag_ABI_HardFP_use[] =
9071 {"As Tag_VFP_arch", "SP only", "DP only", "SP and DP"};
9072 static const char * arm_attr_tag_ABI_VFP_args[] =
9073 {"AAPCS", "VFP registers", "custom"};
9074 static const char * arm_attr_tag_ABI_WMMX_args[] =
9075 {"AAPCS", "WMMX registers", "custom"};
9076 static const char * arm_attr_tag_ABI_optimization_goals[] =
9077 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
9078 "Aggressive Size", "Prefer Debug", "Aggressive Debug"};
9079 static const char * arm_attr_tag_ABI_FP_optimization_goals[] =
9080 {"None", "Prefer Speed", "Aggressive Speed", "Prefer Size",
9081 "Aggressive Size", "Prefer Accuracy", "Aggressive Accuracy"};
9082 static const char * arm_attr_tag_CPU_unaligned_access[] = {"None", "v6"};
9083 static const char * arm_attr_tag_VFP_HP_extension[] =
9084 {"Not Allowed", "Allowed"};
9085 static const char * arm_attr_tag_ABI_FP_16bit_format[] =
9086 {"None", "IEEE 754", "Alternative Format"};
9087 static const char * arm_attr_tag_T2EE_use[] = {"Not Allowed", "Allowed"};
9088 static const char * arm_attr_tag_Virtualization_use[] =
9089 {"Not Allowed", "Allowed"};
9090 static const char * arm_attr_tag_MPextension_use[] = {"Not Allowed", "Allowed"};
9092 #define LOOKUP(id, name) \
9093 {id, #name, 0x80 | ARRAY_SIZE(arm_attr_tag_##name), arm_attr_tag_##name}
9094 static arm_attr_public_tag arm_attr_public_tags[] =
9096 {4, "CPU_raw_name", 1, NULL},
9097 {5, "CPU_name", 1, NULL},
9098 LOOKUP(6, CPU_arch),
9099 {7, "CPU_arch_profile", 0, NULL},
9100 LOOKUP(8, ARM_ISA_use),
9101 LOOKUP(9, THUMB_ISA_use),
9102 LOOKUP(10, VFP_arch),
9103 LOOKUP(11, WMMX_arch),
9104 LOOKUP(12, Advanced_SIMD_arch),
9105 LOOKUP(13, PCS_config),
9106 LOOKUP(14, ABI_PCS_R9_use),
9107 LOOKUP(15, ABI_PCS_RW_data),
9108 LOOKUP(16, ABI_PCS_RO_data),
9109 LOOKUP(17, ABI_PCS_GOT_use),
9110 LOOKUP(18, ABI_PCS_wchar_t),
9111 LOOKUP(19, ABI_FP_rounding),
9112 LOOKUP(20, ABI_FP_denormal),
9113 LOOKUP(21, ABI_FP_exceptions),
9114 LOOKUP(22, ABI_FP_user_exceptions),
9115 LOOKUP(23, ABI_FP_number_model),
9116 LOOKUP(24, ABI_align8_needed),
9117 LOOKUP(25, ABI_align8_preserved),
9118 LOOKUP(26, ABI_enum_size),
9119 LOOKUP(27, ABI_HardFP_use),
9120 LOOKUP(28, ABI_VFP_args),
9121 LOOKUP(29, ABI_WMMX_args),
9122 LOOKUP(30, ABI_optimization_goals),
9123 LOOKUP(31, ABI_FP_optimization_goals),
9124 {32, "compatibility", 0, NULL},
9125 LOOKUP(34, CPU_unaligned_access),
9126 LOOKUP(36, VFP_HP_extension),
9127 LOOKUP(38, ABI_FP_16bit_format),
9128 {64, "nodefaults", 0, NULL},
9129 {65, "also_compatible_with", 0, NULL},
9130 LOOKUP(66, T2EE_use),
9131 {67, "conformance", 1, NULL},
9132 LOOKUP(68, Virtualization_use),
9133 LOOKUP(70, MPextension_use)
9137 /* Read an unsigned LEB128 encoded value from p. Set *PLEN to the number of
9141 read_uleb128 (unsigned char * p, unsigned int * plen)
9155 val |= ((unsigned int)c & 0x7f) << shift;
9164 static unsigned char *
9165 display_arm_attribute (unsigned char * p)
9170 arm_attr_public_tag * attr;
9174 tag = read_uleb128 (p, &len);
9177 for (i = 0; i < ARRAY_SIZE (arm_attr_public_tags); i++)
9179 if (arm_attr_public_tags[i].tag == tag)
9181 attr = &arm_attr_public_tags[i];
9188 printf (" Tag_%s: ", attr->name);
9194 case 7: /* Tag_CPU_arch_profile. */
9195 val = read_uleb128 (p, &len);
9199 case 0: printf ("None\n"); break;
9200 case 'A': printf ("Application\n"); break;
9201 case 'R': printf ("Realtime\n"); break;
9202 case 'M': printf ("Microcontroller\n"); break;
9203 default: printf ("??? (%d)\n", val); break;
9207 case 32: /* Tag_compatibility. */
9208 val = read_uleb128 (p, &len);
9210 printf ("flag = %d, vendor = %s\n", val, p);
9211 p += strlen ((char *) p) + 1;
9214 case 64: /* Tag_nodefaults. */
9219 case 65: /* Tag_also_compatible_with. */
9220 val = read_uleb128 (p, &len);
9222 if (val == 6 /* Tag_CPU_arch. */)
9224 val = read_uleb128 (p, &len);
9226 if ((unsigned int)val >= ARRAY_SIZE (arm_attr_tag_CPU_arch))
9227 printf ("??? (%d)\n", val);
9229 printf ("%s\n", arm_attr_tag_CPU_arch[val]);
9233 while (*(p++) != '\0' /* NUL terminator. */);
9247 assert (attr->type & 0x80);
9248 val = read_uleb128 (p, &len);
9250 type = attr->type & 0x7f;
9252 printf ("??? (%d)\n", val);
9254 printf ("%s\n", attr->table[val]);
9261 type = 1; /* String. */
9263 type = 2; /* uleb128. */
9264 printf (" Tag_unknown_%d: ", tag);
9269 printf ("\"%s\"\n", p);
9270 p += strlen ((char *) p) + 1;
9274 val = read_uleb128 (p, &len);
9276 printf ("%d (0x%x)\n", val, val);
9282 static unsigned char *
9283 display_gnu_attribute (unsigned char * p,
9284 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int))
9291 tag = read_uleb128 (p, &len);
9294 /* Tag_compatibility is the only generic GNU attribute defined at
9298 val = read_uleb128 (p, &len);
9300 printf ("flag = %d, vendor = %s\n", val, p);
9301 p += strlen ((char *) p) + 1;
9305 if ((tag & 2) == 0 && display_proc_gnu_attribute)
9306 return display_proc_gnu_attribute (p, tag);
9309 type = 1; /* String. */
9311 type = 2; /* uleb128. */
9312 printf (" Tag_unknown_%d: ", tag);
9316 printf ("\"%s\"\n", p);
9317 p += strlen ((char *) p) + 1;
9321 val = read_uleb128 (p, &len);
9323 printf ("%d (0x%x)\n", val, val);
9329 static unsigned char *
9330 display_power_gnu_attribute (unsigned char * p, int tag)
9336 if (tag == Tag_GNU_Power_ABI_FP)
9338 val = read_uleb128 (p, &len);
9340 printf (" Tag_GNU_Power_ABI_FP: ");
9345 printf ("Hard or soft float\n");
9348 printf ("Hard float\n");
9351 printf ("Soft float\n");
9354 printf ("Single-precision hard float\n");
9357 printf ("??? (%d)\n", val);
9363 if (tag == Tag_GNU_Power_ABI_Vector)
9365 val = read_uleb128 (p, &len);
9367 printf (" Tag_GNU_Power_ABI_Vector: ");
9374 printf ("Generic\n");
9377 printf ("AltiVec\n");
9383 printf ("??? (%d)\n", val);
9389 if (tag == Tag_GNU_Power_ABI_Struct_Return)
9391 val = read_uleb128 (p, &len);
9393 printf (" Tag_GNU_Power_ABI_Struct_Return: ");
9403 printf ("Memory\n");
9406 printf ("??? (%d)\n", val);
9413 type = 1; /* String. */
9415 type = 2; /* uleb128. */
9416 printf (" Tag_unknown_%d: ", tag);
9420 printf ("\"%s\"\n", p);
9421 p += strlen ((char *) p) + 1;
9425 val = read_uleb128 (p, &len);
9427 printf ("%d (0x%x)\n", val, val);
9433 static unsigned char *
9434 display_mips_gnu_attribute (unsigned char * p, int tag)
9440 if (tag == Tag_GNU_MIPS_ABI_FP)
9442 val = read_uleb128 (p, &len);
9444 printf (" Tag_GNU_MIPS_ABI_FP: ");
9449 printf ("Hard or soft float\n");
9452 printf ("Hard float (-mdouble-float)\n");
9455 printf ("Hard float (-msingle-float)\n");
9458 printf ("Soft float\n");
9461 printf ("64-bit float (-mips32r2 -mfp64)\n");
9464 printf ("??? (%d)\n", val);
9471 type = 1; /* String. */
9473 type = 2; /* uleb128. */
9474 printf (" Tag_unknown_%d: ", tag);
9478 printf ("\"%s\"\n", p);
9479 p += strlen ((char *) p) + 1;
9483 val = read_uleb128 (p, &len);
9485 printf ("%d (0x%x)\n", val, val);
9492 process_attributes (FILE * file,
9493 const char * public_name,
9494 unsigned int proc_type,
9495 unsigned char * (* display_pub_attribute) (unsigned char *),
9496 unsigned char * (* display_proc_gnu_attribute) (unsigned char *, int))
9498 Elf_Internal_Shdr * sect;
9499 unsigned char * contents;
9501 unsigned char * end;
9502 bfd_vma section_len;
9506 /* Find the section header so that we get the size. */
9507 for (i = 0, sect = section_headers;
9508 i < elf_header.e_shnum;
9511 if (sect->sh_type != proc_type && sect->sh_type != SHT_GNU_ATTRIBUTES)
9514 contents = (unsigned char *) get_data (NULL, file, sect->sh_offset, 1,
9515 sect->sh_size, _("attributes"));
9516 if (contents == NULL)
9522 len = sect->sh_size - 1;
9528 bfd_boolean public_section;
9529 bfd_boolean gnu_section;
9531 section_len = byte_get (p, 4);
9534 if (section_len > len)
9536 printf (_("ERROR: Bad section length (%d > %d)\n"),
9537 (int) section_len, (int) len);
9542 printf ("Attribute Section: %s\n", p);
9544 if (public_name && streq ((char *) p, public_name))
9545 public_section = TRUE;
9547 public_section = FALSE;
9549 if (streq ((char *) p, "gnu"))
9552 gnu_section = FALSE;
9554 namelen = strlen ((char *) p) + 1;
9556 section_len -= namelen + 4;
9558 while (section_len > 0)
9564 size = byte_get (p, 4);
9565 if (size > section_len)
9567 printf (_("ERROR: Bad subsection length (%d > %d)\n"),
9568 (int) size, (int) section_len);
9572 section_len -= size;
9579 printf ("File Attributes\n");
9582 printf ("Section Attributes:");
9585 printf ("Symbol Attributes:");
9591 val = read_uleb128 (p, &j);
9595 printf (" %d", val);
9600 printf ("Unknown tag: %d\n", tag);
9601 public_section = FALSE;
9608 p = display_pub_attribute (p);
9610 else if (gnu_section)
9613 p = display_gnu_attribute (p,
9614 display_proc_gnu_attribute);
9618 /* ??? Do something sensible, like dump hex. */
9619 printf (" Unknown section contexts\n");
9626 printf (_("Unknown format '%c'\n"), *p);
9634 process_arm_specific (FILE * file)
9636 return process_attributes (file, "aeabi", SHT_ARM_ATTRIBUTES,
9637 display_arm_attribute, NULL);
9641 process_power_specific (FILE * file)
9643 return process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
9644 display_power_gnu_attribute);
9647 /* DATA points to the contents of a MIPS GOT that starts at VMA PLTGOT.
9648 Print the Address, Access and Initial fields of an entry at VMA ADDR
9649 and return the VMA of the next entry. */
9652 print_mips_got_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
9655 print_vma (addr, LONG_HEX);
9657 if (addr < pltgot + 0xfff0)
9658 printf ("%6d(gp)", (int) (addr - pltgot - 0x7ff0));
9660 printf ("%10s", "");
9663 printf ("%*s", is_32bit_elf ? 8 : 16, "<unknown>");
9668 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
9669 print_vma (entry, LONG_HEX);
9671 return addr + (is_32bit_elf ? 4 : 8);
9674 /* DATA points to the contents of a MIPS PLT GOT that starts at VMA
9675 PLTGOT. Print the Address and Initial fields of an entry at VMA
9676 ADDR and return the VMA of the next entry. */
9679 print_mips_pltgot_entry (unsigned char * data, bfd_vma pltgot, bfd_vma addr)
9682 print_vma (addr, LONG_HEX);
9685 printf ("%*s", is_32bit_elf ? 8 : 16, "<unknown>");
9690 entry = byte_get (data + addr - pltgot, is_32bit_elf ? 4 : 8);
9691 print_vma (entry, LONG_HEX);
9693 return addr + (is_32bit_elf ? 4 : 8);
9697 process_mips_specific (FILE * file)
9699 Elf_Internal_Dyn * entry;
9700 size_t liblist_offset = 0;
9701 size_t liblistno = 0;
9702 size_t conflictsno = 0;
9703 size_t options_offset = 0;
9704 size_t conflicts_offset = 0;
9705 size_t pltrelsz = 0;
9708 bfd_vma mips_pltgot = 0;
9710 bfd_vma local_gotno = 0;
9712 bfd_vma symtabno = 0;
9714 process_attributes (file, NULL, SHT_GNU_ATTRIBUTES, NULL,
9715 display_mips_gnu_attribute);
9717 /* We have a lot of special sections. Thanks SGI! */
9718 if (dynamic_section == NULL)
9719 /* No information available. */
9722 for (entry = dynamic_section; entry->d_tag != DT_NULL; ++entry)
9723 switch (entry->d_tag)
9725 case DT_MIPS_LIBLIST:
9727 = offset_from_vma (file, entry->d_un.d_val,
9728 liblistno * sizeof (Elf32_External_Lib));
9730 case DT_MIPS_LIBLISTNO:
9731 liblistno = entry->d_un.d_val;
9733 case DT_MIPS_OPTIONS:
9734 options_offset = offset_from_vma (file, entry->d_un.d_val, 0);
9736 case DT_MIPS_CONFLICT:
9738 = offset_from_vma (file, entry->d_un.d_val,
9739 conflictsno * sizeof (Elf32_External_Conflict));
9741 case DT_MIPS_CONFLICTNO:
9742 conflictsno = entry->d_un.d_val;
9745 pltgot = entry->d_un.d_ptr;
9747 case DT_MIPS_LOCAL_GOTNO:
9748 local_gotno = entry->d_un.d_val;
9750 case DT_MIPS_GOTSYM:
9751 gotsym = entry->d_un.d_val;
9753 case DT_MIPS_SYMTABNO:
9754 symtabno = entry->d_un.d_val;
9756 case DT_MIPS_PLTGOT:
9757 mips_pltgot = entry->d_un.d_ptr;
9760 pltrel = entry->d_un.d_val;
9763 pltrelsz = entry->d_un.d_val;
9766 jmprel = entry->d_un.d_ptr;
9772 if (liblist_offset != 0 && liblistno != 0 && do_dynamic)
9774 Elf32_External_Lib * elib;
9777 elib = (Elf32_External_Lib *) get_data (NULL, file, liblist_offset,
9779 sizeof (Elf32_External_Lib),
9783 printf ("\nSection '.liblist' contains %lu entries:\n",
9784 (unsigned long) liblistno);
9785 fputs (" Library Time Stamp Checksum Version Flags\n",
9788 for (cnt = 0; cnt < liblistno; ++cnt)
9795 liblist.l_name = BYTE_GET (elib[cnt].l_name);
9796 atime = BYTE_GET (elib[cnt].l_time_stamp);
9797 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
9798 liblist.l_version = BYTE_GET (elib[cnt].l_version);
9799 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
9801 tmp = gmtime (&atime);
9802 snprintf (timebuf, sizeof (timebuf),
9803 "%04u-%02u-%02uT%02u:%02u:%02u",
9804 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
9805 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
9807 printf ("%3lu: ", (unsigned long) cnt);
9808 if (VALID_DYNAMIC_NAME (liblist.l_name))
9809 print_symbol (20, GET_DYNAMIC_NAME (liblist.l_name));
9811 printf ("<corrupt: %9ld>", liblist.l_name);
9812 printf (" %s %#10lx %-7ld", timebuf, liblist.l_checksum,
9815 if (liblist.l_flags == 0)
9826 { " EXACT_MATCH", LL_EXACT_MATCH },
9827 { " IGNORE_INT_VER", LL_IGNORE_INT_VER },
9828 { " REQUIRE_MINOR", LL_REQUIRE_MINOR },
9829 { " EXPORTS", LL_EXPORTS },
9830 { " DELAY_LOAD", LL_DELAY_LOAD },
9831 { " DELTA", LL_DELTA }
9833 int flags = liblist.l_flags;
9836 for (fcnt = 0; fcnt < ARRAY_SIZE (l_flags_vals); ++fcnt)
9837 if ((flags & l_flags_vals[fcnt].bit) != 0)
9839 fputs (l_flags_vals[fcnt].name, stdout);
9840 flags ^= l_flags_vals[fcnt].bit;
9843 printf (" %#x", (unsigned int) flags);
9853 if (options_offset != 0)
9855 Elf_External_Options * eopt;
9856 Elf_Internal_Shdr * sect = section_headers;
9857 Elf_Internal_Options * iopt;
9858 Elf_Internal_Options * option;
9862 /* Find the section header so that we get the size. */
9863 while (sect->sh_type != SHT_MIPS_OPTIONS)
9866 eopt = (Elf_External_Options *) get_data (NULL, file, options_offset, 1,
9867 sect->sh_size, _("options"));
9870 iopt = (Elf_Internal_Options *)
9871 cmalloc ((sect->sh_size / sizeof (eopt)), sizeof (* iopt));
9874 error (_("Out of memory\n"));
9881 while (offset < sect->sh_size)
9883 Elf_External_Options * eoption;
9885 eoption = (Elf_External_Options *) ((char *) eopt + offset);
9887 option->kind = BYTE_GET (eoption->kind);
9888 option->size = BYTE_GET (eoption->size);
9889 option->section = BYTE_GET (eoption->section);
9890 option->info = BYTE_GET (eoption->info);
9892 offset += option->size;
9898 printf (_("\nSection '%s' contains %d entries:\n"),
9899 SECTION_NAME (sect), cnt);
9907 switch (option->kind)
9910 /* This shouldn't happen. */
9911 printf (" NULL %d %lx", option->section, option->info);
9914 printf (" REGINFO ");
9915 if (elf_header.e_machine == EM_MIPS)
9918 Elf32_External_RegInfo * ereg;
9919 Elf32_RegInfo reginfo;
9921 ereg = (Elf32_External_RegInfo *) (option + 1);
9922 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
9923 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
9924 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
9925 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
9926 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
9927 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
9929 printf ("GPR %08lx GP 0x%lx\n",
9931 (unsigned long) reginfo.ri_gp_value);
9932 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9933 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
9934 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
9939 Elf64_External_RegInfo * ereg;
9940 Elf64_Internal_RegInfo reginfo;
9942 ereg = (Elf64_External_RegInfo *) (option + 1);
9943 reginfo.ri_gprmask = BYTE_GET (ereg->ri_gprmask);
9944 reginfo.ri_cprmask[0] = BYTE_GET (ereg->ri_cprmask[0]);
9945 reginfo.ri_cprmask[1] = BYTE_GET (ereg->ri_cprmask[1]);
9946 reginfo.ri_cprmask[2] = BYTE_GET (ereg->ri_cprmask[2]);
9947 reginfo.ri_cprmask[3] = BYTE_GET (ereg->ri_cprmask[3]);
9948 reginfo.ri_gp_value = BYTE_GET (ereg->ri_gp_value);
9950 printf ("GPR %08lx GP 0x",
9951 reginfo.ri_gprmask);
9952 printf_vma (reginfo.ri_gp_value);
9955 printf (" CPR0 %08lx CPR1 %08lx CPR2 %08lx CPR3 %08lx\n",
9956 reginfo.ri_cprmask[0], reginfo.ri_cprmask[1],
9957 reginfo.ri_cprmask[2], reginfo.ri_cprmask[3]);
9961 case ODK_EXCEPTIONS:
9962 fputs (" EXCEPTIONS fpe_min(", stdout);
9963 process_mips_fpe_exception (option->info & OEX_FPU_MIN);
9964 fputs (") fpe_max(", stdout);
9965 process_mips_fpe_exception ((option->info & OEX_FPU_MAX) >> 8);
9966 fputs (")", stdout);
9968 if (option->info & OEX_PAGE0)
9969 fputs (" PAGE0", stdout);
9970 if (option->info & OEX_SMM)
9971 fputs (" SMM", stdout);
9972 if (option->info & OEX_FPDBUG)
9973 fputs (" FPDBUG", stdout);
9974 if (option->info & OEX_DISMISS)
9975 fputs (" DISMISS", stdout);
9978 fputs (" PAD ", stdout);
9979 if (option->info & OPAD_PREFIX)
9980 fputs (" PREFIX", stdout);
9981 if (option->info & OPAD_POSTFIX)
9982 fputs (" POSTFIX", stdout);
9983 if (option->info & OPAD_SYMBOL)
9984 fputs (" SYMBOL", stdout);
9987 fputs (" HWPATCH ", stdout);
9988 if (option->info & OHW_R4KEOP)
9989 fputs (" R4KEOP", stdout);
9990 if (option->info & OHW_R8KPFETCH)
9991 fputs (" R8KPFETCH", stdout);
9992 if (option->info & OHW_R5KEOP)
9993 fputs (" R5KEOP", stdout);
9994 if (option->info & OHW_R5KCVTL)
9995 fputs (" R5KCVTL", stdout);
9998 fputs (" FILL ", stdout);
9999 /* XXX Print content of info word? */
10002 fputs (" TAGS ", stdout);
10003 /* XXX Print content of info word? */
10006 fputs (" HWAND ", stdout);
10007 if (option->info & OHWA0_R4KEOP_CHECKED)
10008 fputs (" R4KEOP_CHECKED", stdout);
10009 if (option->info & OHWA0_R4KEOP_CLEAN)
10010 fputs (" R4KEOP_CLEAN", stdout);
10013 fputs (" HWOR ", stdout);
10014 if (option->info & OHWA0_R4KEOP_CHECKED)
10015 fputs (" R4KEOP_CHECKED", stdout);
10016 if (option->info & OHWA0_R4KEOP_CLEAN)
10017 fputs (" R4KEOP_CLEAN", stdout);
10020 printf (" GP_GROUP %#06lx self-contained %#06lx",
10021 option->info & OGP_GROUP,
10022 (option->info & OGP_SELF) >> 16);
10025 printf (" IDENT %#06lx self-contained %#06lx",
10026 option->info & OGP_GROUP,
10027 (option->info & OGP_SELF) >> 16);
10030 /* This shouldn't happen. */
10031 printf (" %3d ??? %d %lx",
10032 option->kind, option->section, option->info);
10036 len = sizeof (* eopt);
10037 while (len < option->size)
10038 if (((char *) option)[len] >= ' '
10039 && ((char *) option)[len] < 0x7f)
10040 printf ("%c", ((char *) option)[len++]);
10042 printf ("\\%03o", ((char *) option)[len++]);
10044 fputs ("\n", stdout);
10052 if (conflicts_offset != 0 && conflictsno != 0)
10054 Elf32_Conflict * iconf;
10057 if (dynamic_symbols == NULL)
10059 error (_("conflict list found without a dynamic symbol table\n"));
10063 iconf = (Elf32_Conflict *) cmalloc (conflictsno, sizeof (* iconf));
10066 error (_("Out of memory\n"));
10072 Elf32_External_Conflict * econf32;
10074 econf32 = (Elf32_External_Conflict *)
10075 get_data (NULL, file, conflicts_offset, conflictsno,
10076 sizeof (* econf32), _("conflict"));
10080 for (cnt = 0; cnt < conflictsno; ++cnt)
10081 iconf[cnt] = BYTE_GET (econf32[cnt]);
10087 Elf64_External_Conflict * econf64;
10089 econf64 = (Elf64_External_Conflict *)
10090 get_data (NULL, file, conflicts_offset, conflictsno,
10091 sizeof (* econf64), _("conflict"));
10095 for (cnt = 0; cnt < conflictsno; ++cnt)
10096 iconf[cnt] = BYTE_GET (econf64[cnt]);
10101 printf (_("\nSection '.conflict' contains %lu entries:\n"),
10102 (unsigned long) conflictsno);
10103 puts (_(" Num: Index Value Name"));
10105 for (cnt = 0; cnt < conflictsno; ++cnt)
10107 Elf_Internal_Sym * psym = & dynamic_symbols[iconf[cnt]];
10109 printf ("%5lu: %8lu ", (unsigned long) cnt, iconf[cnt]);
10110 print_vma (psym->st_value, FULL_HEX);
10112 if (VALID_DYNAMIC_NAME (psym->st_name))
10113 print_symbol (25, GET_DYNAMIC_NAME (psym->st_name));
10115 printf ("<corrupt: %14ld>", psym->st_name);
10122 if (pltgot != 0 && local_gotno != 0)
10124 bfd_vma ent, local_end, global_end;
10126 unsigned char * data;
10130 addr_size = (is_32bit_elf ? 4 : 8);
10131 local_end = pltgot + local_gotno * addr_size;
10132 global_end = local_end + (symtabno - gotsym) * addr_size;
10134 offset = offset_from_vma (file, pltgot, global_end - pltgot);
10135 data = (unsigned char *) get_data (NULL, file, offset,
10136 global_end - pltgot, 1, _("GOT"));
10137 printf (_("\nPrimary GOT:\n"));
10138 printf (_(" Canonical gp value: "));
10139 print_vma (pltgot + 0x7ff0, LONG_HEX);
10142 printf (_(" Reserved entries:\n"));
10143 printf (_(" %*s %10s %*s Purpose\n"),
10144 addr_size * 2, "Address", "Access",
10145 addr_size * 2, "Initial");
10146 ent = print_mips_got_entry (data, pltgot, ent);
10147 printf (" Lazy resolver\n");
10149 && (byte_get (data + ent - pltgot, addr_size)
10150 >> (addr_size * 8 - 1)) != 0)
10152 ent = print_mips_got_entry (data, pltgot, ent);
10153 printf (" Module pointer (GNU extension)\n");
10157 if (ent < local_end)
10159 printf (_(" Local entries:\n"));
10160 printf (_(" %*s %10s %*s\n"),
10161 addr_size * 2, "Address", "Access",
10162 addr_size * 2, "Initial");
10163 while (ent < local_end)
10165 ent = print_mips_got_entry (data, pltgot, ent);
10171 if (gotsym < symtabno)
10175 printf (_(" Global entries:\n"));
10176 printf (_(" %*s %10s %*s %*s %-7s %3s %s\n"),
10177 addr_size * 2, "Address", "Access",
10178 addr_size * 2, "Initial",
10179 addr_size * 2, "Sym.Val.", "Type", "Ndx", "Name");
10180 sym_width = (is_32bit_elf ? 80 : 160) - 28 - addr_size * 6 - 1;
10181 for (i = gotsym; i < symtabno; i++)
10183 Elf_Internal_Sym * psym;
10185 psym = dynamic_symbols + i;
10186 ent = print_mips_got_entry (data, pltgot, ent);
10188 print_vma (psym->st_value, LONG_HEX);
10189 printf (" %-7s %3s ",
10190 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
10191 get_symbol_index_type (psym->st_shndx));
10192 if (VALID_DYNAMIC_NAME (psym->st_name))
10193 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
10195 printf ("<corrupt: %14ld>", psym->st_name);
10205 if (mips_pltgot != 0 && jmprel != 0 && pltrel != 0 && pltrelsz != 0)
10208 size_t offset, rel_offset;
10209 unsigned long count, i;
10210 unsigned char * data;
10211 int addr_size, sym_width;
10212 Elf_Internal_Rela * rels;
10214 rel_offset = offset_from_vma (file, jmprel, pltrelsz);
10215 if (pltrel == DT_RELA)
10217 if (!slurp_rela_relocs (file, rel_offset, pltrelsz, &rels, &count))
10222 if (!slurp_rel_relocs (file, rel_offset, pltrelsz, &rels, &count))
10227 addr_size = (is_32bit_elf ? 4 : 8);
10228 end = mips_pltgot + (2 + count) * addr_size;
10230 offset = offset_from_vma (file, mips_pltgot, end - mips_pltgot);
10231 data = (unsigned char *) get_data (NULL, file, offset, end - mips_pltgot,
10233 printf (_("\nPLT GOT:\n\n"));
10234 printf (_(" Reserved entries:\n"));
10235 printf (_(" %*s %*s Purpose\n"),
10236 addr_size * 2, "Address", addr_size * 2, "Initial");
10237 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
10238 printf (" PLT lazy resolver\n");
10239 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
10240 printf (" Module pointer\n");
10243 printf (_(" Entries:\n"));
10244 printf (_(" %*s %*s %*s %-7s %3s %s\n"),
10245 addr_size * 2, "Address",
10246 addr_size * 2, "Initial",
10247 addr_size * 2, "Sym.Val.", "Type", "Ndx", "Name");
10248 sym_width = (is_32bit_elf ? 80 : 160) - 17 - addr_size * 6 - 1;
10249 for (i = 0; i < count; i++)
10251 Elf_Internal_Sym * psym;
10253 psym = dynamic_symbols + get_reloc_symindex (rels[i].r_info);
10254 ent = print_mips_pltgot_entry (data, mips_pltgot, ent);
10256 print_vma (psym->st_value, LONG_HEX);
10257 printf (" %-7s %3s ",
10258 get_symbol_type (ELF_ST_TYPE (psym->st_info)),
10259 get_symbol_index_type (psym->st_shndx));
10260 if (VALID_DYNAMIC_NAME (psym->st_name))
10261 print_symbol (sym_width, GET_DYNAMIC_NAME (psym->st_name));
10263 printf ("<corrupt: %14ld>", psym->st_name);
10277 process_gnu_liblist (FILE * file)
10279 Elf_Internal_Shdr * section;
10280 Elf_Internal_Shdr * string_sec;
10281 Elf32_External_Lib * elib;
10283 size_t strtab_size;
10290 for (i = 0, section = section_headers;
10291 i < elf_header.e_shnum;
10294 switch (section->sh_type)
10296 case SHT_GNU_LIBLIST:
10297 if (section->sh_link >= elf_header.e_shnum)
10300 elib = (Elf32_External_Lib *)
10301 get_data (NULL, file, section->sh_offset, 1, section->sh_size,
10306 string_sec = section_headers + section->sh_link;
10308 strtab = (char *) get_data (NULL, file, string_sec->sh_offset, 1,
10309 string_sec->sh_size,
10310 _("liblist string table"));
10311 strtab_size = string_sec->sh_size;
10314 || section->sh_entsize != sizeof (Elf32_External_Lib))
10320 printf (_("\nLibrary list section '%s' contains %lu entries:\n"),
10321 SECTION_NAME (section),
10322 (unsigned long) (section->sh_size / sizeof (Elf32_External_Lib)));
10324 puts (" Library Time Stamp Checksum Version Flags");
10326 for (cnt = 0; cnt < section->sh_size / sizeof (Elf32_External_Lib);
10334 liblist.l_name = BYTE_GET (elib[cnt].l_name);
10335 atime = BYTE_GET (elib[cnt].l_time_stamp);
10336 liblist.l_checksum = BYTE_GET (elib[cnt].l_checksum);
10337 liblist.l_version = BYTE_GET (elib[cnt].l_version);
10338 liblist.l_flags = BYTE_GET (elib[cnt].l_flags);
10340 tmp = gmtime (&atime);
10341 snprintf (timebuf, sizeof (timebuf),
10342 "%04u-%02u-%02uT%02u:%02u:%02u",
10343 tmp->tm_year + 1900, tmp->tm_mon + 1, tmp->tm_mday,
10344 tmp->tm_hour, tmp->tm_min, tmp->tm_sec);
10346 printf ("%3lu: ", (unsigned long) cnt);
10348 printf ("%-20s", liblist.l_name < strtab_size
10349 ? strtab + liblist.l_name : "<corrupt>");
10351 printf ("%-20.20s", liblist.l_name < strtab_size
10352 ? strtab + liblist.l_name : "<corrupt>");
10353 printf (" %s %#010lx %-7ld %-7ld\n", timebuf, liblist.l_checksum,
10354 liblist.l_version, liblist.l_flags);
10364 static const char *
10365 get_note_type (unsigned e_type)
10367 static char buff[64];
10369 if (elf_header.e_type == ET_CORE)
10373 return _("NT_AUXV (auxiliary vector)");
10375 return _("NT_PRSTATUS (prstatus structure)");
10377 return _("NT_FPREGSET (floating point registers)");
10379 return _("NT_PRPSINFO (prpsinfo structure)");
10380 case NT_TASKSTRUCT:
10381 return _("NT_TASKSTRUCT (task structure)");
10383 return _("NT_PRXFPREG (user_xfpregs structure)");
10385 return _("NT_PPC_VMX (ppc Altivec registers)");
10387 return _("NT_PPC_VSX (ppc VSX registers)");
10388 case NT_S390_HIGH_GPRS:
10389 return _("NT_S390_HIGH_GPRS (s390 upper register halves)");
10391 return _("NT_PSTATUS (pstatus structure)");
10393 return _("NT_FPREGS (floating point registers)");
10395 return _("NT_PSINFO (psinfo structure)");
10397 return _("NT_LWPSTATUS (lwpstatus_t structure)");
10399 return _("NT_LWPSINFO (lwpsinfo_t structure)");
10400 case NT_WIN32PSTATUS:
10401 return _("NT_WIN32PSTATUS (win32_pstatus structure)");
10409 return _("NT_VERSION (version)");
10411 return _("NT_ARCH (architecture)");
10416 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
10420 static const char *
10421 get_gnu_elf_note_type (unsigned e_type)
10423 static char buff[64];
10427 case NT_GNU_ABI_TAG:
10428 return _("NT_GNU_ABI_TAG (ABI version tag)");
10430 return _("NT_GNU_HWCAP (DSO-supplied software HWCAP info)");
10431 case NT_GNU_BUILD_ID:
10432 return _("NT_GNU_BUILD_ID (unique build ID bitstring)");
10433 case NT_GNU_GOLD_VERSION:
10434 return _("NT_GNU_GOLD_VERSION (gold version)");
10439 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
10443 static const char *
10444 get_netbsd_elfcore_note_type (unsigned e_type)
10446 static char buff[64];
10448 if (e_type == NT_NETBSDCORE_PROCINFO)
10450 /* NetBSD core "procinfo" structure. */
10451 return _("NetBSD procinfo structure");
10454 /* As of Jan 2002 there are no other machine-independent notes
10455 defined for NetBSD core files. If the note type is less
10456 than the start of the machine-dependent note types, we don't
10459 if (e_type < NT_NETBSDCORE_FIRSTMACH)
10461 snprintf (buff, sizeof (buff), _("Unknown note type: (0x%08x)"), e_type);
10465 switch (elf_header.e_machine)
10467 /* On the Alpha, SPARC (32-bit and 64-bit), PT_GETREGS == mach+0
10468 and PT_GETFPREGS == mach+2. */
10473 case EM_SPARC32PLUS:
10477 case NT_NETBSDCORE_FIRSTMACH+0:
10478 return _("PT_GETREGS (reg structure)");
10479 case NT_NETBSDCORE_FIRSTMACH+2:
10480 return _("PT_GETFPREGS (fpreg structure)");
10486 /* On all other arch's, PT_GETREGS == mach+1 and
10487 PT_GETFPREGS == mach+3. */
10491 case NT_NETBSDCORE_FIRSTMACH+1:
10492 return _("PT_GETREGS (reg structure)");
10493 case NT_NETBSDCORE_FIRSTMACH+3:
10494 return _("PT_GETFPREGS (fpreg structure)");
10500 snprintf (buff, sizeof (buff), _("PT_FIRSTMACH+%d"),
10501 e_type - NT_NETBSDCORE_FIRSTMACH);
10505 /* Note that by the ELF standard, the name field is already null byte
10506 terminated, and namesz includes the terminating null byte.
10507 I.E. the value of namesz for the name "FSF" is 4.
10509 If the value of namesz is zero, there is no name present. */
10511 process_note (Elf_Internal_Note * pnote)
10513 const char * name = pnote->namesz ? pnote->namedata : "(NONE)";
10516 if (pnote->namesz == 0)
10517 /* If there is no note name, then use the default set of
10518 note type strings. */
10519 nt = get_note_type (pnote->type);
10521 else if (const_strneq (pnote->namedata, "GNU"))
10522 /* GNU-specific object file notes. */
10523 nt = get_gnu_elf_note_type (pnote->type);
10525 else if (const_strneq (pnote->namedata, "NetBSD-CORE"))
10526 /* NetBSD-specific core file notes. */
10527 nt = get_netbsd_elfcore_note_type (pnote->type);
10529 else if (strneq (pnote->namedata, "SPU/", 4))
10531 /* SPU-specific core file notes. */
10532 nt = pnote->namedata + 4;
10537 /* Don't recognize this note name; just use the default set of
10538 note type strings. */
10539 nt = get_note_type (pnote->type);
10541 printf (" %s\t\t0x%08lx\t%s\n", name, pnote->descsz, nt);
10547 process_corefile_note_segment (FILE * file, bfd_vma offset, bfd_vma length)
10549 Elf_External_Note * pnotes;
10550 Elf_External_Note * external;
10556 pnotes = (Elf_External_Note *) get_data (NULL, file, offset, 1, length,
10563 printf (_("\nNotes at offset 0x%08lx with length 0x%08lx:\n"),
10564 (unsigned long) offset, (unsigned long) length);
10565 printf (_(" Owner\t\tData size\tDescription\n"));
10567 while (external < (Elf_External_Note *) ((char *) pnotes + length))
10569 Elf_External_Note * next;
10570 Elf_Internal_Note inote;
10571 char * temp = NULL;
10573 inote.type = BYTE_GET (external->type);
10574 inote.namesz = BYTE_GET (external->namesz);
10575 inote.namedata = external->name;
10576 inote.descsz = BYTE_GET (external->descsz);
10577 inote.descdata = inote.namedata + align_power (inote.namesz, 2);
10578 inote.descpos = offset + (inote.descdata - (char *) pnotes);
10580 next = (Elf_External_Note *) (inote.descdata + align_power (inote.descsz, 2));
10582 if (((char *) next) > (((char *) pnotes) + length))
10584 warn (_("corrupt note found at offset %lx into core notes\n"),
10585 (unsigned long) ((char *) external - (char *) pnotes));
10586 warn (_(" type: %lx, namesize: %08lx, descsize: %08lx\n"),
10587 inote.type, inote.namesz, inote.descsz);
10593 /* Verify that name is null terminated. It appears that at least
10594 one version of Linux (RedHat 6.0) generates corefiles that don't
10595 comply with the ELF spec by failing to include the null byte in
10597 if (inote.namedata[inote.namesz] != '\0')
10599 temp = (char *) malloc (inote.namesz + 1);
10603 error (_("Out of memory\n"));
10608 strncpy (temp, inote.namedata, inote.namesz);
10609 temp[inote.namesz] = 0;
10611 /* warn (_("'%s' NOTE name not properly null terminated\n"), temp); */
10612 inote.namedata = temp;
10615 res &= process_note (& inote);
10630 process_corefile_note_segments (FILE * file)
10632 Elf_Internal_Phdr * segment;
10636 if (! get_program_headers (file))
10639 for (i = 0, segment = program_headers;
10640 i < elf_header.e_phnum;
10643 if (segment->p_type == PT_NOTE)
10644 res &= process_corefile_note_segment (file,
10645 (bfd_vma) segment->p_offset,
10646 (bfd_vma) segment->p_filesz);
10653 process_note_sections (FILE * file)
10655 Elf_Internal_Shdr * section;
10659 for (i = 0, section = section_headers;
10660 i < elf_header.e_shnum;
10662 if (section->sh_type == SHT_NOTE)
10663 res &= process_corefile_note_segment (file,
10664 (bfd_vma) section->sh_offset,
10665 (bfd_vma) section->sh_size);
10671 process_notes (FILE * file)
10673 /* If we have not been asked to display the notes then do nothing. */
10677 if (elf_header.e_type != ET_CORE)
10678 return process_note_sections (file);
10680 /* No program headers means no NOTE segment. */
10681 if (elf_header.e_phnum > 0)
10682 return process_corefile_note_segments (file);
10684 printf (_("No note segments present in the core file.\n"));
10689 process_arch_specific (FILE * file)
10694 switch (elf_header.e_machine)
10697 return process_arm_specific (file);
10699 case EM_MIPS_RS3_LE:
10700 return process_mips_specific (file);
10703 return process_power_specific (file);
10712 get_file_header (FILE * file)
10714 /* Read in the identity array. */
10715 if (fread (elf_header.e_ident, EI_NIDENT, 1, file) != 1)
10718 /* Determine how to read the rest of the header. */
10719 switch (elf_header.e_ident[EI_DATA])
10721 default: /* fall through */
10722 case ELFDATANONE: /* fall through */
10724 byte_get = byte_get_little_endian;
10725 byte_put = byte_put_little_endian;
10728 byte_get = byte_get_big_endian;
10729 byte_put = byte_put_big_endian;
10733 /* For now we only support 32 bit and 64 bit ELF files. */
10734 is_32bit_elf = (elf_header.e_ident[EI_CLASS] != ELFCLASS64);
10736 /* Read in the rest of the header. */
10739 Elf32_External_Ehdr ehdr32;
10741 if (fread (ehdr32.e_type, sizeof (ehdr32) - EI_NIDENT, 1, file) != 1)
10744 elf_header.e_type = BYTE_GET (ehdr32.e_type);
10745 elf_header.e_machine = BYTE_GET (ehdr32.e_machine);
10746 elf_header.e_version = BYTE_GET (ehdr32.e_version);
10747 elf_header.e_entry = BYTE_GET (ehdr32.e_entry);
10748 elf_header.e_phoff = BYTE_GET (ehdr32.e_phoff);
10749 elf_header.e_shoff = BYTE_GET (ehdr32.e_shoff);
10750 elf_header.e_flags = BYTE_GET (ehdr32.e_flags);
10751 elf_header.e_ehsize = BYTE_GET (ehdr32.e_ehsize);
10752 elf_header.e_phentsize = BYTE_GET (ehdr32.e_phentsize);
10753 elf_header.e_phnum = BYTE_GET (ehdr32.e_phnum);
10754 elf_header.e_shentsize = BYTE_GET (ehdr32.e_shentsize);
10755 elf_header.e_shnum = BYTE_GET (ehdr32.e_shnum);
10756 elf_header.e_shstrndx = BYTE_GET (ehdr32.e_shstrndx);
10760 Elf64_External_Ehdr ehdr64;
10762 /* If we have been compiled with sizeof (bfd_vma) == 4, then
10763 we will not be able to cope with the 64bit data found in
10764 64 ELF files. Detect this now and abort before we start
10765 overwriting things. */
10766 if (sizeof (bfd_vma) < 8)
10768 error (_("This instance of readelf has been built without support for a\n\
10769 64 bit data type and so it cannot read 64 bit ELF files.\n"));
10773 if (fread (ehdr64.e_type, sizeof (ehdr64) - EI_NIDENT, 1, file) != 1)
10776 elf_header.e_type = BYTE_GET (ehdr64.e_type);
10777 elf_header.e_machine = BYTE_GET (ehdr64.e_machine);
10778 elf_header.e_version = BYTE_GET (ehdr64.e_version);
10779 elf_header.e_entry = BYTE_GET (ehdr64.e_entry);
10780 elf_header.e_phoff = BYTE_GET (ehdr64.e_phoff);
10781 elf_header.e_shoff = BYTE_GET (ehdr64.e_shoff);
10782 elf_header.e_flags = BYTE_GET (ehdr64.e_flags);
10783 elf_header.e_ehsize = BYTE_GET (ehdr64.e_ehsize);
10784 elf_header.e_phentsize = BYTE_GET (ehdr64.e_phentsize);
10785 elf_header.e_phnum = BYTE_GET (ehdr64.e_phnum);
10786 elf_header.e_shentsize = BYTE_GET (ehdr64.e_shentsize);
10787 elf_header.e_shnum = BYTE_GET (ehdr64.e_shnum);
10788 elf_header.e_shstrndx = BYTE_GET (ehdr64.e_shstrndx);
10791 if (elf_header.e_shoff)
10793 /* There may be some extensions in the first section header. Don't
10794 bomb if we can't read it. */
10796 get_32bit_section_headers (file, 1);
10798 get_64bit_section_headers (file, 1);
10804 /* Process one ELF object file according to the command line options.
10805 This file may actually be stored in an archive. The file is
10806 positioned at the start of the ELF object. */
10809 process_object (char * file_name, FILE * file)
10813 if (! get_file_header (file))
10815 error (_("%s: Failed to read file header\n"), file_name);
10819 /* Initialise per file variables. */
10820 for (i = ARRAY_SIZE (version_info); i--;)
10821 version_info[i] = 0;
10823 for (i = ARRAY_SIZE (dynamic_info); i--;)
10824 dynamic_info[i] = 0;
10826 /* Process the file. */
10828 printf (_("\nFile: %s\n"), file_name);
10830 /* Initialise the dump_sects array from the cmdline_dump_sects array.
10831 Note we do this even if cmdline_dump_sects is empty because we
10832 must make sure that the dump_sets array is zeroed out before each
10833 object file is processed. */
10834 if (num_dump_sects > num_cmdline_dump_sects)
10835 memset (dump_sects, 0, num_dump_sects * sizeof (* dump_sects));
10837 if (num_cmdline_dump_sects > 0)
10839 if (num_dump_sects == 0)
10840 /* A sneaky way of allocating the dump_sects array. */
10841 request_dump_bynumber (num_cmdline_dump_sects, 0);
10843 assert (num_dump_sects >= num_cmdline_dump_sects);
10844 memcpy (dump_sects, cmdline_dump_sects,
10845 num_cmdline_dump_sects * sizeof (* dump_sects));
10848 if (! process_file_header ())
10851 if (! process_section_headers (file))
10853 /* Without loaded section headers we cannot process lots of
10855 do_unwind = do_version = do_dump = do_arch = 0;
10857 if (! do_using_dynamic)
10858 do_syms = do_reloc = 0;
10861 if (! process_section_groups (file))
10863 /* Without loaded section groups we cannot process unwind. */
10867 if (process_program_headers (file))
10868 process_dynamic_section (file);
10870 process_relocs (file);
10872 process_unwind (file);
10874 process_symbol_table (file);
10876 process_syminfo (file);
10878 process_version_sections (file);
10880 process_section_contents (file);
10882 process_notes (file);
10884 process_gnu_liblist (file);
10886 process_arch_specific (file);
10888 if (program_headers)
10890 free (program_headers);
10891 program_headers = NULL;
10894 if (section_headers)
10896 free (section_headers);
10897 section_headers = NULL;
10902 free (string_table);
10903 string_table = NULL;
10904 string_table_length = 0;
10907 if (dynamic_strings)
10909 free (dynamic_strings);
10910 dynamic_strings = NULL;
10911 dynamic_strings_length = 0;
10914 if (dynamic_symbols)
10916 free (dynamic_symbols);
10917 dynamic_symbols = NULL;
10918 num_dynamic_syms = 0;
10921 if (dynamic_syminfo)
10923 free (dynamic_syminfo);
10924 dynamic_syminfo = NULL;
10927 if (section_headers_groups)
10929 free (section_headers_groups);
10930 section_headers_groups = NULL;
10933 if (section_groups)
10935 struct group_list * g;
10936 struct group_list * next;
10938 for (i = 0; i < group_count; i++)
10940 for (g = section_groups [i].root; g != NULL; g = next)
10947 free (section_groups);
10948 section_groups = NULL;
10951 free_debug_memory ();
10956 /* Return the path name for a proxy entry in a thin archive, adjusted relative
10957 to the path name of the thin archive itself if necessary. Always returns
10958 a pointer to malloc'ed memory. */
10961 adjust_relative_path (char * file_name, char * name, int name_len)
10963 char * member_file_name;
10964 const char * base_name = lbasename (file_name);
10966 /* This is a proxy entry for a thin archive member.
10967 If the extended name table contains an absolute path
10968 name, or if the archive is in the current directory,
10969 use the path name as given. Otherwise, we need to
10970 find the member relative to the directory where the
10971 archive is located. */
10972 if (IS_ABSOLUTE_PATH (name) || base_name == file_name)
10974 member_file_name = (char *) malloc (name_len + 1);
10975 if (member_file_name == NULL)
10977 error (_("Out of memory\n"));
10980 memcpy (member_file_name, name, name_len);
10981 member_file_name[name_len] = '\0';
10985 /* Concatenate the path components of the archive file name
10986 to the relative path name from the extended name table. */
10987 size_t prefix_len = base_name - file_name;
10988 member_file_name = (char *) malloc (prefix_len + name_len + 1);
10989 if (member_file_name == NULL)
10991 error (_("Out of memory\n"));
10994 memcpy (member_file_name, file_name, prefix_len);
10995 memcpy (member_file_name + prefix_len, name, name_len);
10996 member_file_name[prefix_len + name_len] = '\0';
10998 return member_file_name;
11001 /* Structure to hold information about an archive file. */
11003 struct archive_info
11005 char * file_name; /* Archive file name. */
11006 FILE * file; /* Open file descriptor. */
11007 unsigned long index_num; /* Number of symbols in table. */
11008 unsigned long * index_array; /* The array of member offsets. */
11009 char * sym_table; /* The symbol table. */
11010 unsigned long sym_size; /* Size of the symbol table. */
11011 char * longnames; /* The long file names table. */
11012 unsigned long longnames_size; /* Size of the long file names table. */
11013 unsigned long nested_member_origin; /* Origin in the nested archive of the current member. */
11014 unsigned long next_arhdr_offset; /* Offset of the next archive header. */
11015 bfd_boolean is_thin_archive; /* TRUE if this is a thin archive. */
11016 struct ar_hdr arhdr; /* Current archive header. */
11019 /* Read the symbol table and long-name table from an archive. */
11022 setup_archive (struct archive_info * arch, char * file_name, FILE * file,
11023 bfd_boolean is_thin_archive, bfd_boolean read_symbols)
11026 unsigned long size;
11028 arch->file_name = strdup (file_name);
11030 arch->index_num = 0;
11031 arch->index_array = NULL;
11032 arch->sym_table = NULL;
11033 arch->sym_size = 0;
11034 arch->longnames = NULL;
11035 arch->longnames_size = 0;
11036 arch->nested_member_origin = 0;
11037 arch->is_thin_archive = is_thin_archive;
11038 arch->next_arhdr_offset = SARMAG;
11040 /* Read the first archive member header. */
11041 if (fseek (file, SARMAG, SEEK_SET) != 0)
11043 error (_("%s: failed to seek to first archive header\n"), file_name);
11046 got = fread (&arch->arhdr, 1, sizeof arch->arhdr, file);
11047 if (got != sizeof arch->arhdr)
11052 error (_("%s: failed to read archive header\n"), file_name);
11056 /* See if this is the archive symbol table. */
11057 if (const_strneq (arch->arhdr.ar_name, "/ ")
11058 || const_strneq (arch->arhdr.ar_name, "/SYM64/ "))
11060 size = strtoul (arch->arhdr.ar_size, NULL, 10);
11061 size = size + (size & 1);
11063 arch->next_arhdr_offset += sizeof arch->arhdr + size;
11068 /* A buffer used to hold numbers read in from an archive index.
11069 These are always 4 bytes long and stored in big-endian format. */
11070 #define SIZEOF_AR_INDEX_NUMBERS 4
11071 unsigned char integer_buffer[SIZEOF_AR_INDEX_NUMBERS];
11072 unsigned char * index_buffer;
11074 /* Check the size of the archive index. */
11075 if (size < SIZEOF_AR_INDEX_NUMBERS)
11077 error (_("%s: the archive index is empty\n"), file_name);
11081 /* Read the numer of entries in the archive index. */
11082 got = fread (integer_buffer, 1, sizeof integer_buffer, file);
11083 if (got != sizeof (integer_buffer))
11085 error (_("%s: failed to read archive index\n"), file_name);
11088 arch->index_num = byte_get_big_endian (integer_buffer, sizeof integer_buffer);
11089 size -= SIZEOF_AR_INDEX_NUMBERS;
11091 /* Read in the archive index. */
11092 if (size < arch->index_num * SIZEOF_AR_INDEX_NUMBERS)
11094 error (_("%s: the archive index is supposed to have %ld entries, but the size in the header is too small\n"),
11095 file_name, arch->index_num);
11098 index_buffer = (unsigned char *)
11099 malloc (arch->index_num * SIZEOF_AR_INDEX_NUMBERS);
11100 if (index_buffer == NULL)
11102 error (_("Out of memory whilst trying to read archive symbol index\n"));
11105 got = fread (index_buffer, SIZEOF_AR_INDEX_NUMBERS, arch->index_num, file);
11106 if (got != arch->index_num)
11108 free (index_buffer);
11109 error (_("%s: failed to read archive index\n"), file_name);
11112 size -= arch->index_num * SIZEOF_AR_INDEX_NUMBERS;
11114 /* Convert the index numbers into the host's numeric format. */
11115 arch->index_array = (long unsigned int *)
11116 malloc (arch->index_num * sizeof (* arch->index_array));
11117 if (arch->index_array == NULL)
11119 free (index_buffer);
11120 error (_("Out of memory whilst trying to convert the archive symbol index\n"));
11124 for (i = 0; i < arch->index_num; i++)
11125 arch->index_array[i] = byte_get_big_endian ((unsigned char *) (index_buffer + (i * SIZEOF_AR_INDEX_NUMBERS)),
11126 SIZEOF_AR_INDEX_NUMBERS);
11127 free (index_buffer);
11129 /* The remaining space in the header is taken up by the symbol table. */
11132 error (_("%s: the archive has an index but no symbols\n"), file_name);
11135 arch->sym_table = (char *) malloc (size);
11136 arch->sym_size = size;
11137 if (arch->sym_table == NULL)
11139 error (_("Out of memory whilst trying to read archive index symbol table\n"));
11142 got = fread (arch->sym_table, 1, size, file);
11145 error (_("%s: failed to read archive index symbol table\n"), file_name);
11151 if (fseek (file, size, SEEK_CUR) != 0)
11153 error (_("%s: failed to skip archive symbol table\n"), file_name);
11158 /* Read the next archive header. */
11159 got = fread (&arch->arhdr, 1, sizeof arch->arhdr, file);
11160 if (got != sizeof arch->arhdr)
11164 error (_("%s: failed to read archive header following archive index\n"), file_name);
11168 else if (read_symbols)
11169 printf (_("%s has no archive index\n"), file_name);
11171 if (const_strneq (arch->arhdr.ar_name, "// "))
11173 /* This is the archive string table holding long member names. */
11174 arch->longnames_size = strtoul (arch->arhdr.ar_size, NULL, 10);
11175 arch->next_arhdr_offset += sizeof arch->arhdr + arch->longnames_size;
11177 arch->longnames = (char *) malloc (arch->longnames_size);
11178 if (arch->longnames == NULL)
11180 error (_("Out of memory reading long symbol names in archive\n"));
11184 if (fread (arch->longnames, arch->longnames_size, 1, file) != 1)
11186 free (arch->longnames);
11187 arch->longnames = NULL;
11188 error (_("%s: failed to read long symbol name string table\n"), file_name);
11192 if ((arch->longnames_size & 1) != 0)
11199 /* Release the memory used for the archive information. */
11202 release_archive (struct archive_info * arch)
11204 if (arch->file_name != NULL)
11205 free (arch->file_name);
11206 if (arch->index_array != NULL)
11207 free (arch->index_array);
11208 if (arch->sym_table != NULL)
11209 free (arch->sym_table);
11210 if (arch->longnames != NULL)
11211 free (arch->longnames);
11214 /* Open and setup a nested archive, if not already open. */
11217 setup_nested_archive (struct archive_info * nested_arch, char * member_file_name)
11219 FILE * member_file;
11221 /* Have we already setup this archive? */
11222 if (nested_arch->file_name != NULL
11223 && streq (nested_arch->file_name, member_file_name))
11226 /* Close previous file and discard cached information. */
11227 if (nested_arch->file != NULL)
11228 fclose (nested_arch->file);
11229 release_archive (nested_arch);
11231 member_file = fopen (member_file_name, "rb");
11232 if (member_file == NULL)
11234 return setup_archive (nested_arch, member_file_name, member_file, FALSE, FALSE);
11238 get_archive_member_name_at (struct archive_info * arch,
11239 unsigned long offset,
11240 struct archive_info * nested_arch);
11242 /* Get the name of an archive member from the current archive header.
11243 For simple names, this will modify the ar_name field of the current
11244 archive header. For long names, it will return a pointer to the
11245 longnames table. For nested archives, it will open the nested archive
11246 and get the name recursively. NESTED_ARCH is a single-entry cache so
11247 we don't keep rereading the same information from a nested archive. */
11250 get_archive_member_name (struct archive_info * arch,
11251 struct archive_info * nested_arch)
11253 unsigned long j, k;
11255 if (arch->arhdr.ar_name[0] == '/')
11257 /* We have a long name. */
11259 char * member_file_name;
11260 char * member_name;
11262 arch->nested_member_origin = 0;
11263 k = j = strtoul (arch->arhdr.ar_name + 1, &endp, 10);
11264 if (arch->is_thin_archive && endp != NULL && * endp == ':')
11265 arch->nested_member_origin = strtoul (endp + 1, NULL, 10);
11267 while ((j < arch->longnames_size)
11268 && (arch->longnames[j] != '\n')
11269 && (arch->longnames[j] != '\0'))
11271 if (arch->longnames[j-1] == '/')
11273 arch->longnames[j] = '\0';
11275 if (!arch->is_thin_archive || arch->nested_member_origin == 0)
11276 return arch->longnames + k;
11278 /* This is a proxy for a member of a nested archive.
11279 Find the name of the member in that archive. */
11280 member_file_name = adjust_relative_path (arch->file_name, arch->longnames + k, j - k);
11281 if (member_file_name != NULL
11282 && setup_nested_archive (nested_arch, member_file_name) == 0
11283 && (member_name = get_archive_member_name_at (nested_arch, arch->nested_member_origin, NULL)) != NULL)
11285 free (member_file_name);
11286 return member_name;
11288 free (member_file_name);
11290 /* Last resort: just return the name of the nested archive. */
11291 return arch->longnames + k;
11294 /* We have a normal (short) name. */
11296 while ((arch->arhdr.ar_name[j] != '/') && (j < 16))
11298 arch->arhdr.ar_name[j] = '\0';
11299 return arch->arhdr.ar_name;
11302 /* Get the name of an archive member at a given OFFSET within an archive ARCH. */
11305 get_archive_member_name_at (struct archive_info * arch,
11306 unsigned long offset,
11307 struct archive_info * nested_arch)
11311 if (fseek (arch->file, offset, SEEK_SET) != 0)
11313 error (_("%s: failed to seek to next file name\n"), arch->file_name);
11316 got = fread (&arch->arhdr, 1, sizeof arch->arhdr, arch->file);
11317 if (got != sizeof arch->arhdr)
11319 error (_("%s: failed to read archive header\n"), arch->file_name);
11322 if (memcmp (arch->arhdr.ar_fmag, ARFMAG, 2) != 0)
11324 error (_("%s: did not find a valid archive header\n"), arch->file_name);
11328 return get_archive_member_name (arch, nested_arch);
11331 /* Construct a string showing the name of the archive member, qualified
11332 with the name of the containing archive file. For thin archives, we
11333 use square brackets to denote the indirection. For nested archives,
11334 we show the qualified name of the external member inside the square
11335 brackets (e.g., "thin.a[normal.a(foo.o)]"). */
11338 make_qualified_name (struct archive_info * arch,
11339 struct archive_info * nested_arch,
11340 char * member_name)
11345 len = strlen (arch->file_name) + strlen (member_name) + 3;
11346 if (arch->is_thin_archive && arch->nested_member_origin != 0)
11347 len += strlen (nested_arch->file_name) + 2;
11349 name = (char *) malloc (len);
11352 error (_("Out of memory\n"));
11356 if (arch->is_thin_archive && arch->nested_member_origin != 0)
11357 snprintf (name, len, "%s[%s(%s)]", arch->file_name, nested_arch->file_name, member_name);
11358 else if (arch->is_thin_archive)
11359 snprintf (name, len, "%s[%s]", arch->file_name, member_name);
11361 snprintf (name, len, "%s(%s)", arch->file_name, member_name);
11366 /* Process an ELF archive.
11367 On entry the file is positioned just after the ARMAG string. */
11370 process_archive (char * file_name, FILE * file, bfd_boolean is_thin_archive)
11372 struct archive_info arch;
11373 struct archive_info nested_arch;
11375 size_t file_name_size;
11380 /* The ARCH structure is used to hold information about this archive. */
11381 arch.file_name = NULL;
11383 arch.index_array = NULL;
11384 arch.sym_table = NULL;
11385 arch.longnames = NULL;
11387 /* The NESTED_ARCH structure is used as a single-item cache of information
11388 about a nested archive (when members of a thin archive reside within
11389 another regular archive file). */
11390 nested_arch.file_name = NULL;
11391 nested_arch.file = NULL;
11392 nested_arch.index_array = NULL;
11393 nested_arch.sym_table = NULL;
11394 nested_arch.longnames = NULL;
11396 if (setup_archive (&arch, file_name, file, is_thin_archive, do_archive_index) != 0)
11402 if (do_archive_index)
11404 if (arch.sym_table == NULL)
11405 error (_("%s: unable to dump the index as none was found\n"), file_name);
11409 unsigned long current_pos;
11411 printf (_("Index of archive %s: (%ld entries, 0x%lx bytes in the symbol table)\n"),
11412 file_name, arch.index_num, arch.sym_size);
11413 current_pos = ftell (file);
11415 for (i = l = 0; i < arch.index_num; i++)
11417 if ((i == 0) || ((i > 0) && (arch.index_array[i] != arch.index_array[i - 1])))
11419 char * member_name;
11421 member_name = get_archive_member_name_at (&arch, arch.index_array[i], &nested_arch);
11423 if (member_name != NULL)
11425 char * qualified_name = make_qualified_name (&arch, &nested_arch, member_name);
11427 if (qualified_name != NULL)
11429 printf (_("Binary %s contains:\n"), qualified_name);
11430 free (qualified_name);
11435 if (l >= arch.sym_size)
11437 error (_("%s: end of the symbol table reached before the end of the index\n"),
11441 printf ("\t%s\n", arch.sym_table + l);
11442 l += strlen (arch.sym_table + l) + 1;
11447 if (l < arch.sym_size)
11448 error (_("%s: symbols remain in the index symbol table, but without corresponding entries in the index table\n"),
11451 if (fseek (file, current_pos, SEEK_SET) != 0)
11453 error (_("%s: failed to seek back to start of object files in the archive\n"), file_name);
11459 if (!do_dynamic && !do_syms && !do_reloc && !do_unwind && !do_sections
11460 && !do_segments && !do_header && !do_dump && !do_version
11461 && !do_histogram && !do_debugging && !do_arch && !do_notes
11462 && !do_section_groups)
11464 ret = 0; /* Archive index only. */
11469 file_name_size = strlen (file_name);
11476 char * qualified_name;
11478 /* Read the next archive header. */
11479 if (fseek (file, arch.next_arhdr_offset, SEEK_SET) != 0)
11481 error (_("%s: failed to seek to next archive header\n"), file_name);
11484 got = fread (&arch.arhdr, 1, sizeof arch.arhdr, file);
11485 if (got != sizeof arch.arhdr)
11489 error (_("%s: failed to read archive header\n"), file_name);
11493 if (memcmp (arch.arhdr.ar_fmag, ARFMAG, 2) != 0)
11495 error (_("%s: did not find a valid archive header\n"), arch.file_name);
11500 arch.next_arhdr_offset += sizeof arch.arhdr;
11502 archive_file_size = strtoul (arch.arhdr.ar_size, NULL, 10);
11503 if (archive_file_size & 01)
11504 ++archive_file_size;
11506 name = get_archive_member_name (&arch, &nested_arch);
11509 error (_("%s: bad archive file name\n"), file_name);
11513 namelen = strlen (name);
11515 qualified_name = make_qualified_name (&arch, &nested_arch, name);
11516 if (qualified_name == NULL)
11518 error (_("%s: bad archive file name\n"), file_name);
11523 if (is_thin_archive && arch.nested_member_origin == 0)
11525 /* This is a proxy for an external member of a thin archive. */
11526 FILE * member_file;
11527 char * member_file_name = adjust_relative_path (file_name, name, namelen);
11528 if (member_file_name == NULL)
11534 member_file = fopen (member_file_name, "rb");
11535 if (member_file == NULL)
11537 error (_("Input file '%s' is not readable.\n"), member_file_name);
11538 free (member_file_name);
11543 archive_file_offset = arch.nested_member_origin;
11545 ret |= process_object (qualified_name, member_file);
11547 fclose (member_file);
11548 free (member_file_name);
11550 else if (is_thin_archive)
11552 /* This is a proxy for a member of a nested archive. */
11553 archive_file_offset = arch.nested_member_origin + sizeof arch.arhdr;
11555 /* The nested archive file will have been opened and setup by
11556 get_archive_member_name. */
11557 if (fseek (nested_arch.file, archive_file_offset, SEEK_SET) != 0)
11559 error (_("%s: failed to seek to archive member.\n"), nested_arch.file_name);
11564 ret |= process_object (qualified_name, nested_arch.file);
11568 archive_file_offset = arch.next_arhdr_offset;
11569 arch.next_arhdr_offset += archive_file_size;
11571 ret |= process_object (qualified_name, file);
11574 free (qualified_name);
11578 if (nested_arch.file != NULL)
11579 fclose (nested_arch.file);
11580 release_archive (&nested_arch);
11581 release_archive (&arch);
11587 process_file (char * file_name)
11590 struct stat statbuf;
11591 char armag[SARMAG];
11594 if (stat (file_name, &statbuf) < 0)
11596 if (errno == ENOENT)
11597 error (_("'%s': No such file\n"), file_name);
11599 error (_("Could not locate '%s'. System error message: %s\n"),
11600 file_name, strerror (errno));
11604 if (! S_ISREG (statbuf.st_mode))
11606 error (_("'%s' is not an ordinary file\n"), file_name);
11610 file = fopen (file_name, "rb");
11613 error (_("Input file '%s' is not readable.\n"), file_name);
11617 if (fread (armag, SARMAG, 1, file) != 1)
11619 error (_("%s: Failed to read file's magic number\n"), file_name);
11624 if (memcmp (armag, ARMAG, SARMAG) == 0)
11625 ret = process_archive (file_name, file, FALSE);
11626 else if (memcmp (armag, ARMAGT, SARMAG) == 0)
11627 ret = process_archive (file_name, file, TRUE);
11630 if (do_archive_index)
11631 error (_("File %s is not an archive so its index cannot be displayed.\n"),
11635 archive_file_size = archive_file_offset = 0;
11636 ret = process_object (file_name, file);
11644 #ifdef SUPPORT_DISASSEMBLY
11645 /* Needed by the i386 disassembler. For extra credit, someone could
11646 fix this so that we insert symbolic addresses here, esp for GOT/PLT
11650 print_address (unsigned int addr, FILE * outfile)
11652 fprintf (outfile,"0x%8.8x", addr);
11655 /* Needed by the i386 disassembler. */
11657 db_task_printsym (unsigned int addr)
11659 print_address (addr, stderr);
11664 main (int argc, char ** argv)
11668 #if defined (HAVE_SETLOCALE) && defined (HAVE_LC_MESSAGES)
11669 setlocale (LC_MESSAGES, "");
11671 #if defined (HAVE_SETLOCALE)
11672 setlocale (LC_CTYPE, "");
11674 bindtextdomain (PACKAGE, LOCALEDIR);
11675 textdomain (PACKAGE);
11677 expandargv (&argc, &argv);
11679 parse_args (argc, argv);
11681 if (num_dump_sects > 0)
11683 /* Make a copy of the dump_sects array. */
11684 cmdline_dump_sects = (dump_type *)
11685 malloc (num_dump_sects * sizeof (* dump_sects));
11686 if (cmdline_dump_sects == NULL)
11687 error (_("Out of memory allocating dump request table.\n"));
11690 memcpy (cmdline_dump_sects, dump_sects,
11691 num_dump_sects * sizeof (* dump_sects));
11692 num_cmdline_dump_sects = num_dump_sects;
11696 if (optind < (argc - 1))
11700 while (optind < argc)
11701 err |= process_file (argv[optind++]);
11703 if (dump_sects != NULL)
11705 if (cmdline_dump_sects != NULL)
11706 free (cmdline_dump_sects);